[go: up one dir, main page]
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_FS_SUPER_H
3#define _LINUX_FS_SUPER_H
4
5#include <linux/fs/super_types.h>
6#include <linux/unicode.h>
7
8/*
9 * These are internal functions, please use sb_start_{write,pagefault,intwrite}
10 * instead.
11 */
12static inline void __sb_end_write(struct super_block *sb, int level)
13{
14 percpu_up_read(sem: sb->s_writers.rw_sem + level - 1);
15}
16
17static inline void __sb_start_write(struct super_block *sb, int level)
18{
19 percpu_down_read_freezable(sem: sb->s_writers.rw_sem + level - 1, freeze: true);
20}
21
22static inline bool __sb_start_write_trylock(struct super_block *sb, int level)
23{
24 return percpu_down_read_trylock(sem: sb->s_writers.rw_sem + level - 1);
25}
26
27#define __sb_writers_acquired(sb, lev) \
28 percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev) - 1], 1, _THIS_IP_)
29#define __sb_writers_release(sb, lev) \
30 percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev) - 1], _THIS_IP_)
31
32/**
33 * __sb_write_started - check if sb freeze level is held
34 * @sb: the super we write to
35 * @level: the freeze level
36 *
37 * * > 0 - sb freeze level is held
38 * * 0 - sb freeze level is not held
39 * * < 0 - !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN
40 */
41static inline int __sb_write_started(const struct super_block *sb, int level)
42{
43 return lockdep_is_held_type(sb->s_writers.rw_sem + level - 1, 1);
44}
45
46/**
47 * sb_write_started - check if SB_FREEZE_WRITE is held
48 * @sb: the super we write to
49 *
50 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
51 */
52static inline bool sb_write_started(const struct super_block *sb)
53{
54 return __sb_write_started(sb, level: SB_FREEZE_WRITE);
55}
56
57/**
58 * sb_write_not_started - check if SB_FREEZE_WRITE is not held
59 * @sb: the super we write to
60 *
61 * May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
62 */
63static inline bool sb_write_not_started(const struct super_block *sb)
64{
65 return __sb_write_started(sb, level: SB_FREEZE_WRITE) <= 0;
66}
67
68/**
69 * sb_end_write - drop write access to a superblock
70 * @sb: the super we wrote to
71 *
72 * Decrement number of writers to the filesystem. Wake up possible waiters
73 * wanting to freeze the filesystem.
74 */
75static inline void sb_end_write(struct super_block *sb)
76{
77 __sb_end_write(sb, level: SB_FREEZE_WRITE);
78}
79
80/**
81 * sb_end_pagefault - drop write access to a superblock from a page fault
82 * @sb: the super we wrote to
83 *
84 * Decrement number of processes handling write page fault to the filesystem.
85 * Wake up possible waiters wanting to freeze the filesystem.
86 */
87static inline void sb_end_pagefault(struct super_block *sb)
88{
89 __sb_end_write(sb, level: SB_FREEZE_PAGEFAULT);
90}
91
92/**
93 * sb_end_intwrite - drop write access to a superblock for internal fs purposes
94 * @sb: the super we wrote to
95 *
96 * Decrement fs-internal number of writers to the filesystem. Wake up possible
97 * waiters wanting to freeze the filesystem.
98 */
99static inline void sb_end_intwrite(struct super_block *sb)
100{
101 __sb_end_write(sb, level: SB_FREEZE_FS);
102}
103
104/**
105 * sb_start_write - get write access to a superblock
106 * @sb: the super we write to
107 *
108 * When a process wants to write data or metadata to a file system (i.e. dirty
109 * a page or an inode), it should embed the operation in a sb_start_write() -
110 * sb_end_write() pair to get exclusion against file system freezing. This
111 * function increments number of writers preventing freezing. If the file
112 * system is already frozen, the function waits until the file system is
113 * thawed.
114 *
115 * Since freeze protection behaves as a lock, users have to preserve
116 * ordering of freeze protection and other filesystem locks. Generally,
117 * freeze protection should be the outermost lock. In particular, we have:
118 *
119 * sb_start_write
120 * -> i_rwsem (write path, truncate, directory ops, ...)
121 * -> s_umount (freeze_super, thaw_super)
122 */
123static inline void sb_start_write(struct super_block *sb)
124{
125 __sb_start_write(sb, level: SB_FREEZE_WRITE);
126}
127
128DEFINE_GUARD(super_write,
129 struct super_block *,
130 sb_start_write(_T),
131 sb_end_write(_T))
132
133static inline bool sb_start_write_trylock(struct super_block *sb)
134{
135 return __sb_start_write_trylock(sb, level: SB_FREEZE_WRITE);
136}
137
138/**
139 * sb_start_pagefault - get write access to a superblock from a page fault
140 * @sb: the super we write to
141 *
142 * When a process starts handling write page fault, it should embed the
143 * operation into sb_start_pagefault() - sb_end_pagefault() pair to get
144 * exclusion against file system freezing. This is needed since the page fault
145 * is going to dirty a page. This function increments number of running page
146 * faults preventing freezing. If the file system is already frozen, the
147 * function waits until the file system is thawed.
148 *
149 * Since page fault freeze protection behaves as a lock, users have to preserve
150 * ordering of freeze protection and other filesystem locks. It is advised to
151 * put sb_start_pagefault() close to mmap_lock in lock ordering. Page fault
152 * handling code implies lock dependency:
153 *
154 * mmap_lock
155 * -> sb_start_pagefault
156 */
157static inline void sb_start_pagefault(struct super_block *sb)
158{
159 __sb_start_write(sb, level: SB_FREEZE_PAGEFAULT);
160}
161
162/**
163 * sb_start_intwrite - get write access to a superblock for internal fs purposes
164 * @sb: the super we write to
165 *
166 * This is the third level of protection against filesystem freezing. It is
167 * free for use by a filesystem. The only requirement is that it must rank
168 * below sb_start_pagefault.
169 *
170 * For example filesystem can call sb_start_intwrite() when starting a
171 * transaction which somewhat eases handling of freezing for internal sources
172 * of filesystem changes (internal fs threads, discarding preallocation on file
173 * close, etc.).
174 */
175static inline void sb_start_intwrite(struct super_block *sb)
176{
177 __sb_start_write(sb, level: SB_FREEZE_FS);
178}
179
180static inline bool sb_start_intwrite_trylock(struct super_block *sb)
181{
182 return __sb_start_write_trylock(sb, level: SB_FREEZE_FS);
183}
184
185static inline bool sb_rdonly(const struct super_block *sb)
186{
187 return sb->s_flags & SB_RDONLY;
188}
189
190static inline bool sb_is_blkdev_sb(struct super_block *sb)
191{
192 return IS_ENABLED(CONFIG_BLOCK) && sb == blockdev_superblock;
193}
194
195#if IS_ENABLED(CONFIG_UNICODE)
196static inline struct unicode_map *sb_encoding(const struct super_block *sb)
197{
198 return sb->s_encoding;
199}
200
201/* Compare if two super blocks have the same encoding and flags */
202static inline bool sb_same_encoding(const struct super_block *sb1,
203 const struct super_block *sb2)
204{
205 if (sb1->s_encoding == sb2->s_encoding)
206 return true;
207
208 return (sb1->s_encoding && sb2->s_encoding &&
209 (sb1->s_encoding->version == sb2->s_encoding->version) &&
210 (sb1->s_encoding_flags == sb2->s_encoding_flags));
211}
212#else
213static inline struct unicode_map *sb_encoding(const struct super_block *sb)
214{
215 return NULL;
216}
217
218static inline bool sb_same_encoding(const struct super_block *sb1,
219 const struct super_block *sb2)
220{
221 return true;
222}
223#endif
224
225static inline bool sb_has_encoding(const struct super_block *sb)
226{
227 return !!sb_encoding(sb);
228}
229
230int sb_set_blocksize(struct super_block *sb, int size);
231int __must_check sb_min_blocksize(struct super_block *sb, int size);
232
233int freeze_super(struct super_block *super, enum freeze_holder who,
234 const void *freeze_owner);
235int thaw_super(struct super_block *super, enum freeze_holder who,
236 const void *freeze_owner);
237
238#endif /* _LINUX_FS_SUPER_H */
239

source code of linux/include/linux/fs/super.h