1 /* 2 FUSE: Filesystem in Userspace 3 Copyright (C) 2001-2005 Miklos Szeredi <miklos@szeredi.hu> 4 5 This program can be distributed under the terms of the GNU GPL. 6 See the file COPYING. 7 */ 8 9 #include <linux/fuse.h> 10 #include <linux/fs.h> 11 #include <linux/wait.h> 12 #include <linux/list.h> 13 #include <linux/spinlock.h> 14 #include <linux/mm.h> 15 #include <linux/backing-dev.h> 16 #include <asm/semaphore.h> 17 18 /** Max number of pages that can be used in a single read request */ 19 #define FUSE_MAX_PAGES_PER_REQ 32 20 21 /** If more requests are outstanding, then the operation will block */ 22 #define FUSE_MAX_OUTSTANDING 10 23 24 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem 25 module will check permissions based on the file mode. Otherwise no 26 permission checking is done in the kernel */ 27 #define FUSE_DEFAULT_PERMISSIONS (1 << 0) 28 29 /** If the FUSE_ALLOW_OTHER flag is given, then not only the user 30 doing the mount will be allowed to access the filesystem */ 31 #define FUSE_ALLOW_OTHER (1 << 1) 32 33 34 /** FUSE inode */ 35 struct fuse_inode { 36 /** Inode data */ 37 struct inode inode; 38 39 /** Unique ID, which identifies the inode between userspace 40 * and kernel */ 41 u64 nodeid; 42 43 /** Number of lookups on this inode */ 44 u64 nlookup; 45 46 /** The request used for sending the FORGET message */ 47 struct fuse_req *forget_req; 48 49 /** Time in jiffies until the file attributes are valid */ 50 unsigned long i_time; 51 }; 52 53 /** FUSE specific file data */ 54 struct fuse_file { 55 /** Request reserved for flush and release */ 56 struct fuse_req *release_req; 57 58 /** File handle used by userspace */ 59 u64 fh; 60 }; 61 62 /** One input argument of a request */ 63 struct fuse_in_arg { 64 unsigned size; 65 const void *value; 66 }; 67 68 /** The request input */ 69 struct fuse_in { 70 /** The request header */ 71 struct fuse_in_header h; 72 73 /** True if the data for the last argument is in req->pages */ 74 unsigned argpages:1; 75 76 /** Number of arguments */ 77 unsigned numargs; 78 79 /** Array of arguments */ 80 struct fuse_in_arg args[3]; 81 }; 82 83 /** One output argument of a request */ 84 struct fuse_arg { 85 unsigned size; 86 void *value; 87 }; 88 89 /** The request output */ 90 struct fuse_out { 91 /** Header returned from userspace */ 92 struct fuse_out_header h; 93 94 /** Last argument is variable length (can be shorter than 95 arg->size) */ 96 unsigned argvar:1; 97 98 /** Last argument is a list of pages to copy data to */ 99 unsigned argpages:1; 100 101 /** Zero partially or not copied pages */ 102 unsigned page_zeroing:1; 103 104 /** Number or arguments */ 105 unsigned numargs; 106 107 /** Array of arguments */ 108 struct fuse_arg args[3]; 109 }; 110 111 struct fuse_req; 112 struct fuse_conn; 113 114 /** 115 * A request to the client 116 */ 117 struct fuse_req { 118 /** This can be on either unused_list, pending or processing 119 lists in fuse_conn */ 120 struct list_head list; 121 122 /** Entry on the background list */ 123 struct list_head bg_entry; 124 125 /** refcount */ 126 atomic_t count; 127 128 /** True if the request has reply */ 129 unsigned isreply:1; 130 131 /** The request is preallocated */ 132 unsigned preallocated:1; 133 134 /** The request was interrupted */ 135 unsigned interrupted:1; 136 137 /** Request is sent in the background */ 138 unsigned background:1; 139 140 /** Data is being copied to/from the request */ 141 unsigned locked:1; 142 143 /** Request has been sent to userspace */ 144 unsigned sent:1; 145 146 /** The request is finished */ 147 unsigned finished:1; 148 149 /** The request input */ 150 struct fuse_in in; 151 152 /** The request output */ 153 struct fuse_out out; 154 155 /** Used to wake up the task waiting for completion of request*/ 156 wait_queue_head_t waitq; 157 158 /** Data for asynchronous requests */ 159 union { 160 struct fuse_forget_in forget_in; 161 struct fuse_release_in release_in; 162 struct fuse_init_in_out init_in_out; 163 } misc; 164 165 /** page vector */ 166 struct page *pages[FUSE_MAX_PAGES_PER_REQ]; 167 168 /** number of pages in vector */ 169 unsigned num_pages; 170 171 /** offset of data on first page */ 172 unsigned page_offset; 173 174 /** Inode used in the request */ 175 struct inode *inode; 176 177 /** Second inode used in the request (or NULL) */ 178 struct inode *inode2; 179 180 /** File used in the request (or NULL) */ 181 struct file *file; 182 }; 183 184 /** 185 * A Fuse connection. 186 * 187 * This structure is created, when the filesystem is mounted, and is 188 * destroyed, when the client device is closed and the filesystem is 189 * unmounted. 190 */ 191 struct fuse_conn { 192 /** Reference count */ 193 int count; 194 195 /** The user id for this mount */ 196 uid_t user_id; 197 198 /** The group id for this mount */ 199 gid_t group_id; 200 201 /** The fuse mount flags for this mount */ 202 unsigned flags; 203 204 /** Maximum read size */ 205 unsigned max_read; 206 207 /** Maximum write size */ 208 unsigned max_write; 209 210 /** Readers of the connection are waiting on this */ 211 wait_queue_head_t waitq; 212 213 /** The list of pending requests */ 214 struct list_head pending; 215 216 /** The list of requests being processed */ 217 struct list_head processing; 218 219 /** Requests put in the background (RELEASE or any other 220 interrupted request) */ 221 struct list_head background; 222 223 /** Controls the maximum number of outstanding requests */ 224 struct semaphore outstanding_sem; 225 226 /** This counts the number of outstanding requests if 227 outstanding_sem would go negative */ 228 unsigned outstanding_debt; 229 230 /** RW semaphore for exclusion with fuse_put_super() */ 231 struct rw_semaphore sbput_sem; 232 233 /** The list of unused requests */ 234 struct list_head unused_list; 235 236 /** The next unique request id */ 237 u64 reqctr; 238 239 /** Mount is active */ 240 unsigned mounted : 1; 241 242 /** Connection established */ 243 unsigned connected : 1; 244 245 /** Connection failed (version mismatch) */ 246 unsigned conn_error : 1; 247 248 /** Is fsync not implemented by fs? */ 249 unsigned no_fsync : 1; 250 251 /** Is fsyncdir not implemented by fs? */ 252 unsigned no_fsyncdir : 1; 253 254 /** Is flush not implemented by fs? */ 255 unsigned no_flush : 1; 256 257 /** Is setxattr not implemented by fs? */ 258 unsigned no_setxattr : 1; 259 260 /** Is getxattr not implemented by fs? */ 261 unsigned no_getxattr : 1; 262 263 /** Is listxattr not implemented by fs? */ 264 unsigned no_listxattr : 1; 265 266 /** Is removexattr not implemented by fs? */ 267 unsigned no_removexattr : 1; 268 269 /** Is access not implemented by fs? */ 270 unsigned no_access : 1; 271 272 /** Is create not implemented by fs? */ 273 unsigned no_create : 1; 274 275 /** Backing dev info */ 276 struct backing_dev_info bdi; 277 }; 278 279 static inline struct fuse_conn **get_fuse_conn_super_p(struct super_block *sb) 280 { 281 return (struct fuse_conn **) &sb->s_fs_info; 282 } 283 284 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 285 { 286 return *get_fuse_conn_super_p(sb); 287 } 288 289 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 290 { 291 return get_fuse_conn_super(inode->i_sb); 292 } 293 294 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 295 { 296 return container_of(inode, struct fuse_inode, inode); 297 } 298 299 static inline u64 get_node_id(struct inode *inode) 300 { 301 return get_fuse_inode(inode)->nodeid; 302 } 303 304 /** Device operations */ 305 extern struct file_operations fuse_dev_operations; 306 307 /** 308 * This is the single global spinlock which protects FUSE's structures 309 * 310 * The following data is protected by this lock: 311 * 312 * - the private_data field of the device file 313 * - the s_fs_info field of the super block 314 * - unused_list, pending, processing lists in fuse_conn 315 * - background list in fuse_conn 316 * - the unique request ID counter reqctr in fuse_conn 317 * - the sb (super_block) field in fuse_conn 318 * - the file (device file) field in fuse_conn 319 */ 320 extern spinlock_t fuse_lock; 321 322 /** 323 * Get a filled in inode 324 */ 325 struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid, 326 int generation, struct fuse_attr *attr); 327 328 /** 329 * Send FORGET command 330 */ 331 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req, 332 unsigned long nodeid, u64 nlookup); 333 334 /** 335 * Send READ or READDIR request 336 */ 337 size_t fuse_send_read_common(struct fuse_req *req, struct file *file, 338 struct inode *inode, loff_t pos, size_t count, 339 int isdir); 340 341 /** 342 * Send OPEN or OPENDIR request 343 */ 344 int fuse_open_common(struct inode *inode, struct file *file, int isdir); 345 346 struct fuse_file *fuse_file_alloc(void); 347 void fuse_file_free(struct fuse_file *ff); 348 void fuse_finish_open(struct inode *inode, struct file *file, 349 struct fuse_file *ff, struct fuse_open_out *outarg); 350 351 /** 352 * Send a RELEASE request 353 */ 354 void fuse_send_release(struct fuse_conn *fc, struct fuse_file *ff, 355 u64 nodeid, struct inode *inode, int flags, int isdir); 356 357 /** 358 * Send RELEASE or RELEASEDIR request 359 */ 360 int fuse_release_common(struct inode *inode, struct file *file, int isdir); 361 362 /** 363 * Send FSYNC or FSYNCDIR request 364 */ 365 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync, 366 int isdir); 367 368 /** 369 * Initialize file operations on a regular file 370 */ 371 void fuse_init_file_inode(struct inode *inode); 372 373 /** 374 * Initialize inode operations on regular files and special files 375 */ 376 void fuse_init_common(struct inode *inode); 377 378 /** 379 * Initialize inode and file operations on a directory 380 */ 381 void fuse_init_dir(struct inode *inode); 382 383 /** 384 * Initialize inode operations on a symlink 385 */ 386 void fuse_init_symlink(struct inode *inode); 387 388 /** 389 * Change attributes of an inode 390 */ 391 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr); 392 393 /** 394 * Check if the connection can be released, and if yes, then free the 395 * connection structure 396 */ 397 void fuse_release_conn(struct fuse_conn *fc); 398 399 /** 400 * Initialize the client device 401 */ 402 int fuse_dev_init(void); 403 404 /** 405 * Cleanup the client device 406 */ 407 void fuse_dev_cleanup(void); 408 409 /** 410 * Allocate a request 411 */ 412 struct fuse_req *fuse_request_alloc(void); 413 414 /** 415 * Free a request 416 */ 417 void fuse_request_free(struct fuse_req *req); 418 419 /** 420 * Reinitialize a request, the preallocated flag is left unmodified 421 */ 422 void fuse_reset_request(struct fuse_req *req); 423 424 /** 425 * Reserve a preallocated request 426 */ 427 struct fuse_req *fuse_get_request(struct fuse_conn *fc); 428 429 /** 430 * Decrement reference count of a request. If count goes to zero put 431 * on unused list (preallocated) or free request (not preallocated). 432 */ 433 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 434 435 /** 436 * Send a request (synchronous) 437 */ 438 void request_send(struct fuse_conn *fc, struct fuse_req *req); 439 440 /** 441 * Send a request with no reply 442 */ 443 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req); 444 445 /** 446 * Send a request in the background 447 */ 448 void request_send_background(struct fuse_conn *fc, struct fuse_req *req); 449 450 /** 451 * Release inodes and file associated with background request 452 */ 453 void fuse_release_background(struct fuse_req *req); 454 455 /** 456 * Get the attributes of a file 457 */ 458 int fuse_do_getattr(struct inode *inode); 459 460 /** 461 * Invalidate inode attributes 462 */ 463 void fuse_invalidate_attr(struct inode *inode); 464 465 /** 466 * Send the INIT message 467 */ 468 void fuse_send_init(struct fuse_conn *fc); 469