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