fuse_i.h 9.98 KB
Newer Older
Miklos Szeredi's avatar
Miklos Szeredi committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
  FUSE: Filesystem in Userspace
  Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>

  This program can be distributed under the terms of the GNU GPL.
  See the file COPYING.
*/

#include <linux/fuse.h>
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/mm.h>
#include <linux/backing-dev.h>
#include <asm/semaphore.h>

18
19
20
21
22
23
/** Max number of pages that can be used in a single read request */
#define FUSE_MAX_PAGES_PER_REQ 32

/** If more requests are outstanding, then the operation will block */
#define FUSE_MAX_OUTSTANDING 10

Miklos Szeredi's avatar
Miklos Szeredi committed
24
25
26
27
28
29
30
31
32
/** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
    module will check permissions based on the file mode.  Otherwise no
    permission checking is done in the kernel */
#define FUSE_DEFAULT_PERMISSIONS (1 << 0)

/** If the FUSE_ALLOW_OTHER flag is given, then not only the user
    doing the mount will be allowed to access the filesystem */
#define FUSE_ALLOW_OTHER         (1 << 1)

Miklos Szeredi's avatar
Miklos Szeredi committed
33

Miklos Szeredi's avatar
Miklos Szeredi committed
34
35
36
37
38
39
40
41
42
/** FUSE inode */
struct fuse_inode {
	/** Inode data */
	struct inode inode;

	/** Unique ID, which identifies the inode between userspace
	 * and kernel */
	u64 nodeid;

43
44
45
	/** Number of lookups on this inode */
	u64 nlookup;

46
47
48
	/** The request used for sending the FORGET message */
	struct fuse_req *forget_req;

Miklos Szeredi's avatar
Miklos Szeredi committed
49
50
51
52
	/** Time in jiffies until the file attributes are valid */
	unsigned long i_time;
};

53
54
55
56
57
58
59
60
61
/** FUSE specific file data */
struct fuse_file {
	/** Request reserved for flush and release */
	struct fuse_req *release_req;

	/** File handle used by userspace */
	u64 fh;
};

62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
/** One input argument of a request */
struct fuse_in_arg {
	unsigned size;
	const void *value;
};

/** The request input */
struct fuse_in {
	/** The request header */
	struct fuse_in_header h;

	/** True if the data for the last argument is in req->pages */
	unsigned argpages:1;

	/** Number of arguments */
	unsigned numargs;

	/** Array of arguments */
	struct fuse_in_arg args[3];
};

/** One output argument of a request */
struct fuse_arg {
	unsigned size;
	void *value;
};

/** The request output */
struct fuse_out {
	/** Header returned from userspace */
	struct fuse_out_header h;

	/** Last argument is variable length (can be shorter than
	    arg->size) */
	unsigned argvar:1;

	/** Last argument is a list of pages to copy data to */
	unsigned argpages:1;

	/** Zero partially or not copied pages */
	unsigned page_zeroing:1;

	/** Number or arguments */
	unsigned numargs;

	/** Array of arguments */
	struct fuse_arg args[3];
};

struct fuse_req;
struct fuse_conn;

/**
 * A request to the client
 */
struct fuse_req {
	/** This can be on either unused_list, pending or processing
	    lists in fuse_conn */
	struct list_head list;

Miklos Szeredi's avatar
Miklos Szeredi committed
122
123
124
	/** Entry on the background list */
	struct list_head bg_entry;

125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
	/** refcount */
	atomic_t count;

	/** True if the request has reply */
	unsigned isreply:1;

	/** The request is preallocated */
	unsigned preallocated:1;

	/** The request was interrupted */
	unsigned interrupted:1;

	/** Request is sent in the background */
	unsigned background:1;

	/** Data is being copied to/from the request */
	unsigned locked:1;

	/** Request has been sent to userspace */
	unsigned sent:1;

	/** The request is finished */
	unsigned finished:1;

	/** The request input */
	struct fuse_in in;

	/** The request output */
	struct fuse_out out;

	/** Used to wake up the task waiting for completion of request*/
	wait_queue_head_t waitq;

	/** Data for asynchronous requests */
	union {
160
		struct fuse_forget_in forget_in;
161
		struct fuse_release_in release_in;
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
		struct fuse_init_in_out init_in_out;
	} misc;

	/** page vector */
	struct page *pages[FUSE_MAX_PAGES_PER_REQ];

	/** number of pages in vector */
	unsigned num_pages;

	/** offset of data on first page */
	unsigned page_offset;

	/** Inode used in the request */
	struct inode *inode;

	/** Second inode used in the request (or NULL) */
	struct inode *inode2;

	/** File used in the request (or NULL) */
	struct file *file;
};

Miklos Szeredi's avatar
Miklos Szeredi committed
184
185
186
187
188
189
190
191
/**
 * A Fuse connection.
 *
 * This structure is created, when the filesystem is mounted, and is
 * destroyed, when the client device is closed and the filesystem is
 * unmounted.
 */
struct fuse_conn {
Miklos Szeredi's avatar
Miklos Szeredi committed
192
193
	/** Reference count */
	int count;
194

Miklos Szeredi's avatar
Miklos Szeredi committed
195
196
197
	/** The user id for this mount */
	uid_t user_id;

198
199
200
	/** The group id for this mount */
	gid_t group_id;

Miklos Szeredi's avatar
Miklos Szeredi committed
201
202
203
	/** The fuse mount flags for this mount */
	unsigned flags;

204
205
206
	/** Maximum read size */
	unsigned max_read;

Miklos Szeredi's avatar
Miklos Szeredi committed
207
208
209
	/** Maximum write size */
	unsigned max_write;

210
211
212
213
214
215
216
217
218
	/** Readers of the connection are waiting on this */
	wait_queue_head_t waitq;

	/** The list of pending requests */
	struct list_head pending;

	/** The list of requests being processed */
	struct list_head processing;

Miklos Szeredi's avatar
Miklos Szeredi committed
219
220
221
222
	/** Requests put in the background (RELEASE or any other
	    interrupted request) */
	struct list_head background;

223
224
225
226
227
228
229
	/** Controls the maximum number of outstanding requests */
	struct semaphore outstanding_sem;

	/** This counts the number of outstanding requests if
	    outstanding_sem would go negative */
	unsigned outstanding_debt;

Miklos Szeredi's avatar
Miklos Szeredi committed
230
231
232
	/** RW semaphore for exclusion with fuse_put_super() */
	struct rw_semaphore sbput_sem;

233
234
235
236
237
238
	/** The list of unused requests */
	struct list_head unused_list;

	/** The next unique request id */
	u64 reqctr;

Miklos Szeredi's avatar
Miklos Szeredi committed
239
240
241
242
243
244
	/** Mount is active */
	unsigned mounted : 1;

	/** Connection established */
	unsigned connected : 1;

245
246
247
	/** Connection failed (version mismatch) */
	unsigned conn_error : 1;

248
249
250
	/** Is fsync not implemented by fs? */
	unsigned no_fsync : 1;

251
252
253
	/** Is fsyncdir not implemented by fs? */
	unsigned no_fsyncdir : 1;

254
255
256
	/** Is flush not implemented by fs? */
	unsigned no_flush : 1;

257
258
259
260
261
262
263
264
265
266
267
268
	/** Is setxattr not implemented by fs? */
	unsigned no_setxattr : 1;

	/** Is getxattr not implemented by fs? */
	unsigned no_getxattr : 1;

	/** Is listxattr not implemented by fs? */
	unsigned no_listxattr : 1;

	/** Is removexattr not implemented by fs? */
	unsigned no_removexattr : 1;

Miklos Szeredi's avatar
Miklos Szeredi committed
269
270
271
	/** Is access not implemented by fs? */
	unsigned no_access : 1;

Miklos Szeredi's avatar
Miklos Szeredi committed
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
	/** Backing dev info */
	struct backing_dev_info bdi;
};

static inline struct fuse_conn **get_fuse_conn_super_p(struct super_block *sb)
{
	return (struct fuse_conn **) &sb->s_fs_info;
}

static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
{
	return *get_fuse_conn_super_p(sb);
}

static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
{
	return get_fuse_conn_super(inode->i_sb);
}

static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
{
	return container_of(inode, struct fuse_inode, inode);
}

static inline u64 get_node_id(struct inode *inode)
{
	return get_fuse_inode(inode)->nodeid;
}

301
302
303
/** Device operations */
extern struct file_operations fuse_dev_operations;

Miklos Szeredi's avatar
Miklos Szeredi committed
304
305
306
307
308
/**
 * This is the single global spinlock which protects FUSE's structures
 *
 * The following data is protected by this lock:
 *
309
 *  - the private_data field of the device file
Miklos Szeredi's avatar
Miklos Szeredi committed
310
 *  - the s_fs_info field of the super block
311
 *  - unused_list, pending, processing lists in fuse_conn
Miklos Szeredi's avatar
Miklos Szeredi committed
312
 *  - background list in fuse_conn
313
 *  - the unique request ID counter reqctr in fuse_conn
Miklos Szeredi's avatar
Miklos Szeredi committed
314
 *  - the sb (super_block) field in fuse_conn
315
 *  - the file (device file) field in fuse_conn
Miklos Szeredi's avatar
Miklos Szeredi committed
316
317
318
 */
extern spinlock_t fuse_lock;

319
320
321
322
/**
 * Get a filled in inode
 */
struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
323
			int generation, struct fuse_attr *attr);
324
325
326
327
328

/**
 * Send FORGET command
 */
void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
329
		      unsigned long nodeid, u64 nlookup);
330

331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
/**
 * Send READ or READDIR request
 */
size_t fuse_send_read_common(struct fuse_req *req, struct file *file,
			     struct inode *inode, loff_t pos, size_t count,
			     int isdir);

/**
 * Send OPEN or OPENDIR request
 */
int fuse_open_common(struct inode *inode, struct file *file, int isdir);

/**
 * Send RELEASE or RELEASEDIR request
 */
int fuse_release_common(struct inode *inode, struct file *file, int isdir);

348
349
350
351
352
353
/**
 * Send FSYNC or FSYNCDIR request
 */
int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
		      int isdir);

354
/**
Miklos Szeredi's avatar
Miklos Szeredi committed
355
 * Initialize file operations on a regular file
356
357
358
 */
void fuse_init_file_inode(struct inode *inode);

359
/**
Miklos Szeredi's avatar
Miklos Szeredi committed
360
 * Initialize inode operations on regular files and special files
361
362
363
364
 */
void fuse_init_common(struct inode *inode);

/**
Miklos Szeredi's avatar
Miklos Szeredi committed
365
 * Initialize inode and file operations on a directory
366
367
368
369
 */
void fuse_init_dir(struct inode *inode);

/**
Miklos Szeredi's avatar
Miklos Szeredi committed
370
 * Initialize inode operations on a symlink
371
372
373
374
375
376
377
378
 */
void fuse_init_symlink(struct inode *inode);

/**
 * Change attributes of an inode
 */
void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr);

Miklos Szeredi's avatar
Miklos Szeredi committed
379
380
381
382
383
384
/**
 * Check if the connection can be released, and if yes, then free the
 * connection structure
 */
void fuse_release_conn(struct fuse_conn *fc);

385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
/**
 * Initialize the client device
 */
int fuse_dev_init(void);

/**
 * Cleanup the client device
 */
void fuse_dev_cleanup(void);

/**
 * Allocate a request
 */
struct fuse_req *fuse_request_alloc(void);

/**
 * Free a request
 */
void fuse_request_free(struct fuse_req *req);

/**
 * Reinitialize a request, the preallocated flag is left unmodified
 */
void fuse_reset_request(struct fuse_req *req);

/**
 * Reserve a preallocated request
 */
struct fuse_req *fuse_get_request(struct fuse_conn *fc);

/**
 * Decrement reference count of a request.  If count goes to zero put
Miklos Szeredi's avatar
Miklos Szeredi committed
417
 * on unused list (preallocated) or free request (not preallocated).
418
419
420
421
 */
void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);

/**
422
 * Send a request (synchronous)
423
424
425
426
427
428
429
430
431
432
433
434
435
 */
void request_send(struct fuse_conn *fc, struct fuse_req *req);

/**
 * Send a request with no reply
 */
void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req);

/**
 * Send a request in the background
 */
void request_send_background(struct fuse_conn *fc, struct fuse_req *req);

Miklos Szeredi's avatar
Miklos Szeredi committed
436
/**
Miklos Szeredi's avatar
Miklos Szeredi committed
437
 * Release inodes and file associated with background request
Miklos Szeredi's avatar
Miklos Szeredi committed
438
439
440
 */
void fuse_release_background(struct fuse_req *req);

441
442
443
444
445
446
447
448
449
450
/**
 * Get the attributes of a file
 */
int fuse_do_getattr(struct inode *inode);

/**
 * Invalidate inode attributes
 */
void fuse_invalidate_attr(struct inode *inode);

451
452
453
454
/**
 * Send the INIT message
 */
void fuse_send_init(struct fuse_conn *fc);