libfuse: lib/fuse_lowlevel.c Source File

libfuse

fuse_lowlevel.c
1 /*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
4
5 Implementation of (most of) the low-level FUSE API. The session loop
6 functions are implemented in separate files.
7
8 This program can be distributed under the terms of the GNU LGPLv2.
9 See the file COPYING.LIB
10 */
11
12 #define _GNU_SOURCE
13
14 #include "config.h"
15 #include "fuse_i.h"
16 #include "fuse_kernel.h"
17 #include "fuse_opt.h"
18 #include "fuse_misc.h"
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stddef.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <limits.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <sys/file.h>
29
30 #ifndef F_LINUX_SPECIFIC_BASE
31 #define F_LINUX_SPECIFIC_BASE 1024
32 #endif
33 #ifndef F_SETPIPE_SZ
34 #define F_SETPIPE_SZ (F_LINUX_SPECIFIC_BASE + 7)
35 #endif
36
37
38 #define PARAM(inarg) (((char *)(inarg)) + sizeof(*(inarg)))
39 #define OFFSET_MAX 0x7fffffffffffffffLL
40
41 #define container_of(ptr, type, member) ({ \
42 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
43 (type *)( (char *)__mptr - offsetof(type,member) );})
44
45 struct fuse_pollhandle {
46 uint64_t kh;
47 struct fuse_session *se;
48 };
49
50 static size_t pagesize;
51
52 static __attribute__((constructor)) void fuse_ll_init_pagesize(void)
53 {
54 pagesize = getpagesize();
55 }
56
57 static void convert_stat(const struct stat *stbuf, struct fuse_attr *attr)
58 {
59 attr->ino = stbuf->st_ino;
60 attr->mode = stbuf->st_mode;
61 attr->nlink = stbuf->st_nlink;
62 attr->uid = stbuf->st_uid;
63 attr->gid = stbuf->st_gid;
64 attr->rdev = stbuf->st_rdev;
65 attr->size = stbuf->st_size;
66 attr->blksize = stbuf->st_blksize;
67 attr->blocks = stbuf->st_blocks;
68 attr->atime = stbuf->st_atime;
69 attr->mtime = stbuf->st_mtime;
70 attr->ctime = stbuf->st_ctime;
71 attr->atimensec = ST_ATIM_NSEC(stbuf);
72 attr->mtimensec = ST_MTIM_NSEC(stbuf);
73 attr->ctimensec = ST_CTIM_NSEC(stbuf);
74 }
75
76 static void convert_attr(const struct fuse_setattr_in *attr, struct stat *stbuf)
77 {
78 stbuf->st_mode = attr->mode;
79 stbuf->st_uid = attr->uid;
80 stbuf->st_gid = attr->gid;
81 stbuf->st_size = attr->size;
82 stbuf->st_atime = attr->atime;
83 stbuf->st_mtime = attr->mtime;
84 stbuf->st_ctime = attr->ctime;
85 ST_ATIM_NSEC_SET(stbuf, attr->atimensec);
86 ST_MTIM_NSEC_SET(stbuf, attr->mtimensec);
87 ST_CTIM_NSEC_SET(stbuf, attr->ctimensec);
88 }
89
90 static size_t iov_length(const struct iovec *iov, size_t count)
91 {
92 size_t seg;
93 size_t ret = 0;
94
95 for (seg = 0; seg < count; seg++)
96 ret += iov[seg].iov_len;
97 return ret;
98 }
99
100 static void list_init_req(struct fuse_req *req)
101 {
102 req->next = req;
103 req->prev = req;
104 }
105
106 static void list_del_req(struct fuse_req *req)
107 {
108 struct fuse_req *prev = req->prev;
109 struct fuse_req *next = req->next;
110 prev->next = next;
111 next->prev = prev;
112 }
113
114 static void list_add_req(struct fuse_req *req, struct fuse_req *next)
115 {
116 struct fuse_req *prev = next->prev;
117 req->next = next;
118 req->prev = prev;
119 prev->next = req;
120 next->prev = req;
121 }
122
123 static void destroy_req(fuse_req_t req)
124 {
125 pthread_mutex_destroy(&req->lock);
126 free(req);
127 }
128
129 void fuse_free_req(fuse_req_t req)
130 {
131 int ctr;
132 struct fuse_session *se = req->se;
133
134 pthread_mutex_lock(&se->lock);
135 req->u.ni.func = NULL;
136 req->u.ni.data = NULL;
137 list_del_req(req);
138 ctr = --req->ctr;
139 fuse_chan_put(req->ch);
140 req->ch = NULL;
141 pthread_mutex_unlock(&se->lock);
142 if (!ctr)
143 destroy_req(req);
144 }
145
146 static struct fuse_req *fuse_ll_alloc_req(struct fuse_session *se)
147 {
148 struct fuse_req *req;
149
150 req = (struct fuse_req *) calloc(1, sizeof(struct fuse_req));
151 if (req == NULL) {
152 fprintf(stderr, "fuse: failed to allocate request\n");
153 } else {
154 req->se = se;
155 req->ctr = 1;
156 list_init_req(req);
157 fuse_mutex_init(&req->lock);
158 }
159
160 return req;
161 }
162
163 /* Send data. If *ch* is NULL, send via session master fd */
164 static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
165 struct iovec *iov, int count)
166 {
167 struct fuse_out_header *out = iov[0].iov_base;
168
169 out->len = iov_length(iov, count);
170 if (se->debug) {
171 if (out->unique == 0) {
172 fprintf(stderr, "NOTIFY: code=%d length=%u\n",
173 out->error, out->len);
174 } else if (out->error) {
175 fprintf(stderr,
176 " unique: %llu, error: %i (%s), outsize: %i\n",
177 (unsigned long long) out->unique, out->error,
178 strerror(-out->error), out->len);
179 } else {
180 fprintf(stderr,
181 " unique: %llu, success, outsize: %i\n",
182 (unsigned long long) out->unique, out->len);
183 }
184 }
185
186 ssize_t res = writev(ch ? ch->fd : se->fd,
187 iov, count);
188 int err = errno;
189
190 if (res == -1) {
191 assert(se != NULL);
192
193 /* ENOENT means the operation was interrupted */
194 if (!fuse_session_exited(se) && err != ENOENT)
195 perror("fuse: writing device");
196 return -err;
197 }
198
199 return 0;
200 }
201
202
203 int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
204 int count)
205 {
206 struct fuse_out_header out;
207
208 if (error <= -1000 || error > 0) {
209 fprintf(stderr, "fuse: bad error value: %i\n", error);
210 error = -ERANGE;
211 }
212
213 out.unique = req->unique;
214 out.error = error;
215
216 iov[0].iov_base = &out;
217 iov[0].iov_len = sizeof(struct fuse_out_header);
218
219 return fuse_send_msg(req->se, req->ch, iov, count);
220 }
221
222 static int send_reply_iov(fuse_req_t req, int error, struct iovec *iov,
223 int count)
224 {
225 int res;
226
227 res = fuse_send_reply_iov_nofree(req, error, iov, count);
228 fuse_free_req(req);
229 return res;
230 }
231
232 static int send_reply(fuse_req_t req, int error, const void *arg,
233 size_t argsize)
234 {
235 struct iovec iov[2];
236 int count = 1;
237 if (argsize) {
238 iov[1].iov_base = (void *) arg;
239 iov[1].iov_len = argsize;
240 count++;
241 }
242 return send_reply_iov(req, error, iov, count);
243 }
244
245 int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count)
246 {
247 int res;
248 struct iovec *padded_iov;
249
250 padded_iov = malloc((count + 1) * sizeof(struct iovec));
251 if (padded_iov == NULL)
252 return fuse_reply_err(req, ENOMEM);
253
254 memcpy(padded_iov + 1, iov, count * sizeof(struct iovec));
255 count++;
256
257 res = send_reply_iov(req, 0, padded_iov, count);
258 free(padded_iov);
259
260 return res;
261 }
262
263
264 /* `buf` is allowed to be empty so that the proper size may be
265 allocated by the caller */
266 size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
267 const char *name, const struct stat *stbuf, off_t off)
268 {
269 (void)req;
270 size_t namelen;
271 size_t entlen;
272 size_t entlen_padded;
273 struct fuse_dirent *dirent;
274
275 namelen = strlen(name);
276 entlen = FUSE_NAME_OFFSET + namelen;
277 entlen_padded = FUSE_DIRENT_ALIGN(entlen);
278
279 if ((buf == NULL) || (entlen_padded > bufsize))
280 return entlen_padded;
281
282 dirent = (struct fuse_dirent*) buf;
283 dirent->ino = stbuf->st_ino;
284 dirent->off = off;
285 dirent->namelen = namelen;
286 dirent->type = (stbuf->st_mode & 0170000) >> 12;
287 strncpy(dirent->name, name, namelen);
288 memset(dirent->name + namelen, 0, entlen_padded - entlen);
289
290 return entlen_padded;
291 }
292
293 static void convert_statfs(const struct statvfs *stbuf,
294 struct fuse_kstatfs *kstatfs)
295 {
296 kstatfs->bsize = stbuf->f_bsize;
297 kstatfs->frsize = stbuf->f_frsize;
298 kstatfs->blocks = stbuf->f_blocks;
299 kstatfs->bfree = stbuf->f_bfree;
300 kstatfs->bavail = stbuf->f_bavail;
301 kstatfs->files = stbuf->f_files;
302 kstatfs->ffree = stbuf->f_ffree;
303 kstatfs->namelen = stbuf->f_namemax;
304 }
305
306 static int send_reply_ok(fuse_req_t req, const void *arg, size_t argsize)
307 {
308 return send_reply(req, 0, arg, argsize);
309 }
310
311 int fuse_reply_err(fuse_req_t req, int err)
312 {
313 return send_reply(req, -err, NULL, 0);
314 }
315
316 void fuse_reply_none(fuse_req_t req)
317 {
318 fuse_free_req(req);
319 }
320
321 static unsigned long calc_timeout_sec(double t)
322 {
323 if (t > (double) ULONG_MAX)
324 return ULONG_MAX;
325 else if (t < 0.0)
326 return 0;
327 else
328 return (unsigned long) t;
329 }
330
331 static unsigned int calc_timeout_nsec(double t)
332 {
333 double f = t - (double) calc_timeout_sec(t);
334 if (f < 0.0)
335 return 0;
336 else if (f >= 0.999999999)
337 return 999999999;
338 else
339 return (unsigned int) (f * 1.0e9);
340 }
341
342 static void fill_entry(struct fuse_entry_out *arg,
343 const struct fuse_entry_param *e)
344 {
345 arg->nodeid = e->ino;
346 arg->generation = e->generation;
347 arg->entry_valid = calc_timeout_sec(e->entry_timeout);
348 arg->entry_valid_nsec = calc_timeout_nsec(e->entry_timeout);
349 arg->attr_valid = calc_timeout_sec(e->attr_timeout);
350 arg->attr_valid_nsec = calc_timeout_nsec(e->attr_timeout);
351 convert_stat(&e->attr, &arg->attr);
352 }
353
354 /* `buf` is allowed to be empty so that the proper size may be
355 allocated by the caller */
356 size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize,
357 const char *name,
358 const struct fuse_entry_param *e, off_t off)
359 {
360 (void)req;
361 size_t namelen;
362 size_t entlen;
363 size_t entlen_padded;
364
365 namelen = strlen(name);
366 entlen = FUSE_NAME_OFFSET_DIRENTPLUS + namelen;
367 entlen_padded = FUSE_DIRENT_ALIGN(entlen);
368 if ((buf == NULL) || (entlen_padded > bufsize))
369 return entlen_padded;
370
371 struct fuse_direntplus *dp = (struct fuse_direntplus *) buf;
372 memset(&dp->entry_out, 0, sizeof(dp->entry_out));
373 fill_entry(&dp->entry_out, e);
374
375 struct fuse_dirent *dirent = &dp->dirent;
376 dirent->ino = e->attr.st_ino;
377 dirent->off = off;
378 dirent->namelen = namelen;
379 dirent->type = (e->attr.st_mode & 0170000) >> 12;
380 strncpy(dirent->name, name, namelen);
381 memset(dirent->name + namelen, 0, entlen_padded - entlen);
382
383 return entlen_padded;
384 }
385
386 static void fill_open(struct fuse_open_out *arg,
387 const struct fuse_file_info *f)
388 {
389 arg->fh = f->fh;
390 if (f->direct_io)
391 arg->open_flags |= FOPEN_DIRECT_IO;
392 if (f->keep_cache)
393 arg->open_flags |= FOPEN_KEEP_CACHE;
394 if (f->nonseekable)
395 arg->open_flags |= FOPEN_NONSEEKABLE;
396 }
397
398 int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)
399 {
400 struct fuse_entry_out arg;
401 size_t size = req->se->conn.proto_minor < 9 ?
402 FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(arg);
403
404 /* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
405 negative entry */
406 if (!e->ino && req->se->conn.proto_minor < 4)
407 return fuse_reply_err(req, ENOENT);
408
409 memset(&arg, 0, sizeof(arg));
410 fill_entry(&arg, e);
411 return send_reply_ok(req, &arg, size);
412 }
413
414 int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
415 const struct fuse_file_info *f)
416 {
417 char buf[sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out)];
418 size_t entrysize = req->se->conn.proto_minor < 9 ?
419 FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(struct fuse_entry_out);
420 struct fuse_entry_out *earg = (struct fuse_entry_out *) buf;
421 struct fuse_open_out *oarg = (struct fuse_open_out *) (buf + entrysize);
422
423 memset(buf, 0, sizeof(buf));
424 fill_entry(earg, e);
425 fill_open(oarg, f);
426 return send_reply_ok(req, buf,
427 entrysize + sizeof(struct fuse_open_out));
428 }
429
430 int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
431 double attr_timeout)
432 {
433 struct fuse_attr_out arg;
434 size_t size = req->se->conn.proto_minor < 9 ?
435 FUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);
436
437 memset(&arg, 0, sizeof(arg));
438 arg.attr_valid = calc_timeout_sec(attr_timeout);
439 arg.attr_valid_nsec = calc_timeout_nsec(attr_timeout);
440 convert_stat(attr, &arg.attr);
441
442 return send_reply_ok(req, &arg, size);
443 }
444
445 int fuse_reply_readlink(fuse_req_t req, const char *linkname)
446 {
447 return send_reply_ok(req, linkname, strlen(linkname));
448 }
449
450 int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *f)
451 {
452 struct fuse_open_out arg;
453
454 memset(&arg, 0, sizeof(arg));
455 fill_open(&arg, f);
456 return send_reply_ok(req, &arg, sizeof(arg));
457 }
458
459 int fuse_reply_write(fuse_req_t req, size_t count)
460 {
461 struct fuse_write_out arg;
462
463 memset(&arg, 0, sizeof(arg));
464 arg.size = count;
465
466 return send_reply_ok(req, &arg, sizeof(arg));
467 }
468
469 int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size)
470 {
471 return send_reply_ok(req, buf, size);
472 }
473
474 static int fuse_send_data_iov_fallback(struct fuse_session *se,
475 struct fuse_chan *ch,
476 struct iovec *iov, int iov_count,
477 struct fuse_bufvec *buf,
478 size_t len)
479 {
480 struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);
481 void *mbuf;
482 int res;
483
484 /* Optimize common case */
485 if (buf->count == 1 && buf->idx == 0 && buf->off == 0 &&
486 !(buf->buf[0].flags & FUSE_BUF_IS_FD)) {
487 /* FIXME: also avoid memory copy if there are multiple buffers
488 but none of them contain an fd */
489
490 iov[iov_count].iov_base = buf->buf[0].mem;
491 iov[iov_count].iov_len = len;
492 iov_count++;
493 return fuse_send_msg(se, ch, iov, iov_count);
494 }
495
496 res = posix_memalign(&mbuf, pagesize, len);
497 if (res != 0)
498 return res;
499
500 mem_buf.buf[0].mem = mbuf;
501 res = fuse_buf_copy(&mem_buf, buf, 0);
502 if (res < 0) {
503 free(mbuf);
504 return -res;
505 }
506 len = res;
507
508 iov[iov_count].iov_base = mbuf;
509 iov[iov_count].iov_len = len;
510 iov_count++;
511 res = fuse_send_msg(se, ch, iov, iov_count);
512 free(mbuf);
513
514 return res;
515 }
516
517 struct fuse_ll_pipe {
518 size_t size;
519 int can_grow;
520 int pipe[2];
521 };
522
523 static void fuse_ll_pipe_free(struct fuse_ll_pipe *llp)
524 {
525 close(llp->pipe[0]);
526 close(llp->pipe[1]);
527 free(llp);
528 }
529
530 #ifdef HAVE_SPLICE
531 #if !defined(HAVE_PIPE2) || !defined(O_CLOEXEC)
532 static int fuse_pipe(int fds[2])
533 {
534 int rv = pipe(fds);
535
536 if (rv == -1)
537 return rv;
538
539 if (fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1 ||
540 fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1 ||
541 fcntl(fds[0], F_SETFD, FD_CLOEXEC) == -1 ||
542 fcntl(fds[1], F_SETFD, FD_CLOEXEC) == -1) {
543 close(fds[0]);
544 close(fds[1]);
545 rv = -1;
546 }
547 return rv;
548 }
549 #else
550 static int fuse_pipe(int fds[2])
551 {
552 return pipe2(fds, O_CLOEXEC | O_NONBLOCK);
553 }
554 #endif
555
556 static struct fuse_ll_pipe *fuse_ll_get_pipe(struct fuse_session *se)
557 {
558 struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);
559 if (llp == NULL) {
560 int res;
561
562 llp = malloc(sizeof(struct fuse_ll_pipe));
563 if (llp == NULL)
564 return NULL;
565
566 res = fuse_pipe(llp->pipe);
567 if (res == -1) {
568 free(llp);
569 return NULL;
570 }
571
572 /*
573 *the default size is 16 pages on linux
574 */
575 llp->size = pagesize * 16;
576 llp->can_grow = 1;
577
578 pthread_setspecific(se->pipe_key, llp);
579 }
580
581 return llp;
582 }
583 #endif
584
585 static void fuse_ll_clear_pipe(struct fuse_session *se)
586 {
587 struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);
588 if (llp) {
589 pthread_setspecific(se->pipe_key, NULL);
590 fuse_ll_pipe_free(llp);
591 }
592 }
593
594 #if defined(HAVE_SPLICE) && defined(HAVE_VMSPLICE)
595 static int read_back(int fd, char *buf, size_t len)
596 {
597 int res;
598
599 res = read(fd, buf, len);
600 if (res == -1) {
601 fprintf(stderr, "fuse: internal error: failed to read back from pipe: %s\n", strerror(errno));
602 return -EIO;
603 }
604 if (res != len) {
605 fprintf(stderr, "fuse: internal error: short read back from pipe: %i from %zi\n", res, len);
606 return -EIO;
607 }
608 return 0;
609 }
610
611 static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
612 struct iovec *iov, int iov_count,
613 struct fuse_bufvec *buf, unsigned int flags)
614 {
615 int res;
616 size_t len = fuse_buf_size(buf);
617 struct fuse_out_header *out = iov[0].iov_base;
618 struct fuse_ll_pipe *llp;
619 int splice_flags;
620 size_t pipesize;
621 size_t total_fd_size;
622 size_t idx;
623 size_t headerlen;
624 struct fuse_bufvec pipe_buf = FUSE_BUFVEC_INIT(len);
625
626 if (se->broken_splice_nonblock)
627 goto fallback;
628
629 if (flags & FUSE_BUF_NO_SPLICE)
630 goto fallback;
631
632 total_fd_size = 0;
633 for (idx = buf->idx; idx < buf->count; idx++) {
634 if (buf->buf[idx].flags & FUSE_BUF_IS_FD) {
635 total_fd_size = buf->buf[idx].size;
636 if (idx == buf->idx)
637 total_fd_size -= buf->off;
638 }
639 }
640 if (total_fd_size < 2 * pagesize)
641 goto fallback;
642
643 if (se->conn.proto_minor < 14 ||
644 !(se->conn.want & FUSE_CAP_SPLICE_WRITE))
645 goto fallback;
646
647 llp = fuse_ll_get_pipe(se);
648 if (llp == NULL)
649 goto fallback;
650
651
652 headerlen = iov_length(iov, iov_count);
653
654 out->len = headerlen + len;
655
656 /*
657 * Heuristic for the required pipe size, does not work if the
658 * source contains less than page size fragments
659 */
660 pipesize = pagesize * (iov_count + buf->count + 1) + out->len;
661
662 if (llp->size < pipesize) {
663 if (llp->can_grow) {
664 res = fcntl(llp->pipe[0], F_SETPIPE_SZ, pipesize);
665 if (res == -1) {
666 llp->can_grow = 0;
667 goto fallback;
668 }
669 llp->size = res;
670 }
671 if (llp->size < pipesize)
672 goto fallback;
673 }
674
675
676 res = vmsplice(llp->pipe[1], iov, iov_count, SPLICE_F_NONBLOCK);
677 if (res == -1)
678 goto fallback;
679
680 if (res != headerlen) {
681 res = -EIO;
682 fprintf(stderr, "fuse: short vmsplice to pipe: %u/%zu\n", res,
683 headerlen);
684 goto clear_pipe;
685 }
686
687 pipe_buf.buf[0].flags = FUSE_BUF_IS_FD;
688 pipe_buf.buf[0].fd = llp->pipe[1];
689
690 res = fuse_buf_copy(&pipe_buf, buf,
691 FUSE_BUF_FORCE_SPLICE | FUSE_BUF_SPLICE_NONBLOCK);
692 if (res < 0) {
693 if (res == -EAGAIN || res == -EINVAL) {
694 /*
695 * Should only get EAGAIN on kernels with
696 * broken SPLICE_F_NONBLOCK support (<=
697 * 2.6.35) where this error or a short read is
698 * returned even if the pipe itself is not
699 * full
700 *
701 * EINVAL might mean that splice can't handle
702 * this combination of input and output.
703 */
704 if (res == -EAGAIN)
705 se->broken_splice_nonblock = 1;
706
707 pthread_setspecific(se->pipe_key, NULL);
708 fuse_ll_pipe_free(llp);
709 goto fallback;
710 }
711 res = -res;
712 goto clear_pipe;
713 }
714
715 if (res != 0 && res < len) {
716 struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);
717 void *mbuf;
718 size_t now_len = res;
719 /*
720 * For regular files a short count is either
721 * 1) due to EOF, or
722 * 2) because of broken SPLICE_F_NONBLOCK (see above)
723 *
724 * For other inputs it's possible that we overflowed
725 * the pipe because of small buffer fragments.
726 */
727
728 res = posix_memalign(&mbuf, pagesize, len);
729 if (res != 0)
730 goto clear_pipe;
731
732 mem_buf.buf[0].mem = mbuf;
733 mem_buf.off = now_len;
734 res = fuse_buf_copy(&mem_buf, buf, 0);
735 if (res > 0) {
736 char *tmpbuf;
737 size_t extra_len = res;
738 /*
739 * Trickiest case: got more data. Need to get
740 * back the data from the pipe and then fall
741 * back to regular write.
742 */
743 tmpbuf = malloc(headerlen);
744 if (tmpbuf == NULL) {
745 free(mbuf);
746 res = ENOMEM;
747 goto clear_pipe;
748 }
749 res = read_back(llp->pipe[0], tmpbuf, headerlen);
750 free(tmpbuf);
751 if (res != 0) {
752 free(mbuf);
753 goto clear_pipe;
754 }
755 res = read_back(llp->pipe[0], mbuf, now_len);
756 if (res != 0) {
757 free(mbuf);
758 goto clear_pipe;
759 }
760 len = now_len + extra_len;
761 iov[iov_count].iov_base = mbuf;
762 iov[iov_count].iov_len = len;
763 iov_count++;
764 res = fuse_send_msg(se, ch, iov, iov_count);
765 free(mbuf);
766 return res;
767 }
768 free(mbuf);
769 res = now_len;
770 }
771 len = res;
772 out->len = headerlen + len;
773
774 if (se->debug) {
775 fprintf(stderr,
776 " unique: %llu, success, outsize: %i (splice)\n",
777 (unsigned long long) out->unique, out->len);
778 }
779
780 splice_flags = 0;
781 if ((flags & FUSE_BUF_SPLICE_MOVE) &&
782 (se->conn.want & FUSE_CAP_SPLICE_MOVE))
783 splice_flags |= SPLICE_F_MOVE;
784
785 res = splice(llp->pipe[0], NULL, ch ? ch->fd : se->fd,
786 NULL, out->len, splice_flags);
787 if (res == -1) {
788 res = -errno;
789 perror("fuse: splice from pipe");
790 goto clear_pipe;
791 }
792 if (res != out->len) {
793 res = -EIO;
794 fprintf(stderr, "fuse: short splice from pipe: %u/%u\n",
795 res, out->len);
796 goto clear_pipe;
797 }
798 return 0;
799
800 clear_pipe:
801 fuse_ll_clear_pipe(se);
802 return res;
803
804 fallback:
805 return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
806 }
807 #else
808 static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
809 struct iovec *iov, int iov_count,
810 struct fuse_bufvec *buf, unsigned int flags)
811 {
812 size_t len = fuse_buf_size(buf);
813 (void) flags;
814
815 return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
816 }
817 #endif
818
819 int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
820 enum fuse_buf_copy_flags flags)
821 {
822 struct iovec iov[2];
823 struct fuse_out_header out;
824 int res;
825
826 iov[0].iov_base = &out;
827 iov[0].iov_len = sizeof(struct fuse_out_header);
828
829 out.unique = req->unique;
830 out.error = 0;
831
832 res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
833 if (res <= 0) {
834 fuse_free_req(req);
835 return res;
836 } else {
837 return fuse_reply_err(req, res);
838 }
839 }
840
841 int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
842 {
843 struct fuse_statfs_out arg;
844 size_t size = req->se->conn.proto_minor < 4 ?
845 FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
846
847 memset(&arg, 0, sizeof(arg));
848 convert_statfs(stbuf, &arg.st);
849
850 return send_reply_ok(req, &arg, size);
851 }
852
853 int fuse_reply_xattr(fuse_req_t req, size_t count)
854 {
855 struct fuse_getxattr_out arg;
856
857 memset(&arg, 0, sizeof(arg));
858 arg.size = count;
859
860 return send_reply_ok(req, &arg, sizeof(arg));
861 }
862
863 int fuse_reply_lock(fuse_req_t req, const struct flock *lock)
864 {
865 struct fuse_lk_out arg;
866
867 memset(&arg, 0, sizeof(arg));
868 arg.lk.type = lock->l_type;
869 if (lock->l_type != F_UNLCK) {
870 arg.lk.start = lock->l_start;
871 if (lock->l_len == 0)
872 arg.lk.end = OFFSET_MAX;
873 else
874 arg.lk.end = lock->l_start + lock->l_len - 1;
875 }
876 arg.lk.pid = lock->l_pid;
877 return send_reply_ok(req, &arg, sizeof(arg));
878 }
879
880 int fuse_reply_bmap(fuse_req_t req, uint64_t idx)
881 {
882 struct fuse_bmap_out arg;
883
884 memset(&arg, 0, sizeof(arg));
885 arg.block = idx;
886
887 return send_reply_ok(req, &arg, sizeof(arg));
888 }
889
890 static struct fuse_ioctl_iovec *fuse_ioctl_iovec_copy(const struct iovec *iov,
891 size_t count)
892 {
893 struct fuse_ioctl_iovec *fiov;
894 size_t i;
895
896 fiov = malloc(sizeof(fiov[0]) * count);
897 if (!fiov)
898 return NULL;
899
900 for (i = 0; i < count; i++) {
901 fiov[i].base = (uintptr_t) iov[i].iov_base;
902 fiov[i].len = iov[i].iov_len;
903 }
904
905 return fiov;
906 }
907
908 int fuse_reply_ioctl_retry(fuse_req_t req,
909 const struct iovec *in_iov, size_t in_count,
910 const struct iovec *out_iov, size_t out_count)
911 {
912 struct fuse_ioctl_out arg;
913 struct fuse_ioctl_iovec *in_fiov = NULL;
914 struct fuse_ioctl_iovec *out_fiov = NULL;
915 struct iovec iov[4];
916 size_t count = 1;
917 int res;
918
919 memset(&arg, 0, sizeof(arg));
920 arg.flags |= FUSE_IOCTL_RETRY;
921 arg.in_iovs = in_count;
922 arg.out_iovs = out_count;
923 iov[count].iov_base = &arg;
924 iov[count].iov_len = sizeof(arg);
925 count++;
926
927 if (req->se->conn.proto_minor < 16) {
928 if (in_count) {
929 iov[count].iov_base = (void *)in_iov;
930 iov[count].iov_len = sizeof(in_iov[0]) * in_count;
931 count++;
932 }
933
934 if (out_count) {
935 iov[count].iov_base = (void *)out_iov;
936 iov[count].iov_len = sizeof(out_iov[0]) * out_count;
937 count++;
938 }
939 } else {
940 /* Can't handle non-compat 64bit ioctls on 32bit */
941 if (sizeof(void *) == 4 && req->ioctl_64bit) {
942 res = fuse_reply_err(req, EINVAL);
943 goto out;
944 }
945
946 if (in_count) {
947 in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
948 if (!in_fiov)
949 goto enomem;
950
951 iov[count].iov_base = (void *)in_fiov;
952 iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
953 count++;
954 }
955 if (out_count) {
956 out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
957 if (!out_fiov)
958 goto enomem;
959
960 iov[count].iov_base = (void *)out_fiov;
961 iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
962 count++;
963 }
964 }
965
966 res = send_reply_iov(req, 0, iov, count);
967 out:
968 free(in_fiov);
969 free(out_fiov);
970
971 return res;
972
973 enomem:
974 res = fuse_reply_err(req, ENOMEM);
975 goto out;
976 }
977
978 int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size)
979 {
980 struct fuse_ioctl_out arg;
981 struct iovec iov[3];
982 size_t count = 1;
983
984 memset(&arg, 0, sizeof(arg));
985 arg.result = result;
986 iov[count].iov_base = &arg;
987 iov[count].iov_len = sizeof(arg);
988 count++;
989
990 if (size) {
991 iov[count].iov_base = (char *) buf;
992 iov[count].iov_len = size;
993 count++;
994 }
995
996 return send_reply_iov(req, 0, iov, count);
997 }
998
999 int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
1000 int count)
1001 {
1002 struct iovec *padded_iov;
1003 struct fuse_ioctl_out arg;
1004 int res;
1005
1006 padded_iov = malloc((count + 2) * sizeof(struct iovec));
1007 if (padded_iov == NULL)
1008 return fuse_reply_err(req, ENOMEM);
1009
1010 memset(&arg, 0, sizeof(arg));
1011 arg.result = result;
1012 padded_iov[1].iov_base = &arg;
1013 padded_iov[1].iov_len = sizeof(arg);
1014
1015 memcpy(&padded_iov[2], iov, count * sizeof(struct iovec));
1016
1017 res = send_reply_iov(req, 0, padded_iov, count + 2);
1018 free(padded_iov);
1019
1020 return res;
1021 }
1022
1023 int fuse_reply_poll(fuse_req_t req, unsigned revents)
1024 {
1025 struct fuse_poll_out arg;
1026
1027 memset(&arg, 0, sizeof(arg));
1028 arg.revents = revents;
1029
1030 return send_reply_ok(req, &arg, sizeof(arg));
1031 }
1032
1033 static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1034 {
1035 char *name = (char *) inarg;
1036
1037 if (req->se->op.lookup)
1038 req->se->op.lookup(req, nodeid, name);
1039 else
1040 fuse_reply_err(req, ENOSYS);
1041 }
1042
1043 static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1044 {
1045 struct fuse_forget_in *arg = (struct fuse_forget_in *) inarg;
1046
1047 if (req->se->op.forget)
1048 req->se->op.forget(req, nodeid, arg->nlookup);
1049 else
1050 fuse_reply_none(req);
1051 }
1052
1053 static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
1054 const void *inarg)
1055 {
1056 struct fuse_batch_forget_in *arg = (void *) inarg;
1057 struct fuse_forget_one *param = (void *) PARAM(arg);
1058 unsigned int i;
1059
1060 (void) nodeid;
1061
1062 if (req->se->op.forget_multi) {
1063 req->se->op.forget_multi(req, arg->count,
1064 (struct fuse_forget_data *) param);
1065 } else if (req->se->op.forget) {
1066 for (i = 0; i < arg->count; i++) {
1067 struct fuse_forget_one *forget = &param[i];
1068 struct fuse_req *dummy_req;
1069
1070 dummy_req = fuse_ll_alloc_req(req->se);
1071 if (dummy_req == NULL)
1072 break;
1073
1074 dummy_req->unique = req->unique;
1075 dummy_req->ctx = req->ctx;
1076 dummy_req->ch = NULL;
1077
1078 req->se->op.forget(dummy_req, forget->nodeid,
1079 forget->nlookup);
1080 }
1081 fuse_reply_none(req);
1082 } else {
1083 fuse_reply_none(req);
1084 }
1085 }
1086
1087 static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1088 {
1089 struct fuse_file_info *fip = NULL;
1090 struct fuse_file_info fi;
1091
1092 if (req->se->conn.proto_minor >= 9) {
1093 struct fuse_getattr_in *arg = (struct fuse_getattr_in *) inarg;
1094
1095 if (arg->getattr_flags & FUSE_GETATTR_FH) {
1096 memset(&fi, 0, sizeof(fi));
1097 fi.fh = arg->fh;
1098 fip = &fi;
1099 }
1100 }
1101
1102 if (req->se->op.getattr)
1103 req->se->op.getattr(req, nodeid, fip);
1104 else
1105 fuse_reply_err(req, ENOSYS);
1106 }
1107
1108 static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1109 {
1110 struct fuse_setattr_in *arg = (struct fuse_setattr_in *) inarg;
1111
1112 if (req->se->op.setattr) {
1113 struct fuse_file_info *fi = NULL;
1114 struct fuse_file_info fi_store;
1115 struct stat stbuf;
1116 memset(&stbuf, 0, sizeof(stbuf));
1117 convert_attr(arg, &stbuf);
1118 if (arg->valid & FATTR_FH) {
1119 arg->valid &= ~FATTR_FH;
1120 memset(&fi_store, 0, sizeof(fi_store));
1121 fi = &fi_store;
1122 fi->fh = arg->fh;
1123 }
1124 arg->valid &=
1125 FUSE_SET_ATTR_MODE |
1126 FUSE_SET_ATTR_UID |
1127 FUSE_SET_ATTR_GID |
1128 FUSE_SET_ATTR_SIZE |
1129 FUSE_SET_ATTR_ATIME |
1130 FUSE_SET_ATTR_MTIME |
1131 FUSE_SET_ATTR_ATIME_NOW |
1132 FUSE_SET_ATTR_MTIME_NOW |
1133 FUSE_SET_ATTR_CTIME;
1134
1135 req->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
1136 } else
1137 fuse_reply_err(req, ENOSYS);
1138 }
1139
1140 static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1141 {
1142 struct fuse_access_in *arg = (struct fuse_access_in *) inarg;
1143
1144 if (req->se->op.access)
1145 req->se->op.access(req, nodeid, arg->mask);
1146 else
1147 fuse_reply_err(req, ENOSYS);
1148 }
1149
1150 static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1151 {
1152 (void) inarg;
1153
1154 if (req->se->op.readlink)
1155 req->se->op.readlink(req, nodeid);
1156 else
1157 fuse_reply_err(req, ENOSYS);
1158 }
1159
1160 static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1161 {
1162 struct fuse_mknod_in *arg = (struct fuse_mknod_in *) inarg;
1163 char *name = PARAM(arg);
1164
1165 if (req->se->conn.proto_minor >= 12)
1166 req->ctx.umask = arg->umask;
1167 else
1168 name = (char *) inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
1169
1170 if (req->se->op.mknod)
1171 req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
1172 else
1173 fuse_reply_err(req, ENOSYS);
1174 }
1175
1176 static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1177 {
1178 struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inarg;
1179
1180 if (req->se->conn.proto_minor >= 12)
1181 req->ctx.umask = arg->umask;
1182
1183 if (req->se->op.mkdir)
1184 req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
1185 else
1186 fuse_reply_err(req, ENOSYS);
1187 }
1188
1189 static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1190 {
1191 char *name = (char *) inarg;
1192
1193 if (req->se->op.unlink)
1194 req->se->op.unlink(req, nodeid, name);
1195 else
1196 fuse_reply_err(req, ENOSYS);
1197 }
1198
1199 static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1200 {
1201 char *name = (char *) inarg;
1202
1203 if (req->se->op.rmdir)
1204 req->se->op.rmdir(req, nodeid, name);
1205 else
1206 fuse_reply_err(req, ENOSYS);
1207 }
1208
1209 static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1210 {
1211 char *name = (char *) inarg;
1212 char *linkname = ((char *) inarg) + strlen((char *) inarg) + 1;
1213
1214 if (req->se->op.symlink)
1215 req->se->op.symlink(req, linkname, nodeid, name);
1216 else
1217 fuse_reply_err(req, ENOSYS);
1218 }
1219
1220 static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1221 {
1222 struct fuse_rename_in *arg = (struct fuse_rename_in *) inarg;
1223 char *oldname = PARAM(arg);
1224 char *newname = oldname + strlen(oldname) + 1;
1225
1226 if (req->se->op.rename)
1227 req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
1228 0);
1229 else
1230 fuse_reply_err(req, ENOSYS);
1231 }
1232
1233 static void do_rename2(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1234 {
1235 struct fuse_rename2_in *arg = (struct fuse_rename2_in *) inarg;
1236 char *oldname = PARAM(arg);
1237 char *newname = oldname + strlen(oldname) + 1;
1238
1239 if (req->se->op.rename)
1240 req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
1241 arg->flags);
1242 else
1243 fuse_reply_err(req, ENOSYS);
1244 }
1245
1246 static void do_link(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1247 {
1248 struct fuse_link_in *arg = (struct fuse_link_in *) inarg;
1249
1250 if (req->se->op.link)
1251 req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
1252 else
1253 fuse_reply_err(req, ENOSYS);
1254 }
1255
1256 static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1257 {
1258 struct fuse_create_in *arg = (struct fuse_create_in *) inarg;
1259
1260 if (req->se->op.create) {
1261 struct fuse_file_info fi;
1262 char *name = PARAM(arg);
1263
1264 memset(&fi, 0, sizeof(fi));
1265 fi.flags = arg->flags;
1266
1267 if (req->se->conn.proto_minor >= 12)
1268 req->ctx.umask = arg->umask;
1269 else
1270 name = (char *) inarg + sizeof(struct fuse_open_in);
1271
1272 req->se->op.create(req, nodeid, name, arg->mode, &fi);
1273 } else
1274 fuse_reply_err(req, ENOSYS);
1275 }
1276
1277 static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1278 {
1279 struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
1280 struct fuse_file_info fi;
1281
1282 memset(&fi, 0, sizeof(fi));
1283 fi.flags = arg->flags;
1284
1285 if (req->se->op.open)
1286 req->se->op.open(req, nodeid, &fi);
1287 else
1288 fuse_reply_open(req, &fi);
1289 }
1290
1291 static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1292 {
1293 struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
1294
1295 if (req->se->op.read) {
1296 struct fuse_file_info fi;
1297
1298 memset(&fi, 0, sizeof(fi));
1299 fi.fh = arg->fh;
1300 if (req->se->conn.proto_minor >= 9) {
1301 fi.lock_owner = arg->lock_owner;
1302 fi.flags = arg->flags;
1303 }
1304 req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
1305 } else
1306 fuse_reply_err(req, ENOSYS);
1307 }
1308
1309 static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1310 {
1311 struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
1312 struct fuse_file_info fi;
1313 char *param;
1314
1315 memset(&fi, 0, sizeof(fi));
1316 fi.fh = arg->fh;
1317 fi.writepage = (arg->write_flags & 1) != 0;
1318
1319 if (req->se->conn.proto_minor < 9) {
1320 param = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
1321 } else {
1322 fi.lock_owner = arg->lock_owner;
1323 fi.flags = arg->flags;
1324 param = PARAM(arg);
1325 }
1326
1327 if (req->se->op.write)
1328 req->se->op.write(req, nodeid, param, arg->size,
1329 arg->offset, &fi);
1330 else
1331 fuse_reply_err(req, ENOSYS);
1332 }
1333
1334 static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
1335 const struct fuse_buf *ibuf)
1336 {
1337 struct fuse_session *se = req->se;
1338 struct fuse_bufvec bufv = {
1339 .buf[0] = *ibuf,
1340 .count = 1,
1341 };
1342 struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
1343 struct fuse_file_info fi;
1344
1345 memset(&fi, 0, sizeof(fi));
1346 fi.fh = arg->fh;
1347 fi.writepage = arg->write_flags & 1;
1348
1349 if (se->conn.proto_minor < 9) {
1350 bufv.buf[0].mem = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
1351 bufv.buf[0].size -= sizeof(struct fuse_in_header) +
1352 FUSE_COMPAT_WRITE_IN_SIZE;
1353 assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
1354 } else {
1355 fi.lock_owner = arg->lock_owner;
1356 fi.flags = arg->flags;
1357 if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
1358 bufv.buf[0].mem = PARAM(arg);
1359
1360 bufv.buf[0].size -= sizeof(struct fuse_in_header) +
1361 sizeof(struct fuse_write_in);
1362 }
1363 if (bufv.buf[0].size < arg->size) {
1364 fprintf(stderr, "fuse: do_write_buf: buffer size too small\n");
1365 fuse_reply_err(req, EIO);
1366 goto out;
1367 }
1368 bufv.buf[0].size = arg->size;
1369
1370 se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
1371
1372 out:
1373 /* Need to reset the pipe if ->write_buf() didn't consume all data */
1374 if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
1375 fuse_ll_clear_pipe(se);
1376 }
1377
1378 static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1379 {
1380 struct fuse_flush_in *arg = (struct fuse_flush_in *) inarg;
1381 struct fuse_file_info fi;
1382
1383 memset(&fi, 0, sizeof(fi));
1384 fi.fh = arg->fh;
1385 fi.flush = 1;
1386 if (req->se->conn.proto_minor >= 7)
1387 fi.lock_owner = arg->lock_owner;
1388
1389 if (req->se->op.flush)
1390 req->se->op.flush(req, nodeid, &fi);
1391 else
1392 fuse_reply_err(req, ENOSYS);
1393 }
1394
1395 static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1396 {
1397 struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
1398 struct fuse_file_info fi;
1399
1400 memset(&fi, 0, sizeof(fi));
1401 fi.flags = arg->flags;
1402 fi.fh = arg->fh;
1403 if (req->se->conn.proto_minor >= 8) {
1404 fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
1405 fi.lock_owner = arg->lock_owner;
1406 }
1407 if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
1408 fi.flock_release = 1;
1409 fi.lock_owner = arg->lock_owner;
1410 }
1411
1412 if (req->se->op.release)
1413 req->se->op.release(req, nodeid, &fi);
1414 else
1415 fuse_reply_err(req, 0);
1416 }
1417
1418 static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1419 {
1420 struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
1421 struct fuse_file_info fi;
1422
1423 memset(&fi, 0, sizeof(fi));
1424 fi.fh = arg->fh;
1425
1426 if (req->se->op.fsync)
1427 req->se->op.fsync(req, nodeid, arg->fsync_flags & 1, &fi);
1428 else
1429 fuse_reply_err(req, ENOSYS);
1430 }
1431
1432 static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1433 {
1434 struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
1435 struct fuse_file_info fi;
1436
1437 memset(&fi, 0, sizeof(fi));
1438 fi.flags = arg->flags;
1439
1440 if (req->se->op.opendir)
1441 req->se->op.opendir(req, nodeid, &fi);
1442 else
1443 fuse_reply_open(req, &fi);
1444 }
1445
1446 static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1447 {
1448 struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
1449 struct fuse_file_info fi;
1450
1451 memset(&fi, 0, sizeof(fi));
1452 fi.fh = arg->fh;
1453
1454 if (req->se->op.readdir)
1455 req->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
1456 else
1457 fuse_reply_err(req, ENOSYS);
1458 }
1459
1460 static void do_readdirplus(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1461 {
1462 struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
1463 struct fuse_file_info fi;
1464
1465 memset(&fi, 0, sizeof(fi));
1466 fi.fh = arg->fh;
1467
1468 if (req->se->op.readdirplus)
1469 req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
1470 else
1471 fuse_reply_err(req, ENOSYS);
1472 }
1473
1474 static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1475 {
1476 struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
1477 struct fuse_file_info fi;
1478
1479 memset(&fi, 0, sizeof(fi));
1480 fi.flags = arg->flags;
1481 fi.fh = arg->fh;
1482
1483 if (req->se->op.releasedir)
1484 req->se->op.releasedir(req, nodeid, &fi);
1485 else
1486 fuse_reply_err(req, 0);
1487 }
1488
1489 static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1490 {
1491 struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
1492 struct fuse_file_info fi;
1493
1494 memset(&fi, 0, sizeof(fi));
1495 fi.fh = arg->fh;
1496
1497 if (req->se->op.fsyncdir)
1498 req->se->op.fsyncdir(req, nodeid, arg->fsync_flags & 1, &fi);
1499 else
1500 fuse_reply_err(req, ENOSYS);
1501 }
1502
1503 static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1504 {
1505 (void) nodeid;
1506 (void) inarg;
1507
1508 if (req->se->op.statfs)
1509 req->se->op.statfs(req, nodeid);
1510 else {
1511 struct statvfs buf = {
1512 .f_namemax = 255,
1513 .f_bsize = 512,
1514 };
1515 fuse_reply_statfs(req, &buf);
1516 }
1517 }
1518
1519 static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1520 {
1521 struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg;
1522 char *name = PARAM(arg);
1523 char *value = name + strlen(name) + 1;
1524
1525 if (req->se->op.setxattr)
1526 req->se->op.setxattr(req, nodeid, name, value, arg->size,
1527 arg->flags);
1528 else
1529 fuse_reply_err(req, ENOSYS);
1530 }
1531
1532 static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1533 {
1534 struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
1535
1536 if (req->se->op.getxattr)
1537 req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
1538 else
1539 fuse_reply_err(req, ENOSYS);
1540 }
1541
1542 static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1543 {
1544 struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
1545
1546 if (req->se->op.listxattr)
1547 req->se->op.listxattr(req, nodeid, arg->size);
1548 else
1549 fuse_reply_err(req, ENOSYS);
1550 }
1551
1552 static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1553 {
1554 char *name = (char *) inarg;
1555
1556 if (req->se->op.removexattr)
1557 req->se->op.removexattr(req, nodeid, name);
1558 else
1559 fuse_reply_err(req, ENOSYS);
1560 }
1561
1562 static void convert_fuse_file_lock(struct fuse_file_lock *fl,
1563 struct flock *flock)
1564 {
1565 memset(flock, 0, sizeof(struct flock));
1566 flock->l_type = fl->type;
1567 flock->l_whence = SEEK_SET;
1568 flock->l_start = fl->start;
1569 if (fl->end == OFFSET_MAX)
1570 flock->l_len = 0;
1571 else
1572 flock->l_len = fl->end - fl->start + 1;
1573 flock->l_pid = fl->pid;
1574 }
1575
1576 static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1577 {
1578 struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
1579 struct fuse_file_info fi;
1580 struct flock flock;
1581
1582 memset(&fi, 0, sizeof(fi));
1583 fi.fh = arg->fh;
1584 fi.lock_owner = arg->owner;
1585
1586 convert_fuse_file_lock(&arg->lk, &flock);
1587 if (req->se->op.getlk)
1588 req->se->op.getlk(req, nodeid, &fi, &flock);
1589 else
1590 fuse_reply_err(req, ENOSYS);
1591 }
1592
1593 static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
1594 const void *inarg, int sleep)
1595 {
1596 struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
1597 struct fuse_file_info fi;
1598 struct flock flock;
1599
1600 memset(&fi, 0, sizeof(fi));
1601 fi.fh = arg->fh;
1602 fi.lock_owner = arg->owner;
1603
1604 if (arg->lk_flags & FUSE_LK_FLOCK) {
1605 int op = 0;
1606
1607 switch (arg->lk.type) {
1608 case F_RDLCK:
1609 op = LOCK_SH;
1610 break;
1611 case F_WRLCK:
1612 op = LOCK_EX;
1613 break;
1614 case F_UNLCK:
1615 op = LOCK_UN;
1616 break;
1617 }
1618 if (!sleep)
1619 op |= LOCK_NB;
1620
1621 if (req->se->op.flock)
1622 req->se->op.flock(req, nodeid, &fi, op);
1623 else
1624 fuse_reply_err(req, ENOSYS);
1625 } else {
1626 convert_fuse_file_lock(&arg->lk, &flock);
1627 if (req->se->op.setlk)
1628 req->se->op.setlk(req, nodeid, &fi, &flock, sleep);
1629 else
1630 fuse_reply_err(req, ENOSYS);
1631 }
1632 }
1633
1634 static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1635 {
1636 do_setlk_common(req, nodeid, inarg, 0);
1637 }
1638
1639 static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1640 {
1641 do_setlk_common(req, nodeid, inarg, 1);
1642 }
1643
1644 static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
1645 {
1646 struct fuse_req *curr;
1647
1648 for (curr = se->list.next; curr != &se->list; curr = curr->next) {
1649 if (curr->unique == req->u.i.unique) {
1650 fuse_interrupt_func_t func;
1651 void *data;
1652
1653 curr->ctr++;
1654 pthread_mutex_unlock(&se->lock);
1655
1656 /* Ugh, ugly locking */
1657 pthread_mutex_lock(&curr->lock);
1658 pthread_mutex_lock(&se->lock);
1659 curr->interrupted = 1;
1660 func = curr->u.ni.func;
1661 data = curr->u.ni.data;
1662 pthread_mutex_unlock(&se->lock);
1663 if (func)
1664 func(curr, data);
1665 pthread_mutex_unlock(&curr->lock);
1666
1667 pthread_mutex_lock(&se->lock);
1668 curr->ctr--;
1669 if (!curr->ctr)
1670 destroy_req(curr);
1671
1672 return 1;
1673 }
1674 }
1675 for (curr = se->interrupts.next; curr != &se->interrupts;
1676 curr = curr->next) {
1677 if (curr->u.i.unique == req->u.i.unique)
1678 return 1;
1679 }
1680 return 0;
1681 }
1682
1683 static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1684 {
1685 struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *) inarg;
1686 struct fuse_session *se = req->se;
1687
1688 (void) nodeid;
1689 if (se->debug)
1690 fprintf(stderr, "INTERRUPT: %llu\n",
1691 (unsigned long long) arg->unique);
1692
1693 req->u.i.unique = arg->unique;
1694
1695 pthread_mutex_lock(&se->lock);
1696 if (find_interrupted(se, req))
1697 destroy_req(req);
1698 else
1699 list_add_req(req, &se->interrupts);
1700 pthread_mutex_unlock(&se->lock);
1701 }
1702
1703 static struct fuse_req *check_interrupt(struct fuse_session *se,
1704 struct fuse_req *req)
1705 {
1706 struct fuse_req *curr;
1707
1708 for (curr = se->interrupts.next; curr != &se->interrupts;
1709 curr = curr->next) {
1710 if (curr->u.i.unique == req->unique) {
1711 req->interrupted = 1;
1712 list_del_req(curr);
1713 free(curr);
1714 return NULL;
1715 }
1716 }
1717 curr = se->interrupts.next;
1718 if (curr != &se->interrupts) {
1719 list_del_req(curr);
1720 list_init_req(curr);
1721 return curr;
1722 } else
1723 return NULL;
1724 }
1725
1726 static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1727 {
1728 struct fuse_bmap_in *arg = (struct fuse_bmap_in *) inarg;
1729
1730 if (req->se->op.bmap)
1731 req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
1732 else
1733 fuse_reply_err(req, ENOSYS);
1734 }
1735
1736 static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1737 {
1738 struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *) inarg;
1739 unsigned int flags = arg->flags;
1740 void *in_buf = arg->in_size ? PARAM(arg) : NULL;
1741 struct fuse_file_info fi;
1742
1743 if (flags & FUSE_IOCTL_DIR &&
1744 !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
1745 fuse_reply_err(req, ENOTTY);
1746 return;
1747 }
1748
1749 memset(&fi, 0, sizeof(fi));
1750 fi.fh = arg->fh;
1751
1752 if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
1753 !(flags & FUSE_IOCTL_32BIT)) {
1754 req->ioctl_64bit = 1;
1755 }
1756
1757 if (req->se->op.ioctl)
1758 req->se->op.ioctl(req, nodeid, arg->cmd,
1759 (void *)(uintptr_t)arg->arg, &fi, flags,
1760 in_buf, arg->in_size, arg->out_size);
1761 else
1762 fuse_reply_err(req, ENOSYS);
1763 }
1764
1765 void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
1766 {
1767 free(ph);
1768 }
1769
1770 static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1771 {
1772 struct fuse_poll_in *arg = (struct fuse_poll_in *) inarg;
1773 struct fuse_file_info fi;
1774
1775 memset(&fi, 0, sizeof(fi));
1776 fi.fh = arg->fh;
1777 fi.poll_events = arg->events;
1778
1779 if (req->se->op.poll) {
1780 struct fuse_pollhandle *ph = NULL;
1781
1782 if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
1783 ph = malloc(sizeof(struct fuse_pollhandle));
1784 if (ph == NULL) {
1785 fuse_reply_err(req, ENOMEM);
1786 return;
1787 }
1788 ph->kh = arg->kh;
1789 ph->se = req->se;
1790 }
1791
1792 req->se->op.poll(req, nodeid, &fi, ph);
1793 } else {
1794 fuse_reply_err(req, ENOSYS);
1795 }
1796 }
1797
1798 static void do_fallocate(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1799 {
1800 struct fuse_fallocate_in *arg = (struct fuse_fallocate_in *) inarg;
1801 struct fuse_file_info fi;
1802
1803 memset(&fi, 0, sizeof(fi));
1804 fi.fh = arg->fh;
1805
1806 if (req->se->op.fallocate)
1807 req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);
1808 else
1809 fuse_reply_err(req, ENOSYS);
1810 }
1811
1812 static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1813 {
1814 struct fuse_init_in *arg = (struct fuse_init_in *) inarg;
1815 struct fuse_init_out outarg;
1816 struct fuse_session *se = req->se;
1817 size_t bufsize = se->bufsize;
1818 size_t outargsize = sizeof(outarg);
1819
1820 (void) nodeid;
1821 if (se->debug) {
1822 fprintf(stderr, "INIT: %u.%u\n", arg->major, arg->minor);
1823 if (arg->major == 7 && arg->minor >= 6) {
1824 fprintf(stderr, "flags=0x%08x\n", arg->flags);
1825 fprintf(stderr, "max_readahead=0x%08x\n",
1826 arg->max_readahead);
1827 }
1828 }
1829 se->conn.proto_major = arg->major;
1830 se->conn.proto_minor = arg->minor;
1831 se->conn.capable = 0;
1832 se->conn.want = 0;
1833
1834 memset(&outarg, 0, sizeof(outarg));
1835 outarg.major = FUSE_KERNEL_VERSION;
1836 outarg.minor = FUSE_KERNEL_MINOR_VERSION;
1837
1838 if (arg->major < 7) {
1839 fprintf(stderr, "fuse: unsupported protocol version: %u.%u\n",
1840 arg->major, arg->minor);
1841 fuse_reply_err(req, EPROTO);
1842 return;
1843 }
1844
1845 if (arg->major > 7) {
1846 /* Wait for a second INIT request with a 7.X version */
1847 send_reply_ok(req, &outarg, sizeof(outarg));
1848 return;
1849 }
1850
1851 if (arg->minor >= 6) {
1852 if (arg->max_readahead < se->conn.max_readahead)
1853 se->conn.max_readahead = arg->max_readahead;
1854 if (arg->flags & FUSE_ASYNC_READ)
1855 se->conn.capable |= FUSE_CAP_ASYNC_READ;
1856 if (arg->flags & FUSE_POSIX_LOCKS)
1857 se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
1858 if (arg->flags & FUSE_ATOMIC_O_TRUNC)
1859 se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
1860 if (arg->flags & FUSE_EXPORT_SUPPORT)
1861 se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
1862 if (arg->flags & FUSE_DONT_MASK)
1863 se->conn.capable |= FUSE_CAP_DONT_MASK;
1864 if (arg->flags & FUSE_FLOCK_LOCKS)
1865 se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
1866 if (arg->flags & FUSE_AUTO_INVAL_DATA)
1867 se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
1868 if (arg->flags & FUSE_DO_READDIRPLUS)
1869 se->conn.capable |= FUSE_CAP_READDIRPLUS;
1870 if (arg->flags & FUSE_READDIRPLUS_AUTO)
1871 se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
1872 if (arg->flags & FUSE_ASYNC_DIO)
1873 se->conn.capable |= FUSE_CAP_ASYNC_DIO;
1874 if (arg->flags & FUSE_WRITEBACK_CACHE)
1875 se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
1876 if (arg->flags & FUSE_NO_OPEN_SUPPORT)
1877 se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
1878 if (arg->flags & FUSE_PARALLEL_DIROPS)
1879 se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
1880 if (arg->flags & FUSE_POSIX_ACL)
1881 se->conn.capable |= FUSE_CAP_POSIX_ACL;
1882 if (arg->flags & FUSE_HANDLE_KILLPRIV)
1883 se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
1884 } else {
1885 se->conn.max_readahead = 0;
1886 }
1887
1888 if (se->conn.proto_minor >= 14) {
1889 #ifdef HAVE_SPLICE
1890 #ifdef HAVE_VMSPLICE
1891 se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
1892 #endif
1893 se->conn.capable |= FUSE_CAP_SPLICE_READ;
1894 #endif
1895 }
1896 if (se->conn.proto_minor >= 18)
1897 se->conn.capable |= FUSE_CAP_IOCTL_DIR;
1898
1899 /* Default settings for modern filesystems.
1900 *
1901 * Most of these capabilities were disabled by default in
1902 * libfuse2 for backwards compatibility reasons. In libfuse3,
1903 * we can finally enable them by default (as long as they're
1904 * supported by the kernel).
1905 */
1906 #define LL_SET_DEFAULT(cond, cap) \
1907 if ((cond) && (se->conn.capable & (cap))) \
1908 se->conn.want |= (cap)
1909 LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);
1910 LL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);
1911 LL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);
1912 LL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);
1913 LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);
1914 LL_SET_DEFAULT(1, FUSE_CAP_IOCTL_DIR);
1915 LL_SET_DEFAULT(1, FUSE_CAP_ATOMIC_O_TRUNC);
1916 LL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);
1917 LL_SET_DEFAULT(se->op.getlk && se->op.setlk,
1918 FUSE_CAP_POSIX_LOCKS);
1919 LL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);
1920 LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);
1921 LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS_AUTO);
1922 se->conn.time_gran = 1;
1923
1924 if (bufsize < FUSE_MIN_READ_BUFFER) {
1925 fprintf(stderr, "fuse: warning: buffer size too small: %zu\n",
1926 bufsize);
1927 bufsize = FUSE_MIN_READ_BUFFER;
1928 }
1929
1930 bufsize -= 4096;
1931 if (bufsize < se->conn.max_write)
1932 se->conn.max_write = bufsize;
1933
1934 se->got_init = 1;
1935 if (se->op.init)
1936 se->op.init(se->userdata, &se->conn);
1937
1938 if (se->conn.want & (~se->conn.capable)) {
1939 fprintf(stderr, "fuse: error: filesystem requested capabilities "
1940 "0x%x that are not supported by kernel, aborting.\n",
1941 se->conn.want & (~se->conn.capable));
1942 fuse_reply_err(req, EPROTO);
1943 se->error = -EPROTO;
1944 fuse_session_exit(se);
1945 return;
1946 }
1947
1948 unsigned max_read_mo = get_max_read(se->mo);
1949 if (se->conn.max_read != max_read_mo) {
1950 fprintf(stderr, "fuse: error: init() and fuse_session_new() "
1951 "requested different maximum read size (%u vs %u)\n",
1952 se->conn.max_read, max_read_mo);
1953 fuse_reply_err(req, EPROTO);
1954 se->error = -EPROTO;
1955 fuse_session_exit(se);
1956 return;
1957 }
1958
1959 /* Always enable big writes, this is superseded
1960 by the max_write option */
1961 outarg.flags |= FUSE_BIG_WRITES;
1962
1963 if (se->conn.want & FUSE_CAP_ASYNC_READ)
1964 outarg.flags |= FUSE_ASYNC_READ;
1965 if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
1966 outarg.flags |= FUSE_POSIX_LOCKS;
1967 if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
1968 outarg.flags |= FUSE_ATOMIC_O_TRUNC;
1969 if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
1970 outarg.flags |= FUSE_EXPORT_SUPPORT;
1971 if (se->conn.want & FUSE_CAP_DONT_MASK)
1972 outarg.flags |= FUSE_DONT_MASK;
1973 if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
1974 outarg.flags |= FUSE_FLOCK_LOCKS;
1975 if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
1976 outarg.flags |= FUSE_AUTO_INVAL_DATA;
1977 if (se->conn.want & FUSE_CAP_READDIRPLUS)
1978 outarg.flags |= FUSE_DO_READDIRPLUS;
1979 if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
1980 outarg.flags |= FUSE_READDIRPLUS_AUTO;
1981 if (se->conn.want & FUSE_CAP_ASYNC_DIO)
1982 outarg.flags |= FUSE_ASYNC_DIO;
1983 if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
1984 outarg.flags |= FUSE_WRITEBACK_CACHE;
1985 if (se->conn.want & FUSE_CAP_POSIX_ACL)
1986 outarg.flags |= FUSE_POSIX_ACL;
1987 outarg.max_readahead = se->conn.max_readahead;
1988 outarg.max_write = se->conn.max_write;
1989 if (se->conn.proto_minor >= 13) {
1990 if (se->conn.max_background >= (1 << 16))
1991 se->conn.max_background = (1 << 16) - 1;
1992 if (se->conn.congestion_threshold > se->conn.max_background)
1993 se->conn.congestion_threshold = se->conn.max_background;
1994 if (!se->conn.congestion_threshold) {
1995 se->conn.congestion_threshold =
1996 se->conn.max_background * 3 / 4;
1997 }
1998
1999 outarg.max_background = se->conn.max_background;
2000 outarg.congestion_threshold = se->conn.congestion_threshold;
2001 }
2002 if (se->conn.proto_minor >= 23)
2003 outarg.time_gran = se->conn.time_gran;
2004
2005 if (se->debug) {
2006 fprintf(stderr, " INIT: %u.%u\n", outarg.major, outarg.minor);
2007 fprintf(stderr, " flags=0x%08x\n", outarg.flags);
2008 fprintf(stderr, " max_readahead=0x%08x\n",
2009 outarg.max_readahead);
2010 fprintf(stderr, " max_write=0x%08x\n", outarg.max_write);
2011 fprintf(stderr, " max_background=%i\n",
2012 outarg.max_background);
2013 fprintf(stderr, " congestion_threshold=%i\n",
2014 outarg.congestion_threshold);
2015 fprintf(stderr, " time_gran=%u\n",
2016 outarg.time_gran);
2017 }
2018 if (arg->minor < 5)
2019 outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
2020 else if (arg->minor < 23)
2021 outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
2022
2023 send_reply_ok(req, &outarg, outargsize);
2024 }
2025
2026 static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
2027 {
2028 struct fuse_session *se = req->se;
2029
2030 (void) nodeid;
2031 (void) inarg;
2032
2033 se->got_destroy = 1;
2034 if (se->op.destroy)
2035 se->op.destroy(se->userdata);
2036
2037 send_reply_ok(req, NULL, 0);
2038 }
2039
2040 static void list_del_nreq(struct fuse_notify_req *nreq)
2041 {
2042 struct fuse_notify_req *prev = nreq->prev;
2043 struct fuse_notify_req *next = nreq->next;
2044 prev->next = next;
2045 next->prev = prev;
2046 }
2047
2048 static void list_add_nreq(struct fuse_notify_req *nreq,
2049 struct fuse_notify_req *next)
2050 {
2051 struct fuse_notify_req *prev = next->prev;
2052 nreq->next = next;
2053 nreq->prev = prev;
2054 prev->next = nreq;
2055 next->prev = nreq;
2056 }
2057
2058 static void list_init_nreq(struct fuse_notify_req *nreq)
2059 {
2060 nreq->next = nreq;
2061 nreq->prev = nreq;
2062 }
2063
2064 static void do_notify_reply(fuse_req_t req, fuse_ino_t nodeid,
2065 const void *inarg, const struct fuse_buf *buf)
2066 {
2067 struct fuse_session *se = req->se;
2068 struct fuse_notify_req *nreq;
2069 struct fuse_notify_req *head;
2070
2071 pthread_mutex_lock(&se->lock);
2072 head = &se->notify_list;
2073 for (nreq = head->next; nreq != head; nreq = nreq->next) {
2074 if (nreq->unique == req->unique) {
2075 list_del_nreq(nreq);
2076 break;
2077 }
2078 }
2079 pthread_mutex_unlock(&se->lock);
2080
2081 if (nreq != head)
2082 nreq->reply(nreq, req, nodeid, inarg, buf);
2083 }
2084
2085 static int send_notify_iov(struct fuse_session *se, int notify_code,
2086 struct iovec *iov, int count)
2087 {
2088 struct fuse_out_header out;
2089
2090 if (!se->got_init)
2091 return -ENOTCONN;
2092
2093 out.unique = 0;
2094 out.error = notify_code;
2095 iov[0].iov_base = &out;
2096 iov[0].iov_len = sizeof(struct fuse_out_header);
2097
2098 return fuse_send_msg(se, NULL, iov, count);
2099 }
2100
2101 int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
2102 {
2103 if (ph != NULL) {
2104 struct fuse_notify_poll_wakeup_out outarg;
2105 struct iovec iov[2];
2106
2107 outarg.kh = ph->kh;
2108
2109 iov[1].iov_base = &outarg;
2110 iov[1].iov_len = sizeof(outarg);
2111
2112 return send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);
2113 } else {
2114 return 0;
2115 }
2116 }
2117
2118 int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
2119 off_t off, off_t len)
2120 {
2121 struct fuse_notify_inval_inode_out outarg;
2122 struct iovec iov[2];
2123
2124 if (!se)
2125 return -EINVAL;
2126
2127 if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
2128 return -ENOSYS;
2129
2130 outarg.ino = ino;
2131 outarg.off = off;
2132 outarg.len = len;
2133
2134 iov[1].iov_base = &outarg;
2135 iov[1].iov_len = sizeof(outarg);
2136
2137 return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
2138 }
2139
2140 int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
2141 const char *name, size_t namelen)
2142 {
2143 struct fuse_notify_inval_entry_out outarg;
2144 struct iovec iov[3];
2145
2146 if (!se)
2147 return -EINVAL;
2148
2149 if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
2150 return -ENOSYS;
2151
2152 outarg.parent = parent;
2153 outarg.namelen = namelen;
2154 outarg.padding = 0;
2155
2156 iov[1].iov_base = &outarg;
2157 iov[1].iov_len = sizeof(outarg);
2158 iov[2].iov_base = (void *)name;
2159 iov[2].iov_len = namelen + 1;
2160
2161 return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
2162 }
2163
2164 int fuse_lowlevel_notify_delete(struct fuse_session *se,
2165 fuse_ino_t parent, fuse_ino_t child,
2166 const char *name, size_t namelen)
2167 {
2168 struct fuse_notify_delete_out outarg;
2169 struct iovec iov[3];
2170
2171 if (!se)
2172 return -EINVAL;
2173
2174 if (se->conn.proto_major < 6 || se->conn.proto_minor < 18)
2175 return -ENOSYS;
2176
2177 outarg.parent = parent;
2178 outarg.child = child;
2179 outarg.namelen = namelen;
2180 outarg.padding = 0;
2181
2182 iov[1].iov_base = &outarg;
2183 iov[1].iov_len = sizeof(outarg);
2184 iov[2].iov_base = (void *)name;
2185 iov[2].iov_len = namelen + 1;
2186
2187 return send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);
2188 }
2189
2190 int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
2191 off_t offset, struct fuse_bufvec *bufv,
2192 enum fuse_buf_copy_flags flags)
2193 {
2194 struct fuse_out_header out;
2195 struct fuse_notify_store_out outarg;
2196 struct iovec iov[3];
2197 size_t size = fuse_buf_size(bufv);
2198 int res;
2199
2200 if (!se)
2201 return -EINVAL;
2202
2203 if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
2204 return -ENOSYS;
2205
2206 out.unique = 0;
2207 out.error = FUSE_NOTIFY_STORE;
2208
2209 outarg.nodeid = ino;
2210 outarg.offset = offset;
2211 outarg.size = size;
2212 outarg.padding = 0;
2213
2214 iov[0].iov_base = &out;
2215 iov[0].iov_len = sizeof(out);
2216 iov[1].iov_base = &outarg;
2217 iov[1].iov_len = sizeof(outarg);
2218
2219 res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
2220 if (res > 0)
2221 res = -res;
2222
2223 return res;
2224 }
2225
2226 struct fuse_retrieve_req {
2227 struct fuse_notify_req nreq;
2228 void *cookie;
2229 };
2230
2231 static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
2232 fuse_req_t req, fuse_ino_t ino,
2233 const void *inarg,
2234 const struct fuse_buf *ibuf)
2235 {
2236 struct fuse_session *se = req->se;
2237 struct fuse_retrieve_req *rreq =
2238 container_of(nreq, struct fuse_retrieve_req, nreq);
2239 const struct fuse_notify_retrieve_in *arg = inarg;
2240 struct fuse_bufvec bufv = {
2241 .buf[0] = *ibuf,
2242 .count = 1,
2243 };
2244
2245 if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
2246 bufv.buf[0].mem = PARAM(arg);
2247
2248 bufv.buf[0].size -= sizeof(struct fuse_in_header) +
2249 sizeof(struct fuse_notify_retrieve_in);
2250
2251 if (bufv.buf[0].size < arg->size) {
2252 fprintf(stderr, "fuse: retrieve reply: buffer size too small\n");
2253 fuse_reply_none(req);
2254 goto out;
2255 }
2256 bufv.buf[0].size = arg->size;
2257
2258 if (se->op.retrieve_reply) {
2259 se->op.retrieve_reply(req, rreq->cookie, ino,
2260 arg->offset, &bufv);
2261 } else {
2262 fuse_reply_none(req);
2263 }
2264 out:
2265 free(rreq);
2266 if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
2267 fuse_ll_clear_pipe(se);
2268 }
2269
2270 int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
2271 size_t size, off_t offset, void *cookie)
2272 {
2273 struct fuse_notify_retrieve_out outarg;
2274 struct iovec iov[2];
2275 struct fuse_retrieve_req *rreq;
2276 int err;
2277
2278 if (!se)
2279 return -EINVAL;
2280
2281 if (se->conn.proto_major < 6 || se->conn.proto_minor < 15)
2282 return -ENOSYS;
2283
2284 rreq = malloc(sizeof(*rreq));
2285 if (rreq == NULL)
2286 return -ENOMEM;
2287
2288 pthread_mutex_lock(&se->lock);
2289 rreq->cookie = cookie;
2290 rreq->nreq.unique = se->notify_ctr++;
2291 rreq->nreq.reply = fuse_ll_retrieve_reply;
2292 list_add_nreq(&rreq->nreq, &se->notify_list);
2293 pthread_mutex_unlock(&se->lock);
2294
2295 outarg.notify_unique = rreq->nreq.unique;
2296 outarg.nodeid = ino;
2297 outarg.offset = offset;
2298 outarg.size = size;
2299 outarg.padding = 0;
2300
2301 iov[1].iov_base = &outarg;
2302 iov[1].iov_len = sizeof(outarg);
2303
2304 err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
2305 if (err) {
2306 pthread_mutex_lock(&se->lock);
2307 list_del_nreq(&rreq->nreq);
2308 pthread_mutex_unlock(&se->lock);
2309 free(rreq);
2310 }
2311
2312 return err;
2313 }
2314
2315 void *fuse_req_userdata(fuse_req_t req)
2316 {
2317 return req->se->userdata;
2318 }
2319
2320 const struct fuse_ctx *fuse_req_ctx(fuse_req_t req)
2321 {
2322 return &req->ctx;
2323 }
2324
2325 void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
2326 void *data)
2327 {
2328 pthread_mutex_lock(&req->lock);
2329 pthread_mutex_lock(&req->se->lock);
2330 req->u.ni.func = func;
2331 req->u.ni.data = data;
2332 pthread_mutex_unlock(&req->se->lock);
2333 if (req->interrupted && func)
2334 func(req, data);
2335 pthread_mutex_unlock(&req->lock);
2336 }
2337
2338 int fuse_req_interrupted(fuse_req_t req)
2339 {
2340 int interrupted;
2341
2342 pthread_mutex_lock(&req->se->lock);
2343 interrupted = req->interrupted;
2344 pthread_mutex_unlock(&req->se->lock);
2345
2346 return interrupted;
2347 }
2348
2349 static struct {
2350 void (*func)(fuse_req_t, fuse_ino_t, const void *);
2351 const char *name;
2352 } fuse_ll_ops[] = {
2353 [FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
2354 [FUSE_FORGET] = { do_forget, "FORGET" },
2355 [FUSE_GETATTR] = { do_getattr, "GETATTR" },
2356 [FUSE_SETATTR] = { do_setattr, "SETATTR" },
2357 [FUSE_READLINK] = { do_readlink, "READLINK" },
2358 [FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
2359 [FUSE_MKNOD] = { do_mknod, "MKNOD" },
2360 [FUSE_MKDIR] = { do_mkdir, "MKDIR" },
2361 [FUSE_UNLINK] = { do_unlink, "UNLINK" },
2362 [FUSE_RMDIR] = { do_rmdir, "RMDIR" },
2363 [FUSE_RENAME] = { do_rename, "RENAME" },
2364 [FUSE_LINK] = { do_link, "LINK" },
2365 [FUSE_OPEN] = { do_open, "OPEN" },
2366 [FUSE_READ] = { do_read, "READ" },
2367 [FUSE_WRITE] = { do_write, "WRITE" },
2368 [FUSE_STATFS] = { do_statfs, "STATFS" },
2369 [FUSE_RELEASE] = { do_release, "RELEASE" },
2370 [FUSE_FSYNC] = { do_fsync, "FSYNC" },
2371 [FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
2372 [FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
2373 [FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
2374 [FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
2375 [FUSE_FLUSH] = { do_flush, "FLUSH" },
2376 [FUSE_INIT] = { do_init, "INIT" },
2377 [FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
2378 [FUSE_READDIR] = { do_readdir, "READDIR" },
2379 [FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
2380 [FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
2381 [FUSE_GETLK] = { do_getlk, "GETLK" },
2382 [FUSE_SETLK] = { do_setlk, "SETLK" },
2383 [FUSE_SETLKW] = { do_setlkw, "SETLKW" },
2384 [FUSE_ACCESS] = { do_access, "ACCESS" },
2385 [FUSE_CREATE] = { do_create, "CREATE" },
2386 [FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
2387 [FUSE_BMAP] = { do_bmap, "BMAP" },
2388 [FUSE_IOCTL] = { do_ioctl, "IOCTL" },
2389 [FUSE_POLL] = { do_poll, "POLL" },
2390 [FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
2391 [FUSE_DESTROY] = { do_destroy, "DESTROY" },
2392 [FUSE_NOTIFY_REPLY] = { (void *) 1, "NOTIFY_REPLY" },
2393 [FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
2394 [FUSE_READDIRPLUS] = { do_readdirplus, "READDIRPLUS"},
2395 [FUSE_RENAME2] = { do_rename2, "RENAME2" },
2396 [CUSE_INIT] = { cuse_lowlevel_init, "CUSE_INIT" },
2397 };
2398
2399 #define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
2400
2401 static const char *opname(enum fuse_opcode opcode)
2402 {
2403 if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)
2404 return "???";
2405 else
2406 return fuse_ll_ops[opcode].name;
2407 }
2408
2409 static int fuse_ll_copy_from_pipe(struct fuse_bufvec *dst,
2410 struct fuse_bufvec *src)
2411 {
2412 ssize_t res = fuse_buf_copy(dst, src, 0);
2413 if (res < 0) {
2414 fprintf(stderr, "fuse: copy from pipe: %s\n", strerror(-res));
2415 return res;
2416 }
2417 if ((size_t)res < fuse_buf_size(dst)) {
2418 fprintf(stderr, "fuse: copy from pipe: short read\n");
2419 return -1;
2420 }
2421 return 0;
2422 }
2423
2424 void fuse_session_process_buf(struct fuse_session *se,
2425 const struct fuse_buf *buf)
2426 {
2427 fuse_session_process_buf_int(se, buf, NULL);
2428 }
2429
2430 void fuse_session_process_buf_int(struct fuse_session *se,
2431 const struct fuse_buf *buf, struct fuse_chan *ch)
2432 {
2433 const size_t write_header_size = sizeof(struct fuse_in_header) +
2434 sizeof(struct fuse_write_in);
2435 struct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };
2436 struct fuse_bufvec tmpbuf = FUSE_BUFVEC_INIT(write_header_size);
2437 struct fuse_in_header *in;
2438 const void *inarg;
2439 struct fuse_req *req;
2440 void *mbuf = NULL;
2441 int err;
2442 int res;
2443
2444 if (buf->flags & FUSE_BUF_IS_FD) {
2445 if (buf->size < tmpbuf.buf[0].size)
2446 tmpbuf.buf[0].size = buf->size;
2447
2448 mbuf = malloc(tmpbuf.buf[0].size);
2449 if (mbuf == NULL) {
2450 fprintf(stderr, "fuse: failed to allocate header\n");
2451 goto clear_pipe;
2452 }
2453 tmpbuf.buf[0].mem = mbuf;
2454
2455 res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
2456 if (res < 0)
2457 goto clear_pipe;
2458
2459 in = mbuf;
2460 } else {
2461 in = buf->mem;
2462 }
2463
2464 if (se->debug) {
2465 fprintf(stderr,
2466 "unique: %llu, opcode: %s (%i), nodeid: %llu, insize: %zu, pid: %u\n",
2467 (unsigned long long) in->unique,
2468 opname((enum fuse_opcode) in->opcode), in->opcode,
2469 (unsigned long long) in->nodeid, buf->size, in->pid);
2470 }
2471
2472 req = fuse_ll_alloc_req(se);
2473 if (req == NULL) {
2474 struct fuse_out_header out = {
2475 .unique = in->unique,
2476 .error = -ENOMEM,
2477 };
2478 struct iovec iov = {
2479 .iov_base = &out,
2480 .iov_len = sizeof(struct fuse_out_header),
2481 };
2482
2483 fuse_send_msg(se, ch, &iov, 1);
2484 goto clear_pipe;
2485 }
2486
2487 req->unique = in->unique;
2488 req->ctx.uid = in->uid;
2489 req->ctx.gid = in->gid;
2490 req->ctx.pid = in->pid;
2491 req->ch = ch ? fuse_chan_get(ch) : NULL;
2492
2493 err = EIO;
2494 if (!se->got_init) {
2495 enum fuse_opcode expected;
2496
2497 expected = se->cuse_data ? CUSE_INIT : FUSE_INIT;
2498 if (in->opcode != expected)
2499 goto reply_err;
2500 } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)
2501 goto reply_err;
2502
2503 err = EACCES;
2504 /* Implement -o allow_root */
2505 if (se->deny_others && in->uid != se->owner && in->uid != 0 &&
2506 in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
2507 in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
2508 in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
2509 in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR &&
2510 in->opcode != FUSE_NOTIFY_REPLY &&
2511 in->opcode != FUSE_READDIRPLUS)
2512 goto reply_err;
2513
2514 err = ENOSYS;
2515 if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
2516 goto reply_err;
2517 if (in->opcode != FUSE_INTERRUPT) {
2518 struct fuse_req *intr;
2519 pthread_mutex_lock(&se->lock);
2520 intr = check_interrupt(se, req);
2521 list_add_req(req, &se->list);
2522 pthread_mutex_unlock(&se->lock);
2523 if (intr)
2524 fuse_reply_err(intr, EAGAIN);
2525 }
2526
2527 if ((buf->flags & FUSE_BUF_IS_FD) && write_header_size < buf->size &&
2528 (in->opcode != FUSE_WRITE || !se->op.write_buf) &&
2529 in->opcode != FUSE_NOTIFY_REPLY) {
2530 void *newmbuf;
2531
2532 err = ENOMEM;
2533 newmbuf = realloc(mbuf, buf->size);
2534 if (newmbuf == NULL)
2535 goto reply_err;
2536 mbuf = newmbuf;
2537
2538 tmpbuf = FUSE_BUFVEC_INIT(buf->size - write_header_size);
2539 tmpbuf.buf[0].mem = mbuf + write_header_size;
2540
2541 res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
2542 err = -res;
2543 if (res < 0)
2544 goto reply_err;
2545
2546 in = mbuf;
2547 }
2548
2549 inarg = (void *) &in[1];
2550 if (in->opcode == FUSE_WRITE && se->op.write_buf)
2551 do_write_buf(req, in->nodeid, inarg, buf);
2552 else if (in->opcode == FUSE_NOTIFY_REPLY)
2553 do_notify_reply(req, in->nodeid, inarg, buf);
2554 else
2555 fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
2556
2557 out_free:
2558 free(mbuf);
2559 return;
2560
2561 reply_err:
2562 fuse_reply_err(req, err);
2563 clear_pipe:
2564 if (buf->flags & FUSE_BUF_IS_FD)
2565 fuse_ll_clear_pipe(se);
2566 goto out_free;
2567 }
2568
2569 #define LL_OPTION(n,o,v) \
2570 { n, offsetof(struct fuse_session, o), v }
2571
2572 static const struct fuse_opt fuse_ll_opts[] = {
2573 LL_OPTION("debug", debug, 1),
2574 LL_OPTION("-d", debug, 1),
2575 LL_OPTION("--debug", debug, 1),
2576 LL_OPTION("allow_root", deny_others, 1),
2577 FUSE_OPT_END
2578 };
2579
2580 void fuse_lowlevel_version(void)
2581 {
2582 printf("using FUSE kernel interface version %i.%i\n",
2583 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
2584 fuse_mount_version();
2585 }
2586
2587 void fuse_lowlevel_help(void)
2588 {
2589 /* These are not all options, but the ones that are
2590 potentially of interest to an end-user */
2591 printf(
2592 " -o allow_other allow access by all users\n"
2593 " -o allow_root allow access by root\n"
2594 " -o auto_unmount auto unmount on process termination\n");
2595 }
2596
2597 void fuse_session_destroy(struct fuse_session *se)
2598 {
2599 struct fuse_ll_pipe *llp;
2600
2601 if (se->got_init && !se->got_destroy) {
2602 if (se->op.destroy)
2603 se->op.destroy(se->userdata);
2604 }
2605 llp = pthread_getspecific(se->pipe_key);
2606 if (llp != NULL)
2607 fuse_ll_pipe_free(llp);
2608 pthread_key_delete(se->pipe_key);
2609 pthread_mutex_destroy(&se->lock);
2610 free(se->cuse_data);
2611 if (se->fd != -1)
2612 close(se->fd);
2613 destroy_mount_opts(se->mo);
2614 free(se);
2615 }
2616
2617
2618 static void fuse_ll_pipe_destructor(void *data)
2619 {
2620 struct fuse_ll_pipe *llp = data;
2621 fuse_ll_pipe_free(llp);
2622 }
2623
2624 int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf)
2625 {
2626 return fuse_session_receive_buf_int(se, buf, NULL);
2627 }
2628
2629 int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
2630 struct fuse_chan *ch)
2631 {
2632 int err;
2633 ssize_t res;
2634 #ifdef HAVE_SPLICE
2635 size_t bufsize = se->bufsize;
2636 struct fuse_ll_pipe *llp;
2637 struct fuse_buf tmpbuf;
2638
2639 if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
2640 goto fallback;
2641
2642 llp = fuse_ll_get_pipe(se);
2643 if (llp == NULL)
2644 goto fallback;
2645
2646 if (llp->size < bufsize) {
2647 if (llp->can_grow) {
2648 res = fcntl(llp->pipe[0], F_SETPIPE_SZ, bufsize);
2649 if (res == -1) {
2650 llp->can_grow = 0;
2651 goto fallback;
2652 }
2653 llp->size = res;
2654 }
2655 if (llp->size < bufsize)
2656 goto fallback;
2657 }
2658
2659 res = splice(ch ? ch->fd : se->fd,
2660 NULL, llp->pipe[1], NULL, bufsize, 0);
2661 err = errno;
2662
2663 if (fuse_session_exited(se))
2664 return 0;
2665
2666 if (res == -1) {
2667 if (err == ENODEV) {
2668 /* Filesystem was unmounted, or connection was aborted
2669 via /sys/fs/fuse/connections */
2670 fuse_session_exit(se);
2671 return 0;
2672 }
2673 if (err != EINTR && err != EAGAIN)
2674 perror("fuse: splice from device");
2675 return -err;
2676 }
2677
2678 if (res < sizeof(struct fuse_in_header)) {
2679 fprintf(stderr, "short splice from fuse device\n");
2680 return -EIO;
2681 }
2682
2683 tmpbuf = (struct fuse_buf) {
2684 .size = res,
2685 .flags = FUSE_BUF_IS_FD,
2686 .fd = llp->pipe[0],
2687 };
2688
2689 /*
2690 * Don't bother with zero copy for small requests.
2691 * fuse_loop_mt() needs to check for FORGET so this more than
2692 * just an optimization.
2693 */
2694 if (res < sizeof(struct fuse_in_header) +
2695 sizeof(struct fuse_write_in) + pagesize) {
2696 struct fuse_bufvec src = { .buf[0] = tmpbuf, .count = 1 };
2697 struct fuse_bufvec dst = { .count = 1 };
2698
2699 if (!buf->mem) {
2700 buf->mem = malloc(se->bufsize);
2701 if (!buf->mem) {
2702 fprintf(stderr,
2703 "fuse: failed to allocate read buffer\n");
2704 return -ENOMEM;
2705 }
2706 }
2707 buf->size = se->bufsize;
2708 buf->flags = 0;
2709 dst.buf[0] = *buf;
2710
2711 res = fuse_buf_copy(&dst, &src, 0);
2712 if (res < 0) {
2713 fprintf(stderr, "fuse: copy from pipe: %s\n",
2714 strerror(-res));
2715 fuse_ll_clear_pipe(se);
2716 return res;
2717 }
2718 if (res < tmpbuf.size) {
2719 fprintf(stderr, "fuse: copy from pipe: short read\n");
2720 fuse_ll_clear_pipe(se);
2721 return -EIO;
2722 }
2723 assert(res == tmpbuf.size);
2724
2725 } else {
2726 /* Don't overwrite buf->mem, as that would cause a leak */
2727 buf->fd = tmpbuf.fd;
2728 buf->flags = tmpbuf.flags;
2729 }
2730 buf->size = tmpbuf.size;
2731
2732 return res;
2733
2734 fallback:
2735 #endif
2736 if (!buf->mem) {
2737 buf->mem = malloc(se->bufsize);
2738 if (!buf->mem) {
2739 fprintf(stderr,
2740 "fuse: failed to allocate read buffer\n");
2741 return -ENOMEM;
2742 }
2743 }
2744
2745 restart:
2746 res = read(ch ? ch->fd : se->fd, buf->mem, se->bufsize);
2747 err = errno;
2748
2749 if (fuse_session_exited(se))
2750 return 0;
2751 if (res == -1) {
2752 /* ENOENT means the operation was interrupted, it's safe
2753 to restart */
2754 if (err == ENOENT)
2755 goto restart;
2756
2757 if (err == ENODEV) {
2758 /* Filesystem was unmounted, or connection was aborted
2759 via /sys/fs/fuse/connections */
2760 fuse_session_exit(se);
2761 return 0;
2762 }
2763 /* Errors occurring during normal operation: EINTR (read
2764 interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
2765 umounted) */
2766 if (err != EINTR && err != EAGAIN)
2767 perror("fuse: reading device");
2768 return -err;
2769 }
2770 if ((size_t) res < sizeof(struct fuse_in_header)) {
2771 fprintf(stderr, "short read on fuse device\n");
2772 return -EIO;
2773 }
2774
2775 buf->size = res;
2776
2777 return res;
2778 }
2779
2780 #define KERNEL_BUF_PAGES 32
2781
2782 /* room needed in buffer to accommodate header */
2783 #define HEADER_SIZE 0x1000
2784
2785 struct fuse_session *fuse_session_new(struct fuse_args *args,
2786 const struct fuse_lowlevel_ops *op,
2787 size_t op_size, void *userdata)
2788 {
2789 int err;
2790 struct fuse_session *se;
2791 struct mount_opts *mo;
2792
2793 if (sizeof(struct fuse_lowlevel_ops) < op_size) {
2794 fprintf(stderr, "fuse: warning: library too old, some operations may not work\n");
2795 op_size = sizeof(struct fuse_lowlevel_ops);
2796 }
2797
2798 if (args->argc == 0) {
2799 fprintf(stderr, "fuse: empty argv passed to fuse_session_new().\n");
2800 return NULL;
2801 }
2802
2803 se = (struct fuse_session *) calloc(1, sizeof(struct fuse_session));
2804 if (se == NULL) {
2805 fprintf(stderr, "fuse: failed to allocate fuse object\n");
2806 goto out1;
2807 }
2808 se->fd = -1;
2809 se->conn.max_write = UINT_MAX;
2810 se->conn.max_readahead = UINT_MAX;
2811
2812 /* Parse options */
2813 if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
2814 goto out2;
2815 if(se->deny_others) {
2816 /* Allowing access only by root is done by instructing
2817 * kernel to allow access by everyone, and then restricting
2818 * access to root and mountpoint owner in libfuse.
2819 */
2820 // We may be adding the option a second time, but
2821 // that doesn't hurt.
2822 if(fuse_opt_add_arg(args, "-oallow_other") == -1)
2823 goto out2;
2824 }
2825 mo = parse_mount_opts(args);
2826 if (mo == NULL)
2827 goto out3;
2828
2829 if(args->argc == 1 &&
2830 args->argv[0][0] == '-') {
2831 fprintf(stderr, "fuse: warning: argv[0] looks like an option, but "
2832 "will be ignored\n");
2833 } else if (args->argc != 1) {
2834 int i;
2835 fprintf(stderr, "fuse: unknown option(s): `");
2836 for(i = 1; i < args->argc-1; i++)
2837 fprintf(stderr, "%s ", args->argv[i]);
2838 fprintf(stderr, "%s'\n", args->argv[i]);
2839 goto out4;
2840 }
2841
2842 if (se->debug)
2843 fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
2844
2845 se->bufsize = KERNEL_BUF_PAGES * getpagesize() + HEADER_SIZE;
2846
2847 list_init_req(&se->list);
2848 list_init_req(&se->interrupts);
2849 list_init_nreq(&se->notify_list);
2850 se->notify_ctr = 1;
2851 fuse_mutex_init(&se->lock);
2852
2853 err = pthread_key_create(&se->pipe_key, fuse_ll_pipe_destructor);
2854 if (err) {
2855 fprintf(stderr, "fuse: failed to create thread specific key: %s\n",
2856 strerror(err));
2857 goto out5;
2858 }
2859
2860 memcpy(&se->op, op, op_size);
2861 se->owner = getuid();
2862 se->userdata = userdata;
2863
2864 se->mo = mo;
2865 return se;
2866
2867 out5:
2868 pthread_mutex_destroy(&se->lock);
2869 out4:
2870 fuse_opt_free_args(args);
2871 out3:
2872 free(mo);
2873 out2:
2874 free(se);
2875 out1:
2876 return NULL;
2877 }
2878
2879 int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
2880 {
2881 int fd;
2882
2883 /*
2884 * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
2885 * would ensue.
2886 */
2887 do {
2888 fd = open("/dev/null", O_RDWR);
2889 if (fd > 2)
2890 close(fd);
2891 } while (fd >= 0 && fd <= 2);
2892
2893 /* Open channel */
2894 fd = fuse_kern_mount(mountpoint, se->mo);
2895 if (fd == -1)
2896 return -1;
2897 se->fd = fd;
2898
2899 /* Save mountpoint */
2900 se->mountpoint = strdup(mountpoint);
2901 if (se->mountpoint == NULL)
2902 goto error_out;
2903
2904 return 0;
2905
2906 error_out:
2907 fuse_kern_unmount(mountpoint, fd);
2908 return -1;
2909 }
2910
2911 int fuse_session_fd(struct fuse_session *se)
2912 {
2913 return se->fd;
2914 }
2915
2916 void fuse_session_unmount(struct fuse_session *se)
2917 {
2918 fuse_kern_unmount(se->mountpoint, se->fd);
2919 free(se->mountpoint);
2920 se->mountpoint = NULL;
2921 }
2922
2923 #ifdef linux
2924 int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
2925 {
2926 char *buf;
2927 size_t bufsize = 1024;
2928 char path[128];
2929 int ret;
2930 int fd;
2931 unsigned long pid = req->ctx.pid;
2932 char *s;
2933
2934 sprintf(path, "/proc/%lu/task/%lu/status", pid, pid);
2935
2936 retry:
2937 buf = malloc(bufsize);
2938 if (buf == NULL)
2939 return -ENOMEM;
2940
2941 ret = -EIO;
2942 fd = open(path, O_RDONLY);
2943 if (fd == -1)
2944 goto out_free;
2945
2946 ret = read(fd, buf, bufsize);
2947 close(fd);
2948 if (ret < 0) {
2949 ret = -EIO;
2950 goto out_free;
2951 }
2952
2953 if ((size_t)ret == bufsize) {
2954 free(buf);
2955 bufsize *= 4;
2956 goto retry;
2957 }
2958
2959 ret = -EIO;
2960 s = strstr(buf, "\nGroups:");
2961 if (s == NULL)
2962 goto out_free;
2963
2964 s += 8;
2965 ret = 0;
2966 while (1) {
2967 char *end;
2968 unsigned long val = strtoul(s, &end, 0);
2969 if (end == s)
2970 break;
2971
2972 s = end;
2973 if (ret < size)
2974 list[ret] = val;
2975 ret++;
2976 }
2977
2978 out_free:
2979 free(buf);
2980 return ret;
2981 }
2982 #else /* linux */
2983 /*
2984 * This is currently not implemented on other than Linux...
2985 */
2986 int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
2987 {
2988 (void) req; (void) size; (void) list;
2989 return -ENOSYS;
2990 }
2991 #endif
2992
2993 void fuse_session_exit(struct fuse_session *se)
2994 {
2995 se->exited = 1;
2996 }
2997
2998 void fuse_session_reset(struct fuse_session *se)
2999 {
3000 se->exited = 0;
3001 se->error = 0;
3002 }
3003
3004 int fuse_session_exited(struct fuse_session *se)
3005 {
3006 return se->exited;
3007 }
FUSE_CAP_ASYNC_DIO
#define FUSE_CAP_ASYNC_DIO
Definition: fuse_common.h:246
fuse_bufvec::off
size_t off
Definition: fuse_common.h:668
fuse_session_receive_buf
int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf)
Definition: fuse_lowlevel.c:2624
fuse_file_info::fh
uint64_t fh
Definition: fuse_common.h:72
fuse_session_process_buf
void fuse_session_process_buf(struct fuse_session *se, const struct fuse_buf *buf)
Definition: fuse_lowlevel.c:2424
fuse_file_info::writepage
unsigned int writepage
Definition: fuse_common.h:43
fuse_reply_write
int fuse_reply_write(fuse_req_t req, size_t count)
Definition: fuse_lowlevel.c:459
fuse_args::argc
int argc
Definition: fuse_opt.h:111
fuse_file_info::direct_io
unsigned int direct_io
Definition: fuse_common.h:46
FUSE_BUF_SPLICE_MOVE
Definition: fuse_common.h:595
FUSE_CAP_DONT_MASK
#define FUSE_CAP_DONT_MASK
Definition: fuse_common.h:152
FUSE_CAP_ATOMIC_O_TRUNC
#define FUSE_CAP_ATOMIC_O_TRUNC
Definition: fuse_common.h:137
fuse_file_info::poll_events
uint32_t poll_events
Definition: fuse_common.h:79
fuse_session_reset
void fuse_session_reset(struct fuse_session *se)
Definition: fuse_lowlevel.c:2998
fuse_req_t
struct fuse_req * fuse_req_t
Definition: fuse_lowlevel.h:49
FUSE_BUF_SPLICE_NONBLOCK
Definition: fuse_common.h:604
fuse_lowlevel_notify_inval_entry
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent, const char *name, size_t namelen)
Definition: fuse_lowlevel.c:2140
fuse_reply_iov
int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count)
Definition: fuse_lowlevel.c:245
FUSE_CAP_IOCTL_DIR
#define FUSE_CAP_IOCTL_DIR
Definition: fuse_common.h:197
fuse_ino_t
uint64_t fuse_ino_t
Definition: fuse_lowlevel.h:46
FUSE_CAP_POSIX_LOCKS
#define FUSE_CAP_POSIX_LOCKS
Definition: fuse_common.h:128
FUSE_CAP_READDIRPLUS
#define FUSE_CAP_READDIRPLUS
Definition: fuse_common.h:227
fuse_req_ctx
const struct fuse_ctx * fuse_req_ctx(fuse_req_t req)
Definition: fuse_lowlevel.c:2320
FUSE_CAP_PARALLEL_DIROPS
#define FUSE_CAP_PARALLEL_DIROPS
Definition: fuse_common.h:278
fuse_entry_param::attr
struct stat attr
Definition: fuse_lowlevel.h:91
FUSE_CAP_WRITEBACK_CACHE
#define FUSE_CAP_WRITEBACK_CACHE
Definition: fuse_common.h:255
fuse_session_unmount
void fuse_session_unmount(struct fuse_session *se)
Definition: fuse_lowlevel.c:2916
fuse_file_info::keep_cache
unsigned int keep_cache
Definition: fuse_common.h:51
FUSE_CAP_SPLICE_READ
#define FUSE_CAP_SPLICE_READ
Definition: fuse_common.h:177
FUSE_CAP_AUTO_INVAL_DATA
#define FUSE_CAP_AUTO_INVAL_DATA
Definition: fuse_common.h:219
fuse_entry_param
Definition: fuse_lowlevel.h:59
fuse_add_direntry_plus
size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize, const char *name, const struct fuse_entry_param *e, off_t off)
Definition: fuse_lowlevel.c:356
fuse_entry_param::ino
fuse_ino_t ino
Definition: fuse_lowlevel.h:67
fuse_file_info::lock_owner
uint64_t lock_owner
Definition: fuse_common.h:75
fuse_reply_data
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv, enum fuse_buf_copy_flags flags)
Definition: fuse_lowlevel.c:819
fuse_reply_ioctl
int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size)
Definition: fuse_lowlevel.c:978
fuse_reply_entry
int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)
Definition: fuse_lowlevel.c:398
fuse_session_mount
int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
Definition: fuse_lowlevel.c:2879
FUSE_CAP_FLOCK_LOCKS
#define FUSE_CAP_FLOCK_LOCKS
Definition: fuse_common.h:190
fuse_reply_statfs
int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
Definition: fuse_lowlevel.c:841
fuse_reply_ioctl_iov
int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov, int count)
Definition: fuse_lowlevel.c:999
fuse_file_info
Definition: fuse_common.h:37
fuse_buf_size
size_t fuse_buf_size(const struct fuse_bufvec *bufv)
Definition: buffer.c:22
fuse_lowlevel_help
void fuse_lowlevel_help(void)
Definition: fuse_lowlevel.c:2587
fuse_buf_copy
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src, enum fuse_buf_copy_flags flags)
Definition: buffer.c:281
fuse_req_interrupted
int fuse_req_interrupted(fuse_req_t req)
Definition: fuse_lowlevel.c:2338
fuse_reply_poll
int fuse_reply_poll(fuse_req_t req, unsigned revents)
Definition: fuse_lowlevel.c:1023
fuse_file_info::flags
int flags
Definition: fuse_common.h:39
fuse_bufvec
Definition: fuse_common.h:654
FUSE_CAP_HANDLE_KILLPRIV
#define FUSE_CAP_HANDLE_KILLPRIV
Definition: fuse_common.h:306
fuse_lowlevel_notify_store
int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino, off_t offset, struct fuse_bufvec *bufv, enum fuse_buf_copy_flags flags)
Definition: fuse_lowlevel.c:2190
fuse_args::argv
char ** argv
Definition: fuse_opt.h:114
fuse_bufvec::idx
size_t idx
Definition: fuse_common.h:663
fuse_ctx
Definition: fuse_lowlevel.h:114
fuse_reply_err
int fuse_reply_err(fuse_req_t req, int err)
Definition: fuse_lowlevel.c:311
FUSE_CAP_SPLICE_WRITE
#define FUSE_CAP_SPLICE_WRITE
Definition: fuse_common.h:160
FUSE_CAP_NO_OPEN_SUPPORT
#define FUSE_CAP_NO_OPEN_SUPPORT
Definition: fuse_common.h:268
fuse_bufvec::count
size_t count
Definition: fuse_common.h:658
fuse_reply_ioctl_retry
int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov, size_t in_count, const struct iovec *out_iov, size_t out_count)
Definition: fuse_lowlevel.c:908
FUSE_BUF_FORCE_SPLICE
Definition: fuse_common.h:586
FUSE_BUF_NO_SPLICE
Definition: fuse_common.h:578
fuse_file_info::nonseekable
unsigned int nonseekable
Definition: fuse_common.h:60
fuse_req_userdata
void * fuse_req_userdata(fuse_req_t req)
Definition: fuse_lowlevel.c:2315
fuse_buf::flags
enum fuse_buf_flags flags
Definition: fuse_common.h:622
fuse_reply_none
void fuse_reply_none(fuse_req_t req)
Definition: fuse_lowlevel.c:316
fuse_file_info::flush
unsigned int flush
Definition: fuse_common.h:56
fuse_session_exited
int fuse_session_exited(struct fuse_session *se)
Definition: fuse_lowlevel.c:3004
fuse_opt_add_arg
int fuse_opt_add_arg(struct fuse_args *args, const char *arg)
Definition: fuse_opt.c:54
fuse_session_destroy
void fuse_session_destroy(struct fuse_session *se)
Definition: fuse_lowlevel.c:2597
FUSE_CAP_POSIX_ACL
#define FUSE_CAP_POSIX_ACL
Definition: fuse_common.h:297
fuse_reply_open
int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi)
Definition: fuse_lowlevel.c:450
fuse_session_exit
void fuse_session_exit(struct fuse_session *se)
Definition: fuse_lowlevel.c:2993
fuse_reply_readlink
int fuse_reply_readlink(fuse_req_t req, const char *link)
Definition: fuse_lowlevel.c:445
fuse_pollhandle_destroy
void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
Definition: fuse_lowlevel.c:1765
fuse_interrupt_func_t
void(* fuse_interrupt_func_t)(fuse_req_t req, void *data)
Definition: fuse_lowlevel.h:1704
fuse_reply_attr
int fuse_reply_attr(fuse_req_t req, const struct stat *attr, double attr_timeout)
Definition: fuse_lowlevel.c:430
fuse_entry_param::generation
uint64_t generation
Definition: fuse_lowlevel.h:82
fuse_req_interrupt_func
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func, void *data)
Definition: fuse_lowlevel.c:2325
fuse_opt_free_args
void fuse_opt_free_args(struct fuse_args *args)
Definition: fuse_opt.c:33
fuse_req_getgroups
int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
Definition: fuse_lowlevel.c:2986
fuse_reply_lock
int fuse_reply_lock(fuse_req_t req, const struct flock *lock)
Definition: fuse_lowlevel.c:863
fuse_lowlevel_ops
Definition: fuse_lowlevel.h:175
fuse_buf_copy_flags
fuse_buf_copy_flags
Definition: fuse_common.h:568
fuse_reply_create
int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e, const struct fuse_file_info *fi)
Definition: fuse_lowlevel.c:414
fuse_opt
Definition: fuse_opt.h:77
fuse_session_new
struct fuse_session * fuse_session_new(struct fuse_args *args, const struct fuse_lowlevel_ops *op, size_t op_size, void *userdata)
Definition: fuse_lowlevel.c:2785
fuse_session_fd
int fuse_session_fd(struct fuse_session *se)
Definition: fuse_lowlevel.c:2911
fuse_buf::mem
void * mem
Definition: fuse_common.h:629
fuse_bufvec::buf
struct fuse_buf buf[1]
Definition: fuse_common.h:673
fuse_args
Definition: fuse_opt.h:109
fuse_lowlevel_notify_retrieve
int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino, size_t size, off_t offset, void *cookie)
Definition: fuse_lowlevel.c:2270
fuse_lowlevel_notify_inval_inode
int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino, off_t off, off_t len)
Definition: fuse_lowlevel.c:2118
fuse_lowlevel_version
void fuse_lowlevel_version(void)
Definition: fuse_lowlevel.c:2580
fuse_buf::size
size_t size
Definition: fuse_common.h:617
FUSE_BUF_IS_FD
Definition: fuse_common.h:544
fuse_entry_param::entry_timeout
double entry_timeout
Definition: fuse_lowlevel.h:103
FUSE_CAP_EXPORT_SUPPORT
#define FUSE_CAP_EXPORT_SUPPORT
Definition: fuse_common.h:144
fuse_reply_bmap
int fuse_reply_bmap(fuse_req_t req, uint64_t idx)
Definition: fuse_lowlevel.c:880
fuse_buf::fd
int fd
Definition: fuse_common.h:636
fuse_entry_param::attr_timeout
double attr_timeout
Definition: fuse_lowlevel.h:97
FUSE_CAP_SPLICE_MOVE
#define FUSE_CAP_SPLICE_MOVE
Definition: fuse_common.h:168
FUSE_OPT_END
#define FUSE_OPT_END
Definition: fuse_opt.h:104
fuse_lowlevel_notify_poll
int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
Definition: fuse_lowlevel.c:2101
fuse_buf
Definition: fuse_common.h:613
fuse_opt_parse
int fuse_opt_parse(struct fuse_args *args, void *data, const struct fuse_opt opts[], fuse_opt_proc_t proc)
Definition: fuse_opt.c:397
FUSE_CAP_ASYNC_READ
#define FUSE_CAP_ASYNC_READ
Definition: fuse_common.h:120
fuse_reply_buf
int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size)
Definition: fuse_lowlevel.c:469
fuse_add_direntry
size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize, const char *name, const struct stat *stbuf, off_t off)
Definition: fuse_lowlevel.c:266
fuse_reply_xattr
int fuse_reply_xattr(fuse_req_t req, size_t count)
Definition: fuse_lowlevel.c:853
fuse_lowlevel_notify_delete
int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent, fuse_ino_t child, const char *name, size_t namelen)
Definition: fuse_lowlevel.c:2164
FUSE_CAP_READDIRPLUS_AUTO
#define FUSE_CAP_READDIRPLUS_AUTO
Definition: fuse_common.h:235