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