proc.c 20.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/*
 *  linux/fs/nfs/proc.c
 *
 *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
 *
 *  OS-independent nfs remote procedure call functions
 *
 *  Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
 *  so at last we can have decent(ish) throughput off a 
 *  Sun server.
 *
 *  Coding optimized and cleaned up by Florian La Roche.
 *  Note: Error returns are optimized for NFS_OK, which isn't translated via
 *  nfs_stat_to_errno(), but happens to be already the right return code.
 *
 *  Also, the code currently doesn't check the size of the packet, when
 *  it decodes the packet.
 *
 *  Feel free to fix it and mail me the diffs if it worries you.
 *
 *  Completely rewritten to support the new RPC call interface;
 *  rewrote and moved the entire XDR stuff to xdr.c
 *  --Olaf Kirch June 1996
 *
 *  The code below initializes all auto variables explicitly, otherwise
 *  it will fail to work as a module (gcc generates a memset call for an
 *  incomplete struct).
 */

#include <linux/types.h>
#include <linux/param.h>
#include <linux/time.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/in.h>
#include <linux/pagemap.h>
#include <linux/sunrpc/clnt.h>
#include <linux/nfs.h>
#include <linux/nfs2.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
#include <linux/lockd/bind.h>
44
#include <linux/freezer.h>
D
David Howells 已提交
45
#include "internal.h"
L
Linus Torvalds 已提交
46 47 48

#define NFSDBG_FACILITY		NFSDBG_PROC

49 50 51 52 53 54 55 56 57 58 59 60 61 62
/*
 * wrapper to handle the -EKEYEXPIRED error message. This should generally
 * only happen if using krb5 auth and a user's TGT expires. NFSv2 doesn't
 * support the NFSERR_JUKEBOX error code, but we handle this situation in the
 * same way that we handle that error with NFSv3.
 */
static int
nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
{
	int res;
	do {
		res = rpc_call_sync(clnt, msg, flags);
		if (res != -EKEYEXPIRED)
			break;
63
		freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
		res = -ERESTARTSYS;
	} while (!fatal_signal_pending(current));
	return res;
}

#define rpc_call_sync(clnt, msg, flags)	nfs_rpc_wrapper(clnt, msg, flags)

static int
nfs_async_handle_expired_key(struct rpc_task *task)
{
	if (task->tk_status != -EKEYEXPIRED)
		return 0;
	task->tk_status = 0;
	rpc_restart_call(task);
	rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
	return 1;
}

L
Linus Torvalds 已提交
82 83 84 85 86 87 88 89 90
/*
 * Bare-bones access to getattr: this is for nfs_read_super.
 */
static int
nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
		  struct nfs_fsinfo *info)
{
	struct nfs_fattr *fattr = info->fattr;
	struct nfs2_fsstat fsinfo;
C
Chuck Lever 已提交
91 92 93 94 95
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_GETATTR],
		.rpc_argp	= fhandle,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
96 97
	int status;

98
	dprintk("%s: call getattr\n", __func__);
99
	nfs_fattr_init(fattr);
E
EG Keizer 已提交
100 101 102 103
	status = rpc_call_sync(server->client, &msg, 0);
	/* Retry with default authentication if different */
	if (status && server->nfs_client->cl_rpcclient != server->client)
		status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
104
	dprintk("%s: reply getattr: %d\n", __func__, status);
L
Linus Torvalds 已提交
105 106
	if (status)
		return status;
107
	dprintk("%s: call statfs\n", __func__);
C
Chuck Lever 已提交
108 109
	msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
	msg.rpc_resp = &fsinfo;
E
EG Keizer 已提交
110 111 112 113
	status = rpc_call_sync(server->client, &msg, 0);
	/* Retry with default authentication if different */
	if (status && server->nfs_client->cl_rpcclient != server->client)
		status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
114
	dprintk("%s: reply statfs: %d\n", __func__, status);
L
Linus Torvalds 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	if (status)
		return status;
	info->rtmax  = NFS_MAXDATA;
	info->rtpref = fsinfo.tsize;
	info->rtmult = fsinfo.bsize;
	info->wtmax  = NFS_MAXDATA;
	info->wtpref = fsinfo.tsize;
	info->wtmult = fsinfo.bsize;
	info->dtpref = fsinfo.tsize;
	info->maxfilesize = 0x7FFFFFFF;
	info->lease_time = 0;
	return 0;
}

/*
 * One function for each procedure in the NFS protocol.
 */
static int
nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_fattr *fattr)
{
C
Chuck Lever 已提交
136 137 138 139 140
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_GETATTR],
		.rpc_argp	= fhandle,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
141 142 143
	int	status;

	dprintk("NFS call  getattr\n");
144
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
145
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153 154 155 156 157 158
	dprintk("NFS reply getattr: %d\n", status);
	return status;
}

static int
nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
		 struct iattr *sattr)
{
	struct inode *inode = dentry->d_inode;
	struct nfs_sattrargs	arg = { 
		.fh	= NFS_FH(inode),
		.sattr	= sattr
	};
C
Chuck Lever 已提交
159 160 161 162 163
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_SETATTR],
		.rpc_argp	= &arg,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
164 165
	int	status;

166 167 168
	/* Mask out the non-modebit related stuff from attr->ia_mode */
	sattr->ia_mode &= S_IALLUGO;

L
Linus Torvalds 已提交
169
	dprintk("NFS call  setattr\n");
170 171
	if (sattr->ia_valid & ATTR_FILE)
		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
172
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
173
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
174 175
	if (status == 0)
		nfs_setattr_update_inode(inode, sattr);
L
Linus Torvalds 已提交
176 177 178 179 180
	dprintk("NFS reply setattr: %d\n", status);
	return status;
}

static int
181
nfs_proc_lookup(struct inode *dir, struct qstr *name,
L
Linus Torvalds 已提交
182 183 184 185 186 187 188 189 190 191 192
		struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	struct nfs_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
	struct nfs_diropok	res = {
		.fh		= fhandle,
		.fattr		= fattr
	};
C
Chuck Lever 已提交
193 194 195 196 197
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_LOOKUP],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
L
Linus Torvalds 已提交
198 199 200
	int			status;

	dprintk("NFS call  lookup %s\n", name->name);
201
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
202
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
L
Linus Torvalds 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215
	dprintk("NFS reply lookup: %d\n", status);
	return status;
}

static int nfs_proc_readlink(struct inode *inode, struct page *page,
		unsigned int pgbase, unsigned int pglen)
{
	struct nfs_readlinkargs	args = {
		.fh		= NFS_FH(inode),
		.pgbase		= pgbase,
		.pglen		= pglen,
		.pages		= &page
	};
C
Chuck Lever 已提交
216 217 218 219
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_READLINK],
		.rpc_argp	= &args,
	};
L
Linus Torvalds 已提交
220 221 222
	int			status;

	dprintk("NFS call  readlink\n");
C
Chuck Lever 已提交
223
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
L
Linus Torvalds 已提交
224 225 226 227
	dprintk("NFS reply readlink: %d\n", status);
	return status;
}

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
struct nfs_createdata {
	struct nfs_createargs arg;
	struct nfs_diropok res;
	struct nfs_fh fhandle;
	struct nfs_fattr fattr;
};

static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
		struct dentry *dentry, struct iattr *sattr)
{
	struct nfs_createdata *data;

	data = kmalloc(sizeof(*data), GFP_KERNEL);

	if (data != NULL) {
		data->arg.fh = NFS_FH(dir);
		data->arg.name = dentry->d_name.name;
		data->arg.len = dentry->d_name.len;
		data->arg.sattr = sattr;
		nfs_fattr_init(&data->fattr);
		data->fhandle.size = 0;
		data->res.fh = &data->fhandle;
		data->res.fattr = &data->fattr;
	}
	return data;
};

static void nfs_free_createdata(const struct nfs_createdata *data)
{
	kfree(data);
}

L
Linus Torvalds 已提交
260 261
static int
nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
262
		int flags, struct nfs_open_context *ctx)
L
Linus Torvalds 已提交
263
{
264
	struct nfs_createdata *data;
C
Chuck Lever 已提交
265 266 267
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
	};
268
	int status = -ENOMEM;
L
Linus Torvalds 已提交
269 270

	dprintk("NFS call  create %s\n", dentry->d_name.name);
271 272 273 274 275
	data = nfs_alloc_createdata(dir, dentry, sattr);
	if (data == NULL)
		goto out;
	msg.rpc_argp = &data->arg;
	msg.rpc_resp = &data->res;
C
Chuck Lever 已提交
276
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
277
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
278
	if (status == 0)
279 280 281
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
	nfs_free_createdata(data);
out:
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289 290 291 292
	dprintk("NFS reply create: %d\n", status);
	return status;
}

/*
 * In NFSv2, mknod is grafted onto the create call.
 */
static int
nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
	       dev_t rdev)
{
293
	struct nfs_createdata *data;
C
Chuck Lever 已提交
294 295 296
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
	};
297 298
	umode_t mode;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
299 300 301 302 303 304 305 306 307 308 309 310

	dprintk("NFS call  mknod %s\n", dentry->d_name.name);

	mode = sattr->ia_mode;
	if (S_ISFIFO(mode)) {
		sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
		sattr->ia_valid &= ~ATTR_SIZE;
	} else if (S_ISCHR(mode) || S_ISBLK(mode)) {
		sattr->ia_valid |= ATTR_SIZE;
		sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
	}

311 312 313 314 315 316
	data = nfs_alloc_createdata(dir, dentry, sattr);
	if (data == NULL)
		goto out;
	msg.rpc_argp = &data->arg;
	msg.rpc_resp = &data->res;

C
Chuck Lever 已提交
317
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
318
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
319 320 321

	if (status == -EINVAL && S_ISFIFO(mode)) {
		sattr->ia_mode = mode;
322
		nfs_fattr_init(data->res.fattr);
C
Chuck Lever 已提交
323
		status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
L
Linus Torvalds 已提交
324 325
	}
	if (status == 0)
326 327 328
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
	nfs_free_createdata(data);
out:
L
Linus Torvalds 已提交
329 330 331 332 333 334 335
	dprintk("NFS reply mknod: %d\n", status);
	return status;
}
  
static int
nfs_proc_remove(struct inode *dir, struct qstr *name)
{
336 337
	struct nfs_removeargs arg = {
		.fh = NFS_FH(dir),
338
		.name = *name,
L
Linus Torvalds 已提交
339
	};
340 341 342
	struct rpc_message msg = { 
		.rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
		.rpc_argp = &arg,
L
Linus Torvalds 已提交
343 344 345 346 347
	};
	int			status;

	dprintk("NFS call  remove %s\n", name->name);
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
348
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
349 350 351 352 353

	dprintk("NFS reply remove: %d\n", status);
	return status;
}

354 355
static void
nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
L
Linus Torvalds 已提交
356 357 358 359
{
	msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
}

360 361 362 363 364
static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
{
	rpc_call_start(task);
}

365
static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
L
Linus Torvalds 已提交
366
{
367 368
	if (nfs_async_handle_expired_key(task))
		return 0;
369 370
	nfs_mark_for_revalidate(dir);
	return 1;
L
Linus Torvalds 已提交
371 372
}

373 374 375 376 377 378
static void
nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
{
	msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
}

379 380 381 382 383
static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
{
	rpc_call_start(task);
}

384 385 386 387 388 389 390 391 392 393 394
static int
nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
		     struct inode *new_dir)
{
	if (nfs_async_handle_expired_key(task))
		return 0;
	nfs_mark_for_revalidate(old_dir);
	nfs_mark_for_revalidate(new_dir);
	return 1;
}

L
Linus Torvalds 已提交
395 396 397 398 399
static int
nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
		struct inode *new_dir, struct qstr *new_name)
{
	struct nfs_renameargs	arg = {
400 401 402 403
		.old_dir	= NFS_FH(old_dir),
		.old_name	= old_name,
		.new_dir	= NFS_FH(new_dir),
		.new_name	= new_name,
L
Linus Torvalds 已提交
404
	};
C
Chuck Lever 已提交
405 406 407 408
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_RENAME],
		.rpc_argp	= &arg,
	};
L
Linus Torvalds 已提交
409 410 411
	int			status;

	dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
C
Chuck Lever 已提交
412
	status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
413 414
	nfs_mark_for_revalidate(old_dir);
	nfs_mark_for_revalidate(new_dir);
L
Linus Torvalds 已提交
415 416 417 418 419 420 421 422 423 424 425 426 427
	dprintk("NFS reply rename: %d\n", status);
	return status;
}

static int
nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
	struct nfs_linkargs	arg = {
		.fromfh		= NFS_FH(inode),
		.tofh		= NFS_FH(dir),
		.toname		= name->name,
		.tolen		= name->len
	};
C
Chuck Lever 已提交
428 429 430 431
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_LINK],
		.rpc_argp	= &arg,
	};
L
Linus Torvalds 已提交
432 433 434
	int			status;

	dprintk("NFS call  link %s\n", name->name);
C
Chuck Lever 已提交
435
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
436
	nfs_mark_for_revalidate(inode);
437
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
438 439 440 441 442
	dprintk("NFS reply link: %d\n", status);
	return status;
}

static int
443 444
nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
		 unsigned int len, struct iattr *sattr)
L
Linus Torvalds 已提交
445
{
446 447
	struct nfs_fh *fh;
	struct nfs_fattr *fattr;
L
Linus Torvalds 已提交
448 449
	struct nfs_symlinkargs	arg = {
		.fromfh		= NFS_FH(dir),
450 451
		.fromname	= dentry->d_name.name,
		.fromlen	= dentry->d_name.len,
452 453
		.pages		= &page,
		.pathlen	= len,
L
Linus Torvalds 已提交
454 455
		.sattr		= sattr
	};
C
Chuck Lever 已提交
456 457 458 459
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_SYMLINK],
		.rpc_argp	= &arg,
	};
460 461 462
	int status = -ENAMETOOLONG;

	dprintk("NFS call  symlink %s\n", dentry->d_name.name);
L
Linus Torvalds 已提交
463

464
	if (len > NFS2_MAXPATHLEN)
465
		goto out;
466

467 468 469 470
	fh = nfs_alloc_fhandle();
	fattr = nfs_alloc_fattr();
	status = -ENOMEM;
	if (fh == NULL || fattr == NULL)
471
		goto out_free;
472

C
Chuck Lever 已提交
473
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
474
	nfs_mark_for_revalidate(dir);
475 476 477 478 479 480

	/*
	 * V2 SYMLINK requests don't return any attributes.  Setting the
	 * filehandle size to zero indicates to nfs_instantiate that it
	 * should fill in the data with a LOOKUP call on the wire.
	 */
481 482
	if (status == 0)
		status = nfs_instantiate(dentry, fh, fattr);
483

484
out_free:
485 486 487
	nfs_free_fattr(fattr);
	nfs_free_fhandle(fh);
out:
L
Linus Torvalds 已提交
488 489 490 491 492 493 494
	dprintk("NFS reply symlink: %d\n", status);
	return status;
}

static int
nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
{
495
	struct nfs_createdata *data;
C
Chuck Lever 已提交
496 497 498
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_MKDIR],
	};
499
	int status = -ENOMEM;
L
Linus Torvalds 已提交
500 501

	dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
502 503 504 505 506 507
	data = nfs_alloc_createdata(dir, dentry, sattr);
	if (data == NULL)
		goto out;
	msg.rpc_argp = &data->arg;
	msg.rpc_resp = &data->res;

C
Chuck Lever 已提交
508
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
509
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
510
	if (status == 0)
511 512 513
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
	nfs_free_createdata(data);
out:
L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521 522 523 524 525
	dprintk("NFS reply mkdir: %d\n", status);
	return status;
}

static int
nfs_proc_rmdir(struct inode *dir, struct qstr *name)
{
	struct nfs_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
C
Chuck Lever 已提交
526 527 528 529
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_RMDIR],
		.rpc_argp	= &arg,
	};
L
Linus Torvalds 已提交
530 531 532
	int			status;

	dprintk("NFS call  rmdir %s\n", name->name);
C
Chuck Lever 已提交
533
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
534
	nfs_mark_for_revalidate(dir);
L
Linus Torvalds 已提交
535 536 537 538 539 540 541 542 543 544 545 546 547
	dprintk("NFS reply rmdir: %d\n", status);
	return status;
}

/*
 * The READDIR implementation is somewhat hackish - we pass a temporary
 * buffer to the encode function, which installs it in the receive
 * the receive iovec. The decode function just parses the reply to make
 * sure it is syntactically correct; the entries itself are decoded
 * from nfs_readdir by calling the decode_entry function directly.
 */
static int
nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
B
Bryan Schumaker 已提交
548
		 u64 cookie, struct page **pages, unsigned int count, int plus)
L
Linus Torvalds 已提交
549 550 551 552 553 554
{
	struct inode		*dir = dentry->d_inode;
	struct nfs_readdirargs	arg = {
		.fh		= NFS_FH(dir),
		.cookie		= cookie,
		.count		= count,
B
Bryan Schumaker 已提交
555
		.pages		= pages,
L
Linus Torvalds 已提交
556 557 558 559
	};
	struct rpc_message	msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_READDIR],
		.rpc_argp	= &arg,
C
Chuck Lever 已提交
560
		.rpc_cred	= cred,
L
Linus Torvalds 已提交
561 562 563 564 565 566
	};
	int			status;

	dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);

567 568
	nfs_invalidate_atime(dir);

L
Linus Torvalds 已提交
569 570 571 572 573 574 575 576 577
	dprintk("NFS reply readdir: %d\n", status);
	return status;
}

static int
nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
			struct nfs_fsstat *stat)
{
	struct nfs2_fsstat fsinfo;
C
Chuck Lever 已提交
578 579 580 581 582
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
		.rpc_argp	= fhandle,
		.rpc_resp	= &fsinfo,
	};
L
Linus Torvalds 已提交
583 584 585
	int	status;

	dprintk("NFS call  statfs\n");
586
	nfs_fattr_init(stat->fattr);
C
Chuck Lever 已提交
587
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
	dprintk("NFS reply statfs: %d\n", status);
	if (status)
		goto out;
	stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
	stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
	stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
	stat->tfiles = 0;
	stat->ffiles = 0;
	stat->afiles = 0;
out:
	return status;
}

static int
nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
			struct nfs_fsinfo *info)
{
	struct nfs2_fsstat fsinfo;
C
Chuck Lever 已提交
606 607 608 609 610
	struct rpc_message msg = {
		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
		.rpc_argp	= fhandle,
		.rpc_resp	= &fsinfo,
	};
L
Linus Torvalds 已提交
611 612 613
	int	status;

	dprintk("NFS call  fsinfo\n");
614
	nfs_fattr_init(info->fattr);
C
Chuck Lever 已提交
615
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
	dprintk("NFS reply fsinfo: %d\n", status);
	if (status)
		goto out;
	info->rtmax  = NFS_MAXDATA;
	info->rtpref = fsinfo.tsize;
	info->rtmult = fsinfo.bsize;
	info->wtmax  = NFS_MAXDATA;
	info->wtpref = fsinfo.tsize;
	info->wtmult = fsinfo.bsize;
	info->dtpref = fsinfo.tsize;
	info->maxfilesize = 0x7FFFFFFF;
	info->lease_time = 0;
out:
	return status;
}

static int
nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		  struct nfs_pathconf *info)
{
	info->max_link = 0;
	info->max_namelen = NFS2_MAXNAMLEN;
	return 0;
}

T
Trond Myklebust 已提交
641
static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
L
Linus Torvalds 已提交
642
{
643 644
	struct inode *inode = data->header->inode;

645 646 647
	if (nfs_async_handle_expired_key(task))
		return -EAGAIN;

648
	nfs_invalidate_atime(inode);
L
Linus Torvalds 已提交
649
	if (task->tk_status >= 0) {
650
		nfs_refresh_inode(inode, data->res.fattr);
L
Linus Torvalds 已提交
651 652 653
		/* Emulate the eof flag, which isn't normally needed in NFSv2
		 * as it is guaranteed to always return the file attributes
		 */
654
		if (data->args.offset + data->res.count >= data->res.fattr->size)
L
Linus Torvalds 已提交
655 656
			data->res.eof = 1;
	}
T
Trond Myklebust 已提交
657
	return 0;
L
Linus Torvalds 已提交
658 659
}

660
static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
661
{
662
	msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
L
Linus Torvalds 已提交
663 664
}

665 666 667 668 669
static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
{
	rpc_call_start(task);
}

670
static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
L
Linus Torvalds 已提交
671
{
672 673
	struct inode *inode = data->header->inode;

674 675 676
	if (nfs_async_handle_expired_key(task))
		return -EAGAIN;

L
Linus Torvalds 已提交
677
	if (task->tk_status >= 0)
678
		nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
679
	return 0;
L
Linus Torvalds 已提交
680 681
}

682
static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
683 684 685
{
	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
	data->args.stable = NFS_FILE_SYNC;
686
	msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
L
Linus Torvalds 已提交
687 688
}

689 690 691 692 693
static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
{
	rpc_call_start(task);
}

694 695 696 697 698
static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
{
	BUG();
}

L
Linus Torvalds 已提交
699
static void
700
nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
701 702 703 704 705 706 707
{
	BUG();
}

static int
nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
708 709 710
	struct inode *inode = filp->f_path.dentry->d_inode;

	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
L
Linus Torvalds 已提交
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
/* Helper functions for NFS lock bounds checking */
#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
static int nfs_lock_check_bounds(const struct file_lock *fl)
{
	__s32 start, end;

	start = (__s32)fl->fl_start;
	if ((loff_t)start != fl->fl_start)
		goto out_einval;

	if (fl->fl_end != OFFSET_MAX) {
		end = (__s32)fl->fl_end;
		if ((loff_t)end != fl->fl_end)
			goto out_einval;
	} else
		end = NFS_LOCK32_OFFSET_MAX;

	if (start < 0 || start > end)
		goto out_einval;
	return 0;
out_einval:
	return -EINVAL;
}
L
Linus Torvalds 已提交
736

737 738 739 740 741
static int nfs_have_delegation(struct inode *inode, fmode_t flags)
{
	return 0;
}

742 743 744 745 746 747
static int nfs_return_delegation(struct inode *inode)
{
	nfs_wb_all(inode);
	return 0;
}

D
David Howells 已提交
748
const struct nfs_rpc_ops nfs_v2_clientops = {
L
Linus Torvalds 已提交
749 750 751
	.version	= 2,		       /* protocol version */
	.dentry_ops	= &nfs_dentry_operations,
	.dir_inode_ops	= &nfs_dir_inode_operations,
752
	.file_inode_ops	= &nfs_file_inode_operations,
753
	.file_ops	= &nfs_file_operations,
L
Linus Torvalds 已提交
754
	.getroot	= nfs_proc_get_root,
B
Bryan Schumaker 已提交
755
	.submount	= nfs_submount,
L
Linus Torvalds 已提交
756 757 758 759 760 761 762 763
	.getattr	= nfs_proc_getattr,
	.setattr	= nfs_proc_setattr,
	.lookup		= nfs_proc_lookup,
	.access		= NULL,		       /* access */
	.readlink	= nfs_proc_readlink,
	.create		= nfs_proc_create,
	.remove		= nfs_proc_remove,
	.unlink_setup	= nfs_proc_unlink_setup,
764
	.unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
L
Linus Torvalds 已提交
765 766
	.unlink_done	= nfs_proc_unlink_done,
	.rename		= nfs_proc_rename,
767
	.rename_setup	= nfs_proc_rename_setup,
768
	.rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
769
	.rename_done	= nfs_proc_rename_done,
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778
	.link		= nfs_proc_link,
	.symlink	= nfs_proc_symlink,
	.mkdir		= nfs_proc_mkdir,
	.rmdir		= nfs_proc_rmdir,
	.readdir	= nfs_proc_readdir,
	.mknod		= nfs_proc_mknod,
	.statfs		= nfs_proc_statfs,
	.fsinfo		= nfs_proc_fsinfo,
	.pathconf	= nfs_proc_pathconf,
779
	.decode_dirent	= nfs2_decode_dirent,
L
Linus Torvalds 已提交
780
	.read_setup	= nfs_proc_read_setup,
781
	.read_rpc_prepare = nfs_proc_read_rpc_prepare,
T
Trond Myklebust 已提交
782
	.read_done	= nfs_read_done,
L
Linus Torvalds 已提交
783
	.write_setup	= nfs_proc_write_setup,
784
	.write_rpc_prepare = nfs_proc_write_rpc_prepare,
785
	.write_done	= nfs_write_done,
L
Linus Torvalds 已提交
786
	.commit_setup	= nfs_proc_commit_setup,
787
	.commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
L
Linus Torvalds 已提交
788
	.lock		= nfs_proc_lock,
789
	.lock_check_bounds = nfs_lock_check_bounds,
T
Trond Myklebust 已提交
790
	.close_context	= nfs_close_context,
791
	.have_delegation = nfs_have_delegation,
792
	.return_delegation = nfs_return_delegation,
793
	.alloc_client	= nfs_alloc_client,
794
	.init_client	= nfs_init_client,
795
	.free_client	= nfs_free_client,
L
Linus Torvalds 已提交
796
};