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