1/* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10#include <linux/slab.h> 11#include <linux/spinlock.h> 12#include <linux/completion.h> 13#include <linux/buffer_head.h> 14#include <linux/namei.h> 15#include <linux/mm.h> 16#include <linux/xattr.h> 17#include <linux/posix_acl.h> 18#include <linux/gfs2_ondisk.h> 19#include <linux/crc32.h> 20#include <linux/fiemap.h> 21#include <asm/uaccess.h> 22 23#include "gfs2.h" 24#include "incore.h" 25#include "acl.h" 26#include "bmap.h" 27#include "dir.h" 28#include "xattr.h" 29#include "glock.h" 30#include "inode.h" 31#include "meta_io.h" 32#include "quota.h" 33#include "rgrp.h" 34#include "trans.h" 35#include "util.h" 36#include "super.h" 37 38/** 39 * gfs2_create - Create a file 40 * @dir: The directory in which to create the file 41 * @dentry: The dentry of the new file 42 * @mode: The mode of the new file 43 * 44 * Returns: errno 45 */ 46 47static int gfs2_create(struct inode *dir, struct dentry *dentry, 48 int mode, struct nameidata *nd) 49{ 50 struct gfs2_inode *dip = GFS2_I(dir); 51 struct gfs2_sbd *sdp = GFS2_SB(dir); 52 struct gfs2_holder ghs[2]; 53 struct inode *inode; 54 55 gfs2_holder_init(dip->i_gl, 0, 0, ghs); 56 57 for (;;) { 58 inode = gfs2_createi(ghs, &dentry->d_name, S_IFREG | mode, 0); 59 if (!IS_ERR(inode)) { 60 gfs2_trans_end(sdp); 61 if (dip->i_alloc->al_rgd) 62 gfs2_inplace_release(dip); 63 gfs2_quota_unlock(dip); 64 gfs2_alloc_put(dip); 65 gfs2_glock_dq_uninit_m(2, ghs); 66 mark_inode_dirty(inode); 67 break; 68 } else if (PTR_ERR(inode) != -EEXIST || 69 (nd && nd->flags & LOOKUP_EXCL)) { 70 gfs2_holder_uninit(ghs); 71 return PTR_ERR(inode); 72 } 73 74 inode = gfs2_lookupi(dir, &dentry->d_name, 0); 75 if (inode) { 76 if (!IS_ERR(inode)) { 77 gfs2_holder_uninit(ghs); 78 break; 79 } else { 80 gfs2_holder_uninit(ghs); 81 return PTR_ERR(inode); 82 } 83 } 84 } 85 86 d_instantiate(dentry, inode); 87 88 return 0; 89} 90 91/** 92 * gfs2_lookup - Look up a filename in a directory and return its inode 93 * @dir: The directory inode 94 * @dentry: The dentry of the new inode 95 * @nd: passed from Linux VFS, ignored by us 96 * 97 * Called by the VFS layer. Lock dir and call gfs2_lookupi() 98 * 99 * Returns: errno 100 */ 101 102static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry, 103 struct nameidata *nd) 104{ 105 struct inode *inode = NULL; 106 107 dentry->d_op = &gfs2_dops; 108 109 inode = gfs2_lookupi(dir, &dentry->d_name, 0); 110 if (inode && IS_ERR(inode)) 111 return ERR_CAST(inode); 112 113 if (inode) { 114 struct gfs2_glock *gl = GFS2_I(inode)->i_gl; 115 struct gfs2_holder gh; 116 int error; 117 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh); 118 if (error) { 119 iput(inode); 120 return ERR_PTR(error); 121 } 122 gfs2_glock_dq_uninit(&gh); 123 return d_splice_alias(inode, dentry); 124 } 125 d_add(dentry, inode); 126 127 return NULL; 128} 129 130/** 131 * gfs2_link - Link to a file 132 * @old_dentry: The inode to link 133 * @dir: Add link to this directory 134 * @dentry: The name of the link 135 * 136 * Link the inode in "old_dentry" into the directory "dir" with the 137 * name in "dentry". 138 * 139 * Returns: errno 140 */ 141 142static int gfs2_link(struct dentry *old_dentry, struct inode *dir, 143 struct dentry *dentry) 144{ 145 struct gfs2_inode *dip = GFS2_I(dir); 146 struct gfs2_sbd *sdp = GFS2_SB(dir); 147 struct inode *inode = old_dentry->d_inode; 148 struct gfs2_inode *ip = GFS2_I(inode); 149 struct gfs2_holder ghs[2]; 150 int alloc_required; 151 int error; 152 153 if (S_ISDIR(inode->i_mode)) 154 return -EPERM; 155 156 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 157 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1); 158 159 error = gfs2_glock_nq(ghs); /* parent */ 160 if (error) 161 goto out_parent; 162 163 error = gfs2_glock_nq(ghs + 1); /* child */ 164 if (error) 165 goto out_child; 166 167 error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC); 168 if (error) 169 goto out_gunlock; 170 171 error = gfs2_dir_check(dir, &dentry->d_name, NULL); 172 switch (error) { 173 case -ENOENT: 174 break; 175 case 0: 176 error = -EEXIST; 177 default: 178 goto out_gunlock; 179 } 180 181 error = -EINVAL; 182 if (!dip->i_inode.i_nlink) 183 goto out_gunlock; 184 error = -EFBIG; 185 if (dip->i_entries == (u32)-1) 186 goto out_gunlock; 187 error = -EPERM; 188 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 189 goto out_gunlock; 190 error = -EINVAL; 191 if (!ip->i_inode.i_nlink) 192 goto out_gunlock; 193 error = -EMLINK; 194 if (ip->i_inode.i_nlink == (u32)-1) 195 goto out_gunlock; 196 197 alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name); 198 if (error < 0) 199 goto out_gunlock; 200 error = 0; 201 202 if (alloc_required) { 203 struct gfs2_alloc *al = gfs2_alloc_get(dip); 204 if (!al) { 205 error = -ENOMEM; 206 goto out_gunlock; 207 } 208 209 error = gfs2_quota_lock_check(dip); 210 if (error) 211 goto out_alloc; 212 213 al->al_requested = sdp->sd_max_dirres; 214 215 error = gfs2_inplace_reserve(dip); 216 if (error) 217 goto out_gunlock_q; 218 219 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 220 al->al_rgd->rd_length + 221 2 * RES_DINODE + RES_STATFS + 222 RES_QUOTA, 0); 223 if (error) 224 goto out_ipres; 225 } else { 226 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0); 227 if (error) 228 goto out_ipres; 229 } 230 231 error = gfs2_dir_add(dir, &dentry->d_name, ip, IF2DT(inode->i_mode)); 232 if (error) 233 goto out_end_trans; 234 235 error = gfs2_change_nlink(ip, +1); 236 237out_end_trans: 238 gfs2_trans_end(sdp); 239out_ipres: 240 if (alloc_required) 241 gfs2_inplace_release(dip); 242out_gunlock_q: 243 if (alloc_required) 244 gfs2_quota_unlock(dip); 245out_alloc: 246 if (alloc_required) 247 gfs2_alloc_put(dip); 248out_gunlock: 249 gfs2_glock_dq(ghs + 1); 250out_child: 251 gfs2_glock_dq(ghs); 252out_parent: 253 gfs2_holder_uninit(ghs); 254 gfs2_holder_uninit(ghs + 1); 255 if (!error) { 256 atomic_inc(&inode->i_count); 257 d_instantiate(dentry, inode); 258 mark_inode_dirty(inode); 259 } 260 return error; 261} 262 263/* 264 * gfs2_unlink_ok - check to see that a inode is still in a directory 265 * @dip: the directory 266 * @name: the name of the file 267 * @ip: the inode 268 * 269 * Assumes that the lock on (at least) @dip is held. 270 * 271 * Returns: 0 if the parent/child relationship is correct, errno if it isn't 272 */ 273 274static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, 275 const struct gfs2_inode *ip) 276{ 277 int error; 278 279 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) 280 return -EPERM; 281 282 if ((dip->i_inode.i_mode & S_ISVTX) && 283 dip->i_inode.i_uid != current_fsuid() && 284 ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER)) 285 return -EPERM; 286 287 if (IS_APPEND(&dip->i_inode)) 288 return -EPERM; 289 290 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC); 291 if (error) 292 return error; 293 294 error = gfs2_dir_check(&dip->i_inode, name, ip); 295 if (error) 296 return error; 297 298 return 0; 299} 300 301/** 302 * gfs2_unlink - Unlink a file 303 * @dir: The inode of the directory containing the file to unlink 304 * @dentry: The file itself 305 * 306 * Unlink a file. Call gfs2_unlinki() 307 * 308 * Returns: errno 309 */ 310 311static int gfs2_unlink(struct inode *dir, struct dentry *dentry) 312{ 313 struct gfs2_inode *dip = GFS2_I(dir); 314 struct gfs2_sbd *sdp = GFS2_SB(dir); 315 struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 316 struct gfs2_holder ghs[3]; 317 struct gfs2_rgrpd *rgd; 318 struct gfs2_holder ri_gh; 319 int error; 320 321 error = gfs2_rindex_hold(sdp, &ri_gh); 322 if (error) 323 return error; 324 325 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 326 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1); 327 328 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr); 329 gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2); 330 331 332 error = gfs2_glock_nq(ghs); /* parent */ 333 if (error) 334 goto out_parent; 335 336 error = gfs2_glock_nq(ghs + 1); /* child */ 337 if (error) 338 goto out_child; 339 340 error = gfs2_glock_nq(ghs + 2); /* rgrp */ 341 if (error) 342 goto out_rgrp; 343 344 error = gfs2_unlink_ok(dip, &dentry->d_name, ip); 345 if (error) 346 goto out_gunlock; 347 348 error = gfs2_trans_begin(sdp, 2*RES_DINODE + RES_LEAF + RES_RG_BIT, 0); 349 if (error) 350 goto out_gunlock; 351 352 error = gfs2_dir_del(dip, &dentry->d_name); 353 if (error) 354 goto out_end_trans; 355 356 error = gfs2_change_nlink(ip, -1); 357 358out_end_trans: 359 gfs2_trans_end(sdp); 360out_gunlock: 361 gfs2_glock_dq(ghs + 2); 362out_rgrp: 363 gfs2_holder_uninit(ghs + 2); 364 gfs2_glock_dq(ghs + 1); 365out_child: 366 gfs2_holder_uninit(ghs + 1); 367 gfs2_glock_dq(ghs); 368out_parent: 369 gfs2_holder_uninit(ghs); 370 gfs2_glock_dq_uninit(&ri_gh); 371 return error; 372} 373 374/** 375 * gfs2_symlink - Create a symlink 376 * @dir: The directory to create the symlink in 377 * @dentry: The dentry to put the symlink in 378 * @symname: The thing which the link points to 379 * 380 * Returns: errno 381 */ 382 383static int gfs2_symlink(struct inode *dir, struct dentry *dentry, 384 const char *symname) 385{ 386 struct gfs2_inode *dip = GFS2_I(dir), *ip; 387 struct gfs2_sbd *sdp = GFS2_SB(dir); 388 struct gfs2_holder ghs[2]; 389 struct inode *inode; 390 struct buffer_head *dibh; 391 int size; 392 int error; 393 394 /* Must be stuffed with a null terminator for gfs2_follow_link() */ 395 size = strlen(symname); 396 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1) 397 return -ENAMETOOLONG; 398 399 gfs2_holder_init(dip->i_gl, 0, 0, ghs); 400 401 inode = gfs2_createi(ghs, &dentry->d_name, S_IFLNK | S_IRWXUGO, 0); 402 if (IS_ERR(inode)) { 403 gfs2_holder_uninit(ghs); 404 return PTR_ERR(inode); 405 } 406 407 ip = ghs[1].gh_gl->gl_object; 408 409 ip->i_disksize = size; 410 i_size_write(inode, size); 411 412 error = gfs2_meta_inode_buffer(ip, &dibh); 413 414 if (!gfs2_assert_withdraw(sdp, !error)) { 415 gfs2_dinode_out(ip, dibh->b_data); 416 memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, 417 size); 418 brelse(dibh); 419 } 420 421 gfs2_trans_end(sdp); 422 if (dip->i_alloc->al_rgd) 423 gfs2_inplace_release(dip); 424 gfs2_quota_unlock(dip); 425 gfs2_alloc_put(dip); 426 427 gfs2_glock_dq_uninit_m(2, ghs); 428 429 d_instantiate(dentry, inode); 430 mark_inode_dirty(inode); 431 432 return 0; 433} 434 435/** 436 * gfs2_mkdir - Make a directory 437 * @dir: The parent directory of the new one 438 * @dentry: The dentry of the new directory 439 * @mode: The mode of the new directory 440 * 441 * Returns: errno 442 */ 443 444static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode) 445{ 446 struct gfs2_inode *dip = GFS2_I(dir), *ip; 447 struct gfs2_sbd *sdp = GFS2_SB(dir); 448 struct gfs2_holder ghs[2]; 449 struct inode *inode; 450 struct buffer_head *dibh; 451 int error; 452 453 gfs2_holder_init(dip->i_gl, 0, 0, ghs); 454 455 inode = gfs2_createi(ghs, &dentry->d_name, S_IFDIR | mode, 0); 456 if (IS_ERR(inode)) { 457 gfs2_holder_uninit(ghs); 458 return PTR_ERR(inode); 459 } 460 461 ip = ghs[1].gh_gl->gl_object; 462 463 ip->i_inode.i_nlink = 2; 464 ip->i_disksize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode); 465 ip->i_diskflags |= GFS2_DIF_JDATA; 466 ip->i_entries = 2; 467 468 error = gfs2_meta_inode_buffer(ip, &dibh); 469 470 if (!gfs2_assert_withdraw(sdp, !error)) { 471 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data; 472 struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1); 473 struct qstr str; 474 475 gfs2_str2qstr(&str, "."); 476 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 477 gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent); 478 dent->de_inum = di->di_num; /* already GFS2 endian */ 479 dent->de_type = cpu_to_be16(DT_DIR); 480 di->di_entries = cpu_to_be32(1); 481 482 gfs2_str2qstr(&str, ".."); 483 dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1)); 484 gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent); 485 486 gfs2_inum_out(dip, dent); 487 dent->de_type = cpu_to_be16(DT_DIR); 488 489 gfs2_dinode_out(ip, di); 490 491 brelse(dibh); 492 } 493 494 error = gfs2_change_nlink(dip, +1); 495 gfs2_assert_withdraw(sdp, !error); /* dip already pinned */ 496 497 gfs2_trans_end(sdp); 498 if (dip->i_alloc->al_rgd) 499 gfs2_inplace_release(dip); 500 gfs2_quota_unlock(dip); 501 gfs2_alloc_put(dip); 502 503 gfs2_glock_dq_uninit_m(2, ghs); 504 505 d_instantiate(dentry, inode); 506 mark_inode_dirty(inode); 507 508 return 0; 509} 510 511/** 512 * gfs2_rmdiri - Remove a directory 513 * @dip: The parent directory of the directory to be removed 514 * @name: The name of the directory to be removed 515 * @ip: The GFS2 inode of the directory to be removed 516 * 517 * Assumes Glocks on dip and ip are held 518 * 519 * Returns: errno 520 */ 521 522static int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name, 523 struct gfs2_inode *ip) 524{ 525 struct qstr dotname; 526 int error; 527 528 if (ip->i_entries != 2) { 529 if (gfs2_consist_inode(ip)) 530 gfs2_dinode_print(ip); 531 return -EIO; 532 } 533 534 error = gfs2_dir_del(dip, name); 535 if (error) 536 return error; 537 538 error = gfs2_change_nlink(dip, -1); 539 if (error) 540 return error; 541 542 gfs2_str2qstr(&dotname, "."); 543 error = gfs2_dir_del(ip, &dotname); 544 if (error) 545 return error; 546 547 gfs2_str2qstr(&dotname, ".."); 548 error = gfs2_dir_del(ip, &dotname); 549 if (error) 550 return error; 551 552 /* It looks odd, but it really should be done twice */ 553 error = gfs2_change_nlink(ip, -1); 554 if (error) 555 return error; 556 557 error = gfs2_change_nlink(ip, -1); 558 if (error) 559 return error; 560 561 return error; 562} 563 564/** 565 * gfs2_rmdir - Remove a directory 566 * @dir: The parent directory of the directory to be removed 567 * @dentry: The dentry of the directory to remove 568 * 569 * Remove a directory. Call gfs2_rmdiri() 570 * 571 * Returns: errno 572 */ 573 574static int gfs2_rmdir(struct inode *dir, struct dentry *dentry) 575{ 576 struct gfs2_inode *dip = GFS2_I(dir); 577 struct gfs2_sbd *sdp = GFS2_SB(dir); 578 struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 579 struct gfs2_holder ghs[3]; 580 struct gfs2_rgrpd *rgd; 581 struct gfs2_holder ri_gh; 582 int error; 583 584 error = gfs2_rindex_hold(sdp, &ri_gh); 585 if (error) 586 return error; 587 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 588 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1); 589 590 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr); 591 gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2); 592 593 error = gfs2_glock_nq(ghs); /* parent */ 594 if (error) 595 goto out_parent; 596 597 error = gfs2_glock_nq(ghs + 1); /* child */ 598 if (error) 599 goto out_child; 600 601 error = gfs2_glock_nq(ghs + 2); /* rgrp */ 602 if (error) 603 goto out_rgrp; 604 605 error = gfs2_unlink_ok(dip, &dentry->d_name, ip); 606 if (error) 607 goto out_gunlock; 608 609 if (ip->i_entries < 2) { 610 if (gfs2_consist_inode(ip)) 611 gfs2_dinode_print(ip); 612 error = -EIO; 613 goto out_gunlock; 614 } 615 if (ip->i_entries > 2) { 616 error = -ENOTEMPTY; 617 goto out_gunlock; 618 } 619 620 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + 3 * RES_LEAF + RES_RG_BIT, 0); 621 if (error) 622 goto out_gunlock; 623 624 error = gfs2_rmdiri(dip, &dentry->d_name, ip); 625 626 gfs2_trans_end(sdp); 627 628out_gunlock: 629 gfs2_glock_dq(ghs + 2); 630out_rgrp: 631 gfs2_holder_uninit(ghs + 2); 632 gfs2_glock_dq(ghs + 1); 633out_child: 634 gfs2_holder_uninit(ghs + 1); 635 gfs2_glock_dq(ghs); 636out_parent: 637 gfs2_holder_uninit(ghs); 638 gfs2_glock_dq_uninit(&ri_gh); 639 return error; 640} 641 642/** 643 * gfs2_mknod - Make a special file 644 * @dir: The directory in which the special file will reside 645 * @dentry: The dentry of the special file 646 * @mode: The mode of the special file 647 * @rdev: The device specification of the special file 648 * 649 */ 650 651static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode, 652 dev_t dev) 653{ 654 struct gfs2_inode *dip = GFS2_I(dir); 655 struct gfs2_sbd *sdp = GFS2_SB(dir); 656 struct gfs2_holder ghs[2]; 657 struct inode *inode; 658 659 gfs2_holder_init(dip->i_gl, 0, 0, ghs); 660 661 inode = gfs2_createi(ghs, &dentry->d_name, mode, dev); 662 if (IS_ERR(inode)) { 663 gfs2_holder_uninit(ghs); 664 return PTR_ERR(inode); 665 } 666 667 gfs2_trans_end(sdp); 668 if (dip->i_alloc->al_rgd) 669 gfs2_inplace_release(dip); 670 gfs2_quota_unlock(dip); 671 gfs2_alloc_put(dip); 672 673 gfs2_glock_dq_uninit_m(2, ghs); 674 675 d_instantiate(dentry, inode); 676 mark_inode_dirty(inode); 677 678 return 0; 679} 680 681/* 682 * gfs2_ok_to_move - check if it's ok to move a directory to another directory 683 * @this: move this 684 * @to: to here 685 * 686 * Follow @to back to the root and make sure we don't encounter @this 687 * Assumes we already hold the rename lock. 688 * 689 * Returns: errno 690 */ 691 692static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) 693{ 694 struct inode *dir = &to->i_inode; 695 struct super_block *sb = dir->i_sb; 696 struct inode *tmp; 697 struct qstr dotdot; 698 int error = 0; 699 700 gfs2_str2qstr(&dotdot, ".."); 701 702 igrab(dir); 703 704 for (;;) { 705 if (dir == &this->i_inode) { 706 error = -EINVAL; 707 break; 708 } 709 if (dir == sb->s_root->d_inode) { 710 error = 0; 711 break; 712 } 713 714 tmp = gfs2_lookupi(dir, &dotdot, 1); 715 if (IS_ERR(tmp)) { 716 error = PTR_ERR(tmp); 717 break; 718 } 719 720 iput(dir); 721 dir = tmp; 722 } 723 724 iput(dir); 725 726 return error; 727} 728 729/** 730 * gfs2_rename - Rename a file 731 * @odir: Parent directory of old file name 732 * @odentry: The old dentry of the file 733 * @ndir: Parent directory of new file name 734 * @ndentry: The new dentry of the file 735 * 736 * Returns: errno 737 */ 738 739static int gfs2_rename(struct inode *odir, struct dentry *odentry, 740 struct inode *ndir, struct dentry *ndentry) 741{ 742 struct gfs2_inode *odip = GFS2_I(odir); 743 struct gfs2_inode *ndip = GFS2_I(ndir); 744 struct gfs2_inode *ip = GFS2_I(odentry->d_inode); 745 struct gfs2_inode *nip = NULL; 746 struct gfs2_sbd *sdp = GFS2_SB(odir); 747 struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }; 748 struct gfs2_rgrpd *nrgd; 749 unsigned int num_gh; 750 int dir_rename = 0; 751 int alloc_required = 0; 752 unsigned int x; 753 int error; 754 755 if (ndentry->d_inode) { 756 nip = GFS2_I(ndentry->d_inode); 757 if (ip == nip) 758 return 0; 759 } 760 761 762 if (odip != ndip) { 763 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE, 764 0, &r_gh); 765 if (error) 766 goto out; 767 768 if (S_ISDIR(ip->i_inode.i_mode)) { 769 dir_rename = 1; 770 /* don't move a dirctory into it's subdir */ 771 error = gfs2_ok_to_move(ip, ndip); 772 if (error) 773 goto out_gunlock_r; 774 } 775 } 776 777 num_gh = 1; 778 gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 779 if (odip != ndip) { 780 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 781 num_gh++; 782 } 783 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 784 num_gh++; 785 786 if (nip) { 787 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 788 num_gh++; 789 /* grab the resource lock for unlink flag twiddling 790 * this is the case of the target file already existing 791 * so we unlink before doing the rename 792 */ 793 nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr); 794 if (nrgd) 795 gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++); 796 } 797 798 for (x = 0; x < num_gh; x++) { 799 error = gfs2_glock_nq(ghs + x); 800 if (error) 801 goto out_gunlock; 802 } 803 804 /* Check out the old directory */ 805 806 error = gfs2_unlink_ok(odip, &odentry->d_name, ip); 807 if (error) 808 goto out_gunlock; 809 810 /* Check out the new directory */ 811 812 if (nip) { 813 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip); 814 if (error) 815 goto out_gunlock; 816 817 if (S_ISDIR(nip->i_inode.i_mode)) { 818 if (nip->i_entries < 2) { 819 if (gfs2_consist_inode(nip)) 820 gfs2_dinode_print(nip); 821 error = -EIO; 822 goto out_gunlock; 823 } 824 if (nip->i_entries > 2) { 825 error = -ENOTEMPTY; 826 goto out_gunlock; 827 } 828 } 829 } else { 830 error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC); 831 if (error) 832 goto out_gunlock; 833 834 error = gfs2_dir_check(ndir, &ndentry->d_name, NULL); 835 switch (error) { 836 case -ENOENT: 837 error = 0; 838 break; 839 case 0: 840 error = -EEXIST; 841 default: 842 goto out_gunlock; 843 }; 844 845 if (odip != ndip) { 846 if (!ndip->i_inode.i_nlink) { 847 error = -EINVAL; 848 goto out_gunlock; 849 } 850 if (ndip->i_entries == (u32)-1) { 851 error = -EFBIG; 852 goto out_gunlock; 853 } 854 if (S_ISDIR(ip->i_inode.i_mode) && 855 ndip->i_inode.i_nlink == (u32)-1) { 856 error = -EMLINK; 857 goto out_gunlock; 858 } 859 } 860 } 861 862 /* Check out the dir to be renamed */ 863 864 if (dir_rename) { 865 error = gfs2_permission(odentry->d_inode, MAY_WRITE); 866 if (error) 867 goto out_gunlock; 868 } 869 870 if (nip == NULL) 871 alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name); 872 error = alloc_required; 873 if (error < 0) 874 goto out_gunlock; 875 error = 0; 876 877 if (alloc_required) { 878 struct gfs2_alloc *al = gfs2_alloc_get(ndip); 879 if (!al) { 880 error = -ENOMEM; 881 goto out_gunlock; 882 } 883 884 error = gfs2_quota_lock_check(ndip); 885 if (error) 886 goto out_alloc; 887 888 al->al_requested = sdp->sd_max_dirres; 889 890 error = gfs2_inplace_reserve(ndip); 891 if (error) 892 goto out_gunlock_q; 893 894 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 895 al->al_rgd->rd_length + 896 4 * RES_DINODE + 4 * RES_LEAF + 897 RES_STATFS + RES_QUOTA + 4, 0); 898 if (error) 899 goto out_ipreserv; 900 } else { 901 error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 902 5 * RES_LEAF + 4, 0); 903 if (error) 904 goto out_gunlock; 905 } 906 907 /* Remove the target file, if it exists */ 908 909 if (nip) { 910 if (S_ISDIR(nip->i_inode.i_mode)) 911 error = gfs2_rmdiri(ndip, &ndentry->d_name, nip); 912 else { 913 error = gfs2_dir_del(ndip, &ndentry->d_name); 914 if (error) 915 goto out_end_trans; 916 error = gfs2_change_nlink(nip, -1); 917 } 918 if (error) 919 goto out_end_trans; 920 } 921 922 if (dir_rename) { 923 struct qstr name; 924 gfs2_str2qstr(&name, ".."); 925 926 error = gfs2_change_nlink(ndip, +1); 927 if (error) 928 goto out_end_trans; 929 error = gfs2_change_nlink(odip, -1); 930 if (error) 931 goto out_end_trans; 932 933 error = gfs2_dir_mvino(ip, &name, ndip, DT_DIR); 934 if (error) 935 goto out_end_trans; 936 } else { 937 struct buffer_head *dibh; 938 error = gfs2_meta_inode_buffer(ip, &dibh); 939 if (error) 940 goto out_end_trans; 941 ip->i_inode.i_ctime = CURRENT_TIME; 942 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 943 gfs2_dinode_out(ip, dibh->b_data); 944 brelse(dibh); 945 } 946 947 error = gfs2_dir_del(odip, &odentry->d_name); 948 if (error) 949 goto out_end_trans; 950 951 error = gfs2_dir_add(ndir, &ndentry->d_name, ip, IF2DT(ip->i_inode.i_mode)); 952 if (error) 953 goto out_end_trans; 954 955out_end_trans: 956 gfs2_trans_end(sdp); 957out_ipreserv: 958 if (alloc_required) 959 gfs2_inplace_release(ndip); 960out_gunlock_q: 961 if (alloc_required) 962 gfs2_quota_unlock(ndip); 963out_alloc: 964 if (alloc_required) 965 gfs2_alloc_put(ndip); 966out_gunlock: 967 while (x--) { 968 gfs2_glock_dq(ghs + x); 969 gfs2_holder_uninit(ghs + x); 970 } 971out_gunlock_r: 972 if (r_gh.gh_gl) 973 gfs2_glock_dq_uninit(&r_gh); 974out: 975 return error; 976} 977 978/** 979 * gfs2_follow_link - Follow a symbolic link 980 * @dentry: The dentry of the link 981 * @nd: Data that we pass to vfs_follow_link() 982 * 983 * This can handle symlinks of any size. 984 * 985 * Returns: 0 on success or error code 986 */ 987 988static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd) 989{ 990 struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 991 struct gfs2_holder i_gh; 992 struct buffer_head *dibh; 993 unsigned int x; 994 char *buf; 995 int error; 996 997 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh); 998 error = gfs2_glock_nq(&i_gh); 999 if (error) { 1000 gfs2_holder_uninit(&i_gh); 1001 nd_set_link(nd, ERR_PTR(error)); 1002 return NULL; 1003 } 1004 1005 if (!ip->i_disksize) { 1006 gfs2_consist_inode(ip); 1007 buf = ERR_PTR(-EIO); 1008 goto out; 1009 } 1010 1011 error = gfs2_meta_inode_buffer(ip, &dibh); 1012 if (error) { 1013 buf = ERR_PTR(error); 1014 goto out; 1015 } 1016 1017 x = ip->i_disksize + 1; 1018 buf = kmalloc(x, GFP_NOFS); 1019 if (!buf) 1020 buf = ERR_PTR(-ENOMEM); 1021 else 1022 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), x); 1023 brelse(dibh); 1024out: 1025 gfs2_glock_dq_uninit(&i_gh); 1026 nd_set_link(nd, buf); 1027 return NULL; 1028} 1029 1030static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p) 1031{ 1032 char *s = nd_get_link(nd); 1033 if (!IS_ERR(s)) 1034 kfree(s); 1035} 1036 1037/** 1038 * gfs2_permission - 1039 * @inode: 1040 * @mask: 1041 * @nd: passed from Linux VFS, ignored by us 1042 * 1043 * This may be called from the VFS directly, or from within GFS2 with the 1044 * inode locked, so we look to see if the glock is already locked and only 1045 * lock the glock if its not already been done. 1046 * 1047 * Returns: errno 1048 */ 1049 1050int gfs2_permission(struct inode *inode, int mask) 1051{ 1052 struct gfs2_inode *ip = GFS2_I(inode); 1053 struct gfs2_holder i_gh; 1054 int error; 1055 int unlock = 0; 1056 1057 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) { 1058 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); 1059 if (error) 1060 return error; 1061 unlock = 1; 1062 } 1063 1064 if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode)) 1065 error = -EACCES; 1066 else 1067 error = generic_permission(inode, mask, gfs2_check_acl); 1068 if (unlock) 1069 gfs2_glock_dq_uninit(&i_gh); 1070 1071 return error; 1072} 1073 1074static int setattr_size(struct inode *inode, struct iattr *attr) 1075{ 1076 struct gfs2_inode *ip = GFS2_I(inode); 1077 struct gfs2_sbd *sdp = GFS2_SB(inode); 1078 int error; 1079 1080 if (attr->ia_size != ip->i_disksize) { 1081 error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks); 1082 if (error) 1083 return error; 1084 truncate_setsize(inode, attr->ia_size); 1085 gfs2_trans_end(sdp); 1086 } 1087 1088 error = gfs2_truncatei(ip, attr->ia_size); 1089 if (error && (inode->i_size != ip->i_disksize)) 1090 i_size_write(inode, ip->i_disksize); 1091 1092 return error; 1093} 1094 1095static int setattr_chown(struct inode *inode, struct iattr *attr) 1096{ 1097 struct gfs2_inode *ip = GFS2_I(inode); 1098 struct gfs2_sbd *sdp = GFS2_SB(inode); 1099 struct buffer_head *dibh; 1100 u32 ouid, ogid, nuid, ngid; 1101 int error; 1102 1103 ouid = inode->i_uid; 1104 ogid = inode->i_gid; 1105 nuid = attr->ia_uid; 1106 ngid = attr->ia_gid; 1107 1108 if (!(attr->ia_valid & ATTR_UID) || ouid == nuid) 1109 ouid = nuid = NO_QUOTA_CHANGE; 1110 if (!(attr->ia_valid & ATTR_GID) || ogid == ngid) 1111 ogid = ngid = NO_QUOTA_CHANGE; 1112 1113 if (!gfs2_alloc_get(ip)) 1114 return -ENOMEM; 1115 1116 error = gfs2_quota_lock(ip, nuid, ngid); 1117 if (error) 1118 goto out_alloc; 1119 1120 if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) { 1121 error = gfs2_quota_check(ip, nuid, ngid); 1122 if (error) 1123 goto out_gunlock_q; 1124 } 1125 1126 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0); 1127 if (error) 1128 goto out_gunlock_q; 1129 1130 error = gfs2_meta_inode_buffer(ip, &dibh); 1131 if (error) 1132 goto out_end_trans; 1133 1134 if ((attr->ia_valid & ATTR_SIZE) && 1135 attr->ia_size != i_size_read(inode)) { 1136 int error; 1137 1138 error = vmtruncate(inode, attr->ia_size); 1139 gfs2_assert_warn(sdp, !error); 1140 } 1141 1142 setattr_copy(inode, attr); 1143 mark_inode_dirty(inode); 1144 1145 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1146 gfs2_dinode_out(ip, dibh->b_data); 1147 brelse(dibh); 1148 1149 if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) { 1150 u64 blocks = gfs2_get_inode_blocks(&ip->i_inode); 1151 gfs2_quota_change(ip, -blocks, ouid, ogid); 1152 gfs2_quota_change(ip, blocks, nuid, ngid); 1153 } 1154 1155out_end_trans: 1156 gfs2_trans_end(sdp); 1157out_gunlock_q: 1158 gfs2_quota_unlock(ip); 1159out_alloc: 1160 gfs2_alloc_put(ip); 1161 return error; 1162} 1163 1164/** 1165 * gfs2_setattr - Change attributes on an inode 1166 * @dentry: The dentry which is changing 1167 * @attr: The structure describing the change 1168 * 1169 * The VFS layer wants to change one or more of an inodes attributes. Write 1170 * that change out to disk. 1171 * 1172 * Returns: errno 1173 */ 1174 1175static int gfs2_setattr(struct dentry *dentry, struct iattr *attr) 1176{ 1177 struct inode *inode = dentry->d_inode; 1178 struct gfs2_inode *ip = GFS2_I(inode); 1179 struct gfs2_holder i_gh; 1180 int error; 1181 1182 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh); 1183 if (error) 1184 return error; 1185 1186 error = -EPERM; 1187 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 1188 goto out; 1189 1190 error = inode_change_ok(inode, attr); 1191 if (error) 1192 goto out; 1193 1194 if (attr->ia_valid & ATTR_SIZE) 1195 error = setattr_size(inode, attr); 1196 else if (attr->ia_valid & (ATTR_UID | ATTR_GID)) 1197 error = setattr_chown(inode, attr); 1198 else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode)) 1199 error = gfs2_acl_chmod(ip, attr); 1200 else 1201 error = gfs2_setattr_simple(ip, attr); 1202 1203out: 1204 gfs2_glock_dq_uninit(&i_gh); 1205 if (!error) 1206 mark_inode_dirty(inode); 1207 return error; 1208} 1209 1210/** 1211 * gfs2_getattr - Read out an inode's attributes 1212 * @mnt: The vfsmount the inode is being accessed from 1213 * @dentry: The dentry to stat 1214 * @stat: The inode's stats 1215 * 1216 * This may be called from the VFS directly, or from within GFS2 with the 1217 * inode locked, so we look to see if the glock is already locked and only 1218 * lock the glock if its not already been done. Note that its the NFS 1219 * readdirplus operation which causes this to be called (from filldir) 1220 * with the glock already held. 1221 * 1222 * Returns: errno 1223 */ 1224 1225static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry, 1226 struct kstat *stat) 1227{ 1228 struct inode *inode = dentry->d_inode; 1229 struct gfs2_inode *ip = GFS2_I(inode); 1230 struct gfs2_holder gh; 1231 int error; 1232 int unlock = 0; 1233 1234 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) { 1235 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh); 1236 if (error) 1237 return error; 1238 unlock = 1; 1239 } 1240 1241 generic_fillattr(inode, stat); 1242 if (unlock) 1243 gfs2_glock_dq_uninit(&gh); 1244 1245 return 0; 1246} 1247 1248static int gfs2_setxattr(struct dentry *dentry, const char *name, 1249 const void *data, size_t size, int flags) 1250{ 1251 struct inode *inode = dentry->d_inode; 1252 struct gfs2_inode *ip = GFS2_I(inode); 1253 struct gfs2_holder gh; 1254 int ret; 1255 1256 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 1257 ret = gfs2_glock_nq(&gh); 1258 if (ret == 0) { 1259 ret = generic_setxattr(dentry, name, data, size, flags); 1260 gfs2_glock_dq(&gh); 1261 } 1262 gfs2_holder_uninit(&gh); 1263 return ret; 1264} 1265 1266static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name, 1267 void *data, size_t size) 1268{ 1269 struct inode *inode = dentry->d_inode; 1270 struct gfs2_inode *ip = GFS2_I(inode); 1271 struct gfs2_holder gh; 1272 int ret; 1273 1274 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh); 1275 ret = gfs2_glock_nq(&gh); 1276 if (ret == 0) { 1277 ret = generic_getxattr(dentry, name, data, size); 1278 gfs2_glock_dq(&gh); 1279 } 1280 gfs2_holder_uninit(&gh); 1281 return ret; 1282} 1283 1284static int gfs2_removexattr(struct dentry *dentry, const char *name) 1285{ 1286 struct inode *inode = dentry->d_inode; 1287 struct gfs2_inode *ip = GFS2_I(inode); 1288 struct gfs2_holder gh; 1289 int ret; 1290 1291 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 1292 ret = gfs2_glock_nq(&gh); 1293 if (ret == 0) { 1294 ret = generic_removexattr(dentry, name); 1295 gfs2_glock_dq(&gh); 1296 } 1297 gfs2_holder_uninit(&gh); 1298 return ret; 1299} 1300 1301static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 1302 u64 start, u64 len) 1303{ 1304 struct gfs2_inode *ip = GFS2_I(inode); 1305 struct gfs2_holder gh; 1306 int ret; 1307 1308 ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC); 1309 if (ret) 1310 return ret; 1311 1312 mutex_lock(&inode->i_mutex); 1313 1314 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 1315 if (ret) 1316 goto out; 1317 1318 if (gfs2_is_stuffed(ip)) { 1319 u64 phys = ip->i_no_addr << inode->i_blkbits; 1320 u64 size = i_size_read(inode); 1321 u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED| 1322 FIEMAP_EXTENT_DATA_INLINE; 1323 phys += sizeof(struct gfs2_dinode); 1324 phys += start; 1325 if (start + len > size) 1326 len = size - start; 1327 if (start < size) 1328 ret = fiemap_fill_next_extent(fieinfo, start, phys, 1329 len, flags); 1330 if (ret == 1) 1331 ret = 0; 1332 } else { 1333 ret = __generic_block_fiemap(inode, fieinfo, start, len, 1334 gfs2_block_map); 1335 } 1336 1337 gfs2_glock_dq_uninit(&gh); 1338out: 1339 mutex_unlock(&inode->i_mutex); 1340 return ret; 1341} 1342 1343const struct inode_operations gfs2_file_iops = { 1344 .permission = gfs2_permission, 1345 .setattr = gfs2_setattr, 1346 .getattr = gfs2_getattr, 1347 .setxattr = gfs2_setxattr, 1348 .getxattr = gfs2_getxattr, 1349 .listxattr = gfs2_listxattr, 1350 .removexattr = gfs2_removexattr, 1351 .fiemap = gfs2_fiemap, 1352}; 1353 1354const struct inode_operations gfs2_dir_iops = { 1355 .create = gfs2_create, 1356 .lookup = gfs2_lookup, 1357 .link = gfs2_link, 1358 .unlink = gfs2_unlink, 1359 .symlink = gfs2_symlink, 1360 .mkdir = gfs2_mkdir, 1361 .rmdir = gfs2_rmdir, 1362 .mknod = gfs2_mknod, 1363 .rename = gfs2_rename, 1364 .permission = gfs2_permission, 1365 .setattr = gfs2_setattr, 1366 .getattr = gfs2_getattr, 1367 .setxattr = gfs2_setxattr, 1368 .getxattr = gfs2_getxattr, 1369 .listxattr = gfs2_listxattr, 1370 .removexattr = gfs2_removexattr, 1371 .fiemap = gfs2_fiemap, 1372}; 1373 1374const struct inode_operations gfs2_symlink_iops = { 1375 .readlink = generic_readlink, 1376 .follow_link = gfs2_follow_link, 1377 .put_link = gfs2_put_link, 1378 .permission = gfs2_permission, 1379 .setattr = gfs2_setattr, 1380 .getattr = gfs2_getattr, 1381 .setxattr = gfs2_setxattr, 1382 .getxattr = gfs2_getxattr, 1383 .listxattr = gfs2_listxattr, 1384 .removexattr = gfs2_removexattr, 1385 .fiemap = gfs2_fiemap, 1386}; 1387