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