xref: /openbmc/linux/fs/xfs/xfs_inode.h (revision f8e17c17)
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_afp;		/* attribute fork pointer */
37 	struct xfs_ifork	*i_cowfp;	/* copy on write extents */
38 	struct xfs_ifork	i_df;		/* data 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 	mrlock_t		i_mmaplock;	/* inode mmap IO lock */
44 	atomic_t		i_pincount;	/* inode pin count */
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 
58 	struct xfs_icdinode	i_d;		/* most of ondisk inode */
59 
60 	xfs_extnum_t		i_cnextents;	/* # of extents in cow fork */
61 	unsigned int		i_cformat;	/* format of cow fork */
62 
63 	/* VFS inode */
64 	struct inode		i_vnode;	/* embedded VFS inode */
65 
66 	/* pending io completions */
67 	spinlock_t		i_ioend_lock;
68 	struct work_struct	i_ioend_work;
69 	struct list_head	i_ioend_list;
70 } xfs_inode_t;
71 
72 /* Convert from vfs inode to xfs inode */
73 static inline struct xfs_inode *XFS_I(struct inode *inode)
74 {
75 	return container_of(inode, struct xfs_inode, i_vnode);
76 }
77 
78 /* convert from xfs inode to vfs inode */
79 static inline struct inode *VFS_I(struct xfs_inode *ip)
80 {
81 	return &ip->i_vnode;
82 }
83 
84 /*
85  * For regular files we only update the on-disk filesize when actually
86  * writing data back to disk.  Until then only the copy in the VFS inode
87  * is uptodate.
88  */
89 static inline xfs_fsize_t XFS_ISIZE(struct xfs_inode *ip)
90 {
91 	if (S_ISREG(VFS_I(ip)->i_mode))
92 		return i_size_read(VFS_I(ip));
93 	return ip->i_d.di_size;
94 }
95 
96 /*
97  * If this I/O goes past the on-disk inode size update it unless it would
98  * be past the current in-core inode size.
99  */
100 static inline xfs_fsize_t
101 xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)
102 {
103 	xfs_fsize_t i_size = i_size_read(VFS_I(ip));
104 
105 	if (new_size > i_size || new_size < 0)
106 		new_size = i_size;
107 	return new_size > ip->i_d.di_size ? new_size : 0;
108 }
109 
110 /*
111  * i_flags helper functions
112  */
113 static inline void
114 __xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
115 {
116 	ip->i_flags |= flags;
117 }
118 
119 static inline void
120 xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
121 {
122 	spin_lock(&ip->i_flags_lock);
123 	__xfs_iflags_set(ip, flags);
124 	spin_unlock(&ip->i_flags_lock);
125 }
126 
127 static inline void
128 xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags)
129 {
130 	spin_lock(&ip->i_flags_lock);
131 	ip->i_flags &= ~flags;
132 	spin_unlock(&ip->i_flags_lock);
133 }
134 
135 static inline int
136 __xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
137 {
138 	return (ip->i_flags & flags);
139 }
140 
141 static inline int
142 xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
143 {
144 	int ret;
145 	spin_lock(&ip->i_flags_lock);
146 	ret = __xfs_iflags_test(ip, flags);
147 	spin_unlock(&ip->i_flags_lock);
148 	return ret;
149 }
150 
151 static inline int
152 xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags)
153 {
154 	int ret;
155 
156 	spin_lock(&ip->i_flags_lock);
157 	ret = ip->i_flags & flags;
158 	if (ret)
159 		ip->i_flags &= ~flags;
160 	spin_unlock(&ip->i_flags_lock);
161 	return ret;
162 }
163 
164 static inline int
165 xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned short flags)
166 {
167 	int ret;
168 
169 	spin_lock(&ip->i_flags_lock);
170 	ret = ip->i_flags & flags;
171 	if (!ret)
172 		ip->i_flags |= flags;
173 	spin_unlock(&ip->i_flags_lock);
174 	return ret;
175 }
176 
177 static inline prid_t
178 xfs_get_initial_prid(struct xfs_inode *dp)
179 {
180 	if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
181 		return dp->i_d.di_projid;
182 
183 	return XFS_PROJID_DEFAULT;
184 }
185 
186 static inline bool xfs_is_reflink_inode(struct xfs_inode *ip)
187 {
188 	return ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK;
189 }
190 
191 /*
192  * Check if an inode has any data in the COW fork.  This might be often false
193  * even for inodes with the reflink flag when there is no pending COW operation.
194  */
195 static inline bool xfs_inode_has_cow_data(struct xfs_inode *ip)
196 {
197 	return ip->i_cowfp && ip->i_cowfp->if_bytes;
198 }
199 
200 /*
201  * Return the buftarg used for data allocations on a given inode.
202  */
203 #define xfs_inode_buftarg(ip) \
204 	(XFS_IS_REALTIME_INODE(ip) ? \
205 		(ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp)
206 
207 /*
208  * In-core inode flags.
209  */
210 #define XFS_IRECLAIM		(1 << 0) /* started reclaiming this inode */
211 #define XFS_ISTALE		(1 << 1) /* inode has been staled */
212 #define XFS_IRECLAIMABLE	(1 << 2) /* inode can be reclaimed */
213 #define __XFS_INEW_BIT		3	 /* inode has just been allocated */
214 #define XFS_INEW		(1 << __XFS_INEW_BIT)
215 #define XFS_ITRUNCATED		(1 << 5) /* truncated down so flush-on-close */
216 #define XFS_IDIRTY_RELEASE	(1 << 6) /* dirty release already seen */
217 #define __XFS_IFLOCK_BIT	7	 /* inode is being flushed right now */
218 #define XFS_IFLOCK		(1 << __XFS_IFLOCK_BIT)
219 #define __XFS_IPINNED_BIT	8	 /* wakeup key for zero pin count */
220 #define XFS_IPINNED		(1 << __XFS_IPINNED_BIT)
221 #define XFS_IDONTCACHE		(1 << 9) /* don't cache the inode long term */
222 #define XFS_IEOFBLOCKS		(1 << 10)/* has the preallocblocks tag set */
223 /*
224  * If this unlinked inode is in the middle of recovery, don't let drop_inode
225  * truncate and free the inode.  This can happen if we iget the inode during
226  * log recovery to replay a bmap operation on the inode.
227  */
228 #define XFS_IRECOVERY		(1 << 11)
229 #define XFS_ICOWBLOCKS		(1 << 12)/* has the cowblocks tag set */
230 
231 /*
232  * Per-lifetime flags need to be reset when re-using a reclaimable inode during
233  * inode lookup. This prevents unintended behaviour on the new inode from
234  * ocurring.
235  */
236 #define XFS_IRECLAIM_RESET_FLAGS	\
237 	(XFS_IRECLAIMABLE | XFS_IRECLAIM | \
238 	 XFS_IDIRTY_RELEASE | XFS_ITRUNCATED)
239 
240 /*
241  * Synchronize processes attempting to flush the in-core inode back to disk.
242  */
243 
244 static inline int xfs_isiflocked(struct xfs_inode *ip)
245 {
246 	return xfs_iflags_test(ip, XFS_IFLOCK);
247 }
248 
249 extern void __xfs_iflock(struct xfs_inode *ip);
250 
251 static inline int xfs_iflock_nowait(struct xfs_inode *ip)
252 {
253 	return !xfs_iflags_test_and_set(ip, XFS_IFLOCK);
254 }
255 
256 static inline void xfs_iflock(struct xfs_inode *ip)
257 {
258 	if (!xfs_iflock_nowait(ip))
259 		__xfs_iflock(ip);
260 }
261 
262 static inline void xfs_ifunlock(struct xfs_inode *ip)
263 {
264 	ASSERT(xfs_isiflocked(ip));
265 	xfs_iflags_clear(ip, XFS_IFLOCK);
266 	smp_mb();
267 	wake_up_bit(&ip->i_flags, __XFS_IFLOCK_BIT);
268 }
269 
270 /*
271  * Flags for inode locking.
272  * Bit ranges:	1<<1  - 1<<16-1 -- iolock/ilock modes (bitfield)
273  *		1<<16 - 1<<32-1 -- lockdep annotation (integers)
274  */
275 #define	XFS_IOLOCK_EXCL		(1<<0)
276 #define	XFS_IOLOCK_SHARED	(1<<1)
277 #define	XFS_ILOCK_EXCL		(1<<2)
278 #define	XFS_ILOCK_SHARED	(1<<3)
279 #define	XFS_MMAPLOCK_EXCL	(1<<4)
280 #define	XFS_MMAPLOCK_SHARED	(1<<5)
281 
282 #define XFS_LOCK_MASK		(XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \
283 				| XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \
284 				| XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)
285 
286 #define XFS_LOCK_FLAGS \
287 	{ XFS_IOLOCK_EXCL,	"IOLOCK_EXCL" }, \
288 	{ XFS_IOLOCK_SHARED,	"IOLOCK_SHARED" }, \
289 	{ XFS_ILOCK_EXCL,	"ILOCK_EXCL" }, \
290 	{ XFS_ILOCK_SHARED,	"ILOCK_SHARED" }, \
291 	{ XFS_MMAPLOCK_EXCL,	"MMAPLOCK_EXCL" }, \
292 	{ XFS_MMAPLOCK_SHARED,	"MMAPLOCK_SHARED" }
293 
294 
295 /*
296  * Flags for lockdep annotations.
297  *
298  * XFS_LOCK_PARENT - for directory operations that require locking a
299  * parent directory inode and a child entry inode. IOLOCK requires nesting,
300  * MMAPLOCK does not support this class, ILOCK requires a single subclass
301  * to differentiate parent from child.
302  *
303  * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary
304  * inodes do not participate in the normal lock order, and thus have their
305  * own subclasses.
306  *
307  * XFS_LOCK_INUMORDER - for locking several inodes at the some time
308  * with xfs_lock_inodes().  This flag is used as the starting subclass
309  * and each subsequent lock acquired will increment the subclass by one.
310  * However, MAX_LOCKDEP_SUBCLASSES == 8, which means we are greatly
311  * limited to the subclasses we can represent via nesting. We need at least
312  * 5 inodes nest depth for the ILOCK through rename, and we also have to support
313  * XFS_ILOCK_PARENT, which gives 6 subclasses. Then we have XFS_ILOCK_RTBITMAP
314  * and XFS_ILOCK_RTSUM, which are another 2 unique subclasses, so that's all
315  * 8 subclasses supported by lockdep.
316  *
317  * This also means we have to number the sub-classes in the lowest bits of
318  * the mask we keep, and we have to ensure we never exceed 3 bits of lockdep
319  * mask and we can't use bit-masking to build the subclasses. What a mess.
320  *
321  * Bit layout:
322  *
323  * Bit		Lock Region
324  * 16-19	XFS_IOLOCK_SHIFT dependencies
325  * 20-23	XFS_MMAPLOCK_SHIFT dependencies
326  * 24-31	XFS_ILOCK_SHIFT dependencies
327  *
328  * IOLOCK values
329  *
330  * 0-3		subclass value
331  * 4-7		unused
332  *
333  * MMAPLOCK values
334  *
335  * 0-3		subclass value
336  * 4-7		unused
337  *
338  * ILOCK values
339  * 0-4		subclass values
340  * 5		PARENT subclass (not nestable)
341  * 6		RTBITMAP subclass (not nestable)
342  * 7		RTSUM subclass (not nestable)
343  *
344  */
345 #define XFS_IOLOCK_SHIFT		16
346 #define XFS_IOLOCK_MAX_SUBCLASS		3
347 #define XFS_IOLOCK_DEP_MASK		0x000f0000
348 
349 #define XFS_MMAPLOCK_SHIFT		20
350 #define XFS_MMAPLOCK_NUMORDER		0
351 #define XFS_MMAPLOCK_MAX_SUBCLASS	3
352 #define XFS_MMAPLOCK_DEP_MASK		0x00f00000
353 
354 #define XFS_ILOCK_SHIFT			24
355 #define XFS_ILOCK_PARENT_VAL		5
356 #define XFS_ILOCK_MAX_SUBCLASS		(XFS_ILOCK_PARENT_VAL - 1)
357 #define XFS_ILOCK_RTBITMAP_VAL		6
358 #define XFS_ILOCK_RTSUM_VAL		7
359 #define XFS_ILOCK_DEP_MASK		0xff000000
360 #define	XFS_ILOCK_PARENT		(XFS_ILOCK_PARENT_VAL << XFS_ILOCK_SHIFT)
361 #define	XFS_ILOCK_RTBITMAP		(XFS_ILOCK_RTBITMAP_VAL << XFS_ILOCK_SHIFT)
362 #define	XFS_ILOCK_RTSUM			(XFS_ILOCK_RTSUM_VAL << XFS_ILOCK_SHIFT)
363 
364 #define XFS_LOCK_SUBCLASS_MASK	(XFS_IOLOCK_DEP_MASK | \
365 				 XFS_MMAPLOCK_DEP_MASK | \
366 				 XFS_ILOCK_DEP_MASK)
367 
368 #define XFS_IOLOCK_DEP(flags)	(((flags) & XFS_IOLOCK_DEP_MASK) \
369 					>> XFS_IOLOCK_SHIFT)
370 #define XFS_MMAPLOCK_DEP(flags)	(((flags) & XFS_MMAPLOCK_DEP_MASK) \
371 					>> XFS_MMAPLOCK_SHIFT)
372 #define XFS_ILOCK_DEP(flags)	(((flags) & XFS_ILOCK_DEP_MASK) \
373 					>> XFS_ILOCK_SHIFT)
374 
375 /*
376  * Layouts are broken in the BREAK_WRITE case to ensure that
377  * layout-holders do not collide with local writes. Additionally,
378  * layouts are broken in the BREAK_UNMAP case to make sure the
379  * layout-holder has a consistent view of the file's extent map. While
380  * BREAK_WRITE breaks can be satisfied by recalling FL_LAYOUT leases,
381  * BREAK_UNMAP breaks additionally require waiting for busy dax-pages to
382  * go idle.
383  */
384 enum layout_break_reason {
385         BREAK_WRITE,
386         BREAK_UNMAP,
387 };
388 
389 /*
390  * For multiple groups support: if S_ISGID bit is set in the parent
391  * directory, group of new file is set to that of the parent, and
392  * new subdirectory gets S_ISGID bit from parent.
393  */
394 #define XFS_INHERIT_GID(pip)	\
395 	(((pip)->i_mount->m_flags & XFS_MOUNT_GRPID) || \
396 	 (VFS_I(pip)->i_mode & S_ISGID))
397 
398 int		xfs_release(struct xfs_inode *ip);
399 void		xfs_inactive(struct xfs_inode *ip);
400 int		xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
401 			   struct xfs_inode **ipp, struct xfs_name *ci_name);
402 int		xfs_create(struct xfs_inode *dp, struct xfs_name *name,
403 			   umode_t mode, dev_t rdev, struct xfs_inode **ipp);
404 int		xfs_create_tmpfile(struct xfs_inode *dp, umode_t mode,
405 			   struct xfs_inode **ipp);
406 int		xfs_remove(struct xfs_inode *dp, struct xfs_name *name,
407 			   struct xfs_inode *ip);
408 int		xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,
409 			 struct xfs_name *target_name);
410 int		xfs_rename(struct xfs_inode *src_dp, struct xfs_name *src_name,
411 			   struct xfs_inode *src_ip, struct xfs_inode *target_dp,
412 			   struct xfs_name *target_name,
413 			   struct xfs_inode *target_ip, unsigned int flags);
414 
415 void		xfs_ilock(xfs_inode_t *, uint);
416 int		xfs_ilock_nowait(xfs_inode_t *, uint);
417 void		xfs_iunlock(xfs_inode_t *, uint);
418 void		xfs_ilock_demote(xfs_inode_t *, uint);
419 int		xfs_isilocked(xfs_inode_t *, uint);
420 uint		xfs_ilock_data_map_shared(struct xfs_inode *);
421 uint		xfs_ilock_attr_map_shared(struct xfs_inode *);
422 
423 uint		xfs_ip2xflags(struct xfs_inode *);
424 int		xfs_ifree(struct xfs_trans *, struct xfs_inode *);
425 int		xfs_itruncate_extents_flags(struct xfs_trans **,
426 				struct xfs_inode *, int, xfs_fsize_t, int);
427 void		xfs_iext_realloc(xfs_inode_t *, int, int);
428 
429 void		xfs_iunpin_wait(xfs_inode_t *);
430 #define xfs_ipincount(ip)	((unsigned int) atomic_read(&ip->i_pincount))
431 
432 int		xfs_iflush(struct xfs_inode *, struct xfs_buf **);
433 void		xfs_lock_two_inodes(struct xfs_inode *ip0, uint ip0_mode,
434 				struct xfs_inode *ip1, uint ip1_mode);
435 
436 xfs_extlen_t	xfs_get_extsz_hint(struct xfs_inode *ip);
437 xfs_extlen_t	xfs_get_cowextsz_hint(struct xfs_inode *ip);
438 
439 int		xfs_dir_ialloc(struct xfs_trans **, struct xfs_inode *, umode_t,
440 			       xfs_nlink_t, dev_t, prid_t,
441 			       struct xfs_inode **);
442 
443 static inline int
444 xfs_itruncate_extents(
445 	struct xfs_trans	**tpp,
446 	struct xfs_inode	*ip,
447 	int			whichfork,
448 	xfs_fsize_t		new_size)
449 {
450 	return xfs_itruncate_extents_flags(tpp, ip, whichfork, new_size, 0);
451 }
452 
453 /* from xfs_file.c */
454 enum xfs_prealloc_flags {
455 	XFS_PREALLOC_SET	= (1 << 1),
456 	XFS_PREALLOC_CLEAR	= (1 << 2),
457 	XFS_PREALLOC_SYNC	= (1 << 3),
458 	XFS_PREALLOC_INVISIBLE	= (1 << 4),
459 };
460 
461 int	xfs_update_prealloc_flags(struct xfs_inode *ip,
462 				  enum xfs_prealloc_flags flags);
463 int	xfs_break_layouts(struct inode *inode, uint *iolock,
464 		enum layout_break_reason reason);
465 
466 /* from xfs_iops.c */
467 extern void xfs_setup_inode(struct xfs_inode *ip);
468 extern void xfs_setup_iops(struct xfs_inode *ip);
469 
470 /*
471  * When setting up a newly allocated inode, we need to call
472  * xfs_finish_inode_setup() once the inode is fully instantiated at
473  * the VFS level to prevent the rest of the world seeing the inode
474  * before we've completed instantiation. Otherwise we can do it
475  * the moment the inode lookup is complete.
476  */
477 static inline void xfs_finish_inode_setup(struct xfs_inode *ip)
478 {
479 	xfs_iflags_clear(ip, XFS_INEW);
480 	barrier();
481 	unlock_new_inode(VFS_I(ip));
482 	wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
483 }
484 
485 static inline void xfs_setup_existing_inode(struct xfs_inode *ip)
486 {
487 	xfs_setup_inode(ip);
488 	xfs_setup_iops(ip);
489 	xfs_finish_inode_setup(ip);
490 }
491 
492 void xfs_irele(struct xfs_inode *ip);
493 
494 extern struct kmem_zone	*xfs_inode_zone;
495 
496 /* The default CoW extent size hint. */
497 #define XFS_DEFAULT_COWEXTSZ_HINT 32
498 
499 bool xfs_inode_verify_forks(struct xfs_inode *ip);
500 
501 int xfs_iunlink_init(struct xfs_perag *pag);
502 void xfs_iunlink_destroy(struct xfs_perag *pag);
503 
504 void xfs_end_io(struct work_struct *work);
505 
506 #endif	/* __XFS_INODE_H__ */
507