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