fs/ocfs2/inode.c

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