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