123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514 |
- // SPDX-License-Identifier: GPL-2.0-or-later
- #include <linux/fdtable.h>
- #include <linux/anon_inodes.h>
- #include <linux/uio.h>
- #include "internal.h"
- static int cachefiles_ondemand_fd_release(struct inode *inode,
- struct file *file)
- {
- struct cachefiles_object *object = file->private_data;
- struct cachefiles_cache *cache = object->volume->cache;
- int object_id = object->ondemand_id;
- struct cachefiles_req *req;
- XA_STATE(xas, &cache->reqs, 0);
- xa_lock(&cache->reqs);
- object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
- /*
- * Flush all pending READ requests since their completion depends on
- * anon_fd.
- */
- xas_for_each(&xas, req, ULONG_MAX) {
- if (req->msg.object_id == object_id &&
- req->msg.opcode == CACHEFILES_OP_READ) {
- req->error = -EIO;
- complete(&req->done);
- xas_store(&xas, NULL);
- }
- }
- xa_unlock(&cache->reqs);
- xa_erase(&cache->ondemand_ids, object_id);
- trace_cachefiles_ondemand_fd_release(object, object_id);
- cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
- cachefiles_put_unbind_pincount(cache);
- return 0;
- }
- static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,
- struct iov_iter *iter)
- {
- struct cachefiles_object *object = kiocb->ki_filp->private_data;
- struct cachefiles_cache *cache = object->volume->cache;
- struct file *file = object->file;
- size_t len = iter->count;
- loff_t pos = kiocb->ki_pos;
- const struct cred *saved_cred;
- int ret;
- if (!file)
- return -ENOBUFS;
- cachefiles_begin_secure(cache, &saved_cred);
- ret = __cachefiles_prepare_write(object, file, &pos, &len, true);
- cachefiles_end_secure(cache, saved_cred);
- if (ret < 0)
- return ret;
- trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
- ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
- if (!ret)
- ret = len;
- return ret;
- }
- static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos,
- int whence)
- {
- struct cachefiles_object *object = filp->private_data;
- struct file *file = object->file;
- if (!file)
- return -ENOBUFS;
- return vfs_llseek(file, pos, whence);
- }
- static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl,
- unsigned long arg)
- {
- struct cachefiles_object *object = filp->private_data;
- struct cachefiles_cache *cache = object->volume->cache;
- struct cachefiles_req *req;
- unsigned long id;
- if (ioctl != CACHEFILES_IOC_READ_COMPLETE)
- return -EINVAL;
- if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
- return -EOPNOTSUPP;
- id = arg;
- req = xa_erase(&cache->reqs, id);
- if (!req)
- return -EINVAL;
- trace_cachefiles_ondemand_cread(object, id);
- complete(&req->done);
- return 0;
- }
- static const struct file_operations cachefiles_ondemand_fd_fops = {
- .owner = THIS_MODULE,
- .release = cachefiles_ondemand_fd_release,
- .write_iter = cachefiles_ondemand_fd_write_iter,
- .llseek = cachefiles_ondemand_fd_llseek,
- .unlocked_ioctl = cachefiles_ondemand_fd_ioctl,
- };
- /*
- * OPEN request Completion (copen)
- * - command: "copen <id>,<cache_size>"
- * <cache_size> indicates the object size if >=0, error code if negative
- */
- int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args)
- {
- struct cachefiles_req *req;
- struct fscache_cookie *cookie;
- char *pid, *psize;
- unsigned long id;
- long size;
- int ret;
- if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
- return -EOPNOTSUPP;
- if (!*args) {
- pr_err("Empty id specified\n");
- return -EINVAL;
- }
- pid = args;
- psize = strchr(args, ',');
- if (!psize) {
- pr_err("Cache size is not specified\n");
- return -EINVAL;
- }
- *psize = 0;
- psize++;
- ret = kstrtoul(pid, 0, &id);
- if (ret)
- return ret;
- req = xa_erase(&cache->reqs, id);
- if (!req)
- return -EINVAL;
- /* fail OPEN request if copen format is invalid */
- ret = kstrtol(psize, 0, &size);
- if (ret) {
- req->error = ret;
- goto out;
- }
- /* fail OPEN request if daemon reports an error */
- if (size < 0) {
- if (!IS_ERR_VALUE(size)) {
- req->error = -EINVAL;
- ret = -EINVAL;
- } else {
- req->error = size;
- ret = 0;
- }
- goto out;
- }
- cookie = req->object->cookie;
- cookie->object_size = size;
- if (size)
- clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
- else
- set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
- trace_cachefiles_ondemand_copen(req->object, id, size);
- out:
- complete(&req->done);
- return ret;
- }
- static int cachefiles_ondemand_get_fd(struct cachefiles_req *req)
- {
- struct cachefiles_object *object;
- struct cachefiles_cache *cache;
- struct cachefiles_open *load;
- struct file *file;
- u32 object_id;
- int ret, fd;
- object = cachefiles_grab_object(req->object,
- cachefiles_obj_get_ondemand_fd);
- cache = object->volume->cache;
- ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL,
- XA_LIMIT(1, INT_MAX),
- &cache->ondemand_id_next, GFP_KERNEL);
- if (ret < 0)
- goto err;
- fd = get_unused_fd_flags(O_WRONLY);
- if (fd < 0) {
- ret = fd;
- goto err_free_id;
- }
- file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops,
- object, O_WRONLY);
- if (IS_ERR(file)) {
- ret = PTR_ERR(file);
- goto err_put_fd;
- }
- file->f_mode |= FMODE_PWRITE | FMODE_LSEEK;
- fd_install(fd, file);
- load = (void *)req->msg.data;
- load->fd = fd;
- req->msg.object_id = object_id;
- object->ondemand_id = object_id;
- cachefiles_get_unbind_pincount(cache);
- trace_cachefiles_ondemand_open(object, &req->msg, load);
- return 0;
- err_put_fd:
- put_unused_fd(fd);
- err_free_id:
- xa_erase(&cache->ondemand_ids, object_id);
- err:
- cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
- return ret;
- }
- ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
- char __user *_buffer, size_t buflen)
- {
- struct cachefiles_req *req;
- struct cachefiles_msg *msg;
- unsigned long id = 0;
- size_t n;
- int ret = 0;
- XA_STATE(xas, &cache->reqs, cache->req_id_next);
- /*
- * Cyclically search for a request that has not ever been processed,
- * to prevent requests from being processed repeatedly, and make
- * request distribution fair.
- */
- xa_lock(&cache->reqs);
- req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
- if (!req && cache->req_id_next > 0) {
- xas_set(&xas, 0);
- req = xas_find_marked(&xas, cache->req_id_next - 1, CACHEFILES_REQ_NEW);
- }
- if (!req) {
- xa_unlock(&cache->reqs);
- return 0;
- }
- msg = &req->msg;
- n = msg->len;
- if (n > buflen) {
- xa_unlock(&cache->reqs);
- return -EMSGSIZE;
- }
- xas_clear_mark(&xas, CACHEFILES_REQ_NEW);
- cache->req_id_next = xas.xa_index + 1;
- xa_unlock(&cache->reqs);
- id = xas.xa_index;
- msg->msg_id = id;
- if (msg->opcode == CACHEFILES_OP_OPEN) {
- ret = cachefiles_ondemand_get_fd(req);
- if (ret)
- goto error;
- }
- if (copy_to_user(_buffer, msg, n) != 0) {
- ret = -EFAULT;
- goto err_put_fd;
- }
- /* CLOSE request has no reply */
- if (msg->opcode == CACHEFILES_OP_CLOSE) {
- xa_erase(&cache->reqs, id);
- complete(&req->done);
- }
- return n;
- err_put_fd:
- if (msg->opcode == CACHEFILES_OP_OPEN)
- close_fd(((struct cachefiles_open *)msg->data)->fd);
- error:
- xa_erase(&cache->reqs, id);
- req->error = ret;
- complete(&req->done);
- return ret;
- }
- typedef int (*init_req_fn)(struct cachefiles_req *req, void *private);
- static int cachefiles_ondemand_send_req(struct cachefiles_object *object,
- enum cachefiles_opcode opcode,
- size_t data_len,
- init_req_fn init_req,
- void *private)
- {
- struct cachefiles_cache *cache = object->volume->cache;
- struct cachefiles_req *req;
- XA_STATE(xas, &cache->reqs, 0);
- int ret;
- if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
- return 0;
- if (test_bit(CACHEFILES_DEAD, &cache->flags))
- return -EIO;
- req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
- if (!req)
- return -ENOMEM;
- req->object = object;
- init_completion(&req->done);
- req->msg.opcode = opcode;
- req->msg.len = sizeof(struct cachefiles_msg) + data_len;
- ret = init_req(req, private);
- if (ret)
- goto out;
- do {
- /*
- * Stop enqueuing the request when daemon is dying. The
- * following two operations need to be atomic as a whole.
- * 1) check cache state, and
- * 2) enqueue request if cache is alive.
- * Otherwise the request may be enqueued after xarray has been
- * flushed, leaving the orphan request never being completed.
- *
- * CPU 1 CPU 2
- * ===== =====
- * test CACHEFILES_DEAD bit
- * set CACHEFILES_DEAD bit
- * flush requests in the xarray
- * enqueue the request
- */
- xas_lock(&xas);
- if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
- xas_unlock(&xas);
- ret = -EIO;
- goto out;
- }
- /* coupled with the barrier in cachefiles_flush_reqs() */
- smp_mb();
- if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) {
- WARN_ON_ONCE(object->ondemand_id == 0);
- xas_unlock(&xas);
- ret = -EIO;
- goto out;
- }
- xas.xa_index = 0;
- xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK);
- if (xas.xa_node == XAS_RESTART)
- xas_set_err(&xas, -EBUSY);
- xas_store(&xas, req);
- xas_clear_mark(&xas, XA_FREE_MARK);
- xas_set_mark(&xas, CACHEFILES_REQ_NEW);
- xas_unlock(&xas);
- } while (xas_nomem(&xas, GFP_KERNEL));
- ret = xas_error(&xas);
- if (ret)
- goto out;
- wake_up_all(&cache->daemon_pollwq);
- wait_for_completion(&req->done);
- ret = req->error;
- out:
- kfree(req);
- return ret;
- }
- static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req,
- void *private)
- {
- struct cachefiles_object *object = req->object;
- struct fscache_cookie *cookie = object->cookie;
- struct fscache_volume *volume = object->volume->vcookie;
- struct cachefiles_open *load = (void *)req->msg.data;
- size_t volume_key_size, cookie_key_size;
- void *volume_key, *cookie_key;
- /*
- * Volume key is a NUL-terminated string. key[0] stores strlen() of the
- * string, followed by the content of the string (excluding '\0').
- */
- volume_key_size = volume->key[0] + 1;
- volume_key = volume->key + 1;
- /* Cookie key is binary data, which is netfs specific. */
- cookie_key_size = cookie->key_len;
- cookie_key = fscache_get_key(cookie);
- if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) {
- pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n");
- return -EINVAL;
- }
- load->volume_key_size = volume_key_size;
- load->cookie_key_size = cookie_key_size;
- memcpy(load->data, volume_key, volume_key_size);
- memcpy(load->data + volume_key_size, cookie_key, cookie_key_size);
- return 0;
- }
- static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req,
- void *private)
- {
- struct cachefiles_object *object = req->object;
- int object_id = object->ondemand_id;
- /*
- * It's possible that object id is still 0 if the cookie looking up
- * phase failed before OPEN request has ever been sent. Also avoid
- * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means
- * anon_fd has already been closed.
- */
- if (object_id <= 0)
- return -ENOENT;
- req->msg.object_id = object_id;
- trace_cachefiles_ondemand_close(object, &req->msg);
- return 0;
- }
- struct cachefiles_read_ctx {
- loff_t off;
- size_t len;
- };
- static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req,
- void *private)
- {
- struct cachefiles_object *object = req->object;
- struct cachefiles_read *load = (void *)req->msg.data;
- struct cachefiles_read_ctx *read_ctx = private;
- int object_id = object->ondemand_id;
- /* Stop enqueuing requests when daemon has closed anon_fd. */
- if (object_id <= 0) {
- WARN_ON_ONCE(object_id == 0);
- pr_info_once("READ: anonymous fd closed prematurely.\n");
- return -EIO;
- }
- req->msg.object_id = object_id;
- load->off = read_ctx->off;
- load->len = read_ctx->len;
- trace_cachefiles_ondemand_read(object, &req->msg, load);
- return 0;
- }
- int cachefiles_ondemand_init_object(struct cachefiles_object *object)
- {
- struct fscache_cookie *cookie = object->cookie;
- struct fscache_volume *volume = object->volume->vcookie;
- size_t volume_key_size, cookie_key_size, data_len;
- /*
- * CacheFiles will firstly check the cache file under the root cache
- * directory. If the coherency check failed, it will fallback to
- * creating a new tmpfile as the cache file. Reuse the previously
- * allocated object ID if any.
- */
- if (object->ondemand_id > 0)
- return 0;
- volume_key_size = volume->key[0] + 1;
- cookie_key_size = cookie->key_len;
- data_len = sizeof(struct cachefiles_open) +
- volume_key_size + cookie_key_size;
- return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN,
- data_len, cachefiles_ondemand_init_open_req, NULL);
- }
- void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
- {
- cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0,
- cachefiles_ondemand_init_close_req, NULL);
- }
- int cachefiles_ondemand_read(struct cachefiles_object *object,
- loff_t pos, size_t len)
- {
- struct cachefiles_read_ctx read_ctx = {pos, len};
- return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ,
- sizeof(struct cachefiles_read),
- cachefiles_ondemand_init_read_req, &read_ctx);
- }
|