linux/fs/gfs2/inode.c
<<
>>
Prefs
   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
  40struct gfs2_skip_data {
  41        u64 no_addr;
  42        int skipped;
  43        int non_block;
  44};
  45
  46static 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
  62static 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
  74struct 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
  85static 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
 105static 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
 140struct 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
 191fail_refresh:
 192        ip->i_iopen_gh.gh_gl->gl_object = NULL;
 193        gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 194fail_iopen:
 195        if (io_gl)
 196                gfs2_glock_put(io_gl);
 197fail_put:
 198        ip->i_gl->gl_object = NULL;
 199        gfs2_glock_put(ip->i_gl);
 200fail:
 201        iget_failed(inode);
 202        return ERR_PTR(error);
 203}
 204
 205struct 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
 240fail:
 241        gfs2_glock_dq_uninit(&i_gh);
 242        return error ? ERR_PTR(error) : inode;
 243fail_iput:
 244        iput(inode);
 245        goto fail;
 246}
 247
 248
 249struct 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
 282struct 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);
 318out:
 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
 335static 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
 367static 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
 388static 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
 406out_ipreserv:
 407        gfs2_inplace_release(dip);
 408out:
 409        return error;
 410}
 411
 412static 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
 445static 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
 514static 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
 544out_quota:
 545        gfs2_quota_unlock(dip);
 546        return error;
 547}
 548
 549static 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
 602fail_end_trans:
 603        gfs2_trans_end(sdp);
 604
 605fail_ipreserv:
 606        if (alloc_required)
 607                gfs2_inplace_release(dip);
 608
 609fail_quota_locks:
 610        gfs2_quota_unlock(dip);
 611
 612fail:
 613        return error;
 614}
 615
 616static 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
 632static 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
 651static 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
 750fail_gunlock2:
 751        gfs2_glock_dq_uninit(ghs + 1);
 752fail_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        }
 758fail:
 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
 774static 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
 791static 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
 821static 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
 926out_brelse:
 927        brelse(dibh);
 928out_end_trans:
 929        gfs2_trans_end(sdp);
 930out_ipres:
 931        if (alloc_required)
 932                gfs2_inplace_release(dip);
 933out_gunlock_q:
 934        if (alloc_required)
 935                gfs2_quota_unlock(dip);
 936out_gunlock:
 937        gfs2_glock_dq(ghs + 1);
 938out_child:
 939        gfs2_glock_dq(ghs);
 940out_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
 957static 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
 997static 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
1033static 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
1097out_end_trans:
1098        gfs2_trans_end(sdp);
1099out_gunlock:
1100        gfs2_glock_dq(ghs + 2);
1101out_rgrp:
1102        gfs2_glock_dq(ghs + 1);
1103out_child:
1104        gfs2_glock_dq(ghs);
1105out_parent:
1106        gfs2_holder_uninit(ghs + 2);
1107out_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
1122static 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
1144static 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
1158static 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
1175static 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
1219static 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
1427out_end_trans:
1428        gfs2_trans_end(sdp);
1429out_ipreserv:
1430        if (alloc_required)
1431                gfs2_inplace_release(ndip);
1432out_gunlock_q:
1433        if (alloc_required)
1434                gfs2_quota_unlock(ndip);
1435out_gunlock:
1436        while (x--) {
1437                gfs2_glock_dq(ghs + x);
1438                gfs2_holder_uninit(ghs + x);
1439        }
1440out_gunlock_r:
1441        if (r_gh.gh_gl)
1442                gfs2_glock_dq_uninit(&r_gh);
1443out:
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
1457static 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);
1493out:
1494        gfs2_glock_dq_uninit(&i_gh);
1495        nd_set_link(nd, buf);
1496        return NULL;
1497}
1498
1499static 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
1519int 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
1547static 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
1562int 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
1578static 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
1619out_end_trans:
1620        gfs2_trans_end(sdp);
1621out_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
1637static 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
1669out:
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
1691static 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
1714static 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 = gfs2_rs_alloc(ip);
1726                if (ret == 0)
1727                        ret = generic_setxattr(dentry, name, data, size, flags);
1728                gfs2_glock_dq(&gh);
1729        }
1730        gfs2_holder_uninit(&gh);
1731        return ret;
1732}
1733
1734static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1735                             void *data, size_t size)
1736{
1737        struct inode *inode = dentry->d_inode;
1738        struct gfs2_inode *ip = GFS2_I(inode);
1739        struct gfs2_holder gh;
1740        int ret;
1741
1742        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1743        ret = gfs2_glock_nq(&gh);
1744        if (ret == 0) {
1745                ret = generic_getxattr(dentry, name, data, size);
1746                gfs2_glock_dq(&gh);
1747        }
1748        gfs2_holder_uninit(&gh);
1749        return ret;
1750}
1751
1752static int gfs2_removexattr(struct dentry *dentry, const char *name)
1753{
1754        struct inode *inode = dentry->d_inode;
1755        struct gfs2_inode *ip = GFS2_I(inode);
1756        struct gfs2_holder gh;
1757        int ret;
1758
1759        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1760        ret = gfs2_glock_nq(&gh);
1761        if (ret == 0) {
1762                ret = gfs2_rs_alloc(ip);
1763                if (ret == 0)
1764                        ret = generic_removexattr(dentry, name);
1765                gfs2_glock_dq(&gh);
1766        }
1767        gfs2_holder_uninit(&gh);
1768        return ret;
1769}
1770
1771static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1772                       u64 start, u64 len)
1773{
1774        struct gfs2_inode *ip = GFS2_I(inode);
1775        struct gfs2_holder gh;
1776        int ret;
1777
1778        ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
1779        if (ret)
1780                return ret;
1781
1782        mutex_lock(&inode->i_mutex);
1783
1784        ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
1785        if (ret)
1786                goto out;
1787
1788        if (gfs2_is_stuffed(ip)) {
1789                u64 phys = ip->i_no_addr << inode->i_blkbits;
1790                u64 size = i_size_read(inode);
1791                u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
1792                            FIEMAP_EXTENT_DATA_INLINE;
1793                phys += sizeof(struct gfs2_dinode);
1794                phys += start;
1795                if (start + len > size)
1796                        len = size - start;
1797                if (start < size)
1798                        ret = fiemap_fill_next_extent(fieinfo, start, phys,
1799                                                      len, flags);
1800                if (ret == 1)
1801                        ret = 0;
1802        } else {
1803                ret = __generic_block_fiemap(inode, fieinfo, start, len,
1804                                             gfs2_block_map);
1805        }
1806
1807        gfs2_glock_dq_uninit(&gh);
1808out:
1809        mutex_unlock(&inode->i_mutex);
1810        return ret;
1811}
1812
1813const struct inode_operations gfs2_file_iops = {
1814        .permission = gfs2_permission,
1815        .setattr = gfs2_setattr,
1816        .getattr = gfs2_getattr,
1817        .setxattr = gfs2_setxattr,
1818        .getxattr = gfs2_getxattr,
1819        .listxattr = gfs2_listxattr,
1820        .removexattr = gfs2_removexattr,
1821        .fiemap = gfs2_fiemap,
1822        .get_acl = gfs2_get_acl,
1823};
1824
1825const struct inode_operations gfs2_dir_iops = {
1826        .create = gfs2_create,
1827        .lookup = gfs2_lookup,
1828        .link = gfs2_link,
1829        .unlink = gfs2_unlink,
1830        .symlink = gfs2_symlink,
1831        .mkdir = gfs2_mkdir,
1832        .rmdir = gfs2_unlink,
1833        .mknod = gfs2_mknod,
1834        .rename = gfs2_rename,
1835        .permission = gfs2_permission,
1836        .setattr = gfs2_setattr,
1837        .getattr = gfs2_getattr,
1838        .setxattr = gfs2_setxattr,
1839        .getxattr = gfs2_getxattr,
1840        .listxattr = gfs2_listxattr,
1841        .removexattr = gfs2_removexattr,
1842        .fiemap = gfs2_fiemap,
1843        .get_acl = gfs2_get_acl,
1844};
1845
1846const struct inode_operations gfs2_symlink_iops = {
1847        .readlink = generic_readlink,
1848        .follow_link = gfs2_follow_link,
1849        .put_link = gfs2_put_link,
1850        .permission = gfs2_permission,
1851        .setattr = gfs2_setattr,
1852        .getattr = gfs2_getattr,
1853        .setxattr = gfs2_setxattr,
1854        .getxattr = gfs2_getxattr,
1855        .listxattr = gfs2_listxattr,
1856        .removexattr = gfs2_removexattr,
1857        .fiemap = gfs2_fiemap,
1858        .get_acl = gfs2_get_acl,
1859};
1860
1861
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.