The Design and Implementation of the FreeBSD Operating System, Second Edition
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 

    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 }

Cache object: e8ec36f7558ef2fde293cbd8a9c040e1


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.