vfs_file.c 18.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 *  linux/fs/9p/vfs_file.c
 *
 * This file contians vfs file ops for 9P2000.
 *
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
10 11
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
29
#include <linux/sched.h>
30 31 32 33 34
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/inet.h>
#include <linux/list.h>
35
#include <linux/pagemap.h>
M. Mohan Kumar's avatar
M. Mohan Kumar committed
36
#include <linux/utsname.h>
37 38
#include <asm/uaccess.h>
#include <linux/idr.h>
39 40
#include <net/9p/9p.h>
#include <net/9p/client.h>
41 42 43 44

#include "v9fs.h"
#include "v9fs_vfs.h"
#include "fid.h"
45
#include "cache.h"
46

47 48
static const struct vm_operations_struct v9fs_file_vm_ops;

49 50 51 52 53 54 55 56 57
/**
 * v9fs_file_open - open a file (or directory)
 * @inode: inode to be opened
 * @file: file being opened
 *
 */

int v9fs_file_open(struct inode *inode, struct file *file)
{
58
	int err;
59
	struct v9fs_inode *v9inode;
60 61 62
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid;
	int omode;
63

64
	p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
65
	v9inode = V9FS_I(inode);
66
	v9ses = v9fs_inode2v9ses(inode);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
67
	if (v9fs_proto_dotl(v9ses))
68
		omode = v9fs_open_to_dotl_flags(file->f_flags);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
69 70 71
	else
		omode = v9fs_uflags2omode(file->f_flags,
					v9fs_proto_dotu(v9ses));
72 73 74 75 76 77 78
	fid = file->private_data;
	if (!fid) {
		fid = v9fs_fid_clone(file->f_path.dentry);
		if (IS_ERR(fid))
			return PTR_ERR(fid);

		err = p9_client_open(fid, omode);
79
		if (err < 0) {
80 81 82
			p9_client_clunk(fid);
			return err;
		}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
83
		if (file->f_flags & O_TRUNC) {
84
			i_size_write(inode, 0);
85 86
			inode->i_blocks = 0;
		}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
87 88
		if ((file->f_flags & O_APPEND) &&
			(!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
89
			generic_file_llseek(file, 0, SEEK_END);
90
	}
91

92
	file->private_data = fid;
93
	mutex_lock(&v9inode->v_mutex);
94 95
	if (v9ses->cache && !v9inode->writeback_fid &&
	    ((file->f_flags & O_ACCMODE) != O_RDONLY)) {
96
		/*
97
		 * clone a fid and add it to writeback_fid
98 99 100 101 102 103 104 105
		 * we do it during open time instead of
		 * page dirty time via write_begin/page_mkwrite
		 * because we want write after unlink usecase
		 * to work.
		 */
		fid = v9fs_writeback_fid(file->f_path.dentry);
		if (IS_ERR(fid)) {
			err = PTR_ERR(fid);
106
			mutex_unlock(&v9inode->v_mutex);
107 108
			goto out_error;
		}
109
		v9inode->writeback_fid = (void *) fid;
110
	}
111
	mutex_unlock(&v9inode->v_mutex);
112
#ifdef CONFIG_9P_FSCACHE
113
	if (v9ses->cache)
114
		v9fs_cache_inode_set_cookie(inode, file);
115
#endif
116
	return 0;
117 118 119 120
out_error:
	p9_client_clunk(file->private_data);
	file->private_data = NULL;
	return err;
121 122 123 124
}

/**
 * v9fs_file_lock - lock a file (or directory)
125 126 127
 * @filp: file to be locked
 * @cmd: lock command
 * @fl: file lock structure
128
 *
129
 * Bugs: this looks like a local only lock, we should extend into 9P
130 131 132 133 134 135
 *       by using open exclusive
 */

static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
{
	int res = 0;
136
	struct inode *inode = filp->f_path.dentry->d_inode;
137

138
	p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
139 140

	/* No mandatory locks */
141
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
142 143 144
		return -ENOLCK;

	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
145
		filemap_write_and_wait(inode->i_mapping);
146
		invalidate_mapping_pages(&inode->i_data, 0, -1);
147 148 149 150 151
	}

	return res;
}

M. Mohan Kumar's avatar
M. Mohan Kumar committed
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
{
	struct p9_flock flock;
	struct p9_fid *fid;
	uint8_t status;
	int res = 0;
	unsigned char fl_type;

	fid = filp->private_data;
	BUG_ON(fid == NULL);

	if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
		BUG();

	res = posix_lock_file_wait(filp, fl);
	if (res < 0)
		goto out;

	/* convert posix lock to p9 tlock args */
	memset(&flock, 0, sizeof(flock));
172 173 174 175 176 177 178 179 180 181 182 183
	/* map the lock type */
	switch (fl->fl_type) {
	case F_RDLCK:
		flock.type = P9_LOCK_TYPE_RDLCK;
		break;
	case F_WRLCK:
		flock.type = P9_LOCK_TYPE_WRLCK;
		break;
	case F_UNLCK:
		flock.type = P9_LOCK_TYPE_UNLCK;
		break;
	}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
	flock.start = fl->fl_start;
	if (fl->fl_end == OFFSET_MAX)
		flock.length = 0;
	else
		flock.length = fl->fl_end - fl->fl_start + 1;
	flock.proc_id = fl->fl_pid;
	flock.client_id = utsname()->nodename;
	if (IS_SETLKW(cmd))
		flock.flags = P9_LOCK_FLAGS_BLOCK;

	/*
	 * if its a blocked request and we get P9_LOCK_BLOCKED as the status
	 * for lock request, keep on trying
	 */
	for (;;) {
		res = p9_client_lock_dotl(fid, &flock, &status);
		if (res < 0)
			break;

		if (status != P9_LOCK_BLOCKED)
			break;
		if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))
			break;
207 208
		if (schedule_timeout_interruptible(P9_LOCK_TIMEOUT) != 0)
			break;
M. Mohan Kumar's avatar
M. Mohan Kumar committed
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
	}

	/* map 9p status to VFS status */
	switch (status) {
	case P9_LOCK_SUCCESS:
		res = 0;
		break;
	case P9_LOCK_BLOCKED:
		res = -EAGAIN;
		break;
	case P9_LOCK_ERROR:
	case P9_LOCK_GRACE:
		res = -ENOLCK;
		break;
	default:
		BUG();
	}

	/*
	 * incase server returned error for lock request, revert
	 * it locally
	 */
	if (res < 0 && fl->fl_type != F_UNLCK) {
		fl_type = fl->fl_type;
		fl->fl_type = F_UNLCK;
		res = posix_lock_file_wait(filp, fl);
		fl->fl_type = fl_type;
	}
out:
	return res;
}

M. Mohan Kumar's avatar
M. Mohan Kumar committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
{
	struct p9_getlock glock;
	struct p9_fid *fid;
	int res = 0;

	fid = filp->private_data;
	BUG_ON(fid == NULL);

	posix_test_lock(filp, fl);
	/*
	 * if we have a conflicting lock locally, no need to validate
	 * with server
	 */
	if (fl->fl_type != F_UNLCK)
		return res;

	/* convert posix lock to p9 tgetlock args */
	memset(&glock, 0, sizeof(glock));
260
	glock.type  = P9_LOCK_TYPE_UNLCK;
M. Mohan Kumar's avatar
M. Mohan Kumar committed
261 262 263 264 265 266 267 268 269 270 271
	glock.start = fl->fl_start;
	if (fl->fl_end == OFFSET_MAX)
		glock.length = 0;
	else
		glock.length = fl->fl_end - fl->fl_start + 1;
	glock.proc_id = fl->fl_pid;
	glock.client_id = utsname()->nodename;

	res = p9_client_getlock_dotl(fid, &glock);
	if (res < 0)
		return res;
272 273 274 275 276 277 278 279 280 281 282 283 284
	/* map 9p lock type to os lock type */
	switch (glock.type) {
	case P9_LOCK_TYPE_RDLCK:
		fl->fl_type = F_RDLCK;
		break;
	case P9_LOCK_TYPE_WRLCK:
		fl->fl_type = F_WRLCK;
		break;
	case P9_LOCK_TYPE_UNLCK:
		fl->fl_type = F_UNLCK;
		break;
	}
	if (glock.type != P9_LOCK_TYPE_UNLCK) {
M. Mohan Kumar's avatar
M. Mohan Kumar committed
285 286 287 288 289 290
		fl->fl_start = glock.start;
		if (glock.length == 0)
			fl->fl_end = OFFSET_MAX;
		else
			fl->fl_end = glock.start + glock.length - 1;
		fl->fl_pid = glock.proc_id;
291
	}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
292 293 294
	return res;
}

M. Mohan Kumar's avatar
M. Mohan Kumar committed
295 296 297 298 299 300 301 302 303 304 305 306 307
/**
 * v9fs_file_lock_dotl - lock a file (or directory)
 * @filp: file to be locked
 * @cmd: lock command
 * @fl: file lock structure
 *
 */

static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	int ret = -ENOLCK;

308 309
	p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
		 filp, cmd, fl, filp->f_path.dentry->d_name.name);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
310 311 312 313 314 315 316 317 318 319 320 321

	/* No mandatory locks */
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
		goto out_err;

	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
		filemap_write_and_wait(inode->i_mapping);
		invalidate_mapping_pages(&inode->i_data, 0, -1);
	}

	if (IS_SETLK(cmd) || IS_SETLKW(cmd))
		ret = v9fs_file_do_lock(filp, cmd, fl);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
322 323
	else if (IS_GETLK(cmd))
		ret = v9fs_file_getlock(filp, fl);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	else
		ret = -EINVAL;
out_err:
	return ret;
}

/**
 * v9fs_file_flock_dotl - lock a file
 * @filp: file to be locked
 * @cmd: lock command
 * @fl: file lock structure
 *
 */

static int v9fs_file_flock_dotl(struct file *filp, int cmd,
	struct file_lock *fl)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	int ret = -ENOLCK;

344 345
	p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n",
		 filp, cmd, fl, filp->f_path.dentry->d_name.name);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372

	/* No mandatory locks */
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
		goto out_err;

	if (!(fl->fl_flags & FL_FLOCK))
		goto out_err;

	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
		filemap_write_and_wait(inode->i_mapping);
		invalidate_mapping_pages(&inode->i_data, 0, -1);
	}
	/* Convert flock to posix lock */
	fl->fl_owner = (fl_owner_t)filp;
	fl->fl_start = 0;
	fl->fl_end = OFFSET_MAX;
	fl->fl_flags |= FL_POSIX;
	fl->fl_flags ^= FL_FLOCK;

	if (IS_SETLK(cmd) | IS_SETLKW(cmd))
		ret = v9fs_file_do_lock(filp, cmd, fl);
	else
		ret = -EINVAL;
out_err:
	return ret;
}

373
/**
374 375
 * v9fs_fid_readn - read from a fid
 * @fid: fid to read
376
 * @data: data buffer to read data into
377
 * @udata: user data buffer to read data into
378 379 380 381
 * @count: size of buffer
 * @offset: offset at which to read data
 *
 */
382
ssize_t
383
v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
384 385
	       u64 offset)
{
386
	int n, total, size;
387

388 389
	p9_debug(P9_DEBUG_VFS, "fid %d offset %llu count %d\n",
		 fid->fid, (long long unsigned)offset, count);
390 391
	n = 0;
	total = 0;
392
	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
393 394 395 396 397 398 399 400 401 402 403 404 405
	do {
		n = p9_client_read(fid, data, udata, offset, count);
		if (n <= 0)
			break;

		if (data)
			data += n;
		if (udata)
			udata += n;

		offset += n;
		count -= n;
		total += n;
406
	} while (count > 0 && n == size);
407 408 409 410 411 412 413

	if (n < 0)
		total = n;

	return total;
}

414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
/**
 * v9fs_file_readn - read from a file
 * @filp: file pointer to read
 * @data: data buffer to read data into
 * @udata: user data buffer to read data into
 * @count: size of buffer
 * @offset: offset at which to read data
 *
 */
ssize_t
v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
	       u64 offset)
{
	return v9fs_fid_readn(filp->private_data, data, udata, count, offset);
}

430 431 432 433 434 435 436 437 438
/**
 * v9fs_file_read - read from a file
 * @filp: file pointer to read
 * @udata: user data buffer to read data into
 * @count: size of buffer
 * @offset: offset at which to read data
 *
 */

439
static ssize_t
440
v9fs_file_read(struct file *filp, char __user *udata, size_t count,
441
	       loff_t * offset)
442
{
443 444
	int ret;
	struct p9_fid *fid;
445
	size_t size;
446

447
	p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset);
448
	fid = filp->private_data;
449

450 451
	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
	if (count > size)
452 453 454 455
		ret = v9fs_file_readn(filp, NULL, udata, count, *offset);
	else
		ret = p9_client_read(fid, NULL, udata, *offset, count);

456 457
	if (ret > 0)
		*offset += ret;
458

459
	return ret;
460 461
}

462 463 464 465
ssize_t
v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
			 const char __user *data, size_t count,
			 loff_t *offset, int invalidate)
466
{
467
	int n;
468
	loff_t i_size;
469
	size_t total = 0;
470
	struct p9_client *clnt;
471
	loff_t origin = *offset;
472
	unsigned long pg_start, pg_end;
473

474 475
	p9_debug(P9_DEBUG_VFS, "data %p count %d offset %x\n",
		 data, (int)count, (int)*offset);
476

477 478
	clnt = fid->clnt;
	do {
479
		n = p9_client_write(fid, NULL, data+total, origin+total, count);
480 481 482 483 484 485
		if (n <= 0)
			break;
		count -= n;
		total += n;
	} while (count > 0);

486
	if (invalidate && (total > 0)) {
487 488
		pg_start = origin >> PAGE_CACHE_SHIFT;
		pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
489 490 491
		if (inode->i_mapping && inode->i_mapping->nrpages)
			invalidate_inode_pages2_range(inode->i_mapping,
						      pg_start, pg_end);
492
		*offset += total;
493 494 495 496 497
		i_size = i_size_read(inode);
		if (*offset > i_size) {
			inode_add_bytes(inode, *offset - i_size);
			i_size_write(inode, *offset);
		}
498
	}
499
	if (n < 0)
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
		return n;

	return total;
}

/**
 * v9fs_file_write - write to a file
 * @filp: file pointer to write
 * @data: data buffer to write data from
 * @count: size of buffer
 * @offset: offset at which to write data
 *
 */
static ssize_t
v9fs_file_write(struct file *filp, const char __user * data,
		size_t count, loff_t *offset)
{
	ssize_t retval = 0;
	loff_t origin = *offset;


	retval = generic_write_checks(filp, &origin, &count, 0);
	if (retval)
		goto out;

	retval = -EINVAL;
	if ((ssize_t) count < 0)
		goto out;
	retval = 0;
	if (!count)
		goto out;

532
	retval = v9fs_file_write_internal(filp->f_path.dentry->d_inode,
533
					filp->private_data,
534 535 536 537
					data, count, &origin, 1);
	/* update offset on successful write */
	if (retval > 0)
		*offset = origin;
538 539
out:
	return retval;
540 541
}

542

543 544
static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end,
			   int datasync)
545 546
{
	struct p9_fid *fid;
547
	struct inode *inode = filp->f_mapping->host;
548 549 550
	struct p9_wstat wstat;
	int retval;

551 552 553 554 555
	retval = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (retval)
		return retval;

	mutex_lock(&inode->i_mutex);
556
	p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
557 558 559 560 561

	fid = filp->private_data;
	v9fs_blank_wstat(&wstat);

	retval = p9_client_wstat(fid, &wstat);
562 563
	mutex_unlock(&inode->i_mutex);

564 565 566
	return retval;
}

567 568
int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
			 int datasync)
569 570
{
	struct p9_fid *fid;
571
	struct inode *inode = filp->f_mapping->host;
572 573
	int retval;

574 575 576 577 578
	retval = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (retval)
		return retval;

	mutex_lock(&inode->i_mutex);
579
	p9_debug(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
580 581 582

	fid = filp->private_data;

583
	retval = p9_client_fsync(fid, datasync);
584 585
	mutex_unlock(&inode->i_mutex);

586 587 588
	return retval;
}

589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
static int
v9fs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int retval;

	retval = generic_file_mmap(file, vma);
	if (!retval)
		vma->vm_ops = &v9fs_file_vm_ops;

	return retval;
}

static int
v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
{
604
	struct v9fs_inode *v9inode;
605 606 607 608 609
	struct page *page = vmf->page;
	struct file *filp = vma->vm_file;
	struct inode *inode = filp->f_path.dentry->d_inode;


610 611
	p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n",
		 page, (unsigned long)filp->private_data);
612

613 614 615
	/* Update file times before taking page lock */
	file_update_time(filp);

616
	v9inode = V9FS_I(inode);
617 618
	/* make sure the cache has finished storing the page */
	v9fs_fscache_wait_on_page_write(inode, page);
619
	BUG_ON(!v9inode->writeback_fid);
620 621 622 623 624 625 626 627 628 629
	lock_page(page);
	if (page->mapping != inode->i_mapping)
		goto out_unlock;

	return VM_FAULT_LOCKED;
out_unlock:
	unlock_page(page);
	return VM_FAULT_NOPAGE;
}

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
static ssize_t
v9fs_direct_read(struct file *filp, char __user *udata, size_t count,
		 loff_t *offsetp)
{
	loff_t size, offset;
	struct inode *inode;
	struct address_space *mapping;

	offset = *offsetp;
	mapping = filp->f_mapping;
	inode = mapping->host;
	if (!count)
		return 0;
	size = i_size_read(inode);
	if (offset < size)
		filemap_write_and_wait_range(mapping, offset,
					     offset + count - 1);

	return v9fs_file_read(filp, udata, count, offsetp);
}

/**
 * v9fs_cached_file_read - read from a file
 * @filp: file pointer to read
 * @udata: user data buffer to read data into
 * @count: size of buffer
 * @offset: offset at which to read data
 *
 */
static ssize_t
v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
		      loff_t *offset)
{
	if (filp->f_flags & O_DIRECT)
		return v9fs_direct_read(filp, data, count, offset);
	return do_sync_read(filp, data, count, offset);
}

static ssize_t
v9fs_direct_write(struct file *filp, const char __user * data,
		  size_t count, loff_t *offsetp)
{
	loff_t offset;
	ssize_t retval;
	struct inode *inode;
	struct address_space *mapping;

	offset = *offsetp;
	mapping = filp->f_mapping;
	inode = mapping->host;
	if (!count)
		return 0;

	mutex_lock(&inode->i_mutex);
	retval = filemap_write_and_wait_range(mapping, offset,
					      offset + count - 1);
	if (retval)
		goto err_out;
	/*
	 * After a write we want buffered reads to be sure to go to disk to get
	 * the new data.  We invalidate clean cached page from the region we're
	 * about to write.  We do this *before* the write so that if we fail
	 * here we fall back to buffered write
	 */
	if (mapping->nrpages) {
		pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT;
		pgoff_t pg_end   = (offset + count - 1) >> PAGE_CACHE_SHIFT;

		retval = invalidate_inode_pages2_range(mapping,
							pg_start, pg_end);
		/*
		 * If a page can not be invalidated, fall back
		 * to buffered write.
		 */
		if (retval) {
			if (retval == -EBUSY)
				goto buff_write;
			goto err_out;
		}
	}
	retval = v9fs_file_write(filp, data, count, offsetp);
err_out:
	mutex_unlock(&inode->i_mutex);
	return retval;

buff_write:
	mutex_unlock(&inode->i_mutex);
	return do_sync_write(filp, data, count, offsetp);
}

/**
 * v9fs_cached_file_write - write to a file
 * @filp: file pointer to write
 * @data: data buffer to write data from
 * @count: size of buffer
 * @offset: offset at which to write data
 *
 */
static ssize_t
v9fs_cached_file_write(struct file *filp, const char __user * data,
		       size_t count, loff_t *offset)
{

	if (filp->f_flags & O_DIRECT)
		return v9fs_direct_write(filp, data, count, offset);
	return do_sync_write(filp, data, count, offset);
}

738 739 740
static const struct vm_operations_struct v9fs_file_vm_ops = {
	.fault = filemap_fault,
	.page_mkwrite = v9fs_vm_page_mkwrite,
741
	.remap_pages = generic_file_remap_pages,
742 743
};

744

745
const struct file_operations v9fs_cached_file_operations = {
746
	.llseek = generic_file_llseek,
747 748
	.read = v9fs_cached_file_read,
	.write = v9fs_cached_file_write,
749
	.aio_read = generic_file_aio_read,
750
	.aio_write = generic_file_aio_write,
751 752 753
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
	.lock = v9fs_file_lock,
754
	.mmap = v9fs_file_mmap,
755
	.fsync = v9fs_file_fsync,
756 757
};

758
const struct file_operations v9fs_cached_file_operations_dotl = {
759
	.llseek = generic_file_llseek,
760 761
	.read = v9fs_cached_file_read,
	.write = v9fs_cached_file_write,
762
	.aio_read = generic_file_aio_read,
763
	.aio_write = generic_file_aio_write,
764 765
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
M. Mohan Kumar's avatar
M. Mohan Kumar committed
766 767
	.lock = v9fs_file_lock_dotl,
	.flock = v9fs_file_flock_dotl,
768
	.mmap = v9fs_file_mmap,
769
	.fsync = v9fs_file_fsync_dotl,
770 771
};

772
const struct file_operations v9fs_file_operations = {
773 774 775 776 777 778
	.llseek = generic_file_llseek,
	.read = v9fs_file_read,
	.write = v9fs_file_write,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
	.lock = v9fs_file_lock,
779
	.mmap = generic_file_readonly_mmap,
780
	.fsync = v9fs_file_fsync,
781
};
782 783 784 785 786 787 788

const struct file_operations v9fs_file_operations_dotl = {
	.llseek = generic_file_llseek,
	.read = v9fs_file_read,
	.write = v9fs_file_write,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
M. Mohan Kumar's avatar
M. Mohan Kumar committed
789 790
	.lock = v9fs_file_lock_dotl,
	.flock = v9fs_file_flock_dotl,
791
	.mmap = generic_file_readonly_mmap,
792
	.fsync = v9fs_file_fsync_dotl,
793
};