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