1 |
/* |
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_ */ |