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 version 2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/posix_acl.h>
  16 #include <linux/sort.h>
  17 #include <linux/gfs2_ondisk.h>
  18 #include <linux/crc32.h>
  19 #include <linux/lm_interface.h>
  20 #include <linux/security.h>
  21
  22 #include "gfs2.h"
  23 #include "incore.h"
  24 #include "acl.h"
  25 #include "bmap.h"
  26 #include "dir.h"
  27 #include "eattr.h"
  28 #include "glock.h"
  29 #include "glops.h"
  30 #include "inode.h"
  31 #include "log.h"
  32 #include "meta_io.h"
  33 #include "ops_address.h"
  34 #include "ops_file.h"
  35 #include "ops_inode.h"
  36 #include "quota.h"
  37 #include "rgrp.h"
  38 #include "trans.h"
  39 #include "util.h"
  40
  41 /**
  42  * gfs2_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 void gfs2_inode_attr_in(struct gfs2_inode *ip)
  49 {
  50         struct inode *inode = &ip->i_inode;
  51         struct gfs2_dinode_host *di = &ip->i_di;
  52
  53         inode->i_ino = ip->i_num.no_addr;
  54         i_size_write(inode, di->di_size);
  55         inode->i_blocks = di->di_blocks <<
  56                 (GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
  57
  58         if (di->di_flags & GFS2_DIF_IMMUTABLE)
  59                 inode->i_flags |= S_IMMUTABLE;
  60         else
  61                 inode->i_flags &= ~S_IMMUTABLE;
  62
  63         if (di->di_flags & GFS2_DIF_APPENDONLY)
  64                 inode->i_flags |= S_APPEND;
  65         else
  66                 inode->i_flags &= ~S_APPEND;
  67 }
  68
  69 static int iget_test(struct inode *inode, void *opaque)
  70 {
  71         struct gfs2_inode *ip = GFS2_I(inode);
  72         struct gfs2_inum_host *inum = opaque;
  73
  74         if (ip && ip->i_num.no_addr == inum->no_addr)
  75                 return 1;
  76
  77         return 0;
  78 }
  79
  80 static int iget_set(struct inode *inode, void *opaque)
  81 {
  82         struct gfs2_inode *ip = GFS2_I(inode);
  83         struct gfs2_inum_host *inum = opaque;
  84
  85         ip->i_num = *inum;
  86         return 0;
  87 }
  88
  89 struct inode *gfs2_ilookup(struct super_block *sb, struct gfs2_inum_host *inum)
  90 {
  91         return ilookup5(sb, (unsigned long)inum->no_formal_ino,
  92                         iget_test, inum);
  93 }
  94
  95 static struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum_host *inum)
  96 {
  97         return iget5_locked(sb, (unsigned long)inum->no_formal_ino,
  98                      iget_test, iget_set, inum);
  99 }
 100
 101 /**
 102  * gfs2_inode_lookup - Lookup an inode
 103  * @sb: The super block
 104  * @inum: The inode number
 105  * @type: The type of the inode
 106  *
 107  * Returns: A VFS inode, or an error
 108  */
 109
 110 struct inode *gfs2_inode_lookup(struct super_block *sb, struct gfs2_inum_host *inum, unsigned int type)
 111 {
 112         struct inode *inode = gfs2_iget(sb, inum);
 113         struct gfs2_inode *ip = GFS2_I(inode);
 114         struct gfs2_glock *io_gl;
 115         int error;
 116
 117         if (!inode)
 118                 return ERR_PTR(-ENOBUFS);
 119
 120         if (inode->i_state & I_NEW) {
 121                 struct gfs2_sbd *sdp = GFS2_SB(inode);
 122                 umode_t mode = DT2IF(type);
 123                 inode->i_private = ip;
 124                 inode->i_mode = mode;
 125
 126                 if (S_ISREG(mode)) {
 127                         inode->i_op = &gfs2_file_iops;
 128                         inode->i_fop = &gfs2_file_fops;
 129                         inode->i_mapping->a_ops = &gfs2_file_aops;
 130                 } else if (S_ISDIR(mode)) {
 131                         inode->i_op = &gfs2_dir_iops;
 132                         inode->i_fop = &gfs2_dir_fops;
 133                 } else if (S_ISLNK(mode)) {
 134                         inode->i_op = &gfs2_symlink_iops;
 135                 } else {
 136                         inode->i_op = &gfs2_dev_iops;
 137                 }
 138
 139                 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 140                 if (unlikely(error))
 141                         goto fail;
 142                 ip->i_gl->gl_object = ip;
 143
 144                 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 145                 if (unlikely(error))
 146                         goto fail_put;
 147
 148                 ip->i_vn = ip->i_gl->gl_vn - 1;
 149                 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 150                 if (unlikely(error))
 151                         goto fail_iopen;
 152
 153                 gfs2_glock_put(io_gl);
 154                 unlock_new_inode(inode);
 155         }
 156
 157         return inode;
 158 fail_iopen:
 159         gfs2_glock_put(io_gl);
 160 fail_put:
 161         ip->i_gl->gl_object = NULL;
 162         gfs2_glock_put(ip->i_gl);
 163 fail:
 164         iput(inode);
 165         return ERR_PTR(error);
 166 }
 167
 168 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
 169 {
 170         struct gfs2_dinode_host *di = &ip->i_di;
 171         const struct gfs2_dinode *str = buf;
 172
 173         if (ip->i_num.no_addr != be64_to_cpu(str->di_num.no_addr)) {
 174                 if (gfs2_consist_inode(ip))
 175                         gfs2_dinode_print(ip);
 176                 return -EIO;
 177         }
 178         if (ip->i_num.no_formal_ino != be64_to_cpu(str->di_num.no_formal_ino))
 179                 return -ESTALE;
 180
 181         ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
 182         ip->i_inode.i_rdev = 0;
 183         switch (ip->i_inode.i_mode & S_IFMT) {
 184         case S_IFBLK:
 185         case S_IFCHR:
 186                 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
 187                                            be32_to_cpu(str->di_minor));
 188                 break;
 189         };
 190
 191         ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
 192         ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
 193         /*
 194          * We will need to review setting the nlink count here in the
 195          * light of the forthcoming ro bind mount work. This is a reminder
 196          * to do that.
 197          */
 198         ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
 199         di->di_size = be64_to_cpu(str->di_size);
 200         di->di_blocks = be64_to_cpu(str->di_blocks);
 201         ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime);
 202         ip->i_inode.i_atime.tv_nsec = 0;
 203         ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
 204         ip->i_inode.i_mtime.tv_nsec = 0;
 205         ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
 206         ip->i_inode.i_ctime.tv_nsec = 0;
 207
 208         di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
 209         di->di_goal_data = be64_to_cpu(str->di_goal_data);
 210         di->di_generation = be64_to_cpu(str->di_generation);
 211
 212         di->di_flags = be32_to_cpu(str->di_flags);
 213         di->di_payload_format = be32_to_cpu(str->di_payload_format);
 214         di->di_height = be16_to_cpu(str->di_height);
 215
 216         di->di_depth = be16_to_cpu(str->di_depth);
 217         di->di_entries = be32_to_cpu(str->di_entries);
 218
 219         di->di_eattr = be64_to_cpu(str->di_eattr);
 220         return 0;
 221 }
 222
 223 /**
 224  * gfs2_inode_refresh - Refresh the incore copy of the dinode
 225  * @ip: The GFS2 inode
 226  *
 227  * Returns: errno
 228  */
 229
 230 int gfs2_inode_refresh(struct gfs2_inode *ip)
 231 {
 232         struct buffer_head *dibh;
 233         int error;
 234
 235         error = gfs2_meta_inode_buffer(ip, &dibh);
 236         if (error)
 237                 return error;
 238
 239         if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
 240                 brelse(dibh);
 241                 return -EIO;
 242         }
 243
 244         error = gfs2_dinode_in(ip, dibh->b_data);
 245         brelse(dibh);
 246         ip->i_vn = ip->i_gl->gl_vn;
 247
 248         return error;
 249 }
 250
 251 int gfs2_dinode_dealloc(struct gfs2_inode *ip)
 252 {
 253         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 254         struct gfs2_alloc *al;
 255         struct gfs2_rgrpd *rgd;
 256         int error;
 257
 258         if (ip->i_di.di_blocks != 1) {
 259                 if (gfs2_consist_inode(ip))
 260                         gfs2_dinode_print(ip);
 261                 return -EIO;
 262         }
 263
 264         al = gfs2_alloc_get(ip);
 265
 266         error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 267         if (error)
 268                 goto out;
 269
 270         error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
 271         if (error)
 272                 goto out_qs;
 273
 274         rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
 275         if (!rgd) {
 276                 gfs2_consist_inode(ip);
 277                 error = -EIO;
 278                 goto out_rindex_relse;
 279         }
 280
 281         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
 282                                    &al->al_rgd_gh);
 283         if (error)
 284                 goto out_rindex_relse;
 285
 286         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
 287         if (error)
 288                 goto out_rg_gunlock;
 289
 290         gfs2_trans_add_gl(ip->i_gl);
 291
 292         gfs2_free_di(rgd, ip);
 293
 294         gfs2_trans_end(sdp);
 295         clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 296
 297 out_rg_gunlock:
 298         gfs2_glock_dq_uninit(&al->al_rgd_gh);
 299 out_rindex_relse:
 300         gfs2_glock_dq_uninit(&al->al_ri_gh);
 301 out_qs:
 302         gfs2_quota_unhold(ip);
 303 out:
 304         gfs2_alloc_put(ip);
 305         return error;
 306 }
 307
 308 /**
 309  * gfs2_change_nlink - Change nlink count on inode
 310  * @ip: The GFS2 inode
 311  * @diff: The change in the nlink count required
 312  *
 313  * Returns: errno
 314  */
 315
 316 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
 317 {
 318         struct gfs2_sbd *sdp = ip->i_inode.i_sb->s_fs_info;
 319         struct buffer_head *dibh;
 320         u32 nlink;
 321         int error;
 322
 323         BUG_ON(diff != 1 && diff != -1);
 324         nlink = ip->i_inode.i_nlink + diff;
 325
 326         /* If we are reducing the nlink count, but the new value ends up being
 327            bigger than the old one, we must have underflowed. */
 328         if (diff < 0 && nlink > ip->i_inode.i_nlink) {
 329                 if (gfs2_consist_inode(ip))
 330                         gfs2_dinode_print(ip);
 331                 return -EIO;
 332         }
 333
 334         error = gfs2_meta_inode_buffer(ip, &dibh);
 335         if (error)
 336                 return error;
 337
 338         if (diff > 0)
 339                 inc_nlink(&ip->i_inode);
 340         else
 341                 drop_nlink(&ip->i_inode);
 342
 343         ip->i_inode.i_ctime.tv_sec = get_seconds();
 344
 345         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 346         gfs2_dinode_out(ip, dibh->b_data);
 347         brelse(dibh);
 348         mark_inode_dirty(&ip->i_inode);
 349
 350         if (ip->i_inode.i_nlink == 0) {
 351                 struct gfs2_rgrpd *rgd;
 352                 struct gfs2_holder ri_gh, rg_gh;
 353
 354                 error = gfs2_rindex_hold(sdp, &ri_gh);
 355                 if (error)
 356                         goto out;
 357                 error = -EIO;
 358                 rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
 359                 if (!rgd)
 360                         goto out_norgrp;
 361                 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);
 362                 if (error)
 363                         goto out_norgrp;
 364
 365                 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
 366                 gfs2_glock_dq_uninit(&rg_gh);
 367 out_norgrp:
 368                 gfs2_glock_dq_uninit(&ri_gh);
 369         }
 370 out:
 371         return error;
 372 }
 373
 374 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 375 {
 376         struct qstr qstr;
 377         gfs2_str2qstr(&qstr, name);
 378         return gfs2_lookupi(dip, &qstr, 1, NULL);
 379 }
 380
 381
 382 /**
 383  * gfs2_lookupi - Look up a filename in a directory and return its inode
 384  * @d_gh: An initialized holder for the directory glock
 385  * @name: The name of the inode to look for
 386  * @is_root: If 1, ignore the caller's permissions
 387  * @i_gh: An uninitialized holder for the new inode glock
 388  *
 389  * There will always be a vnode (Linux VFS inode) for the d_gh inode unless
 390  * @is_root is true.
 391  *
 392  * Returns: errno
 393  */
 394
 395 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 396                            int is_root, struct nameidata *nd)
 397 {
 398         struct super_block *sb = dir->i_sb;
 399         struct gfs2_inode *dip = GFS2_I(dir);
 400         struct gfs2_holder d_gh;
 401         struct gfs2_inum_host inum;
 402         unsigned int type;
 403         int error = 0;
 404         struct inode *inode = NULL;
 405
 406         if (!name->len || name->len > GFS2_FNAMESIZE)
 407                 return ERR_PTR(-ENAMETOOLONG);
 408
 409         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 410             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 411              dir == sb->s_root->d_inode)) {
 412                 igrab(dir);
 413                 return dir;
 414         }
 415
 416         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 417         if (error)
 418                 return ERR_PTR(error);
 419
 420         if (!is_root) {
 421                 error = permission(dir, MAY_EXEC, NULL);
 422                 if (error)
 423                         goto out;
 424         }
 425
 426         error = gfs2_dir_search(dir, name, &inum, &type);
 427         if (error)
 428                 goto out;
 429
 430         inode = gfs2_inode_lookup(sb, &inum, type);
 431
 432 out:
 433         gfs2_glock_dq_uninit(&d_gh);
 434         if (error == -ENOENT)
 435                 return NULL;
 436         return inode;
 437 }
 438
 439 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
 440 {
 441         struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
 442         struct buffer_head *bh;
 443         struct gfs2_inum_range_host ir;
 444         int error;
 445
 446         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
 447         if (error)
 448                 return error;
 449         mutex_lock(&sdp->sd_inum_mutex);
 450
 451         error = gfs2_meta_inode_buffer(ip, &bh);
 452         if (error) {
 453                 mutex_unlock(&sdp->sd_inum_mutex);
 454                 gfs2_trans_end(sdp);
 455                 return error;
 456         }
 457
 458         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 459
 460         if (ir.ir_length) {
 461                 *formal_ino = ir.ir_start++;
 462                 ir.ir_length--;
 463                 gfs2_trans_add_bh(ip->i_gl, bh, 1);
 464                 gfs2_inum_range_out(&ir,
 465                                     bh->b_data + sizeof(struct gfs2_dinode));
 466                 brelse(bh);
 467                 mutex_unlock(&sdp->sd_inum_mutex);
 468                 gfs2_trans_end(sdp);
 469                 return 0;
 470         }
 471
 472         brelse(bh);
 473
 474         mutex_unlock(&sdp->sd_inum_mutex);
 475         gfs2_trans_end(sdp);
 476
 477         return 1;
 478 }
 479
 480 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
 481 {
 482         struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
 483         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
 484         struct gfs2_holder gh;
 485         struct buffer_head *bh;
 486         struct gfs2_inum_range_host ir;
 487         int error;
 488
 489         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 490         if (error)
 491                 return error;
 492
 493         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
 494         if (error)
 495                 goto out;
 496         mutex_lock(&sdp->sd_inum_mutex);
 497
 498         error = gfs2_meta_inode_buffer(ip, &bh);
 499         if (error)
 500                 goto out_end_trans;
 501
 502         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 503
 504         if (!ir.ir_length) {
 505                 struct buffer_head *m_bh;
 506                 u64 x, y;
 507                 __be64 z;
 508
 509                 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 510                 if (error)
 511                         goto out_brelse;
 512
 513                 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
 514                 x = y = be64_to_cpu(z);
 515                 ir.ir_start = x;
 516                 ir.ir_length = GFS2_INUM_QUANTUM;
 517                 x += GFS2_INUM_QUANTUM;
 518                 if (x < y)
 519                         gfs2_consist_inode(m_ip);
 520                 z = cpu_to_be64(x);
 521                 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
 522                 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
 523
 524                 brelse(m_bh);
 525         }
 526
 527         *formal_ino = ir.ir_start++;
 528         ir.ir_length--;
 529
 530         gfs2_trans_add_bh(ip->i_gl, bh, 1);
 531         gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 532
 533 out_brelse:
 534         brelse(bh);
 535 out_end_trans:
 536         mutex_unlock(&sdp->sd_inum_mutex);
 537         gfs2_trans_end(sdp);
 538 out:
 539         gfs2_glock_dq_uninit(&gh);
 540         return error;
 541 }
 542
 543 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
 544 {
 545         int error;
 546
 547         error = pick_formal_ino_1(sdp, inum);
 548         if (error <= 0)
 549                 return error;
 550
 551         error = pick_formal_ino_2(sdp, inum);
 552
 553         return error;
 554 }
 555
 556 /**
 557  * create_ok - OK to create a new on-disk inode here?
 558  * @dip:  Directory in which dinode is to be created
 559  * @name:  Name of new dinode
 560  * @mode:
 561  *
 562  * Returns: errno
 563  */
 564
 565 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 566                      unsigned int mode)
 567 {
 568         int error;
 569
 570         error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
 571         if (error)
 572                 return error;
 573
 574         /*  Don't create entries in an unlinked directory  */
 575         if (!dip->i_inode.i_nlink)
 576                 return -EPERM;
 577
 578         error = gfs2_dir_search(&dip->i_inode, name, NULL, NULL);
 579         switch (error) {
 580         case -ENOENT:
 581                 error = 0;
 582                 break;
 583         case 0:
 584                 return -EEXIST;
 585         default:
 586                 return error;
 587         }
 588
 589         if (dip->i_di.di_entries == (u32)-1)
 590                 return -EFBIG;
 591         if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 592                 return -EMLINK;
 593
 594         return 0;
 595 }
 596
 597 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
 598                                unsigned int *uid, unsigned int *gid)
 599 {
 600         if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 601             (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
 602                 if (S_ISDIR(*mode))
 603                         *mode |= S_ISUID;
 604                 else if (dip->i_inode.i_uid != current->fsuid)
 605                         *mode &= ~07111;
 606                 *uid = dip->i_inode.i_uid;
 607         } else
 608                 *uid = current->fsuid;
 609
 610         if (dip->i_inode.i_mode & S_ISGID) {
 611                 if (S_ISDIR(*mode))
 612                         *mode |= S_ISGID;
 613                 *gid = dip->i_inode.i_gid;
 614         } else
 615                 *gid = current->fsgid;
 616 }
 617
 618 static int alloc_dinode(struct gfs2_inode *dip, struct gfs2_inum_host *inum,
 619                         u64 *generation)
 620 {
 621         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 622         int error;
 623
 624         gfs2_alloc_get(dip);
 625
 626         dip->i_alloc.al_requested = RES_DINODE;
 627         error = gfs2_inplace_reserve(dip);
 628         if (error)
 629                 goto out;
 630
 631         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
 632         if (error)
 633                 goto out_ipreserv;
 634
 635         inum->no_addr = gfs2_alloc_di(dip, generation);
 636
 637         gfs2_trans_end(sdp);
 638
 639 out_ipreserv:
 640         gfs2_inplace_release(dip);
 641 out:
 642         gfs2_alloc_put(dip);
 643         return error;
 644 }
 645
 646 /**
 647  * init_dinode - Fill in a new dinode structure
 648  * @dip: the directory this inode is being created in
 649  * @gl: The glock covering the new inode
 650  * @inum: the inode number
 651  * @mode: the file permissions
 652  * @uid:
 653  * @gid:
 654  *
 655  */
 656
 657 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 658                         const struct gfs2_inum_host *inum, unsigned int mode,
 659                         unsigned int uid, unsigned int gid,
 660                         const u64 *generation, dev_t dev)
 661 {
 662         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 663         struct gfs2_dinode *di;
 664         struct buffer_head *dibh;
 665
 666         dibh = gfs2_meta_new(gl, inum->no_addr);
 667         gfs2_trans_add_bh(gl, dibh, 1);
 668         gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
 669         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 670         di = (struct gfs2_dinode *)dibh->b_data;
 671
 672         di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
 673         di->di_num.no_addr = cpu_to_be64(inum->no_addr);
 674         di->di_mode = cpu_to_be32(mode);
 675         di->di_uid = cpu_to_be32(uid);
 676         di->di_gid = cpu_to_be32(gid);
 677         di->di_nlink = cpu_to_be32(0);
 678         di->di_size = cpu_to_be64(0);
 679         di->di_blocks = cpu_to_be64(1);
 680         di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds());
 681         di->di_major = cpu_to_be32(MAJOR(dev));
 682         di->di_minor = cpu_to_be32(MINOR(dev));
 683         di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
 684         di->di_generation = cpu_to_be64(*generation);
 685         di->di_flags = cpu_to_be32(0);
 686
 687         if (S_ISREG(mode)) {
 688                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
 689                     gfs2_tune_get(sdp, gt_new_files_jdata))
 690                         di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 691                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
 692                     gfs2_tune_get(sdp, gt_new_files_directio))
 693                         di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
 694         } else if (S_ISDIR(mode)) {
 695                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
 696                                             GFS2_DIF_INHERIT_DIRECTIO);
 697                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
 698                                             GFS2_DIF_INHERIT_JDATA);
 699         }
 700
 701         di->__pad1 = 0;
 702         di->di_payload_format = cpu_to_be32(0);
 703         di->di_height = cpu_to_be32(0);
 704         di->__pad2 = 0;
 705         di->__pad3 = 0;
 706         di->di_depth = cpu_to_be16(0);
 707         di->di_entries = cpu_to_be32(0);
 708         memset(&di->__pad4, 0, sizeof(di->__pad4));
 709         di->di_eattr = cpu_to_be64(0);
 710         memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 711
 712         brelse(dibh);
 713 }
 714
 715 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 716                        unsigned int mode, const struct gfs2_inum_host *inum,
 717                        const u64 *generation, dev_t dev)
 718 {
 719         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 720         unsigned int uid, gid;
 721         int error;
 722
 723         munge_mode_uid_gid(dip, &mode, &uid, &gid);
 724         gfs2_alloc_get(dip);
 725
 726         error = gfs2_quota_lock(dip, uid, gid);
 727         if (error)
 728                 goto out;
 729
 730         error = gfs2_quota_check(dip, uid, gid);
 731         if (error)
 732                 goto out_quota;
 733
 734         error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
 735         if (error)
 736                 goto out_quota;
 737
 738         init_dinode(dip, gl, inum, mode, uid, gid, generation, dev);
 739         gfs2_quota_change(dip, +1, uid, gid);
 740         gfs2_trans_end(sdp);
 741
 742 out_quota:
 743         gfs2_quota_unlock(dip);
 744 out:
 745         gfs2_alloc_put(dip);
 746         return error;
 747 }
 748
 749 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 750                        struct gfs2_inode *ip)
 751 {
 752         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 753         struct gfs2_alloc *al;
 754         int alloc_required;
 755         struct buffer_head *dibh;
 756         int error;
 757
 758         al = gfs2_alloc_get(dip);
 759
 760         error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 761         if (error)
 762                 goto fail;
 763
 764         error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
 765         if (alloc_required < 0)
 766                 goto fail;
 767         if (alloc_required) {
 768                 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
 769                 if (error)
 770                         goto fail_quota_locks;
 771
 772                 al->al_requested = sdp->sd_max_dirres;
 773
 774                 error = gfs2_inplace_reserve(dip);
 775                 if (error)
 776                         goto fail_quota_locks;
 777
 778                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 779                                          al->al_rgd->rd_ri.ri_length +
 780                                          2 * RES_DINODE +
 781                                          RES_STATFS + RES_QUOTA, 0);
 782                 if (error)
 783                         goto fail_ipreserv;
 784         } else {
 785                 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 786                 if (error)
 787                         goto fail_quota_locks;
 788         }
 789
 790         error = gfs2_dir_add(&dip->i_inode, name, &ip->i_num, IF2DT(ip->i_inode.i_mode));
 791         if (error)
 792                 goto fail_end_trans;
 793
 794         error = gfs2_meta_inode_buffer(ip, &dibh);
 795         if (error)
 796                 goto fail_end_trans;
 797         ip->i_inode.i_nlink = 1;
 798         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 799         gfs2_dinode_out(ip, dibh->b_data);
 800         brelse(dibh);
 801         return 0;
 802
 803 fail_end_trans:
 804         gfs2_trans_end(sdp);
 805
 806 fail_ipreserv:
 807         if (dip->i_alloc.al_rgd)
 808                 gfs2_inplace_release(dip);
 809
 810 fail_quota_locks:
 811         gfs2_quota_unlock(dip);
 812
 813 fail:
 814         gfs2_alloc_put(dip);
 815         return error;
 816 }
 817
 818 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
 819 {
 820         int err;
 821         size_t len;
 822         void *value;
 823         char *name;
 824         struct gfs2_ea_request er;
 825
 826         err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
 827                                            &name, &value, &len);
 828
 829         if (err) {
 830                 if (err == -EOPNOTSUPP)
 831                         return 0;
 832                 return err;
 833         }
 834
 835         memset(&er, 0, sizeof(struct gfs2_ea_request));
 836
 837         er.er_type = GFS2_EATYPE_SECURITY;
 838         er.er_name = name;
 839         er.er_data = value;
 840         er.er_name_len = strlen(name);
 841         er.er_data_len = len;
 842
 843         err = gfs2_ea_set_i(ip, &er);
 844
 845         kfree(value);
 846         kfree(name);
 847
 848         return err;
 849 }
 850
 851 /**
 852  * gfs2_createi - Create a new inode
 853  * @ghs: An array of two holders
 854  * @name: The name of the new file
 855  * @mode: the permissions on the new inode
 856  *
 857  * @ghs[0] is an initialized holder for the directory
 858  * @ghs[1] is the holder for the inode lock
 859  *
 860  * If the return value is not NULL, the glocks on both the directory and the new
 861  * file are held.  A transaction has been started and an inplace reservation
 862  * is held, as well.
 863  *
 864  * Returns: An inode
 865  */
 866
 867 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
 868                            unsigned int mode, dev_t dev)
 869 {
 870         struct inode *inode;
 871         struct gfs2_inode *dip = ghs->gh_gl->gl_object;
 872         struct inode *dir = &dip->i_inode;
 873         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 874         struct gfs2_inum_host inum;
 875         int error;
 876         u64 generation;
 877
 878         if (!name->len || name->len > GFS2_FNAMESIZE)
 879                 return ERR_PTR(-ENAMETOOLONG);
 880
 881         gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
 882         error = gfs2_glock_nq(ghs);
 883         if (error)
 884                 goto fail;
 885
 886         error = create_ok(dip, name, mode);
 887         if (error)
 888                 goto fail_gunlock;
 889
 890         error = pick_formal_ino(sdp, &inum.no_formal_ino);
 891         if (error)
 892                 goto fail_gunlock;
 893
 894         error = alloc_dinode(dip, &inum, &generation);
 895         if (error)
 896                 goto fail_gunlock;
 897
 898         if (inum.no_addr < dip->i_num.no_addr) {
 899                 gfs2_glock_dq(ghs);
 900
 901                 error = gfs2_glock_nq_num(sdp, inum.no_addr,
 902                                           &gfs2_inode_glops, LM_ST_EXCLUSIVE,
 903                                           GL_SKIP, ghs + 1);
 904                 if (error) {
 905                         return ERR_PTR(error);
 906                 }
 907
 908                 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
 909                 error = gfs2_glock_nq(ghs);
 910                 if (error) {
 911                         gfs2_glock_dq_uninit(ghs + 1);
 912                         return ERR_PTR(error);
 913                 }
 914
 915                 error = create_ok(dip, name, mode);
 916                 if (error)
 917                         goto fail_gunlock2;
 918         } else {
 919                 error = gfs2_glock_nq_num(sdp, inum.no_addr,
 920                                           &gfs2_inode_glops, LM_ST_EXCLUSIVE,
 921                                           GL_SKIP, ghs + 1);
 922                 if (error)
 923                         goto fail_gunlock;
 924         }
 925
 926         error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev);
 927         if (error)
 928                 goto fail_gunlock2;
 929
 930         inode = gfs2_inode_lookup(dir->i_sb, &inum, IF2DT(mode));
 931         if (IS_ERR(inode))
 932                 goto fail_gunlock2;
 933
 934         error = gfs2_inode_refresh(GFS2_I(inode));
 935         if (error)
 936                 goto fail_iput;
 937
 938         error = gfs2_acl_create(dip, GFS2_I(inode));
 939         if (error)
 940                 goto fail_iput;
 941
 942         error = gfs2_security_init(dip, GFS2_I(inode));
 943         if (error)
 944                 goto fail_iput;
 945
 946         error = link_dinode(dip, name, GFS2_I(inode));
 947         if (error)
 948                 goto fail_iput;
 949
 950         if (!inode)
 951                 return ERR_PTR(-ENOMEM);
 952         return inode;
 953
 954 fail_iput:
 955         iput(inode);
 956 fail_gunlock2:
 957         gfs2_glock_dq_uninit(ghs + 1);
 958 fail_gunlock:
 959         gfs2_glock_dq(ghs);
 960 fail:
 961         return ERR_PTR(error);
 962 }
 963
 964 /**
 965  * gfs2_rmdiri - Remove a directory
 966  * @dip: The parent directory of the directory to be removed
 967  * @name: The name of the directory to be removed
 968  * @ip: The GFS2 inode of the directory to be removed
 969  *
 970  * Assumes Glocks on dip and ip are held
 971  *
 972  * Returns: errno
 973  */
 974
 975 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
 976                 struct gfs2_inode *ip)
 977 {
 978         struct qstr dotname;
 979         int error;
 980
 981         if (ip->i_di.di_entries != 2) {
 982                 if (gfs2_consist_inode(ip))
 983                         gfs2_dinode_print(ip);
 984                 return -EIO;
 985         }
 986
 987         error = gfs2_dir_del(dip, name);
 988         if (error)
 989                 return error;
 990
 991         error = gfs2_change_nlink(dip, -1);
 992         if (error)
 993                 return error;
 994
 995         gfs2_str2qstr(&dotname, ".");
 996         error = gfs2_dir_del(ip, &dotname);
 997         if (error)
 998                 return error;
 999
1000         gfs2_str2qstr(&dotname, "..");
1001         error = gfs2_dir_del(ip, &dotname);
1002         if (error)
1003                 return error;
1004
1005         /* It looks odd, but it really should be done twice */
1006         error = gfs2_change_nlink(ip, -1);
1007         if (error)
1008                 return error;
1009
1010         error = gfs2_change_nlink(ip, -1);
1011         if (error)
1012                 return error;
1013
1014         return error;
1015 }
1016
1017 /*
1018  * gfs2_unlink_ok - check to see that a inode is still in a directory
1019  * @dip: the directory
1020  * @name: the name of the file
1021  * @ip: the inode
1022  *
1023  * Assumes that the lock on (at least) @dip is held.
1024  *
1025  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1026  */
1027
1028 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
1029                    struct gfs2_inode *ip)
1030 {
1031         struct gfs2_inum_host inum;
1032         unsigned int type;
1033         int error;
1034
1035         if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
1036                 return -EPERM;
1037
1038         if ((dip->i_inode.i_mode & S_ISVTX) &&
1039             dip->i_inode.i_uid != current->fsuid &&
1040             ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER))
1041                 return -EPERM;
1042
1043         if (IS_APPEND(&dip->i_inode))
1044                 return -EPERM;
1045
1046         error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
1047         if (error)
1048                 return error;
1049
1050         error = gfs2_dir_search(&dip->i_inode, name, &inum, &type);
1051         if (error)
1052                 return error;
1053
1054         if (!gfs2_inum_equal(&inum, &ip->i_num))
1055                 return -ENOENT;
1056
1057         if (IF2DT(ip->i_inode.i_mode) != type) {
1058                 gfs2_consist_inode(dip);
1059                 return -EIO;
1060         }
1061
1062         return 0;
1063 }
1064
1065 /*
1066  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1067  * @this: move this
1068  * @to: to here
1069  *
1070  * Follow @to back to the root and make sure we don't encounter @this
1071  * Assumes we already hold the rename lock.
1072  *
1073  * Returns: errno
1074  */
1075
1076 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1077 {
1078         struct inode *dir = &to->i_inode;
1079         struct super_block *sb = dir->i_sb;
1080         struct inode *tmp;
1081         struct qstr dotdot;
1082         int error = 0;
1083
1084         gfs2_str2qstr(&dotdot, "..");
1085
1086         igrab(dir);
1087
1088         for (;;) {
1089                 if (dir == &this->i_inode) {
1090                         error = -EINVAL;
1091                         break;
1092                 }
1093                 if (dir == sb->s_root->d_inode) {
1094                         error = 0;
1095                         break;
1096                 }
1097
1098                 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1099                 if (IS_ERR(tmp)) {
1100                         error = PTR_ERR(tmp);
1101                         break;
1102                 }
1103
1104                 iput(dir);
1105                 dir = tmp;
1106         }
1107
1108         iput(dir);
1109
1110         return error;
1111 }
1112
1113 /**
1114  * gfs2_readlinki - return the contents of a symlink
1115  * @ip: the symlink's inode
1116  * @buf: a pointer to the buffer to be filled
1117  * @len: a pointer to the length of @buf
1118  *
1119  * If @buf is too small, a piece of memory is kmalloc()ed and needs
1120  * to be freed by the caller.
1121  *
1122  * Returns: errno
1123  */
1124
1125 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1126 {
1127         struct gfs2_holder i_gh;
1128         struct buffer_head *dibh;
1129         unsigned int x;
1130         int error;
1131
1132         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1133         error = gfs2_glock_nq_atime(&i_gh);
1134         if (error) {
1135                 gfs2_holder_uninit(&i_gh);
1136                 return error;
1137         }
1138
1139         if (!ip->i_di.di_size) {
1140                 gfs2_consist_inode(ip);
1141                 error = -EIO;
1142                 goto out;
1143         }
1144
1145         error = gfs2_meta_inode_buffer(ip, &dibh);
1146         if (error)
1147                 goto out;
1148
1149         x = ip->i_di.di_size + 1;
1150         if (x > *len) {
1151                 *buf = kmalloc(x, GFP_KERNEL);
1152                 if (!*buf) {
1153                         error = -ENOMEM;
1154                         goto out_brelse;
1155                 }
1156         }
1157
1158         memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1159         *len = x;
1160
1161 out_brelse:
1162         brelse(dibh);
1163 out:
1164         gfs2_glock_dq_uninit(&i_gh);
1165         return error;
1166 }
1167
1168 /**
1169  * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1170  *       conditionally update the inode's atime
1171  * @gh: the holder to acquire
1172  *
1173  * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1174  * Update if the difference between the current time and the inode's current
1175  * atime is greater than an interval specified at mount.
1176  *
1177  * Returns: errno
1178  */
1179
1180 int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1181 {
1182         struct gfs2_glock *gl = gh->gh_gl;
1183         struct gfs2_sbd *sdp = gl->gl_sbd;
1184         struct gfs2_inode *ip = gl->gl_object;
1185         s64 curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
1186         unsigned int state;
1187         int flags;
1188         int error;
1189
1190         if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1191             gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1192             gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1193                 return -EINVAL;
1194
1195         state = gh->gh_state;
1196         flags = gh->gh_flags;
1197
1198         error = gfs2_glock_nq(gh);
1199         if (error)
1200                 return error;
1201
1202         if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1203             (sdp->sd_vfs->s_flags & MS_RDONLY))
1204                 return 0;
1205
1206         curtime = get_seconds();
1207         if (curtime - ip->i_inode.i_atime.tv_sec >= quantum) {
1208                 gfs2_glock_dq(gh);
1209                 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY,
1210                                    gh);
1211                 error = gfs2_glock_nq(gh);
1212                 if (error)
1213                         return error;
1214
1215                 /* Verify that atime hasn't been updated while we were
1216                    trying to get exclusive lock. */
1217
1218                 curtime = get_seconds();
1219                 if (curtime - ip->i_inode.i_atime.tv_sec >= quantum) {
1220                         struct buffer_head *dibh;
1221                         struct gfs2_dinode *di;
1222
1223                         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1224                         if (error == -EROFS)
1225                                 return 0;
1226                         if (error)
1227                                 goto fail;
1228
1229                         error = gfs2_meta_inode_buffer(ip, &dibh);
1230                         if (error)
1231                                 goto fail_end_trans;
1232
1233                         ip->i_inode.i_atime.tv_sec = curtime;
1234
1235                         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1236                         di = (struct gfs2_dinode *)dibh->b_data;
1237                         di->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1238                         brelse(dibh);
1239
1240                         gfs2_trans_end(sdp);
1241                 }
1242
1243                 /* If someone else has asked for the glock,
1244                    unlock and let them have it. Then reacquire
1245                    in the original state. */
1246                 if (gfs2_glock_is_blocking(gl)) {
1247                         gfs2_glock_dq(gh);
1248                         gfs2_holder_reinit(state, flags, gh);
1249                         return gfs2_glock_nq(gh);
1250                 }
1251         }
1252
1253         return 0;
1254
1255 fail_end_trans:
1256         gfs2_trans_end(sdp);
1257 fail:
1258         gfs2_glock_dq(gh);
1259         return error;
1260 }
1261
1262 /**
1263  * glock_compare_atime - Compare two struct gfs2_glock structures for sort
1264  * @arg_a: the first structure
1265  * @arg_b: the second structure
1266  *
1267  * Returns: 1 if A > B
1268  *         -1 if A < B
1269  *          0 if A == B
1270  */
1271
1272 static int glock_compare_atime(const void *arg_a, const void *arg_b)
1273 {
1274         const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
1275         const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
1276         const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1277         const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
1278
1279         if (a->ln_number > b->ln_number)
1280                 return 1;
1281         if (a->ln_number < b->ln_number)
1282                 return -1;
1283         if (gh_a->gh_state == LM_ST_SHARED && gh_b->gh_state == LM_ST_EXCLUSIVE)
1284                 return 1;
1285         if (gh_a->gh_state == LM_ST_SHARED && (gh_b->gh_flags & GL_ATIME))
1286                 return 1;
1287
1288         return 0;
1289 }
1290
1291 /**
1292  * gfs2_glock_nq_m_atime - acquire multiple glocks where one may need an
1293  *      atime update
1294  * @num_gh: the number of structures
1295  * @ghs: an array of struct gfs2_holder structures
1296  *
1297  * Returns: 0 on success (all glocks acquired),
1298  *          errno on failure (no glocks acquired)
1299  */
1300
1301 int gfs2_glock_nq_m_atime(unsigned int num_gh, struct gfs2_holder *ghs)
1302 {
1303         struct gfs2_holder **p;
1304         unsigned int x;
1305         int error = 0;
1306
1307         if (!num_gh)
1308                 return 0;
1309
1310         if (num_gh == 1) {
1311                 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1312                 if (ghs->gh_flags & GL_ATIME)
1313                         error = gfs2_glock_nq_atime(ghs);
1314                 else
1315                         error = gfs2_glock_nq(ghs);
1316                 return error;
1317         }
1318
1319         p = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL);
1320         if (!p)
1321                 return -ENOMEM;
1322
1323         for (x = 0; x < num_gh; x++)
1324                 p[x] = &ghs[x];
1325
1326         sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare_atime,NULL);
1327
1328         for (x = 0; x < num_gh; x++) {
1329                 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1330
1331                 if (p[x]->gh_flags & GL_ATIME)
1332                         error = gfs2_glock_nq_atime(p[x]);
1333                 else
1334                         error = gfs2_glock_nq(p[x]);
1335
1336                 if (error) {
1337                         while (x--)
1338                                 gfs2_glock_dq(p[x]);
1339                         break;
1340                 }
1341         }
1342
1343         kfree(p);
1344         return error;
1345 }
1346
1347
1348 static int
1349 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1350 {
1351         struct buffer_head *dibh;
1352         int error;
1353
1354         error = gfs2_meta_inode_buffer(ip, &dibh);
1355         if (!error) {
1356                 error = inode_setattr(&ip->i_inode, attr);
1357                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1358                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1359                 gfs2_dinode_out(ip, dibh->b_data);
1360                 brelse(dibh);
1361         }
1362         return error;
1363 }
1364
1365 /**
1366  * gfs2_setattr_simple -
1367  * @ip:
1368  * @attr:
1369  *
1370  * Called with a reference on the vnode.
1371  *
1372  * Returns: errno
1373  */
1374
1375 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1376 {
1377         int error;
1378
1379         if (current->journal_info)
1380                 return __gfs2_setattr_simple(ip, attr);
1381
1382         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
1383         if (error)
1384                 return error;
1385
1386         error = __gfs2_setattr_simple(ip, attr);
1387         gfs2_trans_end(GFS2_SB(&ip->i_inode));
1388         return error;
1389 }
1390