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: releng/8.4/sys/fs/coda/coda_venus.c 208702 2010-06-01 14:29:26Z rwatson $"); 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*/ struct 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, struct 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, struct 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, struct 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, struct CodaFid *fid, struct ucred *cred, 308 struct vattr *vap) 309 { 310 struct proc *p; 311 DECL(coda_getattr); /* sets Isize & Osize */ 312 ALLOC(coda_getattr); /* sets inp & outp */ 313 314 /* 315 * Send the open to venus. 316 */ 317 p = curthread->td_proc; 318 INIT_IN(&inp->ih, CODA_GETATTR, cred, p); 319 inp->Fid = *fid; 320 321 error = coda_call(mdp, Isize, &Osize, (char *)inp); 322 if (!error) 323 CNV_VV2V_ATTR(vap, &outp->attr); 324 325 CODA_FREE(inp, coda_getattr_size); 326 return (error); 327 } 328 329 int 330 venus_setattr(void *mdp, struct CodaFid *fid, struct vattr *vap, 331 struct ucred *cred) 332 { 333 struct proc *p; 334 DECL_NO_OUT(coda_setattr); /* sets Isize & Osize */ 335 ALLOC_NO_OUT(coda_setattr); /* sets inp & outp */ 336 337 /* 338 * Send the open to venus. 339 */ 340 p = curthread->td_proc; 341 INIT_IN(&inp->ih, CODA_SETATTR, cred, p); 342 inp->Fid = *fid; 343 CNV_V2VV_ATTR(&inp->attr, vap); 344 345 error = coda_call(mdp, Isize, &Osize, (char *)inp); 346 347 CODA_FREE(inp, coda_setattr_size); 348 return (error); 349 } 350 351 int 352 venus_access(void *mdp, struct CodaFid *fid, accmode_t accmode, 353 struct ucred *cred, struct proc *p) 354 { 355 DECL_NO_OUT(coda_access); /* sets Isize & Osize */ 356 ALLOC_NO_OUT(coda_access); /* sets inp & outp */ 357 358 /* 359 * Send the open to venus. 360 */ 361 INIT_IN(&inp->ih, CODA_ACCESS, cred, p); 362 inp->Fid = *fid; 363 364 /* 365 * NOTE: FreeBSD and Venus internals use the "data" in the low 3 366 * bits. Hence, the conversion. 367 * 368 * XXX: We cast accmode_t variable into an int. 369 */ 370 inp->flags = (int)accmode>>6; 371 372 error = coda_call(mdp, Isize, &Osize, (char *)inp); 373 374 CODA_FREE(inp, coda_access_size); 375 return (error); 376 } 377 378 int 379 venus_readlink(void *mdp, struct CodaFid *fid, struct ucred *cred, 380 struct proc *p, /*out*/ char **str, int *len) 381 { 382 DECL(coda_readlink); /* sets Isize & Osize */ 383 coda_readlink_size += CODA_MAXPATHLEN; 384 ALLOC(coda_readlink); /* sets inp & outp */ 385 386 /* 387 * Send the open to venus. 388 */ 389 INIT_IN(&inp->ih, CODA_READLINK, cred, p); 390 inp->Fid = *fid; 391 392 Osize += CODA_MAXPATHLEN; 393 error = coda_call(mdp, Isize, &Osize, (char *)inp); 394 if (!error) { 395 CODA_ALLOC(*str, char *, outp->count); 396 *len = outp->count; 397 bcopy((char *)outp + (long)outp->data, *str, *len); 398 } 399 400 CODA_FREE(inp, coda_readlink_size); 401 return (error); 402 } 403 404 int 405 venus_fsync(void *mdp, struct CodaFid *fid, struct proc *p) 406 { 407 DECL_NO_OUT(coda_fsync); /* sets Isize & Osize */ 408 ALLOC_NO_OUT(coda_fsync); /* sets inp & outp */ 409 410 /* 411 * Send the open to venus. 412 * 413 * XXX: should be cached mount cred. 414 */ 415 INIT_IN(&inp->ih, CODA_FSYNC, NOCRED, p); 416 inp->Fid = *fid; 417 418 error = coda_call(mdp, Isize, &Osize, (char *)inp); 419 420 CODA_FREE(inp, coda_fsync_size); 421 return (error); 422 } 423 424 int 425 venus_lookup(void *mdp, struct CodaFid *fid, const char *nm, int len, 426 struct ucred *cred, struct proc *p, /*out*/ struct CodaFid *VFid, 427 int *vtype) 428 { 429 DECL(coda_lookup); /* sets Isize & Osize */ 430 coda_lookup_size += len + 1; 431 ALLOC(coda_lookup); /* sets inp & outp */ 432 433 /* 434 * Send the open to venus. 435 */ 436 INIT_IN(&inp->ih, CODA_LOOKUP, cred, p); 437 inp->Fid = *fid; 438 439 /* 440 * NOTE: Between version 1 and version 2 we have added an extra flag 441 * field to this structure. But because the string was at the end 442 * and because of the wierd way we represent strings by having the 443 * slot point to where the string characters are in the "heap", we 444 * can just slip the flag parameter in after the string slot pointer 445 * and veni that don't know better won't see this new flag field ... 446 * Otherwise we'd need two different venus_lookup functions. 447 */ 448 inp->name = Isize; 449 inp->flags = CLU_CASE_SENSITIVE; /* doesn't really matter for BSD */ 450 STRCPY(name, nm, len); /* increments Isize */ 451 452 error = coda_call(mdp, Isize, &Osize, (char *)inp); 453 if (!error) { 454 *VFid = outp->Fid; 455 *vtype = outp->vtype; 456 } 457 458 CODA_FREE(inp, coda_lookup_size); 459 return (error); 460 } 461 462 int 463 venus_create(void *mdp, struct CodaFid *fid, const char *nm, int len, 464 int exclusive, int mode, struct vattr *va, struct ucred *cred, 465 struct proc *p, /*out*/ struct CodaFid *VFid, struct vattr *attr) 466 { 467 DECL(coda_create); /* sets Isize & Osize */ 468 coda_create_size += len + 1; 469 ALLOC(coda_create); /* sets inp & outp */ 470 471 /* 472 * Send the open to venus. 473 */ 474 INIT_IN(&inp->ih, CODA_CREATE, cred, p); 475 inp->Fid = *fid; 476 inp->excl = exclusive ? C_O_EXCL : 0; 477 inp->mode = mode; 478 CNV_V2VV_ATTR(&inp->attr, va); 479 480 inp->name = Isize; 481 STRCPY(name, nm, len); /* increments Isize */ 482 483 error = coda_call(mdp, Isize, &Osize, (char *)inp); 484 if (!error) { 485 *VFid = outp->Fid; 486 CNV_VV2V_ATTR(attr, &outp->attr); 487 } 488 489 CODA_FREE(inp, coda_create_size); 490 return (error); 491 } 492 493 int 494 venus_remove(void *mdp, struct CodaFid *fid, const char *nm, int len, 495 struct ucred *cred, struct proc *p) 496 { 497 DECL_NO_OUT(coda_remove); /* sets Isize & Osize */ 498 coda_remove_size += len + 1; 499 ALLOC_NO_OUT(coda_remove); /* sets inp & outp */ 500 501 /* 502 * Send the open to venus. 503 */ 504 INIT_IN(&inp->ih, CODA_REMOVE, cred, p); 505 inp->Fid = *fid; 506 507 inp->name = Isize; 508 STRCPY(name, nm, len); /* increments Isize */ 509 510 error = coda_call(mdp, Isize, &Osize, (char *)inp); 511 512 CODA_FREE(inp, coda_remove_size); 513 return (error); 514 } 515 516 int 517 venus_link(void *mdp, struct CodaFid *fid, struct CodaFid *tfid, 518 const char *nm, int len, struct ucred *cred, struct proc *p) 519 { 520 DECL_NO_OUT(coda_link); /* sets Isize & Osize */ 521 coda_link_size += len + 1; 522 ALLOC_NO_OUT(coda_link); /* sets inp & outp */ 523 524 /* 525 * Send the open to venus. 526 */ 527 INIT_IN(&inp->ih, CODA_LINK, cred, p); 528 inp->sourceFid = *fid; 529 inp->destFid = *tfid; 530 531 inp->tname = Isize; 532 STRCPY(tname, nm, len); /* increments Isize */ 533 534 error = coda_call(mdp, Isize, &Osize, (char *)inp); 535 536 CODA_FREE(inp, coda_link_size); 537 return (error); 538 } 539 540 int 541 venus_rename(void *mdp, struct CodaFid *fid, struct CodaFid *tfid, 542 const char *nm, int len, const char *tnm, int tlen, struct ucred *cred, 543 struct proc *p) 544 { 545 DECL_NO_OUT(coda_rename); /* sets Isize & Osize */ 546 coda_rename_size += len + 1 + tlen + 1; 547 ALLOC_NO_OUT(coda_rename); /* sets inp & outp */ 548 549 /* 550 * Send the open to venus. 551 */ 552 INIT_IN(&inp->ih, CODA_RENAME, cred, p); 553 inp->sourceFid = *fid; 554 inp->destFid = *tfid; 555 556 inp->srcname = Isize; 557 STRCPY(srcname, nm, len); /* increments Isize */ 558 559 inp->destname = Isize; 560 STRCPY(destname, tnm, tlen); /* increments Isize */ 561 562 error = coda_call(mdp, Isize, &Osize, (char *)inp); 563 564 CODA_FREE(inp, coda_rename_size); 565 return (error); 566 } 567 568 int 569 venus_mkdir(void *mdp, struct CodaFid *fid, const char *nm, int len, 570 struct vattr *va, struct ucred *cred, struct proc *p, 571 /*out*/ struct CodaFid *VFid, struct vattr *ova) 572 { 573 DECL(coda_mkdir); /* sets Isize & Osize */ 574 coda_mkdir_size += len + 1; 575 ALLOC(coda_mkdir); /* sets inp & outp */ 576 577 /* 578 * Send the open to venus. 579 */ 580 INIT_IN(&inp->ih, CODA_MKDIR, cred, p); 581 inp->Fid = *fid; 582 CNV_V2VV_ATTR(&inp->attr, va); 583 584 inp->name = Isize; 585 STRCPY(name, nm, len); /* increments Isize */ 586 587 error = coda_call(mdp, Isize, &Osize, (char *)inp); 588 if (!error) { 589 *VFid = outp->Fid; 590 CNV_VV2V_ATTR(ova, &outp->attr); 591 } 592 593 CODA_FREE(inp, coda_mkdir_size); 594 return (error); 595 } 596 597 int 598 venus_rmdir(void *mdp, struct CodaFid *fid, const char *nm, int len, 599 struct ucred *cred, struct proc *p) 600 { 601 DECL_NO_OUT(coda_rmdir); /* sets Isize & Osize */ 602 coda_rmdir_size += len + 1; 603 ALLOC_NO_OUT(coda_rmdir); /* sets inp & outp */ 604 605 /* 606 * Send the open to venus. 607 */ 608 INIT_IN(&inp->ih, CODA_RMDIR, cred, p); 609 inp->Fid = *fid; 610 611 inp->name = Isize; 612 STRCPY(name, nm, len); /* increments Isize */ 613 614 error = coda_call(mdp, Isize, &Osize, (char *)inp); 615 616 CODA_FREE(inp, coda_rmdir_size); 617 return (error); 618 } 619 620 int 621 venus_symlink(void *mdp, struct CodaFid *fid, const char *lnm, int llen, 622 const char *nm, int len, struct vattr *va, struct ucred *cred, 623 struct proc *p) 624 { 625 DECL_NO_OUT(coda_symlink); /* sets Isize & Osize */ 626 coda_symlink_size += llen + 1 + len + 1; 627 ALLOC_NO_OUT(coda_symlink); /* sets inp & outp */ 628 629 /* 630 * Send the open to venus. 631 */ 632 INIT_IN(&inp->ih, CODA_SYMLINK, cred, p); 633 inp->Fid = *fid; 634 CNV_V2VV_ATTR(&inp->attr, va); 635 636 inp->srcname = Isize; 637 STRCPY(srcname, lnm, llen); /* increments Isize */ 638 639 inp->tname = Isize; 640 STRCPY(tname, nm, len); /* increments Isize */ 641 642 error = coda_call(mdp, Isize, &Osize, (char *)inp); 643 644 CODA_FREE(inp, coda_symlink_size); 645 return (error); 646 } 647 648 /* 649 * XXX: Unused. 650 */ 651 int 652 venus_readdir(void *mdp, struct CodaFid *fid, int count, int offset, 653 struct ucred *cred, struct proc *p, /*out*/ char *buffer, int *len) 654 { 655 DECL(coda_readdir); /* sets Isize & Osize */ 656 coda_readdir_size = VC_MAXMSGSIZE; 657 ALLOC(coda_readdir); /* sets inp & outp */ 658 659 /* 660 * Send the open to venus. 661 */ 662 INIT_IN(&inp->ih, CODA_READDIR, cred, p); 663 inp->Fid = *fid; 664 inp->count = count; 665 inp->offset = offset; 666 667 Osize = VC_MAXMSGSIZE; 668 error = coda_call(mdp, Isize, &Osize, (char *)inp); 669 if (!error) { 670 bcopy((char *)outp + (long)outp->data, buffer, outp->size); 671 *len = outp->size; 672 } 673 674 CODA_FREE(inp, coda_readdir_size); 675 return (error); 676 } 677 678 int 679 venus_fhtovp(void *mdp, struct CodaFid *fid, struct ucred *cred, 680 struct proc *p, /*out*/ struct CodaFid *VFid, int *vtype) 681 { 682 DECL(coda_vget); /* sets Isize & Osize */ 683 ALLOC(coda_vget); /* sets inp & outp */ 684 685 /* 686 * Send the open to Venus. 687 */ 688 INIT_IN(&inp->ih, CODA_VGET, cred, p); 689 inp->Fid = *fid; 690 691 error = coda_call(mdp, Isize, &Osize, (char *)inp); 692 if (!error) { 693 *VFid = outp->Fid; 694 *vtype = outp->vtype; 695 } 696 697 CODA_FREE(inp, coda_vget_size); 698 return (error); 699 }
Cache object: f2ded98986b5393607ef6d5eb41e7c51
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]