645 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.4 * All Rights Reserved.5 */6#ifndef __XFS_INODE_H__7#define __XFS_INODE_H__8 9#include "xfs_inode_buf.h"10#include "xfs_inode_fork.h"11#include "xfs_inode_util.h"12 13/*14 * Kernel only inode definitions15 */16struct xfs_dinode;17struct xfs_inode;18struct xfs_buf;19struct xfs_bmbt_irec;20struct xfs_inode_log_item;21struct xfs_mount;22struct xfs_trans;23struct xfs_dquot;24 25typedef struct xfs_inode {26 /* Inode linking and identification information. */27 struct xfs_mount *i_mount; /* fs mount struct ptr */28 struct xfs_dquot *i_udquot; /* user dquot */29 struct xfs_dquot *i_gdquot; /* group dquot */30 struct xfs_dquot *i_pdquot; /* project dquot */31 32 /* Inode location stuff */33 xfs_ino_t i_ino; /* inode number (agno/agino)*/34 struct xfs_imap i_imap; /* location for xfs_imap() */35 36 /* Extent information. */37 struct xfs_ifork *i_cowfp; /* copy on write extents */38 struct xfs_ifork i_df; /* data fork */39 struct xfs_ifork i_af; /* attribute fork */40 41 /* Transaction and locking information. */42 struct xfs_inode_log_item *i_itemp; /* logging information */43 struct rw_semaphore i_lock; /* inode lock */44 atomic_t i_pincount; /* inode pin count */45 struct llist_node i_gclist; /* deferred inactivation list */46 47 /*48 * Bitsets of inode metadata that have been checked and/or are sick.49 * Callers must hold i_flags_lock before accessing this field.50 */51 uint16_t i_checked;52 uint16_t i_sick;53 54 spinlock_t i_flags_lock; /* inode i_flags lock */55 /* Miscellaneous state. */56 unsigned long i_flags; /* see defined flags below */57 uint64_t i_delayed_blks; /* count of delay alloc blks */58 xfs_fsize_t i_disk_size; /* number of bytes in file */59 xfs_rfsblock_t i_nblocks; /* # of direct & btree blocks */60 prid_t i_projid; /* owner's project id */61 xfs_extlen_t i_extsize; /* basic/minimum extent size */62 /* cowextsize is only used for v3 inodes, flushiter for v1/2 */63 union {64 xfs_extlen_t i_cowextsize; /* basic cow extent size */65 uint16_t i_flushiter; /* incremented on flush */66 };67 uint8_t i_forkoff; /* attr fork offset >> 3 */68 uint16_t i_diflags; /* XFS_DIFLAG_... */69 uint64_t i_diflags2; /* XFS_DIFLAG2_... */70 struct timespec64 i_crtime; /* time created */71 72 /*73 * Unlinked list pointers. These point to the next and previous inodes74 * in the AGI unlinked bucket list, respectively. These fields can75 * only be updated with the AGI locked.76 *77 * i_next_unlinked caches di_next_unlinked.78 */79 xfs_agino_t i_next_unlinked;80 81 /*82 * If the inode is not on an unlinked list, this field is zero. If the83 * inode is the first element in an unlinked list, this field is84 * NULLAGINO. Otherwise, i_prev_unlinked points to the previous inode85 * in the unlinked list.86 */87 xfs_agino_t i_prev_unlinked;88 89 /* VFS inode */90 struct inode i_vnode; /* embedded VFS inode */91 92 /* pending io completions */93 spinlock_t i_ioend_lock;94 struct work_struct i_ioend_work;95 struct list_head i_ioend_list;96} xfs_inode_t;97 98static inline bool xfs_inode_on_unlinked_list(const struct xfs_inode *ip)99{100 return ip->i_prev_unlinked != 0;101}102 103static inline bool xfs_inode_has_attr_fork(struct xfs_inode *ip)104{105 return ip->i_forkoff > 0;106}107 108static inline struct xfs_ifork *109xfs_ifork_ptr(110 struct xfs_inode *ip,111 int whichfork)112{113 switch (whichfork) {114 case XFS_DATA_FORK:115 return &ip->i_df;116 case XFS_ATTR_FORK:117 if (!xfs_inode_has_attr_fork(ip))118 return NULL;119 return &ip->i_af;120 case XFS_COW_FORK:121 return ip->i_cowfp;122 default:123 ASSERT(0);124 return NULL;125 }126}127 128static inline unsigned int xfs_inode_fork_boff(struct xfs_inode *ip)129{130 return ip->i_forkoff << 3;131}132 133static inline unsigned int xfs_inode_data_fork_size(struct xfs_inode *ip)134{135 if (xfs_inode_has_attr_fork(ip))136 return xfs_inode_fork_boff(ip);137 138 return XFS_LITINO(ip->i_mount);139}140 141static inline unsigned int xfs_inode_attr_fork_size(struct xfs_inode *ip)142{143 if (xfs_inode_has_attr_fork(ip))144 return XFS_LITINO(ip->i_mount) - xfs_inode_fork_boff(ip);145 return 0;146}147 148static inline unsigned int149xfs_inode_fork_size(150 struct xfs_inode *ip,151 int whichfork)152{153 switch (whichfork) {154 case XFS_DATA_FORK:155 return xfs_inode_data_fork_size(ip);156 case XFS_ATTR_FORK:157 return xfs_inode_attr_fork_size(ip);158 default:159 return 0;160 }161}162 163/* Convert from vfs inode to xfs inode */164static inline struct xfs_inode *XFS_I(struct inode *inode)165{166 return container_of(inode, struct xfs_inode, i_vnode);167}168 169/* convert from xfs inode to vfs inode */170static inline struct inode *VFS_I(struct xfs_inode *ip)171{172 return &ip->i_vnode;173}174 175/* convert from const xfs inode to const vfs inode */176static inline const struct inode *VFS_IC(const struct xfs_inode *ip)177{178 return &ip->i_vnode;179}180 181/*182 * For regular files we only update the on-disk filesize when actually183 * writing data back to disk. Until then only the copy in the VFS inode184 * is uptodate.185 */186static inline xfs_fsize_t XFS_ISIZE(struct xfs_inode *ip)187{188 if (S_ISREG(VFS_I(ip)->i_mode))189 return i_size_read(VFS_I(ip));190 return ip->i_disk_size;191}192 193/*194 * If this I/O goes past the on-disk inode size update it unless it would195 * be past the current in-core inode size.196 */197static inline xfs_fsize_t198xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)199{200 xfs_fsize_t i_size = i_size_read(VFS_I(ip));201 202 if (new_size > i_size || new_size < 0)203 new_size = i_size;204 return new_size > ip->i_disk_size ? new_size : 0;205}206 207/*208 * i_flags helper functions209 */210static inline void211__xfs_iflags_set(xfs_inode_t *ip, unsigned long flags)212{213 ip->i_flags |= flags;214}215 216static inline void217xfs_iflags_set(xfs_inode_t *ip, unsigned long flags)218{219 spin_lock(&ip->i_flags_lock);220 __xfs_iflags_set(ip, flags);221 spin_unlock(&ip->i_flags_lock);222}223 224static inline void225xfs_iflags_clear(xfs_inode_t *ip, unsigned long flags)226{227 spin_lock(&ip->i_flags_lock);228 ip->i_flags &= ~flags;229 spin_unlock(&ip->i_flags_lock);230}231 232static inline int233__xfs_iflags_test(xfs_inode_t *ip, unsigned long flags)234{235 return (ip->i_flags & flags);236}237 238static inline int239xfs_iflags_test(xfs_inode_t *ip, unsigned long flags)240{241 int ret;242 spin_lock(&ip->i_flags_lock);243 ret = __xfs_iflags_test(ip, flags);244 spin_unlock(&ip->i_flags_lock);245 return ret;246}247 248static inline int249xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned long flags)250{251 int ret;252 253 spin_lock(&ip->i_flags_lock);254 ret = ip->i_flags & flags;255 if (ret)256 ip->i_flags &= ~flags;257 spin_unlock(&ip->i_flags_lock);258 return ret;259}260 261static inline int262xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned long flags)263{264 int ret;265 266 spin_lock(&ip->i_flags_lock);267 ret = ip->i_flags & flags;268 if (!ret)269 ip->i_flags |= flags;270 spin_unlock(&ip->i_flags_lock);271 return ret;272}273 274static inline bool xfs_is_reflink_inode(struct xfs_inode *ip)275{276 return ip->i_diflags2 & XFS_DIFLAG2_REFLINK;277}278 279static inline bool xfs_is_metadata_inode(const struct xfs_inode *ip)280{281 struct xfs_mount *mp = ip->i_mount;282 283 return ip->i_ino == mp->m_sb.sb_rbmino ||284 ip->i_ino == mp->m_sb.sb_rsumino ||285 xfs_is_quota_inode(&mp->m_sb, ip->i_ino);286}287 288bool xfs_is_always_cow_inode(struct xfs_inode *ip);289 290static inline bool xfs_is_cow_inode(struct xfs_inode *ip)291{292 return xfs_is_reflink_inode(ip) || xfs_is_always_cow_inode(ip);293}294 295static inline bool xfs_inode_has_filedata(const struct xfs_inode *ip)296{297 return ip->i_df.if_nextents > 0 || ip->i_delayed_blks > 0;298}299 300/*301 * Check if an inode has any data in the COW fork. This might be often false302 * even for inodes with the reflink flag when there is no pending COW operation.303 */304static inline bool xfs_inode_has_cow_data(struct xfs_inode *ip)305{306 return ip->i_cowfp && ip->i_cowfp->if_bytes;307}308 309static inline bool xfs_inode_has_bigtime(struct xfs_inode *ip)310{311 return ip->i_diflags2 & XFS_DIFLAG2_BIGTIME;312}313 314static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip)315{316 return ip->i_diflags2 & XFS_DIFLAG2_NREXT64;317}318 319/*320 * Decide if this file is a realtime file whose data allocation unit is larger321 * than a single filesystem block.322 */323static inline bool xfs_inode_has_bigrtalloc(struct xfs_inode *ip)324{325 return XFS_IS_REALTIME_INODE(ip) && ip->i_mount->m_sb.sb_rextsize > 1;326}327 328/*329 * Return the buftarg used for data allocations on a given inode.330 */331#define xfs_inode_buftarg(ip) \332 (XFS_IS_REALTIME_INODE(ip) ? \333 (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp)334 335/*336 * In-core inode flags.337 */338#define XFS_IRECLAIM (1 << 0) /* started reclaiming this inode */339#define XFS_ISTALE (1 << 1) /* inode has been staled */340#define XFS_IRECLAIMABLE (1 << 2) /* inode can be reclaimed */341#define XFS_INEW (1 << 3) /* inode has just been allocated */342#define XFS_IPRESERVE_DM_FIELDS (1 << 4) /* has legacy DMAPI fields set */343#define XFS_ITRUNCATED (1 << 5) /* truncated down so flush-on-close */344#define XFS_EOFBLOCKS_RELEASED (1 << 6) /* eofblocks were freed in ->release */345#define XFS_IFLUSHING (1 << 7) /* inode is being flushed */346#define __XFS_IPINNED_BIT 8 /* wakeup key for zero pin count */347#define XFS_IPINNED (1 << __XFS_IPINNED_BIT)348#define XFS_IEOFBLOCKS (1 << 9) /* has the preallocblocks tag set */349#define XFS_NEED_INACTIVE (1 << 10) /* see XFS_INACTIVATING below */350/*351 * If this unlinked inode is in the middle of recovery, don't let drop_inode352 * truncate and free the inode. This can happen if we iget the inode during353 * log recovery to replay a bmap operation on the inode.354 */355#define XFS_IRECOVERY (1 << 11)356#define XFS_ICOWBLOCKS (1 << 12)/* has the cowblocks tag set */357 358/*359 * If we need to update on-disk metadata before this IRECLAIMABLE inode can be360 * freed, then NEED_INACTIVE will be set. Once we start the updates, the361 * INACTIVATING bit will be set to keep iget away from this inode. After the362 * inactivation completes, both flags will be cleared and the inode is a363 * plain old IRECLAIMABLE inode.364 */365#define XFS_INACTIVATING (1 << 13)366 367/* Quotacheck is running but inode has not been added to quota counts. */368#define XFS_IQUOTAUNCHECKED (1 << 14)369 370/*371 * Remap in progress. Callers that wish to update file data while372 * holding a shared IOLOCK or MMAPLOCK must drop the lock and retake373 * the lock in exclusive mode. Relocking the file will block until374 * IREMAPPING is cleared.375 */376#define XFS_IREMAPPING (1U << 15)377 378/* All inode state flags related to inode reclaim. */379#define XFS_ALL_IRECLAIM_FLAGS (XFS_IRECLAIMABLE | \380 XFS_IRECLAIM | \381 XFS_NEED_INACTIVE | \382 XFS_INACTIVATING)383 384/*385 * Per-lifetime flags need to be reset when re-using a reclaimable inode during386 * inode lookup. This prevents unintended behaviour on the new inode from387 * ocurring.388 */389#define XFS_IRECLAIM_RESET_FLAGS \390 (XFS_IRECLAIMABLE | XFS_IRECLAIM | \391 XFS_EOFBLOCKS_RELEASED | XFS_ITRUNCATED | XFS_NEED_INACTIVE | \392 XFS_INACTIVATING | XFS_IQUOTAUNCHECKED)393 394/*395 * Flags for inode locking.396 * Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield)397 * 1<<16 - 1<<32-1 -- lockdep annotation (integers)398 */399#define XFS_IOLOCK_EXCL (1u << 0)400#define XFS_IOLOCK_SHARED (1u << 1)401#define XFS_ILOCK_EXCL (1u << 2)402#define XFS_ILOCK_SHARED (1u << 3)403#define XFS_MMAPLOCK_EXCL (1u << 4)404#define XFS_MMAPLOCK_SHARED (1u << 5)405 406#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \407 | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \408 | XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)409 410#define XFS_LOCK_FLAGS \411 { XFS_IOLOCK_EXCL, "IOLOCK_EXCL" }, \412 { XFS_IOLOCK_SHARED, "IOLOCK_SHARED" }, \413 { XFS_ILOCK_EXCL, "ILOCK_EXCL" }, \414 { XFS_ILOCK_SHARED, "ILOCK_SHARED" }, \415 { XFS_MMAPLOCK_EXCL, "MMAPLOCK_EXCL" }, \416 { XFS_MMAPLOCK_SHARED, "MMAPLOCK_SHARED" }417 418 419/*420 * Flags for lockdep annotations.421 *422 * XFS_LOCK_PARENT - for directory operations that require locking a423 * parent directory inode and a child entry inode. IOLOCK requires nesting,424 * MMAPLOCK does not support this class, ILOCK requires a single subclass425 * to differentiate parent from child.426 *427 * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary428 * inodes do not participate in the normal lock order, and thus have their429 * own subclasses.430 *431 * XFS_LOCK_INUMORDER - for locking several inodes at the some time432 * with xfs_lock_inodes(). This flag is used as the starting subclass433 * and each subsequent lock acquired will increment the subclass by one.434 * However, MAX_LOCKDEP_SUBCLASSES == 8, which means we are greatly435 * limited to the subclasses we can represent via nesting. We need at least436 * 5 inodes nest depth for the ILOCK through rename, and we also have to support437 * XFS_ILOCK_PARENT, which gives 6 subclasses. Then we have XFS_ILOCK_RTBITMAP438 * and XFS_ILOCK_RTSUM, which are another 2 unique subclasses, so that's all439 * 8 subclasses supported by lockdep.440 *441 * This also means we have to number the sub-classes in the lowest bits of442 * the mask we keep, and we have to ensure we never exceed 3 bits of lockdep443 * mask and we can't use bit-masking to build the subclasses. What a mess.444 *445 * Bit layout:446 *447 * Bit Lock Region448 * 16-19 XFS_IOLOCK_SHIFT dependencies449 * 20-23 XFS_MMAPLOCK_SHIFT dependencies450 * 24-31 XFS_ILOCK_SHIFT dependencies451 *452 * IOLOCK values453 *454 * 0-3 subclass value455 * 4-7 unused456 *457 * MMAPLOCK values458 *459 * 0-3 subclass value460 * 4-7 unused461 *462 * ILOCK values463 * 0-4 subclass values464 * 5 PARENT subclass (not nestable)465 * 6 RTBITMAP subclass (not nestable)466 * 7 RTSUM subclass (not nestable)467 * 468 */469#define XFS_IOLOCK_SHIFT 16470#define XFS_IOLOCK_MAX_SUBCLASS 3471#define XFS_IOLOCK_DEP_MASK 0x000f0000u472 473#define XFS_MMAPLOCK_SHIFT 20474#define XFS_MMAPLOCK_NUMORDER 0475#define XFS_MMAPLOCK_MAX_SUBCLASS 3476#define XFS_MMAPLOCK_DEP_MASK 0x00f00000u477 478#define XFS_ILOCK_SHIFT 24479#define XFS_ILOCK_PARENT_VAL 5u480#define XFS_ILOCK_MAX_SUBCLASS (XFS_ILOCK_PARENT_VAL - 1)481#define XFS_ILOCK_RTBITMAP_VAL 6u482#define XFS_ILOCK_RTSUM_VAL 7u483#define XFS_ILOCK_DEP_MASK 0xff000000u484#define XFS_ILOCK_PARENT (XFS_ILOCK_PARENT_VAL << XFS_ILOCK_SHIFT)485#define XFS_ILOCK_RTBITMAP (XFS_ILOCK_RTBITMAP_VAL << XFS_ILOCK_SHIFT)486#define XFS_ILOCK_RTSUM (XFS_ILOCK_RTSUM_VAL << XFS_ILOCK_SHIFT)487 488#define XFS_LOCK_SUBCLASS_MASK (XFS_IOLOCK_DEP_MASK | \489 XFS_MMAPLOCK_DEP_MASK | \490 XFS_ILOCK_DEP_MASK)491 492#define XFS_IOLOCK_DEP(flags) (((flags) & XFS_IOLOCK_DEP_MASK) \493 >> XFS_IOLOCK_SHIFT)494#define XFS_MMAPLOCK_DEP(flags) (((flags) & XFS_MMAPLOCK_DEP_MASK) \495 >> XFS_MMAPLOCK_SHIFT)496#define XFS_ILOCK_DEP(flags) (((flags) & XFS_ILOCK_DEP_MASK) \497 >> XFS_ILOCK_SHIFT)498 499/*500 * Layouts are broken in the BREAK_WRITE case to ensure that501 * layout-holders do not collide with local writes. Additionally,502 * layouts are broken in the BREAK_UNMAP case to make sure the503 * layout-holder has a consistent view of the file's extent map. While504 * BREAK_WRITE breaks can be satisfied by recalling FL_LAYOUT leases,505 * BREAK_UNMAP breaks additionally require waiting for busy dax-pages to506 * go idle.507 */508enum layout_break_reason {509 BREAK_WRITE,510 BREAK_UNMAP,511};512 513/*514 * For multiple groups support: if S_ISGID bit is set in the parent515 * directory, group of new file is set to that of the parent, and516 * new subdirectory gets S_ISGID bit from parent.517 */518#define XFS_INHERIT_GID(pip) \519 (xfs_has_grpid((pip)->i_mount) || (VFS_I(pip)->i_mode & S_ISGID))520 521int xfs_inactive(struct xfs_inode *ip);522int xfs_lookup(struct xfs_inode *dp, const struct xfs_name *name,523 struct xfs_inode **ipp, struct xfs_name *ci_name);524int xfs_create(const struct xfs_icreate_args *iargs,525 struct xfs_name *name, struct xfs_inode **ipp);526int xfs_create_tmpfile(const struct xfs_icreate_args *iargs,527 struct xfs_inode **ipp);528int xfs_remove(struct xfs_inode *dp, struct xfs_name *name,529 struct xfs_inode *ip);530int xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,531 struct xfs_name *target_name);532int xfs_rename(struct mnt_idmap *idmap,533 struct xfs_inode *src_dp, struct xfs_name *src_name,534 struct xfs_inode *src_ip, struct xfs_inode *target_dp,535 struct xfs_name *target_name,536 struct xfs_inode *target_ip, unsigned int flags);537 538void xfs_ilock(xfs_inode_t *, uint);539int xfs_ilock_nowait(xfs_inode_t *, uint);540void xfs_iunlock(xfs_inode_t *, uint);541void xfs_ilock_demote(xfs_inode_t *, uint);542void xfs_assert_ilocked(struct xfs_inode *, uint);543uint xfs_ilock_data_map_shared(struct xfs_inode *);544uint xfs_ilock_attr_map_shared(struct xfs_inode *);545 546int xfs_ifree(struct xfs_trans *, struct xfs_inode *);547int xfs_itruncate_extents_flags(struct xfs_trans **,548 struct xfs_inode *, int, xfs_fsize_t, int);549void xfs_iext_realloc(xfs_inode_t *, int, int);550 551int xfs_log_force_inode(struct xfs_inode *ip);552void xfs_iunpin_wait(xfs_inode_t *);553#define xfs_ipincount(ip) ((unsigned int) atomic_read(&ip->i_pincount))554 555int xfs_iflush_cluster(struct xfs_buf *);556void xfs_lock_two_inodes(struct xfs_inode *ip0, uint ip0_mode,557 struct xfs_inode *ip1, uint ip1_mode);558 559int xfs_icreate(struct xfs_trans *tp, xfs_ino_t ino,560 const struct xfs_icreate_args *args, struct xfs_inode **ipp);561 562static inline int563xfs_itruncate_extents(564 struct xfs_trans **tpp,565 struct xfs_inode *ip,566 int whichfork,567 xfs_fsize_t new_size)568{569 return xfs_itruncate_extents_flags(tpp, ip, whichfork, new_size, 0);570}571 572int xfs_break_dax_layouts(struct inode *inode, bool *retry);573int xfs_break_layouts(struct inode *inode, uint *iolock,574 enum layout_break_reason reason);575 576static inline void xfs_update_stable_writes(struct xfs_inode *ip)577{578 if (bdev_stable_writes(xfs_inode_buftarg(ip)->bt_bdev))579 mapping_set_stable_writes(VFS_I(ip)->i_mapping);580 else581 mapping_clear_stable_writes(VFS_I(ip)->i_mapping);582}583 584/*585 * When setting up a newly allocated inode, we need to call586 * xfs_finish_inode_setup() once the inode is fully instantiated at587 * the VFS level to prevent the rest of the world seeing the inode588 * before we've completed instantiation. Otherwise we can do it589 * the moment the inode lookup is complete.590 */591static inline void xfs_finish_inode_setup(struct xfs_inode *ip)592{593 xfs_iflags_clear(ip, XFS_INEW);594 barrier();595 unlock_new_inode(VFS_I(ip));596}597 598static inline void xfs_setup_existing_inode(struct xfs_inode *ip)599{600 xfs_setup_inode(ip);601 xfs_setup_iops(ip);602 xfs_finish_inode_setup(ip);603}604 605void xfs_irele(struct xfs_inode *ip);606 607extern struct kmem_cache *xfs_inode_cache;608 609/* The default CoW extent size hint. */610#define XFS_DEFAULT_COWEXTSZ_HINT 32611 612bool xfs_inode_needs_inactive(struct xfs_inode *ip);613 614struct xfs_inode *xfs_iunlink_lookup(struct xfs_perag *pag, xfs_agino_t agino);615int xfs_iunlink_reload_next(struct xfs_trans *tp, struct xfs_buf *agibp,616 xfs_agino_t prev_agino, xfs_agino_t next_agino);617 618void xfs_end_io(struct work_struct *work);619 620int xfs_ilock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2);621void xfs_iunlock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2);622void xfs_iunlock2_remapping(struct xfs_inode *ip1, struct xfs_inode *ip2);623void xfs_lock_inodes(struct xfs_inode **ips, int inodes, uint lock_mode);624void xfs_sort_inodes(struct xfs_inode **i_tab, unsigned int num_inodes);625 626static inline bool627xfs_inode_unlinked_incomplete(628 struct xfs_inode *ip)629{630 return VFS_I(ip)->i_nlink == 0 && !xfs_inode_on_unlinked_list(ip);631}632int xfs_inode_reload_unlinked_bucket(struct xfs_trans *tp, struct xfs_inode *ip);633int xfs_inode_reload_unlinked(struct xfs_inode *ip);634 635bool xfs_ifork_zapped(const struct xfs_inode *ip, int whichfork);636void xfs_inode_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip,637 xfs_filblks_t *dblocks, xfs_filblks_t *rblocks);638unsigned int xfs_inode_alloc_unitsize(struct xfs_inode *ip);639 640int xfs_icreate_dqalloc(const struct xfs_icreate_args *args,641 struct xfs_dquot **udqpp, struct xfs_dquot **gdqpp,642 struct xfs_dquot **pdqpp);643 644#endif /* __XFS_INODE_H__ */645