fs/cachefiles/ondemand.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 #include <linux/fdtable.h>
0003 #include <linux/anon_inodes.h>
0004 #include <linux/uio.h>
0005 #include "internal.h"
0006
0007 static int cachefiles_ondemand_fd_release(struct inode *inode,
0008                       struct file *file)
0009 {
0010     struct cachefiles_object *object = file->private_data;
0011     struct cachefiles_cache *cache = object->volume->cache;
0012     int object_id = object->ondemand_id;
0013     struct cachefiles_req *req;
0014     XA_STATE(xas, &cache->reqs, 0);
0015
0016     xa_lock(&cache->reqs);
0017     object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
0018
0019     /*
0020      * Flush all pending READ requests since their completion depends on
0021      * anon_fd.
0022      */
0023     xas_for_each(&xas, req, ULONG_MAX) {
0024         if (req->msg.object_id == object_id &&
0025             req->msg.opcode == CACHEFILES_OP_READ) {
0026             req->error = -EIO;
0027             complete(&req->done);
0028             xas_store(&xas, NULL);
0029         }
0030     }
0031     xa_unlock(&cache->reqs);
0032
0033     xa_erase(&cache->ondemand_ids, object_id);
0034     trace_cachefiles_ondemand_fd_release(object, object_id);
0035     cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
0036     cachefiles_put_unbind_pincount(cache);
0037     return 0;
0038 }
0039
0040 static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,
0041                          struct iov_iter *iter)
0042 {
0043     struct cachefiles_object *object = kiocb->ki_filp->private_data;
0044     struct cachefiles_cache *cache = object->volume->cache;
0045     struct file *file = object->file;
0046     size_t len = iter->count;
0047     loff_t pos = kiocb->ki_pos;
0048     const struct cred *saved_cred;
0049     int ret;
0050
0051     if (!file)
0052         return -ENOBUFS;
0053
0054     cachefiles_begin_secure(cache, &saved_cred);
0055     ret = __cachefiles_prepare_write(object, file, &pos, &len, true);
0056     cachefiles_end_secure(cache, saved_cred);
0057     if (ret < 0)
0058         return ret;
0059
0060     trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
0061     ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
0062     if (!ret)
0063         ret = len;
0064
0065     return ret;
0066 }
0067
0068 static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos,
0069                         int whence)
0070 {
0071     struct cachefiles_object *object = filp->private_data;
0072     struct file *file = object->file;
0073
0074     if (!file)
0075         return -ENOBUFS;
0076
0077     return vfs_llseek(file, pos, whence);
0078 }
0079
0080 static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl,
0081                      unsigned long arg)
0082 {
0083     struct cachefiles_object *object = filp->private_data;
0084     struct cachefiles_cache *cache = object->volume->cache;
0085     struct cachefiles_req *req;
0086     unsigned long id;
0087
0088     if (ioctl != CACHEFILES_IOC_READ_COMPLETE)
0089         return -EINVAL;
0090
0091     if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
0092         return -EOPNOTSUPP;
0093
0094     id = arg;
0095     req = xa_erase(&cache->reqs, id);
0096     if (!req)
0097         return -EINVAL;
0098
0099     trace_cachefiles_ondemand_cread(object, id);
0100     complete(&req->done);
0101     return 0;
0102 }
0103
0104 static const struct file_operations cachefiles_ondemand_fd_fops = {
0105     .owner      = THIS_MODULE,
0106     .release    = cachefiles_ondemand_fd_release,
0107     .write_iter = cachefiles_ondemand_fd_write_iter,
0108     .llseek     = cachefiles_ondemand_fd_llseek,
0109     .unlocked_ioctl = cachefiles_ondemand_fd_ioctl,
0110 };
0111
0112 /*
0113  * OPEN request Completion (copen)
0114  * - command: "copen <id>,<cache_size>"
0115  *   <cache_size> indicates the object size if >=0, error code if negative
0116  */
0117 int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args)
0118 {
0119     struct cachefiles_req *req;
0120     struct fscache_cookie *cookie;
0121     char *pid, *psize;
0122     unsigned long id;
0123     long size;
0124     int ret;
0125
0126     if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
0127         return -EOPNOTSUPP;
0128
0129     if (!*args) {
0130         pr_err("Empty id specified\n");
0131         return -EINVAL;
0132     }
0133
0134     pid = args;
0135     psize = strchr(args, ',');
0136     if (!psize) {
0137         pr_err("Cache size is not specified\n");
0138         return -EINVAL;
0139     }
0140
0141     *psize = 0;
0142     psize++;
0143
0144     ret = kstrtoul(pid, 0, &id);
0145     if (ret)
0146         return ret;
0147
0148     req = xa_erase(&cache->reqs, id);
0149     if (!req)
0150         return -EINVAL;
0151
0152     /* fail OPEN request if copen format is invalid */
0153     ret = kstrtol(psize, 0, &size);
0154     if (ret) {
0155         req->error = ret;
0156         goto out;
0157     }
0158
0159     /* fail OPEN request if daemon reports an error */
0160     if (size < 0) {
0161         if (!IS_ERR_VALUE(size)) {
0162             req->error = -EINVAL;
0163             ret = -EINVAL;
0164         } else {
0165             req->error = size;
0166             ret = 0;
0167         }
0168         goto out;
0169     }
0170
0171     cookie = req->object->cookie;
0172     cookie->object_size = size;
0173     if (size)
0174         clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
0175     else
0176         set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
0177     trace_cachefiles_ondemand_copen(req->object, id, size);
0178
0179 out:
0180     complete(&req->done);
0181     return ret;
0182 }
0183
0184 static int cachefiles_ondemand_get_fd(struct cachefiles_req *req)
0185 {
0186     struct cachefiles_object *object;
0187     struct cachefiles_cache *cache;
0188     struct cachefiles_open *load;
0189     struct file *file;
0190     u32 object_id;
0191     int ret, fd;
0192
0193     object = cachefiles_grab_object(req->object,
0194             cachefiles_obj_get_ondemand_fd);
0195     cache = object->volume->cache;
0196
0197     ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL,
0198                   XA_LIMIT(1, INT_MAX),
0199                   &cache->ondemand_id_next, GFP_KERNEL);
0200     if (ret < 0)
0201         goto err;
0202
0203     fd = get_unused_fd_flags(O_WRONLY);
0204     if (fd < 0) {
0205         ret = fd;
0206         goto err_free_id;
0207     }
0208
0209     file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops,
0210                   object, O_WRONLY);
0211     if (IS_ERR(file)) {
0212         ret = PTR_ERR(file);
0213         goto err_put_fd;
0214     }
0215
0216     file->f_mode |= FMODE_PWRITE | FMODE_LSEEK;
0217     fd_install(fd, file);
0218
0219     load = (void *)req->msg.data;
0220     load->fd = fd;
0221     req->msg.object_id = object_id;
0222     object->ondemand_id = object_id;
0223
0224     cachefiles_get_unbind_pincount(cache);
0225     trace_cachefiles_ondemand_open(object, &req->msg, load);
0226     return 0;
0227
0228 err_put_fd:
0229     put_unused_fd(fd);
0230 err_free_id:
0231     xa_erase(&cache->ondemand_ids, object_id);
0232 err:
0233     cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
0234     return ret;
0235 }
0236
0237 ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
0238                     char __user *_buffer, size_t buflen)
0239 {
0240     struct cachefiles_req *req;
0241     struct cachefiles_msg *msg;
0242     unsigned long id = 0;
0243     size_t n;
0244     int ret = 0;
0245     XA_STATE(xas, &cache->reqs, cache->req_id_next);
0246
0247     /*
0248      * Cyclically search for a request that has not ever been processed,
0249      * to prevent requests from being processed repeatedly, and make
0250      * request distribution fair.
0251      */
0252     xa_lock(&cache->reqs);
0253     req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
0254     if (!req && cache->req_id_next > 0) {
0255         xas_set(&xas, 0);
0256         req = xas_find_marked(&xas, cache->req_id_next - 1, CACHEFILES_REQ_NEW);
0257     }
0258     if (!req) {
0259         xa_unlock(&cache->reqs);
0260         return 0;
0261     }
0262
0263     msg = &req->msg;
0264     n = msg->len;
0265
0266     if (n > buflen) {
0267         xa_unlock(&cache->reqs);
0268         return -EMSGSIZE;
0269     }
0270
0271     xas_clear_mark(&xas, CACHEFILES_REQ_NEW);
0272     cache->req_id_next = xas.xa_index + 1;
0273     xa_unlock(&cache->reqs);
0274
0275     id = xas.xa_index;
0276     msg->msg_id = id;
0277
0278     if (msg->opcode == CACHEFILES_OP_OPEN) {
0279         ret = cachefiles_ondemand_get_fd(req);
0280         if (ret)
0281             goto error;
0282     }
0283
0284     if (copy_to_user(_buffer, msg, n) != 0) {
0285         ret = -EFAULT;
0286         goto err_put_fd;
0287     }
0288
0289     /* CLOSE request has no reply */
0290     if (msg->opcode == CACHEFILES_OP_CLOSE) {
0291         xa_erase(&cache->reqs, id);
0292         complete(&req->done);
0293     }
0294
0295     return n;
0296
0297 err_put_fd:
0298     if (msg->opcode == CACHEFILES_OP_OPEN)
0299         close_fd(((struct cachefiles_open *)msg->data)->fd);
0300 error:
0301     xa_erase(&cache->reqs, id);
0302     req->error = ret;
0303     complete(&req->done);
0304     return ret;
0305 }
0306
0307 typedef int (*init_req_fn)(struct cachefiles_req *req, void *private);
0308
0309 static int cachefiles_ondemand_send_req(struct cachefiles_object *object,
0310                     enum cachefiles_opcode opcode,
0311                     size_t data_len,
0312                     init_req_fn init_req,
0313                     void *private)
0314 {
0315     struct cachefiles_cache *cache = object->volume->cache;
0316     struct cachefiles_req *req;
0317     XA_STATE(xas, &cache->reqs, 0);
0318     int ret;
0319
0320     if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
0321         return 0;
0322
0323     if (test_bit(CACHEFILES_DEAD, &cache->flags))
0324         return -EIO;
0325
0326     req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
0327     if (!req)
0328         return -ENOMEM;
0329
0330     req->object = object;
0331     init_completion(&req->done);
0332     req->msg.opcode = opcode;
0333     req->msg.len = sizeof(struct cachefiles_msg) + data_len;
0334
0335     ret = init_req(req, private);
0336     if (ret)
0337         goto out;
0338
0339     do {
0340         /*
0341          * Stop enqueuing the request when daemon is dying. The
0342          * following two operations need to be atomic as a whole.
0343          *   1) check cache state, and
0344          *   2) enqueue request if cache is alive.
0345          * Otherwise the request may be enqueued after xarray has been
0346          * flushed, leaving the orphan request never being completed.
0347          *
0348          * CPU 1            CPU 2
0349          * =====            =====
0350          *              test CACHEFILES_DEAD bit
0351          * set CACHEFILES_DEAD bit
0352          * flush requests in the xarray
0353          *              enqueue the request
0354          */
0355         xas_lock(&xas);
0356
0357         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
0358             xas_unlock(&xas);
0359             ret = -EIO;
0360             goto out;
0361         }
0362
0363         /* coupled with the barrier in cachefiles_flush_reqs() */
0364         smp_mb();
0365
0366         if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) {
0367             WARN_ON_ONCE(object->ondemand_id == 0);
0368             xas_unlock(&xas);
0369             ret = -EIO;
0370             goto out;
0371         }
0372
0373         xas.xa_index = 0;
0374         xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK);
0375         if (xas.xa_node == XAS_RESTART)
0376             xas_set_err(&xas, -EBUSY);
0377         xas_store(&xas, req);
0378         xas_clear_mark(&xas, XA_FREE_MARK);
0379         xas_set_mark(&xas, CACHEFILES_REQ_NEW);
0380         xas_unlock(&xas);
0381     } while (xas_nomem(&xas, GFP_KERNEL));
0382
0383     ret = xas_error(&xas);
0384     if (ret)
0385         goto out;
0386
0387     wake_up_all(&cache->daemon_pollwq);
0388     wait_for_completion(&req->done);
0389     ret = req->error;
0390 out:
0391     kfree(req);
0392     return ret;
0393 }
0394
0395 static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req,
0396                          void *private)
0397 {
0398     struct cachefiles_object *object = req->object;
0399     struct fscache_cookie *cookie = object->cookie;
0400     struct fscache_volume *volume = object->volume->vcookie;
0401     struct cachefiles_open *load = (void *)req->msg.data;
0402     size_t volume_key_size, cookie_key_size;
0403     void *volume_key, *cookie_key;
0404
0405     /*
0406      * Volume key is a NUL-terminated string. key[0] stores strlen() of the
0407      * string, followed by the content of the string (excluding '\0').
0408      */
0409     volume_key_size = volume->key[0] + 1;
0410     volume_key = volume->key + 1;
0411
0412     /* Cookie key is binary data, which is netfs specific. */
0413     cookie_key_size = cookie->key_len;
0414     cookie_key = fscache_get_key(cookie);
0415
0416     if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) {
0417         pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n");
0418         return -EINVAL;
0419     }
0420
0421     load->volume_key_size = volume_key_size;
0422     load->cookie_key_size = cookie_key_size;
0423     memcpy(load->data, volume_key, volume_key_size);
0424     memcpy(load->data + volume_key_size, cookie_key, cookie_key_size);
0425
0426     return 0;
0427 }
0428
0429 static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req,
0430                           void *private)
0431 {
0432     struct cachefiles_object *object = req->object;
0433     int object_id = object->ondemand_id;
0434
0435     /*
0436      * It's possible that object id is still 0 if the cookie looking up
0437      * phase failed before OPEN request has ever been sent. Also avoid
0438      * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means
0439      * anon_fd has already been closed.
0440      */
0441     if (object_id <= 0)
0442         return -ENOENT;
0443
0444     req->msg.object_id = object_id;
0445     trace_cachefiles_ondemand_close(object, &req->msg);
0446     return 0;
0447 }
0448
0449 struct cachefiles_read_ctx {
0450     loff_t off;
0451     size_t len;
0452 };
0453
0454 static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req,
0455                          void *private)
0456 {
0457     struct cachefiles_object *object = req->object;
0458     struct cachefiles_read *load = (void *)req->msg.data;
0459     struct cachefiles_read_ctx *read_ctx = private;
0460     int object_id = object->ondemand_id;
0461
0462     /* Stop enqueuing requests when daemon has closed anon_fd. */
0463     if (object_id <= 0) {
0464         WARN_ON_ONCE(object_id == 0);
0465         pr_info_once("READ: anonymous fd closed prematurely.\n");
0466         return -EIO;
0467     }
0468
0469     req->msg.object_id = object_id;
0470     load->off = read_ctx->off;
0471     load->len = read_ctx->len;
0472     trace_cachefiles_ondemand_read(object, &req->msg, load);
0473     return 0;
0474 }
0475
0476 int cachefiles_ondemand_init_object(struct cachefiles_object *object)
0477 {
0478     struct fscache_cookie *cookie = object->cookie;
0479     struct fscache_volume *volume = object->volume->vcookie;
0480     size_t volume_key_size, cookie_key_size, data_len;
0481
0482     /*
0483      * CacheFiles will firstly check the cache file under the root cache
0484      * directory. If the coherency check failed, it will fallback to
0485      * creating a new tmpfile as the cache file. Reuse the previously
0486      * allocated object ID if any.
0487      */
0488     if (object->ondemand_id > 0)
0489         return 0;
0490
0491     volume_key_size = volume->key[0] + 1;
0492     cookie_key_size = cookie->key_len;
0493     data_len = sizeof(struct cachefiles_open) +
0494            volume_key_size + cookie_key_size;
0495
0496     return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN,
0497             data_len, cachefiles_ondemand_init_open_req, NULL);
0498 }
0499
0500 void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
0501 {
0502     cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0,
0503             cachefiles_ondemand_init_close_req, NULL);
0504 }
0505
0506 int cachefiles_ondemand_read(struct cachefiles_object *object,
0507                  loff_t pos, size_t len)
0508 {
0509     struct cachefiles_read_ctx read_ctx = {pos, len};
0510
0511     return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ,
0512             sizeof(struct cachefiles_read),
0513             cachefiles_ondemand_init_read_req, &read_ctx);
0514 }