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 /** Backing dev info */ 270 struct backing_dev_info bdi; 271 }; 272 273 static inline struct fuse_conn **get_fuse_conn_super_p(struct super_block *sb) 274 { 275 return (struct fuse_conn **) &sb->s_fs_info; 276 } 277 278 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 279 { 280 return *get_fuse_conn_super_p(sb); 281 } 282 283 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 284 { 285 return get_fuse_conn_super(inode->i_sb); 286 } 287 288 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 289 { 290 return container_of(inode, struct fuse_inode, inode); 291 } 292 293 static inline u64 get_node_id(struct inode *inode) 294 { 295 return get_fuse_inode(inode)->nodeid; 296 } 297 298 /** Device operations */ 299 extern struct file_operations fuse_dev_operations; 300 301 /** 302 * This is the single global spinlock which protects FUSE's structures 303 * 304 * The following data is protected by this lock: 305 * 306 * - the private_data field of the device file 307 * - the s_fs_info field of the super block 308 * - unused_list, pending, processing lists in fuse_conn 309 * - background list in fuse_conn 310 * - the unique request ID counter reqctr in fuse_conn 311 * - the sb (super_block) field in fuse_conn 312 * - the file (device file) field in fuse_conn 313 */ 314 extern spinlock_t fuse_lock; 315 316 /** 317 * Get a filled in inode 318 */ 319 struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid, 320 int generation, struct fuse_attr *attr); 321 322 /** 323 * Send FORGET command 324 */ 325 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req, 326 unsigned long nodeid, u64 nlookup); 327 328 /** 329 * Send READ or READDIR request 330 */ 331 size_t fuse_send_read_common(struct fuse_req *req, struct file *file, 332 struct inode *inode, loff_t pos, size_t count, 333 int isdir); 334 335 /** 336 * Send OPEN or OPENDIR request 337 */ 338 int fuse_open_common(struct inode *inode, struct file *file, int isdir); 339 340 /** 341 * Send RELEASE or RELEASEDIR request 342 */ 343 int fuse_release_common(struct inode *inode, struct file *file, int isdir); 344 345 /** 346 * Send FSYNC or FSYNCDIR request 347 */ 348 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync, 349 int isdir); 350 351 /** 352 * Initialize file operations on a regular file 353 */ 354 void fuse_init_file_inode(struct inode *inode); 355 356 /** 357 * Initialize inode operations on regular files and special files 358 */ 359 void fuse_init_common(struct inode *inode); 360 361 /** 362 * Initialize inode and file operations on a directory 363 */ 364 void fuse_init_dir(struct inode *inode); 365 366 /** 367 * Initialize inode operations on a symlink 368 */ 369 void fuse_init_symlink(struct inode *inode); 370 371 /** 372 * Change attributes of an inode 373 */ 374 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr); 375 376 /** 377 * Check if the connection can be released, and if yes, then free the 378 * connection structure 379 */ 380 void fuse_release_conn(struct fuse_conn *fc); 381 382 /** 383 * Initialize the client device 384 */ 385 int fuse_dev_init(void); 386 387 /** 388 * Cleanup the client device 389 */ 390 void fuse_dev_cleanup(void); 391 392 /** 393 * Allocate a request 394 */ 395 struct fuse_req *fuse_request_alloc(void); 396 397 /** 398 * Free a request 399 */ 400 void fuse_request_free(struct fuse_req *req); 401 402 /** 403 * Reinitialize a request, the preallocated flag is left unmodified 404 */ 405 void fuse_reset_request(struct fuse_req *req); 406 407 /** 408 * Reserve a preallocated request 409 */ 410 struct fuse_req *fuse_get_request(struct fuse_conn *fc); 411 412 /** 413 * Decrement reference count of a request. If count goes to zero put 414 * on unused list (preallocated) or free request (not preallocated). 415 */ 416 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 417 418 /** 419 * Send a request (synchronous) 420 */ 421 void request_send(struct fuse_conn *fc, struct fuse_req *req); 422 423 /** 424 * Send a request with no reply 425 */ 426 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req); 427 428 /** 429 * Send a request in the background 430 */ 431 void request_send_background(struct fuse_conn *fc, struct fuse_req *req); 432 433 /** 434 * Release inodes and file associated with background request 435 */ 436 void fuse_release_background(struct fuse_req *req); 437 438 /** 439 * Get the attributes of a file 440 */ 441 int fuse_do_getattr(struct inode *inode); 442 443 /** 444 * Invalidate inode attributes 445 */ 446 void fuse_invalidate_attr(struct inode *inode); 447 448 /** 449 * Send the INIT message 450 */ 451 void fuse_send_init(struct fuse_conn *fc); 452