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