1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
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 | |
12 | /* |
13 | * Kernel only inode definitions |
14 | */ |
15 | struct xfs_dinode; |
16 | struct xfs_inode; |
17 | struct xfs_buf; |
18 | struct xfs_bmbt_irec; |
19 | struct xfs_inode_log_item; |
20 | struct xfs_mount; |
21 | struct xfs_trans; |
22 | struct xfs_dquot; |
23 | |
24 | typedef struct xfs_inode { |
25 | /* Inode linking and identification information. */ |
26 | struct xfs_mount *i_mount; /* fs mount struct ptr */ |
27 | struct xfs_dquot *i_udquot; /* user dquot */ |
28 | struct xfs_dquot *i_gdquot; /* group dquot */ |
29 | struct xfs_dquot *i_pdquot; /* project dquot */ |
30 | |
31 | /* Inode location stuff */ |
32 | xfs_ino_t i_ino; /* inode number (agno/agino)*/ |
33 | struct xfs_imap i_imap; /* location for xfs_imap() */ |
34 | |
35 | /* Extent information. */ |
36 | struct xfs_ifork *i_cowfp; /* copy on write extents */ |
37 | struct xfs_ifork i_df; /* data fork */ |
38 | struct xfs_ifork i_af; /* attribute fork */ |
39 | |
40 | /* Transaction and locking information. */ |
41 | struct xfs_inode_log_item *i_itemp; /* logging information */ |
42 | mrlock_t i_lock; /* inode lock */ |
43 | atomic_t i_pincount; /* inode pin count */ |
44 | struct llist_node i_gclist; /* deferred inactivation list */ |
45 | |
46 | /* |
47 | * Bitsets of inode metadata that have been checked and/or are sick. |
48 | * Callers must hold i_flags_lock before accessing this field. |
49 | */ |
50 | uint16_t i_checked; |
51 | uint16_t i_sick; |
52 | |
53 | spinlock_t i_flags_lock; /* inode i_flags lock */ |
54 | /* Miscellaneous state. */ |
55 | unsigned long i_flags; /* see defined flags below */ |
56 | uint64_t i_delayed_blks; /* count of delay alloc blks */ |
57 | xfs_fsize_t i_disk_size; /* number of bytes in file */ |
58 | xfs_rfsblock_t i_nblocks; /* # of direct & btree blocks */ |
59 | prid_t i_projid; /* owner's project id */ |
60 | xfs_extlen_t i_extsize; /* basic/minimum extent size */ |
61 | /* cowextsize is only used for v3 inodes, flushiter for v1/2 */ |
62 | union { |
63 | xfs_extlen_t i_cowextsize; /* basic cow extent size */ |
64 | uint16_t i_flushiter; /* incremented on flush */ |
65 | }; |
66 | uint8_t i_forkoff; /* attr fork offset >> 3 */ |
67 | uint16_t i_diflags; /* XFS_DIFLAG_... */ |
68 | uint64_t i_diflags2; /* XFS_DIFLAG2_... */ |
69 | struct timespec64 i_crtime; /* time created */ |
70 | |
71 | /* |
72 | * Unlinked list pointers. These point to the next and previous inodes |
73 | * in the AGI unlinked bucket list, respectively. These fields can |
74 | * only be updated with the AGI locked. |
75 | * |
76 | * i_next_unlinked caches di_next_unlinked. |
77 | */ |
78 | xfs_agino_t i_next_unlinked; |
79 | |
80 | /* |
81 | * If the inode is not on an unlinked list, this field is zero. If the |
82 | * inode is the first element in an unlinked list, this field is |
83 | * NULLAGINO. Otherwise, i_prev_unlinked points to the previous inode |
84 | * in the unlinked list. |
85 | */ |
86 | xfs_agino_t i_prev_unlinked; |
87 | |
88 | /* VFS inode */ |
89 | struct inode i_vnode; /* embedded VFS inode */ |
90 | |
91 | /* pending io completions */ |
92 | spinlock_t i_ioend_lock; |
93 | struct work_struct i_ioend_work; |
94 | struct list_head i_ioend_list; |
95 | } xfs_inode_t; |
96 | |
97 | static inline bool xfs_inode_on_unlinked_list(const struct xfs_inode *ip) |
98 | { |
99 | return ip->i_prev_unlinked != 0; |
100 | } |
101 | |
102 | static inline bool xfs_inode_has_attr_fork(struct xfs_inode *ip) |
103 | { |
104 | return ip->i_forkoff > 0; |
105 | } |
106 | |
107 | static inline struct xfs_ifork * |
108 | xfs_ifork_ptr( |
109 | struct xfs_inode *ip, |
110 | int whichfork) |
111 | { |
112 | switch (whichfork) { |
113 | case XFS_DATA_FORK: |
114 | return &ip->i_df; |
115 | case XFS_ATTR_FORK: |
116 | if (!xfs_inode_has_attr_fork(ip)) |
117 | return NULL; |
118 | return &ip->i_af; |
119 | case XFS_COW_FORK: |
120 | return ip->i_cowfp; |
121 | default: |
122 | ASSERT(0); |
123 | return NULL; |
124 | } |
125 | } |
126 | |
127 | static inline unsigned int xfs_inode_fork_boff(struct xfs_inode *ip) |
128 | { |
129 | return ip->i_forkoff << 3; |
130 | } |
131 | |
132 | static inline unsigned int xfs_inode_data_fork_size(struct xfs_inode *ip) |
133 | { |
134 | if (xfs_inode_has_attr_fork(ip)) |
135 | return xfs_inode_fork_boff(ip); |
136 | |
137 | return XFS_LITINO(ip->i_mount); |
138 | } |
139 | |
140 | static inline unsigned int xfs_inode_attr_fork_size(struct xfs_inode *ip) |
141 | { |
142 | if (xfs_inode_has_attr_fork(ip)) |
143 | return XFS_LITINO(ip->i_mount) - xfs_inode_fork_boff(ip); |
144 | return 0; |
145 | } |
146 | |
147 | static inline unsigned int |
148 | xfs_inode_fork_size( |
149 | struct xfs_inode *ip, |
150 | int whichfork) |
151 | { |
152 | switch (whichfork) { |
153 | case XFS_DATA_FORK: |
154 | return xfs_inode_data_fork_size(ip); |
155 | case XFS_ATTR_FORK: |
156 | return xfs_inode_attr_fork_size(ip); |
157 | default: |
158 | return 0; |
159 | } |
160 | } |
161 | |
162 | /* Convert from vfs inode to xfs inode */ |
163 | static inline struct xfs_inode *XFS_I(struct inode *inode) |
164 | { |
165 | return container_of(inode, struct xfs_inode, i_vnode); |
166 | } |
167 | |
168 | /* convert from xfs inode to vfs inode */ |
169 | static inline struct inode *VFS_I(struct xfs_inode *ip) |
170 | { |
171 | return &ip->i_vnode; |
172 | } |
173 | |
174 | /* |
175 | * For regular files we only update the on-disk filesize when actually |
176 | * writing data back to disk. Until then only the copy in the VFS inode |
177 | * is uptodate. |
178 | */ |
179 | static inline xfs_fsize_t XFS_ISIZE(struct xfs_inode *ip) |
180 | { |
181 | if (S_ISREG(VFS_I(ip)->i_mode)) |
182 | return i_size_read(inode: VFS_I(ip)); |
183 | return ip->i_disk_size; |
184 | } |
185 | |
186 | /* |
187 | * If this I/O goes past the on-disk inode size update it unless it would |
188 | * be past the current in-core inode size. |
189 | */ |
190 | static inline xfs_fsize_t |
191 | xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size) |
192 | { |
193 | xfs_fsize_t i_size = i_size_read(VFS_I(ip)); |
194 | |
195 | if (new_size > i_size || new_size < 0) |
196 | new_size = i_size; |
197 | return new_size > ip->i_disk_size ? new_size : 0; |
198 | } |
199 | |
200 | /* |
201 | * i_flags helper functions |
202 | */ |
203 | static inline void |
204 | __xfs_iflags_set(xfs_inode_t *ip, unsigned short flags) |
205 | { |
206 | ip->i_flags |= flags; |
207 | } |
208 | |
209 | static inline void |
210 | xfs_iflags_set(xfs_inode_t *ip, unsigned short flags) |
211 | { |
212 | spin_lock(lock: &ip->i_flags_lock); |
213 | __xfs_iflags_set(ip, flags); |
214 | spin_unlock(lock: &ip->i_flags_lock); |
215 | } |
216 | |
217 | static inline void |
218 | xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags) |
219 | { |
220 | spin_lock(lock: &ip->i_flags_lock); |
221 | ip->i_flags &= ~flags; |
222 | spin_unlock(lock: &ip->i_flags_lock); |
223 | } |
224 | |
225 | static inline int |
226 | __xfs_iflags_test(xfs_inode_t *ip, unsigned short flags) |
227 | { |
228 | return (ip->i_flags & flags); |
229 | } |
230 | |
231 | static inline int |
232 | xfs_iflags_test(xfs_inode_t *ip, unsigned short flags) |
233 | { |
234 | int ret; |
235 | spin_lock(lock: &ip->i_flags_lock); |
236 | ret = __xfs_iflags_test(ip, flags); |
237 | spin_unlock(lock: &ip->i_flags_lock); |
238 | return ret; |
239 | } |
240 | |
241 | static inline int |
242 | xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags) |
243 | { |
244 | int ret; |
245 | |
246 | spin_lock(lock: &ip->i_flags_lock); |
247 | ret = ip->i_flags & flags; |
248 | if (ret) |
249 | ip->i_flags &= ~flags; |
250 | spin_unlock(lock: &ip->i_flags_lock); |
251 | return ret; |
252 | } |
253 | |
254 | static inline int |
255 | xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned short flags) |
256 | { |
257 | int ret; |
258 | |
259 | spin_lock(lock: &ip->i_flags_lock); |
260 | ret = ip->i_flags & flags; |
261 | if (!ret) |
262 | ip->i_flags |= flags; |
263 | spin_unlock(lock: &ip->i_flags_lock); |
264 | return ret; |
265 | } |
266 | |
267 | static inline prid_t |
268 | xfs_get_initial_prid(struct xfs_inode *dp) |
269 | { |
270 | if (dp->i_diflags & XFS_DIFLAG_PROJINHERIT) |
271 | return dp->i_projid; |
272 | |
273 | return XFS_PROJID_DEFAULT; |
274 | } |
275 | |
276 | static inline bool xfs_is_reflink_inode(struct xfs_inode *ip) |
277 | { |
278 | return ip->i_diflags2 & XFS_DIFLAG2_REFLINK; |
279 | } |
280 | |
281 | static inline bool xfs_is_metadata_inode(struct xfs_inode *ip) |
282 | { |
283 | struct xfs_mount *mp = ip->i_mount; |
284 | |
285 | return ip == mp->m_rbmip || ip == mp->m_rsumip || |
286 | xfs_is_quota_inode(&mp->m_sb, ip->i_ino); |
287 | } |
288 | |
289 | /* |
290 | * Check if an inode has any data in the COW fork. This might be often false |
291 | * even for inodes with the reflink flag when there is no pending COW operation. |
292 | */ |
293 | static inline bool xfs_inode_has_cow_data(struct xfs_inode *ip) |
294 | { |
295 | return ip->i_cowfp && ip->i_cowfp->if_bytes; |
296 | } |
297 | |
298 | static inline bool xfs_inode_has_bigtime(struct xfs_inode *ip) |
299 | { |
300 | return ip->i_diflags2 & XFS_DIFLAG2_BIGTIME; |
301 | } |
302 | |
303 | static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip) |
304 | { |
305 | return ip->i_diflags2 & XFS_DIFLAG2_NREXT64; |
306 | } |
307 | |
308 | /* |
309 | * Return the buftarg used for data allocations on a given inode. |
310 | */ |
311 | #define xfs_inode_buftarg(ip) \ |
312 | (XFS_IS_REALTIME_INODE(ip) ? \ |
313 | (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp) |
314 | |
315 | /* |
316 | * In-core inode flags. |
317 | */ |
318 | #define XFS_IRECLAIM (1 << 0) /* started reclaiming this inode */ |
319 | #define XFS_ISTALE (1 << 1) /* inode has been staled */ |
320 | #define XFS_IRECLAIMABLE (1 << 2) /* inode can be reclaimed */ |
321 | #define XFS_INEW (1 << 3) /* inode has just been allocated */ |
322 | #define XFS_IPRESERVE_DM_FIELDS (1 << 4) /* has legacy DMAPI fields set */ |
323 | #define XFS_ITRUNCATED (1 << 5) /* truncated down so flush-on-close */ |
324 | #define XFS_IDIRTY_RELEASE (1 << 6) /* dirty release already seen */ |
325 | #define XFS_IFLUSHING (1 << 7) /* inode is being flushed */ |
326 | #define __XFS_IPINNED_BIT 8 /* wakeup key for zero pin count */ |
327 | #define XFS_IPINNED (1 << __XFS_IPINNED_BIT) |
328 | #define XFS_IEOFBLOCKS (1 << 9) /* has the preallocblocks tag set */ |
329 | #define XFS_NEED_INACTIVE (1 << 10) /* see XFS_INACTIVATING below */ |
330 | /* |
331 | * If this unlinked inode is in the middle of recovery, don't let drop_inode |
332 | * truncate and free the inode. This can happen if we iget the inode during |
333 | * log recovery to replay a bmap operation on the inode. |
334 | */ |
335 | #define XFS_IRECOVERY (1 << 11) |
336 | #define XFS_ICOWBLOCKS (1 << 12)/* has the cowblocks tag set */ |
337 | |
338 | /* |
339 | * If we need to update on-disk metadata before this IRECLAIMABLE inode can be |
340 | * freed, then NEED_INACTIVE will be set. Once we start the updates, the |
341 | * INACTIVATING bit will be set to keep iget away from this inode. After the |
342 | * inactivation completes, both flags will be cleared and the inode is a |
343 | * plain old IRECLAIMABLE inode. |
344 | */ |
345 | #define XFS_INACTIVATING (1 << 13) |
346 | |
347 | /* Quotacheck is running but inode has not been added to quota counts. */ |
348 | #define XFS_IQUOTAUNCHECKED (1 << 14) |
349 | |
350 | /* |
351 | * Remap in progress. Callers that wish to update file data while |
352 | * holding a shared IOLOCK or MMAPLOCK must drop the lock and retake |
353 | * the lock in exclusive mode. Relocking the file will block until |
354 | * IREMAPPING is cleared. |
355 | */ |
356 | #define XFS_IREMAPPING (1U << 15) |
357 | |
358 | /* All inode state flags related to inode reclaim. */ |
359 | #define XFS_ALL_IRECLAIM_FLAGS (XFS_IRECLAIMABLE | \ |
360 | XFS_IRECLAIM | \ |
361 | XFS_NEED_INACTIVE | \ |
362 | XFS_INACTIVATING) |
363 | |
364 | /* |
365 | * Per-lifetime flags need to be reset when re-using a reclaimable inode during |
366 | * inode lookup. This prevents unintended behaviour on the new inode from |
367 | * ocurring. |
368 | */ |
369 | #define XFS_IRECLAIM_RESET_FLAGS \ |
370 | (XFS_IRECLAIMABLE | XFS_IRECLAIM | \ |
371 | XFS_IDIRTY_RELEASE | XFS_ITRUNCATED | XFS_NEED_INACTIVE | \ |
372 | XFS_INACTIVATING | XFS_IQUOTAUNCHECKED) |
373 | |
374 | /* |
375 | * Flags for inode locking. |
376 | * Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield) |
377 | * 1<<16 - 1<<32-1 -- lockdep annotation (integers) |
378 | */ |
379 | #define XFS_IOLOCK_EXCL (1u << 0) |
380 | #define XFS_IOLOCK_SHARED (1u << 1) |
381 | #define XFS_ILOCK_EXCL (1u << 2) |
382 | #define XFS_ILOCK_SHARED (1u << 3) |
383 | #define XFS_MMAPLOCK_EXCL (1u << 4) |
384 | #define XFS_MMAPLOCK_SHARED (1u << 5) |
385 | |
386 | #define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ |
387 | | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \ |
388 | | XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED) |
389 | |
390 | #define XFS_LOCK_FLAGS \ |
391 | { XFS_IOLOCK_EXCL, "IOLOCK_EXCL" }, \ |
392 | { XFS_IOLOCK_SHARED, "IOLOCK_SHARED" }, \ |
393 | { XFS_ILOCK_EXCL, "ILOCK_EXCL" }, \ |
394 | { XFS_ILOCK_SHARED, "ILOCK_SHARED" }, \ |
395 | { XFS_MMAPLOCK_EXCL, "MMAPLOCK_EXCL" }, \ |
396 | { XFS_MMAPLOCK_SHARED, "MMAPLOCK_SHARED" } |
397 | |
398 | |
399 | /* |
400 | * Flags for lockdep annotations. |
401 | * |
402 | * XFS_LOCK_PARENT - for directory operations that require locking a |
403 | * parent directory inode and a child entry inode. IOLOCK requires nesting, |
404 | * MMAPLOCK does not support this class, ILOCK requires a single subclass |
405 | * to differentiate parent from child. |
406 | * |
407 | * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary |
408 | * inodes do not participate in the normal lock order, and thus have their |
409 | * own subclasses. |
410 | * |
411 | * XFS_LOCK_INUMORDER - for locking several inodes at the some time |
412 | * with xfs_lock_inodes(). This flag is used as the starting subclass |
413 | * and each subsequent lock acquired will increment the subclass by one. |
414 | * However, MAX_LOCKDEP_SUBCLASSES == 8, which means we are greatly |
415 | * limited to the subclasses we can represent via nesting. We need at least |
416 | * 5 inodes nest depth for the ILOCK through rename, and we also have to support |
417 | * XFS_ILOCK_PARENT, which gives 6 subclasses. Then we have XFS_ILOCK_RTBITMAP |
418 | * and XFS_ILOCK_RTSUM, which are another 2 unique subclasses, so that's all |
419 | * 8 subclasses supported by lockdep. |
420 | * |
421 | * This also means we have to number the sub-classes in the lowest bits of |
422 | * the mask we keep, and we have to ensure we never exceed 3 bits of lockdep |
423 | * mask and we can't use bit-masking to build the subclasses. What a mess. |
424 | * |
425 | * Bit layout: |
426 | * |
427 | * Bit Lock Region |
428 | * 16-19 XFS_IOLOCK_SHIFT dependencies |
429 | * 20-23 XFS_MMAPLOCK_SHIFT dependencies |
430 | * 24-31 XFS_ILOCK_SHIFT dependencies |
431 | * |
432 | * IOLOCK values |
433 | * |
434 | * 0-3 subclass value |
435 | * 4-7 unused |
436 | * |
437 | * MMAPLOCK values |
438 | * |
439 | * 0-3 subclass value |
440 | * 4-7 unused |
441 | * |
442 | * ILOCK values |
443 | * 0-4 subclass values |
444 | * 5 PARENT subclass (not nestable) |
445 | * 6 RTBITMAP subclass (not nestable) |
446 | * 7 RTSUM subclass (not nestable) |
447 | * |
448 | */ |
449 | #define XFS_IOLOCK_SHIFT 16 |
450 | #define XFS_IOLOCK_MAX_SUBCLASS 3 |
451 | #define XFS_IOLOCK_DEP_MASK 0x000f0000u |
452 | |
453 | #define XFS_MMAPLOCK_SHIFT 20 |
454 | #define XFS_MMAPLOCK_NUMORDER 0 |
455 | #define XFS_MMAPLOCK_MAX_SUBCLASS 3 |
456 | #define XFS_MMAPLOCK_DEP_MASK 0x00f00000u |
457 | |
458 | #define XFS_ILOCK_SHIFT 24 |
459 | #define XFS_ILOCK_PARENT_VAL 5u |
460 | #define XFS_ILOCK_MAX_SUBCLASS (XFS_ILOCK_PARENT_VAL - 1) |
461 | #define XFS_ILOCK_RTBITMAP_VAL 6u |
462 | #define XFS_ILOCK_RTSUM_VAL 7u |
463 | #define XFS_ILOCK_DEP_MASK 0xff000000u |
464 | #define XFS_ILOCK_PARENT (XFS_ILOCK_PARENT_VAL << XFS_ILOCK_SHIFT) |
465 | #define XFS_ILOCK_RTBITMAP (XFS_ILOCK_RTBITMAP_VAL << XFS_ILOCK_SHIFT) |
466 | #define XFS_ILOCK_RTSUM (XFS_ILOCK_RTSUM_VAL << XFS_ILOCK_SHIFT) |
467 | |
468 | #define XFS_LOCK_SUBCLASS_MASK (XFS_IOLOCK_DEP_MASK | \ |
469 | XFS_MMAPLOCK_DEP_MASK | \ |
470 | XFS_ILOCK_DEP_MASK) |
471 | |
472 | #define XFS_IOLOCK_DEP(flags) (((flags) & XFS_IOLOCK_DEP_MASK) \ |
473 | >> XFS_IOLOCK_SHIFT) |
474 | #define XFS_MMAPLOCK_DEP(flags) (((flags) & XFS_MMAPLOCK_DEP_MASK) \ |
475 | >> XFS_MMAPLOCK_SHIFT) |
476 | #define XFS_ILOCK_DEP(flags) (((flags) & XFS_ILOCK_DEP_MASK) \ |
477 | >> XFS_ILOCK_SHIFT) |
478 | |
479 | /* |
480 | * Layouts are broken in the BREAK_WRITE case to ensure that |
481 | * layout-holders do not collide with local writes. Additionally, |
482 | * layouts are broken in the BREAK_UNMAP case to make sure the |
483 | * layout-holder has a consistent view of the file's extent map. While |
484 | * BREAK_WRITE breaks can be satisfied by recalling FL_LAYOUT leases, |
485 | * BREAK_UNMAP breaks additionally require waiting for busy dax-pages to |
486 | * go idle. |
487 | */ |
488 | enum layout_break_reason { |
489 | BREAK_WRITE, |
490 | BREAK_UNMAP, |
491 | }; |
492 | |
493 | /* |
494 | * For multiple groups support: if S_ISGID bit is set in the parent |
495 | * directory, group of new file is set to that of the parent, and |
496 | * new subdirectory gets S_ISGID bit from parent. |
497 | */ |
498 | #define XFS_INHERIT_GID(pip) \ |
499 | (xfs_has_grpid((pip)->i_mount) || (VFS_I(pip)->i_mode & S_ISGID)) |
500 | |
501 | int xfs_release(struct xfs_inode *ip); |
502 | int xfs_inactive(struct xfs_inode *ip); |
503 | int xfs_lookup(struct xfs_inode *dp, const struct xfs_name *name, |
504 | struct xfs_inode **ipp, struct xfs_name *ci_name); |
505 | int xfs_create(struct mnt_idmap *idmap, |
506 | struct xfs_inode *dp, struct xfs_name *name, |
507 | umode_t mode, dev_t rdev, bool need_xattr, |
508 | struct xfs_inode **ipp); |
509 | int xfs_create_tmpfile(struct mnt_idmap *idmap, |
510 | struct xfs_inode *dp, umode_t mode, |
511 | struct xfs_inode **ipp); |
512 | int xfs_remove(struct xfs_inode *dp, struct xfs_name *name, |
513 | struct xfs_inode *ip); |
514 | int xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip, |
515 | struct xfs_name *target_name); |
516 | int xfs_rename(struct mnt_idmap *idmap, |
517 | struct xfs_inode *src_dp, struct xfs_name *src_name, |
518 | struct xfs_inode *src_ip, struct xfs_inode *target_dp, |
519 | struct xfs_name *target_name, |
520 | struct xfs_inode *target_ip, unsigned int flags); |
521 | |
522 | void xfs_ilock(xfs_inode_t *, uint); |
523 | int xfs_ilock_nowait(xfs_inode_t *, uint); |
524 | void xfs_iunlock(xfs_inode_t *, uint); |
525 | void xfs_ilock_demote(xfs_inode_t *, uint); |
526 | bool xfs_isilocked(struct xfs_inode *, uint); |
527 | uint xfs_ilock_data_map_shared(struct xfs_inode *); |
528 | uint xfs_ilock_attr_map_shared(struct xfs_inode *); |
529 | |
530 | uint xfs_ip2xflags(struct xfs_inode *); |
531 | int xfs_ifree(struct xfs_trans *, struct xfs_inode *); |
532 | int xfs_itruncate_extents_flags(struct xfs_trans **, |
533 | struct xfs_inode *, int, xfs_fsize_t, int); |
534 | void xfs_iext_realloc(xfs_inode_t *, int, int); |
535 | |
536 | int xfs_log_force_inode(struct xfs_inode *ip); |
537 | void xfs_iunpin_wait(xfs_inode_t *); |
538 | #define xfs_ipincount(ip) ((unsigned int) atomic_read(&ip->i_pincount)) |
539 | |
540 | int xfs_iflush_cluster(struct xfs_buf *); |
541 | void xfs_lock_two_inodes(struct xfs_inode *ip0, uint ip0_mode, |
542 | struct xfs_inode *ip1, uint ip1_mode); |
543 | |
544 | xfs_extlen_t xfs_get_extsz_hint(struct xfs_inode *ip); |
545 | xfs_extlen_t xfs_get_cowextsz_hint(struct xfs_inode *ip); |
546 | |
547 | int xfs_init_new_inode(struct mnt_idmap *idmap, struct xfs_trans *tp, |
548 | struct xfs_inode *pip, xfs_ino_t ino, umode_t mode, |
549 | xfs_nlink_t nlink, dev_t rdev, prid_t prid, bool init_xattrs, |
550 | struct xfs_inode **ipp); |
551 | |
552 | static inline int |
553 | xfs_itruncate_extents( |
554 | struct xfs_trans **tpp, |
555 | struct xfs_inode *ip, |
556 | int whichfork, |
557 | xfs_fsize_t new_size) |
558 | { |
559 | return xfs_itruncate_extents_flags(tpp, ip, whichfork, xfs_fsize_t: new_size, 0); |
560 | } |
561 | |
562 | /* from xfs_file.c */ |
563 | int xfs_break_dax_layouts(struct inode *inode, bool *retry); |
564 | int xfs_break_layouts(struct inode *inode, uint *iolock, |
565 | enum layout_break_reason reason); |
566 | |
567 | /* from xfs_iops.c */ |
568 | extern void xfs_setup_inode(struct xfs_inode *ip); |
569 | extern void xfs_setup_iops(struct xfs_inode *ip); |
570 | extern void xfs_diflags_to_iflags(struct xfs_inode *ip, bool init); |
571 | |
572 | /* |
573 | * When setting up a newly allocated inode, we need to call |
574 | * xfs_finish_inode_setup() once the inode is fully instantiated at |
575 | * the VFS level to prevent the rest of the world seeing the inode |
576 | * before we've completed instantiation. Otherwise we can do it |
577 | * the moment the inode lookup is complete. |
578 | */ |
579 | static inline void xfs_finish_inode_setup(struct xfs_inode *ip) |
580 | { |
581 | xfs_iflags_clear(ip, XFS_INEW); |
582 | barrier(); |
583 | unlock_new_inode(VFS_I(ip)); |
584 | } |
585 | |
586 | static inline void xfs_setup_existing_inode(struct xfs_inode *ip) |
587 | { |
588 | xfs_setup_inode(ip); |
589 | xfs_setup_iops(ip); |
590 | xfs_finish_inode_setup(ip); |
591 | } |
592 | |
593 | void xfs_irele(struct xfs_inode *ip); |
594 | |
595 | extern struct kmem_cache *xfs_inode_cache; |
596 | |
597 | /* The default CoW extent size hint. */ |
598 | #define XFS_DEFAULT_COWEXTSZ_HINT 32 |
599 | |
600 | bool xfs_inode_needs_inactive(struct xfs_inode *ip); |
601 | |
602 | void xfs_end_io(struct work_struct *work); |
603 | |
604 | int xfs_ilock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2); |
605 | void xfs_iunlock2_io_mmap(struct xfs_inode *ip1, struct xfs_inode *ip2); |
606 | void xfs_iunlock2_remapping(struct xfs_inode *ip1, struct xfs_inode *ip2); |
607 | |
608 | static inline bool |
609 | xfs_inode_unlinked_incomplete( |
610 | struct xfs_inode *ip) |
611 | { |
612 | return VFS_I(ip)->i_nlink == 0 && !xfs_inode_on_unlinked_list(ip); |
613 | } |
614 | int xfs_inode_reload_unlinked_bucket(struct xfs_trans *tp, struct xfs_inode *ip); |
615 | int xfs_inode_reload_unlinked(struct xfs_inode *ip); |
616 | |
617 | #endif /* __XFS_INODE_H__ */ |
618 | |