~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ocfs2/inode.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
1662 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp