sys/fs/coda/coda_venus.c

   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*/ 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 }