blob: 0c672588fe5a71217ac83df8e1a11701934c5f9c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/proc.c
3 *
4 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
5 *
6 * OS-independent nfs remote procedure call functions
7 *
8 * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
9 * so at last we can have decent(ish) throughput off a
10 * Sun server.
11 *
12 * Coding optimized and cleaned up by Florian La Roche.
13 * Note: Error returns are optimized for NFS_OK, which isn't translated via
14 * nfs_stat_to_errno(), but happens to be already the right return code.
15 *
16 * Also, the code currently doesn't check the size of the packet, when
17 * it decodes the packet.
18 *
19 * Feel free to fix it and mail me the diffs if it worries you.
20 *
21 * Completely rewritten to support the new RPC call interface;
22 * rewrote and moved the entire XDR stuff to xdr.c
23 * --Olaf Kirch June 1996
24 *
25 * The code below initializes all auto variables explicitly, otherwise
26 * it will fail to work as a module (gcc generates a memset call for an
27 * incomplete struct).
28 */
29
30#include <linux/types.h>
31#include <linux/param.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/time.h>
33#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/errno.h>
35#include <linux/string.h>
36#include <linux/in.h>
37#include <linux/pagemap.h>
38#include <linux/sunrpc/clnt.h>
39#include <linux/nfs.h>
40#include <linux/nfs2.h>
41#include <linux/nfs_fs.h>
42#include <linux/nfs_page.h>
43#include <linux/lockd/bind.h>
Jeff Laytond3103102011-12-01 22:44:39 +010044#include <linux/freezer.h>
David Howellsf7b422b2006-06-09 09:34:33 -040045#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#define NFSDBG_FACILITY NFSDBG_PROC
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/*
Jeff Layton97cefcc2010-01-08 12:17:21 -050050 * wrapper to handle the -EKEYEXPIRED error message. This should generally
51 * only happen if using krb5 auth and a user's TGT expires. NFSv2 doesn't
52 * support the NFSERR_JUKEBOX error code, but we handle this situation in the
53 * same way that we handle that error with NFSv3.
54 */
55static int
56nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
57{
58 int res;
59 do {
60 res = rpc_call_sync(clnt, msg, flags);
61 if (res != -EKEYEXPIRED)
62 break;
Jeff Laytond3103102011-12-01 22:44:39 +010063 freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
Jeff Layton97cefcc2010-01-08 12:17:21 -050064 res = -ERESTARTSYS;
65 } while (!fatal_signal_pending(current));
66 return res;
67}
68
69#define rpc_call_sync(clnt, msg, flags) nfs_rpc_wrapper(clnt, msg, flags)
70
71static int
72nfs_async_handle_expired_key(struct rpc_task *task)
73{
74 if (task->tk_status != -EKEYEXPIRED)
75 return 0;
76 task->tk_status = 0;
77 rpc_restart_call(task);
78 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
79 return 1;
80}
81
82/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 * Bare-bones access to getattr: this is for nfs_read_super.
84 */
85static int
86nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
87 struct nfs_fsinfo *info)
88{
89 struct nfs_fattr *fattr = info->fattr;
90 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -050091 struct rpc_message msg = {
92 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
93 .rpc_argp = fhandle,
94 .rpc_resp = fattr,
95 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 int status;
97
Harvey Harrison3110ff82008-05-02 13:42:44 -070098 dprintk("%s: call getattr\n", __func__);
Trond Myklebust0e574af2005-10-27 22:12:38 -040099 nfs_fattr_init(fattr);
EG Keizer37ca8f52008-08-19 16:34:36 -0400100 status = rpc_call_sync(server->client, &msg, 0);
101 /* Retry with default authentication if different */
102 if (status && server->nfs_client->cl_rpcclient != server->client)
103 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
Harvey Harrison3110ff82008-05-02 13:42:44 -0700104 dprintk("%s: reply getattr: %d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 if (status)
106 return status;
Harvey Harrison3110ff82008-05-02 13:42:44 -0700107 dprintk("%s: call statfs\n", __func__);
Chuck Leverdead28d2006-03-20 13:44:23 -0500108 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
109 msg.rpc_resp = &fsinfo;
EG Keizer37ca8f52008-08-19 16:34:36 -0400110 status = rpc_call_sync(server->client, &msg, 0);
111 /* Retry with default authentication if different */
112 if (status && server->nfs_client->cl_rpcclient != server->client)
113 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
Harvey Harrison3110ff82008-05-02 13:42:44 -0700114 dprintk("%s: reply statfs: %d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (status)
116 return status;
117 info->rtmax = NFS_MAXDATA;
118 info->rtpref = fsinfo.tsize;
119 info->rtmult = fsinfo.bsize;
120 info->wtmax = NFS_MAXDATA;
121 info->wtpref = fsinfo.tsize;
122 info->wtmult = fsinfo.bsize;
123 info->dtpref = fsinfo.tsize;
124 info->maxfilesize = 0x7FFFFFFF;
125 info->lease_time = 0;
126 return 0;
127}
128
129/*
130 * One function for each procedure in the NFS protocol.
131 */
132static int
133nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
134 struct nfs_fattr *fattr)
135{
Chuck Leverdead28d2006-03-20 13:44:23 -0500136 struct rpc_message msg = {
137 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
138 .rpc_argp = fhandle,
139 .rpc_resp = fattr,
140 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 int status;
142
143 dprintk("NFS call getattr\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400144 nfs_fattr_init(fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500145 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 dprintk("NFS reply getattr: %d\n", status);
147 return status;
148}
149
150static int
151nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
152 struct iattr *sattr)
153{
154 struct inode *inode = dentry->d_inode;
155 struct nfs_sattrargs arg = {
156 .fh = NFS_FH(inode),
157 .sattr = sattr
158 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500159 struct rpc_message msg = {
160 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR],
161 .rpc_argp = &arg,
162 .rpc_resp = fattr,
163 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 int status;
165
Trond Myklebustcf3fff52006-01-03 09:55:53 +0100166 /* Mask out the non-modebit related stuff from attr->ia_mode */
167 sattr->ia_mode &= S_IALLUGO;
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 dprintk("NFS call setattr\n");
Trond Myklebust659bfcd2008-06-10 19:39:41 -0400170 if (sattr->ia_valid & ATTR_FILE)
171 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
Trond Myklebust0e574af2005-10-27 22:12:38 -0400172 nfs_fattr_init(fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500173 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Trond Myklebust65e43082005-08-16 11:49:44 -0400174 if (status == 0)
175 nfs_setattr_update_inode(inode, sattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 dprintk("NFS reply setattr: %d\n", status);
177 return status;
178}
179
180static int
Bryan Schumaker7c513052011-03-24 17:12:24 +0000181nfs_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
183{
184 struct nfs_diropargs arg = {
185 .fh = NFS_FH(dir),
186 .name = name->name,
187 .len = name->len
188 };
189 struct nfs_diropok res = {
190 .fh = fhandle,
191 .fattr = fattr
192 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500193 struct rpc_message msg = {
194 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
195 .rpc_argp = &arg,
196 .rpc_resp = &res,
197 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 int status;
199
200 dprintk("NFS call lookup %s\n", name->name);
Trond Myklebust0e574af2005-10-27 22:12:38 -0400201 nfs_fattr_init(fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500202 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 dprintk("NFS reply lookup: %d\n", status);
204 return status;
205}
206
207static int nfs_proc_readlink(struct inode *inode, struct page *page,
208 unsigned int pgbase, unsigned int pglen)
209{
210 struct nfs_readlinkargs args = {
211 .fh = NFS_FH(inode),
212 .pgbase = pgbase,
213 .pglen = pglen,
214 .pages = &page
215 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500216 struct rpc_message msg = {
217 .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
218 .rpc_argp = &args,
219 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 int status;
221
222 dprintk("NFS call readlink\n");
Chuck Leverdead28d2006-03-20 13:44:23 -0500223 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 dprintk("NFS reply readlink: %d\n", status);
225 return status;
226}
227
Trond Myklebusteb872f02010-04-16 16:22:51 -0400228struct nfs_createdata {
229 struct nfs_createargs arg;
230 struct nfs_diropok res;
231 struct nfs_fh fhandle;
232 struct nfs_fattr fattr;
233};
234
235static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
236 struct dentry *dentry, struct iattr *sattr)
237{
238 struct nfs_createdata *data;
239
240 data = kmalloc(sizeof(*data), GFP_KERNEL);
241
242 if (data != NULL) {
243 data->arg.fh = NFS_FH(dir);
244 data->arg.name = dentry->d_name.name;
245 data->arg.len = dentry->d_name.len;
246 data->arg.sattr = sattr;
247 nfs_fattr_init(&data->fattr);
248 data->fhandle.size = 0;
249 data->res.fh = &data->fhandle;
250 data->res.fattr = &data->fattr;
251 }
252 return data;
253};
254
255static void nfs_free_createdata(const struct nfs_createdata *data)
256{
257 kfree(data);
258}
259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260static int
261nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
Trond Myklebustc0204fd2010-09-17 10:56:51 -0400262 int flags, struct nfs_open_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400264 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500265 struct rpc_message msg = {
266 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
Chuck Leverdead28d2006-03-20 13:44:23 -0500267 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400268 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 dprintk("NFS call create %s\n", dentry->d_name.name);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400271 data = nfs_alloc_createdata(dir, dentry, sattr);
272 if (data == NULL)
273 goto out;
274 msg.rpc_argp = &data->arg;
275 msg.rpc_resp = &data->res;
Chuck Leverdead28d2006-03-20 13:44:23 -0500276 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustbad2a522007-10-20 13:07:21 -0400277 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 if (status == 0)
Trond Myklebusteb872f02010-04-16 16:22:51 -0400279 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
280 nfs_free_createdata(data);
281out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 dprintk("NFS reply create: %d\n", status);
283 return status;
284}
285
286/*
287 * In NFSv2, mknod is grafted onto the create call.
288 */
289static int
290nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
291 dev_t rdev)
292{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400293 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500294 struct rpc_message msg = {
295 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
Chuck Leverdead28d2006-03-20 13:44:23 -0500296 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400297 umode_t mode;
298 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 dprintk("NFS call mknod %s\n", dentry->d_name.name);
301
302 mode = sattr->ia_mode;
303 if (S_ISFIFO(mode)) {
304 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
305 sattr->ia_valid &= ~ATTR_SIZE;
306 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
307 sattr->ia_valid |= ATTR_SIZE;
308 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
309 }
310
Trond Myklebusteb872f02010-04-16 16:22:51 -0400311 data = nfs_alloc_createdata(dir, dentry, sattr);
312 if (data == NULL)
313 goto out;
314 msg.rpc_argp = &data->arg;
315 msg.rpc_resp = &data->res;
316
Chuck Leverdead28d2006-03-20 13:44:23 -0500317 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400318 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 if (status == -EINVAL && S_ISFIFO(mode)) {
321 sattr->ia_mode = mode;
Trond Myklebusteb872f02010-04-16 16:22:51 -0400322 nfs_fattr_init(data->res.fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500323 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
325 if (status == 0)
Trond Myklebusteb872f02010-04-16 16:22:51 -0400326 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
327 nfs_free_createdata(data);
328out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 dprintk("NFS reply mknod: %d\n", status);
330 return status;
331}
332
333static int
334nfs_proc_remove(struct inode *dir, struct qstr *name)
335{
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400336 struct nfs_removeargs arg = {
337 .fh = NFS_FH(dir),
338 .name.len = name->len,
339 .name.name = name->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 };
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400341 struct rpc_message msg = {
342 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
343 .rpc_argp = &arg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 };
345 int status;
346
347 dprintk("NFS call remove %s\n", name->name);
348 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400349 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
351 dprintk("NFS reply remove: %d\n", status);
352 return status;
353}
354
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400355static void
356nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400361static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Jeff Layton97cefcc2010-01-08 12:17:21 -0500363 if (nfs_async_handle_expired_key(task))
364 return 0;
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400365 nfs_mark_for_revalidate(dir);
366 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
Jeff Laytond3d41522010-09-17 17:31:57 -0400369static void
370nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
371{
372 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
373}
374
375static int
376nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
377 struct inode *new_dir)
378{
379 if (nfs_async_handle_expired_key(task))
380 return 0;
381 nfs_mark_for_revalidate(old_dir);
382 nfs_mark_for_revalidate(new_dir);
383 return 1;
384}
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386static int
387nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
388 struct inode *new_dir, struct qstr *new_name)
389{
390 struct nfs_renameargs arg = {
Jeff Layton920769f2010-09-17 17:30:25 -0400391 .old_dir = NFS_FH(old_dir),
392 .old_name = old_name,
393 .new_dir = NFS_FH(new_dir),
394 .new_name = new_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500396 struct rpc_message msg = {
397 .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
398 .rpc_argp = &arg,
399 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 int status;
401
402 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500403 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400404 nfs_mark_for_revalidate(old_dir);
405 nfs_mark_for_revalidate(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 dprintk("NFS reply rename: %d\n", status);
407 return status;
408}
409
410static int
411nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
412{
413 struct nfs_linkargs arg = {
414 .fromfh = NFS_FH(inode),
415 .tofh = NFS_FH(dir),
416 .toname = name->name,
417 .tolen = name->len
418 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500419 struct rpc_message msg = {
420 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
421 .rpc_argp = &arg,
422 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 int status;
424
425 dprintk("NFS call link %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500426 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Trond Myklebust5ba7cc42005-12-03 15:20:17 -0500427 nfs_mark_for_revalidate(inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400428 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 dprintk("NFS reply link: %d\n", status);
430 return status;
431}
432
433static int
Chuck Lever94a6d752006-08-22 20:06:23 -0400434nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
435 unsigned int len, struct iattr *sattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
Trond Myklebust23a30612010-04-16 16:22:51 -0400437 struct nfs_fh *fh;
438 struct nfs_fattr *fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 struct nfs_symlinkargs arg = {
440 .fromfh = NFS_FH(dir),
Chuck Lever4f390c12006-08-22 20:06:22 -0400441 .fromname = dentry->d_name.name,
442 .fromlen = dentry->d_name.len,
Chuck Lever94a6d752006-08-22 20:06:23 -0400443 .pages = &page,
444 .pathlen = len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 .sattr = sattr
446 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500447 struct rpc_message msg = {
448 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
449 .rpc_argp = &arg,
450 };
Trond Myklebust23a30612010-04-16 16:22:51 -0400451 int status = -ENAMETOOLONG;
Chuck Lever4f390c12006-08-22 20:06:22 -0400452
Chuck Lever94a6d752006-08-22 20:06:23 -0400453 dprintk("NFS call symlink %s\n", dentry->d_name.name);
454
Trond Myklebust23a30612010-04-16 16:22:51 -0400455 if (len > NFS2_MAXPATHLEN)
456 goto out;
457
458 fh = nfs_alloc_fhandle();
459 fattr = nfs_alloc_fattr();
460 status = -ENOMEM;
461 if (fh == NULL || fattr == NULL)
Jesper Juhl878215f2010-12-24 22:22:37 +0000462 goto out_free;
Trond Myklebust23a30612010-04-16 16:22:51 -0400463
Chuck Leverdead28d2006-03-20 13:44:23 -0500464 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400465 nfs_mark_for_revalidate(dir);
Chuck Lever4f390c12006-08-22 20:06:22 -0400466
467 /*
468 * V2 SYMLINK requests don't return any attributes. Setting the
469 * filehandle size to zero indicates to nfs_instantiate that it
470 * should fill in the data with a LOOKUP call on the wire.
471 */
Trond Myklebust23a30612010-04-16 16:22:51 -0400472 if (status == 0)
473 status = nfs_instantiate(dentry, fh, fattr);
Chuck Lever4f390c12006-08-22 20:06:22 -0400474
Jesper Juhl878215f2010-12-24 22:22:37 +0000475out_free:
Trond Myklebust23a30612010-04-16 16:22:51 -0400476 nfs_free_fattr(fattr);
477 nfs_free_fhandle(fh);
478out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 dprintk("NFS reply symlink: %d\n", status);
480 return status;
481}
482
483static int
484nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
485{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400486 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500487 struct rpc_message msg = {
488 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
Chuck Leverdead28d2006-03-20 13:44:23 -0500489 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400490 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
492 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400493 data = nfs_alloc_createdata(dir, dentry, sattr);
494 if (data == NULL)
495 goto out;
496 msg.rpc_argp = &data->arg;
497 msg.rpc_resp = &data->res;
498
Chuck Leverdead28d2006-03-20 13:44:23 -0500499 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400500 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (status == 0)
Trond Myklebusteb872f02010-04-16 16:22:51 -0400502 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
503 nfs_free_createdata(data);
504out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 dprintk("NFS reply mkdir: %d\n", status);
506 return status;
507}
508
509static int
510nfs_proc_rmdir(struct inode *dir, struct qstr *name)
511{
512 struct nfs_diropargs arg = {
513 .fh = NFS_FH(dir),
514 .name = name->name,
515 .len = name->len
516 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500517 struct rpc_message msg = {
518 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
519 .rpc_argp = &arg,
520 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 int status;
522
523 dprintk("NFS call rmdir %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500524 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400525 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 dprintk("NFS reply rmdir: %d\n", status);
527 return status;
528}
529
530/*
531 * The READDIR implementation is somewhat hackish - we pass a temporary
532 * buffer to the encode function, which installs it in the receive
533 * the receive iovec. The decode function just parses the reply to make
534 * sure it is syntactically correct; the entries itself are decoded
535 * from nfs_readdir by calling the decode_entry function directly.
536 */
537static int
538nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400539 u64 cookie, struct page **pages, unsigned int count, int plus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 struct inode *dir = dentry->d_inode;
542 struct nfs_readdirargs arg = {
543 .fh = NFS_FH(dir),
544 .cookie = cookie,
545 .count = count,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400546 .pages = pages,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 };
548 struct rpc_message msg = {
549 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
550 .rpc_argp = &arg,
Chuck Leverdead28d2006-03-20 13:44:23 -0500551 .rpc_cred = cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 };
553 int status;
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 dprintk("NFS call readdir %d\n", (unsigned int)cookie);
556 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
557
Trond Myklebustc4812992007-09-28 17:11:45 -0400558 nfs_invalidate_atime(dir);
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 dprintk("NFS reply readdir: %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 return status;
562}
563
564static int
565nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
566 struct nfs_fsstat *stat)
567{
568 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500569 struct rpc_message msg = {
570 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
571 .rpc_argp = fhandle,
572 .rpc_resp = &fsinfo,
573 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 int status;
575
576 dprintk("NFS call statfs\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400577 nfs_fattr_init(stat->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500578 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 dprintk("NFS reply statfs: %d\n", status);
580 if (status)
581 goto out;
582 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
583 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
584 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
585 stat->tfiles = 0;
586 stat->ffiles = 0;
587 stat->afiles = 0;
588out:
589 return status;
590}
591
592static int
593nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
594 struct nfs_fsinfo *info)
595{
596 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500597 struct rpc_message msg = {
598 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
599 .rpc_argp = fhandle,
600 .rpc_resp = &fsinfo,
601 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 int status;
603
604 dprintk("NFS call fsinfo\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400605 nfs_fattr_init(info->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500606 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 dprintk("NFS reply fsinfo: %d\n", status);
608 if (status)
609 goto out;
610 info->rtmax = NFS_MAXDATA;
611 info->rtpref = fsinfo.tsize;
612 info->rtmult = fsinfo.bsize;
613 info->wtmax = NFS_MAXDATA;
614 info->wtpref = fsinfo.tsize;
615 info->wtmult = fsinfo.bsize;
616 info->dtpref = fsinfo.tsize;
617 info->maxfilesize = 0x7FFFFFFF;
618 info->lease_time = 0;
619out:
620 return status;
621}
622
623static int
624nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
625 struct nfs_pathconf *info)
626{
627 info->max_link = 0;
628 info->max_namelen = NFS2_MAXNAMLEN;
629 return 0;
630}
631
Trond Myklebustec06c092006-03-20 13:44:27 -0500632static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Jeff Layton97cefcc2010-01-08 12:17:21 -0500634 if (nfs_async_handle_expired_key(task))
635 return -EAGAIN;
636
Trond Myklebust8850df92007-09-28 17:20:07 -0400637 nfs_invalidate_atime(data->inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 if (task->tk_status >= 0) {
639 nfs_refresh_inode(data->inode, data->res.fattr);
640 /* Emulate the eof flag, which isn't normally needed in NFSv2
641 * as it is guaranteed to always return the file attributes
642 */
643 if (data->args.offset + data->args.count >= data->res.fattr->size)
644 data->res.eof = 1;
645 }
Trond Myklebustec06c092006-03-20 13:44:27 -0500646 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647}
648
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400649static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650{
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400651 msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
Trond Myklebust788e7a82006-03-20 13:44:27 -0500654static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Jeff Layton97cefcc2010-01-08 12:17:21 -0500656 if (nfs_async_handle_expired_key(task))
657 return -EAGAIN;
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 if (task->tk_status >= 0)
Trond Myklebust70ca8852007-09-30 15:21:24 -0400660 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -0500661 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400664static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
667 data->args.stable = NFS_FILE_SYNC;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400668 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669}
670
671static void
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400672nfs_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674 BUG();
675}
676
677static int
678nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
679{
Chuck Lever1093a602008-01-11 17:09:59 -0500680 struct inode *inode = filp->f_path.dentry->d_inode;
681
682 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
Trond Myklebust21162712008-05-20 19:34:39 -0400685/* Helper functions for NFS lock bounds checking */
686#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
687static int nfs_lock_check_bounds(const struct file_lock *fl)
688{
689 __s32 start, end;
690
691 start = (__s32)fl->fl_start;
692 if ((loff_t)start != fl->fl_start)
693 goto out_einval;
694
695 if (fl->fl_end != OFFSET_MAX) {
696 end = (__s32)fl->fl_end;
697 if ((loff_t)end != fl->fl_end)
698 goto out_einval;
699 } else
700 end = NFS_LOCK32_OFFSET_MAX;
701
702 if (start < 0 || start > end)
703 goto out_einval;
704 return 0;
705out_einval:
706 return -EINVAL;
707}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
David Howells509de812006-08-22 20:06:11 -0400709const struct nfs_rpc_ops nfs_v2_clientops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 .version = 2, /* protocol version */
711 .dentry_ops = &nfs_dentry_operations,
712 .dir_inode_ops = &nfs_dir_inode_operations,
J. Bruce Fields92cfc622005-06-22 17:16:22 +0000713 .file_inode_ops = &nfs_file_inode_operations,
Jeff Layton1788ea62011-11-04 13:31:21 -0400714 .file_ops = &nfs_file_operations,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 .getroot = nfs_proc_get_root,
716 .getattr = nfs_proc_getattr,
717 .setattr = nfs_proc_setattr,
718 .lookup = nfs_proc_lookup,
719 .access = NULL, /* access */
720 .readlink = nfs_proc_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 .create = nfs_proc_create,
722 .remove = nfs_proc_remove,
723 .unlink_setup = nfs_proc_unlink_setup,
724 .unlink_done = nfs_proc_unlink_done,
725 .rename = nfs_proc_rename,
Jeff Laytond3d41522010-09-17 17:31:57 -0400726 .rename_setup = nfs_proc_rename_setup,
727 .rename_done = nfs_proc_rename_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 .link = nfs_proc_link,
729 .symlink = nfs_proc_symlink,
730 .mkdir = nfs_proc_mkdir,
731 .rmdir = nfs_proc_rmdir,
732 .readdir = nfs_proc_readdir,
733 .mknod = nfs_proc_mknod,
734 .statfs = nfs_proc_statfs,
735 .fsinfo = nfs_proc_fsinfo,
736 .pathconf = nfs_proc_pathconf,
Chuck Leverf796f8b2010-12-14 14:55:10 +0000737 .decode_dirent = nfs2_decode_dirent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 .read_setup = nfs_proc_read_setup,
Trond Myklebustec06c092006-03-20 13:44:27 -0500739 .read_done = nfs_read_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 .write_setup = nfs_proc_write_setup,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500741 .write_done = nfs_write_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 .commit_setup = nfs_proc_commit_setup,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 .lock = nfs_proc_lock,
Trond Myklebust21162712008-05-20 19:34:39 -0400744 .lock_check_bounds = nfs_lock_check_bounds,
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400745 .close_context = nfs_close_context,
Andy Adamson45a52a02011-03-01 01:34:08 +0000746 .init_client = nfs_init_client,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747};