1 |
dpavlin |
4 |
/* |
2 |
|
|
FUSE: Filesystem in Userspace |
3 |
|
|
Copyright (C) 2001-2004 Miklos Szeredi <miklos@szeredi.hu> |
4 |
|
|
|
5 |
|
|
This program can be distributed under the terms of the GNU LGPL. |
6 |
|
|
See the file COPYING.LIB. |
7 |
|
|
*/ |
8 |
|
|
|
9 |
|
|
#ifndef _FUSE_H_ |
10 |
|
|
#define _FUSE_H_ |
11 |
|
|
|
12 |
|
|
/* This file defines the library interface of FUSE */ |
13 |
|
|
|
14 |
|
|
/** Major version of FUSE library interface */ |
15 |
|
|
#define FUSE_MAJOR_VERSION 2 |
16 |
|
|
|
17 |
|
|
/** Minor version of FUSE library interface */ |
18 |
|
|
#define FUSE_MINOR_VERSION 0 |
19 |
|
|
|
20 |
|
|
/* This interface uses 64 bit off_t */ |
21 |
|
|
#if _FILE_OFFSET_BITS != 64 |
22 |
|
|
#error Please add -D_FILE_OFFSET_BITS=64 to your compile flags! |
23 |
|
|
#endif |
24 |
|
|
|
25 |
|
|
#include <sys/types.h> |
26 |
|
|
#include <sys/stat.h> |
27 |
|
|
#include <sys/statfs.h> |
28 |
|
|
#include <utime.h> |
29 |
|
|
|
30 |
|
|
/* ----------------------------------------------------------- * |
31 |
|
|
* Basic FUSE API * |
32 |
|
|
* ----------------------------------------------------------- */ |
33 |
|
|
|
34 |
|
|
/** Handle for a FUSE filesystem */ |
35 |
|
|
struct fuse; |
36 |
|
|
|
37 |
|
|
/** Handle for a getdir() operation */ |
38 |
|
|
typedef struct fuse_dirhandle *fuse_dirh_t; |
39 |
|
|
|
40 |
|
|
/** Function to add an entry in a getdir() operation |
41 |
|
|
* |
42 |
|
|
* @param h the handle passed to the getdir() operation |
43 |
|
|
* @param name the file name of the directory entry |
44 |
|
|
* @param type the file type (0 if unknown) see <dirent.h> |
45 |
|
|
* @return 0 on success, -errno on error |
46 |
|
|
*/ |
47 |
|
|
typedef int (*fuse_dirfil_t) (fuse_dirh_t h, const char *name, int type); |
48 |
|
|
|
49 |
|
|
/** |
50 |
|
|
* The file system operations: |
51 |
|
|
* |
52 |
|
|
* Most of these should work very similarly to the well known UNIX |
53 |
|
|
* file system operations. Exceptions are: |
54 |
|
|
* |
55 |
|
|
* - All operations should return the negated error value (-errno) on |
56 |
|
|
* error. |
57 |
|
|
* |
58 |
|
|
* - Getattr() doesn't need to fill in the following fields: |
59 |
|
|
* st_ino |
60 |
|
|
* st_dev |
61 |
|
|
* st_blksize |
62 |
|
|
* |
63 |
|
|
* - readlink() should fill the buffer with a null terminated string. The |
64 |
|
|
* buffer size argument includes the space for the terminating null |
65 |
|
|
* character. If the linkname is too long to fit in the buffer, it should |
66 |
|
|
* be truncated. The return value should be 0 for success. |
67 |
|
|
* |
68 |
|
|
* - getdir() is the opendir(), readdir(), ..., closedir() sequence |
69 |
|
|
* in one call. For each directory entry the filldir parameter should |
70 |
|
|
* be called. |
71 |
|
|
* |
72 |
|
|
* - There is no create() operation, mknod() will be called for |
73 |
|
|
* creation of all non directory, non symlink nodes. |
74 |
|
|
* |
75 |
|
|
* - open() should not return a filehandle, but 0 on success. No |
76 |
|
|
* creation, or trunctation flags (O_CREAT, O_EXCL, O_TRUNC) will be |
77 |
|
|
* passed to open(). Open should only check if the operation is |
78 |
|
|
* permitted for the given flags. |
79 |
|
|
* |
80 |
|
|
* - read(), write() are not passed a filehandle, but rather a |
81 |
|
|
* pathname. The offset of the read and write is passed as the last |
82 |
|
|
* argument, like the pread() and pwrite() system calls. (NOTE: |
83 |
|
|
* read() should always return the number of bytes requested, except |
84 |
|
|
* at end of file) |
85 |
|
|
* |
86 |
|
|
* - release() is called when an open file has: |
87 |
|
|
* 1) all file descriptors closed |
88 |
|
|
* 2) all memory mappings unmapped |
89 |
|
|
* For every open() call there will be exactly one release() call |
90 |
|
|
* with the same flags. It is possible to have a file opened more |
91 |
|
|
* than once, in which case only the last release will mean, that no |
92 |
|
|
* more reads/writes will happen on the file. The return value of |
93 |
|
|
* release is ignored. Implementing this method is optional. |
94 |
|
|
* |
95 |
|
|
* - flush() is called when close() has been called on an open file. |
96 |
|
|
* NOTE: this does not mean that the file is released (e.g. after |
97 |
|
|
* fork() an open file will have two references which both must be |
98 |
|
|
* closed before the file is released). The flush() method may be |
99 |
|
|
* called more than once for each open(). The return value of |
100 |
|
|
* flush() is passed on to the close() system call. Implementing |
101 |
|
|
* this method is optional. |
102 |
|
|
* |
103 |
|
|
* - fsync() has a boolean 'datasync' parameter which if TRUE then do |
104 |
|
|
* an fdatasync() operation. Implementing this method is optional. |
105 |
|
|
*/ |
106 |
|
|
struct fuse_operations { |
107 |
|
|
int (*getattr) (const char *, struct stat *); |
108 |
|
|
int (*readlink) (const char *, char *, size_t); |
109 |
|
|
int (*getdir) (const char *, fuse_dirh_t, fuse_dirfil_t); |
110 |
|
|
int (*mknod) (const char *, mode_t, dev_t); |
111 |
|
|
int (*mkdir) (const char *, mode_t); |
112 |
|
|
int (*unlink) (const char *); |
113 |
|
|
int (*rmdir) (const char *); |
114 |
|
|
int (*symlink) (const char *, const char *); |
115 |
|
|
int (*rename) (const char *, const char *); |
116 |
|
|
int (*link) (const char *, const char *); |
117 |
|
|
int (*chmod) (const char *, mode_t); |
118 |
|
|
int (*chown) (const char *, uid_t, gid_t); |
119 |
|
|
int (*truncate) (const char *, off_t); |
120 |
|
|
int (*utime) (const char *, struct utimbuf *); |
121 |
|
|
int (*open) (const char *, int); |
122 |
|
|
int (*read) (const char *, char *, size_t, off_t); |
123 |
|
|
int (*write) (const char *, const char *, size_t, off_t); |
124 |
|
|
int (*statfs) (const char *, struct statfs *); |
125 |
|
|
int (*flush) (const char *); |
126 |
|
|
int (*release) (const char *, int); |
127 |
|
|
int (*fsync) (const char *, int); |
128 |
|
|
int (*setxattr) (const char *, const char *, const char *, size_t, int); |
129 |
|
|
int (*getxattr) (const char *, const char *, char *, size_t); |
130 |
|
|
int (*listxattr) (const char *, char *, size_t); |
131 |
|
|
int (*removexattr) (const char *, const char *); |
132 |
|
|
}; |
133 |
|
|
|
134 |
|
|
/** Extra context that may be needed by some filesystems */ |
135 |
|
|
struct fuse_context { |
136 |
|
|
uid_t uid; |
137 |
|
|
gid_t gid; |
138 |
|
|
}; |
139 |
|
|
|
140 |
|
|
#ifdef __cplusplus |
141 |
|
|
extern "C" { |
142 |
|
|
#endif |
143 |
|
|
|
144 |
|
|
/* |
145 |
|
|
* Main function of FUSE. |
146 |
|
|
* |
147 |
|
|
* This is for the lazy. This is all that has to be called from the |
148 |
|
|
* main() function. |
149 |
|
|
* |
150 |
|
|
* This function does the following: |
151 |
|
|
* - parses command line options (-d -s and -h) |
152 |
|
|
* - passes relevant mount options to the fuse_mount() |
153 |
|
|
* - installs signal handlers for INT, HUP, TERM and PIPE |
154 |
|
|
* - registers an exit handler to unmount the filesystem on program exit |
155 |
|
|
* - creates a fuse handle |
156 |
|
|
* - registers the operations |
157 |
|
|
* - calls either the single-threaded or the multi-threaded event loop |
158 |
|
|
* |
159 |
|
|
* @param argc the argument counter passed to the main() function |
160 |
|
|
* @param argv the argument vector passed to the main() function |
161 |
|
|
* @param op the file system operation |
162 |
|
|
*/ |
163 |
|
|
void fuse_main(int argc, char *argv[], const struct fuse_operations *op); |
164 |
|
|
|
165 |
|
|
/* |
166 |
|
|
* Returns the fuse object created by fuse_main() |
167 |
|
|
* |
168 |
|
|
* This is useful when fuse_get_context() is used. |
169 |
|
|
* |
170 |
|
|
* @return the fuse object |
171 |
|
|
*/ |
172 |
|
|
struct fuse *fuse_get(void); |
173 |
|
|
|
174 |
|
|
/** |
175 |
|
|
* Invalidate cached data of a file. |
176 |
|
|
* |
177 |
|
|
* Useful if the 'kernel_cache' mount option is given, since in that |
178 |
|
|
* case the cache is not invalidated on file open. |
179 |
|
|
* |
180 |
|
|
* @return 0 on success or -errno on failure |
181 |
|
|
*/ |
182 |
|
|
int fuse_invalidate(struct fuse *f, const char *path); |
183 |
|
|
|
184 |
|
|
/* ----------------------------------------------------------- * |
185 |
|
|
* More detailed API * |
186 |
|
|
* ----------------------------------------------------------- */ |
187 |
|
|
|
188 |
|
|
/* |
189 |
|
|
* Create a FUSE mountpoint |
190 |
|
|
* |
191 |
|
|
* Returns a control file descriptor suitable for passing to |
192 |
|
|
* fuse_new() |
193 |
|
|
* |
194 |
|
|
* @param mountpoint the mount point path |
195 |
|
|
* @param opts a comma separated list of mount options. Can be NULL. |
196 |
|
|
* @return the control file descriptor on success, -1 on failure |
197 |
|
|
*/ |
198 |
|
|
int fuse_mount(const char *mountpoint, const char *opts); |
199 |
|
|
|
200 |
|
|
/* |
201 |
|
|
* Umount a FUSE mountpoint |
202 |
|
|
* |
203 |
|
|
* @param mountpoint the mount point path |
204 |
|
|
*/ |
205 |
|
|
void fuse_unmount(const char *mountpoint); |
206 |
|
|
|
207 |
|
|
/** |
208 |
|
|
* Create a new FUSE filesystem. |
209 |
|
|
* |
210 |
|
|
* @param fd the control file descriptor |
211 |
|
|
* @param opts mount options to be used by the library |
212 |
|
|
* @param op the operations |
213 |
|
|
* @return the created FUSE handle |
214 |
|
|
*/ |
215 |
|
|
struct fuse *fuse_new(int fd, const char *opts, |
216 |
|
|
const struct fuse_operations *op); |
217 |
|
|
|
218 |
|
|
/** |
219 |
|
|
* Destroy the FUSE handle. |
220 |
|
|
* |
221 |
|
|
* The filesystem is not unmounted. |
222 |
|
|
* |
223 |
|
|
* @param f the FUSE handle |
224 |
|
|
*/ |
225 |
|
|
void fuse_destroy(struct fuse *f); |
226 |
|
|
|
227 |
|
|
/** |
228 |
|
|
* FUSE event loop. |
229 |
|
|
* |
230 |
|
|
* Requests from the kernel are processed, and the apropriate |
231 |
|
|
* operations are called. |
232 |
|
|
* |
233 |
|
|
* @param f the FUSE handle |
234 |
|
|
*/ |
235 |
|
|
void fuse_loop(struct fuse *f); |
236 |
|
|
|
237 |
|
|
/** |
238 |
|
|
* Exit from event loop |
239 |
|
|
* |
240 |
|
|
* @param f the FUSE handle |
241 |
|
|
*/ |
242 |
|
|
void fuse_exit(struct fuse *f); |
243 |
|
|
|
244 |
|
|
/** |
245 |
|
|
* FUSE event loop with multiple threads |
246 |
|
|
* |
247 |
|
|
* Requests from the kernel are processed, and the apropriate |
248 |
|
|
* operations are called. Request are processed in parallel by |
249 |
|
|
* distributing them between multiple threads. |
250 |
|
|
* |
251 |
|
|
* Calling this function requires the pthreads library to be linked to |
252 |
|
|
* the application. |
253 |
|
|
* |
254 |
|
|
* @param f the FUSE handle |
255 |
|
|
*/ |
256 |
|
|
void fuse_loop_mt(struct fuse *f); |
257 |
|
|
|
258 |
|
|
/** |
259 |
|
|
* Get the current context |
260 |
|
|
* |
261 |
|
|
* The context is only valid for the duration of a filesystem |
262 |
|
|
* operation, and thus must not be stored and used later. |
263 |
|
|
* |
264 |
|
|
* @param f the FUSE handle |
265 |
|
|
* @return the context |
266 |
|
|
*/ |
267 |
|
|
struct fuse_context *fuse_get_context(struct fuse *f); |
268 |
|
|
|
269 |
|
|
/** |
270 |
|
|
* Check whether a mount option should be passed to the kernel or the |
271 |
|
|
* library |
272 |
|
|
* |
273 |
|
|
* @param opt the option to check |
274 |
|
|
* @return 1 if it is a library option, 0 otherwise |
275 |
|
|
*/ |
276 |
|
|
int fuse_is_lib_option(const char *opt); |
277 |
|
|
|
278 |
|
|
|
279 |
|
|
/* ----------------------------------------------------------- * |
280 |
|
|
* Advanced API for event handling, don't worry about this... * |
281 |
|
|
* ----------------------------------------------------------- */ |
282 |
|
|
|
283 |
|
|
struct fuse_cmd; |
284 |
|
|
typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *); |
285 |
|
|
struct fuse_cmd *__fuse_read_cmd(struct fuse *f); |
286 |
|
|
void __fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd); |
287 |
|
|
void __fuse_loop_mt(struct fuse *f, fuse_processor_t proc, void *data); |
288 |
|
|
int __fuse_exited(struct fuse* f); |
289 |
|
|
|
290 |
|
|
#ifdef __cplusplus |
291 |
|
|
} |
292 |
|
|
#endif |
293 |
|
|
|
294 |
|
|
#endif /* _FUSE_H_ */ |