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