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