Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
19207231 | 2 | * In-kernel MOUNT protocol client |
1da177e4 LT |
3 | * |
4 | * Copyright (C) 1997, Olaf Kirch <okir@monad.swb.de> | |
5 | */ | |
6 | ||
7 | #include <linux/types.h> | |
8 | #include <linux/socket.h> | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/errno.h> | |
11 | #include <linux/uio.h> | |
12 | #include <linux/net.h> | |
13 | #include <linux/in.h> | |
14 | #include <linux/sunrpc/clnt.h> | |
1da177e4 LT |
15 | #include <linux/sunrpc/sched.h> |
16 | #include <linux/nfs_fs.h> | |
8491945f | 17 | #include "internal.h" |
1da177e4 LT |
18 | |
19 | #ifdef RPC_DEBUG | |
3ea97309 | 20 | # define NFSDBG_FACILITY NFSDBG_MOUNT |
1da177e4 LT |
21 | #endif |
22 | ||
29a1bd6b CL |
23 | /* |
24 | * Defined by RFC 1094, section A.3; and RFC 1813, section 5.1.4 | |
25 | */ | |
26 | #define MNTPATHLEN (1024) | |
27 | ||
28 | /* | |
29 | * XDR data type sizes | |
30 | */ | |
31 | #define encode_dirpath_sz (1 + XDR_QUADLEN(MNTPATHLEN)) | |
fb125295 CL |
32 | #define MNT_status_sz (1) |
33 | #define MNT_fhs_status_sz (1) | |
4fdcd996 CL |
34 | #define MNT_fhandle_sz XDR_QUADLEN(NFS2_FHSIZE) |
35 | #define MNT_fhandle3_sz (1 + XDR_QUADLEN(NFS3_FHSIZE)) | |
a14017db | 36 | #define MNT_authflav3_sz (1 + NFS_MAX_SECFLAVORS) |
29a1bd6b CL |
37 | |
38 | /* | |
39 | * XDR argument and result sizes | |
40 | */ | |
41 | #define MNT_enc_dirpath_sz encode_dirpath_sz | |
42 | ||
2ad78097 CL |
43 | /* |
44 | * Defined by RFC 1094, section A.5 | |
45 | */ | |
46 | enum { | |
47 | MOUNTPROC_NULL = 0, | |
48 | MOUNTPROC_MNT = 1, | |
49 | MOUNTPROC_DUMP = 2, | |
50 | MOUNTPROC_UMNT = 3, | |
51 | MOUNTPROC_UMNTALL = 4, | |
52 | MOUNTPROC_EXPORT = 5, | |
53 | }; | |
54 | ||
55 | /* | |
56 | * Defined by RFC 1813, section 5.2 | |
57 | */ | |
58 | enum { | |
59 | MOUNTPROC3_NULL = 0, | |
60 | MOUNTPROC3_MNT = 1, | |
61 | MOUNTPROC3_DUMP = 2, | |
62 | MOUNTPROC3_UMNT = 3, | |
63 | MOUNTPROC3_UMNTALL = 4, | |
64 | MOUNTPROC3_EXPORT = 5, | |
65 | }; | |
66 | ||
1da177e4 LT |
67 | static struct rpc_program mnt_program; |
68 | ||
fb125295 CL |
69 | /* |
70 | * Defined by OpenGroup XNFS Version 3W, chapter 8 | |
71 | */ | |
72 | enum mountstat { | |
73 | MNT_OK = 0, | |
74 | MNT_EPERM = 1, | |
75 | MNT_ENOENT = 2, | |
76 | MNT_EACCES = 13, | |
77 | MNT_EINVAL = 22, | |
78 | }; | |
79 | ||
80 | static struct { | |
81 | u32 status; | |
82 | int errno; | |
83 | } mnt_errtbl[] = { | |
84 | { .status = MNT_OK, .errno = 0, }, | |
85 | { .status = MNT_EPERM, .errno = -EPERM, }, | |
86 | { .status = MNT_ENOENT, .errno = -ENOENT, }, | |
87 | { .status = MNT_EACCES, .errno = -EACCES, }, | |
88 | { .status = MNT_EINVAL, .errno = -EINVAL, }, | |
89 | }; | |
90 | ||
91 | /* | |
92 | * Defined by RFC 1813, section 5.1.5 | |
93 | */ | |
94 | enum mountstat3 { | |
95 | MNT3_OK = 0, /* no error */ | |
96 | MNT3ERR_PERM = 1, /* Not owner */ | |
97 | MNT3ERR_NOENT = 2, /* No such file or directory */ | |
98 | MNT3ERR_IO = 5, /* I/O error */ | |
99 | MNT3ERR_ACCES = 13, /* Permission denied */ | |
100 | MNT3ERR_NOTDIR = 20, /* Not a directory */ | |
101 | MNT3ERR_INVAL = 22, /* Invalid argument */ | |
102 | MNT3ERR_NAMETOOLONG = 63, /* Filename too long */ | |
103 | MNT3ERR_NOTSUPP = 10004, /* Operation not supported */ | |
104 | MNT3ERR_SERVERFAULT = 10006, /* A failure on the server */ | |
105 | }; | |
106 | ||
107 | static struct { | |
108 | u32 status; | |
109 | int errno; | |
110 | } mnt3_errtbl[] = { | |
111 | { .status = MNT3_OK, .errno = 0, }, | |
112 | { .status = MNT3ERR_PERM, .errno = -EPERM, }, | |
113 | { .status = MNT3ERR_NOENT, .errno = -ENOENT, }, | |
114 | { .status = MNT3ERR_IO, .errno = -EIO, }, | |
115 | { .status = MNT3ERR_ACCES, .errno = -EACCES, }, | |
116 | { .status = MNT3ERR_NOTDIR, .errno = -ENOTDIR, }, | |
117 | { .status = MNT3ERR_INVAL, .errno = -EINVAL, }, | |
118 | { .status = MNT3ERR_NAMETOOLONG, .errno = -ENAMETOOLONG, }, | |
119 | { .status = MNT3ERR_NOTSUPP, .errno = -ENOTSUPP, }, | |
120 | { .status = MNT3ERR_SERVERFAULT, .errno = -ESERVERFAULT, }, | |
121 | }; | |
122 | ||
123 | struct mountres { | |
124 | int errno; | |
125 | struct nfs_fh *fh; | |
a14017db CL |
126 | unsigned int *auth_count; |
127 | rpc_authflavor_t *auth_flavors; | |
fb125295 CL |
128 | }; |
129 | ||
1da177e4 | 130 | struct mnt_fhstatus { |
19207231 CL |
131 | u32 status; |
132 | struct nfs_fh *fh; | |
1da177e4 LT |
133 | }; |
134 | ||
3ea97309 CL |
135 | /** |
136 | * nfs_mount - Obtain an NFS file handle for the given host and path | |
c5d120f8 | 137 | * @info: pointer to mount request arguments |
3ea97309 CL |
138 | * |
139 | * Uses default timeout parameters specified by underlying transport. | |
1da177e4 | 140 | */ |
c5d120f8 | 141 | int nfs_mount(struct nfs_mount_request *info) |
1da177e4 | 142 | { |
1da177e4 | 143 | struct mnt_fhstatus result = { |
c5d120f8 | 144 | .fh = info->fh |
1da177e4 | 145 | }; |
dead28da | 146 | struct rpc_message msg = { |
c5d120f8 | 147 | .rpc_argp = info->dirpath, |
dead28da CL |
148 | .rpc_resp = &result, |
149 | }; | |
3ea97309 | 150 | struct rpc_create_args args = { |
c5d120f8 CL |
151 | .protocol = info->protocol, |
152 | .address = info->sap, | |
153 | .addrsize = info->salen, | |
154 | .servername = info->hostname, | |
3ea97309 | 155 | .program = &mnt_program, |
c5d120f8 | 156 | .version = info->version, |
3ea97309 | 157 | .authflavor = RPC_AUTH_UNIX, |
3ea97309 CL |
158 | }; |
159 | struct rpc_clnt *mnt_clnt; | |
1da177e4 | 160 | int status; |
1da177e4 | 161 | |
3ea97309 | 162 | dprintk("NFS: sending MNT request for %s:%s\n", |
c5d120f8 CL |
163 | (info->hostname ? info->hostname : "server"), |
164 | info->dirpath); | |
1da177e4 | 165 | |
50a737f8 CL |
166 | if (info->noresvport) |
167 | args.flags |= RPC_CLNT_CREATE_NONPRIVPORT; | |
168 | ||
3ea97309 | 169 | mnt_clnt = rpc_create(&args); |
1da177e4 | 170 | if (IS_ERR(mnt_clnt)) |
013a8c1a | 171 | goto out_clnt_err; |
1da177e4 | 172 | |
c5d120f8 | 173 | if (info->version == NFS_MNT3_VERSION) |
dead28da CL |
174 | msg.rpc_proc = &mnt_clnt->cl_procinfo[MOUNTPROC3_MNT]; |
175 | else | |
2ad78097 | 176 | msg.rpc_proc = &mnt_clnt->cl_procinfo[MOUNTPROC_MNT]; |
dead28da CL |
177 | |
178 | status = rpc_call_sync(mnt_clnt, &msg, 0); | |
90c5755f | 179 | rpc_shutdown_client(mnt_clnt); |
013a8c1a CL |
180 | |
181 | if (status < 0) | |
182 | goto out_call_err; | |
183 | if (result.status != 0) | |
184 | goto out_mnt_err; | |
185 | ||
186 | dprintk("NFS: MNT request succeeded\n"); | |
187 | status = 0; | |
188 | ||
189 | out: | |
190 | return status; | |
191 | ||
192 | out_clnt_err: | |
193 | status = PTR_ERR(mnt_clnt); | |
194 | dprintk("NFS: failed to create RPC client, status=%d\n", status); | |
195 | goto out; | |
196 | ||
197 | out_call_err: | |
198 | dprintk("NFS: failed to start MNT request, status=%d\n", status); | |
199 | goto out; | |
200 | ||
201 | out_mnt_err: | |
202 | dprintk("NFS: MNT server returned result %d\n", result.status); | |
8491945f | 203 | status = nfs_stat_to_errno(result.status); |
013a8c1a | 204 | goto out; |
1da177e4 LT |
205 | } |
206 | ||
1da177e4 LT |
207 | /* |
208 | * XDR encode/decode functions for MOUNT | |
209 | */ | |
1da177e4 | 210 | |
29a1bd6b CL |
211 | static int encode_mntdirpath(struct xdr_stream *xdr, const char *pathname) |
212 | { | |
213 | const u32 pathname_len = strlen(pathname); | |
214 | __be32 *p; | |
215 | ||
216 | if (unlikely(pathname_len > MNTPATHLEN)) | |
217 | return -EIO; | |
218 | ||
219 | p = xdr_reserve_space(xdr, sizeof(u32) + pathname_len); | |
220 | if (unlikely(p == NULL)) | |
221 | return -EIO; | |
222 | xdr_encode_opaque(p, pathname, pathname_len); | |
223 | ||
224 | return 0; | |
225 | } | |
226 | ||
227 | static int mnt_enc_dirpath(struct rpc_rqst *req, __be32 *p, | |
228 | const char *dirpath) | |
229 | { | |
230 | struct xdr_stream xdr; | |
231 | ||
232 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
233 | return encode_mntdirpath(&xdr, dirpath); | |
234 | } | |
235 | ||
19207231 CL |
236 | static int xdr_decode_fhstatus(struct rpc_rqst *req, __be32 *p, |
237 | struct mnt_fhstatus *res) | |
1da177e4 LT |
238 | { |
239 | struct nfs_fh *fh = res->fh; | |
240 | ||
241 | if ((res->status = ntohl(*p++)) == 0) { | |
242 | fh->size = NFS2_FHSIZE; | |
243 | memcpy(fh->data, p, NFS2_FHSIZE); | |
244 | } | |
245 | return 0; | |
246 | } | |
247 | ||
fb125295 CL |
248 | /* |
249 | * RFC 1094: "A non-zero status indicates some sort of error. In this | |
250 | * case, the status is a UNIX error number." This can be problematic | |
251 | * if the server and client use different errno values for the same | |
252 | * error. | |
253 | * | |
254 | * However, the OpenGroup XNFS spec provides a simple mapping that is | |
255 | * independent of local errno values on the server and the client. | |
256 | */ | |
257 | static int decode_status(struct xdr_stream *xdr, struct mountres *res) | |
258 | { | |
259 | unsigned int i; | |
260 | u32 status; | |
261 | __be32 *p; | |
262 | ||
263 | p = xdr_inline_decode(xdr, sizeof(status)); | |
264 | if (unlikely(p == NULL)) | |
265 | return -EIO; | |
266 | status = ntohl(*p); | |
267 | ||
268 | for (i = 0; i <= ARRAY_SIZE(mnt_errtbl); i++) { | |
269 | if (mnt_errtbl[i].status == status) { | |
270 | res->errno = mnt_errtbl[i].errno; | |
271 | return 0; | |
272 | } | |
273 | } | |
274 | ||
275 | dprintk("NFS: unrecognized MNT status code: %u\n", status); | |
276 | res->errno = -EACCES; | |
277 | return 0; | |
278 | } | |
279 | ||
4fdcd996 CL |
280 | static int decode_fhandle(struct xdr_stream *xdr, struct mountres *res) |
281 | { | |
282 | struct nfs_fh *fh = res->fh; | |
283 | __be32 *p; | |
284 | ||
285 | p = xdr_inline_decode(xdr, NFS2_FHSIZE); | |
286 | if (unlikely(p == NULL)) | |
287 | return -EIO; | |
288 | ||
289 | fh->size = NFS2_FHSIZE; | |
290 | memcpy(fh->data, p, NFS2_FHSIZE); | |
291 | return 0; | |
292 | } | |
293 | ||
fb125295 CL |
294 | static int decode_fhs_status(struct xdr_stream *xdr, struct mountres *res) |
295 | { | |
296 | unsigned int i; | |
297 | u32 status; | |
298 | __be32 *p; | |
299 | ||
300 | p = xdr_inline_decode(xdr, sizeof(status)); | |
301 | if (unlikely(p == NULL)) | |
302 | return -EIO; | |
303 | status = ntohl(*p); | |
304 | ||
305 | for (i = 0; i <= ARRAY_SIZE(mnt3_errtbl); i++) { | |
306 | if (mnt3_errtbl[i].status == status) { | |
307 | res->errno = mnt3_errtbl[i].errno; | |
308 | return 0; | |
309 | } | |
310 | } | |
311 | ||
312 | dprintk("NFS: unrecognized MNT3 status code: %u\n", status); | |
313 | res->errno = -EACCES; | |
314 | return 0; | |
315 | } | |
316 | ||
4fdcd996 CL |
317 | static int decode_fhandle3(struct xdr_stream *xdr, struct mountres *res) |
318 | { | |
319 | struct nfs_fh *fh = res->fh; | |
320 | u32 size; | |
321 | __be32 *p; | |
322 | ||
323 | p = xdr_inline_decode(xdr, sizeof(size)); | |
324 | if (unlikely(p == NULL)) | |
325 | return -EIO; | |
326 | ||
327 | size = ntohl(*p++); | |
328 | if (size > NFS3_FHSIZE || size == 0) | |
329 | return -EIO; | |
330 | ||
331 | p = xdr_inline_decode(xdr, size); | |
332 | if (unlikely(p == NULL)) | |
333 | return -EIO; | |
334 | ||
335 | fh->size = size; | |
336 | memcpy(fh->data, p, size); | |
337 | return 0; | |
338 | } | |
339 | ||
a14017db CL |
340 | static int decode_auth_flavors(struct xdr_stream *xdr, struct mountres *res) |
341 | { | |
342 | rpc_authflavor_t *flavors = res->auth_flavors; | |
343 | unsigned int *count = res->auth_count; | |
344 | u32 entries, i; | |
345 | __be32 *p; | |
346 | ||
347 | if (*count == 0) | |
348 | return 0; | |
349 | ||
350 | p = xdr_inline_decode(xdr, sizeof(entries)); | |
351 | if (unlikely(p == NULL)) | |
352 | return -EIO; | |
353 | entries = ntohl(*p); | |
354 | dprintk("NFS: received %u auth flavors\n", entries); | |
355 | if (entries > NFS_MAX_SECFLAVORS) | |
356 | entries = NFS_MAX_SECFLAVORS; | |
357 | ||
358 | p = xdr_inline_decode(xdr, sizeof(u32) * entries); | |
359 | if (unlikely(p == NULL)) | |
360 | return -EIO; | |
361 | ||
362 | if (entries > *count) | |
363 | entries = *count; | |
364 | ||
365 | for (i = 0; i < entries; i++) { | |
366 | flavors[i] = ntohl(*p++); | |
367 | dprintk("NFS:\tflavor %u: %d\n", i, flavors[i]); | |
368 | } | |
369 | *count = i; | |
370 | ||
371 | return 0; | |
372 | } | |
373 | ||
19207231 CL |
374 | static int xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p, |
375 | struct mnt_fhstatus *res) | |
1da177e4 LT |
376 | { |
377 | struct nfs_fh *fh = res->fh; | |
b7e24457 | 378 | unsigned size; |
1da177e4 LT |
379 | |
380 | if ((res->status = ntohl(*p++)) == 0) { | |
b7e24457 TM |
381 | size = ntohl(*p++); |
382 | if (size <= NFS3_FHSIZE && size != 0) { | |
1da177e4 LT |
383 | fh->size = size; |
384 | memcpy(fh->data, p, size); | |
385 | } else | |
386 | res->status = -EBADHANDLE; | |
387 | } | |
388 | return 0; | |
389 | } | |
390 | ||
1da177e4 | 391 | #define MNT_fhstatus_sz (1 + 8) |
2bea90d4 | 392 | #define MNT_fhstatus3_sz (1 + 16) |
1da177e4 | 393 | |
19207231 | 394 | static struct rpc_procinfo mnt_procedures[] = { |
2ad78097 CL |
395 | [MOUNTPROC_MNT] = { |
396 | .p_proc = MOUNTPROC_MNT, | |
29a1bd6b | 397 | .p_encode = (kxdrproc_t)mnt_enc_dirpath, |
19207231 | 398 | .p_decode = (kxdrproc_t) xdr_decode_fhstatus, |
29a1bd6b | 399 | .p_arglen = MNT_enc_dirpath_sz, |
19207231 | 400 | .p_replen = MNT_fhstatus_sz, |
2ad78097 | 401 | .p_statidx = MOUNTPROC_MNT, |
19207231 | 402 | .p_name = "MOUNT", |
1da177e4 LT |
403 | }, |
404 | }; | |
405 | ||
406 | static struct rpc_procinfo mnt3_procedures[] = { | |
19207231 CL |
407 | [MOUNTPROC3_MNT] = { |
408 | .p_proc = MOUNTPROC3_MNT, | |
29a1bd6b | 409 | .p_encode = (kxdrproc_t)mnt_enc_dirpath, |
19207231 | 410 | .p_decode = (kxdrproc_t) xdr_decode_fhstatus3, |
29a1bd6b | 411 | .p_arglen = MNT_enc_dirpath_sz, |
19207231 CL |
412 | .p_replen = MNT_fhstatus3_sz, |
413 | .p_statidx = MOUNTPROC3_MNT, | |
414 | .p_name = "MOUNT", | |
1da177e4 LT |
415 | }, |
416 | }; | |
417 | ||
418 | ||
19207231 CL |
419 | static struct rpc_version mnt_version1 = { |
420 | .number = 1, | |
421 | .nrprocs = 2, | |
422 | .procs = mnt_procedures, | |
1da177e4 LT |
423 | }; |
424 | ||
19207231 CL |
425 | static struct rpc_version mnt_version3 = { |
426 | .number = 3, | |
427 | .nrprocs = 2, | |
428 | .procs = mnt3_procedures, | |
1da177e4 LT |
429 | }; |
430 | ||
19207231 | 431 | static struct rpc_version *mnt_version[] = { |
1da177e4 LT |
432 | NULL, |
433 | &mnt_version1, | |
434 | NULL, | |
435 | &mnt_version3, | |
436 | }; | |
437 | ||
19207231 | 438 | static struct rpc_stat mnt_stats; |
1da177e4 | 439 | |
19207231 | 440 | static struct rpc_program mnt_program = { |
1da177e4 LT |
441 | .name = "mount", |
442 | .number = NFS_MNT_PROGRAM, | |
e8c96f8c | 443 | .nrvers = ARRAY_SIZE(mnt_version), |
1da177e4 LT |
444 | .version = mnt_version, |
445 | .stats = &mnt_stats, | |
446 | }; |