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/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_inode.h" 35 #include "quota.h" 36 #include "rgrp.h" 37 #include "trans.h" 38 #include "util.h" 39 40 struct gfs2_inum_range_host { 41 u64 ir_start; 42 u64 ir_length; 43 }; 44 45 static int iget_test(struct inode *inode, void *opaque) 46 { 47 struct gfs2_inode *ip = GFS2_I(inode); 48 u64 *no_addr = opaque; 49 50 if (ip->i_no_addr == *no_addr && 51 inode->i_private != NULL) 52 return 1; 53 54 return 0; 55 } 56 57 static int iget_set(struct inode *inode, void *opaque) 58 { 59 struct gfs2_inode *ip = GFS2_I(inode); 60 u64 *no_addr = opaque; 61 62 inode->i_ino = (unsigned long)*no_addr; 63 ip->i_no_addr = *no_addr; 64 return 0; 65 } 66 67 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr) 68 { 69 unsigned long hash = (unsigned long)no_addr; 70 return ilookup5(sb, hash, iget_test, &no_addr); 71 } 72 73 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr) 74 { 75 unsigned long hash = (unsigned long)no_addr; 76 return iget5_locked(sb, hash, iget_test, iget_set, &no_addr); 77 } 78 79 struct gfs2_skip_data { 80 u64 no_addr; 81 int skipped; 82 }; 83 84 static int iget_skip_test(struct inode *inode, void *opaque) 85 { 86 struct gfs2_inode *ip = GFS2_I(inode); 87 struct gfs2_skip_data *data = opaque; 88 89 if (ip->i_no_addr == data->no_addr && inode->i_private != NULL){ 90 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){ 91 data->skipped = 1; 92 return 0; 93 } 94 return 1; 95 } 96 return 0; 97 } 98 99 static int iget_skip_set(struct inode *inode, void *opaque) 100 { 101 struct gfs2_inode *ip = GFS2_I(inode); 102 struct gfs2_skip_data *data = opaque; 103 104 if (data->skipped) 105 return 1; 106 inode->i_ino = (unsigned long)(data->no_addr); 107 ip->i_no_addr = data->no_addr; 108 return 0; 109 } 110 111 static struct inode *gfs2_iget_skip(struct super_block *sb, 112 u64 no_addr) 113 { 114 struct gfs2_skip_data data; 115 unsigned long hash = (unsigned long)no_addr; 116 117 data.no_addr = no_addr; 118 data.skipped = 0; 119 return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data); 120 } 121 122 /** 123 * GFS2 lookup code fills in vfs inode contents based on info obtained 124 * from directory entry inside gfs2_inode_lookup(). This has caused issues 125 * with NFS code path since its get_dentry routine doesn't have the relevant 126 * directory entry when gfs2_inode_lookup() is invoked. Part of the code 127 * segment inside gfs2_inode_lookup code needs to get moved around. 128 * 129 * Clean up I_LOCK and I_NEW as well. 130 **/ 131 132 void gfs2_set_iop(struct inode *inode) 133 { 134 struct gfs2_sbd *sdp = GFS2_SB(inode); 135 umode_t mode = inode->i_mode; 136 137 if (S_ISREG(mode)) { 138 inode->i_op = &gfs2_file_iops; 139 if (sdp->sd_args.ar_localflocks) 140 inode->i_fop = &gfs2_file_fops_nolock; 141 else 142 inode->i_fop = &gfs2_file_fops; 143 } else if (S_ISDIR(mode)) { 144 inode->i_op = &gfs2_dir_iops; 145 if (sdp->sd_args.ar_localflocks) 146 inode->i_fop = &gfs2_dir_fops_nolock; 147 else 148 inode->i_fop = &gfs2_dir_fops; 149 } else if (S_ISLNK(mode)) { 150 inode->i_op = &gfs2_symlink_iops; 151 } else { 152 inode->i_op = &gfs2_dev_iops; 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 inode->i_private = ip; 190 ip->i_no_formal_ino = no_formal_ino; 191 192 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 193 if (unlikely(error)) 194 goto fail; 195 ip->i_gl->gl_object = ip; 196 197 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl); 198 if (unlikely(error)) 199 goto fail_put; 200 201 set_bit(GIF_INVALID, &ip->i_flags); 202 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh); 203 if (unlikely(error)) 204 goto fail_iopen; 205 ip->i_iopen_gh.gh_gl->gl_object = ip; 206 207 gfs2_glock_put(io_gl); 208 209 if ((type == DT_UNKNOWN) && (no_formal_ino == 0)) 210 goto gfs2_nfsbypass; 211 212 inode->i_mode = DT2IF(type); 213 214 /* 215 * We must read the inode in order to work out its type in 216 * this case. Note that this doesn't happen often as we normally 217 * know the type beforehand. This code path only occurs during 218 * unlinked inode recovery (where it is safe to do this glock, 219 * which is not true in the general case). 220 */ 221 if (type == DT_UNKNOWN) { 222 struct gfs2_holder gh; 223 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 224 if (unlikely(error)) 225 goto fail_glock; 226 /* Inode is now uptodate */ 227 gfs2_glock_dq_uninit(&gh); 228 } 229 230 gfs2_set_iop(inode); 231 } 232 233 gfs2_nfsbypass: 234 return inode; 235 fail_glock: 236 gfs2_glock_dq(&ip->i_iopen_gh); 237 fail_iopen: 238 gfs2_glock_put(io_gl); 239 fail_put: 240 ip->i_gl->gl_object = NULL; 241 gfs2_glock_put(ip->i_gl); 242 fail: 243 iget_failed(inode); 244 return ERR_PTR(error); 245 } 246 247 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) 248 { 249 struct gfs2_dinode_host *di = &ip->i_di; 250 const struct gfs2_dinode *str = buf; 251 u16 height; 252 253 if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr))) 254 goto corrupt; 255 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino); 256 ip->i_inode.i_mode = be32_to_cpu(str->di_mode); 257 ip->i_inode.i_rdev = 0; 258 switch (ip->i_inode.i_mode & S_IFMT) { 259 case S_IFBLK: 260 case S_IFCHR: 261 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major), 262 be32_to_cpu(str->di_minor)); 263 break; 264 }; 265 266 ip->i_inode.i_uid = be32_to_cpu(str->di_uid); 267 ip->i_inode.i_gid = be32_to_cpu(str->di_gid); 268 /* 269 * We will need to review setting the nlink count here in the 270 * light of the forthcoming ro bind mount work. This is a reminder 271 * to do that. 272 */ 273 ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink); 274 di->di_size = be64_to_cpu(str->di_size); 275 i_size_write(&ip->i_inode, di->di_size); 276 di->di_blocks = be64_to_cpu(str->di_blocks); 277 gfs2_set_inode_blocks(&ip->i_inode); 278 ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime); 279 ip->i_inode.i_atime.tv_nsec = be32_to_cpu(str->di_atime_nsec); 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 di->di_goal_meta = be64_to_cpu(str->di_goal_meta); 286 di->di_goal_data = be64_to_cpu(str->di_goal_data); 287 di->di_generation = be64_to_cpu(str->di_generation); 288 289 di->di_flags = be32_to_cpu(str->di_flags); 290 gfs2_set_inode_flags(&ip->i_inode); 291 height = be16_to_cpu(str->di_height); 292 if (unlikely(height > GFS2_MAX_META_HEIGHT)) 293 goto corrupt; 294 ip->i_height = (u8)height; 295 296 di->di_depth = be16_to_cpu(str->di_depth); 297 di->di_entries = be32_to_cpu(str->di_entries); 298 299 di->di_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 (ip->i_di.di_blocks != 1) { 346 if (gfs2_consist_inode(ip)) 347 gfs2_dinode_print(ip); 348 return -EIO; 349 } 350 351 al = gfs2_alloc_get(ip); 352 353 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 354 if (error) 355 goto out; 356 357 error = gfs2_rindex_hold(sdp, &al->al_ri_gh); 358 if (error) 359 goto out_qs; 360 361 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr); 362 if (!rgd) { 363 gfs2_consist_inode(ip); 364 error = -EIO; 365 goto out_rindex_relse; 366 } 367 368 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, 369 &al->al_rgd_gh); 370 if (error) 371 goto out_rindex_relse; 372 373 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1); 374 if (error) 375 goto out_rg_gunlock; 376 377 set_bit(GLF_DIRTY, &ip->i_gl->gl_flags); 378 set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags); 379 380 gfs2_free_di(rgd, ip); 381 382 gfs2_trans_end(sdp); 383 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags); 384 385 out_rg_gunlock: 386 gfs2_glock_dq_uninit(&al->al_rgd_gh); 387 out_rindex_relse: 388 gfs2_glock_dq_uninit(&al->al_ri_gh); 389 out_qs: 390 gfs2_quota_unhold(ip); 391 out: 392 gfs2_alloc_put(ip); 393 return error; 394 } 395 396 /** 397 * gfs2_change_nlink - Change nlink count on inode 398 * @ip: The GFS2 inode 399 * @diff: The change in the nlink count required 400 * 401 * Returns: errno 402 */ 403 int gfs2_change_nlink(struct gfs2_inode *ip, int diff) 404 { 405 struct buffer_head *dibh; 406 u32 nlink; 407 int error; 408 409 BUG_ON(diff != 1 && diff != -1); 410 nlink = ip->i_inode.i_nlink + diff; 411 412 /* If we are reducing the nlink count, but the new value ends up being 413 bigger than the old one, we must have underflowed. */ 414 if (diff < 0 && nlink > ip->i_inode.i_nlink) { 415 if (gfs2_consist_inode(ip)) 416 gfs2_dinode_print(ip); 417 return -EIO; 418 } 419 420 error = gfs2_meta_inode_buffer(ip, &dibh); 421 if (error) 422 return error; 423 424 if (diff > 0) 425 inc_nlink(&ip->i_inode); 426 else 427 drop_nlink(&ip->i_inode); 428 429 ip->i_inode.i_ctime = CURRENT_TIME; 430 431 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 432 gfs2_dinode_out(ip, dibh->b_data); 433 brelse(dibh); 434 mark_inode_dirty(&ip->i_inode); 435 436 if (ip->i_inode.i_nlink == 0) 437 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */ 438 439 return error; 440 } 441 442 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name) 443 { 444 struct qstr qstr; 445 struct inode *inode; 446 gfs2_str2qstr(&qstr, name); 447 inode = gfs2_lookupi(dip, &qstr, 1, NULL); 448 /* gfs2_lookupi has inconsistent callers: vfs 449 * related routines expect NULL for no entry found, 450 * gfs2_lookup_simple callers expect ENOENT 451 * and do not check for NULL. 452 */ 453 if (inode == NULL) 454 return ERR_PTR(-ENOENT); 455 else 456 return inode; 457 } 458 459 460 /** 461 * gfs2_lookupi - Look up a filename in a directory and return its inode 462 * @d_gh: An initialized holder for the directory glock 463 * @name: The name of the inode to look for 464 * @is_root: If 1, ignore the caller's permissions 465 * @i_gh: An uninitialized holder for the new inode glock 466 * 467 * This can be called via the VFS filldir function when NFS is doing 468 * a readdirplus and the inode which its intending to stat isn't 469 * already in cache. In this case we must not take the directory glock 470 * again, since the readdir call will have already taken that lock. 471 * 472 * Returns: errno 473 */ 474 475 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name, 476 int is_root, struct nameidata *nd) 477 { 478 struct super_block *sb = dir->i_sb; 479 struct gfs2_inode *dip = GFS2_I(dir); 480 struct gfs2_holder d_gh; 481 int error = 0; 482 struct inode *inode = NULL; 483 int unlock = 0; 484 485 if (!name->len || name->len > GFS2_FNAMESIZE) 486 return ERR_PTR(-ENAMETOOLONG); 487 488 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) || 489 (name->len == 2 && memcmp(name->name, "..", 2) == 0 && 490 dir == sb->s_root->d_inode)) { 491 igrab(dir); 492 return dir; 493 } 494 495 if (gfs2_glock_is_locked_by_me(dip->i_gl) == 0) { 496 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); 497 if (error) 498 return ERR_PTR(error); 499 unlock = 1; 500 } 501 502 if (!is_root) { 503 error = permission(dir, MAY_EXEC, NULL); 504 if (error) 505 goto out; 506 } 507 508 inode = gfs2_dir_search(dir, name); 509 if (IS_ERR(inode)) 510 error = PTR_ERR(inode); 511 out: 512 if (unlock) 513 gfs2_glock_dq_uninit(&d_gh); 514 if (error == -ENOENT) 515 return NULL; 516 return inode ? inode : ERR_PTR(error); 517 } 518 519 static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf) 520 { 521 const struct gfs2_inum_range *str = buf; 522 523 ir->ir_start = be64_to_cpu(str->ir_start); 524 ir->ir_length = be64_to_cpu(str->ir_length); 525 } 526 527 static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf) 528 { 529 struct gfs2_inum_range *str = buf; 530 531 str->ir_start = cpu_to_be64(ir->ir_start); 532 str->ir_length = cpu_to_be64(ir->ir_length); 533 } 534 535 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino) 536 { 537 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 538 struct buffer_head *bh; 539 struct gfs2_inum_range_host ir; 540 int error; 541 542 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 543 if (error) 544 return error; 545 mutex_lock(&sdp->sd_inum_mutex); 546 547 error = gfs2_meta_inode_buffer(ip, &bh); 548 if (error) { 549 mutex_unlock(&sdp->sd_inum_mutex); 550 gfs2_trans_end(sdp); 551 return error; 552 } 553 554 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 555 556 if (ir.ir_length) { 557 *formal_ino = ir.ir_start++; 558 ir.ir_length--; 559 gfs2_trans_add_bh(ip->i_gl, bh, 1); 560 gfs2_inum_range_out(&ir, 561 bh->b_data + sizeof(struct gfs2_dinode)); 562 brelse(bh); 563 mutex_unlock(&sdp->sd_inum_mutex); 564 gfs2_trans_end(sdp); 565 return 0; 566 } 567 568 brelse(bh); 569 570 mutex_unlock(&sdp->sd_inum_mutex); 571 gfs2_trans_end(sdp); 572 573 return 1; 574 } 575 576 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino) 577 { 578 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 579 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode); 580 struct gfs2_holder gh; 581 struct buffer_head *bh; 582 struct gfs2_inum_range_host ir; 583 int error; 584 585 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 586 if (error) 587 return error; 588 589 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 590 if (error) 591 goto out; 592 mutex_lock(&sdp->sd_inum_mutex); 593 594 error = gfs2_meta_inode_buffer(ip, &bh); 595 if (error) 596 goto out_end_trans; 597 598 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 599 600 if (!ir.ir_length) { 601 struct buffer_head *m_bh; 602 u64 x, y; 603 __be64 z; 604 605 error = gfs2_meta_inode_buffer(m_ip, &m_bh); 606 if (error) 607 goto out_brelse; 608 609 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)); 610 x = y = be64_to_cpu(z); 611 ir.ir_start = x; 612 ir.ir_length = GFS2_INUM_QUANTUM; 613 x += GFS2_INUM_QUANTUM; 614 if (x < y) 615 gfs2_consist_inode(m_ip); 616 z = cpu_to_be64(x); 617 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1); 618 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z; 619 620 brelse(m_bh); 621 } 622 623 *formal_ino = ir.ir_start++; 624 ir.ir_length--; 625 626 gfs2_trans_add_bh(ip->i_gl, bh, 1); 627 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode)); 628 629 out_brelse: 630 brelse(bh); 631 out_end_trans: 632 mutex_unlock(&sdp->sd_inum_mutex); 633 gfs2_trans_end(sdp); 634 out: 635 gfs2_glock_dq_uninit(&gh); 636 return error; 637 } 638 639 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum) 640 { 641 int error; 642 643 error = pick_formal_ino_1(sdp, inum); 644 if (error <= 0) 645 return error; 646 647 error = pick_formal_ino_2(sdp, inum); 648 649 return error; 650 } 651 652 /** 653 * create_ok - OK to create a new on-disk inode here? 654 * @dip: Directory in which dinode is to be created 655 * @name: Name of new dinode 656 * @mode: 657 * 658 * Returns: errno 659 */ 660 661 static int create_ok(struct gfs2_inode *dip, const struct qstr *name, 662 unsigned int mode) 663 { 664 int error; 665 666 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 667 if (error) 668 return error; 669 670 /* Don't create entries in an unlinked directory */ 671 if (!dip->i_inode.i_nlink) 672 return -EPERM; 673 674 error = gfs2_dir_check(&dip->i_inode, name, NULL); 675 switch (error) { 676 case -ENOENT: 677 error = 0; 678 break; 679 case 0: 680 return -EEXIST; 681 default: 682 return error; 683 } 684 685 if (dip->i_di.di_entries == (u32)-1) 686 return -EFBIG; 687 if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1) 688 return -EMLINK; 689 690 return 0; 691 } 692 693 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode, 694 unsigned int *uid, unsigned int *gid) 695 { 696 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir && 697 (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) { 698 if (S_ISDIR(*mode)) 699 *mode |= S_ISUID; 700 else if (dip->i_inode.i_uid != current->fsuid) 701 *mode &= ~07111; 702 *uid = dip->i_inode.i_uid; 703 } else 704 *uid = current->fsuid; 705 706 if (dip->i_inode.i_mode & S_ISGID) { 707 if (S_ISDIR(*mode)) 708 *mode |= S_ISGID; 709 *gid = dip->i_inode.i_gid; 710 } else 711 *gid = current->fsgid; 712 } 713 714 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation) 715 { 716 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 717 int error; 718 719 if (gfs2_alloc_get(dip) == NULL) 720 return -ENOMEM; 721 722 dip->i_alloc->al_requested = RES_DINODE; 723 error = gfs2_inplace_reserve(dip); 724 if (error) 725 goto out; 726 727 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0); 728 if (error) 729 goto out_ipreserv; 730 731 *no_addr = gfs2_alloc_di(dip, generation); 732 733 gfs2_trans_end(sdp); 734 735 out_ipreserv: 736 gfs2_inplace_release(dip); 737 out: 738 gfs2_alloc_put(dip); 739 return error; 740 } 741 742 /** 743 * init_dinode - Fill in a new dinode structure 744 * @dip: the directory this inode is being created in 745 * @gl: The glock covering the new inode 746 * @inum: the inode number 747 * @mode: the file permissions 748 * @uid: 749 * @gid: 750 * 751 */ 752 753 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 754 const struct gfs2_inum_host *inum, unsigned int mode, 755 unsigned int uid, unsigned int gid, 756 const u64 *generation, dev_t dev, struct buffer_head **bhp) 757 { 758 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 759 struct gfs2_dinode *di; 760 struct buffer_head *dibh; 761 struct timespec tv = CURRENT_TIME; 762 763 dibh = gfs2_meta_new(gl, inum->no_addr); 764 gfs2_trans_add_bh(gl, dibh, 1); 765 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI); 766 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 767 di = (struct gfs2_dinode *)dibh->b_data; 768 769 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino); 770 di->di_num.no_addr = cpu_to_be64(inum->no_addr); 771 di->di_mode = cpu_to_be32(mode); 772 di->di_uid = cpu_to_be32(uid); 773 di->di_gid = cpu_to_be32(gid); 774 di->di_nlink = 0; 775 di->di_size = 0; 776 di->di_blocks = cpu_to_be64(1); 777 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec); 778 di->di_major = cpu_to_be32(MAJOR(dev)); 779 di->di_minor = cpu_to_be32(MINOR(dev)); 780 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr); 781 di->di_generation = cpu_to_be64(*generation); 782 di->di_flags = 0; 783 784 if (S_ISREG(mode)) { 785 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) || 786 gfs2_tune_get(sdp, gt_new_files_jdata)) 787 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA); 788 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) || 789 gfs2_tune_get(sdp, gt_new_files_directio)) 790 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO); 791 } else if (S_ISDIR(mode)) { 792 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 793 GFS2_DIF_INHERIT_DIRECTIO); 794 di->di_flags |= cpu_to_be32(dip->i_di.di_flags & 795 GFS2_DIF_INHERIT_JDATA); 796 } 797 798 di->__pad1 = 0; 799 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0); 800 di->di_height = 0; 801 di->__pad2 = 0; 802 di->__pad3 = 0; 803 di->di_depth = 0; 804 di->di_entries = 0; 805 memset(&di->__pad4, 0, sizeof(di->__pad4)); 806 di->di_eattr = 0; 807 di->di_atime_nsec = cpu_to_be32(tv.tv_nsec); 808 di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec); 809 di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec); 810 memset(&di->di_reserved, 0, sizeof(di->di_reserved)); 811 812 set_buffer_uptodate(dibh); 813 814 *bhp = dibh; 815 } 816 817 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl, 818 unsigned int mode, const struct gfs2_inum_host *inum, 819 const u64 *generation, dev_t dev, struct buffer_head **bhp) 820 { 821 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 822 unsigned int uid, gid; 823 int error; 824 825 munge_mode_uid_gid(dip, &mode, &uid, &gid); 826 gfs2_alloc_get(dip); 827 828 error = gfs2_quota_lock(dip, uid, gid); 829 if (error) 830 goto out; 831 832 error = gfs2_quota_check(dip, uid, gid); 833 if (error) 834 goto out_quota; 835 836 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0); 837 if (error) 838 goto out_quota; 839 840 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp); 841 gfs2_quota_change(dip, +1, uid, gid); 842 gfs2_trans_end(sdp); 843 844 out_quota: 845 gfs2_quota_unlock(dip); 846 out: 847 gfs2_alloc_put(dip); 848 return error; 849 } 850 851 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name, 852 struct gfs2_inode *ip) 853 { 854 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 855 struct gfs2_alloc *al; 856 int alloc_required; 857 struct buffer_head *dibh; 858 int error; 859 860 al = gfs2_alloc_get(dip); 861 862 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 863 if (error) 864 goto fail; 865 866 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name); 867 if (alloc_required < 0) 868 goto fail_quota_locks; 869 if (alloc_required) { 870 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid); 871 if (error) 872 goto fail_quota_locks; 873 874 al->al_requested = sdp->sd_max_dirres; 875 876 error = gfs2_inplace_reserve(dip); 877 if (error) 878 goto fail_quota_locks; 879 880 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 881 al->al_rgd->rd_length + 882 2 * RES_DINODE + 883 RES_STATFS + RES_QUOTA, 0); 884 if (error) 885 goto fail_ipreserv; 886 } else { 887 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0); 888 if (error) 889 goto fail_quota_locks; 890 } 891 892 error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode)); 893 if (error) 894 goto fail_end_trans; 895 896 error = gfs2_meta_inode_buffer(ip, &dibh); 897 if (error) 898 goto fail_end_trans; 899 ip->i_inode.i_nlink = 1; 900 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 901 gfs2_dinode_out(ip, dibh->b_data); 902 brelse(dibh); 903 return 0; 904 905 fail_end_trans: 906 gfs2_trans_end(sdp); 907 908 fail_ipreserv: 909 if (dip->i_alloc->al_rgd) 910 gfs2_inplace_release(dip); 911 912 fail_quota_locks: 913 gfs2_quota_unlock(dip); 914 915 fail: 916 gfs2_alloc_put(dip); 917 return error; 918 } 919 920 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip) 921 { 922 int err; 923 size_t len; 924 void *value; 925 char *name; 926 struct gfs2_ea_request er; 927 928 err = security_inode_init_security(&ip->i_inode, &dip->i_inode, 929 &name, &value, &len); 930 931 if (err) { 932 if (err == -EOPNOTSUPP) 933 return 0; 934 return err; 935 } 936 937 memset(&er, 0, sizeof(struct gfs2_ea_request)); 938 939 er.er_type = GFS2_EATYPE_SECURITY; 940 er.er_name = name; 941 er.er_data = value; 942 er.er_name_len = strlen(name); 943 er.er_data_len = len; 944 945 err = gfs2_ea_set_i(ip, &er); 946 947 kfree(value); 948 kfree(name); 949 950 return err; 951 } 952 953 /** 954 * gfs2_createi - Create a new inode 955 * @ghs: An array of two holders 956 * @name: The name of the new file 957 * @mode: the permissions on the new inode 958 * 959 * @ghs[0] is an initialized holder for the directory 960 * @ghs[1] is the holder for the inode lock 961 * 962 * If the return value is not NULL, the glocks on both the directory and the new 963 * file are held. A transaction has been started and an inplace reservation 964 * is held, as well. 965 * 966 * Returns: An inode 967 */ 968 969 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name, 970 unsigned int mode, dev_t dev) 971 { 972 struct inode *inode = NULL; 973 struct gfs2_inode *dip = ghs->gh_gl->gl_object; 974 struct inode *dir = &dip->i_inode; 975 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 976 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 }; 977 int error; 978 u64 generation; 979 struct buffer_head *bh = NULL; 980 981 if (!name->len || name->len > GFS2_FNAMESIZE) 982 return ERR_PTR(-ENAMETOOLONG); 983 984 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs); 985 error = gfs2_glock_nq(ghs); 986 if (error) 987 goto fail; 988 989 error = create_ok(dip, name, mode); 990 if (error) 991 goto fail_gunlock; 992 993 error = pick_formal_ino(sdp, &inum.no_formal_ino); 994 if (error) 995 goto fail_gunlock; 996 997 error = alloc_dinode(dip, &inum.no_addr, &generation); 998 if (error) 999 goto fail_gunlock; 1000 1001 error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops, 1002 LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1); 1003 if (error) 1004 goto fail_gunlock; 1005 1006 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh); 1007 if (error) 1008 goto fail_gunlock2; 1009 1010 inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), 1011 inum.no_addr, 1012 inum.no_formal_ino, 0); 1013 if (IS_ERR(inode)) 1014 goto fail_gunlock2; 1015 1016 error = gfs2_inode_refresh(GFS2_I(inode)); 1017 if (error) 1018 goto fail_gunlock2; 1019 1020 error = gfs2_acl_create(dip, GFS2_I(inode)); 1021 if (error) 1022 goto fail_gunlock2; 1023 1024 error = gfs2_security_init(dip, GFS2_I(inode)); 1025 if (error) 1026 goto fail_gunlock2; 1027 1028 error = link_dinode(dip, name, GFS2_I(inode)); 1029 if (error) 1030 goto fail_gunlock2; 1031 1032 if (bh) 1033 brelse(bh); 1034 if (!inode) 1035 return ERR_PTR(-ENOMEM); 1036 return inode; 1037 1038 fail_gunlock2: 1039 gfs2_glock_dq_uninit(ghs + 1); 1040 if (inode) 1041 iput(inode); 1042 fail_gunlock: 1043 gfs2_glock_dq(ghs); 1044 fail: 1045 if (bh) 1046 brelse(bh); 1047 return ERR_PTR(error); 1048 } 1049 1050 /** 1051 * gfs2_rmdiri - Remove a directory 1052 * @dip: The parent directory of the directory to be removed 1053 * @name: The name of the directory to be removed 1054 * @ip: The GFS2 inode of the directory to be removed 1055 * 1056 * Assumes Glocks on dip and ip are held 1057 * 1058 * Returns: errno 1059 */ 1060 1061 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name, 1062 struct gfs2_inode *ip) 1063 { 1064 struct qstr dotname; 1065 int error; 1066 1067 if (ip->i_di.di_entries != 2) { 1068 if (gfs2_consist_inode(ip)) 1069 gfs2_dinode_print(ip); 1070 return -EIO; 1071 } 1072 1073 error = gfs2_dir_del(dip, name); 1074 if (error) 1075 return error; 1076 1077 error = gfs2_change_nlink(dip, -1); 1078 if (error) 1079 return error; 1080 1081 gfs2_str2qstr(&dotname, "."); 1082 error = gfs2_dir_del(ip, &dotname); 1083 if (error) 1084 return error; 1085 1086 gfs2_str2qstr(&dotname, ".."); 1087 error = gfs2_dir_del(ip, &dotname); 1088 if (error) 1089 return error; 1090 1091 /* It looks odd, but it really should be done twice */ 1092 error = gfs2_change_nlink(ip, -1); 1093 if (error) 1094 return error; 1095 1096 error = gfs2_change_nlink(ip, -1); 1097 if (error) 1098 return error; 1099 1100 return error; 1101 } 1102 1103 /* 1104 * gfs2_unlink_ok - check to see that a inode is still in a directory 1105 * @dip: the directory 1106 * @name: the name of the file 1107 * @ip: the inode 1108 * 1109 * Assumes that the lock on (at least) @dip is held. 1110 * 1111 * Returns: 0 if the parent/child relationship is correct, errno if it isn't 1112 */ 1113 1114 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name, 1115 const struct gfs2_inode *ip) 1116 { 1117 int error; 1118 1119 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode)) 1120 return -EPERM; 1121 1122 if ((dip->i_inode.i_mode & S_ISVTX) && 1123 dip->i_inode.i_uid != current->fsuid && 1124 ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER)) 1125 return -EPERM; 1126 1127 if (IS_APPEND(&dip->i_inode)) 1128 return -EPERM; 1129 1130 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL); 1131 if (error) 1132 return error; 1133 1134 error = gfs2_dir_check(&dip->i_inode, name, ip); 1135 if (error) 1136 return error; 1137 1138 return 0; 1139 } 1140 1141 /* 1142 * gfs2_ok_to_move - check if it's ok to move a directory to another directory 1143 * @this: move this 1144 * @to: to here 1145 * 1146 * Follow @to back to the root and make sure we don't encounter @this 1147 * Assumes we already hold the rename lock. 1148 * 1149 * Returns: errno 1150 */ 1151 1152 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to) 1153 { 1154 struct inode *dir = &to->i_inode; 1155 struct super_block *sb = dir->i_sb; 1156 struct inode *tmp; 1157 struct qstr dotdot; 1158 int error = 0; 1159 1160 gfs2_str2qstr(&dotdot, ".."); 1161 1162 igrab(dir); 1163 1164 for (;;) { 1165 if (dir == &this->i_inode) { 1166 error = -EINVAL; 1167 break; 1168 } 1169 if (dir == sb->s_root->d_inode) { 1170 error = 0; 1171 break; 1172 } 1173 1174 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL); 1175 if (IS_ERR(tmp)) { 1176 error = PTR_ERR(tmp); 1177 break; 1178 } 1179 1180 iput(dir); 1181 dir = tmp; 1182 } 1183 1184 iput(dir); 1185 1186 return error; 1187 } 1188 1189 /** 1190 * gfs2_readlinki - return the contents of a symlink 1191 * @ip: the symlink's inode 1192 * @buf: a pointer to the buffer to be filled 1193 * @len: a pointer to the length of @buf 1194 * 1195 * If @buf is too small, a piece of memory is kmalloc()ed and needs 1196 * to be freed by the caller. 1197 * 1198 * Returns: errno 1199 */ 1200 1201 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len) 1202 { 1203 struct gfs2_holder i_gh; 1204 struct buffer_head *dibh; 1205 unsigned int x; 1206 int error; 1207 1208 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh); 1209 error = gfs2_glock_nq_atime(&i_gh); 1210 if (error) { 1211 gfs2_holder_uninit(&i_gh); 1212 return error; 1213 } 1214 1215 if (!ip->i_di.di_size) { 1216 gfs2_consist_inode(ip); 1217 error = -EIO; 1218 goto out; 1219 } 1220 1221 error = gfs2_meta_inode_buffer(ip, &dibh); 1222 if (error) 1223 goto out; 1224 1225 x = ip->i_di.di_size + 1; 1226 if (x > *len) { 1227 *buf = kmalloc(x, GFP_KERNEL); 1228 if (!*buf) { 1229 error = -ENOMEM; 1230 goto out_brelse; 1231 } 1232 } 1233 1234 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x); 1235 *len = x; 1236 1237 out_brelse: 1238 brelse(dibh); 1239 out: 1240 gfs2_glock_dq_uninit(&i_gh); 1241 return error; 1242 } 1243 1244 /** 1245 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and 1246 * conditionally update the inode's atime 1247 * @gh: the holder to acquire 1248 * 1249 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap 1250 * Update if the difference between the current time and the inode's current 1251 * atime is greater than an interval specified at mount. 1252 * 1253 * Returns: errno 1254 */ 1255 1256 int gfs2_glock_nq_atime(struct gfs2_holder *gh) 1257 { 1258 struct gfs2_glock *gl = gh->gh_gl; 1259 struct gfs2_sbd *sdp = gl->gl_sbd; 1260 struct gfs2_inode *ip = gl->gl_object; 1261 s64 quantum = gfs2_tune_get(sdp, gt_atime_quantum); 1262 unsigned int state; 1263 int flags; 1264 int error; 1265 struct timespec tv = CURRENT_TIME; 1266 1267 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) || 1268 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) || 1269 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops)) 1270 return -EINVAL; 1271 1272 state = gh->gh_state; 1273 flags = gh->gh_flags; 1274 1275 error = gfs2_glock_nq(gh); 1276 if (error) 1277 return error; 1278 1279 if (test_bit(SDF_NOATIME, &sdp->sd_flags) || 1280 (sdp->sd_vfs->s_flags & MS_RDONLY)) 1281 return 0; 1282 1283 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) { 1284 gfs2_glock_dq(gh); 1285 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY, 1286 gh); 1287 error = gfs2_glock_nq(gh); 1288 if (error) 1289 return error; 1290 1291 /* Verify that atime hasn't been updated while we were 1292 trying to get exclusive lock. */ 1293 1294 tv = CURRENT_TIME; 1295 if (tv.tv_sec - ip->i_inode.i_atime.tv_sec >= quantum) { 1296 struct buffer_head *dibh; 1297 struct gfs2_dinode *di; 1298 1299 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1300 if (error == -EROFS) 1301 return 0; 1302 if (error) 1303 goto fail; 1304 1305 error = gfs2_meta_inode_buffer(ip, &dibh); 1306 if (error) 1307 goto fail_end_trans; 1308 1309 ip->i_inode.i_atime = tv; 1310 1311 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1312 di = (struct gfs2_dinode *)dibh->b_data; 1313 di->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 1314 di->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 1315 brelse(dibh); 1316 1317 gfs2_trans_end(sdp); 1318 } 1319 1320 /* If someone else has asked for the glock, 1321 unlock and let them have it. Then reacquire 1322 in the original state. */ 1323 if (gfs2_glock_is_blocking(gl)) { 1324 gfs2_glock_dq(gh); 1325 gfs2_holder_reinit(state, flags, gh); 1326 return gfs2_glock_nq(gh); 1327 } 1328 } 1329 1330 return 0; 1331 1332 fail_end_trans: 1333 gfs2_trans_end(sdp); 1334 fail: 1335 gfs2_glock_dq(gh); 1336 return error; 1337 } 1338 1339 static int 1340 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1341 { 1342 struct buffer_head *dibh; 1343 int error; 1344 1345 error = gfs2_meta_inode_buffer(ip, &dibh); 1346 if (!error) { 1347 error = inode_setattr(&ip->i_inode, attr); 1348 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); 1349 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1350 gfs2_dinode_out(ip, dibh->b_data); 1351 brelse(dibh); 1352 } 1353 return error; 1354 } 1355 1356 /** 1357 * gfs2_setattr_simple - 1358 * @ip: 1359 * @attr: 1360 * 1361 * Called with a reference on the vnode. 1362 * 1363 * Returns: errno 1364 */ 1365 1366 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr) 1367 { 1368 int error; 1369 1370 if (current->journal_info) 1371 return __gfs2_setattr_simple(ip, attr); 1372 1373 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0); 1374 if (error) 1375 return error; 1376 1377 error = __gfs2_setattr_simple(ip, attr); 1378 gfs2_trans_end(GFS2_SB(&ip->i_inode)); 1379 return error; 1380 } 1381 1382 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 1383 { 1384 const struct gfs2_dinode_host *di = &ip->i_di; 1385 struct gfs2_dinode *str = buf; 1386 1387 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 1388 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 1389 str->di_header.__pad0 = 0; 1390 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 1391 str->di_header.__pad1 = 0; 1392 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 1393 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 1394 str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 1395 str->di_uid = cpu_to_be32(ip->i_inode.i_uid); 1396 str->di_gid = cpu_to_be32(ip->i_inode.i_gid); 1397 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 1398 str->di_size = cpu_to_be64(di->di_size); 1399 str->di_blocks = cpu_to_be64(di->di_blocks); 1400 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 1401 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec); 1402 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec); 1403 1404 str->di_goal_meta = cpu_to_be64(di->di_goal_meta); 1405 str->di_goal_data = cpu_to_be64(di->di_goal_data); 1406 str->di_generation = cpu_to_be64(di->di_generation); 1407 1408 str->di_flags = cpu_to_be32(di->di_flags); 1409 str->di_height = cpu_to_be16(ip->i_height); 1410 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && 1411 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ? 1412 GFS2_FORMAT_DE : 0); 1413 str->di_depth = cpu_to_be16(di->di_depth); 1414 str->di_entries = cpu_to_be32(di->di_entries); 1415 1416 str->di_eattr = cpu_to_be64(di->di_eattr); 1417 str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 1418 str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); 1419 str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); 1420 } 1421 1422 void gfs2_dinode_print(const struct gfs2_inode *ip) 1423 { 1424 const struct gfs2_dinode_host *di = &ip->i_di; 1425 1426 printk(KERN_INFO " no_formal_ino = %llu\n", 1427 (unsigned long long)ip->i_no_formal_ino); 1428 printk(KERN_INFO " no_addr = %llu\n", 1429 (unsigned long long)ip->i_no_addr); 1430 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size); 1431 printk(KERN_INFO " di_blocks = %llu\n", 1432 (unsigned long long)di->di_blocks); 1433 printk(KERN_INFO " di_goal_meta = %llu\n", 1434 (unsigned long long)di->di_goal_meta); 1435 printk(KERN_INFO " di_goal_data = %llu\n", 1436 (unsigned long long)di->di_goal_data); 1437 printk(KERN_INFO " di_flags = 0x%.8X\n", di->di_flags); 1438 printk(KERN_INFO " i_height = %u\n", ip->i_height); 1439 printk(KERN_INFO " di_depth = %u\n", di->di_depth); 1440 printk(KERN_INFO " di_entries = %u\n", di->di_entries); 1441 printk(KERN_INFO " di_eattr = %llu\n", 1442 (unsigned long long)di->di_eattr); 1443 } 1444 1445