Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
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> | |
1da177e4 LT |
33 | #include <linux/time.h> |
34 | #include <linux/mm.h> | |
1da177e4 LT |
35 | #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> | |
d310310c | 45 | #include <linux/freezer.h> |
f7b422b1 | 46 | #include "internal.h" |
1da177e4 LT |
47 | |
48 | #define NFSDBG_FACILITY NFSDBG_PROC | |
49 | ||
1da177e4 LT |
50 | /* |
51 | * Bare-bones access to getattr: this is for nfs_read_super. | |
52 | */ | |
53 | static int | |
54 | nfs_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; | |
dead28da CL |
59 | struct rpc_message msg = { |
60 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
61 | .rpc_argp = fhandle, | |
62 | .rpc_resp = fattr, | |
63 | }; | |
1da177e4 LT |
64 | int status; |
65 | ||
3110ff80 | 66 | dprintk("%s: call getattr\n", __func__); |
0e574af1 | 67 | nfs_fattr_init(fattr); |
37ca8f5c EK |
68 | 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); | |
3110ff80 | 72 | dprintk("%s: reply getattr: %d\n", __func__, status); |
1da177e4 LT |
73 | if (status) |
74 | return status; | |
3110ff80 | 75 | dprintk("%s: call statfs\n", __func__); |
dead28da CL |
76 | msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS]; |
77 | msg.rpc_resp = &fsinfo; | |
37ca8f5c EK |
78 | 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); | |
3110ff80 | 82 | dprintk("%s: reply statfs: %d\n", __func__, status); |
1da177e4 LT |
83 | 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; | |
94 | return 0; | |
95 | } | |
96 | ||
97 | /* | |
98 | * One function for each procedure in the NFS protocol. | |
99 | */ | |
100 | static int | |
101 | nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, | |
1775fd3e | 102 | struct nfs_fattr *fattr, struct nfs4_label *label) |
1da177e4 | 103 | { |
dead28da CL |
104 | struct rpc_message msg = { |
105 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
106 | .rpc_argp = fhandle, | |
107 | .rpc_resp = fattr, | |
108 | }; | |
1da177e4 LT |
109 | int status; |
110 | ||
111 | dprintk("NFS call getattr\n"); | |
0e574af1 | 112 | nfs_fattr_init(fattr); |
dead28da | 113 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
114 | dprintk("NFS reply getattr: %d\n", status); |
115 | return status; | |
116 | } | |
117 | ||
118 | static int | |
119 | nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, | |
120 | struct iattr *sattr) | |
121 | { | |
2b0143b5 | 122 | struct inode *inode = d_inode(dentry); |
1da177e4 LT |
123 | struct nfs_sattrargs arg = { |
124 | .fh = NFS_FH(inode), | |
125 | .sattr = sattr | |
126 | }; | |
dead28da CL |
127 | struct rpc_message msg = { |
128 | .rpc_proc = &nfs_procedures[NFSPROC_SETATTR], | |
129 | .rpc_argp = &arg, | |
130 | .rpc_resp = fattr, | |
131 | }; | |
1da177e4 LT |
132 | int status; |
133 | ||
cf3fff54 TM |
134 | /* Mask out the non-modebit related stuff from attr->ia_mode */ |
135 | sattr->ia_mode &= S_IALLUGO; | |
136 | ||
1da177e4 | 137 | dprintk("NFS call setattr\n"); |
659bfcd6 TM |
138 | if (sattr->ia_valid & ATTR_FILE) |
139 | msg.rpc_cred = nfs_file_cred(sattr->ia_file); | |
0e574af1 | 140 | nfs_fattr_init(fattr); |
dead28da | 141 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
65e4308d | 142 | if (status == 0) |
f044636d | 143 | nfs_setattr_update_inode(inode, sattr, fattr); |
1da177e4 LT |
144 | dprintk("NFS reply setattr: %d\n", status); |
145 | return status; | |
146 | } | |
147 | ||
148 | static int | |
beffb8fe | 149 | nfs_proc_lookup(struct inode *dir, const struct qstr *name, |
1775fd3e DQ |
150 | struct nfs_fh *fhandle, struct nfs_fattr *fattr, |
151 | struct nfs4_label *label) | |
1da177e4 LT |
152 | { |
153 | struct nfs_diropargs arg = { | |
154 | .fh = NFS_FH(dir), | |
155 | .name = name->name, | |
156 | .len = name->len | |
157 | }; | |
158 | struct nfs_diropok res = { | |
159 | .fh = fhandle, | |
160 | .fattr = fattr | |
161 | }; | |
dead28da CL |
162 | struct rpc_message msg = { |
163 | .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP], | |
164 | .rpc_argp = &arg, | |
165 | .rpc_resp = &res, | |
166 | }; | |
1da177e4 LT |
167 | int status; |
168 | ||
169 | dprintk("NFS call lookup %s\n", name->name); | |
0e574af1 | 170 | nfs_fattr_init(fattr); |
dead28da | 171 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
172 | dprintk("NFS reply lookup: %d\n", status); |
173 | return status; | |
174 | } | |
175 | ||
176 | static int nfs_proc_readlink(struct inode *inode, struct page *page, | |
177 | unsigned int pgbase, unsigned int pglen) | |
178 | { | |
179 | struct nfs_readlinkargs args = { | |
180 | .fh = NFS_FH(inode), | |
181 | .pgbase = pgbase, | |
182 | .pglen = pglen, | |
183 | .pages = &page | |
184 | }; | |
dead28da CL |
185 | struct rpc_message msg = { |
186 | .rpc_proc = &nfs_procedures[NFSPROC_READLINK], | |
187 | .rpc_argp = &args, | |
188 | }; | |
1da177e4 LT |
189 | int status; |
190 | ||
191 | dprintk("NFS call readlink\n"); | |
dead28da | 192 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
1da177e4 LT |
193 | dprintk("NFS reply readlink: %d\n", status); |
194 | return status; | |
195 | } | |
196 | ||
eb872f0c TM |
197 | struct nfs_createdata { |
198 | struct nfs_createargs arg; | |
199 | struct nfs_diropok res; | |
200 | struct nfs_fh fhandle; | |
201 | struct nfs_fattr fattr; | |
202 | }; | |
203 | ||
204 | static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir, | |
205 | struct dentry *dentry, struct iattr *sattr) | |
206 | { | |
207 | struct nfs_createdata *data; | |
208 | ||
209 | data = kmalloc(sizeof(*data), GFP_KERNEL); | |
210 | ||
211 | if (data != NULL) { | |
212 | data->arg.fh = NFS_FH(dir); | |
213 | data->arg.name = dentry->d_name.name; | |
214 | data->arg.len = dentry->d_name.len; | |
215 | data->arg.sattr = sattr; | |
216 | nfs_fattr_init(&data->fattr); | |
217 | data->fhandle.size = 0; | |
218 | data->res.fh = &data->fhandle; | |
219 | data->res.fattr = &data->fattr; | |
220 | } | |
221 | return data; | |
222 | }; | |
223 | ||
224 | static void nfs_free_createdata(const struct nfs_createdata *data) | |
225 | { | |
226 | kfree(data); | |
227 | } | |
228 | ||
1da177e4 LT |
229 | static int |
230 | nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
8867fe58 | 231 | int flags) |
1da177e4 | 232 | { |
eb872f0c | 233 | struct nfs_createdata *data; |
dead28da CL |
234 | struct rpc_message msg = { |
235 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
dead28da | 236 | }; |
eb872f0c | 237 | int status = -ENOMEM; |
1da177e4 | 238 | |
6de1472f | 239 | dprintk("NFS call create %pd\n", dentry); |
eb872f0c TM |
240 | data = nfs_alloc_createdata(dir, dentry, sattr); |
241 | if (data == NULL) | |
242 | goto out; | |
243 | msg.rpc_argp = &data->arg; | |
244 | msg.rpc_resp = &data->res; | |
dead28da | 245 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
bad2a524 | 246 | nfs_mark_for_revalidate(dir); |
1da177e4 | 247 | if (status == 0) |
1775fd3e | 248 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); |
eb872f0c TM |
249 | nfs_free_createdata(data); |
250 | out: | |
1da177e4 LT |
251 | dprintk("NFS reply create: %d\n", status); |
252 | return status; | |
253 | } | |
254 | ||
255 | /* | |
256 | * In NFSv2, mknod is grafted onto the create call. | |
257 | */ | |
258 | static int | |
259 | nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
260 | dev_t rdev) | |
261 | { | |
eb872f0c | 262 | struct nfs_createdata *data; |
dead28da CL |
263 | struct rpc_message msg = { |
264 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
dead28da | 265 | }; |
eb872f0c TM |
266 | umode_t mode; |
267 | int status = -ENOMEM; | |
1da177e4 | 268 | |
6de1472f | 269 | dprintk("NFS call mknod %pd\n", dentry); |
1da177e4 LT |
270 | |
271 | mode = sattr->ia_mode; | |
272 | if (S_ISFIFO(mode)) { | |
273 | sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR; | |
274 | sattr->ia_valid &= ~ATTR_SIZE; | |
275 | } else if (S_ISCHR(mode) || S_ISBLK(mode)) { | |
276 | sattr->ia_valid |= ATTR_SIZE; | |
277 | sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */ | |
278 | } | |
279 | ||
eb872f0c TM |
280 | data = nfs_alloc_createdata(dir, dentry, sattr); |
281 | if (data == NULL) | |
282 | goto out; | |
283 | msg.rpc_argp = &data->arg; | |
284 | msg.rpc_resp = &data->res; | |
285 | ||
dead28da | 286 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 287 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
288 | |
289 | if (status == -EINVAL && S_ISFIFO(mode)) { | |
290 | sattr->ia_mode = mode; | |
eb872f0c | 291 | nfs_fattr_init(data->res.fattr); |
dead28da | 292 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
293 | } |
294 | if (status == 0) | |
1775fd3e | 295 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); |
eb872f0c TM |
296 | nfs_free_createdata(data); |
297 | out: | |
1da177e4 LT |
298 | dprintk("NFS reply mknod: %d\n", status); |
299 | return status; | |
300 | } | |
301 | ||
302 | static int | |
912678db | 303 | nfs_proc_remove(struct inode *dir, struct dentry *dentry) |
1da177e4 | 304 | { |
4fdc17b2 TM |
305 | struct nfs_removeargs arg = { |
306 | .fh = NFS_FH(dir), | |
912678db | 307 | .name = dentry->d_name, |
1da177e4 | 308 | }; |
4fdc17b2 TM |
309 | struct rpc_message msg = { |
310 | .rpc_proc = &nfs_procedures[NFSPROC_REMOVE], | |
311 | .rpc_argp = &arg, | |
1da177e4 LT |
312 | }; |
313 | int status; | |
314 | ||
912678db | 315 | dprintk("NFS call remove %pd2\n",dentry); |
1da177e4 | 316 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 317 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
318 | |
319 | dprintk("NFS reply remove: %d\n", status); | |
320 | return status; | |
321 | } | |
322 | ||
e4eff1a6 | 323 | static void |
977fcc2b | 324 | nfs_proc_unlink_setup(struct rpc_message *msg, struct dentry *dentry) |
1da177e4 | 325 | { |
1da177e4 | 326 | msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE]; |
1da177e4 LT |
327 | } |
328 | ||
34e137cc BS |
329 | static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) |
330 | { | |
331 | rpc_call_start(task); | |
332 | } | |
333 | ||
e4eff1a6 | 334 | static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir) |
1da177e4 | 335 | { |
e4eff1a6 TM |
336 | nfs_mark_for_revalidate(dir); |
337 | return 1; | |
1da177e4 LT |
338 | } |
339 | ||
d3d4152a | 340 | static void |
f2c2c552 TM |
341 | nfs_proc_rename_setup(struct rpc_message *msg, |
342 | struct dentry *old_dentry, | |
343 | struct dentry *new_dentry) | |
d3d4152a JL |
344 | { |
345 | msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME]; | |
346 | } | |
347 | ||
c6bfa1a1 BS |
348 | static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) |
349 | { | |
350 | rpc_call_start(task); | |
351 | } | |
352 | ||
d3d4152a JL |
353 | static int |
354 | nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir, | |
355 | struct inode *new_dir) | |
356 | { | |
d3d4152a JL |
357 | nfs_mark_for_revalidate(old_dir); |
358 | nfs_mark_for_revalidate(new_dir); | |
359 | return 1; | |
360 | } | |
361 | ||
1da177e4 | 362 | static int |
beffb8fe | 363 | nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name) |
1da177e4 LT |
364 | { |
365 | struct nfs_linkargs arg = { | |
366 | .fromfh = NFS_FH(inode), | |
367 | .tofh = NFS_FH(dir), | |
368 | .toname = name->name, | |
369 | .tolen = name->len | |
370 | }; | |
dead28da CL |
371 | struct rpc_message msg = { |
372 | .rpc_proc = &nfs_procedures[NFSPROC_LINK], | |
373 | .rpc_argp = &arg, | |
374 | }; | |
1da177e4 LT |
375 | int status; |
376 | ||
377 | dprintk("NFS call link %s\n", name->name); | |
dead28da | 378 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
5ba7cc48 | 379 | nfs_mark_for_revalidate(inode); |
decf491f | 380 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
381 | dprintk("NFS reply link: %d\n", status); |
382 | return status; | |
383 | } | |
384 | ||
385 | static int | |
94a6d753 CL |
386 | nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, |
387 | unsigned int len, struct iattr *sattr) | |
1da177e4 | 388 | { |
23a30612 TM |
389 | struct nfs_fh *fh; |
390 | struct nfs_fattr *fattr; | |
1da177e4 LT |
391 | struct nfs_symlinkargs arg = { |
392 | .fromfh = NFS_FH(dir), | |
4f390c15 CL |
393 | .fromname = dentry->d_name.name, |
394 | .fromlen = dentry->d_name.len, | |
94a6d753 CL |
395 | .pages = &page, |
396 | .pathlen = len, | |
1da177e4 LT |
397 | .sattr = sattr |
398 | }; | |
dead28da CL |
399 | struct rpc_message msg = { |
400 | .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK], | |
401 | .rpc_argp = &arg, | |
402 | }; | |
23a30612 TM |
403 | int status = -ENAMETOOLONG; |
404 | ||
6de1472f | 405 | dprintk("NFS call symlink %pd\n", dentry); |
1da177e4 | 406 | |
94a6d753 | 407 | if (len > NFS2_MAXPATHLEN) |
23a30612 | 408 | goto out; |
4f390c15 | 409 | |
23a30612 TM |
410 | fh = nfs_alloc_fhandle(); |
411 | fattr = nfs_alloc_fattr(); | |
412 | status = -ENOMEM; | |
413 | if (fh == NULL || fattr == NULL) | |
878215fe | 414 | goto out_free; |
94a6d753 | 415 | |
dead28da | 416 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 417 | nfs_mark_for_revalidate(dir); |
4f390c15 CL |
418 | |
419 | /* | |
420 | * V2 SYMLINK requests don't return any attributes. Setting the | |
421 | * filehandle size to zero indicates to nfs_instantiate that it | |
422 | * should fill in the data with a LOOKUP call on the wire. | |
423 | */ | |
23a30612 | 424 | if (status == 0) |
1775fd3e | 425 | status = nfs_instantiate(dentry, fh, fattr, NULL); |
4f390c15 | 426 | |
878215fe | 427 | out_free: |
23a30612 TM |
428 | nfs_free_fattr(fattr); |
429 | nfs_free_fhandle(fh); | |
430 | out: | |
1da177e4 LT |
431 | dprintk("NFS reply symlink: %d\n", status); |
432 | return status; | |
433 | } | |
434 | ||
435 | static int | |
436 | nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) | |
437 | { | |
eb872f0c | 438 | struct nfs_createdata *data; |
dead28da CL |
439 | struct rpc_message msg = { |
440 | .rpc_proc = &nfs_procedures[NFSPROC_MKDIR], | |
dead28da | 441 | }; |
eb872f0c | 442 | int status = -ENOMEM; |
1da177e4 | 443 | |
6de1472f | 444 | dprintk("NFS call mkdir %pd\n", dentry); |
eb872f0c TM |
445 | data = nfs_alloc_createdata(dir, dentry, sattr); |
446 | if (data == NULL) | |
447 | goto out; | |
448 | msg.rpc_argp = &data->arg; | |
449 | msg.rpc_resp = &data->res; | |
450 | ||
dead28da | 451 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 452 | nfs_mark_for_revalidate(dir); |
1da177e4 | 453 | if (status == 0) |
1775fd3e | 454 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); |
eb872f0c TM |
455 | nfs_free_createdata(data); |
456 | out: | |
1da177e4 LT |
457 | dprintk("NFS reply mkdir: %d\n", status); |
458 | return status; | |
459 | } | |
460 | ||
461 | static int | |
beffb8fe | 462 | nfs_proc_rmdir(struct inode *dir, const struct qstr *name) |
1da177e4 LT |
463 | { |
464 | struct nfs_diropargs arg = { | |
465 | .fh = NFS_FH(dir), | |
466 | .name = name->name, | |
467 | .len = name->len | |
468 | }; | |
dead28da CL |
469 | struct rpc_message msg = { |
470 | .rpc_proc = &nfs_procedures[NFSPROC_RMDIR], | |
471 | .rpc_argp = &arg, | |
472 | }; | |
1da177e4 LT |
473 | int status; |
474 | ||
475 | dprintk("NFS call rmdir %s\n", name->name); | |
dead28da | 476 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 477 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
478 | dprintk("NFS reply rmdir: %d\n", status); |
479 | return status; | |
480 | } | |
481 | ||
482 | /* | |
483 | * The READDIR implementation is somewhat hackish - we pass a temporary | |
484 | * buffer to the encode function, which installs it in the receive | |
485 | * the receive iovec. The decode function just parses the reply to make | |
486 | * sure it is syntactically correct; the entries itself are decoded | |
487 | * from nfs_readdir by calling the decode_entry function directly. | |
488 | */ | |
489 | static int | |
490 | nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, | |
a7a3b1e9 | 491 | u64 cookie, struct page **pages, unsigned int count, bool plus) |
1da177e4 | 492 | { |
2b0143b5 | 493 | struct inode *dir = d_inode(dentry); |
1da177e4 LT |
494 | struct nfs_readdirargs arg = { |
495 | .fh = NFS_FH(dir), | |
496 | .cookie = cookie, | |
497 | .count = count, | |
56e4ebf8 | 498 | .pages = pages, |
1da177e4 LT |
499 | }; |
500 | struct rpc_message msg = { | |
501 | .rpc_proc = &nfs_procedures[NFSPROC_READDIR], | |
502 | .rpc_argp = &arg, | |
dead28da | 503 | .rpc_cred = cred, |
1da177e4 LT |
504 | }; |
505 | int status; | |
506 | ||
1da177e4 LT |
507 | dprintk("NFS call readdir %d\n", (unsigned int)cookie); |
508 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); | |
509 | ||
c4812998 TM |
510 | nfs_invalidate_atime(dir); |
511 | ||
1da177e4 | 512 | dprintk("NFS reply readdir: %d\n", status); |
1da177e4 LT |
513 | return status; |
514 | } | |
515 | ||
516 | static int | |
517 | nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, | |
518 | struct nfs_fsstat *stat) | |
519 | { | |
520 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
521 | struct rpc_message msg = { |
522 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
523 | .rpc_argp = fhandle, | |
524 | .rpc_resp = &fsinfo, | |
525 | }; | |
1da177e4 LT |
526 | int status; |
527 | ||
528 | dprintk("NFS call statfs\n"); | |
0e574af1 | 529 | nfs_fattr_init(stat->fattr); |
dead28da | 530 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
531 | dprintk("NFS reply statfs: %d\n", status); |
532 | if (status) | |
533 | goto out; | |
534 | stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize; | |
535 | stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize; | |
536 | stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize; | |
537 | stat->tfiles = 0; | |
538 | stat->ffiles = 0; | |
539 | stat->afiles = 0; | |
540 | out: | |
541 | return status; | |
542 | } | |
543 | ||
544 | static int | |
545 | nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, | |
546 | struct nfs_fsinfo *info) | |
547 | { | |
548 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
549 | struct rpc_message msg = { |
550 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
551 | .rpc_argp = fhandle, | |
552 | .rpc_resp = &fsinfo, | |
553 | }; | |
1da177e4 LT |
554 | int status; |
555 | ||
556 | dprintk("NFS call fsinfo\n"); | |
0e574af1 | 557 | nfs_fattr_init(info->fattr); |
dead28da | 558 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
559 | dprintk("NFS reply fsinfo: %d\n", status); |
560 | if (status) | |
561 | goto out; | |
562 | info->rtmax = NFS_MAXDATA; | |
563 | info->rtpref = fsinfo.tsize; | |
564 | info->rtmult = fsinfo.bsize; | |
565 | info->wtmax = NFS_MAXDATA; | |
566 | info->wtpref = fsinfo.tsize; | |
567 | info->wtmult = fsinfo.bsize; | |
568 | info->dtpref = fsinfo.tsize; | |
569 | info->maxfilesize = 0x7FFFFFFF; | |
570 | info->lease_time = 0; | |
571 | out: | |
572 | return status; | |
573 | } | |
574 | ||
575 | static int | |
576 | nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, | |
577 | struct nfs_pathconf *info) | |
578 | { | |
579 | info->max_link = 0; | |
580 | info->max_namelen = NFS2_MAXNAMLEN; | |
581 | return 0; | |
582 | } | |
583 | ||
d45f60c6 | 584 | static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) |
1da177e4 | 585 | { |
d45f60c6 | 586 | struct inode *inode = hdr->inode; |
cd841605 | 587 | |
cd841605 | 588 | nfs_invalidate_atime(inode); |
1da177e4 | 589 | if (task->tk_status >= 0) { |
d45f60c6 | 590 | nfs_refresh_inode(inode, hdr->res.fattr); |
1da177e4 LT |
591 | /* Emulate the eof flag, which isn't normally needed in NFSv2 |
592 | * as it is guaranteed to always return the file attributes | |
593 | */ | |
d45f60c6 WAA |
594 | if (hdr->args.offset + hdr->res.count >= hdr->res.fattr->size) |
595 | hdr->res.eof = 1; | |
1da177e4 | 596 | } |
ec06c096 | 597 | return 0; |
1da177e4 LT |
598 | } |
599 | ||
d45f60c6 WAA |
600 | static void nfs_proc_read_setup(struct nfs_pgio_header *hdr, |
601 | struct rpc_message *msg) | |
1da177e4 | 602 | { |
bdc7f021 | 603 | msg->rpc_proc = &nfs_procedures[NFSPROC_READ]; |
1da177e4 LT |
604 | } |
605 | ||
d45f60c6 WAA |
606 | static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task, |
607 | struct nfs_pgio_header *hdr) | |
ea7c3303 BS |
608 | { |
609 | rpc_call_start(task); | |
ef1820f9 | 610 | return 0; |
ea7c3303 BS |
611 | } |
612 | ||
d45f60c6 | 613 | static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) |
1da177e4 | 614 | { |
1da177e4 | 615 | if (task->tk_status >= 0) |
a08a8cd3 | 616 | nfs_writeback_update_inode(hdr); |
788e7a89 | 617 | return 0; |
1da177e4 LT |
618 | } |
619 | ||
d45f60c6 WAA |
620 | static void nfs_proc_write_setup(struct nfs_pgio_header *hdr, |
621 | struct rpc_message *msg) | |
1da177e4 | 622 | { |
1da177e4 | 623 | /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */ |
d45f60c6 | 624 | hdr->args.stable = NFS_FILE_SYNC; |
bdc7f021 | 625 | msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE]; |
1da177e4 LT |
626 | } |
627 | ||
0b7c0153 FI |
628 | static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) |
629 | { | |
630 | BUG(); | |
631 | } | |
632 | ||
1da177e4 | 633 | static void |
0b7c0153 | 634 | nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) |
1da177e4 LT |
635 | { |
636 | BUG(); | |
637 | } | |
638 | ||
639 | static int | |
640 | nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl) | |
641 | { | |
496ad9aa | 642 | struct inode *inode = file_inode(filp); |
1093a60e | 643 | |
b1ece737 | 644 | return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL); |
1da177e4 LT |
645 | } |
646 | ||
2116271a TM |
647 | /* Helper functions for NFS lock bounds checking */ |
648 | #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL) | |
649 | static int nfs_lock_check_bounds(const struct file_lock *fl) | |
650 | { | |
651 | __s32 start, end; | |
652 | ||
653 | start = (__s32)fl->fl_start; | |
654 | if ((loff_t)start != fl->fl_start) | |
655 | goto out_einval; | |
656 | ||
657 | if (fl->fl_end != OFFSET_MAX) { | |
658 | end = (__s32)fl->fl_end; | |
659 | if ((loff_t)end != fl->fl_end) | |
660 | goto out_einval; | |
661 | } else | |
662 | end = NFS_LOCK32_OFFSET_MAX; | |
663 | ||
664 | if (start < 0 || start > end) | |
665 | goto out_einval; | |
666 | return 0; | |
667 | out_einval: | |
668 | return -EINVAL; | |
669 | } | |
1da177e4 | 670 | |
011e2a7f BS |
671 | static int nfs_have_delegation(struct inode *inode, fmode_t flags) |
672 | { | |
673 | return 0; | |
674 | } | |
675 | ||
597d9289 BS |
676 | static const struct inode_operations nfs_dir_inode_operations = { |
677 | .create = nfs_create, | |
678 | .lookup = nfs_lookup, | |
679 | .link = nfs_link, | |
680 | .unlink = nfs_unlink, | |
681 | .symlink = nfs_symlink, | |
682 | .mkdir = nfs_mkdir, | |
683 | .rmdir = nfs_rmdir, | |
684 | .mknod = nfs_mknod, | |
685 | .rename = nfs_rename, | |
686 | .permission = nfs_permission, | |
687 | .getattr = nfs_getattr, | |
688 | .setattr = nfs_setattr, | |
689 | }; | |
690 | ||
691 | static const struct inode_operations nfs_file_inode_operations = { | |
692 | .permission = nfs_permission, | |
693 | .getattr = nfs_getattr, | |
694 | .setattr = nfs_setattr, | |
695 | }; | |
696 | ||
509de811 | 697 | const struct nfs_rpc_ops nfs_v2_clientops = { |
1da177e4 LT |
698 | .version = 2, /* protocol version */ |
699 | .dentry_ops = &nfs_dentry_operations, | |
700 | .dir_inode_ops = &nfs_dir_inode_operations, | |
92cfc62c | 701 | .file_inode_ops = &nfs_file_inode_operations, |
1788ea6e | 702 | .file_ops = &nfs_file_operations, |
1da177e4 | 703 | .getroot = nfs_proc_get_root, |
281cad46 | 704 | .submount = nfs_submount, |
ff9099f2 | 705 | .try_mount = nfs_try_mount, |
1da177e4 LT |
706 | .getattr = nfs_proc_getattr, |
707 | .setattr = nfs_proc_setattr, | |
708 | .lookup = nfs_proc_lookup, | |
709 | .access = NULL, /* access */ | |
710 | .readlink = nfs_proc_readlink, | |
1da177e4 LT |
711 | .create = nfs_proc_create, |
712 | .remove = nfs_proc_remove, | |
713 | .unlink_setup = nfs_proc_unlink_setup, | |
34e137cc | 714 | .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare, |
1da177e4 | 715 | .unlink_done = nfs_proc_unlink_done, |
d3d4152a | 716 | .rename_setup = nfs_proc_rename_setup, |
c6bfa1a1 | 717 | .rename_rpc_prepare = nfs_proc_rename_rpc_prepare, |
d3d4152a | 718 | .rename_done = nfs_proc_rename_done, |
1da177e4 LT |
719 | .link = nfs_proc_link, |
720 | .symlink = nfs_proc_symlink, | |
721 | .mkdir = nfs_proc_mkdir, | |
722 | .rmdir = nfs_proc_rmdir, | |
723 | .readdir = nfs_proc_readdir, | |
724 | .mknod = nfs_proc_mknod, | |
725 | .statfs = nfs_proc_statfs, | |
726 | .fsinfo = nfs_proc_fsinfo, | |
727 | .pathconf = nfs_proc_pathconf, | |
f796f8b3 | 728 | .decode_dirent = nfs2_decode_dirent, |
a4cdda59 | 729 | .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare, |
1da177e4 | 730 | .read_setup = nfs_proc_read_setup, |
ec06c096 | 731 | .read_done = nfs_read_done, |
1da177e4 | 732 | .write_setup = nfs_proc_write_setup, |
788e7a89 | 733 | .write_done = nfs_write_done, |
1da177e4 | 734 | .commit_setup = nfs_proc_commit_setup, |
0b7c0153 | 735 | .commit_rpc_prepare = nfs_proc_commit_rpc_prepare, |
1da177e4 | 736 | .lock = nfs_proc_lock, |
2116271a | 737 | .lock_check_bounds = nfs_lock_check_bounds, |
7fe5c398 | 738 | .close_context = nfs_close_context, |
011e2a7f | 739 | .have_delegation = nfs_have_delegation, |
6663ee7f | 740 | .alloc_client = nfs_alloc_client, |
45a52a02 | 741 | .init_client = nfs_init_client, |
cdb7eced | 742 | .free_client = nfs_free_client, |
1179acc6 BS |
743 | .create_server = nfs_create_server, |
744 | .clone_server = nfs_clone_server, | |
1da177e4 | 745 | }; |