xref: /third_party/libfuse/lib/fuse.c

173 	fuse_req_t req;
188 	fuse_req_t req;
1499 static struct fuse *req_fuse(fuse_req_t req)
1501 	return (struct fuse *) fuse_req_userdata(req);
1516 static void fuse_interrupt(fuse_req_t req, void *d_)
1519 	struct fuse *f = req_fuse(req);
1538 static void fuse_do_finish_interrupt(struct fuse *f, fuse_req_t req,
1545 	fuse_req_interrupt_func(req, NULL, NULL);
1549 static void fuse_do_prepare_interrupt(fuse_req_t req, struct fuse_intr_data *d)
1554 	fuse_req_interrupt_func(req, fuse_interrupt, d);
1557 static inline void fuse_finish_interrupt(struct fuse *f, fuse_req_t req,
1561 		fuse_do_finish_interrupt(f, req, d);
1564 static inline void fuse_prepare_interrupt(struct fuse *f, fuse_req_t req,
1568 		fuse_do_prepare_interrupt(req, d);
2561 static struct fuse *req_fuse_prepare(fuse_req_t req)
2563 	struct fuse_context_i *c = fuse_create_context(req_fuse(req));
2564 	const struct fuse_ctx *ctx = fuse_req_ctx(req);
2565 	c->req = req;
2573 static inline void reply_err(fuse_req_t req, int err)
2576 	fuse_reply_err(req, -err);
2579 static void reply_entry(fuse_req_t req, const struct fuse_entry_param *e,
2583 		struct fuse *f = req_fuse(req);
2584 		if (fuse_reply_entry(req, e) == -ENOENT) {
2590 		reply_err(req, err);
2632 static void fuse_lib_lookup(fuse_req_t req, fuse_ino_t parent,
2635 	struct fuse *f = req_fuse_prepare(req);
2652 					reply_entry(req, &e, -ESTALE);
2671 		fuse_prepare_interrupt(f, req, &d);
2678 		fuse_finish_interrupt(f, req, &d);
2686 	reply_entry(req, &e, err);
2697 static void fuse_lib_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
2699 	do_forget(req_fuse(req), ino, nlookup);
2700 	fuse_reply_none(req);
2703 static void fuse_lib_forget_multi(fuse_req_t req, size_t count,
2706 	struct fuse *f = req_fuse(req);
2712 	fuse_reply_none(req);
2716 static void fuse_lib_getattr(fuse_req_t req, fuse_ino_t ino,
2719 	struct fuse *f = req_fuse_prepare(req);
2732 		fuse_prepare_interrupt(f, req, &d);
2734 		fuse_finish_interrupt(f, req, &d);
2748 		fuse_reply_attr(req, &buf, f->conf.attr_timeout);
2750 		reply_err(req, err);
2770 static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
2773 	struct fuse *f = req_fuse_prepare(req);
2785 		fuse_prepare_interrupt(f, req, &d);
2836 		fuse_finish_interrupt(f, req, &d);
2846 		fuse_reply_attr(req, &buf, f->conf.attr_timeout);
2848 		reply_err(req, err);
2851 static void fuse_lib_access(fuse_req_t req, fuse_ino_t ino, int mask)
2853 	struct fuse *f = req_fuse_prepare(req);
2861 		fuse_prepare_interrupt(f, req, &d);
2863 		fuse_finish_interrupt(f, req, &d);
2866 	reply_err(req, err);
2869 static void fuse_lib_readlink(fuse_req_t req, fuse_ino_t ino)
2871 	struct fuse *f = req_fuse_prepare(req);
2879 		fuse_prepare_interrupt(f, req, &d);
2881 		fuse_finish_interrupt(f, req, &d);
2886 		fuse_reply_readlink(req, linkname);
2888 		reply_err(req, err);
2891 static void fuse_lib_mknod(fuse_req_t req, fuse_ino_t parent, const char *name,
2894 	struct fuse *f = req_fuse_prepare(req);
2903 		fuse_prepare_interrupt(f, req, &d);
2923 		fuse_finish_interrupt(f, req, &d);
2926 	reply_entry(req, &e, err);
2929 static void fuse_lib_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
2932 	struct fuse *f = req_fuse_prepare(req);
2941 		fuse_prepare_interrupt(f, req, &d);
2945 		fuse_finish_interrupt(f, req, &d);
2948 	reply_entry(req, &e, err);
2951 static void fuse_lib_unlink(fuse_req_t req, fuse_ino_t parent,
2954 	struct fuse *f = req_fuse_prepare(req);
2963 		fuse_prepare_interrupt(f, req, &d);
2985 		fuse_finish_interrupt(f, req, &d);
2988 	reply_err(req, err);
2991 static void fuse_lib_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
2993 	struct fuse *f = req_fuse_prepare(req);
3002 		fuse_prepare_interrupt(f, req, &d);
3004 		fuse_finish_interrupt(f, req, &d);
3009 	reply_err(req, err);
3012 static void fuse_lib_symlink(fuse_req_t req, const char *linkname,
3015 	struct fuse *f = req_fuse_prepare(req);
3024 		fuse_prepare_interrupt(f, req, &d);
3028 		fuse_finish_interrupt(f, req, &d);
3031 	reply_entry(req, &e, err);
3034 static void fuse_lib_rename(fuse_req_t req, fuse_ino_t olddir,
3038 	struct fuse *f = req_fuse_prepare(req);
3050 		fuse_prepare_interrupt(f, req, &d);
3066 		fuse_finish_interrupt(f, req, &d);
3069 	reply_err(req, err);
3072 static void fuse_lib_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
3075 	struct fuse *f = req_fuse_prepare(req);
3086 		fuse_prepare_interrupt(f, req, &d);
3091 		fuse_finish_interrupt(f, req, &d);
3094 	reply_entry(req, &e, err);
3129 static void fuse_lib_create(fuse_req_t req, fuse_ino_t parent,
3133 	struct fuse *f = req_fuse_prepare(req);
3141 		fuse_prepare_interrupt(f, req, &d);
3161 		fuse_finish_interrupt(f, req, &d);
3167 		if (fuse_reply_create(req, &e, fi) == -ENOENT) {
3174 		reply_err(req, err);
3218 static void fuse_lib_open(fuse_req_t req, fuse_ino_t ino,
3221 	struct fuse *f = req_fuse_prepare(req);
3228 		fuse_prepare_interrupt(f, req, &d);
3247 		fuse_finish_interrupt(f, req, &d);
3253 		if (fuse_reply_open(req, fi) == -ENOENT) {
3259 		reply_err(req, err);
3264 static void fuse_lib_read(fuse_req_t req, fuse_ino_t ino, size_t size,
3267 	struct fuse *f = req_fuse_prepare(req);
3276 		fuse_prepare_interrupt(f, req, &d);
3278 		fuse_finish_interrupt(f, req, &d);
3283 		fuse_reply_data(req, buf, FUSE_BUF_SPLICE_MOVE);
3285 		reply_err(req, res);
3290 static void fuse_lib_write_buf(fuse_req_t req, fuse_ino_t ino,
3294 	struct fuse *f = req_fuse_prepare(req);
3302 		fuse_prepare_interrupt(f, req, &d);
3304 		fuse_finish_interrupt(f, req, &d);
3309 		fuse_reply_write(req, res);
3311 		reply_err(req, res);
3314 static void fuse_lib_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
3317 	struct fuse *f = req_fuse_prepare(req);
3325 		fuse_prepare_interrupt(f, req, &d);
3327 		fuse_finish_interrupt(f, req, &d);
3330 	reply_err(req, err);
3342 static void fuse_lib_opendir(fuse_req_t req, fuse_ino_t ino,
3345 	struct fuse *f = req_fuse_prepare(req);
3354 		reply_err(req, -ENOMEM);
3373 		fuse_prepare_interrupt(f, req, &d);
3375 		fuse_finish_interrupt(f, req, &d);
3381 		if (fuse_reply_open(req, llfi) == -ENOENT) {
3389 		reply_err(req, err);
3504 			fuse_add_direntry(dh->req, dh->contents + dh->len,
3581 			fuse_add_direntry_plus(dh->req, dh->contents + dh->len,
3607 static int readdir_fill(struct fuse *f, fuse_req_t req, fuse_ino_t ino,
3633 		dh->req = req;
3634 		fuse_prepare_interrupt(f, req, &d);
3636 		fuse_finish_interrupt(f, req, &d);
3637 		dh->req = NULL;
3647 static int readdir_fill_from_list(fuse_req_t req, struct fuse_dh *dh,
3676 			thislen = fuse_add_direntry_plus(req, p, rem,
3679 			thislen = fuse_add_direntry(req, p, rem,
3691 static void fuse_readdir_common(fuse_req_t req, fuse_ino_t ino, size_t size,
3695 	struct fuse *f = req_fuse_prepare(req);
3707 		err = readdir_fill(f, req, ino, size, off, dh, &fi, flags);
3709 			reply_err(req, err);
3715 		err = readdir_fill_from_list(req, dh, off, flags);
3717 			reply_err(req, err);
3721 	fuse_reply_buf(req, dh->contents, dh->len);
3726 static void fuse_lib_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
3729 	fuse_readdir_common(req, ino, size, off, llfi, 0);
3732 static void fuse_lib_readdirplus(fuse_req_t req, fuse_ino_t ino, size_t size,
3735 	fuse_readdir_common(req, ino, size, off, llfi, FUSE_READDIR_PLUS);
3738 static void fuse_lib_releasedir(fuse_req_t req, fuse_ino_t ino,
3741 	struct fuse *f = req_fuse_prepare(req);
3749 	fuse_prepare_interrupt(f, req, &d);
3751 	fuse_finish_interrupt(f, req, &d);
3760 	reply_err(req, 0);
3763 static void fuse_lib_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
3766 	struct fuse *f = req_fuse_prepare(req);
3776 		fuse_prepare_interrupt(f, req, &d);
3778 		fuse_finish_interrupt(f, req, &d);
3781 	reply_err(req, err);
3784 static void fuse_lib_statfs(fuse_req_t req, fuse_ino_t ino)
3786 	struct fuse *f = req_fuse_prepare(req);
3797 		fuse_prepare_interrupt(f, req, &d);
3799 		fuse_finish_interrupt(f, req, &d);
3804 		fuse_reply_statfs(req, &buf);
3806 		reply_err(req, err);
3809 static void fuse_lib_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
3812 	struct fuse *f = req_fuse_prepare(req);
3819 		fuse_prepare_interrupt(f, req, &d);
3821 		fuse_finish_interrupt(f, req, &d);
3824 	reply_err(req, err);
3827 static int common_getxattr(struct fuse *f, fuse_req_t req, fuse_ino_t ino,
3836 		fuse_prepare_interrupt(f, req, &d);
3838 		fuse_finish_interrupt(f, req, &d);
3844 static void fuse_lib_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
3847 	struct fuse *f = req_fuse_prepare(req);
3853 			reply_err(req, -ENOMEM);
3856 		res = common_getxattr(f, req, ino, name, value, size);
3858 			fuse_reply_buf(req, value, res);
3860 			reply_err(req, res);
3863 		res = common_getxattr(f, req, ino, name, NULL, 0);
3865 			fuse_reply_xattr(req, res);
3867 			reply_err(req, res);
3871 static int common_listxattr(struct fuse *f, fuse_req_t req, fuse_ino_t ino,
3880 		fuse_prepare_interrupt(f, req, &d);
3882 		fuse_finish_interrupt(f, req, &d);
3888 static void fuse_lib_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
3890 	struct fuse *f = req_fuse_prepare(req);
3896 			reply_err(req, -ENOMEM);
3899 		res = common_listxattr(f, req, ino, list, size);
3901 			fuse_reply_buf(req, list, res);
3903 			reply_err(req, res);
3906 		res = common_listxattr(f, req, ino, NULL, 0);
3908 			fuse_reply_xattr(req, res);
3910 			reply_err(req, res);
3914 static void fuse_lib_removexattr(fuse_req_t req, fuse_ino_t ino,
3917 	struct fuse *f = req_fuse_prepare(req);
3924 		fuse_prepare_interrupt(f, req, &d);
3926 		fuse_finish_interrupt(f, req, &d);
3929 	reply_err(req, err);
4051 static int fuse_flush_common(struct fuse *f, fuse_req_t req, fuse_ino_t ino,
4060 	fuse_prepare_interrupt(f, req, &d);
4066 	fuse_finish_interrupt(f, req, &d);
4083 static void fuse_lib_release(fuse_req_t req, fuse_ino_t ino,
4086 	struct fuse *f = req_fuse_prepare(req);
4093 		err = fuse_flush_common(f, req, ino, path, fi);
4098 	fuse_prepare_interrupt(f, req, &d);
4100 	fuse_finish_interrupt(f, req, &d);
4103 	reply_err(req, err);
4106 static void fuse_lib_flush(fuse_req_t req, fuse_ino_t ino,
4109 	struct fuse *f = req_fuse_prepare(req);
4114 	err = fuse_flush_common(f, req, ino, path, fi);
4117 	reply_err(req, err);
4120 static int fuse_lock_common(fuse_req_t req, fuse_ino_t ino,
4124 	struct fuse *f = req_fuse_prepare(req);
4131 		fuse_prepare_interrupt(f, req, &d);
4133 		fuse_finish_interrupt(f, req, &d);
4139 static void fuse_lib_getlk(fuse_req_t req, fuse_ino_t ino,
4145 	struct fuse *f = req_fuse(req);
4155 		err = fuse_lock_common(req, ino, fi, lock, F_GETLK);
4160 		fuse_reply_lock(req, lock);
4162 		reply_err(req, err);
4165 static void fuse_lib_setlk(fuse_req_t req, fuse_ino_t ino,
4169 	int err = fuse_lock_common(req, ino, fi, lock,
4172 		struct fuse *f = req_fuse(req);
4180 	reply_err(req, err);
4183 static void fuse_lib_flock(fuse_req_t req, fuse_ino_t ino,
4186 	struct fuse *f = req_fuse_prepare(req);
4193 		fuse_prepare_interrupt(f, req, &d);
4195 		fuse_finish_interrupt(f, req, &d);
4198 	reply_err(req, err);
4201 static void fuse_lib_bmap(fuse_req_t req, fuse_ino_t ino, size_t blocksize,
4204 	struct fuse *f = req_fuse_prepare(req);
4211 		fuse_prepare_interrupt(f, req, &d);
4213 		fuse_finish_interrupt(f, req, &d);
4217 		fuse_reply_bmap(req, idx);
4219 		reply_err(req, err);
4222 static void fuse_lib_ioctl(fuse_req_t req, fuse_ino_t ino, unsigned int cmd,
4227 	struct fuse *f = req_fuse_prepare(req);
4257 	fuse_prepare_interrupt(f, req, &d);
4262 	fuse_finish_interrupt(f, req, &d);
4267 	fuse_reply_ioctl(req, err, out_buf, out_bufsz);
4270 	reply_err(req, err);
4275 static void fuse_lib_poll(fuse_req_t req, fuse_ino_t ino,
4278 	struct fuse *f = req_fuse_prepare(req);
4286 		fuse_prepare_interrupt(f, req, &d);
4288 		fuse_finish_interrupt(f, req, &d);
4292 		fuse_reply_poll(req, revents);
4294 		reply_err(req, err);
4297 static void fuse_lib_fallocate(fuse_req_t req, fuse_ino_t ino, int mode,
4300 	struct fuse *f = req_fuse_prepare(req);
4307 		fuse_prepare_interrupt(f, req, &d);
4309 		fuse_finish_interrupt(f, req, &d);
4312 	reply_err(req, err);
4315 static void fuse_lib_copy_file_range(fuse_req_t req, fuse_ino_t nodeid_in,
4321 	struct fuse *f = req_fuse_prepare(req);
4329 		reply_err(req, err);
4336 		reply_err(req, err);
4340 	fuse_prepare_interrupt(f, req, &d);
4343 	fuse_finish_interrupt(f, req, &d);
4346 		fuse_reply_write(req, res);
4348 		reply_err(req, res);
4354 static void fuse_lib_lseek(fuse_req_t req, fuse_ino_t ino, off_t off, int whence,
4357 	struct fuse *f = req_fuse_prepare(req);
4365 		reply_err(req, err);
4369 	fuse_prepare_interrupt(f, req, &d);
4371 	fuse_finish_interrupt(f, req, &d);
4374 		fuse_reply_lseek(req, res);
4376 		reply_err(req, res);
4624 	return fuse_req_getgroups(c->req, size, list);
4632 		return fuse_req_interrupted(c->req);

Indexes created Thu Nov 07 10:32:03 CST 2024