SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/gfs2/inode.c

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