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