Branch data Line data Source code
1 : : /*
2 : : FUSE: Filesystem in Userspace
3 : : Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
4 : :
5 : : This program can be distributed under the terms of the GNU GPL.
6 : : See the file COPYING.
7 : : */
8 : :
9 : : #include "fuse_i.h"
10 : :
11 : : #include <linux/init.h>
12 : : #include <linux/module.h>
13 : : #include <linux/poll.h>
14 : : #include <linux/sched/signal.h>
15 : : #include <linux/uio.h>
16 : : #include <linux/miscdevice.h>
17 : : #include <linux/pagemap.h>
18 : : #include <linux/file.h>
19 : : #include <linux/slab.h>
20 : : #include <linux/pipe_fs_i.h>
21 : : #include <linux/swap.h>
22 : : #include <linux/splice.h>
23 : : #include <linux/sched.h>
24 : :
25 : : MODULE_ALIAS_MISCDEV(FUSE_MINOR);
26 : : MODULE_ALIAS("devname:fuse");
27 : :
28 : : /* Ordinary requests have even IDs, while interrupts IDs are odd */
29 : : #define FUSE_INT_REQ_BIT (1ULL << 0)
30 : : #define FUSE_REQ_ID_STEP (1ULL << 1)
31 : :
32 : : static struct kmem_cache *fuse_req_cachep;
33 : :
34 : : static struct fuse_dev *fuse_get_dev(struct file *file)
35 : : {
36 : : /*
37 : : * Lockless access is OK, because file->private data is set
38 : : * once during mount and is valid until the file is released.
39 : : */
40 : : return READ_ONCE(file->private_data);
41 : : }
42 : :
43 : 3 : static void fuse_request_init(struct fuse_req *req)
44 : : {
45 : 3 : INIT_LIST_HEAD(&req->list);
46 : 3 : INIT_LIST_HEAD(&req->intr_entry);
47 : 3 : init_waitqueue_head(&req->waitq);
48 : : refcount_set(&req->count, 1);
49 : : __set_bit(FR_PENDING, &req->flags);
50 : 3 : }
51 : :
52 : 3 : static struct fuse_req *fuse_request_alloc(gfp_t flags)
53 : : {
54 : 3 : struct fuse_req *req = kmem_cache_zalloc(fuse_req_cachep, flags);
55 : 3 : if (req)
56 : 3 : fuse_request_init(req);
57 : :
58 : 3 : return req;
59 : : }
60 : :
61 : : static void fuse_request_free(struct fuse_req *req)
62 : : {
63 : 3 : kmem_cache_free(fuse_req_cachep, req);
64 : : }
65 : :
66 : : static void __fuse_get_request(struct fuse_req *req)
67 : : {
68 : 3 : refcount_inc(&req->count);
69 : : }
70 : :
71 : : /* Must be called with > 1 refcount */
72 : : static void __fuse_put_request(struct fuse_req *req)
73 : : {
74 : 0 : refcount_dec(&req->count);
75 : : }
76 : :
77 : 3 : void fuse_set_initialized(struct fuse_conn *fc)
78 : : {
79 : : /* Make sure stores before this are seen on another CPU */
80 : 3 : smp_wmb();
81 : 3 : fc->initialized = 1;
82 : 3 : }
83 : :
84 : : static bool fuse_block_alloc(struct fuse_conn *fc, bool for_background)
85 : : {
86 : 3 : return !fc->initialized || (for_background && fc->blocked);
87 : : }
88 : :
89 : 3 : static void fuse_drop_waiting(struct fuse_conn *fc)
90 : : {
91 : : /*
92 : : * lockess check of fc->connected is okay, because atomic_dec_and_test()
93 : : * provides a memory barrier mached with the one in fuse_wait_aborted()
94 : : * to ensure no wake-up is missed.
95 : : */
96 : 3 : if (atomic_dec_and_test(&fc->num_waiting) &&
97 : : !READ_ONCE(fc->connected)) {
98 : : /* wake up aborters */
99 : 0 : wake_up_all(&fc->blocked_waitq);
100 : : }
101 : 3 : }
102 : :
103 : : static void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);
104 : :
105 : 3 : static struct fuse_req *fuse_get_req(struct fuse_conn *fc, bool for_background)
106 : : {
107 : : struct fuse_req *req;
108 : : int err;
109 : 3 : atomic_inc(&fc->num_waiting);
110 : :
111 : 3 : if (fuse_block_alloc(fc, for_background)) {
112 : : err = -EINTR;
113 : 0 : if (wait_event_killable_exclusive(fc->blocked_waitq,
114 : : !fuse_block_alloc(fc, for_background)))
115 : : goto out;
116 : : }
117 : : /* Matches smp_wmb() in fuse_set_initialized() */
118 : 3 : smp_rmb();
119 : :
120 : : err = -ENOTCONN;
121 : 3 : if (!fc->connected)
122 : : goto out;
123 : :
124 : : err = -ECONNREFUSED;
125 : 3 : if (fc->conn_error)
126 : : goto out;
127 : :
128 : 3 : req = fuse_request_alloc(GFP_KERNEL);
129 : : err = -ENOMEM;
130 : 3 : if (!req) {
131 : 0 : if (for_background)
132 : 0 : wake_up(&fc->blocked_waitq);
133 : : goto out;
134 : : }
135 : :
136 : 3 : req->in.h.uid = from_kuid(fc->user_ns, current_fsuid());
137 : 3 : req->in.h.gid = from_kgid(fc->user_ns, current_fsgid());
138 : 3 : req->in.h.pid = pid_nr_ns(task_pid(current), fc->pid_ns);
139 : :
140 : : __set_bit(FR_WAITING, &req->flags);
141 : 3 : if (for_background)
142 : : __set_bit(FR_BACKGROUND, &req->flags);
143 : :
144 : 3 : if (unlikely(req->in.h.uid == ((uid_t)-1) ||
145 : : req->in.h.gid == ((gid_t)-1))) {
146 : 0 : fuse_put_request(fc, req);
147 : 0 : return ERR_PTR(-EOVERFLOW);
148 : : }
149 : : return req;
150 : :
151 : : out:
152 : 0 : fuse_drop_waiting(fc);
153 : 0 : return ERR_PTR(err);
154 : : }
155 : :
156 : 3 : static void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
157 : : {
158 : 3 : if (refcount_dec_and_test(&req->count)) {
159 : 3 : if (test_bit(FR_BACKGROUND, &req->flags)) {
160 : : /*
161 : : * We get here in the unlikely case that a background
162 : : * request was allocated but not sent
163 : : */
164 : : spin_lock(&fc->bg_lock);
165 : 0 : if (!fc->blocked)
166 : 0 : wake_up(&fc->blocked_waitq);
167 : : spin_unlock(&fc->bg_lock);
168 : : }
169 : :
170 : 3 : if (test_bit(FR_WAITING, &req->flags)) {
171 : : __clear_bit(FR_WAITING, &req->flags);
172 : 3 : fuse_drop_waiting(fc);
173 : : }
174 : :
175 : : fuse_request_free(req);
176 : : }
177 : 3 : }
178 : :
179 : 0 : unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args)
180 : : {
181 : : unsigned nbytes = 0;
182 : : unsigned i;
183 : :
184 : 3 : for (i = 0; i < numargs; i++)
185 : 3 : nbytes += args[i].size;
186 : :
187 : 3 : return nbytes;
188 : : }
189 : : EXPORT_SYMBOL_GPL(fuse_len_args);
190 : :
191 : 0 : u64 fuse_get_unique(struct fuse_iqueue *fiq)
192 : : {
193 : 3 : fiq->reqctr += FUSE_REQ_ID_STEP;
194 : 0 : return fiq->reqctr;
195 : : }
196 : : EXPORT_SYMBOL_GPL(fuse_get_unique);
197 : :
198 : : static unsigned int fuse_req_hash(u64 unique)
199 : : {
200 : 3 : return hash_long(unique & ~FUSE_INT_REQ_BIT, FUSE_PQ_HASH_BITS);
201 : : }
202 : :
203 : : /**
204 : : * A new request is available, wake fiq->waitq
205 : : */
206 : 3 : static void fuse_dev_wake_and_unlock(struct fuse_iqueue *fiq)
207 : : __releases(fiq->lock)
208 : : {
209 : 3 : wake_up(&fiq->waitq);
210 : 3 : kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
211 : : spin_unlock(&fiq->lock);
212 : 3 : }
213 : :
214 : : const struct fuse_iqueue_ops fuse_dev_fiq_ops = {
215 : : .wake_forget_and_unlock = fuse_dev_wake_and_unlock,
216 : : .wake_interrupt_and_unlock = fuse_dev_wake_and_unlock,
217 : : .wake_pending_and_unlock = fuse_dev_wake_and_unlock,
218 : : };
219 : : EXPORT_SYMBOL_GPL(fuse_dev_fiq_ops);
220 : :
221 : 3 : static void queue_request_and_unlock(struct fuse_iqueue *fiq,
222 : : struct fuse_req *req)
223 : : __releases(fiq->lock)
224 : : {
225 : 3 : req->in.h.len = sizeof(struct fuse_in_header) +
226 : 3 : fuse_len_args(req->args->in_numargs,
227 : 3 : (struct fuse_arg *) req->args->in_args);
228 : 3 : list_add_tail(&req->list, &fiq->pending);
229 : 3 : fiq->ops->wake_pending_and_unlock(fiq);
230 : 3 : }
231 : :
232 : 0 : void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
233 : : u64 nodeid, u64 nlookup)
234 : : {
235 : 0 : struct fuse_iqueue *fiq = &fc->iq;
236 : :
237 : 0 : forget->forget_one.nodeid = nodeid;
238 : 0 : forget->forget_one.nlookup = nlookup;
239 : :
240 : : spin_lock(&fiq->lock);
241 : 0 : if (fiq->connected) {
242 : 0 : fiq->forget_list_tail->next = forget;
243 : 0 : fiq->forget_list_tail = forget;
244 : 0 : fiq->ops->wake_forget_and_unlock(fiq);
245 : : } else {
246 : 0 : kfree(forget);
247 : : spin_unlock(&fiq->lock);
248 : : }
249 : 0 : }
250 : :
251 : 3 : static void flush_bg_queue(struct fuse_conn *fc)
252 : : {
253 : 3 : struct fuse_iqueue *fiq = &fc->iq;
254 : :
255 : 3 : while (fc->active_background < fc->max_background &&
256 : 3 : !list_empty(&fc->bg_queue)) {
257 : : struct fuse_req *req;
258 : :
259 : 3 : req = list_first_entry(&fc->bg_queue, struct fuse_req, list);
260 : : list_del(&req->list);
261 : 3 : fc->active_background++;
262 : : spin_lock(&fiq->lock);
263 : 3 : req->in.h.unique = fuse_get_unique(fiq);
264 : 3 : queue_request_and_unlock(fiq, req);
265 : : }
266 : 3 : }
267 : :
268 : : /*
269 : : * This function is called when a request is finished. Either a reply
270 : : * has arrived or it was aborted (and not yet sent) or some error
271 : : * occurred during communication with userspace, or the device file
272 : : * was closed. The requester thread is woken up (if still waiting),
273 : : * the 'end' callback is called if given, else the reference to the
274 : : * request is released
275 : : */
276 : 3 : void fuse_request_end(struct fuse_conn *fc, struct fuse_req *req)
277 : : {
278 : : struct fuse_iqueue *fiq = &fc->iq;
279 : :
280 : 3 : if (test_and_set_bit(FR_FINISHED, &req->flags))
281 : : goto put_request;
282 : :
283 : : /*
284 : : * test_and_set_bit() implies smp_mb() between bit
285 : : * changing and below intr_entry check. Pairs with
286 : : * smp_mb() from queue_interrupt().
287 : : */
288 : 3 : if (!list_empty(&req->intr_entry)) {
289 : : spin_lock(&fiq->lock);
290 : : list_del_init(&req->intr_entry);
291 : : spin_unlock(&fiq->lock);
292 : : }
293 : 3 : WARN_ON(test_bit(FR_PENDING, &req->flags));
294 : 3 : WARN_ON(test_bit(FR_SENT, &req->flags));
295 : 3 : if (test_bit(FR_BACKGROUND, &req->flags)) {
296 : : spin_lock(&fc->bg_lock);
297 : 3 : clear_bit(FR_BACKGROUND, &req->flags);
298 : 3 : if (fc->num_background == fc->max_background) {
299 : 0 : fc->blocked = 0;
300 : 0 : wake_up(&fc->blocked_waitq);
301 : 3 : } else if (!fc->blocked) {
302 : : /*
303 : : * Wake up next waiter, if any. It's okay to use
304 : : * waitqueue_active(), as we've already synced up
305 : : * fc->blocked with waiters with the wake_up() call
306 : : * above.
307 : : */
308 : 3 : if (waitqueue_active(&fc->blocked_waitq))
309 : 0 : wake_up(&fc->blocked_waitq);
310 : : }
311 : :
312 : 3 : if (fc->num_background == fc->congestion_threshold && fc->sb) {
313 : 0 : clear_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC);
314 : 0 : clear_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC);
315 : : }
316 : 3 : fc->num_background--;
317 : 3 : fc->active_background--;
318 : 3 : flush_bg_queue(fc);
319 : : spin_unlock(&fc->bg_lock);
320 : : } else {
321 : : /* Wake up waiter sleeping in request_wait_answer() */
322 : 3 : wake_up(&req->waitq);
323 : : }
324 : :
325 : 3 : if (test_bit(FR_ASYNC, &req->flags))
326 : 3 : req->args->end(fc, req->args, req->out.h.error);
327 : : put_request:
328 : 3 : fuse_put_request(fc, req);
329 : 3 : }
330 : : EXPORT_SYMBOL_GPL(fuse_request_end);
331 : :
332 : 0 : static int queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req)
333 : : {
334 : : spin_lock(&fiq->lock);
335 : : /* Check for we've sent request to interrupt this req */
336 : 0 : if (unlikely(!test_bit(FR_INTERRUPTED, &req->flags))) {
337 : : spin_unlock(&fiq->lock);
338 : 0 : return -EINVAL;
339 : : }
340 : :
341 : 0 : if (list_empty(&req->intr_entry)) {
342 : 0 : list_add_tail(&req->intr_entry, &fiq->interrupts);
343 : : /*
344 : : * Pairs with smp_mb() implied by test_and_set_bit()
345 : : * from request_end().
346 : : */
347 : 0 : smp_mb();
348 : 0 : if (test_bit(FR_FINISHED, &req->flags)) {
349 : : list_del_init(&req->intr_entry);
350 : : spin_unlock(&fiq->lock);
351 : 0 : return 0;
352 : : }
353 : 0 : fiq->ops->wake_interrupt_and_unlock(fiq);
354 : : } else {
355 : : spin_unlock(&fiq->lock);
356 : : }
357 : : return 0;
358 : : }
359 : :
360 : 3 : static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
361 : : {
362 : 3 : struct fuse_iqueue *fiq = &fc->iq;
363 : : int err;
364 : :
365 : 3 : if (!fc->no_interrupt) {
366 : : /* Any signal may interrupt this */
367 : 3 : err = wait_event_interruptible(req->waitq,
368 : : test_bit(FR_FINISHED, &req->flags));
369 : 3 : if (!err)
370 : : return;
371 : :
372 : 0 : set_bit(FR_INTERRUPTED, &req->flags);
373 : : /* matches barrier in fuse_dev_do_read() */
374 : 0 : smp_mb__after_atomic();
375 : 0 : if (test_bit(FR_SENT, &req->flags))
376 : 0 : queue_interrupt(fiq, req);
377 : : }
378 : :
379 : 0 : if (!test_bit(FR_FORCE, &req->flags)) {
380 : : /* Only fatal signals may interrupt this */
381 : 0 : err = wait_event_killable(req->waitq,
382 : : test_bit(FR_FINISHED, &req->flags));
383 : 0 : if (!err)
384 : : return;
385 : :
386 : : spin_lock(&fiq->lock);
387 : : /* Request is not yet in userspace, bail out */
388 : 0 : if (test_bit(FR_PENDING, &req->flags)) {
389 : : list_del(&req->list);
390 : : spin_unlock(&fiq->lock);
391 : : __fuse_put_request(req);
392 : 0 : req->out.h.error = -EINTR;
393 : 0 : return;
394 : : }
395 : : spin_unlock(&fiq->lock);
396 : : }
397 : :
398 : : /*
399 : : * Either request is already in userspace, or it was forced.
400 : : * Wait it out.
401 : : */
402 : 0 : wait_event(req->waitq, test_bit(FR_FINISHED, &req->flags));
403 : : }
404 : :
405 : 3 : static void __fuse_request_send(struct fuse_conn *fc, struct fuse_req *req)
406 : : {
407 : 3 : struct fuse_iqueue *fiq = &fc->iq;
408 : :
409 : 3 : BUG_ON(test_bit(FR_BACKGROUND, &req->flags));
410 : : spin_lock(&fiq->lock);
411 : 3 : if (!fiq->connected) {
412 : : spin_unlock(&fiq->lock);
413 : 0 : req->out.h.error = -ENOTCONN;
414 : : } else {
415 : 3 : req->in.h.unique = fuse_get_unique(fiq);
416 : : /* acquire extra reference, since request is still needed
417 : : after fuse_request_end() */
418 : : __fuse_get_request(req);
419 : 3 : queue_request_and_unlock(fiq, req);
420 : :
421 : 3 : request_wait_answer(fc, req);
422 : : /* Pairs with smp_wmb() in fuse_request_end() */
423 : 3 : smp_rmb();
424 : : }
425 : 3 : }
426 : :
427 : 3 : static void fuse_adjust_compat(struct fuse_conn *fc, struct fuse_args *args)
428 : : {
429 : 3 : if (fc->minor < 4 && args->opcode == FUSE_STATFS)
430 : 0 : args->out_args[0].size = FUSE_COMPAT_STATFS_SIZE;
431 : :
432 : 3 : if (fc->minor < 9) {
433 : 0 : switch (args->opcode) {
434 : : case FUSE_LOOKUP:
435 : : case FUSE_CREATE:
436 : : case FUSE_MKNOD:
437 : : case FUSE_MKDIR:
438 : : case FUSE_SYMLINK:
439 : : case FUSE_LINK:
440 : 0 : args->out_args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
441 : 0 : break;
442 : : case FUSE_GETATTR:
443 : : case FUSE_SETATTR:
444 : 0 : args->out_args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
445 : 0 : break;
446 : : }
447 : : }
448 : 3 : if (fc->minor < 12) {
449 : 0 : switch (args->opcode) {
450 : : case FUSE_CREATE:
451 : 0 : args->in_args[0].size = sizeof(struct fuse_open_in);
452 : 0 : break;
453 : : case FUSE_MKNOD:
454 : 0 : args->in_args[0].size = FUSE_COMPAT_MKNOD_IN_SIZE;
455 : 0 : break;
456 : : }
457 : : }
458 : 3 : }
459 : :
460 : 0 : static void fuse_force_creds(struct fuse_conn *fc, struct fuse_req *req)
461 : : {
462 : 0 : req->in.h.uid = from_kuid_munged(fc->user_ns, current_fsuid());
463 : 0 : req->in.h.gid = from_kgid_munged(fc->user_ns, current_fsgid());
464 : 0 : req->in.h.pid = pid_nr_ns(task_pid(current), fc->pid_ns);
465 : 0 : }
466 : :
467 : : static void fuse_args_to_req(struct fuse_req *req, struct fuse_args *args)
468 : : {
469 : 3 : req->in.h.opcode = args->opcode;
470 : 3 : req->in.h.nodeid = args->nodeid;
471 : 3 : req->args = args;
472 : 3 : if (args->end)
473 : : __set_bit(FR_ASYNC, &req->flags);
474 : : }
475 : :
476 : 3 : ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args)
477 : : {
478 : : struct fuse_req *req;
479 : : ssize_t ret;
480 : :
481 : 3 : if (args->force) {
482 : 0 : atomic_inc(&fc->num_waiting);
483 : 0 : req = fuse_request_alloc(GFP_KERNEL | __GFP_NOFAIL);
484 : :
485 : 0 : if (!args->nocreds)
486 : 0 : fuse_force_creds(fc, req);
487 : :
488 : : __set_bit(FR_WAITING, &req->flags);
489 : : __set_bit(FR_FORCE, &req->flags);
490 : : } else {
491 : 3 : WARN_ON(args->nocreds);
492 : 3 : req = fuse_get_req(fc, false);
493 : 3 : if (IS_ERR(req))
494 : 0 : return PTR_ERR(req);
495 : : }
496 : :
497 : : /* Needs to be done after fuse_get_req() so that fc->minor is valid */
498 : 3 : fuse_adjust_compat(fc, args);
499 : : fuse_args_to_req(req, args);
500 : :
501 : 3 : if (!args->noreply)
502 : : __set_bit(FR_ISREPLY, &req->flags);
503 : 3 : __fuse_request_send(fc, req);
504 : 3 : ret = req->out.h.error;
505 : 3 : if (!ret && args->out_argvar) {
506 : 0 : BUG_ON(args->out_numargs == 0);
507 : 0 : ret = args->out_args[args->out_numargs - 1].size;
508 : : }
509 : 3 : fuse_put_request(fc, req);
510 : :
511 : 3 : return ret;
512 : : }
513 : :
514 : 3 : static bool fuse_request_queue_background(struct fuse_conn *fc,
515 : : struct fuse_req *req)
516 : : {
517 : : bool queued = false;
518 : :
519 : 3 : WARN_ON(!test_bit(FR_BACKGROUND, &req->flags));
520 : 3 : if (!test_bit(FR_WAITING, &req->flags)) {
521 : : __set_bit(FR_WAITING, &req->flags);
522 : 3 : atomic_inc(&fc->num_waiting);
523 : : }
524 : : __set_bit(FR_ISREPLY, &req->flags);
525 : : spin_lock(&fc->bg_lock);
526 : 3 : if (likely(fc->connected)) {
527 : 3 : fc->num_background++;
528 : 3 : if (fc->num_background == fc->max_background)
529 : 0 : fc->blocked = 1;
530 : 3 : if (fc->num_background == fc->congestion_threshold && fc->sb) {
531 : 0 : set_bdi_congested(fc->sb->s_bdi, BLK_RW_SYNC);
532 : 0 : set_bdi_congested(fc->sb->s_bdi, BLK_RW_ASYNC);
533 : : }
534 : 3 : list_add_tail(&req->list, &fc->bg_queue);
535 : 3 : flush_bg_queue(fc);
536 : : queued = true;
537 : : }
538 : : spin_unlock(&fc->bg_lock);
539 : :
540 : 3 : return queued;
541 : : }
542 : :
543 : 3 : int fuse_simple_background(struct fuse_conn *fc, struct fuse_args *args,
544 : : gfp_t gfp_flags)
545 : : {
546 : : struct fuse_req *req;
547 : :
548 : 3 : if (args->force) {
549 : 3 : WARN_ON(!args->nocreds);
550 : 3 : req = fuse_request_alloc(gfp_flags);
551 : 3 : if (!req)
552 : : return -ENOMEM;
553 : : __set_bit(FR_BACKGROUND, &req->flags);
554 : : } else {
555 : 0 : WARN_ON(args->nocreds);
556 : 0 : req = fuse_get_req(fc, true);
557 : 0 : if (IS_ERR(req))
558 : 0 : return PTR_ERR(req);
559 : : }
560 : :
561 : : fuse_args_to_req(req, args);
562 : :
563 : 3 : if (!fuse_request_queue_background(fc, req)) {
564 : 0 : fuse_put_request(fc, req);
565 : 0 : return -ENOTCONN;
566 : : }
567 : :
568 : : return 0;
569 : : }
570 : : EXPORT_SYMBOL_GPL(fuse_simple_background);
571 : :
572 : 0 : static int fuse_simple_notify_reply(struct fuse_conn *fc,
573 : : struct fuse_args *args, u64 unique)
574 : : {
575 : : struct fuse_req *req;
576 : 0 : struct fuse_iqueue *fiq = &fc->iq;
577 : : int err = 0;
578 : :
579 : 0 : req = fuse_get_req(fc, false);
580 : 0 : if (IS_ERR(req))
581 : 0 : return PTR_ERR(req);
582 : :
583 : : __clear_bit(FR_ISREPLY, &req->flags);
584 : 0 : req->in.h.unique = unique;
585 : :
586 : : fuse_args_to_req(req, args);
587 : :
588 : : spin_lock(&fiq->lock);
589 : 0 : if (fiq->connected) {
590 : 0 : queue_request_and_unlock(fiq, req);
591 : : } else {
592 : : err = -ENODEV;
593 : : spin_unlock(&fiq->lock);
594 : 0 : fuse_put_request(fc, req);
595 : : }
596 : :
597 : 0 : return err;
598 : : }
599 : :
600 : : /*
601 : : * Lock the request. Up to the next unlock_request() there mustn't be
602 : : * anything that could cause a page-fault. If the request was already
603 : : * aborted bail out.
604 : : */
605 : 3 : static int lock_request(struct fuse_req *req)
606 : : {
607 : : int err = 0;
608 : 3 : if (req) {
609 : : spin_lock(&req->waitq.lock);
610 : 3 : if (test_bit(FR_ABORTED, &req->flags))
611 : : err = -ENOENT;
612 : : else
613 : 3 : set_bit(FR_LOCKED, &req->flags);
614 : : spin_unlock(&req->waitq.lock);
615 : : }
616 : 3 : return err;
617 : : }
618 : :
619 : : /*
620 : : * Unlock request. If it was aborted while locked, caller is responsible
621 : : * for unlocking and ending the request.
622 : : */
623 : 3 : static int unlock_request(struct fuse_req *req)
624 : : {
625 : : int err = 0;
626 : 3 : if (req) {
627 : : spin_lock(&req->waitq.lock);
628 : 3 : if (test_bit(FR_ABORTED, &req->flags))
629 : : err = -ENOENT;
630 : : else
631 : 3 : clear_bit(FR_LOCKED, &req->flags);
632 : : spin_unlock(&req->waitq.lock);
633 : : }
634 : 3 : return err;
635 : : }
636 : :
637 : : struct fuse_copy_state {
638 : : int write;
639 : : struct fuse_req *req;
640 : : struct iov_iter *iter;
641 : : struct pipe_buffer *pipebufs;
642 : : struct pipe_buffer *currbuf;
643 : : struct pipe_inode_info *pipe;
644 : : unsigned long nr_segs;
645 : : struct page *pg;
646 : : unsigned len;
647 : : unsigned offset;
648 : : unsigned move_pages:1;
649 : : };
650 : :
651 : : static void fuse_copy_init(struct fuse_copy_state *cs, int write,
652 : : struct iov_iter *iter)
653 : : {
654 : 3 : memset(cs, 0, sizeof(*cs));
655 : 3 : cs->write = write;
656 : 3 : cs->iter = iter;
657 : : }
658 : :
659 : : /* Unmap and put previous page of userspace buffer */
660 : 3 : static void fuse_copy_finish(struct fuse_copy_state *cs)
661 : : {
662 : 3 : if (cs->currbuf) {
663 : : struct pipe_buffer *buf = cs->currbuf;
664 : :
665 : 0 : if (cs->write)
666 : 0 : buf->len = PAGE_SIZE - cs->len;
667 : 0 : cs->currbuf = NULL;
668 : 3 : } else if (cs->pg) {
669 : 3 : if (cs->write) {
670 : 3 : flush_dcache_page(cs->pg);
671 : 3 : set_page_dirty_lock(cs->pg);
672 : : }
673 : 3 : put_page(cs->pg);
674 : : }
675 : 3 : cs->pg = NULL;
676 : 3 : }
677 : :
678 : : /*
679 : : * Get another pagefull of userspace buffer, and map it to kernel
680 : : * address space, and lock request
681 : : */
682 : 3 : static int fuse_copy_fill(struct fuse_copy_state *cs)
683 : : {
684 : : struct page *page;
685 : : int err;
686 : :
687 : 3 : err = unlock_request(cs->req);
688 : 3 : if (err)
689 : : return err;
690 : :
691 : 3 : fuse_copy_finish(cs);
692 : 3 : if (cs->pipebufs) {
693 : : struct pipe_buffer *buf = cs->pipebufs;
694 : :
695 : 0 : if (!cs->write) {
696 : 0 : err = pipe_buf_confirm(cs->pipe, buf);
697 : 0 : if (err)
698 : : return err;
699 : :
700 : 0 : BUG_ON(!cs->nr_segs);
701 : 0 : cs->currbuf = buf;
702 : 0 : cs->pg = buf->page;
703 : 0 : cs->offset = buf->offset;
704 : 0 : cs->len = buf->len;
705 : 0 : cs->pipebufs++;
706 : 0 : cs->nr_segs--;
707 : : } else {
708 : 0 : if (cs->nr_segs == cs->pipe->buffers)
709 : : return -EIO;
710 : :
711 : 0 : page = alloc_page(GFP_HIGHUSER);
712 : 0 : if (!page)
713 : : return -ENOMEM;
714 : :
715 : 0 : buf->page = page;
716 : 0 : buf->offset = 0;
717 : 0 : buf->len = 0;
718 : :
719 : 0 : cs->currbuf = buf;
720 : 0 : cs->pg = page;
721 : 0 : cs->offset = 0;
722 : 0 : cs->len = PAGE_SIZE;
723 : 0 : cs->pipebufs++;
724 : 0 : cs->nr_segs++;
725 : : }
726 : : } else {
727 : : size_t off;
728 : 3 : err = iov_iter_get_pages(cs->iter, &page, PAGE_SIZE, 1, &off);
729 : 3 : if (err < 0)
730 : 0 : return err;
731 : 3 : BUG_ON(!err);
732 : 3 : cs->len = err;
733 : 3 : cs->offset = off;
734 : 3 : cs->pg = page;
735 : 3 : iov_iter_advance(cs->iter, err);
736 : : }
737 : :
738 : 3 : return lock_request(cs->req);
739 : : }
740 : :
741 : : /* Do as much copy to/from userspace buffer as we can */
742 : 3 : static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
743 : : {
744 : 3 : unsigned ncpy = min(*size, cs->len);
745 : 3 : if (val) {
746 : 3 : void *pgaddr = kmap_atomic(cs->pg);
747 : 3 : void *buf = pgaddr + cs->offset;
748 : :
749 : 3 : if (cs->write)
750 : 3 : memcpy(buf, *val, ncpy);
751 : : else
752 : 3 : memcpy(*val, buf, ncpy);
753 : :
754 : : kunmap_atomic(pgaddr);
755 : 3 : *val += ncpy;
756 : : }
757 : 3 : *size -= ncpy;
758 : 3 : cs->len -= ncpy;
759 : 3 : cs->offset += ncpy;
760 : 3 : return ncpy;
761 : : }
762 : :
763 : 0 : static int fuse_check_page(struct page *page)
764 : : {
765 : 0 : if (page_mapcount(page) ||
766 : 0 : page->mapping != NULL ||
767 : 0 : page_count(page) != 1 ||
768 : 0 : (page->flags & PAGE_FLAGS_CHECK_AT_PREP &
769 : : ~(1 << PG_locked |
770 : : 1 << PG_referenced |
771 : : 1 << PG_uptodate |
772 : : 1 << PG_lru |
773 : : 1 << PG_active |
774 : : 1 << PG_reclaim |
775 : : 1 << PG_waiters))) {
776 : 0 : pr_warn("trying to steal weird page\n");
777 : 0 : pr_warn(" page=%p index=%li flags=%08lx, count=%i, mapcount=%i, mapping=%p\n", page, page->index, page->flags, page_count(page), page_mapcount(page), page->mapping);
778 : 0 : return 1;
779 : : }
780 : : return 0;
781 : : }
782 : :
783 : 0 : static int fuse_try_move_page(struct fuse_copy_state *cs, struct page **pagep)
784 : : {
785 : : int err;
786 : 0 : struct page *oldpage = *pagep;
787 : : struct page *newpage;
788 : 0 : struct pipe_buffer *buf = cs->pipebufs;
789 : :
790 : 0 : err = unlock_request(cs->req);
791 : 0 : if (err)
792 : : return err;
793 : :
794 : 0 : fuse_copy_finish(cs);
795 : :
796 : 0 : err = pipe_buf_confirm(cs->pipe, buf);
797 : 0 : if (err)
798 : : return err;
799 : :
800 : 0 : BUG_ON(!cs->nr_segs);
801 : 0 : cs->currbuf = buf;
802 : 0 : cs->len = buf->len;
803 : 0 : cs->pipebufs++;
804 : 0 : cs->nr_segs--;
805 : :
806 : 0 : if (cs->len != PAGE_SIZE)
807 : : goto out_fallback;
808 : :
809 : 0 : if (pipe_buf_steal(cs->pipe, buf) != 0)
810 : : goto out_fallback;
811 : :
812 : 0 : newpage = buf->page;
813 : :
814 : 0 : if (!PageUptodate(newpage))
815 : : SetPageUptodate(newpage);
816 : :
817 : : ClearPageMappedToDisk(newpage);
818 : :
819 : 0 : if (fuse_check_page(newpage) != 0)
820 : : goto out_fallback_unlock;
821 : :
822 : : /*
823 : : * This is a new and locked page, it shouldn't be mapped or
824 : : * have any special flags on it
825 : : */
826 : 0 : if (WARN_ON(page_mapped(oldpage)))
827 : : goto out_fallback_unlock;
828 : 0 : if (WARN_ON(page_has_private(oldpage)))
829 : : goto out_fallback_unlock;
830 : 0 : if (WARN_ON(PageDirty(oldpage) || PageWriteback(oldpage)))
831 : : goto out_fallback_unlock;
832 : 0 : if (WARN_ON(PageMlocked(oldpage)))
833 : : goto out_fallback_unlock;
834 : :
835 : 0 : err = replace_page_cache_page(oldpage, newpage, GFP_KERNEL);
836 : 0 : if (err) {
837 : 0 : unlock_page(newpage);
838 : 0 : return err;
839 : : }
840 : :
841 : 0 : get_page(newpage);
842 : :
843 : 0 : if (!(buf->flags & PIPE_BUF_FLAG_LRU))
844 : 0 : lru_cache_add_file(newpage);
845 : :
846 : : err = 0;
847 : 0 : spin_lock(&cs->req->waitq.lock);
848 : 0 : if (test_bit(FR_ABORTED, &cs->req->flags))
849 : : err = -ENOENT;
850 : : else
851 : 0 : *pagep = newpage;
852 : 0 : spin_unlock(&cs->req->waitq.lock);
853 : :
854 : 0 : if (err) {
855 : 0 : unlock_page(newpage);
856 : 0 : put_page(newpage);
857 : 0 : return err;
858 : : }
859 : :
860 : 0 : unlock_page(oldpage);
861 : 0 : put_page(oldpage);
862 : 0 : cs->len = 0;
863 : :
864 : 0 : return 0;
865 : :
866 : : out_fallback_unlock:
867 : 0 : unlock_page(newpage);
868 : : out_fallback:
869 : 0 : cs->pg = buf->page;
870 : 0 : cs->offset = buf->offset;
871 : :
872 : 0 : err = lock_request(cs->req);
873 : 0 : if (err)
874 : 0 : return err;
875 : :
876 : : return 1;
877 : : }
878 : :
879 : 0 : static int fuse_ref_page(struct fuse_copy_state *cs, struct page *page,
880 : : unsigned offset, unsigned count)
881 : : {
882 : : struct pipe_buffer *buf;
883 : : int err;
884 : :
885 : 0 : if (cs->nr_segs == cs->pipe->buffers)
886 : : return -EIO;
887 : :
888 : 0 : err = unlock_request(cs->req);
889 : 0 : if (err)
890 : : return err;
891 : :
892 : 0 : fuse_copy_finish(cs);
893 : :
894 : 0 : buf = cs->pipebufs;
895 : 0 : get_page(page);
896 : 0 : buf->page = page;
897 : 0 : buf->offset = offset;
898 : 0 : buf->len = count;
899 : :
900 : 0 : cs->pipebufs++;
901 : 0 : cs->nr_segs++;
902 : 0 : cs->len = 0;
903 : :
904 : 0 : return 0;
905 : : }
906 : :
907 : : /*
908 : : * Copy a page in the request to/from the userspace buffer. Must be
909 : : * done atomically
910 : : */
911 : 0 : static int fuse_copy_page(struct fuse_copy_state *cs, struct page **pagep,
912 : : unsigned offset, unsigned count, int zeroing)
913 : : {
914 : : int err;
915 : 0 : struct page *page = *pagep;
916 : :
917 : 0 : if (page && zeroing && count < PAGE_SIZE)
918 : 0 : clear_highpage(page);
919 : :
920 : 0 : while (count) {
921 : 0 : if (cs->write && cs->pipebufs && page) {
922 : 0 : return fuse_ref_page(cs, page, offset, count);
923 : 0 : } else if (!cs->len) {
924 : 0 : if (cs->move_pages && page &&
925 : 0 : offset == 0 && count == PAGE_SIZE) {
926 : 0 : err = fuse_try_move_page(cs, pagep);
927 : 0 : if (err <= 0)
928 : 0 : return err;
929 : : } else {
930 : 0 : err = fuse_copy_fill(cs);
931 : 0 : if (err)
932 : 0 : return err;
933 : : }
934 : : }
935 : 0 : if (page) {
936 : 0 : void *mapaddr = kmap_atomic(page);
937 : 0 : void *buf = mapaddr + offset;
938 : 0 : offset += fuse_copy_do(cs, &buf, &count);
939 : : kunmap_atomic(mapaddr);
940 : : } else
941 : 0 : offset += fuse_copy_do(cs, NULL, &count);
942 : : }
943 : 0 : if (page && !cs->write)
944 : 0 : flush_dcache_page(page);
945 : : return 0;
946 : : }
947 : :
948 : : /* Copy pages in the request to/from userspace buffer */
949 : 0 : static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
950 : : int zeroing)
951 : : {
952 : : unsigned i;
953 : 0 : struct fuse_req *req = cs->req;
954 : 0 : struct fuse_args_pages *ap = container_of(req->args, typeof(*ap), args);
955 : :
956 : :
957 : 0 : for (i = 0; i < ap->num_pages && (nbytes || zeroing); i++) {
958 : : int err;
959 : 0 : unsigned int offset = ap->descs[i].offset;
960 : 0 : unsigned int count = min(nbytes, ap->descs[i].length);
961 : :
962 : 0 : err = fuse_copy_page(cs, &ap->pages[i], offset, count, zeroing);
963 : 0 : if (err)
964 : 0 : return err;
965 : :
966 : 0 : nbytes -= count;
967 : : }
968 : : return 0;
969 : : }
970 : :
971 : : /* Copy a single argument in the request to/from userspace buffer */
972 : 3 : static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
973 : : {
974 : 3 : while (size) {
975 : 3 : if (!cs->len) {
976 : 3 : int err = fuse_copy_fill(cs);
977 : 3 : if (err)
978 : 0 : return err;
979 : : }
980 : 3 : fuse_copy_do(cs, &val, &size);
981 : : }
982 : : return 0;
983 : : }
984 : :
985 : : /* Copy request arguments to/from userspace buffer */
986 : 3 : static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
987 : : unsigned argpages, struct fuse_arg *args,
988 : : int zeroing)
989 : : {
990 : : int err = 0;
991 : : unsigned i;
992 : :
993 : 3 : for (i = 0; !err && i < numargs; i++) {
994 : 3 : struct fuse_arg *arg = &args[i];
995 : 3 : if (i == numargs - 1 && argpages)
996 : 0 : err = fuse_copy_pages(cs, arg->size, zeroing);
997 : : else
998 : 3 : err = fuse_copy_one(cs, arg->value, arg->size);
999 : : }
1000 : 3 : return err;
1001 : : }
1002 : :
1003 : : static int forget_pending(struct fuse_iqueue *fiq)
1004 : : {
1005 : 3 : return fiq->forget_list_head.next != NULL;
1006 : : }
1007 : :
1008 : : static int request_pending(struct fuse_iqueue *fiq)
1009 : : {
1010 : 3 : return !list_empty(&fiq->pending) || !list_empty(&fiq->interrupts) ||
1011 : : forget_pending(fiq);
1012 : : }
1013 : :
1014 : : /*
1015 : : * Transfer an interrupt request to userspace
1016 : : *
1017 : : * Unlike other requests this is assembled on demand, without a need
1018 : : * to allocate a separate fuse_req structure.
1019 : : *
1020 : : * Called with fiq->lock held, releases it
1021 : : */
1022 : 0 : static int fuse_read_interrupt(struct fuse_iqueue *fiq,
1023 : : struct fuse_copy_state *cs,
1024 : : size_t nbytes, struct fuse_req *req)
1025 : : __releases(fiq->lock)
1026 : : {
1027 : : struct fuse_in_header ih;
1028 : : struct fuse_interrupt_in arg;
1029 : : unsigned reqsize = sizeof(ih) + sizeof(arg);
1030 : : int err;
1031 : :
1032 : 0 : list_del_init(&req->intr_entry);
1033 : 0 : memset(&ih, 0, sizeof(ih));
1034 : 0 : memset(&arg, 0, sizeof(arg));
1035 : 0 : ih.len = reqsize;
1036 : 0 : ih.opcode = FUSE_INTERRUPT;
1037 : 0 : ih.unique = (req->in.h.unique | FUSE_INT_REQ_BIT);
1038 : 0 : arg.unique = req->in.h.unique;
1039 : :
1040 : : spin_unlock(&fiq->lock);
1041 : 0 : if (nbytes < reqsize)
1042 : : return -EINVAL;
1043 : :
1044 : 0 : err = fuse_copy_one(cs, &ih, sizeof(ih));
1045 : 0 : if (!err)
1046 : 0 : err = fuse_copy_one(cs, &arg, sizeof(arg));
1047 : 0 : fuse_copy_finish(cs);
1048 : :
1049 : 0 : return err ? err : reqsize;
1050 : : }
1051 : :
1052 : 0 : struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq,
1053 : : unsigned int max,
1054 : : unsigned int *countp)
1055 : : {
1056 : 0 : struct fuse_forget_link *head = fiq->forget_list_head.next;
1057 : : struct fuse_forget_link **newhead = &head;
1058 : : unsigned count;
1059 : :
1060 : 0 : for (count = 0; *newhead != NULL && count < max; count++)
1061 : 0 : newhead = &(*newhead)->next;
1062 : :
1063 : 0 : fiq->forget_list_head.next = *newhead;
1064 : 0 : *newhead = NULL;
1065 : 0 : if (fiq->forget_list_head.next == NULL)
1066 : 0 : fiq->forget_list_tail = &fiq->forget_list_head;
1067 : :
1068 : 0 : if (countp != NULL)
1069 : 0 : *countp = count;
1070 : :
1071 : 0 : return head;
1072 : : }
1073 : : EXPORT_SYMBOL(fuse_dequeue_forget);
1074 : :
1075 : 0 : static int fuse_read_single_forget(struct fuse_iqueue *fiq,
1076 : : struct fuse_copy_state *cs,
1077 : : size_t nbytes)
1078 : : __releases(fiq->lock)
1079 : : {
1080 : : int err;
1081 : : struct fuse_forget_link *forget = fuse_dequeue_forget(fiq, 1, NULL);
1082 : 0 : struct fuse_forget_in arg = {
1083 : 0 : .nlookup = forget->forget_one.nlookup,
1084 : : };
1085 : 0 : struct fuse_in_header ih = {
1086 : : .opcode = FUSE_FORGET,
1087 : 0 : .nodeid = forget->forget_one.nodeid,
1088 : : .unique = fuse_get_unique(fiq),
1089 : : .len = sizeof(ih) + sizeof(arg),
1090 : : };
1091 : :
1092 : : spin_unlock(&fiq->lock);
1093 : 0 : kfree(forget);
1094 : 0 : if (nbytes < ih.len)
1095 : : return -EINVAL;
1096 : :
1097 : 0 : err = fuse_copy_one(cs, &ih, sizeof(ih));
1098 : 0 : if (!err)
1099 : 0 : err = fuse_copy_one(cs, &arg, sizeof(arg));
1100 : 0 : fuse_copy_finish(cs);
1101 : :
1102 : 0 : if (err)
1103 : : return err;
1104 : :
1105 : 0 : return ih.len;
1106 : : }
1107 : :
1108 : 0 : static int fuse_read_batch_forget(struct fuse_iqueue *fiq,
1109 : : struct fuse_copy_state *cs, size_t nbytes)
1110 : : __releases(fiq->lock)
1111 : : {
1112 : : int err;
1113 : : unsigned max_forgets;
1114 : : unsigned count;
1115 : : struct fuse_forget_link *head;
1116 : 0 : struct fuse_batch_forget_in arg = { .count = 0 };
1117 : 0 : struct fuse_in_header ih = {
1118 : : .opcode = FUSE_BATCH_FORGET,
1119 : : .unique = fuse_get_unique(fiq),
1120 : : .len = sizeof(ih) + sizeof(arg),
1121 : : };
1122 : :
1123 : 0 : if (nbytes < ih.len) {
1124 : : spin_unlock(&fiq->lock);
1125 : 0 : return -EINVAL;
1126 : : }
1127 : :
1128 : 0 : max_forgets = (nbytes - ih.len) / sizeof(struct fuse_forget_one);
1129 : : head = fuse_dequeue_forget(fiq, max_forgets, &count);
1130 : : spin_unlock(&fiq->lock);
1131 : :
1132 : 0 : arg.count = count;
1133 : 0 : ih.len += count * sizeof(struct fuse_forget_one);
1134 : 0 : err = fuse_copy_one(cs, &ih, sizeof(ih));
1135 : 0 : if (!err)
1136 : 0 : err = fuse_copy_one(cs, &arg, sizeof(arg));
1137 : :
1138 : 0 : while (head) {
1139 : : struct fuse_forget_link *forget = head;
1140 : :
1141 : 0 : if (!err) {
1142 : 0 : err = fuse_copy_one(cs, &forget->forget_one,
1143 : : sizeof(forget->forget_one));
1144 : : }
1145 : 0 : head = forget->next;
1146 : 0 : kfree(forget);
1147 : : }
1148 : :
1149 : 0 : fuse_copy_finish(cs);
1150 : :
1151 : 0 : if (err)
1152 : 0 : return err;
1153 : :
1154 : 0 : return ih.len;
1155 : : }
1156 : :
1157 : 0 : static int fuse_read_forget(struct fuse_conn *fc, struct fuse_iqueue *fiq,
1158 : : struct fuse_copy_state *cs,
1159 : : size_t nbytes)
1160 : : __releases(fiq->lock)
1161 : : {
1162 : 0 : if (fc->minor < 16 || fiq->forget_list_head.next->next == NULL)
1163 : 0 : return fuse_read_single_forget(fiq, cs, nbytes);
1164 : : else
1165 : 0 : return fuse_read_batch_forget(fiq, cs, nbytes);
1166 : : }
1167 : :
1168 : : /*
1169 : : * Read a single request into the userspace filesystem's buffer. This
1170 : : * function waits until a request is available, then removes it from
1171 : : * the pending list and copies request data to userspace buffer. If
1172 : : * no reply is needed (FORGET) or request has been aborted or there
1173 : : * was an error during the copying then it's finished by calling
1174 : : * fuse_request_end(). Otherwise add it to the processing list, and set
1175 : : * the 'sent' flag.
1176 : : */
1177 : 3 : static ssize_t fuse_dev_do_read(struct fuse_dev *fud, struct file *file,
1178 : : struct fuse_copy_state *cs, size_t nbytes)
1179 : : {
1180 : : ssize_t err;
1181 : 3 : struct fuse_conn *fc = fud->fc;
1182 : 3 : struct fuse_iqueue *fiq = &fc->iq;
1183 : : struct fuse_pqueue *fpq = &fud->pq;
1184 : : struct fuse_req *req;
1185 : : struct fuse_args *args;
1186 : : unsigned reqsize;
1187 : : unsigned int hash;
1188 : :
1189 : : /*
1190 : : * Require sane minimum read buffer - that has capacity for fixed part
1191 : : * of any request header + negotiated max_write room for data.
1192 : : *
1193 : : * Historically libfuse reserves 4K for fixed header room, but e.g.
1194 : : * GlusterFS reserves only 80 bytes
1195 : : *
1196 : : * = `sizeof(fuse_in_header) + sizeof(fuse_write_in)`
1197 : : *
1198 : : * which is the absolute minimum any sane filesystem should be using
1199 : : * for header room.
1200 : : */
1201 : 3 : if (nbytes < max_t(size_t, FUSE_MIN_READ_BUFFER,
1202 : : sizeof(struct fuse_in_header) +
1203 : : sizeof(struct fuse_write_in) +
1204 : : fc->max_write))
1205 : : return -EINVAL;
1206 : :
1207 : : restart:
1208 : : for (;;) {
1209 : : spin_lock(&fiq->lock);
1210 : 3 : if (!fiq->connected || request_pending(fiq))
1211 : : break;
1212 : : spin_unlock(&fiq->lock);
1213 : :
1214 : 3 : if (file->f_flags & O_NONBLOCK)
1215 : : return -EAGAIN;
1216 : 3 : err = wait_event_interruptible_exclusive(fiq->waitq,
1217 : : !fiq->connected || request_pending(fiq));
1218 : 3 : if (err)
1219 : 0 : return err;
1220 : : }
1221 : :
1222 : 3 : if (!fiq->connected) {
1223 : 0 : err = fc->aborted ? -ECONNABORTED : -ENODEV;
1224 : : goto err_unlock;
1225 : : }
1226 : :
1227 : 3 : if (!list_empty(&fiq->interrupts)) {
1228 : 0 : req = list_entry(fiq->interrupts.next, struct fuse_req,
1229 : : intr_entry);
1230 : 0 : return fuse_read_interrupt(fiq, cs, nbytes, req);
1231 : : }
1232 : :
1233 : 3 : if (forget_pending(fiq)) {
1234 : 0 : if (list_empty(&fiq->pending) || fiq->forget_batch-- > 0)
1235 : 0 : return fuse_read_forget(fc, fiq, cs, nbytes);
1236 : :
1237 : 0 : if (fiq->forget_batch <= -8)
1238 : 0 : fiq->forget_batch = 16;
1239 : : }
1240 : :
1241 : 3 : req = list_entry(fiq->pending.next, struct fuse_req, list);
1242 : 3 : clear_bit(FR_PENDING, &req->flags);
1243 : 3 : list_del_init(&req->list);
1244 : : spin_unlock(&fiq->lock);
1245 : :
1246 : 3 : args = req->args;
1247 : 3 : reqsize = req->in.h.len;
1248 : :
1249 : : /* If request is too large, reply with an error and restart the read */
1250 : 3 : if (nbytes < reqsize) {
1251 : 0 : req->out.h.error = -EIO;
1252 : : /* SETXATTR is special, since it may contain too large data */
1253 : 0 : if (args->opcode == FUSE_SETXATTR)
1254 : 0 : req->out.h.error = -E2BIG;
1255 : 0 : fuse_request_end(fc, req);
1256 : 0 : goto restart;
1257 : : }
1258 : : spin_lock(&fpq->lock);
1259 : 3 : list_add(&req->list, &fpq->io);
1260 : : spin_unlock(&fpq->lock);
1261 : 3 : cs->req = req;
1262 : 3 : err = fuse_copy_one(cs, &req->in.h, sizeof(req->in.h));
1263 : 3 : if (!err)
1264 : 3 : err = fuse_copy_args(cs, args->in_numargs, args->in_pages,
1265 : 3 : (struct fuse_arg *) args->in_args, 0);
1266 : 3 : fuse_copy_finish(cs);
1267 : : spin_lock(&fpq->lock);
1268 : 3 : clear_bit(FR_LOCKED, &req->flags);
1269 : 3 : if (!fpq->connected) {
1270 : 0 : err = fc->aborted ? -ECONNABORTED : -ENODEV;
1271 : 0 : goto out_end;
1272 : : }
1273 : 3 : if (err) {
1274 : 0 : req->out.h.error = -EIO;
1275 : 0 : goto out_end;
1276 : : }
1277 : 3 : if (!test_bit(FR_ISREPLY, &req->flags)) {
1278 : 0 : err = reqsize;
1279 : 0 : goto out_end;
1280 : : }
1281 : 3 : hash = fuse_req_hash(req->in.h.unique);
1282 : 3 : list_move_tail(&req->list, &fpq->processing[hash]);
1283 : : __fuse_get_request(req);
1284 : 3 : set_bit(FR_SENT, &req->flags);
1285 : : spin_unlock(&fpq->lock);
1286 : : /* matches barrier in request_wait_answer() */
1287 : 3 : smp_mb__after_atomic();
1288 : 3 : if (test_bit(FR_INTERRUPTED, &req->flags))
1289 : 0 : queue_interrupt(fiq, req);
1290 : 3 : fuse_put_request(fc, req);
1291 : :
1292 : 3 : return reqsize;
1293 : :
1294 : : out_end:
1295 : 0 : if (!test_bit(FR_PRIVATE, &req->flags))
1296 : 0 : list_del_init(&req->list);
1297 : : spin_unlock(&fpq->lock);
1298 : 0 : fuse_request_end(fc, req);
1299 : 0 : return err;
1300 : :
1301 : : err_unlock:
1302 : : spin_unlock(&fiq->lock);
1303 : 0 : return err;
1304 : : }
1305 : :
1306 : 3 : static int fuse_dev_open(struct inode *inode, struct file *file)
1307 : : {
1308 : : /*
1309 : : * The fuse device's file's private_data is used to hold
1310 : : * the fuse_conn(ection) when it is mounted, and is used to
1311 : : * keep track of whether the file has been mounted already.
1312 : : */
1313 : 3 : file->private_data = NULL;
1314 : 3 : return 0;
1315 : : }
1316 : :
1317 : 3 : static ssize_t fuse_dev_read(struct kiocb *iocb, struct iov_iter *to)
1318 : : {
1319 : : struct fuse_copy_state cs;
1320 : 3 : struct file *file = iocb->ki_filp;
1321 : : struct fuse_dev *fud = fuse_get_dev(file);
1322 : :
1323 : 3 : if (!fud)
1324 : : return -EPERM;
1325 : :
1326 : 3 : if (!iter_is_iovec(to))
1327 : : return -EINVAL;
1328 : :
1329 : : fuse_copy_init(&cs, 1, to);
1330 : :
1331 : 3 : return fuse_dev_do_read(fud, file, &cs, iov_iter_count(to));
1332 : : }
1333 : :
1334 : 0 : static ssize_t fuse_dev_splice_read(struct file *in, loff_t *ppos,
1335 : : struct pipe_inode_info *pipe,
1336 : : size_t len, unsigned int flags)
1337 : : {
1338 : : int total, ret;
1339 : : int page_nr = 0;
1340 : : struct pipe_buffer *bufs;
1341 : : struct fuse_copy_state cs;
1342 : : struct fuse_dev *fud = fuse_get_dev(in);
1343 : :
1344 : 0 : if (!fud)
1345 : : return -EPERM;
1346 : :
1347 : 0 : bufs = kvmalloc_array(pipe->buffers, sizeof(struct pipe_buffer),
1348 : : GFP_KERNEL);
1349 : 0 : if (!bufs)
1350 : : return -ENOMEM;
1351 : :
1352 : : fuse_copy_init(&cs, 1, NULL);
1353 : 0 : cs.pipebufs = bufs;
1354 : 0 : cs.pipe = pipe;
1355 : 0 : ret = fuse_dev_do_read(fud, in, &cs, len);
1356 : 0 : if (ret < 0)
1357 : : goto out;
1358 : :
1359 : 0 : if (pipe->nrbufs + cs.nr_segs > pipe->buffers) {
1360 : : ret = -EIO;
1361 : : goto out;
1362 : : }
1363 : :
1364 : 0 : for (ret = total = 0; page_nr < cs.nr_segs; total += ret) {
1365 : : /*
1366 : : * Need to be careful about this. Having buf->ops in module
1367 : : * code can Oops if the buffer persists after module unload.
1368 : : */
1369 : 0 : bufs[page_nr].ops = &nosteal_pipe_buf_ops;
1370 : 0 : bufs[page_nr].flags = 0;
1371 : 0 : ret = add_to_pipe(pipe, &bufs[page_nr++]);
1372 : 0 : if (unlikely(ret < 0))
1373 : : break;
1374 : : }
1375 : 0 : if (total)
1376 : 0 : ret = total;
1377 : : out:
1378 : 0 : for (; page_nr < cs.nr_segs; page_nr++)
1379 : 0 : put_page(bufs[page_nr].page);
1380 : :
1381 : 0 : kvfree(bufs);
1382 : 0 : return ret;
1383 : : }
1384 : :
1385 : 0 : static int fuse_notify_poll(struct fuse_conn *fc, unsigned int size,
1386 : : struct fuse_copy_state *cs)
1387 : : {
1388 : : struct fuse_notify_poll_wakeup_out outarg;
1389 : : int err = -EINVAL;
1390 : :
1391 : 0 : if (size != sizeof(outarg))
1392 : : goto err;
1393 : :
1394 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1395 : 0 : if (err)
1396 : : goto err;
1397 : :
1398 : 0 : fuse_copy_finish(cs);
1399 : 0 : return fuse_notify_poll_wakeup(fc, &outarg);
1400 : :
1401 : : err:
1402 : 0 : fuse_copy_finish(cs);
1403 : 0 : return err;
1404 : : }
1405 : :
1406 : 0 : static int fuse_notify_inval_inode(struct fuse_conn *fc, unsigned int size,
1407 : : struct fuse_copy_state *cs)
1408 : : {
1409 : : struct fuse_notify_inval_inode_out outarg;
1410 : : int err = -EINVAL;
1411 : :
1412 : 0 : if (size != sizeof(outarg))
1413 : : goto err;
1414 : :
1415 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1416 : 0 : if (err)
1417 : : goto err;
1418 : 0 : fuse_copy_finish(cs);
1419 : :
1420 : 0 : down_read(&fc->killsb);
1421 : : err = -ENOENT;
1422 : 0 : if (fc->sb) {
1423 : 0 : err = fuse_reverse_inval_inode(fc->sb, outarg.ino,
1424 : : outarg.off, outarg.len);
1425 : : }
1426 : 0 : up_read(&fc->killsb);
1427 : 0 : return err;
1428 : :
1429 : : err:
1430 : 0 : fuse_copy_finish(cs);
1431 : 0 : return err;
1432 : : }
1433 : :
1434 : 0 : static int fuse_notify_inval_entry(struct fuse_conn *fc, unsigned int size,
1435 : : struct fuse_copy_state *cs)
1436 : : {
1437 : : struct fuse_notify_inval_entry_out outarg;
1438 : : int err = -ENOMEM;
1439 : : char *buf;
1440 : : struct qstr name;
1441 : :
1442 : 0 : buf = kzalloc(FUSE_NAME_MAX + 1, GFP_KERNEL);
1443 : 0 : if (!buf)
1444 : : goto err;
1445 : :
1446 : : err = -EINVAL;
1447 : 0 : if (size < sizeof(outarg))
1448 : : goto err;
1449 : :
1450 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1451 : 0 : if (err)
1452 : : goto err;
1453 : :
1454 : : err = -ENAMETOOLONG;
1455 : 0 : if (outarg.namelen > FUSE_NAME_MAX)
1456 : : goto err;
1457 : :
1458 : : err = -EINVAL;
1459 : 0 : if (size != sizeof(outarg) + outarg.namelen + 1)
1460 : : goto err;
1461 : :
1462 : 0 : name.name = buf;
1463 : 0 : name.len = outarg.namelen;
1464 : 0 : err = fuse_copy_one(cs, buf, outarg.namelen + 1);
1465 : 0 : if (err)
1466 : : goto err;
1467 : 0 : fuse_copy_finish(cs);
1468 : 0 : buf[outarg.namelen] = 0;
1469 : :
1470 : 0 : down_read(&fc->killsb);
1471 : : err = -ENOENT;
1472 : 0 : if (fc->sb)
1473 : 0 : err = fuse_reverse_inval_entry(fc->sb, outarg.parent, 0, &name);
1474 : 0 : up_read(&fc->killsb);
1475 : 0 : kfree(buf);
1476 : 0 : return err;
1477 : :
1478 : : err:
1479 : 0 : kfree(buf);
1480 : 0 : fuse_copy_finish(cs);
1481 : 0 : return err;
1482 : : }
1483 : :
1484 : 0 : static int fuse_notify_delete(struct fuse_conn *fc, unsigned int size,
1485 : : struct fuse_copy_state *cs)
1486 : : {
1487 : : struct fuse_notify_delete_out outarg;
1488 : : int err = -ENOMEM;
1489 : : char *buf;
1490 : : struct qstr name;
1491 : :
1492 : 0 : buf = kzalloc(FUSE_NAME_MAX + 1, GFP_KERNEL);
1493 : 0 : if (!buf)
1494 : : goto err;
1495 : :
1496 : : err = -EINVAL;
1497 : 0 : if (size < sizeof(outarg))
1498 : : goto err;
1499 : :
1500 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1501 : 0 : if (err)
1502 : : goto err;
1503 : :
1504 : : err = -ENAMETOOLONG;
1505 : 0 : if (outarg.namelen > FUSE_NAME_MAX)
1506 : : goto err;
1507 : :
1508 : : err = -EINVAL;
1509 : 0 : if (size != sizeof(outarg) + outarg.namelen + 1)
1510 : : goto err;
1511 : :
1512 : 0 : name.name = buf;
1513 : 0 : name.len = outarg.namelen;
1514 : 0 : err = fuse_copy_one(cs, buf, outarg.namelen + 1);
1515 : 0 : if (err)
1516 : : goto err;
1517 : 0 : fuse_copy_finish(cs);
1518 : 0 : buf[outarg.namelen] = 0;
1519 : :
1520 : 0 : down_read(&fc->killsb);
1521 : : err = -ENOENT;
1522 : 0 : if (fc->sb)
1523 : 0 : err = fuse_reverse_inval_entry(fc->sb, outarg.parent,
1524 : : outarg.child, &name);
1525 : 0 : up_read(&fc->killsb);
1526 : 0 : kfree(buf);
1527 : 0 : return err;
1528 : :
1529 : : err:
1530 : 0 : kfree(buf);
1531 : 0 : fuse_copy_finish(cs);
1532 : 0 : return err;
1533 : : }
1534 : :
1535 : 0 : static int fuse_notify_store(struct fuse_conn *fc, unsigned int size,
1536 : : struct fuse_copy_state *cs)
1537 : : {
1538 : : struct fuse_notify_store_out outarg;
1539 : : struct inode *inode;
1540 : : struct address_space *mapping;
1541 : : u64 nodeid;
1542 : : int err;
1543 : : pgoff_t index;
1544 : : unsigned int offset;
1545 : : unsigned int num;
1546 : : loff_t file_size;
1547 : : loff_t end;
1548 : :
1549 : : err = -EINVAL;
1550 : 0 : if (size < sizeof(outarg))
1551 : : goto out_finish;
1552 : :
1553 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1554 : 0 : if (err)
1555 : : goto out_finish;
1556 : :
1557 : : err = -EINVAL;
1558 : 0 : if (size - sizeof(outarg) != outarg.size)
1559 : : goto out_finish;
1560 : :
1561 : 0 : nodeid = outarg.nodeid;
1562 : :
1563 : 0 : down_read(&fc->killsb);
1564 : :
1565 : : err = -ENOENT;
1566 : 0 : if (!fc->sb)
1567 : : goto out_up_killsb;
1568 : :
1569 : 0 : inode = ilookup5(fc->sb, nodeid, fuse_inode_eq, &nodeid);
1570 : 0 : if (!inode)
1571 : : goto out_up_killsb;
1572 : :
1573 : 0 : mapping = inode->i_mapping;
1574 : 0 : index = outarg.offset >> PAGE_SHIFT;
1575 : 0 : offset = outarg.offset & ~PAGE_MASK;
1576 : : file_size = i_size_read(inode);
1577 : 0 : end = outarg.offset + outarg.size;
1578 : 0 : if (end > file_size) {
1579 : : file_size = end;
1580 : 0 : fuse_write_update_size(inode, file_size);
1581 : : }
1582 : :
1583 : 0 : num = outarg.size;
1584 : 0 : while (num) {
1585 : : struct page *page;
1586 : : unsigned int this_num;
1587 : :
1588 : : err = -ENOMEM;
1589 : 0 : page = find_or_create_page(mapping, index,
1590 : : mapping_gfp_mask(mapping));
1591 : 0 : if (!page)
1592 : : goto out_iput;
1593 : :
1594 : 0 : this_num = min_t(unsigned, num, PAGE_SIZE - offset);
1595 : 0 : err = fuse_copy_page(cs, &page, offset, this_num, 0);
1596 : 0 : if (!err && offset == 0 &&
1597 : 0 : (this_num == PAGE_SIZE || file_size == end))
1598 : 0 : SetPageUptodate(page);
1599 : 0 : unlock_page(page);
1600 : 0 : put_page(page);
1601 : :
1602 : 0 : if (err)
1603 : : goto out_iput;
1604 : :
1605 : 0 : num -= this_num;
1606 : : offset = 0;
1607 : 0 : index++;
1608 : : }
1609 : :
1610 : : err = 0;
1611 : :
1612 : : out_iput:
1613 : 0 : iput(inode);
1614 : : out_up_killsb:
1615 : 0 : up_read(&fc->killsb);
1616 : : out_finish:
1617 : 0 : fuse_copy_finish(cs);
1618 : 0 : return err;
1619 : : }
1620 : :
1621 : : struct fuse_retrieve_args {
1622 : : struct fuse_args_pages ap;
1623 : : struct fuse_notify_retrieve_in inarg;
1624 : : };
1625 : :
1626 : 0 : static void fuse_retrieve_end(struct fuse_conn *fc, struct fuse_args *args,
1627 : : int error)
1628 : : {
1629 : : struct fuse_retrieve_args *ra =
1630 : : container_of(args, typeof(*ra), ap.args);
1631 : :
1632 : 0 : release_pages(ra->ap.pages, ra->ap.num_pages);
1633 : 0 : kfree(ra);
1634 : 0 : }
1635 : :
1636 : 0 : static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
1637 : : struct fuse_notify_retrieve_out *outarg)
1638 : : {
1639 : : int err;
1640 : 0 : struct address_space *mapping = inode->i_mapping;
1641 : : pgoff_t index;
1642 : : loff_t file_size;
1643 : : unsigned int num;
1644 : : unsigned int offset;
1645 : : size_t total_len = 0;
1646 : : unsigned int num_pages;
1647 : : struct fuse_retrieve_args *ra;
1648 : : size_t args_size = sizeof(*ra);
1649 : : struct fuse_args_pages *ap;
1650 : : struct fuse_args *args;
1651 : :
1652 : 0 : offset = outarg->offset & ~PAGE_MASK;
1653 : : file_size = i_size_read(inode);
1654 : :
1655 : 0 : num = min(outarg->size, fc->max_write);
1656 : 0 : if (outarg->offset > file_size)
1657 : : num = 0;
1658 : 0 : else if (outarg->offset + num > file_size)
1659 : 0 : num = file_size - outarg->offset;
1660 : :
1661 : 0 : num_pages = (num + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
1662 : 0 : num_pages = min(num_pages, fc->max_pages);
1663 : :
1664 : 0 : args_size += num_pages * (sizeof(ap->pages[0]) + sizeof(ap->descs[0]));
1665 : :
1666 : 0 : ra = kzalloc(args_size, GFP_KERNEL);
1667 : 0 : if (!ra)
1668 : : return -ENOMEM;
1669 : :
1670 : : ap = &ra->ap;
1671 : 0 : ap->pages = (void *) (ra + 1);
1672 : 0 : ap->descs = (void *) (ap->pages + num_pages);
1673 : :
1674 : 0 : args = &ap->args;
1675 : 0 : args->nodeid = outarg->nodeid;
1676 : 0 : args->opcode = FUSE_NOTIFY_REPLY;
1677 : 0 : args->in_numargs = 2;
1678 : 0 : args->in_pages = true;
1679 : 0 : args->end = fuse_retrieve_end;
1680 : :
1681 : 0 : index = outarg->offset >> PAGE_SHIFT;
1682 : :
1683 : 0 : while (num && ap->num_pages < num_pages) {
1684 : : struct page *page;
1685 : : unsigned int this_num;
1686 : :
1687 : : page = find_get_page(mapping, index);
1688 : 0 : if (!page)
1689 : : break;
1690 : :
1691 : 0 : this_num = min_t(unsigned, num, PAGE_SIZE - offset);
1692 : 0 : ap->pages[ap->num_pages] = page;
1693 : 0 : ap->descs[ap->num_pages].offset = offset;
1694 : 0 : ap->descs[ap->num_pages].length = this_num;
1695 : 0 : ap->num_pages++;
1696 : :
1697 : : offset = 0;
1698 : 0 : num -= this_num;
1699 : 0 : total_len += this_num;
1700 : 0 : index++;
1701 : : }
1702 : 0 : ra->inarg.offset = outarg->offset;
1703 : 0 : ra->inarg.size = total_len;
1704 : 0 : args->in_args[0].size = sizeof(ra->inarg);
1705 : 0 : args->in_args[0].value = &ra->inarg;
1706 : 0 : args->in_args[1].size = total_len;
1707 : :
1708 : 0 : err = fuse_simple_notify_reply(fc, args, outarg->notify_unique);
1709 : 0 : if (err)
1710 : : fuse_retrieve_end(fc, args, err);
1711 : :
1712 : 0 : return err;
1713 : : }
1714 : :
1715 : 0 : static int fuse_notify_retrieve(struct fuse_conn *fc, unsigned int size,
1716 : : struct fuse_copy_state *cs)
1717 : : {
1718 : : struct fuse_notify_retrieve_out outarg;
1719 : : struct inode *inode;
1720 : : int err;
1721 : :
1722 : : err = -EINVAL;
1723 : 0 : if (size != sizeof(outarg))
1724 : : goto copy_finish;
1725 : :
1726 : 0 : err = fuse_copy_one(cs, &outarg, sizeof(outarg));
1727 : 0 : if (err)
1728 : : goto copy_finish;
1729 : :
1730 : 0 : fuse_copy_finish(cs);
1731 : :
1732 : 0 : down_read(&fc->killsb);
1733 : : err = -ENOENT;
1734 : 0 : if (fc->sb) {
1735 : 0 : u64 nodeid = outarg.nodeid;
1736 : :
1737 : 0 : inode = ilookup5(fc->sb, nodeid, fuse_inode_eq, &nodeid);
1738 : 0 : if (inode) {
1739 : 0 : err = fuse_retrieve(fc, inode, &outarg);
1740 : 0 : iput(inode);
1741 : : }
1742 : : }
1743 : 0 : up_read(&fc->killsb);
1744 : :
1745 : 0 : return err;
1746 : :
1747 : : copy_finish:
1748 : 0 : fuse_copy_finish(cs);
1749 : 0 : return err;
1750 : : }
1751 : :
1752 : 0 : static int fuse_notify(struct fuse_conn *fc, enum fuse_notify_code code,
1753 : : unsigned int size, struct fuse_copy_state *cs)
1754 : : {
1755 : : /* Don't try to move pages (yet) */
1756 : 0 : cs->move_pages = 0;
1757 : :
1758 : 0 : switch (code) {
1759 : : case FUSE_NOTIFY_POLL:
1760 : 0 : return fuse_notify_poll(fc, size, cs);
1761 : :
1762 : : case FUSE_NOTIFY_INVAL_INODE:
1763 : 0 : return fuse_notify_inval_inode(fc, size, cs);
1764 : :
1765 : : case FUSE_NOTIFY_INVAL_ENTRY:
1766 : 0 : return fuse_notify_inval_entry(fc, size, cs);
1767 : :
1768 : : case FUSE_NOTIFY_STORE:
1769 : 0 : return fuse_notify_store(fc, size, cs);
1770 : :
1771 : : case FUSE_NOTIFY_RETRIEVE:
1772 : 0 : return fuse_notify_retrieve(fc, size, cs);
1773 : :
1774 : : case FUSE_NOTIFY_DELETE:
1775 : 0 : return fuse_notify_delete(fc, size, cs);
1776 : :
1777 : : default:
1778 : 0 : fuse_copy_finish(cs);
1779 : 0 : return -EINVAL;
1780 : : }
1781 : : }
1782 : :
1783 : : /* Look up request on processing list by unique ID */
1784 : : static struct fuse_req *request_find(struct fuse_pqueue *fpq, u64 unique)
1785 : : {
1786 : : unsigned int hash = fuse_req_hash(unique);
1787 : : struct fuse_req *req;
1788 : :
1789 : 3 : list_for_each_entry(req, &fpq->processing[hash], list) {
1790 : 3 : if (req->in.h.unique == unique)
1791 : 3 : return req;
1792 : : }
1793 : : return NULL;
1794 : : }
1795 : :
1796 : 3 : static int copy_out_args(struct fuse_copy_state *cs, struct fuse_args *args,
1797 : : unsigned nbytes)
1798 : : {
1799 : : unsigned reqsize = sizeof(struct fuse_out_header);
1800 : :
1801 : 3 : reqsize += fuse_len_args(args->out_numargs, args->out_args);
1802 : :
1803 : 3 : if (reqsize < nbytes || (reqsize > nbytes && !args->out_argvar))
1804 : : return -EINVAL;
1805 : 3 : else if (reqsize > nbytes) {
1806 : 3 : struct fuse_arg *lastarg = &args->out_args[args->out_numargs-1];
1807 : 3 : unsigned diffsize = reqsize - nbytes;
1808 : :
1809 : 3 : if (diffsize > lastarg->size)
1810 : : return -EINVAL;
1811 : 3 : lastarg->size -= diffsize;
1812 : : }
1813 : 3 : return fuse_copy_args(cs, args->out_numargs, args->out_pages,
1814 : 3 : args->out_args, args->page_zeroing);
1815 : : }
1816 : :
1817 : : /*
1818 : : * Write a single reply to a request. First the header is copied from
1819 : : * the write buffer. The request is then searched on the processing
1820 : : * list by the unique ID found in the header. If found, then remove
1821 : : * it from the list and copy the rest of the buffer to the request.
1822 : : * The request is finished by calling fuse_request_end().
1823 : : */
1824 : 3 : static ssize_t fuse_dev_do_write(struct fuse_dev *fud,
1825 : : struct fuse_copy_state *cs, size_t nbytes)
1826 : : {
1827 : : int err;
1828 : 3 : struct fuse_conn *fc = fud->fc;
1829 : : struct fuse_pqueue *fpq = &fud->pq;
1830 : : struct fuse_req *req;
1831 : : struct fuse_out_header oh;
1832 : :
1833 : : err = -EINVAL;
1834 : 3 : if (nbytes < sizeof(struct fuse_out_header))
1835 : : goto out;
1836 : :
1837 : 3 : err = fuse_copy_one(cs, &oh, sizeof(oh));
1838 : 3 : if (err)
1839 : : goto copy_finish;
1840 : :
1841 : : err = -EINVAL;
1842 : 3 : if (oh.len != nbytes)
1843 : : goto copy_finish;
1844 : :
1845 : : /*
1846 : : * Zero oh.unique indicates unsolicited notification message
1847 : : * and error contains notification code.
1848 : : */
1849 : 3 : if (!oh.unique) {
1850 : 0 : err = fuse_notify(fc, oh.error, nbytes - sizeof(oh), cs);
1851 : 0 : goto out;
1852 : : }
1853 : :
1854 : : err = -EINVAL;
1855 : 3 : if (oh.error <= -1000 || oh.error > 0)
1856 : : goto copy_finish;
1857 : :
1858 : : spin_lock(&fpq->lock);
1859 : : req = NULL;
1860 : 3 : if (fpq->connected)
1861 : 3 : req = request_find(fpq, oh.unique & ~FUSE_INT_REQ_BIT);
1862 : :
1863 : : err = -ENOENT;
1864 : 3 : if (!req) {
1865 : : spin_unlock(&fpq->lock);
1866 : : goto copy_finish;
1867 : : }
1868 : :
1869 : : /* Is it an interrupt reply ID? */
1870 : 3 : if (oh.unique & FUSE_INT_REQ_BIT) {
1871 : : __fuse_get_request(req);
1872 : : spin_unlock(&fpq->lock);
1873 : :
1874 : : err = 0;
1875 : 0 : if (nbytes != sizeof(struct fuse_out_header))
1876 : : err = -EINVAL;
1877 : 0 : else if (oh.error == -ENOSYS)
1878 : 0 : fc->no_interrupt = 1;
1879 : 0 : else if (oh.error == -EAGAIN)
1880 : 0 : err = queue_interrupt(&fc->iq, req);
1881 : :
1882 : 0 : fuse_put_request(fc, req);
1883 : :
1884 : 0 : goto copy_finish;
1885 : : }
1886 : :
1887 : 3 : clear_bit(FR_SENT, &req->flags);
1888 : 3 : list_move(&req->list, &fpq->io);
1889 : 3 : req->out.h = oh;
1890 : 3 : set_bit(FR_LOCKED, &req->flags);
1891 : : spin_unlock(&fpq->lock);
1892 : 3 : cs->req = req;
1893 : 3 : if (!req->args->page_replace)
1894 : 3 : cs->move_pages = 0;
1895 : :
1896 : 3 : if (oh.error)
1897 : 3 : err = nbytes != sizeof(oh) ? -EINVAL : 0;
1898 : : else
1899 : 3 : err = copy_out_args(cs, req->args, nbytes);
1900 : 3 : fuse_copy_finish(cs);
1901 : :
1902 : : spin_lock(&fpq->lock);
1903 : 3 : clear_bit(FR_LOCKED, &req->flags);
1904 : 3 : if (!fpq->connected)
1905 : : err = -ENOENT;
1906 : 3 : else if (err)
1907 : 0 : req->out.h.error = -EIO;
1908 : 3 : if (!test_bit(FR_PRIVATE, &req->flags))
1909 : : list_del_init(&req->list);
1910 : : spin_unlock(&fpq->lock);
1911 : :
1912 : 3 : fuse_request_end(fc, req);
1913 : : out:
1914 : 3 : return err ? err : nbytes;
1915 : :
1916 : : copy_finish:
1917 : 0 : fuse_copy_finish(cs);
1918 : 0 : goto out;
1919 : : }
1920 : :
1921 : 3 : static ssize_t fuse_dev_write(struct kiocb *iocb, struct iov_iter *from)
1922 : : {
1923 : : struct fuse_copy_state cs;
1924 : 3 : struct fuse_dev *fud = fuse_get_dev(iocb->ki_filp);
1925 : :
1926 : 3 : if (!fud)
1927 : : return -EPERM;
1928 : :
1929 : 3 : if (!iter_is_iovec(from))
1930 : : return -EINVAL;
1931 : :
1932 : : fuse_copy_init(&cs, 0, from);
1933 : :
1934 : 3 : return fuse_dev_do_write(fud, &cs, iov_iter_count(from));
1935 : : }
1936 : :
1937 : 0 : static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
1938 : : struct file *out, loff_t *ppos,
1939 : : size_t len, unsigned int flags)
1940 : : {
1941 : : unsigned nbuf;
1942 : : unsigned idx;
1943 : : struct pipe_buffer *bufs;
1944 : : struct fuse_copy_state cs;
1945 : : struct fuse_dev *fud;
1946 : : size_t rem;
1947 : : ssize_t ret;
1948 : :
1949 : : fud = fuse_get_dev(out);
1950 : 0 : if (!fud)
1951 : : return -EPERM;
1952 : :
1953 : 0 : pipe_lock(pipe);
1954 : :
1955 : 0 : bufs = kvmalloc_array(pipe->nrbufs, sizeof(struct pipe_buffer),
1956 : : GFP_KERNEL);
1957 : 0 : if (!bufs) {
1958 : 0 : pipe_unlock(pipe);
1959 : 0 : return -ENOMEM;
1960 : : }
1961 : :
1962 : : nbuf = 0;
1963 : : rem = 0;
1964 : 0 : for (idx = 0; idx < pipe->nrbufs && rem < len; idx++)
1965 : 0 : rem += pipe->bufs[(pipe->curbuf + idx) & (pipe->buffers - 1)].len;
1966 : :
1967 : : ret = -EINVAL;
1968 : 0 : if (rem < len)
1969 : : goto out_free;
1970 : :
1971 : : rem = len;
1972 : 0 : while (rem) {
1973 : : struct pipe_buffer *ibuf;
1974 : : struct pipe_buffer *obuf;
1975 : :
1976 : 0 : BUG_ON(nbuf >= pipe->buffers);
1977 : 0 : BUG_ON(!pipe->nrbufs);
1978 : 0 : ibuf = &pipe->bufs[pipe->curbuf];
1979 : 0 : obuf = &bufs[nbuf];
1980 : :
1981 : 0 : if (rem >= ibuf->len) {
1982 : 0 : *obuf = *ibuf;
1983 : 0 : ibuf->ops = NULL;
1984 : 0 : pipe->curbuf = (pipe->curbuf + 1) & (pipe->buffers - 1);
1985 : 0 : pipe->nrbufs--;
1986 : : } else {
1987 : 0 : if (!pipe_buf_get(pipe, ibuf))
1988 : : goto out_free;
1989 : :
1990 : 0 : *obuf = *ibuf;
1991 : 0 : obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
1992 : 0 : obuf->len = rem;
1993 : 0 : ibuf->offset += obuf->len;
1994 : 0 : ibuf->len -= obuf->len;
1995 : : }
1996 : 0 : nbuf++;
1997 : 0 : rem -= obuf->len;
1998 : : }
1999 : 0 : pipe_unlock(pipe);
2000 : :
2001 : : fuse_copy_init(&cs, 0, NULL);
2002 : 0 : cs.pipebufs = bufs;
2003 : 0 : cs.nr_segs = nbuf;
2004 : 0 : cs.pipe = pipe;
2005 : :
2006 : 0 : if (flags & SPLICE_F_MOVE)
2007 : 0 : cs.move_pages = 1;
2008 : :
2009 : 0 : ret = fuse_dev_do_write(fud, &cs, len);
2010 : :
2011 : 0 : pipe_lock(pipe);
2012 : : out_free:
2013 : 0 : for (idx = 0; idx < nbuf; idx++)
2014 : 0 : pipe_buf_release(pipe, &bufs[idx]);
2015 : 0 : pipe_unlock(pipe);
2016 : :
2017 : 0 : kvfree(bufs);
2018 : 0 : return ret;
2019 : : }
2020 : :
2021 : 0 : static __poll_t fuse_dev_poll(struct file *file, poll_table *wait)
2022 : : {
2023 : : __poll_t mask = EPOLLOUT | EPOLLWRNORM;
2024 : : struct fuse_iqueue *fiq;
2025 : : struct fuse_dev *fud = fuse_get_dev(file);
2026 : :
2027 : 0 : if (!fud)
2028 : : return EPOLLERR;
2029 : :
2030 : 0 : fiq = &fud->fc->iq;
2031 : 0 : poll_wait(file, &fiq->waitq, wait);
2032 : :
2033 : : spin_lock(&fiq->lock);
2034 : 0 : if (!fiq->connected)
2035 : : mask = EPOLLERR;
2036 : 0 : else if (request_pending(fiq))
2037 : : mask |= EPOLLIN | EPOLLRDNORM;
2038 : : spin_unlock(&fiq->lock);
2039 : :
2040 : 0 : return mask;
2041 : : }
2042 : :
2043 : : /* Abort all requests on the given list (pending or processing) */
2044 : 0 : static void end_requests(struct fuse_conn *fc, struct list_head *head)
2045 : : {
2046 : 0 : while (!list_empty(head)) {
2047 : : struct fuse_req *req;
2048 : 0 : req = list_entry(head->next, struct fuse_req, list);
2049 : 0 : req->out.h.error = -ECONNABORTED;
2050 : 0 : clear_bit(FR_SENT, &req->flags);
2051 : 0 : list_del_init(&req->list);
2052 : 0 : fuse_request_end(fc, req);
2053 : : }
2054 : 0 : }
2055 : :
2056 : 0 : static void end_polls(struct fuse_conn *fc)
2057 : : {
2058 : : struct rb_node *p;
2059 : :
2060 : 0 : p = rb_first(&fc->polled_files);
2061 : :
2062 : 0 : while (p) {
2063 : : struct fuse_file *ff;
2064 : : ff = rb_entry(p, struct fuse_file, polled_node);
2065 : 0 : wake_up_interruptible_all(&ff->poll_wait);
2066 : :
2067 : 0 : p = rb_next(p);
2068 : : }
2069 : 0 : }
2070 : :
2071 : : /*
2072 : : * Abort all requests.
2073 : : *
2074 : : * Emergency exit in case of a malicious or accidental deadlock, or just a hung
2075 : : * filesystem.
2076 : : *
2077 : : * The same effect is usually achievable through killing the filesystem daemon
2078 : : * and all users of the filesystem. The exception is the combination of an
2079 : : * asynchronous request and the tricky deadlock (see
2080 : : * Documentation/filesystems/fuse.txt).
2081 : : *
2082 : : * Aborting requests under I/O goes as follows: 1: Separate out unlocked
2083 : : * requests, they should be finished off immediately. Locked requests will be
2084 : : * finished after unlock; see unlock_request(). 2: Finish off the unlocked
2085 : : * requests. It is possible that some request will finish before we can. This
2086 : : * is OK, the request will in that case be removed from the list before we touch
2087 : : * it.
2088 : : */
2089 : 0 : void fuse_abort_conn(struct fuse_conn *fc)
2090 : : {
2091 : : struct fuse_iqueue *fiq = &fc->iq;
2092 : :
2093 : : spin_lock(&fc->lock);
2094 : 0 : if (fc->connected) {
2095 : : struct fuse_dev *fud;
2096 : : struct fuse_req *req, *next;
2097 : 0 : LIST_HEAD(to_end);
2098 : : unsigned int i;
2099 : :
2100 : : /* Background queuing checks fc->connected under bg_lock */
2101 : : spin_lock(&fc->bg_lock);
2102 : 0 : fc->connected = 0;
2103 : : spin_unlock(&fc->bg_lock);
2104 : :
2105 : : fuse_set_initialized(fc);
2106 : 0 : list_for_each_entry(fud, &fc->devices, entry) {
2107 : : struct fuse_pqueue *fpq = &fud->pq;
2108 : :
2109 : : spin_lock(&fpq->lock);
2110 : 0 : fpq->connected = 0;
2111 : 0 : list_for_each_entry_safe(req, next, &fpq->io, list) {
2112 : 0 : req->out.h.error = -ECONNABORTED;
2113 : : spin_lock(&req->waitq.lock);
2114 : 0 : set_bit(FR_ABORTED, &req->flags);
2115 : 0 : if (!test_bit(FR_LOCKED, &req->flags)) {
2116 : 0 : set_bit(FR_PRIVATE, &req->flags);
2117 : : __fuse_get_request(req);
2118 : : list_move(&req->list, &to_end);
2119 : : }
2120 : : spin_unlock(&req->waitq.lock);
2121 : : }
2122 : 0 : for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
2123 : 0 : list_splice_tail_init(&fpq->processing[i],
2124 : : &to_end);
2125 : : spin_unlock(&fpq->lock);
2126 : : }
2127 : : spin_lock(&fc->bg_lock);
2128 : 0 : fc->blocked = 0;
2129 : 0 : fc->max_background = UINT_MAX;
2130 : 0 : flush_bg_queue(fc);
2131 : : spin_unlock(&fc->bg_lock);
2132 : :
2133 : : spin_lock(&fiq->lock);
2134 : 0 : fiq->connected = 0;
2135 : 0 : list_for_each_entry(req, &fiq->pending, list)
2136 : 0 : clear_bit(FR_PENDING, &req->flags);
2137 : 0 : list_splice_tail_init(&fiq->pending, &to_end);
2138 : 0 : while (forget_pending(fiq))
2139 : 0 : kfree(fuse_dequeue_forget(fiq, 1, NULL));
2140 : 0 : wake_up_all(&fiq->waitq);
2141 : : spin_unlock(&fiq->lock);
2142 : 0 : kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
2143 : 0 : end_polls(fc);
2144 : 0 : wake_up_all(&fc->blocked_waitq);
2145 : : spin_unlock(&fc->lock);
2146 : :
2147 : 0 : end_requests(fc, &to_end);
2148 : : } else {
2149 : : spin_unlock(&fc->lock);
2150 : : }
2151 : 0 : }
2152 : : EXPORT_SYMBOL_GPL(fuse_abort_conn);
2153 : :
2154 : 0 : void fuse_wait_aborted(struct fuse_conn *fc)
2155 : : {
2156 : : /* matches implicit memory barrier in fuse_drop_waiting() */
2157 : 0 : smp_mb();
2158 : 0 : wait_event(fc->blocked_waitq, atomic_read(&fc->num_waiting) == 0);
2159 : 0 : }
2160 : :
2161 : 3 : int fuse_dev_release(struct inode *inode, struct file *file)
2162 : : {
2163 : : struct fuse_dev *fud = fuse_get_dev(file);
2164 : :
2165 : 3 : if (fud) {
2166 : 0 : struct fuse_conn *fc = fud->fc;
2167 : : struct fuse_pqueue *fpq = &fud->pq;
2168 : 0 : LIST_HEAD(to_end);
2169 : : unsigned int i;
2170 : :
2171 : : spin_lock(&fpq->lock);
2172 : 0 : WARN_ON(!list_empty(&fpq->io));
2173 : 0 : for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
2174 : 0 : list_splice_init(&fpq->processing[i], &to_end);
2175 : : spin_unlock(&fpq->lock);
2176 : :
2177 : 0 : end_requests(fc, &to_end);
2178 : :
2179 : : /* Are we the last open device? */
2180 : 0 : if (atomic_dec_and_test(&fc->dev_count)) {
2181 : 0 : WARN_ON(fc->iq.fasync != NULL);
2182 : 0 : fuse_abort_conn(fc);
2183 : : }
2184 : 0 : fuse_dev_free(fud);
2185 : : }
2186 : 3 : return 0;
2187 : : }
2188 : : EXPORT_SYMBOL_GPL(fuse_dev_release);
2189 : :
2190 : 0 : static int fuse_dev_fasync(int fd, struct file *file, int on)
2191 : : {
2192 : : struct fuse_dev *fud = fuse_get_dev(file);
2193 : :
2194 : 0 : if (!fud)
2195 : : return -EPERM;
2196 : :
2197 : : /* No locking - fasync_helper does its own locking */
2198 : 0 : return fasync_helper(fd, file, on, &fud->fc->iq.fasync);
2199 : : }
2200 : :
2201 : 0 : static int fuse_device_clone(struct fuse_conn *fc, struct file *new)
2202 : : {
2203 : : struct fuse_dev *fud;
2204 : :
2205 : 0 : if (new->private_data)
2206 : : return -EINVAL;
2207 : :
2208 : 0 : fud = fuse_dev_alloc_install(fc);
2209 : 0 : if (!fud)
2210 : : return -ENOMEM;
2211 : :
2212 : 0 : new->private_data = fud;
2213 : 0 : atomic_inc(&fc->dev_count);
2214 : :
2215 : 0 : return 0;
2216 : : }
2217 : :
2218 : 0 : static long fuse_dev_ioctl(struct file *file, unsigned int cmd,
2219 : : unsigned long arg)
2220 : : {
2221 : : int err = -ENOTTY;
2222 : :
2223 : 0 : if (cmd == FUSE_DEV_IOC_CLONE) {
2224 : : int oldfd;
2225 : :
2226 : : err = -EFAULT;
2227 : 0 : if (!get_user(oldfd, (__u32 __user *) arg)) {
2228 : 0 : struct file *old = fget(oldfd);
2229 : :
2230 : : err = -EINVAL;
2231 : 0 : if (old) {
2232 : : struct fuse_dev *fud = NULL;
2233 : :
2234 : : /*
2235 : : * Check against file->f_op because CUSE
2236 : : * uses the same ioctl handler.
2237 : : */
2238 : 0 : if (old->f_op == file->f_op &&
2239 : 0 : old->f_cred->user_ns == file->f_cred->user_ns)
2240 : : fud = fuse_get_dev(old);
2241 : :
2242 : 0 : if (fud) {
2243 : 0 : mutex_lock(&fuse_mutex);
2244 : 0 : err = fuse_device_clone(fud->fc, file);
2245 : 0 : mutex_unlock(&fuse_mutex);
2246 : : }
2247 : 0 : fput(old);
2248 : : }
2249 : : }
2250 : : }
2251 : 0 : return err;
2252 : : }
2253 : :
2254 : : const struct file_operations fuse_dev_operations = {
2255 : : .owner = THIS_MODULE,
2256 : : .open = fuse_dev_open,
2257 : : .llseek = no_llseek,
2258 : : .read_iter = fuse_dev_read,
2259 : : .splice_read = fuse_dev_splice_read,
2260 : : .write_iter = fuse_dev_write,
2261 : : .splice_write = fuse_dev_splice_write,
2262 : : .poll = fuse_dev_poll,
2263 : : .release = fuse_dev_release,
2264 : : .fasync = fuse_dev_fasync,
2265 : : .unlocked_ioctl = fuse_dev_ioctl,
2266 : : .compat_ioctl = fuse_dev_ioctl,
2267 : : };
2268 : : EXPORT_SYMBOL_GPL(fuse_dev_operations);
2269 : :
2270 : : static struct miscdevice fuse_miscdevice = {
2271 : : .minor = FUSE_MINOR,
2272 : : .name = "fuse",
2273 : : .fops = &fuse_dev_operations,
2274 : : };
2275 : :
2276 : 3 : int __init fuse_dev_init(void)
2277 : : {
2278 : : int err = -ENOMEM;
2279 : 3 : fuse_req_cachep = kmem_cache_create("fuse_request",
2280 : : sizeof(struct fuse_req),
2281 : : 0, 0, NULL);
2282 : 3 : if (!fuse_req_cachep)
2283 : : goto out;
2284 : :
2285 : 3 : err = misc_register(&fuse_miscdevice);
2286 : 3 : if (err)
2287 : : goto out_cache_clean;
2288 : :
2289 : : return 0;
2290 : :
2291 : : out_cache_clean:
2292 : 0 : kmem_cache_destroy(fuse_req_cachep);
2293 : : out:
2294 : 0 : return err;
2295 : : }
2296 : :
2297 : 0 : void fuse_dev_cleanup(void)
2298 : : {
2299 : 0 : misc_deregister(&fuse_miscdevice);
2300 : 0 : kmem_cache_destroy(fuse_req_cachep);
2301 : 0 : }
|
