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/slab.h> 29#include <linux/highmem.h> 30#include <linux/pagemap.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 "dlmglue.h" 41#include "extent_map.h" 42#include "file.h" 43#include "heartbeat.h" 44#include "inode.h" 45#include "journal.h" 46#include "namei.h" 47#include "suballoc.h" 48#include "super.h" 49#include "symlink.h" 50#include "sysfile.h" 51#include "uptodate.h" 52#include "vote.h" 53 54#include "buffer_head_io.h" 55 56struct ocfs2_find_inode_args 57{ 58 u64 fi_blkno; 59 unsigned long fi_ino; 60 unsigned int fi_flags; 61}; 62 63static int ocfs2_read_locked_inode(struct inode *inode, 64 struct ocfs2_find_inode_args *args); 65static int ocfs2_init_locked_inode(struct inode *inode, void *opaque); 66static int ocfs2_find_actor(struct inode *inode, void *opaque); 67static int ocfs2_truncate_for_delete(struct ocfs2_super *osb, 68 struct inode *inode, 69 struct buffer_head *fe_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_iget(struct ocfs2_super *osb, u64 blkno, int flags) 111{ 112 struct inode *inode = NULL; 113 struct super_block *sb = osb->sb; 114 struct ocfs2_find_inode_args args; 115 116 mlog_entry("(blkno = %llu)\n", (unsigned long long)blkno); 117 118 /* Ok. By now we've either got the offsets passed to us by the 119 * caller, or we just pulled them off the bh. Lets do some 120 * sanity checks to make sure they're OK. */ 121 if (blkno == 0) { 122 inode = ERR_PTR(-EINVAL); 123 mlog_errno(PTR_ERR(inode)); 124 goto bail; 125 } 126 127 args.fi_blkno = blkno; 128 args.fi_flags = flags; 129 args.fi_ino = ino_from_blkno(sb, blkno); 130 131 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor, 132 ocfs2_init_locked_inode, &args); 133 /* inode was *not* in the inode cache. 2.6.x requires 134 * us to do our own read_inode call and unlock it 135 * afterwards. */ 136 if (inode && inode->i_state & I_NEW) { 137 mlog(0, "Inode was not in inode cache, reading it.\n"); 138 ocfs2_read_locked_inode(inode, &args); 139 unlock_new_inode(inode); 140 } 141 if (inode == NULL) { 142 inode = ERR_PTR(-ENOMEM); 143 mlog_errno(PTR_ERR(inode)); 144 goto bail; 145 } 146 if (is_bad_inode(inode)) { 147 iput(inode); 148 inode = ERR_PTR(-ESTALE); 149 goto bail; 150 } 151 152bail: 153 if (!IS_ERR(inode)) { 154 mlog(0, "returning inode with number %llu\n", 155 (unsigned long long)OCFS2_I(inode)->ip_blkno); 156 mlog_exit_ptr(inode); 157 } 158 159 return inode; 160} 161 162 163/* 164 * here's how inodes get read from disk: 165 * iget5_locked -> find_actor -> OCFS2_FIND_ACTOR 166 * found? : return the in-memory inode 167 * not found? : get_new_inode -> OCFS2_INIT_LOCKED_INODE 168 */ 169 170static int ocfs2_find_actor(struct inode *inode, void *opaque) 171{ 172 struct ocfs2_find_inode_args *args = NULL; 173 struct ocfs2_inode_info *oi = OCFS2_I(inode); 174 int ret = 0; 175 176 mlog_entry("(0x%p, %lu, 0x%p)\n", inode, inode->i_ino, opaque); 177 178 args = opaque; 179 180 mlog_bug_on_msg(!inode, "No inode in find actor!\n"); 181 182 if (oi->ip_blkno != args->fi_blkno) 183 goto bail; 184 185 ret = 1; 186bail: 187 mlog_exit(ret); 188 return ret; 189} 190 191/* 192 * initialize the new inode, but don't do anything that would cause 193 * us to sleep. 194 * return 0 on success, 1 on failure 195 */ 196static int ocfs2_init_locked_inode(struct inode *inode, void *opaque) 197{ 198 struct ocfs2_find_inode_args *args = opaque; 199 200 mlog_entry("inode = %p, opaque = %p\n", inode, opaque); 201 202 inode->i_ino = args->fi_ino; 203 OCFS2_I(inode)->ip_blkno = args->fi_blkno; 204 205 mlog_exit(0); 206 return 0; 207} 208 209int ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe, 210 int create_ino) 211{ 212 struct super_block *sb; 213 struct ocfs2_super *osb; 214 int status = -EINVAL; 215 216 mlog_entry("(0x%p, size:%llu)\n", inode, 217 (unsigned long long)le64_to_cpu(fe->i_size)); 218 219 sb = inode->i_sb; 220 osb = OCFS2_SB(sb); 221 222 /* this means that read_inode cannot create a superblock inode 223 * today. change if needed. */ 224 if (!OCFS2_IS_VALID_DINODE(fe) || 225 !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL))) { 226 mlog(0, "Invalid dinode: i_ino=%lu, i_blkno=%llu, " 227 "signature = %.*s, flags = 0x%x\n", 228 inode->i_ino, 229 (unsigned long long)le64_to_cpu(fe->i_blkno), 7, 230 fe->i_signature, le32_to_cpu(fe->i_flags)); 231 goto bail; 232 } 233 234 if (le32_to_cpu(fe->i_fs_generation) != osb->fs_generation) { 235 mlog(ML_ERROR, "file entry generation does not match " 236 "superblock! osb->fs_generation=%x, " 237 "fe->i_fs_generation=%x\n", 238 osb->fs_generation, le32_to_cpu(fe->i_fs_generation)); 239 goto bail; 240 } 241 242 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 243 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr); 244 245 inode->i_version = 1; 246 inode->i_generation = le32_to_cpu(fe->i_generation); 247 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev)); 248 inode->i_mode = le16_to_cpu(fe->i_mode); 249 inode->i_uid = le32_to_cpu(fe->i_uid); 250 inode->i_gid = le32_to_cpu(fe->i_gid); 251 252 /* Fast symlinks will have i_size but no allocated clusters. */ 253 if (S_ISLNK(inode->i_mode) && !fe->i_clusters) 254 inode->i_blocks = 0; 255 else 256 inode->i_blocks = ocfs2_inode_sector_count(inode); 257 inode->i_mapping->a_ops = &ocfs2_aops; 258 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime); 259 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec); 260 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime); 261 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec); 262 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime); 263 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec); 264 265 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno)) 266 mlog(ML_ERROR, 267 "ip_blkno %llu != i_blkno %llu!\n", 268 (unsigned long long)OCFS2_I(inode)->ip_blkno, 269 (unsigned long long)le64_to_cpu(fe->i_blkno)); 270 271 inode->i_nlink = le16_to_cpu(fe->i_links_count); 272 273 if (fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) 274 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE; 275 276 if (fe->i_flags & cpu_to_le32(OCFS2_LOCAL_ALLOC_FL)) { 277 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP; 278 mlog(0, "local alloc inode: i_ino=%lu\n", inode->i_ino); 279 } else if (fe->i_flags & cpu_to_le32(OCFS2_BITMAP_FL)) { 280 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP; 281 } else if (fe->i_flags & cpu_to_le32(OCFS2_SUPER_BLOCK_FL)) { 282 mlog(0, "superblock inode: i_ino=%lu\n", inode->i_ino); 283 /* we can't actually hit this as read_inode can't 284 * handle superblocks today ;-) */ 285 BUG(); 286 } 287 288 switch (inode->i_mode & S_IFMT) { 289 case S_IFREG: 290 inode->i_fop = &ocfs2_fops; 291 inode->i_op = &ocfs2_file_iops; 292 i_size_write(inode, le64_to_cpu(fe->i_size)); 293 break; 294 case S_IFDIR: 295 inode->i_op = &ocfs2_dir_iops; 296 inode->i_fop = &ocfs2_dops; 297 i_size_write(inode, le64_to_cpu(fe->i_size)); 298 break; 299 case S_IFLNK: 300 if (ocfs2_inode_is_fast_symlink(inode)) 301 inode->i_op = &ocfs2_fast_symlink_inode_operations; 302 else 303 inode->i_op = &ocfs2_symlink_inode_operations; 304 i_size_write(inode, le64_to_cpu(fe->i_size)); 305 break; 306 default: 307 inode->i_op = &ocfs2_special_file_iops; 308 init_special_inode(inode, inode->i_mode, 309 inode->i_rdev); 310 break; 311 } 312 313 if (create_ino) { 314 inode->i_ino = ino_from_blkno(inode->i_sb, 315 le64_to_cpu(fe->i_blkno)); 316 317 /* 318 * If we ever want to create system files from kernel, 319 * the generation argument to 320 * ocfs2_inode_lock_res_init() will have to change. 321 */ 322 BUG_ON(le32_to_cpu(fe->i_flags) & OCFS2_SYSTEM_FL); 323 324 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres, 325 OCFS2_LOCK_TYPE_META, 0, inode); 326 327 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres, 328 OCFS2_LOCK_TYPE_OPEN, 0, inode); 329 } 330 331 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres, 332 OCFS2_LOCK_TYPE_RW, inode->i_generation, 333 inode); 334 335 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_data_lockres, 336 OCFS2_LOCK_TYPE_DATA, inode->i_generation, 337 inode); 338 339 ocfs2_set_inode_flags(inode); 340 341 status = 0; 342bail: 343 mlog_exit(status); 344 return status; 345} 346 347static int ocfs2_read_locked_inode(struct inode *inode, 348 struct ocfs2_find_inode_args *args) 349{ 350 struct super_block *sb; 351 struct ocfs2_super *osb; 352 struct ocfs2_dinode *fe; 353 struct buffer_head *bh = NULL; 354 int status, can_lock; 355 u32 generation = 0; 356 357 mlog_entry("(0x%p, 0x%p)\n", inode, args); 358 359 status = -EINVAL; 360 if (inode == NULL || inode->i_sb == NULL) { 361 mlog(ML_ERROR, "bad inode\n"); 362 return status; 363 } 364 sb = inode->i_sb; 365 osb = OCFS2_SB(sb); 366 367 if (!args) { 368 mlog(ML_ERROR, "bad inode args\n"); 369 make_bad_inode(inode); 370 return status; 371 } 372 373 /* 374 * To improve performance of cold-cache inode stats, we take 375 * the cluster lock here if possible. 376 * 377 * Generally, OCFS2 never trusts the contents of an inode 378 * unless it's holding a cluster lock, so taking it here isn't 379 * a correctness issue as much as it is a performance 380 * improvement. 381 * 382 * There are three times when taking the lock is not a good idea: 383 * 384 * 1) During startup, before we have initialized the DLM. 385 * 386 * 2) If we are reading certain system files which never get 387 * cluster locks (local alloc, truncate log). 388 * 389 * 3) If the process doing the iget() is responsible for 390 * orphan dir recovery. We're holding the orphan dir lock and 391 * can get into a deadlock with another process on another 392 * node in ->delete_inode(). 393 * 394 * #1 and #2 can be simply solved by never taking the lock 395 * here for system files (which are the only type we read 396 * during mount). It's a heavier approach, but our main 397 * concern is user-accesible files anyway. 398 * 399 * #3 works itself out because we'll eventually take the 400 * cluster lock before trusting anything anyway. 401 */ 402 can_lock = !(args->fi_flags & OCFS2_FI_FLAG_SYSFILE) 403 && !(args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) 404 && !ocfs2_mount_local(osb); 405 406 /* 407 * To maintain backwards compatibility with older versions of 408 * ocfs2-tools, we still store the generation value for system 409 * files. The only ones that actually matter to userspace are 410 * the journals, but it's easier and inexpensive to just flag 411 * all system files similarly. 412 */ 413 if (args->fi_flags & OCFS2_FI_FLAG_SYSFILE) 414 generation = osb->fs_generation; 415 416 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_meta_lockres, 417 OCFS2_LOCK_TYPE_META, 418 generation, inode); 419 420 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres, 421 OCFS2_LOCK_TYPE_OPEN, 422 0, inode); 423 424 if (can_lock) { 425 status = ocfs2_open_lock(inode); 426 if (status) { 427 make_bad_inode(inode); 428 mlog_errno(status); 429 return status; 430 } 431 status = ocfs2_meta_lock(inode, NULL, 0); 432 if (status) { 433 make_bad_inode(inode); 434 mlog_errno(status); 435 return status; 436 } 437 } 438 439 if (args->fi_flags & OCFS2_FI_FLAG_ORPHAN_RECOVERY) { 440 status = ocfs2_try_open_lock(inode, 0); 441 if (status) { 442 make_bad_inode(inode); 443 return status; 444 } 445 } 446 447 status = ocfs2_read_block(osb, args->fi_blkno, &bh, 0, 448 can_lock ? inode : NULL); 449 if (status < 0) { 450 mlog_errno(status); 451 goto bail; 452 } 453 454 status = -EINVAL; 455 fe = (struct ocfs2_dinode *) bh->b_data; 456 if (!OCFS2_IS_VALID_DINODE(fe)) { 457 mlog(ML_ERROR, "Invalid dinode #%llu: signature = %.*s\n", 458 (unsigned long long)le64_to_cpu(fe->i_blkno), 7, 459 fe->i_signature); 460 goto bail; 461 } 462 463 /* 464 * This is a code bug. Right now the caller needs to 465 * understand whether it is asking for a system file inode or 466 * not so the proper lock names can be built. 467 */ 468 mlog_bug_on_msg(!!(fe->i_flags & cpu_to_le32(OCFS2_SYSTEM_FL)) != 469 !!(args->fi_flags & OCFS2_FI_FLAG_SYSFILE), 470 "Inode %llu: system file state is ambigous\n", 471 (unsigned long long)args->fi_blkno); 472 473 if (S_ISCHR(le16_to_cpu(fe->i_mode)) || 474 S_ISBLK(le16_to_cpu(fe->i_mode))) 475 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev)); 476 477 if (ocfs2_populate_inode(inode, fe, 0) < 0) 478 goto bail; 479 480 BUG_ON(args->fi_blkno != le64_to_cpu(fe->i_blkno)); 481 482 status = 0; 483 484bail: 485 if (can_lock) 486 ocfs2_meta_unlock(inode, 0); 487 488 if (status < 0) 489 make_bad_inode(inode); 490 491 if (args && bh) 492 brelse(bh); 493 494 mlog_exit(status); 495 return status; 496} 497 498void ocfs2_sync_blockdev(struct super_block *sb) 499{ 500 sync_blockdev(sb->s_bdev); 501} 502 503static int ocfs2_truncate_for_delete(struct ocfs2_super *osb, 504 struct inode *inode, 505 struct buffer_head *fe_bh) 506{ 507 int status = 0; 508 struct ocfs2_truncate_context *tc = NULL; 509 struct ocfs2_dinode *fe; 510 handle_t *handle = NULL; 511 512 mlog_entry_void(); 513 514 fe = (struct ocfs2_dinode *) fe_bh->b_data; 515 516 if (fe->i_clusters) { 517 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 518 if (IS_ERR(handle)) { 519 status = PTR_ERR(handle); 520 mlog_errno(status); 521 goto out; 522 } 523 524 status = ocfs2_journal_access(handle, inode, fe_bh, 525 OCFS2_JOURNAL_ACCESS_WRITE); 526 if (status < 0) { 527 mlog_errno(status); 528 goto out; 529 } 530 531 i_size_write(inode, 0); 532 533 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh); 534 if (status < 0) { 535 mlog_errno(status); 536 goto out; 537 } 538 539 ocfs2_commit_trans(osb, handle); 540 handle = NULL; 541 542 status = ocfs2_prepare_truncate(osb, inode, fe_bh, &tc); 543 if (status < 0) { 544 mlog_errno(status); 545 goto out; 546 } 547 548 status = ocfs2_commit_truncate(osb, inode, fe_bh, tc); 549 if (status < 0) { 550 mlog_errno(status); 551 goto out; 552 } 553 } 554 555out: 556 if (handle) 557 ocfs2_commit_trans(osb, handle); 558 mlog_exit(status); 559 return status; 560} 561 562static int ocfs2_remove_inode(struct inode *inode, 563 struct buffer_head *di_bh, 564 struct inode *orphan_dir_inode, 565 struct buffer_head *orphan_dir_bh) 566{ 567 int status; 568 struct inode *inode_alloc_inode = NULL; 569 struct buffer_head *inode_alloc_bh = NULL; 570 handle_t *handle; 571 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 572 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 573 574 inode_alloc_inode = 575 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE, 576 le16_to_cpu(di->i_suballoc_slot)); 577 if (!inode_alloc_inode) { 578 status = -EEXIST; 579 mlog_errno(status); 580 goto bail; 581 } 582 583 mutex_lock(&inode_alloc_inode->i_mutex); 584 status = ocfs2_meta_lock(inode_alloc_inode, &inode_alloc_bh, 1); 585 if (status < 0) { 586 mutex_unlock(&inode_alloc_inode->i_mutex); 587 588 mlog_errno(status); 589 goto bail; 590 } 591 592 handle = ocfs2_start_trans(osb, OCFS2_DELETE_INODE_CREDITS); 593 if (IS_ERR(handle)) { 594 status = PTR_ERR(handle); 595 mlog_errno(status); 596 goto bail_unlock; 597 } 598 599 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode, 600 orphan_dir_bh); 601 if (status < 0) { 602 mlog_errno(status); 603 goto bail_commit; 604 } 605 606 /* set the inodes dtime */ 607 status = ocfs2_journal_access(handle, inode, di_bh, 608 OCFS2_JOURNAL_ACCESS_WRITE); 609 if (status < 0) { 610 mlog_errno(status); 611 goto bail_commit; 612 } 613 614 di->i_dtime = cpu_to_le64(CURRENT_TIME.tv_sec); 615 le32_and_cpu(&di->i_flags, ~(OCFS2_VALID_FL | OCFS2_ORPHANED_FL)); 616 617 status = ocfs2_journal_dirty(handle, di_bh); 618 if (status < 0) { 619 mlog_errno(status); 620 goto bail_commit; 621 } 622 623 ocfs2_remove_from_cache(inode, di_bh); 624 625 status = ocfs2_free_dinode(handle, inode_alloc_inode, 626 inode_alloc_bh, di); 627 if (status < 0) 628 mlog_errno(status); 629 630bail_commit: 631 ocfs2_commit_trans(osb, handle); 632bail_unlock: 633 ocfs2_meta_unlock(inode_alloc_inode, 1); 634 mutex_unlock(&inode_alloc_inode->i_mutex); 635 brelse(inode_alloc_bh); 636bail: 637 iput(inode_alloc_inode); 638 639 return status; 640} 641 642/* 643 * Serialize with orphan dir recovery. If the process doing 644 * recovery on this orphan dir does an iget() with the dir 645 * i_mutex held, we'll deadlock here. Instead we detect this 646 * and exit early - recovery will wipe this inode for us. 647 */ 648static int ocfs2_check_orphan_recovery_state(struct ocfs2_super *osb, 649 int slot) 650{ 651 int ret = 0; 652 653 spin_lock(&osb->osb_lock); 654 if (ocfs2_node_map_test_bit(osb, &osb->osb_recovering_orphan_dirs, slot)) { 655 mlog(0, "Recovery is happening on orphan dir %d, will skip " 656 "this inode\n", slot); 657 ret = -EDEADLK; 658 goto out; 659 } 660 /* This signals to the orphan recovery process that it should 661 * wait for us to handle the wipe. */ 662 osb->osb_orphan_wipes[slot]++; 663out: 664 spin_unlock(&osb->osb_lock); 665 return ret; 666} 667 668static void ocfs2_signal_wipe_completion(struct ocfs2_super *osb, 669 int slot) 670{ 671 spin_lock(&osb->osb_lock); 672 osb->osb_orphan_wipes[slot]--; 673 spin_unlock(&osb->osb_lock); 674 675 wake_up(&osb->osb_wipe_event); 676} 677 678static int ocfs2_wipe_inode(struct inode *inode, 679 struct buffer_head *di_bh) 680{ 681 int status, orphaned_slot; 682 struct inode *orphan_dir_inode = NULL; 683 struct buffer_head *orphan_dir_bh = NULL; 684 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 685 struct ocfs2_dinode *di; 686 687 di = (struct ocfs2_dinode *) di_bh->b_data; 688 orphaned_slot = le16_to_cpu(di->i_orphaned_slot); 689 690 status = ocfs2_check_orphan_recovery_state(osb, orphaned_slot); 691 if (status) 692 return status; 693 694 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 695 ORPHAN_DIR_SYSTEM_INODE, 696 orphaned_slot); 697 if (!orphan_dir_inode) { 698 status = -EEXIST; 699 mlog_errno(status); 700 goto bail; 701 } 702 703 /* Lock the orphan dir. The lock will be held for the entire 704 * delete_inode operation. We do this now to avoid races with 705 * recovery completion on other nodes. */ 706 mutex_lock(&orphan_dir_inode->i_mutex); 707 status = ocfs2_meta_lock(orphan_dir_inode, &orphan_dir_bh, 1); 708 if (status < 0) { 709 mutex_unlock(&orphan_dir_inode->i_mutex); 710 711 mlog_errno(status); 712 goto bail; 713 } 714 715 /* we do this while holding the orphan dir lock because we 716 * don't want recovery being run from another node to vote for 717 * an inode delete on us -- this will result in two nodes 718 * truncating the same file! */ 719 status = ocfs2_truncate_for_delete(osb, inode, di_bh); 720 if (status < 0) { 721 mlog_errno(status); 722 goto bail_unlock_dir; 723 } 724 725 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode, 726 orphan_dir_bh); 727 if (status < 0) 728 mlog_errno(status); 729 730bail_unlock_dir: 731 ocfs2_meta_unlock(orphan_dir_inode, 1); 732 mutex_unlock(&orphan_dir_inode->i_mutex); 733 brelse(orphan_dir_bh); 734bail: 735 iput(orphan_dir_inode); 736 ocfs2_signal_wipe_completion(osb, orphaned_slot); 737 738 return status; 739} 740 741/* There is a series of simple checks that should be done before a 742 * vote is even considered. Encapsulate those in this function. */ 743static int ocfs2_inode_is_valid_to_delete(struct inode *inode) 744{ 745 int ret = 0; 746 struct ocfs2_inode_info *oi = OCFS2_I(inode); 747 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 748 749 /* We shouldn't be getting here for the root directory 750 * inode.. */ 751 if (inode == osb->root_inode) { 752 mlog(ML_ERROR, "Skipping delete of root inode.\n"); 753 goto bail; 754 } 755 756 /* If we're coming from process_vote we can't go into our own 757 * voting [hello, deadlock city!], so unforuntately we just 758 * have to skip deleting this guy. That's OK though because 759 * the node who's doing the actual deleting should handle it 760 * anyway. */ 761 if (current == osb->vote_task) { 762 mlog(0, "Skipping delete of %lu because we're currently " 763 "in process_vote\n", inode->i_ino); 764 goto bail; 765 } 766 767 spin_lock(&oi->ip_lock); 768 /* OCFS2 *never* deletes system files. This should technically 769 * never get here as system file inodes should always have a 770 * positive link count. */ 771 if (oi->ip_flags & OCFS2_INODE_SYSTEM_FILE) { 772 mlog(ML_ERROR, "Skipping delete of system file %llu\n", 773 (unsigned long long)oi->ip_blkno); 774 goto bail_unlock; 775 } 776 777 /* If we have voted "yes" on the wipe of this inode for 778 * another node, it will be marked here so we can safely skip 779 * it. Recovery will cleanup any inodes we might inadvertantly 780 * skip here. */ 781 if (oi->ip_flags & OCFS2_INODE_SKIP_DELETE) { 782 mlog(0, "Skipping delete of %lu because another node " 783 "has done this for us.\n", inode->i_ino); 784 goto bail_unlock; 785 } 786 787 ret = 1; 788bail_unlock: 789 spin_unlock(&oi->ip_lock); 790bail: 791 return ret; 792} 793 794/* Query the cluster to determine whether we should wipe an inode from 795 * disk or not. 796 * 797 * Requires the inode to have the cluster lock. */ 798static int ocfs2_query_inode_wipe(struct inode *inode, 799 struct buffer_head *di_bh, 800 int *wipe) 801{ 802 int status = 0; 803 struct ocfs2_inode_info *oi = OCFS2_I(inode); 804 struct ocfs2_dinode *di; 805 806 *wipe = 0; 807 808 /* While we were waiting for the cluster lock in 809 * ocfs2_delete_inode, another node might have asked to delete 810 * the inode. Recheck our flags to catch this. */ 811 if (!ocfs2_inode_is_valid_to_delete(inode)) { 812 mlog(0, "Skipping delete of %llu because flags changed\n", 813 (unsigned long long)oi->ip_blkno); 814 goto bail; 815 } 816 817 /* Now that we have an up to date inode, we can double check 818 * the link count. */ 819 if (inode->i_nlink) { 820 mlog(0, "Skipping delete of %llu because nlink = %u\n", 821 (unsigned long long)oi->ip_blkno, inode->i_nlink); 822 goto bail; 823 } 824 825 /* Do some basic inode verification... */ 826 di = (struct ocfs2_dinode *) di_bh->b_data; 827 if (!(di->i_flags & cpu_to_le32(OCFS2_ORPHANED_FL))) { 828 /* for lack of a better error? */ 829 status = -EEXIST; 830 mlog(ML_ERROR, 831 "Inode %llu (on-disk %llu) not orphaned! " 832 "Disk flags 0x%x, inode flags 0x%x\n", 833 (unsigned long long)oi->ip_blkno, 834 (unsigned long long)le64_to_cpu(di->i_blkno), 835 le32_to_cpu(di->i_flags), oi->ip_flags); 836 goto bail; 837 } 838 839 /* has someone already deleted us?! baaad... */ 840 if (di->i_dtime) { 841 status = -EEXIST; 842 mlog_errno(status); 843 goto bail; 844 } 845 846 /* 847 * This is how ocfs2 determines whether an inode is still live 848 * within the cluster. Every node takes a shared read lock on 849 * the inode open lock in ocfs2_read_locked_inode(). When we 850 * get to ->delete_inode(), each node tries to convert it's 851 * lock to an exclusive. Trylocks are serialized by the inode 852 * meta data lock. If the upconvert suceeds, we know the inode 853 * is no longer live and can be deleted. 854 * 855 * Though we call this with the meta data lock held, the 856 * trylock keeps us from ABBA deadlock. 857 */ 858 status = ocfs2_try_open_lock(inode, 1); 859 if (status == -EAGAIN) { 860 status = 0; 861 mlog(0, "Skipping delete of %llu because it is in use on" 862 "other nodes\n", (unsigned long long)oi->ip_blkno); 863 goto bail; 864 } 865 if (status < 0) { 866 mlog_errno(status); 867 goto bail; 868 } 869 870 *wipe = 1; 871 mlog(0, "Inode %llu is ok to wipe from orphan dir %u\n", 872 (unsigned long long)oi->ip_blkno, 873 le16_to_cpu(di->i_orphaned_slot)); 874 875bail: 876 return status; 877} 878 879/* Support function for ocfs2_delete_inode. Will help us keep the 880 * inode data in a consistent state for clear_inode. Always truncates 881 * pages, optionally sync's them first. */ 882static void ocfs2_cleanup_delete_inode(struct inode *inode, 883 int sync_data) 884{ 885 mlog(0, "Cleanup inode %llu, sync = %d\n", 886 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data); 887 if (sync_data) 888 write_inode_now(inode, 1); 889 truncate_inode_pages(&inode->i_data, 0); 890} 891 892void ocfs2_delete_inode(struct inode *inode) 893{ 894 int wipe, status; 895 sigset_t blocked, oldset; 896 struct buffer_head *di_bh = NULL; 897 898 mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino); 899 900 if (is_bad_inode(inode)) { 901 mlog(0, "Skipping delete of bad inode\n"); 902 goto bail; 903 } 904 905 if (!ocfs2_inode_is_valid_to_delete(inode)) { 906 /* It's probably not necessary to truncate_inode_pages 907 * here but we do it for safety anyway (it will most 908 * likely be a no-op anyway) */ 909 ocfs2_cleanup_delete_inode(inode, 0); 910 goto bail; 911 } 912 913 /* We want to block signals in delete_inode as the lock and 914 * messaging paths may return us -ERESTARTSYS. Which would 915 * cause us to exit early, resulting in inodes being orphaned 916 * forever. */ 917 sigfillset(&blocked); 918 status = sigprocmask(SIG_BLOCK, &blocked, &oldset); 919 if (status < 0) { 920 mlog_errno(status); 921 ocfs2_cleanup_delete_inode(inode, 1); 922 goto bail; 923 } 924 925 /* Lock down the inode. This gives us an up to date view of 926 * it's metadata (for verification), and allows us to 927 * serialize delete_inode votes. 928 * 929 * Even though we might be doing a truncate, we don't take the 930 * allocation lock here as it won't be needed - nobody will 931 * have the file open. 932 */ 933 status = ocfs2_meta_lock(inode, &di_bh, 1); 934 if (status < 0) { 935 if (status != -ENOENT) 936 mlog_errno(status); 937 ocfs2_cleanup_delete_inode(inode, 0); 938 goto bail_unblock; 939 } 940 941 /* Query the cluster. This will be the final decision made 942 * before we go ahead and wipe the inode. */ 943 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe); 944 if (!wipe || status < 0) { 945 /* Error and inode busy vote both mean we won't be 946 * removing the inode, so they take almost the same 947 * path. */ 948 if (status < 0) 949 mlog_errno(status); 950 951 /* Someone in the cluster has voted to not wipe this 952 * inode, or it was never completely orphaned. Write 953 * out the pages and exit now. */ 954 ocfs2_cleanup_delete_inode(inode, 1); 955 goto bail_unlock_inode; 956 } 957 958 ocfs2_cleanup_delete_inode(inode, 0); 959 960 status = ocfs2_wipe_inode(inode, di_bh); 961 if (status < 0) { 962 if (status != -EDEADLK) 963 mlog_errno(status); 964 goto bail_unlock_inode; 965 } 966 967 /* 968 * Mark the inode as successfully deleted. 969 * 970 * This is important for ocfs2_clear_inode() as it will check 971 * this flag and skip any checkpointing work 972 * 973 * ocfs2_stuff_meta_lvb() also uses this flag to invalidate 974 * the LVB for other nodes. 975 */ 976 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED; 977 978bail_unlock_inode: 979 ocfs2_meta_unlock(inode, 1); 980 brelse(di_bh); 981bail_unblock: 982 status = sigprocmask(SIG_SETMASK, &oldset, NULL); 983 if (status < 0) 984 mlog_errno(status); 985bail: 986 clear_inode(inode); 987 mlog_exit_void(); 988} 989 990void ocfs2_clear_inode(struct inode *inode) 991{ 992 int status; 993 struct ocfs2_inode_info *oi = OCFS2_I(inode); 994 995 mlog_entry_void(); 996 997 if (!inode) 998 goto bail; 999 1000 mlog(0, "Clearing inode: %llu, nlink = %u\n", 1001 (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_nlink); 1002 1003 mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL, 1004 "Inode=%lu\n", inode->i_ino); 1005 1006 /* For remove delete_inode vote, we hold open lock before, 1007 * now it is time to unlock PR and EX open locks. */ 1008 ocfs2_open_unlock(inode); 1009 1010 /* Do these before all the other work so that we don't bounce 1011 * the vote thread while waiting to destroy the locks. */ 1012 ocfs2_mark_lockres_freeing(&oi->ip_rw_lockres); 1013 ocfs2_mark_lockres_freeing(&oi->ip_meta_lockres); 1014 ocfs2_mark_lockres_freeing(&oi->ip_data_lockres); 1015 ocfs2_mark_lockres_freeing(&oi->ip_open_lockres); 1016 1017 /* We very well may get a clear_inode before all an inodes 1018 * metadata has hit disk. Of course, we can't drop any cluster 1019 * locks until the journal has finished with it. The only 1020 * exception here are successfully wiped inodes - their 1021 * metadata can now be considered to be part of the system 1022 * inodes from which it came. */ 1023 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED)) 1024 ocfs2_checkpoint_inode(inode); 1025 1026 mlog_bug_on_msg(!list_empty(&oi->ip_io_markers), 1027 "Clear inode of %llu, inode has io markers\n", 1028 (unsigned long long)oi->ip_blkno); 1029 1030 ocfs2_extent_map_trunc(inode, 0); 1031 1032 status = ocfs2_drop_inode_locks(inode); 1033 if (status < 0) 1034 mlog_errno(status); 1035 1036 ocfs2_lock_res_free(&oi->ip_rw_lockres); 1037 ocfs2_lock_res_free(&oi->ip_meta_lockres); 1038 ocfs2_lock_res_free(&oi->ip_data_lockres); 1039 ocfs2_lock_res_free(&oi->ip_open_lockres); 1040 1041 ocfs2_metadata_cache_purge(inode); 1042 1043 mlog_bug_on_msg(oi->ip_metadata_cache.ci_num_cached, 1044 "Clear inode of %llu, inode has %u cache items\n", 1045 (unsigned long long)oi->ip_blkno, oi->ip_metadata_cache.ci_num_cached); 1046 1047 mlog_bug_on_msg(!(oi->ip_flags & OCFS2_INODE_CACHE_INLINE), 1048 "Clear inode of %llu, inode has a bad flag\n", 1049 (unsigned long long)oi->ip_blkno); 1050 1051 mlog_bug_on_msg(spin_is_locked(&oi->ip_lock), 1052 "Clear inode of %llu, inode is locked\n", 1053 (unsigned long long)oi->ip_blkno); 1054 1055 mlog_bug_on_msg(!mutex_trylock(&oi->ip_io_mutex), 1056 "Clear inode of %llu, io_mutex is locked\n", 1057 (unsigned long long)oi->ip_blkno); 1058 mutex_unlock(&oi->ip_io_mutex); 1059 1060 /* 1061 * down_trylock() returns 0, down_write_trylock() returns 1 1062 * kernel 1, world 0 1063 */ 1064 mlog_bug_on_msg(!down_write_trylock(&oi->ip_alloc_sem), 1065 "Clear inode of %llu, alloc_sem is locked\n", 1066 (unsigned long long)oi->ip_blkno); 1067 up_write(&oi->ip_alloc_sem); 1068 1069 mlog_bug_on_msg(oi->ip_open_count, 1070 "Clear inode of %llu has open count %d\n", 1071 (unsigned long long)oi->ip_blkno, oi->ip_open_count); 1072 1073 /* Clear all other flags. */ 1074 oi->ip_flags = OCFS2_INODE_CACHE_INLINE; 1075 oi->ip_created_trans = 0; 1076 oi->ip_last_trans = 0; 1077 oi->ip_dir_start_lookup = 0; 1078 oi->ip_blkno = 0ULL; 1079 1080bail: 1081 mlog_exit_void(); 1082} 1083 1084/* Called under inode_lock, with no more references on the 1085 * struct inode, so it's safe here to check the flags field 1086 * and to manipulate i_nlink without any other locks. */ 1087void ocfs2_drop_inode(struct inode *inode) 1088{ 1089 struct ocfs2_inode_info *oi = OCFS2_I(inode); 1090 1091 mlog_entry_void(); 1092 1093 mlog(0, "Drop inode %llu, nlink = %u, ip_flags = 0x%x\n", 1094 (unsigned long long)oi->ip_blkno, inode->i_nlink, oi->ip_flags); 1095 1096 if (oi->ip_flags & OCFS2_INODE_MAYBE_ORPHANED) 1097 generic_delete_inode(inode); 1098 else 1099 generic_drop_inode(inode); 1100 1101 mlog_exit_void(); 1102} 1103 1104/* 1105 * TODO: this should probably be merged into ocfs2_get_block 1106 * 1107 * However, you now need to pay attention to the cont_prepare_write() 1108 * stuff in ocfs2_get_block (that is, ocfs2_get_block pretty much 1109 * expects never to extend). 1110 */ 1111struct buffer_head *ocfs2_bread(struct inode *inode, 1112 int block, int *err, int reada) 1113{ 1114 struct buffer_head *bh = NULL; 1115 int tmperr; 1116 u64 p_blkno; 1117 int readflags = OCFS2_BH_CACHED; 1118 1119 if (reada) 1120 readflags |= OCFS2_BH_READAHEAD; 1121 1122 if (((u64)block << inode->i_sb->s_blocksize_bits) >= 1123 i_size_read(inode)) { 1124 BUG_ON(!reada); 1125 return NULL; 1126 } 1127 1128 down_read(&OCFS2_I(inode)->ip_alloc_sem); 1129 tmperr = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL, 1130 NULL); 1131 up_read(&OCFS2_I(inode)->ip_alloc_sem); 1132 if (tmperr < 0) { 1133 mlog_errno(tmperr); 1134 goto fail; 1135 } 1136 1137 tmperr = ocfs2_read_block(OCFS2_SB(inode->i_sb), p_blkno, &bh, 1138 readflags, inode); 1139 if (tmperr < 0) 1140 goto fail; 1141 1142 tmperr = 0; 1143 1144 *err = 0; 1145 return bh; 1146 1147fail: 1148 if (bh) { 1149 brelse(bh); 1150 bh = NULL; 1151 } 1152 *err = -EIO; 1153 return NULL; 1154} 1155 1156/* 1157 * This is called from our getattr. 1158 */ 1159int ocfs2_inode_revalidate(struct dentry *dentry) 1160{ 1161 struct inode *inode = dentry->d_inode; 1162 int status = 0; 1163 1164 mlog_entry("(inode = 0x%p, ino = %llu)\n", inode, 1165 inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL); 1166 1167 if (!inode) { 1168 mlog(0, "eep, no inode!\n"); 1169 status = -ENOENT; 1170 goto bail; 1171 } 1172 1173 spin_lock(&OCFS2_I(inode)->ip_lock); 1174 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) { 1175 spin_unlock(&OCFS2_I(inode)->ip_lock); 1176 mlog(0, "inode deleted!\n"); 1177 status = -ENOENT; 1178 goto bail; 1179 } 1180 spin_unlock(&OCFS2_I(inode)->ip_lock); 1181 1182 /* Let ocfs2_meta_lock do the work of updating our struct 1183 * inode for us. */ 1184 status = ocfs2_meta_lock(inode, NULL, 0); 1185 if (status < 0) { 1186 if (status != -ENOENT) 1187 mlog_errno(status); 1188 goto bail; 1189 } 1190 ocfs2_meta_unlock(inode, 0); 1191bail: 1192 mlog_exit(status); 1193 1194 return status; 1195} 1196 1197/* 1198 * Updates a disk inode from a 1199 * struct inode. 1200 * Only takes ip_lock. 1201 */ 1202int ocfs2_mark_inode_dirty(handle_t *handle, 1203 struct inode *inode, 1204 struct buffer_head *bh) 1205{ 1206 int status; 1207 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data; 1208 1209 mlog_entry("(inode %llu)\n", 1210 (unsigned long long)OCFS2_I(inode)->ip_blkno); 1211 1212 status = ocfs2_journal_access(handle, inode, bh, 1213 OCFS2_JOURNAL_ACCESS_WRITE); 1214 if (status < 0) { 1215 mlog_errno(status); 1216 goto leave; 1217 } 1218 1219 spin_lock(&OCFS2_I(inode)->ip_lock); 1220 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters); 1221 ocfs2_get_inode_flags(OCFS2_I(inode)); 1222 fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr); 1223 spin_unlock(&OCFS2_I(inode)->ip_lock); 1224 1225 fe->i_size = cpu_to_le64(i_size_read(inode)); 1226 fe->i_links_count = cpu_to_le16(inode->i_nlink); 1227 fe->i_uid = cpu_to_le32(inode->i_uid); 1228 fe->i_gid = cpu_to_le32(inode->i_gid); 1229 fe->i_mode = cpu_to_le16(inode->i_mode); 1230 fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec); 1231 fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); 1232 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 1233 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 1234 fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 1235 fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 1236 1237 status = ocfs2_journal_dirty(handle, bh); 1238 if (status < 0) 1239 mlog_errno(status); 1240 1241 status = 0; 1242leave: 1243 1244 mlog_exit(status); 1245 return status; 1246} 1247 1248/* 1249 * 1250 * Updates a struct inode from a disk inode. 1251 * does no i/o, only takes ip_lock. 1252 */ 1253void ocfs2_refresh_inode(struct inode *inode, 1254 struct ocfs2_dinode *fe) 1255{ 1256 spin_lock(&OCFS2_I(inode)->ip_lock); 1257 1258 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 1259 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr); 1260 ocfs2_set_inode_flags(inode); 1261 i_size_write(inode, le64_to_cpu(fe->i_size)); 1262 inode->i_nlink = le16_to_cpu(fe->i_links_count); 1263 inode->i_uid = le32_to_cpu(fe->i_uid); 1264 inode->i_gid = le32_to_cpu(fe->i_gid); 1265 inode->i_mode = le16_to_cpu(fe->i_mode); 1266 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0) 1267 inode->i_blocks = 0; 1268 else 1269 inode->i_blocks = ocfs2_inode_sector_count(inode); 1270 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime); 1271 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec); 1272 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime); 1273 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec); 1274 inode->i_ctime.tv_sec = le64_to_cpu(fe->i_ctime); 1275 inode->i_ctime.tv_nsec = le32_to_cpu(fe->i_ctime_nsec); 1276 1277 spin_unlock(&OCFS2_I(inode)->ip_lock); 1278} 1279