1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * inode.c 4 * 5 * vfs' aops, fops, dops and iops 6 * 7 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 8 */ 9 10#include <linux/fs.h> 11#include <linux/types.h> 12#include <linux/highmem.h> 13#include <linux/pagemap.h> 14#include <linux/quotaops.h> 15#include <linux/iversion.h> 16 17#include <asm/byteorder.h> 18 19#include <cluster/masklog.h> 20 21#include "ocfs2.h" 22 23#include "alloc.h" 24#include "dir.h" 25#include "blockcheck.h" 26#include "dlmglue.h" 27#include "extent_map.h" 28#include "file.h" 29#include "heartbeat.h" 30#include "inode.h" 31#include "journal.h" 32#include "namei.h" 33#include "suballoc.h" 34#include "super.h" 35#include "symlink.h" 36#include "sysfile.h" 37#include "uptodate.h" 38#include "xattr.h" 39#include "refcounttree.h" 40#include "ocfs2_trace.h" 41#include "filecheck.h" 42 43#include "buffer_head_io.h" 44 45struct ocfs2_find_inode_args 46{ 47 u64 fi_blkno; 48 unsigned long fi_ino; 49 unsigned int fi_flags; 50 unsigned int fi_sysfile_type; 51}; 52 53static struct lock_class_key ocfs2_sysfile_lock_key[NUM_SYSTEM_INODES]; 54 55static int ocfs2_read_locked_inode(struct inode *inode, 56 struct ocfs2_find_inode_args *args); 57static int ocfs2_init_locked_inode(struct inode *inode, void *opaque); 58static int ocfs2_find_actor(struct inode *inode, void *opaque); 59static int ocfs2_truncate_for_delete(struct ocfs2_super *osb, 60 struct inode *inode, 61 struct buffer_head *fe_bh); 62 63static int ocfs2_filecheck_read_inode_block_full(struct inode *inode, 64 struct buffer_head **bh, 65 int flags, int type); 66static int ocfs2_filecheck_validate_inode_block(struct super_block *sb, 67 struct buffer_head *bh); 68static int ocfs2_filecheck_repair_inode_block(struct super_block *sb, 69 struct buffer_head *bh); 70 71void ocfs2_set_inode_flags(struct inode *inode) 72{ 73 unsigned int flags = OCFS2_I(inode)->ip_attr; 74 75 inode->i_flags &= ~(S_IMMUTABLE | 76 S_SYNC | S_APPEND | S_NOATIME | S_DIRSYNC); 77 78 if (flags & OCFS2_IMMUTABLE_FL) 79 inode->i_flags |= S_IMMUTABLE; 80 81 if (flags & OCFS2_SYNC_FL) 82 inode->i_flags |= S_SYNC; 83 if (flags & OCFS2_APPEND_FL) 84 inode->i_flags |= S_APPEND; 85 if (flags & OCFS2_NOATIME_FL) 86 inode->i_flags |= S_NOATIME; 87 if (flags & OCFS2_DIRSYNC_FL) 88 inode->i_flags |= S_DIRSYNC; 89} 90 91/* Propagate flags from i_flags to OCFS2_I(inode)->ip_attr */ 92void ocfs2_get_inode_flags(struct ocfs2_inode_info *oi) 93{ 94 unsigned int flags = oi->vfs_inode.i_flags; 95 96 oi->ip_attr &= ~(OCFS2_SYNC_FL|OCFS2_APPEND_FL| 97 OCFS2_IMMUTABLE_FL|OCFS2_NOATIME_FL|OCFS2_DIRSYNC_FL); 98 if (flags & S_SYNC) 99 oi->ip_attr |= OCFS2_SYNC_FL; 100 if (flags & S_APPEND) 101 oi->ip_attr |= OCFS2_APPEND_FL; 102 if (flags & S_IMMUTABLE) 103 oi->ip_attr |= OCFS2_IMMUTABLE_FL; 104 if (flags & S_NOATIME) 105 oi->ip_attr |= OCFS2_NOATIME_FL; 106 if (flags & S_DIRSYNC) 107 oi->ip_attr |= OCFS2_DIRSYNC_FL; 108} 109 110struct inode *ocfs2_ilookup(struct super_block *sb, u64 blkno) 111{ 112 struct ocfs2_find_inode_args args; 113 114 args.fi_blkno = blkno; 115 args.fi_flags = 0; 116 args.fi_ino = ino_from_blkno(sb, blkno); 117 args.fi_sysfile_type = 0; 118 119 return ilookup5(sb, blkno, ocfs2_find_actor, &args); 120} 121struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags, 122 int sysfile_type) 123{ 124 int rc = -ESTALE; 125 struct inode *inode = NULL; 126 struct super_block *sb = osb->sb; 127 struct ocfs2_find_inode_args args; 128 journal_t *journal = osb->journal->j_journal; 129 130 trace_ocfs2_iget_begin((unsigned long long)blkno, flags, 131 sysfile_type); 132 133 /* Ok. By now we've either got the offsets passed to us by the 134 * caller, or we just pulled them off the bh. Lets do some 135 * sanity checks to make sure they're OK. */ 136 if (blkno == 0) { 137 inode = ERR_PTR(-EINVAL); 138 mlog_errno(PTR_ERR(inode)); 139 goto bail; 140 } 141 142 args.fi_blkno = blkno; 143 args.fi_flags = flags; 144 args.fi_ino = ino_from_blkno(sb, blkno); 145 args.fi_sysfile_type = sysfile_type; 146 147 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor, 148 ocfs2_init_locked_inode, &args); 149 /* inode was *not* in the inode cache. 2.6.x requires 150 * us to do our own read_inode call and unlock it 151 * afterwards. */ 152 if (inode == NULL) { 153 inode = ERR_PTR(-ENOMEM); 154 mlog_errno(PTR_ERR(inode)); 155 goto bail; 156 } 157 trace_ocfs2_iget5_locked(inode->i_state); 158 if (inode->i_state & I_NEW) { 159 rc = ocfs2_read_locked_inode(inode, &args); 160 unlock_new_inode(inode); 161 } 162 if (is_bad_inode(inode)) { 163 iput(inode); 164 inode = ERR_PTR(rc); 165 goto bail; 166 } 167 168 /* 169 * Set transaction id's of transactions that have to be committed 170 * to finish f[data]sync. We set them to currently running transaction 171 * as we cannot be sure that the inode or some of its metadata isn't 172 * part of the transaction - the inode could have been reclaimed and 173 * now it is reread from disk. 174 */ 175 if (journal) { 176 transaction_t *transaction; 177 tid_t tid; 178 struct ocfs2_inode_info *oi = OCFS2_I(inode); 179 180 read_lock(&journal->j_state_lock); 181 if (journal->j_running_transaction) 182 transaction = journal->j_running_transaction; 183 else 184 transaction = journal->j_committing_transaction; 185 if (transaction) 186 tid = transaction->t_tid; 187 else 188 tid = journal->j_commit_sequence; 189 read_unlock(&journal->j_state_lock); 190 oi->i_sync_tid = tid; 191 oi->i_datasync_tid = tid; 192 } 193 194bail: 195 if (!IS_ERR(inode)) { 196 trace_ocfs2_iget_end(inode, 197 (unsigned long long)OCFS2_I(inode)->ip_blkno); 198 } 199 200 return inode; 201} 202 203 204/* 205 * here's how inodes get read from disk: 206 * iget5_locked -> find_actor -> OCFS2_FIND_ACTOR 207 * found? : return the in-memory inode 208 * not found? : get_new_inode -> OCFS2_INIT_LOCKED_INODE 209 */ 210 211static int ocfs2_find_actor(struct inode *inode, void *opaque) 212{ 213 struct ocfs2_find_inode_args *args = NULL; 214 struct ocfs2_inode_info *oi = OCFS2_I(inode); 215 int ret = 0; 216 217 args = opaque; 218 219 mlog_bug_on_msg(!inode, "No inode in find actor!\n"); 220 221 trace_ocfs2_find_actor(inode, inode->i_ino, opaque, args->fi_blkno); 222 223 if (oi->ip_blkno != args->fi_blkno) 224 goto bail; 225 226 ret = 1; 227bail: 228 return ret; 229} 230 231/* 232 * initialize the new inode, but don't do anything that would cause 233 * us to sleep. 234 * return 0 on success, 1 on failure 235 */ 236static int ocfs2_init_locked_inode(struct inode *inode, void *opaque) 237{ 238 struct ocfs2_find_inode_args *args = opaque; 239 static struct lock_class_key ocfs2_quota_ip_alloc_sem_key, 240 ocfs2_file_ip_alloc_sem_key; 241 242 inode->i_ino = args->fi_ino; 243 OCFS2_I(inode)->ip_blkno = args->fi_blkno; 244 if (args->fi_sysfile_type != 0) 245 lockdep_set_class(&inode->i_rwsem, 246 &ocfs2_sysfile_lock_key[args->fi_sysfile_type]); 247 if (args->fi_sysfile_type == USER_QUOTA_SYSTEM_INODE || 248 args->fi_sysfile_type == GROUP_QUOTA_SYSTEM_INODE || 249 args->fi_sysfile_type == LOCAL_USER_QUOTA_SYSTEM_INODE || 250 args->fi_sysfile_type == LOCAL_GROUP_QUOTA_SYSTEM_INODE) 251 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem, 252 &ocfs2_quota_ip_alloc_sem_key); 253 else 254 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem, 255 &ocfs2_file_ip_alloc_sem_key); 256 257 return 0; 258} 259 260void ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe, 261 int create_ino) 262{ 263 struct super_block *sb; 264 struct ocfs2_super *osb; 265 int use_plocks = 1; 266 267 sb = inode->i_sb; 268 osb = OCFS2_SB(sb); 269 270 if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) || 271 ocfs2_mount_local(osb) || !ocfs2_stack_supports_plocks()) 272 use_plocks = 0; 273 274 /* 275 * These have all been checked by ocfs2_read_inode_block() or set 276 * by ocfs2_mknod_locked(), so a failure is a code bug. 277 */ 278 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); /* This means that read_inode 279 cannot create a superblock 280 inode today. change if 281 that is needed. */ 282 BUG_ON(!(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))); 283 BUG_ON(le32_to_cpu(fe->i_fs_generation) != osb->fs_generation); 284 285 286 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 287 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr); 288 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features); 289 290 inode_set_iversion(inode, 1); 291 inode->i_generation = le32_to_cpu(fe->i_generation); 292 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev)); 293 inode->i_mode = le16_to_cpu(fe->i_mode); 294 i_uid_write(inode, le32_to_cpu(fe->i_uid)); 295 i_gid_write(inode, le32_to_cpu(fe->i_gid)); 296 297 /* Fast symlinks will have i_size but no allocated clusters. */ 298 if (S_ISLNK(inode->i_mode) && !fe->i_clusters) { 299 inode->i_blocks = 0; 300 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops; 301 } else { 302 inode->i_blocks = ocfs2_inode_sector_count(inode); 303 inode->i_mapping->a_ops = &ocfs2_aops; 304 } 305 inode_set_atime(inode, le64_to_cpu(fe->i_atime), 306 le32_to_cpu(fe->i_atime_nsec)); 307 inode_set_mtime(inode, le64_to_cpu(fe->i_mtime), 308 le32_to_cpu(fe->i_mtime_nsec)); 309 inode_set_ctime(inode, le64_to_cpu(fe->i_ctime), 310 le32_to_cpu(fe->i_ctime_nsec)); 311 312 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno)) 313 mlog(ML_ERROR, 314 "ip_blkno %llu != i_blkno %llu!\n", 315 (unsigned long long)OCFS2_I(inode)->ip_blkno, 316 (unsigned long long)le64_to_cpu(fe->i_blkno)); 317 318 set_nlink(inode, ocfs2_read_links_count(fe)); 319 320 trace_ocfs2_populate_inode(OCFS2_I(inode)->ip_blkno, 321 le32_to_cpu(fe->i_flags)); 322 if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) { 323 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE; 324 inode->i_flags |= S_NOQUOTA; 325 } 326 327 if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) { 328 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP; 329 } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) { 330 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP; 331 } else if (fe->i_flags & cpu_to_le32(OCFS2_QUOTA_FL)) { 332 inode->i_flags |= S_NOQUOTA; 333 } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) { 334 /* we can't actually hit this as read_inode can't 335 * handle superblocks today ;-) */ 336 BUG(); 337 } 338 339 switch (inode->i_mode & S_IFMT) { 340 case S_IFREG: 341 if (use_plocks) 342 inode->i_fop = &ocfs2_fops; 343 else 344 inode->i_fop = &ocfs2_fops_no_plocks; 345 inode->i_op = &ocfs2_file_iops; 346 i_size_write(inode, le64_to_cpu(fe->i_size)); 347 break; 348 case S_IFDIR: 349 inode->i_op = &ocfs2_dir_iops; 350 if (use_plocks) 351 inode->i_fop = &ocfs2_dops; 352 else 353 inode->i_fop = &ocfs2_dops_no_plocks; 354 i_size_write(inode, le64_to_cpu(fe->i_size)); 355 OCFS2_I(inode)->ip_dir_lock_gen = 1; 356 break; 357 case S_IFLNK: 358 inode->i_op = &ocfs2_symlink_inode_operations; 359 inode_nohighmem(inode); 360 i_size_write(inode, le64_to_cpu(fe->i_size)); 361 break; 362 default: 363 inode->i_op = &ocfs2_special_file_iops; 364 init_special_inode(inode, inode->i_mode, 365 inode->i_rdev); 366 break; 367 } 368 369 if (create_ino) { 370 inode->i_ino = ino_from_blkno(inode->i_sb, 371 le64_to_cpu(fe->i_blkno)); 372 373 /* 374 * If we ever want to create system files from kernel, 375 * the generation argument to 376 * ocfs2_inode_lock_res_init() will have to change. 377 */ 378 BUG_ON(le32_to_cpu(fe->i_flags) & OCFS2_SYSTEM_FL); 379 380 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres, 381 OCFS2_LOCK_TYPE_META, 0, inode); 382 383 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres, 384 OCFS2_LOCK_TYPE_OPEN, 0, inode); 385 } 386 387 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres, 388 OCFS2_LOCK_TYPE_RW, inode->i_generation, 389 inode); 390 391 ocfs2_set_inode_flags(inode); 392 393 OCFS2_I(inode)->ip_last_used_slot = 0; 394 OCFS2_I(inode)->ip_last_used_group = 0; 395 396 if (S_ISDIR(inode->i_mode)) 397 ocfs2_resv_set_type(&OCFS2_I(inode)->ip_la_data_resv, 398 OCFS2_RESV_FLAG_DIR); 399} 400 401static int ocfs2_read_locked_inode(struct inode *inode, 402 struct ocfs2_find_inode_args *args) 403{ 404 struct super_block *sb; 405 struct ocfs2_super *osb; 406 struct ocfs2_dinode *fe; 407 struct buffer_head *bh = NULL; 408 int status, can_lock, lock_level = 0; 409 u32 generation = 0; 410 411 status = -EINVAL; 412 sb = inode->i_sb; 413 osb = OCFS2_SB(sb); 414 415 /* 416 * To improve performance of cold-cache inode stats, we take 417 * the cluster lock here if possible. 418 * 419 * Generally, OCFS2 never trusts the contents of an inode 420 * unless it's holding a cluster lock, so taking it here isn't 421 * a correctness issue as much as it is a performance 422 * improvement. 423 * 424 * There are three times when taking the lock is not a good idea: 425 * 426 * 1) During startup, before we have initialized the DLM. 427 * 428 * 2) If we are reading certain system files which never get 429 * cluster locks (local alloc, truncate log). 430 * 431 * 3) If the process doing the iget() is responsible for 432 * orphan dir recovery. We're holding the orphan dir lock and 433 * can get into a deadlock with another process on another 434 * node in ->delete_inode(). 435 * 436 * #1 and #2 can be simply solved by never taking the lock 437 * here for system files (which are the only type we read 438 * during mount). It's a heavier approach, but our main 439 * concern is user-accessible files anyway. 440 * 441 * #3 works itself out because we'll eventually take the 442 * cluster lock before trusting anything anyway. 443 */ 444 can_lock = !(args->fi_flags & OCFS2_FI_FLAG_SYSFILE) 445 && !(args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) 446 && !ocfs2_mount_local(osb); 447 448 trace_ocfs2_read_locked_inode( 449 (unsigned long long)OCFS2_I(inode)->ip_blkno, can_lock); 450 451 /* 452 * To maintain backwards compatibility with older versions of 453 * ocfs2-tools, we still store the generation value for system 454 * files. The only ones that actually matter to userspace are 455 * the journals, but it's easier and inexpensive to just flag 456 * all system files similarly. 457 */ 458 if (args->fi_flags & OCFS2_FI_FLAG_SYSFILE) 459 generation = osb->fs_generation; 460 461 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres, 462 OCFS2_LOCK_TYPE_META, 463 generation, inode); 464 465 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres, 466 OCFS2_LOCK_TYPE_OPEN, 467 0, inode); 468 469 if (can_lock) { 470 status = ocfs2_open_lock(inode); 471 if (status) { 472 make_bad_inode(inode); 473 mlog_errno(status); 474 return status; 475 } 476 status = ocfs2_inode_lock(inode, NULL, lock_level); 477 if (status) { 478 make_bad_inode(inode); 479 mlog_errno(status); 480 return status; 481 } 482 } 483 484 if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) { 485 status = ocfs2_try_open_lock(inode, 0); 486 if (status) { 487 make_bad_inode(inode); 488 return status; 489 } 490 } 491 492 if (can_lock) { 493 if (args->fi_flags & OCFS2_FI_FLAG_FILECHECK_CHK) 494 status = ocfs2_filecheck_read_inode_block_full(inode, 495 &bh, OCFS2_BH_IGNORE_CACHE, 0); 496 else if (args->fi_flags & OCFS2_FI_FLAG_FILECHECK_FIX) 497 status = ocfs2_filecheck_read_inode_block_full(inode, 498 &bh, OCFS2_BH_IGNORE_CACHE, 1); 499 else 500 status = ocfs2_read_inode_block_full(inode, 501 &bh, OCFS2_BH_IGNORE_CACHE); 502 } else { 503 status = ocfs2_read_blocks_sync(osb, args->fi_blkno, 1, &bh); 504 /* 505 * If buffer is in jbd, then its checksum may not have been 506 * computed as yet. 507 */ 508 if (!status && !buffer_jbd(bh)) { 509 if (args->fi_flags & OCFS2_FI_FLAG_FILECHECK_CHK) 510 status = ocfs2_filecheck_validate_inode_block( 511 osb->sb, bh); 512 else if (args->fi_flags & OCFS2_FI_FLAG_FILECHECK_FIX) 513 status = ocfs2_filecheck_repair_inode_block( 514 osb->sb, bh); 515 else 516 status = ocfs2_validate_inode_block( 517 osb->sb, bh); 518 } 519 } 520 if (status < 0) { 521 mlog_errno(status); 522 goto bail; 523 } 524 525 status = -EINVAL; 526 fe = (struct ocfs2_dinode *) bh->b_data; 527 528 /* 529 * This is a code bug. Right now the caller needs to 530 * understand whether it is asking for a system file inode or 531 * not so the proper lock names can be built. 532 */ 533 mlog_bug_on_msg(!!(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) != 534 !!(args->fi_flags & OCFS2_FI_FLAG_SYSFILE), 535 "Inode %llu: system file state is ambiguous\n", 536 (unsigned long long)args->fi_blkno); 537 538 if (S_ISCHR(le16_to_cpu(fe->i_mode)) || 539 S_ISBLK(le16_to_cpu(fe->i_mode))) 540 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev)); 541 542 ocfs2_populate_inode(inode, fe, 0); 543 544 BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno)); 545 546 if (buffer_dirty(bh) && !buffer_jbd(bh)) { 547 if (can_lock) { 548 ocfs2_inode_unlock(inode, lock_level); 549 lock_level = 1; 550 ocfs2_inode_lock(inode, NULL, lock_level); 551 } 552 status = ocfs2_write_block(osb, bh, INODE_CACHE(inode)); 553 if (status < 0) { 554 mlog_errno(status); 555 goto bail; 556 } 557 } 558 559 status = 0; 560 561bail: 562 if (can_lock) 563 ocfs2_inode_unlock(inode, lock_level); 564 565 if (status < 0) 566 make_bad_inode(inode); 567 568 brelse(bh); 569 570 return status; 571} 572 573void ocfs2_sync_blockdev(struct super_block *sb) 574{ 575 sync_blockdev(sb->s_bdev); 576} 577 578static int ocfs2_truncate_for_delete(struct ocfs2_super *osb, 579 struct inode *inode, 580 struct buffer_head *fe_bh) 581{ 582 int status = 0; 583 struct ocfs2_dinode *fe; 584 handle_t *handle = NULL; 585 586 fe = (struct ocfs2_dinode *) fe_bh->b_data; 587 588 /* 589 * This check will also skip truncate of inodes with inline 590 * data and fast symlinks. 591 */ 592 if (fe->i_clusters) { 593 if (ocfs2_should_order_data(inode)) 594 ocfs2_begin_ordered_truncate(inode, 0); 595 596 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 597 if (IS_ERR(handle)) { 598 status = PTR_ERR(handle); 599 handle = NULL; 600 mlog_errno(status); 601 goto out; 602 } 603 604 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), 605 fe_bh, 606 OCFS2_JOURNAL_ACCESS_WRITE); 607 if (status < 0) { 608 mlog_errno(status); 609 goto out; 610 } 611 612 i_size_write(inode, 0); 613 614 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh); 615 if (status < 0) { 616 mlog_errno(status); 617 goto out; 618 } 619 620 ocfs2_commit_trans(osb, handle); 621 handle = NULL; 622 623 status = ocfs2_commit_truncate(osb, inode, fe_bh); 624 if (status < 0) 625 mlog_errno(status); 626 } 627 628out: 629 if (handle) 630 ocfs2_commit_trans(osb, handle); 631 return status; 632} 633 634static int ocfs2_remove_inode(struct inode *inode, 635 struct buffer_head *di_bh, 636 struct inode *orphan_dir_inode, 637 struct buffer_head *orphan_dir_bh) 638{ 639 int status; 640 struct inode *inode_alloc_inode = NULL; 641 struct buffer_head *inode_alloc_bh = NULL; 642 handle_t *handle; 643 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 644 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 645 646 inode_alloc_inode = 647 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE, 648 le16_to_cpu(di->i_suballoc_slot)); 649 if (!inode_alloc_inode) { 650 status = -ENOENT; 651 mlog_errno(status); 652 goto bail; 653 } 654 655 inode_lock(inode_alloc_inode); 656 status = ocfs2_inode_lock(inode_alloc_inode, &inode_alloc_bh, 1); 657 if (status < 0) { 658 inode_unlock(inode_alloc_inode); 659 660 mlog_errno(status); 661 goto bail; 662 } 663 664 handle = ocfs2_start_trans(osb, OCFS2_DELETE_INODE_CREDITS + 665 ocfs2_quota_trans_credits(inode->i_sb)); 666 if (IS_ERR(handle)) { 667 status = PTR_ERR(handle); 668 mlog_errno(status); 669 goto bail_unlock; 670 } 671 672 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)) { 673 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode, 674 orphan_dir_bh, false); 675 if (status < 0) { 676 mlog_errno(status); 677 goto bail_commit; 678 } 679 } 680 681 /* set the inodes dtime */ 682 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 683 OCFS2_JOURNAL_ACCESS_WRITE); 684 if (status < 0) { 685 mlog_errno(status); 686 goto bail_commit; 687 } 688 689 di->i_dtime = cpu_to_le64(ktime_get_real_seconds()); 690 di->i_flags &= cpu_to_le32(~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL)); 691 ocfs2_journal_dirty(handle, di_bh); 692 693 ocfs2_remove_from_cache(INODE_CACHE(inode), di_bh); 694 dquot_free_inode(inode); 695 696 status = ocfs2_free_dinode(handle, inode_alloc_inode, 697 inode_alloc_bh, di); 698 if (status < 0) 699 mlog_errno(status); 700 701bail_commit: 702 ocfs2_commit_trans(osb, handle); 703bail_unlock: 704 ocfs2_inode_unlock(inode_alloc_inode, 1); 705 inode_unlock(inode_alloc_inode); 706 brelse(inode_alloc_bh); 707bail: 708 iput(inode_alloc_inode); 709 710 return status; 711} 712 713/* 714 * Serialize with orphan dir recovery. If the process doing 715 * recovery on this orphan dir does an iget() with the dir 716 * i_rwsem held, we'll deadlock here. Instead we detect this 717 * and exit early - recovery will wipe this inode for us. 718 */ 719static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb, 720 int slot) 721{ 722 int ret = 0; 723 724 spin_lock(&osb->osb_lock); 725 if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) { 726 ret = -EDEADLK; 727 goto out; 728 } 729 /* This signals to the orphan recovery process that it should 730 * wait for us to handle the wipe. */ 731 osb->osb_orphan_wipes[slot]++; 732out: 733 spin_unlock(&osb->osb_lock); 734 trace_ocfs2_check_orphan_recovery_state(slot, ret); 735 return ret; 736} 737 738static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb, 739 int slot) 740{ 741 spin_lock(&osb->osb_lock); 742 osb->osb_orphan_wipes[slot]--; 743 spin_unlock(&osb->osb_lock); 744 745 wake_up(&osb->osb_wipe_event); 746} 747 748static int ocfs2_wipe_inode(struct inode *inode, 749 struct buffer_head *di_bh) 750{ 751 int status, orphaned_slot = -1; 752 struct inode *orphan_dir_inode = NULL; 753 struct buffer_head *orphan_dir_bh = NULL; 754 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 755 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 756 757 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)) { 758 orphaned_slot = le16_to_cpu(di->i_orphaned_slot); 759 760 status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot); 761 if (status) 762 return status; 763 764 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 765 ORPHAN_DIR_SYSTEM_INODE, 766 orphaned_slot); 767 if (!orphan_dir_inode) { 768 status = -ENOENT; 769 mlog_errno(status); 770 goto bail; 771 } 772 773 /* Lock the orphan dir. The lock will be held for the entire 774 * delete_inode operation. We do this now to avoid races with 775 * recovery completion on other nodes. */ 776 inode_lock(orphan_dir_inode); 777 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1); 778 if (status < 0) { 779 inode_unlock(orphan_dir_inode); 780 781 mlog_errno(status); 782 goto bail; 783 } 784 } 785 786 /* we do this while holding the orphan dir lock because we 787 * don't want recovery being run from another node to try an 788 * inode delete underneath us -- this will result in two nodes 789 * truncating the same file! */ 790 status = ocfs2_truncate_for_delete(osb, inode, di_bh); 791 if (status < 0) { 792 mlog_errno(status); 793 goto bail_unlock_dir; 794 } 795 796 /* Remove any dir index tree */ 797 if (S_ISDIR(inode->i_mode)) { 798 status = ocfs2_dx_dir_truncate(inode, di_bh); 799 if (status) { 800 mlog_errno(status); 801 goto bail_unlock_dir; 802 } 803 } 804 805 /*Free extended attribute resources associated with this inode.*/ 806 status = ocfs2_xattr_remove(inode, di_bh); 807 if (status < 0) { 808 mlog_errno(status); 809 goto bail_unlock_dir; 810 } 811 812 status = ocfs2_remove_refcount_tree(inode, di_bh); 813 if (status < 0) { 814 mlog_errno(status); 815 goto bail_unlock_dir; 816 } 817 818 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode, 819 orphan_dir_bh); 820 if (status < 0) 821 mlog_errno(status); 822 823bail_unlock_dir: 824 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR) 825 return status; 826 827 ocfs2_inode_unlock(orphan_dir_inode, 1); 828 inode_unlock(orphan_dir_inode); 829 brelse(orphan_dir_bh); 830bail: 831 iput(orphan_dir_inode); 832 ocfs2_signal_wipe_completion(osb, orphaned_slot); 833 834 return status; 835} 836 837/* There is a series of simple checks that should be done before a 838 * trylock is even considered. Encapsulate those in this function. */ 839static int ocfs2_inode_is_valid_to_delete(struct inode *inode) 840{ 841 int ret = 0; 842 struct ocfs2_inode_info *oi = OCFS2_I(inode); 843 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 844 845 trace_ocfs2_inode_is_valid_to_delete(current, osb->dc_task, 846 (unsigned long long)oi->ip_blkno, 847 oi->ip_flags); 848 849 /* We shouldn't be getting here for the root directory 850 * inode.. */ 851 if (inode == osb->root_inode) { 852 mlog(ML_ERROR, "Skipping delete of root inode.\n"); 853 goto bail; 854 } 855 856 /* 857 * If we're coming from downconvert_thread we can't go into our own 858 * voting [hello, deadlock city!] so we cannot delete the inode. But 859 * since we dropped last inode ref when downconverting dentry lock, 860 * we cannot have the file open and thus the node doing unlink will 861 * take care of deleting the inode. 862 */ 863 if (current == osb->dc_task) 864 goto bail; 865 866 spin_lock(&oi->ip_lock); 867 /* OCFS2 *never* deletes system files. This should technically 868 * never get here as system file inodes should always have a 869 * positive link count. */ 870 if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) { 871 mlog(ML_ERROR, "Skipping delete of system file %llu\n", 872 (unsigned long long)oi->ip_blkno); 873 goto bail_unlock; 874 } 875 876 ret = 1; 877bail_unlock: 878 spin_unlock(&oi->ip_lock); 879bail: 880 return ret; 881} 882 883/* Query the cluster to determine whether we should wipe an inode from 884 * disk or not. 885 * 886 * Requires the inode to have the cluster lock. */ 887static int ocfs2_query_inode_wipe(struct inode *inode, 888 struct buffer_head *di_bh, 889 int *wipe) 890{ 891 int status = 0, reason = 0; 892 struct ocfs2_inode_info *oi = OCFS2_I(inode); 893 struct ocfs2_dinode *di; 894 895 *wipe = 0; 896 897 trace_ocfs2_query_inode_wipe_begin((unsigned long long)oi->ip_blkno, 898 inode->i_nlink); 899 900 /* While we were waiting for the cluster lock in 901 * ocfs2_delete_inode, another node might have asked to delete 902 * the inode. Recheck our flags to catch this. */ 903 if (!ocfs2_inode_is_valid_to_delete(inode)) { 904 reason = 1; 905 goto bail; 906 } 907 908 /* Now that we have an up to date inode, we can double check 909 * the link count. */ 910 if (inode->i_nlink) 911 goto bail; 912 913 /* Do some basic inode verification... */ 914 di = (struct ocfs2_dinode *) di_bh->b_data; 915 if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL)) && 916 !(oi->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)) { 917 /* 918 * Inodes in the orphan dir must have ORPHANED_FL. The only 919 * inodes that come back out of the orphan dir are reflink 920 * targets. A reflink target may be moved out of the orphan 921 * dir between the time we scan the directory and the time we 922 * process it. This would lead to HAS_REFCOUNT_FL being set but 923 * ORPHANED_FL not. 924 */ 925 if (di->i_dyn_features & cpu_to_le16(OCFS2_HAS_REFCOUNT_FL)) { 926 reason = 2; 927 goto bail; 928 } 929 930 /* for lack of a better error? */ 931 status = -EEXIST; 932 mlog(ML_ERROR, 933 "Inode %llu (on-disk %llu) not orphaned! " 934 "Disk flags 0x%x, inode flags 0x%x\n", 935 (unsigned long long)oi->ip_blkno, 936 (unsigned long long)le64_to_cpu(di->i_blkno), 937 le32_to_cpu(di->i_flags), oi->ip_flags); 938 goto bail; 939 } 940 941 /* has someone already deleted us?! baaad... */ 942 if (di->i_dtime) { 943 status = -EEXIST; 944 mlog_errno(status); 945 goto bail; 946 } 947 948 /* 949 * This is how ocfs2 determines whether an inode is still live 950 * within the cluster. Every node takes a shared read lock on 951 * the inode open lock in ocfs2_read_locked_inode(). When we 952 * get to ->delete_inode(), each node tries to convert it's 953 * lock to an exclusive. Trylocks are serialized by the inode 954 * meta data lock. If the upconvert succeeds, we know the inode 955 * is no longer live and can be deleted. 956 * 957 * Though we call this with the meta data lock held, the 958 * trylock keeps us from ABBA deadlock. 959 */ 960 status = ocfs2_try_open_lock(inode, 1); 961 if (status == -EAGAIN) { 962 status = 0; 963 reason = 3; 964 goto bail; 965 } 966 if (status < 0) { 967 mlog_errno(status); 968 goto bail; 969 } 970 971 *wipe = 1; 972 trace_ocfs2_query_inode_wipe_succ(le16_to_cpu(di->i_orphaned_slot)); 973 974bail: 975 trace_ocfs2_query_inode_wipe_end(status, reason); 976 return status; 977} 978 979/* Support function for ocfs2_delete_inode. Will help us keep the 980 * inode data in a consistent state for clear_inode. Always truncates 981 * pages, optionally sync's them first. */ 982static void ocfs2_cleanup_delete_inode(struct inode *inode, 983 int sync_data) 984{ 985 trace_ocfs2_cleanup_delete_inode( 986 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data); 987 if (sync_data) 988 filemap_write_and_wait(inode->i_mapping); 989 truncate_inode_pages_final(&inode->i_data); 990} 991 992static void ocfs2_delete_inode(struct inode *inode) 993{ 994 int wipe, status; 995 sigset_t oldset; 996 struct buffer_head *di_bh = NULL; 997 struct ocfs2_dinode *di = NULL; 998 999 trace_ocfs2_delete_inode(inode->i_ino, 1000 (unsigned long long)OCFS2_I(inode)->ip_blkno, 1001 is_bad_inode(inode)); 1002 1003 /* When we fail in read_inode() we mark inode as bad. The second test 1004 * catches the case when inode allocation fails before allocating 1005 * a block for inode. */ 1006 if (is_bad_inode(inode) || !OCFS2_I(inode)->ip_blkno) 1007 goto bail; 1008 1009 if (!ocfs2_inode_is_valid_to_delete(inode)) { 1010 /* It's probably not necessary to truncate_inode_pages 1011 * here but we do it for safety anyway (it will most 1012 * likely be a no-op anyway) */ 1013 ocfs2_cleanup_delete_inode(inode, 0); 1014 goto bail; 1015 } 1016 1017 dquot_initialize(inode); 1018 1019 /* We want to block signals in delete_inode as the lock and 1020 * messaging paths may return us -ERESTARTSYS. Which would 1021 * cause us to exit early, resulting in inodes being orphaned 1022 * forever. */ 1023 ocfs2_block_signals(&oldset); 1024 1025 /* 1026 * Synchronize us against ocfs2_get_dentry. We take this in 1027 * shared mode so that all nodes can still concurrently 1028 * process deletes. 1029 */ 1030 status = ocfs2_nfs_sync_lock(OCFS2_SB(inode->i_sb), 0); 1031 if (status < 0) { 1032 mlog(ML_ERROR, "getting nfs sync lock(PR) failed %d\n", status); 1033 ocfs2_cleanup_delete_inode(inode, 0); 1034 goto bail_unblock; 1035 } 1036 /* Lock down the inode. This gives us an up to date view of 1037 * it's metadata (for verification), and allows us to 1038 * serialize delete_inode on multiple nodes. 1039 * 1040 * Even though we might be doing a truncate, we don't take the 1041 * allocation lock here as it won't be needed - nobody will 1042 * have the file open. 1043 */ 1044 status = ocfs2_inode_lock(inode, &di_bh, 1); 1045 if (status < 0) { 1046 if (status != -ENOENT) 1047 mlog_errno(status); 1048 ocfs2_cleanup_delete_inode(inode, 0); 1049 goto bail_unlock_nfs_sync; 1050 } 1051 1052 di = (struct ocfs2_dinode *)di_bh->b_data; 1053 /* Skip inode deletion and wait for dio orphan entry recovered 1054 * first */ 1055 if (unlikely(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))) { 1056 ocfs2_cleanup_delete_inode(inode, 0); 1057 goto bail_unlock_inode; 1058 } 1059 1060 /* Query the cluster. This will be the final decision made 1061 * before we go ahead and wipe the inode. */ 1062 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe); 1063 if (!wipe || status < 0) { 1064 /* Error and remote inode busy both mean we won't be 1065 * removing the inode, so they take almost the same 1066 * path. */ 1067 if (status < 0) 1068 mlog_errno(status); 1069 1070 /* Someone in the cluster has disallowed a wipe of 1071 * this inode, or it was never completely 1072 * orphaned. Write out the pages and exit now. */ 1073 ocfs2_cleanup_delete_inode(inode, 1); 1074 goto bail_unlock_inode; 1075 } 1076 1077 ocfs2_cleanup_delete_inode(inode, 0); 1078 1079 status = ocfs2_wipe_inode(inode, di_bh); 1080 if (status < 0) { 1081 if (status != -EDEADLK) 1082 mlog_errno(status); 1083 goto bail_unlock_inode; 1084 } 1085 1086 /* 1087 * Mark the inode as successfully deleted. 1088 * 1089 * This is important for ocfs2_clear_inode() as it will check 1090 * this flag and skip any checkpointing work 1091 * 1092 * ocfs2_stuff_meta_lvb() also uses this flag to invalidate 1093 * the LVB for other nodes. 1094 */ 1095 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED; 1096 1097bail_unlock_inode: 1098 ocfs2_inode_unlock(inode, 1); 1099 brelse(di_bh); 1100 1101bail_unlock_nfs_sync: 1102 ocfs2_nfs_sync_unlock(OCFS2_SB(inode->i_sb), 0); 1103 1104bail_unblock: 1105 ocfs2_unblock_signals(&oldset); 1106bail: 1107 return; 1108} 1109 1110static void ocfs2_clear_inode(struct inode *inode) 1111{ 1112 int status; 1113 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1114 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1115 1116 clear_inode(inode); 1117 trace_ocfs2_clear_inode((unsigned long long)oi->ip_blkno, 1118 inode->i_nlink); 1119 1120 mlog_bug_on_msg(osb == NULL, 1121 "Inode=%lu\n", inode->i_ino); 1122 1123 dquot_drop(inode); 1124 1125 /* To preven remote deletes we hold open lock before, now it 1126 * is time to unlock PR and EX open locks. */ 1127 ocfs2_open_unlock(inode); 1128 1129 /* Do these before all the other work so that we don't bounce 1130 * the downconvert thread while waiting to destroy the locks. */ 1131 ocfs2_mark_lockres_freeing(osb, &oi->ip_rw_lockres); 1132 ocfs2_mark_lockres_freeing(osb, &oi->ip_inode_lockres); 1133 ocfs2_mark_lockres_freeing(osb, &oi->ip_open_lockres); 1134 1135 ocfs2_resv_discard(&osb->osb_la_resmap, 1136 &oi->ip_la_data_resv); 1137 ocfs2_resv_init_once(&oi->ip_la_data_resv); 1138 1139 /* We very well may get a clear_inode before all an inodes 1140 * metadata has hit disk. Of course, we can't drop any cluster 1141 * locks until the journal has finished with it. The only 1142 * exception here are successfully wiped inodes - their 1143 * metadata can now be considered to be part of the system 1144 * inodes from which it came. */ 1145 if (!(oi->ip_flags & OCFS2_INODE_DELETED)) 1146 ocfs2_checkpoint_inode(inode); 1147 1148 mlog_bug_on_msg(!list_empty(&oi->ip_io_markers), 1149 "Clear inode of %llu, inode has io markers\n", 1150 (unsigned long long)oi->ip_blkno); 1151 mlog_bug_on_msg(!list_empty(&oi->ip_unwritten_list), 1152 "Clear inode of %llu, inode has unwritten extents\n", 1153 (unsigned long long)oi->ip_blkno); 1154 1155 ocfs2_extent_map_trunc(inode, 0); 1156 1157 status = ocfs2_drop_inode_locks(inode); 1158 if (status < 0) 1159 mlog_errno(status); 1160 1161 ocfs2_lock_res_free(&oi->ip_rw_lockres); 1162 ocfs2_lock_res_free(&oi->ip_inode_lockres); 1163 ocfs2_lock_res_free(&oi->ip_open_lockres); 1164 1165 ocfs2_metadata_cache_exit(INODE_CACHE(inode)); 1166 1167 mlog_bug_on_msg(INODE_CACHE(inode)->ci_num_cached, 1168 "Clear inode of %llu, inode has %u cache items\n", 1169 (unsigned long long)oi->ip_blkno, 1170 INODE_CACHE(inode)->ci_num_cached); 1171 1172 mlog_bug_on_msg(!(INODE_CACHE(inode)->ci_flags & OCFS2_CACHE_FL_INLINE), 1173 "Clear inode of %llu, inode has a bad flag\n", 1174 (unsigned long long)oi->ip_blkno); 1175 1176 mlog_bug_on_msg(spin_is_locked(&oi->ip_lock), 1177 "Clear inode of %llu, inode is locked\n", 1178 (unsigned long long)oi->ip_blkno); 1179 1180 mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex), 1181 "Clear inode of %llu, io_mutex is locked\n", 1182 (unsigned long long)oi->ip_blkno); 1183 mutex_unlock(&oi->ip_io_mutex); 1184 1185 /* 1186 * down_trylock() returns 0, down_write_trylock() returns 1 1187 * kernel 1, world 0 1188 */ 1189 mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem), 1190 "Clear inode of %llu, alloc_sem is locked\n", 1191 (unsigned long long)oi->ip_blkno); 1192 up_write(&oi->ip_alloc_sem); 1193 1194 mlog_bug_on_msg(oi->ip_open_count, 1195 "Clear inode of %llu has open count %d\n", 1196 (unsigned long long)oi->ip_blkno, oi->ip_open_count); 1197 1198 /* Clear all other flags. */ 1199 oi->ip_flags = 0; 1200 oi->ip_dir_start_lookup = 0; 1201 oi->ip_blkno = 0ULL; 1202 1203 /* 1204 * ip_jinode is used to track txns against this inode. We ensure that 1205 * the journal is flushed before journal shutdown. Thus it is safe to 1206 * have inodes get cleaned up after journal shutdown. 1207 */ 1208 jbd2_journal_release_jbd_inode(osb->journal->j_journal, 1209 &oi->ip_jinode); 1210} 1211 1212void ocfs2_evict_inode(struct inode *inode) 1213{ 1214 if (!inode->i_nlink || 1215 (OCFS2_I(inode)->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)) { 1216 ocfs2_delete_inode(inode); 1217 } else { 1218 truncate_inode_pages_final(&inode->i_data); 1219 } 1220 ocfs2_clear_inode(inode); 1221} 1222 1223/* Called under inode_lock, with no more references on the 1224 * struct inode, so it's safe here to check the flags field 1225 * and to manipulate i_nlink without any other locks. */ 1226int ocfs2_drop_inode(struct inode *inode) 1227{ 1228 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1229 1230 trace_ocfs2_drop_inode((unsigned long long)oi->ip_blkno, 1231 inode->i_nlink, oi->ip_flags); 1232 1233 assert_spin_locked(&inode->i_lock); 1234 inode->i_state |= I_WILL_FREE; 1235 spin_unlock(&inode->i_lock); 1236 write_inode_now(inode, 1); 1237 spin_lock(&inode->i_lock); 1238 WARN_ON(inode->i_state & I_NEW); 1239 inode->i_state &= ~I_WILL_FREE; 1240 1241 return 1; 1242} 1243 1244/* 1245 * This is called from our getattr. 1246 */ 1247int ocfs2_inode_revalidate(struct dentry *dentry) 1248{ 1249 struct inode *inode = d_inode(dentry); 1250 int status = 0; 1251 1252 trace_ocfs2_inode_revalidate(inode, 1253 inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL, 1254 inode ? (unsigned long long)OCFS2_I(inode)->ip_flags : 0); 1255 1256 if (!inode) { 1257 status = -ENOENT; 1258 goto bail; 1259 } 1260 1261 spin_lock(&OCFS2_I(inode)->ip_lock); 1262 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) { 1263 spin_unlock(&OCFS2_I(inode)->ip_lock); 1264 status = -ENOENT; 1265 goto bail; 1266 } 1267 spin_unlock(&OCFS2_I(inode)->ip_lock); 1268 1269 /* Let ocfs2_inode_lock do the work of updating our struct 1270 * inode for us. */ 1271 status = ocfs2_inode_lock(inode, NULL, 0); 1272 if (status < 0) { 1273 if (status != -ENOENT) 1274 mlog_errno(status); 1275 goto bail; 1276 } 1277 ocfs2_inode_unlock(inode, 0); 1278bail: 1279 return status; 1280} 1281 1282/* 1283 * Updates a disk inode from a 1284 * struct inode. 1285 * Only takes ip_lock. 1286 */ 1287int ocfs2_mark_inode_dirty(handle_t *handle, 1288 struct inode *inode, 1289 struct buffer_head *bh) 1290{ 1291 int status; 1292 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data; 1293 1294 trace_ocfs2_mark_inode_dirty((unsigned long long)OCFS2_I(inode)->ip_blkno); 1295 1296 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh, 1297 OCFS2_JOURNAL_ACCESS_WRITE); 1298 if (status < 0) { 1299 mlog_errno(status); 1300 goto leave; 1301 } 1302 1303 spin_lock(&OCFS2_I(inode)->ip_lock); 1304 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters); 1305 ocfs2_get_inode_flags(OCFS2_I(inode)); 1306 fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr); 1307 fe->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features); 1308 spin_unlock(&OCFS2_I(inode)->ip_lock); 1309 1310 fe->i_size = cpu_to_le64(i_size_read(inode)); 1311 ocfs2_set_links_count(fe, inode->i_nlink); 1312 fe->i_uid = cpu_to_le32(i_uid_read(inode)); 1313 fe->i_gid = cpu_to_le32(i_gid_read(inode)); 1314 fe->i_mode = cpu_to_le16(inode->i_mode); 1315 fe->i_atime = cpu_to_le64(inode_get_atime_sec(inode)); 1316 fe->i_atime_nsec = cpu_to_le32(inode_get_atime_nsec(inode)); 1317 fe->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode)); 1318 fe->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode)); 1319 fe->i_mtime = cpu_to_le64(inode_get_mtime_sec(inode)); 1320 fe->i_mtime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode)); 1321 1322 ocfs2_journal_dirty(handle, bh); 1323 ocfs2_update_inode_fsync_trans(handle, inode, 1); 1324leave: 1325 return status; 1326} 1327 1328/* 1329 * 1330 * Updates a struct inode from a disk inode. 1331 * does no i/o, only takes ip_lock. 1332 */ 1333void ocfs2_refresh_inode(struct inode *inode, 1334 struct ocfs2_dinode *fe) 1335{ 1336 spin_lock(&OCFS2_I(inode)->ip_lock); 1337 1338 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 1339 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr); 1340 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features); 1341 ocfs2_set_inode_flags(inode); 1342 i_size_write(inode, le64_to_cpu(fe->i_size)); 1343 set_nlink(inode, ocfs2_read_links_count(fe)); 1344 i_uid_write(inode, le32_to_cpu(fe->i_uid)); 1345 i_gid_write(inode, le32_to_cpu(fe->i_gid)); 1346 inode->i_mode = le16_to_cpu(fe->i_mode); 1347 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0) 1348 inode->i_blocks = 0; 1349 else 1350 inode->i_blocks = ocfs2_inode_sector_count(inode); 1351 inode_set_atime(inode, le64_to_cpu(fe->i_atime), 1352 le32_to_cpu(fe->i_atime_nsec)); 1353 inode_set_mtime(inode, le64_to_cpu(fe->i_mtime), 1354 le32_to_cpu(fe->i_mtime_nsec)); 1355 inode_set_ctime(inode, le64_to_cpu(fe->i_ctime), 1356 le32_to_cpu(fe->i_ctime_nsec)); 1357 1358 spin_unlock(&OCFS2_I(inode)->ip_lock); 1359} 1360 1361int ocfs2_validate_inode_block(struct super_block *sb, 1362 struct buffer_head *bh) 1363{ 1364 int rc; 1365 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 1366 1367 trace_ocfs2_validate_inode_block((unsigned long long)bh->b_blocknr); 1368 1369 BUG_ON(!buffer_uptodate(bh)); 1370 1371 /* 1372 * If the ecc fails, we return the error but otherwise 1373 * leave the filesystem running. We know any error is 1374 * local to this block. 1375 */ 1376 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check); 1377 if (rc) { 1378 mlog(ML_ERROR, "Checksum failed for dinode %llu\n", 1379 (unsigned long long)bh->b_blocknr); 1380 goto bail; 1381 } 1382 1383 /* 1384 * Errors after here are fatal. 1385 */ 1386 1387 rc = -EINVAL; 1388 1389 if (!OCFS2_IS_VALID_DINODE(di)) { 1390 rc = ocfs2_error(sb, "Invalid dinode #%llu: signature = %.*s\n", 1391 (unsigned long long)bh->b_blocknr, 7, 1392 di->i_signature); 1393 goto bail; 1394 } 1395 1396 if (le64_to_cpu(di->i_blkno) != bh->b_blocknr) { 1397 rc = ocfs2_error(sb, "Invalid dinode #%llu: i_blkno is %llu\n", 1398 (unsigned long long)bh->b_blocknr, 1399 (unsigned long long)le64_to_cpu(di->i_blkno)); 1400 goto bail; 1401 } 1402 1403 if (!(di->i_flags & cpu_to_le32(OCFS2_VALID_FL))) { 1404 rc = ocfs2_error(sb, 1405 "Invalid dinode #%llu: OCFS2_VALID_FL not set\n", 1406 (unsigned long long)bh->b_blocknr); 1407 goto bail; 1408 } 1409 1410 if (le32_to_cpu(di->i_fs_generation) != 1411 OCFS2_SB(sb)->fs_generation) { 1412 rc = ocfs2_error(sb, 1413 "Invalid dinode #%llu: fs_generation is %u\n", 1414 (unsigned long long)bh->b_blocknr, 1415 le32_to_cpu(di->i_fs_generation)); 1416 goto bail; 1417 } 1418 1419 rc = 0; 1420 1421bail: 1422 return rc; 1423} 1424 1425static int ocfs2_filecheck_validate_inode_block(struct super_block *sb, 1426 struct buffer_head *bh) 1427{ 1428 int rc = 0; 1429 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 1430 1431 trace_ocfs2_filecheck_validate_inode_block( 1432 (unsigned long long)bh->b_blocknr); 1433 1434 BUG_ON(!buffer_uptodate(bh)); 1435 1436 /* 1437 * Call ocfs2_validate_meta_ecc() first since it has ecc repair 1438 * function, but we should not return error immediately when ecc 1439 * validation fails, because the reason is quite likely the invalid 1440 * inode number inputed. 1441 */ 1442 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check); 1443 if (rc) { 1444 mlog(ML_ERROR, 1445 "Filecheck: checksum failed for dinode %llu\n", 1446 (unsigned long long)bh->b_blocknr); 1447 rc = -OCFS2_FILECHECK_ERR_BLOCKECC; 1448 } 1449 1450 if (!OCFS2_IS_VALID_DINODE(di)) { 1451 mlog(ML_ERROR, 1452 "Filecheck: invalid dinode #%llu: signature = %.*s\n", 1453 (unsigned long long)bh->b_blocknr, 7, di->i_signature); 1454 rc = -OCFS2_FILECHECK_ERR_INVALIDINO; 1455 goto bail; 1456 } else if (rc) 1457 goto bail; 1458 1459 if (le64_to_cpu(di->i_blkno) != bh->b_blocknr) { 1460 mlog(ML_ERROR, 1461 "Filecheck: invalid dinode #%llu: i_blkno is %llu\n", 1462 (unsigned long long)bh->b_blocknr, 1463 (unsigned long long)le64_to_cpu(di->i_blkno)); 1464 rc = -OCFS2_FILECHECK_ERR_BLOCKNO; 1465 goto bail; 1466 } 1467 1468 if (!(di->i_flags & cpu_to_le32(OCFS2_VALID_FL))) { 1469 mlog(ML_ERROR, 1470 "Filecheck: invalid dinode #%llu: OCFS2_VALID_FL " 1471 "not set\n", 1472 (unsigned long long)bh->b_blocknr); 1473 rc = -OCFS2_FILECHECK_ERR_VALIDFLAG; 1474 goto bail; 1475 } 1476 1477 if (le32_to_cpu(di->i_fs_generation) != 1478 OCFS2_SB(sb)->fs_generation) { 1479 mlog(ML_ERROR, 1480 "Filecheck: invalid dinode #%llu: fs_generation is %u\n", 1481 (unsigned long long)bh->b_blocknr, 1482 le32_to_cpu(di->i_fs_generation)); 1483 rc = -OCFS2_FILECHECK_ERR_GENERATION; 1484 } 1485 1486bail: 1487 return rc; 1488} 1489 1490static int ocfs2_filecheck_repair_inode_block(struct super_block *sb, 1491 struct buffer_head *bh) 1492{ 1493 int changed = 0; 1494 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 1495 1496 if (!ocfs2_filecheck_validate_inode_block(sb, bh)) 1497 return 0; 1498 1499 trace_ocfs2_filecheck_repair_inode_block( 1500 (unsigned long long)bh->b_blocknr); 1501 1502 if (ocfs2_is_hard_readonly(OCFS2_SB(sb)) || 1503 ocfs2_is_soft_readonly(OCFS2_SB(sb))) { 1504 mlog(ML_ERROR, 1505 "Filecheck: cannot repair dinode #%llu " 1506 "on readonly filesystem\n", 1507 (unsigned long long)bh->b_blocknr); 1508 return -OCFS2_FILECHECK_ERR_READONLY; 1509 } 1510 1511 if (buffer_jbd(bh)) { 1512 mlog(ML_ERROR, 1513 "Filecheck: cannot repair dinode #%llu, " 1514 "its buffer is in jbd\n", 1515 (unsigned long long)bh->b_blocknr); 1516 return -OCFS2_FILECHECK_ERR_INJBD; 1517 } 1518 1519 if (!OCFS2_IS_VALID_DINODE(di)) { 1520 /* Cannot fix invalid inode block */ 1521 return -OCFS2_FILECHECK_ERR_INVALIDINO; 1522 } 1523 1524 if (!(di->i_flags & cpu_to_le32(OCFS2_VALID_FL))) { 1525 /* Cannot just add VALID_FL flag back as a fix, 1526 * need more things to check here. 1527 */ 1528 return -OCFS2_FILECHECK_ERR_VALIDFLAG; 1529 } 1530 1531 if (le64_to_cpu(di->i_blkno) != bh->b_blocknr) { 1532 di->i_blkno = cpu_to_le64(bh->b_blocknr); 1533 changed = 1; 1534 mlog(ML_ERROR, 1535 "Filecheck: reset dinode #%llu: i_blkno to %llu\n", 1536 (unsigned long long)bh->b_blocknr, 1537 (unsigned long long)le64_to_cpu(di->i_blkno)); 1538 } 1539 1540 if (le32_to_cpu(di->i_fs_generation) != 1541 OCFS2_SB(sb)->fs_generation) { 1542 di->i_fs_generation = cpu_to_le32(OCFS2_SB(sb)->fs_generation); 1543 changed = 1; 1544 mlog(ML_ERROR, 1545 "Filecheck: reset dinode #%llu: fs_generation to %u\n", 1546 (unsigned long long)bh->b_blocknr, 1547 le32_to_cpu(di->i_fs_generation)); 1548 } 1549 1550 if (changed || ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check)) { 1551 ocfs2_compute_meta_ecc(sb, bh->b_data, &di->i_check); 1552 mark_buffer_dirty(bh); 1553 mlog(ML_ERROR, 1554 "Filecheck: reset dinode #%llu: compute meta ecc\n", 1555 (unsigned long long)bh->b_blocknr); 1556 } 1557 1558 return 0; 1559} 1560 1561static int 1562ocfs2_filecheck_read_inode_block_full(struct inode *inode, 1563 struct buffer_head **bh, 1564 int flags, int type) 1565{ 1566 int rc; 1567 struct buffer_head *tmp = *bh; 1568 1569 if (!type) /* Check inode block */ 1570 rc = ocfs2_read_blocks(INODE_CACHE(inode), 1571 OCFS2_I(inode)->ip_blkno, 1572 1, &tmp, flags, 1573 ocfs2_filecheck_validate_inode_block); 1574 else /* Repair inode block */ 1575 rc = ocfs2_read_blocks(INODE_CACHE(inode), 1576 OCFS2_I(inode)->ip_blkno, 1577 1, &tmp, flags, 1578 ocfs2_filecheck_repair_inode_block); 1579 1580 /* If ocfs2_read_blocks() got us a new bh, pass it up. */ 1581 if (!rc && !*bh) 1582 *bh = tmp; 1583 1584 return rc; 1585} 1586 1587int ocfs2_read_inode_block_full(struct inode *inode, struct buffer_head **bh, 1588 int flags) 1589{ 1590 int rc; 1591 struct buffer_head *tmp = *bh; 1592 1593 rc = ocfs2_read_blocks(INODE_CACHE(inode), OCFS2_I(inode)->ip_blkno, 1594 1, &tmp, flags, ocfs2_validate_inode_block); 1595 1596 /* If ocfs2_read_blocks() got us a new bh, pass it up. */ 1597 if (!rc && !*bh) 1598 *bh = tmp; 1599 1600 return rc; 1601} 1602 1603int ocfs2_read_inode_block(struct inode *inode, struct buffer_head **bh) 1604{ 1605 return ocfs2_read_inode_block_full(inode, bh, 0); 1606} 1607 1608 1609static u64 ocfs2_inode_cache_owner(struct ocfs2_caching_info *ci) 1610{ 1611 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1612 1613 return oi->ip_blkno; 1614} 1615 1616static struct super_block *ocfs2_inode_cache_get_super(struct ocfs2_caching_info *ci) 1617{ 1618 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1619 1620 return oi->vfs_inode.i_sb; 1621} 1622 1623static void ocfs2_inode_cache_lock(struct ocfs2_caching_info *ci) 1624{ 1625 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1626 1627 spin_lock(&oi->ip_lock); 1628} 1629 1630static void ocfs2_inode_cache_unlock(struct ocfs2_caching_info *ci) 1631{ 1632 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1633 1634 spin_unlock(&oi->ip_lock); 1635} 1636 1637static void ocfs2_inode_cache_io_lock(struct ocfs2_caching_info *ci) 1638{ 1639 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1640 1641 mutex_lock(&oi->ip_io_mutex); 1642} 1643 1644static void ocfs2_inode_cache_io_unlock(struct ocfs2_caching_info *ci) 1645{ 1646 struct ocfs2_inode_info *oi = cache_info_to_inode(ci); 1647 1648 mutex_unlock(&oi->ip_io_mutex); 1649} 1650 1651const struct ocfs2_caching_operations ocfs2_inode_caching_ops = { 1652 .co_owner = ocfs2_inode_cache_owner, 1653 .co_get_super = ocfs2_inode_cache_get_super, 1654 .co_cache_lock = ocfs2_inode_cache_lock, 1655 .co_cache_unlock = ocfs2_inode_cache_unlock, 1656 .co_io_lock = ocfs2_inode_cache_io_lock, 1657 .co_io_unlock = ocfs2_inode_cache_io_unlock, 1658}; 1659 1660