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 */ 25void netfs_rreq_unlock_folios(struct netfs_io_request *rreq); 26int netfs_prefetch_for_write(struct file *file, struct folio *folio, 27 size_t offset, size_t len); 28 29/* 30 * io.c 31 */ 32int netfs_begin_read(struct netfs_io_request *rreq, bool sync); 33 34/* 35 * main.c 36 */ 37extern unsigned int netfs_debug; 38extern struct list_head netfs_io_requests; 39extern spinlock_t netfs_proc_lock; 40 41#ifdef CONFIG_PROC_FS 42static 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} 48static 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 57static inline void netfs_proc_add_rreq(struct netfs_io_request *rreq) {} 58static 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) 66int netfs_xa_store_and_mark(struct xarray *xa, unsigned long index, 67 struct folio *folio, unsigned int flags, 68 gfp_t gfp_mask); 69int netfs_add_folios_to_buffer(struct xarray *buffer, 70 struct address_space *mapping, 71 pgoff_t index, pgoff_t to, gfp_t gfp_mask); 72void netfs_clear_buffer(struct xarray *buffer); 73 74/* 75 * objects.c 76 */ 77struct 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); 81void netfs_get_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace what); 82void netfs_clear_subrequests(struct netfs_io_request *rreq, bool was_async); 83void netfs_put_request(struct netfs_io_request *rreq, bool was_async, 84 enum netfs_rreq_ref_trace what); 85struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq); 86 87static 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 */ 96int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait, 97 enum netfs_write_trace what); 98struct netfs_io_request *netfs_begin_writethrough(struct kiocb *iocb, size_t len); 99int netfs_advance_writethrough(struct netfs_io_request *wreq, size_t copied, bool to_page_end); 100int netfs_end_writethrough(struct netfs_io_request *wreq, struct kiocb *iocb); 101 102/* 103 * stats.c 104 */ 105#ifdef CONFIG_NETFS_STATS 106extern atomic_t netfs_n_rh_dio_read; 107extern atomic_t netfs_n_rh_dio_write; 108extern atomic_t netfs_n_rh_readahead; 109extern atomic_t netfs_n_rh_readpage; 110extern atomic_t netfs_n_rh_rreq; 111extern atomic_t netfs_n_rh_sreq; 112extern atomic_t netfs_n_rh_download; 113extern atomic_t netfs_n_rh_download_done; 114extern atomic_t netfs_n_rh_download_failed; 115extern atomic_t netfs_n_rh_download_instead; 116extern atomic_t netfs_n_rh_read; 117extern atomic_t netfs_n_rh_read_done; 118extern atomic_t netfs_n_rh_read_failed; 119extern atomic_t netfs_n_rh_zero; 120extern atomic_t netfs_n_rh_short_read; 121extern atomic_t netfs_n_rh_write; 122extern atomic_t netfs_n_rh_write_begin; 123extern atomic_t netfs_n_rh_write_done; 124extern atomic_t netfs_n_rh_write_failed; 125extern atomic_t netfs_n_rh_write_zskip; 126extern atomic_t netfs_n_wh_wstream_conflict; 127extern atomic_t netfs_n_wh_upload; 128extern atomic_t netfs_n_wh_upload_done; 129extern atomic_t netfs_n_wh_upload_failed; 130extern atomic_t netfs_n_wh_write; 131extern atomic_t netfs_n_wh_write_done; 132extern atomic_t netfs_n_wh_write_failed; 133 134int netfs_stats_show(struct seq_file *m, void *v); 135 136static inline void netfs_stat(atomic_t *stat) 137{ 138 atomic_inc(stat); 139} 140 141static 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 */ 154static 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 */ 169static 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 */ 179static 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 */ 188static 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 198extern const struct seq_operations fscache_caches_seq_ops; 199#endif 200bool fscache_begin_cache_access(struct fscache_cache *cache, enum fscache_access_trace why); 201void fscache_end_cache_access(struct fscache_cache *cache, enum fscache_access_trace why); 202struct fscache_cache *fscache_lookup_cache(const char *name, bool is_cache); 203void fscache_put_cache(struct fscache_cache *cache, enum fscache_cache_trace where); 204 205static inline enum fscache_cache_state fscache_cache_state(const struct fscache_cache *cache) 206{ 207 return smp_load_acquire(&cache->state); 208} 209 210static inline bool fscache_cache_is_live(const struct fscache_cache *cache) 211{ 212 return fscache_cache_state(cache) == FSCACHE_CACHE_IS_ACTIVE; 213} 214 215static 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 222static 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 */ 232extern struct kmem_cache *fscache_cookie_jar; 233#ifdef CONFIG_PROC_FS 234extern const struct seq_operations fscache_cookies_seq_ops; 235#endif 236extern struct timer_list fscache_cookie_lru_timer; 237 238extern void fscache_print_cookie(struct fscache_cookie *cookie, char prefix); 239extern bool fscache_begin_cookie_access(struct fscache_cookie *cookie, 240 enum fscache_access_trace why); 241 242static 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 */ 252extern unsigned int fscache_hash(unsigned int salt, const void *data, size_t len); 253#ifdef CONFIG_FSCACHE 254int __init fscache_init(void); 255void __exit fscache_exit(void); 256#else 257static inline int fscache_init(void) { return 0; } 258static inline void fscache_exit(void) {} 259#endif 260 261/* 262 * fscache-proc.c 263 */ 264#ifdef CONFIG_PROC_FS 265extern int __init fscache_proc_init(void); 266extern 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 276extern atomic_t fscache_n_volumes; 277extern atomic_t fscache_n_volumes_collision; 278extern atomic_t fscache_n_volumes_nomem; 279extern atomic_t fscache_n_cookies; 280extern atomic_t fscache_n_cookies_lru; 281extern atomic_t fscache_n_cookies_lru_expired; 282extern atomic_t fscache_n_cookies_lru_removed; 283extern atomic_t fscache_n_cookies_lru_dropped; 284 285extern atomic_t fscache_n_acquires; 286extern atomic_t fscache_n_acquires_ok; 287extern atomic_t fscache_n_acquires_oom; 288 289extern atomic_t fscache_n_invalidates; 290 291extern atomic_t fscache_n_relinquishes; 292extern atomic_t fscache_n_relinquishes_retire; 293extern atomic_t fscache_n_relinquishes_dropped; 294 295extern atomic_t fscache_n_resizes; 296extern atomic_t fscache_n_resizes_null; 297 298static inline void fscache_stat(atomic_t *stat) 299{ 300 atomic_inc(stat); 301} 302 303static inline void fscache_stat_d(atomic_t *stat) 304{ 305 atomic_dec(stat); 306} 307 308#define __fscache_stat(stat) (stat) 309 310int 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 317static 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 324extern const struct seq_operations fscache_volumes_seq_ops; 325#endif 326 327struct fscache_volume *fscache_get_volume(struct fscache_volume *volume, 328 enum fscache_volume_trace where); 329void fscache_put_volume(struct fscache_volume *volume, 330 enum fscache_volume_trace where); 331bool fscache_begin_volume_access(struct fscache_volume *volume, 332 struct fscache_cookie *cookie, 333 enum fscache_access_trace why); 334void 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, ...) \ 354do { \ 355 if (netfs_debug) \ 356 kenter(FMT, ##__VA_ARGS__); \ 357} while (0) 358 359#define _leave(FMT, ...) \ 360do { \ 361 if (netfs_debug) \ 362 kleave(FMT, ##__VA_ARGS__); \ 363} while (0) 364 365#define _debug(FMT, ...) \ 366do { \ 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) \ 383do { \ 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) \ 392do { \ 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) \ 403do { \ 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) \ 412do { \ 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