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/coda/coda_venus.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  *             Coda: an Experimental Distributed File System
    3  *                              Release 3.1
    4  * 
    5  *           Copyright (c) 1987-1998 Carnegie Mellon University
    6  *                          All Rights Reserved
    7  * 
    8  * Permission  to  use, copy, modify and distribute this software and its
    9  * documentation is hereby granted,  provided  that  both  the  copyright
   10  * notice  and  this  permission  notice  appear  in  all  copies  of the
   11  * software, derivative works or  modified  versions,  and  any  portions
   12  * thereof, and that both notices appear in supporting documentation, and
   13  * that credit is given to Carnegie Mellon University  in  all  documents
   14  * and publicity pertaining to direct or indirect use of this code or its
   15  * derivatives.
   16  * 
   17  * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS  KNOWN  TO  HAVE  BUGS,
   18  * SOME  OF  WHICH MAY HAVE SERIOUS CONSEQUENCES.  CARNEGIE MELLON ALLOWS
   19  * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.   CARNEGIE  MELLON
   20  * DISCLAIMS  ANY  LIABILITY  OF  ANY  KIND  FOR  ANY  DAMAGES WHATSOEVER
   21  * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE  OR  OF
   22  * ANY DERIVATIVE WORK.
   23  * 
   24  * Carnegie  Mellon  encourages  users  of  this  software  to return any
   25  * improvements or extensions that  they  make,  and  to  grant  Carnegie
   26  * Mellon the rights to redistribute these changes without encumbrance.
   27  * 
   28  *      @(#) src/sys/cfs/coda_venus.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
   29  */
   30 
   31 #include <sys/cdefs.h>
   32 __FBSDID("$FreeBSD: releng/6.3/sys/coda/coda_venus.c 143637 2005-03-15 12:39:30Z phk $");
   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 <coda/coda.h>
   45 #include <coda/cnode.h>
   46 #include <coda/coda_venus.h>
   47 #include <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) \
   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) ? (p->p_session->s_leader->p_pid) : -1; \
  103           sx_sunlock(&proctree_lock); \
  104           if (ident != NOCRED) {                              \
  105               (in)->cred.cr_uid = ident->cr_uid;              \
  106               (in)->cred.cr_groupid = ident->cr_gid;          \
  107           } else {                                            \
  108               bzero(&((in)->cred),sizeof(struct coda_cred));  \
  109               (in)->cred.cr_uid = -1;                         \
  110               (in)->cred.cr_groupid = -1;                     \
  111           }
  112 #else
  113 #define INIT_IN(in, op, ident, p)                       \
  114           (in)->opcode = (op);                          \
  115           (in)->pid = p ? p->p_pid : -1;                \
  116           (in)->pgid = p ? p->p_pgid : -1;              \
  117           if (ident != NOCRED) {                        \
  118               (in)->uid = ident->cr_uid;                \
  119           } else {                                      \
  120               (in)->uid = -1;                           \
  121           }     
  122 #endif
  123 #define CNV_OFLAG(to, from)                             \
  124     do {                                                \
  125           to = 0;                                       \
  126           if (from & FREAD)   to |= C_O_READ;           \
  127           if (from & FWRITE)  to |= C_O_WRITE;          \
  128           if (from & O_TRUNC) to |= C_O_TRUNC;          \
  129           if (from & O_EXCL)  to |= C_O_EXCL;           \
  130           if (from & O_CREAT) to |= C_O_CREAT;          \
  131     } while (0)
  132 
  133 #define CNV_VV2V_ATTR(top, fromp) \
  134         do { \
  135                 (top)->va_type = (fromp)->va_type; \
  136                 (top)->va_mode = (fromp)->va_mode; \
  137                 (top)->va_nlink = (fromp)->va_nlink; \
  138                 (top)->va_uid = (fromp)->va_uid; \
  139                 (top)->va_gid = (fromp)->va_gid; \
  140                 (top)->va_fsid = VNOVAL; \
  141                 (top)->va_fileid = (fromp)->va_fileid; \
  142                 (top)->va_size = (fromp)->va_size; \
  143                 (top)->va_blocksize = (fromp)->va_blocksize; \
  144                 (top)->va_atime = (fromp)->va_atime; \
  145                 (top)->va_mtime = (fromp)->va_mtime; \
  146                 (top)->va_ctime = (fromp)->va_ctime; \
  147                 (top)->va_gen = (fromp)->va_gen; \
  148                 (top)->va_flags = (fromp)->va_flags; \
  149                 (top)->va_rdev = (fromp)->va_rdev; \
  150                 (top)->va_bytes = (fromp)->va_bytes; \
  151                 (top)->va_filerev = (fromp)->va_filerev; \
  152                 (top)->va_vaflags = VNOVAL; \
  153                 (top)->va_spare = VNOVAL; \
  154         } while (0)
  155 
  156 #define CNV_V2VV_ATTR(top, fromp) \
  157         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 
  177 int coda_kernel_version = CODA_KERNEL_VERSION;
  178 
  179 int
  180 venus_root(void *mdp,
  181         struct ucred *cred, struct proc *p,
  182 /*out*/ CodaFid *VFid)
  183 {
  184     DECL_NO_IN(coda_root);              /* sets Isize & Osize */
  185     ALLOC_NO_IN(coda_root);             /* sets inp & outp */
  186 
  187     /* send the open to venus. */
  188     INIT_IN(inp, CODA_ROOT, cred, p);  
  189 
  190     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  191     if (!error)
  192         *VFid = outp->Fid;
  193 
  194     CODA_FREE(inp, coda_root_size);
  195     return error;
  196 }
  197 
  198 int
  199 venus_open(void *mdp, CodaFid *fid, int flag,
  200         struct ucred *cred, struct proc *p,
  201 /*out*/ struct cdev **dev, ino_t *inode)
  202 {
  203 #if 0
  204     int cflag;
  205     DECL(coda_open);                    /* sets Isize & Osize */
  206     ALLOC(coda_open);                   /* sets inp & outp */
  207 
  208     /* send the open to venus. */
  209     INIT_IN(&inp->ih, CODA_OPEN, cred, p);
  210     inp->Fid = *fid;
  211     CNV_OFLAG(cflag, flag);
  212     inp->flags = cflag;
  213 
  214     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  215     if (!error) {
  216         *dev =  findcdev(outp->dev);
  217         *inode = outp->inode;
  218     }
  219 
  220     CODA_FREE(inp, coda_open_size);
  221     return error;
  222 #else
  223     return (EOPNOTSUPP);
  224 #endif
  225 }
  226 
  227 int
  228 venus_close(void *mdp, CodaFid *fid, int flag,
  229         struct ucred *cred, struct proc *p)
  230 {
  231     int cflag;
  232     DECL_NO_OUT(coda_close);            /* sets Isize & Osize */
  233     ALLOC_NO_OUT(coda_close);           /* sets inp & outp */
  234 
  235     INIT_IN(&inp->ih, CODA_CLOSE, cred, p);
  236     inp->Fid = *fid;
  237     CNV_OFLAG(cflag, flag);
  238     inp->flags = cflag;
  239 
  240     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  241 
  242     CODA_FREE(inp, coda_close_size);
  243     return error;
  244 }
  245 
  246 /*
  247  * these two calls will not exist!!!  the container file is read/written
  248  * directly.
  249  */
  250 void
  251 venus_read(void)
  252 {
  253 }
  254 
  255 void
  256 venus_write(void)
  257 {
  258 }
  259 
  260 /*
  261  * this is a bit sad too.  the ioctl's are for the control file, not for
  262  * normal files.
  263  */
  264 int
  265 venus_ioctl(void *mdp, CodaFid *fid,
  266         int com, int flag, caddr_t data,
  267         struct ucred *cred, struct proc *p)
  268 {
  269     DECL(coda_ioctl);                   /* sets Isize & Osize */
  270     struct PioctlData *iap = (struct PioctlData *)data;
  271     int tmp;
  272 
  273     coda_ioctl_size = VC_MAXMSGSIZE;
  274     ALLOC(coda_ioctl);                  /* sets inp & outp */
  275 
  276     INIT_IN(&inp->ih, CODA_IOCTL, cred, p);
  277     inp->Fid = *fid;
  278 
  279     /* command was mutated by increasing its size field to reflect the  
  280      * path and follow args. we need to subtract that out before sending
  281      * the command to venus.
  282      */
  283     inp->cmd = (com & ~(IOCPARM_MASK << 16));
  284     tmp = ((com >> 16) & IOCPARM_MASK) - sizeof (char *) - sizeof (int);
  285     inp->cmd |= (tmp & IOCPARM_MASK) << 16;
  286 
  287     inp->rwflag = flag;
  288     inp->len = iap->vi.in_size;
  289     inp->data = (char *)(sizeof (struct coda_ioctl_in));
  290 
  291     error = copyin(iap->vi.in, (char*)inp + (long)inp->data, 
  292                    iap->vi.in_size);
  293     if (error) {
  294         CODA_FREE(inp, coda_ioctl_size);
  295         return(error);
  296     }
  297 
  298     Osize = VC_MAXMSGSIZE;
  299     error = coda_call(mdp, Isize + iap->vi.in_size, &Osize, (char *)inp);
  300 
  301         /* copy out the out buffer. */
  302     if (!error) {
  303         if (outp->len > iap->vi.out_size) {
  304             error = EINVAL;
  305         } else {
  306             error = copyout((char *)outp + (long)outp->data, 
  307                             iap->vi.out, iap->vi.out_size);
  308         }
  309     }
  310 
  311     CODA_FREE(inp, coda_ioctl_size);
  312     return error;
  313 }
  314 
  315 int
  316 venus_getattr(void *mdp, CodaFid *fid,
  317         struct ucred *cred, struct proc *p,
  318 /*out*/ struct vattr *vap)
  319 {
  320     DECL(coda_getattr);                 /* sets Isize & Osize */
  321     ALLOC(coda_getattr);                        /* sets inp & outp */
  322 
  323     /* send the open to venus. */
  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 
  332     CODA_FREE(inp, coda_getattr_size);
  333     return error;
  334 }
  335 
  336 int
  337 venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap,
  338         struct ucred *cred, struct proc *p)
  339 {
  340     DECL_NO_OUT(coda_setattr);          /* sets Isize & Osize */
  341     ALLOC_NO_OUT(coda_setattr);         /* sets inp & outp */
  342 
  343     /* send the open to venus. */
  344     INIT_IN(&inp->ih, CODA_SETATTR, cred, p);
  345     inp->Fid = *fid;
  346     CNV_V2VV_ATTR(&inp->attr, vap);
  347 
  348     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  349 
  350     CODA_FREE(inp, coda_setattr_size);
  351     return error;
  352 }
  353 
  354 int
  355 venus_access(void *mdp, CodaFid *fid, int mode,
  356         struct ucred *cred, struct proc *p)
  357 {
  358     DECL_NO_OUT(coda_access);           /* sets Isize & Osize */
  359     ALLOC_NO_OUT(coda_access);          /* sets inp & outp */
  360 
  361     /* send the open to venus. */
  362     INIT_IN(&inp->ih, CODA_ACCESS, cred, p);
  363     inp->Fid = *fid;
  364     /* NOTE:
  365      * NetBSD and Venus internals use the "data" in the low 3 bits.
  366      * Hence, the conversion.
  367      */
  368     inp->flags = mode>>6;
  369 
  370     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  371 
  372     CODA_FREE(inp, coda_access_size);
  373     return error;
  374 }
  375 
  376 int
  377 venus_readlink(void *mdp, CodaFid *fid,
  378         struct ucred *cred, struct proc *p,
  379 /*out*/ char **str, int *len)
  380 {
  381     DECL(coda_readlink);                        /* sets Isize & Osize */
  382     coda_readlink_size += CODA_MAXPATHLEN;
  383     ALLOC(coda_readlink);               /* sets inp & outp */
  384 
  385     /* send the open to venus. */
  386     INIT_IN(&inp->ih, CODA_READLINK, cred, p);
  387     inp->Fid = *fid;
  388 
  389     Osize += CODA_MAXPATHLEN;
  390     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  391     if (!error) {
  392             CODA_ALLOC(*str, char *, outp->count);
  393             *len = outp->count;
  394             bcopy((char *)outp + (long)outp->data, *str, *len);
  395     }
  396 
  397     CODA_FREE(inp, coda_readlink_size);
  398     return error;
  399 }
  400 
  401 int
  402 venus_fsync(void *mdp, CodaFid *fid, struct proc *p)
  403 {
  404     DECL_NO_OUT(coda_fsync);            /* sets Isize & Osize */
  405     ALLOC_NO_OUT(coda_fsync);           /* sets inp & outp */
  406 
  407     /* send the open to venus. */
  408     INIT_IN(&inp->ih, CODA_FSYNC, NOCRED, p);   /* XXX: should be cached mount cred */
  409     inp->Fid = *fid;
  410 
  411     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  412 
  413     CODA_FREE(inp, coda_fsync_size);
  414     return error;
  415 }
  416 
  417 int
  418 venus_lookup(void *mdp, CodaFid *fid,
  419         const char *nm, int len,
  420         struct ucred *cred, struct proc *p,
  421 /*out*/ CodaFid *VFid, int *vtype)
  422 {
  423     DECL(coda_lookup);                  /* sets Isize & Osize */
  424     coda_lookup_size += len + 1;
  425     ALLOC(coda_lookup);                 /* sets inp & outp */
  426 
  427     /* send the open to venus. */
  428     INIT_IN(&inp->ih, CODA_LOOKUP, cred, p);
  429     inp->Fid = *fid;
  430 
  431     /* NOTE:
  432      * Between version 1 and version 2 we have added an extra flag field
  433      * to this structure.  But because the string was at the end and because
  434      * of the wierd way we represent strings by having the slot point to
  435      * where the string characters are in the "heap", we can just slip the
  436      * flag parameter in after the string slot pointer and veni that don't
  437      * know better won't see this new flag field ...
  438      * Otherwise we'd need two different venus_lookup functions.
  439      */
  440     inp->name = Isize;
  441     inp->flags = CLU_CASE_SENSITIVE;    /* doesn't really matter for BSD */
  442     STRCPY(name, nm, len);              /* increments Isize */
  443 
  444     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  445     if (!error) {
  446         *VFid = outp->Fid;
  447         *vtype = outp->vtype;
  448     }
  449 
  450     CODA_FREE(inp, coda_lookup_size);
  451     return error;
  452 }
  453 
  454 int
  455 venus_create(void *mdp, CodaFid *fid,
  456         const char *nm, int len, int exclusive, int mode, struct vattr *va,
  457         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     /* send the open to venus. */
  465     INIT_IN(&inp->ih, CODA_CREATE, cred, p);
  466     inp->Fid = *fid;
  467     inp->excl = exclusive ? C_O_EXCL : 0;
  468     inp->mode = mode;
  469     CNV_V2VV_ATTR(&inp->attr, va);
  470 
  471     inp->name = Isize;
  472     STRCPY(name, nm, len);              /* increments Isize */
  473 
  474     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  475     if (!error) {
  476         *VFid = outp->Fid;
  477         CNV_VV2V_ATTR(attr, &outp->attr);
  478     }
  479 
  480     CODA_FREE(inp, coda_create_size);
  481     return error;
  482 }
  483 
  484 int
  485 venus_remove(void *mdp, CodaFid *fid,
  486         const char *nm, int len,
  487         struct ucred *cred, struct proc *p)
  488 {
  489     DECL_NO_OUT(coda_remove);           /* sets Isize & Osize */
  490     coda_remove_size += len + 1;
  491     ALLOC_NO_OUT(coda_remove);          /* sets inp & outp */
  492 
  493     /* send the open to venus. */
  494     INIT_IN(&inp->ih, CODA_REMOVE, cred, p);
  495     inp->Fid = *fid;
  496 
  497     inp->name = Isize;
  498     STRCPY(name, nm, len);              /* increments Isize */
  499 
  500     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  501 
  502     CODA_FREE(inp, coda_remove_size);
  503     return error;
  504 }
  505 
  506 int
  507 venus_link(void *mdp, CodaFid *fid, CodaFid *tfid,
  508         const char *nm, int len,
  509         struct ucred *cred, struct proc *p)
  510 {
  511     DECL_NO_OUT(coda_link);             /* sets Isize & Osize */
  512     coda_link_size += len + 1;
  513     ALLOC_NO_OUT(coda_link);            /* sets inp & outp */
  514 
  515     /* send the open to venus. */
  516     INIT_IN(&inp->ih, CODA_LINK, cred, p);
  517     inp->sourceFid = *fid;
  518     inp->destFid = *tfid;
  519 
  520     inp->tname = Isize;
  521     STRCPY(tname, nm, len);             /* increments Isize */
  522 
  523     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  524 
  525     CODA_FREE(inp, coda_link_size);
  526     return error;
  527 }
  528 
  529 int
  530 venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid,
  531         const char *nm, int len, const char *tnm, int tlen,
  532         struct ucred *cred, struct proc *p)
  533 {
  534     DECL_NO_OUT(coda_rename);           /* sets Isize & Osize */
  535     coda_rename_size += len + 1 + tlen + 1;
  536     ALLOC_NO_OUT(coda_rename);          /* sets inp & outp */
  537 
  538     /* send the open to venus. */
  539     INIT_IN(&inp->ih, CODA_RENAME, cred, p);
  540     inp->sourceFid = *fid;
  541     inp->destFid = *tfid;
  542 
  543     inp->srcname = Isize;
  544     STRCPY(srcname, nm, len);           /* increments Isize */
  545 
  546     inp->destname = Isize;
  547     STRCPY(destname, tnm, tlen);        /* increments Isize */
  548 
  549     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  550 
  551     CODA_FREE(inp, coda_rename_size);
  552     return error;
  553 }
  554 
  555 int
  556 venus_mkdir(void *mdp, CodaFid *fid,
  557         const char *nm, int len, struct vattr *va,
  558         struct ucred *cred, struct proc *p,
  559 /*out*/ CodaFid *VFid, struct vattr *ova)
  560 {
  561     DECL(coda_mkdir);                   /* sets Isize & Osize */
  562     coda_mkdir_size += len + 1;
  563     ALLOC(coda_mkdir);                  /* sets inp & outp */
  564 
  565     /* send the open to venus. */
  566     INIT_IN(&inp->ih, CODA_MKDIR, cred, p);
  567     inp->Fid = *fid;
  568     CNV_V2VV_ATTR(&inp->attr, va);
  569 
  570     inp->name = Isize;
  571     STRCPY(name, nm, len);              /* increments Isize */
  572 
  573     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  574     if (!error) {
  575         *VFid = outp->Fid;
  576         CNV_VV2V_ATTR(ova, &outp->attr);
  577     }
  578 
  579     CODA_FREE(inp, coda_mkdir_size);
  580     return error;
  581 }
  582 
  583 int
  584 venus_rmdir(void *mdp, CodaFid *fid,
  585         const char *nm, int len,
  586         struct ucred *cred, struct proc *p)
  587 {
  588     DECL_NO_OUT(coda_rmdir);            /* sets Isize & Osize */
  589     coda_rmdir_size += len + 1;
  590     ALLOC_NO_OUT(coda_rmdir);           /* sets inp & outp */
  591 
  592     /* send the open to venus. */
  593     INIT_IN(&inp->ih, CODA_RMDIR, cred, p);
  594     inp->Fid = *fid;
  595 
  596     inp->name = Isize;
  597     STRCPY(name, nm, len);              /* increments Isize */
  598 
  599     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  600 
  601     CODA_FREE(inp, coda_rmdir_size);
  602     return error;
  603 }
  604 
  605 int
  606 venus_symlink(void *mdp, CodaFid *fid,
  607         const char *lnm, int llen, const char *nm, int len, struct vattr *va,
  608         struct ucred *cred, struct proc *p)
  609 {
  610     DECL_NO_OUT(coda_symlink);          /* sets Isize & Osize */
  611     coda_symlink_size += llen + 1 + len + 1;
  612     ALLOC_NO_OUT(coda_symlink);         /* sets inp & outp */
  613 
  614     /* send the open to venus. */
  615     INIT_IN(&inp->ih, CODA_SYMLINK, cred, p);
  616     inp->Fid = *fid;
  617     CNV_V2VV_ATTR(&inp->attr, va);
  618 
  619     inp->srcname = Isize;
  620     STRCPY(srcname, lnm, llen);         /* increments Isize */
  621 
  622     inp->tname = Isize;
  623     STRCPY(tname, nm, len);             /* increments Isize */
  624 
  625     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  626 
  627     CODA_FREE(inp, coda_symlink_size);
  628     return error;
  629 }
  630 
  631 int
  632 venus_readdir(void *mdp, CodaFid *fid,
  633         int count, int offset,
  634         struct ucred *cred, struct proc *p,
  635 /*out*/ char *buffer, int *len)
  636 {
  637     DECL(coda_readdir);                 /* sets Isize & Osize */
  638     coda_readdir_size = VC_MAXMSGSIZE;
  639     ALLOC(coda_readdir);                        /* sets inp & outp */
  640 
  641     /* send the open to venus. */
  642     INIT_IN(&inp->ih, CODA_READDIR, cred, p);
  643     inp->Fid = *fid;
  644     inp->count = count;
  645     inp->offset = offset;
  646 
  647     Osize = VC_MAXMSGSIZE;
  648     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  649     if (!error) {
  650         bcopy((char *)outp + (long)outp->data, buffer, outp->size);
  651         *len = outp->size;
  652     }
  653 
  654     CODA_FREE(inp, coda_readdir_size);
  655     return error;
  656 }
  657 
  658 int
  659 venus_fhtovp(void *mdp, CodaFid *fid,
  660         struct ucred *cred, struct proc *p,
  661 /*out*/ CodaFid *VFid, int *vtype)
  662 {
  663     DECL(coda_vget);                    /* sets Isize & Osize */
  664     ALLOC(coda_vget);                   /* sets inp & outp */
  665 
  666     /* Send the open to Venus. */
  667     INIT_IN(&inp->ih, CODA_VGET, cred, p);
  668     inp->Fid = *fid;
  669 
  670     error = coda_call(mdp, Isize, &Osize, (char *)inp);
  671     if (!error) {
  672         *VFid = outp->Fid;
  673         *vtype = outp->vtype;
  674     }
  675 
  676     CODA_FREE(inp, coda_vget_size);
  677     return error;
  678 }

Cache object: d46d5b9a434bc20b4be51eabdd29040f


[ 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.