1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2011 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 <linux/security.h> 22 #include <asm/uaccess.h> 23 24 #include "gfs2.h" 25 #include "incore.h" 26 #include "acl.h" 27 #include "bmap.h" 28 #include "dir.h" 29 #include "xattr.h" 30 #include "glock.h" 31 #include "inode.h" 32 #include "meta_io.h" 33 #include "quota.h" 34 #include "rgrp.h" 35 #include "trans.h" 36 #include "util.h" 37 #include "super.h" 38 #include "glops.h" 39 40 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr) 41 { 42 return ilookup(sb, (unsigned long)no_addr); 43 } 44 45 /** 46 * gfs2_set_iop - Sets inode operations 47 * @inode: The inode with correct i_mode filled in 48 * 49 * GFS2 lookup code fills in vfs inode contents based on info obtained 50 * from directory entry inside gfs2_inode_lookup(). 51 */ 52 53 static void gfs2_set_iop(struct inode *inode) 54 { 55 struct gfs2_sbd *sdp = GFS2_SB(inode); 56 umode_t mode = inode->i_mode; 57 58 if (S_ISREG(mode)) { 59 inode->i_op = &gfs2_file_iops; 60 if (gfs2_localflocks(sdp)) 61 inode->i_fop = &gfs2_file_fops_nolock; 62 else 63 inode->i_fop = &gfs2_file_fops; 64 } else if (S_ISDIR(mode)) { 65 inode->i_op = &gfs2_dir_iops; 66 if (gfs2_localflocks(sdp)) 67 inode->i_fop = &gfs2_dir_fops_nolock; 68 else 69 inode->i_fop = &gfs2_dir_fops; 70 } else if (S_ISLNK(mode)) { 71 inode->i_op = &gfs2_symlink_iops; 72 } else { 73 inode->i_op = &gfs2_file_iops; 74 init_special_inode(inode, inode->i_mode, inode->i_rdev); 75 } 76 } 77 78 /** 79 * gfs2_inode_lookup - Lookup an inode 80 * @sb: The super block 81 * @no_addr: The inode number 82 * @type: The type of the inode 83 * 84 * Returns: A VFS inode, or an error 85 */ 86 87 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type, 88 u64 no_addr, u64 no_formal_ino) 89 { 90 struct inode *inode; 91 struct gfs2_inode *ip; 92 struct gfs2_glock *io_gl = NULL; 93 int error; 94 95 inode = iget_locked(sb, (unsigned long)no_addr); 96 if (!inode) 97 return ERR_PTR(-ENOMEM); 98 99 ip = GFS2_I(inode); 100 ip->i_no_addr = no_addr; 101 102 if (inode->i_state & I_NEW) { 103 struct gfs2_sbd *sdp = GFS2_SB(inode); 104 ip->i_no_formal_ino = no_formal_ino; 105 106 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 107 if (unlikely(error)) 108 goto fail; 109 ip->i_gl->gl_object = ip; 110 111 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl); 112 if (unlikely(error)) 113 goto fail_put; 114 115 set_bit(GIF_INVALID, &ip->i_flags); 116 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 117 if (unlikely(error)) 118 goto fail_iopen; 119 120 ip->i_iopen_gh.gh_gl->gl_object = ip; 121 gfs2_glock_put(io_gl); 122 io_gl = NULL; 123 124 if (type == DT_UNKNOWN) { 125 /* Inode glock must be locked already */ 126 error = gfs2_inode_refresh(GFS2_I(inode)); 127 if (error) 128 goto fail_refresh; 129 } else { 130 inode->i_mode = DT2IF(type); 131 } 132 133 gfs2_set_iop(inode); 134 unlock_new_inode(inode); 135 } 136 137 return inode; 138 139 fail_refresh: 140 ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 141 ip->i_iopen_gh.gh_gl->gl_object = NULL; 142 gfs2_glock_dq_wait(&ip->i_iopen_gh); 143 gfs2_holder_uninit(&ip->i_iopen_gh); 144 fail_iopen: 145 if (io_gl) 146 gfs2_glock_put(io_gl); 147 fail_put: 148 ip->i_gl->gl_object = NULL; 149 fail: 150 iget_failed(inode); 151 return ERR_PTR(error); 152 } 153 154 struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr, 155 u64 *no_formal_ino, unsigned int blktype) 156 { 157 struct super_block *sb = sdp->sd_vfs; 158 struct gfs2_holder i_gh; 159 struct inode *inode = NULL; 160 int error; 161 162 /* Must not read in block until block type is verified */ 163 error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops, 164 LM_ST_EXCLUSIVE, GL_SKIP, &i_gh); 165 if (error) 166 return ERR_PTR(error); 167 168 error = gfs2_check_blk_type(sdp, no_addr, blktype); 169 if (error) 170 goto fail; 171 172 inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0); 173 if (IS_ERR(inode)) 174 goto fail; 175 176 /* Two extra checks for NFS only */ 177 if (no_formal_ino) { 178 error = -ESTALE; 179 if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino) 180 goto fail_iput; 181 182 error = -EIO; 183 if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM) 184 goto fail_iput; 185 186 error = 0; 187 } 188 189 fail: 190 gfs2_glock_dq_uninit(&i_gh); 191 return error ? ERR_PTR(error) : inode; 192 fail_iput: 193 iput(inode); 194 goto fail; 195 } 196 197 198 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name) 199 { 200 struct qstr qstr; 201 struct inode *inode; 202 gfs2_str2qstr(&qstr, name); 203 inode = gfs2_lookupi(dip, &qstr, 1); 204 /* gfs2_lookupi has inconsistent callers: vfs 205 * related routines expect NULL for no entry found, 206 * gfs2_lookup_simple callers expect ENOENT 207 * and do not check for NULL. 208 */ 209 if (inode == NULL) 210 return ERR_PTR(-ENOENT); 211 else 212 return inode; 213 } 214 215 216 /** 217 * gfs2_lookupi - Look up a filename in a directory and return its inode 218 * @d_gh: An initialized holder for the directory glock 219 * @name: The name of the inode to look for 220 * @is_root: If 1, ignore the caller's permissions 221 * @i_gh: An uninitialized holder for the new inode glock 222 * 223 * This can be called via the VFS filldir function when NFS is doing 224 * a readdirplus and the inode which its intending to stat isn't 225 * already in cache. In this case we must not take the directory glock 226 * again, since the readdir call will have already taken that lock. 227 * 228 * Returns: errno 229 */ 230 231 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name, 232 int is_root) 233 { 234 struct super_block *sb = dir->i_sb; 235 struct gfs2_inode *dip = GFS2_I(dir); 236 struct gfs2_holder d_gh; 237 int error = 0; 238 struct inode *inode = NULL; 239 int unlock = 0; 240 241 if (!name->len || name->len > GFS2_FNAMESIZE) 242 return ERR_PTR(-ENAMETOOLONG); 243 244 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) || 245 (name->len == 2 && memcmp(name->name, "..", 2) == 0 && 246 dir == d_inode(sb->s_root))) { 247 igrab(dir); 248 return dir; 249 } 250 251 if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) { 252 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); 253 if (error) 254 return ERR_PTR(error); 255 unlock = 1; 256 } 257 258 if (!is_root) { 259 error = gfs2_permission(dir, MAY_EXEC); 260 if (error) 261 goto out; 262 } 263 264 inode = gfs2_dir_search(dir, name, false); 265 if (IS_ERR(inode)) 266 error = PTR_ERR(inode); 267 out: 268 if (unlock) 269 gfs2_glock_dq_uninit(&d_gh); 270 if (error == -ENOENT) 271 return NULL; 272 return inode ? inode : ERR_PTR(error); 273 } 274 275 /** 276 * create_ok - OK to create a new on-disk inode here? 277 * @dip: Directory in which dinode is to be created 278 * @name: Name of new dinode 279 * @mode: 280 * 281 * Returns: errno 282 */ 283 284 static int create_ok(struct gfs2_inode *dip, const struct qstr *name, 285 umode_t mode) 286 { 287 int error; 288 289 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC); 290 if (error) 291 return error; 292 293 /* Don't create entries in an unlinked directory */ 294 if (!dip->i_inode.i_nlink) 295 return -ENOENT; 296 297 if (dip->i_entries == (u32)-1) 298 return -EFBIG; 299 if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1) 300 return -EMLINK; 301 302 return 0; 303 } 304 305 static void munge_mode_uid_gid(const struct gfs2_inode *dip, 306 struct inode *inode) 307 { 308 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir && 309 (dip->i_inode.i_mode & S_ISUID) && 310 !uid_eq(dip->i_inode.i_uid, GLOBAL_ROOT_UID)) { 311 if (S_ISDIR(inode->i_mode)) 312 inode->i_mode |= S_ISUID; 313 else if (!uid_eq(dip->i_inode.i_uid, current_fsuid())) 314 inode->i_mode &= ~07111; 315 inode->i_uid = dip->i_inode.i_uid; 316 } else 317 inode->i_uid = current_fsuid(); 318 319 if (dip->i_inode.i_mode & S_ISGID) { 320 if (S_ISDIR(inode->i_mode)) 321 inode->i_mode |= S_ISGID; 322 inode->i_gid = dip->i_inode.i_gid; 323 } else 324 inode->i_gid = current_fsgid(); 325 } 326 327 static int alloc_dinode(struct gfs2_inode *ip, u32 flags, unsigned *dblocks) 328 { 329 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 330 struct gfs2_alloc_parms ap = { .target = *dblocks, .aflags = flags, }; 331 int error; 332 333 error = gfs2_quota_lock_check(ip, &ap); 334 if (error) 335 goto out; 336 337 error = gfs2_inplace_reserve(ip, &ap); 338 if (error) 339 goto out_quota; 340 341 error = gfs2_trans_begin(sdp, (*dblocks * RES_RG_BIT) + RES_STATFS + RES_QUOTA, 0); 342 if (error) 343 goto out_ipreserv; 344 345 error = gfs2_alloc_blocks(ip, &ip->i_no_addr, dblocks, 1, &ip->i_generation); 346 ip->i_no_formal_ino = ip->i_generation; 347 ip->i_inode.i_ino = ip->i_no_addr; 348 ip->i_goal = ip->i_no_addr; 349 350 gfs2_trans_end(sdp); 351 352 out_ipreserv: 353 gfs2_inplace_release(ip); 354 out_quota: 355 gfs2_quota_unlock(ip); 356 out: 357 return error; 358 } 359 360 static void gfs2_init_dir(struct buffer_head *dibh, 361 const struct gfs2_inode *parent) 362 { 363 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data; 364 struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1); 365 366 gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent); 367 dent->de_inum = di->di_num; /* already GFS2 endian */ 368 dent->de_type = cpu_to_be16(DT_DIR); 369 370 dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1)); 371 gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent); 372 gfs2_inum_out(parent, dent); 373 dent->de_type = cpu_to_be16(DT_DIR); 374 375 } 376 377 /** 378 * gfs2_init_xattr - Initialise an xattr block for a new inode 379 * @ip: The inode in question 380 * 381 * This sets up an empty xattr block for a new inode, ready to 382 * take any ACLs, LSM xattrs, etc. 383 */ 384 385 static void gfs2_init_xattr(struct gfs2_inode *ip) 386 { 387 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 388 struct buffer_head *bh; 389 struct gfs2_ea_header *ea; 390 391 bh = gfs2_meta_new(ip->i_gl, ip->i_eattr); 392 gfs2_trans_add_meta(ip->i_gl, bh); 393 gfs2_metatype_set(bh, GFS2_METATYPE_EA, GFS2_FORMAT_EA); 394 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header)); 395 396 ea = GFS2_EA_BH2FIRST(bh); 397 ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize); 398 ea->ea_type = GFS2_EATYPE_UNUSED; 399 ea->ea_flags = GFS2_EAFLAG_LAST; 400 401 brelse(bh); 402 } 403 404 /** 405 * init_dinode - Fill in a new dinode structure 406 * @dip: The directory this inode is being created in 407 * @ip: The inode 408 * @symname: The symlink destination (if a symlink) 409 * @bhp: The buffer head (returned to caller) 410 * 411 */ 412 413 static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip, 414 const char *symname) 415 { 416 struct gfs2_dinode *di; 417 struct buffer_head *dibh; 418 419 dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr); 420 gfs2_trans_add_meta(ip->i_gl, dibh); 421 di = (struct gfs2_dinode *)dibh->b_data; 422 gfs2_dinode_out(ip, di); 423 424 di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev)); 425 di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev)); 426 di->__pad1 = 0; 427 di->__pad2 = 0; 428 di->__pad3 = 0; 429 memset(&di->__pad4, 0, sizeof(di->__pad4)); 430 memset(&di->di_reserved, 0, sizeof(di->di_reserved)); 431 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 432 433 switch(ip->i_inode.i_mode & S_IFMT) { 434 case S_IFDIR: 435 gfs2_init_dir(dibh, dip); 436 break; 437 case S_IFLNK: 438 memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size); 439 break; 440 } 441 442 set_buffer_uptodate(dibh); 443 brelse(dibh); 444 } 445 446 /** 447 * gfs2_trans_da_blocks - Calculate number of blocks to link inode 448 * @dip: The directory we are linking into 449 * @da: The dir add information 450 * @nr_inodes: The number of inodes involved 451 * 452 * This calculate the number of blocks we need to reserve in a 453 * transaction to link @nr_inodes into a directory. In most cases 454 * @nr_inodes will be 2 (the directory plus the inode being linked in) 455 * but in case of rename, 4 may be required. 456 * 457 * Returns: Number of blocks 458 */ 459 460 static unsigned gfs2_trans_da_blks(const struct gfs2_inode *dip, 461 const struct gfs2_diradd *da, 462 unsigned nr_inodes) 463 { 464 return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) + 465 (nr_inodes * RES_DINODE) + RES_QUOTA + RES_STATFS; 466 } 467 468 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, 469 struct gfs2_inode *ip, struct gfs2_diradd *da) 470 { 471 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 472 struct gfs2_alloc_parms ap = { .target = da->nr_blocks, }; 473 int error; 474 475 if (da->nr_blocks) { 476 error = gfs2_quota_lock_check(dip, &ap); 477 if (error) 478 goto fail_quota_locks; 479 480 error = gfs2_inplace_reserve(dip, &ap); 481 if (error) 482 goto fail_quota_locks; 483 484 error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0); 485 if (error) 486 goto fail_ipreserv; 487 } else { 488 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0); 489 if (error) 490 goto fail_quota_locks; 491 } 492 493 error = gfs2_dir_add(&dip->i_inode, name, ip, da); 494 495 gfs2_trans_end(sdp); 496 fail_ipreserv: 497 gfs2_inplace_release(dip); 498 fail_quota_locks: 499 gfs2_quota_unlock(dip); 500 return error; 501 } 502 503 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array, 504 void *fs_info) 505 { 506 const struct xattr *xattr; 507 int err = 0; 508 509 for (xattr = xattr_array; xattr->name != NULL; xattr++) { 510 err = __gfs2_xattr_set(inode, xattr->name, xattr->value, 511 xattr->value_len, 0, 512 GFS2_EATYPE_SECURITY); 513 if (err < 0) 514 break; 515 } 516 return err; 517 } 518 519 /** 520 * gfs2_create_inode - Create a new inode 521 * @dir: The parent directory 522 * @dentry: The new dentry 523 * @file: If non-NULL, the file which is being opened 524 * @mode: The permissions on the new inode 525 * @dev: For device nodes, this is the device number 526 * @symname: For symlinks, this is the link destination 527 * @size: The initial size of the inode (ignored for directories) 528 * 529 * Returns: 0 on success, or error code 530 */ 531 532 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry, 533 struct file *file, 534 umode_t mode, dev_t dev, const char *symname, 535 unsigned int size, int excl, int *opened) 536 { 537 const struct qstr *name = &dentry->d_name; 538 struct posix_acl *default_acl, *acl; 539 struct gfs2_holder ghs[2]; 540 struct inode *inode = NULL; 541 struct gfs2_inode *dip = GFS2_I(dir), *ip; 542 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 543 struct gfs2_glock *io_gl = NULL; 544 int error, free_vfs_inode = 1; 545 u32 aflags = 0; 546 unsigned blocks = 1; 547 struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, }; 548 549 if (!name->len || name->len > GFS2_FNAMESIZE) 550 return -ENAMETOOLONG; 551 552 error = gfs2_rsqa_alloc(dip); 553 if (error) 554 return error; 555 556 error = gfs2_rindex_update(sdp); 557 if (error) 558 return error; 559 560 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 561 if (error) 562 goto fail; 563 564 error = create_ok(dip, name, mode); 565 if (error) 566 goto fail_gunlock; 567 568 inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl); 569 error = PTR_ERR(inode); 570 if (!IS_ERR(inode)) { 571 if (S_ISDIR(inode->i_mode)) { 572 iput(inode); 573 inode = ERR_PTR(-EISDIR); 574 goto fail_gunlock; 575 } 576 d_instantiate(dentry, inode); 577 error = 0; 578 if (file) { 579 if (S_ISREG(inode->i_mode)) 580 error = finish_open(file, dentry, gfs2_open_common, opened); 581 else 582 error = finish_no_open(file, NULL); 583 } 584 gfs2_glock_dq_uninit(ghs); 585 return error; 586 } else if (error != -ENOENT) { 587 goto fail_gunlock; 588 } 589 590 error = gfs2_diradd_alloc_required(dir, name, &da); 591 if (error < 0) 592 goto fail_gunlock; 593 594 inode = new_inode(sdp->sd_vfs); 595 error = -ENOMEM; 596 if (!inode) 597 goto fail_gunlock; 598 599 error = posix_acl_create(dir, &mode, &default_acl, &acl); 600 if (error) 601 goto fail_gunlock; 602 603 ip = GFS2_I(inode); 604 error = gfs2_rsqa_alloc(ip); 605 if (error) 606 goto fail_free_acls; 607 608 inode->i_mode = mode; 609 set_nlink(inode, S_ISDIR(mode) ? 2 : 1); 610 inode->i_rdev = dev; 611 inode->i_size = size; 612 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 613 gfs2_set_inode_blocks(inode, 1); 614 munge_mode_uid_gid(dip, inode); 615 check_and_update_goal(dip); 616 ip->i_goal = dip->i_goal; 617 ip->i_diskflags = 0; 618 ip->i_eattr = 0; 619 ip->i_height = 0; 620 ip->i_depth = 0; 621 ip->i_entries = 0; 622 623 switch(mode & S_IFMT) { 624 case S_IFREG: 625 if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) || 626 gfs2_tune_get(sdp, gt_new_files_jdata)) 627 ip->i_diskflags |= GFS2_DIF_JDATA; 628 gfs2_set_aops(inode); 629 break; 630 case S_IFDIR: 631 ip->i_diskflags |= (dip->i_diskflags & GFS2_DIF_INHERIT_JDATA); 632 ip->i_diskflags |= GFS2_DIF_JDATA; 633 ip->i_entries = 2; 634 break; 635 } 636 637 /* Force SYSTEM flag on all files and subdirs of a SYSTEM directory */ 638 if (dip->i_diskflags & GFS2_DIF_SYSTEM) 639 ip->i_diskflags |= GFS2_DIF_SYSTEM; 640 641 gfs2_set_inode_flags(inode); 642 643 if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) || 644 (dip->i_diskflags & GFS2_DIF_TOPDIR)) 645 aflags |= GFS2_AF_ORLOV; 646 647 if (default_acl || acl) 648 blocks++; 649 650 error = alloc_dinode(ip, aflags, &blocks); 651 if (error) 652 goto fail_free_inode; 653 654 gfs2_set_inode_blocks(inode, blocks); 655 656 error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 657 if (error) 658 goto fail_free_inode; 659 660 ip->i_gl->gl_object = ip; 661 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1); 662 if (error) 663 goto fail_free_inode; 664 665 error = gfs2_trans_begin(sdp, blocks, 0); 666 if (error) 667 goto fail_gunlock2; 668 669 if (blocks > 1) { 670 ip->i_eattr = ip->i_no_addr + 1; 671 gfs2_init_xattr(ip); 672 } 673 init_dinode(dip, ip, symname); 674 gfs2_trans_end(sdp); 675 676 error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl); 677 if (error) 678 goto fail_gunlock2; 679 680 BUG_ON(test_and_set_bit(GLF_INODE_CREATING, &io_gl->gl_flags)); 681 682 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 683 if (error) 684 goto fail_gunlock2; 685 686 ip->i_iopen_gh.gh_gl->gl_object = ip; 687 gfs2_glock_put(io_gl); 688 gfs2_set_iop(inode); 689 insert_inode_hash(inode); 690 691 free_vfs_inode = 0; /* After this point, the inode is no longer 692 considered free. Any failures need to undo 693 the gfs2 structures. */ 694 if (default_acl) { 695 error = __gfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT); 696 posix_acl_release(default_acl); 697 } 698 if (acl) { 699 if (!error) 700 error = __gfs2_set_acl(inode, acl, ACL_TYPE_ACCESS); 701 posix_acl_release(acl); 702 } 703 704 if (error) 705 goto fail_gunlock3; 706 707 error = security_inode_init_security(&ip->i_inode, &dip->i_inode, name, 708 &gfs2_initxattrs, NULL); 709 if (error) 710 goto fail_gunlock3; 711 712 error = link_dinode(dip, name, ip, &da); 713 if (error) 714 goto fail_gunlock3; 715 716 mark_inode_dirty(inode); 717 d_instantiate(dentry, inode); 718 if (file) { 719 *opened |= FILE_CREATED; 720 error = finish_open(file, dentry, gfs2_open_common, opened); 721 } 722 gfs2_glock_dq_uninit(ghs); 723 gfs2_glock_dq_uninit(ghs + 1); 724 clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags); 725 return error; 726 727 fail_gunlock3: 728 gfs2_glock_dq_uninit(&ip->i_iopen_gh); 729 gfs2_glock_put(io_gl); 730 fail_gunlock2: 731 if (io_gl) 732 clear_bit(GLF_INODE_CREATING, &io_gl->gl_flags); 733 gfs2_glock_dq_uninit(ghs + 1); 734 fail_free_inode: 735 if (ip->i_gl) 736 gfs2_glock_put(ip->i_gl); 737 gfs2_rsqa_delete(ip, NULL); 738 fail_free_acls: 739 if (default_acl) 740 posix_acl_release(default_acl); 741 if (acl) 742 posix_acl_release(acl); 743 fail_gunlock: 744 gfs2_dir_no_add(&da); 745 gfs2_glock_dq_uninit(ghs); 746 if (inode && !IS_ERR(inode)) { 747 clear_nlink(inode); 748 if (!free_vfs_inode) 749 mark_inode_dirty(inode); 750 set_bit(free_vfs_inode ? GIF_FREE_VFS_INODE : GIF_ALLOC_FAILED, 751 &GFS2_I(inode)->i_flags); 752 iput(inode); 753 } 754 fail: 755 return error; 756 } 757 758 /** 759 * gfs2_create - Create a file 760 * @dir: The directory in which to create the file 761 * @dentry: The dentry of the new file 762 * @mode: The mode of the new file 763 * 764 * Returns: errno 765 */ 766 767 static int gfs2_create(struct inode *dir, struct dentry *dentry, 768 umode_t mode, bool excl) 769 { 770 return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL); 771 } 772 773 /** 774 * __gfs2_lookup - Look up a filename in a directory and return its inode 775 * @dir: The directory inode 776 * @dentry: The dentry of the new inode 777 * @file: File to be opened 778 * @opened: atomic_open flags 779 * 780 * 781 * Returns: errno 782 */ 783 784 static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry, 785 struct file *file, int *opened) 786 { 787 struct inode *inode; 788 struct dentry *d; 789 struct gfs2_holder gh; 790 struct gfs2_glock *gl; 791 int error; 792 793 inode = gfs2_lookupi(dir, &dentry->d_name, 0); 794 if (inode == NULL) { 795 d_add(dentry, NULL); 796 return NULL; 797 } 798 if (IS_ERR(inode)) 799 return ERR_CAST(inode); 800 801 gl = GFS2_I(inode)->i_gl; 802 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh); 803 if (error) { 804 iput(inode); 805 return ERR_PTR(error); 806 } 807 808 d = d_splice_alias(inode, dentry); 809 if (IS_ERR(d)) { 810 gfs2_glock_dq_uninit(&gh); 811 return d; 812 } 813 if (file && S_ISREG(inode->i_mode)) 814 error = finish_open(file, dentry, gfs2_open_common, opened); 815 816 gfs2_glock_dq_uninit(&gh); 817 if (error) { 818 dput(d); 819 return ERR_PTR(error); 820 } 821 return d; 822 } 823 824 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry, 825 unsigned flags) 826 { 827 return __gfs2_lookup(dir, dentry, NULL, NULL); 828 } 829 830 /** 831 * gfs2_link - Link to a file 832 * @old_dentry: The inode to link 833 * @dir: Add link to this directory 834 * @dentry: The name of the link 835 * 836 * Link the inode in "old_dentry" into the directory "dir" with the 837 * name in "dentry". 838 * 839 * Returns: errno 840 */ 841 842 static int gfs2_link(struct dentry *old_dentry, struct inode *dir, 843 struct dentry *dentry) 844 { 845 struct gfs2_inode *dip = GFS2_I(dir); 846 struct gfs2_sbd *sdp = GFS2_SB(dir); 847 struct inode *inode = d_inode(old_dentry); 848 struct gfs2_inode *ip = GFS2_I(inode); 849 struct gfs2_holder ghs[2]; 850 struct buffer_head *dibh; 851 struct gfs2_diradd da = { .bh = NULL, .save_loc = 1, }; 852 int error; 853 854 if (S_ISDIR(inode->i_mode)) 855 return -EPERM; 856 857 error = gfs2_rsqa_alloc(dip); 858 if (error) 859 return error; 860 861 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 862 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1); 863 864 error = gfs2_glock_nq(ghs); /* parent */ 865 if (error) 866 goto out_parent; 867 868 error = gfs2_glock_nq(ghs + 1); /* child */ 869 if (error) 870 goto out_child; 871 872 error = -ENOENT; 873 if (inode->i_nlink == 0) 874 goto out_gunlock; 875 876 error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC); 877 if (error) 878 goto out_gunlock; 879 880 error = gfs2_dir_check(dir, &dentry->d_name, NULL); 881 switch (error) { 882 case -ENOENT: 883 break; 884 case 0: 885 error = -EEXIST; 886 default: 887 goto out_gunlock; 888 } 889 890 error = -EINVAL; 891 if (!dip->i_inode.i_nlink) 892 goto out_gunlock; 893 error = -EFBIG; 894 if (dip->i_entries == (u32)-1) 895 goto out_gunlock; 896 error = -EPERM; 897 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 898 goto out_gunlock; 899 error = -EINVAL; 900 if (!ip->i_inode.i_nlink) 901 goto out_gunlock; 902 error = -EMLINK; 903 if (ip->i_inode.i_nlink == (u32)-1) 904 goto out_gunlock; 905 906 error = gfs2_diradd_alloc_required(dir, &dentry->d_name, &da); 907 if (error < 0) 908 goto out_gunlock; 909 910 if (da.nr_blocks) { 911 struct gfs2_alloc_parms ap = { .target = da.nr_blocks, }; 912 error = gfs2_quota_lock_check(dip, &ap); 913 if (error) 914 goto out_gunlock; 915 916 error = gfs2_inplace_reserve(dip, &ap); 917 if (error) 918 goto out_gunlock_q; 919 920 error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, &da, 2), 0); 921 if (error) 922 goto out_ipres; 923 } else { 924 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0); 925 if (error) 926 goto out_ipres; 927 } 928 929 error = gfs2_meta_inode_buffer(ip, &dibh); 930 if (error) 931 goto out_end_trans; 932 933 error = gfs2_dir_add(dir, &dentry->d_name, ip, &da); 934 if (error) 935 goto out_brelse; 936 937 gfs2_trans_add_meta(ip->i_gl, dibh); 938 inc_nlink(&ip->i_inode); 939 ip->i_inode.i_ctime = CURRENT_TIME; 940 ihold(inode); 941 d_instantiate(dentry, inode); 942 mark_inode_dirty(inode); 943 944 out_brelse: 945 brelse(dibh); 946 out_end_trans: 947 gfs2_trans_end(sdp); 948 out_ipres: 949 if (da.nr_blocks) 950 gfs2_inplace_release(dip); 951 out_gunlock_q: 952 if (da.nr_blocks) 953 gfs2_quota_unlock(dip); 954 out_gunlock: 955 gfs2_dir_no_add(&da); 956 gfs2_glock_dq(ghs + 1); 957 out_child: 958 gfs2_glock_dq(ghs); 959 out_parent: 960 gfs2_holder_uninit(ghs); 961 gfs2_holder_uninit(ghs + 1); 962 return error; 963 } 964 965 /* 966 * gfs2_unlink_ok - check to see that a inode is still in a directory 967 * @dip: the directory 968 * @name: the name of the file 969 * @ip: the inode 970 * 971 * Assumes that the lock on (at least) @dip is held. 972 * 973 * Returns: 0 if the parent/child relationship is correct, errno if it isn't 974 */ 975 976 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, 977 const struct gfs2_inode *ip) 978 { 979 int error; 980 981 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) 982 return -EPERM; 983 984 if ((dip->i_inode.i_mode & S_ISVTX) && 985 !uid_eq(dip->i_inode.i_uid, current_fsuid()) && 986 !uid_eq(ip->i_inode.i_uid, current_fsuid()) && !capable(CAP_FOWNER)) 987 return -EPERM; 988 989 if (IS_APPEND(&dip->i_inode)) 990 return -EPERM; 991 992 error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC); 993 if (error) 994 return error; 995 996 return gfs2_dir_check(&dip->i_inode, name, ip); 997 } 998 999 /** 1000 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it 1001 * @dip: The parent directory 1002 * @name: The name of the entry in the parent directory 1003 * @inode: The inode to be removed 1004 * 1005 * Called with all the locks and in a transaction. This will only be 1006 * called for a directory after it has been checked to ensure it is empty. 1007 * 1008 * Returns: 0 on success, or an error 1009 */ 1010 1011 static int gfs2_unlink_inode(struct gfs2_inode *dip, 1012 const struct dentry *dentry) 1013 { 1014 struct inode *inode = d_inode(dentry); 1015 struct gfs2_inode *ip = GFS2_I(inode); 1016 int error; 1017 1018 error = gfs2_dir_del(dip, dentry); 1019 if (error) 1020 return error; 1021 1022 ip->i_entries = 0; 1023 inode->i_ctime = CURRENT_TIME; 1024 if (S_ISDIR(inode->i_mode)) 1025 clear_nlink(inode); 1026 else 1027 drop_nlink(inode); 1028 mark_inode_dirty(inode); 1029 if (inode->i_nlink == 0) 1030 gfs2_unlink_di(inode); 1031 return 0; 1032 } 1033 1034 1035 /** 1036 * gfs2_unlink - Unlink an inode (this does rmdir as well) 1037 * @dir: The inode of the directory containing the inode to unlink 1038 * @dentry: The file itself 1039 * 1040 * This routine uses the type of the inode as a flag to figure out 1041 * whether this is an unlink or an rmdir. 1042 * 1043 * Returns: errno 1044 */ 1045 1046 static int gfs2_unlink(struct inode *dir, struct dentry *dentry) 1047 { 1048 struct gfs2_inode *dip = GFS2_I(dir); 1049 struct gfs2_sbd *sdp = GFS2_SB(dir); 1050 struct inode *inode = d_inode(dentry); 1051 struct gfs2_inode *ip = GFS2_I(inode); 1052 struct gfs2_holder ghs[3]; 1053 struct gfs2_rgrpd *rgd; 1054 int error; 1055 1056 error = gfs2_rindex_update(sdp); 1057 if (error) 1058 return error; 1059 1060 error = -EROFS; 1061 1062 gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 1063 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1); 1064 1065 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1); 1066 if (!rgd) 1067 goto out_inodes; 1068 1069 gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2); 1070 1071 1072 error = gfs2_glock_nq(ghs); /* parent */ 1073 if (error) 1074 goto out_parent; 1075 1076 error = gfs2_glock_nq(ghs + 1); /* child */ 1077 if (error) 1078 goto out_child; 1079 1080 error = -ENOENT; 1081 if (inode->i_nlink == 0) 1082 goto out_rgrp; 1083 1084 if (S_ISDIR(inode->i_mode)) { 1085 error = -ENOTEMPTY; 1086 if (ip->i_entries > 2 || inode->i_nlink > 2) 1087 goto out_rgrp; 1088 } 1089 1090 error = gfs2_glock_nq(ghs + 2); /* rgrp */ 1091 if (error) 1092 goto out_rgrp; 1093 1094 error = gfs2_unlink_ok(dip, &dentry->d_name, ip); 1095 if (error) 1096 goto out_gunlock; 1097 1098 error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0); 1099 if (error) 1100 goto out_end_trans; 1101 1102 error = gfs2_unlink_inode(dip, dentry); 1103 1104 out_end_trans: 1105 gfs2_trans_end(sdp); 1106 out_gunlock: 1107 gfs2_glock_dq(ghs + 2); 1108 out_rgrp: 1109 gfs2_glock_dq(ghs + 1); 1110 out_child: 1111 gfs2_glock_dq(ghs); 1112 out_parent: 1113 gfs2_holder_uninit(ghs + 2); 1114 out_inodes: 1115 gfs2_holder_uninit(ghs + 1); 1116 gfs2_holder_uninit(ghs); 1117 return error; 1118 } 1119 1120 /** 1121 * gfs2_symlink - Create a symlink 1122 * @dir: The directory to create the symlink in 1123 * @dentry: The dentry to put the symlink in 1124 * @symname: The thing which the link points to 1125 * 1126 * Returns: errno 1127 */ 1128 1129 static int gfs2_symlink(struct inode *dir, struct dentry *dentry, 1130 const char *symname) 1131 { 1132 struct gfs2_sbd *sdp = GFS2_SB(dir); 1133 unsigned int size; 1134 1135 size = strlen(symname); 1136 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1) 1137 return -ENAMETOOLONG; 1138 1139 return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL); 1140 } 1141 1142 /** 1143 * gfs2_mkdir - Make a directory 1144 * @dir: The parent directory of the new one 1145 * @dentry: The dentry of the new directory 1146 * @mode: The mode of the new directory 1147 * 1148 * Returns: errno 1149 */ 1150 1151 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1152 { 1153 struct gfs2_sbd *sdp = GFS2_SB(dir); 1154 unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode); 1155 return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL); 1156 } 1157 1158 /** 1159 * gfs2_mknod - Make a special file 1160 * @dir: The directory in which the special file will reside 1161 * @dentry: The dentry of the special file 1162 * @mode: The mode of the special file 1163 * @dev: The device specification of the special file 1164 * 1165 */ 1166 1167 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, 1168 dev_t dev) 1169 { 1170 return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL); 1171 } 1172 1173 /** 1174 * gfs2_atomic_open - Atomically open a file 1175 * @dir: The directory 1176 * @dentry: The proposed new entry 1177 * @file: The proposed new struct file 1178 * @flags: open flags 1179 * @mode: File mode 1180 * @opened: Flag to say whether the file has been opened or not 1181 * 1182 * Returns: error code or 0 for success 1183 */ 1184 1185 static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry, 1186 struct file *file, unsigned flags, 1187 umode_t mode, int *opened) 1188 { 1189 struct dentry *d; 1190 bool excl = !!(flags & O_EXCL); 1191 1192 if (!d_in_lookup(dentry)) 1193 goto skip_lookup; 1194 1195 d = __gfs2_lookup(dir, dentry, file, opened); 1196 if (IS_ERR(d)) 1197 return PTR_ERR(d); 1198 if (d != NULL) 1199 dentry = d; 1200 if (d_really_is_positive(dentry)) { 1201 if (!(*opened & FILE_OPENED)) 1202 return finish_no_open(file, d); 1203 dput(d); 1204 return 0; 1205 } 1206 1207 BUG_ON(d != NULL); 1208 1209 skip_lookup: 1210 if (!(flags & O_CREAT)) 1211 return -ENOENT; 1212 1213 return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened); 1214 } 1215 1216 /* 1217 * gfs2_ok_to_move - check if it's ok to move a directory to another directory 1218 * @this: move this 1219 * @to: to here 1220 * 1221 * Follow @to back to the root and make sure we don't encounter @this 1222 * Assumes we already hold the rename lock. 1223 * 1224 * Returns: errno 1225 */ 1226 1227 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) 1228 { 1229 struct inode *dir = &to->i_inode; 1230 struct super_block *sb = dir->i_sb; 1231 struct inode *tmp; 1232 int error = 0; 1233 1234 igrab(dir); 1235 1236 for (;;) { 1237 if (dir == &this->i_inode) { 1238 error = -EINVAL; 1239 break; 1240 } 1241 if (dir == d_inode(sb->s_root)) { 1242 error = 0; 1243 break; 1244 } 1245 1246 tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1); 1247 if (!tmp) { 1248 error = -ENOENT; 1249 break; 1250 } 1251 if (IS_ERR(tmp)) { 1252 error = PTR_ERR(tmp); 1253 break; 1254 } 1255 1256 iput(dir); 1257 dir = tmp; 1258 } 1259 1260 iput(dir); 1261 1262 return error; 1263 } 1264 1265 /** 1266 * update_moved_ino - Update an inode that's being moved 1267 * @ip: The inode being moved 1268 * @ndip: The parent directory of the new filename 1269 * @dir_rename: True of ip is a directory 1270 * 1271 * Returns: errno 1272 */ 1273 1274 static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip, 1275 int dir_rename) 1276 { 1277 int error; 1278 struct buffer_head *dibh; 1279 1280 if (dir_rename) 1281 return gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR); 1282 1283 error = gfs2_meta_inode_buffer(ip, &dibh); 1284 if (error) 1285 return error; 1286 ip->i_inode.i_ctime = CURRENT_TIME; 1287 gfs2_trans_add_meta(ip->i_gl, dibh); 1288 gfs2_dinode_out(ip, dibh->b_data); 1289 brelse(dibh); 1290 return 0; 1291 } 1292 1293 1294 /** 1295 * gfs2_rename - Rename a file 1296 * @odir: Parent directory of old file name 1297 * @odentry: The old dentry of the file 1298 * @ndir: Parent directory of new file name 1299 * @ndentry: The new dentry of the file 1300 * 1301 * Returns: errno 1302 */ 1303 1304 static int gfs2_rename(struct inode *odir, struct dentry *odentry, 1305 struct inode *ndir, struct dentry *ndentry) 1306 { 1307 struct gfs2_inode *odip = GFS2_I(odir); 1308 struct gfs2_inode *ndip = GFS2_I(ndir); 1309 struct gfs2_inode *ip = GFS2_I(d_inode(odentry)); 1310 struct gfs2_inode *nip = NULL; 1311 struct gfs2_sbd *sdp = GFS2_SB(odir); 1312 struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }; 1313 struct gfs2_rgrpd *nrgd; 1314 unsigned int num_gh; 1315 int dir_rename = 0; 1316 struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, }; 1317 unsigned int x; 1318 int error; 1319 1320 if (d_really_is_positive(ndentry)) { 1321 nip = GFS2_I(d_inode(ndentry)); 1322 if (ip == nip) 1323 return 0; 1324 } 1325 1326 error = gfs2_rindex_update(sdp); 1327 if (error) 1328 return error; 1329 1330 error = gfs2_rsqa_alloc(ndip); 1331 if (error) 1332 return error; 1333 1334 if (odip != ndip) { 1335 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE, 1336 0, &r_gh); 1337 if (error) 1338 goto out; 1339 1340 if (S_ISDIR(ip->i_inode.i_mode)) { 1341 dir_rename = 1; 1342 /* don't move a directory into its subdir */ 1343 error = gfs2_ok_to_move(ip, ndip); 1344 if (error) 1345 goto out_gunlock_r; 1346 } 1347 } 1348 1349 num_gh = 1; 1350 gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 1351 if (odip != ndip) { 1352 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1353 num_gh++; 1354 } 1355 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1356 num_gh++; 1357 1358 if (nip) { 1359 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1360 num_gh++; 1361 /* grab the resource lock for unlink flag twiddling 1362 * this is the case of the target file already existing 1363 * so we unlink before doing the rename 1364 */ 1365 nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1); 1366 if (nrgd) 1367 gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++); 1368 } 1369 1370 for (x = 0; x < num_gh; x++) { 1371 error = gfs2_glock_nq(ghs + x); 1372 if (error) 1373 goto out_gunlock; 1374 } 1375 1376 error = -ENOENT; 1377 if (ip->i_inode.i_nlink == 0) 1378 goto out_gunlock; 1379 1380 /* Check out the old directory */ 1381 1382 error = gfs2_unlink_ok(odip, &odentry->d_name, ip); 1383 if (error) 1384 goto out_gunlock; 1385 1386 /* Check out the new directory */ 1387 1388 if (nip) { 1389 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip); 1390 if (error) 1391 goto out_gunlock; 1392 1393 if (nip->i_inode.i_nlink == 0) { 1394 error = -EAGAIN; 1395 goto out_gunlock; 1396 } 1397 1398 if (S_ISDIR(nip->i_inode.i_mode)) { 1399 if (nip->i_entries < 2) { 1400 gfs2_consist_inode(nip); 1401 error = -EIO; 1402 goto out_gunlock; 1403 } 1404 if (nip->i_entries > 2) { 1405 error = -ENOTEMPTY; 1406 goto out_gunlock; 1407 } 1408 } 1409 } else { 1410 error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC); 1411 if (error) 1412 goto out_gunlock; 1413 1414 error = gfs2_dir_check(ndir, &ndentry->d_name, NULL); 1415 switch (error) { 1416 case -ENOENT: 1417 error = 0; 1418 break; 1419 case 0: 1420 error = -EEXIST; 1421 default: 1422 goto out_gunlock; 1423 }; 1424 1425 if (odip != ndip) { 1426 if (!ndip->i_inode.i_nlink) { 1427 error = -ENOENT; 1428 goto out_gunlock; 1429 } 1430 if (ndip->i_entries == (u32)-1) { 1431 error = -EFBIG; 1432 goto out_gunlock; 1433 } 1434 if (S_ISDIR(ip->i_inode.i_mode) && 1435 ndip->i_inode.i_nlink == (u32)-1) { 1436 error = -EMLINK; 1437 goto out_gunlock; 1438 } 1439 } 1440 } 1441 1442 /* Check out the dir to be renamed */ 1443 1444 if (dir_rename) { 1445 error = gfs2_permission(d_inode(odentry), MAY_WRITE); 1446 if (error) 1447 goto out_gunlock; 1448 } 1449 1450 if (nip == NULL) { 1451 error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name, &da); 1452 if (error) 1453 goto out_gunlock; 1454 } 1455 1456 if (da.nr_blocks) { 1457 struct gfs2_alloc_parms ap = { .target = da.nr_blocks, }; 1458 error = gfs2_quota_lock_check(ndip, &ap); 1459 if (error) 1460 goto out_gunlock; 1461 1462 error = gfs2_inplace_reserve(ndip, &ap); 1463 if (error) 1464 goto out_gunlock_q; 1465 1466 error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(ndip, &da, 4) + 1467 4 * RES_LEAF + 4, 0); 1468 if (error) 1469 goto out_ipreserv; 1470 } else { 1471 error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 1472 5 * RES_LEAF + 4, 0); 1473 if (error) 1474 goto out_gunlock; 1475 } 1476 1477 /* Remove the target file, if it exists */ 1478 1479 if (nip) 1480 error = gfs2_unlink_inode(ndip, ndentry); 1481 1482 error = update_moved_ino(ip, ndip, dir_rename); 1483 if (error) 1484 goto out_end_trans; 1485 1486 error = gfs2_dir_del(odip, odentry); 1487 if (error) 1488 goto out_end_trans; 1489 1490 error = gfs2_dir_add(ndir, &ndentry->d_name, ip, &da); 1491 if (error) 1492 goto out_end_trans; 1493 1494 out_end_trans: 1495 gfs2_trans_end(sdp); 1496 out_ipreserv: 1497 if (da.nr_blocks) 1498 gfs2_inplace_release(ndip); 1499 out_gunlock_q: 1500 if (da.nr_blocks) 1501 gfs2_quota_unlock(ndip); 1502 out_gunlock: 1503 gfs2_dir_no_add(&da); 1504 while (x--) { 1505 gfs2_glock_dq(ghs + x); 1506 gfs2_holder_uninit(ghs + x); 1507 } 1508 out_gunlock_r: 1509 if (r_gh.gh_gl) 1510 gfs2_glock_dq_uninit(&r_gh); 1511 out: 1512 return error; 1513 } 1514 1515 /** 1516 * gfs2_exchange - exchange two files 1517 * @odir: Parent directory of old file name 1518 * @odentry: The old dentry of the file 1519 * @ndir: Parent directory of new file name 1520 * @ndentry: The new dentry of the file 1521 * @flags: The rename flags 1522 * 1523 * Returns: errno 1524 */ 1525 1526 static int gfs2_exchange(struct inode *odir, struct dentry *odentry, 1527 struct inode *ndir, struct dentry *ndentry, 1528 unsigned int flags) 1529 { 1530 struct gfs2_inode *odip = GFS2_I(odir); 1531 struct gfs2_inode *ndip = GFS2_I(ndir); 1532 struct gfs2_inode *oip = GFS2_I(odentry->d_inode); 1533 struct gfs2_inode *nip = GFS2_I(ndentry->d_inode); 1534 struct gfs2_sbd *sdp = GFS2_SB(odir); 1535 struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }; 1536 unsigned int num_gh; 1537 unsigned int x; 1538 umode_t old_mode = oip->i_inode.i_mode; 1539 umode_t new_mode = nip->i_inode.i_mode; 1540 int error; 1541 1542 error = gfs2_rindex_update(sdp); 1543 if (error) 1544 return error; 1545 1546 if (odip != ndip) { 1547 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE, 1548 0, &r_gh); 1549 if (error) 1550 goto out; 1551 1552 if (S_ISDIR(old_mode)) { 1553 /* don't move a directory into its subdir */ 1554 error = gfs2_ok_to_move(oip, ndip); 1555 if (error) 1556 goto out_gunlock_r; 1557 } 1558 1559 if (S_ISDIR(new_mode)) { 1560 /* don't move a directory into its subdir */ 1561 error = gfs2_ok_to_move(nip, odip); 1562 if (error) 1563 goto out_gunlock_r; 1564 } 1565 } 1566 1567 num_gh = 1; 1568 gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs); 1569 if (odip != ndip) { 1570 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1571 num_gh++; 1572 } 1573 gfs2_holder_init(oip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1574 num_gh++; 1575 1576 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh); 1577 num_gh++; 1578 1579 for (x = 0; x < num_gh; x++) { 1580 error = gfs2_glock_nq(ghs + x); 1581 if (error) 1582 goto out_gunlock; 1583 } 1584 1585 error = -ENOENT; 1586 if (oip->i_inode.i_nlink == 0 || nip->i_inode.i_nlink == 0) 1587 goto out_gunlock; 1588 1589 error = gfs2_unlink_ok(odip, &odentry->d_name, oip); 1590 if (error) 1591 goto out_gunlock; 1592 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip); 1593 if (error) 1594 goto out_gunlock; 1595 1596 if (S_ISDIR(old_mode)) { 1597 error = gfs2_permission(odentry->d_inode, MAY_WRITE); 1598 if (error) 1599 goto out_gunlock; 1600 } 1601 if (S_ISDIR(new_mode)) { 1602 error = gfs2_permission(ndentry->d_inode, MAY_WRITE); 1603 if (error) 1604 goto out_gunlock; 1605 } 1606 error = gfs2_trans_begin(sdp, 4 * RES_DINODE + 4 * RES_LEAF, 0); 1607 if (error) 1608 goto out_gunlock; 1609 1610 error = update_moved_ino(oip, ndip, S_ISDIR(old_mode)); 1611 if (error) 1612 goto out_end_trans; 1613 1614 error = update_moved_ino(nip, odip, S_ISDIR(new_mode)); 1615 if (error) 1616 goto out_end_trans; 1617 1618 error = gfs2_dir_mvino(ndip, &ndentry->d_name, oip, 1619 IF2DT(old_mode)); 1620 if (error) 1621 goto out_end_trans; 1622 1623 error = gfs2_dir_mvino(odip, &odentry->d_name, nip, 1624 IF2DT(new_mode)); 1625 if (error) 1626 goto out_end_trans; 1627 1628 if (odip != ndip) { 1629 if (S_ISDIR(new_mode) && !S_ISDIR(old_mode)) { 1630 inc_nlink(&odip->i_inode); 1631 drop_nlink(&ndip->i_inode); 1632 } else if (S_ISDIR(old_mode) && !S_ISDIR(new_mode)) { 1633 inc_nlink(&ndip->i_inode); 1634 drop_nlink(&odip->i_inode); 1635 } 1636 } 1637 mark_inode_dirty(&ndip->i_inode); 1638 if (odip != ndip) 1639 mark_inode_dirty(&odip->i_inode); 1640 1641 out_end_trans: 1642 gfs2_trans_end(sdp); 1643 out_gunlock: 1644 while (x--) { 1645 gfs2_glock_dq(ghs + x); 1646 gfs2_holder_uninit(ghs + x); 1647 } 1648 out_gunlock_r: 1649 if (r_gh.gh_gl) 1650 gfs2_glock_dq_uninit(&r_gh); 1651 out: 1652 return error; 1653 } 1654 1655 static int gfs2_rename2(struct inode *odir, struct dentry *odentry, 1656 struct inode *ndir, struct dentry *ndentry, 1657 unsigned int flags) 1658 { 1659 flags &= ~RENAME_NOREPLACE; 1660 1661 if (flags & ~RENAME_EXCHANGE) 1662 return -EINVAL; 1663 1664 if (flags & RENAME_EXCHANGE) 1665 return gfs2_exchange(odir, odentry, ndir, ndentry, flags); 1666 1667 return gfs2_rename(odir, odentry, ndir, ndentry); 1668 } 1669 1670 /** 1671 * gfs2_get_link - Follow a symbolic link 1672 * @dentry: The dentry of the link 1673 * @inode: The inode of the link 1674 * @done: destructor for return value 1675 * 1676 * This can handle symlinks of any size. 1677 * 1678 * Returns: 0 on success or error code 1679 */ 1680 1681 static const char *gfs2_get_link(struct dentry *dentry, 1682 struct inode *inode, 1683 struct delayed_call *done) 1684 { 1685 struct gfs2_inode *ip = GFS2_I(inode); 1686 struct gfs2_holder i_gh; 1687 struct buffer_head *dibh; 1688 unsigned int size; 1689 char *buf; 1690 int error; 1691 1692 if (!dentry) 1693 return ERR_PTR(-ECHILD); 1694 1695 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh); 1696 error = gfs2_glock_nq(&i_gh); 1697 if (error) { 1698 gfs2_holder_uninit(&i_gh); 1699 return ERR_PTR(error); 1700 } 1701 1702 size = (unsigned int)i_size_read(&ip->i_inode); 1703 if (size == 0) { 1704 gfs2_consist_inode(ip); 1705 buf = ERR_PTR(-EIO); 1706 goto out; 1707 } 1708 1709 error = gfs2_meta_inode_buffer(ip, &dibh); 1710 if (error) { 1711 buf = ERR_PTR(error); 1712 goto out; 1713 } 1714 1715 buf = kzalloc(size + 1, GFP_NOFS); 1716 if (!buf) 1717 buf = ERR_PTR(-ENOMEM); 1718 else 1719 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size); 1720 brelse(dibh); 1721 out: 1722 gfs2_glock_dq_uninit(&i_gh); 1723 if (!IS_ERR(buf)) 1724 set_delayed_call(done, kfree_link, buf); 1725 return buf; 1726 } 1727 1728 /** 1729 * gfs2_permission - 1730 * @inode: The inode 1731 * @mask: The mask to be tested 1732 * @flags: Indicates whether this is an RCU path walk or not 1733 * 1734 * This may be called from the VFS directly, or from within GFS2 with the 1735 * inode locked, so we look to see if the glock is already locked and only 1736 * lock the glock if its not already been done. 1737 * 1738 * Returns: errno 1739 */ 1740 1741 int gfs2_permission(struct inode *inode, int mask) 1742 { 1743 struct gfs2_inode *ip; 1744 struct gfs2_holder i_gh; 1745 int error; 1746 int unlock = 0; 1747 1748 1749 ip = GFS2_I(inode); 1750 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) { 1751 if (mask & MAY_NOT_BLOCK) 1752 return -ECHILD; 1753 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); 1754 if (error) 1755 return error; 1756 unlock = 1; 1757 } 1758 1759 if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode)) 1760 error = -EACCES; 1761 else 1762 error = generic_permission(inode, mask); 1763 if (unlock) 1764 gfs2_glock_dq_uninit(&i_gh); 1765 1766 return error; 1767 } 1768 1769 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr) 1770 { 1771 setattr_copy(inode, attr); 1772 mark_inode_dirty(inode); 1773 return 0; 1774 } 1775 1776 /** 1777 * gfs2_setattr_simple - 1778 * @ip: 1779 * @attr: 1780 * 1781 * Returns: errno 1782 */ 1783 1784 int gfs2_setattr_simple(struct inode *inode, struct iattr *attr) 1785 { 1786 int error; 1787 1788 if (current->journal_info) 1789 return __gfs2_setattr_simple(inode, attr); 1790 1791 error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0); 1792 if (error) 1793 return error; 1794 1795 error = __gfs2_setattr_simple(inode, attr); 1796 gfs2_trans_end(GFS2_SB(inode)); 1797 return error; 1798 } 1799 1800 static int setattr_chown(struct inode *inode, struct iattr *attr) 1801 { 1802 struct gfs2_inode *ip = GFS2_I(inode); 1803 struct gfs2_sbd *sdp = GFS2_SB(inode); 1804 kuid_t ouid, nuid; 1805 kgid_t ogid, ngid; 1806 int error; 1807 struct gfs2_alloc_parms ap; 1808 1809 ouid = inode->i_uid; 1810 ogid = inode->i_gid; 1811 nuid = attr->ia_uid; 1812 ngid = attr->ia_gid; 1813 1814 if (!(attr->ia_valid & ATTR_UID) || uid_eq(ouid, nuid)) 1815 ouid = nuid = NO_UID_QUOTA_CHANGE; 1816 if (!(attr->ia_valid & ATTR_GID) || gid_eq(ogid, ngid)) 1817 ogid = ngid = NO_GID_QUOTA_CHANGE; 1818 1819 error = gfs2_rsqa_alloc(ip); 1820 if (error) 1821 goto out; 1822 1823 error = gfs2_rindex_update(sdp); 1824 if (error) 1825 goto out; 1826 1827 error = gfs2_quota_lock(ip, nuid, ngid); 1828 if (error) 1829 goto out; 1830 1831 ap.target = gfs2_get_inode_blocks(&ip->i_inode); 1832 1833 if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) || 1834 !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) { 1835 error = gfs2_quota_check(ip, nuid, ngid, &ap); 1836 if (error) 1837 goto out_gunlock_q; 1838 } 1839 1840 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0); 1841 if (error) 1842 goto out_gunlock_q; 1843 1844 error = gfs2_setattr_simple(inode, attr); 1845 if (error) 1846 goto out_end_trans; 1847 1848 if (!uid_eq(ouid, NO_UID_QUOTA_CHANGE) || 1849 !gid_eq(ogid, NO_GID_QUOTA_CHANGE)) { 1850 gfs2_quota_change(ip, -(s64)ap.target, ouid, ogid); 1851 gfs2_quota_change(ip, ap.target, nuid, ngid); 1852 } 1853 1854 out_end_trans: 1855 gfs2_trans_end(sdp); 1856 out_gunlock_q: 1857 gfs2_quota_unlock(ip); 1858 out: 1859 return error; 1860 } 1861 1862 /** 1863 * gfs2_setattr - Change attributes on an inode 1864 * @dentry: The dentry which is changing 1865 * @attr: The structure describing the change 1866 * 1867 * The VFS layer wants to change one or more of an inodes attributes. Write 1868 * that change out to disk. 1869 * 1870 * Returns: errno 1871 */ 1872 1873 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr) 1874 { 1875 struct inode *inode = d_inode(dentry); 1876 struct gfs2_inode *ip = GFS2_I(inode); 1877 struct gfs2_holder i_gh; 1878 int error; 1879 1880 error = gfs2_rsqa_alloc(ip); 1881 if (error) 1882 return error; 1883 1884 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh); 1885 if (error) 1886 return error; 1887 1888 error = -EPERM; 1889 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 1890 goto out; 1891 1892 error = inode_change_ok(inode, attr); 1893 if (error) 1894 goto out; 1895 1896 if (attr->ia_valid & ATTR_SIZE) 1897 error = gfs2_setattr_size(inode, attr->ia_size); 1898 else if (attr->ia_valid & (ATTR_UID | ATTR_GID)) 1899 error = setattr_chown(inode, attr); 1900 else { 1901 error = gfs2_setattr_simple(inode, attr); 1902 if (!error && attr->ia_valid & ATTR_MODE) 1903 error = posix_acl_chmod(inode, inode->i_mode); 1904 } 1905 1906 out: 1907 if (!error) 1908 mark_inode_dirty(inode); 1909 gfs2_glock_dq_uninit(&i_gh); 1910 return error; 1911 } 1912 1913 /** 1914 * gfs2_getattr - Read out an inode's attributes 1915 * @mnt: The vfsmount the inode is being accessed from 1916 * @dentry: The dentry to stat 1917 * @stat: The inode's stats 1918 * 1919 * This may be called from the VFS directly, or from within GFS2 with the 1920 * inode locked, so we look to see if the glock is already locked and only 1921 * lock the glock if its not already been done. Note that its the NFS 1922 * readdirplus operation which causes this to be called (from filldir) 1923 * with the glock already held. 1924 * 1925 * Returns: errno 1926 */ 1927 1928 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry, 1929 struct kstat *stat) 1930 { 1931 struct inode *inode = d_inode(dentry); 1932 struct gfs2_inode *ip = GFS2_I(inode); 1933 struct gfs2_holder gh; 1934 int error; 1935 int unlock = 0; 1936 1937 if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) { 1938 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh); 1939 if (error) 1940 return error; 1941 unlock = 1; 1942 } 1943 1944 generic_fillattr(inode, stat); 1945 if (unlock) 1946 gfs2_glock_dq_uninit(&gh); 1947 1948 return 0; 1949 } 1950 1951 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 1952 u64 start, u64 len) 1953 { 1954 struct gfs2_inode *ip = GFS2_I(inode); 1955 struct gfs2_holder gh; 1956 int ret; 1957 1958 ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC); 1959 if (ret) 1960 return ret; 1961 1962 inode_lock(inode); 1963 1964 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh); 1965 if (ret) 1966 goto out; 1967 1968 if (gfs2_is_stuffed(ip)) { 1969 u64 phys = ip->i_no_addr << inode->i_blkbits; 1970 u64 size = i_size_read(inode); 1971 u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED| 1972 FIEMAP_EXTENT_DATA_INLINE; 1973 phys += sizeof(struct gfs2_dinode); 1974 phys += start; 1975 if (start + len > size) 1976 len = size - start; 1977 if (start < size) 1978 ret = fiemap_fill_next_extent(fieinfo, start, phys, 1979 len, flags); 1980 if (ret == 1) 1981 ret = 0; 1982 } else { 1983 ret = __generic_block_fiemap(inode, fieinfo, start, len, 1984 gfs2_block_map); 1985 } 1986 1987 gfs2_glock_dq_uninit(&gh); 1988 out: 1989 inode_unlock(inode); 1990 return ret; 1991 } 1992 1993 const struct inode_operations gfs2_file_iops = { 1994 .permission = gfs2_permission, 1995 .setattr = gfs2_setattr, 1996 .getattr = gfs2_getattr, 1997 .setxattr = generic_setxattr, 1998 .getxattr = generic_getxattr, 1999 .listxattr = gfs2_listxattr, 2000 .removexattr = generic_removexattr, 2001 .fiemap = gfs2_fiemap, 2002 .get_acl = gfs2_get_acl, 2003 .set_acl = gfs2_set_acl, 2004 }; 2005 2006 const struct inode_operations gfs2_dir_iops = { 2007 .create = gfs2_create, 2008 .lookup = gfs2_lookup, 2009 .link = gfs2_link, 2010 .unlink = gfs2_unlink, 2011 .symlink = gfs2_symlink, 2012 .mkdir = gfs2_mkdir, 2013 .rmdir = gfs2_unlink, 2014 .mknod = gfs2_mknod, 2015 .rename2 = gfs2_rename2, 2016 .permission = gfs2_permission, 2017 .setattr = gfs2_setattr, 2018 .getattr = gfs2_getattr, 2019 .setxattr = generic_setxattr, 2020 .getxattr = generic_getxattr, 2021 .listxattr = gfs2_listxattr, 2022 .removexattr = generic_removexattr, 2023 .fiemap = gfs2_fiemap, 2024 .get_acl = gfs2_get_acl, 2025 .set_acl = gfs2_set_acl, 2026 .atomic_open = gfs2_atomic_open, 2027 }; 2028 2029 const struct inode_operations gfs2_symlink_iops = { 2030 .readlink = generic_readlink, 2031 .get_link = gfs2_get_link, 2032 .permission = gfs2_permission, 2033 .setattr = gfs2_setattr, 2034 .getattr = gfs2_getattr, 2035 .setxattr = generic_setxattr, 2036 .getxattr = generic_getxattr, 2037 .listxattr = gfs2_listxattr, 2038 .removexattr = generic_removexattr, 2039 .fiemap = gfs2_fiemap, 2040 }; 2041 2042