1 /* 2 * linux/fs/9p/vfs_file.c 3 * 4 * This file contians vfs file ops for 9P2000. 5 * 6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> 7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 11 * as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to: 20 * Free Software Foundation 21 * 51 Franklin Street, Fifth Floor 22 * Boston, MA 02111-1301 USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/fs.h> 29 #include <linux/sched.h> 30 #include <linux/file.h> 31 #include <linux/stat.h> 32 #include <linux/string.h> 33 #include <linux/inet.h> 34 #include <linux/list.h> 35 #include <linux/pagemap.h> 36 #include <linux/utsname.h> 37 #include <asm/uaccess.h> 38 #include <linux/idr.h> 39 #include <net/9p/9p.h> 40 #include <net/9p/client.h> 41 42 #include "v9fs.h" 43 #include "v9fs_vfs.h" 44 #include "fid.h" 45 #include "cache.h" 46 47 static const struct file_operations v9fs_cached_file_operations; 48 static const struct file_operations v9fs_cached_file_operations_dotl; 49 50 /** 51 * v9fs_file_open - open a file (or directory) 52 * @inode: inode to be opened 53 * @file: file being opened 54 * 55 */ 56 57 int v9fs_file_open(struct inode *inode, struct file *file) 58 { 59 int err; 60 struct v9fs_session_info *v9ses; 61 struct p9_fid *fid; 62 int omode; 63 64 P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file); 65 v9ses = v9fs_inode2v9ses(inode); 66 if (v9fs_proto_dotl(v9ses)) 67 omode = file->f_flags; 68 else 69 omode = v9fs_uflags2omode(file->f_flags, 70 v9fs_proto_dotu(v9ses)); 71 fid = file->private_data; 72 if (!fid) { 73 fid = v9fs_fid_clone(file->f_path.dentry); 74 if (IS_ERR(fid)) 75 return PTR_ERR(fid); 76 77 err = p9_client_open(fid, omode); 78 if (err < 0) { 79 p9_client_clunk(fid); 80 return err; 81 } 82 if (file->f_flags & O_TRUNC) { 83 i_size_write(inode, 0); 84 inode->i_blocks = 0; 85 } 86 if ((file->f_flags & O_APPEND) && 87 (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))) 88 generic_file_llseek(file, 0, SEEK_END); 89 } 90 91 file->private_data = fid; 92 if ((fid->qid.version) && (v9ses->cache)) { 93 P9_DPRINTK(P9_DEBUG_VFS, "cached"); 94 /* enable cached file options */ 95 if(file->f_op == &v9fs_file_operations) 96 file->f_op = &v9fs_cached_file_operations; 97 else if (file->f_op == &v9fs_file_operations_dotl) 98 file->f_op = &v9fs_cached_file_operations_dotl; 99 100 #ifdef CONFIG_9P_FSCACHE 101 v9fs_cache_inode_set_cookie(inode, file); 102 #endif 103 } 104 105 return 0; 106 } 107 108 /** 109 * v9fs_file_lock - lock a file (or directory) 110 * @filp: file to be locked 111 * @cmd: lock command 112 * @fl: file lock structure 113 * 114 * Bugs: this looks like a local only lock, we should extend into 9P 115 * by using open exclusive 116 */ 117 118 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) 119 { 120 int res = 0; 121 struct inode *inode = filp->f_path.dentry->d_inode; 122 123 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl); 124 125 /* No mandatory locks */ 126 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 127 return -ENOLCK; 128 129 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 130 filemap_write_and_wait(inode->i_mapping); 131 invalidate_mapping_pages(&inode->i_data, 0, -1); 132 } 133 134 return res; 135 } 136 137 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) 138 { 139 struct p9_flock flock; 140 struct p9_fid *fid; 141 uint8_t status; 142 int res = 0; 143 unsigned char fl_type; 144 145 fid = filp->private_data; 146 BUG_ON(fid == NULL); 147 148 if ((fl->fl_flags & FL_POSIX) != FL_POSIX) 149 BUG(); 150 151 res = posix_lock_file_wait(filp, fl); 152 if (res < 0) 153 goto out; 154 155 /* convert posix lock to p9 tlock args */ 156 memset(&flock, 0, sizeof(flock)); 157 flock.type = fl->fl_type; 158 flock.start = fl->fl_start; 159 if (fl->fl_end == OFFSET_MAX) 160 flock.length = 0; 161 else 162 flock.length = fl->fl_end - fl->fl_start + 1; 163 flock.proc_id = fl->fl_pid; 164 flock.client_id = utsname()->nodename; 165 if (IS_SETLKW(cmd)) 166 flock.flags = P9_LOCK_FLAGS_BLOCK; 167 168 /* 169 * if its a blocked request and we get P9_LOCK_BLOCKED as the status 170 * for lock request, keep on trying 171 */ 172 for (;;) { 173 res = p9_client_lock_dotl(fid, &flock, &status); 174 if (res < 0) 175 break; 176 177 if (status != P9_LOCK_BLOCKED) 178 break; 179 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd)) 180 break; 181 schedule_timeout_interruptible(P9_LOCK_TIMEOUT); 182 } 183 184 /* map 9p status to VFS status */ 185 switch (status) { 186 case P9_LOCK_SUCCESS: 187 res = 0; 188 break; 189 case P9_LOCK_BLOCKED: 190 res = -EAGAIN; 191 break; 192 case P9_LOCK_ERROR: 193 case P9_LOCK_GRACE: 194 res = -ENOLCK; 195 break; 196 default: 197 BUG(); 198 } 199 200 /* 201 * incase server returned error for lock request, revert 202 * it locally 203 */ 204 if (res < 0 && fl->fl_type != F_UNLCK) { 205 fl_type = fl->fl_type; 206 fl->fl_type = F_UNLCK; 207 res = posix_lock_file_wait(filp, fl); 208 fl->fl_type = fl_type; 209 } 210 out: 211 return res; 212 } 213 214 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl) 215 { 216 struct p9_getlock glock; 217 struct p9_fid *fid; 218 int res = 0; 219 220 fid = filp->private_data; 221 BUG_ON(fid == NULL); 222 223 posix_test_lock(filp, fl); 224 /* 225 * if we have a conflicting lock locally, no need to validate 226 * with server 227 */ 228 if (fl->fl_type != F_UNLCK) 229 return res; 230 231 /* convert posix lock to p9 tgetlock args */ 232 memset(&glock, 0, sizeof(glock)); 233 glock.type = fl->fl_type; 234 glock.start = fl->fl_start; 235 if (fl->fl_end == OFFSET_MAX) 236 glock.length = 0; 237 else 238 glock.length = fl->fl_end - fl->fl_start + 1; 239 glock.proc_id = fl->fl_pid; 240 glock.client_id = utsname()->nodename; 241 242 res = p9_client_getlock_dotl(fid, &glock); 243 if (res < 0) 244 return res; 245 if (glock.type != F_UNLCK) { 246 fl->fl_type = glock.type; 247 fl->fl_start = glock.start; 248 if (glock.length == 0) 249 fl->fl_end = OFFSET_MAX; 250 else 251 fl->fl_end = glock.start + glock.length - 1; 252 fl->fl_pid = glock.proc_id; 253 } else 254 fl->fl_type = F_UNLCK; 255 256 return res; 257 } 258 259 /** 260 * v9fs_file_lock_dotl - lock a file (or directory) 261 * @filp: file to be locked 262 * @cmd: lock command 263 * @fl: file lock structure 264 * 265 */ 266 267 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) 268 { 269 struct inode *inode = filp->f_path.dentry->d_inode; 270 int ret = -ENOLCK; 271 272 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp, 273 cmd, fl, filp->f_path.dentry->d_name.name); 274 275 /* No mandatory locks */ 276 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 277 goto out_err; 278 279 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 280 filemap_write_and_wait(inode->i_mapping); 281 invalidate_mapping_pages(&inode->i_data, 0, -1); 282 } 283 284 if (IS_SETLK(cmd) || IS_SETLKW(cmd)) 285 ret = v9fs_file_do_lock(filp, cmd, fl); 286 else if (IS_GETLK(cmd)) 287 ret = v9fs_file_getlock(filp, fl); 288 else 289 ret = -EINVAL; 290 out_err: 291 return ret; 292 } 293 294 /** 295 * v9fs_file_flock_dotl - lock a file 296 * @filp: file to be locked 297 * @cmd: lock command 298 * @fl: file lock structure 299 * 300 */ 301 302 static int v9fs_file_flock_dotl(struct file *filp, int cmd, 303 struct file_lock *fl) 304 { 305 struct inode *inode = filp->f_path.dentry->d_inode; 306 int ret = -ENOLCK; 307 308 P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp, 309 cmd, fl, filp->f_path.dentry->d_name.name); 310 311 /* No mandatory locks */ 312 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 313 goto out_err; 314 315 if (!(fl->fl_flags & FL_FLOCK)) 316 goto out_err; 317 318 if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) { 319 filemap_write_and_wait(inode->i_mapping); 320 invalidate_mapping_pages(&inode->i_data, 0, -1); 321 } 322 /* Convert flock to posix lock */ 323 fl->fl_owner = (fl_owner_t)filp; 324 fl->fl_start = 0; 325 fl->fl_end = OFFSET_MAX; 326 fl->fl_flags |= FL_POSIX; 327 fl->fl_flags ^= FL_FLOCK; 328 329 if (IS_SETLK(cmd) | IS_SETLKW(cmd)) 330 ret = v9fs_file_do_lock(filp, cmd, fl); 331 else 332 ret = -EINVAL; 333 out_err: 334 return ret; 335 } 336 337 /** 338 * v9fs_file_readn - read from a file 339 * @filp: file pointer to read 340 * @data: data buffer to read data into 341 * @udata: user data buffer to read data into 342 * @count: size of buffer 343 * @offset: offset at which to read data 344 * 345 */ 346 347 ssize_t 348 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count, 349 u64 offset) 350 { 351 int n, total, size; 352 struct p9_fid *fid = filp->private_data; 353 354 P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid, 355 (long long unsigned) offset, count); 356 357 n = 0; 358 total = 0; 359 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 360 do { 361 n = p9_client_read(fid, data, udata, offset, count); 362 if (n <= 0) 363 break; 364 365 if (data) 366 data += n; 367 if (udata) 368 udata += n; 369 370 offset += n; 371 count -= n; 372 total += n; 373 } while (count > 0 && n == size); 374 375 if (n < 0) 376 total = n; 377 378 return total; 379 } 380 381 /** 382 * v9fs_file_read - read from a file 383 * @filp: file pointer to read 384 * @udata: user data buffer to read data into 385 * @count: size of buffer 386 * @offset: offset at which to read data 387 * 388 */ 389 390 static ssize_t 391 v9fs_file_read(struct file *filp, char __user *udata, size_t count, 392 loff_t * offset) 393 { 394 int ret; 395 struct p9_fid *fid; 396 size_t size; 397 398 P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset); 399 fid = filp->private_data; 400 401 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 402 if (count > size) 403 ret = v9fs_file_readn(filp, NULL, udata, count, *offset); 404 else 405 ret = p9_client_read(fid, NULL, udata, *offset, count); 406 407 if (ret > 0) 408 *offset += ret; 409 410 return ret; 411 } 412 413 /** 414 * v9fs_file_write - write to a file 415 * @filp: file pointer to write 416 * @data: data buffer to write data from 417 * @count: size of buffer 418 * @offset: offset at which to write data 419 * 420 */ 421 422 static ssize_t 423 v9fs_file_write(struct file *filp, const char __user * data, 424 size_t count, loff_t * offset) 425 { 426 ssize_t retval; 427 size_t total = 0; 428 int n; 429 struct p9_fid *fid; 430 struct p9_client *clnt; 431 struct inode *inode = filp->f_path.dentry->d_inode; 432 loff_t origin = *offset; 433 unsigned long pg_start, pg_end; 434 435 P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data, 436 (int)count, (int)*offset); 437 438 fid = filp->private_data; 439 clnt = fid->clnt; 440 441 retval = generic_write_checks(filp, &origin, &count, 0); 442 if (retval) 443 goto out; 444 445 retval = -EINVAL; 446 if ((ssize_t) count < 0) 447 goto out; 448 retval = 0; 449 if (!count) 450 goto out; 451 452 do { 453 n = p9_client_write(fid, NULL, data+total, origin+total, count); 454 if (n <= 0) 455 break; 456 count -= n; 457 total += n; 458 } while (count > 0); 459 460 if (total > 0) { 461 pg_start = origin >> PAGE_CACHE_SHIFT; 462 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT; 463 if (inode->i_mapping && inode->i_mapping->nrpages) 464 invalidate_inode_pages2_range(inode->i_mapping, 465 pg_start, pg_end); 466 *offset += total; 467 i_size_write(inode, i_size_read(inode) + total); 468 inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9; 469 } 470 471 if (n < 0) 472 retval = n; 473 else 474 retval = total; 475 out: 476 return retval; 477 } 478 479 static int v9fs_file_fsync(struct file *filp, int datasync) 480 { 481 struct p9_fid *fid; 482 struct p9_wstat wstat; 483 int retval; 484 485 P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync); 486 487 fid = filp->private_data; 488 v9fs_blank_wstat(&wstat); 489 490 retval = p9_client_wstat(fid, &wstat); 491 return retval; 492 } 493 494 static int v9fs_file_fsync_dotl(struct file *filp, int datasync) 495 { 496 struct p9_fid *fid; 497 int retval; 498 499 P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n", 500 filp, datasync); 501 502 fid = filp->private_data; 503 504 retval = p9_client_fsync(fid); 505 return retval; 506 } 507 508 static const struct file_operations v9fs_cached_file_operations = { 509 .llseek = generic_file_llseek, 510 .read = do_sync_read, 511 .aio_read = generic_file_aio_read, 512 .write = v9fs_file_write, 513 .open = v9fs_file_open, 514 .release = v9fs_dir_release, 515 .lock = v9fs_file_lock, 516 .mmap = generic_file_readonly_mmap, 517 .fsync = v9fs_file_fsync, 518 }; 519 520 static const struct file_operations v9fs_cached_file_operations_dotl = { 521 .llseek = generic_file_llseek, 522 .read = do_sync_read, 523 .aio_read = generic_file_aio_read, 524 .write = v9fs_file_write, 525 .open = v9fs_file_open, 526 .release = v9fs_dir_release, 527 .lock = v9fs_file_lock_dotl, 528 .flock = v9fs_file_flock_dotl, 529 .mmap = generic_file_readonly_mmap, 530 .fsync = v9fs_file_fsync_dotl, 531 }; 532 533 const struct file_operations v9fs_file_operations = { 534 .llseek = generic_file_llseek, 535 .read = v9fs_file_read, 536 .write = v9fs_file_write, 537 .open = v9fs_file_open, 538 .release = v9fs_dir_release, 539 .lock = v9fs_file_lock, 540 .mmap = generic_file_readonly_mmap, 541 .fsync = v9fs_file_fsync, 542 }; 543 544 const struct file_operations v9fs_file_operations_dotl = { 545 .llseek = generic_file_llseek, 546 .read = v9fs_file_read, 547 .write = v9fs_file_write, 548 .open = v9fs_file_open, 549 .release = v9fs_dir_release, 550 .lock = v9fs_file_lock_dotl, 551 .flock = v9fs_file_flock_dotl, 552 .mmap = generic_file_readonly_mmap, 553 .fsync = v9fs_file_fsync_dotl, 554 }; 555