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