Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 1 | /* |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 2 | FUSE: Filesystem in Userspace |
Miklos Szeredi | 149f607 | 2005-01-10 12:29:28 +0000 | [diff] [blame] | 3 | Copyright (C) 2001-2005 Miklos Szeredi <miklos@szeredi.hu> |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 4 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 5 | This program can be distributed under the terms of the GNU GPL. |
| 6 | See the file COPYING. |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 7 | */ |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 8 | |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 9 | #include "fuse_i.h" |
| 10 | |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 11 | #include <linux/pagemap.h> |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 12 | #include <linux/slab.h> |
Miklos Szeredi | 13ed482 | 2004-11-20 11:12:21 +0000 | [diff] [blame] | 13 | #include <linux/kernel.h> |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 14 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 15 | #ifndef KERNEL_2_6 |
Miklos Szeredi | 13ed482 | 2004-11-20 11:12:21 +0000 | [diff] [blame] | 16 | #define PageUptodate(page) Page_Uptodate(page) |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 17 | #define clear_page_dirty(page) ClearPageDirty(page) |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 18 | #endif |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 19 | int fuse_open_common(struct inode *inode, struct file *file, int isdir) |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 20 | { |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 21 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 22 | struct fuse_req *req; |
Miklos Szeredi | 4369643 | 2001-11-18 19:15:05 +0000 | [diff] [blame] | 23 | struct fuse_open_in inarg; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 24 | struct fuse_open_out outarg; |
| 25 | struct fuse_file *ff; |
Miklos Szeredi | f58cc61 | 2004-02-06 13:52:00 +0000 | [diff] [blame] | 26 | int err; |
| 27 | |
| 28 | err = generic_file_open(inode, file); |
Miklos Szeredi | c26c14d | 2004-04-09 17:48:32 +0000 | [diff] [blame] | 29 | if (err) |
Miklos Szeredi | f58cc61 | 2004-02-06 13:52:00 +0000 | [diff] [blame] | 30 | return err; |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 31 | |
Miklos Szeredi | fe25def | 2001-12-20 15:38:05 +0000 | [diff] [blame] | 32 | /* If opening the root node, no lookup has been performed on |
| 33 | it, so the attributes must be refreshed */ |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 34 | if (get_node_id(inode) == FUSE_ROOT_ID) { |
Miklos Szeredi | f85ab24 | 2004-01-07 12:16:45 +0000 | [diff] [blame] | 35 | int err = fuse_do_getattr(inode); |
Miklos Szeredi | c26c14d | 2004-04-09 17:48:32 +0000 | [diff] [blame] | 36 | if (err) |
Miklos Szeredi | fe25def | 2001-12-20 15:38:05 +0000 | [diff] [blame] | 37 | return err; |
| 38 | } |
| 39 | |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 40 | req = fuse_get_request(fc); |
| 41 | if (!req) |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 42 | return -ERESTARTSYS; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 43 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 44 | err = -ENOMEM; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 45 | ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL); |
| 46 | if (!ff) |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 47 | goto out_put_request; |
Miklos Szeredi | d3dd2d5 | 2004-06-22 18:46:02 +0000 | [diff] [blame] | 48 | |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 49 | ff->release_req = fuse_request_alloc(); |
| 50 | if (!ff->release_req) { |
| 51 | kfree(ff); |
| 52 | goto out_put_request; |
| 53 | } |
| 54 | |
Miklos Szeredi | 4369643 | 2001-11-18 19:15:05 +0000 | [diff] [blame] | 55 | memset(&inarg, 0, sizeof(inarg)); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 56 | inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 57 | req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 58 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 59 | req->inode = inode; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 60 | req->in.numargs = 1; |
| 61 | req->in.args[0].size = sizeof(inarg); |
| 62 | req->in.args[0].value = &inarg; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 63 | req->out.numargs = 1; |
| 64 | req->out.args[0].size = sizeof(outarg); |
| 65 | req->out.args[0].value = &outarg; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 66 | request_send(fc, req); |
| 67 | err = req->out.h.error; |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 68 | if (!err && !(fc->flags & FUSE_KERNEL_CACHE)) |
Miklos Szeredi | f85ab24 | 2004-01-07 12:16:45 +0000 | [diff] [blame] | 69 | #ifdef KERNEL_2_6 |
| 70 | invalidate_inode_pages(inode->i_mapping); |
| 71 | #else |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 72 | invalidate_inode_pages(inode); |
Miklos Szeredi | f85ab24 | 2004-01-07 12:16:45 +0000 | [diff] [blame] | 73 | #endif |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 74 | if (err) { |
| 75 | fuse_request_free(ff->release_req); |
| 76 | kfree(ff); |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 77 | } else { |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 78 | ff->fh = outarg.fh; |
| 79 | file->private_data = ff; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 80 | } |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 81 | |
| 82 | out_put_request: |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 83 | fuse_put_request(fc, req); |
| 84 | return err; |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 85 | } |
| 86 | |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 87 | int fuse_release_common(struct inode *inode, struct file *file, int isdir) |
Miklos Szeredi | c8ba237 | 2002-12-10 12:26:00 +0000 | [diff] [blame] | 88 | { |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 89 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 90 | struct fuse_file *ff = file->private_data; |
| 91 | struct fuse_req *req = ff->release_req; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 92 | struct fuse_release_in *inarg = &req->misc.release_in; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 93 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 94 | inarg->fh = ff->fh; |
| 95 | inarg->flags = file->f_flags & ~O_EXCL; |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 96 | req->in.h.opcode = isdir ? FUSE_RELEASEDIR : FUSE_RELEASE; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 97 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 98 | req->inode = inode; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 99 | req->in.numargs = 1; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 100 | req->in.args[0].size = sizeof(struct fuse_release_in); |
| 101 | req->in.args[0].value = inarg; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 102 | request_send_background(fc, req); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 103 | kfree(ff); |
Miklos Szeredi | 383a9df | 2002-12-10 14:54:57 +0000 | [diff] [blame] | 104 | |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 105 | /* Return value is ignored by VFS */ |
Miklos Szeredi | 383a9df | 2002-12-10 14:54:57 +0000 | [diff] [blame] | 106 | return 0; |
Miklos Szeredi | c8ba237 | 2002-12-10 12:26:00 +0000 | [diff] [blame] | 107 | } |
| 108 | |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 109 | static int fuse_open(struct inode *inode, struct file *file) |
| 110 | { |
| 111 | return fuse_open_common(inode, file, 0); |
| 112 | } |
| 113 | |
| 114 | static int fuse_release(struct inode *inode, struct file *file) |
| 115 | { |
| 116 | return fuse_release_common(inode, file, 0); |
| 117 | } |
| 118 | |
Miklos Szeredi | e2e4ac2 | 2004-05-18 08:45:28 +0000 | [diff] [blame] | 119 | static int fuse_flush(struct file *file) |
| 120 | { |
| 121 | struct inode *inode = file->f_dentry->d_inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 122 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 123 | struct fuse_file *ff = file->private_data; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 124 | struct fuse_req *req; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 125 | struct fuse_flush_in inarg; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 126 | int err; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 127 | |
Miklos Szeredi | 63b8c1c | 2004-06-03 14:45:04 +0000 | [diff] [blame] | 128 | if (fc->no_flush) |
| 129 | return 0; |
| 130 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 131 | req = fuse_get_request_nonint(fc); |
| 132 | if (!req) |
| 133 | return -EINTR; |
| 134 | |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 135 | memset(&inarg, 0, sizeof(inarg)); |
| 136 | inarg.fh = ff->fh; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 137 | req->in.h.opcode = FUSE_FLUSH; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 138 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 139 | req->inode = inode; |
| 140 | req->file = file; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 141 | req->in.numargs = 1; |
| 142 | req->in.args[0].size = sizeof(inarg); |
| 143 | req->in.args[0].value = &inarg; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 144 | request_send_nonint(fc, req); |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 145 | err = req->out.h.error; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 146 | fuse_put_request(fc, req); |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 147 | if (err == -ENOSYS) { |
Miklos Szeredi | 63b8c1c | 2004-06-03 14:45:04 +0000 | [diff] [blame] | 148 | fc->no_flush = 1; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 149 | err = 0; |
Miklos Szeredi | 63b8c1c | 2004-06-03 14:45:04 +0000 | [diff] [blame] | 150 | } |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 151 | return err; |
Miklos Szeredi | e2e4ac2 | 2004-05-18 08:45:28 +0000 | [diff] [blame] | 152 | } |
| 153 | |
Miklos Szeredi | 4283ee7 | 2005-03-21 12:09:04 +0000 | [diff] [blame] | 154 | int fuse_fsync_common(struct file *file, struct dentry *de, int datasync, |
| 155 | int isdir) |
Miklos Szeredi | e4cf733 | 2003-12-12 11:53:31 +0000 | [diff] [blame] | 156 | { |
Miklos Szeredi | 5e43f2c | 2003-12-12 14:06:41 +0000 | [diff] [blame] | 157 | struct inode *inode = de->d_inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 158 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 159 | struct fuse_file *ff = file->private_data; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 160 | struct fuse_req *req; |
Miklos Szeredi | 5e43f2c | 2003-12-12 14:06:41 +0000 | [diff] [blame] | 161 | struct fuse_fsync_in inarg; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 162 | int err; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 163 | |
Miklos Szeredi | 4283ee7 | 2005-03-21 12:09:04 +0000 | [diff] [blame] | 164 | if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir)) |
Miklos Szeredi | 63b8c1c | 2004-06-03 14:45:04 +0000 | [diff] [blame] | 165 | return 0; |
| 166 | |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 167 | req = fuse_get_request(fc); |
| 168 | if (!req) |
| 169 | return -ERESTARTSYS; |
Miklos Szeredi | 069c950 | 2004-07-16 16:17:02 +0000 | [diff] [blame] | 170 | |
Miklos Szeredi | 5e43f2c | 2003-12-12 14:06:41 +0000 | [diff] [blame] | 171 | memset(&inarg, 0, sizeof(inarg)); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 172 | inarg.fh = ff->fh; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 173 | inarg.fsync_flags = datasync ? 1 : 0; |
Miklos Szeredi | 4283ee7 | 2005-03-21 12:09:04 +0000 | [diff] [blame] | 174 | req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 175 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 176 | req->inode = inode; |
| 177 | req->file = file; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 178 | req->in.numargs = 1; |
| 179 | req->in.args[0].size = sizeof(inarg); |
| 180 | req->in.args[0].value = &inarg; |
| 181 | request_send(fc, req); |
| 182 | err = req->out.h.error; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 183 | fuse_put_request(fc, req); |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 184 | if (err == -ENOSYS) { |
Miklos Szeredi | 4283ee7 | 2005-03-21 12:09:04 +0000 | [diff] [blame] | 185 | if (isdir) |
| 186 | fc->no_fsyncdir = 1; |
| 187 | else |
| 188 | fc->no_fsync = 1; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 189 | err = 0; |
Miklos Szeredi | 63b8c1c | 2004-06-03 14:45:04 +0000 | [diff] [blame] | 190 | } |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 191 | return err; |
Miklos Szeredi | e4cf733 | 2003-12-12 11:53:31 +0000 | [diff] [blame] | 192 | } |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 193 | |
Miklos Szeredi | 4283ee7 | 2005-03-21 12:09:04 +0000 | [diff] [blame] | 194 | static int fuse_fsync(struct file *file, struct dentry *de, int datasync) |
| 195 | { |
| 196 | return fuse_fsync_common(file, de, datasync, 0); |
| 197 | } |
| 198 | |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 199 | size_t fuse_send_read_common(struct fuse_req *req, struct file *file, |
Miklos Szeredi | e22acbe | 2005-01-20 08:37:30 +0000 | [diff] [blame] | 200 | struct inode *inode, loff_t pos, size_t count, |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 201 | int isdir) |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 202 | { |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 203 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 204 | struct fuse_file *ff = file->private_data; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 205 | struct fuse_read_in inarg; |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 206 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 207 | memset(&inarg, 0, sizeof(struct fuse_read_in)); |
| 208 | inarg.fh = ff->fh; |
| 209 | inarg.offset = pos; |
| 210 | inarg.size = count; |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 211 | req->in.h.opcode = isdir ? FUSE_READDIR : FUSE_READ; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 212 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 213 | req->inode = inode; |
| 214 | req->file = file; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 215 | req->in.numargs = 1; |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 216 | req->in.args[0].size = sizeof(struct fuse_read_in); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 217 | req->in.args[0].value = &inarg; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 218 | req->out.argpages = 1; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 219 | req->out.argvar = 1; |
| 220 | req->out.numargs = 1; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 221 | req->out.args[0].size = count; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 222 | request_send_nonint(fc, req); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 223 | return req->out.args[0].size; |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 224 | } |
| 225 | |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 226 | static inline size_t fuse_send_read(struct fuse_req *req, struct file *file, |
| 227 | struct inode *inode, loff_t pos, |
| 228 | size_t count) |
| 229 | { |
| 230 | return fuse_send_read_common(req, file, inode, pos, count, 0); |
| 231 | } |
| 232 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 233 | static int fuse_readpage(struct file *file, struct page *page) |
| 234 | { |
| 235 | struct inode *inode = page->mapping->host; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 236 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 237 | loff_t pos = (loff_t) page->index << PAGE_CACHE_SHIFT; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 238 | struct fuse_req *req = fuse_get_request_nonint(fc); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 239 | int err = -EINTR; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 240 | if (!req) |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 241 | goto out; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 242 | |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 243 | req->out.page_zeroing = 1; |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 244 | req->num_pages = 1; |
| 245 | req->pages[0] = page; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 246 | fuse_send_read(req, file, inode, pos, PAGE_CACHE_SIZE); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 247 | err = req->out.h.error; |
| 248 | fuse_put_request(fc, req); |
| 249 | if (!err) |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 250 | SetPageUptodate(page); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 251 | out: |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 252 | unlock_page(page); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 253 | return err; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 254 | } |
| 255 | |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 256 | #ifdef KERNEL_2_6 |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 257 | static int fuse_send_readpages(struct fuse_req *req, struct file *file, |
| 258 | struct inode *inode) |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 259 | { |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 260 | loff_t pos = (loff_t) req->pages[0]->index << PAGE_CACHE_SHIFT; |
| 261 | size_t count = req->num_pages << PAGE_CACHE_SHIFT; |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 262 | unsigned i; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 263 | req->out.page_zeroing = 1; |
| 264 | fuse_send_read(req, file, inode, pos, count); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 265 | for (i = 0; i < req->num_pages; i++) { |
| 266 | struct page *page = req->pages[i]; |
| 267 | if (!req->out.h.error) |
| 268 | SetPageUptodate(page); |
| 269 | unlock_page(page); |
| 270 | } |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 271 | return req->out.h.error; |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 274 | struct fuse_readpages_data { |
| 275 | struct fuse_req *req; |
| 276 | struct file *file; |
| 277 | struct inode *inode; |
| 278 | }; |
| 279 | |
| 280 | static int fuse_readpages_fill(void *_data, struct page *page) |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 281 | { |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 282 | struct fuse_readpages_data *data = _data; |
| 283 | struct fuse_req *req = data->req; |
| 284 | struct inode *inode = data->inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 285 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 286 | |
| 287 | if (req->num_pages && |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 288 | (req->num_pages == FUSE_MAX_PAGES_PER_REQ || |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 289 | (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read || |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 290 | req->pages[req->num_pages - 1]->index + 1 != page->index)) { |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 291 | int err = fuse_send_readpages(req, data->file, inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 292 | if (err) { |
| 293 | unlock_page(page); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 294 | return err; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 295 | } |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 296 | fuse_reset_request(req); |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 297 | } |
| 298 | req->pages[req->num_pages] = page; |
| 299 | req->num_pages ++; |
| 300 | return 0; |
| 301 | } |
| 302 | |
| 303 | static int fuse_readpages(struct file *file, struct address_space *mapping, |
| 304 | struct list_head *pages, unsigned nr_pages) |
| 305 | { |
| 306 | struct inode *inode = mapping->host; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 307 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 308 | struct fuse_readpages_data data; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 309 | int err; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 310 | data.file = file; |
| 311 | data.inode = inode; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 312 | data.req = fuse_get_request_nonint(fc); |
| 313 | if (!data.req) |
| 314 | return -EINTR; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 315 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 316 | err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data); |
| 317 | if (!err && data.req->num_pages) |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 318 | err = fuse_send_readpages(data.req, file, inode); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 319 | fuse_put_request(fc, data.req); |
| 320 | return err; |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 321 | } |
Miklos Szeredi | 13ed482 | 2004-11-20 11:12:21 +0000 | [diff] [blame] | 322 | #else /* KERNEL_2_6 */ |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 323 | #define FUSE_BLOCK_SHIFT 16 |
| 324 | #define FUSE_BLOCK_SIZE (1UL << FUSE_BLOCK_SHIFT) |
| 325 | #define FUSE_BLOCK_MASK (~(FUSE_BLOCK_SIZE-1)) |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 326 | #if (1UL << (FUSE_BLOCK_SHIFT - PAGE_CACHE_SHIFT)) > FUSE_MAX_PAGES_PER_REQ |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 327 | #error FUSE_BLOCK_SHIFT too large |
| 328 | #endif |
| 329 | |
| 330 | static int fuse_is_block_uptodate(struct inode *inode, unsigned start, |
| 331 | unsigned end) |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 332 | { |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 333 | int index; |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 334 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 335 | for (index = start; index < end; index++) { |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 336 | struct page *page = find_get_page(inode->i_mapping, index); |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 337 | if (!page) |
| 338 | return 0; |
Miklos Szeredi | f85ab24 | 2004-01-07 12:16:45 +0000 | [diff] [blame] | 339 | if (!PageUptodate(page)) { |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 340 | page_cache_release(page); |
| 341 | return 0; |
| 342 | } |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 343 | page_cache_release(page); |
| 344 | } |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 345 | return 1; |
| 346 | } |
| 347 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 348 | static int fuse_file_read_block(struct fuse_req *req, struct file *file, |
| 349 | struct inode *inode, unsigned start, |
| 350 | unsigned end) |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 351 | { |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 352 | loff_t pos; |
| 353 | size_t count; |
| 354 | int index; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 355 | int err = -EBUSY; |
Michael Grigoriev | 37b3f3b | 2003-11-09 15:33:24 +0000 | [diff] [blame] | 356 | int i; |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 357 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 358 | for (index = start; index < end; index++) { |
| 359 | struct page *page = grab_cache_page(inode->i_mapping, index); |
Michael Grigoriev | 37b3f3b | 2003-11-09 15:33:24 +0000 | [diff] [blame] | 360 | if (!page) |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 361 | goto out; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 362 | if (PageUptodate(page)) { |
| 363 | unlock_page(page); |
| 364 | page_cache_release(page); |
| 365 | page = NULL; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 366 | } |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 367 | req->pages[req->num_pages++] = page; |
| 368 | } |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 369 | pos = (loff_t) start << PAGE_CACHE_SHIFT; |
| 370 | count = req->num_pages << PAGE_CACHE_SHIFT; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 371 | fuse_send_read(req, file, inode, pos, count); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 372 | err = req->out.h.error; |
| 373 | out: |
| 374 | for (i = 0; i < req->num_pages; i++) { |
| 375 | struct page *page = req->pages[i]; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 376 | if (page) { |
| 377 | if (!err) |
| 378 | SetPageUptodate(page); |
| 379 | unlock_page(page); |
| 380 | page_cache_release(page); |
| 381 | } |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 382 | } |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 383 | return err; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 384 | } |
Miklos Szeredi | 36ca556 | 2003-11-03 19:32:14 +0000 | [diff] [blame] | 385 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 386 | static int fuse_file_bigread(struct file *file, struct inode *inode, |
| 387 | loff_t pos, size_t count) |
Miklos Szeredi | 307242f | 2004-01-26 11:28:44 +0000 | [diff] [blame] | 388 | { |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 389 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 390 | unsigned starti; |
| 391 | unsigned endi; |
| 392 | unsigned nexti; |
| 393 | struct fuse_req *req; |
| 394 | loff_t size = i_size_read(inode); |
| 395 | loff_t end = (pos + count + FUSE_BLOCK_SIZE - 1) & FUSE_BLOCK_MASK; |
| 396 | end = min(end, size); |
| 397 | if (end <= pos) |
| 398 | return 0; |
| 399 | |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 400 | starti = (pos & FUSE_BLOCK_MASK) >> PAGE_CACHE_SHIFT; |
| 401 | endi = (end + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; |
| 402 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 403 | req = fuse_get_request(fc); |
| 404 | if (!req) |
| 405 | return -ERESTARTSYS; |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 406 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 407 | for (; starti < endi; starti = nexti) { |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 408 | nexti = starti + (FUSE_BLOCK_SIZE >> PAGE_CACHE_SHIFT); |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 409 | nexti = min(nexti, endi); |
| 410 | if (!fuse_is_block_uptodate(inode, starti, nexti)) { |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 411 | if (fuse_file_read_block(req, file, inode, starti, nexti)) |
| 412 | break; |
| 413 | |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 414 | fuse_reset_request(req); |
| 415 | } |
Miklos Szeredi | 307242f | 2004-01-26 11:28:44 +0000 | [diff] [blame] | 416 | } |
Miklos Szeredi | 83a0744 | 2004-11-30 18:25:20 +0000 | [diff] [blame] | 417 | fuse_put_request(fc, req); |
| 418 | return 0; |
Miklos Szeredi | 307242f | 2004-01-26 11:28:44 +0000 | [diff] [blame] | 419 | } |
Miklos Szeredi | 13ed482 | 2004-11-20 11:12:21 +0000 | [diff] [blame] | 420 | #endif /* KERNEL_2_6 */ |
Miklos Szeredi | 307242f | 2004-01-26 11:28:44 +0000 | [diff] [blame] | 421 | |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 422 | static size_t fuse_send_write(struct fuse_req *req, struct file *file, |
Miklos Szeredi | 3ead28e | 2005-01-18 21:23:41 +0000 | [diff] [blame] | 423 | struct inode *inode, loff_t pos, size_t count) |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 424 | { |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 425 | struct fuse_conn *fc = get_fuse_conn(inode); |
| 426 | struct fuse_file *ff = file->private_data; |
| 427 | struct fuse_write_in inarg; |
| 428 | struct fuse_write_out outarg; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 429 | |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 430 | memset(&inarg, 0, sizeof(struct fuse_write_in)); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 431 | inarg.fh = ff->fh; |
| 432 | inarg.offset = pos; |
| 433 | inarg.size = count; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 434 | req->in.h.opcode = FUSE_WRITE; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 435 | req->in.h.nodeid = get_node_id(inode); |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 436 | req->inode = inode; |
| 437 | req->file = file; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 438 | req->in.argpages = 1; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 439 | req->in.numargs = 2; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 440 | req->in.args[0].size = sizeof(struct fuse_write_in); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 441 | req->in.args[0].value = &inarg; |
Miklos Szeredi | 7eafcce | 2004-06-19 22:42:38 +0000 | [diff] [blame] | 442 | req->in.args[1].size = count; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 443 | req->out.numargs = 1; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 444 | req->out.args[0].size = sizeof(struct fuse_write_out); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 445 | req->out.args[0].value = &outarg; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 446 | request_send_nonint(fc, req); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 447 | return outarg.size; |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 448 | } |
| 449 | |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 450 | static int fuse_prepare_write(struct file *file, struct page *page, |
| 451 | unsigned offset, unsigned to) |
| 452 | { |
| 453 | /* No op */ |
| 454 | return 0; |
| 455 | } |
| 456 | |
| 457 | static int fuse_commit_write(struct file *file, struct page *page, |
| 458 | unsigned offset, unsigned to) |
| 459 | { |
| 460 | int err; |
Miklos Szeredi | 1adb227 | 2005-01-18 21:19:58 +0000 | [diff] [blame] | 461 | size_t nres; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 462 | unsigned count = to - offset; |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 463 | struct inode *inode = page->mapping->host; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 464 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 465 | loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + offset; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 466 | struct fuse_req *req = fuse_get_request_nonint(fc); |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 467 | if (!req) |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 468 | return -EINTR; |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 469 | |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 470 | req->num_pages = 1; |
| 471 | req->pages[0] = page; |
| 472 | req->page_offset = offset; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 473 | nres = fuse_send_write(req, file, inode, pos, count); |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 474 | err = req->out.h.error; |
Miklos Szeredi | 0fcfa03 | 2004-12-13 15:22:28 +0000 | [diff] [blame] | 475 | fuse_put_request(fc, req); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 476 | if (!err && nres != count) |
| 477 | err = -EIO; |
Miklos Szeredi | c26c14d | 2004-04-09 17:48:32 +0000 | [diff] [blame] | 478 | if (!err) { |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 479 | pos += count; |
Miklos Szeredi | c26c14d | 2004-04-09 17:48:32 +0000 | [diff] [blame] | 480 | if (pos > i_size_read(inode)) |
Miklos Szeredi | d1199f8 | 2004-02-06 15:29:22 +0000 | [diff] [blame] | 481 | i_size_write(inode, pos); |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 482 | |
| 483 | if (offset == 0 && to == PAGE_CACHE_SIZE) { |
Miklos Szeredi | 069c950 | 2004-07-16 16:17:02 +0000 | [diff] [blame] | 484 | clear_page_dirty(page); |
| 485 | SetPageUptodate(page); |
| 486 | } |
Miklos Szeredi | 0fcfa03 | 2004-12-13 15:22:28 +0000 | [diff] [blame] | 487 | } else if (err == -EINTR || err == -EIO) |
| 488 | fuse_invalidate_attr(inode); |
Miklos Szeredi | a181e61 | 2001-11-06 12:03:23 +0000 | [diff] [blame] | 489 | return err; |
| 490 | } |
| 491 | |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 492 | static void fuse_release_user_pages(struct fuse_req *req, int write) |
| 493 | { |
| 494 | unsigned i; |
| 495 | |
| 496 | for (i = 0; i < req->num_pages; i++) { |
| 497 | struct page *page = req->pages[i]; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 498 | if (write) |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 499 | set_page_dirty_lock(page); |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 500 | put_page(page); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 501 | } |
| 502 | } |
| 503 | |
| 504 | static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf, |
| 505 | unsigned nbytes, int write) |
| 506 | { |
| 507 | unsigned long user_addr = (unsigned long) buf; |
| 508 | unsigned offset = user_addr & ~PAGE_MASK; |
| 509 | int npages; |
| 510 | |
| 511 | nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT); |
| 512 | npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT; |
| 513 | npages = min(npages, FUSE_MAX_PAGES_PER_REQ); |
Miklos Szeredi | c45d1a6 | 2004-12-07 20:13:47 +0000 | [diff] [blame] | 514 | down_read(¤t->mm->mmap_sem); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 515 | npages = get_user_pages(current, current->mm, user_addr, npages, write, |
| 516 | 0, req->pages, NULL); |
Miklos Szeredi | c45d1a6 | 2004-12-07 20:13:47 +0000 | [diff] [blame] | 517 | up_read(¤t->mm->mmap_sem); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 518 | if (npages < 0) |
| 519 | return npages; |
| 520 | |
| 521 | req->num_pages = npages; |
| 522 | req->page_offset = offset; |
| 523 | return 0; |
| 524 | } |
| 525 | |
| 526 | static ssize_t fuse_direct_io(struct file *file, const char __user *buf, |
| 527 | size_t count, loff_t *ppos, int write) |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 528 | { |
| 529 | struct inode *inode = file->f_dentry->d_inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 530 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | eab72ef | 2005-03-31 19:59:12 +0000 | [diff] [blame^] | 531 | size_t nmax = write ? fc->max_write : fc->max_read; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 532 | loff_t pos = *ppos; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 533 | ssize_t res = 0; |
| 534 | struct fuse_req *req = fuse_get_request(fc); |
Miklos Szeredi | 069c950 | 2004-07-16 16:17:02 +0000 | [diff] [blame] | 535 | if (!req) |
| 536 | return -ERESTARTSYS; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 537 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 538 | while (count) { |
Miklos Szeredi | eab72ef | 2005-03-31 19:59:12 +0000 | [diff] [blame^] | 539 | size_t tmp; |
| 540 | size_t nres; |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 541 | size_t nbytes = min(count, nmax); |
| 542 | int err = fuse_get_user_pages(req, buf, nbytes, !write); |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 543 | if (err) { |
| 544 | res = err; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 545 | break; |
| 546 | } |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 547 | tmp = (req->num_pages << PAGE_SHIFT) - req->page_offset; |
| 548 | nbytes = min(nbytes, tmp); |
| 549 | if (write) |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 550 | nres = fuse_send_write(req, file, inode, pos, nbytes); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 551 | else |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 552 | nres = fuse_send_read(req, file, inode, pos, nbytes); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 553 | fuse_release_user_pages(req, !write); |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 554 | if (req->out.h.error) { |
| 555 | if (!res) |
| 556 | res = req->out.h.error; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 557 | break; |
Miklos Szeredi | e56818b | 2004-12-12 11:45:24 +0000 | [diff] [blame] | 558 | } else if (nres > nbytes) { |
| 559 | res = -EIO; |
| 560 | break; |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 561 | } |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 562 | count -= nres; |
| 563 | res += nres; |
| 564 | pos += nres; |
| 565 | buf += nres; |
| 566 | if (nres != nbytes) |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 567 | break; |
Miklos Szeredi | 069c950 | 2004-07-16 16:17:02 +0000 | [diff] [blame] | 568 | if (count) |
| 569 | fuse_reset_request(req); |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 570 | } |
Miklos Szeredi | 069c950 | 2004-07-16 16:17:02 +0000 | [diff] [blame] | 571 | fuse_put_request(fc, req); |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 572 | if (res > 0) { |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 573 | if (write && pos > i_size_read(inode)) |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 574 | i_size_write(inode, pos); |
| 575 | *ppos = pos; |
Miklos Szeredi | 0fcfa03 | 2004-12-13 15:22:28 +0000 | [diff] [blame] | 576 | } else if (write && (res == -EINTR || res == -EIO)) |
| 577 | fuse_invalidate_attr(inode); |
| 578 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 579 | return res; |
| 580 | } |
| 581 | |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 582 | static ssize_t fuse_file_read(struct file *file, char __user *buf, |
| 583 | size_t count, loff_t *ppos) |
| 584 | { |
| 585 | struct inode *inode = file->f_dentry->d_inode; |
| 586 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 587 | |
| 588 | if (fc->flags & FUSE_DIRECT_IO) |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 589 | return fuse_direct_io(file, buf, count, ppos, 0); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 590 | #ifndef KERNEL_2_6 |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 591 | else { |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 592 | if (fc->flags & FUSE_LARGE_READ) { |
Miklos Szeredi | 6498819 | 2004-12-05 21:24:00 +0000 | [diff] [blame] | 593 | int res; |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 594 | down(&inode->i_sem); |
| 595 | res = fuse_file_bigread(file, inode, *ppos, count); |
| 596 | up(&inode->i_sem); |
| 597 | if (res) |
| 598 | return res; |
| 599 | } |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 600 | return generic_file_read(file, buf, count, ppos); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 601 | } |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 602 | #else |
| 603 | else |
| 604 | return generic_file_read(file, buf, count, ppos); |
| 605 | #endif |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 606 | } |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 607 | |
Miklos Szeredi | 13ed482 | 2004-11-20 11:12:21 +0000 | [diff] [blame] | 608 | static ssize_t fuse_file_write(struct file *file, const char __user *buf, |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 609 | size_t count, loff_t *ppos) |
| 610 | { |
| 611 | struct inode *inode = file->f_dentry->d_inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 612 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 613 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 614 | if (fc->flags & FUSE_DIRECT_IO) { |
| 615 | ssize_t res; |
Miklos Szeredi | 0f62d72 | 2005-01-04 12:45:54 +0000 | [diff] [blame] | 616 | /* Don't allow parallel writes to the same file */ |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 617 | down(&inode->i_sem); |
Miklos Szeredi | 5c7e63e | 2004-12-01 23:31:03 +0000 | [diff] [blame] | 618 | res = fuse_direct_io(file, buf, count, ppos, 1); |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 619 | up(&inode->i_sem); |
| 620 | return res; |
| 621 | } |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 622 | else |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 623 | return generic_file_write(file, buf, count, ppos); |
| 624 | } |
Miklos Szeredi | aa63b6b | 2004-12-03 13:24:35 +0000 | [diff] [blame] | 625 | |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 626 | static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma) |
| 627 | { |
| 628 | struct inode *inode = file->f_dentry->d_inode; |
Miklos Szeredi | 039322d | 2004-12-01 18:39:12 +0000 | [diff] [blame] | 629 | struct fuse_conn *fc = get_fuse_conn(inode); |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 630 | |
| 631 | if (fc->flags & FUSE_DIRECT_IO) |
| 632 | return -ENODEV; |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 633 | |
| 634 | if ((vma->vm_flags & VM_SHARED)) { |
| 635 | if ((vma->vm_flags & VM_WRITE)) |
| 636 | return -ENODEV; |
| 637 | else |
| 638 | vma->vm_flags &= ~VM_MAYWRITE; |
Miklos Szeredi | 209f5d0 | 2004-07-24 19:56:16 +0000 | [diff] [blame] | 639 | } |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 640 | return generic_file_mmap(file, vma); |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 641 | } |
| 642 | |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 643 | #ifdef KERNEL_2_6 |
| 644 | static int fuse_set_page_dirty(struct page *page) |
| 645 | { |
| 646 | printk("fuse_set_page_dirty: should not happen\n"); |
| 647 | dump_stack(); |
| 648 | return 0; |
| 649 | } |
| 650 | #endif |
| 651 | |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 652 | static struct file_operations fuse_file_operations = { |
Miklos Szeredi | f43f063 | 2005-02-28 11:46:56 +0000 | [diff] [blame] | 653 | .llseek = generic_file_llseek, |
Miklos Szeredi | 89b86af | 2004-02-06 17:02:08 +0000 | [diff] [blame] | 654 | .read = fuse_file_read, |
Miklos Szeredi | ad051c3 | 2004-07-02 09:22:50 +0000 | [diff] [blame] | 655 | .write = fuse_file_write, |
| 656 | .mmap = fuse_file_mmap, |
Miklos Szeredi | 89b86af | 2004-02-06 17:02:08 +0000 | [diff] [blame] | 657 | .open = fuse_open, |
Miklos Szeredi | e2e4ac2 | 2004-05-18 08:45:28 +0000 | [diff] [blame] | 658 | .flush = fuse_flush, |
Miklos Szeredi | 89b86af | 2004-02-06 17:02:08 +0000 | [diff] [blame] | 659 | .release = fuse_release, |
| 660 | .fsync = fuse_fsync, |
| 661 | #ifdef KERNEL_2_6 |
| 662 | .sendfile = generic_file_sendfile, |
| 663 | #endif |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 664 | }; |
| 665 | |
| 666 | static struct address_space_operations fuse_file_aops = { |
Miklos Szeredi | 84ba0f4 | 2004-07-18 11:32:59 +0000 | [diff] [blame] | 667 | .readpage = fuse_readpage, |
Miklos Szeredi | 84ba0f4 | 2004-07-18 11:32:59 +0000 | [diff] [blame] | 668 | .prepare_write = fuse_prepare_write, |
| 669 | .commit_write = fuse_commit_write, |
Miklos Szeredi | 015fe70 | 2004-07-12 11:52:24 +0000 | [diff] [blame] | 670 | #ifdef KERNEL_2_6 |
Miklos Szeredi | 5886537 | 2004-07-20 14:22:26 +0000 | [diff] [blame] | 671 | .readpages = fuse_readpages, |
Miklos Szeredi | 2a92727 | 2005-01-07 11:14:15 +0000 | [diff] [blame] | 672 | .set_page_dirty = fuse_set_page_dirty, |
Miklos Szeredi | 015fe70 | 2004-07-12 11:52:24 +0000 | [diff] [blame] | 673 | #endif |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 674 | }; |
| 675 | |
| 676 | void fuse_init_file_inode(struct inode *inode) |
| 677 | { |
| 678 | inode->i_fop = &fuse_file_operations; |
| 679 | inode->i_data.a_ops = &fuse_file_aops; |
Miklos Szeredi | 5e18348 | 2001-10-31 14:52:35 +0000 | [diff] [blame] | 680 | } |