blob: a706b6bcc286a5a401318e868b0d1fbab2a206a4 [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 Schumaker80a16b22012-04-27 13:27:46 -0400181nfs_proc_lookup(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),
Linus Torvalds26fe5752012-05-10 13:14:12 -0700338 .name = *name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 };
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400340 struct rpc_message msg = {
341 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
342 .rpc_argp = &arg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 };
344 int status;
345
346 dprintk("NFS call remove %s\n", name->name);
347 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400348 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 dprintk("NFS reply remove: %d\n", status);
351 return status;
352}
353
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400354static void
355nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Bryan Schumaker34e137c2012-03-19 14:54:41 -0400360static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
361{
362 rpc_call_start(task);
363}
364
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400365static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Jeff Layton97cefcc2010-01-08 12:17:21 -0500367 if (nfs_async_handle_expired_key(task))
368 return 0;
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400369 nfs_mark_for_revalidate(dir);
370 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Jeff Laytond3d41522010-09-17 17:31:57 -0400373static void
374nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
375{
376 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
377}
378
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -0400379static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
380{
381 rpc_call_start(task);
382}
383
Jeff Laytond3d41522010-09-17 17:31:57 -0400384static int
385nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
386 struct inode *new_dir)
387{
388 if (nfs_async_handle_expired_key(task))
389 return 0;
390 nfs_mark_for_revalidate(old_dir);
391 nfs_mark_for_revalidate(new_dir);
392 return 1;
393}
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395static int
396nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
397 struct inode *new_dir, struct qstr *new_name)
398{
399 struct nfs_renameargs arg = {
Jeff Layton920769f2010-09-17 17:30:25 -0400400 .old_dir = NFS_FH(old_dir),
401 .old_name = old_name,
402 .new_dir = NFS_FH(new_dir),
403 .new_name = new_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500405 struct rpc_message msg = {
406 .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
407 .rpc_argp = &arg,
408 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 int status;
410
411 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500412 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400413 nfs_mark_for_revalidate(old_dir);
414 nfs_mark_for_revalidate(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 dprintk("NFS reply rename: %d\n", status);
416 return status;
417}
418
419static int
420nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
421{
422 struct nfs_linkargs arg = {
423 .fromfh = NFS_FH(inode),
424 .tofh = NFS_FH(dir),
425 .toname = name->name,
426 .tolen = name->len
427 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500428 struct rpc_message msg = {
429 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
430 .rpc_argp = &arg,
431 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 int status;
433
434 dprintk("NFS call link %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500435 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Trond Myklebust5ba7cc42005-12-03 15:20:17 -0500436 nfs_mark_for_revalidate(inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400437 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 dprintk("NFS reply link: %d\n", status);
439 return status;
440}
441
442static int
Chuck Lever94a6d752006-08-22 20:06:23 -0400443nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
444 unsigned int len, struct iattr *sattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
Trond Myklebust23a30612010-04-16 16:22:51 -0400446 struct nfs_fh *fh;
447 struct nfs_fattr *fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 struct nfs_symlinkargs arg = {
449 .fromfh = NFS_FH(dir),
Chuck Lever4f390c12006-08-22 20:06:22 -0400450 .fromname = dentry->d_name.name,
451 .fromlen = dentry->d_name.len,
Chuck Lever94a6d752006-08-22 20:06:23 -0400452 .pages = &page,
453 .pathlen = len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 .sattr = sattr
455 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500456 struct rpc_message msg = {
457 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
458 .rpc_argp = &arg,
459 };
Trond Myklebust23a30612010-04-16 16:22:51 -0400460 int status = -ENAMETOOLONG;
Chuck Lever4f390c12006-08-22 20:06:22 -0400461
Chuck Lever94a6d752006-08-22 20:06:23 -0400462 dprintk("NFS call symlink %s\n", dentry->d_name.name);
463
Trond Myklebust23a30612010-04-16 16:22:51 -0400464 if (len > NFS2_MAXPATHLEN)
465 goto out;
466
467 fh = nfs_alloc_fhandle();
468 fattr = nfs_alloc_fattr();
469 status = -ENOMEM;
470 if (fh == NULL || fattr == NULL)
Jesper Juhl878215f2010-12-24 22:22:37 +0000471 goto out_free;
Trond Myklebust23a30612010-04-16 16:22:51 -0400472
Chuck Leverdead28d2006-03-20 13:44:23 -0500473 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400474 nfs_mark_for_revalidate(dir);
Chuck Lever4f390c12006-08-22 20:06:22 -0400475
476 /*
477 * V2 SYMLINK requests don't return any attributes. Setting the
478 * filehandle size to zero indicates to nfs_instantiate that it
479 * should fill in the data with a LOOKUP call on the wire.
480 */
Trond Myklebust23a30612010-04-16 16:22:51 -0400481 if (status == 0)
482 status = nfs_instantiate(dentry, fh, fattr);
Chuck Lever4f390c12006-08-22 20:06:22 -0400483
Jesper Juhl878215f2010-12-24 22:22:37 +0000484out_free:
Trond Myklebust23a30612010-04-16 16:22:51 -0400485 nfs_free_fattr(fattr);
486 nfs_free_fhandle(fh);
487out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 dprintk("NFS reply symlink: %d\n", status);
489 return status;
490}
491
492static int
493nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
494{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400495 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500496 struct rpc_message msg = {
497 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
Chuck Leverdead28d2006-03-20 13:44:23 -0500498 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400499 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400502 data = nfs_alloc_createdata(dir, dentry, sattr);
503 if (data == NULL)
504 goto out;
505 msg.rpc_argp = &data->arg;
506 msg.rpc_resp = &data->res;
507
Chuck Leverdead28d2006-03-20 13:44:23 -0500508 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400509 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if (status == 0)
Trond Myklebusteb872f02010-04-16 16:22:51 -0400511 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
512 nfs_free_createdata(data);
513out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 dprintk("NFS reply mkdir: %d\n", status);
515 return status;
516}
517
518static int
519nfs_proc_rmdir(struct inode *dir, struct qstr *name)
520{
521 struct nfs_diropargs arg = {
522 .fh = NFS_FH(dir),
523 .name = name->name,
524 .len = name->len
525 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500526 struct rpc_message msg = {
527 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
528 .rpc_argp = &arg,
529 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 int status;
531
532 dprintk("NFS call rmdir %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500533 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400534 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 dprintk("NFS reply rmdir: %d\n", status);
536 return status;
537}
538
539/*
540 * The READDIR implementation is somewhat hackish - we pass a temporary
541 * buffer to the encode function, which installs it in the receive
542 * the receive iovec. The decode function just parses the reply to make
543 * sure it is syntactically correct; the entries itself are decoded
544 * from nfs_readdir by calling the decode_entry function directly.
545 */
546static int
547nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400548 u64 cookie, struct page **pages, unsigned int count, int plus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
550 struct inode *dir = dentry->d_inode;
551 struct nfs_readdirargs arg = {
552 .fh = NFS_FH(dir),
553 .cookie = cookie,
554 .count = count,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -0400555 .pages = pages,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 };
557 struct rpc_message msg = {
558 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
559 .rpc_argp = &arg,
Chuck Leverdead28d2006-03-20 13:44:23 -0500560 .rpc_cred = cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 };
562 int status;
563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 dprintk("NFS call readdir %d\n", (unsigned int)cookie);
565 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
566
Trond Myklebustc4812992007-09-28 17:11:45 -0400567 nfs_invalidate_atime(dir);
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 dprintk("NFS reply readdir: %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 return status;
571}
572
573static int
574nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
575 struct nfs_fsstat *stat)
576{
577 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500578 struct rpc_message msg = {
579 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
580 .rpc_argp = fhandle,
581 .rpc_resp = &fsinfo,
582 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 int status;
584
585 dprintk("NFS call statfs\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400586 nfs_fattr_init(stat->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500587 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 dprintk("NFS reply statfs: %d\n", status);
589 if (status)
590 goto out;
591 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
592 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
593 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
594 stat->tfiles = 0;
595 stat->ffiles = 0;
596 stat->afiles = 0;
597out:
598 return status;
599}
600
601static int
602nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
603 struct nfs_fsinfo *info)
604{
605 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500606 struct rpc_message msg = {
607 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
608 .rpc_argp = fhandle,
609 .rpc_resp = &fsinfo,
610 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 int status;
612
613 dprintk("NFS call fsinfo\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400614 nfs_fattr_init(info->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500615 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 dprintk("NFS reply fsinfo: %d\n", status);
617 if (status)
618 goto out;
619 info->rtmax = NFS_MAXDATA;
620 info->rtpref = fsinfo.tsize;
621 info->rtmult = fsinfo.bsize;
622 info->wtmax = NFS_MAXDATA;
623 info->wtpref = fsinfo.tsize;
624 info->wtmult = fsinfo.bsize;
625 info->dtpref = fsinfo.tsize;
626 info->maxfilesize = 0x7FFFFFFF;
627 info->lease_time = 0;
628out:
629 return status;
630}
631
632static int
633nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
634 struct nfs_pathconf *info)
635{
636 info->max_link = 0;
637 info->max_namelen = NFS2_MAXNAMLEN;
638 return 0;
639}
640
Trond Myklebustec06c092006-03-20 13:44:27 -0500641static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
Fred Isamancd841602012-04-20 14:47:44 -0400643 struct inode *inode = data->header->inode;
644
Jeff Layton97cefcc2010-01-08 12:17:21 -0500645 if (nfs_async_handle_expired_key(task))
646 return -EAGAIN;
647
Fred Isamancd841602012-04-20 14:47:44 -0400648 nfs_invalidate_atime(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (task->tk_status >= 0) {
Fred Isamancd841602012-04-20 14:47:44 -0400650 nfs_refresh_inode(inode, data->res.fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 /* Emulate the eof flag, which isn't normally needed in NFSv2
652 * as it is guaranteed to always return the file attributes
653 */
654 if (data->args.offset + data->args.count >= data->res.fattr->size)
655 data->res.eof = 1;
656 }
Trond Myklebustec06c092006-03-20 13:44:27 -0500657 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400660static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400662 msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663}
664
Bryan Schumakerea7c3302012-03-19 14:54:40 -0400665static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
666{
667 rpc_call_start(task);
668}
669
Trond Myklebust788e7a82006-03-20 13:44:27 -0500670static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
Fred Isamancd841602012-04-20 14:47:44 -0400672 struct inode *inode = data->header->inode;
673
Jeff Layton97cefcc2010-01-08 12:17:21 -0500674 if (nfs_async_handle_expired_key(task))
675 return -EAGAIN;
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (task->tk_status >= 0)
Fred Isamancd841602012-04-20 14:47:44 -0400678 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
Trond Myklebust788e7a82006-03-20 13:44:27 -0500679 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680}
681
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400682static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
685 data->args.stable = NFS_FILE_SYNC;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400686 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
Bryan Schumakerc6cb80d2012-03-19 14:54:39 -0400689static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
690{
691 rpc_call_start(task);
692}
693
Fred Isaman0b7c0152012-04-20 14:47:39 -0400694static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
695{
696 BUG();
697}
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699static void
Fred Isaman0b7c0152012-04-20 14:47:39 -0400700nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701{
702 BUG();
703}
704
705static int
706nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
707{
Chuck Lever1093a602008-01-11 17:09:59 -0500708 struct inode *inode = filp->f_path.dentry->d_inode;
709
710 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Trond Myklebust21162712008-05-20 19:34:39 -0400713/* Helper functions for NFS lock bounds checking */
714#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
715static int nfs_lock_check_bounds(const struct file_lock *fl)
716{
717 __s32 start, end;
718
719 start = (__s32)fl->fl_start;
720 if ((loff_t)start != fl->fl_start)
721 goto out_einval;
722
723 if (fl->fl_end != OFFSET_MAX) {
724 end = (__s32)fl->fl_end;
725 if ((loff_t)end != fl->fl_end)
726 goto out_einval;
727 } else
728 end = NFS_LOCK32_OFFSET_MAX;
729
730 if (start < 0 || start > end)
731 goto out_einval;
732 return 0;
733out_einval:
734 return -EINVAL;
735}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
David Howells509de812006-08-22 20:06:11 -0400737const struct nfs_rpc_ops nfs_v2_clientops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 .version = 2, /* protocol version */
739 .dentry_ops = &nfs_dentry_operations,
740 .dir_inode_ops = &nfs_dir_inode_operations,
J. Bruce Fields92cfc622005-06-22 17:16:22 +0000741 .file_inode_ops = &nfs_file_inode_operations,
Jeff Layton1788ea62011-11-04 13:31:21 -0400742 .file_ops = &nfs_file_operations,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 .getroot = nfs_proc_get_root,
Bryan Schumaker281cad42012-04-27 13:27:45 -0400744 .submount = nfs_submount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 .getattr = nfs_proc_getattr,
746 .setattr = nfs_proc_setattr,
747 .lookup = nfs_proc_lookup,
748 .access = NULL, /* access */
749 .readlink = nfs_proc_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 .create = nfs_proc_create,
751 .remove = nfs_proc_remove,
752 .unlink_setup = nfs_proc_unlink_setup,
Bryan Schumaker34e137c2012-03-19 14:54:41 -0400753 .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 .unlink_done = nfs_proc_unlink_done,
755 .rename = nfs_proc_rename,
Jeff Laytond3d41522010-09-17 17:31:57 -0400756 .rename_setup = nfs_proc_rename_setup,
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -0400757 .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
Jeff Laytond3d41522010-09-17 17:31:57 -0400758 .rename_done = nfs_proc_rename_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 .link = nfs_proc_link,
760 .symlink = nfs_proc_symlink,
761 .mkdir = nfs_proc_mkdir,
762 .rmdir = nfs_proc_rmdir,
763 .readdir = nfs_proc_readdir,
764 .mknod = nfs_proc_mknod,
765 .statfs = nfs_proc_statfs,
766 .fsinfo = nfs_proc_fsinfo,
767 .pathconf = nfs_proc_pathconf,
Chuck Leverf796f8b2010-12-14 14:55:10 +0000768 .decode_dirent = nfs2_decode_dirent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 .read_setup = nfs_proc_read_setup,
Bryan Schumakerea7c3302012-03-19 14:54:40 -0400770 .read_rpc_prepare = nfs_proc_read_rpc_prepare,
Trond Myklebustec06c092006-03-20 13:44:27 -0500771 .read_done = nfs_read_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 .write_setup = nfs_proc_write_setup,
Bryan Schumakerc6cb80d2012-03-19 14:54:39 -0400773 .write_rpc_prepare = nfs_proc_write_rpc_prepare,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500774 .write_done = nfs_write_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 .commit_setup = nfs_proc_commit_setup,
Fred Isaman0b7c0152012-04-20 14:47:39 -0400776 .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 .lock = nfs_proc_lock,
Trond Myklebust21162712008-05-20 19:34:39 -0400778 .lock_check_bounds = nfs_lock_check_bounds,
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400779 .close_context = nfs_close_context,
Andy Adamson45a52a02011-03-01 01:34:08 +0000780 .init_client = nfs_init_client,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781};