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