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