fs/ocfs2/inode.c

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