fs/gfs2/inode.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/slab.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/completion.h>
  13 #include <linux/buffer_head.h>
  14 #include <linux/namei.h>
  15 #include <linux/mm.h>
  16 #include <linux/xattr.h>
  17 #include <linux/posix_acl.h>
  18 #include <linux/gfs2_ondisk.h>
  19 #include <linux/crc32.h>
  20 #include <linux/fiemap.h>
  21 #include <linux/security.h>
  22 #include <asm/uaccess.h>
  23
  24 #include "gfs2.h"
  25 #include "incore.h"
  26 #include "acl.h"
  27 #include "bmap.h"
  28 #include "dir.h"
  29 #include "xattr.h"
  30 #include "glock.h"
  31 #include "inode.h"
  32 #include "meta_io.h"
  33 #include "quota.h"
  34 #include "rgrp.h"
  35 #include "trans.h"
  36 #include "util.h"
  37 #include "super.h"
  38 #include "glops.h"
  39
  40 struct gfs2_skip_data {
  41         u64 no_addr;
  42         int skipped;
  43         int non_block;
  44 };
  45
  46 static int iget_test(struct inode *inode, void *opaque)
  47 {
  48         struct gfs2_inode *ip = GFS2_I(inode);
  49         struct gfs2_skip_data *data = opaque;
  50
  51         if (ip->i_no_addr == data->no_addr) {
  52                 if (data->non_block &&
  53                     inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
  54                         data->skipped = 1;
  55                         return 0;
  56                 }
  57                 return 1;
  58         }
  59         return 0;
  60 }
  61
  62 static int iget_set(struct inode *inode, void *opaque)
  63 {
  64         struct gfs2_inode *ip = GFS2_I(inode);
  65         struct gfs2_skip_data *data = opaque;
  66
  67         if (data->skipped)
  68                 return -ENOENT;
  69         inode->i_ino = (unsigned long)(data->no_addr);
  70         ip->i_no_addr = data->no_addr;
  71         return 0;
  72 }
  73
  74 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
  75 {
  76         unsigned long hash = (unsigned long)no_addr;
  77         struct gfs2_skip_data data;
  78
  79         data.no_addr = no_addr;
  80         data.skipped = 0;
  81         data.non_block = non_block;
  82         return ilookup5(sb, hash, iget_test, &data);
  83 }
  84
  85 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
  86                                int non_block)
  87 {
  88         struct gfs2_skip_data data;
  89         unsigned long hash = (unsigned long)no_addr;
  90
  91         data.no_addr = no_addr;
  92         data.skipped = 0;
  93         data.non_block = non_block;
  94         return iget5_locked(sb, hash, iget_test, iget_set, &data);
  95 }
  96
  97 /**
  98  * gfs2_set_iop - Sets inode operations
  99  * @inode: The inode with correct i_mode filled in
 100  *
 101  * GFS2 lookup code fills in vfs inode contents based on info obtained
 102  * from directory entry inside gfs2_inode_lookup().
 103  */
 104
 105 static void gfs2_set_iop(struct inode *inode)
 106 {
 107         struct gfs2_sbd *sdp = GFS2_SB(inode);
 108         umode_t mode = inode->i_mode;
 109
 110         if (S_ISREG(mode)) {
 111                 inode->i_op = &gfs2_file_iops;
 112                 if (gfs2_localflocks(sdp))
 113                         inode->i_fop = &gfs2_file_fops_nolock;
 114                 else
 115                         inode->i_fop = &gfs2_file_fops;
 116         } else if (S_ISDIR(mode)) {
 117                 inode->i_op = &gfs2_dir_iops;
 118                 if (gfs2_localflocks(sdp))
 119                         inode->i_fop = &gfs2_dir_fops_nolock;
 120                 else
 121                         inode->i_fop = &gfs2_dir_fops;
 122         } else if (S_ISLNK(mode)) {
 123                 inode->i_op = &gfs2_symlink_iops;
 124         } else {
 125                 inode->i_op = &gfs2_file_iops;
 126                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
 127         }
 128 }
 129
 130 /**
 131  * gfs2_inode_lookup - Lookup an inode
 132  * @sb: The super block
 133  * @no_addr: The inode number
 134  * @type: The type of the inode
 135  * non_block: Can we block on inodes that are being freed?
 136  *
 137  * Returns: A VFS inode, or an error
 138  */
 139
 140 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
 141                                 u64 no_addr, u64 no_formal_ino, int non_block)
 142 {
 143         struct inode *inode;
 144         struct gfs2_inode *ip;
 145         struct gfs2_glock *io_gl = NULL;
 146         int error;
 147
 148         inode = gfs2_iget(sb, no_addr, non_block);
 149         ip = GFS2_I(inode);
 150
 151         if (!inode)
 152                 return ERR_PTR(-ENOBUFS);
 153
 154         if (inode->i_state & I_NEW) {
 155                 struct gfs2_sbd *sdp = GFS2_SB(inode);
 156                 ip->i_no_formal_ino = no_formal_ino;
 157
 158                 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 159                 if (unlikely(error))
 160                         goto fail;
 161                 ip->i_gl->gl_object = ip;
 162
 163                 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 164                 if (unlikely(error))
 165                         goto fail_put;
 166
 167                 set_bit(GIF_INVALID, &ip->i_flags);
 168                 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 169                 if (unlikely(error))
 170                         goto fail_iopen;
 171
 172                 ip->i_iopen_gh.gh_gl->gl_object = ip;
 173                 gfs2_glock_put(io_gl);
 174                 io_gl = NULL;
 175
 176                 if (type == DT_UNKNOWN) {
 177                         /* Inode glock must be locked already */
 178                         error = gfs2_inode_refresh(GFS2_I(inode));
 179                         if (error)
 180                                 goto fail_refresh;
 181                 } else {
 182                         inode->i_mode = DT2IF(type);
 183                 }
 184
 185                 gfs2_set_iop(inode);
 186                 unlock_new_inode(inode);
 187         }
 188
 189         return inode;
 190
 191 fail_refresh:
 192         ip->i_iopen_gh.gh_gl->gl_object = NULL;
 193         gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 194 fail_iopen:
 195         if (io_gl)
 196                 gfs2_glock_put(io_gl);
 197 fail_put:
 198         ip->i_gl->gl_object = NULL;
 199         gfs2_glock_put(ip->i_gl);
 200 fail:
 201         iget_failed(inode);
 202         return ERR_PTR(error);
 203 }
 204
 205 struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
 206                                   u64 *no_formal_ino, unsigned int blktype)
 207 {
 208         struct super_block *sb = sdp->sd_vfs;
 209         struct gfs2_holder i_gh;
 210         struct inode *inode = NULL;
 211         int error;
 212
 213         /* Must not read in block until block type is verified */
 214         error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
 215                                   LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
 216         if (error)
 217                 return ERR_PTR(error);
 218
 219         error = gfs2_check_blk_type(sdp, no_addr, blktype);
 220         if (error)
 221                 goto fail;
 222
 223         inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
 224         if (IS_ERR(inode))
 225                 goto fail;
 226
 227         /* Two extra checks for NFS only */
 228         if (no_formal_ino) {
 229                 error = -ESTALE;
 230                 if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
 231                         goto fail_iput;
 232
 233                 error = -EIO;
 234                 if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
 235                         goto fail_iput;
 236
 237                 error = 0;
 238         }
 239
 240 fail:
 241         gfs2_glock_dq_uninit(&i_gh);
 242         return error ? ERR_PTR(error) : inode;
 243 fail_iput:
 244         iput(inode);
 245         goto fail;
 246 }
 247
 248
 249 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 250 {
 251         struct qstr qstr;
 252         struct inode *inode;
 253         gfs2_str2qstr(&qstr, name);
 254         inode = gfs2_lookupi(dip, &qstr, 1);
 255         /* gfs2_lookupi has inconsistent callers: vfs
 256          * related routines expect NULL for no entry found,
 257          * gfs2_lookup_simple callers expect ENOENT
 258          * and do not check for NULL.
 259          */
 260         if (inode == NULL)
 261                 return ERR_PTR(-ENOENT);
 262         else
 263                 return inode;
 264 }
 265
 266
 267 /**
 268  * gfs2_lookupi - Look up a filename in a directory and return its inode
 269  * @d_gh: An initialized holder for the directory glock
 270  * @name: The name of the inode to look for
 271  * @is_root: If 1, ignore the caller's permissions
 272  * @i_gh: An uninitialized holder for the new inode glock
 273  *
 274  * This can be called via the VFS filldir function when NFS is doing
 275  * a readdirplus and the inode which its intending to stat isn't
 276  * already in cache. In this case we must not take the directory glock
 277  * again, since the readdir call will have already taken that lock.
 278  *
 279  * Returns: errno
 280  */
 281
 282 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 283                            int is_root)
 284 {
 285         struct super_block *sb = dir->i_sb;
 286         struct gfs2_inode *dip = GFS2_I(dir);
 287         struct gfs2_holder d_gh;
 288         int error = 0;
 289         struct inode *inode = NULL;
 290         int unlock = 0;
 291
 292         if (!name->len || name->len > GFS2_FNAMESIZE)
 293                 return ERR_PTR(-ENAMETOOLONG);
 294
 295         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 296             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 297              dir == sb->s_root->d_inode)) {
 298                 igrab(dir);
 299                 return dir;
 300         }
 301
 302         if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 303                 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 304                 if (error)
 305                         return ERR_PTR(error);
 306                 unlock = 1;
 307         }
 308
 309         if (!is_root) {
 310                 error = gfs2_permission(dir, MAY_EXEC);
 311                 if (error)
 312                         goto out;
 313         }
 314
 315         inode = gfs2_dir_search(dir, name);
 316         if (IS_ERR(inode))
 317                 error = PTR_ERR(inode);
 318 out:
 319         if (unlock)
 320                 gfs2_glock_dq_uninit(&d_gh);
 321         if (error == -ENOENT)
 322                 return NULL;
 323         return inode ? inode : ERR_PTR(error);
 324 }
 325
 326 /**
 327  * create_ok - OK to create a new on-disk inode here?
 328  * @dip:  Directory in which dinode is to be created
 329  * @name:  Name of new dinode
 330  * @mode:
 331  *
 332  * Returns: errno
 333  */
 334
 335 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 336                      umode_t mode)
 337 {
 338         int error;
 339
 340         error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 341         if (error)
 342                 return error;
 343
 344         /*  Don't create entries in an unlinked directory  */
 345         if (!dip->i_inode.i_nlink)
 346                 return -ENOENT;
 347
 348         error = gfs2_dir_check(&dip->i_inode, name, NULL);
 349         switch (error) {
 350         case -ENOENT:
 351                 error = 0;
 352                 break;
 353         case 0:
 354                 return -EEXIST;
 355         default:
 356                 return error;
 357         }
 358
 359         if (dip->i_entries == (u32)-1)
 360                 return -EFBIG;
 361         if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 362                 return -EMLINK;
 363
 364         return 0;
 365 }
 366
 367 static void munge_mode_uid_gid(struct gfs2_inode *dip, umode_t *mode,
 368                                unsigned int *uid, unsigned int *gid)
 369 {
 370         if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 371             (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
 372                 if (S_ISDIR(*mode))
 373                         *mode |= S_ISUID;
 374                 else if (dip->i_inode.i_uid != current_fsuid())
 375                         *mode &= ~07111;
 376                 *uid = dip->i_inode.i_uid;
 377         } else
 378                 *uid = current_fsuid();
 379
 380         if (dip->i_inode.i_mode & S_ISGID) {
 381                 if (S_ISDIR(*mode))
 382                         *mode |= S_ISGID;
 383                 *gid = dip->i_inode.i_gid;
 384         } else
 385                 *gid = current_fsgid();
 386 }
 387
 388 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
 389 {
 390         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 391         int error;
 392         int dblocks = 1;
 393
 394         error = gfs2_inplace_reserve(dip, RES_DINODE);
 395         if (error)
 396                 goto out;
 397
 398         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
 399         if (error)
 400                 goto out_ipreserv;
 401
 402         error = gfs2_alloc_blocks(dip, no_addr, &dblocks, 1, generation);
 403
 404         gfs2_trans_end(sdp);
 405
 406 out_ipreserv:
 407         gfs2_inplace_release(dip);
 408 out:
 409         return error;
 410 }
 411
 412 static void gfs2_init_dir(struct buffer_head *dibh,
 413                           const struct gfs2_inode *parent)
 414 {
 415         struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 416         struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 417
 418         gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 419         dent->de_inum = di->di_num; /* already GFS2 endian */
 420         dent->de_type = cpu_to_be16(DT_DIR);
 421
 422         dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 423         gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 424         gfs2_inum_out(parent, dent);
 425         dent->de_type = cpu_to_be16(DT_DIR);
 426
 427 }
 428
 429 /**
 430  * init_dinode - Fill in a new dinode structure
 431  * @dip: The directory this inode is being created in
 432  * @gl: The glock covering the new inode
 433  * @inum: The inode number
 434  * @mode: The file permissions
 435  * @uid: The uid of the new inode
 436  * @gid: The gid of the new inode
 437  * @generation: The generation number of the new inode
 438  * @dev: The device number (if a device node)
 439  * @symname: The symlink destination (if a symlink)
 440  * @size: The inode size (ignored for directories)
 441  * @bhp: The buffer head (returned to caller)
 442  *
 443  */
 444
 445 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 446                         const struct gfs2_inum_host *inum, umode_t mode,
 447                         unsigned int uid, unsigned int gid,
 448                         const u64 *generation, dev_t dev, const char *symname,
 449                         unsigned size, struct buffer_head **bhp)
 450 {
 451         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 452         struct gfs2_dinode *di;
 453         struct buffer_head *dibh;
 454         struct timespec tv = CURRENT_TIME;
 455
 456         dibh = gfs2_meta_new(gl, inum->no_addr);
 457         gfs2_trans_add_bh(gl, dibh, 1);
 458         gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
 459         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 460         di = (struct gfs2_dinode *)dibh->b_data;
 461
 462         di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
 463         di->di_num.no_addr = cpu_to_be64(inum->no_addr);
 464         di->di_mode = cpu_to_be32(mode);
 465         di->di_uid = cpu_to_be32(uid);
 466         di->di_gid = cpu_to_be32(gid);
 467         di->di_nlink = 0;
 468         di->di_size = cpu_to_be64(size);
 469         di->di_blocks = cpu_to_be64(1);
 470         di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
 471         di->di_major = cpu_to_be32(MAJOR(dev));
 472         di->di_minor = cpu_to_be32(MINOR(dev));
 473         di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
 474         di->di_generation = cpu_to_be64(*generation);
 475         di->di_flags = 0;
 476         di->__pad1 = 0;
 477         di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
 478         di->di_height = 0;
 479         di->__pad2 = 0;
 480         di->__pad3 = 0;
 481         di->di_depth = 0;
 482         di->di_entries = 0;
 483         memset(&di->__pad4, 0, sizeof(di->__pad4));
 484         di->di_eattr = 0;
 485         di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
 486         di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
 487         di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
 488         memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 489
 490         switch(mode & S_IFMT) {
 491         case S_IFREG:
 492                 if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 493                     gfs2_tune_get(sdp, gt_new_files_jdata))
 494                         di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 495                 break;
 496         case S_IFDIR:
 497                 di->di_flags |= cpu_to_be32(dip->i_diskflags &
 498                                             GFS2_DIF_INHERIT_JDATA);
 499                 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 500                 di->di_size = cpu_to_be64(sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode));
 501                 di->di_entries = cpu_to_be32(2);
 502                 gfs2_init_dir(dibh, dip);
 503                 break;
 504         case S_IFLNK:
 505                 memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, size);
 506                 break;
 507         }
 508
 509         set_buffer_uptodate(dibh);
 510
 511         *bhp = dibh;
 512 }
 513
 514 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 515                        umode_t mode, const struct gfs2_inum_host *inum,
 516                        const u64 *generation, dev_t dev, const char *symname,
 517                        unsigned int size, struct buffer_head **bhp)
 518 {
 519         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 520         unsigned int uid, gid;
 521         int error;
 522
 523         munge_mode_uid_gid(dip, &mode, &uid, &gid);
 524         error = gfs2_rindex_update(sdp);
 525         if (error)
 526                 return error;
 527
 528         error = gfs2_quota_lock(dip, uid, gid);
 529         if (error)
 530                 return error;
 531
 532         error = gfs2_quota_check(dip, uid, gid);
 533         if (error)
 534                 goto out_quota;
 535
 536         error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
 537         if (error)
 538                 goto out_quota;
 539
 540         init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, symname, size, bhp);
 541         gfs2_quota_change(dip, +1, uid, gid);
 542         gfs2_trans_end(sdp);
 543
 544 out_quota:
 545         gfs2_quota_unlock(dip);
 546         return error;
 547 }
 548
 549 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 550                        struct gfs2_inode *ip)
 551 {
 552         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 553         int alloc_required;
 554         struct buffer_head *dibh;
 555         int error;
 556
 557         error = gfs2_rindex_update(sdp);
 558         if (error)
 559                 return error;
 560
 561         error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 562         if (error)
 563                 goto fail;
 564
 565         error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
 566         if (alloc_required < 0)
 567                 goto fail_quota_locks;
 568         if (alloc_required) {
 569                 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
 570                 if (error)
 571                         goto fail_quota_locks;
 572
 573                 error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres);
 574                 if (error)
 575                         goto fail_quota_locks;
 576
 577                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 578                                          dip->i_rgd->rd_length +
 579                                          2 * RES_DINODE +
 580                                          RES_STATFS + RES_QUOTA, 0);
 581                 if (error)
 582                         goto fail_ipreserv;
 583         } else {
 584                 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 585                 if (error)
 586                         goto fail_quota_locks;
 587         }
 588
 589         error = gfs2_dir_add(&dip->i_inode, name, ip);
 590         if (error)
 591                 goto fail_end_trans;
 592
 593         error = gfs2_meta_inode_buffer(ip, &dibh);
 594         if (error)
 595                 goto fail_end_trans;
 596         set_nlink(&ip->i_inode, S_ISDIR(ip->i_inode.i_mode) ? 2 : 1);
 597         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 598         gfs2_dinode_out(ip, dibh->b_data);
 599         brelse(dibh);
 600         return 0;
 601
 602 fail_end_trans:
 603         gfs2_trans_end(sdp);
 604
 605 fail_ipreserv:
 606         if (alloc_required)
 607                 gfs2_inplace_release(dip);
 608
 609 fail_quota_locks:
 610         gfs2_quota_unlock(dip);
 611
 612 fail:
 613         return error;
 614 }
 615
 616 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
 617                     void *fs_info)
 618 {
 619         const struct xattr *xattr;
 620         int err = 0;
 621
 622         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 623                 err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
 624                                        xattr->value_len, 0,
 625                                        GFS2_EATYPE_SECURITY);
 626                 if (err < 0)
 627                         break;
 628         }
 629         return err;
 630 }
 631
 632 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
 633                               const struct qstr *qstr)
 634 {
 635         return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
 636                                             &gfs2_initxattrs, NULL);
 637 }
 638
 639 /**
 640  * gfs2_create_inode - Create a new inode
 641  * @dir: The parent directory
 642  * @dentry: The new dentry
 643  * @mode: The permissions on the new inode
 644  * @dev: For device nodes, this is the device number
 645  * @symname: For symlinks, this is the link destination
 646  * @size: The initial size of the inode (ignored for directories)
 647  *
 648  * Returns: 0 on success, or error code
 649  */
 650
 651 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 652                              umode_t mode, dev_t dev, const char *symname,
 653                              unsigned int size, int excl)
 654 {
 655         const struct qstr *name = &dentry->d_name;
 656         struct gfs2_holder ghs[2];
 657         struct inode *inode = NULL;
 658         struct gfs2_inode *dip = GFS2_I(dir), *ip;
 659         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 660         struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
 661         int error;
 662         u64 generation;
 663         struct buffer_head *bh = NULL;
 664
 665         if (!name->len || name->len > GFS2_FNAMESIZE)
 666                 return -ENAMETOOLONG;
 667
 668         /* We need a reservation to allocate the new dinode block. The
 669            directory ip temporarily points to the reservation, but this is
 670            being done to get a set of contiguous blocks for the new dinode.
 671            Since this is a create, we don't have a sizehint yet, so it will
 672            have to use the minimum reservation size. */
 673         error = gfs2_rs_alloc(dip);
 674         if (error)
 675                 return error;
 676
 677         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 678         if (error)
 679                 goto fail;
 680
 681         error = create_ok(dip, name, mode);
 682         if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
 683                 inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 684                 gfs2_glock_dq_uninit(ghs);
 685                 d_instantiate(dentry, inode);
 686                 return IS_ERR(inode) ? PTR_ERR(inode) : 0;
 687         }
 688         if (error)
 689                 goto fail_gunlock;
 690
 691         error = alloc_dinode(dip, &inum.no_addr, &generation);
 692         if (error)
 693                 goto fail_gunlock;
 694         inum.no_formal_ino = generation;
 695
 696         error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
 697                                   LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
 698         if (error)
 699                 goto fail_gunlock;
 700
 701         error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, symname, size, &bh);
 702         if (error)
 703                 goto fail_gunlock2;
 704
 705         inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
 706                                   inum.no_formal_ino, 0);
 707         if (IS_ERR(inode))
 708                 goto fail_gunlock2;
 709
 710         ip = GFS2_I(inode);
 711         error = gfs2_inode_refresh(ip);
 712         if (error)
 713                 goto fail_gunlock2;
 714
 715         /* The newly created inode needs a reservation so it can allocate
 716            xattrs. At the same time, we want new blocks allocated to the new
 717            dinode to be as contiguous as possible. Since we allocated the
 718            dinode block under the directory's reservation, we transfer
 719            ownership of that reservation to the new inode. The directory
 720            doesn't need a reservation unless it needs a new allocation. */
 721         ip->i_res = dip->i_res;
 722         dip->i_res = NULL;
 723
 724         error = gfs2_acl_create(dip, inode);
 725         if (error)
 726                 goto fail_gunlock2;
 727
 728         error = gfs2_security_init(dip, ip, name);
 729         if (error)
 730                 goto fail_gunlock2;
 731
 732         error = link_dinode(dip, name, ip);
 733         if (error)
 734                 goto fail_gunlock2;
 735
 736         if (bh)
 737                 brelse(bh);
 738
 739         gfs2_trans_end(sdp);
 740         /* Check if we reserved space in the rgrp. Function link_dinode may
 741            not, depending on whether alloc is required. */
 742         if (gfs2_mb_reserved(dip))
 743                 gfs2_inplace_release(dip);
 744         gfs2_quota_unlock(dip);
 745         mark_inode_dirty(inode);
 746         gfs2_glock_dq_uninit_m(2, ghs);
 747         d_instantiate(dentry, inode);
 748         return 0;
 749
 750 fail_gunlock2:
 751         gfs2_glock_dq_uninit(ghs + 1);
 752 fail_gunlock:
 753         gfs2_glock_dq_uninit(ghs);
 754         if (inode && !IS_ERR(inode)) {
 755                 set_bit(GIF_ALLOC_FAILED, &GFS2_I(inode)->i_flags);
 756                 iput(inode);
 757         }
 758 fail:
 759         gfs2_rs_delete(dip);
 760         if (bh)
 761                 brelse(bh);
 762         return error;
 763 }
 764
 765 /**
 766  * gfs2_create - Create a file
 767  * @dir: The directory in which to create the file
 768  * @dentry: The dentry of the new file
 769  * @mode: The mode of the new file
 770  *
 771  * Returns: errno
 772  */
 773
 774 static int gfs2_create(struct inode *dir, struct dentry *dentry,
 775                        umode_t mode, bool excl)
 776 {
 777         return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
 778 }
 779
 780 /**
 781  * gfs2_lookup - Look up a filename in a directory and return its inode
 782  * @dir: The directory inode
 783  * @dentry: The dentry of the new inode
 784  * @nd: passed from Linux VFS, ignored by us
 785  *
 786  * Called by the VFS layer. Lock dir and call gfs2_lookupi()
 787  *
 788  * Returns: errno
 789  */
 790
 791 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 792                                   unsigned int flags)
 793 {
 794         struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 795         if (inode && !IS_ERR(inode)) {
 796                 struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
 797                 struct gfs2_holder gh;
 798                 int error;
 799                 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 800                 if (error) {
 801                         iput(inode);
 802                         return ERR_PTR(error);
 803                 }
 804                 gfs2_glock_dq_uninit(&gh);
 805         }
 806         return d_splice_alias(inode, dentry);
 807 }
 808
 809 /**
 810  * gfs2_link - Link to a file
 811  * @old_dentry: The inode to link
 812  * @dir: Add link to this directory
 813  * @dentry: The name of the link
 814  *
 815  * Link the inode in "old_dentry" into the directory "dir" with the
 816  * name in "dentry".
 817  *
 818  * Returns: errno
 819  */
 820
 821 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 822                      struct dentry *dentry)
 823 {
 824         struct gfs2_inode *dip = GFS2_I(dir);
 825         struct gfs2_sbd *sdp = GFS2_SB(dir);
 826         struct inode *inode = old_dentry->d_inode;
 827         struct gfs2_inode *ip = GFS2_I(inode);
 828         struct gfs2_holder ghs[2];
 829         struct buffer_head *dibh;
 830         int alloc_required;
 831         int error;
 832
 833         if (S_ISDIR(inode->i_mode))
 834                 return -EPERM;
 835
 836         error = gfs2_rs_alloc(dip);
 837         if (error)
 838                 return error;
 839
 840         gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 841         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 842
 843         error = gfs2_glock_nq(ghs); /* parent */
 844         if (error)
 845                 goto out_parent;
 846
 847         error = gfs2_glock_nq(ghs + 1); /* child */
 848         if (error)
 849                 goto out_child;
 850
 851         error = -ENOENT;
 852         if (inode->i_nlink == 0)
 853                 goto out_gunlock;
 854
 855         error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
 856         if (error)
 857                 goto out_gunlock;
 858
 859         error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 860         switch (error) {
 861         case -ENOENT:
 862                 break;
 863         case 0:
 864                 error = -EEXIST;
 865         default:
 866                 goto out_gunlock;
 867         }
 868
 869         error = -EINVAL;
 870         if (!dip->i_inode.i_nlink)
 871                 goto out_gunlock;
 872         error = -EFBIG;
 873         if (dip->i_entries == (u32)-1)
 874                 goto out_gunlock;
 875         error = -EPERM;
 876         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 877                 goto out_gunlock;
 878         error = -EINVAL;
 879         if (!ip->i_inode.i_nlink)
 880                 goto out_gunlock;
 881         error = -EMLINK;
 882         if (ip->i_inode.i_nlink == (u32)-1)
 883                 goto out_gunlock;
 884
 885         alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
 886         if (error < 0)
 887                 goto out_gunlock;
 888         error = 0;
 889
 890         if (alloc_required) {
 891                 error = gfs2_quota_lock_check(dip);
 892                 if (error)
 893                         goto out_gunlock;
 894
 895                 error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres);
 896                 if (error)
 897                         goto out_gunlock_q;
 898
 899                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 900                                          gfs2_rg_blocks(dip) +
 901                                          2 * RES_DINODE + RES_STATFS +
 902                                          RES_QUOTA, 0);
 903                 if (error)
 904                         goto out_ipres;
 905         } else {
 906                 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 907                 if (error)
 908                         goto out_ipres;
 909         }
 910
 911         error = gfs2_meta_inode_buffer(ip, &dibh);
 912         if (error)
 913                 goto out_end_trans;
 914
 915         error = gfs2_dir_add(dir, &dentry->d_name, ip);
 916         if (error)
 917                 goto out_brelse;
 918
 919         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 920         inc_nlink(&ip->i_inode);
 921         ip->i_inode.i_ctime = CURRENT_TIME;
 922         ihold(inode);
 923         d_instantiate(dentry, inode);
 924         mark_inode_dirty(inode);
 925
 926 out_brelse:
 927         brelse(dibh);
 928 out_end_trans:
 929         gfs2_trans_end(sdp);
 930 out_ipres:
 931         if (alloc_required)
 932                 gfs2_inplace_release(dip);
 933 out_gunlock_q:
 934         if (alloc_required)
 935                 gfs2_quota_unlock(dip);
 936 out_gunlock:
 937         gfs2_glock_dq(ghs + 1);
 938 out_child:
 939         gfs2_glock_dq(ghs);
 940 out_parent:
 941         gfs2_holder_uninit(ghs);
 942         gfs2_holder_uninit(ghs + 1);
 943         return error;
 944 }
 945
 946 /*
 947  * gfs2_unlink_ok - check to see that a inode is still in a directory
 948  * @dip: the directory
 949  * @name: the name of the file
 950  * @ip: the inode
 951  *
 952  * Assumes that the lock on (at least) @dip is held.
 953  *
 954  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 955  */
 956
 957 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 958                           const struct gfs2_inode *ip)
 959 {
 960         int error;
 961
 962         if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 963                 return -EPERM;
 964
 965         if ((dip->i_inode.i_mode & S_ISVTX) &&
 966             dip->i_inode.i_uid != current_fsuid() &&
 967             ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
 968                 return -EPERM;
 969
 970         if (IS_APPEND(&dip->i_inode))
 971                 return -EPERM;
 972
 973         error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 974         if (error)
 975                 return error;
 976
 977         error = gfs2_dir_check(&dip->i_inode, name, ip);
 978         if (error)
 979                 return error;
 980
 981         return 0;
 982 }
 983
 984 /**
 985  * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
 986  * @dip: The parent directory
 987  * @name: The name of the entry in the parent directory
 988  * @bh: The inode buffer for the inode to be removed
 989  * @inode: The inode to be removed
 990  *
 991  * Called with all the locks and in a transaction. This will only be
 992  * called for a directory after it has been checked to ensure it is empty.
 993  *
 994  * Returns: 0 on success, or an error
 995  */
 996
 997 static int gfs2_unlink_inode(struct gfs2_inode *dip,
 998                              const struct dentry *dentry,
 999                              struct buffer_head *bh)
1000 {
1001         struct inode *inode = dentry->d_inode;
1002         struct gfs2_inode *ip = GFS2_I(inode);
1003         int error;
1004
1005         error = gfs2_dir_del(dip, dentry);
1006         if (error)
1007                 return error;
1008
1009         ip->i_entries = 0;
1010         inode->i_ctime = CURRENT_TIME;
1011         if (S_ISDIR(inode->i_mode))
1012                 clear_nlink(inode);
1013         else
1014                 drop_nlink(inode);
1015         mark_inode_dirty(inode);
1016         if (inode->i_nlink == 0)
1017                 gfs2_unlink_di(inode);
1018         return 0;
1019 }
1020
1021
1022 /**
1023  * gfs2_unlink - Unlink an inode (this does rmdir as well)
1024  * @dir: The inode of the directory containing the inode to unlink
1025  * @dentry: The file itself
1026  *
1027  * This routine uses the type of the inode as a flag to figure out
1028  * whether this is an unlink or an rmdir.
1029  *
1030  * Returns: errno
1031  */
1032
1033 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
1034 {
1035         struct gfs2_inode *dip = GFS2_I(dir);
1036         struct gfs2_sbd *sdp = GFS2_SB(dir);
1037         struct inode *inode = dentry->d_inode;
1038         struct gfs2_inode *ip = GFS2_I(inode);
1039         struct buffer_head *bh;
1040         struct gfs2_holder ghs[3];
1041         struct gfs2_rgrpd *rgd;
1042         int error;
1043
1044         error = gfs2_rindex_update(sdp);
1045         if (error)
1046                 return error;
1047
1048         error = -EROFS;
1049
1050         gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1051         gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
1052
1053         rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
1054         if (!rgd)
1055                 goto out_inodes;
1056
1057         gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
1058
1059
1060         error = gfs2_glock_nq(ghs); /* parent */
1061         if (error)
1062                 goto out_parent;
1063
1064         error = gfs2_glock_nq(ghs + 1); /* child */
1065         if (error)
1066                 goto out_child;
1067
1068         error = -ENOENT;
1069         if (inode->i_nlink == 0)
1070                 goto out_rgrp;
1071
1072         if (S_ISDIR(inode->i_mode)) {
1073                 error = -ENOTEMPTY;
1074                 if (ip->i_entries > 2 || inode->i_nlink > 2)
1075                         goto out_rgrp;
1076         }
1077
1078         error = gfs2_glock_nq(ghs + 2); /* rgrp */
1079         if (error)
1080                 goto out_rgrp;
1081
1082         error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
1083         if (error)
1084                 goto out_gunlock;
1085
1086         error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
1087         if (error)
1088                 goto out_gunlock;
1089
1090         error = gfs2_meta_inode_buffer(ip, &bh);
1091         if (error)
1092                 goto out_end_trans;
1093
1094         error = gfs2_unlink_inode(dip, dentry, bh);
1095         brelse(bh);
1096
1097 out_end_trans:
1098         gfs2_trans_end(sdp);
1099 out_gunlock:
1100         gfs2_glock_dq(ghs + 2);
1101 out_rgrp:
1102         gfs2_glock_dq(ghs + 1);
1103 out_child:
1104         gfs2_glock_dq(ghs);
1105 out_parent:
1106         gfs2_holder_uninit(ghs + 2);
1107 out_inodes:
1108         gfs2_holder_uninit(ghs + 1);
1109         gfs2_holder_uninit(ghs);
1110         return error;
1111 }
1112
1113 /**
1114  * gfs2_symlink - Create a symlink
1115  * @dir: The directory to create the symlink in
1116  * @dentry: The dentry to put the symlink in
1117  * @symname: The thing which the link points to
1118  *
1119  * Returns: errno
1120  */
1121
1122 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
1123                         const char *symname)
1124 {
1125         struct gfs2_sbd *sdp = GFS2_SB(dir);
1126         unsigned int size;
1127
1128         size = strlen(symname);
1129         if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
1130                 return -ENAMETOOLONG;
1131
1132         return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
1133 }
1134
1135 /**
1136  * gfs2_mkdir - Make a directory
1137  * @dir: The parent directory of the new one
1138  * @dentry: The dentry of the new directory
1139  * @mode: The mode of the new directory
1140  *
1141  * Returns: errno
1142  */
1143
1144 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1145 {
1146         return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0, 0);
1147 }
1148
1149 /**
1150  * gfs2_mknod - Make a special file
1151  * @dir: The directory in which the special file will reside
1152  * @dentry: The dentry of the special file
1153  * @mode: The mode of the special file
1154  * @dev: The device specification of the special file
1155  *
1156  */
1157
1158 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
1159                       dev_t dev)
1160 {
1161         return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
1162 }
1163
1164 /*
1165  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1166  * @this: move this
1167  * @to: to here
1168  *
1169  * Follow @to back to the root and make sure we don't encounter @this
1170  * Assumes we already hold the rename lock.
1171  *
1172  * Returns: errno
1173  */
1174
1175 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1176 {
1177         struct inode *dir = &to->i_inode;
1178         struct super_block *sb = dir->i_sb;
1179         struct inode *tmp;
1180         int error = 0;
1181
1182         igrab(dir);
1183
1184         for (;;) {
1185                 if (dir == &this->i_inode) {
1186                         error = -EINVAL;
1187                         break;
1188                 }
1189                 if (dir == sb->s_root->d_inode) {
1190                         error = 0;
1191                         break;
1192                 }
1193
1194                 tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
1195                 if (IS_ERR(tmp)) {
1196                         error = PTR_ERR(tmp);
1197                         break;
1198                 }
1199
1200                 iput(dir);
1201                 dir = tmp;
1202         }
1203
1204         iput(dir);
1205
1206         return error;
1207 }
1208
1209 /**
1210  * gfs2_rename - Rename a file
1211  * @odir: Parent directory of old file name
1212  * @odentry: The old dentry of the file
1213  * @ndir: Parent directory of new file name
1214  * @ndentry: The new dentry of the file
1215  *
1216  * Returns: errno
1217  */
1218
1219 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
1220                        struct inode *ndir, struct dentry *ndentry)
1221 {
1222         struct gfs2_inode *odip = GFS2_I(odir);
1223         struct gfs2_inode *ndip = GFS2_I(ndir);
1224         struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
1225         struct gfs2_inode *nip = NULL;
1226         struct gfs2_sbd *sdp = GFS2_SB(odir);
1227         struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
1228         struct gfs2_rgrpd *nrgd;
1229         unsigned int num_gh;
1230         int dir_rename = 0;
1231         int alloc_required = 0;
1232         unsigned int x;
1233         int error;
1234
1235         if (ndentry->d_inode) {
1236                 nip = GFS2_I(ndentry->d_inode);
1237                 if (ip == nip)
1238                         return 0;
1239         }
1240
1241         error = gfs2_rindex_update(sdp);
1242         if (error)
1243                 return error;
1244
1245         error = gfs2_rs_alloc(ndip);
1246         if (error)
1247                 return error;
1248
1249         if (odip != ndip) {
1250                 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
1251                                            0, &r_gh);
1252                 if (error)
1253                         goto out;
1254
1255                 if (S_ISDIR(ip->i_inode.i_mode)) {
1256                         dir_rename = 1;
1257                         /* don't move a dirctory into it's subdir */
1258                         error = gfs2_ok_to_move(ip, ndip);
1259                         if (error)
1260                                 goto out_gunlock_r;
1261                 }
1262         }
1263
1264         num_gh = 1;
1265         gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
1266         if (odip != ndip) {
1267                 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1268                 num_gh++;
1269         }
1270         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1271         num_gh++;
1272
1273         if (nip) {
1274                 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
1275                 num_gh++;
1276                 /* grab the resource lock for unlink flag twiddling
1277                  * this is the case of the target file already existing
1278                  * so we unlink before doing the rename
1279                  */
1280                 nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
1281                 if (nrgd)
1282                         gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
1283         }
1284
1285         for (x = 0; x < num_gh; x++) {
1286                 error = gfs2_glock_nq(ghs + x);
1287                 if (error)
1288                         goto out_gunlock;
1289         }
1290
1291         error = -ENOENT;
1292         if (ip->i_inode.i_nlink == 0)
1293                 goto out_gunlock;
1294
1295         /* Check out the old directory */
1296
1297         error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
1298         if (error)
1299                 goto out_gunlock;
1300
1301         /* Check out the new directory */
1302
1303         if (nip) {
1304                 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
1305                 if (error)
1306                         goto out_gunlock;
1307
1308                 if (nip->i_inode.i_nlink == 0) {
1309                         error = -EAGAIN;
1310                         goto out_gunlock;
1311                 }
1312
1313                 if (S_ISDIR(nip->i_inode.i_mode)) {
1314                         if (nip->i_entries < 2) {
1315                                 gfs2_consist_inode(nip);
1316                                 error = -EIO;
1317                                 goto out_gunlock;
1318                         }
1319                         if (nip->i_entries > 2) {
1320                                 error = -ENOTEMPTY;
1321                                 goto out_gunlock;
1322                         }
1323                 }
1324         } else {
1325                 error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
1326                 if (error)
1327                         goto out_gunlock;
1328
1329                 error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
1330                 switch (error) {
1331                 case -ENOENT:
1332                         error = 0;
1333                         break;
1334                 case 0:
1335                         error = -EEXIST;
1336                 default:
1337                         goto out_gunlock;
1338                 };
1339
1340                 if (odip != ndip) {
1341                         if (!ndip->i_inode.i_nlink) {
1342                                 error = -ENOENT;
1343                                 goto out_gunlock;
1344                         }
1345                         if (ndip->i_entries == (u32)-1) {
1346                                 error = -EFBIG;
1347                                 goto out_gunlock;
1348                         }
1349                         if (S_ISDIR(ip->i_inode.i_mode) &&
1350                             ndip->i_inode.i_nlink == (u32)-1) {
1351                                 error = -EMLINK;
1352                                 goto out_gunlock;
1353                         }
1354                 }
1355         }
1356
1357         /* Check out the dir to be renamed */
1358
1359         if (dir_rename) {
1360                 error = gfs2_permission(odentry->d_inode, MAY_WRITE);
1361                 if (error)
1362                         goto out_gunlock;
1363         }
1364
1365         if (nip == NULL)
1366                 alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
1367         error = alloc_required;
1368         if (error < 0)
1369                 goto out_gunlock;
1370
1371         if (alloc_required) {
1372                 error = gfs2_quota_lock_check(ndip);
1373                 if (error)
1374                         goto out_gunlock;
1375
1376                 error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres);
1377                 if (error)
1378                         goto out_gunlock_q;
1379
1380                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
1381                                          gfs2_rg_blocks(ndip) +
1382                                          4 * RES_DINODE + 4 * RES_LEAF +
1383                                          RES_STATFS + RES_QUOTA + 4, 0);
1384                 if (error)
1385                         goto out_ipreserv;
1386         } else {
1387                 error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
1388                                          5 * RES_LEAF + 4, 0);
1389                 if (error)
1390                         goto out_gunlock;
1391         }
1392
1393         /* Remove the target file, if it exists */
1394
1395         if (nip) {
1396                 struct buffer_head *bh;
1397                 error = gfs2_meta_inode_buffer(nip, &bh);
1398                 if (error)
1399                         goto out_end_trans;
1400                 error = gfs2_unlink_inode(ndip, ndentry, bh);
1401                 brelse(bh);
1402         }
1403
1404         if (dir_rename) {
1405                 error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
1406                 if (error)
1407                         goto out_end_trans;
1408         } else {
1409                 struct buffer_head *dibh;
1410                 error = gfs2_meta_inode_buffer(ip, &dibh);
1411                 if (error)
1412                         goto out_end_trans;
1413                 ip->i_inode.i_ctime = CURRENT_TIME;
1414                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1415                 gfs2_dinode_out(ip, dibh->b_data);
1416                 brelse(dibh);
1417         }
1418
1419         error = gfs2_dir_del(odip, odentry);
1420         if (error)
1421                 goto out_end_trans;
1422
1423         error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
1424         if (error)
1425                 goto out_end_trans;
1426
1427 out_end_trans:
1428         gfs2_trans_end(sdp);
1429 out_ipreserv:
1430         if (alloc_required)
1431                 gfs2_inplace_release(ndip);
1432 out_gunlock_q:
1433         if (alloc_required)
1434                 gfs2_quota_unlock(ndip);
1435 out_gunlock:
1436         while (x--) {
1437                 gfs2_glock_dq(ghs + x);
1438                 gfs2_holder_uninit(ghs + x);
1439         }
1440 out_gunlock_r:
1441         if (r_gh.gh_gl)
1442                 gfs2_glock_dq_uninit(&r_gh);
1443 out:
1444         return error;
1445 }
1446
1447 /**
1448  * gfs2_follow_link - Follow a symbolic link
1449  * @dentry: The dentry of the link
1450  * @nd: Data that we pass to vfs_follow_link()
1451  *
1452  * This can handle symlinks of any size.
1453  *
1454  * Returns: 0 on success or error code
1455  */
1456
1457 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
1458 {
1459         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
1460         struct gfs2_holder i_gh;
1461         struct buffer_head *dibh;
1462         unsigned int size;
1463         char *buf;
1464         int error;
1465
1466         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
1467         error = gfs2_glock_nq(&i_gh);
1468         if (error) {
1469                 gfs2_holder_uninit(&i_gh);
1470                 nd_set_link(nd, ERR_PTR(error));
1471                 return NULL;
1472         }
1473
1474         size = (unsigned int)i_size_read(&ip->i_inode);
1475         if (size == 0) {
1476                 gfs2_consist_inode(ip);
1477                 buf = ERR_PTR(-EIO);
1478                 goto out;
1479         }
1480
1481         error = gfs2_meta_inode_buffer(ip, &dibh);
1482         if (error) {
1483                 buf = ERR_PTR(error);
1484                 goto out;
1485         }
1486
1487         buf = kzalloc(size + 1, GFP_NOFS);
1488         if (!buf)
1489                 buf = ERR_PTR(-ENOMEM);
1490         else
1491                 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
1492         brelse(dibh);
1493 out:
1494         gfs2_glock_dq_uninit(&i_gh);
1495         nd_set_link(nd, buf);
1496         return NULL;
1497 }
1498
1499 static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1500 {
1501         char *s = nd_get_link(nd);
1502         if (!IS_ERR(s))
1503                 kfree(s);
1504 }
1505
1506 /**
1507  * gfs2_permission -
1508  * @inode: The inode
1509  * @mask: The mask to be tested
1510  * @flags: Indicates whether this is an RCU path walk or not
1511  *
1512  * This may be called from the VFS directly, or from within GFS2 with the
1513  * inode locked, so we look to see if the glock is already locked and only
1514  * lock the glock if its not already been done.
1515  *
1516  * Returns: errno
1517  */
1518
1519 int gfs2_permission(struct inode *inode, int mask)
1520 {
1521         struct gfs2_inode *ip;
1522         struct gfs2_holder i_gh;
1523         int error;
1524         int unlock = 0;
1525
1526
1527         ip = GFS2_I(inode);
1528         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1529                 if (mask & MAY_NOT_BLOCK)
1530                         return -ECHILD;
1531                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
1532                 if (error)
1533                         return error;
1534                 unlock = 1;
1535         }
1536
1537         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
1538                 error = -EACCES;
1539         else
1540                 error = generic_permission(inode, mask);
1541         if (unlock)
1542                 gfs2_glock_dq_uninit(&i_gh);
1543
1544         return error;
1545 }
1546
1547 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1548 {
1549         setattr_copy(inode, attr);
1550         mark_inode_dirty(inode);
1551         return 0;
1552 }
1553
1554 /**
1555  * gfs2_setattr_simple -
1556  * @ip:
1557  * @attr:
1558  *
1559  * Returns: errno
1560  */
1561
1562 int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
1563 {
1564         int error;
1565
1566         if (current->journal_info)
1567                 return __gfs2_setattr_simple(inode, attr);
1568
1569         error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
1570         if (error)
1571                 return error;
1572
1573         error = __gfs2_setattr_simple(inode, attr);
1574         gfs2_trans_end(GFS2_SB(inode));
1575         return error;
1576 }
1577
1578 static int setattr_chown(struct inode *inode, struct iattr *attr)
1579 {
1580         struct gfs2_inode *ip = GFS2_I(inode);
1581         struct gfs2_sbd *sdp = GFS2_SB(inode);
1582         u32 ouid, ogid, nuid, ngid;
1583         int error;
1584
1585         ouid = inode->i_uid;
1586         ogid = inode->i_gid;
1587         nuid = attr->ia_uid;
1588         ngid = attr->ia_gid;
1589
1590         if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
1591                 ouid = nuid = NO_QUOTA_CHANGE;
1592         if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
1593                 ogid = ngid = NO_QUOTA_CHANGE;
1594
1595         error = gfs2_quota_lock(ip, nuid, ngid);
1596         if (error)
1597                 return error;
1598
1599         if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1600                 error = gfs2_quota_check(ip, nuid, ngid);
1601                 if (error)
1602                         goto out_gunlock_q;
1603         }
1604
1605         error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1606         if (error)
1607                 goto out_gunlock_q;
1608
1609         error = gfs2_setattr_simple(inode, attr);
1610         if (error)
1611                 goto out_end_trans;
1612
1613         if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1614                 u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1615                 gfs2_quota_change(ip, -blocks, ouid, ogid);
1616                 gfs2_quota_change(ip, blocks, nuid, ngid);
1617         }
1618
1619 out_end_trans:
1620         gfs2_trans_end(sdp);
1621 out_gunlock_q:
1622         gfs2_quota_unlock(ip);
1623         return error;
1624 }
1625
1626 /**
1627  * gfs2_setattr - Change attributes on an inode
1628  * @dentry: The dentry which is changing
1629  * @attr: The structure describing the change
1630  *
1631  * The VFS layer wants to change one or more of an inodes attributes.  Write
1632  * that change out to disk.
1633  *
1634  * Returns: errno
1635  */
1636
1637 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1638 {
1639         struct inode *inode = dentry->d_inode;
1640         struct gfs2_inode *ip = GFS2_I(inode);
1641         struct gfs2_holder i_gh;
1642         int error;
1643
1644         error = gfs2_rs_alloc(ip);
1645         if (error)
1646                 return error;
1647
1648         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1649         if (error)
1650                 return error;
1651
1652         error = -EPERM;
1653         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1654                 goto out;
1655
1656         error = inode_change_ok(inode, attr);
1657         if (error)
1658                 goto out;
1659
1660         if (attr->ia_valid & ATTR_SIZE)
1661                 error = gfs2_setattr_size(inode, attr->ia_size);
1662         else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1663                 error = setattr_chown(inode, attr);
1664         else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1665                 error = gfs2_acl_chmod(ip, attr);
1666         else
1667                 error = gfs2_setattr_simple(inode, attr);
1668
1669 out:
1670         if (!error)
1671                 mark_inode_dirty(inode);
1672         gfs2_glock_dq_uninit(&i_gh);
1673         return error;
1674 }
1675
1676 /**
1677  * gfs2_getattr - Read out an inode's attributes
1678  * @mnt: The vfsmount the inode is being accessed from
1679  * @dentry: The dentry to stat
1680  * @stat: The inode's stats
1681  *
1682  * This may be called from the VFS directly, or from within GFS2 with the
1683  * inode locked, so we look to see if the glock is already locked and only
1684  * lock the glock if its not already been done. Note that its the NFS
1685  * readdirplus operation which causes this to be called (from filldir)
1686  * with the glock already held.
1687  *
1688  * Returns: errno
1689  */
1690
1691 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1692                         struct kstat *stat)
1693 {
1694         struct inode *inode = dentry->d_inode;
1695         struct gfs2_inode *ip = GFS2_I(inode);
1696         struct gfs2_holder gh;
1697         int error;
1698         int unlock = 0;
1699
1700         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1701                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1702                 if (error)
1703                         return error;
1704                 unlock = 1;
1705         }
1706
1707         generic_fillattr(inode, stat);
1708         if (unlock)
1709                 gfs2_glock_dq_uninit(&gh);
1710
1711         return 0;
1712 }
1713
1714 static int gfs2_setxattr(struct dentry *dentry, const char *name,
1715                          const void *data, size_t size, int flags)
1716 {
1717         struct inode *inode = dentry->d_inode;
1718         struct gfs2_inode *ip = GFS2_I(inode);
1719         struct gfs2_holder gh;
1720         int ret;
1721
1722         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1723         ret = gfs2_glock_nq(&gh);
1724         if (ret == 0) {
1725                 ret = generic_setxattr(dentry, name, data, size, flags);
1726                 gfs2_glock_dq(&gh);
1727         }
1728         gfs2_holder_uninit(&gh);
1729         return ret;
1730 }
1731
1732 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1733                              void *data, size_t size)
1734 {
1735         struct inode *inode = dentry->d_inode;
1736         struct gfs2_inode *ip = GFS2_I(inode);
1737         struct gfs2_holder gh;
1738         int ret;
1739
1740         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1741         ret = gfs2_glock_nq(&gh);
1742         if (ret == 0) {
1743                 ret = generic_getxattr(dentry, name, data, size);
1744                 gfs2_glock_dq(&gh);
1745         }
1746         gfs2_holder_uninit(&gh);
1747         return ret;
1748 }
1749
1750 static int gfs2_removexattr(struct dentry *dentry, const char *name)
1751 {
1752         struct inode *inode = dentry->d_inode;
1753         struct gfs2_inode *ip = GFS2_I(inode);
1754         struct gfs2_holder gh;
1755         int ret;
1756
1757         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1758         ret = gfs2_glock_nq(&gh);
1759         if (ret == 0) {
1760                 ret = generic_removexattr(dentry, name);
1761                 gfs2_glock_dq(&gh);
1762         }
1763         gfs2_holder_uninit(&gh);
1764         return ret;
1765 }
1766
1767 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1768                        u64 start, u64 len)
1769 {
1770         struct gfs2_inode *ip = GFS2_I(inode);
1771         struct gfs2_holder gh;
1772         int ret;
1773
1774         ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1775         if (ret)
1776                 return ret;
1777
1778         mutex_lock(&inode->i_mutex);
1779
1780         ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1781         if (ret)
1782                 goto out;
1783
1784         if (gfs2_is_stuffed(ip)) {
1785                 u64 phys = ip->i_no_addr << inode->i_blkbits;
1786                 u64 size = i_size_read(inode);
1787                 u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1788                             FIEMAP_EXTENT_DATA_INLINE;
1789                 phys += sizeof(struct gfs2_dinode);
1790                 phys += start;
1791                 if (start + len > size)
1792                         len = size - start;
1793                 if (start < size)
1794                         ret = fiemap_fill_next_extent(fieinfo, start, phys,
1795                                                       len, flags);
1796                 if (ret == 1)
1797                         ret = 0;
1798         } else {
1799                 ret = __generic_block_fiemap(inode, fieinfo, start, len,
1800                                              gfs2_block_map);
1801         }
1802
1803         gfs2_glock_dq_uninit(&gh);
1804 out:
1805         mutex_unlock(&inode->i_mutex);
1806         return ret;
1807 }
1808
1809 const struct inode_operations gfs2_file_iops = {
1810         .permission = gfs2_permission,
1811         .setattr = gfs2_setattr,
1812         .getattr = gfs2_getattr,
1813         .setxattr = gfs2_setxattr,
1814         .getxattr = gfs2_getxattr,
1815         .listxattr = gfs2_listxattr,
1816         .removexattr = gfs2_removexattr,
1817         .fiemap = gfs2_fiemap,
1818         .get_acl = gfs2_get_acl,
1819 };
1820
1821 const struct inode_operations gfs2_dir_iops = {
1822         .create = gfs2_create,
1823         .lookup = gfs2_lookup,
1824         .link = gfs2_link,
1825         .unlink = gfs2_unlink,
1826         .symlink = gfs2_symlink,
1827         .mkdir = gfs2_mkdir,
1828         .rmdir = gfs2_unlink,
1829         .mknod = gfs2_mknod,
1830         .rename = gfs2_rename,
1831         .permission = gfs2_permission,
1832         .setattr = gfs2_setattr,
1833         .getattr = gfs2_getattr,
1834         .setxattr = gfs2_setxattr,
1835         .getxattr = gfs2_getxattr,
1836         .listxattr = gfs2_listxattr,
1837         .removexattr = gfs2_removexattr,
1838         .fiemap = gfs2_fiemap,
1839         .get_acl = gfs2_get_acl,
1840 };
1841
1842 const struct inode_operations gfs2_symlink_iops = {
1843         .readlink = generic_readlink,
1844         .follow_link = gfs2_follow_link,
1845         .put_link = gfs2_put_link,
1846         .permission = gfs2_permission,
1847         .setattr = gfs2_setattr,
1848         .getattr = gfs2_getattr,
1849         .setxattr = gfs2_setxattr,
1850         .getxattr = gfs2_getxattr,
1851         .listxattr = gfs2_listxattr,
1852         .removexattr = gfs2_removexattr,
1853         .fiemap = gfs2_fiemap,
1854         .get_acl = gfs2_get_acl,
1855 };
1856