1 | /* $NetBSD: coda_venus.c,v 1.30 2013/10/17 20:56:02 christos Exp $ */ |
2 | |
3 | /* |
4 | * |
5 | * Coda: an Experimental Distributed File System |
6 | * Release 3.1 |
7 | * |
8 | * Copyright (c) 1987-1998 Carnegie Mellon University |
9 | * All Rights Reserved |
10 | * |
11 | * Permission to use, copy, modify and distribute this software and its |
12 | * documentation is hereby granted, provided that both the copyright |
13 | * notice and this permission notice appear in all copies of the |
14 | * software, derivative works or modified versions, and any portions |
15 | * thereof, and that both notices appear in supporting documentation, and |
16 | * that credit is given to Carnegie Mellon University in all documents |
17 | * and publicity pertaining to direct or indirect use of this code or its |
18 | * derivatives. |
19 | * |
20 | * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS, |
21 | * SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS |
22 | * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON |
23 | * DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER |
24 | * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF |
25 | * ANY DERIVATIVE WORK. |
26 | * |
27 | * Carnegie Mellon encourages users of this software to return any |
28 | * improvements or extensions that they make, and to grant Carnegie |
29 | * Mellon the rights to redistribute these changes without encumbrance. |
30 | * |
31 | * @(#) coda/coda_venus.c,v 1.1.1.1 1998/08/29 21:26:45 rvb Exp $ |
32 | */ |
33 | |
34 | #include <sys/cdefs.h> |
35 | __KERNEL_RCSID(0, "$NetBSD: coda_venus.c,v 1.30 2013/10/17 20:56:02 christos Exp $" ); |
36 | |
37 | #include <sys/param.h> |
38 | #include <sys/systm.h> |
39 | #include <sys/malloc.h> |
40 | #include <sys/proc.h> |
41 | #include <sys/select.h> |
42 | #include <sys/ioctl.h> |
43 | /* for CNV_OFLAGS below */ |
44 | #include <sys/fcntl.h> |
45 | #include <sys/kauth.h> |
46 | |
47 | #include <coda/coda.h> |
48 | #include <coda/cnode.h> |
49 | #include <coda/coda_venus.h> |
50 | #include <coda/coda_pioctl.h> |
51 | |
52 | #ifdef _KERNEL_OPT |
53 | #include "opt_coda_compat.h" |
54 | #endif |
55 | |
56 | /* |
57 | * Isize and Osize are the sizes of the input and output arguments. |
58 | * SEMI-INVARIANT: name##_size (e.g. coda_readlink_size) is the max of |
59 | * the input and output. This invariant is not well maintained, but |
60 | * should be true after ALLOC_*. Isize is modified after allocation |
61 | * by STRCPY below - this is in general unsafe and needs fixing. |
62 | */ |
63 | |
64 | #define DECL_NO_IN(name) \ |
65 | struct coda_in_hdr *inp; \ |
66 | struct name ## _out *outp; \ |
67 | int name ## _size = sizeof (struct coda_in_hdr); \ |
68 | int Isize = sizeof (struct coda_in_hdr); \ |
69 | int Osize = sizeof (struct name ## _out); \ |
70 | int error |
71 | |
72 | #define DECL(name) \ |
73 | struct name ## _in *inp; \ |
74 | struct name ## _out *outp; \ |
75 | int name ## _size = sizeof (struct name ## _in); \ |
76 | int Isize = sizeof (struct name ## _in); \ |
77 | int Osize = sizeof (struct name ## _out); \ |
78 | int error |
79 | |
80 | #define DECL_NO_OUT(name) \ |
81 | struct name ## _in *inp; \ |
82 | int name ## _size = sizeof (struct name ## _in); \ |
83 | int Isize = sizeof (struct name ## _in); \ |
84 | int Osize = sizeof (struct coda_out_hdr); \ |
85 | int error |
86 | |
87 | #define ALLOC_NO_IN(name) \ |
88 | if (Osize > name ## _size) \ |
89 | name ## _size = Osize; \ |
90 | CODA_ALLOC(inp, struct coda_in_hdr *, name ## _size);\ |
91 | outp = (struct name ## _out *) inp |
92 | |
93 | #define ALLOC(name) \ |
94 | if (Osize > name ## _size) \ |
95 | name ## _size = Osize; \ |
96 | CODA_ALLOC(inp, struct name ## _in *, name ## _size);\ |
97 | outp = (struct name ## _out *) inp |
98 | |
99 | #define ALLOC_NO_OUT(name) \ |
100 | if (Osize > name ## _size) \ |
101 | name ## _size = Osize; \ |
102 | CODA_ALLOC(inp, struct name ## _in *, name ## _size);\ |
103 | |
104 | #define STRCPY(struc, name, len) \ |
105 | memcpy((char *)inp + (int)inp->struc, name, len); \ |
106 | ((char*)inp + (int)inp->struc)[len++] = 0; \ |
107 | Isize += len |
108 | /* XXX verify that Isize has not overrun available storage */ |
109 | |
110 | #ifdef CODA_COMPAT_5 |
111 | |
112 | #define INIT_IN(in, op, ident, p) \ |
113 | (in)->opcode = (op); \ |
114 | (in)->pid = p ? p->p_pid : -1; \ |
115 | (in)->pgid = p ? p->p_pgid : -1; \ |
116 | (in)->sid = (p && p->p_session && p->p_session->s_leader) ? \ |
117 | (p->p_session->s_leader->p_pid) : -1; \ |
118 | KASSERT(cred != NULL); \ |
119 | KASSERT(cred != FSCRED); \ |
120 | if (ident != NOCRED) { \ |
121 | (in)->cred.cr_uid = kauth_cred_geteuid(ident); \ |
122 | (in)->cred.cr_groupid = kauth_cred_getegid(ident); \ |
123 | } else { \ |
124 | memset(&((in)->cred), 0, sizeof(struct coda_cred)); \ |
125 | (in)->cred.cr_uid = -1; \ |
126 | (in)->cred.cr_groupid = -1; \ |
127 | } \ |
128 | |
129 | #else |
130 | |
131 | #define INIT_IN(in, op, ident, p) \ |
132 | (in)->opcode = (op); \ |
133 | (in)->pid = p ? p->p_pid : -1; \ |
134 | (in)->pgid = p ? p->p_pgid : -1; \ |
135 | KASSERT(cred != NULL); \ |
136 | KASSERT(cred != FSCRED); \ |
137 | if (ident != NOCRED) { \ |
138 | (in)->uid = kauth_cred_geteuid(ident); \ |
139 | } else { \ |
140 | (in)->uid = -1; \ |
141 | } \ |
142 | |
143 | #endif |
144 | |
145 | #define INIT_IN_L(in, op, ident, l) \ |
146 | INIT_IN(in, op, ident, (l ? l->l_proc : NULL)) |
147 | |
148 | #define CNV_OFLAG(to, from) \ |
149 | do { \ |
150 | to = 0; \ |
151 | if (from & FREAD) to |= C_O_READ; \ |
152 | if (from & FWRITE) to |= C_O_WRITE; \ |
153 | if (from & O_TRUNC) to |= C_O_TRUNC; \ |
154 | if (from & O_EXCL) to |= C_O_EXCL; \ |
155 | if (from & O_CREAT) to |= C_O_CREAT; \ |
156 | } while (/*CONSTCOND*/ 0) |
157 | |
158 | #define CNV_VV2V_ATTR(top, fromp) \ |
159 | do { \ |
160 | (top)->va_type = (fromp)->va_type; \ |
161 | (top)->va_mode = (fromp)->va_mode; \ |
162 | (top)->va_nlink = (fromp)->va_nlink; \ |
163 | (top)->va_uid = (fromp)->va_uid; \ |
164 | (top)->va_gid = (fromp)->va_gid; \ |
165 | (top)->va_fsid = VNOVAL; \ |
166 | (top)->va_fileid = (fromp)->va_fileid; \ |
167 | (top)->va_size = (fromp)->va_size; \ |
168 | (top)->va_blocksize = (fromp)->va_blocksize; \ |
169 | (top)->va_atime = (fromp)->va_atime; \ |
170 | (top)->va_mtime = (fromp)->va_mtime; \ |
171 | (top)->va_ctime = (fromp)->va_ctime; \ |
172 | (top)->va_gen = (fromp)->va_gen; \ |
173 | (top)->va_flags = (fromp)->va_flags; \ |
174 | (top)->va_rdev = (fromp)->va_rdev; \ |
175 | (top)->va_bytes = (fromp)->va_bytes; \ |
176 | (top)->va_filerev = (fromp)->va_filerev; \ |
177 | (top)->va_vaflags = VNOVAL; \ |
178 | (top)->va_spare = VNOVAL; \ |
179 | } while (/*CONSTCOND*/ 0) |
180 | |
181 | #define CNV_V2VV_ATTR(top, fromp) \ |
182 | do { \ |
183 | (top)->va_type = (fromp)->va_type; \ |
184 | (top)->va_mode = (fromp)->va_mode; \ |
185 | (top)->va_nlink = (fromp)->va_nlink; \ |
186 | (top)->va_uid = (fromp)->va_uid; \ |
187 | (top)->va_gid = (fromp)->va_gid; \ |
188 | (top)->va_fileid = (fromp)->va_fileid; \ |
189 | (top)->va_size = (fromp)->va_size; \ |
190 | (top)->va_blocksize = (fromp)->va_blocksize; \ |
191 | (top)->va_atime = (fromp)->va_atime; \ |
192 | (top)->va_mtime = (fromp)->va_mtime; \ |
193 | (top)->va_ctime = (fromp)->va_ctime; \ |
194 | (top)->va_gen = (fromp)->va_gen; \ |
195 | (top)->va_flags = (fromp)->va_flags; \ |
196 | (top)->va_rdev = (fromp)->va_rdev; \ |
197 | (top)->va_bytes = (fromp)->va_bytes; \ |
198 | (top)->va_filerev = (fromp)->va_filerev; \ |
199 | } while (/*CONSTCOND*/ 0) |
200 | |
201 | |
202 | int |
203 | venus_root(void *mdp, |
204 | kauth_cred_t cred, struct proc *p, |
205 | /*out*/ CodaFid *VFid) |
206 | { |
207 | DECL_NO_IN(coda_root); /* sets Isize & Osize */ |
208 | ALLOC_NO_IN(coda_root); /* sets inp & outp */ |
209 | |
210 | /* send the open to venus. */ |
211 | INIT_IN(inp, CODA_ROOT, cred, p); |
212 | |
213 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
214 | if (!error) |
215 | *VFid = outp->Fid; |
216 | |
217 | CODA_FREE(inp, coda_root_size); |
218 | return error; |
219 | } |
220 | |
221 | int |
222 | venus_open(void *mdp, CodaFid *fid, int flag, |
223 | kauth_cred_t cred, struct lwp *l, |
224 | /*out*/ dev_t *dev, ino_t *inode) |
225 | { |
226 | int cflag; |
227 | DECL(coda_open); /* sets Isize & Osize */ |
228 | ALLOC(coda_open); /* sets inp & outp */ |
229 | |
230 | /* send the open to venus. */ |
231 | INIT_IN_L(&inp->ih, CODA_OPEN, cred, l); |
232 | inp->Fid = *fid; |
233 | CNV_OFLAG(cflag, flag); |
234 | inp->flags = cflag; |
235 | |
236 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
237 | KASSERT(outp != NULL); |
238 | if (!error) { |
239 | *dev = outp->dev; |
240 | *inode = outp->inode; |
241 | } |
242 | |
243 | CODA_FREE(inp, coda_open_size); |
244 | return error; |
245 | } |
246 | |
247 | int |
248 | venus_close(void *mdp, CodaFid *fid, int flag, |
249 | kauth_cred_t cred, struct lwp *l) |
250 | { |
251 | int cflag; |
252 | DECL_NO_OUT(coda_close); /* sets Isize & Osize */ |
253 | ALLOC_NO_OUT(coda_close); /* sets inp & outp */ |
254 | |
255 | INIT_IN_L(&inp->ih, CODA_CLOSE, cred, l); |
256 | inp->Fid = *fid; |
257 | CNV_OFLAG(cflag, flag); |
258 | inp->flags = cflag; |
259 | |
260 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
261 | |
262 | CODA_FREE(inp, coda_close_size); |
263 | return error; |
264 | } |
265 | |
266 | /* |
267 | * these two calls will not exist!!! the container file is read/written |
268 | * directly. |
269 | */ |
270 | void |
271 | venus_read(void) |
272 | { |
273 | } |
274 | |
275 | void |
276 | venus_write(void) |
277 | { |
278 | } |
279 | |
280 | /* |
281 | * this is a bit sad too. the ioctl's are for the control file, not for |
282 | * normal files. |
283 | */ |
284 | int |
285 | venus_ioctl(void *mdp, CodaFid *fid, |
286 | int com, int flag, void *data, |
287 | kauth_cred_t cred, struct lwp *l) |
288 | { |
289 | DECL(coda_ioctl); /* sets Isize & Osize */ |
290 | struct PioctlData *iap = (struct PioctlData *)data; |
291 | int tmp; |
292 | |
293 | coda_ioctl_size = VC_MAXMSGSIZE; |
294 | ALLOC(coda_ioctl); /* sets inp & outp */ |
295 | |
296 | INIT_IN_L(&inp->ih, CODA_IOCTL, cred, l); |
297 | inp->Fid = *fid; |
298 | |
299 | /* command was mutated by increasing its size field to reflect the |
300 | * path and follow args. we need to subtract that out before sending |
301 | * the command to venus. |
302 | */ |
303 | inp->cmd = (com & ~(IOCPARM_MASK << 16)); |
304 | tmp = ((com >> 16) & IOCPARM_MASK) - sizeof (char *) - sizeof (int); |
305 | inp->cmd |= (tmp & IOCPARM_MASK) << 16; |
306 | |
307 | if (iap->vi.in_size > VC_MAXMSGSIZE || iap->vi.out_size > VC_MAXMSGSIZE) { |
308 | CODA_FREE(inp, coda_ioctl_size); |
309 | return (EINVAL); |
310 | } |
311 | |
312 | inp->rwflag = flag; |
313 | inp->len = iap->vi.in_size; |
314 | inp->data = (char *)(sizeof (struct coda_ioctl_in)); |
315 | |
316 | error = copyin(iap->vi.in, (char*)inp + (int)(long)inp->data, |
317 | iap->vi.in_size); |
318 | if (error) { |
319 | CODA_FREE(inp, coda_ioctl_size); |
320 | return(error); |
321 | } |
322 | |
323 | Osize = VC_MAXMSGSIZE; |
324 | error = coda_call(mdp, Isize + iap->vi.in_size, &Osize, (char *)inp); |
325 | |
326 | /* copy out the out buffer. */ |
327 | if (!error) { |
328 | if (outp->len > iap->vi.out_size) { |
329 | error = EINVAL; |
330 | } else { |
331 | error = copyout((char *)outp + (int)(long)outp->data, |
332 | iap->vi.out, iap->vi.out_size); |
333 | } |
334 | } |
335 | |
336 | CODA_FREE(inp, coda_ioctl_size); |
337 | return error; |
338 | } |
339 | |
340 | int |
341 | venus_getattr(void *mdp, CodaFid *fid, |
342 | kauth_cred_t cred, struct lwp *l, |
343 | /*out*/ struct vattr *vap) |
344 | { |
345 | DECL(coda_getattr); /* sets Isize & Osize */ |
346 | ALLOC(coda_getattr); /* sets inp & outp */ |
347 | |
348 | /* send the open to venus. */ |
349 | INIT_IN_L(&inp->ih, CODA_GETATTR, cred, l); |
350 | inp->Fid = *fid; |
351 | |
352 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
353 | if (!error) { |
354 | CNV_VV2V_ATTR(vap, &outp->attr); |
355 | } |
356 | |
357 | CODA_FREE(inp, coda_getattr_size); |
358 | return error; |
359 | } |
360 | |
361 | int |
362 | venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap, |
363 | kauth_cred_t cred, struct lwp *l) |
364 | { |
365 | DECL_NO_OUT(coda_setattr); /* sets Isize & Osize */ |
366 | ALLOC_NO_OUT(coda_setattr); /* sets inp & outp */ |
367 | |
368 | /* send the open to venus. */ |
369 | INIT_IN_L(&inp->ih, CODA_SETATTR, cred, l); |
370 | inp->Fid = *fid; |
371 | CNV_V2VV_ATTR(&inp->attr, vap); |
372 | |
373 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
374 | |
375 | CODA_FREE(inp, coda_setattr_size); |
376 | return error; |
377 | } |
378 | |
379 | int |
380 | venus_access(void *mdp, CodaFid *fid, int mode, |
381 | kauth_cred_t cred, struct lwp *l) |
382 | { |
383 | DECL_NO_OUT(coda_access); /* sets Isize & Osize */ |
384 | ALLOC_NO_OUT(coda_access); /* sets inp & outp */ |
385 | |
386 | /* send the open to venus. */ |
387 | INIT_IN_L(&inp->ih, CODA_ACCESS, cred, l); |
388 | inp->Fid = *fid; |
389 | inp->flags = mode; |
390 | |
391 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
392 | |
393 | CODA_FREE(inp, coda_access_size); |
394 | return error; |
395 | } |
396 | |
397 | int |
398 | venus_readlink(void *mdp, CodaFid *fid, |
399 | kauth_cred_t cred, struct lwp *l, |
400 | /*out*/ char **str, int *len) |
401 | { |
402 | DECL(coda_readlink); /* sets Isize & Osize */ |
403 | /* XXX coda_readlink_size should not be set here */ |
404 | coda_readlink_size += CODA_MAXPATHLEN; |
405 | Osize += CODA_MAXPATHLEN; |
406 | ALLOC(coda_readlink); /* sets inp & outp */ |
407 | |
408 | /* send the open to venus. */ |
409 | INIT_IN_L(&inp->ih, CODA_READLINK, cred, l); |
410 | inp->Fid = *fid; |
411 | |
412 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
413 | KASSERT(outp != NULL); |
414 | if (error != 0) |
415 | goto out; |
416 | |
417 | /* Check count for reasonableness */ |
418 | if (outp->count <= 0 || outp->count > CODA_MAXPATHLEN) { |
419 | printf("venus_readlink: bad count %d\n" , outp->count); |
420 | error = EINVAL; |
421 | goto out; |
422 | } |
423 | |
424 | /* |
425 | * Check data pointer for reasonableness. It must point after |
426 | * itself, and within the allocated region. |
427 | */ |
428 | if ((intptr_t) outp->data < sizeof(struct coda_readlink_out) ) { |
429 | printf("venus_readlink: data pointer %lld too low\n" , |
430 | (long long)((intptr_t) outp->data)); |
431 | error = EINVAL; |
432 | goto out; |
433 | } |
434 | |
435 | if ((intptr_t) outp->data + outp->count > |
436 | sizeof(struct coda_readlink_out) + CODA_MAXPATHLEN) { |
437 | printf("venus_readlink: data pointer %lld too high\n" , |
438 | (long long)((intptr_t) outp->data)); |
439 | error = EINVAL; |
440 | goto out; |
441 | } |
442 | |
443 | if (!error) { |
444 | CODA_ALLOC(*str, char *, outp->count); |
445 | *len = outp->count; |
446 | memcpy(*str, (char *)outp + (int)(long)outp->data, *len); |
447 | } |
448 | |
449 | out: |
450 | CODA_FREE(inp, coda_readlink_size); |
451 | return error; |
452 | } |
453 | |
454 | int |
455 | venus_fsync(void *mdp, CodaFid *fid, |
456 | kauth_cred_t cred, struct lwp *l) |
457 | { |
458 | DECL_NO_OUT(coda_fsync); /* sets Isize & Osize */ |
459 | ALLOC_NO_OUT(coda_fsync); /* sets inp & outp */ |
460 | |
461 | /* send the open to venus. */ |
462 | INIT_IN_L(&inp->ih, CODA_FSYNC, cred, l); |
463 | inp->Fid = *fid; |
464 | |
465 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
466 | |
467 | CODA_FREE(inp, coda_fsync_size); |
468 | return error; |
469 | } |
470 | |
471 | int |
472 | venus_lookup(void *mdp, CodaFid *fid, |
473 | const char *nm, int len, |
474 | kauth_cred_t cred, struct lwp *l, |
475 | /*out*/ CodaFid *VFid, int *vtype) |
476 | { |
477 | DECL(coda_lookup); /* sets Isize & Osize */ |
478 | coda_lookup_size += len + 1; |
479 | ALLOC(coda_lookup); /* sets inp & outp */ |
480 | |
481 | /* send the open to venus. */ |
482 | INIT_IN_L(&inp->ih, CODA_LOOKUP, cred, l); |
483 | inp->Fid = *fid; |
484 | |
485 | /* NOTE: |
486 | * Between version 1 and version 2 we have added an extra flag field |
487 | * to this structure. But because the string was at the end and because |
488 | * of the weird way we represent strings by having the slot point to |
489 | * where the string characters are in the "heap", we can just slip the |
490 | * flag parameter in after the string slot pointer and veni that don't |
491 | * know better won't see this new flag field ... |
492 | * Otherwise we'd need two different venus_lookup functions. |
493 | */ |
494 | inp->name = Isize; |
495 | inp->flags = CLU_CASE_SENSITIVE; /* doesn't really matter for BSD */ |
496 | /* This is safe because we preallocated len+1 extra. */ |
497 | STRCPY(name, nm, len); /* increments Isize */ |
498 | |
499 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
500 | KASSERT(outp != NULL); |
501 | if (!error) { |
502 | *VFid = outp->Fid; |
503 | *vtype = outp->vtype; |
504 | } |
505 | |
506 | CODA_FREE(inp, coda_lookup_size); |
507 | return error; |
508 | } |
509 | |
510 | int |
511 | venus_create(void *mdp, CodaFid *fid, |
512 | const char *nm, int len, int exclusive, int mode, struct vattr *va, |
513 | kauth_cred_t cred, struct lwp *l, |
514 | /*out*/ CodaFid *VFid, struct vattr *attr) |
515 | { |
516 | DECL(coda_create); /* sets Isize & Osize */ |
517 | coda_create_size += len + 1; |
518 | ALLOC(coda_create); /* sets inp & outp */ |
519 | |
520 | /* send the open to venus. */ |
521 | INIT_IN_L(&inp->ih, CODA_CREATE, cred, l); |
522 | inp->Fid = *fid; |
523 | inp->excl = exclusive ? C_O_EXCL : 0; |
524 | inp->mode = mode<<6; |
525 | CNV_V2VV_ATTR(&inp->attr, va); |
526 | |
527 | inp->name = Isize; |
528 | STRCPY(name, nm, len); /* increments Isize */ |
529 | |
530 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
531 | KASSERT(outp != NULL); |
532 | if (!error) { |
533 | *VFid = outp->Fid; |
534 | CNV_VV2V_ATTR(attr, &outp->attr); |
535 | } |
536 | |
537 | CODA_FREE(inp, coda_create_size); |
538 | return error; |
539 | } |
540 | |
541 | int |
542 | venus_remove(void *mdp, CodaFid *fid, |
543 | const char *nm, int len, |
544 | kauth_cred_t cred, struct lwp *l) |
545 | { |
546 | DECL_NO_OUT(coda_remove); /* sets Isize & Osize */ |
547 | coda_remove_size += len + 1; |
548 | ALLOC_NO_OUT(coda_remove); /* sets inp & outp */ |
549 | |
550 | /* send the open to venus. */ |
551 | INIT_IN_L(&inp->ih, CODA_REMOVE, cred, l); |
552 | inp->Fid = *fid; |
553 | |
554 | inp->name = Isize; |
555 | STRCPY(name, nm, len); /* increments Isize */ |
556 | |
557 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
558 | |
559 | CODA_FREE(inp, coda_remove_size); |
560 | return error; |
561 | } |
562 | |
563 | int |
564 | venus_link(void *mdp, CodaFid *fid, CodaFid *tfid, |
565 | const char *nm, int len, |
566 | kauth_cred_t cred, struct lwp *l) |
567 | { |
568 | DECL_NO_OUT(coda_link); /* sets Isize & Osize */ |
569 | coda_link_size += len + 1; |
570 | ALLOC_NO_OUT(coda_link); /* sets inp & outp */ |
571 | |
572 | /* send the open to venus. */ |
573 | INIT_IN_L(&inp->ih, CODA_LINK, cred, l); |
574 | inp->sourceFid = *fid; |
575 | inp->destFid = *tfid; |
576 | |
577 | inp->tname = Isize; |
578 | STRCPY(tname, nm, len); /* increments Isize */ |
579 | |
580 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
581 | |
582 | CODA_FREE(inp, coda_link_size); |
583 | return error; |
584 | } |
585 | |
586 | int |
587 | venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid, |
588 | const char *nm, int len, const char *tnm, int tlen, |
589 | kauth_cred_t cred, struct lwp *l) |
590 | { |
591 | DECL_NO_OUT(coda_rename); /* sets Isize & Osize */ |
592 | coda_rename_size += len + 1 + tlen + 1; |
593 | ALLOC_NO_OUT(coda_rename); /* sets inp & outp */ |
594 | |
595 | /* send the open to venus. */ |
596 | INIT_IN_L(&inp->ih, CODA_RENAME, cred, l); |
597 | inp->sourceFid = *fid; |
598 | inp->destFid = *tfid; |
599 | |
600 | inp->srcname = Isize; |
601 | STRCPY(srcname, nm, len); /* increments Isize */ |
602 | |
603 | inp->destname = Isize; |
604 | STRCPY(destname, tnm, tlen); /* increments Isize */ |
605 | |
606 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
607 | |
608 | CODA_FREE(inp, coda_rename_size); |
609 | return error; |
610 | } |
611 | |
612 | int |
613 | venus_mkdir(void *mdp, CodaFid *fid, |
614 | const char *nm, int len, struct vattr *va, |
615 | kauth_cred_t cred, struct lwp *l, |
616 | /*out*/ CodaFid *VFid, struct vattr *ova) |
617 | { |
618 | DECL(coda_mkdir); /* sets Isize & Osize */ |
619 | coda_mkdir_size += len + 1; |
620 | ALLOC(coda_mkdir); /* sets inp & outp */ |
621 | |
622 | /* send the open to venus. */ |
623 | INIT_IN_L(&inp->ih, CODA_MKDIR, cred, l); |
624 | inp->Fid = *fid; |
625 | CNV_V2VV_ATTR(&inp->attr, va); |
626 | |
627 | inp->name = Isize; |
628 | STRCPY(name, nm, len); /* increments Isize */ |
629 | |
630 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
631 | KASSERT(outp != NULL); |
632 | if (!error) { |
633 | *VFid = outp->Fid; |
634 | CNV_VV2V_ATTR(ova, &outp->attr); |
635 | } |
636 | |
637 | CODA_FREE(inp, coda_mkdir_size); |
638 | return error; |
639 | } |
640 | |
641 | int |
642 | venus_rmdir(void *mdp, CodaFid *fid, |
643 | const char *nm, int len, |
644 | kauth_cred_t cred, struct lwp *l) |
645 | { |
646 | DECL_NO_OUT(coda_rmdir); /* sets Isize & Osize */ |
647 | coda_rmdir_size += len + 1; |
648 | ALLOC_NO_OUT(coda_rmdir); /* sets inp & outp */ |
649 | |
650 | /* send the open to venus. */ |
651 | INIT_IN_L(&inp->ih, CODA_RMDIR, cred, l); |
652 | inp->Fid = *fid; |
653 | |
654 | inp->name = Isize; |
655 | STRCPY(name, nm, len); /* increments Isize */ |
656 | |
657 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
658 | |
659 | CODA_FREE(inp, coda_rmdir_size); |
660 | return error; |
661 | } |
662 | |
663 | int |
664 | venus_symlink(void *mdp, CodaFid *fid, |
665 | const char *lnm, int llen, const char *nm, int len, struct vattr *va, |
666 | kauth_cred_t cred, struct lwp *l) |
667 | { |
668 | DECL_NO_OUT(coda_symlink); /* sets Isize & Osize */ |
669 | coda_symlink_size += llen + 1 + len + 1; |
670 | ALLOC_NO_OUT(coda_symlink); /* sets inp & outp */ |
671 | |
672 | /* send the open to venus. */ |
673 | INIT_IN_L(&inp->ih, CODA_SYMLINK, cred, l); |
674 | inp->Fid = *fid; |
675 | CNV_V2VV_ATTR(&inp->attr, va); |
676 | |
677 | inp->srcname = Isize; |
678 | STRCPY(srcname, lnm, llen); /* increments Isize */ |
679 | |
680 | inp->tname = Isize; |
681 | STRCPY(tname, nm, len); /* increments Isize */ |
682 | |
683 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
684 | |
685 | CODA_FREE(inp, coda_symlink_size); |
686 | return error; |
687 | } |
688 | |
689 | int |
690 | venus_readdir(void *mdp, CodaFid *fid, |
691 | int count, int offset, |
692 | kauth_cred_t cred, struct lwp *l, |
693 | /*out*/ char *buffer, int *len) |
694 | { |
695 | DECL(coda_readdir); /* sets Isize & Osize */ |
696 | coda_readdir_size = VC_MAXMSGSIZE; |
697 | ALLOC(coda_readdir); /* sets inp & outp */ |
698 | |
699 | /* send the open to venus. */ |
700 | INIT_IN_L(&inp->ih, CODA_READDIR, cred, l); |
701 | inp->Fid = *fid; |
702 | inp->count = count; |
703 | inp->offset = offset; |
704 | |
705 | Osize = VC_MAXMSGSIZE; |
706 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
707 | KASSERT(outp != NULL); |
708 | if (!error) { |
709 | memcpy(buffer, (char *)outp + (int)(long)outp->data, outp->size); |
710 | *len = outp->size; |
711 | } |
712 | |
713 | CODA_FREE(inp, coda_readdir_size); |
714 | return error; |
715 | } |
716 | |
717 | int |
718 | venus_statfs(void *mdp, kauth_cred_t cred, struct lwp *l, |
719 | /*out*/ struct coda_statfs *fsp) |
720 | { |
721 | DECL(coda_statfs); /* sets Isize & Osize */ |
722 | ALLOC(coda_statfs); /* sets inp & outp */ |
723 | |
724 | /* send the open to venus. */ |
725 | INIT_IN_L(&inp->ih, CODA_STATFS, cred, l); |
726 | |
727 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
728 | KASSERT(outp != NULL); |
729 | if (!error) { |
730 | *fsp = outp->stat; |
731 | } |
732 | |
733 | CODA_FREE(inp, coda_statfs_size); |
734 | return error; |
735 | } |
736 | |
737 | int |
738 | venus_fhtovp(void *mdp, CodaFid *fid, |
739 | kauth_cred_t cred, struct proc *p, |
740 | /*out*/ CodaFid *VFid, int *vtype) |
741 | { |
742 | DECL(coda_vget); /* sets Isize & Osize */ |
743 | ALLOC(coda_vget); /* sets inp & outp */ |
744 | |
745 | /* Send the open to Venus. */ |
746 | INIT_IN(&inp->ih, CODA_VGET, cred, p); |
747 | inp->Fid = *fid; |
748 | |
749 | error = coda_call(mdp, Isize, &Osize, (char *)inp); |
750 | KASSERT(outp != NULL); |
751 | if (!error) { |
752 | *VFid = outp->Fid; |
753 | *vtype = outp->vtype; |
754 | } |
755 | |
756 | CODA_FREE(inp, coda_vget_size); |
757 | return error; |
758 | } |
759 | |