| 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 | |