super_types.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _LINUX_FS_SUPER_TYPES_H
  3#define _LINUX_FS_SUPER_TYPES_H
  4
  5#include <linux/fs_dirent.h>
  6#include <linux/errseq.h>
  7#include <linux/list_lru.h>
  8#include <linux/list.h>
  9#include <linux/list_bl.h>
 10#include <linux/llist.h>
 11#include <linux/uidgid.h>
 12#include <linux/uuid.h>
 13#include <linux/percpu-rwsem.h>
 14#include <linux/workqueue_types.h>
 15#include <linux/quota.h>
 16
 17struct backing_dev_info;
 18struct block_device;
 19struct dentry;
 20struct dentry_operations;
 21struct dquot_operations;
 22struct export_operations;
 23struct file;
 24struct file_system_type;
 25struct fscrypt_operations;
 26struct fsnotify_sb_info;
 27struct fsverity_operations;
 28struct kstatfs;
 29struct mount;
 30struct mtd_info;
 31struct quotactl_ops;
 32struct shrinker;
 33struct unicode_map;
 34struct user_namespace;
 35struct workqueue_struct;
 36struct writeback_control;
 37struct xattr_handler;
 38
 39extern struct super_block *blockdev_superblock;
 40
 41/* Possible states of 'frozen' field */
 42enum {
 43	SB_UNFROZEN		= 0,	/* FS is unfrozen */
 44	SB_FREEZE_WRITE		= 1,	/* Writes, dir ops, ioctls frozen */
 45	SB_FREEZE_PAGEFAULT	= 2,	/* Page faults stopped as well */
 46	SB_FREEZE_FS		= 3,	/* For internal FS use (e.g. to stop internal threads if needed) */
 47	SB_FREEZE_COMPLETE	= 4,	/* ->freeze_fs finished successfully */
 48};
 49
 50#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
 51
 52struct sb_writers {
 53	unsigned short			frozen;		/* Is sb frozen? */
 54	int				freeze_kcount;	/* How many kernel freeze requests? */
 55	int				freeze_ucount;	/* How many userspace freeze requests? */
 56	const void			*freeze_owner;	/* Owner of the freeze */
 57	struct percpu_rw_semaphore	rw_sem[SB_FREEZE_LEVELS];
 58};
 59
 60/**
 61 * enum freeze_holder - holder of the freeze
 62 * @FREEZE_HOLDER_KERNEL: kernel wants to freeze or thaw filesystem
 63 * @FREEZE_HOLDER_USERSPACE: userspace wants to freeze or thaw filesystem
 64 * @FREEZE_MAY_NEST: whether nesting freeze and thaw requests is allowed
 65 * @FREEZE_EXCL: a freeze that can only be undone by the owner
 66 *
 67 * Indicate who the owner of the freeze or thaw request is and whether
 68 * the freeze needs to be exclusive or can nest.
 69 * Without @FREEZE_MAY_NEST, multiple freeze and thaw requests from the
 70 * same holder aren't allowed. It is however allowed to hold a single
 71 * @FREEZE_HOLDER_USERSPACE and a single @FREEZE_HOLDER_KERNEL freeze at
 72 * the same time. This is relied upon by some filesystems during online
 73 * repair or similar.
 74 */
 75enum freeze_holder {
 76	FREEZE_HOLDER_KERNEL	= (1U << 0),
 77	FREEZE_HOLDER_USERSPACE	= (1U << 1),
 78	FREEZE_MAY_NEST		= (1U << 2),
 79	FREEZE_EXCL		= (1U << 3),
 80};
 81
 82struct super_operations {
 83	struct inode *(*alloc_inode)(struct super_block *sb);
 84	void (*destroy_inode)(struct inode *inode);
 85	void (*free_inode)(struct inode *inode);
 86	void (*dirty_inode)(struct inode *inode, int flags);
 87	int (*write_inode)(struct inode *inode, struct writeback_control *wbc);
 88	int (*drop_inode)(struct inode *inode);
 89	void (*evict_inode)(struct inode *inode);
 90	void (*put_super)(struct super_block *sb);
 91	int (*sync_fs)(struct super_block *sb, int wait);
 92	int (*freeze_super)(struct super_block *sb, enum freeze_holder who,
 93			    const void *owner);
 94	int (*freeze_fs)(struct super_block *sb);
 95	int (*thaw_super)(struct super_block *sb, enum freeze_holder who,
 96			  const void *owner);
 97	int (*unfreeze_fs)(struct super_block *sb);
 98	int (*statfs)(struct dentry *dentry, struct kstatfs *kstatfs);
 99	int (*remount_fs) (struct super_block *, int *, char *);
100	void (*umount_begin)(struct super_block *sb);
101
102	int (*show_options)(struct seq_file *seq, struct dentry *dentry);
103	int (*show_devname)(struct seq_file *seq, struct dentry *dentry);
104	int (*show_path)(struct seq_file *seq, struct dentry *dentry);
105	int (*show_stats)(struct seq_file *seq, struct dentry *dentry);
106#ifdef CONFIG_QUOTA
107	ssize_t (*quota_read)(struct super_block *sb, int type, char *data,
108			      size_t len, loff_t off);
109	ssize_t (*quota_write)(struct super_block *sb, int type,
110			       const char *data, size_t len, loff_t off);
111	struct dquot __rcu **(*get_dquots)(struct inode *inode);
112#endif
113	long (*nr_cached_objects)(struct super_block *sb,
114				  struct shrink_control *sc);
115	long (*free_cached_objects)(struct super_block *sb,
116				    struct shrink_control *sc);
117	/*
118	 * If a filesystem can support graceful removal of a device and
119	 * continue read-write operations, implement this callback.
120	 *
121	 * Return 0 if the filesystem can continue read-write.
122	 * Non-zero return value or no such callback means the fs will be shutdown
123	 * as usual.
124	 */
125	int (*remove_bdev)(struct super_block *sb, struct block_device *bdev);
126	void (*shutdown)(struct super_block *sb);
127};
128
129struct super_block {
130	struct list_head			s_list;		/* Keep this first */
131	dev_t					s_dev;		/* search index; _not_ kdev_t */
132	unsigned char				s_blocksize_bits;
133	unsigned long				s_blocksize;
134	loff_t					s_maxbytes;	/* Max file size */
135	struct file_system_type			*s_type;
136	const struct super_operations		*s_op;
137	const struct dquot_operations		*dq_op;
138	const struct quotactl_ops		*s_qcop;
139	const struct export_operations		*s_export_op;
140	unsigned long				s_flags;
141	unsigned long				s_iflags;	/* internal SB_I_* flags */
142	unsigned long				s_magic;
143	struct dentry				*s_root;
144	struct rw_semaphore			s_umount;
145	int					s_count;
146	atomic_t				s_active;
147#ifdef CONFIG_SECURITY
148	void					*s_security;
149#endif
150	const struct xattr_handler		*const *s_xattr;
151#ifdef CONFIG_FS_ENCRYPTION
152	const struct fscrypt_operations		*s_cop;
153	struct fscrypt_keyring			*s_master_keys; /* master crypto keys in use */
154#endif
155#ifdef CONFIG_FS_VERITY
156	const struct fsverity_operations	*s_vop;
157#endif
158#if IS_ENABLED(CONFIG_UNICODE)
159	struct unicode_map			*s_encoding;
160	__u16					s_encoding_flags;
161#endif
162	struct hlist_bl_head			s_roots;	/* alternate root dentries for NFS */
163	struct mount				*s_mounts;	/* list of mounts; _not_ for fs use */
164	struct block_device			*s_bdev;	/* can go away once we use an accessor for @s_bdev_file */
165	struct file				*s_bdev_file;
166	struct backing_dev_info 		*s_bdi;
167	struct mtd_info				*s_mtd;
168	struct hlist_node			s_instances;
169	unsigned int				s_quota_types;	/* Bitmask of supported quota types */
170	struct quota_info			s_dquot;	/* Diskquota specific options */
171
172	struct sb_writers			s_writers;
173
174	/*
175	 * Keep s_fs_info, s_time_gran, s_fsnotify_mask, and
176	 * s_fsnotify_info together for cache efficiency. They are frequently
177	 * accessed and rarely modified.
178	 */
179	void					*s_fs_info;	/* Filesystem private info */
180
181	/* Granularity of c/m/atime in ns (cannot be worse than a second) */
182	u32					s_time_gran;
183	/* Time limits for c/m/atime in seconds */
184	time64_t				s_time_min;
185	time64_t		   		s_time_max;
186#ifdef CONFIG_FSNOTIFY
187	u32					s_fsnotify_mask;
188	struct fsnotify_sb_info			*s_fsnotify_info;
189#endif
190
191	/*
192	 * q: why are s_id and s_sysfs_name not the same? both are human
193	 * readable strings that identify the filesystem
194	 * a: s_id is allowed to change at runtime; it's used in log messages,
195	 * and we want to when a device starts out as single device (s_id is dev
196	 * name) but then a device is hot added and we have to switch to
197	 * identifying it by UUID
198	 * but s_sysfs_name is a handle for programmatic access, and can't
199	 * change at runtime
200	 */
201	char					s_id[32];	/* Informational name */
202	uuid_t					s_uuid;		/* UUID */
203	u8					s_uuid_len;	/* Default 16, possibly smaller for weird filesystems */
204
205	/* if set, fs shows up under sysfs at /sys/fs/$FSTYP/s_sysfs_name */
206	char					s_sysfs_name[UUID_STRING_LEN + 1];
207
208	unsigned int				s_max_links;
209	unsigned int				s_d_flags;	/* default d_flags for dentries */
210
211	/*
212	 * The next field is for VFS *only*. No filesystems have any business
213	 * even looking at it. You had been warned.
214	 */
215	struct mutex				s_vfs_rename_mutex;	/* Kludge */
216
217	/*
218	 * Filesystem subtype.  If non-empty the filesystem type field
219	 * in /proc/mounts will be "type.subtype"
220	 */
221	const char				*s_subtype;
222
223	const struct dentry_operations		*__s_d_op; /* default d_op for dentries */
224
225	struct shrinker				*s_shrink;	/* per-sb shrinker handle */
226
227	/* Number of inodes with nlink == 0 but still referenced */
228	atomic_long_t				s_remove_count;
229
230	/* Read-only state of the superblock is being changed */
231	int					s_readonly_remount;
232
233	/* per-sb errseq_t for reporting writeback errors via syncfs */
234	errseq_t s_wb_err;
235
236	/* AIO completions deferred from interrupt context */
237	struct workqueue_struct			*s_dio_done_wq;
238	struct hlist_head			s_pins;
239
240	/*
241	 * Owning user namespace and default context in which to
242	 * interpret filesystem uids, gids, quotas, device nodes,
243	 * xattrs and security labels.
244	 */
245	struct user_namespace			*s_user_ns;
246
247	/*
248	 * The list_lru structure is essentially just a pointer to a table
249	 * of per-node lru lists, each of which has its own spinlock.
250	 * There is no need to put them into separate cachelines.
251	 */
252	struct list_lru				s_dentry_lru;
253	struct list_lru				s_inode_lru;
254	struct rcu_head				rcu;
255	struct work_struct			destroy_work;
256
257	struct mutex				s_sync_lock;	/* sync serialisation lock */
258
259	/*
260	 * Indicates how deep in a filesystem stack this SB is
261	 */
262	int s_stack_depth;
263
264	/* s_inode_list_lock protects s_inodes */
265	spinlock_t				s_inode_list_lock ____cacheline_aligned_in_smp;
266	struct list_head			s_inodes;	/* all inodes */
267
268	spinlock_t				s_inode_wblist_lock;
269	struct list_head			s_inodes_wb;	/* writeback inodes */
270	long					s_min_writeback_pages;
271} __randomize_layout;
272
273/*
274 * sb->s_flags.  Note that these mirror the equivalent MS_* flags where
275 * represented in both.
276 */
277#define SB_RDONLY       BIT(0)	/* Mount read-only */
278#define SB_NOSUID       BIT(1)	/* Ignore suid and sgid bits */
279#define SB_NODEV        BIT(2)	/* Disallow access to device special files */
280#define SB_NOEXEC       BIT(3)	/* Disallow program execution */
281#define SB_SYNCHRONOUS  BIT(4)	/* Writes are synced at once */
282#define SB_MANDLOCK     BIT(6)	/* Allow mandatory locks on an FS */
283#define SB_DIRSYNC      BIT(7)	/* Directory modifications are synchronous */
284#define SB_NOATIME      BIT(10)	/* Do not update access times. */
285#define SB_NODIRATIME   BIT(11)	/* Do not update directory access times */
286#define SB_SILENT       BIT(15)
287#define SB_POSIXACL     BIT(16)	/* Supports POSIX ACLs */
288#define SB_INLINECRYPT  BIT(17)	/* Use blk-crypto for encrypted files */
289#define SB_KERNMOUNT    BIT(22)	/* this is a kern_mount call */
290#define SB_I_VERSION    BIT(23)	/* Update inode I_version field */
291#define SB_LAZYTIME     BIT(25)	/* Update the on-disk [acm]times lazily */
292
293/* These sb flags are internal to the kernel */
294#define SB_DEAD         BIT(21)
295#define SB_DYING        BIT(24)
296#define SB_FORCE        BIT(27)
297#define SB_NOSEC        BIT(28)
298#define SB_BORN         BIT(29)
299#define SB_ACTIVE       BIT(30)
300#define SB_NOUSER       BIT(31)
301
302/* These flags relate to encoding and casefolding */
303#define SB_ENC_STRICT_MODE_FL		(1 << 0)
304#define SB_ENC_NO_COMPAT_FALLBACK_FL	(1 << 1)
305
306#define sb_has_strict_encoding(sb) \
307	(sb->s_encoding_flags & SB_ENC_STRICT_MODE_FL)
308
309#if IS_ENABLED(CONFIG_UNICODE)
310#define sb_no_casefold_compat_fallback(sb) \
311	(sb->s_encoding_flags & SB_ENC_NO_COMPAT_FALLBACK_FL)
312#else
313#define sb_no_casefold_compat_fallback(sb) (1)
314#endif
315
316/* sb->s_iflags */
317#define SB_I_CGROUPWB	0x00000001	/* cgroup-aware writeback enabled */
318#define SB_I_NOEXEC	0x00000002	/* Ignore executables on this fs */
319#define SB_I_NODEV	0x00000004	/* Ignore devices on this fs */
320#define SB_I_STABLE_WRITES 0x00000008	/* don't modify blks until WB is done */
321
322/* sb->s_iflags to limit user namespace mounts */
323#define SB_I_USERNS_VISIBLE		0x00000010 /* fstype already mounted */
324#define SB_I_IMA_UNVERIFIABLE_SIGNATURE	0x00000020
325#define SB_I_UNTRUSTED_MOUNTER		0x00000040
326#define SB_I_EVM_HMAC_UNSUPPORTED	0x00000080
327
328#define SB_I_SKIP_SYNC	0x00000100	/* Skip superblock at global sync */
329#define SB_I_PERSB_BDI	0x00000200	/* has a per-sb bdi */
330#define SB_I_TS_EXPIRY_WARNED 0x00000400 /* warned about timestamp range expiry */
331#define SB_I_RETIRED	0x00000800	/* superblock shouldn't be reused */
332#define SB_I_NOUMASK	0x00001000	/* VFS does not apply umask */
333#define SB_I_NOIDMAP	0x00002000	/* No idmapped mounts on this superblock */
334#define SB_I_ALLOW_HSM	0x00004000	/* Allow HSM events on this superblock */
335#define SB_I_NO_DATA_INTEGRITY	0x00008000 /* fs cannot guarantee data persistence on sync */
336
337#endif /* _LINUX_FS_SUPER_TYPES_H */