vfs_file.c 12.8 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
49
50
51
52
53
54
55

/**
 * 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)
{
56
	int err;
57
58
59
	struct v9fs_session_info *v9ses;
	struct p9_fid *fid;
	int omode;
60

M. Mohan Kumar's avatar
M. Mohan Kumar committed
61
	P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
62
	v9ses = v9fs_inode2v9ses(inode);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
63
64
65
66
67
	if (v9fs_proto_dotl(v9ses))
		omode = file->f_flags;
	else
		omode = v9fs_uflags2omode(file->f_flags,
					v9fs_proto_dotu(v9ses));
68
69
70
71
72
73
74
	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);
75
		if (err < 0) {
76
77
78
			p9_client_clunk(fid);
			return err;
		}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
79
		if (file->f_flags & O_TRUNC) {
80
			i_size_write(inode, 0);
81
82
			inode->i_blocks = 0;
		}
M. Mohan Kumar's avatar
M. Mohan Kumar committed
83
84
		if ((file->f_flags & O_APPEND) &&
			(!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
85
			generic_file_llseek(file, 0, SEEK_END);
86
	}
87

88
	file->private_data = fid;
89
#ifdef CONFIG_9P_FSCACHE
90
	if (v9ses->cache)
91
		v9fs_cache_inode_set_cookie(inode, file);
92
#endif
93
	return 0;
94
95
96
97
}

/**
 * v9fs_file_lock - lock a file (or directory)
98
99
100
 * @filp: file to be locked
 * @cmd: lock command
 * @fl: file lock structure
101
 *
102
 * Bugs: this looks like a local only lock, we should extend into 9P
103
104
105
106
107
108
 *       by using open exclusive
 */

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

111
	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
112
113

	/* No mandatory locks */
114
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
115
116
117
		return -ENOLCK;

	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
118
		filemap_write_and_wait(inode->i_mapping);
119
		invalidate_mapping_pages(&inode->i_data, 0, -1);
120
121
122
123
124
	}

	return res;
}

M. Mohan Kumar's avatar
M. Mohan Kumar committed
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
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));
	flock.type = fl->fl_type;
	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;
		schedule_timeout_interruptible(P9_LOCK_TIMEOUT);
	}

	/* 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
202
203
204
205
206
207
208
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
241
242
243
244
245
246
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));
	glock.type = fl->fl_type;
	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;
	if (glock.type != F_UNLCK) {
		fl->fl_type = glock.type;
		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;
	} else
		fl->fl_type = F_UNLCK;

	return res;
}

M. Mohan Kumar's avatar
M. Mohan Kumar committed
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
/**
 * 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;

	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
				cmd, fl, filp->f_path.dentry->d_name.name);

	/* 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
274
275
	else if (IS_GETLK(cmd))
		ret = v9fs_file_getlock(filp, fl);
M. Mohan Kumar's avatar
M. Mohan Kumar committed
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
	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;

	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
				cmd, fl, filp->f_path.dentry->d_name.name);

	/* 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;
}

325
/**
326
327
 * v9fs_fid_readn - read from a fid
 * @fid: fid to read
328
 * @data: data buffer to read data into
329
 * @udata: user data buffer to read data into
330
331
332
333
 * @count: size of buffer
 * @offset: offset at which to read data
 *
 */
334
ssize_t
335
v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
336
337
	       u64 offset)
{
338
	int n, total, size;
339

340
	P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid,
341
		   (long long unsigned) offset, count);
342
343
	n = 0;
	total = 0;
344
	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
345
346
347
348
349
350
351
352
353
354
355
356
357
	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;
358
	} while (count > 0 && n == size);
359
360
361
362
363
364
365

	if (n < 0)
		total = n;

	return total;
}

366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
/**
 * 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);
}

382
383
384
385
386
387
388
389
390
/**
 * 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
 *
 */

391
static ssize_t
392
v9fs_file_read(struct file *filp, char __user *udata, size_t count,
393
	       loff_t * offset)
394
{
395
396
	int ret;
	struct p9_fid *fid;
397
	size_t size;
398

Eric Van Hensbergen's avatar
Eric Van Hensbergen committed
399
	P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset);
400
	fid = filp->private_data;
401

402
403
	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
	if (count > size)
404
405
406
407
		ret = v9fs_file_readn(filp, NULL, udata, count, *offset);
	else
		ret = p9_client_read(fid, NULL, udata, *offset, count);

408
409
	if (ret > 0)
		*offset += ret;
410

411
	return ret;
412
413
}

414
415
416
417
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)
418
{
419
	int n;
420
	size_t total = 0;
421
	struct p9_client *clnt;
422
	loff_t origin = *offset;
423
	unsigned long pg_start, pg_end;
424

425
426
	P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
		(int)count, (int)*offset);
427

428
429
	clnt = fid->clnt;
	do {
430
		n = p9_client_write(fid, NULL, data+total, origin+total, count);
431
432
433
434
435
436
		if (n <= 0)
			break;
		count -= n;
		total += n;
	} while (count > 0);

437
	if (invalidate && (total > 0)) {
438
439
		pg_start = origin >> PAGE_CACHE_SHIFT;
		pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
440
441
442
		if (inode->i_mapping && inode->i_mapping->nrpages)
			invalidate_inode_pages2_range(inode->i_mapping,
						      pg_start, pg_end);
443
		*offset += total;
444
		i_size_write(inode, i_size_read(inode) + total);
445
		inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
446
	}
447
	if (n < 0)
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
		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;

	return v9fs_file_write_internal(filp->f_path.dentry->d_inode,
					filp->private_data,
					data, count, offset, 1);
483
484
out:
	return retval;
485
486
}

487
static int v9fs_file_fsync(struct file *filp, int datasync)
488
489
490
491
492
{
	struct p9_fid *fid;
	struct p9_wstat wstat;
	int retval;

493
	P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
494
495
496
497
498
499
500
501

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

	retval = p9_client_wstat(fid, &wstat);
	return retval;
}

502
int v9fs_file_fsync_dotl(struct file *filp, int datasync)
503
504
505
506
507
508
509
510
511
{
	struct p9_fid *fid;
	int retval;

	P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n",
			filp, datasync);

	fid = filp->private_data;

512
	retval = p9_client_fsync(fid, datasync);
513
514
515
	return retval;
}

516
const struct file_operations v9fs_cached_file_operations = {
517
518
519
520
521
522
523
	.llseek = generic_file_llseek,
	.read = do_sync_read,
	.aio_read = generic_file_aio_read,
	.write = v9fs_file_write,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
	.lock = v9fs_file_lock,
524
	.mmap = generic_file_readonly_mmap,
525
	.fsync = v9fs_file_fsync,
526
527
};

528
const struct file_operations v9fs_cached_file_operations_dotl = {
529
530
531
532
533
534
	.llseek = generic_file_llseek,
	.read = do_sync_read,
	.aio_read = generic_file_aio_read,
	.write = v9fs_file_write,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
M. Mohan Kumar's avatar
M. Mohan Kumar committed
535
536
	.lock = v9fs_file_lock_dotl,
	.flock = v9fs_file_flock_dotl,
537
	.mmap = generic_file_readonly_mmap,
538
	.fsync = v9fs_file_fsync_dotl,
539
540
};

541
const struct file_operations v9fs_file_operations = {
542
543
544
545
546
547
	.llseek = generic_file_llseek,
	.read = v9fs_file_read,
	.write = v9fs_file_write,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
	.lock = v9fs_file_lock,
548
	.mmap = generic_file_readonly_mmap,
549
	.fsync = v9fs_file_fsync,
550
};
551
552
553
554
555
556
557

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
558
559
	.lock = v9fs_file_lock_dotl,
	.flock = v9fs_file_flock_dotl,
560
	.mmap = generic_file_readonly_mmap,
561
	.fsync = v9fs_file_fsync_dotl,
562
};