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 "fuse_i.h" 10 11 #include <linux/pagemap.h> 12 #include <linux/slab.h> 13 #include <linux/kernel.h> 14 15 static const struct file_operations fuse_direct_io_file_operations; 16 17 static int fuse_send_open(struct inode *inode, struct file *file, int isdir, 18 struct fuse_open_out *outargp) 19 { 20 struct fuse_conn *fc = get_fuse_conn(inode); 21 struct fuse_open_in inarg; 22 struct fuse_req *req; 23 int err; 24 25 req = fuse_get_req(fc); 26 if (IS_ERR(req)) 27 return PTR_ERR(req); 28 29 memset(&inarg, 0, sizeof(inarg)); 30 inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); 31 req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN; 32 req->in.h.nodeid = get_node_id(inode); 33 req->in.numargs = 1; 34 req->in.args[0].size = sizeof(inarg); 35 req->in.args[0].value = &inarg; 36 req->out.numargs = 1; 37 req->out.args[0].size = sizeof(*outargp); 38 req->out.args[0].value = outargp; 39 request_send(fc, req); 40 err = req->out.h.error; 41 fuse_put_request(fc, req); 42 43 return err; 44 } 45 46 struct fuse_file *fuse_file_alloc(void) 47 { 48 struct fuse_file *ff; 49 ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL); 50 if (ff) { 51 ff->reserved_req = fuse_request_alloc(); 52 if (!ff->reserved_req) { 53 kfree(ff); 54 ff = NULL; 55 } 56 } 57 return ff; 58 } 59 60 void fuse_file_free(struct fuse_file *ff) 61 { 62 fuse_request_free(ff->reserved_req); 63 kfree(ff); 64 } 65 66 void fuse_finish_open(struct inode *inode, struct file *file, 67 struct fuse_file *ff, struct fuse_open_out *outarg) 68 { 69 if (outarg->open_flags & FOPEN_DIRECT_IO) 70 file->f_op = &fuse_direct_io_file_operations; 71 if (!(outarg->open_flags & FOPEN_KEEP_CACHE)) 72 invalidate_inode_pages(inode->i_mapping); 73 ff->fh = outarg->fh; 74 file->private_data = ff; 75 } 76 77 int fuse_open_common(struct inode *inode, struct file *file, int isdir) 78 { 79 struct fuse_open_out outarg; 80 struct fuse_file *ff; 81 int err; 82 83 /* VFS checks this, but only _after_ ->open() */ 84 if (file->f_flags & O_DIRECT) 85 return -EINVAL; 86 87 err = generic_file_open(inode, file); 88 if (err) 89 return err; 90 91 /* If opening the root node, no lookup has been performed on 92 it, so the attributes must be refreshed */ 93 if (get_node_id(inode) == FUSE_ROOT_ID) { 94 err = fuse_do_getattr(inode); 95 if (err) 96 return err; 97 } 98 99 ff = fuse_file_alloc(); 100 if (!ff) 101 return -ENOMEM; 102 103 err = fuse_send_open(inode, file, isdir, &outarg); 104 if (err) 105 fuse_file_free(ff); 106 else { 107 if (isdir) 108 outarg.open_flags &= ~FOPEN_DIRECT_IO; 109 fuse_finish_open(inode, file, ff, &outarg); 110 } 111 112 return err; 113 } 114 115 struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags, 116 int opcode) 117 { 118 struct fuse_req *req = ff->reserved_req; 119 struct fuse_release_in *inarg = &req->misc.release_in; 120 121 inarg->fh = ff->fh; 122 inarg->flags = flags; 123 req->in.h.opcode = opcode; 124 req->in.h.nodeid = nodeid; 125 req->in.numargs = 1; 126 req->in.args[0].size = sizeof(struct fuse_release_in); 127 req->in.args[0].value = inarg; 128 kfree(ff); 129 130 return req; 131 } 132 133 int fuse_release_common(struct inode *inode, struct file *file, int isdir) 134 { 135 struct fuse_file *ff = file->private_data; 136 if (ff) { 137 struct fuse_conn *fc = get_fuse_conn(inode); 138 struct fuse_req *req; 139 140 req = fuse_release_fill(ff, get_node_id(inode), file->f_flags, 141 isdir ? FUSE_RELEASEDIR : FUSE_RELEASE); 142 143 /* Hold vfsmount and dentry until release is finished */ 144 req->vfsmount = mntget(file->f_vfsmnt); 145 req->dentry = dget(file->f_dentry); 146 request_send_background(fc, req); 147 } 148 149 /* Return value is ignored by VFS */ 150 return 0; 151 } 152 153 static int fuse_open(struct inode *inode, struct file *file) 154 { 155 return fuse_open_common(inode, file, 0); 156 } 157 158 static int fuse_release(struct inode *inode, struct file *file) 159 { 160 return fuse_release_common(inode, file, 0); 161 } 162 163 /* 164 * Scramble the ID space with XTEA, so that the value of the files_struct 165 * pointer is not exposed to userspace. 166 */ 167 static u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id) 168 { 169 u32 *k = fc->scramble_key; 170 u64 v = (unsigned long) id; 171 u32 v0 = v; 172 u32 v1 = v >> 32; 173 u32 sum = 0; 174 int i; 175 176 for (i = 0; i < 32; i++) { 177 v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]); 178 sum += 0x9E3779B9; 179 v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]); 180 } 181 182 return (u64) v0 + ((u64) v1 << 32); 183 } 184 185 static int fuse_flush(struct file *file, fl_owner_t id) 186 { 187 struct inode *inode = file->f_dentry->d_inode; 188 struct fuse_conn *fc = get_fuse_conn(inode); 189 struct fuse_file *ff = file->private_data; 190 struct fuse_req *req; 191 struct fuse_flush_in inarg; 192 int err; 193 194 if (is_bad_inode(inode)) 195 return -EIO; 196 197 if (fc->no_flush) 198 return 0; 199 200 req = fuse_get_req_nofail(fc, file); 201 memset(&inarg, 0, sizeof(inarg)); 202 inarg.fh = ff->fh; 203 inarg.lock_owner = fuse_lock_owner_id(fc, id); 204 req->in.h.opcode = FUSE_FLUSH; 205 req->in.h.nodeid = get_node_id(inode); 206 req->in.numargs = 1; 207 req->in.args[0].size = sizeof(inarg); 208 req->in.args[0].value = &inarg; 209 req->force = 1; 210 request_send(fc, req); 211 err = req->out.h.error; 212 fuse_put_request(fc, req); 213 if (err == -ENOSYS) { 214 fc->no_flush = 1; 215 err = 0; 216 } 217 return err; 218 } 219 220 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync, 221 int isdir) 222 { 223 struct inode *inode = de->d_inode; 224 struct fuse_conn *fc = get_fuse_conn(inode); 225 struct fuse_file *ff = file->private_data; 226 struct fuse_req *req; 227 struct fuse_fsync_in inarg; 228 int err; 229 230 if (is_bad_inode(inode)) 231 return -EIO; 232 233 if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir)) 234 return 0; 235 236 req = fuse_get_req(fc); 237 if (IS_ERR(req)) 238 return PTR_ERR(req); 239 240 memset(&inarg, 0, sizeof(inarg)); 241 inarg.fh = ff->fh; 242 inarg.fsync_flags = datasync ? 1 : 0; 243 req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC; 244 req->in.h.nodeid = get_node_id(inode); 245 req->in.numargs = 1; 246 req->in.args[0].size = sizeof(inarg); 247 req->in.args[0].value = &inarg; 248 request_send(fc, req); 249 err = req->out.h.error; 250 fuse_put_request(fc, req); 251 if (err == -ENOSYS) { 252 if (isdir) 253 fc->no_fsyncdir = 1; 254 else 255 fc->no_fsync = 1; 256 err = 0; 257 } 258 return err; 259 } 260 261 static int fuse_fsync(struct file *file, struct dentry *de, int datasync) 262 { 263 return fuse_fsync_common(file, de, datasync, 0); 264 } 265 266 void fuse_read_fill(struct fuse_req *req, struct file *file, 267 struct inode *inode, loff_t pos, size_t count, int opcode) 268 { 269 struct fuse_file *ff = file->private_data; 270 struct fuse_read_in *inarg = &req->misc.read_in; 271 272 inarg->fh = ff->fh; 273 inarg->offset = pos; 274 inarg->size = count; 275 req->in.h.opcode = opcode; 276 req->in.h.nodeid = get_node_id(inode); 277 req->in.numargs = 1; 278 req->in.args[0].size = sizeof(struct fuse_read_in); 279 req->in.args[0].value = inarg; 280 req->out.argpages = 1; 281 req->out.argvar = 1; 282 req->out.numargs = 1; 283 req->out.args[0].size = count; 284 } 285 286 static size_t fuse_send_read(struct fuse_req *req, struct file *file, 287 struct inode *inode, loff_t pos, size_t count) 288 { 289 struct fuse_conn *fc = get_fuse_conn(inode); 290 fuse_read_fill(req, file, inode, pos, count, FUSE_READ); 291 request_send(fc, req); 292 return req->out.args[0].size; 293 } 294 295 static int fuse_readpage(struct file *file, struct page *page) 296 { 297 struct inode *inode = page->mapping->host; 298 struct fuse_conn *fc = get_fuse_conn(inode); 299 struct fuse_req *req; 300 int err; 301 302 err = -EIO; 303 if (is_bad_inode(inode)) 304 goto out; 305 306 req = fuse_get_req(fc); 307 err = PTR_ERR(req); 308 if (IS_ERR(req)) 309 goto out; 310 311 req->out.page_zeroing = 1; 312 req->num_pages = 1; 313 req->pages[0] = page; 314 fuse_send_read(req, file, inode, page_offset(page), PAGE_CACHE_SIZE); 315 err = req->out.h.error; 316 fuse_put_request(fc, req); 317 if (!err) 318 SetPageUptodate(page); 319 fuse_invalidate_attr(inode); /* atime changed */ 320 out: 321 unlock_page(page); 322 return err; 323 } 324 325 static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_req *req) 326 { 327 int i; 328 329 fuse_invalidate_attr(req->pages[0]->mapping->host); /* atime changed */ 330 331 for (i = 0; i < req->num_pages; i++) { 332 struct page *page = req->pages[i]; 333 if (!req->out.h.error) 334 SetPageUptodate(page); 335 else 336 SetPageError(page); 337 unlock_page(page); 338 } 339 fuse_put_request(fc, req); 340 } 341 342 static void fuse_send_readpages(struct fuse_req *req, struct file *file, 343 struct inode *inode) 344 { 345 struct fuse_conn *fc = get_fuse_conn(inode); 346 loff_t pos = page_offset(req->pages[0]); 347 size_t count = req->num_pages << PAGE_CACHE_SHIFT; 348 req->out.page_zeroing = 1; 349 fuse_read_fill(req, file, inode, pos, count, FUSE_READ); 350 if (fc->async_read) { 351 get_file(file); 352 req->file = file; 353 req->end = fuse_readpages_end; 354 request_send_background(fc, req); 355 } else { 356 request_send(fc, req); 357 fuse_readpages_end(fc, req); 358 } 359 } 360 361 struct fuse_readpages_data { 362 struct fuse_req *req; 363 struct file *file; 364 struct inode *inode; 365 }; 366 367 static int fuse_readpages_fill(void *_data, struct page *page) 368 { 369 struct fuse_readpages_data *data = _data; 370 struct fuse_req *req = data->req; 371 struct inode *inode = data->inode; 372 struct fuse_conn *fc = get_fuse_conn(inode); 373 374 if (req->num_pages && 375 (req->num_pages == FUSE_MAX_PAGES_PER_REQ || 376 (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read || 377 req->pages[req->num_pages - 1]->index + 1 != page->index)) { 378 fuse_send_readpages(req, data->file, inode); 379 data->req = req = fuse_get_req(fc); 380 if (IS_ERR(req)) { 381 unlock_page(page); 382 return PTR_ERR(req); 383 } 384 } 385 req->pages[req->num_pages] = page; 386 req->num_pages ++; 387 return 0; 388 } 389 390 static int fuse_readpages(struct file *file, struct address_space *mapping, 391 struct list_head *pages, unsigned nr_pages) 392 { 393 struct inode *inode = mapping->host; 394 struct fuse_conn *fc = get_fuse_conn(inode); 395 struct fuse_readpages_data data; 396 int err; 397 398 if (is_bad_inode(inode)) 399 return -EIO; 400 401 data.file = file; 402 data.inode = inode; 403 data.req = fuse_get_req(fc); 404 if (IS_ERR(data.req)) 405 return PTR_ERR(data.req); 406 407 err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data); 408 if (!err) { 409 if (data.req->num_pages) 410 fuse_send_readpages(data.req, file, inode); 411 else 412 fuse_put_request(fc, data.req); 413 } 414 return err; 415 } 416 417 static size_t fuse_send_write(struct fuse_req *req, struct file *file, 418 struct inode *inode, loff_t pos, size_t count) 419 { 420 struct fuse_conn *fc = get_fuse_conn(inode); 421 struct fuse_file *ff = file->private_data; 422 struct fuse_write_in inarg; 423 struct fuse_write_out outarg; 424 425 memset(&inarg, 0, sizeof(struct fuse_write_in)); 426 inarg.fh = ff->fh; 427 inarg.offset = pos; 428 inarg.size = count; 429 req->in.h.opcode = FUSE_WRITE; 430 req->in.h.nodeid = get_node_id(inode); 431 req->in.argpages = 1; 432 req->in.numargs = 2; 433 req->in.args[0].size = sizeof(struct fuse_write_in); 434 req->in.args[0].value = &inarg; 435 req->in.args[1].size = count; 436 req->out.numargs = 1; 437 req->out.args[0].size = sizeof(struct fuse_write_out); 438 req->out.args[0].value = &outarg; 439 request_send(fc, req); 440 return outarg.size; 441 } 442 443 static int fuse_prepare_write(struct file *file, struct page *page, 444 unsigned offset, unsigned to) 445 { 446 /* No op */ 447 return 0; 448 } 449 450 static int fuse_commit_write(struct file *file, struct page *page, 451 unsigned offset, unsigned to) 452 { 453 int err; 454 size_t nres; 455 unsigned count = to - offset; 456 struct inode *inode = page->mapping->host; 457 struct fuse_conn *fc = get_fuse_conn(inode); 458 loff_t pos = page_offset(page) + offset; 459 struct fuse_req *req; 460 461 if (is_bad_inode(inode)) 462 return -EIO; 463 464 req = fuse_get_req(fc); 465 if (IS_ERR(req)) 466 return PTR_ERR(req); 467 468 req->num_pages = 1; 469 req->pages[0] = page; 470 req->page_offset = offset; 471 nres = fuse_send_write(req, file, inode, pos, count); 472 err = req->out.h.error; 473 fuse_put_request(fc, req); 474 if (!err && nres != count) 475 err = -EIO; 476 if (!err) { 477 pos += count; 478 if (pos > i_size_read(inode)) 479 i_size_write(inode, pos); 480 481 if (offset == 0 && to == PAGE_CACHE_SIZE) { 482 clear_page_dirty(page); 483 SetPageUptodate(page); 484 } 485 } 486 fuse_invalidate_attr(inode); 487 return err; 488 } 489 490 static void fuse_release_user_pages(struct fuse_req *req, int write) 491 { 492 unsigned i; 493 494 for (i = 0; i < req->num_pages; i++) { 495 struct page *page = req->pages[i]; 496 if (write) 497 set_page_dirty_lock(page); 498 put_page(page); 499 } 500 } 501 502 static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf, 503 unsigned nbytes, int write) 504 { 505 unsigned long user_addr = (unsigned long) buf; 506 unsigned offset = user_addr & ~PAGE_MASK; 507 int npages; 508 509 /* This doesn't work with nfsd */ 510 if (!current->mm) 511 return -EPERM; 512 513 nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT); 514 npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT; 515 npages = min(max(npages, 1), FUSE_MAX_PAGES_PER_REQ); 516 down_read(¤t->mm->mmap_sem); 517 npages = get_user_pages(current, current->mm, user_addr, npages, write, 518 0, req->pages, NULL); 519 up_read(¤t->mm->mmap_sem); 520 if (npages < 0) 521 return npages; 522 523 req->num_pages = npages; 524 req->page_offset = offset; 525 return 0; 526 } 527 528 static ssize_t fuse_direct_io(struct file *file, const char __user *buf, 529 size_t count, loff_t *ppos, int write) 530 { 531 struct inode *inode = file->f_dentry->d_inode; 532 struct fuse_conn *fc = get_fuse_conn(inode); 533 size_t nmax = write ? fc->max_write : fc->max_read; 534 loff_t pos = *ppos; 535 ssize_t res = 0; 536 struct fuse_req *req; 537 538 if (is_bad_inode(inode)) 539 return -EIO; 540 541 req = fuse_get_req(fc); 542 if (IS_ERR(req)) 543 return PTR_ERR(req); 544 545 while (count) { 546 size_t nres; 547 size_t nbytes = min(count, nmax); 548 int err = fuse_get_user_pages(req, buf, nbytes, !write); 549 if (err) { 550 res = err; 551 break; 552 } 553 nbytes = (req->num_pages << PAGE_SHIFT) - req->page_offset; 554 nbytes = min(count, nbytes); 555 if (write) 556 nres = fuse_send_write(req, file, inode, pos, nbytes); 557 else 558 nres = fuse_send_read(req, file, inode, pos, nbytes); 559 fuse_release_user_pages(req, !write); 560 if (req->out.h.error) { 561 if (!res) 562 res = req->out.h.error; 563 break; 564 } else if (nres > nbytes) { 565 res = -EIO; 566 break; 567 } 568 count -= nres; 569 res += nres; 570 pos += nres; 571 buf += nres; 572 if (nres != nbytes) 573 break; 574 if (count) { 575 fuse_put_request(fc, req); 576 req = fuse_get_req(fc); 577 if (IS_ERR(req)) 578 break; 579 } 580 } 581 fuse_put_request(fc, req); 582 if (res > 0) { 583 if (write && pos > i_size_read(inode)) 584 i_size_write(inode, pos); 585 *ppos = pos; 586 } 587 fuse_invalidate_attr(inode); 588 589 return res; 590 } 591 592 static ssize_t fuse_direct_read(struct file *file, char __user *buf, 593 size_t count, loff_t *ppos) 594 { 595 return fuse_direct_io(file, buf, count, ppos, 0); 596 } 597 598 static ssize_t fuse_direct_write(struct file *file, const char __user *buf, 599 size_t count, loff_t *ppos) 600 { 601 struct inode *inode = file->f_dentry->d_inode; 602 ssize_t res; 603 /* Don't allow parallel writes to the same file */ 604 mutex_lock(&inode->i_mutex); 605 res = fuse_direct_io(file, buf, count, ppos, 1); 606 mutex_unlock(&inode->i_mutex); 607 return res; 608 } 609 610 static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma) 611 { 612 if ((vma->vm_flags & VM_SHARED)) { 613 if ((vma->vm_flags & VM_WRITE)) 614 return -ENODEV; 615 else 616 vma->vm_flags &= ~VM_MAYWRITE; 617 } 618 return generic_file_mmap(file, vma); 619 } 620 621 static int fuse_set_page_dirty(struct page *page) 622 { 623 printk("fuse_set_page_dirty: should not happen\n"); 624 dump_stack(); 625 return 0; 626 } 627 628 static int convert_fuse_file_lock(const struct fuse_file_lock *ffl, 629 struct file_lock *fl) 630 { 631 switch (ffl->type) { 632 case F_UNLCK: 633 break; 634 635 case F_RDLCK: 636 case F_WRLCK: 637 if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX || 638 ffl->end < ffl->start) 639 return -EIO; 640 641 fl->fl_start = ffl->start; 642 fl->fl_end = ffl->end; 643 fl->fl_pid = ffl->pid; 644 break; 645 646 default: 647 return -EIO; 648 } 649 fl->fl_type = ffl->type; 650 return 0; 651 } 652 653 static void fuse_lk_fill(struct fuse_req *req, struct file *file, 654 const struct file_lock *fl, int opcode, pid_t pid) 655 { 656 struct inode *inode = file->f_dentry->d_inode; 657 struct fuse_conn *fc = get_fuse_conn(inode); 658 struct fuse_file *ff = file->private_data; 659 struct fuse_lk_in *arg = &req->misc.lk_in; 660 661 arg->fh = ff->fh; 662 arg->owner = fuse_lock_owner_id(fc, fl->fl_owner); 663 arg->lk.start = fl->fl_start; 664 arg->lk.end = fl->fl_end; 665 arg->lk.type = fl->fl_type; 666 arg->lk.pid = pid; 667 req->in.h.opcode = opcode; 668 req->in.h.nodeid = get_node_id(inode); 669 req->in.numargs = 1; 670 req->in.args[0].size = sizeof(*arg); 671 req->in.args[0].value = arg; 672 } 673 674 static int fuse_getlk(struct file *file, struct file_lock *fl) 675 { 676 struct inode *inode = file->f_dentry->d_inode; 677 struct fuse_conn *fc = get_fuse_conn(inode); 678 struct fuse_req *req; 679 struct fuse_lk_out outarg; 680 int err; 681 682 req = fuse_get_req(fc); 683 if (IS_ERR(req)) 684 return PTR_ERR(req); 685 686 fuse_lk_fill(req, file, fl, FUSE_GETLK, 0); 687 req->out.numargs = 1; 688 req->out.args[0].size = sizeof(outarg); 689 req->out.args[0].value = &outarg; 690 request_send(fc, req); 691 err = req->out.h.error; 692 fuse_put_request(fc, req); 693 if (!err) 694 err = convert_fuse_file_lock(&outarg.lk, fl); 695 696 return err; 697 } 698 699 static int fuse_setlk(struct file *file, struct file_lock *fl) 700 { 701 struct inode *inode = file->f_dentry->d_inode; 702 struct fuse_conn *fc = get_fuse_conn(inode); 703 struct fuse_req *req; 704 int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK; 705 pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0; 706 int err; 707 708 /* Unlock on close is handled by the flush method */ 709 if (fl->fl_flags & FL_CLOSE) 710 return 0; 711 712 req = fuse_get_req(fc); 713 if (IS_ERR(req)) 714 return PTR_ERR(req); 715 716 fuse_lk_fill(req, file, fl, opcode, pid); 717 request_send(fc, req); 718 err = req->out.h.error; 719 /* locking is restartable */ 720 if (err == -EINTR) 721 err = -ERESTARTSYS; 722 fuse_put_request(fc, req); 723 return err; 724 } 725 726 static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl) 727 { 728 struct inode *inode = file->f_dentry->d_inode; 729 struct fuse_conn *fc = get_fuse_conn(inode); 730 int err; 731 732 if (cmd == F_GETLK) { 733 if (fc->no_lock) { 734 if (!posix_test_lock(file, fl, fl)) 735 fl->fl_type = F_UNLCK; 736 err = 0; 737 } else 738 err = fuse_getlk(file, fl); 739 } else { 740 if (fc->no_lock) 741 err = posix_lock_file_wait(file, fl); 742 else 743 err = fuse_setlk(file, fl); 744 } 745 return err; 746 } 747 748 static const struct file_operations fuse_file_operations = { 749 .llseek = generic_file_llseek, 750 .read = generic_file_read, 751 .write = generic_file_write, 752 .mmap = fuse_file_mmap, 753 .open = fuse_open, 754 .flush = fuse_flush, 755 .release = fuse_release, 756 .fsync = fuse_fsync, 757 .lock = fuse_file_lock, 758 .sendfile = generic_file_sendfile, 759 }; 760 761 static const struct file_operations fuse_direct_io_file_operations = { 762 .llseek = generic_file_llseek, 763 .read = fuse_direct_read, 764 .write = fuse_direct_write, 765 .open = fuse_open, 766 .flush = fuse_flush, 767 .release = fuse_release, 768 .fsync = fuse_fsync, 769 .lock = fuse_file_lock, 770 /* no mmap and sendfile */ 771 }; 772 773 static const struct address_space_operations fuse_file_aops = { 774 .readpage = fuse_readpage, 775 .prepare_write = fuse_prepare_write, 776 .commit_write = fuse_commit_write, 777 .readpages = fuse_readpages, 778 .set_page_dirty = fuse_set_page_dirty, 779 }; 780 781 void fuse_init_file_inode(struct inode *inode) 782 { 783 inode->i_fop = &fuse_file_operations; 784 inode->i_data.a_ops = &fuse_file_aops; 785 } 786