blob: ecc4e717808c4ee5958b30d1b5f513c260a427df [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * linux/fs/nfs/proc.c
4 *
5 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
6 *
7 * OS-independent nfs remote procedure call functions
8 *
9 * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
10 * so at last we can have decent(ish) throughput off a
11 * Sun server.
12 *
13 * Coding optimized and cleaned up by Florian La Roche.
14 * Note: Error returns are optimized for NFS_OK, which isn't translated via
15 * nfs_stat_to_errno(), but happens to be already the right return code.
16 *
17 * Also, the code currently doesn't check the size of the packet, when
18 * it decodes the packet.
19 *
20 * Feel free to fix it and mail me the diffs if it worries you.
21 *
22 * Completely rewritten to support the new RPC call interface;
23 * rewrote and moved the entire XDR stuff to xdr.c
24 * --Olaf Kirch June 1996
25 *
26 * The code below initializes all auto variables explicitly, otherwise
27 * it will fail to work as a module (gcc generates a memset call for an
28 * incomplete struct).
29 */
30
31#include <linux/types.h>
32#include <linux/param.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/time.h>
34#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/errno.h>
36#include <linux/string.h>
37#include <linux/in.h>
38#include <linux/pagemap.h>
39#include <linux/sunrpc/clnt.h>
40#include <linux/nfs.h>
41#include <linux/nfs2.h>
42#include <linux/nfs_fs.h>
43#include <linux/nfs_page.h>
44#include <linux/lockd/bind.h>
Jeff Laytond3103102011-12-01 22:44:39 +010045#include <linux/freezer.h>
David Howellsf7b422b2006-06-09 09:34:33 -040046#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define NFSDBG_FACILITY NFSDBG_PROC
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/*
51 * Bare-bones access to getattr: this is for nfs_read_super.
52 */
53static int
54nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
55 struct nfs_fsinfo *info)
56{
57 struct nfs_fattr *fattr = info->fattr;
58 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -050059 struct rpc_message msg = {
60 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
61 .rpc_argp = fhandle,
62 .rpc_resp = fattr,
63 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 int status;
65
Harvey Harrison3110ff82008-05-02 13:42:44 -070066 dprintk("%s: call getattr\n", __func__);
Trond Myklebust0e574af2005-10-27 22:12:38 -040067 nfs_fattr_init(fattr);
EG Keizer37ca8f52008-08-19 16:34:36 -040068 status = rpc_call_sync(server->client, &msg, 0);
69 /* Retry with default authentication if different */
70 if (status && server->nfs_client->cl_rpcclient != server->client)
71 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
Harvey Harrison3110ff82008-05-02 13:42:44 -070072 dprintk("%s: reply getattr: %d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 if (status)
74 return status;
Harvey Harrison3110ff82008-05-02 13:42:44 -070075 dprintk("%s: call statfs\n", __func__);
Chuck Leverdead28d2006-03-20 13:44:23 -050076 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
77 msg.rpc_resp = &fsinfo;
EG Keizer37ca8f52008-08-19 16:34:36 -040078 status = rpc_call_sync(server->client, &msg, 0);
79 /* Retry with default authentication if different */
80 if (status && server->nfs_client->cl_rpcclient != server->client)
81 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
Harvey Harrison3110ff82008-05-02 13:42:44 -070082 dprintk("%s: reply statfs: %d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 if (status)
84 return status;
85 info->rtmax = NFS_MAXDATA;
86 info->rtpref = fsinfo.tsize;
87 info->rtmult = fsinfo.bsize;
88 info->wtmax = NFS_MAXDATA;
89 info->wtpref = fsinfo.tsize;
90 info->wtmult = fsinfo.bsize;
91 info->dtpref = fsinfo.tsize;
92 info->maxfilesize = 0x7FFFFFFF;
93 info->lease_time = 0;
Trond Myklebusteea41332021-09-26 14:05:04 -040094 info->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 return 0;
96}
97
98/*
99 * One function for each procedure in the NFS protocol.
100 */
101static int
102nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
Trond Myklebusta841b542018-04-07 13:50:59 -0400103 struct nfs_fattr *fattr, struct nfs4_label *label,
104 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
Chuck Leverdead28d2006-03-20 13:44:23 -0500106 struct rpc_message msg = {
107 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
108 .rpc_argp = fhandle,
109 .rpc_resp = fattr,
110 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 int status;
Trond Myklebustc74dfe92020-01-06 15:39:37 -0500112 unsigned short task_flags = 0;
113
114 /* Is this is an attribute revalidation, subject to softreval? */
115 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))
116 task_flags |= RPC_TASK_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 dprintk("NFS call getattr\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400119 nfs_fattr_init(fattr);
Trond Myklebustc74dfe92020-01-06 15:39:37 -0500120 status = rpc_call_sync(server->client, &msg, task_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 dprintk("NFS reply getattr: %d\n", status);
122 return status;
123}
124
125static int
126nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
127 struct iattr *sattr)
128{
David Howells2b0143b2015-03-17 22:25:59 +0000129 struct inode *inode = d_inode(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 struct nfs_sattrargs arg = {
131 .fh = NFS_FH(inode),
132 .sattr = sattr
133 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500134 struct rpc_message msg = {
135 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR],
136 .rpc_argp = &arg,
137 .rpc_resp = fattr,
138 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 int status;
140
Trond Myklebustcf3fff52006-01-03 09:55:53 +0100141 /* Mask out the non-modebit related stuff from attr->ia_mode */
142 sattr->ia_mode &= S_IALLUGO;
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 dprintk("NFS call setattr\n");
Trond Myklebust659bfcd2008-06-10 19:39:41 -0400145 if (sattr->ia_valid & ATTR_FILE)
146 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
Trond Myklebust0e574af2005-10-27 22:12:38 -0400147 nfs_fattr_init(fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500148 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Trond Myklebust65e43082005-08-16 11:49:44 -0400149 if (status == 0)
Trond Myklebustf0446362015-02-26 16:09:04 -0500150 nfs_setattr_update_inode(inode, sattr, fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 dprintk("NFS reply setattr: %d\n", status);
152 return status;
153}
154
155static int
Trond Myklebustf7b37b82020-01-14 12:06:34 -0500156nfs_proc_lookup(struct inode *dir, struct dentry *dentry,
David Quigley1775fd32013-05-22 12:50:42 -0400157 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
158 struct nfs4_label *label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
160 struct nfs_diropargs arg = {
161 .fh = NFS_FH(dir),
Trond Myklebustf7b37b82020-01-14 12:06:34 -0500162 .name = dentry->d_name.name,
163 .len = dentry->d_name.len
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 };
165 struct nfs_diropok res = {
166 .fh = fhandle,
167 .fattr = fattr
168 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500169 struct rpc_message msg = {
170 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
171 .rpc_argp = &arg,
172 .rpc_resp = &res,
173 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 int status;
Trond Myklebustf7b37b82020-01-14 12:06:34 -0500175 unsigned short task_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Trond Myklebustf7b37b82020-01-14 12:06:34 -0500177 /* Is this is an attribute revalidation, subject to softreval? */
178 if (nfs_lookup_is_soft_revalidate(dentry))
179 task_flags |= RPC_TASK_TIMEOUT;
180
181 dprintk("NFS call lookup %pd2\n", dentry);
Trond Myklebust0e574af2005-10-27 22:12:38 -0400182 nfs_fattr_init(fattr);
Trond Myklebustf7b37b82020-01-14 12:06:34 -0500183 status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 dprintk("NFS reply lookup: %d\n", status);
185 return status;
186}
187
188static int nfs_proc_readlink(struct inode *inode, struct page *page,
189 unsigned int pgbase, unsigned int pglen)
190{
191 struct nfs_readlinkargs args = {
192 .fh = NFS_FH(inode),
193 .pgbase = pgbase,
194 .pglen = pglen,
195 .pages = &page
196 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500197 struct rpc_message msg = {
198 .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
199 .rpc_argp = &args,
200 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 int status;
202
203 dprintk("NFS call readlink\n");
Chuck Leverdead28d2006-03-20 13:44:23 -0500204 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 dprintk("NFS reply readlink: %d\n", status);
206 return status;
207}
208
Trond Myklebusteb872f02010-04-16 16:22:51 -0400209struct nfs_createdata {
210 struct nfs_createargs arg;
211 struct nfs_diropok res;
212 struct nfs_fh fhandle;
213 struct nfs_fattr fattr;
214};
215
216static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
217 struct dentry *dentry, struct iattr *sattr)
218{
219 struct nfs_createdata *data;
220
221 data = kmalloc(sizeof(*data), GFP_KERNEL);
222
223 if (data != NULL) {
224 data->arg.fh = NFS_FH(dir);
225 data->arg.name = dentry->d_name.name;
226 data->arg.len = dentry->d_name.len;
227 data->arg.sattr = sattr;
228 nfs_fattr_init(&data->fattr);
229 data->fhandle.size = 0;
230 data->res.fh = &data->fhandle;
231 data->res.fattr = &data->fattr;
232 }
233 return data;
234};
235
236static void nfs_free_createdata(const struct nfs_createdata *data)
237{
238 kfree(data);
239}
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241static int
242nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
Miklos Szeredi8867fe52012-06-05 15:10:19 +0200243 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400245 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500246 struct rpc_message msg = {
247 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
Chuck Leverdead28d2006-03-20 13:44:23 -0500248 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400249 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Al Viro6de14722013-09-16 10:53:17 -0400251 dprintk("NFS call create %pd\n", dentry);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400252 data = nfs_alloc_createdata(dir, dentry, sattr);
253 if (data == NULL)
254 goto out;
255 msg.rpc_argp = &data->arg;
256 msg.rpc_resp = &data->res;
Chuck Leverdead28d2006-03-20 13:44:23 -0500257 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustbad2a522007-10-20 13:07:21 -0400258 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (status == 0)
David Quigley1775fd32013-05-22 12:50:42 -0400260 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400261 nfs_free_createdata(data);
262out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 dprintk("NFS reply create: %d\n", status);
264 return status;
265}
266
267/*
268 * In NFSv2, mknod is grafted onto the create call.
269 */
270static int
271nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
272 dev_t rdev)
273{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400274 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500275 struct rpc_message msg = {
276 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
Chuck Leverdead28d2006-03-20 13:44:23 -0500277 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400278 umode_t mode;
279 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Al Viro6de14722013-09-16 10:53:17 -0400281 dprintk("NFS call mknod %pd\n", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 mode = sattr->ia_mode;
284 if (S_ISFIFO(mode)) {
285 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
286 sattr->ia_valid &= ~ATTR_SIZE;
287 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
288 sattr->ia_valid |= ATTR_SIZE;
289 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
290 }
291
Trond Myklebusteb872f02010-04-16 16:22:51 -0400292 data = nfs_alloc_createdata(dir, dentry, sattr);
293 if (data == NULL)
294 goto out;
295 msg.rpc_argp = &data->arg;
296 msg.rpc_resp = &data->res;
297
Chuck Leverdead28d2006-03-20 13:44:23 -0500298 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400299 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 if (status == -EINVAL && S_ISFIFO(mode)) {
302 sattr->ia_mode = mode;
Trond Myklebusteb872f02010-04-16 16:22:51 -0400303 nfs_fattr_init(data->res.fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500304 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 }
306 if (status == 0)
David Quigley1775fd32013-05-22 12:50:42 -0400307 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400308 nfs_free_createdata(data);
309out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 dprintk("NFS reply mknod: %d\n", status);
311 return status;
312}
313
314static int
Trond Myklebust912678d2018-03-20 16:43:15 -0400315nfs_proc_remove(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400317 struct nfs_removeargs arg = {
318 .fh = NFS_FH(dir),
Trond Myklebust912678d2018-03-20 16:43:15 -0400319 .name = dentry->d_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 };
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400321 struct rpc_message msg = {
322 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
323 .rpc_argp = &arg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 };
325 int status;
326
Trond Myklebust912678d2018-03-20 16:43:15 -0400327 dprintk("NFS call remove %pd2\n",dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400329 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
331 dprintk("NFS reply remove: %d\n", status);
332 return status;
333}
334
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400335static void
Trond Myklebusted7e9ad2018-05-30 16:11:52 -0400336nfs_proc_unlink_setup(struct rpc_message *msg,
337 struct dentry *dentry,
338 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341}
342
Bryan Schumaker34e137c2012-03-19 14:54:41 -0400343static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
344{
345 rpc_call_start(task);
346}
347
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400348static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Trond Myklebuste4eff1a2007-07-14 15:39:58 -0400350 nfs_mark_for_revalidate(dir);
351 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352}
353
Jeff Laytond3d41522010-09-17 17:31:57 -0400354static void
Trond Myklebustf2c2c552018-03-20 16:43:16 -0400355nfs_proc_rename_setup(struct rpc_message *msg,
356 struct dentry *old_dentry,
357 struct dentry *new_dentry)
Jeff Laytond3d41522010-09-17 17:31:57 -0400358{
359 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
360}
361
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -0400362static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
363{
364 rpc_call_start(task);
365}
366
Jeff Laytond3d41522010-09-17 17:31:57 -0400367static int
368nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
369 struct inode *new_dir)
370{
Jeff Laytond3d41522010-09-17 17:31:57 -0400371 nfs_mark_for_revalidate(old_dir);
372 nfs_mark_for_revalidate(new_dir);
373 return 1;
374}
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376static int
Al Virobeffb8f2016-07-20 16:34:42 -0400377nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
379 struct nfs_linkargs arg = {
380 .fromfh = NFS_FH(inode),
381 .tofh = NFS_FH(dir),
382 .toname = name->name,
383 .tolen = name->len
384 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500385 struct rpc_message msg = {
386 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
387 .rpc_argp = &arg,
388 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 int status;
390
391 dprintk("NFS call link %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500392 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
Trond Myklebust5ba7cc42005-12-03 15:20:17 -0500393 nfs_mark_for_revalidate(inode);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400394 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 dprintk("NFS reply link: %d\n", status);
396 return status;
397}
398
399static int
Chuck Lever94a6d752006-08-22 20:06:23 -0400400nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
401 unsigned int len, struct iattr *sattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
Trond Myklebust23a30612010-04-16 16:22:51 -0400403 struct nfs_fh *fh;
404 struct nfs_fattr *fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 struct nfs_symlinkargs arg = {
406 .fromfh = NFS_FH(dir),
Chuck Lever4f390c12006-08-22 20:06:22 -0400407 .fromname = dentry->d_name.name,
408 .fromlen = dentry->d_name.len,
Chuck Lever94a6d752006-08-22 20:06:23 -0400409 .pages = &page,
410 .pathlen = len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 .sattr = sattr
412 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500413 struct rpc_message msg = {
414 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
415 .rpc_argp = &arg,
416 };
Trond Myklebust23a30612010-04-16 16:22:51 -0400417 int status = -ENAMETOOLONG;
Chuck Lever4f390c12006-08-22 20:06:22 -0400418
Al Viro6de14722013-09-16 10:53:17 -0400419 dprintk("NFS call symlink %pd\n", dentry);
Chuck Lever94a6d752006-08-22 20:06:23 -0400420
Trond Myklebust23a30612010-04-16 16:22:51 -0400421 if (len > NFS2_MAXPATHLEN)
422 goto out;
423
424 fh = nfs_alloc_fhandle();
425 fattr = nfs_alloc_fattr();
426 status = -ENOMEM;
427 if (fh == NULL || fattr == NULL)
Jesper Juhl878215f2010-12-24 22:22:37 +0000428 goto out_free;
Trond Myklebust23a30612010-04-16 16:22:51 -0400429
Chuck Leverdead28d2006-03-20 13:44:23 -0500430 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400431 nfs_mark_for_revalidate(dir);
Chuck Lever4f390c12006-08-22 20:06:22 -0400432
433 /*
434 * V2 SYMLINK requests don't return any attributes. Setting the
435 * filehandle size to zero indicates to nfs_instantiate that it
436 * should fill in the data with a LOOKUP call on the wire.
437 */
Trond Myklebust23a30612010-04-16 16:22:51 -0400438 if (status == 0)
David Quigley1775fd32013-05-22 12:50:42 -0400439 status = nfs_instantiate(dentry, fh, fattr, NULL);
Chuck Lever4f390c12006-08-22 20:06:22 -0400440
Jesper Juhl878215f2010-12-24 22:22:37 +0000441out_free:
Trond Myklebust23a30612010-04-16 16:22:51 -0400442 nfs_free_fattr(fattr);
443 nfs_free_fhandle(fh);
444out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 dprintk("NFS reply symlink: %d\n", status);
446 return status;
447}
448
449static int
450nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
451{
Trond Myklebusteb872f02010-04-16 16:22:51 -0400452 struct nfs_createdata *data;
Chuck Leverdead28d2006-03-20 13:44:23 -0500453 struct rpc_message msg = {
454 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
Chuck Leverdead28d2006-03-20 13:44:23 -0500455 };
Trond Myklebusteb872f02010-04-16 16:22:51 -0400456 int status = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Al Viro6de14722013-09-16 10:53:17 -0400458 dprintk("NFS call mkdir %pd\n", dentry);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400459 data = nfs_alloc_createdata(dir, dentry, sattr);
460 if (data == NULL)
461 goto out;
462 msg.rpc_argp = &data->arg;
463 msg.rpc_resp = &data->res;
464
Chuck Leverdead28d2006-03-20 13:44:23 -0500465 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400466 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (status == 0)
David Quigley1775fd32013-05-22 12:50:42 -0400468 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
Trond Myklebusteb872f02010-04-16 16:22:51 -0400469 nfs_free_createdata(data);
470out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 dprintk("NFS reply mkdir: %d\n", status);
472 return status;
473}
474
475static int
Al Virobeffb8f2016-07-20 16:34:42 -0400476nfs_proc_rmdir(struct inode *dir, const struct qstr *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
478 struct nfs_diropargs arg = {
479 .fh = NFS_FH(dir),
480 .name = name->name,
481 .len = name->len
482 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500483 struct rpc_message msg = {
484 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
485 .rpc_argp = &arg,
486 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 int status;
488
489 dprintk("NFS call rmdir %s\n", name->name);
Chuck Leverdead28d2006-03-20 13:44:23 -0500490 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebustdecf4912005-10-27 22:12:39 -0400491 nfs_mark_for_revalidate(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 dprintk("NFS reply rmdir: %d\n", status);
493 return status;
494}
495
496/*
497 * The READDIR implementation is somewhat hackish - we pass a temporary
498 * buffer to the encode function, which installs it in the receive
499 * the receive iovec. The decode function just parses the reply to make
500 * sure it is syntactically correct; the entries itself are decoded
501 * from nfs_readdir by calling the decode_entry function directly.
502 */
Trond Myklebust82e22a52020-11-02 17:34:23 -0500503static int nfs_proc_readdir(struct nfs_readdir_arg *nr_arg,
504 struct nfs_readdir_res *nr_res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Trond Myklebust82e22a52020-11-02 17:34:23 -0500506 struct inode *dir = d_inode(nr_arg->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 struct nfs_readdirargs arg = {
508 .fh = NFS_FH(dir),
Trond Myklebust82e22a52020-11-02 17:34:23 -0500509 .cookie = nr_arg->cookie,
510 .count = nr_arg->page_len,
511 .pages = nr_arg->pages,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 };
513 struct rpc_message msg = {
514 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
515 .rpc_argp = &arg,
Trond Myklebust82e22a52020-11-02 17:34:23 -0500516 .rpc_cred = nr_arg->cred,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 };
518 int status;
519
Trond Myklebust82e22a52020-11-02 17:34:23 -0500520 dprintk("NFS call readdir %llu\n", (unsigned long long)nr_arg->cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
Trond Myklebust82e22a52020-11-02 17:34:23 -0500522 nr_res->verf[0] = nr_res->verf[1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Trond Myklebustc4812992007-09-28 17:11:45 -0400524 nfs_invalidate_atime(dir);
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 dprintk("NFS reply readdir: %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return status;
528}
529
530static int
531nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
532 struct nfs_fsstat *stat)
533{
534 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500535 struct rpc_message msg = {
536 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
537 .rpc_argp = fhandle,
538 .rpc_resp = &fsinfo,
539 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 int status;
541
542 dprintk("NFS call statfs\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400543 nfs_fattr_init(stat->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500544 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 dprintk("NFS reply statfs: %d\n", status);
546 if (status)
547 goto out;
548 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
549 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
550 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
551 stat->tfiles = 0;
552 stat->ffiles = 0;
553 stat->afiles = 0;
554out:
555 return status;
556}
557
558static int
559nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
560 struct nfs_fsinfo *info)
561{
562 struct nfs2_fsstat fsinfo;
Chuck Leverdead28d2006-03-20 13:44:23 -0500563 struct rpc_message msg = {
564 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
565 .rpc_argp = fhandle,
566 .rpc_resp = &fsinfo,
567 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 int status;
569
570 dprintk("NFS call fsinfo\n");
Trond Myklebust0e574af2005-10-27 22:12:38 -0400571 nfs_fattr_init(info->fattr);
Chuck Leverdead28d2006-03-20 13:44:23 -0500572 status = rpc_call_sync(server->client, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 dprintk("NFS reply fsinfo: %d\n", status);
574 if (status)
575 goto out;
576 info->rtmax = NFS_MAXDATA;
577 info->rtpref = fsinfo.tsize;
578 info->rtmult = fsinfo.bsize;
579 info->wtmax = NFS_MAXDATA;
580 info->wtpref = fsinfo.tsize;
581 info->wtmult = fsinfo.bsize;
582 info->dtpref = fsinfo.tsize;
583 info->maxfilesize = 0x7FFFFFFF;
584 info->lease_time = 0;
585out:
586 return status;
587}
588
589static int
590nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
591 struct nfs_pathconf *info)
592{
593 info->max_link = 0;
594 info->max_namelen = NFS2_MAXNAMLEN;
595 return 0;
596}
597
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400598static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400600 struct inode *inode = hdr->inode;
Fred Isamancd841602012-04-20 14:47:44 -0400601
Fred Isamancd841602012-04-20 14:47:44 -0400602 nfs_invalidate_atime(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 if (task->tk_status >= 0) {
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400604 nfs_refresh_inode(inode, hdr->res.fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 /* Emulate the eof flag, which isn't normally needed in NFSv2
606 * as it is guaranteed to always return the file attributes
607 */
Trond Myklebust71affe92019-08-26 20:41:16 -0400608 if ((hdr->res.count == 0 && hdr->args.count > 0) ||
609 hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400610 hdr->res.eof = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 }
Trond Myklebustec06c092006-03-20 13:44:27 -0500612 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400615static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
616 struct rpc_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400618 msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
620
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400621static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
622 struct nfs_pgio_header *hdr)
Bryan Schumakerea7c3302012-03-19 14:54:40 -0400623{
624 rpc_call_start(task);
NeilBrownef1820f2013-09-04 17:04:49 +1000625 return 0;
Bryan Schumakerea7c3302012-03-19 14:54:40 -0400626}
627
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400628static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Trond Myklebustd33d4be2019-08-27 07:03:28 -0400630 if (task->tk_status >= 0) {
631 hdr->res.count = hdr->args.count;
Trond Myklebusta08a8cd2015-02-26 17:36:09 -0500632 nfs_writeback_update_inode(hdr);
Trond Myklebustd33d4be2019-08-27 07:03:28 -0400633 }
Trond Myklebust788e7a82006-03-20 13:44:27 -0500634 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635}
636
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400637static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
Anna Schumakerfb91fb02018-05-04 16:22:48 -0400638 struct rpc_message *msg,
639 struct rpc_clnt **clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -0400642 hdr->args.stable = NFS_FILE_SYNC;
Trond Myklebustbdc7f022007-07-14 15:40:00 -0400643 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
645
Fred Isaman0b7c0152012-04-20 14:47:39 -0400646static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
647{
648 BUG();
649}
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651static void
Anna Schumakere9ae1ee2018-05-04 16:22:49 -0400652nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
653 struct rpc_clnt **clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 BUG();
656}
657
658static int
659nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
660{
Al Viro496ad9a2013-01-23 17:07:38 -0500661 struct inode *inode = file_inode(filp);
Chuck Lever1093a602008-01-11 17:09:59 -0500662
Benjamin Coddingtonb1ece732017-04-11 12:50:11 -0400663 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664}
665
Trond Myklebust21162712008-05-20 19:34:39 -0400666/* Helper functions for NFS lock bounds checking */
667#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
668static int nfs_lock_check_bounds(const struct file_lock *fl)
669{
670 __s32 start, end;
671
672 start = (__s32)fl->fl_start;
673 if ((loff_t)start != fl->fl_start)
674 goto out_einval;
675
676 if (fl->fl_end != OFFSET_MAX) {
677 end = (__s32)fl->fl_end;
678 if ((loff_t)end != fl->fl_end)
679 goto out_einval;
680 } else
681 end = NFS_LOCK32_OFFSET_MAX;
682
683 if (start < 0 || start > end)
684 goto out_einval;
685 return 0;
686out_einval:
687 return -EINVAL;
688}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Bryan Schumaker011e2a72012-06-20 15:53:43 -0400690static int nfs_have_delegation(struct inode *inode, fmode_t flags)
691{
692 return 0;
693}
694
Bryan Schumaker597d9282012-07-16 16:39:10 -0400695static const struct inode_operations nfs_dir_inode_operations = {
696 .create = nfs_create,
697 .lookup = nfs_lookup,
698 .link = nfs_link,
699 .unlink = nfs_unlink,
700 .symlink = nfs_symlink,
701 .mkdir = nfs_mkdir,
702 .rmdir = nfs_rmdir,
703 .mknod = nfs_mknod,
704 .rename = nfs_rename,
705 .permission = nfs_permission,
706 .getattr = nfs_getattr,
707 .setattr = nfs_setattr,
708};
709
710static const struct inode_operations nfs_file_inode_operations = {
711 .permission = nfs_permission,
712 .getattr = nfs_getattr,
713 .setattr = nfs_setattr,
714};
715
David Howells509de812006-08-22 20:06:11 -0400716const struct nfs_rpc_ops nfs_v2_clientops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 .version = 2, /* protocol version */
718 .dentry_ops = &nfs_dentry_operations,
719 .dir_inode_ops = &nfs_dir_inode_operations,
J. Bruce Fields92cfc622005-06-22 17:16:22 +0000720 .file_inode_ops = &nfs_file_inode_operations,
Jeff Layton1788ea62011-11-04 13:31:21 -0400721 .file_ops = &nfs_file_operations,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 .getroot = nfs_proc_get_root,
Bryan Schumaker281cad42012-04-27 13:27:45 -0400723 .submount = nfs_submount,
David Howellsf2aedb72019-12-10 07:31:13 -0500724 .try_get_tree = nfs_try_get_tree,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 .getattr = nfs_proc_getattr,
726 .setattr = nfs_proc_setattr,
727 .lookup = nfs_proc_lookup,
728 .access = NULL, /* access */
729 .readlink = nfs_proc_readlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 .create = nfs_proc_create,
731 .remove = nfs_proc_remove,
732 .unlink_setup = nfs_proc_unlink_setup,
Bryan Schumaker34e137c2012-03-19 14:54:41 -0400733 .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 .unlink_done = nfs_proc_unlink_done,
Jeff Laytond3d41522010-09-17 17:31:57 -0400735 .rename_setup = nfs_proc_rename_setup,
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -0400736 .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
Jeff Laytond3d41522010-09-17 17:31:57 -0400737 .rename_done = nfs_proc_rename_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 .link = nfs_proc_link,
739 .symlink = nfs_proc_symlink,
740 .mkdir = nfs_proc_mkdir,
741 .rmdir = nfs_proc_rmdir,
742 .readdir = nfs_proc_readdir,
743 .mknod = nfs_proc_mknod,
744 .statfs = nfs_proc_statfs,
745 .fsinfo = nfs_proc_fsinfo,
746 .pathconf = nfs_proc_pathconf,
Chuck Leverf796f8b2010-12-14 14:55:10 +0000747 .decode_dirent = nfs2_decode_dirent,
Anna Schumakera4cdda52014-05-06 09:12:31 -0400748 .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 .read_setup = nfs_proc_read_setup,
Trond Myklebustec06c092006-03-20 13:44:27 -0500750 .read_done = nfs_read_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 .write_setup = nfs_proc_write_setup,
Trond Myklebust788e7a82006-03-20 13:44:27 -0500752 .write_done = nfs_write_done,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 .commit_setup = nfs_proc_commit_setup,
Fred Isaman0b7c0152012-04-20 14:47:39 -0400754 .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 .lock = nfs_proc_lock,
Trond Myklebust21162712008-05-20 19:34:39 -0400756 .lock_check_bounds = nfs_lock_check_bounds,
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400757 .close_context = nfs_close_context,
Bryan Schumaker011e2a72012-06-20 15:53:43 -0400758 .have_delegation = nfs_have_delegation,
Bryan Schumaker6663ee72012-06-20 15:53:46 -0400759 .alloc_client = nfs_alloc_client,
Andy Adamson45a52a02011-03-01 01:34:08 +0000760 .init_client = nfs_init_client,
Bryan Schumakercdb7ece2012-06-20 15:53:45 -0400761 .free_client = nfs_free_client,
Bryan Schumaker1179acc2012-07-30 16:05:19 -0400762 .create_server = nfs_create_server,
763 .clone_server = nfs_clone_server,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764};