fs/ocfs2/namei.c

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