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