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