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