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> | |
f7b422b1 | 44 | #include "internal.h" |
1da177e4 LT |
45 | |
46 | #define NFSDBG_FACILITY NFSDBG_PROC | |
47 | ||
97cefcc6 JL |
48 | /* |
49 | * wrapper to handle the -EKEYEXPIRED error message. This should generally | |
50 | * only happen if using krb5 auth and a user's TGT expires. NFSv2 doesn't | |
51 | * support the NFSERR_JUKEBOX error code, but we handle this situation in the | |
52 | * same way that we handle that error with NFSv3. | |
53 | */ | |
54 | static int | |
55 | nfs_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) | |
56 | { | |
57 | int res; | |
58 | do { | |
59 | res = rpc_call_sync(clnt, msg, flags); | |
60 | if (res != -EKEYEXPIRED) | |
61 | break; | |
62 | schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME); | |
63 | res = -ERESTARTSYS; | |
64 | } while (!fatal_signal_pending(current)); | |
65 | return res; | |
66 | } | |
67 | ||
68 | #define rpc_call_sync(clnt, msg, flags) nfs_rpc_wrapper(clnt, msg, flags) | |
69 | ||
70 | static int | |
71 | nfs_async_handle_expired_key(struct rpc_task *task) | |
72 | { | |
73 | if (task->tk_status != -EKEYEXPIRED) | |
74 | return 0; | |
75 | task->tk_status = 0; | |
76 | rpc_restart_call(task); | |
77 | rpc_delay(task, NFS_JUKEBOX_RETRY_TIME); | |
78 | return 1; | |
79 | } | |
80 | ||
1da177e4 LT |
81 | /* |
82 | * Bare-bones access to getattr: this is for nfs_read_super. | |
83 | */ | |
84 | static int | |
85 | nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, | |
86 | struct nfs_fsinfo *info) | |
87 | { | |
88 | struct nfs_fattr *fattr = info->fattr; | |
89 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
90 | struct rpc_message msg = { |
91 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
92 | .rpc_argp = fhandle, | |
93 | .rpc_resp = fattr, | |
94 | }; | |
1da177e4 LT |
95 | int status; |
96 | ||
3110ff80 | 97 | dprintk("%s: call getattr\n", __func__); |
0e574af1 | 98 | nfs_fattr_init(fattr); |
37ca8f5c EK |
99 | status = rpc_call_sync(server->client, &msg, 0); |
100 | /* Retry with default authentication if different */ | |
101 | if (status && server->nfs_client->cl_rpcclient != server->client) | |
102 | status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); | |
3110ff80 | 103 | dprintk("%s: reply getattr: %d\n", __func__, status); |
1da177e4 LT |
104 | if (status) |
105 | return status; | |
3110ff80 | 106 | dprintk("%s: call statfs\n", __func__); |
dead28da CL |
107 | msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS]; |
108 | msg.rpc_resp = &fsinfo; | |
37ca8f5c EK |
109 | status = rpc_call_sync(server->client, &msg, 0); |
110 | /* Retry with default authentication if different */ | |
111 | if (status && server->nfs_client->cl_rpcclient != server->client) | |
112 | status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); | |
3110ff80 | 113 | dprintk("%s: reply statfs: %d\n", __func__, status); |
1da177e4 LT |
114 | if (status) |
115 | return status; | |
116 | info->rtmax = NFS_MAXDATA; | |
117 | info->rtpref = fsinfo.tsize; | |
118 | info->rtmult = fsinfo.bsize; | |
119 | info->wtmax = NFS_MAXDATA; | |
120 | info->wtpref = fsinfo.tsize; | |
121 | info->wtmult = fsinfo.bsize; | |
122 | info->dtpref = fsinfo.tsize; | |
123 | info->maxfilesize = 0x7FFFFFFF; | |
124 | info->lease_time = 0; | |
125 | return 0; | |
126 | } | |
127 | ||
128 | /* | |
129 | * One function for each procedure in the NFS protocol. | |
130 | */ | |
131 | static int | |
132 | nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, | |
133 | struct nfs_fattr *fattr) | |
134 | { | |
dead28da CL |
135 | struct rpc_message msg = { |
136 | .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], | |
137 | .rpc_argp = fhandle, | |
138 | .rpc_resp = fattr, | |
139 | }; | |
1da177e4 LT |
140 | int status; |
141 | ||
142 | dprintk("NFS call getattr\n"); | |
0e574af1 | 143 | nfs_fattr_init(fattr); |
dead28da | 144 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
145 | dprintk("NFS reply getattr: %d\n", status); |
146 | return status; | |
147 | } | |
148 | ||
149 | static int | |
150 | nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, | |
151 | struct iattr *sattr) | |
152 | { | |
153 | struct inode *inode = dentry->d_inode; | |
154 | struct nfs_sattrargs arg = { | |
155 | .fh = NFS_FH(inode), | |
156 | .sattr = sattr | |
157 | }; | |
dead28da CL |
158 | struct rpc_message msg = { |
159 | .rpc_proc = &nfs_procedures[NFSPROC_SETATTR], | |
160 | .rpc_argp = &arg, | |
161 | .rpc_resp = fattr, | |
162 | }; | |
1da177e4 LT |
163 | int status; |
164 | ||
cf3fff54 TM |
165 | /* Mask out the non-modebit related stuff from attr->ia_mode */ |
166 | sattr->ia_mode &= S_IALLUGO; | |
167 | ||
1da177e4 | 168 | dprintk("NFS call setattr\n"); |
659bfcd6 TM |
169 | if (sattr->ia_valid & ATTR_FILE) |
170 | msg.rpc_cred = nfs_file_cred(sattr->ia_file); | |
0e574af1 | 171 | nfs_fattr_init(fattr); |
dead28da | 172 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
65e4308d TM |
173 | if (status == 0) |
174 | nfs_setattr_update_inode(inode, sattr); | |
1da177e4 LT |
175 | dprintk("NFS reply setattr: %d\n", status); |
176 | return status; | |
177 | } | |
178 | ||
179 | static int | |
180 | nfs_proc_lookup(struct inode *dir, struct qstr *name, | |
181 | struct nfs_fh *fhandle, struct nfs_fattr *fattr) | |
182 | { | |
183 | struct nfs_diropargs arg = { | |
184 | .fh = NFS_FH(dir), | |
185 | .name = name->name, | |
186 | .len = name->len | |
187 | }; | |
188 | struct nfs_diropok res = { | |
189 | .fh = fhandle, | |
190 | .fattr = fattr | |
191 | }; | |
dead28da CL |
192 | struct rpc_message msg = { |
193 | .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP], | |
194 | .rpc_argp = &arg, | |
195 | .rpc_resp = &res, | |
196 | }; | |
1da177e4 LT |
197 | int status; |
198 | ||
199 | dprintk("NFS call lookup %s\n", name->name); | |
0e574af1 | 200 | nfs_fattr_init(fattr); |
dead28da | 201 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
202 | dprintk("NFS reply lookup: %d\n", status); |
203 | return status; | |
204 | } | |
205 | ||
206 | static int nfs_proc_readlink(struct inode *inode, struct page *page, | |
207 | unsigned int pgbase, unsigned int pglen) | |
208 | { | |
209 | struct nfs_readlinkargs args = { | |
210 | .fh = NFS_FH(inode), | |
211 | .pgbase = pgbase, | |
212 | .pglen = pglen, | |
213 | .pages = &page | |
214 | }; | |
dead28da CL |
215 | struct rpc_message msg = { |
216 | .rpc_proc = &nfs_procedures[NFSPROC_READLINK], | |
217 | .rpc_argp = &args, | |
218 | }; | |
1da177e4 LT |
219 | int status; |
220 | ||
221 | dprintk("NFS call readlink\n"); | |
dead28da | 222 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
1da177e4 LT |
223 | dprintk("NFS reply readlink: %d\n", status); |
224 | return status; | |
225 | } | |
226 | ||
1da177e4 LT |
227 | static int |
228 | nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
02a913a7 | 229 | int flags, struct nameidata *nd) |
1da177e4 LT |
230 | { |
231 | struct nfs_fh fhandle; | |
232 | struct nfs_fattr fattr; | |
233 | struct nfs_createargs arg = { | |
234 | .fh = NFS_FH(dir), | |
235 | .name = dentry->d_name.name, | |
236 | .len = dentry->d_name.len, | |
237 | .sattr = sattr | |
238 | }; | |
239 | struct nfs_diropok res = { | |
240 | .fh = &fhandle, | |
241 | .fattr = &fattr | |
242 | }; | |
dead28da CL |
243 | struct rpc_message msg = { |
244 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
245 | .rpc_argp = &arg, | |
246 | .rpc_resp = &res, | |
247 | }; | |
1da177e4 LT |
248 | int status; |
249 | ||
0e574af1 | 250 | nfs_fattr_init(&fattr); |
1da177e4 | 251 | dprintk("NFS call create %s\n", dentry->d_name.name); |
dead28da | 252 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
bad2a524 | 253 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
254 | if (status == 0) |
255 | status = nfs_instantiate(dentry, &fhandle, &fattr); | |
256 | dprintk("NFS reply create: %d\n", status); | |
257 | return status; | |
258 | } | |
259 | ||
260 | /* | |
261 | * In NFSv2, mknod is grafted onto the create call. | |
262 | */ | |
263 | static int | |
264 | nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, | |
265 | dev_t rdev) | |
266 | { | |
267 | struct nfs_fh fhandle; | |
268 | struct nfs_fattr fattr; | |
269 | struct nfs_createargs arg = { | |
270 | .fh = NFS_FH(dir), | |
271 | .name = dentry->d_name.name, | |
272 | .len = dentry->d_name.len, | |
273 | .sattr = sattr | |
274 | }; | |
275 | struct nfs_diropok res = { | |
276 | .fh = &fhandle, | |
277 | .fattr = &fattr | |
278 | }; | |
dead28da CL |
279 | struct rpc_message msg = { |
280 | .rpc_proc = &nfs_procedures[NFSPROC_CREATE], | |
281 | .rpc_argp = &arg, | |
282 | .rpc_resp = &res, | |
283 | }; | |
1da177e4 LT |
284 | int status, mode; |
285 | ||
286 | dprintk("NFS call mknod %s\n", dentry->d_name.name); | |
287 | ||
288 | mode = sattr->ia_mode; | |
289 | if (S_ISFIFO(mode)) { | |
290 | sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR; | |
291 | sattr->ia_valid &= ~ATTR_SIZE; | |
292 | } else if (S_ISCHR(mode) || S_ISBLK(mode)) { | |
293 | sattr->ia_valid |= ATTR_SIZE; | |
294 | sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */ | |
295 | } | |
296 | ||
0e574af1 | 297 | nfs_fattr_init(&fattr); |
dead28da | 298 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 299 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
300 | |
301 | if (status == -EINVAL && S_ISFIFO(mode)) { | |
302 | sattr->ia_mode = mode; | |
0e574af1 | 303 | nfs_fattr_init(&fattr); |
dead28da | 304 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
1da177e4 LT |
305 | } |
306 | if (status == 0) | |
307 | status = nfs_instantiate(dentry, &fhandle, &fattr); | |
308 | dprintk("NFS reply mknod: %d\n", status); | |
309 | return status; | |
310 | } | |
311 | ||
312 | static int | |
313 | nfs_proc_remove(struct inode *dir, struct qstr *name) | |
314 | { | |
4fdc17b2 TM |
315 | struct nfs_removeargs arg = { |
316 | .fh = NFS_FH(dir), | |
317 | .name.len = name->len, | |
318 | .name.name = name->name, | |
1da177e4 | 319 | }; |
4fdc17b2 TM |
320 | struct rpc_message msg = { |
321 | .rpc_proc = &nfs_procedures[NFSPROC_REMOVE], | |
322 | .rpc_argp = &arg, | |
1da177e4 LT |
323 | }; |
324 | int status; | |
325 | ||
326 | dprintk("NFS call remove %s\n", name->name); | |
327 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); | |
decf491f | 328 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
329 | |
330 | dprintk("NFS reply remove: %d\n", status); | |
331 | return status; | |
332 | } | |
333 | ||
e4eff1a6 TM |
334 | static void |
335 | nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) | |
1da177e4 | 336 | { |
1da177e4 | 337 | msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE]; |
1da177e4 LT |
338 | } |
339 | ||
e4eff1a6 | 340 | static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir) |
1da177e4 | 341 | { |
97cefcc6 JL |
342 | if (nfs_async_handle_expired_key(task)) |
343 | return 0; | |
e4eff1a6 TM |
344 | nfs_mark_for_revalidate(dir); |
345 | return 1; | |
1da177e4 LT |
346 | } |
347 | ||
348 | static int | |
349 | nfs_proc_rename(struct inode *old_dir, struct qstr *old_name, | |
350 | struct inode *new_dir, struct qstr *new_name) | |
351 | { | |
352 | struct nfs_renameargs arg = { | |
353 | .fromfh = NFS_FH(old_dir), | |
354 | .fromname = old_name->name, | |
355 | .fromlen = old_name->len, | |
356 | .tofh = NFS_FH(new_dir), | |
357 | .toname = new_name->name, | |
358 | .tolen = new_name->len | |
359 | }; | |
dead28da CL |
360 | struct rpc_message msg = { |
361 | .rpc_proc = &nfs_procedures[NFSPROC_RENAME], | |
362 | .rpc_argp = &arg, | |
363 | }; | |
1da177e4 LT |
364 | int status; |
365 | ||
366 | dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); | |
dead28da | 367 | status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); |
decf491f TM |
368 | nfs_mark_for_revalidate(old_dir); |
369 | nfs_mark_for_revalidate(new_dir); | |
1da177e4 LT |
370 | dprintk("NFS reply rename: %d\n", status); |
371 | return status; | |
372 | } | |
373 | ||
374 | static int | |
375 | nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) | |
376 | { | |
377 | struct nfs_linkargs arg = { | |
378 | .fromfh = NFS_FH(inode), | |
379 | .tofh = NFS_FH(dir), | |
380 | .toname = name->name, | |
381 | .tolen = name->len | |
382 | }; | |
dead28da CL |
383 | struct rpc_message msg = { |
384 | .rpc_proc = &nfs_procedures[NFSPROC_LINK], | |
385 | .rpc_argp = &arg, | |
386 | }; | |
1da177e4 LT |
387 | int status; |
388 | ||
389 | dprintk("NFS call link %s\n", name->name); | |
dead28da | 390 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
5ba7cc48 | 391 | nfs_mark_for_revalidate(inode); |
decf491f | 392 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
393 | dprintk("NFS reply link: %d\n", status); |
394 | return status; | |
395 | } | |
396 | ||
397 | static int | |
94a6d753 CL |
398 | nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, |
399 | unsigned int len, struct iattr *sattr) | |
1da177e4 | 400 | { |
4f390c15 CL |
401 | struct nfs_fh fhandle; |
402 | struct nfs_fattr fattr; | |
1da177e4 LT |
403 | struct nfs_symlinkargs arg = { |
404 | .fromfh = NFS_FH(dir), | |
4f390c15 CL |
405 | .fromname = dentry->d_name.name, |
406 | .fromlen = dentry->d_name.len, | |
94a6d753 CL |
407 | .pages = &page, |
408 | .pathlen = len, | |
1da177e4 LT |
409 | .sattr = sattr |
410 | }; | |
dead28da CL |
411 | struct rpc_message msg = { |
412 | .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK], | |
413 | .rpc_argp = &arg, | |
414 | }; | |
1da177e4 LT |
415 | int status; |
416 | ||
94a6d753 | 417 | if (len > NFS2_MAXPATHLEN) |
1da177e4 | 418 | return -ENAMETOOLONG; |
4f390c15 | 419 | |
94a6d753 CL |
420 | dprintk("NFS call symlink %s\n", dentry->d_name.name); |
421 | ||
dead28da | 422 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 423 | nfs_mark_for_revalidate(dir); |
4f390c15 CL |
424 | |
425 | /* | |
426 | * V2 SYMLINK requests don't return any attributes. Setting the | |
427 | * filehandle size to zero indicates to nfs_instantiate that it | |
428 | * should fill in the data with a LOOKUP call on the wire. | |
429 | */ | |
430 | if (status == 0) { | |
431 | nfs_fattr_init(&fattr); | |
432 | fhandle.size = 0; | |
433 | status = nfs_instantiate(dentry, &fhandle, &fattr); | |
434 | } | |
435 | ||
1da177e4 LT |
436 | dprintk("NFS reply symlink: %d\n", status); |
437 | return status; | |
438 | } | |
439 | ||
440 | static int | |
441 | nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) | |
442 | { | |
443 | struct nfs_fh fhandle; | |
444 | struct nfs_fattr fattr; | |
445 | struct nfs_createargs arg = { | |
446 | .fh = NFS_FH(dir), | |
447 | .name = dentry->d_name.name, | |
448 | .len = dentry->d_name.len, | |
449 | .sattr = sattr | |
450 | }; | |
451 | struct nfs_diropok res = { | |
452 | .fh = &fhandle, | |
453 | .fattr = &fattr | |
454 | }; | |
dead28da CL |
455 | struct rpc_message msg = { |
456 | .rpc_proc = &nfs_procedures[NFSPROC_MKDIR], | |
457 | .rpc_argp = &arg, | |
458 | .rpc_resp = &res, | |
459 | }; | |
1da177e4 LT |
460 | int status; |
461 | ||
462 | dprintk("NFS call mkdir %s\n", dentry->d_name.name); | |
0e574af1 | 463 | nfs_fattr_init(&fattr); |
dead28da | 464 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 465 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
466 | if (status == 0) |
467 | status = nfs_instantiate(dentry, &fhandle, &fattr); | |
468 | dprintk("NFS reply mkdir: %d\n", status); | |
469 | return status; | |
470 | } | |
471 | ||
472 | static int | |
473 | nfs_proc_rmdir(struct inode *dir, struct qstr *name) | |
474 | { | |
475 | struct nfs_diropargs arg = { | |
476 | .fh = NFS_FH(dir), | |
477 | .name = name->name, | |
478 | .len = name->len | |
479 | }; | |
dead28da CL |
480 | struct rpc_message msg = { |
481 | .rpc_proc = &nfs_procedures[NFSPROC_RMDIR], | |
482 | .rpc_argp = &arg, | |
483 | }; | |
1da177e4 LT |
484 | int status; |
485 | ||
486 | dprintk("NFS call rmdir %s\n", name->name); | |
dead28da | 487 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
decf491f | 488 | nfs_mark_for_revalidate(dir); |
1da177e4 LT |
489 | dprintk("NFS reply rmdir: %d\n", status); |
490 | return status; | |
491 | } | |
492 | ||
493 | /* | |
494 | * The READDIR implementation is somewhat hackish - we pass a temporary | |
495 | * buffer to the encode function, which installs it in the receive | |
496 | * the receive iovec. The decode function just parses the reply to make | |
497 | * sure it is syntactically correct; the entries itself are decoded | |
498 | * from nfs_readdir by calling the decode_entry function directly. | |
499 | */ | |
500 | static int | |
501 | nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, | |
502 | u64 cookie, struct page *page, unsigned int count, int plus) | |
503 | { | |
504 | struct inode *dir = dentry->d_inode; | |
505 | struct nfs_readdirargs arg = { | |
506 | .fh = NFS_FH(dir), | |
507 | .cookie = cookie, | |
508 | .count = count, | |
dead28da | 509 | .pages = &page, |
1da177e4 LT |
510 | }; |
511 | struct rpc_message msg = { | |
512 | .rpc_proc = &nfs_procedures[NFSPROC_READDIR], | |
513 | .rpc_argp = &arg, | |
dead28da | 514 | .rpc_cred = cred, |
1da177e4 LT |
515 | }; |
516 | int status; | |
517 | ||
1da177e4 LT |
518 | dprintk("NFS call readdir %d\n", (unsigned int)cookie); |
519 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); | |
520 | ||
c4812998 TM |
521 | nfs_invalidate_atime(dir); |
522 | ||
1da177e4 | 523 | dprintk("NFS reply readdir: %d\n", status); |
1da177e4 LT |
524 | return status; |
525 | } | |
526 | ||
527 | static int | |
528 | nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, | |
529 | struct nfs_fsstat *stat) | |
530 | { | |
531 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
532 | struct rpc_message msg = { |
533 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
534 | .rpc_argp = fhandle, | |
535 | .rpc_resp = &fsinfo, | |
536 | }; | |
1da177e4 LT |
537 | int status; |
538 | ||
539 | dprintk("NFS call statfs\n"); | |
0e574af1 | 540 | nfs_fattr_init(stat->fattr); |
dead28da | 541 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
542 | dprintk("NFS reply statfs: %d\n", status); |
543 | if (status) | |
544 | goto out; | |
545 | stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize; | |
546 | stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize; | |
547 | stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize; | |
548 | stat->tfiles = 0; | |
549 | stat->ffiles = 0; | |
550 | stat->afiles = 0; | |
551 | out: | |
552 | return status; | |
553 | } | |
554 | ||
555 | static int | |
556 | nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, | |
557 | struct nfs_fsinfo *info) | |
558 | { | |
559 | struct nfs2_fsstat fsinfo; | |
dead28da CL |
560 | struct rpc_message msg = { |
561 | .rpc_proc = &nfs_procedures[NFSPROC_STATFS], | |
562 | .rpc_argp = fhandle, | |
563 | .rpc_resp = &fsinfo, | |
564 | }; | |
1da177e4 LT |
565 | int status; |
566 | ||
567 | dprintk("NFS call fsinfo\n"); | |
0e574af1 | 568 | nfs_fattr_init(info->fattr); |
dead28da | 569 | status = rpc_call_sync(server->client, &msg, 0); |
1da177e4 LT |
570 | dprintk("NFS reply fsinfo: %d\n", status); |
571 | if (status) | |
572 | goto out; | |
573 | info->rtmax = NFS_MAXDATA; | |
574 | info->rtpref = fsinfo.tsize; | |
575 | info->rtmult = fsinfo.bsize; | |
576 | info->wtmax = NFS_MAXDATA; | |
577 | info->wtpref = fsinfo.tsize; | |
578 | info->wtmult = fsinfo.bsize; | |
579 | info->dtpref = fsinfo.tsize; | |
580 | info->maxfilesize = 0x7FFFFFFF; | |
581 | info->lease_time = 0; | |
582 | out: | |
583 | return status; | |
584 | } | |
585 | ||
586 | static int | |
587 | nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, | |
588 | struct nfs_pathconf *info) | |
589 | { | |
590 | info->max_link = 0; | |
591 | info->max_namelen = NFS2_MAXNAMLEN; | |
592 | return 0; | |
593 | } | |
594 | ||
ec06c096 | 595 | static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data) |
1da177e4 | 596 | { |
97cefcc6 JL |
597 | if (nfs_async_handle_expired_key(task)) |
598 | return -EAGAIN; | |
599 | ||
8850df99 | 600 | nfs_invalidate_atime(data->inode); |
1da177e4 LT |
601 | if (task->tk_status >= 0) { |
602 | nfs_refresh_inode(data->inode, data->res.fattr); | |
603 | /* Emulate the eof flag, which isn't normally needed in NFSv2 | |
604 | * as it is guaranteed to always return the file attributes | |
605 | */ | |
606 | if (data->args.offset + data->args.count >= data->res.fattr->size) | |
607 | data->res.eof = 1; | |
608 | } | |
ec06c096 | 609 | return 0; |
1da177e4 LT |
610 | } |
611 | ||
bdc7f021 | 612 | static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) |
1da177e4 | 613 | { |
bdc7f021 | 614 | msg->rpc_proc = &nfs_procedures[NFSPROC_READ]; |
1da177e4 LT |
615 | } |
616 | ||
788e7a89 | 617 | static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data) |
1da177e4 | 618 | { |
97cefcc6 JL |
619 | if (nfs_async_handle_expired_key(task)) |
620 | return -EAGAIN; | |
621 | ||
1da177e4 | 622 | if (task->tk_status >= 0) |
70ca8852 | 623 | nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr); |
788e7a89 | 624 | return 0; |
1da177e4 LT |
625 | } |
626 | ||
bdc7f021 | 627 | static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) |
1da177e4 | 628 | { |
1da177e4 LT |
629 | /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */ |
630 | data->args.stable = NFS_FILE_SYNC; | |
bdc7f021 | 631 | msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE]; |
1da177e4 LT |
632 | } |
633 | ||
634 | static void | |
bdc7f021 | 635 | nfs_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) |
1da177e4 LT |
636 | { |
637 | BUG(); | |
638 | } | |
639 | ||
640 | static int | |
641 | nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl) | |
642 | { | |
1093a60e CL |
643 | struct inode *inode = filp->f_path.dentry->d_inode; |
644 | ||
645 | return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); | |
1da177e4 LT |
646 | } |
647 | ||
2116271a TM |
648 | /* Helper functions for NFS lock bounds checking */ |
649 | #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL) | |
650 | static int nfs_lock_check_bounds(const struct file_lock *fl) | |
651 | { | |
652 | __s32 start, end; | |
653 | ||
654 | start = (__s32)fl->fl_start; | |
655 | if ((loff_t)start != fl->fl_start) | |
656 | goto out_einval; | |
657 | ||
658 | if (fl->fl_end != OFFSET_MAX) { | |
659 | end = (__s32)fl->fl_end; | |
660 | if ((loff_t)end != fl->fl_end) | |
661 | goto out_einval; | |
662 | } else | |
663 | end = NFS_LOCK32_OFFSET_MAX; | |
664 | ||
665 | if (start < 0 || start > end) | |
666 | goto out_einval; | |
667 | return 0; | |
668 | out_einval: | |
669 | return -EINVAL; | |
670 | } | |
1da177e4 | 671 | |
509de811 | 672 | const struct nfs_rpc_ops nfs_v2_clientops = { |
1da177e4 LT |
673 | .version = 2, /* protocol version */ |
674 | .dentry_ops = &nfs_dentry_operations, | |
675 | .dir_inode_ops = &nfs_dir_inode_operations, | |
92cfc62c | 676 | .file_inode_ops = &nfs_file_inode_operations, |
1da177e4 LT |
677 | .getroot = nfs_proc_get_root, |
678 | .getattr = nfs_proc_getattr, | |
679 | .setattr = nfs_proc_setattr, | |
680 | .lookup = nfs_proc_lookup, | |
681 | .access = NULL, /* access */ | |
682 | .readlink = nfs_proc_readlink, | |
1da177e4 LT |
683 | .create = nfs_proc_create, |
684 | .remove = nfs_proc_remove, | |
685 | .unlink_setup = nfs_proc_unlink_setup, | |
686 | .unlink_done = nfs_proc_unlink_done, | |
687 | .rename = nfs_proc_rename, | |
688 | .link = nfs_proc_link, | |
689 | .symlink = nfs_proc_symlink, | |
690 | .mkdir = nfs_proc_mkdir, | |
691 | .rmdir = nfs_proc_rmdir, | |
692 | .readdir = nfs_proc_readdir, | |
693 | .mknod = nfs_proc_mknod, | |
694 | .statfs = nfs_proc_statfs, | |
695 | .fsinfo = nfs_proc_fsinfo, | |
696 | .pathconf = nfs_proc_pathconf, | |
697 | .decode_dirent = nfs_decode_dirent, | |
698 | .read_setup = nfs_proc_read_setup, | |
ec06c096 | 699 | .read_done = nfs_read_done, |
1da177e4 | 700 | .write_setup = nfs_proc_write_setup, |
788e7a89 | 701 | .write_done = nfs_write_done, |
1da177e4 | 702 | .commit_setup = nfs_proc_commit_setup, |
1da177e4 | 703 | .lock = nfs_proc_lock, |
2116271a | 704 | .lock_check_bounds = nfs_lock_check_bounds, |
7fe5c398 | 705 | .close_context = nfs_close_context, |
1da177e4 | 706 | }; |