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