SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ocfs2/namei.c

   1 /* -*- mode: c; c-basic-offset: 8; -*-
   2  * vim: noexpandtab sw=8 ts=8 sts=0:
   3  *
   4  * namei.c
   5  *
   6  * Create and rename file, directory, symlinks
   7  *
   8  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   9  *
  10  *  Portions of this code from linux/fs/ext3/dir.c
  11  *
  12  *  Copyright (C) 1992, 1993, 1994, 1995
  13  *  Remy Card (card@masi.ibp.fr)
  14  *  Laboratoire MASI - Institut Blaise pascal
  15  *  Universite Pierre et Marie Curie (Paris VI)
  16  *
  17  *   from
  18  *
  19  *   linux/fs/minix/dir.c
  20  *
  21  *   Copyright (C) 1991, 1992 Linux Torvalds
  22  *
  23  * This program is free software; you can redistribute it and/or
  24  * modify it under the terms of the GNU General Public
  25  * License as published by the Free Software Foundation; either
  26  * version 2 of the License, or (at your option) any later version.
  27  *
  28  * This program is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  31  * General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU General Public
  34  * License along with this program; if not, write to the
  35  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  36  * Boston, MA 021110-1307, USA.
  37  */
  38
  39 #include <linux/fs.h>
  40 #include <linux/types.h>
  41 #include <linux/slab.h>
  42 #include <linux/highmem.h>
  43
  44 #define MLOG_MASK_PREFIX ML_NAMEI
  45 #include <cluster/masklog.h>
  46
  47 #include "ocfs2.h"
  48
  49 #include "alloc.h"
  50 #include "dcache.h"
  51 #include "dir.h"
  52 #include "dlmglue.h"
  53 #include "extent_map.h"
  54 #include "file.h"
  55 #include "inode.h"
  56 #include "journal.h"
  57 #include "namei.h"
  58 #include "suballoc.h"
  59 #include "super.h"
  60 #include "symlink.h"
  61 #include "sysfile.h"
  62 #include "uptodate.h"
  63 #include "xattr.h"
  64
  65 #include "buffer_head_io.h"
  66
  67 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
  68                               struct inode *dir,
  69                               struct inode *inode,
  70                               struct dentry *dentry,
  71                               dev_t dev,
  72                               struct buffer_head **new_fe_bh,
  73                               struct buffer_head *parent_fe_bh,
  74                               handle_t *handle,
  75                               struct ocfs2_alloc_context *inode_ac);
  76
  77 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
  78                                     struct inode **ret_orphan_dir,
  79                                     struct inode *inode,
  80                                     char *name,
  81                                     struct buffer_head **de_bh);
  82
  83 static int ocfs2_orphan_add(struct ocfs2_super *osb,
  84                             handle_t *handle,
  85                             struct inode *inode,
  86                             struct ocfs2_dinode *fe,
  87                             char *name,
  88                             struct buffer_head *de_bh,
  89                             struct inode *orphan_dir_inode);
  90
  91 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
  92                                      handle_t *handle,
  93                                      struct inode *inode,
  94                                      const char *symname);
  95
  96 /* An orphan dir name is an 8 byte value, printed as a hex string */
  97 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
  98
  99 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
 100                                    struct nameidata *nd)
 101 {
 102         int status;
 103         u64 blkno;
 104         struct inode *inode = NULL;
 105         struct dentry *ret;
 106         struct ocfs2_inode_info *oi;
 107
 108         mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
 109                    dentry->d_name.len, dentry->d_name.name);
 110
 111         if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
 112                 ret = ERR_PTR(-ENAMETOOLONG);
 113                 goto bail;
 114         }
 115
 116         mlog(0, "find name %.*s in directory %llu\n", dentry->d_name.len,
 117              dentry->d_name.name, (unsigned long long)OCFS2_I(dir)->ip_blkno);
 118
 119         status = ocfs2_inode_lock(dir, NULL, 0);
 120         if (status < 0) {
 121                 if (status != -ENOENT)
 122                         mlog_errno(status);
 123                 ret = ERR_PTR(status);
 124                 goto bail;
 125         }
 126
 127         status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
 128                                             dentry->d_name.len, &blkno);
 129         if (status < 0)
 130                 goto bail_add;
 131
 132         inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
 133         if (IS_ERR(inode)) {
 134                 ret = ERR_PTR(-EACCES);
 135                 goto bail_unlock;
 136         }
 137
 138         oi = OCFS2_I(inode);
 139         /* Clear any orphaned state... If we were able to look up the
 140          * inode from a directory, it certainly can't be orphaned. We
 141          * might have the bad state from a node which intended to
 142          * orphan this inode but crashed before it could commit the
 143          * unlink. */
 144         spin_lock(&oi->ip_lock);
 145         oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
 146         spin_unlock(&oi->ip_lock);
 147
 148 bail_add:
 149         dentry->d_op = &ocfs2_dentry_ops;
 150         ret = d_splice_alias(inode, dentry);
 151
 152         if (inode) {
 153                 /*
 154                  * If d_splice_alias() finds a DCACHE_DISCONNECTED
 155                  * dentry, it will d_move() it on top of ourse. The
 156                  * return value will indicate this however, so in
 157                  * those cases, we switch them around for the locking
 158                  * code.
 159                  *
 160                  * NOTE: This dentry already has ->d_op set from
 161                  * ocfs2_get_parent() and ocfs2_get_dentry()
 162                  */
 163                 if (ret)
 164                         dentry = ret;
 165
 166                 status = ocfs2_dentry_attach_lock(dentry, inode,
 167                                                   OCFS2_I(dir)->ip_blkno);
 168                 if (status) {
 169                         mlog_errno(status);
 170                         ret = ERR_PTR(status);
 171                         goto bail_unlock;
 172                 }
 173         }
 174
 175 bail_unlock:
 176         /* Don't drop the cluster lock until *after* the d_add --
 177          * unlink on another node will message us to remove that
 178          * dentry under this lock so otherwise we can race this with
 179          * the downconvert thread and have a stale dentry. */
 180         ocfs2_inode_unlock(dir, 0);
 181
 182 bail:
 183
 184         mlog_exit_ptr(ret);
 185
 186         return ret;
 187 }
 188
 189 static struct inode *ocfs2_get_init_inode(struct inode *dir, int mode)
 190 {
 191         struct inode *inode;
 192
 193         inode = new_inode(dir->i_sb);
 194         if (!inode) {
 195                 mlog(ML_ERROR, "new_inode failed!\n");
 196                 return NULL;
 197         }
 198
 199         /* populate as many fields early on as possible - many of
 200          * these are used by the support functions here and in
 201          * callers. */
 202         if (S_ISDIR(mode))
 203                 inode->i_nlink = 2;
 204         else
 205                 inode->i_nlink = 1;
 206         inode->i_uid = current_fsuid();
 207         if (dir->i_mode & S_ISGID) {
 208                 inode->i_gid = dir->i_gid;
 209                 if (S_ISDIR(mode))
 210                         mode |= S_ISGID;
 211         } else
 212                 inode->i_gid = current_fsgid();
 213         inode->i_mode = mode;
 214         return inode;
 215 }
 216
 217 static int ocfs2_mknod(struct inode *dir,
 218                        struct dentry *dentry,
 219                        int mode,
 220                        dev_t dev)
 221 {
 222         int status = 0;
 223         struct buffer_head *parent_fe_bh = NULL;
 224         handle_t *handle = NULL;
 225         struct ocfs2_super *osb;
 226         struct ocfs2_dinode *dirfe;
 227         struct buffer_head *new_fe_bh = NULL;
 228         struct buffer_head *de_bh = NULL;
 229         struct inode *inode = NULL;
 230         struct ocfs2_alloc_context *inode_ac = NULL;
 231         struct ocfs2_alloc_context *data_ac = NULL;
 232
 233         mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
 234                    (unsigned long)dev, dentry->d_name.len,
 235                    dentry->d_name.name);
 236
 237         /* get our super block */
 238         osb = OCFS2_SB(dir->i_sb);
 239
 240         status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
 241         if (status < 0) {
 242                 if (status != -ENOENT)
 243                         mlog_errno(status);
 244                 return status;
 245         }
 246
 247         if (S_ISDIR(mode) && (dir->i_nlink >= OCFS2_LINK_MAX)) {
 248                 status = -EMLINK;
 249                 goto leave;
 250         }
 251
 252         dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
 253         if (!dirfe->i_links_count) {
 254                 /* can't make a file in a deleted directory. */
 255                 status = -ENOENT;
 256                 goto leave;
 257         }
 258
 259         status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
 260                                            dentry->d_name.len);
 261         if (status)
 262                 goto leave;
 263
 264         /* get a spot inside the dir. */
 265         status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
 266                                               dentry->d_name.name,
 267                                               dentry->d_name.len, &de_bh);
 268         if (status < 0) {
 269                 mlog_errno(status);
 270                 goto leave;
 271         }
 272
 273         /* reserve an inode spot */
 274         status = ocfs2_reserve_new_inode(osb, &inode_ac);
 275         if (status < 0) {
 276                 if (status != -ENOSPC)
 277                         mlog_errno(status);
 278                 goto leave;
 279         }
 280
 281         inode = ocfs2_get_init_inode(dir, mode);
 282         if (!inode) {
 283                 status = -ENOMEM;
 284                 mlog_errno(status);
 285                 goto leave;
 286         }
 287
 288         /* Reserve a cluster if creating an extent based directory. */
 289         if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
 290                 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
 291                 if (status < 0) {
 292                         if (status != -ENOSPC)
 293                                 mlog_errno(status);
 294                         goto leave;
 295                 }
 296         }
 297
 298         handle = ocfs2_start_trans(osb, OCFS2_MKNOD_CREDITS);
 299         if (IS_ERR(handle)) {
 300                 status = PTR_ERR(handle);
 301                 handle = NULL;
 302                 mlog_errno(status);
 303                 goto leave;
 304         }
 305
 306         /* do the real work now. */
 307         status = ocfs2_mknod_locked(osb, dir, inode, dentry, dev,
 308                                     &new_fe_bh, parent_fe_bh, handle,
 309                                     inode_ac);
 310         if (status < 0) {
 311                 mlog_errno(status);
 312                 goto leave;
 313         }
 314
 315         if (S_ISDIR(mode)) {
 316                 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
 317                                             new_fe_bh, data_ac);
 318                 if (status < 0) {
 319                         mlog_errno(status);
 320                         goto leave;
 321                 }
 322
 323                 status = ocfs2_journal_access(handle, dir, parent_fe_bh,
 324                                               OCFS2_JOURNAL_ACCESS_WRITE);
 325                 if (status < 0) {
 326                         mlog_errno(status);
 327                         goto leave;
 328                 }
 329                 le16_add_cpu(&dirfe->i_links_count, 1);
 330                 status = ocfs2_journal_dirty(handle, parent_fe_bh);
 331                 if (status < 0) {
 332                         mlog_errno(status);
 333                         goto leave;
 334                 }
 335                 inc_nlink(dir);
 336         }
 337
 338         status = ocfs2_add_entry(handle, dentry, inode,
 339                                  OCFS2_I(inode)->ip_blkno, parent_fe_bh,
 340                                  de_bh);
 341         if (status < 0) {
 342                 mlog_errno(status);
 343                 goto leave;
 344         }
 345
 346         status = ocfs2_dentry_attach_lock(dentry, inode,
 347                                           OCFS2_I(dir)->ip_blkno);
 348         if (status) {
 349                 mlog_errno(status);
 350                 goto leave;
 351         }
 352
 353         insert_inode_hash(inode);
 354         dentry->d_op = &ocfs2_dentry_ops;
 355         d_instantiate(dentry, inode);
 356         status = 0;
 357 leave:
 358         if (handle)
 359                 ocfs2_commit_trans(osb, handle);
 360
 361         ocfs2_inode_unlock(dir, 1);
 362
 363         if (status == -ENOSPC)
 364                 mlog(0, "Disk is full\n");
 365
 366         brelse(new_fe_bh);
 367         brelse(de_bh);
 368         brelse(parent_fe_bh);
 369
 370         if ((status < 0) && inode) {
 371                 clear_nlink(inode);
 372                 iput(inode);
 373         }
 374
 375         if (inode_ac)
 376                 ocfs2_free_alloc_context(inode_ac);
 377
 378         if (data_ac)
 379                 ocfs2_free_alloc_context(data_ac);
 380
 381         mlog_exit(status);
 382
 383         return status;
 384 }
 385
 386 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
 387                               struct inode *dir,
 388                               struct inode *inode,
 389                               struct dentry *dentry,
 390                               dev_t dev,
 391                               struct buffer_head **new_fe_bh,
 392                               struct buffer_head *parent_fe_bh,
 393                               handle_t *handle,
 394                               struct ocfs2_alloc_context *inode_ac)
 395 {
 396         int status = 0;
 397         struct ocfs2_dinode *fe = NULL;
 398         struct ocfs2_extent_list *fel;
 399         u64 fe_blkno = 0;
 400         u16 suballoc_bit;
 401
 402         mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry,
 403                    inode->i_mode, (unsigned long)dev, dentry->d_name.len,
 404                    dentry->d_name.name);
 405
 406         *new_fe_bh = NULL;
 407
 408         status = ocfs2_claim_new_inode(osb, handle, inode_ac, &suballoc_bit,
 409                                        &fe_blkno);
 410         if (status < 0) {
 411                 mlog_errno(status);
 412                 goto leave;
 413         }
 414
 415         /* populate as many fields early on as possible - many of
 416          * these are used by the support functions here and in
 417          * callers. */
 418         inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
 419         OCFS2_I(inode)->ip_blkno = fe_blkno;
 420         spin_lock(&osb->osb_lock);
 421         inode->i_generation = osb->s_next_generation++;
 422         spin_unlock(&osb->osb_lock);
 423
 424         *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
 425         if (!*new_fe_bh) {
 426                 status = -EIO;
 427                 mlog_errno(status);
 428                 goto leave;
 429         }
 430         ocfs2_set_new_buffer_uptodate(inode, *new_fe_bh);
 431
 432         status = ocfs2_journal_access(handle, inode, *new_fe_bh,
 433                                       OCFS2_JOURNAL_ACCESS_CREATE);
 434         if (status < 0) {
 435                 mlog_errno(status);
 436                 goto leave;
 437         }
 438
 439         fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
 440         memset(fe, 0, osb->sb->s_blocksize);
 441
 442         fe->i_generation = cpu_to_le32(inode->i_generation);
 443         fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
 444         fe->i_blkno = cpu_to_le64(fe_blkno);
 445         fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
 446         fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
 447         fe->i_uid = cpu_to_le32(inode->i_uid);
 448         fe->i_gid = cpu_to_le32(inode->i_gid);
 449         fe->i_mode = cpu_to_le16(inode->i_mode);
 450         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 451                 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
 452         fe->i_links_count = cpu_to_le16(inode->i_nlink);
 453
 454         fe->i_last_eb_blk = 0;
 455         strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
 456         le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
 457         fe->i_atime = fe->i_ctime = fe->i_mtime =
 458                 cpu_to_le64(CURRENT_TIME.tv_sec);
 459         fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
 460                 cpu_to_le32(CURRENT_TIME.tv_nsec);
 461         fe->i_dtime = 0;
 462
 463         /*
 464          * If supported, directories start with inline data.
 465          */
 466         if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
 467                 u16 feat = le16_to_cpu(fe->i_dyn_features);
 468
 469                 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
 470
 471                 fe->id2.i_data.id_count = cpu_to_le16(ocfs2_max_inline_data(osb->sb));
 472         } else {
 473                 fel = &fe->id2.i_list;
 474                 fel->l_tree_depth = 0;
 475                 fel->l_next_free_rec = 0;
 476                 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
 477         }
 478
 479         status = ocfs2_journal_dirty(handle, *new_fe_bh);
 480         if (status < 0) {
 481                 mlog_errno(status);
 482                 goto leave;
 483         }
 484
 485         if (ocfs2_populate_inode(inode, fe, 1) < 0) {
 486                 mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
 487                      "i_blkno=%llu, i_ino=%lu\n",
 488                      (unsigned long long)(*new_fe_bh)->b_blocknr,
 489                      (unsigned long long)le64_to_cpu(fe->i_blkno),
 490                      inode->i_ino);
 491                 BUG();
 492         }
 493
 494         ocfs2_inode_set_new(osb, inode);
 495         if (!ocfs2_mount_local(osb)) {
 496                 status = ocfs2_create_new_inode_locks(inode);
 497                 if (status < 0)
 498                         mlog_errno(status);
 499         }
 500
 501         status = 0; /* error in ocfs2_create_new_inode_locks is not
 502                      * critical */
 503
 504 leave:
 505         if (status < 0) {
 506                 if (*new_fe_bh) {
 507                         brelse(*new_fe_bh);
 508                         *new_fe_bh = NULL;
 509                 }
 510         }
 511
 512         mlog_exit(status);
 513         return status;
 514 }
 515
 516 static int ocfs2_mkdir(struct inode *dir,
 517                        struct dentry *dentry,
 518                        int mode)
 519 {
 520         int ret;
 521
 522         mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
 523                    dentry->d_name.len, dentry->d_name.name);
 524         ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
 525         mlog_exit(ret);
 526
 527         return ret;
 528 }
 529
 530 static int ocfs2_create(struct inode *dir,
 531                         struct dentry *dentry,
 532                         int mode,
 533                         struct nameidata *nd)
 534 {
 535         int ret;
 536
 537         mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
 538                    dentry->d_name.len, dentry->d_name.name);
 539         ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
 540         mlog_exit(ret);
 541
 542         return ret;
 543 }
 544
 545 static int ocfs2_link(struct dentry *old_dentry,
 546                       struct inode *dir,
 547                       struct dentry *dentry)
 548 {
 549         handle_t *handle;
 550         struct inode *inode = old_dentry->d_inode;
 551         int err;
 552         struct buffer_head *fe_bh = NULL;
 553         struct buffer_head *parent_fe_bh = NULL;
 554         struct buffer_head *de_bh = NULL;
 555         struct ocfs2_dinode *fe = NULL;
 556         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 557
 558         mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
 559                    old_dentry->d_name.len, old_dentry->d_name.name,
 560                    dentry->d_name.len, dentry->d_name.name);
 561
 562         if (S_ISDIR(inode->i_mode))
 563                 return -EPERM;
 564
 565         err = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
 566         if (err < 0) {
 567                 if (err != -ENOENT)
 568                         mlog_errno(err);
 569                 return err;
 570         }
 571
 572         if (!dir->i_nlink) {
 573                 err = -ENOENT;
 574                 goto out;
 575         }
 576
 577         err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
 578                                         dentry->d_name.len);
 579         if (err)
 580                 goto out;
 581
 582         err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
 583                                            dentry->d_name.name,
 584                                            dentry->d_name.len, &de_bh);
 585         if (err < 0) {
 586                 mlog_errno(err);
 587                 goto out;
 588         }
 589
 590         err = ocfs2_inode_lock(inode, &fe_bh, 1);
 591         if (err < 0) {
 592                 if (err != -ENOENT)
 593                         mlog_errno(err);
 594                 goto out;
 595         }
 596
 597         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 598         if (le16_to_cpu(fe->i_links_count) >= OCFS2_LINK_MAX) {
 599                 err = -EMLINK;
 600                 goto out_unlock_inode;
 601         }
 602
 603         handle = ocfs2_start_trans(osb, OCFS2_LINK_CREDITS);
 604         if (IS_ERR(handle)) {
 605                 err = PTR_ERR(handle);
 606                 handle = NULL;
 607                 mlog_errno(err);
 608                 goto out_unlock_inode;
 609         }
 610
 611         err = ocfs2_journal_access(handle, inode, fe_bh,
 612                                    OCFS2_JOURNAL_ACCESS_WRITE);
 613         if (err < 0) {
 614                 mlog_errno(err);
 615                 goto out_commit;
 616         }
 617
 618         inc_nlink(inode);
 619         inode->i_ctime = CURRENT_TIME;
 620         fe->i_links_count = cpu_to_le16(inode->i_nlink);
 621         fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
 622         fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 623
 624         err = ocfs2_journal_dirty(handle, fe_bh);
 625         if (err < 0) {
 626                 le16_add_cpu(&fe->i_links_count, -1);
 627                 drop_nlink(inode);
 628                 mlog_errno(err);
 629                 goto out_commit;
 630         }
 631
 632         err = ocfs2_add_entry(handle, dentry, inode,
 633                               OCFS2_I(inode)->ip_blkno,
 634                               parent_fe_bh, de_bh);
 635         if (err) {
 636                 le16_add_cpu(&fe->i_links_count, -1);
 637                 drop_nlink(inode);
 638                 mlog_errno(err);
 639                 goto out_commit;
 640         }
 641
 642         err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
 643         if (err) {
 644                 mlog_errno(err);
 645                 goto out_commit;
 646         }
 647
 648         atomic_inc(&inode->i_count);
 649         dentry->d_op = &ocfs2_dentry_ops;
 650         d_instantiate(dentry, inode);
 651
 652 out_commit:
 653         ocfs2_commit_trans(osb, handle);
 654 out_unlock_inode:
 655         ocfs2_inode_unlock(inode, 1);
 656
 657 out:
 658         ocfs2_inode_unlock(dir, 1);
 659
 660         brelse(de_bh);
 661         brelse(fe_bh);
 662         brelse(parent_fe_bh);
 663
 664         mlog_exit(err);
 665
 666         return err;
 667 }
 668
 669 /*
 670  * Takes and drops an exclusive lock on the given dentry. This will
 671  * force other nodes to drop it.
 672  */
 673 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
 674 {
 675         int ret;
 676
 677         ret = ocfs2_dentry_lock(dentry, 1);
 678         if (ret)
 679                 mlog_errno(ret);
 680         else
 681                 ocfs2_dentry_unlock(dentry, 1);
 682
 683         return ret;
 684 }
 685
 686 static inline int inode_is_unlinkable(struct inode *inode)
 687 {
 688         if (S_ISDIR(inode->i_mode)) {
 689                 if (inode->i_nlink == 2)
 690                         return 1;
 691                 return 0;
 692         }
 693
 694         if (inode->i_nlink == 1)
 695                 return 1;
 696         return 0;
 697 }
 698
 699 static int ocfs2_unlink(struct inode *dir,
 700                         struct dentry *dentry)
 701 {
 702         int status;
 703         int child_locked = 0;
 704         struct inode *inode = dentry->d_inode;
 705         struct inode *orphan_dir = NULL;
 706         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
 707         u64 blkno;
 708         struct ocfs2_dinode *fe = NULL;
 709         struct buffer_head *fe_bh = NULL;
 710         struct buffer_head *parent_node_bh = NULL;
 711         handle_t *handle = NULL;
 712         struct ocfs2_dir_entry *dirent = NULL;
 713         struct buffer_head *dirent_bh = NULL;
 714         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
 715         struct buffer_head *orphan_entry_bh = NULL;
 716
 717         mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
 718                    dentry->d_name.len, dentry->d_name.name);
 719
 720         BUG_ON(dentry->d_parent->d_inode != dir);
 721
 722         mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
 723
 724         if (inode == osb->root_inode) {
 725                 mlog(0, "Cannot delete the root directory\n");
 726                 return -EPERM;
 727         }
 728
 729         status = ocfs2_inode_lock(dir, &parent_node_bh, 1);
 730         if (status < 0) {
 731                 if (status != -ENOENT)
 732                         mlog_errno(status);
 733                 return status;
 734         }
 735
 736         status = ocfs2_find_files_on_disk(dentry->d_name.name,
 737                                           dentry->d_name.len, &blkno,
 738                                           dir, &dirent_bh, &dirent);
 739         if (status < 0) {
 740                 if (status != -ENOENT)
 741                         mlog_errno(status);
 742                 goto leave;
 743         }
 744
 745         if (OCFS2_I(inode)->ip_blkno != blkno) {
 746                 status = -ENOENT;
 747
 748                 mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
 749                      (unsigned long long)OCFS2_I(inode)->ip_blkno,
 750                      (unsigned long long)blkno, OCFS2_I(inode)->ip_flags);
 751                 goto leave;
 752         }
 753
 754         status = ocfs2_inode_lock(inode, &fe_bh, 1);
 755         if (status < 0) {
 756                 if (status != -ENOENT)
 757                         mlog_errno(status);
 758                 goto leave;
 759         }
 760         child_locked = 1;
 761
 762         if (S_ISDIR(inode->i_mode)) {
 763                 if (!ocfs2_empty_dir(inode)) {
 764                         status = -ENOTEMPTY;
 765                         goto leave;
 766                 } else if (inode->i_nlink != 2) {
 767                         status = -ENOTEMPTY;
 768                         goto leave;
 769                 }
 770         }
 771
 772         status = ocfs2_remote_dentry_delete(dentry);
 773         if (status < 0) {
 774                 /* This remote delete should succeed under all normal
 775                  * circumstances. */
 776                 mlog_errno(status);
 777                 goto leave;
 778         }
 779
 780         if (inode_is_unlinkable(inode)) {
 781                 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, inode,
 782                                                   orphan_name,
 783                                                   &orphan_entry_bh);
 784                 if (status < 0) {
 785                         mlog_errno(status);
 786                         goto leave;
 787                 }
 788         }
 789
 790         handle = ocfs2_start_trans(osb, OCFS2_UNLINK_CREDITS);
 791         if (IS_ERR(handle)) {
 792                 status = PTR_ERR(handle);
 793                 handle = NULL;
 794                 mlog_errno(status);
 795                 goto leave;
 796         }
 797
 798         status = ocfs2_journal_access(handle, inode, fe_bh,
 799                                       OCFS2_JOURNAL_ACCESS_WRITE);
 800         if (status < 0) {
 801                 mlog_errno(status);
 802                 goto leave;
 803         }
 804
 805         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 806
 807         if (inode_is_unlinkable(inode)) {
 808                 status = ocfs2_orphan_add(osb, handle, inode, fe, orphan_name,
 809                                           orphan_entry_bh, orphan_dir);
 810                 if (status < 0) {
 811                         mlog_errno(status);
 812                         goto leave;
 813                 }
 814         }
 815
 816         /* delete the name from the parent dir */
 817         status = ocfs2_delete_entry(handle, dir, dirent, dirent_bh);
 818         if (status < 0) {
 819                 mlog_errno(status);
 820                 goto leave;
 821         }
 822
 823         if (S_ISDIR(inode->i_mode))
 824                 drop_nlink(inode);
 825         drop_nlink(inode);
 826         fe->i_links_count = cpu_to_le16(inode->i_nlink);
 827
 828         status = ocfs2_journal_dirty(handle, fe_bh);
 829         if (status < 0) {
 830                 mlog_errno(status);
 831                 goto leave;
 832         }
 833
 834         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 835         if (S_ISDIR(inode->i_mode))
 836                 drop_nlink(dir);
 837
 838         status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
 839         if (status < 0) {
 840                 mlog_errno(status);
 841                 if (S_ISDIR(inode->i_mode))
 842                         inc_nlink(dir);
 843         }
 844
 845 leave:
 846         if (handle)
 847                 ocfs2_commit_trans(osb, handle);
 848
 849         if (child_locked)
 850                 ocfs2_inode_unlock(inode, 1);
 851
 852         ocfs2_inode_unlock(dir, 1);
 853
 854         if (orphan_dir) {
 855                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
 856                 ocfs2_inode_unlock(orphan_dir, 1);
 857                 mutex_unlock(&orphan_dir->i_mutex);
 858                 iput(orphan_dir);
 859         }
 860
 861         brelse(fe_bh);
 862         brelse(dirent_bh);
 863         brelse(parent_node_bh);
 864         brelse(orphan_entry_bh);
 865
 866         mlog_exit(status);
 867
 868         return status;
 869 }
 870
 871 /*
 872  * The only place this should be used is rename!
 873  * if they have the same id, then the 1st one is the only one locked.
 874  */
 875 static int ocfs2_double_lock(struct ocfs2_super *osb,
 876                              struct buffer_head **bh1,
 877                              struct inode *inode1,
 878                              struct buffer_head **bh2,
 879                              struct inode *inode2)
 880 {
 881         int status;
 882         struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
 883         struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
 884         struct buffer_head **tmpbh;
 885         struct inode *tmpinode;
 886
 887         mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
 888                    (unsigned long long)oi1->ip_blkno,
 889                    (unsigned long long)oi2->ip_blkno);
 890
 891         if (*bh1)
 892                 *bh1 = NULL;
 893         if (*bh2)
 894                 *bh2 = NULL;
 895
 896         /* we always want to lock the one with the lower lockid first. */
 897         if (oi1->ip_blkno != oi2->ip_blkno) {
 898                 if (oi1->ip_blkno < oi2->ip_blkno) {
 899                         /* switch id1 and id2 around */
 900                         mlog(0, "switching them around...\n");
 901                         tmpbh = bh2;
 902                         bh2 = bh1;
 903                         bh1 = tmpbh;
 904
 905                         tmpinode = inode2;
 906                         inode2 = inode1;
 907                         inode1 = tmpinode;
 908                 }
 909                 /* lock id2 */
 910                 status = ocfs2_inode_lock(inode2, bh2, 1);
 911                 if (status < 0) {
 912                         if (status != -ENOENT)
 913                                 mlog_errno(status);
 914                         goto bail;
 915                 }
 916         }
 917
 918         /* lock id1 */
 919         status = ocfs2_inode_lock(inode1, bh1, 1);
 920         if (status < 0) {
 921                 /*
 922                  * An error return must mean that no cluster locks
 923                  * were held on function exit.
 924                  */
 925                 if (oi1->ip_blkno != oi2->ip_blkno)
 926                         ocfs2_inode_unlock(inode2, 1);
 927
 928                 if (status != -ENOENT)
 929                         mlog_errno(status);
 930         }
 931
 932 bail:
 933         mlog_exit(status);
 934         return status;
 935 }
 936
 937 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
 938 {
 939         ocfs2_inode_unlock(inode1, 1);
 940
 941         if (inode1 != inode2)
 942                 ocfs2_inode_unlock(inode2, 1);
 943 }
 944
 945 static int ocfs2_rename(struct inode *old_dir,
 946                         struct dentry *old_dentry,
 947                         struct inode *new_dir,
 948                         struct dentry *new_dentry)
 949 {
 950         int status = 0, rename_lock = 0, parents_locked = 0;
 951         int old_child_locked = 0, new_child_locked = 0;
 952         struct inode *old_inode = old_dentry->d_inode;
 953         struct inode *new_inode = new_dentry->d_inode;
 954         struct inode *orphan_dir = NULL;
 955         struct ocfs2_dinode *newfe = NULL;
 956         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
 957         struct buffer_head *orphan_entry_bh = NULL;
 958         struct buffer_head *newfe_bh = NULL;
 959         struct buffer_head *old_inode_bh = NULL;
 960         struct buffer_head *insert_entry_bh = NULL;
 961         struct ocfs2_super *osb = NULL;
 962         u64 newfe_blkno, old_de_ino;
 963         handle_t *handle = NULL;
 964         struct buffer_head *old_dir_bh = NULL;
 965         struct buffer_head *new_dir_bh = NULL;
 966         struct ocfs2_dir_entry *old_inode_dot_dot_de = NULL, *old_de = NULL,
 967                 *new_de = NULL;
 968         struct buffer_head *new_de_bh = NULL, *old_de_bh = NULL; // bhs for above
 969         struct buffer_head *old_inode_de_bh = NULL; // if old_dentry is a dir,
 970                                                     // this is the 1st dirent bh
 971         nlink_t old_dir_nlink = old_dir->i_nlink;
 972         struct ocfs2_dinode *old_di;
 973
 974         /* At some point it might be nice to break this function up a
 975          * bit. */
 976
 977         mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
 978                    old_dir, old_dentry, new_dir, new_dentry,
 979                    old_dentry->d_name.len, old_dentry->d_name.name,
 980                    new_dentry->d_name.len, new_dentry->d_name.name);
 981
 982         osb = OCFS2_SB(old_dir->i_sb);
 983
 984         if (new_inode) {
 985                 if (!igrab(new_inode))
 986                         BUG();
 987         }
 988
 989         /* Assume a directory hierarchy thusly:
 990          * a/b/c
 991          * a/d
 992          * a,b,c, and d are all directories.
 993          *
 994          * from cwd of 'a' on both nodes:
 995          * node1: mv b/c d
 996          * node2: mv d   b/c
 997          *
 998          * And that's why, just like the VFS, we need a file system
 999          * rename lock. */
1000         if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1001                 status = ocfs2_rename_lock(osb);
1002                 if (status < 0) {
1003                         mlog_errno(status);
1004                         goto bail;
1005                 }
1006                 rename_lock = 1;
1007         }
1008
1009         /* if old and new are the same, this'll just do one lock. */
1010         status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1011                                    &new_dir_bh, new_dir);
1012         if (status < 0) {
1013                 mlog_errno(status);
1014                 goto bail;
1015         }
1016         parents_locked = 1;
1017
1018         /* make sure both dirs have bhs
1019          * get an extra ref on old_dir_bh if old==new */
1020         if (!new_dir_bh) {
1021                 if (old_dir_bh) {
1022                         new_dir_bh = old_dir_bh;
1023                         get_bh(new_dir_bh);
1024                 } else {
1025                         mlog(ML_ERROR, "no old_dir_bh!\n");
1026                         status = -EIO;
1027                         goto bail;
1028                 }
1029         }
1030
1031         /*
1032          * Aside from allowing a meta data update, the locking here
1033          * also ensures that the downconvert thread on other nodes
1034          * won't have to concurrently downconvert the inode and the
1035          * dentry locks.
1036          */
1037         status = ocfs2_inode_lock(old_inode, &old_inode_bh, 1);
1038         if (status < 0) {
1039                 if (status != -ENOENT)
1040                         mlog_errno(status);
1041                 goto bail;
1042         }
1043         old_child_locked = 1;
1044
1045         status = ocfs2_remote_dentry_delete(old_dentry);
1046         if (status < 0) {
1047                 mlog_errno(status);
1048                 goto bail;
1049         }
1050
1051         if (S_ISDIR(old_inode->i_mode)) {
1052                 u64 old_inode_parent;
1053
1054                 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1055                                                   old_inode, &old_inode_de_bh,
1056                                                   &old_inode_dot_dot_de);
1057                 if (status) {
1058                         status = -EIO;
1059                         goto bail;
1060                 }
1061
1062                 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1063                         status = -EIO;
1064                         goto bail;
1065                 }
1066
1067                 if (!new_inode && new_dir != old_dir &&
1068                     new_dir->i_nlink >= OCFS2_LINK_MAX) {
1069                         status = -EMLINK;
1070                         goto bail;
1071                 }
1072         }
1073
1074         status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1075                                             old_dentry->d_name.len,
1076                                             &old_de_ino);
1077         if (status) {
1078                 status = -ENOENT;
1079                 goto bail;
1080         }
1081
1082         /*
1083          *  Check for inode number is _not_ due to possible IO errors.
1084          *  We might rmdir the source, keep it as pwd of some process
1085          *  and merrily kill the link to whatever was created under the
1086          *  same name. Goodbye sticky bit ;-<
1087          */
1088         if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1089                 status = -ENOENT;
1090                 goto bail;
1091         }
1092
1093         /* check if the target already exists (in which case we need
1094          * to delete it */
1095         status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1096                                           new_dentry->d_name.len,
1097                                           &newfe_blkno, new_dir, &new_de_bh,
1098                                           &new_de);
1099         /* The only error we allow here is -ENOENT because the new
1100          * file not existing is perfectly valid. */
1101         if ((status < 0) && (status != -ENOENT)) {
1102                 /* If we cannot find the file specified we should just */
1103                 /* return the error... */
1104                 mlog_errno(status);
1105                 goto bail;
1106         }
1107
1108         if (!new_de && new_inode) {
1109                 /*
1110                  * Target was unlinked by another node while we were
1111                  * waiting to get to ocfs2_rename(). There isn't
1112                  * anything we can do here to help the situation, so
1113                  * bubble up the appropriate error.
1114                  */
1115                 status = -ENOENT;
1116                 goto bail;
1117         }
1118
1119         /* In case we need to overwrite an existing file, we blow it
1120          * away first */
1121         if (new_de) {
1122                 /* VFS didn't think there existed an inode here, but
1123                  * someone else in the cluster must have raced our
1124                  * rename to create one. Today we error cleanly, in
1125                  * the future we should consider calling iget to build
1126                  * a new struct inode for this entry. */
1127                 if (!new_inode) {
1128                         status = -EACCES;
1129
1130                         mlog(0, "We found an inode for name %.*s but VFS "
1131                              "didn't give us one.\n", new_dentry->d_name.len,
1132                              new_dentry->d_name.name);
1133                         goto bail;
1134                 }
1135
1136                 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1137                         status = -EACCES;
1138
1139                         mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
1140                              (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1141                              (unsigned long long)newfe_blkno,
1142                              OCFS2_I(new_inode)->ip_flags);
1143                         goto bail;
1144                 }
1145
1146                 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1147                 if (status < 0) {
1148                         if (status != -ENOENT)
1149                                 mlog_errno(status);
1150                         goto bail;
1151                 }
1152                 new_child_locked = 1;
1153
1154                 status = ocfs2_remote_dentry_delete(new_dentry);
1155                 if (status < 0) {
1156                         mlog_errno(status);
1157                         goto bail;
1158                 }
1159
1160                 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1161
1162                 mlog(0, "aha rename over existing... new_de=%p new_blkno=%llu "
1163                      "newfebh=%p bhblocknr=%llu\n", new_de,
1164                      (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1165                      (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1166
1167                 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1168                         status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1169                                                           new_inode,
1170                                                           orphan_name,
1171                                                           &orphan_entry_bh);
1172                         if (status < 0) {
1173                                 mlog_errno(status);
1174                                 goto bail;
1175                         }
1176                 }
1177         } else {
1178                 BUG_ON(new_dentry->d_parent->d_inode != new_dir);
1179
1180                 status = ocfs2_check_dir_for_entry(new_dir,
1181                                                    new_dentry->d_name.name,
1182                                                    new_dentry->d_name.len);
1183                 if (status)
1184                         goto bail;
1185
1186                 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1187                                                       new_dentry->d_name.name,
1188                                                       new_dentry->d_name.len,
1189                                                       &insert_entry_bh);
1190                 if (status < 0) {
1191                         mlog_errno(status);
1192                         goto bail;
1193                 }
1194         }
1195
1196         handle = ocfs2_start_trans(osb, OCFS2_RENAME_CREDITS);
1197         if (IS_ERR(handle)) {
1198                 status = PTR_ERR(handle);
1199                 handle = NULL;
1200                 mlog_errno(status);
1201                 goto bail;
1202         }
1203
1204         if (new_de) {
1205                 if (S_ISDIR(new_inode->i_mode)) {
1206                         if (!ocfs2_empty_dir(new_inode) ||
1207                             new_inode->i_nlink != 2) {
1208                                 status = -ENOTEMPTY;
1209                                 goto bail;
1210                         }
1211                 }
1212                 status = ocfs2_journal_access(handle, new_inode, newfe_bh,
1213                                               OCFS2_JOURNAL_ACCESS_WRITE);
1214                 if (status < 0) {
1215                         mlog_errno(status);
1216                         goto bail;
1217                 }
1218
1219                 if (S_ISDIR(new_inode->i_mode) ||
1220                     (newfe->i_links_count == cpu_to_le16(1))){
1221                         status = ocfs2_orphan_add(osb, handle, new_inode,
1222                                                   newfe, orphan_name,
1223                                                   orphan_entry_bh, orphan_dir);
1224                         if (status < 0) {
1225                                 mlog_errno(status);
1226                                 goto bail;
1227                         }
1228                 }
1229
1230                 /* change the dirent to point to the correct inode */
1231                 status = ocfs2_update_entry(new_dir, handle, new_de_bh,
1232                                             new_de, old_inode);
1233                 if (status < 0) {
1234                         mlog_errno(status);
1235                         goto bail;
1236                 }
1237                 new_dir->i_version++;
1238
1239                 if (S_ISDIR(new_inode->i_mode))
1240                         newfe->i_links_count = 0;
1241                 else
1242                         le16_add_cpu(&newfe->i_links_count, -1);
1243
1244                 status = ocfs2_journal_dirty(handle, newfe_bh);
1245                 if (status < 0) {
1246                         mlog_errno(status);
1247                         goto bail;
1248                 }
1249         } else {
1250                 /* if the name was not found in new_dir, add it now */
1251                 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1252                                          OCFS2_I(old_inode)->ip_blkno,
1253                                          new_dir_bh, insert_entry_bh);
1254         }
1255
1256         old_inode->i_ctime = CURRENT_TIME;
1257         mark_inode_dirty(old_inode);
1258
1259         status = ocfs2_journal_access(handle, old_inode, old_inode_bh,
1260                                       OCFS2_JOURNAL_ACCESS_WRITE);
1261         if (status >= 0) {
1262                 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1263
1264                 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1265                 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1266
1267                 status = ocfs2_journal_dirty(handle, old_inode_bh);
1268                 if (status < 0)
1269                         mlog_errno(status);
1270         } else
1271                 mlog_errno(status);
1272
1273         /*
1274          * Now that the name has been added to new_dir, remove the old name.
1275          *
1276          * We don't keep any directory entry context around until now
1277          * because the insert might have changed the type of directory
1278          * we're dealing with.
1279          */
1280         old_de_bh = ocfs2_find_entry(old_dentry->d_name.name,
1281                                      old_dentry->d_name.len,
1282                                      old_dir, &old_de);
1283         if (!old_de_bh) {
1284                 status = -EIO;
1285                 goto bail;
1286         }
1287
1288         status = ocfs2_delete_entry(handle, old_dir, old_de, old_de_bh);
1289         if (status < 0) {
1290                 mlog_errno(status);
1291                 goto bail;
1292         }
1293
1294         if (new_inode) {
1295                 new_inode->i_nlink--;
1296                 new_inode->i_ctime = CURRENT_TIME;
1297         }
1298         old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1299         if (old_inode_de_bh) {
1300                 status = ocfs2_update_entry(old_inode, handle, old_inode_de_bh,
1301                                             old_inode_dot_dot_de, new_dir);
1302                 old_dir->i_nlink--;
1303                 if (new_inode) {
1304                         new_inode->i_nlink--;
1305                 } else {
1306                         inc_nlink(new_dir);
1307                         mark_inode_dirty(new_dir);
1308                 }
1309         }
1310         mark_inode_dirty(old_dir);
1311         ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1312         if (new_inode) {
1313                 mark_inode_dirty(new_inode);
1314                 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1315         }
1316
1317         if (old_dir != new_dir) {
1318                 /* Keep the same times on both directories.*/
1319                 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1320
1321                 /*
1322                  * This will also pick up the i_nlink change from the
1323                  * block above.
1324                  */
1325                 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1326         }
1327
1328         if (old_dir_nlink != old_dir->i_nlink) {
1329                 if (!old_dir_bh) {
1330                         mlog(ML_ERROR, "need to change nlink for old dir "
1331                              "%llu from %d to %d but bh is NULL!\n",
1332                              (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1333                              (int)old_dir_nlink, old_dir->i_nlink);
1334                 } else {
1335                         struct ocfs2_dinode *fe;
1336                         status = ocfs2_journal_access(handle, old_dir,
1337                                                       old_dir_bh,
1338                                                       OCFS2_JOURNAL_ACCESS_WRITE);
1339                         fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1340                         fe->i_links_count = cpu_to_le16(old_dir->i_nlink);
1341                         status = ocfs2_journal_dirty(handle, old_dir_bh);
1342                 }
1343         }
1344
1345         ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1346         status = 0;
1347 bail:
1348         if (rename_lock)
1349                 ocfs2_rename_unlock(osb);
1350
1351         if (handle)
1352                 ocfs2_commit_trans(osb, handle);
1353
1354         if (parents_locked)
1355                 ocfs2_double_unlock(old_dir, new_dir);
1356
1357         if (old_child_locked)
1358                 ocfs2_inode_unlock(old_inode, 1);
1359
1360         if (new_child_locked)
1361                 ocfs2_inode_unlock(new_inode, 1);
1362
1363         if (orphan_dir) {
1364                 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1365                 ocfs2_inode_unlock(orphan_dir, 1);
1366                 mutex_unlock(&orphan_dir->i_mutex);
1367                 iput(orphan_dir);
1368         }
1369
1370         if (new_inode)
1371                 sync_mapping_buffers(old_inode->i_mapping);
1372
1373         if (new_inode)
1374                 iput(new_inode);
1375         brelse(newfe_bh);
1376         brelse(old_inode_bh);
1377         brelse(old_dir_bh);
1378         brelse(new_dir_bh);
1379         brelse(new_de_bh);
1380         brelse(old_de_bh);
1381         brelse(old_inode_de_bh);
1382         brelse(orphan_entry_bh);
1383         brelse(insert_entry_bh);
1384
1385         mlog_exit(status);
1386
1387         return status;
1388 }
1389
1390 /*
1391  * we expect i_size = strlen(symname). Copy symname into the file
1392  * data, including the null terminator.
1393  */
1394 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1395                                      handle_t *handle,
1396                                      struct inode *inode,
1397                                      const char *symname)
1398 {
1399         struct buffer_head **bhs = NULL;
1400         const char *c;
1401         struct super_block *sb = osb->sb;
1402         u64 p_blkno, p_blocks;
1403         int virtual, blocks, status, i, bytes_left;
1404
1405         bytes_left = i_size_read(inode) + 1;
1406         /* we can't trust i_blocks because we're actually going to
1407          * write i_size + 1 bytes. */
1408         blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1409
1410         mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
1411                         (unsigned long long)inode->i_blocks,
1412                         i_size_read(inode), blocks);
1413
1414         /* Sanity check -- make sure we're going to fit. */
1415         if (bytes_left >
1416             ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1417                 status = -EIO;
1418                 mlog_errno(status);
1419                 goto bail;
1420         }
1421
1422         bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1423         if (!bhs) {
1424                 status = -ENOMEM;
1425                 mlog_errno(status);
1426                 goto bail;
1427         }
1428
1429         status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1430                                              NULL);
1431         if (status < 0) {
1432                 mlog_errno(status);
1433                 goto bail;
1434         }
1435
1436         /* links can never be larger than one cluster so we know this
1437          * is all going to be contiguous, but do a sanity check
1438          * anyway. */
1439         if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1440                 status = -EIO;
1441                 mlog_errno(status);
1442                 goto bail;
1443         }
1444
1445         virtual = 0;
1446         while(bytes_left > 0) {
1447                 c = &symname[virtual * sb->s_blocksize];
1448
1449                 bhs[virtual] = sb_getblk(sb, p_blkno);
1450                 if (!bhs[virtual]) {
1451                         status = -ENOMEM;
1452                         mlog_errno(status);
1453                         goto bail;
1454                 }
1455                 ocfs2_set_new_buffer_uptodate(inode, bhs[virtual]);
1456
1457                 status = ocfs2_journal_access(handle, inode, bhs[virtual],
1458                                               OCFS2_JOURNAL_ACCESS_CREATE);
1459                 if (status < 0) {
1460                         mlog_errno(status);
1461                         goto bail;
1462                 }
1463
1464                 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1465
1466                 memcpy(bhs[virtual]->b_data, c,
1467                        (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1468                        bytes_left);
1469
1470                 status = ocfs2_journal_dirty(handle, bhs[virtual]);
1471                 if (status < 0) {
1472                         mlog_errno(status);
1473                         goto bail;
1474                 }
1475
1476                 virtual++;
1477                 p_blkno++;
1478                 bytes_left -= sb->s_blocksize;
1479         }
1480
1481         status = 0;
1482 bail:
1483
1484         if (bhs) {
1485                 for(i = 0; i < blocks; i++)
1486                         brelse(bhs[i]);
1487                 kfree(bhs);
1488         }
1489
1490         mlog_exit(status);
1491         return status;
1492 }
1493
1494 static int ocfs2_symlink(struct inode *dir,
1495                          struct dentry *dentry,
1496                          const char *symname)
1497 {
1498         int status, l, credits;
1499         u64 newsize;
1500         struct ocfs2_super *osb = NULL;
1501         struct inode *inode = NULL;
1502         struct super_block *sb;
1503         struct buffer_head *new_fe_bh = NULL;
1504         struct buffer_head *de_bh = NULL;
1505         struct buffer_head *parent_fe_bh = NULL;
1506         struct ocfs2_dinode *fe = NULL;
1507         struct ocfs2_dinode *dirfe;
1508         handle_t *handle = NULL;
1509         struct ocfs2_alloc_context *inode_ac = NULL;
1510         struct ocfs2_alloc_context *data_ac = NULL;
1511
1512         mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
1513                    dentry, symname, dentry->d_name.len, dentry->d_name.name);
1514
1515         sb = dir->i_sb;
1516         osb = OCFS2_SB(sb);
1517
1518         l = strlen(symname) + 1;
1519
1520         credits = ocfs2_calc_symlink_credits(sb);
1521
1522         /* lock the parent directory */
1523         status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1524         if (status < 0) {
1525                 if (status != -ENOENT)
1526                         mlog_errno(status);
1527                 return status;
1528         }
1529
1530         dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1531         if (!dirfe->i_links_count) {
1532                 /* can't make a file in a deleted directory. */
1533                 status = -ENOENT;
1534                 goto bail;
1535         }
1536
1537         status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1538                                            dentry->d_name.len);
1539         if (status)
1540                 goto bail;
1541
1542         status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1543                                               dentry->d_name.name,
1544                                               dentry->d_name.len, &de_bh);
1545         if (status < 0) {
1546                 mlog_errno(status);
1547                 goto bail;
1548         }
1549
1550         status = ocfs2_reserve_new_inode(osb, &inode_ac);
1551         if (status < 0) {
1552                 if (status != -ENOSPC)
1553                         mlog_errno(status);
1554                 goto bail;
1555         }
1556
1557         inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1558         if (!inode) {
1559                 status = -ENOMEM;
1560                 mlog_errno(status);
1561                 goto bail;
1562         }
1563
1564         /* don't reserve bitmap space for fast symlinks. */
1565         if (l > ocfs2_fast_symlink_chars(sb)) {
1566                 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
1567                 if (status < 0) {
1568                         if (status != -ENOSPC)
1569                                 mlog_errno(status);
1570                         goto bail;
1571                 }
1572         }
1573
1574         handle = ocfs2_start_trans(osb, credits);
1575         if (IS_ERR(handle)) {
1576                 status = PTR_ERR(handle);
1577                 handle = NULL;
1578                 mlog_errno(status);
1579                 goto bail;
1580         }
1581
1582         status = ocfs2_mknod_locked(osb, dir, inode, dentry,
1583                                     0, &new_fe_bh, parent_fe_bh, handle,
1584                                     inode_ac);
1585         if (status < 0) {
1586                 mlog_errno(status);
1587                 goto bail;
1588         }
1589
1590         fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1591         inode->i_rdev = 0;
1592         newsize = l - 1;
1593         if (l > ocfs2_fast_symlink_chars(sb)) {
1594                 u32 offset = 0;
1595
1596                 inode->i_op = &ocfs2_symlink_inode_operations;
1597                 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1598                                               new_fe_bh,
1599                                               handle, data_ac, NULL,
1600                                               NULL);
1601                 if (status < 0) {
1602                         if (status != -ENOSPC && status != -EINTR) {
1603                                 mlog(ML_ERROR,
1604                                      "Failed to extend file to %llu\n",
1605                                      (unsigned long long)newsize);
1606                                 mlog_errno(status);
1607                                 status = -ENOSPC;
1608                         }
1609                         goto bail;
1610                 }
1611                 i_size_write(inode, newsize);
1612                 inode->i_blocks = ocfs2_inode_sector_count(inode);
1613         } else {
1614                 inode->i_op = &ocfs2_fast_symlink_inode_operations;
1615                 memcpy((char *) fe->id2.i_symlink, symname, l);
1616                 i_size_write(inode, newsize);
1617                 inode->i_blocks = 0;
1618         }
1619
1620         status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1621         if (status < 0) {
1622                 mlog_errno(status);
1623                 goto bail;
1624         }
1625
1626         if (!ocfs2_inode_is_fast_symlink(inode)) {
1627                 status = ocfs2_create_symlink_data(osb, handle, inode,
1628                                                    symname);
1629                 if (status < 0) {
1630                         mlog_errno(status);
1631                         goto bail;
1632                 }
1633         }
1634
1635         status = ocfs2_add_entry(handle, dentry, inode,
1636                                  le64_to_cpu(fe->i_blkno), parent_fe_bh,
1637                                  de_bh);
1638         if (status < 0) {
1639                 mlog_errno(status);
1640                 goto bail;
1641         }
1642
1643         status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
1644         if (status) {
1645                 mlog_errno(status);
1646                 goto bail;
1647         }
1648
1649         insert_inode_hash(inode);
1650         dentry->d_op = &ocfs2_dentry_ops;
1651         d_instantiate(dentry, inode);
1652 bail:
1653         if (handle)
1654                 ocfs2_commit_trans(osb, handle);
1655
1656         ocfs2_inode_unlock(dir, 1);
1657
1658         brelse(new_fe_bh);
1659         brelse(parent_fe_bh);
1660         brelse(de_bh);
1661         if (inode_ac)
1662                 ocfs2_free_alloc_context(inode_ac);
1663         if (data_ac)
1664                 ocfs2_free_alloc_context(data_ac);
1665         if ((status < 0) && inode) {
1666                 clear_nlink(inode);
1667                 iput(inode);
1668         }
1669
1670         mlog_exit(status);
1671
1672         return status;
1673 }
1674
1675 static int ocfs2_blkno_stringify(u64 blkno, char *name)
1676 {
1677         int status, namelen;
1678
1679         mlog_entry_void();
1680
1681         namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
1682                            (long long)blkno);
1683         if (namelen <= 0) {
1684                 if (namelen)
1685                         status = namelen;
1686                 else
1687                         status = -EINVAL;
1688                 mlog_errno(status);
1689                 goto bail;
1690         }
1691         if (namelen != OCFS2_ORPHAN_NAMELEN) {
1692                 status = -EINVAL;
1693                 mlog_errno(status);
1694                 goto bail;
1695         }
1696
1697         mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name,
1698              namelen);
1699
1700         status = 0;
1701 bail:
1702         mlog_exit(status);
1703         return status;
1704 }
1705
1706 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
1707                                     struct inode **ret_orphan_dir,
1708                                     struct inode *inode,
1709                                     char *name,
1710                                     struct buffer_head **de_bh)
1711 {
1712         struct inode *orphan_dir_inode;
1713         struct buffer_head *orphan_dir_bh = NULL;
1714         int status = 0;
1715
1716         status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1717         if (status < 0) {
1718                 mlog_errno(status);
1719                 return status;
1720         }
1721
1722         orphan_dir_inode = ocfs2_get_system_file_inode(osb,
1723                                                        ORPHAN_DIR_SYSTEM_INODE,
1724                                                        osb->slot_num);
1725         if (!orphan_dir_inode) {
1726                 status = -ENOENT;
1727                 mlog_errno(status);
1728                 return status;
1729         }
1730
1731         mutex_lock(&orphan_dir_inode->i_mutex);
1732
1733         status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
1734         if (status < 0) {
1735                 mlog_errno(status);
1736                 goto leave;
1737         }
1738
1739         status = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
1740                                               orphan_dir_bh, name,
1741                                               OCFS2_ORPHAN_NAMELEN, de_bh);
1742         if (status < 0) {
1743                 ocfs2_inode_unlock(orphan_dir_inode, 1);
1744
1745                 mlog_errno(status);
1746                 goto leave;
1747         }
1748
1749         *ret_orphan_dir = orphan_dir_inode;
1750
1751 leave:
1752         if (status) {
1753                 mutex_unlock(&orphan_dir_inode->i_mutex);
1754                 iput(orphan_dir_inode);
1755         }
1756
1757         brelse(orphan_dir_bh);
1758
1759         mlog_exit(status);
1760         return status;
1761 }
1762
1763 static int ocfs2_orphan_add(struct ocfs2_super *osb,
1764                             handle_t *handle,
1765                             struct inode *inode,
1766                             struct ocfs2_dinode *fe,
1767                             char *name,
1768                             struct buffer_head *de_bh,
1769                             struct inode *orphan_dir_inode)
1770 {
1771         struct buffer_head *orphan_dir_bh = NULL;
1772         int status = 0;
1773         struct ocfs2_dinode *orphan_fe;
1774
1775         mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
1776
1777         status = ocfs2_read_block(orphan_dir_inode,
1778                                   OCFS2_I(orphan_dir_inode)->ip_blkno,
1779                                   &orphan_dir_bh);
1780         if (status < 0) {
1781                 mlog_errno(status);
1782                 goto leave;
1783         }
1784
1785         status = ocfs2_journal_access(handle, orphan_dir_inode, orphan_dir_bh,
1786                                       OCFS2_JOURNAL_ACCESS_WRITE);
1787         if (status < 0) {
1788                 mlog_errno(status);
1789                 goto leave;
1790         }
1791
1792         /* we're a cluster, and nlink can change on disk from
1793          * underneath us... */
1794         orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1795         if (S_ISDIR(inode->i_mode))
1796                 le16_add_cpu(&orphan_fe->i_links_count, 1);
1797         orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1798
1799         status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1800         if (status < 0) {
1801                 mlog_errno(status);
1802                 goto leave;
1803         }
1804
1805         status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
1806                                    OCFS2_ORPHAN_NAMELEN, inode,
1807                                    OCFS2_I(inode)->ip_blkno,
1808                                    orphan_dir_bh, de_bh);
1809         if (status < 0) {
1810                 mlog_errno(status);
1811                 goto leave;
1812         }
1813
1814         le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
1815
1816         /* Record which orphan dir our inode now resides
1817          * in. delete_inode will use this to determine which orphan
1818          * dir to lock. */
1819         fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
1820
1821         mlog(0, "Inode %llu orphaned in slot %d\n",
1822              (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
1823
1824 leave:
1825         brelse(orphan_dir_bh);
1826
1827         mlog_exit(status);
1828         return status;
1829 }
1830
1831 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
1832 int ocfs2_orphan_del(struct ocfs2_super *osb,
1833                      handle_t *handle,
1834                      struct inode *orphan_dir_inode,
1835                      struct inode *inode,
1836                      struct buffer_head *orphan_dir_bh)
1837 {
1838         char name[OCFS2_ORPHAN_NAMELEN + 1];
1839         struct ocfs2_dinode *orphan_fe;
1840         int status = 0;
1841         struct buffer_head *target_de_bh = NULL;
1842         struct ocfs2_dir_entry *target_de = NULL;
1843
1844         mlog_entry_void();
1845
1846         status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
1847         if (status < 0) {
1848                 mlog_errno(status);
1849                 goto leave;
1850         }
1851
1852         mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
1853              name, (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
1854              OCFS2_ORPHAN_NAMELEN);
1855
1856         /* find it's spot in the orphan directory */
1857         target_de_bh = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN,
1858                                         orphan_dir_inode, &target_de);
1859         if (!target_de_bh) {
1860                 status = -ENOENT;
1861                 mlog_errno(status);
1862                 goto leave;
1863         }
1864
1865         /* remove it from the orphan directory */
1866         status = ocfs2_delete_entry(handle, orphan_dir_inode, target_de,
1867                                     target_de_bh);
1868         if (status < 0) {
1869                 mlog_errno(status);
1870                 goto leave;
1871         }
1872
1873         status = ocfs2_journal_access(handle,orphan_dir_inode,  orphan_dir_bh,
1874                                       OCFS2_JOURNAL_ACCESS_WRITE);
1875         if (status < 0) {
1876                 mlog_errno(status);
1877                 goto leave;
1878         }
1879
1880         /* do the i_nlink dance! :) */
1881         orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
1882         if (S_ISDIR(inode->i_mode))
1883                 le16_add_cpu(&orphan_fe->i_links_count, -1);
1884         orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
1885
1886         status = ocfs2_journal_dirty(handle, orphan_dir_bh);
1887         if (status < 0) {
1888                 mlog_errno(status);
1889                 goto leave;
1890         }
1891
1892 leave:
1893         brelse(target_de_bh);
1894
1895         mlog_exit(status);
1896         return status;
1897 }
1898
1899 const struct inode_operations ocfs2_dir_iops = {
1900         .create         = ocfs2_create,
1901         .lookup         = ocfs2_lookup,
1902         .link           = ocfs2_link,
1903         .unlink         = ocfs2_unlink,
1904         .rmdir          = ocfs2_unlink,
1905         .symlink        = ocfs2_symlink,
1906         .mkdir          = ocfs2_mkdir,
1907         .mknod          = ocfs2_mknod,
1908         .rename         = ocfs2_rename,
1909         .setattr        = ocfs2_setattr,
1910         .getattr        = ocfs2_getattr,
1911         .permission     = ocfs2_permission,
1912         .setxattr       = generic_setxattr,
1913         .getxattr       = generic_getxattr,
1914         .listxattr      = ocfs2_listxattr,
1915         .removexattr    = generic_removexattr,
1916 };