fs/gfs2/inode.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2005 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 v.2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/posix_acl.h>
  16 #include <linux/sort.h>
  17 #include <linux/gfs2_ondisk.h>
  18 #include <linux/crc32.h>
  19 #include <asm/semaphore.h>
  20
  21 #include "gfs2.h"
  22 #include "lm_interface.h"
  23 #include "incore.h"
  24 #include "acl.h"
  25 #include "bmap.h"
  26 #include "dir.h"
  27 #include "eattr.h"
  28 #include "glock.h"
  29 #include "glops.h"
  30 #include "inode.h"
  31 #include "log.h"
  32 #include "meta_io.h"
  33 #include "ops_address.h"
  34 #include "ops_file.h"
  35 #include "ops_inode.h"
  36 #include "quota.h"
  37 #include "rgrp.h"
  38 #include "trans.h"
  39 #include "unlinked.h"
  40 #include "util.h"
  41
  42 /**
  43  * inode_attr_in - Copy attributes from the dinode into the VFS inode
  44  * @ip: The GFS2 inode (with embedded disk inode data)
  45  * @inode:  The Linux VFS inode
  46  *
  47  */
  48
  49 static void inode_attr_in(struct gfs2_inode *ip, struct inode *inode)
  50 {
  51         inode->i_ino = ip->i_num.no_formal_ino;
  52
  53         switch (ip->i_di.di_mode & S_IFMT) {
  54         case S_IFBLK:
  55         case S_IFCHR:
  56                 inode->i_rdev = MKDEV(ip->i_di.di_major, ip->i_di.di_minor);
  57                 break;
  58         default:
  59                 inode->i_rdev = 0;
  60                 break;
  61         };
  62
  63         inode->i_mode = ip->i_di.di_mode;
  64         inode->i_nlink = ip->i_di.di_nlink;
  65         inode->i_uid = ip->i_di.di_uid;
  66         inode->i_gid = ip->i_di.di_gid;
  67         i_size_write(inode, ip->i_di.di_size);
  68         inode->i_atime.tv_sec = ip->i_di.di_atime;
  69         inode->i_mtime.tv_sec = ip->i_di.di_mtime;
  70         inode->i_ctime.tv_sec = ip->i_di.di_ctime;
  71         inode->i_atime.tv_nsec = 0;
  72         inode->i_mtime.tv_nsec = 0;
  73         inode->i_ctime.tv_nsec = 0;
  74         inode->i_blksize = PAGE_SIZE;
  75         inode->i_blocks = ip->i_di.di_blocks <<
  76                 (ip->i_sbd->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
  77
  78         if (ip->i_di.di_flags & GFS2_DIF_IMMUTABLE)
  79                 inode->i_flags |= S_IMMUTABLE;
  80         else
  81                 inode->i_flags &= ~S_IMMUTABLE;
  82
  83         if (ip->i_di.di_flags & GFS2_DIF_APPENDONLY)
  84                 inode->i_flags |= S_APPEND;
  85         else
  86                 inode->i_flags &= ~S_APPEND;
  87 }
  88
  89 /**
  90  * gfs2_inode_attr_in - Copy attributes from the dinode into the VFS inode
  91  * @ip: The GFS2 inode (with embedded disk inode data)
  92  *
  93  */
  94
  95 void gfs2_inode_attr_in(struct gfs2_inode *ip)
  96 {
  97         struct inode *inode;
  98
  99         inode = gfs2_ip2v_lookup(ip);
 100         if (inode) {
 101                 inode_attr_in(ip, inode);
 102                 iput(inode);
 103         }
 104 }
 105
 106 /**
 107  * gfs2_inode_attr_out - Copy attributes from VFS inode into the dinode
 108  * @ip: The GFS2 inode
 109  *
 110  * Only copy out the attributes that we want the VFS layer
 111  * to be able to modify.
 112  */
 113
 114 void gfs2_inode_attr_out(struct gfs2_inode *ip)
 115 {
 116         struct inode *inode = ip->i_vnode;
 117
 118         gfs2_assert_withdraw(ip->i_sbd,
 119                 (ip->i_di.di_mode & S_IFMT) == (inode->i_mode & S_IFMT));
 120         ip->i_di.di_mode = inode->i_mode;
 121         ip->i_di.di_uid = inode->i_uid;
 122         ip->i_di.di_gid = inode->i_gid;
 123         ip->i_di.di_atime = inode->i_atime.tv_sec;
 124         ip->i_di.di_mtime = inode->i_mtime.tv_sec;
 125         ip->i_di.di_ctime = inode->i_ctime.tv_sec;
 126 }
 127
 128 /**
 129  * gfs2_ip2v_lookup - Get the struct inode for a struct gfs2_inode
 130  * @ip: the struct gfs2_inode to get the struct inode for
 131  *
 132  * Returns: A VFS inode, or NULL if none
 133  */
 134
 135 struct inode *gfs2_ip2v_lookup(struct gfs2_inode *ip)
 136 {
 137         struct inode *inode = NULL;
 138
 139         gfs2_assert_warn(ip->i_sbd, test_bit(GIF_MIN_INIT, &ip->i_flags));
 140
 141         spin_lock(&ip->i_spin);
 142         if (ip->i_vnode)
 143                 inode = igrab(ip->i_vnode);
 144         spin_unlock(&ip->i_spin);
 145
 146         return inode;
 147 }
 148
 149 /**
 150  * gfs2_ip2v - Get/Create a struct inode for a struct gfs2_inode
 151  * @ip: the struct gfs2_inode to get the struct inode for
 152  *
 153  * Returns: A VFS inode, or NULL if no mem
 154  */
 155
 156 struct inode *gfs2_ip2v(struct gfs2_inode *ip)
 157 {
 158         struct inode *inode, *tmp;
 159
 160         inode = gfs2_ip2v_lookup(ip);
 161         if (inode)
 162                 return inode;
 163
 164         tmp = new_inode(ip->i_sbd->sd_vfs);
 165         if (!tmp)
 166                 return NULL;
 167
 168         inode_attr_in(ip, tmp);
 169
 170         if (S_ISREG(ip->i_di.di_mode)) {
 171                 tmp->i_op = &gfs2_file_iops;
 172                 tmp->i_fop = &gfs2_file_fops;
 173                 tmp->i_mapping->a_ops = &gfs2_file_aops;
 174         } else if (S_ISDIR(ip->i_di.di_mode)) {
 175                 tmp->i_op = &gfs2_dir_iops;
 176                 tmp->i_fop = &gfs2_dir_fops;
 177         } else if (S_ISLNK(ip->i_di.di_mode)) {
 178                 tmp->i_op = &gfs2_symlink_iops;
 179         } else {
 180                 tmp->i_op = &gfs2_dev_iops;
 181                 init_special_inode(tmp, tmp->i_mode, tmp->i_rdev);
 182         }
 183
 184         tmp->u.generic_ip = NULL;
 185
 186         for (;;) {
 187                 spin_lock(&ip->i_spin);
 188                 if (!ip->i_vnode)
 189                         break;
 190                 inode = igrab(ip->i_vnode);
 191                 spin_unlock(&ip->i_spin);
 192
 193                 if (inode) {
 194                         iput(tmp);
 195                         return inode;
 196                 }
 197                 yield();
 198         }
 199
 200         inode = tmp;
 201
 202         gfs2_inode_hold(ip);
 203         ip->i_vnode = inode;
 204         inode->u.generic_ip = ip;
 205
 206         spin_unlock(&ip->i_spin);
 207
 208         insert_inode_hash(inode);
 209
 210         return inode;
 211 }
 212
 213 static int iget_test(struct inode *inode, void *opaque)
 214 {
 215         struct gfs2_inode *ip = inode->u.generic_ip;
 216         struct gfs2_inum *inum = (struct gfs2_inum *)opaque;
 217
 218         if (ip && ip->i_num.no_addr == inum->no_addr)
 219                 return 1;
 220
 221         return 0;
 222 }
 223
 224 struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum *inum)
 225 {
 226         return ilookup5(sb, (unsigned long)inum->no_formal_ino,
 227                         iget_test, inum);
 228 }
 229
 230 void gfs2_inode_min_init(struct gfs2_inode *ip, unsigned int type)
 231 {
 232         if (!test_and_set_bit(GIF_MIN_INIT, &ip->i_flags)) {
 233                 ip->i_di.di_nlink = 1;
 234                 ip->i_di.di_mode = DT2IF(type);
 235         }
 236 }
 237
 238 /**
 239  * gfs2_inode_refresh - Refresh the incore copy of the dinode
 240  * @ip: The GFS2 inode
 241  *
 242  * Returns: errno
 243  */
 244
 245 int gfs2_inode_refresh(struct gfs2_inode *ip)
 246 {
 247         struct buffer_head *dibh;
 248         int error;
 249
 250         error = gfs2_meta_inode_buffer(ip, &dibh);
 251         if (error)
 252                 return error;
 253
 254         if (gfs2_metatype_check(ip->i_sbd, dibh, GFS2_METATYPE_DI)) {
 255                 brelse(dibh);
 256                 return -EIO;
 257         }
 258
 259         gfs2_dinode_in(&ip->i_di, dibh->b_data);
 260         set_bit(GIF_MIN_INIT, &ip->i_flags);
 261
 262         brelse(dibh);
 263
 264         if (ip->i_num.no_addr != ip->i_di.di_num.no_addr) {
 265                 if (gfs2_consist_inode(ip))
 266                         gfs2_dinode_print(&ip->i_di);
 267                 return -EIO;
 268         }
 269         if (ip->i_num.no_formal_ino != ip->i_di.di_num.no_formal_ino)
 270                 return -ESTALE;
 271
 272         ip->i_vn = ip->i_gl->gl_vn;
 273
 274         return 0;
 275 }
 276
 277 /**
 278  * inode_create - create a struct gfs2_inode
 279  * @i_gl: The glock covering the inode
 280  * @inum: The inode number
 281  * @io_gl: the iopen glock to acquire/hold (using holder in new gfs2_inode)
 282  * @io_state: the state the iopen glock should be acquired in
 283  * @ipp: pointer to put the returned inode in
 284  *
 285  * Returns: errno
 286  */
 287
 288 static int inode_create(struct gfs2_glock *i_gl, const struct gfs2_inum *inum,
 289                         struct gfs2_glock *io_gl, unsigned int io_state,
 290                         struct gfs2_inode **ipp)
 291 {
 292         struct gfs2_sbd *sdp = i_gl->gl_sbd;
 293         struct gfs2_inode *ip;
 294         int error = 0;
 295
 296         ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
 297         if (!ip)
 298                 return -ENOMEM;
 299         memset(ip, 0, sizeof(struct gfs2_inode));
 300
 301         ip->i_num = *inum;
 302
 303         atomic_set(&ip->i_count, 1);
 304
 305         ip->i_vn = i_gl->gl_vn - 1;
 306
 307         ip->i_gl = i_gl;
 308         ip->i_sbd = sdp;
 309
 310         spin_lock_init(&ip->i_spin);
 311         init_rwsem(&ip->i_rw_mutex);
 312
 313         ip->i_greedy = gfs2_tune_get(sdp, gt_greedy_default);
 314
 315         error = gfs2_glock_nq_init(io_gl,
 316                                    io_state, GL_LOCAL_EXCL | GL_EXACT,
 317                                    &ip->i_iopen_gh);
 318         if (error)
 319                 goto fail;
 320         ip->i_iopen_gh.gh_owner = NULL;
 321
 322         spin_lock(&io_gl->gl_spin);
 323         gfs2_glock_hold(i_gl);
 324         io_gl->gl_object = i_gl;
 325         spin_unlock(&io_gl->gl_spin);
 326
 327         gfs2_glock_hold(i_gl);
 328         i_gl->gl_object = ip;
 329
 330         atomic_inc(&sdp->sd_inode_count);
 331
 332         *ipp = ip;
 333
 334         return 0;
 335
 336  fail:
 337         gfs2_meta_cache_flush(ip);
 338         kmem_cache_free(gfs2_inode_cachep, ip);
 339         *ipp = NULL;
 340
 341         return error;
 342 }
 343
 344 /**
 345  * gfs2_inode_get - Create or get a reference on an inode
 346  * @i_gl: The glock covering the inode
 347  * @inum: The inode number
 348  * @create:
 349  * @ipp: pointer to put the returned inode in
 350  *
 351  * Returns: errno
 352  */
 353
 354 int gfs2_inode_get(struct gfs2_glock *i_gl, const struct gfs2_inum *inum,
 355                    int create, struct gfs2_inode **ipp)
 356 {
 357         struct gfs2_sbd *sdp = i_gl->gl_sbd;
 358         struct gfs2_glock *io_gl;
 359         int error = 0;
 360
 361         gfs2_glmutex_lock(i_gl);
 362
 363         *ipp = i_gl->gl_object;
 364         if (*ipp) {
 365                 error = -ESTALE;
 366                 if ((*ipp)->i_num.no_formal_ino != inum->no_formal_ino)
 367                         goto out;
 368                 atomic_inc(&(*ipp)->i_count);
 369                 error = 0;
 370                 goto out;
 371         }
 372
 373         if (!create)
 374                 goto out;
 375
 376         error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_iopen_glops,
 377                                CREATE, &io_gl);
 378         if (!error) {
 379                 error = inode_create(i_gl, inum, io_gl, LM_ST_SHARED, ipp);
 380                 gfs2_glock_put(io_gl);
 381         }
 382
 383  out:
 384         gfs2_glmutex_unlock(i_gl);
 385
 386         return error;
 387 }
 388
 389 void gfs2_inode_hold(struct gfs2_inode *ip)
 390 {
 391         gfs2_assert(ip->i_sbd, atomic_read(&ip->i_count) > 0);
 392         atomic_inc(&ip->i_count);
 393 }
 394
 395 void gfs2_inode_put(struct gfs2_inode *ip)
 396 {
 397         gfs2_assert(ip->i_sbd, atomic_read(&ip->i_count) > 0);
 398         atomic_dec(&ip->i_count);
 399 }
 400
 401 void gfs2_inode_destroy(struct gfs2_inode *ip)
 402 {
 403         struct gfs2_sbd *sdp = ip->i_sbd;
 404         struct gfs2_glock *io_gl = ip->i_iopen_gh.gh_gl;
 405         struct gfs2_glock *i_gl = ip->i_gl;
 406
 407         gfs2_assert_warn(sdp, !atomic_read(&ip->i_count));
 408         gfs2_assert(sdp, io_gl->gl_object == i_gl);
 409
 410         spin_lock(&io_gl->gl_spin);
 411         io_gl->gl_object = NULL;
 412         spin_unlock(&io_gl->gl_spin);
 413         gfs2_glock_put(i_gl);
 414
 415         gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 416
 417         gfs2_meta_cache_flush(ip);
 418         kmem_cache_free(gfs2_inode_cachep, ip);
 419
 420         i_gl->gl_object = NULL;
 421         gfs2_glock_put(i_gl);
 422
 423         atomic_dec(&sdp->sd_inode_count);
 424 }
 425
 426 static int dinode_dealloc(struct gfs2_inode *ip, struct gfs2_unlinked *ul)
 427 {
 428         struct gfs2_sbd *sdp = ip->i_sbd;
 429         struct gfs2_alloc *al;
 430         struct gfs2_rgrpd *rgd;
 431         int error;
 432
 433         if (ip->i_di.di_blocks != 1) {
 434                 if (gfs2_consist_inode(ip))
 435                         gfs2_dinode_print(&ip->i_di);
 436                 return -EIO;
 437         }
 438
 439         al = gfs2_alloc_get(ip);
 440
 441         error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 442         if (error)
 443                 goto out;
 444
 445         error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
 446         if (error)
 447                 goto out_qs;
 448
 449         rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
 450         if (!rgd) {
 451                 gfs2_consist_inode(ip);
 452                 error = -EIO;
 453                 goto out_rindex_relse;
 454         }
 455
 456         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
 457                                    &al->al_rgd_gh);
 458         if (error)
 459                 goto out_rindex_relse;
 460
 461         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_UNLINKED +
 462                                  RES_STATFS + RES_QUOTA, 1);
 463         if (error)
 464                 goto out_rg_gunlock;
 465
 466         gfs2_trans_add_gl(ip->i_gl);
 467
 468         gfs2_free_di(rgd, ip);
 469
 470         error = gfs2_unlinked_ondisk_rm(sdp, ul);
 471
 472         gfs2_trans_end(sdp);
 473         clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 474
 475  out_rg_gunlock:
 476         gfs2_glock_dq_uninit(&al->al_rgd_gh);
 477
 478  out_rindex_relse:
 479         gfs2_glock_dq_uninit(&al->al_ri_gh);
 480
 481  out_qs:
 482         gfs2_quota_unhold(ip);
 483
 484  out:
 485         gfs2_alloc_put(ip);
 486
 487         return error;
 488 }
 489
 490 /**
 491  * inode_dealloc - Deallocate all on-disk blocks for an inode (dinode)
 492  * @sdp: the filesystem
 493  * @inum: the inode number to deallocate
 494  * @io_gh: a holder for the iopen glock for this inode
 495  *
 496  * Returns: errno
 497  */
 498
 499 static int inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul,
 500                          struct gfs2_holder *io_gh)
 501 {
 502         struct gfs2_inode *ip;
 503         struct gfs2_holder i_gh;
 504         int error;
 505
 506         error = gfs2_glock_nq_num(sdp,
 507                                   ul->ul_ut.ut_inum.no_addr, &gfs2_inode_glops,
 508                                   LM_ST_EXCLUSIVE, 0, &i_gh);
 509         if (error)
 510                 return error;
 511
 512         /* We reacquire the iopen lock here to avoid a race with the NFS server
 513            calling gfs2_read_inode() with the inode number of a inode we're in
 514            the process of deallocating.  And we can't keep our hold on the lock
 515            from inode_dealloc_init() for deadlock reasons. */
 516
 517         gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY, io_gh);
 518         error = gfs2_glock_nq(io_gh);
 519         switch (error) {
 520         case 0:
 521                 break;
 522         case GLR_TRYFAILED:
 523                 error = 1;
 524         default:
 525                 goto out;
 526         }
 527
 528         gfs2_assert_warn(sdp, !i_gh.gh_gl->gl_object);
 529         error = inode_create(i_gh.gh_gl, &ul->ul_ut.ut_inum, io_gh->gh_gl,
 530                              LM_ST_EXCLUSIVE, &ip);
 531
 532         gfs2_glock_dq(io_gh);
 533
 534         if (error)
 535                 goto out;
 536
 537         error = gfs2_inode_refresh(ip);
 538         if (error)
 539                 goto out_iput;
 540
 541         if (ip->i_di.di_nlink) {
 542                 if (gfs2_consist_inode(ip))
 543                         gfs2_dinode_print(&ip->i_di);
 544                 error = -EIO;
 545                 goto out_iput;
 546         }
 547
 548         if (S_ISDIR(ip->i_di.di_mode) &&
 549             (ip->i_di.di_flags & GFS2_DIF_EXHASH)) {
 550                 error = gfs2_dir_exhash_dealloc(ip);
 551                 if (error)
 552                         goto out_iput;
 553         }
 554
 555         if (ip->i_di.di_eattr) {
 556                 error = gfs2_ea_dealloc(ip);
 557                 if (error)
 558                         goto out_iput;
 559         }
 560
 561         if (!gfs2_is_stuffed(ip)) {
 562                 error = gfs2_file_dealloc(ip);
 563                 if (error)
 564                         goto out_iput;
 565         }
 566
 567         error = dinode_dealloc(ip, ul);
 568         if (error)
 569                 goto out_iput;
 570
 571  out_iput:
 572         gfs2_glmutex_lock(i_gh.gh_gl);
 573         gfs2_inode_put(ip);
 574         gfs2_inode_destroy(ip);
 575         gfs2_glmutex_unlock(i_gh.gh_gl);
 576
 577  out:
 578         gfs2_glock_dq_uninit(&i_gh);
 579
 580         return error;
 581 }
 582
 583 /**
 584  * try_inode_dealloc - Try to deallocate an inode and all its blocks
 585  * @sdp: the filesystem
 586  *
 587  * Returns: 0 on success, -errno on error, 1 on busy (inode open)
 588  */
 589
 590 static int try_inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
 591 {
 592         struct gfs2_holder io_gh;
 593         int error = 0;
 594
 595         gfs2_try_toss_inode(sdp, &ul->ul_ut.ut_inum);
 596
 597         error = gfs2_glock_nq_num(sdp,
 598                                   ul->ul_ut.ut_inum.no_addr, &gfs2_iopen_glops,
 599                                   LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB, &io_gh);
 600         switch (error) {
 601         case 0:
 602                 break;
 603         case GLR_TRYFAILED:
 604                 return 1;
 605         default:
 606                 return error;
 607         }
 608
 609         gfs2_glock_dq(&io_gh);
 610         error = inode_dealloc(sdp, ul, &io_gh);
 611         gfs2_holder_uninit(&io_gh);
 612
 613         return error;
 614 }
 615
 616 static int inode_dealloc_uninit(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
 617 {
 618         struct gfs2_rgrpd *rgd;
 619         struct gfs2_holder ri_gh, rgd_gh;
 620         int error;
 621
 622         error = gfs2_rindex_hold(sdp, &ri_gh);
 623         if (error)
 624                 return error;
 625
 626         rgd = gfs2_blk2rgrpd(sdp, ul->ul_ut.ut_inum.no_addr);
 627         if (!rgd) {
 628                 gfs2_consist(sdp);
 629                 error = -EIO;
 630                 goto out;
 631         }
 632
 633         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rgd_gh);
 634         if (error)
 635                 goto out;
 636
 637         error = gfs2_trans_begin(sdp,
 638                                  RES_RG_BIT + RES_UNLINKED + RES_STATFS,
 639                                  0);
 640         if (error)
 641                 goto out_gunlock;
 642
 643         gfs2_free_uninit_di(rgd, ul->ul_ut.ut_inum.no_addr);
 644         gfs2_unlinked_ondisk_rm(sdp, ul);
 645
 646         gfs2_trans_end(sdp);
 647
 648  out_gunlock:
 649         gfs2_glock_dq_uninit(&rgd_gh);
 650  out:
 651         gfs2_glock_dq_uninit(&ri_gh);
 652
 653         return error;
 654 }
 655
 656 int gfs2_inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
 657 {
 658         if (ul->ul_ut.ut_flags & GFS2_UTF_UNINIT)
 659                 return inode_dealloc_uninit(sdp, ul);
 660         else
 661                 return try_inode_dealloc(sdp, ul);
 662 }
 663
 664 /**
 665  * gfs2_change_nlink - Change nlink count on inode
 666  * @ip: The GFS2 inode
 667  * @diff: The change in the nlink count required
 668  *
 669  * Returns: errno
 670  */
 671
 672 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
 673 {
 674         struct buffer_head *dibh;
 675         uint32_t nlink;
 676         int error;
 677
 678         nlink = ip->i_di.di_nlink + diff;
 679
 680         /* If we are reducing the nlink count, but the new value ends up being
 681            bigger than the old one, we must have underflowed. */
 682         if (diff < 0 && nlink > ip->i_di.di_nlink) {
 683                 if (gfs2_consist_inode(ip))
 684                         gfs2_dinode_print(&ip->i_di);
 685                 return -EIO;
 686         }
 687
 688         error = gfs2_meta_inode_buffer(ip, &dibh);
 689         if (error)
 690                 return error;
 691
 692         ip->i_di.di_nlink = nlink;
 693         ip->i_di.di_ctime = get_seconds();
 694
 695         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 696         gfs2_dinode_out(&ip->i_di, dibh->b_data);
 697         brelse(dibh);
 698
 699         return 0;
 700 }
 701
 702 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 703 {
 704         struct qstr qstr;
 705         gfs2_str2qstr(&qstr, name);
 706         return gfs2_lookupi(dip, &qstr, 1, NULL);
 707 }
 708
 709
 710 /**
 711  * gfs2_lookupi - Look up a filename in a directory and return its inode
 712  * @d_gh: An initialized holder for the directory glock
 713  * @name: The name of the inode to look for
 714  * @is_root: If 1, ignore the caller's permissions
 715  * @i_gh: An uninitialized holder for the new inode glock
 716  *
 717  * There will always be a vnode (Linux VFS inode) for the d_gh inode unless
 718  * @is_root is true.
 719  *
 720  * Returns: errno
 721  */
 722
 723 struct inode *gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
 724                            struct nameidata *nd)
 725
 726 {
 727         struct super_block *sb = dir->i_sb;
 728         struct gfs2_inode *ipp;
 729         struct gfs2_inode *dip = dir->u.generic_ip;
 730         struct gfs2_sbd *sdp = dip->i_sbd;
 731         struct gfs2_holder d_gh;
 732         struct gfs2_inum inum;
 733         unsigned int type;
 734         struct gfs2_glock *gl;
 735         int error = 0;
 736         struct inode *inode = NULL;
 737
 738         if (!name->len || name->len > GFS2_FNAMESIZE)
 739                 return ERR_PTR(-ENAMETOOLONG);
 740
 741         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 742             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 743              dir == sb->s_root->d_inode)) {
 744                 gfs2_inode_hold(dip);
 745                 ipp = dip;
 746                 goto done;
 747         }
 748
 749         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 750         if (error)
 751                 return ERR_PTR(error);
 752
 753         if (!is_root) {
 754                 error = gfs2_repermission(dip->i_vnode, MAY_EXEC, NULL);
 755                 if (error)
 756                         goto out;
 757         }
 758
 759         error = gfs2_dir_search(dir, name, &inum, &type);
 760         if (error)
 761                 goto out;
 762
 763         error = gfs2_glock_get(sdp, inum.no_addr, &gfs2_inode_glops,
 764                                CREATE, &gl);
 765         if (error)
 766                 goto out;
 767
 768         error = gfs2_inode_get(gl, &inum, CREATE, &ipp);
 769         if (!error)
 770                 gfs2_inode_min_init(ipp, type);
 771
 772         gfs2_glock_put(gl);
 773
 774 out:
 775         gfs2_glock_dq_uninit(&d_gh);
 776 done:
 777         if (error == -ENOENT)
 778                 return NULL;
 779         if (error == 0) {
 780                 inode = gfs2_ip2v(ipp);
 781                 gfs2_inode_put(ipp);
 782                 if (!inode)
 783                         return ERR_PTR(-ENOMEM);
 784                 return inode;
 785         }
 786         return ERR_PTR(error);
 787 }
 788
 789 static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
 790 {
 791         struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
 792         struct buffer_head *bh;
 793         struct gfs2_inum_range ir;
 794         int error;
 795
 796         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
 797         if (error)
 798                 return error;
 799         mutex_lock(&sdp->sd_inum_mutex);
 800
 801         error = gfs2_meta_inode_buffer(ip, &bh);
 802         if (error) {
 803                 mutex_unlock(&sdp->sd_inum_mutex);
 804                 gfs2_trans_end(sdp);
 805                 return error;
 806         }
 807
 808         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 809
 810         if (ir.ir_length) {
 811                 *formal_ino = ir.ir_start++;
 812                 ir.ir_length--;
 813                 gfs2_trans_add_bh(ip->i_gl, bh, 1);
 814                 gfs2_inum_range_out(&ir,
 815                                     bh->b_data + sizeof(struct gfs2_dinode));
 816                 brelse(bh);
 817                 mutex_unlock(&sdp->sd_inum_mutex);
 818                 gfs2_trans_end(sdp);
 819                 return 0;
 820         }
 821
 822         brelse(bh);
 823
 824         mutex_unlock(&sdp->sd_inum_mutex);
 825         gfs2_trans_end(sdp);
 826
 827         return 1;
 828 }
 829
 830 static int pick_formal_ino_2(struct gfs2_sbd *sdp, uint64_t *formal_ino)
 831 {
 832         struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
 833         struct gfs2_inode *m_ip = sdp->sd_inum_inode->u.generic_ip;
 834         struct gfs2_holder gh;
 835         struct buffer_head *bh;
 836         struct gfs2_inum_range ir;
 837         int error;
 838
 839         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 840         if (error)
 841                 return error;
 842
 843         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
 844         if (error)
 845                 goto out;
 846         mutex_lock(&sdp->sd_inum_mutex);
 847
 848         error = gfs2_meta_inode_buffer(ip, &bh);
 849         if (error)
 850                 goto out_end_trans;
 851
 852         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 853
 854         if (!ir.ir_length) {
 855                 struct buffer_head *m_bh;
 856                 uint64_t x, y;
 857
 858                 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 859                 if (error)
 860                         goto out_brelse;
 861
 862                 x = *(uint64_t *)(m_bh->b_data + sizeof(struct gfs2_dinode));
 863                 x = y = be64_to_cpu(x);
 864                 ir.ir_start = x;
 865                 ir.ir_length = GFS2_INUM_QUANTUM;
 866                 x += GFS2_INUM_QUANTUM;
 867                 if (x < y)
 868                         gfs2_consist_inode(m_ip);
 869                 x = cpu_to_be64(x);
 870                 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
 871                 *(uint64_t *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = x;
 872
 873                 brelse(m_bh);
 874         }
 875
 876         *formal_ino = ir.ir_start++;
 877         ir.ir_length--;
 878
 879         gfs2_trans_add_bh(ip->i_gl, bh, 1);
 880         gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 881
 882  out_brelse:
 883         brelse(bh);
 884
 885  out_end_trans:
 886         mutex_unlock(&sdp->sd_inum_mutex);
 887         gfs2_trans_end(sdp);
 888
 889  out:
 890         gfs2_glock_dq_uninit(&gh);
 891
 892         return error;
 893 }
 894
 895 static int pick_formal_ino(struct gfs2_sbd *sdp, uint64_t *inum)
 896 {
 897         int error;
 898
 899         error = pick_formal_ino_1(sdp, inum);
 900         if (error <= 0)
 901                 return error;
 902
 903         error = pick_formal_ino_2(sdp, inum);
 904
 905         return error;
 906 }
 907
 908 /**
 909  * create_ok - OK to create a new on-disk inode here?
 910  * @dip:  Directory in which dinode is to be created
 911  * @name:  Name of new dinode
 912  * @mode:
 913  *
 914  * Returns: errno
 915  */
 916
 917 static int create_ok(struct gfs2_inode *dip, struct qstr *name,
 918                      unsigned int mode)
 919 {
 920         int error;
 921
 922         error = gfs2_repermission(dip->i_vnode, MAY_WRITE | MAY_EXEC, NULL);
 923         if (error)
 924                 return error;
 925
 926         /*  Don't create entries in an unlinked directory  */
 927         if (!dip->i_di.di_nlink)
 928                 return -EPERM;
 929
 930         error = gfs2_dir_search(dip->i_vnode, name, NULL, NULL);
 931         switch (error) {
 932         case -ENOENT:
 933                 error = 0;
 934                 break;
 935         case 0:
 936                 return -EEXIST;
 937         default:
 938                 return error;
 939         }
 940
 941         if (dip->i_di.di_entries == (uint32_t)-1)
 942                 return -EFBIG;
 943         if (S_ISDIR(mode) && dip->i_di.di_nlink == (uint32_t)-1)
 944                 return -EMLINK;
 945
 946         return 0;
 947 }
 948
 949 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
 950                                unsigned int *uid, unsigned int *gid)
 951 {
 952         if (dip->i_sbd->sd_args.ar_suiddir &&
 953             (dip->i_di.di_mode & S_ISUID) &&
 954             dip->i_di.di_uid) {
 955                 if (S_ISDIR(*mode))
 956                         *mode |= S_ISUID;
 957                 else if (dip->i_di.di_uid != current->fsuid)
 958                         *mode &= ~07111;
 959                 *uid = dip->i_di.di_uid;
 960         } else
 961                 *uid = current->fsuid;
 962
 963         if (dip->i_di.di_mode & S_ISGID) {
 964                 if (S_ISDIR(*mode))
 965                         *mode |= S_ISGID;
 966                 *gid = dip->i_di.di_gid;
 967         } else
 968                 *gid = current->fsgid;
 969 }
 970
 971 static int alloc_dinode(struct gfs2_inode *dip, struct gfs2_unlinked *ul)
 972 {
 973         struct gfs2_sbd *sdp = dip->i_sbd;
 974         int error;
 975
 976         gfs2_alloc_get(dip);
 977
 978         dip->i_alloc.al_requested = RES_DINODE;
 979         error = gfs2_inplace_reserve(dip);
 980         if (error)
 981                 goto out;
 982
 983         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_UNLINKED +
 984                                  RES_STATFS, 0);
 985         if (error)
 986                 goto out_ipreserv;
 987
 988         ul->ul_ut.ut_inum.no_addr = gfs2_alloc_di(dip);
 989
 990         ul->ul_ut.ut_flags = GFS2_UTF_UNINIT;
 991         error = gfs2_unlinked_ondisk_add(sdp, ul);
 992
 993         gfs2_trans_end(sdp);
 994
 995  out_ipreserv:
 996         gfs2_inplace_release(dip);
 997
 998  out:
 999         gfs2_alloc_put(dip);
1000
1001         return error;
1002 }
1003
1004 /**
1005  * init_dinode - Fill in a new dinode structure
1006  * @dip: the directory this inode is being created in
1007  * @gl: The glock covering the new inode
1008  * @inum: the inode number
1009  * @mode: the file permissions
1010  * @uid:
1011  * @gid:
1012  *
1013  */
1014
1015 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
1016                         struct gfs2_inum *inum, unsigned int mode,
1017                         unsigned int uid, unsigned int gid)
1018 {
1019         struct gfs2_sbd *sdp = dip->i_sbd;
1020         struct gfs2_dinode *di;
1021         struct buffer_head *dibh;
1022
1023         dibh = gfs2_meta_new(gl, inum->no_addr);
1024         gfs2_trans_add_bh(gl, dibh, 1);
1025         gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
1026         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1027         di = (struct gfs2_dinode *)dibh->b_data;
1028
1029         di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
1030         di->di_num.no_addr = cpu_to_be64(inum->no_addr);
1031         di->di_mode = cpu_to_be32(mode);
1032         di->di_uid = cpu_to_be32(uid);
1033         di->di_gid = cpu_to_be32(gid);
1034         di->di_nlink = cpu_to_be32(0);
1035         di->di_size = cpu_to_be64(0);
1036         di->di_blocks = cpu_to_be64(1);
1037         di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds());
1038         di->di_major = di->di_minor = cpu_to_be32(0);
1039         di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
1040         di->__pad[0] = di->__pad[1] = 0;
1041         di->di_flags = cpu_to_be32(0);
1042
1043         if (S_ISREG(mode)) {
1044                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
1045                     gfs2_tune_get(sdp, gt_new_files_jdata))
1046                         di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
1047                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
1048                     gfs2_tune_get(sdp, gt_new_files_directio))
1049                         di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
1050         } else if (S_ISDIR(mode)) {
1051                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
1052                                             GFS2_DIF_INHERIT_DIRECTIO);
1053                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
1054                                             GFS2_DIF_INHERIT_JDATA);
1055         }
1056
1057         di->__pad1 = 0;
1058         di->di_height = cpu_to_be32(0);
1059         di->__pad2 = 0;
1060         di->__pad3 = 0;
1061         di->di_depth = cpu_to_be16(0);
1062         di->di_entries = cpu_to_be32(0);
1063         memset(&di->__pad4, 0, sizeof(di->__pad4));
1064         di->di_eattr = cpu_to_be64(0);
1065         memset(&di->di_reserved, 0, sizeof(di->di_reserved));
1066
1067         brelse(dibh);
1068 }
1069
1070 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
1071                        unsigned int mode, struct gfs2_unlinked *ul)
1072 {
1073         struct gfs2_sbd *sdp = dip->i_sbd;
1074         unsigned int uid, gid;
1075         int error;
1076
1077         munge_mode_uid_gid(dip, &mode, &uid, &gid);
1078
1079         gfs2_alloc_get(dip);
1080
1081         error = gfs2_quota_lock(dip, uid, gid);
1082         if (error)
1083                 goto out;
1084
1085         error = gfs2_quota_check(dip, uid, gid);
1086         if (error)
1087                 goto out_quota;
1088
1089         error = gfs2_trans_begin(sdp, RES_DINODE + RES_UNLINKED +
1090                                  RES_QUOTA, 0);
1091         if (error)
1092                 goto out_quota;
1093
1094         ul->ul_ut.ut_flags = 0;
1095         error = gfs2_unlinked_ondisk_munge(sdp, ul);
1096
1097         init_dinode(dip, gl, &ul->ul_ut.ut_inum,
1098                      mode, uid, gid);
1099
1100         gfs2_quota_change(dip, +1, uid, gid);
1101
1102         gfs2_trans_end(sdp);
1103
1104  out_quota:
1105         gfs2_quota_unlock(dip);
1106
1107  out:
1108         gfs2_alloc_put(dip);
1109
1110         return error;
1111 }
1112
1113 static int link_dinode(struct gfs2_inode *dip, struct qstr *name,
1114                        struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1115 {
1116         struct gfs2_sbd *sdp = dip->i_sbd;
1117         struct gfs2_alloc *al;
1118         int alloc_required;
1119         struct buffer_head *dibh;
1120         int error;
1121
1122         al = gfs2_alloc_get(dip);
1123
1124         error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1125         if (error)
1126                 goto fail;
1127
1128         error = alloc_required = gfs2_diradd_alloc_required(dip->i_vnode, name);
1129         if (alloc_required < 0)
1130                 goto fail;
1131         if (alloc_required) {
1132                 error = gfs2_quota_check(dip, dip->i_di.di_uid,
1133                                          dip->i_di.di_gid);
1134                 if (error)
1135                         goto fail_quota_locks;
1136
1137                 al->al_requested = sdp->sd_max_dirres;
1138
1139                 error = gfs2_inplace_reserve(dip);
1140                 if (error)
1141                         goto fail_quota_locks;
1142
1143                 error = gfs2_trans_begin(sdp,
1144                                          sdp->sd_max_dirres +
1145                                          al->al_rgd->rd_ri.ri_length +
1146                                          2 * RES_DINODE + RES_UNLINKED +
1147                                          RES_STATFS + RES_QUOTA, 0);
1148                 if (error)
1149                         goto fail_ipreserv;
1150         } else {
1151                 error = gfs2_trans_begin(sdp,
1152                                          RES_LEAF +
1153                                          2 * RES_DINODE +
1154                                          RES_UNLINKED, 0);
1155                 if (error)
1156                         goto fail_quota_locks;
1157         }
1158
1159         error = gfs2_dir_add(dip->i_vnode, name, &ip->i_num, IF2DT(ip->i_di.di_mode));
1160         if (error)
1161                 goto fail_end_trans;
1162
1163         error = gfs2_meta_inode_buffer(ip, &dibh);
1164         if (error)
1165                 goto fail_end_trans;
1166         ip->i_di.di_nlink = 1;
1167         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1168         gfs2_dinode_out(&ip->i_di, dibh->b_data);
1169         brelse(dibh);
1170
1171         error = gfs2_unlinked_ondisk_rm(sdp, ul);
1172         if (error)
1173                 goto fail_end_trans;
1174
1175         return 0;
1176
1177  fail_end_trans:
1178         gfs2_trans_end(sdp);
1179
1180  fail_ipreserv:
1181         if (dip->i_alloc.al_rgd)
1182                 gfs2_inplace_release(dip);
1183
1184  fail_quota_locks:
1185         gfs2_quota_unlock(dip);
1186
1187  fail:
1188         gfs2_alloc_put(dip);
1189
1190         return error;
1191 }
1192
1193 /**
1194  * gfs2_createi - Create a new inode
1195  * @ghs: An array of two holders
1196  * @name: The name of the new file
1197  * @mode: the permissions on the new inode
1198  *
1199  * @ghs[0] is an initialized holder for the directory
1200  * @ghs[1] is the holder for the inode lock
1201  *
1202  * If the return value is not NULL, the glocks on both the directory and the new
1203  * file are held.  A transaction has been started and an inplace reservation
1204  * is held, as well.
1205  *
1206  * Returns: An inode
1207  */
1208
1209 struct inode *gfs2_createi(struct gfs2_holder *ghs, struct qstr *name,
1210                            unsigned int mode)
1211 {
1212         struct inode *inode;
1213         struct gfs2_inode *dip = ghs->gh_gl->gl_object;
1214         struct gfs2_sbd *sdp = dip->i_sbd;
1215         struct gfs2_unlinked *ul;
1216         struct gfs2_inode *ip;
1217         int error;
1218
1219         if (!name->len || name->len > GFS2_FNAMESIZE)
1220                 return ERR_PTR(-ENAMETOOLONG);
1221
1222         error = gfs2_unlinked_get(sdp, &ul);
1223         if (error)
1224                 return ERR_PTR(error);
1225
1226         gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
1227         error = gfs2_glock_nq(ghs);
1228         if (error)
1229                 goto fail;
1230
1231         error = create_ok(dip, name, mode);
1232         if (error)
1233                 goto fail_gunlock;
1234
1235         error = pick_formal_ino(sdp, &ul->ul_ut.ut_inum.no_formal_ino);
1236         if (error)
1237                 goto fail_gunlock;
1238
1239         error = alloc_dinode(dip, ul);
1240         if (error)
1241                 goto fail_gunlock;
1242
1243         if (ul->ul_ut.ut_inum.no_addr < dip->i_num.no_addr) {
1244                 gfs2_glock_dq(ghs);
1245
1246                 error = gfs2_glock_nq_num(sdp,
1247                                           ul->ul_ut.ut_inum.no_addr,
1248                                           &gfs2_inode_glops,
1249                                           LM_ST_EXCLUSIVE, GL_SKIP,
1250                                           ghs + 1);
1251                 if (error) {
1252                         gfs2_unlinked_put(sdp, ul);
1253                         return ERR_PTR(error);
1254                 }
1255
1256                 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
1257                 error = gfs2_glock_nq(ghs);
1258                 if (error) {
1259                         gfs2_glock_dq_uninit(ghs + 1);
1260                         gfs2_unlinked_put(sdp, ul);
1261                         return ERR_PTR(error);
1262                 }
1263
1264                 error = create_ok(dip, name, mode);
1265                 if (error)
1266                         goto fail_gunlock2;
1267         } else {
1268                 error = gfs2_glock_nq_num(sdp,
1269                                           ul->ul_ut.ut_inum.no_addr,
1270                                           &gfs2_inode_glops,
1271                                           LM_ST_EXCLUSIVE, GL_SKIP,
1272                                           ghs + 1);
1273                 if (error)
1274                         goto fail_gunlock;
1275         }
1276
1277         error = make_dinode(dip, ghs[1].gh_gl, mode, ul);
1278         if (error)
1279                 goto fail_gunlock2;
1280
1281         error = gfs2_inode_get(ghs[1].gh_gl, &ul->ul_ut.ut_inum, CREATE, &ip);
1282         if (error)
1283                 goto fail_gunlock2;
1284
1285         error = gfs2_inode_refresh(ip);
1286         if (error)
1287                 goto fail_iput;
1288
1289         error = gfs2_acl_create(dip, ip);
1290         if (error)
1291                 goto fail_iput;
1292
1293         error = link_dinode(dip, name, ip, ul);
1294         if (error)
1295                 goto fail_iput;
1296
1297         gfs2_unlinked_put(sdp, ul);
1298
1299         inode = gfs2_ip2v(ip);
1300         gfs2_inode_put(ip);
1301         if (!inode)
1302                 return ERR_PTR(-ENOMEM);
1303         return inode;
1304
1305  fail_iput:
1306         gfs2_inode_put(ip);
1307
1308  fail_gunlock2:
1309         gfs2_glock_dq_uninit(ghs + 1);
1310
1311  fail_gunlock:
1312         gfs2_glock_dq(ghs);
1313
1314  fail:
1315         gfs2_unlinked_put(sdp, ul);
1316
1317         return ERR_PTR(error);
1318 }
1319
1320 /**
1321  * gfs2_unlinki - Unlink a file
1322  * @dip: The inode of the directory
1323  * @name: The name of the file to be unlinked
1324  * @ip: The inode of the file to be removed
1325  *
1326  * Assumes Glocks on both dip and ip are held.
1327  *
1328  * Returns: errno
1329  */
1330
1331 int gfs2_unlinki(struct gfs2_inode *dip, struct qstr *name,
1332                  struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1333 {
1334         struct gfs2_sbd *sdp = dip->i_sbd;
1335         int error;
1336
1337         error = gfs2_dir_del(dip, name);
1338         if (error)
1339                 return error;
1340
1341         error = gfs2_change_nlink(ip, -1);
1342         if (error)
1343                 return error;
1344
1345         /* If this inode is being unlinked from the directory structure,
1346            we need to mark that in the log so that it isn't lost during
1347            a crash. */
1348
1349         if (!ip->i_di.di_nlink) {
1350                 ul->ul_ut.ut_inum = ip->i_num;
1351                 error = gfs2_unlinked_ondisk_add(sdp, ul);
1352                 if (!error)
1353                         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
1354         }
1355
1356         return error;
1357 }
1358
1359 /**
1360  * gfs2_rmdiri - Remove a directory
1361  * @dip: The parent directory of the directory to be removed
1362  * @name: The name of the directory to be removed
1363  * @ip: The GFS2 inode of the directory to be removed
1364  *
1365  * Assumes Glocks on dip and ip are held
1366  *
1367  * Returns: errno
1368  */
1369
1370 int gfs2_rmdiri(struct gfs2_inode *dip, struct qstr *name,
1371                 struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1372 {
1373         struct gfs2_sbd *sdp = dip->i_sbd;
1374         struct qstr dotname;
1375         int error;
1376
1377         if (ip->i_di.di_entries != 2) {
1378                 if (gfs2_consist_inode(ip))
1379                         gfs2_dinode_print(&ip->i_di);
1380                 return -EIO;
1381         }
1382
1383         error = gfs2_dir_del(dip, name);
1384         if (error)
1385                 return error;
1386
1387         error = gfs2_change_nlink(dip, -1);
1388         if (error)
1389                 return error;
1390
1391         gfs2_str2qstr(&dotname, ".");
1392         error = gfs2_dir_del(ip, &dotname);
1393         if (error)
1394                 return error;
1395
1396         dotname.len = 2;
1397         dotname.name = "..";
1398         dotname.hash = gfs2_disk_hash(dotname.name, dotname.len);
1399         error = gfs2_dir_del(ip, &dotname);
1400         if (error)
1401                 return error;
1402
1403         error = gfs2_change_nlink(ip, -2);
1404         if (error)
1405                 return error;
1406
1407         /* This inode is being unlinked from the directory structure and
1408            we need to mark that in the log so that it isn't lost during
1409            a crash. */
1410
1411         ul->ul_ut.ut_inum = ip->i_num;
1412         error = gfs2_unlinked_ondisk_add(sdp, ul);
1413         if (!error)
1414                 set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
1415
1416         return error;
1417 }
1418
1419 /*
1420  * gfs2_unlink_ok - check to see that a inode is still in a directory
1421  * @dip: the directory
1422  * @name: the name of the file
1423  * @ip: the inode
1424  *
1425  * Assumes that the lock on (at least) @dip is held.
1426  *
1427  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1428  */
1429
1430 int gfs2_unlink_ok(struct gfs2_inode *dip, struct qstr *name,
1431                    struct gfs2_inode *ip)
1432 {
1433         struct gfs2_inum inum;
1434         unsigned int type;
1435         int error;
1436
1437         if (IS_IMMUTABLE(ip->i_vnode) || IS_APPEND(ip->i_vnode))
1438                 return -EPERM;
1439
1440         if ((dip->i_di.di_mode & S_ISVTX) &&
1441             dip->i_di.di_uid != current->fsuid &&
1442             ip->i_di.di_uid != current->fsuid &&
1443             !capable(CAP_FOWNER))
1444                 return -EPERM;
1445
1446         if (IS_APPEND(dip->i_vnode))
1447                 return -EPERM;
1448
1449         error = gfs2_repermission(dip->i_vnode, MAY_WRITE | MAY_EXEC, NULL);
1450         if (error)
1451                 return error;
1452
1453         error = gfs2_dir_search(dip->i_vnode, name, &inum, &type);
1454         if (error)
1455                 return error;
1456
1457         if (!gfs2_inum_equal(&inum, &ip->i_num))
1458                 return -ENOENT;
1459
1460         if (IF2DT(ip->i_di.di_mode) != type) {
1461                 gfs2_consist_inode(dip);
1462                 return -EIO;
1463         }
1464
1465         return 0;
1466 }
1467
1468 /*
1469  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1470  * @this: move this
1471  * @to: to here
1472  *
1473  * Follow @to back to the root and make sure we don't encounter @this
1474  * Assumes we already hold the rename lock.
1475  *
1476  * Returns: errno
1477  */
1478
1479 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1480 {
1481         struct inode *dir = to->i_vnode;
1482         struct super_block *sb = dir->i_sb;
1483         struct inode *tmp;
1484         struct qstr dotdot;
1485         int error = 0;
1486
1487         gfs2_str2qstr(&dotdot, "..");
1488
1489         igrab(dir);
1490
1491         for (;;) {
1492                 if (dir == this->i_vnode) {
1493                         error = -EINVAL;
1494                         break;
1495                 }
1496                 if (dir == sb->s_root->d_inode) {
1497                         error = 0;
1498                         break;
1499                 }
1500
1501                 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1502                 if (IS_ERR(tmp)) {
1503                         error = PTR_ERR(tmp);
1504                         break;
1505                 }
1506
1507                 iput(dir);
1508                 dir = tmp;
1509         }
1510
1511         iput(dir);
1512
1513         return error;
1514 }
1515
1516 /**
1517  * gfs2_readlinki - return the contents of a symlink
1518  * @ip: the symlink's inode
1519  * @buf: a pointer to the buffer to be filled
1520  * @len: a pointer to the length of @buf
1521  *
1522  * If @buf is too small, a piece of memory is kmalloc()ed and needs
1523  * to be freed by the caller.
1524  *
1525  * Returns: errno
1526  */
1527
1528 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1529 {
1530         struct gfs2_holder i_gh;
1531         struct buffer_head *dibh;
1532         unsigned int x;
1533         int error;
1534
1535         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1536         error = gfs2_glock_nq_atime(&i_gh);
1537         if (error) {
1538                 gfs2_holder_uninit(&i_gh);
1539                 return error;
1540         }
1541
1542         if (!ip->i_di.di_size) {
1543                 gfs2_consist_inode(ip);
1544                 error = -EIO;
1545                 goto out;
1546         }
1547
1548         error = gfs2_meta_inode_buffer(ip, &dibh);
1549         if (error)
1550                 goto out;
1551
1552         x = ip->i_di.di_size + 1;
1553         if (x > *len) {
1554                 *buf = kmalloc(x, GFP_KERNEL);
1555                 if (!*buf) {
1556                         error = -ENOMEM;
1557                         goto out_brelse;
1558                 }
1559         }
1560
1561         memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1562         *len = x;
1563
1564  out_brelse:
1565         brelse(dibh);
1566
1567  out:
1568         gfs2_glock_dq_uninit(&i_gh);
1569
1570         return error;
1571 }
1572
1573 /**
1574  * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1575  *       conditionally update the inode's atime
1576  * @gh: the holder to acquire
1577  *
1578  * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1579  * Update if the difference between the current time and the inode's current
1580  * atime is greater than an interval specified at mount.
1581  *
1582  * Returns: errno
1583  */
1584
1585 int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1586 {
1587         struct gfs2_glock *gl = gh->gh_gl;
1588         struct gfs2_sbd *sdp = gl->gl_sbd;
1589         struct gfs2_inode *ip = gl->gl_object;
1590         int64_t curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
1591         unsigned int state;
1592         int flags;
1593         int error;
1594
1595         if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1596             gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1597             gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1598                 return -EINVAL;
1599
1600         state = gh->gh_state;
1601         flags = gh->gh_flags;
1602
1603         error = gfs2_glock_nq(gh);
1604         if (error)
1605                 return error;
1606
1607         if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1608             (sdp->sd_vfs->s_flags & MS_RDONLY))
1609                 return 0;
1610
1611         curtime = get_seconds();
1612         if (curtime - ip->i_di.di_atime >= quantum) {
1613                 gfs2_glock_dq(gh);
1614                 gfs2_holder_reinit(LM_ST_EXCLUSIVE,
1615                                   gh->gh_flags & ~LM_FLAG_ANY,
1616                                   gh);
1617                 error = gfs2_glock_nq(gh);
1618                 if (error)
1619                         return error;
1620
1621                 /* Verify that atime hasn't been updated while we were
1622                    trying to get exclusive lock. */
1623
1624                 curtime = get_seconds();
1625                 if (curtime - ip->i_di.di_atime >= quantum) {
1626                         struct buffer_head *dibh;
1627
1628                         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1629                         if (error == -EROFS)
1630                                 return 0;
1631                         if (error)
1632                                 goto fail;
1633
1634                         error = gfs2_meta_inode_buffer(ip, &dibh);
1635                         if (error)
1636                                 goto fail_end_trans;
1637
1638                         ip->i_di.di_atime = curtime;
1639
1640                         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1641                         gfs2_dinode_out(&ip->i_di, dibh->b_data);
1642                         brelse(dibh);
1643
1644                         gfs2_trans_end(sdp);
1645                 }
1646
1647                 /* If someone else has asked for the glock,
1648                    unlock and let them have it. Then reacquire
1649                    in the original state. */
1650                 if (gfs2_glock_is_blocking(gl)) {
1651                         gfs2_glock_dq(gh);
1652                         gfs2_holder_reinit(state, flags, gh);
1653                         return gfs2_glock_nq(gh);
1654                 }
1655         }
1656
1657         return 0;
1658
1659  fail_end_trans:
1660         gfs2_trans_end(sdp);
1661
1662  fail:
1663         gfs2_glock_dq(gh);
1664
1665         return error;
1666 }
1667
1668 /**
1669  * glock_compare_atime - Compare two struct gfs2_glock structures for sort
1670  * @arg_a: the first structure
1671  * @arg_b: the second structure
1672  *
1673  * Returns: 1 if A > B
1674  *         -1 if A < B
1675  *          0 if A = B
1676  */
1677
1678 static int glock_compare_atime(const void *arg_a, const void *arg_b)
1679 {
1680         struct gfs2_holder *gh_a = *(struct gfs2_holder **)arg_a;
1681         struct gfs2_holder *gh_b = *(struct gfs2_holder **)arg_b;
1682         struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1683         struct lm_lockname *b = &gh_b->gh_gl->gl_name;
1684         int ret = 0;
1685
1686         if (a->ln_number > b->ln_number)
1687                 ret = 1;
1688         else if (a->ln_number < b->ln_number)
1689                 ret = -1;
1690         else {
1691                 if (gh_a->gh_state == LM_ST_SHARED &&
1692                     gh_b->gh_state == LM_ST_EXCLUSIVE)
1693                         ret = 1;
1694                 else if (gh_a->gh_state == LM_ST_SHARED &&
1695                          (gh_b->gh_flags & GL_ATIME))
1696                         ret = 1;
1697         }
1698
1699         return ret;
1700 }
1701
1702 /**
1703  * gfs2_glock_nq_m_atime - acquire multiple glocks where one may need an
1704  *      atime update
1705  * @num_gh: the number of structures
1706  * @ghs: an array of struct gfs2_holder structures
1707  *
1708  * Returns: 0 on success (all glocks acquired),
1709  *          errno on failure (no glocks acquired)
1710  */
1711
1712 int gfs2_glock_nq_m_atime(unsigned int num_gh, struct gfs2_holder *ghs)
1713 {
1714         struct gfs2_holder **p;
1715         unsigned int x;
1716         int error = 0;
1717
1718         if (!num_gh)
1719                 return 0;
1720
1721         if (num_gh == 1) {
1722                 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1723                 if (ghs->gh_flags & GL_ATIME)
1724                         error = gfs2_glock_nq_atime(ghs);
1725                 else
1726                         error = gfs2_glock_nq(ghs);
1727                 return error;
1728         }
1729
1730         p = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL);
1731         if (!p)
1732                 return -ENOMEM;
1733
1734         for (x = 0; x < num_gh; x++)
1735                 p[x] = &ghs[x];
1736
1737         sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare_atime,NULL);
1738
1739         for (x = 0; x < num_gh; x++) {
1740                 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1741
1742                 if (p[x]->gh_flags & GL_ATIME)
1743                         error = gfs2_glock_nq_atime(p[x]);
1744                 else
1745                         error = gfs2_glock_nq(p[x]);
1746
1747                 if (error) {
1748                         while (x--)
1749                                 gfs2_glock_dq(p[x]);
1750                         break;
1751                 }
1752         }
1753
1754         kfree(p);
1755
1756         return error;
1757 }
1758
1759 /**
1760  * gfs2_try_toss_vnode - See if we can toss a vnode from memory
1761  * @ip: the inode
1762  *
1763  * Returns:  1 if the vnode was tossed
1764  */
1765
1766 void gfs2_try_toss_vnode(struct gfs2_inode *ip)
1767 {
1768         struct inode *inode;
1769
1770         inode = gfs2_ip2v_lookup(ip);
1771         if (!inode)
1772                 return;
1773
1774         d_prune_aliases(inode);
1775
1776         if (S_ISDIR(ip->i_di.di_mode)) {
1777                 struct list_head *head = &inode->i_dentry;
1778                 struct dentry *d = NULL;
1779
1780                 spin_lock(&dcache_lock);
1781                 if (list_empty(head))
1782                         spin_unlock(&dcache_lock);
1783                 else {
1784                         d = list_entry(head->next, struct dentry, d_alias);
1785                         dget_locked(d);
1786                         spin_unlock(&dcache_lock);
1787
1788                         if (have_submounts(d))
1789                                 dput(d);
1790                         else {
1791                                 shrink_dcache_parent(d);
1792                                 dput(d);
1793                                 d_prune_aliases(inode);
1794                         }
1795                 }
1796         }
1797
1798         inode->i_nlink = 0;
1799         iput(inode);
1800 }
1801
1802
1803 static int
1804 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1805 {
1806         struct buffer_head *dibh;
1807         int error;
1808
1809         error = gfs2_meta_inode_buffer(ip, &dibh);
1810         if (!error) {
1811                 error = inode_setattr(ip->i_vnode, attr);
1812                 gfs2_assert_warn(ip->i_sbd, !error);
1813                 gfs2_inode_attr_out(ip);
1814
1815                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1816                 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1817                 brelse(dibh);
1818         }
1819         return error;
1820 }
1821
1822 /**
1823  * gfs2_setattr_simple -
1824  * @ip:
1825  * @attr:
1826  *
1827  * Called with a reference on the vnode.
1828  *
1829  * Returns: errno
1830  */
1831
1832 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1833 {
1834         int error;
1835
1836         if (current->journal_info)
1837                 return __gfs2_setattr_simple(ip, attr);
1838
1839         error = gfs2_trans_begin(ip->i_sbd, RES_DINODE, 0);
1840         if (error)
1841                 return error;
1842
1843         error = __gfs2_setattr_simple(ip, attr);
1844
1845         gfs2_trans_end(ip->i_sbd);
1846
1847         return error;
1848 }
1849
1850 int gfs2_repermission(struct inode *inode, int mask, struct nameidata *nd)
1851 {
1852         return permission(inode, mask, nd);
1853 }
1854