1 /* 2 FUSE: Filesystem in Userspace 3 Copyright (C) 2001-2006 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/mount.h> 12 #include <linux/wait.h> 13 #include <linux/list.h> 14 #include <linux/spinlock.h> 15 #include <linux/mm.h> 16 #include <linux/backing-dev.h> 17 #include <linux/mutex.h> 18 19 /** Max number of pages that can be used in a single read request */ 20 #define FUSE_MAX_PAGES_PER_REQ 32 21 22 /** Maximum number of outstanding background requests */ 23 #define FUSE_MAX_BACKGROUND 10 24 25 /** It could be as large as PATH_MAX, but would that have any uses? */ 26 #define FUSE_NAME_MAX 1024 27 28 /** Number of dentries for each connection in the control filesystem */ 29 #define FUSE_CTL_NUM_DENTRIES 3 30 31 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem 32 module will check permissions based on the file mode. Otherwise no 33 permission checking is done in the kernel */ 34 #define FUSE_DEFAULT_PERMISSIONS (1 << 0) 35 36 /** If the FUSE_ALLOW_OTHER flag is given, then not only the user 37 doing the mount will be allowed to access the filesystem */ 38 #define FUSE_ALLOW_OTHER (1 << 1) 39 40 /** List of active connections */ 41 extern struct list_head fuse_conn_list; 42 43 /** Global mutex protecting fuse_conn_list and the control filesystem */ 44 extern struct mutex fuse_mutex; 45 46 /** FUSE inode */ 47 struct fuse_inode { 48 /** Inode data */ 49 struct inode inode; 50 51 /** Unique ID, which identifies the inode between userspace 52 * and kernel */ 53 u64 nodeid; 54 55 /** Number of lookups on this inode */ 56 u64 nlookup; 57 58 /** The request used for sending the FORGET message */ 59 struct fuse_req *forget_req; 60 61 /** Time in jiffies until the file attributes are valid */ 62 u64 i_time; 63 }; 64 65 /** FUSE specific file data */ 66 struct fuse_file { 67 /** Request reserved for flush and release */ 68 struct fuse_req *reserved_req; 69 70 /** File handle used by userspace */ 71 u64 fh; 72 }; 73 74 /** One input argument of a request */ 75 struct fuse_in_arg { 76 unsigned size; 77 const void *value; 78 }; 79 80 /** The request input */ 81 struct fuse_in { 82 /** The request header */ 83 struct fuse_in_header h; 84 85 /** True if the data for the last argument is in req->pages */ 86 unsigned argpages:1; 87 88 /** Number of arguments */ 89 unsigned numargs; 90 91 /** Array of arguments */ 92 struct fuse_in_arg args[3]; 93 }; 94 95 /** One output argument of a request */ 96 struct fuse_arg { 97 unsigned size; 98 void *value; 99 }; 100 101 /** The request output */ 102 struct fuse_out { 103 /** Header returned from userspace */ 104 struct fuse_out_header h; 105 106 /* 107 * The following bitfields are not changed during the request 108 * processing 109 */ 110 111 /** Last argument is variable length (can be shorter than 112 arg->size) */ 113 unsigned argvar:1; 114 115 /** Last argument is a list of pages to copy data to */ 116 unsigned argpages:1; 117 118 /** Zero partially or not copied pages */ 119 unsigned page_zeroing:1; 120 121 /** Number or arguments */ 122 unsigned numargs; 123 124 /** Array of arguments */ 125 struct fuse_arg args[3]; 126 }; 127 128 /** The request state */ 129 enum fuse_req_state { 130 FUSE_REQ_INIT = 0, 131 FUSE_REQ_PENDING, 132 FUSE_REQ_READING, 133 FUSE_REQ_SENT, 134 FUSE_REQ_WRITING, 135 FUSE_REQ_FINISHED 136 }; 137 138 struct fuse_conn; 139 140 /** 141 * A request to the client 142 */ 143 struct fuse_req { 144 /** This can be on either pending processing or io lists in 145 fuse_conn */ 146 struct list_head list; 147 148 /** Entry on the interrupts list */ 149 struct list_head intr_entry; 150 151 /** refcount */ 152 atomic_t count; 153 154 /** Unique ID for the interrupt request */ 155 u64 intr_unique; 156 157 /* 158 * The following bitfields are either set once before the 159 * request is queued or setting/clearing them is protected by 160 * fuse_conn->lock 161 */ 162 163 /** True if the request has reply */ 164 unsigned isreply:1; 165 166 /** Force sending of the request even if interrupted */ 167 unsigned force:1; 168 169 /** The request was aborted */ 170 unsigned aborted:1; 171 172 /** Request is sent in the background */ 173 unsigned background:1; 174 175 /** The request has been interrupted */ 176 unsigned interrupted:1; 177 178 /** Data is being copied to/from the request */ 179 unsigned locked:1; 180 181 /** Request is counted as "waiting" */ 182 unsigned waiting:1; 183 184 /** State of the request */ 185 enum fuse_req_state state; 186 187 /** The request input */ 188 struct fuse_in in; 189 190 /** The request output */ 191 struct fuse_out out; 192 193 /** Used to wake up the task waiting for completion of request*/ 194 wait_queue_head_t waitq; 195 196 /** Data for asynchronous requests */ 197 union { 198 struct fuse_forget_in forget_in; 199 struct fuse_release_in release_in; 200 struct fuse_init_in init_in; 201 struct fuse_init_out init_out; 202 struct fuse_read_in read_in; 203 struct fuse_lk_in lk_in; 204 } misc; 205 206 /** page vector */ 207 struct page *pages[FUSE_MAX_PAGES_PER_REQ]; 208 209 /** number of pages in vector */ 210 unsigned num_pages; 211 212 /** offset of data on first page */ 213 unsigned page_offset; 214 215 /** File used in the request (or NULL) */ 216 struct file *file; 217 218 /** vfsmount used in release */ 219 struct vfsmount *vfsmount; 220 221 /** dentry used in release */ 222 struct dentry *dentry; 223 224 /** Request completion callback */ 225 void (*end)(struct fuse_conn *, struct fuse_req *); 226 227 /** Request is stolen from fuse_file->reserved_req */ 228 struct file *stolen_file; 229 }; 230 231 /** 232 * A Fuse connection. 233 * 234 * This structure is created, when the filesystem is mounted, and is 235 * destroyed, when the client device is closed and the filesystem is 236 * unmounted. 237 */ 238 struct fuse_conn { 239 /** Lock protecting accessess to members of this structure */ 240 spinlock_t lock; 241 242 /** Mutex protecting against directory alias creation */ 243 struct mutex inst_mutex; 244 245 /** Refcount */ 246 atomic_t count; 247 248 /** The user id for this mount */ 249 uid_t user_id; 250 251 /** The group id for this mount */ 252 gid_t group_id; 253 254 /** The fuse mount flags for this mount */ 255 unsigned flags; 256 257 /** Maximum read size */ 258 unsigned max_read; 259 260 /** Maximum write size */ 261 unsigned max_write; 262 263 /** Readers of the connection are waiting on this */ 264 wait_queue_head_t waitq; 265 266 /** The list of pending requests */ 267 struct list_head pending; 268 269 /** The list of requests being processed */ 270 struct list_head processing; 271 272 /** The list of requests under I/O */ 273 struct list_head io; 274 275 /** Number of requests currently in the background */ 276 unsigned num_background; 277 278 /** Pending interrupts */ 279 struct list_head interrupts; 280 281 /** Flag indicating if connection is blocked. This will be 282 the case before the INIT reply is received, and if there 283 are too many outstading backgrounds requests */ 284 int blocked; 285 286 /** waitq for blocked connection */ 287 wait_queue_head_t blocked_waitq; 288 289 /** The next unique request id */ 290 u64 reqctr; 291 292 /** Connection established, cleared on umount, connection 293 abort and device release */ 294 unsigned connected; 295 296 /** Connection failed (version mismatch). Cannot race with 297 setting other bitfields since it is only set once in INIT 298 reply, before any other request, and never cleared */ 299 unsigned conn_error : 1; 300 301 /** Connection successful. Only set in INIT */ 302 unsigned conn_init : 1; 303 304 /** Do readpages asynchronously? Only set in INIT */ 305 unsigned async_read : 1; 306 307 /* 308 * The following bitfields are only for optimization purposes 309 * and hence races in setting them will not cause malfunction 310 */ 311 312 /** Is fsync not implemented by fs? */ 313 unsigned no_fsync : 1; 314 315 /** Is fsyncdir not implemented by fs? */ 316 unsigned no_fsyncdir : 1; 317 318 /** Is flush not implemented by fs? */ 319 unsigned no_flush : 1; 320 321 /** Is setxattr not implemented by fs? */ 322 unsigned no_setxattr : 1; 323 324 /** Is getxattr not implemented by fs? */ 325 unsigned no_getxattr : 1; 326 327 /** Is listxattr not implemented by fs? */ 328 unsigned no_listxattr : 1; 329 330 /** Is removexattr not implemented by fs? */ 331 unsigned no_removexattr : 1; 332 333 /** Are file locking primitives not implemented by fs? */ 334 unsigned no_lock : 1; 335 336 /** Is access not implemented by fs? */ 337 unsigned no_access : 1; 338 339 /** Is create not implemented by fs? */ 340 unsigned no_create : 1; 341 342 /** Is interrupt not implemented by fs? */ 343 unsigned no_interrupt : 1; 344 345 /** Is bmap not implemented by fs? */ 346 unsigned no_bmap : 1; 347 348 /** The number of requests waiting for completion */ 349 atomic_t num_waiting; 350 351 /** Negotiated minor version */ 352 unsigned minor; 353 354 /** Backing dev info */ 355 struct backing_dev_info bdi; 356 357 /** Entry on the fuse_conn_list */ 358 struct list_head entry; 359 360 /** Unique ID */ 361 u64 id; 362 363 /** Dentries in the control filesystem */ 364 struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES]; 365 366 /** number of dentries used in the above array */ 367 int ctl_ndents; 368 369 /** O_ASYNC requests */ 370 struct fasync_struct *fasync; 371 372 /** Key for lock owner ID scrambling */ 373 u32 scramble_key[4]; 374 375 /** Reserved request for the DESTROY message */ 376 struct fuse_req *destroy_req; 377 }; 378 379 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 380 { 381 return sb->s_fs_info; 382 } 383 384 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 385 { 386 return get_fuse_conn_super(inode->i_sb); 387 } 388 389 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 390 { 391 return container_of(inode, struct fuse_inode, inode); 392 } 393 394 static inline u64 get_node_id(struct inode *inode) 395 { 396 return get_fuse_inode(inode)->nodeid; 397 } 398 399 /** Device operations */ 400 extern const struct file_operations fuse_dev_operations; 401 402 /** 403 * Get a filled in inode 404 */ 405 struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid, 406 int generation, struct fuse_attr *attr); 407 408 /** 409 * Send FORGET command 410 */ 411 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req, 412 unsigned long nodeid, u64 nlookup); 413 414 /** 415 * Initialize READ or READDIR request 416 */ 417 void fuse_read_fill(struct fuse_req *req, struct file *file, 418 struct inode *inode, loff_t pos, size_t count, int opcode); 419 420 /** 421 * Send OPEN or OPENDIR request 422 */ 423 int fuse_open_common(struct inode *inode, struct file *file, int isdir); 424 425 struct fuse_file *fuse_file_alloc(void); 426 void fuse_file_free(struct fuse_file *ff); 427 void fuse_finish_open(struct inode *inode, struct file *file, 428 struct fuse_file *ff, struct fuse_open_out *outarg); 429 430 /** */ 431 struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags, 432 int opcode); 433 /** 434 * Send RELEASE or RELEASEDIR request 435 */ 436 int fuse_release_common(struct inode *inode, struct file *file, int isdir); 437 438 /** 439 * Send FSYNC or FSYNCDIR request 440 */ 441 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync, 442 int isdir); 443 444 /** 445 * Initialize file operations on a regular file 446 */ 447 void fuse_init_file_inode(struct inode *inode); 448 449 /** 450 * Initialize inode operations on regular files and special files 451 */ 452 void fuse_init_common(struct inode *inode); 453 454 /** 455 * Initialize inode and file operations on a directory 456 */ 457 void fuse_init_dir(struct inode *inode); 458 459 /** 460 * Initialize inode operations on a symlink 461 */ 462 void fuse_init_symlink(struct inode *inode); 463 464 /** 465 * Change attributes of an inode 466 */ 467 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr); 468 469 /** 470 * Initialize the client device 471 */ 472 int fuse_dev_init(void); 473 474 /** 475 * Cleanup the client device 476 */ 477 void fuse_dev_cleanup(void); 478 479 int fuse_ctl_init(void); 480 void fuse_ctl_cleanup(void); 481 482 /** 483 * Allocate a request 484 */ 485 struct fuse_req *fuse_request_alloc(void); 486 487 /** 488 * Free a request 489 */ 490 void fuse_request_free(struct fuse_req *req); 491 492 /** 493 * Get a request, may fail with -ENOMEM 494 */ 495 struct fuse_req *fuse_get_req(struct fuse_conn *fc); 496 497 /** 498 * Gets a requests for a file operation, always succeeds 499 */ 500 struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file); 501 502 /** 503 * Decrement reference count of a request. If count goes to zero free 504 * the request. 505 */ 506 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 507 508 /** 509 * Send a request (synchronous) 510 */ 511 void request_send(struct fuse_conn *fc, struct fuse_req *req); 512 513 /** 514 * Send a request with no reply 515 */ 516 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req); 517 518 /** 519 * Send a request in the background 520 */ 521 void request_send_background(struct fuse_conn *fc, struct fuse_req *req); 522 523 /* Abort all requests */ 524 void fuse_abort_conn(struct fuse_conn *fc); 525 526 /** 527 * Get the attributes of a file 528 */ 529 int fuse_do_getattr(struct inode *inode); 530 531 /** 532 * Invalidate inode attributes 533 */ 534 void fuse_invalidate_attr(struct inode *inode); 535 536 /** 537 * Acquire reference to fuse_conn 538 */ 539 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc); 540 541 /** 542 * Release reference to fuse_conn 543 */ 544 void fuse_conn_put(struct fuse_conn *fc); 545 546 /** 547 * Add connection to control filesystem 548 */ 549 int fuse_ctl_add_conn(struct fuse_conn *fc); 550 551 /** 552 * Remove connection from control filesystem 553 */ 554 void fuse_ctl_remove_conn(struct fuse_conn *fc); 555 556 /** 557 * Is file type valid? 558 */ 559 int fuse_valid_type(int m); 560