Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
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> | |
1da177e4 LT |
32 | #include <linux/time.h> |
33 | #include <linux/mm.h> | |
1da177e4 LT |
34 | #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> | |
d310310c | 44 | #include <linux/freezer.h> |
f7b422b1 | 45 | #include "internal.h" |
1da177e4 LT |
46 | |
47 | #define NFSDBG_FACILITY NFSDBG_PROC | |
48 | ||
97cefcc6 JL |
49 | /* |
50 | * 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 | */ | |
55 | static int | |
56 | nfs_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; | |
d310310c | 63 | freezable_schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME); |
97cefcc6 JL |
64 | 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 | ||
71 | static int | |
72 | nfs_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 | ||
1da177e4 LT |
82 | /* |
83 | * Bare-bones access to getattr: this is for nfs_read_super. | |
84 | */ | |
85 | static int | |
86 | nfs_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; | |
dead28da CL |
91 | struct rpc_message msg = { |
92 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
93 | .rpc_argp = fhandle, | |
94 | .rpc_resp = fattr, | |
95 | }; | |
1da177e4 LT |
96 | int status; |
97 | ||
3110ff80 | 98 | dprintk("%s: call getattr\n", __func__); |
0e574af1 | 99 | nfs_fattr_init(fattr); |
37ca8f5c EK |
100 | 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); | |
3110ff80 | 104 | dprintk("%s: reply getattr: %d\n", __func__, status); |
1da177e4 LT |
105 | if (status) |
106 | return status; | |
3110ff80 | 107 | dprintk("%s: call statfs\n", __func__); |
dead28da CL |
108 | msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS]; |
109 | msg.rpc_resp = &fsinfo; | |
37ca8f5c EK |
110 | 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); | |
3110ff80 | 114 | dprintk("%s: reply statfs: %d\n", __func__, status); |
1da177e4 LT |
115 | 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 | */ | |
132 | static int | |
133 | nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, | |
134 | struct nfs_fattr *fattr) | |
135 | { | |
dead28da CL |
136 | struct rpc_message msg = { |
137 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
138 | .rpc_argp = fhandle, | |
139 | .rpc_resp = fattr, | |
140 | }; | |
1da177e4 LT |
141 | int status; |
142 | ||
143 | dprintk("NFS call getattr\n"); | |
0e574af1 | 144 | nfs_fattr_init(fattr); |
dead28da | 145 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
146 | dprintk("NFS reply getattr: %d\n", status); |
147 | return status; | |
148 | } | |
149 | ||
150 | static int | |
151 | nfs_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 | }; | |
dead28da CL |
159 | struct rpc_message msg = { |
160 | .rpc_proc = &nfs_procedures[NFSPROC_SETATTR], | |
161 | .rpc_argp = &arg, | |
162 | .rpc_resp = fattr, | |
163 | }; | |
1da177e4 LT |
164 | int status; |
165 | ||
cf3fff54 TM |
166 | /* Mask out the non-modebit related stuff from attr->ia_mode */ |
167 | sattr->ia_mode &= S_IALLUGO; | |
168 | ||
1da177e4 | 169 | dprintk("NFS call setattr\n"); |
659bfcd6 TM |
170 | if (sattr->ia_valid & ATTR_FILE) |
171 | msg.rpc_cred = nfs_file_cred(sattr->ia_file); | |
0e574af1 | 172 | nfs_fattr_init(fattr); |
dead28da | 173 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
65e4308d TM |
174 | if (status == 0) |
175 | nfs_setattr_update_inode(inode, sattr); | |
1da177e4 LT |
176 | dprintk("NFS reply setattr: %d\n", status); |
177 | return status; | |
178 | } | |
179 | ||
180 | static int | |
7c513058 | 181 | nfs_proc_lookup(struct rpc_clnt *clnt, struct inode *dir, struct qstr *name, |
1da177e4 LT |
182 | 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 | }; | |
dead28da CL |
193 | struct rpc_message msg = { |
194 | .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP], | |
195 | .rpc_argp = &arg, | |
196 | .rpc_resp = &res, | |
197 | }; | |
1da177e4 LT |
198 | int status; |
199 | ||
200 | dprintk("NFS call lookup %s\n", name->name); | |
0e574af1 | 201 | nfs_fattr_init(fattr); |
dead28da | 202 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
203 | dprintk("NFS reply lookup: %d\n", status); |
204 | return status; | |
205 | } | |
206 | ||
207 | static 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 | }; | |
dead28da CL |
216 | struct rpc_message msg = { |
217 | .rpc_proc = &nfs_procedures[NFSPROC_READLINK], | |
218 | .rpc_argp = &args, | |
219 | }; | |
1da177e4 LT |
220 | int status; |
221 | ||
222 | dprintk("NFS call readlink\n"); | |
dead28da | 223 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
1da177e4 LT |
224 | dprintk("NFS reply readlink: %d\n", status); |
225 | return status; | |
226 | } | |
227 | ||
eb872f0c TM |
228 | struct nfs_createdata { |
229 | struct nfs_createargs arg; | |
230 | struct nfs_diropok res; | |
231 | struct nfs_fh fhandle; | |
232 | struct nfs_fattr fattr; | |
233 | }; | |
234 | ||
235 | static 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 | ||
255 | static void nfs_free_createdata(const struct nfs_createdata *data) | |
256 | { | |
257 | kfree(data); | |
258 | } | |
259 | ||
1da177e4 LT |
260 | static int |
261 | nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
c0204fd2 | 262 | int flags, struct nfs_open_context *ctx) |
1da177e4 | 263 | { |
eb872f0c | 264 | struct nfs_createdata *data; |
dead28da CL |
265 | struct rpc_message msg = { |
266 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
dead28da | 267 | }; |
eb872f0c | 268 | int status = -ENOMEM; |
1da177e4 | 269 | |
1da177e4 | 270 | dprintk("NFS call create %s\n", dentry->d_name.name); |
eb872f0c TM |
271 | 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; | |
dead28da | 276 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
bad2a524 | 277 | nfs_mark_for_revalidate(dir); |
1da177e4 | 278 | if (status == 0) |
eb872f0c TM |
279 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); |
280 | nfs_free_createdata(data); | |
281 | out: | |
1da177e4 LT |
282 | dprintk("NFS reply create: %d\n", status); |
283 | return status; | |
284 | } | |
285 | ||
286 | /* | |
287 | * In NFSv2, mknod is grafted onto the create call. | |
288 | */ | |
289 | static int | |
290 | nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
291 | dev_t rdev) | |
292 | { | |
eb872f0c | 293 | struct nfs_createdata *data; |
dead28da CL |
294 | struct rpc_message msg = { |
295 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
dead28da | 296 | }; |
eb872f0c TM |
297 | umode_t mode; |
298 | int status = -ENOMEM; | |
1da177e4 LT |
299 | |
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 | ||
eb872f0c TM |
311 | 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 | ||
dead28da | 317 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 318 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
319 | |
320 | if (status == -EINVAL && S_ISFIFO(mode)) { | |
321 | sattr->ia_mode = mode; | |
eb872f0c | 322 | nfs_fattr_init(data->res.fattr); |
dead28da | 323 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
324 | } |
325 | if (status == 0) | |
eb872f0c TM |
326 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); |
327 | nfs_free_createdata(data); | |
328 | out: | |
1da177e4 LT |
329 | dprintk("NFS reply mknod: %d\n", status); |
330 | return status; | |
331 | } | |
332 | ||
333 | static int | |
334 | nfs_proc_remove(struct inode *dir, struct qstr *name) | |
335 | { | |
4fdc17b2 TM |
336 | struct nfs_removeargs arg = { |
337 | .fh = NFS_FH(dir), | |
338 | .name.len = name->len, | |
339 | .name.name = name->name, | |
1da177e4 | 340 | }; |
4fdc17b2 TM |
341 | struct rpc_message msg = { |
342 | .rpc_proc = &nfs_procedures[NFSPROC_REMOVE], | |
343 | .rpc_argp = &arg, | |
1da177e4 LT |
344 | }; |
345 | int status; | |
346 | ||
347 | dprintk("NFS call remove %s\n", name->name); | |
348 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); | |
decf491f | 349 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
350 | |
351 | dprintk("NFS reply remove: %d\n", status); | |
352 | return status; | |
353 | } | |
354 | ||
e4eff1a6 TM |
355 | static void |
356 | nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) | |
1da177e4 | 357 | { |
1da177e4 | 358 | msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE]; |
1da177e4 LT |
359 | } |
360 | ||
e4eff1a6 | 361 | static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir) |
1da177e4 | 362 | { |
97cefcc6 JL |
363 | if (nfs_async_handle_expired_key(task)) |
364 | return 0; | |
e4eff1a6 TM |
365 | nfs_mark_for_revalidate(dir); |
366 | return 1; | |
1da177e4 LT |
367 | } |
368 | ||
d3d4152a JL |
369 | static void |
370 | nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir) | |
371 | { | |
372 | msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME]; | |
373 | } | |
374 | ||
375 | static int | |
376 | nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir, | |
377 | struct inode *new_dir) | |
378 | { | |
379 | if (nfs_async_handle_expired_key(task)) | |
380 | return 0; | |
381 | nfs_mark_for_revalidate(old_dir); | |
382 | nfs_mark_for_revalidate(new_dir); | |
383 | return 1; | |
384 | } | |
385 | ||
1da177e4 LT |
386 | static int |
387 | nfs_proc_rename(struct inode *old_dir, struct qstr *old_name, | |
388 | struct inode *new_dir, struct qstr *new_name) | |
389 | { | |
390 | struct nfs_renameargs arg = { | |
920769f0 JL |
391 | .old_dir = NFS_FH(old_dir), |
392 | .old_name = old_name, | |
393 | .new_dir = NFS_FH(new_dir), | |
394 | .new_name = new_name, | |
1da177e4 | 395 | }; |
dead28da CL |
396 | struct rpc_message msg = { |
397 | .rpc_proc = &nfs_procedures[NFSPROC_RENAME], | |
398 | .rpc_argp = &arg, | |
399 | }; | |
1da177e4 LT |
400 | int status; |
401 | ||
402 | dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); | |
dead28da | 403 | status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); |
decf491f TM |
404 | nfs_mark_for_revalidate(old_dir); |
405 | nfs_mark_for_revalidate(new_dir); | |
1da177e4 LT |
406 | dprintk("NFS reply rename: %d\n", status); |
407 | return status; | |
408 | } | |
409 | ||
410 | static int | |
411 | nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) | |
412 | { | |
413 | struct nfs_linkargs arg = { | |
414 | .fromfh = NFS_FH(inode), | |
415 | .tofh = NFS_FH(dir), | |
416 | .toname = name->name, | |
417 | .tolen = name->len | |
418 | }; | |
dead28da CL |
419 | struct rpc_message msg = { |
420 | .rpc_proc = &nfs_procedures[NFSPROC_LINK], | |
421 | .rpc_argp = &arg, | |
422 | }; | |
1da177e4 LT |
423 | int status; |
424 | ||
425 | dprintk("NFS call link %s\n", name->name); | |
dead28da | 426 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
5ba7cc48 | 427 | nfs_mark_for_revalidate(inode); |
decf491f | 428 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
429 | dprintk("NFS reply link: %d\n", status); |
430 | return status; | |
431 | } | |
432 | ||
433 | static int | |
94a6d753 CL |
434 | nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, |
435 | unsigned int len, struct iattr *sattr) | |
1da177e4 | 436 | { |
23a30612 TM |
437 | struct nfs_fh *fh; |
438 | struct nfs_fattr *fattr; | |
1da177e4 LT |
439 | struct nfs_symlinkargs arg = { |
440 | .fromfh = NFS_FH(dir), | |
4f390c15 CL |
441 | .fromname = dentry->d_name.name, |
442 | .fromlen = dentry->d_name.len, | |
94a6d753 CL |
443 | .pages = &page, |
444 | .pathlen = len, | |
1da177e4 LT |
445 | .sattr = sattr |
446 | }; | |
dead28da CL |
447 | struct rpc_message msg = { |
448 | .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK], | |
449 | .rpc_argp = &arg, | |
450 | }; | |
23a30612 TM |
451 | int status = -ENAMETOOLONG; |
452 | ||
453 | dprintk("NFS call symlink %s\n", dentry->d_name.name); | |
1da177e4 | 454 | |
94a6d753 | 455 | if (len > NFS2_MAXPATHLEN) |
23a30612 | 456 | goto out; |
4f390c15 | 457 | |
23a30612 TM |
458 | fh = nfs_alloc_fhandle(); |
459 | fattr = nfs_alloc_fattr(); | |
460 | status = -ENOMEM; | |
461 | if (fh == NULL || fattr == NULL) | |
878215fe | 462 | goto out_free; |
94a6d753 | 463 | |
dead28da | 464 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 465 | nfs_mark_for_revalidate(dir); |
4f390c15 CL |
466 | |
467 | /* | |
468 | * V2 SYMLINK requests don't return any attributes. Setting the | |
469 | * filehandle size to zero indicates to nfs_instantiate that it | |
470 | * should fill in the data with a LOOKUP call on the wire. | |
471 | */ | |
23a30612 TM |
472 | if (status == 0) |
473 | status = nfs_instantiate(dentry, fh, fattr); | |
4f390c15 | 474 | |
878215fe | 475 | out_free: |
23a30612 TM |
476 | nfs_free_fattr(fattr); |
477 | nfs_free_fhandle(fh); | |
478 | out: | |
1da177e4 LT |
479 | dprintk("NFS reply symlink: %d\n", status); |
480 | return status; | |
481 | } | |
482 | ||
483 | static int | |
484 | nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) | |
485 | { | |
eb872f0c | 486 | struct nfs_createdata *data; |
dead28da CL |
487 | struct rpc_message msg = { |
488 | .rpc_proc = &nfs_procedures[NFSPROC_MKDIR], | |
dead28da | 489 | }; |
eb872f0c | 490 | int status = -ENOMEM; |
1da177e4 LT |
491 | |
492 | dprintk("NFS call mkdir %s\n", dentry->d_name.name); | |
eb872f0c TM |
493 | data = nfs_alloc_createdata(dir, dentry, sattr); |
494 | if (data == NULL) | |
495 | goto out; | |
496 | msg.rpc_argp = &data->arg; | |
497 | msg.rpc_resp = &data->res; | |
498 | ||
dead28da | 499 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 500 | nfs_mark_for_revalidate(dir); |
1da177e4 | 501 | if (status == 0) |
eb872f0c TM |
502 | status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); |
503 | nfs_free_createdata(data); | |
504 | out: | |
1da177e4 LT |
505 | dprintk("NFS reply mkdir: %d\n", status); |
506 | return status; | |
507 | } | |
508 | ||
509 | static int | |
510 | nfs_proc_rmdir(struct inode *dir, struct qstr *name) | |
511 | { | |
512 | struct nfs_diropargs arg = { | |
513 | .fh = NFS_FH(dir), | |
514 | .name = name->name, | |
515 | .len = name->len | |
516 | }; | |
dead28da CL |
517 | struct rpc_message msg = { |
518 | .rpc_proc = &nfs_procedures[NFSPROC_RMDIR], | |
519 | .rpc_argp = &arg, | |
520 | }; | |
1da177e4 LT |
521 | int status; |
522 | ||
523 | dprintk("NFS call rmdir %s\n", name->name); | |
dead28da | 524 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 525 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
526 | dprintk("NFS reply rmdir: %d\n", status); |
527 | return status; | |
528 | } | |
529 | ||
530 | /* | |
531 | * The READDIR implementation is somewhat hackish - we pass a temporary | |
532 | * buffer to the encode function, which installs it in the receive | |
533 | * the receive iovec. The decode function just parses the reply to make | |
534 | * sure it is syntactically correct; the entries itself are decoded | |
535 | * from nfs_readdir by calling the decode_entry function directly. | |
536 | */ | |
537 | static int | |
538 | nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, | |
56e4ebf8 | 539 | u64 cookie, struct page **pages, unsigned int count, int plus) |
1da177e4 LT |
540 | { |
541 | struct inode *dir = dentry->d_inode; | |
542 | struct nfs_readdirargs arg = { | |
543 | .fh = NFS_FH(dir), | |
544 | .cookie = cookie, | |
545 | .count = count, | |
56e4ebf8 | 546 | .pages = pages, |
1da177e4 LT |
547 | }; |
548 | struct rpc_message msg = { | |
549 | .rpc_proc = &nfs_procedures[NFSPROC_READDIR], | |
550 | .rpc_argp = &arg, | |
dead28da | 551 | .rpc_cred = cred, |
1da177e4 LT |
552 | }; |
553 | int status; | |
554 | ||
1da177e4 LT |
555 | dprintk("NFS call readdir %d\n", (unsigned int)cookie); |
556 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); | |
557 | ||
c4812998 TM |
558 | nfs_invalidate_atime(dir); |
559 | ||
1da177e4 | 560 | dprintk("NFS reply readdir: %d\n", status); |
1da177e4 LT |
561 | return status; |
562 | } | |
563 | ||
564 | static int | |
565 | nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, | |
566 | struct nfs_fsstat *stat) | |
567 | { | |
568 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
569 | struct rpc_message msg = { |
570 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
571 | .rpc_argp = fhandle, | |
572 | .rpc_resp = &fsinfo, | |
573 | }; | |
1da177e4 LT |
574 | int status; |
575 | ||
576 | dprintk("NFS call statfs\n"); | |
0e574af1 | 577 | nfs_fattr_init(stat->fattr); |
dead28da | 578 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
579 | dprintk("NFS reply statfs: %d\n", status); |
580 | if (status) | |
581 | goto out; | |
582 | stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize; | |
583 | stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize; | |
584 | stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize; | |
585 | stat->tfiles = 0; | |
586 | stat->ffiles = 0; | |
587 | stat->afiles = 0; | |
588 | out: | |
589 | return status; | |
590 | } | |
591 | ||
592 | static int | |
593 | nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, | |
594 | struct nfs_fsinfo *info) | |
595 | { | |
596 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
597 | struct rpc_message msg = { |
598 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
599 | .rpc_argp = fhandle, | |
600 | .rpc_resp = &fsinfo, | |
601 | }; | |
1da177e4 LT |
602 | int status; |
603 | ||
604 | dprintk("NFS call fsinfo\n"); | |
0e574af1 | 605 | nfs_fattr_init(info->fattr); |
dead28da | 606 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
607 | dprintk("NFS reply fsinfo: %d\n", status); |
608 | if (status) | |
609 | goto out; | |
610 | info->rtmax = NFS_MAXDATA; | |
611 | info->rtpref = fsinfo.tsize; | |
612 | info->rtmult = fsinfo.bsize; | |
613 | info->wtmax = NFS_MAXDATA; | |
614 | info->wtpref = fsinfo.tsize; | |
615 | info->wtmult = fsinfo.bsize; | |
616 | info->dtpref = fsinfo.tsize; | |
617 | info->maxfilesize = 0x7FFFFFFF; | |
618 | info->lease_time = 0; | |
619 | out: | |
620 | return status; | |
621 | } | |
622 | ||
623 | static int | |
624 | nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, | |
625 | struct nfs_pathconf *info) | |
626 | { | |
627 | info->max_link = 0; | |
628 | info->max_namelen = NFS2_MAXNAMLEN; | |
629 | return 0; | |
630 | } | |
631 | ||
ec06c096 | 632 | static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data) |
1da177e4 | 633 | { |
97cefcc6 JL |
634 | if (nfs_async_handle_expired_key(task)) |
635 | return -EAGAIN; | |
636 | ||
8850df99 | 637 | nfs_invalidate_atime(data->inode); |
1da177e4 LT |
638 | if (task->tk_status >= 0) { |
639 | nfs_refresh_inode(data->inode, data->res.fattr); | |
640 | /* Emulate the eof flag, which isn't normally needed in NFSv2 | |
641 | * as it is guaranteed to always return the file attributes | |
642 | */ | |
643 | if (data->args.offset + data->args.count >= data->res.fattr->size) | |
644 | data->res.eof = 1; | |
645 | } | |
ec06c096 | 646 | return 0; |
1da177e4 LT |
647 | } |
648 | ||
bdc7f021 | 649 | static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) |
1da177e4 | 650 | { |
bdc7f021 | 651 | msg->rpc_proc = &nfs_procedures[NFSPROC_READ]; |
1da177e4 LT |
652 | } |
653 | ||
ea7c3303 BS |
654 | static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data) |
655 | { | |
656 | rpc_call_start(task); | |
657 | } | |
658 | ||
788e7a89 | 659 | static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data) |
1da177e4 | 660 | { |
97cefcc6 JL |
661 | if (nfs_async_handle_expired_key(task)) |
662 | return -EAGAIN; | |
663 | ||
1da177e4 | 664 | if (task->tk_status >= 0) |
70ca8852 | 665 | nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr); |
788e7a89 | 666 | return 0; |
1da177e4 LT |
667 | } |
668 | ||
bdc7f021 | 669 | static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) |
1da177e4 | 670 | { |
1da177e4 LT |
671 | /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */ |
672 | data->args.stable = NFS_FILE_SYNC; | |
bdc7f021 | 673 | msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE]; |
1da177e4 LT |
674 | } |
675 | ||
c6cb80d0 BS |
676 | static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data) |
677 | { | |
678 | rpc_call_start(task); | |
679 | } | |
680 | ||
1da177e4 | 681 | static void |
bdc7f021 | 682 | nfs_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) |
1da177e4 LT |
683 | { |
684 | BUG(); | |
685 | } | |
686 | ||
687 | static int | |
688 | nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl) | |
689 | { | |
1093a60e CL |
690 | struct inode *inode = filp->f_path.dentry->d_inode; |
691 | ||
692 | return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); | |
1da177e4 LT |
693 | } |
694 | ||
2116271a TM |
695 | /* Helper functions for NFS lock bounds checking */ |
696 | #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL) | |
697 | static int nfs_lock_check_bounds(const struct file_lock *fl) | |
698 | { | |
699 | __s32 start, end; | |
700 | ||
701 | start = (__s32)fl->fl_start; | |
702 | if ((loff_t)start != fl->fl_start) | |
703 | goto out_einval; | |
704 | ||
705 | if (fl->fl_end != OFFSET_MAX) { | |
706 | end = (__s32)fl->fl_end; | |
707 | if ((loff_t)end != fl->fl_end) | |
708 | goto out_einval; | |
709 | } else | |
710 | end = NFS_LOCK32_OFFSET_MAX; | |
711 | ||
712 | if (start < 0 || start > end) | |
713 | goto out_einval; | |
714 | return 0; | |
715 | out_einval: | |
716 | return -EINVAL; | |
717 | } | |
1da177e4 | 718 | |
509de811 | 719 | const struct nfs_rpc_ops nfs_v2_clientops = { |
1da177e4 LT |
720 | .version = 2, /* protocol version */ |
721 | .dentry_ops = &nfs_dentry_operations, | |
722 | .dir_inode_ops = &nfs_dir_inode_operations, | |
92cfc62c | 723 | .file_inode_ops = &nfs_file_inode_operations, |
1788ea6e | 724 | .file_ops = &nfs_file_operations, |
1da177e4 LT |
725 | .getroot = nfs_proc_get_root, |
726 | .getattr = nfs_proc_getattr, | |
727 | .setattr = nfs_proc_setattr, | |
728 | .lookup = nfs_proc_lookup, | |
729 | .access = NULL, /* access */ | |
730 | .readlink = nfs_proc_readlink, | |
1da177e4 LT |
731 | .create = nfs_proc_create, |
732 | .remove = nfs_proc_remove, | |
733 | .unlink_setup = nfs_proc_unlink_setup, | |
734 | .unlink_done = nfs_proc_unlink_done, | |
735 | .rename = nfs_proc_rename, | |
d3d4152a JL |
736 | .rename_setup = nfs_proc_rename_setup, |
737 | .rename_done = nfs_proc_rename_done, | |
1da177e4 LT |
738 | .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, | |
f796f8b3 | 747 | .decode_dirent = nfs2_decode_dirent, |
1da177e4 | 748 | .read_setup = nfs_proc_read_setup, |
ea7c3303 | 749 | .read_rpc_prepare = nfs_proc_read_rpc_prepare, |
ec06c096 | 750 | .read_done = nfs_read_done, |
1da177e4 | 751 | .write_setup = nfs_proc_write_setup, |
c6cb80d0 | 752 | .write_rpc_prepare = nfs_proc_write_rpc_prepare, |
788e7a89 | 753 | .write_done = nfs_write_done, |
1da177e4 | 754 | .commit_setup = nfs_proc_commit_setup, |
1da177e4 | 755 | .lock = nfs_proc_lock, |
2116271a | 756 | .lock_check_bounds = nfs_lock_check_bounds, |
7fe5c398 | 757 | .close_context = nfs_close_context, |
45a52a02 | 758 | .init_client = nfs_init_client, |
1da177e4 | 759 | }; |