fs/cachefiles/ondemand.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 #include <linux/fdtable.h>
   3 #include <linux/anon_inodes.h>
   4 #include <linux/uio.h>
   5 #include "internal.h"
   6
   7 static int cachefiles_ondemand_fd_release(struct inode *inode,
   8                                           struct file *file)
   9 {
  10         struct cachefiles_object *object = file->private_data;
  11         struct cachefiles_cache *cache = object->volume->cache;
  12         struct cachefiles_ondemand_info *info = object->ondemand;
  13         int object_id = info->ondemand_id;
  14         struct cachefiles_req *req;
  15         XA_STATE(xas, &cache->reqs, 0);
  16
  17         xa_lock(&cache->reqs);
  18         info->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
  19         cachefiles_ondemand_set_object_close(object);
  20
  21         /* Only flush CACHEFILES_REQ_NEW marked req to avoid race with daemon_read */
  22         xas_for_each_marked(&xas, req, ULONG_MAX, CACHEFILES_REQ_NEW) {
  23                 if (req->msg.object_id == object_id &&
  24                     req->msg.opcode == CACHEFILES_OP_CLOSE) {
  25                         complete(&req->done);
  26                         xas_store(&xas, NULL);
  27                 }
  28         }
  29         xa_unlock(&cache->reqs);
  30
  31         xa_erase(&cache->ondemand_ids, object_id);
  32         trace_cachefiles_ondemand_fd_release(object, object_id);
  33         cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
  34         cachefiles_put_unbind_pincount(cache);
  35         return 0;
  36 }
  37
  38 static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,
  39                                                  struct iov_iter *iter)
  40 {
  41         struct cachefiles_object *object = kiocb->ki_filp->private_data;
  42         struct cachefiles_cache *cache = object->volume->cache;
  43         struct file *file = object->file;
  44         size_t len = iter->count;
  45         loff_t pos = kiocb->ki_pos;
  46         const struct cred *saved_cred;
  47         int ret;
  48
  49         if (!file)
  50                 return -ENOBUFS;
  51
  52         cachefiles_begin_secure(cache, &saved_cred);
  53         ret = __cachefiles_prepare_write(object, file, &pos, &len, len, true);
  54         cachefiles_end_secure(cache, saved_cred);
  55         if (ret < 0)
  56                 return ret;
  57
  58         trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
  59         ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
  60         if (!ret)
  61                 ret = len;
  62
  63         return ret;
  64 }
  65
  66 static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos,
  67                                             int whence)
  68 {
  69         struct cachefiles_object *object = filp->private_data;
  70         struct file *file = object->file;
  71
  72         if (!file)
  73                 return -ENOBUFS;
  74
  75         return vfs_llseek(file, pos, whence);
  76 }
  77
  78 static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl,
  79                                          unsigned long arg)
  80 {
  81         struct cachefiles_object *object = filp->private_data;
  82         struct cachefiles_cache *cache = object->volume->cache;
  83         struct cachefiles_req *req;
  84         unsigned long id;
  85
  86         if (ioctl != CACHEFILES_IOC_READ_COMPLETE)
  87                 return -EINVAL;
  88
  89         if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
  90                 return -EOPNOTSUPP;
  91
  92         id = arg;
  93         req = xa_erase(&cache->reqs, id);
  94         if (!req)
  95                 return -EINVAL;
  96
  97         trace_cachefiles_ondemand_cread(object, id);
  98         complete(&req->done);
  99         return 0;
 100 }
 101
 102 static const struct file_operations cachefiles_ondemand_fd_fops = {
 103         .owner          = THIS_MODULE,
 104         .release        = cachefiles_ondemand_fd_release,
 105         .write_iter     = cachefiles_ondemand_fd_write_iter,
 106         .llseek         = cachefiles_ondemand_fd_llseek,
 107         .unlocked_ioctl = cachefiles_ondemand_fd_ioctl,
 108 };
 109
 110 /*
 111  * OPEN request Completion (copen)
 112  * - command: "copen <id>,<cache_size>"
 113  *   <cache_size> indicates the object size if >=0, error code if negative
 114  */
 115 int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args)
 116 {
 117         struct cachefiles_req *req;
 118         struct fscache_cookie *cookie;
 119         char *pid, *psize;
 120         unsigned long id;
 121         long size;
 122         int ret;
 123
 124         if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
 125                 return -EOPNOTSUPP;
 126
 127         if (!*args) {
 128                 pr_err("Empty id specified\n");
 129                 return -EINVAL;
 130         }
 131
 132         pid = args;
 133         psize = strchr(args, ',');
 134         if (!psize) {
 135                 pr_err("Cache size is not specified\n");
 136                 return -EINVAL;
 137         }
 138
 139         *psize = 0;
 140         psize++;
 141
 142         ret = kstrtoul(pid, 0, &id);
 143         if (ret)
 144                 return ret;
 145
 146         req = xa_erase(&cache->reqs, id);
 147         if (!req)
 148                 return -EINVAL;
 149
 150         /* fail OPEN request if copen format is invalid */
 151         ret = kstrtol(psize, 0, &size);
 152         if (ret) {
 153                 req->error = ret;
 154                 goto out;
 155         }
 156
 157         /* fail OPEN request if daemon reports an error */
 158         if (size < 0) {
 159                 if (!IS_ERR_VALUE(size)) {
 160                         req->error = -EINVAL;
 161                         ret = -EINVAL;
 162                 } else {
 163                         req->error = size;
 164                         ret = 0;
 165                 }
 166                 goto out;
 167         }
 168
 169         cookie = req->object->cookie;
 170         cookie->object_size = size;
 171         if (size)
 172                 clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
 173         else
 174                 set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
 175         trace_cachefiles_ondemand_copen(req->object, id, size);
 176
 177         cachefiles_ondemand_set_object_open(req->object);
 178         wake_up_all(&cache->daemon_pollwq);
 179
 180 out:
 181         complete(&req->done);
 182         return ret;
 183 }
 184
 185 int cachefiles_ondemand_restore(struct cachefiles_cache *cache, char *args)
 186 {
 187         struct cachefiles_req *req;
 188
 189         XA_STATE(xas, &cache->reqs, 0);
 190
 191         if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
 192                 return -EOPNOTSUPP;
 193
 194         /*
 195          * Reset the requests to CACHEFILES_REQ_NEW state, so that the
 196          * requests have been processed halfway before the crash of the
 197          * user daemon could be reprocessed after the recovery.
 198          */
 199         xas_lock(&xas);
 200         xas_for_each(&xas, req, ULONG_MAX)
 201                 xas_set_mark(&xas, CACHEFILES_REQ_NEW);
 202         xas_unlock(&xas);
 203
 204         wake_up_all(&cache->daemon_pollwq);
 205         return 0;
 206 }
 207
 208 static int cachefiles_ondemand_get_fd(struct cachefiles_req *req)
 209 {
 210         struct cachefiles_object *object;
 211         struct cachefiles_cache *cache;
 212         struct cachefiles_open *load;
 213         struct file *file;
 214         u32 object_id;
 215         int ret, fd;
 216
 217         object = cachefiles_grab_object(req->object,
 218                         cachefiles_obj_get_ondemand_fd);
 219         cache = object->volume->cache;
 220
 221         ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL,
 222                               XA_LIMIT(1, INT_MAX),
 223                               &cache->ondemand_id_next, GFP_KERNEL);
 224         if (ret < 0)
 225                 goto err;
 226
 227         fd = get_unused_fd_flags(O_WRONLY);
 228         if (fd < 0) {
 229                 ret = fd;
 230                 goto err_free_id;
 231         }
 232
 233         file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops,
 234                                   object, O_WRONLY);
 235         if (IS_ERR(file)) {
 236                 ret = PTR_ERR(file);
 237                 goto err_put_fd;
 238         }
 239
 240         file->f_mode |= FMODE_PWRITE | FMODE_LSEEK;
 241         fd_install(fd, file);
 242
 243         load = (void *)req->msg.data;
 244         load->fd = fd;
 245         object->ondemand->ondemand_id = object_id;
 246
 247         cachefiles_get_unbind_pincount(cache);
 248         trace_cachefiles_ondemand_open(object, &req->msg, load);
 249         return 0;
 250
 251 err_put_fd:
 252         put_unused_fd(fd);
 253 err_free_id:
 254         xa_erase(&cache->ondemand_ids, object_id);
 255 err:
 256         cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
 257         return ret;
 258 }
 259
 260 static void ondemand_object_worker(struct work_struct *work)
 261 {
 262         struct cachefiles_ondemand_info *info =
 263                 container_of(work, struct cachefiles_ondemand_info, ondemand_work);
 264
 265         cachefiles_ondemand_init_object(info->object);
 266 }
 267
 268 /*
 269  * If there are any inflight or subsequent READ requests on the
 270  * closed object, reopen it.
 271  * Skip read requests whose related object is reopening.
 272  */
 273 static struct cachefiles_req *cachefiles_ondemand_select_req(struct xa_state *xas,
 274                                                               unsigned long xa_max)
 275 {
 276         struct cachefiles_req *req;
 277         struct cachefiles_object *object;
 278         struct cachefiles_ondemand_info *info;
 279
 280         xas_for_each_marked(xas, req, xa_max, CACHEFILES_REQ_NEW) {
 281                 if (req->msg.opcode != CACHEFILES_OP_READ)
 282                         return req;
 283                 object = req->object;
 284                 info = object->ondemand;
 285                 if (cachefiles_ondemand_object_is_close(object)) {
 286                         cachefiles_ondemand_set_object_reopening(object);
 287                         queue_work(fscache_wq, &info->ondemand_work);
 288                         continue;
 289                 }
 290                 if (cachefiles_ondemand_object_is_reopening(object))
 291                         continue;
 292                 return req;
 293         }
 294         return NULL;
 295 }
 296
 297 ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
 298                                         char __user *_buffer, size_t buflen)
 299 {
 300         struct cachefiles_req *req;
 301         struct cachefiles_msg *msg;
 302         unsigned long id = 0;
 303         size_t n;
 304         int ret = 0;
 305         XA_STATE(xas, &cache->reqs, cache->req_id_next);
 306
 307         xa_lock(&cache->reqs);
 308         /*
 309          * Cyclically search for a request that has not ever been processed,
 310          * to prevent requests from being processed repeatedly, and make
 311          * request distribution fair.
 312          */
 313         req = cachefiles_ondemand_select_req(&xas, ULONG_MAX);
 314         if (!req && cache->req_id_next > 0) {
 315                 xas_set(&xas, 0);
 316                 req = cachefiles_ondemand_select_req(&xas, cache->req_id_next - 1);
 317         }
 318         if (!req) {
 319                 xa_unlock(&cache->reqs);
 320                 return 0;
 321         }
 322
 323         msg = &req->msg;
 324         n = msg->len;
 325
 326         if (n > buflen) {
 327                 xa_unlock(&cache->reqs);
 328                 return -EMSGSIZE;
 329         }
 330
 331         xas_clear_mark(&xas, CACHEFILES_REQ_NEW);
 332         cache->req_id_next = xas.xa_index + 1;
 333         xa_unlock(&cache->reqs);
 334
 335         id = xas.xa_index;
 336
 337         if (msg->opcode == CACHEFILES_OP_OPEN) {
 338                 ret = cachefiles_ondemand_get_fd(req);
 339                 if (ret) {
 340                         cachefiles_ondemand_set_object_close(req->object);
 341                         goto error;
 342                 }
 343         }
 344
 345         msg->msg_id = id;
 346         msg->object_id = req->object->ondemand->ondemand_id;
 347
 348         if (copy_to_user(_buffer, msg, n) != 0) {
 349                 ret = -EFAULT;
 350                 goto err_put_fd;
 351         }
 352
 353         /* CLOSE request has no reply */
 354         if (msg->opcode == CACHEFILES_OP_CLOSE) {
 355                 xa_erase(&cache->reqs, id);
 356                 complete(&req->done);
 357         }
 358
 359         return n;
 360
 361 err_put_fd:
 362         if (msg->opcode == CACHEFILES_OP_OPEN)
 363                 close_fd(((struct cachefiles_open *)msg->data)->fd);
 364 error:
 365         xa_erase(&cache->reqs, id);
 366         req->error = ret;
 367         complete(&req->done);
 368         return ret;
 369 }
 370
 371 typedef int (*init_req_fn)(struct cachefiles_req *req, void *private);
 372
 373 static int cachefiles_ondemand_send_req(struct cachefiles_object *object,
 374                                         enum cachefiles_opcode opcode,
 375                                         size_t data_len,
 376                                         init_req_fn init_req,
 377                                         void *private)
 378 {
 379         struct cachefiles_cache *cache = object->volume->cache;
 380         struct cachefiles_req *req = NULL;
 381         XA_STATE(xas, &cache->reqs, 0);
 382         int ret;
 383
 384         if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
 385                 return 0;
 386
 387         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
 388                 ret = -EIO;
 389                 goto out;
 390         }
 391
 392         req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
 393         if (!req) {
 394                 ret = -ENOMEM;
 395                 goto out;
 396         }
 397
 398         req->object = object;
 399         init_completion(&req->done);
 400         req->msg.opcode = opcode;
 401         req->msg.len = sizeof(struct cachefiles_msg) + data_len;
 402
 403         ret = init_req(req, private);
 404         if (ret)
 405                 goto out;
 406
 407         do {
 408                 /*
 409                  * Stop enqueuing the request when daemon is dying. The
 410                  * following two operations need to be atomic as a whole.
 411                  *   1) check cache state, and
 412                  *   2) enqueue request if cache is alive.
 413                  * Otherwise the request may be enqueued after xarray has been
 414                  * flushed, leaving the orphan request never being completed.
 415                  *
 416                  * CPU 1                        CPU 2
 417                  * =====                        =====
 418                  *                              test CACHEFILES_DEAD bit
 419                  * set CACHEFILES_DEAD bit
 420                  * flush requests in the xarray
 421                  *                              enqueue the request
 422                  */
 423                 xas_lock(&xas);
 424
 425                 if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
 426                         xas_unlock(&xas);
 427                         ret = -EIO;
 428                         goto out;
 429                 }
 430
 431                 /* coupled with the barrier in cachefiles_flush_reqs() */
 432                 smp_mb();
 433
 434                 if (opcode == CACHEFILES_OP_CLOSE &&
 435                         !cachefiles_ondemand_object_is_open(object)) {
 436                         WARN_ON_ONCE(object->ondemand->ondemand_id == 0);
 437                         xas_unlock(&xas);
 438                         ret = -EIO;
 439                         goto out;
 440                 }
 441
 442                 xas.xa_index = 0;
 443                 xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK);
 444                 if (xas.xa_node == XAS_RESTART)
 445                         xas_set_err(&xas, -EBUSY);
 446                 xas_store(&xas, req);
 447                 xas_clear_mark(&xas, XA_FREE_MARK);
 448                 xas_set_mark(&xas, CACHEFILES_REQ_NEW);
 449                 xas_unlock(&xas);
 450         } while (xas_nomem(&xas, GFP_KERNEL));
 451
 452         ret = xas_error(&xas);
 453         if (ret)
 454                 goto out;
 455
 456         wake_up_all(&cache->daemon_pollwq);
 457         wait_for_completion(&req->done);
 458         ret = req->error;
 459         kfree(req);
 460         return ret;
 461 out:
 462         /* Reset the object to close state in error handling path.
 463          * If error occurs after creating the anonymous fd,
 464          * cachefiles_ondemand_fd_release() will set object to close.
 465          */
 466         if (opcode == CACHEFILES_OP_OPEN)
 467                 cachefiles_ondemand_set_object_close(object);
 468         kfree(req);
 469         return ret;
 470 }
 471
 472 static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req,
 473                                              void *private)
 474 {
 475         struct cachefiles_object *object = req->object;
 476         struct fscache_cookie *cookie = object->cookie;
 477         struct fscache_volume *volume = object->volume->vcookie;
 478         struct cachefiles_open *load = (void *)req->msg.data;
 479         size_t volume_key_size, cookie_key_size;
 480         void *volume_key, *cookie_key;
 481
 482         /*
 483          * Volume key is a NUL-terminated string. key[0] stores strlen() of the
 484          * string, followed by the content of the string (excluding '\0').
 485          */
 486         volume_key_size = volume->key[0] + 1;
 487         volume_key = volume->key + 1;
 488
 489         /* Cookie key is binary data, which is netfs specific. */
 490         cookie_key_size = cookie->key_len;
 491         cookie_key = fscache_get_key(cookie);
 492
 493         if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) {
 494                 pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n");
 495                 return -EINVAL;
 496         }
 497
 498         load->volume_key_size = volume_key_size;
 499         load->cookie_key_size = cookie_key_size;
 500         memcpy(load->data, volume_key, volume_key_size);
 501         memcpy(load->data + volume_key_size, cookie_key, cookie_key_size);
 502
 503         return 0;
 504 }
 505
 506 static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req,
 507                                               void *private)
 508 {
 509         struct cachefiles_object *object = req->object;
 510
 511         if (!cachefiles_ondemand_object_is_open(object))
 512                 return -ENOENT;
 513
 514         trace_cachefiles_ondemand_close(object, &req->msg);
 515         return 0;
 516 }
 517
 518 struct cachefiles_read_ctx {
 519         loff_t off;
 520         size_t len;
 521 };
 522
 523 static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req,
 524                                              void *private)
 525 {
 526         struct cachefiles_object *object = req->object;
 527         struct cachefiles_read *load = (void *)req->msg.data;
 528         struct cachefiles_read_ctx *read_ctx = private;
 529
 530         load->off = read_ctx->off;
 531         load->len = read_ctx->len;
 532         trace_cachefiles_ondemand_read(object, &req->msg, load);
 533         return 0;
 534 }
 535
 536 int cachefiles_ondemand_init_object(struct cachefiles_object *object)
 537 {
 538         struct fscache_cookie *cookie = object->cookie;
 539         struct fscache_volume *volume = object->volume->vcookie;
 540         size_t volume_key_size, cookie_key_size, data_len;
 541
 542         if (!object->ondemand)
 543                 return 0;
 544
 545         /*
 546          * CacheFiles will firstly check the cache file under the root cache
 547          * directory. If the coherency check failed, it will fallback to
 548          * creating a new tmpfile as the cache file. Reuse the previously
 549          * allocated object ID if any.
 550          */
 551         if (cachefiles_ondemand_object_is_open(object))
 552                 return 0;
 553
 554         volume_key_size = volume->key[0] + 1;
 555         cookie_key_size = cookie->key_len;
 556         data_len = sizeof(struct cachefiles_open) +
 557                    volume_key_size + cookie_key_size;
 558
 559         return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN,
 560                         data_len, cachefiles_ondemand_init_open_req, NULL);
 561 }
 562
 563 void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
 564 {
 565         cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0,
 566                         cachefiles_ondemand_init_close_req, NULL);
 567 }
 568
 569 int cachefiles_ondemand_init_obj_info(struct cachefiles_object *object,
 570                                 struct cachefiles_volume *volume)
 571 {
 572         if (!cachefiles_in_ondemand_mode(volume->cache))
 573                 return 0;
 574
 575         object->ondemand = kzalloc(sizeof(struct cachefiles_ondemand_info),
 576                                         GFP_KERNEL);
 577         if (!object->ondemand)
 578                 return -ENOMEM;
 579
 580         object->ondemand->object = object;
 581         INIT_WORK(&object->ondemand->ondemand_work, ondemand_object_worker);
 582         return 0;
 583 }
 584
 585 void cachefiles_ondemand_deinit_obj_info(struct cachefiles_object *object)
 586 {
 587         kfree(object->ondemand);
 588         object->ondemand = NULL;
 589 }
 590
 591 int cachefiles_ondemand_read(struct cachefiles_object *object,
 592                              loff_t pos, size_t len)
 593 {
 594         struct cachefiles_read_ctx read_ctx = {pos, len};
 595
 596         return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ,
 597                         sizeof(struct cachefiles_read),
 598                         cachefiles_ondemand_init_read_req, &read_ctx);
 599 }