1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* Internal definitions for network filesystem support
3 *
4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/slab.h>
9 #include <linux/seq_file.h>
10 #include <linux/netfs.h>
11 #include <linux/fscache.h>
12 #include <linux/fscache-cache.h>
13 #include <trace/events/netfs.h>
14 #include <trace/events/fscache.h>
15
16 #ifdef pr_fmt
17 #undef pr_fmt
18 #endif
19
20 #define pr_fmt(fmt) "netfs: " fmt
21
22 /*
23 * buffered_read.c
24 */
25 void netfs_rreq_unlock_folios(struct netfs_io_request *rreq);
26 int netfs_prefetch_for_write(struct file *file, struct folio *folio,
27 size_t offset, size_t len);
28
29 /*
30 * io.c
31 */
32 int netfs_begin_read(struct netfs_io_request *rreq, bool sync);
33
34 /*
35 * main.c
36 */
37 extern unsigned int netfs_debug;
38 extern struct list_head netfs_io_requests;
39 extern spinlock_t netfs_proc_lock;
40
41 #ifdef CONFIG_PROC_FS
netfs_proc_add_rreq(struct netfs_io_request * rreq)42 static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq)
43 {
44 spin_lock(&netfs_proc_lock);
45 list_add_tail_rcu(&rreq->proc_link, &netfs_io_requests);
46 spin_unlock(&netfs_proc_lock);
47 }
netfs_proc_del_rreq(struct netfs_io_request * rreq)48 static inline void netfs_proc_del_rreq(struct netfs_io_request *rreq)
49 {
50 if (!list_empty(&rreq->proc_link)) {
51 spin_lock(&netfs_proc_lock);
52 list_del_rcu(&rreq->proc_link);
53 spin_unlock(&netfs_proc_lock);
54 }
55 }
56 #else
netfs_proc_add_rreq(struct netfs_io_request * rreq)57 static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {}
netfs_proc_del_rreq(struct netfs_io_request * rreq)58 static inline void netfs_proc_del_rreq(struct netfs_io_request *rreq) {}
59 #endif
60
61 /*
62 * misc.c
63 */
64 #define NETFS_FLAG_PUT_MARK BIT(0)
65 #define NETFS_FLAG_PAGECACHE_MARK BIT(1)
66 int netfs_xa_store_and_mark(struct xarray *xa, unsigned long index,
67 struct folio *folio, unsigned int flags,
68 gfp_t gfp_mask);
69 int netfs_add_folios_to_buffer(struct xarray *buffer,
70 struct address_space *mapping,
71 pgoff_t index, pgoff_t to, gfp_t gfp_mask);
72 void netfs_clear_buffer(struct xarray *buffer);
73
74 /*
75 * objects.c
76 */
77 struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
78 struct file *file,
79 loff_t start, size_t len,
80 enum netfs_io_origin origin);
81 void netfs_get_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace what);
82 void netfs_clear_subrequests(struct netfs_io_request *rreq, bool was_async);
83 void netfs_put_request(struct netfs_io_request *rreq, bool was_async,
84 enum netfs_rreq_ref_trace what);
85 struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq);
86
netfs_see_request(struct netfs_io_request * rreq,enum netfs_rreq_ref_trace what)87 static inline void netfs_see_request(struct netfs_io_request *rreq,
88 enum netfs_rreq_ref_trace what)
89 {
90 trace_netfs_rreq_ref(rreq->debug_id, refcount_read(&rreq->ref), what);
91 }
92
93 /*
94 * output.c
95 */
96 int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,
97 enum netfs_write_trace what);
98 struct netfs_io_request *netfs_begin_writethrough(struct kiocb *iocb, size_t len);
99 int netfs_advance_writethrough(struct netfs_io_request *wreq, size_t copied, bool to_page_end);
100 int netfs_end_writethrough(struct netfs_io_request *wreq, struct kiocb *iocb);
101
102 /*
103 * stats.c
104 */
105 #ifdef CONFIG_NETFS_STATS
106 extern atomic_t netfs_n_rh_dio_read;
107 extern atomic_t netfs_n_rh_dio_write;
108 extern atomic_t netfs_n_rh_readahead;
109 extern atomic_t netfs_n_rh_readpage;
110 extern atomic_t netfs_n_rh_rreq;
111 extern atomic_t netfs_n_rh_sreq;
112 extern atomic_t netfs_n_rh_download;
113 extern atomic_t netfs_n_rh_download_done;
114 extern atomic_t netfs_n_rh_download_failed;
115 extern atomic_t netfs_n_rh_download_instead;
116 extern atomic_t netfs_n_rh_read;
117 extern atomic_t netfs_n_rh_read_done;
118 extern atomic_t netfs_n_rh_read_failed;
119 extern atomic_t netfs_n_rh_zero;
120 extern atomic_t netfs_n_rh_short_read;
121 extern atomic_t netfs_n_rh_write;
122 extern atomic_t netfs_n_rh_write_begin;
123 extern atomic_t netfs_n_rh_write_done;
124 extern atomic_t netfs_n_rh_write_failed;
125 extern atomic_t netfs_n_rh_write_zskip;
126 extern atomic_t netfs_n_wh_wstream_conflict;
127 extern atomic_t netfs_n_wh_upload;
128 extern atomic_t netfs_n_wh_upload_done;
129 extern atomic_t netfs_n_wh_upload_failed;
130 extern atomic_t netfs_n_wh_write;
131 extern atomic_t netfs_n_wh_write_done;
132 extern atomic_t netfs_n_wh_write_failed;
133
134 int netfs_stats_show(struct seq_file *m, void *v);
135
netfs_stat(atomic_t * stat)136 static inline void netfs_stat(atomic_t *stat)
137 {
138 atomic_inc(stat);
139 }
140
netfs_stat_d(atomic_t * stat)141 static inline void netfs_stat_d(atomic_t *stat)
142 {
143 atomic_dec(stat);
144 }
145
146 #else
147 #define netfs_stat(x) do {} while(0)
148 #define netfs_stat_d(x) do {} while(0)
149 #endif
150
151 /*
152 * Miscellaneous functions.
153 */
netfs_is_cache_enabled(struct netfs_inode * ctx)154 static inline bool netfs_is_cache_enabled(struct netfs_inode *ctx)
155 {
156 #if IS_ENABLED(CONFIG_FSCACHE)
157 struct fscache_cookie *cookie = ctx->cache;
158
159 return fscache_cookie_valid(cookie) && cookie->cache_priv &&
160 fscache_cookie_enabled(cookie);
161 #else
162 return false;
163 #endif
164 }
165
166 /*
167 * Get a ref on a netfs group attached to a dirty page (e.g. a ceph snap).
168 */
netfs_get_group(struct netfs_group * netfs_group)169 static inline struct netfs_group *netfs_get_group(struct netfs_group *netfs_group)
170 {
171 if (netfs_group)
172 refcount_inc(&netfs_group->ref);
173 return netfs_group;
174 }
175
176 /*
177 * Dispose of a netfs group attached to a dirty page (e.g. a ceph snap).
178 */
netfs_put_group(struct netfs_group * netfs_group)179 static inline void netfs_put_group(struct netfs_group *netfs_group)
180 {
181 if (netfs_group && refcount_dec_and_test(&netfs_group->ref))
182 netfs_group->free(netfs_group);
183 }
184
185 /*
186 * Dispose of a netfs group attached to a dirty page (e.g. a ceph snap).
187 */
netfs_put_group_many(struct netfs_group * netfs_group,int nr)188 static inline void netfs_put_group_many(struct netfs_group *netfs_group, int nr)
189 {
190 if (netfs_group && refcount_sub_and_test(nr, &netfs_group->ref))
191 netfs_group->free(netfs_group);
192 }
193
194 /*
195 * fscache-cache.c
196 */
197 #ifdef CONFIG_PROC_FS
198 extern const struct seq_operations fscache_caches_seq_ops;
199 #endif
200 bool fscache_begin_cache_access(struct fscache_cache *cache, enum fscache_access_trace why);
201 void fscache_end_cache_access(struct fscache_cache *cache, enum fscache_access_trace why);
202 struct fscache_cache *fscache_lookup_cache(const char *name, bool is_cache);
203 void fscache_put_cache(struct fscache_cache *cache, enum fscache_cache_trace where);
204
fscache_cache_state(const struct fscache_cache * cache)205 static inline enum fscache_cache_state fscache_cache_state(const struct fscache_cache *cache)
206 {
207 return smp_load_acquire(&cache->state);
208 }
209
fscache_cache_is_live(const struct fscache_cache * cache)210 static inline bool fscache_cache_is_live(const struct fscache_cache *cache)
211 {
212 return fscache_cache_state(cache) == FSCACHE_CACHE_IS_ACTIVE;
213 }
214
fscache_set_cache_state(struct fscache_cache * cache,enum fscache_cache_state new_state)215 static inline void fscache_set_cache_state(struct fscache_cache *cache,
216 enum fscache_cache_state new_state)
217 {
218 smp_store_release(&cache->state, new_state);
219
220 }
221
fscache_set_cache_state_maybe(struct fscache_cache * cache,enum fscache_cache_state old_state,enum fscache_cache_state new_state)222 static inline bool fscache_set_cache_state_maybe(struct fscache_cache *cache,
223 enum fscache_cache_state old_state,
224 enum fscache_cache_state new_state)
225 {
226 return try_cmpxchg_release(&cache->state, &old_state, new_state);
227 }
228
229 /*
230 * fscache-cookie.c
231 */
232 extern struct kmem_cache *fscache_cookie_jar;
233 #ifdef CONFIG_PROC_FS
234 extern const struct seq_operations fscache_cookies_seq_ops;
235 #endif
236 extern struct timer_list fscache_cookie_lru_timer;
237
238 extern void fscache_print_cookie(struct fscache_cookie *cookie, char prefix);
239 extern bool fscache_begin_cookie_access(struct fscache_cookie *cookie,
240 enum fscache_access_trace why);
241
fscache_see_cookie(struct fscache_cookie * cookie,enum fscache_cookie_trace where)242 static inline void fscache_see_cookie(struct fscache_cookie *cookie,
243 enum fscache_cookie_trace where)
244 {
245 trace_fscache_cookie(cookie->debug_id, refcount_read(&cookie->ref),
246 where);
247 }
248
249 /*
250 * fscache-main.c
251 */
252 extern unsigned int fscache_hash(unsigned int salt, const void *data, size_t len);
253 #ifdef CONFIG_FSCACHE
254 int __init fscache_init(void);
255 void __exit fscache_exit(void);
256 #else
fscache_init(void)257 static inline int fscache_init(void) { return 0; }
fscache_exit(void)258 static inline void fscache_exit(void) {}
259 #endif
260
261 /*
262 * fscache-proc.c
263 */
264 #ifdef CONFIG_PROC_FS
265 extern int __init fscache_proc_init(void);
266 extern void fscache_proc_cleanup(void);
267 #else
268 #define fscache_proc_init() (0)
269 #define fscache_proc_cleanup() do {} while (0)
270 #endif
271
272 /*
273 * fscache-stats.c
274 */
275 #ifdef CONFIG_FSCACHE_STATS
276 extern atomic_t fscache_n_volumes;
277 extern atomic_t fscache_n_volumes_collision;
278 extern atomic_t fscache_n_volumes_nomem;
279 extern atomic_t fscache_n_cookies;
280 extern atomic_t fscache_n_cookies_lru;
281 extern atomic_t fscache_n_cookies_lru_expired;
282 extern atomic_t fscache_n_cookies_lru_removed;
283 extern atomic_t fscache_n_cookies_lru_dropped;
284
285 extern atomic_t fscache_n_acquires;
286 extern atomic_t fscache_n_acquires_ok;
287 extern atomic_t fscache_n_acquires_oom;
288
289 extern atomic_t fscache_n_invalidates;
290
291 extern atomic_t fscache_n_relinquishes;
292 extern atomic_t fscache_n_relinquishes_retire;
293 extern atomic_t fscache_n_relinquishes_dropped;
294
295 extern atomic_t fscache_n_resizes;
296 extern atomic_t fscache_n_resizes_null;
297
fscache_stat(atomic_t * stat)298 static inline void fscache_stat(atomic_t *stat)
299 {
300 atomic_inc(stat);
301 }
302
fscache_stat_d(atomic_t * stat)303 static inline void fscache_stat_d(atomic_t *stat)
304 {
305 atomic_dec(stat);
306 }
307
308 #define __fscache_stat(stat) (stat)
309
310 int fscache_stats_show(struct seq_file *m);
311 #else
312
313 #define __fscache_stat(stat) (NULL)
314 #define fscache_stat(stat) do {} while (0)
315 #define fscache_stat_d(stat) do {} while (0)
316
fscache_stats_show(struct seq_file * m)317 static inline int fscache_stats_show(struct seq_file *m) { return 0; }
318 #endif
319
320 /*
321 * fscache-volume.c
322 */
323 #ifdef CONFIG_PROC_FS
324 extern const struct seq_operations fscache_volumes_seq_ops;
325 #endif
326
327 struct fscache_volume *fscache_get_volume(struct fscache_volume *volume,
328 enum fscache_volume_trace where);
329 void fscache_put_volume(struct fscache_volume *volume,
330 enum fscache_volume_trace where);
331 bool fscache_begin_volume_access(struct fscache_volume *volume,
332 struct fscache_cookie *cookie,
333 enum fscache_access_trace why);
334 void fscache_create_volume(struct fscache_volume *volume, bool wait);
335
336 /*****************************************************************************/
337 /*
338 * debug tracing
339 */
340 #define dbgprintk(FMT, ...) \
341 printk("[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__)
342
343 #define kenter(FMT, ...) dbgprintk("==> %s("FMT")", __func__, ##__VA_ARGS__)
344 #define kleave(FMT, ...) dbgprintk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
345 #define kdebug(FMT, ...) dbgprintk(FMT, ##__VA_ARGS__)
346
347 #ifdef __KDEBUG
348 #define _enter(FMT, ...) kenter(FMT, ##__VA_ARGS__)
349 #define _leave(FMT, ...) kleave(FMT, ##__VA_ARGS__)
350 #define _debug(FMT, ...) kdebug(FMT, ##__VA_ARGS__)
351
352 #elif defined(CONFIG_NETFS_DEBUG)
353 #define _enter(FMT, ...) \
354 do { \
355 if (netfs_debug) \
356 kenter(FMT, ##__VA_ARGS__); \
357 } while (0)
358
359 #define _leave(FMT, ...) \
360 do { \
361 if (netfs_debug) \
362 kleave(FMT, ##__VA_ARGS__); \
363 } while (0)
364
365 #define _debug(FMT, ...) \
366 do { \
367 if (netfs_debug) \
368 kdebug(FMT, ##__VA_ARGS__); \
369 } while (0)
370
371 #else
372 #define _enter(FMT, ...) no_printk("==> %s("FMT")", __func__, ##__VA_ARGS__)
373 #define _leave(FMT, ...) no_printk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
374 #define _debug(FMT, ...) no_printk(FMT, ##__VA_ARGS__)
375 #endif
376
377 /*
378 * assertions
379 */
380 #if 1 /* defined(__KDEBUGALL) */
381
382 #define ASSERT(X) \
383 do { \
384 if (unlikely(!(X))) { \
385 pr_err("\n"); \
386 pr_err("Assertion failed\n"); \
387 BUG(); \
388 } \
389 } while (0)
390
391 #define ASSERTCMP(X, OP, Y) \
392 do { \
393 if (unlikely(!((X) OP (Y)))) { \
394 pr_err("\n"); \
395 pr_err("Assertion failed\n"); \
396 pr_err("%lx " #OP " %lx is false\n", \
397 (unsigned long)(X), (unsigned long)(Y)); \
398 BUG(); \
399 } \
400 } while (0)
401
402 #define ASSERTIF(C, X) \
403 do { \
404 if (unlikely((C) && !(X))) { \
405 pr_err("\n"); \
406 pr_err("Assertion failed\n"); \
407 BUG(); \
408 } \
409 } while (0)
410
411 #define ASSERTIFCMP(C, X, OP, Y) \
412 do { \
413 if (unlikely((C) && !((X) OP (Y)))) { \
414 pr_err("\n"); \
415 pr_err("Assertion failed\n"); \
416 pr_err("%lx " #OP " %lx is false\n", \
417 (unsigned long)(X), (unsigned long)(Y)); \
418 BUG(); \
419 } \
420 } while (0)
421
422 #else
423
424 #define ASSERT(X) do {} while (0)
425 #define ASSERTCMP(X, OP, Y) do {} while (0)
426 #define ASSERTIF(C, X) do {} while (0)
427 #define ASSERTIFCMP(C, X, OP, Y) do {} while (0)
428
429 #endif /* assert or not */
430