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