?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Add missing fuse_session_data to versionscript
[fuse.git] / lib / fuse_lowlevel.c
blob7385de19b8d8e55fc5eef097d5fe596fea34d8ca
1 /*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
4
5 This program can be distributed under the terms of the GNU LGPLv2.
6 See the file COPYING.LIB
7 */
8
9 #include "fuse_i.h"
10 #include "fuse_kernel.h"
11 #include "fuse_opt.h"
12 #include "fuse_misc.h"
13 #include "fuse_common_compat.h"
14 #include "fuse_lowlevel_compat.h"
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <stddef.h>
19 #include <string.h>
20 #include <unistd.h>
21 #include <limits.h>
22 #include <errno.h>
23
24 #define PARAM(inarg) (((char *)(inarg)) + sizeof(*(inarg)))
25 #define OFFSET_MAX 0x7fffffffffffffffLL
26
27 struct fuse_pollhandle {
28 uint64_t kh;
29 struct fuse_chan *ch;
30 struct fuse_ll *f;
31 };
32
33 static void convert_stat(const struct stat *stbuf, struct fuse_attr *attr)
34 {
35 attr->ino = stbuf->st_ino;
36 attr->mode = stbuf->st_mode;
37 attr->nlink = stbuf->st_nlink;
38 attr->uid = stbuf->st_uid;
39 attr->gid = stbuf->st_gid;
40 attr->rdev = stbuf->st_rdev;
41 attr->size = stbuf->st_size;
42 attr->blksize = stbuf->st_blksize;
43 attr->blocks = stbuf->st_blocks;
44 attr->atime = stbuf->st_atime;
45 attr->mtime = stbuf->st_mtime;
46 attr->ctime = stbuf->st_ctime;
47 attr->atimensec = ST_ATIM_NSEC(stbuf);
48 attr->mtimensec = ST_MTIM_NSEC(stbuf);
49 attr->ctimensec = ST_CTIM_NSEC(stbuf);
50 }
51
52 static void convert_attr(const struct fuse_setattr_in *attr, struct stat *stbuf)
53 {
54 stbuf->st_mode = attr->mode;
55 stbuf->st_uid = attr->uid;
56 stbuf->st_gid = attr->gid;
57 stbuf->st_size = attr->size;
58 stbuf->st_atime = attr->atime;
59 stbuf->st_mtime = attr->mtime;
60 ST_ATIM_NSEC_SET(stbuf, attr->atimensec);
61 ST_MTIM_NSEC_SET(stbuf, attr->mtimensec);
62 }
63
64 static size_t iov_length(const struct iovec *iov, size_t count)
65 {
66 size_t seg;
67 size_t ret = 0;
68
69 for (seg = 0; seg < count; seg++)
70 ret += iov[seg].iov_len;
71 return ret;
72 }
73
74 static void list_init_req(struct fuse_req *req)
75 {
76 req->next = req;
77 req->prev = req;
78 }
79
80 static void list_del_req(struct fuse_req *req)
81 {
82 struct fuse_req *prev = req->prev;
83 struct fuse_req *next = req->next;
84 prev->next = next;
85 next->prev = prev;
86 }
87
88 static void list_add_req(struct fuse_req *req, struct fuse_req *next)
89 {
90 struct fuse_req *prev = next->prev;
91 req->next = next;
92 req->prev = prev;
93 prev->next = req;
94 next->prev = req;
95 }
96
97 static void destroy_req(fuse_req_t req)
98 {
99 pthread_mutex_destroy(&req->lock);
100 free(req);
101 }
102
103 void fuse_free_req(fuse_req_t req)
104 {
105 int ctr;
106 struct fuse_ll *f = req->f;
107
108 pthread_mutex_lock(&f->lock);
109 req->u.ni.func = NULL;
110 req->u.ni.data = NULL;
111 list_del_req(req);
112 ctr = --req->ctr;
113 pthread_mutex_unlock(&f->lock);
114 if (!ctr)
115 destroy_req(req);
116 }
117
118 int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
119 int count)
120 {
121 struct fuse_out_header out;
122
123 if (error <= -1000 || error > 0) {
124 fprintf(stderr, "fuse: bad error value: %i\n", error);
125 error = -ERANGE;
126 }
127
128 out.unique = req->unique;
129 out.error = error;
130 iov[0].iov_base = &out;
131 iov[0].iov_len = sizeof(struct fuse_out_header);
132 out.len = iov_length(iov, count);
133
134 if (req->f->debug) {
135 if (out.error) {
136 fprintf(stderr,
137 " unique: %llu, error: %i (%s), outsize: %i\n",
138 (unsigned long long) out.unique, out.error,
139 strerror(-out.error), out.len);
140 } else {
141 fprintf(stderr,
142 " unique: %llu, success, outsize: %i\n",
143 (unsigned long long) out.unique, out.len);
144 }
145 }
146
147 return fuse_chan_send(req->ch, iov, count);
148 }
149
150 static int send_reply_iov(fuse_req_t req, int error, struct iovec *iov,
151 int count)
152 {
153 int res;
154
155 res = fuse_send_reply_iov_nofree(req, error, iov, count);
156 fuse_free_req(req);
157 return res;
158 }
159
160 static int send_reply(fuse_req_t req, int error, const void *arg,
161 size_t argsize)
162 {
163 struct iovec iov[2];
164 int count = 1;
165 if (argsize) {
166 iov[1].iov_base = (void *) arg;
167 iov[1].iov_len = argsize;
168 count++;
169 }
170 return send_reply_iov(req, error, iov, count);
171 }
172
173 int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count)
174 {
175 int res;
176 struct iovec *padded_iov;
177
178 padded_iov = malloc((count + 1) * sizeof(struct iovec));
179 if (padded_iov == NULL)
180 return fuse_reply_err(req, -ENOMEM);
181
182 memcpy(padded_iov + 1, iov, count * sizeof(struct iovec));
183 count++;
184
185 res = send_reply_iov(req, 0, padded_iov, count);
186 free(padded_iov);
187
188 return res;
189 }
190
191 size_t fuse_dirent_size(size_t namelen)
192 {
193 return FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + namelen);
194 }
195
196 char *fuse_add_dirent(char *buf, const char *name, const struct stat *stbuf,
197 off_t off)
198 {
199 unsigned namelen = strlen(name);
200 unsigned entlen = FUSE_NAME_OFFSET + namelen;
201 unsigned entsize = fuse_dirent_size(namelen);
202 unsigned padlen = entsize - entlen;
203 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
204
205 dirent->ino = stbuf->st_ino;
206 dirent->off = off;
207 dirent->namelen = namelen;
208 dirent->type = (stbuf->st_mode & 0170000) >> 12;
209 strncpy(dirent->name, name, namelen);
210 if (padlen)
211 memset(buf + entlen, 0, padlen);
212
213 return buf + entsize;
214 }
215
216 size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize,
217 const char *name, const struct stat *stbuf, off_t off)
218 {
219 size_t entsize;
220
221 (void) req;
222 entsize = fuse_dirent_size(strlen(name));
223 if (entsize <= bufsize && buf)
224 fuse_add_dirent(buf, name, stbuf, off);
225 return entsize;
226 }
227
228 static void convert_statfs(const struct statvfs *stbuf,
229 struct fuse_kstatfs *kstatfs)
230 {
231 kstatfs->bsize = stbuf->f_bsize;
232 kstatfs->frsize = stbuf->f_frsize;
233 kstatfs->blocks = stbuf->f_blocks;
234 kstatfs->bfree = stbuf->f_bfree;
235 kstatfs->bavail = stbuf->f_bavail;
236 kstatfs->files = stbuf->f_files;
237 kstatfs->ffree = stbuf->f_ffree;
238 kstatfs->namelen = stbuf->f_namemax;
239 }
240
241 static int send_reply_ok(fuse_req_t req, const void *arg, size_t argsize)
242 {
243 return send_reply(req, 0, arg, argsize);
244 }
245
246 int fuse_reply_err(fuse_req_t req, int err)
247 {
248 return send_reply(req, -err, NULL, 0);
249 }
250
251 void fuse_reply_none(fuse_req_t req)
252 {
253 fuse_chan_send(req->ch, NULL, 0);
254 fuse_free_req(req);
255 }
256
257 static unsigned long calc_timeout_sec(double t)
258 {
259 if (t > (double) ULONG_MAX)
260 return ULONG_MAX;
261 else if (t < 0.0)
262 return 0;
263 else
264 return (unsigned long) t;
265 }
266
267 static unsigned int calc_timeout_nsec(double t)
268 {
269 double f = t - (double) calc_timeout_sec(t);
270 if (f < 0.0)
271 return 0;
272 else if (f >= 0.999999999)
273 return 999999999;
274 else
275 return (unsigned int) (f * 1.0e9);
276 }
277
278 static void fill_entry(struct fuse_entry_out *arg,
279 const struct fuse_entry_param *e)
280 {
281 arg->nodeid = e->ino;
282 arg->generation = e->generation;
283 arg->entry_valid = calc_timeout_sec(e->entry_timeout);
284 arg->entry_valid_nsec = calc_timeout_nsec(e->entry_timeout);
285 arg->attr_valid = calc_timeout_sec(e->attr_timeout);
286 arg->attr_valid_nsec = calc_timeout_nsec(e->attr_timeout);
287 convert_stat(&e->attr, &arg->attr);
288 }
289
290 static void fill_open(struct fuse_open_out *arg,
291 const struct fuse_file_info *f)
292 {
293 arg->fh = f->fh;
294 if (f->direct_io)
295 arg->open_flags |= FOPEN_DIRECT_IO;
296 if (f->keep_cache)
297 arg->open_flags |= FOPEN_KEEP_CACHE;
298 if (f->nonseekable)
299 arg->open_flags |= FOPEN_NONSEEKABLE;
300 }
301
302 int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)
303 {
304 struct fuse_entry_out arg;
305 size_t size = req->f->conn.proto_minor < 9 ?
306 FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(arg);
307
308 /* before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
309 negative entry */
310 if (!e->ino && req->f->conn.proto_minor < 4)
311 return fuse_reply_err(req, ENOENT);
312
313 memset(&arg, 0, sizeof(arg));
314 fill_entry(&arg, e);
315 return send_reply_ok(req, &arg, size);
316 }
317
318 int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
319 const struct fuse_file_info *f)
320 {
321 char buf[sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out)];
322 size_t entrysize = req->f->conn.proto_minor < 9 ?
323 FUSE_COMPAT_ENTRY_OUT_SIZE : sizeof(struct fuse_entry_out);
324 struct fuse_entry_out *earg = (struct fuse_entry_out *) buf;
325 struct fuse_open_out *oarg = (struct fuse_open_out *) (buf + entrysize);
326
327 memset(buf, 0, sizeof(buf));
328 fill_entry(earg, e);
329 fill_open(oarg, f);
330 return send_reply_ok(req, buf,
331 entrysize + sizeof(struct fuse_open_out));
332 }
333
334 int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
335 double attr_timeout)
336 {
337 struct fuse_attr_out arg;
338 size_t size = req->f->conn.proto_minor < 9 ?
339 FUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);
340
341 memset(&arg, 0, sizeof(arg));
342 arg.attr_valid = calc_timeout_sec(attr_timeout);
343 arg.attr_valid_nsec = calc_timeout_nsec(attr_timeout);
344 convert_stat(attr, &arg.attr);
345
346 return send_reply_ok(req, &arg, size);
347 }
348
349 int fuse_reply_readlink(fuse_req_t req, const char *linkname)
350 {
351 return send_reply_ok(req, linkname, strlen(linkname));
352 }
353
354 int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *f)
355 {
356 struct fuse_open_out arg;
357
358 memset(&arg, 0, sizeof(arg));
359 fill_open(&arg, f);
360 return send_reply_ok(req, &arg, sizeof(arg));
361 }
362
363 int fuse_reply_write(fuse_req_t req, size_t count)
364 {
365 struct fuse_write_out arg;
366
367 memset(&arg, 0, sizeof(arg));
368 arg.size = count;
369
370 return send_reply_ok(req, &arg, sizeof(arg));
371 }
372
373 int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size)
374 {
375 return send_reply_ok(req, buf, size);
376 }
377
378 int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
379 {
380 struct fuse_statfs_out arg;
381 size_t size = req->f->conn.proto_minor < 4 ?
382 FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
383
384 memset(&arg, 0, sizeof(arg));
385 convert_statfs(stbuf, &arg.st);
386
387 return send_reply_ok(req, &arg, size);
388 }
389
390 int fuse_reply_xattr(fuse_req_t req, size_t count)
391 {
392 struct fuse_getxattr_out arg;
393
394 memset(&arg, 0, sizeof(arg));
395 arg.size = count;
396
397 return send_reply_ok(req, &arg, sizeof(arg));
398 }
399
400 int fuse_reply_lock(fuse_req_t req, struct flock *lock)
401 {
402 struct fuse_lk_out arg;
403
404 memset(&arg, 0, sizeof(arg));
405 arg.lk.type = lock->l_type;
406 if (lock->l_type != F_UNLCK) {
407 arg.lk.start = lock->l_start;
408 if (lock->l_len == 0)
409 arg.lk.end = OFFSET_MAX;
410 else
411 arg.lk.end = lock->l_start + lock->l_len - 1;
412 }
413 arg.lk.pid = lock->l_pid;
414 return send_reply_ok(req, &arg, sizeof(arg));
415 }
416
417 int fuse_reply_bmap(fuse_req_t req, uint64_t idx)
418 {
419 struct fuse_bmap_out arg;
420
421 memset(&arg, 0, sizeof(arg));
422 arg.block = idx;
423
424 return send_reply_ok(req, &arg, sizeof(arg));
425 }
426
427 int fuse_reply_ioctl_retry(fuse_req_t req,
428 const struct iovec *in_iov, size_t in_count,
429 const struct iovec *out_iov, size_t out_count)
430 {
431 struct fuse_ioctl_out arg;
432 struct iovec iov[4];
433 size_t count = 1;
434
435 memset(&arg, 0, sizeof(arg));
436 arg.flags |= FUSE_IOCTL_RETRY;
437 arg.in_iovs = in_count;
438 arg.out_iovs = out_count;
439 iov[count].iov_base = &arg;
440 iov[count].iov_len = sizeof(arg);
441 count++;
442
443 if (in_count) {
444 iov[count].iov_base = (void *)in_iov;
445 iov[count].iov_len = sizeof(in_iov[0]) * in_count;
446 count++;
447 }
448
449 if (out_count) {
450 iov[count].iov_base = (void *)out_iov;
451 iov[count].iov_len = sizeof(out_iov[0]) * out_count;
452 count++;
453 }
454
455 return send_reply_iov(req, 0, iov, count);
456 }
457
458 int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size)
459 {
460 struct fuse_ioctl_out arg;
461 struct iovec iov[3];
462 size_t count = 1;
463
464 memset(&arg, 0, sizeof(arg));
465 arg.result = result;
466 iov[count].iov_base = &arg;
467 iov[count].iov_len = sizeof(arg);
468 count++;
469
470 if (size) {
471 iov[count].iov_base = (char *) buf;
472 iov[count].iov_len = size;
473 count++;
474 }
475
476 return send_reply_iov(req, 0, iov, count);
477 }
478
479 int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
480 int count)
481 {
482 struct iovec *padded_iov;
483 struct fuse_ioctl_out arg;
484 int res;
485
486 padded_iov = malloc((count + 2) * sizeof(struct iovec));
487 if (padded_iov == NULL)
488 return fuse_reply_err(req, -ENOMEM);
489
490 memset(&arg, 0, sizeof(arg));
491 arg.result = result;
492 padded_iov[1].iov_base = &arg;
493 padded_iov[1].iov_len = sizeof(arg);
494
495 memcpy(&padded_iov[2], iov, count * sizeof(struct iovec));
496
497 res = send_reply_iov(req, 0, padded_iov, count + 2);
498 free(padded_iov);
499
500 return res;
501 }
502
503 int fuse_reply_poll(fuse_req_t req, unsigned revents)
504 {
505 struct fuse_poll_out arg;
506
507 memset(&arg, 0, sizeof(arg));
508 arg.revents = revents;
509
510 return send_reply_ok(req, &arg, sizeof(arg));
511 }
512
513 static void do_lookup(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
514 {
515 char *name = (char *) inarg;
516
517 if (req->f->op.lookup)
518 req->f->op.lookup(req, nodeid, name);
519 else
520 fuse_reply_err(req, ENOSYS);
521 }
522
523 static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
524 {
525 struct fuse_forget_in *arg = (struct fuse_forget_in *) inarg;
526
527 if (req->f->op.forget)
528 req->f->op.forget(req, nodeid, arg->nlookup);
529 else
530 fuse_reply_none(req);
531 }
532
533 static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
534 {
535 struct fuse_file_info *fip = NULL;
536 struct fuse_file_info fi;
537
538 if (req->f->conn.proto_minor >= 9) {
539 struct fuse_getattr_in *arg = (struct fuse_getattr_in *) inarg;
540
541 if (arg->getattr_flags & FUSE_GETATTR_FH) {
542 memset(&fi, 0, sizeof(fi));
543 fi.fh = arg->fh;
544 fi.fh_old = fi.fh;
545 fip = &fi;
546 }
547 }
548
549 if (req->f->op.getattr)
550 req->f->op.getattr(req, nodeid, fip);
551 else
552 fuse_reply_err(req, ENOSYS);
553 }
554
555 static void do_setattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
556 {
557 struct fuse_setattr_in *arg = (struct fuse_setattr_in *) inarg;
558
559 if (req->f->op.setattr) {
560 struct fuse_file_info *fi = NULL;
561 struct fuse_file_info fi_store;
562 struct stat stbuf;
563 memset(&stbuf, 0, sizeof(stbuf));
564 convert_attr(arg, &stbuf);
565 if (arg->valid & FATTR_FH) {
566 arg->valid &= ~FATTR_FH;
567 memset(&fi_store, 0, sizeof(fi_store));
568 fi = &fi_store;
569 fi->fh = arg->fh;
570 fi->fh_old = fi->fh;
571 }
572 arg->valid &=
573 FUSE_SET_ATTR_MODE |
574 FUSE_SET_ATTR_UID |
575 FUSE_SET_ATTR_GID |
576 FUSE_SET_ATTR_SIZE |
577 FUSE_SET_ATTR_ATIME |
578 FUSE_SET_ATTR_MTIME |
579 FUSE_SET_ATTR_ATIME_NOW |
580 FUSE_SET_ATTR_MTIME_NOW;
581
582 req->f->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
583 } else
584 fuse_reply_err(req, ENOSYS);
585 }
586
587 static void do_access(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
588 {
589 struct fuse_access_in *arg = (struct fuse_access_in *) inarg;
590
591 if (req->f->op.access)
592 req->f->op.access(req, nodeid, arg->mask);
593 else
594 fuse_reply_err(req, ENOSYS);
595 }
596
597 static void do_readlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
598 {
599 (void) inarg;
600
601 if (req->f->op.readlink)
602 req->f->op.readlink(req, nodeid);
603 else
604 fuse_reply_err(req, ENOSYS);
605 }
606
607 static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
608 {
609 struct fuse_mknod_in *arg = (struct fuse_mknod_in *) inarg;
610 char *name = PARAM(arg);
611
612 if (req->f->conn.proto_minor >= 12)
613 req->ctx.umask = arg->umask;
614 else
615 name = (char *) inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
616
617 if (req->f->op.mknod)
618 req->f->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
619 else
620 fuse_reply_err(req, ENOSYS);
621 }
622
623 static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
624 {
625 struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *) inarg;
626
627 if (req->f->conn.proto_minor >= 12)
628 req->ctx.umask = arg->umask;
629
630 if (req->f->op.mkdir)
631 req->f->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
632 else
633 fuse_reply_err(req, ENOSYS);
634 }
635
636 static void do_unlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
637 {
638 char *name = (char *) inarg;
639
640 if (req->f->op.unlink)
641 req->f->op.unlink(req, nodeid, name);
642 else
643 fuse_reply_err(req, ENOSYS);
644 }
645
646 static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
647 {
648 char *name = (char *) inarg;
649
650 if (req->f->op.rmdir)
651 req->f->op.rmdir(req, nodeid, name);
652 else
653 fuse_reply_err(req, ENOSYS);
654 }
655
656 static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
657 {
658 char *name = (char *) inarg;
659 char *linkname = ((char *) inarg) + strlen((char *) inarg) + 1;
660
661 if (req->f->op.symlink)
662 req->f->op.symlink(req, linkname, nodeid, name);
663 else
664 fuse_reply_err(req, ENOSYS);
665 }
666
667 static void do_rename(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
668 {
669 struct fuse_rename_in *arg = (struct fuse_rename_in *) inarg;
670 char *oldname = PARAM(arg);
671 char *newname = oldname + strlen(oldname) + 1;
672
673 if (req->f->op.rename)
674 req->f->op.rename(req, nodeid, oldname, arg->newdir, newname);
675 else
676 fuse_reply_err(req, ENOSYS);
677 }
678
679 static void do_link(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
680 {
681 struct fuse_link_in *arg = (struct fuse_link_in *) inarg;
682
683 if (req->f->op.link)
684 req->f->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
685 else
686 fuse_reply_err(req, ENOSYS);
687 }
688
689 static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
690 {
691 struct fuse_create_in *arg = (struct fuse_create_in *) inarg;
692
693 if (req->f->op.create) {
694 struct fuse_file_info fi;
695 char *name = PARAM(arg);
696
697 memset(&fi, 0, sizeof(fi));
698 fi.flags = arg->flags;
699
700 if (req->f->conn.proto_minor >= 12)
701 req->ctx.umask = arg->umask;
702 else
703 name = (char *) inarg + sizeof(struct fuse_open_in);
704
705 req->f->op.create(req, nodeid, name, arg->mode, &fi);
706 } else
707 fuse_reply_err(req, ENOSYS);
708 }
709
710 static void do_open(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
711 {
712 struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
713 struct fuse_file_info fi;
714
715 memset(&fi, 0, sizeof(fi));
716 fi.flags = arg->flags;
717
718 if (req->f->op.open)
719 req->f->op.open(req, nodeid, &fi);
720 else
721 fuse_reply_open(req, &fi);
722 }
723
724 static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
725 {
726 struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
727
728 if (req->f->op.read) {
729 struct fuse_file_info fi;
730
731 memset(&fi, 0, sizeof(fi));
732 fi.fh = arg->fh;
733 fi.fh_old = fi.fh;
734 if (req->f->conn.proto_minor >= 9) {
735 fi.lock_owner = arg->lock_owner;
736 fi.flags = arg->flags;
737 }
738 req->f->op.read(req, nodeid, arg->size, arg->offset, &fi);
739 } else
740 fuse_reply_err(req, ENOSYS);
741 }
742
743 static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
744 {
745 struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
746 struct fuse_file_info fi;
747 char *param;
748
749 memset(&fi, 0, sizeof(fi));
750 fi.fh = arg->fh;
751 fi.fh_old = fi.fh;
752 fi.writepage = arg->write_flags & 1;
753
754 if (req->f->conn.proto_minor < 9) {
755 param = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
756 } else {
757 fi.lock_owner = arg->lock_owner;
758 fi.flags = arg->flags;
759 param = PARAM(arg);
760 }
761
762 if (req->f->op.write)
763 req->f->op.write(req, nodeid, param, arg->size,
764 arg->offset, &fi);
765 else
766 fuse_reply_err(req, ENOSYS);
767 }
768
769 static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
770 {
771 struct fuse_flush_in *arg = (struct fuse_flush_in *) inarg;
772 struct fuse_file_info fi;
773
774 memset(&fi, 0, sizeof(fi));
775 fi.fh = arg->fh;
776 fi.fh_old = fi.fh;
777 fi.flush = 1;
778 if (req->f->conn.proto_minor >= 7)
779 fi.lock_owner = arg->lock_owner;
780
781 if (req->f->op.flush)
782 req->f->op.flush(req, nodeid, &fi);
783 else
784 fuse_reply_err(req, ENOSYS);
785 }
786
787 static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
788 {
789 struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
790 struct fuse_file_info fi;
791
792 memset(&fi, 0, sizeof(fi));
793 fi.flags = arg->flags;
794 fi.fh = arg->fh;
795 fi.fh_old = fi.fh;
796 if (req->f->conn.proto_minor >= 8) {
797 fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
798 fi.lock_owner = arg->lock_owner;
799 }
800
801 if (req->f->op.release)
802 req->f->op.release(req, nodeid, &fi);
803 else
804 fuse_reply_err(req, 0);
805 }
806
807 static void do_fsync(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
808 {
809 struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
810 struct fuse_file_info fi;
811
812 memset(&fi, 0, sizeof(fi));
813 fi.fh = arg->fh;
814 fi.fh_old = fi.fh;
815
816 if (req->f->op.fsync)
817 req->f->op.fsync(req, nodeid, arg->fsync_flags & 1, &fi);
818 else
819 fuse_reply_err(req, ENOSYS);
820 }
821
822 static void do_opendir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
823 {
824 struct fuse_open_in *arg = (struct fuse_open_in *) inarg;
825 struct fuse_file_info fi;
826
827 memset(&fi, 0, sizeof(fi));
828 fi.flags = arg->flags;
829
830 if (req->f->op.opendir)
831 req->f->op.opendir(req, nodeid, &fi);
832 else
833 fuse_reply_open(req, &fi);
834 }
835
836 static void do_readdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
837 {
838 struct fuse_read_in *arg = (struct fuse_read_in *) inarg;
839 struct fuse_file_info fi;
840
841 memset(&fi, 0, sizeof(fi));
842 fi.fh = arg->fh;
843 fi.fh_old = fi.fh;
844
845 if (req->f->op.readdir)
846 req->f->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
847 else
848 fuse_reply_err(req, ENOSYS);
849 }
850
851 static void do_releasedir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
852 {
853 struct fuse_release_in *arg = (struct fuse_release_in *) inarg;
854 struct fuse_file_info fi;
855
856 memset(&fi, 0, sizeof(fi));
857 fi.flags = arg->flags;
858 fi.fh = arg->fh;
859 fi.fh_old = fi.fh;
860
861 if (req->f->op.releasedir)
862 req->f->op.releasedir(req, nodeid, &fi);
863 else
864 fuse_reply_err(req, 0);
865 }
866
867 static void do_fsyncdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
868 {
869 struct fuse_fsync_in *arg = (struct fuse_fsync_in *) inarg;
870 struct fuse_file_info fi;
871
872 memset(&fi, 0, sizeof(fi));
873 fi.fh = arg->fh;
874 fi.fh_old = fi.fh;
875
876 if (req->f->op.fsyncdir)
877 req->f->op.fsyncdir(req, nodeid, arg->fsync_flags & 1, &fi);
878 else
879 fuse_reply_err(req, ENOSYS);
880 }
881
882 static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
883 {
884 (void) nodeid;
885 (void) inarg;
886
887 if (req->f->op.statfs)
888 req->f->op.statfs(req, nodeid);
889 else {
890 struct statvfs buf = {
891 .f_namemax = 255,
892 .f_bsize = 512,
893 };
894 fuse_reply_statfs(req, &buf);
895 }
896 }
897
898 static void do_setxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
899 {
900 struct fuse_setxattr_in *arg = (struct fuse_setxattr_in *) inarg;
901 char *name = PARAM(arg);
902 char *value = name + strlen(name) + 1;
903
904 if (req->f->op.setxattr)
905 req->f->op.setxattr(req, nodeid, name, value, arg->size,
906 arg->flags);
907 else
908 fuse_reply_err(req, ENOSYS);
909 }
910
911 static void do_getxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
912 {
913 struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
914
915 if (req->f->op.getxattr)
916 req->f->op.getxattr(req, nodeid, PARAM(arg), arg->size);
917 else
918 fuse_reply_err(req, ENOSYS);
919 }
920
921 static void do_listxattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
922 {
923 struct fuse_getxattr_in *arg = (struct fuse_getxattr_in *) inarg;
924
925 if (req->f->op.listxattr)
926 req->f->op.listxattr(req, nodeid, arg->size);
927 else
928 fuse_reply_err(req, ENOSYS);
929 }
930
931 static void do_removexattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
932 {
933 char *name = (char *) inarg;
934
935 if (req->f->op.removexattr)
936 req->f->op.removexattr(req, nodeid, name);
937 else
938 fuse_reply_err(req, ENOSYS);
939 }
940
941 static void convert_fuse_file_lock(struct fuse_file_lock *fl,
942 struct flock *flock)
943 {
944 memset(flock, 0, sizeof(struct flock));
945 flock->l_type = fl->type;
946 flock->l_whence = SEEK_SET;
947 flock->l_start = fl->start;
948 if (fl->end == OFFSET_MAX)
949 flock->l_len = 0;
950 else
951 flock->l_len = fl->end - fl->start + 1;
952 flock->l_pid = fl->pid;
953 }
954
955 static void do_getlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
956 {
957 struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
958 struct fuse_file_info fi;
959 struct flock flock;
960
961 memset(&fi, 0, sizeof(fi));
962 fi.fh = arg->fh;
963 fi.lock_owner = arg->owner;
964
965 convert_fuse_file_lock(&arg->lk, &flock);
966 if (req->f->op.getlk)
967 req->f->op.getlk(req, nodeid, &fi, &flock);
968 else
969 fuse_reply_err(req, ENOSYS);
970 }
971
972 static void do_setlk_common(fuse_req_t req, fuse_ino_t nodeid,
973 const void *inarg, int sleep)
974 {
975 struct fuse_lk_in *arg = (struct fuse_lk_in *) inarg;
976 struct fuse_file_info fi;
977 struct flock flock;
978
979 memset(&fi, 0, sizeof(fi));
980 fi.fh = arg->fh;
981 fi.lock_owner = arg->owner;
982
983 convert_fuse_file_lock(&arg->lk, &flock);
984 if (req->f->op.setlk)
985 req->f->op.setlk(req, nodeid, &fi, &flock, sleep);
986 else
987 fuse_reply_err(req, ENOSYS);
988 }
989
990 static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
991 {
992 do_setlk_common(req, nodeid, inarg, 0);
993 }
994
995 static void do_setlkw(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
996 {
997 do_setlk_common(req, nodeid, inarg, 1);
998 }
999
1000 static int find_interrupted(struct fuse_ll *f, struct fuse_req *req)
1001 {
1002 struct fuse_req *curr;
1003
1004 for (curr = f->list.next; curr != &f->list; curr = curr->next) {
1005 if (curr->unique == req->u.i.unique) {
1006 fuse_interrupt_func_t func;
1007 void *data;
1008
1009 curr->ctr++;
1010 pthread_mutex_unlock(&f->lock);
1011
1012 /* Ugh, ugly locking */
1013 pthread_mutex_lock(&curr->lock);
1014 pthread_mutex_lock(&f->lock);
1015 curr->interrupted = 1;
1016 func = curr->u.ni.func;
1017 data = curr->u.ni.data;
1018 pthread_mutex_unlock(&f->lock);
1019 if (func)
1020 func(curr, data);
1021 pthread_mutex_unlock(&curr->lock);
1022
1023 pthread_mutex_lock(&f->lock);
1024 curr->ctr--;
1025 if (!curr->ctr)
1026 destroy_req(curr);
1027
1028 return 1;
1029 }
1030 }
1031 for (curr = f->interrupts.next; curr != &f->interrupts;
1032 curr = curr->next) {
1033 if (curr->u.i.unique == req->u.i.unique)
1034 return 1;
1035 }
1036 return 0;
1037 }
1038
1039 static void do_interrupt(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1040 {
1041 struct fuse_interrupt_in *arg = (struct fuse_interrupt_in *) inarg;
1042 struct fuse_ll *f = req->f;
1043
1044 (void) nodeid;
1045 if (f->debug)
1046 fprintf(stderr, "INTERRUPT: %llu\n",
1047 (unsigned long long) arg->unique);
1048
1049 req->u.i.unique = arg->unique;
1050
1051 pthread_mutex_lock(&f->lock);
1052 if (find_interrupted(f, req))
1053 destroy_req(req);
1054 else
1055 list_add_req(req, &f->interrupts);
1056 pthread_mutex_unlock(&f->lock);
1057 }
1058
1059 static struct fuse_req *check_interrupt(struct fuse_ll *f, struct fuse_req *req)
1060 {
1061 struct fuse_req *curr;
1062
1063 for (curr = f->interrupts.next; curr != &f->interrupts;
1064 curr = curr->next) {
1065 if (curr->u.i.unique == req->unique) {
1066 req->interrupted = 1;
1067 list_del_req(curr);
1068 free(curr);
1069 return NULL;
1070 }
1071 }
1072 curr = f->interrupts.next;
1073 if (curr != &f->interrupts) {
1074 list_del_req(curr);
1075 list_init_req(curr);
1076 return curr;
1077 } else
1078 return NULL;
1079 }
1080
1081 static void do_bmap(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1082 {
1083 struct fuse_bmap_in *arg = (struct fuse_bmap_in *) inarg;
1084
1085 if (req->f->op.bmap)
1086 req->f->op.bmap(req, nodeid, arg->blocksize, arg->block);
1087 else
1088 fuse_reply_err(req, ENOSYS);
1089 }
1090
1091 static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1092 {
1093 struct fuse_ioctl_in *arg = (struct fuse_ioctl_in *) inarg;
1094 unsigned int flags = arg->flags;
1095 void *in_buf = arg->in_size ? PARAM(arg) : NULL;
1096 struct fuse_file_info fi;
1097
1098 memset(&fi, 0, sizeof(fi));
1099 fi.fh = arg->fh;
1100 fi.fh_old = fi.fh;
1101
1102 if (req->f->op.ioctl)
1103 req->f->op.ioctl(req, nodeid, arg->cmd,
1104 (void *)(uintptr_t)arg->arg, &fi, flags,
1105 in_buf, arg->in_size, arg->out_size);
1106 else
1107 fuse_reply_err(req, ENOSYS);
1108 }
1109
1110 void fuse_pollhandle_destroy(struct fuse_pollhandle *ph)
1111 {
1112 free(ph);
1113 }
1114
1115 static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1116 {
1117 struct fuse_poll_in *arg = (struct fuse_poll_in *) inarg;
1118 struct fuse_file_info fi;
1119
1120 memset(&fi, 0, sizeof(fi));
1121 fi.fh = arg->fh;
1122 fi.fh_old = fi.fh;
1123
1124 if (req->f->op.poll) {
1125 struct fuse_pollhandle *ph = NULL;
1126
1127 if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
1128 ph = malloc(sizeof(struct fuse_pollhandle));
1129 if (ph == NULL) {
1130 fuse_reply_err(req, ENOMEM);
1131 return;
1132 }
1133 ph->kh = arg->kh;
1134 ph->ch = req->ch;
1135 ph->f = req->f;
1136 }
1137
1138 req->f->op.poll(req, nodeid, &fi, ph);
1139 } else {
1140 fuse_reply_err(req, ENOSYS);
1141 }
1142 }
1143
1144 static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1145 {
1146 struct fuse_init_in *arg = (struct fuse_init_in *) inarg;
1147 struct fuse_init_out outarg;
1148 struct fuse_ll *f = req->f;
1149 size_t bufsize = fuse_chan_bufsize(req->ch);
1150
1151 (void) nodeid;
1152 if (f->debug) {
1153 fprintf(stderr, "INIT: %u.%u\n", arg->major, arg->minor);
1154 if (arg->major == 7 && arg->minor >= 6) {
1155 fprintf(stderr, "flags=0x%08x\n", arg->flags);
1156 fprintf(stderr, "max_readahead=0x%08x\n",
1157 arg->max_readahead);
1158 }
1159 }
1160 f->conn.proto_major = arg->major;
1161 f->conn.proto_minor = arg->minor;
1162 f->conn.capable = 0;
1163 f->conn.want = 0;
1164
1165 memset(&outarg, 0, sizeof(outarg));
1166 outarg.major = FUSE_KERNEL_VERSION;
1167 outarg.minor = FUSE_KERNEL_MINOR_VERSION;
1168
1169 if (arg->major < 7) {
1170 fprintf(stderr, "fuse: unsupported protocol version: %u.%u\n",
1171 arg->major, arg->minor);
1172 fuse_reply_err(req, EPROTO);
1173 return;
1174 }
1175
1176 if (arg->major > 7) {
1177 /* Wait for a second INIT request with a 7.X version */
1178 send_reply_ok(req, &outarg, sizeof(outarg));
1179 return;
1180 }
1181
1182 if (arg->minor >= 6) {
1183 if (f->conn.async_read)
1184 f->conn.async_read = arg->flags & FUSE_ASYNC_READ;
1185 if (arg->max_readahead < f->conn.max_readahead)
1186 f->conn.max_readahead = arg->max_readahead;
1187 if (arg->flags & FUSE_ASYNC_READ)
1188 f->conn.capable |= FUSE_CAP_ASYNC_READ;
1189 if (arg->flags & FUSE_POSIX_LOCKS)
1190 f->conn.capable |= FUSE_CAP_POSIX_LOCKS;
1191 if (arg->flags & FUSE_ATOMIC_O_TRUNC)
1192 f->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
1193 if (arg->flags & FUSE_EXPORT_SUPPORT)
1194 f->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
1195 if (arg->flags & FUSE_BIG_WRITES)
1196 f->conn.capable |= FUSE_CAP_BIG_WRITES;
1197 if (arg->flags & FUSE_DONT_MASK)
1198 f->conn.capable |= FUSE_CAP_DONT_MASK;
1199 } else {
1200 f->conn.async_read = 0;
1201 f->conn.max_readahead = 0;
1202 }
1203
1204 if (f->atomic_o_trunc)
1205 f->conn.want |= FUSE_CAP_ATOMIC_O_TRUNC;
1206 if (f->op.getlk && f->op.setlk && !f->no_remote_lock)
1207 f->conn.want |= FUSE_CAP_POSIX_LOCKS;
1208 if (f->big_writes)
1209 f->conn.want |= FUSE_CAP_BIG_WRITES;
1210
1211 if (bufsize < FUSE_MIN_READ_BUFFER) {
1212 fprintf(stderr, "fuse: warning: buffer size too small: %zu\n",
1213 bufsize);
1214 bufsize = FUSE_MIN_READ_BUFFER;
1215 }
1216
1217 bufsize -= 4096;
1218 if (bufsize < f->conn.max_write)
1219 f->conn.max_write = bufsize;
1220
1221 f->got_init = 1;
1222 if (f->op.init)
1223 f->op.init(f->userdata, &f->conn);
1224
1225 if (f->conn.async_read || (f->conn.want & FUSE_CAP_ASYNC_READ))
1226 outarg.flags |= FUSE_ASYNC_READ;
1227 if (f->conn.want & FUSE_CAP_POSIX_LOCKS)
1228 outarg.flags |= FUSE_POSIX_LOCKS;
1229 if (f->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
1230 outarg.flags |= FUSE_ATOMIC_O_TRUNC;
1231 if (f->conn.want & FUSE_CAP_EXPORT_SUPPORT)
1232 outarg.flags |= FUSE_EXPORT_SUPPORT;
1233 if (f->conn.want & FUSE_CAP_BIG_WRITES)
1234 outarg.flags |= FUSE_BIG_WRITES;
1235 if (f->conn.want & FUSE_CAP_DONT_MASK)
1236 outarg.flags |= FUSE_DONT_MASK;
1237 outarg.max_readahead = f->conn.max_readahead;
1238 outarg.max_write = f->conn.max_write;
1239
1240 if (f->debug) {
1241 fprintf(stderr, " INIT: %u.%u\n", outarg.major, outarg.minor);
1242 fprintf(stderr, " flags=0x%08x\n", outarg.flags);
1243 fprintf(stderr, " max_readahead=0x%08x\n",
1244 outarg.max_readahead);
1245 fprintf(stderr, " max_write=0x%08x\n", outarg.max_write);
1246 }
1247
1248 send_reply_ok(req, &outarg, arg->minor < 5 ? 8 : sizeof(outarg));
1249 }
1250
1251 static void do_destroy(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
1252 {
1253 struct fuse_ll *f = req->f;
1254
1255 (void) nodeid;
1256 (void) inarg;
1257
1258 f->got_destroy = 1;
1259 if (f->op.destroy)
1260 f->op.destroy(f->userdata);
1261
1262 send_reply_ok(req, NULL, 0);
1263 }
1264
1265 static int send_notify_iov(struct fuse_ll *f, struct fuse_chan *ch,
1266 int notify_code, struct iovec *iov, int count)
1267 {
1268 struct fuse_out_header out;
1269
1270 out.unique = 0;
1271 out.error = notify_code;
1272 iov[0].iov_base = &out;
1273 iov[0].iov_len = sizeof(struct fuse_out_header);
1274 out.len = iov_length(iov, count);
1275
1276 if (f->debug)
1277 fprintf(stderr, "NOTIFY: code=%d count=%d length=%u\n",
1278 notify_code, count, out.len);
1279
1280 return fuse_chan_send(ch, iov, count);
1281 }
1282
1283 int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph)
1284 {
1285 if (ph != NULL) {
1286 struct fuse_notify_poll_wakeup_out outarg;
1287 struct iovec iov[2];
1288
1289 outarg.kh = ph->kh;
1290
1291 iov[1].iov_base = &outarg;
1292 iov[1].iov_len = sizeof(outarg);
1293
1294 return send_notify_iov(ph->f, ph->ch, FUSE_NOTIFY_POLL, iov, 2);
1295 } else {
1296 return 0;
1297 }
1298 }
1299
1300 int fuse_lowlevel_notify_inval_inode(struct fuse_chan *ch, fuse_ino_t ino,
1301 off_t off, off_t len)
1302 {
1303 struct fuse_notify_inval_inode_out outarg;
1304 struct fuse_ll *f;
1305 struct iovec iov[2];
1306
1307 if (!ch)
1308 return -EINVAL;
1309
1310 f = (struct fuse_ll *)fuse_session_data(fuse_chan_session(ch));
1311 if (!f)
1312 return -ENODEV;
1313
1314 outarg.ino = ino;
1315 outarg.off = off;
1316 outarg.len = len;
1317
1318 iov[1].iov_base = &outarg;
1319 iov[1].iov_len = sizeof(outarg);
1320
1321 return send_notify_iov(f, ch, FUSE_NOTIFY_INVAL_INODE, iov, 2);
1322 }
1323
1324 int fuse_lowlevel_notify_inval_entry(struct fuse_chan *ch, fuse_ino_t parent,
1325 const char *name, size_t namelen)
1326 {
1327 struct fuse_notify_inval_entry_out outarg;
1328 struct fuse_ll *f;
1329 struct iovec iov[3];
1330
1331 if (!ch)
1332 return -EINVAL;
1333
1334 f = (struct fuse_ll *)fuse_session_data(fuse_chan_session(ch));
1335 if (!f)
1336 return -ENODEV;
1337
1338 outarg.parent = parent;
1339 outarg.namelen = namelen;
1340 outarg.padding = 0;
1341
1342 iov[1].iov_base = &outarg;
1343 iov[1].iov_len = sizeof(outarg);
1344 iov[2].iov_base = (void *)name;
1345 iov[2].iov_len = namelen + 1;
1346
1347 return send_notify_iov(f, ch, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
1348 }
1349
1350 void *fuse_req_userdata(fuse_req_t req)
1351 {
1352 return req->f->userdata;
1353 }
1354
1355 const struct fuse_ctx *fuse_req_ctx(fuse_req_t req)
1356 {
1357 return &req->ctx;
1358 }
1359
1360 /*
1361 * The size of fuse_ctx got extended, so need to be careful about
1362 * incompatibility (i.e. a new binary cannot work with an old
1363 * library).
1364 */
1365 const struct fuse_ctx *fuse_req_ctx_compat24(fuse_req_t req);
1366 const struct fuse_ctx *fuse_req_ctx_compat24(fuse_req_t req)
1367 {
1368 return fuse_req_ctx(req);
1369 }
1370 FUSE_SYMVER(".symver fuse_req_ctx_compat24,fuse_req_ctx@FUSE_2.4");
1371
1372
1373 void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
1374 void *data)
1375 {
1376 pthread_mutex_lock(&req->lock);
1377 pthread_mutex_lock(&req->f->lock);
1378 req->u.ni.func = func;
1379 req->u.ni.data = data;
1380 pthread_mutex_unlock(&req->f->lock);
1381 if (req->interrupted && func)
1382 func(req, data);
1383 pthread_mutex_unlock(&req->lock);
1384 }
1385
1386 int fuse_req_interrupted(fuse_req_t req)
1387 {
1388 int interrupted;
1389
1390 pthread_mutex_lock(&req->f->lock);
1391 interrupted = req->interrupted;
1392 pthread_mutex_unlock(&req->f->lock);
1393
1394 return interrupted;
1395 }
1396
1397 static struct {
1398 void (*func)(fuse_req_t, fuse_ino_t, const void *);
1399 const char *name;
1400 } fuse_ll_ops[] = {
1401 [FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
1402 [FUSE_FORGET] = { do_forget, "FORGET" },
1403 [FUSE_GETATTR] = { do_getattr, "GETATTR" },
1404 [FUSE_SETATTR] = { do_setattr, "SETATTR" },
1405 [FUSE_READLINK] = { do_readlink, "READLINK" },
1406 [FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
1407 [FUSE_MKNOD] = { do_mknod, "MKNOD" },
1408 [FUSE_MKDIR] = { do_mkdir, "MKDIR" },
1409 [FUSE_UNLINK] = { do_unlink, "UNLINK" },
1410 [FUSE_RMDIR] = { do_rmdir, "RMDIR" },
1411 [FUSE_RENAME] = { do_rename, "RENAME" },
1412 [FUSE_LINK] = { do_link, "LINK" },
1413 [FUSE_OPEN] = { do_open, "OPEN" },
1414 [FUSE_READ] = { do_read, "READ" },
1415 [FUSE_WRITE] = { do_write, "WRITE" },
1416 [FUSE_STATFS] = { do_statfs, "STATFS" },
1417 [FUSE_RELEASE] = { do_release, "RELEASE" },
1418 [FUSE_FSYNC] = { do_fsync, "FSYNC" },
1419 [FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
1420 [FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
1421 [FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
1422 [FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
1423 [FUSE_FLUSH] = { do_flush, "FLUSH" },
1424 [FUSE_INIT] = { do_init, "INIT" },
1425 [FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
1426 [FUSE_READDIR] = { do_readdir, "READDIR" },
1427 [FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
1428 [FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
1429 [FUSE_GETLK] = { do_getlk, "GETLK" },
1430 [FUSE_SETLK] = { do_setlk, "SETLK" },
1431 [FUSE_SETLKW] = { do_setlkw, "SETLKW" },
1432 [FUSE_ACCESS] = { do_access, "ACCESS" },
1433 [FUSE_CREATE] = { do_create, "CREATE" },
1434 [FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
1435 [FUSE_BMAP] = { do_bmap, "BMAP" },
1436 [FUSE_IOCTL] = { do_ioctl, "IOCTL" },
1437 [FUSE_POLL] = { do_poll, "POLL" },
1438 [FUSE_DESTROY] = { do_destroy, "DESTROY" },
1439 [CUSE_INIT] = { cuse_lowlevel_init, "CUSE_INIT" },
1440 };
1441
1442 #define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
1443
1444 static const char *opname(enum fuse_opcode opcode)
1445 {
1446 if (opcode >= FUSE_MAXOP || !fuse_ll_ops[opcode].name)
1447 return "???";
1448 else
1449 return fuse_ll_ops[opcode].name;
1450 }
1451
1452 static void fuse_ll_process(void *data, const char *buf, size_t len,
1453 struct fuse_chan *ch)
1454 {
1455 struct fuse_ll *f = (struct fuse_ll *) data;
1456 struct fuse_in_header *in = (struct fuse_in_header *) buf;
1457 const void *inarg = buf + sizeof(struct fuse_in_header);
1458 struct fuse_req *req;
1459 int err;
1460
1461 if (f->debug)
1462 fprintf(stderr,
1463 "unique: %llu, opcode: %s (%i), nodeid: %lu, insize: %zu\n",
1464 (unsigned long long) in->unique,
1465 opname((enum fuse_opcode) in->opcode), in->opcode,
1466 (unsigned long) in->nodeid, len);
1467
1468 req = (struct fuse_req *) calloc(1, sizeof(struct fuse_req));
1469 if (req == NULL) {
1470 fprintf(stderr, "fuse: failed to allocate request\n");
1471 return;
1472 }
1473
1474 req->f = f;
1475 req->unique = in->unique;
1476 req->ctx.uid = in->uid;
1477 req->ctx.gid = in->gid;
1478 req->ctx.pid = in->pid;
1479 req->ch = ch;
1480 req->ctr = 1;
1481 list_init_req(req);
1482 fuse_mutex_init(&req->lock);
1483
1484 err = EIO;
1485 if (!f->got_init) {
1486 enum fuse_opcode expected;
1487
1488 expected = f->cuse_data ? CUSE_INIT : FUSE_INIT;
1489 if (in->opcode != expected)
1490 goto reply_err;
1491 } else if (in->opcode == FUSE_INIT || in->opcode == CUSE_INIT)
1492 goto reply_err;
1493
1494 err = EACCES;
1495 if (f->allow_root && in->uid != f->owner && in->uid != 0 &&
1496 in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
1497 in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
1498 in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
1499 in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR)
1500 goto reply_err;
1501
1502 err = ENOSYS;
1503 if (in->opcode >= FUSE_MAXOP || !fuse_ll_ops[in->opcode].func)
1504 goto reply_err;
1505 if (in->opcode != FUSE_INTERRUPT) {
1506 struct fuse_req *intr;
1507 pthread_mutex_lock(&f->lock);
1508 intr = check_interrupt(f, req);
1509 list_add_req(req, &f->list);
1510 pthread_mutex_unlock(&f->lock);
1511 if (intr)
1512 fuse_reply_err(intr, EAGAIN);
1513 }
1514 fuse_ll_ops[in->opcode].func(req, in->nodeid, inarg);
1515 return;
1516
1517 reply_err:
1518 fuse_reply_err(req, err);
1519 }
1520
1521 enum {
1522 KEY_HELP,
1523 KEY_VERSION,
1524 };
1525
1526 static struct fuse_opt fuse_ll_opts[] = {
1527 { "debug", offsetof(struct fuse_ll, debug), 1 },
1528 { "-d", offsetof(struct fuse_ll, debug), 1 },
1529 { "allow_root", offsetof(struct fuse_ll, allow_root), 1 },
1530 { "max_write=%u", offsetof(struct fuse_ll, conn.max_write), 0 },
1531 { "max_readahead=%u", offsetof(struct fuse_ll, conn.max_readahead), 0 },
1532 { "async_read", offsetof(struct fuse_ll, conn.async_read), 1 },
1533 { "sync_read", offsetof(struct fuse_ll, conn.async_read), 0 },
1534 { "atomic_o_trunc", offsetof(struct fuse_ll, atomic_o_trunc), 1},
1535 { "no_remote_lock", offsetof(struct fuse_ll, no_remote_lock), 1},
1536 { "big_writes", offsetof(struct fuse_ll, big_writes), 1},
1537 FUSE_OPT_KEY("max_read=", FUSE_OPT_KEY_DISCARD),
1538 FUSE_OPT_KEY("-h", KEY_HELP),
1539 FUSE_OPT_KEY("--help", KEY_HELP),
1540 FUSE_OPT_KEY("-V", KEY_VERSION),
1541 FUSE_OPT_KEY("--version", KEY_VERSION),
1542 FUSE_OPT_END
1543 };
1544
1545 static void fuse_ll_version(void)
1546 {
1547 fprintf(stderr, "using FUSE kernel interface version %i.%i\n",
1548 FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
1549 }
1550
1551 static void fuse_ll_help(void)
1552 {
1553 fprintf(stderr,
1554 " -o max_write=N set maximum size of write requests\n"
1555 " -o max_readahead=N set maximum readahead\n"
1556 " -o async_read perform reads asynchronously (default)\n"
1557 " -o sync_read perform reads synchronously\n"
1558 " -o atomic_o_trunc enable atomic open+truncate support\n"
1559 " -o big_writes enable larger than 4kB writes\n"
1560 " -o no_remote_lock disable remote file locking\n");
1561 }
1562
1563 static int fuse_ll_opt_proc(void *data, const char *arg, int key,
1564 struct fuse_args *outargs)
1565 {
1566 (void) data; (void) outargs;
1567
1568 switch (key) {
1569 case KEY_HELP:
1570 fuse_ll_help();
1571 break;
1572
1573 case KEY_VERSION:
1574 fuse_ll_version();
1575 break;
1576
1577 default:
1578 fprintf(stderr, "fuse: unknown option `%s'\n", arg);
1579 }
1580
1581 return -1;
1582 }
1583
1584 int fuse_lowlevel_is_lib_option(const char *opt)
1585 {
1586 return fuse_opt_match(fuse_ll_opts, opt);
1587 }
1588
1589 static void fuse_ll_destroy(void *data)
1590 {
1591 struct fuse_ll *f = (struct fuse_ll *) data;
1592
1593 if (f->got_init && !f->got_destroy) {
1594 if (f->op.destroy)
1595 f->op.destroy(f->userdata);
1596 }
1597
1598 pthread_mutex_destroy(&f->lock);
1599 free(f->cuse_data);
1600 free(f);
1601 }
1602
1603 /*
1604 * always call fuse_lowlevel_new_common() internally, to work around a
1605 * misfeature in the FreeBSD runtime linker, which links the old
1606 * version of a symbol to internal references.
1607 */
1608 struct fuse_session *fuse_lowlevel_new_common(struct fuse_args *args,
1609 const struct fuse_lowlevel_ops *op,
1610 size_t op_size, void *userdata)
1611 {
1612 struct fuse_ll *f;
1613 struct fuse_session *se;
1614 struct fuse_session_ops sop = {
1615 .process = fuse_ll_process,
1616 .destroy = fuse_ll_destroy,
1617 };
1618
1619 if (sizeof(struct fuse_lowlevel_ops) < op_size) {
1620 fprintf(stderr, "fuse: warning: library too old, some operations may not work\n");
1621 op_size = sizeof(struct fuse_lowlevel_ops);
1622 }
1623
1624 f = (struct fuse_ll *) calloc(1, sizeof(struct fuse_ll));
1625 if (f == NULL) {
1626 fprintf(stderr, "fuse: failed to allocate fuse object\n");
1627 goto out;
1628 }
1629
1630 f->conn.async_read = 1;
1631 f->conn.max_write = UINT_MAX;
1632 f->conn.max_readahead = UINT_MAX;
1633 f->atomic_o_trunc = 0;
1634 list_init_req(&f->list);
1635 list_init_req(&f->interrupts);
1636 fuse_mutex_init(&f->lock);
1637
1638 if (fuse_opt_parse(args, f, fuse_ll_opts, fuse_ll_opt_proc) == -1)
1639 goto out_free;
1640
1641 if (f->debug)
1642 fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
1643
1644 memcpy(&f->op, op, op_size);
1645 f->owner = getuid();
1646 f->userdata = userdata;
1647
1648 se = fuse_session_new(&sop, f);
1649 if (!se)
1650 goto out_free;
1651
1652 return se;
1653
1654 out_free:
1655 free(f);
1656 out:
1657 return NULL;
1658 }
1659
1660
1661 struct fuse_session *fuse_lowlevel_new(struct fuse_args *args,
1662 const struct fuse_lowlevel_ops *op,
1663 size_t op_size, void *userdata)
1664 {
1665 return fuse_lowlevel_new_common(args, op, op_size, userdata);
1666 }
1667
1668 #ifdef linux
1669 int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[])
1670 {
1671 char *buf;
1672 size_t bufsize = 1024;
1673 char path[128];
1674 int ret;
1675 int fd;
1676 unsigned long pid = req->ctx.pid;
1677 char *s;
1678
1679 sprintf(path, "/proc/%lu/task/%lu/status", pid, pid);
1680
1681 retry:
1682 buf = malloc(bufsize);
1683 if (buf == NULL)
1684 return -ENOMEM;
1685
1686 ret = -EIO;
1687 fd = open(path, O_RDONLY);
1688 if (fd == -1)
1689 goto out_free;
1690
1691 ret = read(fd, buf, bufsize);
1692 close(fd);
1693 if (ret == -1) {
1694 ret = -EIO;
1695 goto out_free;
1696 }
1697
1698 if (ret == bufsize) {
1699 free(buf);
1700 bufsize *= 4;
1701 goto retry;
1702 }
1703
1704 ret = -EIO;
1705 s = strstr(buf, "\nGroups:");
1706 if (s == NULL)
1707 goto out_free;
1708
1709 s += 8;
1710 ret = 0;
1711 while (1) {
1712 char *end;
1713 unsigned long val = strtoul(s, &end, 0);
1714 if (end == s)
1715 break;
1716
1717 s = end;
1718 if (ret < size)
1719 list[ret] = val;
1720 ret++;
1721 }
1722
1723 out_free:
1724 free(buf);
1725 return ret;
1726 }
1727 #else /* linux */
1728 /*
1729 * This is currently not implemented on other than Linux...
1730 */
1731 int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
1732 {
1733 return -ENOSYS;
1734 }
1735 #endif
1736
1737 #ifndef __FreeBSD__
1738
1739 static void fill_open_compat(struct fuse_open_out *arg,
1740 const struct fuse_file_info_compat *f)
1741 {
1742 arg->fh = f->fh;
1743 if (f->direct_io)
1744 arg->open_flags |= FOPEN_DIRECT_IO;
1745 if (f->keep_cache)
1746 arg->open_flags |= FOPEN_KEEP_CACHE;
1747 }
1748
1749 static void convert_statfs_compat(const struct statfs *compatbuf,
1750 struct statvfs *buf)
1751 {
1752 buf->f_bsize = compatbuf->f_bsize;
1753 buf->f_blocks = compatbuf->f_blocks;
1754 buf->f_bfree = compatbuf->f_bfree;
1755 buf->f_bavail = compatbuf->f_bavail;
1756 buf->f_files = compatbuf->f_files;
1757 buf->f_ffree = compatbuf->f_ffree;
1758 buf->f_namemax = compatbuf->f_namelen;
1759 }
1760
1761 int fuse_reply_open_compat(fuse_req_t req,
1762 const struct fuse_file_info_compat *f)
1763 {
1764 struct fuse_open_out arg;
1765
1766 memset(&arg, 0, sizeof(arg));
1767 fill_open_compat(&arg, f);
1768 return send_reply_ok(req, &arg, sizeof(arg));
1769 }
1770
1771 int fuse_reply_statfs_compat(fuse_req_t req, const struct statfs *stbuf)
1772 {
1773 struct statvfs newbuf;
1774
1775 memset(&newbuf, 0, sizeof(newbuf));
1776 convert_statfs_compat(stbuf, &newbuf);
1777
1778 return fuse_reply_statfs(req, &newbuf);
1779 }
1780
1781 struct fuse_session *fuse_lowlevel_new_compat(const char *opts,
1782 const struct fuse_lowlevel_ops_compat *op,
1783 size_t op_size, void *userdata)
1784 {
1785 struct fuse_session *se;
1786 struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
1787
1788 if (opts &&
1789 (fuse_opt_add_arg(&args, "") == -1 ||
1790 fuse_opt_add_arg(&args, "-o") == -1 ||
1791 fuse_opt_add_arg(&args, opts) == -1)) {
1792 fuse_opt_free_args(&args);
1793 return NULL;
1794 }
1795 se = fuse_lowlevel_new(&args, (const struct fuse_lowlevel_ops *) op,
1796 op_size, userdata);
1797 fuse_opt_free_args(&args);
1798
1799 return se;
1800 }
1801
1802 struct fuse_ll_compat_conf {
1803 unsigned max_read;
1804 int set_max_read;
1805 };
1806
1807 static const struct fuse_opt fuse_ll_opts_compat[] = {
1808 { "max_read=", offsetof(struct fuse_ll_compat_conf, set_max_read), 1 },
1809 { "max_read=%u", offsetof(struct fuse_ll_compat_conf, max_read), 0 },
1810 FUSE_OPT_KEY("max_read=", FUSE_OPT_KEY_KEEP),
1811 FUSE_OPT_END
1812 };
1813
1814 int fuse_sync_compat_args(struct fuse_args *args)
1815 {
1816 struct fuse_ll_compat_conf conf;
1817
1818 memset(&conf, 0, sizeof(conf));
1819 if (fuse_opt_parse(args, &conf, fuse_ll_opts_compat, NULL) == -1)
1820 return -1;
1821
1822 if (fuse_opt_insert_arg(args, 1, "-osync_read"))
1823 return -1;
1824
1825 if (conf.set_max_read) {
1826 char tmpbuf[64];
1827
1828 sprintf(tmpbuf, "-omax_readahead=%u", conf.max_read);
1829 if (fuse_opt_insert_arg(args, 1, tmpbuf) == -1)
1830 return -1;
1831 }
1832 return 0;
1833 }
1834
1835 FUSE_SYMVER(".symver fuse_reply_statfs_compat,fuse_reply_statfs@FUSE_2.4");
1836 FUSE_SYMVER(".symver fuse_reply_open_compat,fuse_reply_open@FUSE_2.4");
1837 FUSE_SYMVER(".symver fuse_lowlevel_new_compat,fuse_lowlevel_new@FUSE_2.4");
1838
1839 #else /* __FreeBSD__ */
1840
1841 int fuse_sync_compat_args(struct fuse_args *args)
1842 {
1843 (void) args;
1844 return 0;
1845 }
1846
1847 #endif /* __FreeBSD__ */
1848
1849 struct fuse_session *fuse_lowlevel_new_compat25(struct fuse_args *args,
1850 const struct fuse_lowlevel_ops_compat25 *op,
1851 size_t op_size, void *userdata)
1852 {
1853 if (fuse_sync_compat_args(args) == -1)
1854 return NULL;
1855
1856 return fuse_lowlevel_new_common(args,
1857 (const struct fuse_lowlevel_ops *) op,
1858 op_size, userdata);
1859 }
1860
1861 FUSE_SYMVER(".symver fuse_lowlevel_new_compat25,fuse_lowlevel_new@FUSE_2.5");
mirror for fuse