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