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