1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10 #include <linux/sched.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/posix_acl.h> 16 #include <linux/sort.h> 17 #include <linux/gfs2_ondisk.h> 18 #include <linux/crc32.h> 19 #include <linux/lm_interface.h> 20 #include <linux/security.h> 21 22 #include "gfs2.h" 23 #include "incore.h" 24 #include "acl.h" 25 #include "bmap.h" 26 #include "dir.h" 27 #include "eattr.h" 28 #include "glock.h" 29 #include "glops.h" 30 #include "inode.h" 31 #include "log.h" 32 #include "meta_io.h" 33 #include "ops_address.h" 34 #include "ops_file.h" 35 #include "ops_inode.h" 36 #include "quota.h" 37 #include "rgrp.h" 38 #include "trans.h" 39 #include "util.h" 40 41 /** 42 * gfs2_inode_attr_in - Copy attributes from the dinode into the VFS inode 43 * @ip: The GFS2 inode (with embedded disk inode data) 44 * @inode: The Linux VFS inode 45 * 46 */ 47 48 void gfs2_inode_attr_in(struct gfs2_inode *ip) 49 { 50 struct inode *inode = &ip->i_inode; 51 struct gfs2_dinode_host *di = &ip->i_di; 52 53 inode->i_ino = ip->i_num.no_addr; 54 55 switch (di->di_mode & S_IFMT) { 56 case S_IFBLK: 57 case S_IFCHR: 58 inode->i_rdev = MKDEV(di->di_major, di->di_minor); 59 break; 60 default: 61 inode->i_rdev = 0; 62 break; 63 }; 64 65 inode->i_mode = di->di_mode; 66 inode->i_nlink = di->di_nlink; 67 inode->i_uid = di->di_uid; 68 inode->i_gid = di->di_gid; 69 i_size_write(inode, di->di_size); 70 inode->i_atime.tv_sec = di->di_atime; 71 inode->i_mtime.tv_sec = di->di_mtime; 72 inode->i_ctime.tv_sec = di->di_ctime; 73 inode->i_atime.tv_nsec = 0; 74 inode->i_mtime.tv_nsec = 0; 75 inode->i_ctime.tv_nsec = 0; 76 inode->i_blocks = di->di_blocks << 77 (GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT); 78 79 if (di->di_flags & GFS2_DIF_IMMUTABLE) 80 inode->i_flags |= S_IMMUTABLE; 81 else 82 inode->i_flags &= ~S_IMMUTABLE; 83 84 if (di->di_flags & GFS2_DIF_APPENDONLY) 85 inode->i_flags |= S_APPEND; 86 else 87 inode->i_flags &= ~S_APPEND; 88 } 89 90 /** 91 * gfs2_inode_attr_out - Copy attributes from VFS inode into the dinode 92 * @ip: The GFS2 inode 93 * 94 * Only copy out the attributes that we want the VFS layer 95 * to be able to modify. 96 */ 97 98 void gfs2_inode_attr_out(struct gfs2_inode *ip) 99 { 100 struct inode *inode = &ip->i_inode; 101 struct gfs2_dinode_host *di = &ip->i_di; 102 gfs2_assert_withdraw(GFS2_SB(inode), 103 (di->di_mode & S_IFMT) == (inode->i_mode & S_IFMT)); 104 di->di_mode = inode->i_mode; 105 di->di_uid = inode->i_uid; 106 di->di_gid = inode->i_gid; 107 di->di_atime = inode->i_atime.tv_sec; 108 di->di_mtime = inode->i_mtime.tv_sec; 109 di->di_ctime = inode->i_ctime.tv_sec; 110 } 111 112 static int iget_test(struct inode *inode, void *opaque) 113 { 114 struct gfs2_inode *ip = GFS2_I(inode); 115 struct gfs2_inum_host *inum = opaque; 116 117 if (ip && ip->i_num.no_addr == inum->no_addr) 118 return 1; 119 120 return 0; 121 } 122 123 static int iget_set(struct inode *inode, void *opaque) 124 { 125 struct gfs2_inode *ip = GFS2_I(inode); 126 struct gfs2_inum_host *inum = opaque; 127 128 ip->i_num = *inum; 129 return 0; 130 } 131 132 struct inode *gfs2_ilookup(struct super_block *sb, struct gfs2_inum_host *inum) 133 { 134 return ilookup5(sb, (unsigned long)inum->no_formal_ino, 135 iget_test, inum); 136 } 137 138 static struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum_host *inum) 139 { 140 return iget5_locked(sb, (unsigned long)inum->no_formal_ino, 141 iget_test, iget_set, inum); 142 } 143 144 /** 145 * gfs2_inode_lookup - Lookup an inode 146 * @sb: The super block 147 * @inum: The inode number 148 * @type: The type of the inode 149 * 150 * Returns: A VFS inode, or an error 151 */ 152 153 struct inode *gfs2_inode_lookup(struct super_block *sb, struct gfs2_inum_host *inum, unsigned int type) 154 { 155 struct inode *inode = gfs2_iget(sb, inum); 156 struct gfs2_inode *ip = GFS2_I(inode); 157 struct gfs2_glock *io_gl; 158 int error; 159 160 if (!inode) 161 return ERR_PTR(-ENOBUFS); 162 163 if (inode->i_state & I_NEW) { 164 struct gfs2_sbd *sdp = GFS2_SB(inode); 165 umode_t mode = DT2IF(type); 166 inode->i_private = ip; 167 inode->i_mode = mode; 168 169 if (S_ISREG(mode)) { 170 inode->i_op = &gfs2_file_iops; 171 inode->i_fop = &gfs2_file_fops; 172 inode->i_mapping->a_ops = &gfs2_file_aops; 173 } else if (S_ISDIR(mode)) { 174 inode->i_op = &gfs2_dir_iops; 175 inode->i_fop = &gfs2_dir_fops; 176 } else if (S_ISLNK(mode)) { 177 inode->i_op = &gfs2_symlink_iops; 178 } else { 179 inode->i_op = &gfs2_dev_iops; 180 } 181 182 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 183 if (unlikely(error)) 184 goto fail; 185 ip->i_gl->gl_object = ip; 186 187 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_iopen_glops, CREATE, &io_gl); 188 if (unlikely(error)) 189 goto fail_put; 190 191 ip->i_vn = ip->i_gl->gl_vn - 1; 192 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 193 if (unlikely(error)) 194 goto fail_iopen; 195 196 gfs2_glock_put(io_gl); 197 unlock_new_inode(inode); 198 } 199 200 return inode; 201 fail_iopen: 202 gfs2_glock_put(io_gl); 203 fail_put: 204 ip->i_gl->gl_object = NULL; 205 gfs2_glock_put(ip->i_gl); 206 fail: 207 iput(inode); 208 return ERR_PTR(error); 209 } 210 211 /** 212 * gfs2_inode_refresh - Refresh the incore copy of the dinode 213 * @ip: The GFS2 inode 214 * 215 * Returns: errno 216 */ 217 218 int gfs2_inode_refresh(struct gfs2_inode *ip) 219 { 220 struct buffer_head *dibh; 221 int error; 222 223 error = gfs2_meta_inode_buffer(ip, &dibh); 224 if (error) 225 return error; 226 227 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) { 228 brelse(dibh); 229 return -EIO; 230 } 231 232 gfs2_dinode_in(ip, dibh->b_data); 233 234 brelse(dibh); 235 236 if (ip->i_num.no_addr != ip->i_di.di_num.no_addr) { 237 if (gfs2_consist_inode(ip)) 238 gfs2_dinode_print(&ip->i_di); 239 return -EIO; 240 } 241 if (ip->i_num.no_formal_ino != ip->i_di.di_num.no_formal_ino) 242 return -ESTALE; 243 244 ip->i_vn = ip->i_gl->gl_vn; 245 246 return 0; 247 } 248 249 int gfs2_dinode_dealloc(struct gfs2_inode *ip) 250 { 251 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 252 struct gfs2_alloc *al; 253 struct gfs2_rgrpd *rgd; 254 int error; 255 256 if (ip->i_di.di_blocks != 1) { 257 if (gfs2_consist_inode(ip)) 258 gfs2_dinode_print(&ip->i_di); 259 return -EIO; 260 } 261 262 al = gfs2_alloc_get(ip); 263 264 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 265 if (error) 266 goto out; 267 268 error = gfs2_rindex_hold(sdp, &al->al_ri_gh); 269 if (error) 270 goto out_qs; 271 272 rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr); 273 if (!rgd) { 274 gfs2_consist_inode(ip); 275 error = -EIO; 276 goto out_rindex_relse; 277 } 278 279 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, 280 &al->al_rgd_gh); 281 if (error) 282 goto out_rindex_relse; 283 284 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1); 285 if (error) 286 goto out_rg_gunlock; 287 288 gfs2_trans_add_gl(ip->i_gl); 289 290 gfs2_free_di(rgd, ip); 291 292 gfs2_trans_end(sdp); 293 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags); 294 295 out_rg_gunlock: 296 gfs2_glock_dq_uninit(&al->al_rgd_gh); 297 out_rindex_relse: 298 gfs2_glock_dq_uninit(&al->al_ri_gh); 299 out_qs: 300 gfs2_quota_unhold(ip); 301 out: 302 gfs2_alloc_put(ip); 303 return error; 304 } 305 306 /** 307 * gfs2_change_nlink - Change nlink count on inode 308 * @ip: The GFS2 inode 309 * @diff: The change in the nlink count required 310 * 311 * Returns: errno 312 */ 313 314 int gfs2_change_nlink(struct gfs2_inode *ip, int diff) 315 { 316 struct gfs2_sbd *sdp = ip->i_inode.i_sb->s_fs_info; 317 struct buffer_head *dibh; 318 u32 nlink; 319 int error; 320 321 BUG_ON(ip->i_di.di_nlink != ip->i_inode.i_nlink); 322 nlink = ip->i_di.di_nlink + diff; 323 324 /* If we are reducing the nlink count, but the new value ends up being 325 bigger than the old one, we must have underflowed. */ 326 if (diff < 0 && nlink > ip->i_di.di_nlink) { 327 if (gfs2_consist_inode(ip)) 328 gfs2_dinode_print(&ip->i_di); 329 return -EIO; 330 } 331 332 error = gfs2_meta_inode_buffer(ip, &dibh); 333 if (error) 334 return error; 335 336 ip->i_di.di_nlink = nlink; 337 ip->i_di.di_ctime = get_seconds(); 338 ip->i_inode.i_nlink = nlink; 339 340 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 341 gfs2_dinode_out(ip, dibh->b_data); 342 brelse(dibh); 343 mark_inode_dirty(&ip->i_inode); 344 345 if (ip->i_di.di_nlink == 0) { 346 struct gfs2_rgrpd *rgd; 347 struct gfs2_holder ri_gh, rg_gh; 348 349 error = gfs2_rindex_hold(sdp, &ri_gh); 350 if (error) 351 goto out; 352 error = -EIO; 353 rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr); 354 if (!rgd) 355 goto out_norgrp; 356 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh); 357 if (error) 358 goto out_norgrp; 359 360 clear_nlink(&ip->i_inode); 361 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */ 362 gfs2_glock_dq_uninit(&rg_gh); 363 out_norgrp: 364 gfs2_glock_dq_uninit(&ri_gh); 365 } 366 out: 367 return error; 368 } 369 370 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name) 371 { 372 struct qstr qstr; 373 gfs2_str2qstr(&qstr, name); 374 return gfs2_lookupi(dip, &qstr, 1, NULL); 375 } 376 377 378 /** 379 * gfs2_lookupi - Look up a filename in a directory and return its inode 380 * @d_gh: An initialized holder for the directory glock 381 * @name: The name of the inode to look for 382 * @is_root: If 1, ignore the caller's permissions 383 * @i_gh: An uninitialized holder for the new inode glock 384 * 385 * There will always be a vnode (Linux VFS inode) for the d_gh inode unless 386 * @is_root is true. 387 * 388 * Returns: errno 389 */ 390 391 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name, 392 int is_root, struct nameidata *nd) 393 { 394 struct super_block *sb = dir->i_sb; 395 struct gfs2_inode *dip = GFS2_I(dir); 396 struct gfs2_holder d_gh; 397 struct gfs2_inum_host inum; 398 unsigned int type; 399 int error = 0; 400 struct inode *inode = NULL; 401 402 if (!name->len || name->len > GFS2_FNAMESIZE) 403 return ERR_PTR(-ENAMETOOLONG); 404 405 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) || 406 (name->len == 2 && memcmp(name->name, "..", 2) == 0 && 407 dir == sb->s_root->d_inode)) { 408 igrab(dir); 409 return dir; 410 } 411 412 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); 413 if (error) 414 return ERR_PTR(error); 415 416 if (!is_root) { 417 error = permission(dir, MAY_EXEC, NULL); 418 if (error) 419 goto out; 420 } 421 422 error = gfs2_dir_search(dir, name, &inum, &type); 423 if (error) 424 goto out; 425 426 inode = gfs2_inode_lookup(sb, &inum, type); 427 428 out: 429 gfs2_glock_dq_uninit(&d_gh); 430 if (error == -ENOENT) 431 return NULL; 432 return inode; 433 } 434 435 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino) 436 { 437 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 438 struct buffer_head *bh; 439 struct gfs2_inum_range_host ir; 440 int error; 441 442 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 443 if (error) 444 return error; 445 mutex_lock(&sdp->sd_inum_mutex); 446 447 error = gfs2_meta_inode_buffer(ip, &bh); 448 if (error) { 449 mutex_unlock(&sdp->sd_inum_mutex); 450 gfs2_trans_end(sdp); 451 return error; 452 } 453 454 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 455 456 if (ir.ir_length) { 457 *formal_ino = ir.ir_start++; 458 ir.ir_length--; 459 gfs2_trans_add_bh(ip->i_gl, bh, 1); 460 gfs2_inum_range_out(&ir, 461 bh->b_data + sizeof(struct gfs2_dinode)); 462 brelse(bh); 463 mutex_unlock(&sdp->sd_inum_mutex); 464 gfs2_trans_end(sdp); 465 return 0; 466 } 467 468 brelse(bh); 469 470 mutex_unlock(&sdp->sd_inum_mutex); 471 gfs2_trans_end(sdp); 472 473 return 1; 474 } 475 476 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino) 477 { 478 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 479 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode); 480 struct gfs2_holder gh; 481 struct buffer_head *bh; 482 struct gfs2_inum_range_host ir; 483 int error; 484 485 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 486 if (error) 487 return error; 488 489 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 490 if (error) 491 goto out; 492 mutex_lock(&sdp->sd_inum_mutex); 493 494 error = gfs2_meta_inode_buffer(ip, &bh); 495 if (error) 496 goto out_end_trans; 497 498 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 499 500 if (!ir.ir_length) { 501 struct buffer_head *m_bh; 502 u64 x, y; 503 __be64 z; 504 505 error = gfs2_meta_inode_buffer(m_ip, &m_bh); 506 if (error) 507 goto out_brelse; 508 509 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)); 510 x = y = be64_to_cpu(z); 511 ir.ir_start = x; 512 ir.ir_length = GFS2_INUM_QUANTUM; 513 x += GFS2_INUM_QUANTUM; 514 if (x < y) 515 gfs2_consist_inode(m_ip); 516 z = cpu_to_be64(x); 517 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1); 518 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z; 519 520 brelse(m_bh); 521 } 522 523 *formal_ino = ir.ir_start++; 524 ir.ir_length--; 525 526 gfs2_trans_add_bh(ip->i_gl, bh, 1); 527 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 528 529 out_brelse: 530 brelse(bh); 531 out_end_trans: 532 mutex_unlock(&sdp->sd_inum_mutex); 533 gfs2_trans_end(sdp); 534 out: 535 gfs2_glock_dq_uninit(&gh); 536 return error; 537 } 538 539 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum) 540 { 541 int error; 542 543 error = pick_formal_ino_1(sdp, inum); 544 if (error <= 0) 545 return error; 546 547 error = pick_formal_ino_2(sdp, inum); 548 549 return error; 550 } 551 552 /** 553 * create_ok - OK to create a new on-disk inode here? 554 * @dip: Directory in which dinode is to be created 555 * @name: Name of new dinode 556 * @mode: 557 * 558 * Returns: errno 559 */ 560 561 static int create_ok(struct gfs2_inode *dip, const struct qstr *name, 562 unsigned int mode) 563 { 564 int error; 565 566 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 567 if (error) 568 return error; 569 570 /* Don't create entries in an unlinked directory */ 571 if (!dip->i_di.di_nlink) 572 return -EPERM; 573 574 error = gfs2_dir_search(&dip->i_inode, name, NULL, NULL); 575 switch (error) { 576 case -ENOENT: 577 error = 0; 578 break; 579 case 0: 580 return -EEXIST; 581 default: 582 return error; 583 } 584 585 if (dip->i_di.di_entries == (u32)-1) 586 return -EFBIG; 587 if (S_ISDIR(mode) && dip->i_di.di_nlink == (u32)-1) 588 return -EMLINK; 589 590 return 0; 591 } 592 593 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode, 594 unsigned int *uid, unsigned int *gid) 595 { 596 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir && 597 (dip->i_di.di_mode & S_ISUID) && dip->i_di.di_uid) { 598 if (S_ISDIR(*mode)) 599 *mode |= S_ISUID; 600 else if (dip->i_di.di_uid != current->fsuid) 601 *mode &= ~07111; 602 *uid = dip->i_di.di_uid; 603 } else 604 *uid = current->fsuid; 605 606 if (dip->i_di.di_mode & S_ISGID) { 607 if (S_ISDIR(*mode)) 608 *mode |= S_ISGID; 609 *gid = dip->i_di.di_gid; 610 } else 611 *gid = current->fsgid; 612 } 613 614 static int alloc_dinode(struct gfs2_inode *dip, struct gfs2_inum_host *inum, 615 u64 *generation) 616 { 617 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 618 int error; 619 620 gfs2_alloc_get(dip); 621 622 dip->i_alloc.al_requested = RES_DINODE; 623 error = gfs2_inplace_reserve(dip); 624 if (error) 625 goto out; 626 627 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0); 628 if (error) 629 goto out_ipreserv; 630 631 inum->no_addr = gfs2_alloc_di(dip, generation); 632 633 gfs2_trans_end(sdp); 634 635 out_ipreserv: 636 gfs2_inplace_release(dip); 637 out: 638 gfs2_alloc_put(dip); 639 return error; 640 } 641 642 /** 643 * init_dinode - Fill in a new dinode structure 644 * @dip: the directory this inode is being created in 645 * @gl: The glock covering the new inode 646 * @inum: the inode number 647 * @mode: the file permissions 648 * @uid: 649 * @gid: 650 * 651 */ 652 653 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 654 const struct gfs2_inum_host *inum, unsigned int mode, 655 unsigned int uid, unsigned int gid, 656 const u64 *generation) 657 { 658 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 659 struct gfs2_dinode *di; 660 struct buffer_head *dibh; 661 662 dibh = gfs2_meta_new(gl, inum->no_addr); 663 gfs2_trans_add_bh(gl, dibh, 1); 664 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI); 665 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 666 di = (struct gfs2_dinode *)dibh->b_data; 667 668 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino); 669 di->di_num.no_addr = cpu_to_be64(inum->no_addr); 670 di->di_mode = cpu_to_be32(mode); 671 di->di_uid = cpu_to_be32(uid); 672 di->di_gid = cpu_to_be32(gid); 673 di->di_nlink = cpu_to_be32(0); 674 di->di_size = cpu_to_be64(0); 675 di->di_blocks = cpu_to_be64(1); 676 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds()); 677 di->di_major = di->di_minor = cpu_to_be32(0); 678 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr); 679 di->di_generation = cpu_to_be64(*generation); 680 di->di_flags = cpu_to_be32(0); 681 682 if (S_ISREG(mode)) { 683 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) || 684 gfs2_tune_get(sdp, gt_new_files_jdata)) 685 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA); 686 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) || 687 gfs2_tune_get(sdp, gt_new_files_directio)) 688 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO); 689 } else if (S_ISDIR(mode)) { 690 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 691 GFS2_DIF_INHERIT_DIRECTIO); 692 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 693 GFS2_DIF_INHERIT_JDATA); 694 } 695 696 di->__pad1 = 0; 697 di->di_payload_format = cpu_to_be32(0); 698 di->di_height = cpu_to_be32(0); 699 di->__pad2 = 0; 700 di->__pad3 = 0; 701 di->di_depth = cpu_to_be16(0); 702 di->di_entries = cpu_to_be32(0); 703 memset(&di->__pad4, 0, sizeof(di->__pad4)); 704 di->di_eattr = cpu_to_be64(0); 705 memset(&di->di_reserved, 0, sizeof(di->di_reserved)); 706 707 brelse(dibh); 708 } 709 710 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 711 unsigned int mode, const struct gfs2_inum_host *inum, 712 const u64 *generation) 713 { 714 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 715 unsigned int uid, gid; 716 int error; 717 718 munge_mode_uid_gid(dip, &mode, &uid, &gid); 719 gfs2_alloc_get(dip); 720 721 error = gfs2_quota_lock(dip, uid, gid); 722 if (error) 723 goto out; 724 725 error = gfs2_quota_check(dip, uid, gid); 726 if (error) 727 goto out_quota; 728 729 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0); 730 if (error) 731 goto out_quota; 732 733 init_dinode(dip, gl, inum, mode, uid, gid, generation); 734 gfs2_quota_change(dip, +1, uid, gid); 735 gfs2_trans_end(sdp); 736 737 out_quota: 738 gfs2_quota_unlock(dip); 739 out: 740 gfs2_alloc_put(dip); 741 return error; 742 } 743 744 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, 745 struct gfs2_inode *ip) 746 { 747 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 748 struct gfs2_alloc *al; 749 int alloc_required; 750 struct buffer_head *dibh; 751 int error; 752 753 al = gfs2_alloc_get(dip); 754 755 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 756 if (error) 757 goto fail; 758 759 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name); 760 if (alloc_required < 0) 761 goto fail; 762 if (alloc_required) { 763 error = gfs2_quota_check(dip, dip->i_di.di_uid, 764 dip->i_di.di_gid); 765 if (error) 766 goto fail_quota_locks; 767 768 al->al_requested = sdp->sd_max_dirres; 769 770 error = gfs2_inplace_reserve(dip); 771 if (error) 772 goto fail_quota_locks; 773 774 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 775 al->al_rgd->rd_ri.ri_length + 776 2 * RES_DINODE + 777 RES_STATFS + RES_QUOTA, 0); 778 if (error) 779 goto fail_ipreserv; 780 } else { 781 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0); 782 if (error) 783 goto fail_quota_locks; 784 } 785 786 error = gfs2_dir_add(&dip->i_inode, name, &ip->i_num, IF2DT(ip->i_di.di_mode)); 787 if (error) 788 goto fail_end_trans; 789 790 error = gfs2_meta_inode_buffer(ip, &dibh); 791 if (error) 792 goto fail_end_trans; 793 ip->i_di.di_nlink = 1; 794 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 795 gfs2_dinode_out(ip, dibh->b_data); 796 brelse(dibh); 797 return 0; 798 799 fail_end_trans: 800 gfs2_trans_end(sdp); 801 802 fail_ipreserv: 803 if (dip->i_alloc.al_rgd) 804 gfs2_inplace_release(dip); 805 806 fail_quota_locks: 807 gfs2_quota_unlock(dip); 808 809 fail: 810 gfs2_alloc_put(dip); 811 return error; 812 } 813 814 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip) 815 { 816 int err; 817 size_t len; 818 void *value; 819 char *name; 820 struct gfs2_ea_request er; 821 822 err = security_inode_init_security(&ip->i_inode, &dip->i_inode, 823 &name, &value, &len); 824 825 if (err) { 826 if (err == -EOPNOTSUPP) 827 return 0; 828 return err; 829 } 830 831 memset(&er, 0, sizeof(struct gfs2_ea_request)); 832 833 er.er_type = GFS2_EATYPE_SECURITY; 834 er.er_name = name; 835 er.er_data = value; 836 er.er_name_len = strlen(name); 837 er.er_data_len = len; 838 839 err = gfs2_ea_set_i(ip, &er); 840 841 kfree(value); 842 kfree(name); 843 844 return err; 845 } 846 847 /** 848 * gfs2_createi - Create a new inode 849 * @ghs: An array of two holders 850 * @name: The name of the new file 851 * @mode: the permissions on the new inode 852 * 853 * @ghs[0] is an initialized holder for the directory 854 * @ghs[1] is the holder for the inode lock 855 * 856 * If the return value is not NULL, the glocks on both the directory and the new 857 * file are held. A transaction has been started and an inplace reservation 858 * is held, as well. 859 * 860 * Returns: An inode 861 */ 862 863 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name, 864 unsigned int mode) 865 { 866 struct inode *inode; 867 struct gfs2_inode *dip = ghs->gh_gl->gl_object; 868 struct inode *dir = &dip->i_inode; 869 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 870 struct gfs2_inum_host inum; 871 int error; 872 u64 generation; 873 874 if (!name->len || name->len > GFS2_FNAMESIZE) 875 return ERR_PTR(-ENAMETOOLONG); 876 877 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs); 878 error = gfs2_glock_nq(ghs); 879 if (error) 880 goto fail; 881 882 error = create_ok(dip, name, mode); 883 if (error) 884 goto fail_gunlock; 885 886 error = pick_formal_ino(sdp, &inum.no_formal_ino); 887 if (error) 888 goto fail_gunlock; 889 890 error = alloc_dinode(dip, &inum, &generation); 891 if (error) 892 goto fail_gunlock; 893 894 if (inum.no_addr < dip->i_num.no_addr) { 895 gfs2_glock_dq(ghs); 896 897 error = gfs2_glock_nq_num(sdp, inum.no_addr, 898 &gfs2_inode_glops, LM_ST_EXCLUSIVE, 899 GL_SKIP, ghs + 1); 900 if (error) { 901 return ERR_PTR(error); 902 } 903 904 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs); 905 error = gfs2_glock_nq(ghs); 906 if (error) { 907 gfs2_glock_dq_uninit(ghs + 1); 908 return ERR_PTR(error); 909 } 910 911 error = create_ok(dip, name, mode); 912 if (error) 913 goto fail_gunlock2; 914 } else { 915 error = gfs2_glock_nq_num(sdp, inum.no_addr, 916 &gfs2_inode_glops, LM_ST_EXCLUSIVE, 917 GL_SKIP, ghs + 1); 918 if (error) 919 goto fail_gunlock; 920 } 921 922 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation); 923 if (error) 924 goto fail_gunlock2; 925 926 inode = gfs2_inode_lookup(dir->i_sb, &inum, IF2DT(mode)); 927 if (IS_ERR(inode)) 928 goto fail_gunlock2; 929 930 error = gfs2_inode_refresh(GFS2_I(inode)); 931 if (error) 932 goto fail_iput; 933 934 error = gfs2_acl_create(dip, GFS2_I(inode)); 935 if (error) 936 goto fail_iput; 937 938 error = gfs2_security_init(dip, GFS2_I(inode)); 939 if (error) 940 goto fail_iput; 941 942 error = link_dinode(dip, name, GFS2_I(inode)); 943 if (error) 944 goto fail_iput; 945 946 if (!inode) 947 return ERR_PTR(-ENOMEM); 948 return inode; 949 950 fail_iput: 951 iput(inode); 952 fail_gunlock2: 953 gfs2_glock_dq_uninit(ghs + 1); 954 fail_gunlock: 955 gfs2_glock_dq(ghs); 956 fail: 957 return ERR_PTR(error); 958 } 959 960 /** 961 * gfs2_rmdiri - Remove a directory 962 * @dip: The parent directory of the directory to be removed 963 * @name: The name of the directory to be removed 964 * @ip: The GFS2 inode of the directory to be removed 965 * 966 * Assumes Glocks on dip and ip are held 967 * 968 * Returns: errno 969 */ 970 971 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name, 972 struct gfs2_inode *ip) 973 { 974 struct qstr dotname; 975 int error; 976 977 if (ip->i_di.di_entries != 2) { 978 if (gfs2_consist_inode(ip)) 979 gfs2_dinode_print(&ip->i_di); 980 return -EIO; 981 } 982 983 error = gfs2_dir_del(dip, name); 984 if (error) 985 return error; 986 987 error = gfs2_change_nlink(dip, -1); 988 if (error) 989 return error; 990 991 gfs2_str2qstr(&dotname, "."); 992 error = gfs2_dir_del(ip, &dotname); 993 if (error) 994 return error; 995 996 gfs2_str2qstr(&dotname, ".."); 997 error = gfs2_dir_del(ip, &dotname); 998 if (error) 999 return error; 1000 1001 error = gfs2_change_nlink(ip, -2); 1002 if (error) 1003 return error; 1004 1005 return error; 1006 } 1007 1008 /* 1009 * gfs2_unlink_ok - check to see that a inode is still in a directory 1010 * @dip: the directory 1011 * @name: the name of the file 1012 * @ip: the inode 1013 * 1014 * Assumes that the lock on (at least) @dip is held. 1015 * 1016 * Returns: 0 if the parent/child relationship is correct, errno if it isn't 1017 */ 1018 1019 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, 1020 struct gfs2_inode *ip) 1021 { 1022 struct gfs2_inum_host inum; 1023 unsigned int type; 1024 int error; 1025 1026 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) 1027 return -EPERM; 1028 1029 if ((dip->i_di.di_mode & S_ISVTX) && 1030 dip->i_di.di_uid != current->fsuid && 1031 ip->i_di.di_uid != current->fsuid && !capable(CAP_FOWNER)) 1032 return -EPERM; 1033 1034 if (IS_APPEND(&dip->i_inode)) 1035 return -EPERM; 1036 1037 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 1038 if (error) 1039 return error; 1040 1041 error = gfs2_dir_search(&dip->i_inode, name, &inum, &type); 1042 if (error) 1043 return error; 1044 1045 if (!gfs2_inum_equal(&inum, &ip->i_num)) 1046 return -ENOENT; 1047 1048 if (IF2DT(ip->i_di.di_mode) != type) { 1049 gfs2_consist_inode(dip); 1050 return -EIO; 1051 } 1052 1053 return 0; 1054 } 1055 1056 /* 1057 * gfs2_ok_to_move - check if it's ok to move a directory to another directory 1058 * @this: move this 1059 * @to: to here 1060 * 1061 * Follow @to back to the root and make sure we don't encounter @this 1062 * Assumes we already hold the rename lock. 1063 * 1064 * Returns: errno 1065 */ 1066 1067 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) 1068 { 1069 struct inode *dir = &to->i_inode; 1070 struct super_block *sb = dir->i_sb; 1071 struct inode *tmp; 1072 struct qstr dotdot; 1073 int error = 0; 1074 1075 gfs2_str2qstr(&dotdot, ".."); 1076 1077 igrab(dir); 1078 1079 for (;;) { 1080 if (dir == &this->i_inode) { 1081 error = -EINVAL; 1082 break; 1083 } 1084 if (dir == sb->s_root->d_inode) { 1085 error = 0; 1086 break; 1087 } 1088 1089 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL); 1090 if (IS_ERR(tmp)) { 1091 error = PTR_ERR(tmp); 1092 break; 1093 } 1094 1095 iput(dir); 1096 dir = tmp; 1097 } 1098 1099 iput(dir); 1100 1101 return error; 1102 } 1103 1104 /** 1105 * gfs2_readlinki - return the contents of a symlink 1106 * @ip: the symlink's inode 1107 * @buf: a pointer to the buffer to be filled 1108 * @len: a pointer to the length of @buf 1109 * 1110 * If @buf is too small, a piece of memory is kmalloc()ed and needs 1111 * to be freed by the caller. 1112 * 1113 * Returns: errno 1114 */ 1115 1116 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len) 1117 { 1118 struct gfs2_holder i_gh; 1119 struct buffer_head *dibh; 1120 unsigned int x; 1121 int error; 1122 1123 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh); 1124 error = gfs2_glock_nq_atime(&i_gh); 1125 if (error) { 1126 gfs2_holder_uninit(&i_gh); 1127 return error; 1128 } 1129 1130 if (!ip->i_di.di_size) { 1131 gfs2_consist_inode(ip); 1132 error = -EIO; 1133 goto out; 1134 } 1135 1136 error = gfs2_meta_inode_buffer(ip, &dibh); 1137 if (error) 1138 goto out; 1139 1140 x = ip->i_di.di_size + 1; 1141 if (x > *len) { 1142 *buf = kmalloc(x, GFP_KERNEL); 1143 if (!*buf) { 1144 error = -ENOMEM; 1145 goto out_brelse; 1146 } 1147 } 1148 1149 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x); 1150 *len = x; 1151 1152 out_brelse: 1153 brelse(dibh); 1154 out: 1155 gfs2_glock_dq_uninit(&i_gh); 1156 return error; 1157 } 1158 1159 /** 1160 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and 1161 * conditionally update the inode's atime 1162 * @gh: the holder to acquire 1163 * 1164 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap 1165 * Update if the difference between the current time and the inode's current 1166 * atime is greater than an interval specified at mount. 1167 * 1168 * Returns: errno 1169 */ 1170 1171 int gfs2_glock_nq_atime(struct gfs2_holder *gh) 1172 { 1173 struct gfs2_glock *gl = gh->gh_gl; 1174 struct gfs2_sbd *sdp = gl->gl_sbd; 1175 struct gfs2_inode *ip = gl->gl_object; 1176 s64 curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum); 1177 unsigned int state; 1178 int flags; 1179 int error; 1180 1181 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) || 1182 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) || 1183 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops)) 1184 return -EINVAL; 1185 1186 state = gh->gh_state; 1187 flags = gh->gh_flags; 1188 1189 error = gfs2_glock_nq(gh); 1190 if (error) 1191 return error; 1192 1193 if (test_bit(SDF_NOATIME, &sdp->sd_flags) || 1194 (sdp->sd_vfs->s_flags & MS_RDONLY)) 1195 return 0; 1196 1197 curtime = get_seconds(); 1198 if (curtime - ip->i_di.di_atime >= quantum) { 1199 gfs2_glock_dq(gh); 1200 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY, 1201 gh); 1202 error = gfs2_glock_nq(gh); 1203 if (error) 1204 return error; 1205 1206 /* Verify that atime hasn't been updated while we were 1207 trying to get exclusive lock. */ 1208 1209 curtime = get_seconds(); 1210 if (curtime - ip->i_di.di_atime >= quantum) { 1211 struct buffer_head *dibh; 1212 struct gfs2_dinode *di; 1213 1214 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1215 if (error == -EROFS) 1216 return 0; 1217 if (error) 1218 goto fail; 1219 1220 error = gfs2_meta_inode_buffer(ip, &dibh); 1221 if (error) 1222 goto fail_end_trans; 1223 1224 ip->i_di.di_atime = curtime; 1225 1226 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1227 di = (struct gfs2_dinode *)dibh->b_data; 1228 di->di_atime = cpu_to_be64(ip->i_di.di_atime); 1229 brelse(dibh); 1230 1231 gfs2_trans_end(sdp); 1232 } 1233 1234 /* If someone else has asked for the glock, 1235 unlock and let them have it. Then reacquire 1236 in the original state. */ 1237 if (gfs2_glock_is_blocking(gl)) { 1238 gfs2_glock_dq(gh); 1239 gfs2_holder_reinit(state, flags, gh); 1240 return gfs2_glock_nq(gh); 1241 } 1242 } 1243 1244 return 0; 1245 1246 fail_end_trans: 1247 gfs2_trans_end(sdp); 1248 fail: 1249 gfs2_glock_dq(gh); 1250 return error; 1251 } 1252 1253 /** 1254 * glock_compare_atime - Compare two struct gfs2_glock structures for sort 1255 * @arg_a: the first structure 1256 * @arg_b: the second structure 1257 * 1258 * Returns: 1 if A > B 1259 * -1 if A < B 1260 * 0 if A == B 1261 */ 1262 1263 static int glock_compare_atime(const void *arg_a, const void *arg_b) 1264 { 1265 const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a; 1266 const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b; 1267 const struct lm_lockname *a = &gh_a->gh_gl->gl_name; 1268 const struct lm_lockname *b = &gh_b->gh_gl->gl_name; 1269 1270 if (a->ln_number > b->ln_number) 1271 return 1; 1272 if (a->ln_number < b->ln_number) 1273 return -1; 1274 if (gh_a->gh_state == LM_ST_SHARED && gh_b->gh_state == LM_ST_EXCLUSIVE) 1275 return 1; 1276 if (gh_a->gh_state == LM_ST_SHARED && (gh_b->gh_flags & GL_ATIME)) 1277 return 1; 1278 1279 return 0; 1280 } 1281 1282 /** 1283 * gfs2_glock_nq_m_atime - acquire multiple glocks where one may need an 1284 * atime update 1285 * @num_gh: the number of structures 1286 * @ghs: an array of struct gfs2_holder structures 1287 * 1288 * Returns: 0 on success (all glocks acquired), 1289 * errno on failure (no glocks acquired) 1290 */ 1291 1292 int gfs2_glock_nq_m_atime(unsigned int num_gh, struct gfs2_holder *ghs) 1293 { 1294 struct gfs2_holder **p; 1295 unsigned int x; 1296 int error = 0; 1297 1298 if (!num_gh) 1299 return 0; 1300 1301 if (num_gh == 1) { 1302 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC); 1303 if (ghs->gh_flags & GL_ATIME) 1304 error = gfs2_glock_nq_atime(ghs); 1305 else 1306 error = gfs2_glock_nq(ghs); 1307 return error; 1308 } 1309 1310 p = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL); 1311 if (!p) 1312 return -ENOMEM; 1313 1314 for (x = 0; x < num_gh; x++) 1315 p[x] = &ghs[x]; 1316 1317 sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare_atime,NULL); 1318 1319 for (x = 0; x < num_gh; x++) { 1320 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC); 1321 1322 if (p[x]->gh_flags & GL_ATIME) 1323 error = gfs2_glock_nq_atime(p[x]); 1324 else 1325 error = gfs2_glock_nq(p[x]); 1326 1327 if (error) { 1328 while (x--) 1329 gfs2_glock_dq(p[x]); 1330 break; 1331 } 1332 } 1333 1334 kfree(p); 1335 return error; 1336 } 1337 1338 1339 static int 1340 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1341 { 1342 struct buffer_head *dibh; 1343 int error; 1344 1345 error = gfs2_meta_inode_buffer(ip, &dibh); 1346 if (!error) { 1347 error = inode_setattr(&ip->i_inode, attr); 1348 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); 1349 gfs2_inode_attr_out(ip); 1350 1351 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1352 gfs2_dinode_out(ip, dibh->b_data); 1353 brelse(dibh); 1354 } 1355 return error; 1356 } 1357 1358 /** 1359 * gfs2_setattr_simple - 1360 * @ip: 1361 * @attr: 1362 * 1363 * Called with a reference on the vnode. 1364 * 1365 * Returns: errno 1366 */ 1367 1368 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1369 { 1370 int error; 1371 1372 if (current->journal_info) 1373 return __gfs2_setattr_simple(ip, attr); 1374 1375 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0); 1376 if (error) 1377 return error; 1378 1379 error = __gfs2_setattr_simple(ip, attr); 1380 gfs2_trans_end(GFS2_SB(&ip->i_inode)); 1381 return error; 1382 } 1383 1384