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