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