fs/cachefiles/internal.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /* General netfs cache on cache files internal defs
   3  *
   4  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells ([email protected])
   6  */
   7
   8 #ifdef pr_fmt
   9 #undef pr_fmt
  10 #endif
  11
  12 #define pr_fmt(fmt) "CacheFiles: " fmt
  13
  14
  15 #include <linux/fscache-cache.h>
  16 #include <linux/cred.h>
  17 #include <linux/security.h>
  18 #include <linux/xarray.h>
  19 #include <linux/cachefiles.h>
  20
  21 #define CACHEFILES_DIO_BLOCK_SIZE 4096
  22
  23 struct cachefiles_cache;
  24 struct cachefiles_object;
  25
  26 enum cachefiles_content {
  27         /* These values are saved on disk */
  28         CACHEFILES_CONTENT_NO_DATA      = 0, /* No content stored */
  29         CACHEFILES_CONTENT_SINGLE       = 1, /* Content is monolithic, all is present */
  30         CACHEFILES_CONTENT_ALL          = 2, /* Content is all present, no map */
  31         CACHEFILES_CONTENT_BACKFS_MAP   = 3, /* Content is piecemeal, mapped through backing fs */
  32         CACHEFILES_CONTENT_DIRTY        = 4, /* Content is dirty (only seen on disk) */
  33         nr__cachefiles_content
  34 };
  35
  36 /*
  37  * Cached volume representation.
  38  */
  39 struct cachefiles_volume {
  40         struct cachefiles_cache         *cache;
  41         struct list_head                cache_link;     /* Link in cache->volumes */
  42         struct fscache_volume           *vcookie;       /* The netfs's representation */
  43         struct dentry                   *dentry;        /* The volume dentry */
  44         struct dentry                   *fanout[256];   /* Fanout subdirs */
  45 };
  46
  47 enum cachefiles_object_state {
  48         CACHEFILES_ONDEMAND_OBJSTATE_CLOSE, /* Anonymous fd closed by daemon or initial state */
  49         CACHEFILES_ONDEMAND_OBJSTATE_OPEN, /* Anonymous fd associated with object is available */
  50         CACHEFILES_ONDEMAND_OBJSTATE_REOPENING, /* Object that was closed and is being reopened. */
  51 };
  52
  53 struct cachefiles_ondemand_info {
  54         struct work_struct              ondemand_work;
  55         int                             ondemand_id;
  56         enum cachefiles_object_state    state;
  57         struct cachefiles_object        *object;
  58 };
  59
  60 /*
  61  * Backing file state.
  62  */
  63 struct cachefiles_object {
  64         struct fscache_cookie           *cookie;        /* Netfs data storage object cookie */
  65         struct cachefiles_volume        *volume;        /* Cache volume that holds this object */
  66         struct list_head                cache_link;     /* Link in cache->*_list */
  67         struct file                     *file;          /* The file representing this object */
  68         char                            *d_name;        /* Backing file name */
  69         int                             debug_id;
  70         spinlock_t                      lock;
  71         refcount_t                      ref;
  72         u8                              d_name_len;     /* Length of filename */
  73         enum cachefiles_content         content_info:8; /* Info about content presence */
  74         unsigned long                   flags;
  75 #define CACHEFILES_OBJECT_USING_TMPFILE 0               /* Have an unlinked tmpfile */
  76 #ifdef CONFIG_CACHEFILES_ONDEMAND
  77         struct cachefiles_ondemand_info *ondemand;
  78 #endif
  79 };
  80
  81 #define CACHEFILES_ONDEMAND_ID_CLOSED   -1
  82
  83 /*
  84  * Cache files cache definition
  85  */
  86 struct cachefiles_cache {
  87         struct fscache_cache            *cache;         /* Cache cookie */
  88         struct vfsmount                 *mnt;           /* mountpoint holding the cache */
  89         struct dentry                   *store;         /* Directory into which live objects go */
  90         struct dentry                   *graveyard;     /* directory into which dead objects go */
  91         struct file                     *cachefilesd;   /* manager daemon handle */
  92         struct list_head                volumes;        /* List of volume objects */
  93         struct list_head                object_list;    /* List of active objects */
  94         spinlock_t                      object_list_lock; /* Lock for volumes and object_list */
  95         const struct cred               *cache_cred;    /* security override for accessing cache */
  96         struct mutex                    daemon_mutex;   /* command serialisation mutex */
  97         wait_queue_head_t               daemon_pollwq;  /* poll waitqueue for daemon */
  98         atomic_t                        gravecounter;   /* graveyard uniquifier */
  99         atomic_t                        f_released;     /* number of objects released lately */
 100         atomic_long_t                   b_released;     /* number of blocks released lately */
 101         atomic_long_t                   b_writing;      /* Number of blocks being written */
 102         unsigned                        frun_percent;   /* when to stop culling (% files) */
 103         unsigned                        fcull_percent;  /* when to start culling (% files) */
 104         unsigned                        fstop_percent;  /* when to stop allocating (% files) */
 105         unsigned                        brun_percent;   /* when to stop culling (% blocks) */
 106         unsigned                        bcull_percent;  /* when to start culling (% blocks) */
 107         unsigned                        bstop_percent;  /* when to stop allocating (% blocks) */
 108         unsigned                        bsize;          /* cache's block size */
 109         unsigned                        bshift;         /* ilog2(bsize) */
 110         uint64_t                        frun;           /* when to stop culling */
 111         uint64_t                        fcull;          /* when to start culling */
 112         uint64_t                        fstop;          /* when to stop allocating */
 113         sector_t                        brun;           /* when to stop culling */
 114         sector_t                        bcull;          /* when to start culling */
 115         sector_t                        bstop;          /* when to stop allocating */
 116         unsigned long                   flags;
 117 #define CACHEFILES_READY                0       /* T if cache prepared */
 118 #define CACHEFILES_DEAD                 1       /* T if cache dead */
 119 #define CACHEFILES_CULLING              2       /* T if cull engaged */
 120 #define CACHEFILES_STATE_CHANGED        3       /* T if state changed (poll trigger) */
 121 #define CACHEFILES_ONDEMAND_MODE        4       /* T if in on-demand read mode */
 122         char                            *rootdirname;   /* name of cache root directory */
 123         char                            *secctx;        /* LSM security context */
 124         char                            *tag;           /* cache binding tag */
 125         refcount_t                      unbind_pincount;/* refcount to do daemon unbind */
 126         struct xarray                   reqs;           /* xarray of pending on-demand requests */
 127         unsigned long                   req_id_next;
 128         struct xarray                   ondemand_ids;   /* xarray for ondemand_id allocation */
 129         u32                             ondemand_id_next;
 130 };
 131
 132 static inline bool cachefiles_in_ondemand_mode(struct cachefiles_cache *cache)
 133 {
 134         return IS_ENABLED(CONFIG_CACHEFILES_ONDEMAND) &&
 135                 test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags);
 136 }
 137
 138 struct cachefiles_req {
 139         struct cachefiles_object *object;
 140         struct completion done;
 141         int error;
 142         struct cachefiles_msg msg;
 143 };
 144
 145 #define CACHEFILES_REQ_NEW      XA_MARK_1
 146
 147 #include <trace/events/cachefiles.h>
 148
 149 static inline
 150 struct file *cachefiles_cres_file(struct netfs_cache_resources *cres)
 151 {
 152         return cres->cache_priv2;
 153 }
 154
 155 static inline
 156 struct cachefiles_object *cachefiles_cres_object(struct netfs_cache_resources *cres)
 157 {
 158         return fscache_cres_cookie(cres)->cache_priv;
 159 }
 160
 161 /*
 162  * note change of state for daemon
 163  */
 164 static inline void cachefiles_state_changed(struct cachefiles_cache *cache)
 165 {
 166         set_bit(CACHEFILES_STATE_CHANGED, &cache->flags);
 167         wake_up_all(&cache->daemon_pollwq);
 168 }
 169
 170 /*
 171  * cache.c
 172  */
 173 extern int cachefiles_add_cache(struct cachefiles_cache *cache);
 174 extern void cachefiles_withdraw_cache(struct cachefiles_cache *cache);
 175
 176 enum cachefiles_has_space_for {
 177         cachefiles_has_space_check,
 178         cachefiles_has_space_for_write,
 179         cachefiles_has_space_for_create,
 180 };
 181 extern int cachefiles_has_space(struct cachefiles_cache *cache,
 182                                 unsigned fnr, unsigned bnr,
 183                                 enum cachefiles_has_space_for reason);
 184
 185 /*
 186  * daemon.c
 187  */
 188 extern const struct file_operations cachefiles_daemon_fops;
 189 extern void cachefiles_get_unbind_pincount(struct cachefiles_cache *cache);
 190 extern void cachefiles_put_unbind_pincount(struct cachefiles_cache *cache);
 191
 192 /*
 193  * error_inject.c
 194  */
 195 #ifdef CONFIG_CACHEFILES_ERROR_INJECTION
 196 extern unsigned int cachefiles_error_injection_state;
 197 extern int cachefiles_register_error_injection(void);
 198 extern void cachefiles_unregister_error_injection(void);
 199
 200 #else
 201 #define cachefiles_error_injection_state 0
 202
 203 static inline int cachefiles_register_error_injection(void)
 204 {
 205         return 0;
 206 }
 207
 208 static inline void cachefiles_unregister_error_injection(void)
 209 {
 210 }
 211 #endif
 212
 213
 214 static inline int cachefiles_inject_read_error(void)
 215 {
 216         return cachefiles_error_injection_state & 2 ? -EIO : 0;
 217 }
 218
 219 static inline int cachefiles_inject_write_error(void)
 220 {
 221         return cachefiles_error_injection_state & 2 ? -EIO :
 222                 cachefiles_error_injection_state & 1 ? -ENOSPC :
 223                 0;
 224 }
 225
 226 static inline int cachefiles_inject_remove_error(void)
 227 {
 228         return cachefiles_error_injection_state & 2 ? -EIO : 0;
 229 }
 230
 231 /*
 232  * interface.c
 233  */
 234 extern const struct fscache_cache_ops cachefiles_cache_ops;
 235 extern void cachefiles_see_object(struct cachefiles_object *object,
 236                                   enum cachefiles_obj_ref_trace why);
 237 extern struct cachefiles_object *cachefiles_grab_object(struct cachefiles_object *object,
 238                                                         enum cachefiles_obj_ref_trace why);
 239 extern void cachefiles_put_object(struct cachefiles_object *object,
 240                                   enum cachefiles_obj_ref_trace why);
 241
 242 /*
 243  * io.c
 244  */
 245 extern bool cachefiles_begin_operation(struct netfs_cache_resources *cres,
 246                                        enum fscache_want_state want_state);
 247 extern int __cachefiles_prepare_write(struct cachefiles_object *object,
 248                                       struct file *file,
 249                                       loff_t *_start, size_t *_len, size_t upper_len,
 250                                       bool no_space_allocated_yet);
 251 extern int __cachefiles_write(struct cachefiles_object *object,
 252                               struct file *file,
 253                               loff_t start_pos,
 254                               struct iov_iter *iter,
 255                               netfs_io_terminated_t term_func,
 256                               void *term_func_priv);
 257
 258 /*
 259  * key.c
 260  */
 261 extern bool cachefiles_cook_key(struct cachefiles_object *object);
 262
 263 /*
 264  * main.c
 265  */
 266 extern struct kmem_cache *cachefiles_object_jar;
 267
 268 /*
 269  * namei.c
 270  */
 271 extern void cachefiles_unmark_inode_in_use(struct cachefiles_object *object,
 272                                            struct file *file);
 273 extern int cachefiles_bury_object(struct cachefiles_cache *cache,
 274                                   struct cachefiles_object *object,
 275                                   struct dentry *dir,
 276                                   struct dentry *rep,
 277                                   enum fscache_why_object_killed why);
 278 extern int cachefiles_delete_object(struct cachefiles_object *object,
 279                                     enum fscache_why_object_killed why);
 280 extern bool cachefiles_look_up_object(struct cachefiles_object *object);
 281 extern struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
 282                                                struct dentry *dir,
 283                                                const char *name,
 284                                                bool *_is_new);
 285 extern void cachefiles_put_directory(struct dentry *dir);
 286
 287 extern int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
 288                            char *filename);
 289
 290 extern int cachefiles_check_in_use(struct cachefiles_cache *cache,
 291                                    struct dentry *dir, char *filename);
 292 extern struct file *cachefiles_create_tmpfile(struct cachefiles_object *object);
 293 extern bool cachefiles_commit_tmpfile(struct cachefiles_cache *cache,
 294                                       struct cachefiles_object *object);
 295
 296 /*
 297  * ondemand.c
 298  */
 299 #ifdef CONFIG_CACHEFILES_ONDEMAND
 300 extern ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
 301                                         char __user *_buffer, size_t buflen);
 302
 303 extern int cachefiles_ondemand_copen(struct cachefiles_cache *cache,
 304                                      char *args);
 305
 306 extern int cachefiles_ondemand_restore(struct cachefiles_cache *cache,
 307                                         char *args);
 308
 309 extern int cachefiles_ondemand_init_object(struct cachefiles_object *object);
 310 extern void cachefiles_ondemand_clean_object(struct cachefiles_object *object);
 311
 312 extern int cachefiles_ondemand_read(struct cachefiles_object *object,
 313                                     loff_t pos, size_t len);
 314
 315 extern int cachefiles_ondemand_init_obj_info(struct cachefiles_object *obj,
 316                                         struct cachefiles_volume *volume);
 317 extern void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *obj);
 318
 319 #define CACHEFILES_OBJECT_STATE_FUNCS(_state, _STATE)   \
 320 static inline bool                                                              \
 321 cachefiles_ondemand_object_is_##_state(const struct cachefiles_object *object) \
 322 {                                                                                               \
 323         return object->ondemand->state == CACHEFILES_ONDEMAND_OBJSTATE_##_STATE; \
 324 }                                                                                               \
 325                                                                                                 \
 326 static inline void                                                              \
 327 cachefiles_ondemand_set_object_##_state(struct cachefiles_object *object) \
 328 {                                                                                               \
 329         object->ondemand->state = CACHEFILES_ONDEMAND_OBJSTATE_##_STATE; \
 330 }
 331
 332 CACHEFILES_OBJECT_STATE_FUNCS(open, OPEN);
 333 CACHEFILES_OBJECT_STATE_FUNCS(close, CLOSE);
 334 CACHEFILES_OBJECT_STATE_FUNCS(reopening, REOPENING);
 335
 336 static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req)
 337 {
 338         return cachefiles_ondemand_object_is_reopening(req->object) &&
 339                         req->msg.opcode == CACHEFILES_OP_READ;
 340 }
 341
 342 #else
 343 static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
 344                                         char __user *_buffer, size_t buflen)
 345 {
 346         return -EOPNOTSUPP;
 347 }
 348
 349 static inline int cachefiles_ondemand_init_object(struct cachefiles_object *object)
 350 {
 351         return 0;
 352 }
 353
 354 static inline void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
 355 {
 356 }
 357
 358 static inline int cachefiles_ondemand_read(struct cachefiles_object *object,
 359                                            loff_t pos, size_t len)
 360 {
 361         return -EOPNOTSUPP;
 362 }
 363
 364 static inline int cachefiles_ondemand_init_obj_info(struct cachefiles_object *obj,
 365                                                 struct cachefiles_volume *volume)
 366 {
 367         return 0;
 368 }
 369 static inline void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *obj)
 370 {
 371 }
 372
 373 static inline bool cachefiles_ondemand_is_reopening_read(struct cachefiles_req *req)
 374 {
 375         return false;
 376 }
 377 #endif
 378
 379 /*
 380  * security.c
 381  */
 382 extern int cachefiles_get_security_ID(struct cachefiles_cache *cache);
 383 extern int cachefiles_determine_cache_security(struct cachefiles_cache *cache,
 384                                                struct dentry *root,
 385                                                const struct cred **_saved_cred);
 386
 387 static inline void cachefiles_begin_secure(struct cachefiles_cache *cache,
 388                                            const struct cred **_saved_cred)
 389 {
 390         *_saved_cred = override_creds(cache->cache_cred);
 391 }
 392
 393 static inline void cachefiles_end_secure(struct cachefiles_cache *cache,
 394                                          const struct cred *saved_cred)
 395 {
 396         revert_creds(saved_cred);
 397 }
 398
 399 /*
 400  * volume.c
 401  */
 402 void cachefiles_acquire_volume(struct fscache_volume *volume);
 403 void cachefiles_free_volume(struct fscache_volume *volume);
 404 void cachefiles_withdraw_volume(struct cachefiles_volume *volume);
 405
 406 /*
 407  * xattr.c
 408  */
 409 extern int cachefiles_set_object_xattr(struct cachefiles_object *object);
 410 extern int cachefiles_check_auxdata(struct cachefiles_object *object,
 411                                     struct file *file);
 412 extern int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
 413                                           struct cachefiles_object *object,
 414                                           struct dentry *dentry);
 415 extern void cachefiles_prepare_to_write(struct fscache_cookie *cookie);
 416 extern bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume);
 417 extern int cachefiles_check_volume_xattr(struct cachefiles_volume *volume);
 418
 419 /*
 420  * Error handling
 421  */
 422 #define cachefiles_io_error(___cache, FMT, ...)         \
 423 do {                                                    \
 424         pr_err("I/O Error: " FMT"\n", ##__VA_ARGS__);   \
 425         fscache_io_error((___cache)->cache);            \
 426         set_bit(CACHEFILES_DEAD, &(___cache)->flags);   \
 427 } while (0)
 428
 429 #define cachefiles_io_error_obj(object, FMT, ...)                       \
 430 do {                                                                    \
 431         struct cachefiles_cache *___cache;                              \
 432                                                                         \
 433         ___cache = (object)->volume->cache;                             \
 434         cachefiles_io_error(___cache, FMT " [o=%08x]", ##__VA_ARGS__,   \
 435                             (object)->debug_id);                        \
 436 } while (0)
 437
 438
 439 /*
 440  * Debug tracing
 441  */
 442 extern unsigned cachefiles_debug;
 443 #define CACHEFILES_DEBUG_KENTER 1
 444 #define CACHEFILES_DEBUG_KLEAVE 2
 445 #define CACHEFILES_DEBUG_KDEBUG 4
 446
 447 #define dbgprintk(FMT, ...) \
 448         printk(KERN_DEBUG "[%-6.6s] "FMT"\n", current->comm, ##__VA_ARGS__)
 449
 450 #define kenter(FMT, ...) dbgprintk("==> %s("FMT")", __func__, ##__VA_ARGS__)
 451 #define kleave(FMT, ...) dbgprintk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
 452 #define kdebug(FMT, ...) dbgprintk(FMT, ##__VA_ARGS__)
 453
 454
 455 #if defined(__KDEBUG)
 456 #define _enter(FMT, ...) kenter(FMT, ##__VA_ARGS__)
 457 #define _leave(FMT, ...) kleave(FMT, ##__VA_ARGS__)
 458 #define _debug(FMT, ...) kdebug(FMT, ##__VA_ARGS__)
 459
 460 #elif defined(CONFIG_CACHEFILES_DEBUG)
 461 #define _enter(FMT, ...)                                \
 462 do {                                                    \
 463         if (cachefiles_debug & CACHEFILES_DEBUG_KENTER) \
 464                 kenter(FMT, ##__VA_ARGS__);             \
 465 } while (0)
 466
 467 #define _leave(FMT, ...)                                \
 468 do {                                                    \
 469         if (cachefiles_debug & CACHEFILES_DEBUG_KLEAVE) \
 470                 kleave(FMT, ##__VA_ARGS__);             \
 471 } while (0)
 472
 473 #define _debug(FMT, ...)                                \
 474 do {                                                    \
 475         if (cachefiles_debug & CACHEFILES_DEBUG_KDEBUG) \
 476                 kdebug(FMT, ##__VA_ARGS__);             \
 477 } while (0)
 478
 479 #else
 480 #define _enter(FMT, ...) no_printk("==> %s("FMT")", __func__, ##__VA_ARGS__)
 481 #define _leave(FMT, ...) no_printk("<== %s()"FMT"", __func__, ##__VA_ARGS__)
 482 #define _debug(FMT, ...) no_printk(FMT, ##__VA_ARGS__)
 483 #endif
 484
 485 #if 1 /* defined(__KDEBUGALL) */
 486
 487 #define ASSERT(X)                                                       \
 488 do {                                                                    \
 489         if (unlikely(!(X))) {                                           \
 490                 pr_err("\n");                                           \
 491                 pr_err("Assertion failed\n");           \
 492                 BUG();                                                  \
 493         }                                                               \
 494 } while (0)
 495
 496 #define ASSERTCMP(X, OP, Y)                                             \
 497 do {                                                                    \
 498         if (unlikely(!((X) OP (Y)))) {                                  \
 499                 pr_err("\n");                                           \
 500                 pr_err("Assertion failed\n");           \
 501                 pr_err("%lx " #OP " %lx is false\n",                    \
 502                        (unsigned long)(X), (unsigned long)(Y));         \
 503                 BUG();                                                  \
 504         }                                                               \
 505 } while (0)
 506
 507 #define ASSERTIF(C, X)                                                  \
 508 do {                                                                    \
 509         if (unlikely((C) && !(X))) {                                    \
 510                 pr_err("\n");                                           \
 511                 pr_err("Assertion failed\n");           \
 512                 BUG();                                                  \
 513         }                                                               \
 514 } while (0)
 515
 516 #define ASSERTIFCMP(C, X, OP, Y)                                        \
 517 do {                                                                    \
 518         if (unlikely((C) && !((X) OP (Y)))) {                           \
 519                 pr_err("\n");                                           \
 520                 pr_err("Assertion failed\n");           \
 521                 pr_err("%lx " #OP " %lx is false\n",                    \
 522                        (unsigned long)(X), (unsigned long)(Y));         \
 523                 BUG();                                                  \
 524         }                                                               \
 525 } while (0)
 526
 527 #else
 528
 529 #define ASSERT(X)                       do {} while (0)
 530 #define ASSERTCMP(X, OP, Y)             do {} while (0)
 531 #define ASSERTIF(C, X)                  do {} while (0)
 532 #define ASSERTIFCMP(C, X, OP, Y)        do {} while (0)
 533
 534 #endif