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