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