xref: /freebsd/sys/fs/fuse/fuse_file.c (revision d3d381b2b194b4d24853e92eecef55f262688d1a)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are
9  * met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above
14  *   copyright notice, this list of conditions and the following disclaimer
15  *   in the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of Google Inc. nor the names of its
18  *   contributors may be used to endorse or promote products derived from
19  *   this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Copyright (C) 2005 Csaba Henk.
34  * All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  * 1. Redistributions of source code must retain the above copyright
40  *    notice, this list of conditions and the following disclaimer.
41  * 2. Redistributions in binary form must reproduce the above copyright
42  *    notice, this list of conditions and the following disclaimer in the
43  *    documentation and/or other materials provided with the distribution.
44  *
45  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55  * SUCH DAMAGE.
56  */
57 
58 #include <sys/cdefs.h>
59 __FBSDID("$FreeBSD$");
60 
61 #include <sys/types.h>
62 #include <sys/module.h>
63 #include <sys/systm.h>
64 #include <sys/errno.h>
65 #include <sys/param.h>
66 #include <sys/kernel.h>
67 #include <sys/conf.h>
68 #include <sys/uio.h>
69 #include <sys/malloc.h>
70 #include <sys/queue.h>
71 #include <sys/lock.h>
72 #include <sys/sx.h>
73 #include <sys/mutex.h>
74 #include <sys/proc.h>
75 #include <sys/mount.h>
76 #include <sys/vnode.h>
77 #include <sys/sysctl.h>
78 
79 #include "fuse.h"
80 #include "fuse_file.h"
81 #include "fuse_internal.h"
82 #include "fuse_ipc.h"
83 #include "fuse_node.h"
84 
85 #define FUSE_DEBUG_MODULE FILE
86 #include "fuse_debug.h"
87 
88 static int fuse_fh_count = 0;
89 
90 SYSCTL_INT(_vfs_fuse, OID_AUTO, filehandle_count, CTLFLAG_RD,
91     &fuse_fh_count, 0, "");
92 
93 int
94 fuse_filehandle_open(struct vnode *vp,
95     fufh_type_t fufh_type,
96     struct fuse_filehandle **fufhp,
97     struct thread *td,
98     struct ucred *cred)
99 {
100 	struct fuse_dispatcher fdi;
101 	struct fuse_open_in *foi;
102 	struct fuse_open_out *foo;
103 
104 	int err = 0;
105 	int oflags = 0;
106 	int op = FUSE_OPEN;
107 
108 	fuse_trace_printf("fuse_filehandle_open(vp=%p, fufh_type=%d)\n",
109 	    vp, fufh_type);
110 
111 	if (fuse_filehandle_valid(vp, fufh_type)) {
112 		panic("FUSE: filehandle_open called despite valid fufh (type=%d)",
113 		    fufh_type);
114 		/* NOTREACHED */
115 	}
116 	/*
117          * Note that this means we are effectively FILTERING OUT open() flags.
118          */
119 	oflags = fuse_filehandle_xlate_to_oflags(fufh_type);
120 
121 	if (vnode_isdir(vp)) {
122 		op = FUSE_OPENDIR;
123 		if (fufh_type != FUFH_RDONLY) {
124 			printf("FUSE:non-rdonly fh requested for a directory?\n");
125 			fufh_type = FUFH_RDONLY;
126 		}
127 	}
128 	fdisp_init(&fdi, sizeof(*foi));
129 	fdisp_make_vp(&fdi, op, vp, td, cred);
130 
131 	foi = fdi.indata;
132 	foi->flags = oflags;
133 
134 	if ((err = fdisp_wait_answ(&fdi))) {
135 		debug_printf("OUCH ... daemon didn't give fh (err = %d)\n", err);
136 		if (err == ENOENT) {
137 			fuse_internal_vnode_disappear(vp);
138 		}
139 		goto out;
140 	}
141 	foo = fdi.answ;
142 
143 	fuse_filehandle_init(vp, fufh_type, fufhp, foo->fh);
144 
145 	/*
146 	 * For WRONLY opens, force DIRECT_IO.  This is necessary
147 	 * since writing a partial block through the buffer cache
148 	 * will result in a read of the block and that read won't
149 	 * be allowed by the WRONLY open.
150 	 */
151 	if (fufh_type == FUFH_WRONLY)
152 		fuse_vnode_open(vp, foo->open_flags | FOPEN_DIRECT_IO, td);
153 	else
154 		fuse_vnode_open(vp, foo->open_flags, td);
155 
156 out:
157 	fdisp_destroy(&fdi);
158 	return err;
159 }
160 
161 int
162 fuse_filehandle_close(struct vnode *vp,
163     fufh_type_t fufh_type,
164     struct thread *td,
165     struct ucred *cred)
166 {
167 	struct fuse_dispatcher fdi;
168 	struct fuse_release_in *fri;
169 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
170 	struct fuse_filehandle *fufh = NULL;
171 
172 	int err = 0;
173 	int op = FUSE_RELEASE;
174 
175 	fuse_trace_printf("fuse_filehandle_put(vp=%p, fufh_type=%d)\n",
176 	    vp, fufh_type);
177 
178 	fufh = &(fvdat->fufh[fufh_type]);
179 	if (!FUFH_IS_VALID(fufh)) {
180 		panic("FUSE: filehandle_put called on invalid fufh (type=%d)",
181 		    fufh_type);
182 		/* NOTREACHED */
183 	}
184 	if (fuse_isdeadfs(vp)) {
185 		goto out;
186 	}
187 	if (vnode_isdir(vp))
188 		op = FUSE_RELEASEDIR;
189 	fdisp_init(&fdi, sizeof(*fri));
190 	fdisp_make_vp(&fdi, op, vp, td, cred);
191 	fri = fdi.indata;
192 	fri->fh = fufh->fh_id;
193 	fri->flags = fuse_filehandle_xlate_to_oflags(fufh_type);
194 
195 	err = fdisp_wait_answ(&fdi);
196 	fdisp_destroy(&fdi);
197 
198 out:
199 	atomic_subtract_acq_int(&fuse_fh_count, 1);
200 	fufh->fh_id = (uint64_t)-1;
201 	fufh->fh_type = FUFH_INVALID;
202 
203 	return err;
204 }
205 
206 int
207 fuse_filehandle_valid(struct vnode *vp, fufh_type_t fufh_type)
208 {
209 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
210 	struct fuse_filehandle *fufh;
211 
212 	fufh = &(fvdat->fufh[fufh_type]);
213 	return FUFH_IS_VALID(fufh);
214 }
215 
216 /*
217  * Check for a valid file handle, first the type requested, but if that
218  * isn't valid, try for FUFH_RDWR.
219  * Return the FUFH type that is valid or FUFH_INVALID if there are none.
220  * This is a variant of fuse_filehandle_vaild() analogous to
221  * fuse_filehandle_getrw().
222  */
223 fufh_type_t
224 fuse_filehandle_validrw(struct vnode *vp, fufh_type_t fufh_type)
225 {
226 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
227 	struct fuse_filehandle *fufh;
228 
229 	fufh = &fvdat->fufh[fufh_type];
230 	if (FUFH_IS_VALID(fufh) != 0)
231 		return (fufh_type);
232 	fufh = &fvdat->fufh[FUFH_RDWR];
233 	if (FUFH_IS_VALID(fufh) != 0)
234 		return (FUFH_RDWR);
235 	return (FUFH_INVALID);
236 }
237 
238 int
239 fuse_filehandle_get(struct vnode *vp, fufh_type_t fufh_type,
240     struct fuse_filehandle **fufhp)
241 {
242 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
243 	struct fuse_filehandle *fufh;
244 
245 	fufh = &(fvdat->fufh[fufh_type]);
246 	if (!FUFH_IS_VALID(fufh))
247 		return EBADF;
248 	if (fufhp != NULL)
249 		*fufhp = fufh;
250 	return 0;
251 }
252 
253 int
254 fuse_filehandle_getrw(struct vnode *vp, fufh_type_t fufh_type,
255     struct fuse_filehandle **fufhp)
256 {
257 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
258 	struct fuse_filehandle *fufh;
259 
260 	fufh = &(fvdat->fufh[fufh_type]);
261 	if (!FUFH_IS_VALID(fufh)) {
262 		fufh_type = FUFH_RDWR;
263 	}
264 	return fuse_filehandle_get(vp, fufh_type, fufhp);
265 }
266 
267 void
268 fuse_filehandle_init(struct vnode *vp,
269     fufh_type_t fufh_type,
270     struct fuse_filehandle **fufhp,
271     uint64_t fh_id)
272 {
273 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
274 	struct fuse_filehandle *fufh;
275 
276 	FS_DEBUG("id=%jd type=%d\n", (intmax_t)fh_id, fufh_type);
277 	fufh = &(fvdat->fufh[fufh_type]);
278 	MPASS(!FUFH_IS_VALID(fufh));
279 	fufh->fh_id = fh_id;
280 	fufh->fh_type = fufh_type;
281 	if (!FUFH_IS_VALID(fufh)) {
282 		panic("FUSE: init: invalid filehandle id (type=%d)", fufh_type);
283 	}
284 	if (fufhp != NULL)
285 		*fufhp = fufh;
286 
287 	atomic_add_acq_int(&fuse_fh_count, 1);
288 }
289