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