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