fs/ocfs2/namei.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* -*- mode: c; c-basic-offset: 8; -*-
   3  * vim: noexpandtab sw=8 ts=8 sts=0:
   4  *
   5  * namei.c
   6  *
   7  * Create and rename file, directory, symlinks
   8  *
   9  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
  10  *
  11  *  Portions of this code from linux/fs/ext3/dir.c
  12  *
  13  *  Copyright (C) 1992, 1993, 1994, 1995
  14  *  Remy Card (card@masi.ibp.fr)
  15  *  Laboratoire MASI - Institut Blaise pascal
  16  *  Universite Pierre et Marie Curie (Paris VI)
  17  *
  18  *   from
  19  *
  20  *   linux/fs/minix/dir.c
  21  *
  22  *   Copyright (C) 1991, 1992 Linux Torvalds
  23  */
  24
  25 #include <linux/fs.h>
  26 #include <linux/types.h>
  27 #include <linux/slab.h>
  28 #include <linux/highmem.h>
  29 #include <linux/quotaops.h>
  30 #include <linux/iversion.h>
  31
  32 #include <cluster/masklog.h>
  33
  34 #include "ocfs2.h"
  35
  36 #include "alloc.h"
  37 #include "dcache.h"
  38 #include "dir.h"
  39 #include "dlmglue.h"
  40 #include "extent_map.h"
  41 #include "file.h"
  42 #include "inode.h"
  43 #include "journal.h"
  44 #include "namei.h"
  45 #include "suballoc.h"
  46 #include "super.h"
  47 #include "symlink.h"
  48 #include "sysfile.h"
  49 #include "uptodate.h"
  50 #include "xattr.h"
  51 #include "acl.h"
  52 #include "ocfs2_trace.h"
  53
  54 #include "buffer_head_io.h"
  55
  56 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
  57                               struct inode *dir,
  58                               struct inode *inode,
  59                               dev_t dev,
  60                               struct buffer_head **new_fe_bh,
  61                               struct buffer_head *parent_fe_bh,
  62                               handle_t *handle,
  63                               struct ocfs2_alloc_context *inode_ac);
  64
  65 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
  66                                     struct inode **ret_orphan_dir,
  67                                     u64 blkno,
  68                                     char *name,
  69                                     struct ocfs2_dir_lookup_result *lookup,
  70                                     bool dio);
  71
  72 static int ocfs2_orphan_add(struct ocfs2_super *osb,
  73                             handle_t *handle,
  74                             struct inode *inode,
  75                             struct buffer_head *fe_bh,
  76                             char *name,
  77                             struct ocfs2_dir_lookup_result *lookup,
  78                             struct inode *orphan_dir_inode,
  79                             bool dio);
  80
  81 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
  82                                      handle_t *handle,
  83                                      struct inode *inode,
  84                                      const char *symname);
  85
  86 static int ocfs2_double_lock(struct ocfs2_super *osb,
  87                              struct buffer_head **bh1,
  88                              struct inode *inode1,
  89                              struct buffer_head **bh2,
  90                              struct inode *inode2,
  91                              int rename);
  92
  93 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2);
  94 /* An orphan dir name is an 8 byte value, printed as a hex string */
  95 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
  96
  97 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
  98                                    unsigned int flags)
  99 {
 100         int status;
 101         u64 blkno;
 102         struct inode *inode = NULL;
 103         struct dentry *ret;
 104         struct ocfs2_inode_info *oi;
 105
 106         trace_ocfs2_lookup(dir, dentry, dentry->d_name.len,
 107                            dentry->d_name.name,
 108                            (unsigned long long)OCFS2_I(dir)->ip_blkno, 0);
 109
 110         if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
 111                 ret = ERR_PTR(-ENAMETOOLONG);
 112                 goto bail;
 113         }
 114
 115         status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
 116         if (status < 0) {
 117                 if (status != -ENOENT)
 118                         mlog_errno(status);
 119                 ret = ERR_PTR(status);
 120                 goto bail;
 121         }
 122
 123         status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
 124                                             dentry->d_name.len, &blkno);
 125         if (status < 0)
 126                 goto bail_add;
 127
 128         inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
 129         if (IS_ERR(inode)) {
 130                 ret = ERR_PTR(-EACCES);
 131                 goto bail_unlock;
 132         }
 133
 134         oi = OCFS2_I(inode);
 135         /* Clear any orphaned state... If we were able to look up the
 136          * inode from a directory, it certainly can't be orphaned. We
 137          * might have the bad state from a node which intended to
 138          * orphan this inode but crashed before it could commit the
 139          * unlink. */
 140         spin_lock(&oi->ip_lock);
 141         oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
 142         spin_unlock(&oi->ip_lock);
 143
 144 bail_add:
 145         ret = d_splice_alias(inode, dentry);
 146
 147         if (inode) {
 148                 /*
 149                  * If d_splice_alias() finds a DCACHE_DISCONNECTED
 150                  * dentry, it will d_move() it on top of ourse. The
 151                  * return value will indicate this however, so in
 152                  * those cases, we switch them around for the locking
 153                  * code.
 154                  *
 155                  * NOTE: This dentry already has ->d_op set from
 156                  * ocfs2_get_parent() and ocfs2_get_dentry()
 157                  */
 158                 if (!IS_ERR_OR_NULL(ret))
 159                         dentry = ret;
 160
 161                 status = ocfs2_dentry_attach_lock(dentry, inode,
 162                                                   OCFS2_I(dir)->ip_blkno);
 163                 if (status) {
 164                         mlog_errno(status);
 165                         ret = ERR_PTR(status);
 166                         goto bail_unlock;
 167                 }
 168         } else
 169                 ocfs2_dentry_attach_gen(dentry);
 170
 171 bail_unlock:
 172         /* Don't drop the cluster lock until *after* the d_add --
 173          * unlink on another node will message us to remove that
 174          * dentry under this lock so otherwise we can race this with
 175          * the downconvert thread and have a stale dentry. */
 176         ocfs2_inode_unlock(dir, 0);
 177
 178 bail:
 179
 180         trace_ocfs2_lookup_ret(ret);
 181
 182         return ret;
 183 }
 184
 185 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
 186 {
 187         struct inode *inode;
 188         int status;
 189
 190         inode = new_inode(dir->i_sb);
 191         if (!inode) {
 192                 mlog(ML_ERROR, "new_inode failed!\n");
 193                 return ERR_PTR(-ENOMEM);
 194         }
 195
 196         /* populate as many fields early on as possible - many of
 197          * these are used by the support functions here and in
 198          * callers. */
 199         if (S_ISDIR(mode))
 200                 set_nlink(inode, 2);
 201         inode_init_owner(inode, dir, mode);
 202         status = dquot_initialize(inode);
 203         if (status)
 204                 return ERR_PTR(status);
 205
 206         return inode;
 207 }
 208
 209 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb,
 210                 struct dentry *dentry, struct inode *inode)
 211 {
 212         struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
 213
 214         ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
 215         ocfs2_lock_res_free(&dl->dl_lockres);
 216         BUG_ON(dl->dl_count != 1);
 217         spin_lock(&dentry_attach_lock);
 218         dentry->d_fsdata = NULL;
 219         spin_unlock(&dentry_attach_lock);
 220         kfree(dl);
 221         iput(inode);
 222 }
 223
 224 static int ocfs2_mknod(struct inode *dir,
 225                        struct dentry *dentry,
 226                        umode_t mode,
 227                        dev_t dev)
 228 {
 229         int status = 0;
 230         struct buffer_head *parent_fe_bh = NULL;
 231         handle_t *handle = NULL;
 232         struct ocfs2_super *osb;
 233         struct ocfs2_dinode *dirfe;
 234         struct ocfs2_dinode *fe = NULL;
 235         struct buffer_head *new_fe_bh = NULL;
 236         struct inode *inode = NULL;
 237         struct ocfs2_alloc_context *inode_ac = NULL;
 238         struct ocfs2_alloc_context *data_ac = NULL;
 239         struct ocfs2_alloc_context *meta_ac = NULL;
 240         int want_clusters = 0;
 241         int want_meta = 0;
 242         int xattr_credits = 0;
 243         struct ocfs2_security_xattr_info si = {
 244                 .enable = 1,
 245         };
 246         int did_quota_inode = 0;
 247         struct ocfs2_dir_lookup_result lookup = { NULL, };
 248         sigset_t oldset;
 249         int did_block_signals = 0;
 250         struct ocfs2_dentry_lock *dl = NULL;
 251
 252         trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name,
 253                           (unsigned long long)OCFS2_I(dir)->ip_blkno,
 254                           (unsigned long)dev, mode);
 255
 256         status = dquot_initialize(dir);
 257         if (status) {
 258                 mlog_errno(status);
 259                 return status;
 260         }
 261
 262         /* get our super block */
 263         osb = OCFS2_SB(dir->i_sb);
 264
 265         status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
 266         if (status < 0) {
 267                 if (status != -ENOENT)
 268                         mlog_errno(status);
 269                 return status;
 270         }
 271
 272         if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
 273                 status = -EMLINK;
 274                 goto leave;
 275         }
 276
 277         dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
 278         if (!ocfs2_read_links_count(dirfe)) {
 279                 /* can't make a file in a deleted directory. */
 280                 status = -ENOENT;
 281                 goto leave;
 282         }
 283
 284         status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
 285                                            dentry->d_name.len);
 286         if (status)
 287                 goto leave;
 288
 289         /* get a spot inside the dir. */
 290         status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
 291                                               dentry->d_name.name,
 292                                               dentry->d_name.len, &lookup);
 293         if (status < 0) {
 294                 mlog_errno(status);
 295                 goto leave;
 296         }
 297
 298         /* reserve an inode spot */
 299         status = ocfs2_reserve_new_inode(osb, &inode_ac);
 300         if (status < 0) {
 301                 if (status != -ENOSPC)
 302                         mlog_errno(status);
 303                 goto leave;
 304         }
 305
 306         inode = ocfs2_get_init_inode(dir, mode);
 307         if (IS_ERR(inode)) {
 308                 status = PTR_ERR(inode);
 309                 inode = NULL;
 310                 mlog_errno(status);
 311                 goto leave;
 312         }
 313
 314         /* get security xattr */
 315         status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
 316         if (status) {
 317                 if (status == -EOPNOTSUPP)
 318                         si.enable = 0;
 319                 else {
 320                         mlog_errno(status);
 321                         goto leave;
 322                 }
 323         }
 324
 325         /* calculate meta data/clusters for setting security and acl xattr */
 326         status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
 327                                        &si, &want_clusters,
 328                                        &xattr_credits, &want_meta);
 329         if (status < 0) {
 330                 mlog_errno(status);
 331                 goto leave;
 332         }
 333
 334         /* Reserve a cluster if creating an extent based directory. */
 335         if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
 336                 want_clusters += 1;
 337
 338                 /* Dir indexing requires extra space as well */
 339                 if (ocfs2_supports_indexed_dirs(osb))
 340                         want_meta++;
 341         }
 342
 343         status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
 344         if (status < 0) {
 345                 if (status != -ENOSPC)
 346                         mlog_errno(status);
 347                 goto leave;
 348         }
 349
 350         status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
 351         if (status < 0) {
 352                 if (status != -ENOSPC)
 353                         mlog_errno(status);
 354                 goto leave;
 355         }
 356
 357         handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
 358                                                             S_ISDIR(mode),
 359                                                             xattr_credits));
 360         if (IS_ERR(handle)) {
 361                 status = PTR_ERR(handle);
 362                 handle = NULL;
 363                 mlog_errno(status);
 364                 goto leave;
 365         }
 366
 367         /* Starting to change things, restart is no longer possible. */
 368         ocfs2_block_signals(&oldset);
 369         did_block_signals = 1;
 370
 371         status = dquot_alloc_inode(inode);
 372         if (status)
 373                 goto leave;
 374         did_quota_inode = 1;
 375
 376         /* do the real work now. */
 377         status = ocfs2_mknod_locked(osb, dir, inode, dev,
 378                                     &new_fe_bh, parent_fe_bh, handle,
 379                                     inode_ac);
 380         if (status < 0) {
 381                 mlog_errno(status);
 382                 goto leave;
 383         }
 384
 385         fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
 386         if (S_ISDIR(mode)) {
 387                 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
 388                                             new_fe_bh, data_ac, meta_ac);
 389                 if (status < 0) {
 390                         mlog_errno(status);
 391                         goto leave;
 392                 }
 393
 394                 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
 395                                                  parent_fe_bh,
 396                                                  OCFS2_JOURNAL_ACCESS_WRITE);
 397                 if (status < 0) {
 398                         mlog_errno(status);
 399                         goto leave;
 400                 }
 401                 ocfs2_add_links_count(dirfe, 1);
 402                 ocfs2_journal_dirty(handle, parent_fe_bh);
 403                 inc_nlink(dir);
 404         }
 405
 406         status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
 407                          meta_ac, data_ac);
 408
 409         if (status < 0) {
 410                 mlog_errno(status);
 411                 goto roll_back;
 412         }
 413
 414         if (si.enable) {
 415                 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
 416                                                  meta_ac, data_ac);
 417                 if (status < 0) {
 418                         mlog_errno(status);
 419                         goto roll_back;
 420                 }
 421         }
 422
 423         /*
 424          * Do this before adding the entry to the directory. We add
 425          * also set d_op after success so that ->d_iput() will cleanup
 426          * the dentry lock even if ocfs2_add_entry() fails below.
 427          */
 428         status = ocfs2_dentry_attach_lock(dentry, inode,
 429                                           OCFS2_I(dir)->ip_blkno);
 430         if (status) {
 431                 mlog_errno(status);
 432                 goto roll_back;
 433         }
 434
 435         dl = dentry->d_fsdata;
 436
 437         status = ocfs2_add_entry(handle, dentry, inode,
 438                                  OCFS2_I(inode)->ip_blkno, parent_fe_bh,
 439                                  &lookup);
 440         if (status < 0) {
 441                 mlog_errno(status);
 442                 goto roll_back;
 443         }
 444
 445         insert_inode_hash(inode);
 446         d_instantiate(dentry, inode);
 447         status = 0;
 448
 449 roll_back:
 450         if (status < 0 && S_ISDIR(mode)) {
 451                 ocfs2_add_links_count(dirfe, -1);
 452                 drop_nlink(dir);
 453         }
 454
 455 leave:
 456         if (status < 0 && did_quota_inode)
 457                 dquot_free_inode(inode);
 458         if (handle) {
 459                 if (status < 0 && fe)
 460                         ocfs2_set_links_count(fe, 0);
 461                 ocfs2_commit_trans(osb, handle);
 462         }
 463
 464         ocfs2_inode_unlock(dir, 1);
 465         if (did_block_signals)
 466                 ocfs2_unblock_signals(&oldset);
 467
 468         brelse(new_fe_bh);
 469         brelse(parent_fe_bh);
 470         kfree(si.value);
 471
 472         ocfs2_free_dir_lookup_result(&lookup);
 473
 474         if (inode_ac)
 475                 ocfs2_free_alloc_context(inode_ac);
 476
 477         if (data_ac)
 478                 ocfs2_free_alloc_context(data_ac);
 479
 480         if (meta_ac)
 481                 ocfs2_free_alloc_context(meta_ac);
 482
 483         /*
 484          * We should call iput after the i_mutex of the bitmap been
 485          * unlocked in ocfs2_free_alloc_context, or the
 486          * ocfs2_delete_inode will mutex_lock again.
 487          */
 488         if ((status < 0) && inode) {
 489                 if (dl)
 490                         ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
 491
 492                 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
 493                 clear_nlink(inode);
 494                 iput(inode);
 495         }
 496
 497         if (status)
 498                 mlog_errno(status);
 499
 500         return status;
 501 }
 502
 503 static int __ocfs2_mknod_locked(struct inode *dir,
 504                                 struct inode *inode,
 505                                 dev_t dev,
 506                                 struct buffer_head **new_fe_bh,
 507                                 struct buffer_head *parent_fe_bh,
 508                                 handle_t *handle,
 509                                 struct ocfs2_alloc_context *inode_ac,
 510                                 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit)
 511 {
 512         int status = 0;
 513         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 514         struct ocfs2_dinode *fe = NULL;
 515         struct ocfs2_extent_list *fel;
 516         u16 feat;
 517         struct ocfs2_inode_info *oi = OCFS2_I(inode);
 518         struct timespec64 ts;
 519
 520         *new_fe_bh = NULL;
 521
 522         /* populate as many fields early on as possible - many of
 523          * these are used by the support functions here and in
 524          * callers. */
 525         inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
 526         oi->ip_blkno = fe_blkno;
 527         spin_lock(&osb->osb_lock);
 528         inode->i_generation = osb->s_next_generation++;
 529         spin_unlock(&osb->osb_lock);
 530
 531         *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
 532         if (!*new_fe_bh) {
 533                 status = -ENOMEM;
 534                 mlog_errno(status);
 535                 goto leave;
 536         }
 537         ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
 538
 539         status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
 540                                          *new_fe_bh,
 541                                          OCFS2_JOURNAL_ACCESS_CREATE);
 542         if (status < 0) {
 543                 mlog_errno(status);
 544                 goto leave;
 545         }
 546
 547         fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
 548         memset(fe, 0, osb->sb->s_blocksize);
 549
 550         fe->i_generation = cpu_to_le32(inode->i_generation);
 551         fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
 552         fe->i_blkno = cpu_to_le64(fe_blkno);
 553         fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
 554         fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
 555         fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
 556         fe->i_uid = cpu_to_le32(i_uid_read(inode));
 557         fe->i_gid = cpu_to_le32(i_gid_read(inode));
 558         fe->i_mode = cpu_to_le16(inode->i_mode);
 559         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 560                 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
 561
 562         ocfs2_set_links_count(fe, inode->i_nlink);
 563
 564         fe->i_last_eb_blk = 0;
 565         strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
 566         fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
 567         ktime_get_real_ts64(&ts);
 568         fe->i_atime = fe->i_ctime = fe->i_mtime =
 569                 cpu_to_le64(ts.tv_sec);
 570         fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
 571                 cpu_to_le32(ts.tv_nsec);
 572         fe->i_dtime = 0;
 573
 574         /*
 575          * If supported, directories start with inline data. If inline
 576          * isn't supported, but indexing is, we start them as indexed.
 577          */
 578         feat = le16_to_cpu(fe->i_dyn_features);
 579         if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
 580                 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
 581
 582                 fe->id2.i_data.id_count = cpu_to_le16(
 583                                 ocfs2_max_inline_data_with_xattr(osb->sb, fe));
 584         } else {
 585                 fel = &fe->id2.i_list;
 586                 fel->l_tree_depth = 0;
 587                 fel->l_next_free_rec = 0;
 588                 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
 589         }
 590
 591         ocfs2_journal_dirty(handle, *new_fe_bh);
 592
 593         ocfs2_populate_inode(inode, fe, 1);
 594         ocfs2_ci_set_new(osb, INODE_CACHE(inode));
 595         if (!ocfs2_mount_local(osb)) {
 596                 status = ocfs2_create_new_inode_locks(inode);
 597                 if (status < 0)
 598                         mlog_errno(status);
 599         }
 600
 601         ocfs2_update_inode_fsync_trans(handle, inode, 1);
 602
 603 leave:
 604         if (status < 0) {
 605                 if (*new_fe_bh) {
 606                         brelse(*new_fe_bh);
 607                         *new_fe_bh = NULL;
 608                 }
 609         }
 610
 611         if (status)
 612                 mlog_errno(status);
 613         return status;
 614 }
 615
 616 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
 617                               struct inode *dir,
 618                               struct inode *inode,
 619                               dev_t dev,
 620                               struct buffer_head **new_fe_bh,
 621                               struct buffer_head *parent_fe_bh,
 622                               handle_t *handle,
 623                               struct ocfs2_alloc_context *inode_ac)
 624 {
 625         int status = 0;
 626         u64 suballoc_loc, fe_blkno = 0;
 627         u16 suballoc_bit;
 628
 629         *new_fe_bh = NULL;
 630
 631         status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh,
 632                                        inode_ac, &suballoc_loc,
 633                                        &suballoc_bit, &fe_blkno);
 634         if (status < 0) {
 635                 mlog_errno(status);
 636                 return status;
 637         }
 638
 639         return __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh,
 640                                     parent_fe_bh, handle, inode_ac,
 641                                     fe_blkno, suballoc_loc, suballoc_bit);
 642 }
 643
 644 static int ocfs2_mkdir(struct inode *dir,
 645                        struct dentry *dentry,
 646                        umode_t mode)
 647 {
 648         int ret;
 649
 650         trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name,
 651                           OCFS2_I(dir)->ip_blkno, mode);
 652         ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
 653         if (ret)
 654                 mlog_errno(ret);
 655
 656         return ret;
 657 }
 658
 659 static int ocfs2_create(struct inode *dir,
 660                         struct dentry *dentry,
 661                         umode_t mode,
 662                         bool excl)
 663 {
 664         int ret;
 665
 666         trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name,
 667                            (unsigned long long)OCFS2_I(dir)->ip_blkno, mode);
 668         ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
 669         if (ret)
 670                 mlog_errno(ret);
 671
 672         return ret;
 673 }
 674
 675 static int ocfs2_link(struct dentry *old_dentry,
 676                       struct inode *dir,
 677                       struct dentry *dentry)
 678 {
 679         handle_t *handle;
 680         struct inode *inode = d_inode(old_dentry);
 681         struct inode *old_dir = d_inode(old_dentry->d_parent);
 682         int err;
 683         struct buffer_head *fe_bh = NULL;
 684         struct buffer_head *old_dir_bh = NULL;
 685         struct buffer_head *parent_fe_bh = NULL;
 686         struct ocfs2_dinode *fe = NULL;
 687         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 688         struct ocfs2_dir_lookup_result lookup = { NULL, };
 689         sigset_t oldset;
 690         u64 old_de_ino;
 691
 692         trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno,
 693                          old_dentry->d_name.len, old_dentry->d_name.name,
 694                          dentry->d_name.len, dentry->d_name.name);
 695
 696         if (S_ISDIR(inode->i_mode))
 697                 return -EPERM;
 698
 699         err = dquot_initialize(dir);
 700         if (err) {
 701                 mlog_errno(err);
 702                 return err;
 703         }
 704
 705         err = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
 706                         &parent_fe_bh, dir, 0);
 707         if (err < 0) {
 708                 if (err != -ENOENT)
 709                         mlog_errno(err);
 710                 return err;
 711         }
 712
 713         /* make sure both dirs have bhs
 714          * get an extra ref on old_dir_bh if old==new */
 715         if (!parent_fe_bh) {
 716                 if (old_dir_bh) {
 717                         parent_fe_bh = old_dir_bh;
 718                         get_bh(parent_fe_bh);
 719                 } else {
 720                         mlog(ML_ERROR, "%s: no old_dir_bh!\n", osb->uuid_str);
 721                         err = -EIO;
 722                         goto out;
 723                 }
 724         }
 725
 726         if (!dir->i_nlink) {
 727                 err = -ENOENT;
 728                 goto out;
 729         }
 730
 731         err = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
 732                         old_dentry->d_name.len, &old_de_ino);
 733         if (err) {
 734                 err = -ENOENT;
 735                 goto out;
 736         }
 737
 738         /*
 739          * Check whether another node removed the source inode while we
 740          * were in the vfs.
 741          */
 742         if (old_de_ino != OCFS2_I(inode)->ip_blkno) {
 743                 err = -ENOENT;
 744                 goto out;
 745         }
 746
 747         err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
 748                                         dentry->d_name.len);
 749         if (err)
 750                 goto out;
 751
 752         err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
 753                                            dentry->d_name.name,
 754                                            dentry->d_name.len, &lookup);
 755         if (err < 0) {
 756                 mlog_errno(err);
 757                 goto out;
 758         }
 759
 760         err = ocfs2_inode_lock(inode, &fe_bh, 1);
 761         if (err < 0) {
 762                 if (err != -ENOENT)
 763                         mlog_errno(err);
 764                 goto out;
 765         }
 766
 767         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 768         if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) {
 769                 err = -EMLINK;
 770                 goto out_unlock_inode;
 771         }
 772
 773         handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb));
 774         if (IS_ERR(handle)) {
 775                 err = PTR_ERR(handle);
 776                 handle = NULL;
 777                 mlog_errno(err);
 778                 goto out_unlock_inode;
 779         }
 780
 781         /* Starting to change things, restart is no longer possible. */
 782         ocfs2_block_signals(&oldset);
 783
 784         err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
 785                                       OCFS2_JOURNAL_ACCESS_WRITE);
 786         if (err < 0) {
 787                 mlog_errno(err);
 788                 goto out_commit;
 789         }
 790
 791         inc_nlink(inode);
 792         inode->i_ctime = current_time(inode);
 793         ocfs2_set_links_count(fe, inode->i_nlink);
 794         fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
 795         fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 796         ocfs2_journal_dirty(handle, fe_bh);
 797
 798         err = ocfs2_add_entry(handle, dentry, inode,
 799                               OCFS2_I(inode)->ip_blkno,
 800                               parent_fe_bh, &lookup);
 801         if (err) {
 802                 ocfs2_add_links_count(fe, -1);
 803                 drop_nlink(inode);
 804                 mlog_errno(err);
 805                 goto out_commit;
 806         }
 807
 808         err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
 809         if (err) {
 810                 mlog_errno(err);
 811                 goto out_commit;
 812         }
 813
 814         ihold(inode);
 815         d_instantiate(dentry, inode);
 816
 817 out_commit:
 818         ocfs2_commit_trans(osb, handle);
 819         ocfs2_unblock_signals(&oldset);
 820 out_unlock_inode:
 821         ocfs2_inode_unlock(inode, 1);
 822
 823 out:
 824         ocfs2_double_unlock(old_dir, dir);
 825
 826         brelse(fe_bh);
 827         brelse(parent_fe_bh);
 828         brelse(old_dir_bh);
 829
 830         ocfs2_free_dir_lookup_result(&lookup);
 831
 832         if (err)
 833                 mlog_errno(err);
 834
 835         return err;
 836 }
 837
 838 /*
 839  * Takes and drops an exclusive lock on the given dentry. This will
 840  * force other nodes to drop it.
 841  */
 842 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
 843 {
 844         int ret;
 845
 846         ret = ocfs2_dentry_lock(dentry, 1);
 847         if (ret)
 848                 mlog_errno(ret);
 849         else
 850                 ocfs2_dentry_unlock(dentry, 1);
 851
 852         return ret;
 853 }
 854
 855 static inline int ocfs2_inode_is_unlinkable(struct inode *inode)
 856 {
 857         if (S_ISDIR(inode->i_mode)) {
 858                 if (inode->i_nlink == 2)
 859                         return 1;
 860                 return 0;
 861         }
 862
 863         if (inode->i_nlink == 1)
 864                 return 1;
 865         return 0;
 866 }
 867
 868 static int ocfs2_unlink(struct inode *dir,
 869                         struct dentry *dentry)
 870 {
 871         int status;
 872         int child_locked = 0;
 873         bool is_unlinkable = false;
 874         struct inode *inode = d_inode(dentry);
 875         struct inode *orphan_dir = NULL;
 876         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 877         u64 blkno;
 878         struct ocfs2_dinode *fe = NULL;
 879         struct buffer_head *fe_bh = NULL;
 880         struct buffer_head *parent_node_bh = NULL;
 881         handle_t *handle = NULL;
 882         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
 883         struct ocfs2_dir_lookup_result lookup = { NULL, };
 884         struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
 885
 886         trace_ocfs2_unlink(dir, dentry, dentry->d_name.len,
 887                            dentry->d_name.name,
 888                            (unsigned long long)OCFS2_I(dir)->ip_blkno,
 889                            (unsigned long long)OCFS2_I(inode)->ip_blkno);
 890
 891         status = dquot_initialize(dir);
 892         if (status) {
 893                 mlog_errno(status);
 894                 return status;
 895         }
 896
 897         BUG_ON(d_inode(dentry->d_parent) != dir);
 898
 899         if (inode == osb->root_inode)
 900                 return -EPERM;
 901
 902         status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1,
 903                                          OI_LS_PARENT);
 904         if (status < 0) {
 905                 if (status != -ENOENT)
 906                         mlog_errno(status);
 907                 return status;
 908         }
 909
 910         status = ocfs2_find_files_on_disk(dentry->d_name.name,
 911                                           dentry->d_name.len, &blkno, dir,
 912                                           &lookup);
 913         if (status < 0) {
 914                 if (status != -ENOENT)
 915                         mlog_errno(status);
 916                 goto leave;
 917         }
 918
 919         if (OCFS2_I(inode)->ip_blkno != blkno) {
 920                 status = -ENOENT;
 921
 922                 trace_ocfs2_unlink_noent(
 923                                 (unsigned long long)OCFS2_I(inode)->ip_blkno,
 924                                 (unsigned long long)blkno,
 925                                 OCFS2_I(inode)->ip_flags);
 926                 goto leave;
 927         }
 928
 929         status = ocfs2_inode_lock(inode, &fe_bh, 1);
 930         if (status < 0) {
 931                 if (status != -ENOENT)
 932                         mlog_errno(status);
 933                 goto leave;
 934         }
 935         child_locked = 1;
 936
 937         if (S_ISDIR(inode->i_mode)) {
 938                 if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) {
 939                         status = -ENOTEMPTY;
 940                         goto leave;
 941                 }
 942         }
 943
 944         status = ocfs2_remote_dentry_delete(dentry);
 945         if (status < 0) {
 946                 /* This remote delete should succeed under all normal
 947                  * circumstances. */
 948                 mlog_errno(status);
 949                 goto leave;
 950         }
 951
 952         if (ocfs2_inode_is_unlinkable(inode)) {
 953                 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
 954                                                   OCFS2_I(inode)->ip_blkno,
 955                                                   orphan_name, &orphan_insert,
 956                                                   false);
 957                 if (status < 0) {
 958                         mlog_errno(status);
 959                         goto leave;
 960                 }
 961                 is_unlinkable = true;
 962         }
 963
 964         handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
 965         if (IS_ERR(handle)) {
 966                 status = PTR_ERR(handle);
 967                 handle = NULL;
 968                 mlog_errno(status);
 969                 goto leave;
 970         }
 971
 972         status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
 973                                          OCFS2_JOURNAL_ACCESS_WRITE);
 974         if (status < 0) {
 975                 mlog_errno(status);
 976                 goto leave;
 977         }
 978
 979         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 980
 981         /* delete the name from the parent dir */
 982         status = ocfs2_delete_entry(handle, dir, &lookup);
 983         if (status < 0) {
 984                 mlog_errno(status);
 985                 goto leave;
 986         }
 987
 988         if (S_ISDIR(inode->i_mode))
 989                 drop_nlink(inode);
 990         drop_nlink(inode);
 991         ocfs2_set_links_count(fe, inode->i_nlink);
 992         ocfs2_journal_dirty(handle, fe_bh);
 993
 994         dir->i_ctime = dir->i_mtime = current_time(dir);
 995         if (S_ISDIR(inode->i_mode))
 996                 drop_nlink(dir);
 997
 998         status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
 999         if (status < 0) {
1000                 mlog_errno(status);
1001                 if (S_ISDIR(inode->i_mode))
1002                         inc_nlink(dir);
1003                 goto leave;
1004         }
1005
1006         if (is_unlinkable) {
1007                 status = ocfs2_orphan_add(osb, handle, inode, fe_bh,
1008                                 orphan_name, &orphan_insert, orphan_dir, false);
1009                 if (status < 0)
1010                         mlog_errno(status);
1011         }
1012
1013 leave:
1014         if (handle)
1015                 ocfs2_commit_trans(osb, handle);
1016
1017         if (orphan_dir) {
1018                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1019                 ocfs2_inode_unlock(orphan_dir, 1);
1020                 inode_unlock(orphan_dir);
1021                 iput(orphan_dir);
1022         }
1023
1024         if (child_locked)
1025                 ocfs2_inode_unlock(inode, 1);
1026
1027         ocfs2_inode_unlock(dir, 1);
1028
1029         brelse(fe_bh);
1030         brelse(parent_node_bh);
1031
1032         ocfs2_free_dir_lookup_result(&orphan_insert);
1033         ocfs2_free_dir_lookup_result(&lookup);
1034
1035         if (status && (status != -ENOTEMPTY) && (status != -ENOENT))
1036                 mlog_errno(status);
1037
1038         return status;
1039 }
1040
1041 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb,
1042                 u64 src_inode_no, u64 dest_inode_no)
1043 {
1044         int ret = 0, i = 0;
1045         u64 parent_inode_no = 0;
1046         u64 child_inode_no = src_inode_no;
1047         struct inode *child_inode;
1048
1049 #define MAX_LOOKUP_TIMES 32
1050         while (1) {
1051                 child_inode = ocfs2_iget(osb, child_inode_no, 0, 0);
1052                 if (IS_ERR(child_inode)) {
1053                         ret = PTR_ERR(child_inode);
1054                         break;
1055                 }
1056
1057                 ret = ocfs2_inode_lock(child_inode, NULL, 0);
1058                 if (ret < 0) {
1059                         iput(child_inode);
1060                         if (ret != -ENOENT)
1061                                 mlog_errno(ret);
1062                         break;
1063                 }
1064
1065                 ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2,
1066                                 &parent_inode_no);
1067                 ocfs2_inode_unlock(child_inode, 0);
1068                 iput(child_inode);
1069                 if (ret < 0) {
1070                         ret = -ENOENT;
1071                         break;
1072                 }
1073
1074                 if (parent_inode_no == dest_inode_no) {
1075                         ret = 1;
1076                         break;
1077                 }
1078
1079                 if (parent_inode_no == osb->root_inode->i_ino) {
1080                         ret = 0;
1081                         break;
1082                 }
1083
1084                 child_inode_no = parent_inode_no;
1085
1086                 if (++i >= MAX_LOOKUP_TIMES) {
1087                         mlog(ML_NOTICE, "max lookup times reached, filesystem "
1088                                         "may have nested directories, "
1089                                         "src inode: %llu, dest inode: %llu.\n",
1090                                         (unsigned long long)src_inode_no,
1091                                         (unsigned long long)dest_inode_no);
1092                         ret = 0;
1093                         break;
1094                 }
1095         }
1096
1097         return ret;
1098 }
1099
1100 /*
1101  * The only place this should be used is rename and link!
1102  * if they have the same id, then the 1st one is the only one locked.
1103  */
1104 static int ocfs2_double_lock(struct ocfs2_super *osb,
1105                              struct buffer_head **bh1,
1106                              struct inode *inode1,
1107                              struct buffer_head **bh2,
1108                              struct inode *inode2,
1109                              int rename)
1110 {
1111         int status;
1112         int inode1_is_ancestor, inode2_is_ancestor;
1113         struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
1114         struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
1115
1116         trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno,
1117                                 (unsigned long long)oi2->ip_blkno);
1118
1119         if (*bh1)
1120                 *bh1 = NULL;
1121         if (*bh2)
1122                 *bh2 = NULL;
1123
1124         /* we always want to lock the one with the lower lockid first.
1125          * and if they are nested, we lock ancestor first */
1126         if (oi1->ip_blkno != oi2->ip_blkno) {
1127                 inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno,
1128                                 oi1->ip_blkno);
1129                 if (inode1_is_ancestor < 0) {
1130                         status = inode1_is_ancestor;
1131                         goto bail;
1132                 }
1133
1134                 inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno,
1135                                 oi2->ip_blkno);
1136                 if (inode2_is_ancestor < 0) {
1137                         status = inode2_is_ancestor;
1138                         goto bail;
1139                 }
1140
1141                 if ((inode1_is_ancestor == 1) ||
1142                                 (oi1->ip_blkno < oi2->ip_blkno &&
1143                                 inode2_is_ancestor == 0)) {
1144                         /* switch id1 and id2 around */
1145                         swap(bh2, bh1);
1146                         swap(inode2, inode1);
1147                 }
1148                 /* lock id2 */
1149                 status = ocfs2_inode_lock_nested(inode2, bh2, 1,
1150                                 rename == 1 ? OI_LS_RENAME1 : OI_LS_PARENT);
1151                 if (status < 0) {
1152                         if (status != -ENOENT)
1153                                 mlog_errno(status);
1154                         goto bail;
1155                 }
1156         }
1157
1158         /* lock id1 */
1159         status = ocfs2_inode_lock_nested(inode1, bh1, 1,
1160                         rename == 1 ?  OI_LS_RENAME2 : OI_LS_PARENT);
1161         if (status < 0) {
1162                 /*
1163                  * An error return must mean that no cluster locks
1164                  * were held on function exit.
1165                  */
1166                 if (oi1->ip_blkno != oi2->ip_blkno) {
1167                         ocfs2_inode_unlock(inode2, 1);
1168                         brelse(*bh2);
1169                         *bh2 = NULL;
1170                 }
1171
1172                 if (status != -ENOENT)
1173                         mlog_errno(status);
1174         }
1175
1176         trace_ocfs2_double_lock_end(
1177                         (unsigned long long)oi1->ip_blkno,
1178                         (unsigned long long)oi2->ip_blkno);
1179
1180 bail:
1181         if (status)
1182                 mlog_errno(status);
1183         return status;
1184 }
1185
1186 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
1187 {
1188         ocfs2_inode_unlock(inode1, 1);
1189
1190         if (inode1 != inode2)
1191                 ocfs2_inode_unlock(inode2, 1);
1192 }
1193
1194 static int ocfs2_rename(struct inode *old_dir,
1195                         struct dentry *old_dentry,
1196                         struct inode *new_dir,
1197                         struct dentry *new_dentry,
1198                         unsigned int flags)
1199 {
1200         int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
1201         int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
1202         struct inode *old_inode = d_inode(old_dentry);
1203         struct inode *new_inode = d_inode(new_dentry);
1204         struct inode *orphan_dir = NULL;
1205         struct ocfs2_dinode *newfe = NULL;
1206         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1207         struct buffer_head *newfe_bh = NULL;
1208         struct buffer_head *old_inode_bh = NULL;
1209         struct ocfs2_super *osb = NULL;
1210         u64 newfe_blkno, old_de_ino;
1211         handle_t *handle = NULL;
1212         struct buffer_head *old_dir_bh = NULL;
1213         struct buffer_head *new_dir_bh = NULL;
1214         u32 old_dir_nlink = old_dir->i_nlink;
1215         struct ocfs2_dinode *old_di;
1216         struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, };
1217         struct ocfs2_dir_lookup_result target_lookup_res = { NULL, };
1218         struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, };
1219         struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
1220         struct ocfs2_dir_lookup_result target_insert = { NULL, };
1221         bool should_add_orphan = false;
1222
1223         if (flags)
1224                 return -EINVAL;
1225
1226         /* At some point it might be nice to break this function up a
1227          * bit. */
1228
1229         trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry,
1230                            old_dentry->d_name.len, old_dentry->d_name.name,
1231                            new_dentry->d_name.len, new_dentry->d_name.name);
1232
1233         status = dquot_initialize(old_dir);
1234         if (status) {
1235                 mlog_errno(status);
1236                 goto bail;
1237         }
1238         status = dquot_initialize(new_dir);
1239         if (status) {
1240                 mlog_errno(status);
1241                 goto bail;
1242         }
1243
1244         osb = OCFS2_SB(old_dir->i_sb);
1245
1246         if (new_inode) {
1247                 if (!igrab(new_inode))
1248                         BUG();
1249         }
1250
1251         /* Assume a directory hierarchy thusly:
1252          * a/b/c
1253          * a/d
1254          * a,b,c, and d are all directories.
1255          *
1256          * from cwd of 'a' on both nodes:
1257          * node1: mv b/c d
1258          * node2: mv d   b/c
1259          *
1260          * And that's why, just like the VFS, we need a file system
1261          * rename lock. */
1262         if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1263                 status = ocfs2_rename_lock(osb);
1264                 if (status < 0) {
1265                         mlog_errno(status);
1266                         goto bail;
1267                 }
1268                 rename_lock = 1;
1269
1270                 /* here we cannot guarantee the inodes haven't just been
1271                  * changed, so check if they are nested again */
1272                 status = ocfs2_check_if_ancestor(osb, new_dir->i_ino,
1273                                 old_inode->i_ino);
1274                 if (status < 0) {
1275                         mlog_errno(status);
1276                         goto bail;
1277                 } else if (status == 1) {
1278                         status = -EPERM;
1279                         trace_ocfs2_rename_not_permitted(
1280                                         (unsigned long long)old_inode->i_ino,
1281                                         (unsigned long long)new_dir->i_ino);
1282                         goto bail;
1283                 }
1284         }
1285
1286         /* if old and new are the same, this'll just do one lock. */
1287         status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1288                                    &new_dir_bh, new_dir, 1);
1289         if (status < 0) {
1290                 mlog_errno(status);
1291                 goto bail;
1292         }
1293         parents_locked = 1;
1294
1295         if (!new_dir->i_nlink) {
1296                 status = -EACCES;
1297                 goto bail;
1298         }
1299
1300         /* make sure both dirs have bhs
1301          * get an extra ref on old_dir_bh if old==new */
1302         if (!new_dir_bh) {
1303                 if (old_dir_bh) {
1304                         new_dir_bh = old_dir_bh;
1305                         get_bh(new_dir_bh);
1306                 } else {
1307                         mlog(ML_ERROR, "no old_dir_bh!\n");
1308                         status = -EIO;
1309                         goto bail;
1310                 }
1311         }
1312
1313         /*
1314          * Aside from allowing a meta data update, the locking here
1315          * also ensures that the downconvert thread on other nodes
1316          * won't have to concurrently downconvert the inode and the
1317          * dentry locks.
1318          */
1319         status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1,
1320                                          OI_LS_PARENT);
1321         if (status < 0) {
1322                 if (status != -ENOENT)
1323                         mlog_errno(status);
1324                 goto bail;
1325         }
1326         old_child_locked = 1;
1327
1328         status = ocfs2_remote_dentry_delete(old_dentry);
1329         if (status < 0) {
1330                 mlog_errno(status);
1331                 goto bail;
1332         }
1333
1334         if (S_ISDIR(old_inode->i_mode)) {
1335                 u64 old_inode_parent;
1336
1337                 update_dot_dot = 1;
1338                 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1339                                                   old_inode,
1340                                                   &old_inode_dot_dot_res);
1341                 if (status) {
1342                         status = -EIO;
1343                         goto bail;
1344                 }
1345
1346                 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1347                         status = -EIO;
1348                         goto bail;
1349                 }
1350
1351                 if (!new_inode && new_dir != old_dir &&
1352                     new_dir->i_nlink >= ocfs2_link_max(osb)) {
1353                         status = -EMLINK;
1354                         goto bail;
1355                 }
1356         }
1357
1358         status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1359                                             old_dentry->d_name.len,
1360                                             &old_de_ino);
1361         if (status) {
1362                 status = -ENOENT;
1363                 goto bail;
1364         }
1365
1366         /*
1367          *  Check for inode number is _not_ due to possible IO errors.
1368          *  We might rmdir the source, keep it as pwd of some process
1369          *  and merrily kill the link to whatever was created under the
1370          *  same name. Goodbye sticky bit ;-<
1371          */
1372         if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1373                 status = -ENOENT;
1374                 goto bail;
1375         }
1376
1377         /* check if the target already exists (in which case we need
1378          * to delete it */
1379         status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1380                                           new_dentry->d_name.len,
1381                                           &newfe_blkno, new_dir,
1382                                           &target_lookup_res);
1383         /* The only error we allow here is -ENOENT because the new
1384          * file not existing is perfectly valid. */
1385         if ((status < 0) && (status != -ENOENT)) {
1386                 /* If we cannot find the file specified we should just */
1387                 /* return the error... */
1388                 mlog_errno(status);
1389                 goto bail;
1390         }
1391         if (status == 0)
1392                 target_exists = 1;
1393
1394         if (!target_exists && new_inode) {
1395                 /*
1396                  * Target was unlinked by another node while we were
1397                  * waiting to get to ocfs2_rename(). There isn't
1398                  * anything we can do here to help the situation, so
1399                  * bubble up the appropriate error.
1400                  */
1401                 status = -ENOENT;
1402                 goto bail;
1403         }
1404
1405         /* In case we need to overwrite an existing file, we blow it
1406          * away first */
1407         if (target_exists) {
1408                 /* VFS didn't think there existed an inode here, but
1409                  * someone else in the cluster must have raced our
1410                  * rename to create one. Today we error cleanly, in
1411                  * the future we should consider calling iget to build
1412                  * a new struct inode for this entry. */
1413                 if (!new_inode) {
1414                         status = -EACCES;
1415
1416                         trace_ocfs2_rename_target_exists(new_dentry->d_name.len,
1417                                                 new_dentry->d_name.name);
1418                         goto bail;
1419                 }
1420
1421                 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1422                         status = -EACCES;
1423
1424                         trace_ocfs2_rename_disagree(
1425                              (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1426                              (unsigned long long)newfe_blkno,
1427                              OCFS2_I(new_inode)->ip_flags);
1428                         goto bail;
1429                 }
1430
1431                 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1432                 if (status < 0) {
1433                         if (status != -ENOENT)
1434                                 mlog_errno(status);
1435                         goto bail;
1436                 }
1437                 new_child_locked = 1;
1438
1439                 status = ocfs2_remote_dentry_delete(new_dentry);
1440                 if (status < 0) {
1441                         mlog_errno(status);
1442                         goto bail;
1443                 }
1444
1445                 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1446
1447                 trace_ocfs2_rename_over_existing(
1448                      (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1449                      (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1450
1451                 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1452                         status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1453                                                 OCFS2_I(new_inode)->ip_blkno,
1454                                                 orphan_name, &orphan_insert,
1455                                                 false);
1456                         if (status < 0) {
1457                                 mlog_errno(status);
1458                                 goto bail;
1459                         }
1460                         should_add_orphan = true;
1461                 }
1462         } else {
1463                 BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
1464
1465                 status = ocfs2_check_dir_for_entry(new_dir,
1466                                                    new_dentry->d_name.name,
1467                                                    new_dentry->d_name.len);
1468                 if (status)
1469                         goto bail;
1470
1471                 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1472                                                       new_dentry->d_name.name,
1473                                                       new_dentry->d_name.len,
1474                                                       &target_insert);
1475                 if (status < 0) {
1476                         mlog_errno(status);
1477                         goto bail;
1478                 }
1479         }
1480
1481         handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
1482         if (IS_ERR(handle)) {
1483                 status = PTR_ERR(handle);
1484                 handle = NULL;
1485                 mlog_errno(status);
1486                 goto bail;
1487         }
1488
1489         if (target_exists) {
1490                 if (S_ISDIR(new_inode->i_mode)) {
1491                         if (new_inode->i_nlink != 2 ||
1492                             !ocfs2_empty_dir(new_inode)) {
1493                                 status = -ENOTEMPTY;
1494                                 goto bail;
1495                         }
1496                 }
1497                 status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode),
1498                                                  newfe_bh,
1499                                                  OCFS2_JOURNAL_ACCESS_WRITE);
1500                 if (status < 0) {
1501                         mlog_errno(status);
1502                         goto bail;
1503                 }
1504
1505                 /* change the dirent to point to the correct inode */
1506                 status = ocfs2_update_entry(new_dir, handle, &target_lookup_res,
1507                                             old_inode);
1508                 if (status < 0) {
1509                         mlog_errno(status);
1510                         goto bail;
1511                 }
1512                 inode_inc_iversion(new_dir);
1513
1514                 if (S_ISDIR(new_inode->i_mode))
1515                         ocfs2_set_links_count(newfe, 0);
1516                 else
1517                         ocfs2_add_links_count(newfe, -1);
1518                 ocfs2_journal_dirty(handle, newfe_bh);
1519                 if (should_add_orphan) {
1520                         status = ocfs2_orphan_add(osb, handle, new_inode,
1521                                         newfe_bh, orphan_name,
1522                                         &orphan_insert, orphan_dir, false);
1523                         if (status < 0) {
1524                                 mlog_errno(status);
1525                                 goto bail;
1526                         }
1527                 }
1528         } else {
1529                 /* if the name was not found in new_dir, add it now */
1530                 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1531                                          OCFS2_I(old_inode)->ip_blkno,
1532                                          new_dir_bh, &target_insert);
1533         }
1534
1535         old_inode->i_ctime = current_time(old_inode);
1536         mark_inode_dirty(old_inode);
1537
1538         status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
1539                                          old_inode_bh,
1540                                          OCFS2_JOURNAL_ACCESS_WRITE);
1541         if (status >= 0) {
1542                 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1543
1544                 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1545                 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1546                 ocfs2_journal_dirty(handle, old_inode_bh);
1547         } else
1548                 mlog_errno(status);
1549
1550         /*
1551          * Now that the name has been added to new_dir, remove the old name.
1552          *
1553          * We don't keep any directory entry context around until now
1554          * because the insert might have changed the type of directory
1555          * we're dealing with.
1556          */
1557         status = ocfs2_find_entry(old_dentry->d_name.name,
1558                                   old_dentry->d_name.len, old_dir,
1559                                   &old_entry_lookup);
1560         if (status) {
1561                 if (!is_journal_aborted(osb->journal->j_journal)) {
1562                         ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1563                                         "is not deleted.",
1564                                         new_dentry->d_name.len, new_dentry->d_name.name,
1565                                         old_dentry->d_name.len, old_dentry->d_name.name);
1566                 }
1567                 goto bail;
1568         }
1569
1570         status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup);
1571         if (status < 0) {
1572                 mlog_errno(status);
1573                 if (!is_journal_aborted(osb->journal->j_journal)) {
1574                         ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1575                                         "is not deleted.",
1576                                         new_dentry->d_name.len, new_dentry->d_name.name,
1577                                         old_dentry->d_name.len, old_dentry->d_name.name);
1578                 }
1579                 goto bail;
1580         }
1581
1582         if (new_inode) {
1583                 drop_nlink(new_inode);
1584                 new_inode->i_ctime = current_time(new_inode);
1585         }
1586         old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
1587
1588         if (update_dot_dot) {
1589                 status = ocfs2_update_entry(old_inode, handle,
1590                                             &old_inode_dot_dot_res, new_dir);
1591                 drop_nlink(old_dir);
1592                 if (new_inode) {
1593                         drop_nlink(new_inode);
1594                 } else {
1595                         inc_nlink(new_dir);
1596                         mark_inode_dirty(new_dir);
1597                 }
1598         }
1599         mark_inode_dirty(old_dir);
1600         ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1601         if (new_inode) {
1602                 mark_inode_dirty(new_inode);
1603                 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1604         }
1605
1606         if (old_dir != new_dir) {
1607                 /* Keep the same times on both directories.*/
1608                 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1609
1610                 /*
1611                  * This will also pick up the i_nlink change from the
1612                  * block above.
1613                  */
1614                 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1615         }
1616
1617         if (old_dir_nlink != old_dir->i_nlink) {
1618                 if (!old_dir_bh) {
1619                         mlog(ML_ERROR, "need to change nlink for old dir "
1620                              "%llu from %d to %d but bh is NULL!\n",
1621                              (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1622                              (int)old_dir_nlink, old_dir->i_nlink);
1623                 } else {
1624                         struct ocfs2_dinode *fe;
1625                         status = ocfs2_journal_access_di(handle,
1626                                                          INODE_CACHE(old_dir),
1627                                                          old_dir_bh,
1628                                                          OCFS2_JOURNAL_ACCESS_WRITE);
1629                         fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1630                         ocfs2_set_links_count(fe, old_dir->i_nlink);
1631                         ocfs2_journal_dirty(handle, old_dir_bh);
1632                 }
1633         }
1634         ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1635         status = 0;
1636 bail:
1637         if (handle)
1638                 ocfs2_commit_trans(osb, handle);
1639
1640         if (orphan_dir) {
1641                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1642                 ocfs2_inode_unlock(orphan_dir, 1);
1643                 inode_unlock(orphan_dir);
1644                 iput(orphan_dir);
1645         }
1646
1647         if (new_child_locked)
1648                 ocfs2_inode_unlock(new_inode, 1);
1649
1650         if (old_child_locked)
1651                 ocfs2_inode_unlock(old_inode, 1);
1652
1653         if (parents_locked)
1654                 ocfs2_double_unlock(old_dir, new_dir);
1655
1656         if (rename_lock)
1657                 ocfs2_rename_unlock(osb);
1658
1659         if (new_inode)
1660                 sync_mapping_buffers(old_inode->i_mapping);
1661
1662         iput(new_inode);
1663
1664         ocfs2_free_dir_lookup_result(&target_lookup_res);
1665         ocfs2_free_dir_lookup_result(&old_entry_lookup);
1666         ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res);
1667         ocfs2_free_dir_lookup_result(&orphan_insert);
1668         ocfs2_free_dir_lookup_result(&target_insert);
1669
1670         brelse(newfe_bh);
1671         brelse(old_inode_bh);
1672         brelse(old_dir_bh);
1673         brelse(new_dir_bh);
1674
1675         if (status)
1676                 mlog_errno(status);
1677
1678         return status;
1679 }
1680
1681 /*
1682  * we expect i_size = strlen(symname). Copy symname into the file
1683  * data, including the null terminator.
1684  */
1685 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1686                                      handle_t *handle,
1687                                      struct inode *inode,
1688                                      const char *symname)
1689 {
1690         struct buffer_head **bhs = NULL;
1691         const char *c;
1692         struct super_block *sb = osb->sb;
1693         u64 p_blkno, p_blocks;
1694         int virtual, blocks, status, i, bytes_left;
1695
1696         bytes_left = i_size_read(inode) + 1;
1697         /* we can't trust i_blocks because we're actually going to
1698          * write i_size + 1 bytes. */
1699         blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1700
1701         trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks,
1702                                         i_size_read(inode), blocks);
1703
1704         /* Sanity check -- make sure we're going to fit. */
1705         if (bytes_left >
1706             ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1707                 status = -EIO;
1708                 mlog_errno(status);
1709                 goto bail;
1710         }
1711
1712         bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1713         if (!bhs) {
1714                 status = -ENOMEM;
1715                 mlog_errno(status);
1716                 goto bail;
1717         }
1718
1719         status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1720                                              NULL);
1721         if (status < 0) {
1722                 mlog_errno(status);
1723                 goto bail;
1724         }
1725
1726         /* links can never be larger than one cluster so we know this
1727          * is all going to be contiguous, but do a sanity check
1728          * anyway. */
1729         if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1730                 status = -EIO;
1731                 mlog_errno(status);
1732                 goto bail;
1733         }
1734
1735         virtual = 0;
1736         while(bytes_left > 0) {
1737                 c = &symname[virtual * sb->s_blocksize];
1738
1739                 bhs[virtual] = sb_getblk(sb, p_blkno);
1740                 if (!bhs[virtual]) {
1741                         status = -ENOMEM;
1742                         mlog_errno(status);
1743                         goto bail;
1744                 }
1745                 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode),
1746                                               bhs[virtual]);
1747
1748                 status = ocfs2_journal_access(handle, INODE_CACHE(inode),
1749                                               bhs[virtual],
1750                                               OCFS2_JOURNAL_ACCESS_CREATE);
1751                 if (status < 0) {
1752                         mlog_errno(status);
1753                         goto bail;
1754                 }
1755
1756                 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1757
1758                 memcpy(bhs[virtual]->b_data, c,
1759                        (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1760                        bytes_left);
1761
1762                 ocfs2_journal_dirty(handle, bhs[virtual]);
1763
1764                 virtual++;
1765                 p_blkno++;
1766                 bytes_left -= sb->s_blocksize;
1767         }
1768
1769         status = 0;
1770 bail:
1771
1772         if (bhs) {
1773                 for(i = 0; i < blocks; i++)
1774                         brelse(bhs[i]);
1775                 kfree(bhs);
1776         }
1777
1778         if (status)
1779                 mlog_errno(status);
1780         return status;
1781 }
1782
1783 static int ocfs2_symlink(struct inode *dir,
1784                          struct dentry *dentry,
1785                          const char *symname)
1786 {
1787         int status, l, credits;
1788         u64 newsize;
1789         struct ocfs2_super *osb = NULL;
1790         struct inode *inode = NULL;
1791         struct super_block *sb;
1792         struct buffer_head *new_fe_bh = NULL;
1793         struct buffer_head *parent_fe_bh = NULL;
1794         struct ocfs2_dinode *fe = NULL;
1795         struct ocfs2_dinode *dirfe;
1796         handle_t *handle = NULL;
1797         struct ocfs2_alloc_context *inode_ac = NULL;
1798         struct ocfs2_alloc_context *data_ac = NULL;
1799         struct ocfs2_alloc_context *xattr_ac = NULL;
1800         int want_clusters = 0;
1801         int xattr_credits = 0;
1802         struct ocfs2_security_xattr_info si = {
1803                 .enable = 1,
1804         };
1805         int did_quota = 0, did_quota_inode = 0;
1806         struct ocfs2_dir_lookup_result lookup = { NULL, };
1807         sigset_t oldset;
1808         int did_block_signals = 0;
1809         struct ocfs2_dentry_lock *dl = NULL;
1810
1811         trace_ocfs2_symlink_begin(dir, dentry, symname,
1812                                   dentry->d_name.len, dentry->d_name.name);
1813
1814         status = dquot_initialize(dir);
1815         if (status) {
1816                 mlog_errno(status);
1817                 goto bail;
1818         }
1819
1820         sb = dir->i_sb;
1821         osb = OCFS2_SB(sb);
1822
1823         l = strlen(symname) + 1;
1824
1825         credits = ocfs2_calc_symlink_credits(sb);
1826
1827         /* lock the parent directory */
1828         status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1829         if (status < 0) {
1830                 if (status != -ENOENT)
1831                         mlog_errno(status);
1832                 return status;
1833         }
1834
1835         dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1836         if (!ocfs2_read_links_count(dirfe)) {
1837                 /* can't make a file in a deleted directory. */
1838                 status = -ENOENT;
1839                 goto bail;
1840         }
1841
1842         status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1843                                            dentry->d_name.len);
1844         if (status)
1845                 goto bail;
1846
1847         status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1848                                               dentry->d_name.name,
1849                                               dentry->d_name.len, &lookup);
1850         if (status < 0) {
1851                 mlog_errno(status);
1852                 goto bail;
1853         }
1854
1855         status = ocfs2_reserve_new_inode(osb, &inode_ac);
1856         if (status < 0) {
1857                 if (status != -ENOSPC)
1858                         mlog_errno(status);
1859                 goto bail;
1860         }
1861
1862         inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1863         if (IS_ERR(inode)) {
1864                 status = PTR_ERR(inode);
1865                 inode = NULL;
1866                 mlog_errno(status);
1867                 goto bail;
1868         }
1869
1870         /* get security xattr */
1871         status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
1872         if (status) {
1873                 if (status == -EOPNOTSUPP)
1874                         si.enable = 0;
1875                 else {
1876                         mlog_errno(status);
1877                         goto bail;
1878                 }
1879         }
1880
1881         /* calculate meta data/clusters for setting security xattr */
1882         if (si.enable) {
1883                 status = ocfs2_calc_security_init(dir, &si, &want_clusters,
1884                                                   &xattr_credits, &xattr_ac);
1885                 if (status < 0) {
1886                         mlog_errno(status);
1887                         goto bail;
1888                 }
1889         }
1890
1891         /* don't reserve bitmap space for fast symlinks. */
1892         if (l > ocfs2_fast_symlink_chars(sb))
1893                 want_clusters += 1;
1894
1895         status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
1896         if (status < 0) {
1897                 if (status != -ENOSPC)
1898                         mlog_errno(status);
1899                 goto bail;
1900         }
1901
1902         handle = ocfs2_start_trans(osb, credits + xattr_credits);
1903         if (IS_ERR(handle)) {
1904                 status = PTR_ERR(handle);
1905                 handle = NULL;
1906                 mlog_errno(status);
1907                 goto bail;
1908         }
1909
1910         /* Starting to change things, restart is no longer possible. */
1911         ocfs2_block_signals(&oldset);
1912         did_block_signals = 1;
1913
1914         status = dquot_alloc_inode(inode);
1915         if (status)
1916                 goto bail;
1917         did_quota_inode = 1;
1918
1919         trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len,
1920                                    dentry->d_name.name,
1921                                    (unsigned long long)OCFS2_I(dir)->ip_blkno,
1922                                    inode->i_mode);
1923
1924         status = ocfs2_mknod_locked(osb, dir, inode,
1925                                     0, &new_fe_bh, parent_fe_bh, handle,
1926                                     inode_ac);
1927         if (status < 0) {
1928                 mlog_errno(status);
1929                 goto bail;
1930         }
1931
1932         fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1933         inode->i_rdev = 0;
1934         newsize = l - 1;
1935         inode->i_op = &ocfs2_symlink_inode_operations;
1936         inode_nohighmem(inode);
1937         if (l > ocfs2_fast_symlink_chars(sb)) {
1938                 u32 offset = 0;
1939
1940                 status = dquot_alloc_space_nodirty(inode,
1941                     ocfs2_clusters_to_bytes(osb->sb, 1));
1942                 if (status)
1943                         goto bail;
1944                 did_quota = 1;
1945                 inode->i_mapping->a_ops = &ocfs2_aops;
1946                 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1947                                               new_fe_bh,
1948                                               handle, data_ac, NULL,
1949                                               NULL);
1950                 if (status < 0) {
1951                         if (status != -ENOSPC && status != -EINTR) {
1952                                 mlog(ML_ERROR,
1953                                      "Failed to extend file to %llu\n",
1954                                      (unsigned long long)newsize);
1955                                 mlog_errno(status);
1956                                 status = -ENOSPC;
1957                         }
1958                         goto bail;
1959                 }
1960                 i_size_write(inode, newsize);
1961                 inode->i_blocks = ocfs2_inode_sector_count(inode);
1962         } else {
1963                 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops;
1964                 memcpy((char *) fe->id2.i_symlink, symname, l);
1965                 i_size_write(inode, newsize);
1966                 inode->i_blocks = 0;
1967         }
1968
1969         status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1970         if (status < 0) {
1971                 mlog_errno(status);
1972                 goto bail;
1973         }
1974
1975         if (!ocfs2_inode_is_fast_symlink(inode)) {
1976                 status = ocfs2_create_symlink_data(osb, handle, inode,
1977                                                    symname);
1978                 if (status < 0) {
1979                         mlog_errno(status);
1980                         goto bail;
1981                 }
1982         }
1983
1984         if (si.enable) {
1985                 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
1986                                                  xattr_ac, data_ac);
1987                 if (status < 0) {
1988                         mlog_errno(status);
1989                         goto bail;
1990                 }
1991         }
1992
1993         /*
1994          * Do this before adding the entry to the directory. We add
1995          * also set d_op after success so that ->d_iput() will cleanup
1996          * the dentry lock even if ocfs2_add_entry() fails below.
1997          */
1998         status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
1999         if (status) {
2000                 mlog_errno(status);
2001                 goto bail;
2002         }
2003
2004         dl = dentry->d_fsdata;
2005
2006         status = ocfs2_add_entry(handle, dentry, inode,
2007                                  le64_to_cpu(fe->i_blkno), parent_fe_bh,
2008                                  &lookup);
2009         if (status < 0) {
2010                 mlog_errno(status);
2011                 goto bail;
2012         }
2013
2014         insert_inode_hash(inode);
2015         d_instantiate(dentry, inode);
2016 bail:
2017         if (status < 0 && did_quota)
2018                 dquot_free_space_nodirty(inode,
2019                                         ocfs2_clusters_to_bytes(osb->sb, 1));
2020         if (status < 0 && did_quota_inode)
2021                 dquot_free_inode(inode);
2022         if (handle) {
2023                 if (status < 0 && fe)
2024                         ocfs2_set_links_count(fe, 0);
2025                 ocfs2_commit_trans(osb, handle);
2026         }
2027
2028         ocfs2_inode_unlock(dir, 1);
2029         if (did_block_signals)
2030                 ocfs2_unblock_signals(&oldset);
2031
2032         brelse(new_fe_bh);
2033         brelse(parent_fe_bh);
2034         kfree(si.value);
2035         ocfs2_free_dir_lookup_result(&lookup);
2036         if (inode_ac)
2037                 ocfs2_free_alloc_context(inode_ac);
2038         if (data_ac)
2039                 ocfs2_free_alloc_context(data_ac);
2040         if (xattr_ac)
2041                 ocfs2_free_alloc_context(xattr_ac);
2042         if ((status < 0) && inode) {
2043                 if (dl)
2044                         ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
2045
2046                 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
2047                 clear_nlink(inode);
2048                 iput(inode);
2049         }
2050
2051         if (status)
2052                 mlog_errno(status);
2053
2054         return status;
2055 }
2056
2057 static int ocfs2_blkno_stringify(u64 blkno, char *name)
2058 {
2059         int status, namelen;
2060
2061         namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2062                            (long long)blkno);
2063         if (namelen <= 0) {
2064                 if (namelen)
2065                         status = namelen;
2066                 else
2067                         status = -EINVAL;
2068                 mlog_errno(status);
2069                 goto bail;
2070         }
2071         if (namelen != OCFS2_ORPHAN_NAMELEN) {
2072                 status = -EINVAL;
2073                 mlog_errno(status);
2074                 goto bail;
2075         }
2076
2077         trace_ocfs2_blkno_stringify(blkno, name, namelen);
2078
2079         status = 0;
2080 bail:
2081         if (status < 0)
2082                 mlog_errno(status);
2083         return status;
2084 }
2085
2086 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
2087                                         struct inode **ret_orphan_dir,
2088                                         struct buffer_head **ret_orphan_dir_bh)
2089 {
2090         struct inode *orphan_dir_inode;
2091         struct buffer_head *orphan_dir_bh = NULL;
2092         int ret = 0;
2093
2094         orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2095                                                        ORPHAN_DIR_SYSTEM_INODE,
2096                                                        osb->slot_num);
2097         if (!orphan_dir_inode) {
2098                 ret = -ENOENT;
2099                 mlog_errno(ret);
2100                 return ret;
2101         }
2102
2103         inode_lock(orphan_dir_inode);
2104
2105         ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2106         if (ret < 0) {
2107                 inode_unlock(orphan_dir_inode);
2108                 iput(orphan_dir_inode);
2109
2110                 mlog_errno(ret);
2111                 return ret;
2112         }
2113
2114         *ret_orphan_dir = orphan_dir_inode;
2115         *ret_orphan_dir_bh = orphan_dir_bh;
2116
2117         return 0;
2118 }
2119
2120 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode,
2121                                       struct buffer_head *orphan_dir_bh,
2122                                       u64 blkno,
2123                                       char *name,
2124                                       struct ocfs2_dir_lookup_result *lookup,
2125                                       bool dio)
2126 {
2127         int ret;
2128         struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb);
2129         int namelen = dio ?
2130                         (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2131                         OCFS2_ORPHAN_NAMELEN;
2132
2133         if (dio) {
2134                 ret = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2135                                 OCFS2_DIO_ORPHAN_PREFIX);
2136                 if (ret != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2137                         ret = -EINVAL;
2138                         mlog_errno(ret);
2139                         return ret;
2140                 }
2141
2142                 ret = ocfs2_blkno_stringify(blkno,
2143                                 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2144         } else
2145                 ret = ocfs2_blkno_stringify(blkno, name);
2146         if (ret < 0) {
2147                 mlog_errno(ret);
2148                 return ret;
2149         }
2150
2151         ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2152                                            orphan_dir_bh, name,
2153                                            namelen, lookup);
2154         if (ret < 0) {
2155                 mlog_errno(ret);
2156                 return ret;
2157         }
2158
2159         return 0;
2160 }
2161
2162 /**
2163  * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2164  * insertion of an orphan.
2165  * @osb: ocfs2 file system
2166  * @ret_orphan_dir: Orphan dir inode - returned locked!
2167  * @blkno: Actual block number of the inode to be inserted into orphan dir.
2168  * @lookup: dir lookup result, to be passed back into functions like
2169  *          ocfs2_orphan_add
2170  *
2171  * Returns zero on success and the ret_orphan_dir, name and lookup
2172  * fields will be populated.
2173  *
2174  * Returns non-zero on failure.
2175  */
2176 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2177                                     struct inode **ret_orphan_dir,
2178                                     u64 blkno,
2179                                     char *name,
2180                                     struct ocfs2_dir_lookup_result *lookup,
2181                                     bool dio)
2182 {
2183         struct inode *orphan_dir_inode = NULL;
2184         struct buffer_head *orphan_dir_bh = NULL;
2185         int ret = 0;
2186
2187         ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode,
2188                                            &orphan_dir_bh);
2189         if (ret < 0) {
2190                 mlog_errno(ret);
2191                 return ret;
2192         }
2193
2194         ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh,
2195                                          blkno, name, lookup, dio);
2196         if (ret < 0) {
2197                 mlog_errno(ret);
2198                 goto out;
2199         }
2200
2201         *ret_orphan_dir = orphan_dir_inode;
2202
2203 out:
2204         brelse(orphan_dir_bh);
2205
2206         if (ret) {
2207                 ocfs2_inode_unlock(orphan_dir_inode, 1);
2208                 inode_unlock(orphan_dir_inode);
2209                 iput(orphan_dir_inode);
2210         }
2211
2212         if (ret)
2213                 mlog_errno(ret);
2214         return ret;
2215 }
2216
2217 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2218                             handle_t *handle,
2219                             struct inode *inode,
2220                             struct buffer_head *fe_bh,
2221                             char *name,
2222                             struct ocfs2_dir_lookup_result *lookup,
2223                             struct inode *orphan_dir_inode,
2224                             bool dio)
2225 {
2226         struct buffer_head *orphan_dir_bh = NULL;
2227         int status = 0;
2228         struct ocfs2_dinode *orphan_fe;
2229         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
2230         int namelen = dio ?
2231                         (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2232                         OCFS2_ORPHAN_NAMELEN;
2233
2234         trace_ocfs2_orphan_add_begin(
2235                                 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2236
2237         status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
2238         if (status < 0) {
2239                 mlog_errno(status);
2240                 goto leave;
2241         }
2242
2243         status = ocfs2_journal_access_di(handle,
2244                                          INODE_CACHE(orphan_dir_inode),
2245                                          orphan_dir_bh,
2246                                          OCFS2_JOURNAL_ACCESS_WRITE);
2247         if (status < 0) {
2248                 mlog_errno(status);
2249                 goto leave;
2250         }
2251
2252         /*
2253          * We're going to journal the change of i_flags and i_orphaned_slot.
2254          * It's safe anyway, though some callers may duplicate the journaling.
2255          * Journaling within the func just make the logic look more
2256          * straightforward.
2257          */
2258         status = ocfs2_journal_access_di(handle,
2259                                          INODE_CACHE(inode),
2260                                          fe_bh,
2261                                          OCFS2_JOURNAL_ACCESS_WRITE);
2262         if (status < 0) {
2263                 mlog_errno(status);
2264                 goto leave;
2265         }
2266
2267         /* we're a cluster, and nlink can change on disk from
2268          * underneath us... */
2269         orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2270         if (S_ISDIR(inode->i_mode))
2271                 ocfs2_add_links_count(orphan_fe, 1);
2272         set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2273         ocfs2_journal_dirty(handle, orphan_dir_bh);
2274
2275         status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2276                                    namelen, inode,
2277                                    OCFS2_I(inode)->ip_blkno,
2278                                    orphan_dir_bh, lookup);
2279         if (status < 0) {
2280                 mlog_errno(status);
2281                 goto rollback;
2282         }
2283
2284         if (dio) {
2285                 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2286                  * slot.
2287                  */
2288                 fe->i_flags |= cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2289                 fe->i_dio_orphaned_slot = cpu_to_le16(osb->slot_num);
2290         } else {
2291                 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
2292                 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
2293
2294                 /* Record which orphan dir our inode now resides
2295                  * in. delete_inode will use this to determine which orphan
2296                  * dir to lock. */
2297                 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2298         }
2299
2300         ocfs2_journal_dirty(handle, fe_bh);
2301
2302         trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
2303                                    osb->slot_num);
2304
2305 rollback:
2306         if (status < 0) {
2307                 if (S_ISDIR(inode->i_mode))
2308                         ocfs2_add_links_count(orphan_fe, -1);
2309                 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2310         }
2311
2312 leave:
2313         brelse(orphan_dir_bh);
2314
2315         return status;
2316 }
2317
2318 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2319 int ocfs2_orphan_del(struct ocfs2_super *osb,
2320                      handle_t *handle,
2321                      struct inode *orphan_dir_inode,
2322                      struct inode *inode,
2323                      struct buffer_head *orphan_dir_bh,
2324                      bool dio)
2325 {
2326         char name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2327         struct ocfs2_dinode *orphan_fe;
2328         int status = 0;
2329         struct ocfs2_dir_lookup_result lookup = { NULL, };
2330
2331         if (dio) {
2332                 status = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2333                                 OCFS2_DIO_ORPHAN_PREFIX);
2334                 if (status != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2335                         status = -EINVAL;
2336                         mlog_errno(status);
2337                         return status;
2338                 }
2339
2340                 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno,
2341                                 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2342         } else
2343                 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2344         if (status < 0) {
2345                 mlog_errno(status);
2346                 goto leave;
2347         }
2348
2349         trace_ocfs2_orphan_del(
2350              (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2351              name, strlen(name));
2352
2353         status = ocfs2_journal_access_di(handle,
2354                                          INODE_CACHE(orphan_dir_inode),
2355                                          orphan_dir_bh,
2356                                          OCFS2_JOURNAL_ACCESS_WRITE);
2357         if (status < 0) {
2358                 mlog_errno(status);
2359                 goto leave;
2360         }
2361
2362         /* find it's spot in the orphan directory */
2363         status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode,
2364                                   &lookup);
2365         if (status) {
2366                 mlog_errno(status);
2367                 goto leave;
2368         }
2369
2370         /* remove it from the orphan directory */
2371         status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2372         if (status < 0) {
2373                 mlog_errno(status);
2374                 goto leave;
2375         }
2376
2377         /* do the i_nlink dance! :) */
2378         orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2379         if (S_ISDIR(inode->i_mode))
2380                 ocfs2_add_links_count(orphan_fe, -1);
2381         set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2382         ocfs2_journal_dirty(handle, orphan_dir_bh);
2383
2384 leave:
2385         ocfs2_free_dir_lookup_result(&lookup);
2386
2387         if (status)
2388                 mlog_errno(status);
2389         return status;
2390 }
2391
2392 /**
2393  * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2394  * allocated file. This is different from the typical 'add to orphan dir'
2395  * operation in that the inode does not yet exist. This is a problem because
2396  * the orphan dir stringifies the inode block number to come up with it's
2397  * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2398  * problem. This function works around it by calling deeper into the orphan
2399  * and suballoc code than other callers. Use this only by necessity.
2400  * @dir: The directory which this inode will ultimately wind up under - not the
2401  * orphan dir!
2402  * @dir_bh: buffer_head the @dir inode block
2403  * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2404  * with the string to be used for orphan dirent. Pass back to the orphan dir
2405  * code.
2406  * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2407  * dir code.
2408  * @ret_di_blkno: block number where the new inode will be allocated.
2409  * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2410  * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2411  *
2412  * Returns zero on success and the ret_orphan_dir, name and lookup
2413  * fields will be populated.
2414  *
2415  * Returns non-zero on failure.
2416  */
2417 static int ocfs2_prep_new_orphaned_file(struct inode *dir,
2418                                         struct buffer_head *dir_bh,
2419                                         char *orphan_name,
2420                                         struct inode **ret_orphan_dir,
2421                                         u64 *ret_di_blkno,
2422                                         struct ocfs2_dir_lookup_result *orphan_insert,
2423                                         struct ocfs2_alloc_context **ret_inode_ac)
2424 {
2425         int ret;
2426         u64 di_blkno;
2427         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2428         struct inode *orphan_dir = NULL;
2429         struct buffer_head *orphan_dir_bh = NULL;
2430         struct ocfs2_alloc_context *inode_ac = NULL;
2431
2432         ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh);
2433         if (ret < 0) {
2434                 mlog_errno(ret);
2435                 return ret;
2436         }
2437
2438         /* reserve an inode spot */
2439         ret = ocfs2_reserve_new_inode(osb, &inode_ac);
2440         if (ret < 0) {
2441                 if (ret != -ENOSPC)
2442                         mlog_errno(ret);
2443                 goto out;
2444         }
2445
2446         ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac,
2447                                        &di_blkno);
2448         if (ret) {
2449                 mlog_errno(ret);
2450                 goto out;
2451         }
2452
2453         ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh,
2454                                          di_blkno, orphan_name, orphan_insert,
2455                                          false);
2456         if (ret < 0) {
2457                 mlog_errno(ret);
2458                 goto out;
2459         }
2460
2461 out:
2462         if (ret == 0) {
2463                 *ret_orphan_dir = orphan_dir;
2464                 *ret_di_blkno = di_blkno;
2465                 *ret_inode_ac = inode_ac;
2466                 /*
2467                  * orphan_name and orphan_insert are already up to
2468                  * date via prepare_orphan_dir
2469                  */
2470         } else {
2471                 /* Unroll reserve_new_inode* */
2472                 if (inode_ac)
2473                         ocfs2_free_alloc_context(inode_ac);
2474
2475                 /* Unroll orphan dir locking */
2476                 inode_unlock(orphan_dir);
2477                 ocfs2_inode_unlock(orphan_dir, 1);
2478                 iput(orphan_dir);
2479         }
2480
2481         brelse(orphan_dir_bh);
2482
2483         return ret;
2484 }
2485
2486 int ocfs2_create_inode_in_orphan(struct inode *dir,
2487                                  int mode,
2488                                  struct inode **new_inode)
2489 {
2490         int status, did_quota_inode = 0;
2491         struct inode *inode = NULL;
2492         struct inode *orphan_dir = NULL;
2493         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2494         handle_t *handle = NULL;
2495         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
2496         struct buffer_head *parent_di_bh = NULL;
2497         struct buffer_head *new_di_bh = NULL;
2498         struct ocfs2_alloc_context *inode_ac = NULL;
2499         struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2500         u64 di_blkno, suballoc_loc;
2501         u16 suballoc_bit;
2502
2503         status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2504         if (status < 0) {
2505                 if (status != -ENOENT)
2506                         mlog_errno(status);
2507                 return status;
2508         }
2509
2510         status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh,
2511                                               orphan_name, &orphan_dir,
2512                                               &di_blkno, &orphan_insert, &inode_ac);
2513         if (status < 0) {
2514                 if (status != -ENOSPC)
2515                         mlog_errno(status);
2516                 goto leave;
2517         }
2518
2519         inode = ocfs2_get_init_inode(dir, mode);
2520         if (IS_ERR(inode)) {
2521                 status = PTR_ERR(inode);
2522                 inode = NULL;
2523                 mlog_errno(status);
2524                 goto leave;
2525         }
2526
2527         handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
2528         if (IS_ERR(handle)) {
2529                 status = PTR_ERR(handle);
2530                 handle = NULL;
2531                 mlog_errno(status);
2532                 goto leave;
2533         }
2534
2535         status = dquot_alloc_inode(inode);
2536         if (status)
2537                 goto leave;
2538         did_quota_inode = 1;
2539
2540         status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac,
2541                                               &suballoc_loc,
2542                                               &suballoc_bit, di_blkno);
2543         if (status < 0) {
2544                 mlog_errno(status);
2545                 goto leave;
2546         }
2547
2548         clear_nlink(inode);
2549         /* do the real work now. */
2550         status = __ocfs2_mknod_locked(dir, inode,
2551                                       0, &new_di_bh, parent_di_bh, handle,
2552                                       inode_ac, di_blkno, suballoc_loc,
2553                                       suballoc_bit);
2554         if (status < 0) {
2555                 mlog_errno(status);
2556                 goto leave;
2557         }
2558
2559         status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name,
2560                                   &orphan_insert, orphan_dir, false);
2561         if (status < 0) {
2562                 mlog_errno(status);
2563                 goto leave;
2564         }
2565
2566         /* get open lock so that only nodes can't remove it from orphan dir. */
2567         status = ocfs2_open_lock(inode);
2568         if (status < 0)
2569                 mlog_errno(status);
2570
2571         insert_inode_hash(inode);
2572 leave:
2573         if (status < 0 && did_quota_inode)
2574                 dquot_free_inode(inode);
2575         if (handle)
2576                 ocfs2_commit_trans(osb, handle);
2577
2578         if (orphan_dir) {
2579                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2580                 ocfs2_inode_unlock(orphan_dir, 1);
2581                 inode_unlock(orphan_dir);
2582                 iput(orphan_dir);
2583         }
2584
2585         if ((status < 0) && inode) {
2586                 clear_nlink(inode);
2587                 iput(inode);
2588         }
2589
2590         if (inode_ac)
2591                 ocfs2_free_alloc_context(inode_ac);
2592
2593         brelse(new_di_bh);
2594
2595         if (!status)
2596                 *new_inode = inode;
2597
2598         ocfs2_free_dir_lookup_result(&orphan_insert);
2599
2600         ocfs2_inode_unlock(dir, 1);
2601         brelse(parent_di_bh);
2602         return status;
2603 }
2604
2605 int ocfs2_add_inode_to_orphan(struct ocfs2_super *osb,
2606         struct inode *inode)
2607 {
2608         char orphan_name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2609         struct inode *orphan_dir_inode = NULL;
2610         struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2611         struct buffer_head *di_bh = NULL;
2612         int status = 0;
2613         handle_t *handle = NULL;
2614         struct ocfs2_dinode *di = NULL;
2615
2616         status = ocfs2_inode_lock(inode, &di_bh, 1);
2617         if (status < 0) {
2618                 mlog_errno(status);
2619                 goto bail;
2620         }
2621
2622         di = (struct ocfs2_dinode *) di_bh->b_data;
2623         /*
2624          * Another append dio crashed?
2625          * If so, manually recover it first.
2626          */
2627         if (unlikely(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))) {
2628                 status = ocfs2_truncate_file(inode, di_bh, i_size_read(inode));
2629                 if (status < 0) {
2630                         if (status != -ENOSPC)
2631                                 mlog_errno(status);
2632                         goto bail_unlock_inode;
2633                 }
2634
2635                 status = ocfs2_del_inode_from_orphan(osb, inode, di_bh, 0, 0);
2636                 if (status < 0) {
2637                         mlog_errno(status);
2638                         goto bail_unlock_inode;
2639                 }
2640         }
2641
2642         status = ocfs2_prepare_orphan_dir(osb, &orphan_dir_inode,
2643                         OCFS2_I(inode)->ip_blkno,
2644                         orphan_name,
2645                         &orphan_insert,
2646                         true);
2647         if (status < 0) {
2648                 mlog_errno(status);
2649                 goto bail_unlock_inode;
2650         }
2651
2652         handle = ocfs2_start_trans(osb,
2653                         OCFS2_INODE_ADD_TO_ORPHAN_CREDITS);
2654         if (IS_ERR(handle)) {
2655                 status = PTR_ERR(handle);
2656                 goto bail_unlock_orphan;
2657         }
2658
2659         status = ocfs2_orphan_add(osb, handle, inode, di_bh, orphan_name,
2660                         &orphan_insert, orphan_dir_inode, true);
2661         if (status)
2662                 mlog_errno(status);
2663
2664         ocfs2_commit_trans(osb, handle);
2665
2666 bail_unlock_orphan:
2667         ocfs2_inode_unlock(orphan_dir_inode, 1);
2668         inode_unlock(orphan_dir_inode);
2669         iput(orphan_dir_inode);
2670
2671         ocfs2_free_dir_lookup_result(&orphan_insert);
2672
2673 bail_unlock_inode:
2674         ocfs2_inode_unlock(inode, 1);
2675         brelse(di_bh);
2676
2677 bail:
2678         return status;
2679 }
2680
2681 int ocfs2_del_inode_from_orphan(struct ocfs2_super *osb,
2682                 struct inode *inode, struct buffer_head *di_bh,
2683                 int update_isize, loff_t end)
2684 {
2685         struct inode *orphan_dir_inode = NULL;
2686         struct buffer_head *orphan_dir_bh = NULL;
2687         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2688         handle_t *handle = NULL;
2689         int status = 0;
2690
2691         orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2692                         ORPHAN_DIR_SYSTEM_INODE,
2693                         le16_to_cpu(di->i_dio_orphaned_slot));
2694         if (!orphan_dir_inode) {
2695                 status = -ENOENT;
2696                 mlog_errno(status);
2697                 goto bail;
2698         }
2699
2700         inode_lock(orphan_dir_inode);
2701         status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2702         if (status < 0) {
2703                 inode_unlock(orphan_dir_inode);
2704                 iput(orphan_dir_inode);
2705                 mlog_errno(status);
2706                 goto bail;
2707         }
2708
2709         handle = ocfs2_start_trans(osb,
2710                         OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS);
2711         if (IS_ERR(handle)) {
2712                 status = PTR_ERR(handle);
2713                 goto bail_unlock_orphan;
2714         }
2715
2716         BUG_ON(!(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL)));
2717
2718         status = ocfs2_orphan_del(osb, handle, orphan_dir_inode,
2719                                 inode, orphan_dir_bh, true);
2720         if (status < 0) {
2721                 mlog_errno(status);
2722                 goto bail_commit;
2723         }
2724
2725         status = ocfs2_journal_access_di(handle,
2726                         INODE_CACHE(inode),
2727                         di_bh,
2728                         OCFS2_JOURNAL_ACCESS_WRITE);
2729         if (status < 0) {
2730                 mlog_errno(status);
2731                 goto bail_commit;
2732         }
2733
2734         di->i_flags &= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2735         di->i_dio_orphaned_slot = 0;
2736
2737         if (update_isize) {
2738                 status = ocfs2_set_inode_size(handle, inode, di_bh, end);
2739                 if (status)
2740                         mlog_errno(status);
2741         } else
2742                 ocfs2_journal_dirty(handle, di_bh);
2743
2744 bail_commit:
2745         ocfs2_commit_trans(osb, handle);
2746
2747 bail_unlock_orphan:
2748         ocfs2_inode_unlock(orphan_dir_inode, 1);
2749         inode_unlock(orphan_dir_inode);
2750         brelse(orphan_dir_bh);
2751         iput(orphan_dir_inode);
2752
2753 bail:
2754         return status;
2755 }
2756
2757 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
2758                                    struct inode *inode,
2759                                    struct dentry *dentry)
2760 {
2761         int status = 0;
2762         struct buffer_head *parent_di_bh = NULL;
2763         handle_t *handle = NULL;
2764         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2765         struct ocfs2_dinode *dir_di, *di;
2766         struct inode *orphan_dir_inode = NULL;
2767         struct buffer_head *orphan_dir_bh = NULL;
2768         struct buffer_head *di_bh = NULL;
2769         struct ocfs2_dir_lookup_result lookup = { NULL, };
2770
2771         trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry,
2772                                 dentry->d_name.len, dentry->d_name.name,
2773                                 (unsigned long long)OCFS2_I(dir)->ip_blkno,
2774                                 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2775
2776         status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2777         if (status < 0) {
2778                 if (status != -ENOENT)
2779                         mlog_errno(status);
2780                 return status;
2781         }
2782
2783         dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data;
2784         if (!dir_di->i_links_count) {
2785                 /* can't make a file in a deleted directory. */
2786                 status = -ENOENT;
2787                 goto leave;
2788         }
2789
2790         status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
2791                                            dentry->d_name.len);
2792         if (status)
2793                 goto leave;
2794
2795         /* get a spot inside the dir. */
2796         status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh,
2797                                               dentry->d_name.name,
2798                                               dentry->d_name.len, &lookup);
2799         if (status < 0) {
2800                 mlog_errno(status);
2801                 goto leave;
2802         }
2803
2804         orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2805                                                        ORPHAN_DIR_SYSTEM_INODE,
2806                                                        osb->slot_num);
2807         if (!orphan_dir_inode) {
2808                 status = -ENOENT;
2809                 mlog_errno(status);
2810                 goto leave;
2811         }
2812
2813         inode_lock(orphan_dir_inode);
2814
2815         status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2816         if (status < 0) {
2817                 mlog_errno(status);
2818                 inode_unlock(orphan_dir_inode);
2819                 iput(orphan_dir_inode);
2820                 goto leave;
2821         }
2822
2823         status = ocfs2_read_inode_block(inode, &di_bh);
2824         if (status < 0) {
2825                 mlog_errno(status);
2826                 goto orphan_unlock;
2827         }
2828
2829         handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
2830         if (IS_ERR(handle)) {
2831                 status = PTR_ERR(handle);
2832                 handle = NULL;
2833                 mlog_errno(status);
2834                 goto orphan_unlock;
2835         }
2836
2837         status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
2838                                          di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2839         if (status < 0) {
2840                 mlog_errno(status);
2841                 goto out_commit;
2842         }
2843
2844         status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
2845                                   orphan_dir_bh, false);
2846         if (status < 0) {
2847                 mlog_errno(status);
2848                 goto out_commit;
2849         }
2850
2851         di = (struct ocfs2_dinode *)di_bh->b_data;
2852         di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL);
2853         di->i_orphaned_slot = 0;
2854         set_nlink(inode, 1);
2855         ocfs2_set_links_count(di, inode->i_nlink);
2856         ocfs2_update_inode_fsync_trans(handle, inode, 1);
2857         ocfs2_journal_dirty(handle, di_bh);
2858
2859         status = ocfs2_add_entry(handle, dentry, inode,
2860                                  OCFS2_I(inode)->ip_blkno, parent_di_bh,
2861                                  &lookup);
2862         if (status < 0) {
2863                 mlog_errno(status);
2864                 goto out_commit;
2865         }
2866
2867         status = ocfs2_dentry_attach_lock(dentry, inode,
2868                                           OCFS2_I(dir)->ip_blkno);
2869         if (status) {
2870                 mlog_errno(status);
2871                 goto out_commit;
2872         }
2873
2874         d_instantiate(dentry, inode);
2875         status = 0;
2876 out_commit:
2877         ocfs2_commit_trans(osb, handle);
2878 orphan_unlock:
2879         ocfs2_inode_unlock(orphan_dir_inode, 1);
2880         inode_unlock(orphan_dir_inode);
2881         iput(orphan_dir_inode);
2882 leave:
2883
2884         ocfs2_inode_unlock(dir, 1);
2885
2886         brelse(di_bh);
2887         brelse(parent_di_bh);
2888         brelse(orphan_dir_bh);
2889
2890         ocfs2_free_dir_lookup_result(&lookup);
2891
2892         if (status)
2893                 mlog_errno(status);
2894
2895         return status;
2896 }
2897
2898 const struct inode_operations ocfs2_dir_iops = {
2899         .create         = ocfs2_create,
2900         .lookup         = ocfs2_lookup,
2901         .link           = ocfs2_link,
2902         .unlink         = ocfs2_unlink,
2903         .rmdir          = ocfs2_unlink,
2904         .symlink        = ocfs2_symlink,
2905         .mkdir          = ocfs2_mkdir,
2906         .mknod          = ocfs2_mknod,
2907         .rename         = ocfs2_rename,
2908         .setattr        = ocfs2_setattr,
2909         .getattr        = ocfs2_getattr,
2910         .permission     = ocfs2_permission,
2911         .listxattr      = ocfs2_listxattr,
2912         .fiemap         = ocfs2_fiemap,
2913         .get_acl        = ocfs2_iop_get_acl,
2914         .set_acl        = ocfs2_iop_set_acl,
2915 };