/* $NetBSD: coda_venus.c,v 1.24 2006/05/14 21:24:49 elad Exp $ */ /* * * Coda: an Experimental Distributed File System * Release 3.1 * * Copyright (c) 1987-1998 Carnegie Mellon University * All Rights Reserved * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation, and * that credit is given to Carnegie Mellon University in all documents * and publicity pertaining to direct or indirect use of this code or its * derivatives. * * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS, * SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON * DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF * ANY DERIVATIVE WORK. * * Carnegie Mellon encourages users of this software to return any * improvements or extensions that they make, and to grant Carnegie * Mellon the rights to redistribute these changes without encumbrance. * * @(#) coda/coda_venus.c,v 1.1.1.1 1998/08/29 21:26:45 rvb Exp $ */ #include __KERNEL_RCSID(0, "$NetBSD: coda_venus.c,v 1.24 2006/05/14 21:24:49 elad Exp $"); #include #include #include #include #include #include /* for CNV_OFLAGS below */ #include #include #include #include #include #include #ifdef _KERNEL_OPT #include "opt_coda_compat.h" #endif /* * Isize and Osize are the sizes of the input and output arguments. * SEMI-INVARIANT: name##_size (e.g. coda_readlink_size) is the max of * the input and output. This invariant is not well maintained, but * should be true after ALLOC_*. Isize is modified after allocation * by STRCPY below - this is in general unsafe and needs fixing. */ #define DECL_NO_IN(name) \ struct coda_in_hdr *inp; \ struct name ## _out *outp; \ int name ## _size = sizeof (struct coda_in_hdr); \ int Isize = sizeof (struct coda_in_hdr); \ int Osize = sizeof (struct name ## _out); \ int error #define DECL(name) \ struct name ## _in *inp; \ struct name ## _out *outp; \ int name ## _size = sizeof (struct name ## _in); \ int Isize = sizeof (struct name ## _in); \ int Osize = sizeof (struct name ## _out); \ int error #define DECL_NO_OUT(name) \ struct name ## _in *inp; \ struct coda_out_hdr *outp; \ int name ## _size = sizeof (struct name ## _in); \ int Isize = sizeof (struct name ## _in); \ int Osize = sizeof (struct coda_out_hdr); \ int error #define ALLOC_NO_IN(name) \ if (Osize > name ## _size) \ name ## _size = Osize; \ CODA_ALLOC(inp, struct coda_in_hdr *, name ## _size);\ outp = (struct name ## _out *) inp #define ALLOC(name) \ if (Osize > name ## _size) \ name ## _size = Osize; \ CODA_ALLOC(inp, struct name ## _in *, name ## _size);\ outp = (struct name ## _out *) inp #define ALLOC_NO_OUT(name) \ if (Osize > name ## _size) \ name ## _size = Osize; \ CODA_ALLOC(inp, struct name ## _in *, name ## _size);\ outp = (struct coda_out_hdr *) inp #define STRCPY(struc, name, len) \ bcopy(name, (char *)inp + (int)inp->struc, len); \ ((char*)inp + (int)inp->struc)[len++] = 0; \ Isize += len /* XXX verify that Isize has not overrun available storage */ #ifdef CODA_COMPAT_5 #define INIT_IN(in, op, ident, p) \ (in)->opcode = (op); \ (in)->pid = p ? p->p_pid : -1; \ (in)->pgid = p ? p->p_pgid : -1; \ (in)->sid = (p && p->p_session && p->p_session->s_leader) ? \ (p->p_session->s_leader->p_pid) : -1; \ KASSERT(cred != NULL); \ KASSERT(cred != FSCRED); \ if (ident != NOCRED) { \ (in)->cred.cr_uid = kauth_cred_geteuid(ident); \ (in)->cred.cr_groupid = kauth_cred_getegid(ident); \ } else { \ memset(&((in)->cred), 0, sizeof(struct coda_cred)); \ (in)->cred.cr_uid = -1; \ (in)->cred.cr_groupid = -1; \ } \ #else #define INIT_IN(in, op, ident, p) \ (in)->opcode = (op); \ (in)->pid = p ? p->p_pid : -1; \ (in)->pgid = p ? p->p_pgid : -1; \ KASSERT(cred != NULL); \ KASSERT(cred != FSCRED); \ if (ident != NOCRED) { \ (in)->uid = kauth_cred_geteuid(ident); \ } else { \ (in)->uid = -1; \ } \ #endif #define INIT_IN_L(in, op, ident, l) \ INIT_IN(in, op, ident, (l ? l->l_proc : NULL)) #define CNV_OFLAG(to, from) \ do { \ to = 0; \ if (from & FREAD) to |= C_O_READ; \ if (from & FWRITE) to |= C_O_WRITE; \ if (from & O_TRUNC) to |= C_O_TRUNC; \ if (from & O_EXCL) to |= C_O_EXCL; \ if (from & O_CREAT) to |= C_O_CREAT; \ } while (/*CONSTCOND*/ 0) #define CNV_VV2V_ATTR(top, fromp) \ do { \ (top)->va_type = (fromp)->va_type; \ (top)->va_mode = (fromp)->va_mode; \ (top)->va_nlink = (fromp)->va_nlink; \ (top)->va_uid = (fromp)->va_uid; \ (top)->va_gid = (fromp)->va_gid; \ (top)->va_fsid = VNOVAL; \ (top)->va_fileid = (fromp)->va_fileid; \ (top)->va_size = (fromp)->va_size; \ (top)->va_blocksize = (fromp)->va_blocksize; \ (top)->va_atime = (fromp)->va_atime; \ (top)->va_mtime = (fromp)->va_mtime; \ (top)->va_ctime = (fromp)->va_ctime; \ (top)->va_gen = (fromp)->va_gen; \ (top)->va_flags = (fromp)->va_flags; \ (top)->va_rdev = (fromp)->va_rdev; \ (top)->va_bytes = (fromp)->va_bytes; \ (top)->va_filerev = (fromp)->va_filerev; \ (top)->va_vaflags = VNOVAL; \ (top)->va_spare = VNOVAL; \ } while (/*CONSTCOND*/ 0) #define CNV_V2VV_ATTR(top, fromp) \ do { \ (top)->va_type = (fromp)->va_type; \ (top)->va_mode = (fromp)->va_mode; \ (top)->va_nlink = (fromp)->va_nlink; \ (top)->va_uid = (fromp)->va_uid; \ (top)->va_gid = (fromp)->va_gid; \ (top)->va_fileid = (fromp)->va_fileid; \ (top)->va_size = (fromp)->va_size; \ (top)->va_blocksize = (fromp)->va_blocksize; \ (top)->va_atime = (fromp)->va_atime; \ (top)->va_mtime = (fromp)->va_mtime; \ (top)->va_ctime = (fromp)->va_ctime; \ (top)->va_gen = (fromp)->va_gen; \ (top)->va_flags = (fromp)->va_flags; \ (top)->va_rdev = (fromp)->va_rdev; \ (top)->va_bytes = (fromp)->va_bytes; \ (top)->va_filerev = (fromp)->va_filerev; \ } while (/*CONSTCOND*/ 0) int coda_kernel_version = CODA_KERNEL_VERSION; int venus_root(void *mdp, kauth_cred_t cred, struct proc *p, /*out*/ CodaFid *VFid) { DECL_NO_IN(coda_root); /* sets Isize & Osize */ ALLOC_NO_IN(coda_root); /* sets inp & outp */ /* send the open to venus. */ INIT_IN(inp, CODA_ROOT, cred, p); error = coda_call(mdp, Isize, &Osize, (char *)inp); if (!error) *VFid = outp->Fid; CODA_FREE(inp, coda_root_size); return error; } int venus_open(void *mdp, CodaFid *fid, int flag, kauth_cred_t cred, struct lwp *l, /*out*/ dev_t *dev, ino_t *inode) { int cflag; DECL(coda_open); /* sets Isize & Osize */ ALLOC(coda_open); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_OPEN, cred, l); inp->Fid = *fid; CNV_OFLAG(cflag, flag); inp->flags = cflag; error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *dev = outp->dev; *inode = outp->inode; } CODA_FREE(inp, coda_open_size); return error; } int venus_close(void *mdp, CodaFid *fid, int flag, kauth_cred_t cred, struct lwp *l) { int cflag; DECL_NO_OUT(coda_close); /* sets Isize & Osize */ ALLOC_NO_OUT(coda_close); /* sets inp & outp */ INIT_IN_L(&inp->ih, CODA_CLOSE, cred, l); inp->Fid = *fid; CNV_OFLAG(cflag, flag); inp->flags = cflag; error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_close_size); return error; } /* * these two calls will not exist!!! the container file is read/written * directly. */ void venus_read(void) { } void venus_write(void) { } /* * this is a bit sad too. the ioctl's are for the control file, not for * normal files. */ int venus_ioctl(void *mdp, CodaFid *fid, int com, int flag, caddr_t data, kauth_cred_t cred, struct lwp *l) { DECL(coda_ioctl); /* sets Isize & Osize */ struct PioctlData *iap = (struct PioctlData *)data; int tmp; coda_ioctl_size = VC_MAXMSGSIZE; ALLOC(coda_ioctl); /* sets inp & outp */ INIT_IN_L(&inp->ih, CODA_IOCTL, cred, l); inp->Fid = *fid; /* command was mutated by increasing its size field to reflect the * path and follow args. we need to subtract that out before sending * the command to venus. */ inp->cmd = (com & ~(IOCPARM_MASK << 16)); tmp = ((com >> 16) & IOCPARM_MASK) - sizeof (char *) - sizeof (int); inp->cmd |= (tmp & IOCPARM_MASK) << 16; if (iap->vi.in_size < 0 || iap->vi.in_size > VC_MAXMSGSIZE) { CODA_FREE(inp, coda_ioctl_size); return (EINVAL); } inp->rwflag = flag; inp->len = iap->vi.in_size; inp->data = (char *)(sizeof (struct coda_ioctl_in)); error = copyin(iap->vi.in, (char*)inp + (int)(long)inp->data, iap->vi.in_size); if (error) { CODA_FREE(inp, coda_ioctl_size); return(error); } Osize = VC_MAXMSGSIZE; error = coda_call(mdp, Isize + iap->vi.in_size, &Osize, (char *)inp); /* copy out the out buffer. */ if (!error) { if (outp->len > iap->vi.out_size) { error = EINVAL; } else { error = copyout((char *)outp + (int)(long)outp->data, iap->vi.out, iap->vi.out_size); } } CODA_FREE(inp, coda_ioctl_size); return error; } int venus_getattr(void *mdp, CodaFid *fid, kauth_cred_t cred, struct lwp *l, /*out*/ struct vattr *vap) { DECL(coda_getattr); /* sets Isize & Osize */ ALLOC(coda_getattr); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_GETATTR, cred, l); inp->Fid = *fid; error = coda_call(mdp, Isize, &Osize, (char *)inp); if (!error) { CNV_VV2V_ATTR(vap, &outp->attr); } CODA_FREE(inp, coda_getattr_size); return error; } int venus_setattr(void *mdp, CodaFid *fid, struct vattr *vap, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_setattr); /* sets Isize & Osize */ ALLOC_NO_OUT(coda_setattr); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_SETATTR, cred, l); inp->Fid = *fid; CNV_V2VV_ATTR(&inp->attr, vap); error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_setattr_size); return error; } int venus_access(void *mdp, CodaFid *fid, int mode, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_access); /* sets Isize & Osize */ ALLOC_NO_OUT(coda_access); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_ACCESS, cred, l); inp->Fid = *fid; inp->flags = mode; error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_access_size); return error; } int venus_readlink(void *mdp, CodaFid *fid, kauth_cred_t cred, struct lwp *l, /*out*/ char **str, int *len) { DECL(coda_readlink); /* sets Isize & Osize */ /* XXX coda_readlink_size should not be set here */ coda_readlink_size += CODA_MAXPATHLEN; Osize += CODA_MAXPATHLEN; ALLOC(coda_readlink); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_READLINK, cred, l); inp->Fid = *fid; error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (error != 0) goto out; /* Check count for reasonableness */ if (outp->count <= 0 || outp->count > CODA_MAXPATHLEN) { printf("venus_readlink: bad count %d\n", outp->count); error = EINVAL; goto out; } /* * Check data pointer for reasonableness. It must point after * itself, and within the allocated region. */ if ((intptr_t) outp->data < sizeof(struct coda_readlink_out) ) { printf("venus_readlink: data pointer %lld too low\n", (long long)((intptr_t) outp->data)); error = EINVAL; goto out; } if ((intptr_t) outp->data + outp->count > sizeof(struct coda_readlink_out) + CODA_MAXPATHLEN) { printf("venus_readlink: data pointer %lld too high\n", (long long)((intptr_t) outp->data)); error = EINVAL; goto out; } if (!error) { CODA_ALLOC(*str, char *, outp->count); *len = outp->count; bcopy((char *)outp + (int)(long)outp->data, *str, *len); } out: CODA_FREE(inp, coda_readlink_size); return error; } int venus_fsync(void *mdp, CodaFid *fid, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_fsync); /* sets Isize & Osize */ ALLOC_NO_OUT(coda_fsync); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_FSYNC, cred, l); inp->Fid = *fid; error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_fsync_size); return error; } int venus_lookup(void *mdp, CodaFid *fid, const char *nm, int len, kauth_cred_t cred, struct lwp *l, /*out*/ CodaFid *VFid, int *vtype) { DECL(coda_lookup); /* sets Isize & Osize */ coda_lookup_size += len + 1; ALLOC(coda_lookup); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_LOOKUP, cred, l); inp->Fid = *fid; /* NOTE: * Between version 1 and version 2 we have added an extra flag field * to this structure. But because the string was at the end and because * of the weird way we represent strings by having the slot point to * where the string characters are in the "heap", we can just slip the * flag parameter in after the string slot pointer and veni that don't * know better won't see this new flag field ... * Otherwise we'd need two different venus_lookup functions. */ inp->name = Isize; inp->flags = CLU_CASE_SENSITIVE; /* doesn't really matter for BSD */ /* This is safe because we preallocated len+1 extra. */ STRCPY(name, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *VFid = outp->Fid; *vtype = outp->vtype; } CODA_FREE(inp, coda_lookup_size); return error; } int venus_create(void *mdp, CodaFid *fid, const char *nm, int len, int exclusive, int mode, struct vattr *va, kauth_cred_t cred, struct lwp *l, /*out*/ CodaFid *VFid, struct vattr *attr) { DECL(coda_create); /* sets Isize & Osize */ coda_create_size += len + 1; ALLOC(coda_create); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_CREATE, cred, l); inp->Fid = *fid; inp->excl = exclusive ? C_O_EXCL : 0; inp->mode = mode<<6; CNV_V2VV_ATTR(&inp->attr, va); inp->name = Isize; STRCPY(name, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *VFid = outp->Fid; CNV_VV2V_ATTR(attr, &outp->attr); } CODA_FREE(inp, coda_create_size); return error; } int venus_remove(void *mdp, CodaFid *fid, const char *nm, int len, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_remove); /* sets Isize & Osize */ coda_remove_size += len + 1; ALLOC_NO_OUT(coda_remove); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_REMOVE, cred, l); inp->Fid = *fid; inp->name = Isize; STRCPY(name, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_remove_size); return error; } int venus_link(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_link); /* sets Isize & Osize */ coda_link_size += len + 1; ALLOC_NO_OUT(coda_link); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_LINK, cred, l); inp->sourceFid = *fid; inp->destFid = *tfid; inp->tname = Isize; STRCPY(tname, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_link_size); return error; } int venus_rename(void *mdp, CodaFid *fid, CodaFid *tfid, const char *nm, int len, const char *tnm, int tlen, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_rename); /* sets Isize & Osize */ coda_rename_size += len + 1 + tlen + 1; ALLOC_NO_OUT(coda_rename); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_RENAME, cred, l); inp->sourceFid = *fid; inp->destFid = *tfid; inp->srcname = Isize; STRCPY(srcname, nm, len); /* increments Isize */ inp->destname = Isize; STRCPY(destname, tnm, tlen); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_rename_size); return error; } int venus_mkdir(void *mdp, CodaFid *fid, const char *nm, int len, struct vattr *va, kauth_cred_t cred, struct lwp *l, /*out*/ CodaFid *VFid, struct vattr *ova) { DECL(coda_mkdir); /* sets Isize & Osize */ coda_mkdir_size += len + 1; ALLOC(coda_mkdir); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_MKDIR, cred, l); inp->Fid = *fid; CNV_V2VV_ATTR(&inp->attr, va); inp->name = Isize; STRCPY(name, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *VFid = outp->Fid; CNV_VV2V_ATTR(ova, &outp->attr); } CODA_FREE(inp, coda_mkdir_size); return error; } int venus_rmdir(void *mdp, CodaFid *fid, const char *nm, int len, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_rmdir); /* sets Isize & Osize */ coda_rmdir_size += len + 1; ALLOC_NO_OUT(coda_rmdir); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_RMDIR, cred, l); inp->Fid = *fid; inp->name = Isize; STRCPY(name, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_rmdir_size); return error; } int venus_symlink(void *mdp, CodaFid *fid, const char *lnm, int llen, const char *nm, int len, struct vattr *va, kauth_cred_t cred, struct lwp *l) { DECL_NO_OUT(coda_symlink); /* sets Isize & Osize */ coda_symlink_size += llen + 1 + len + 1; ALLOC_NO_OUT(coda_symlink); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_SYMLINK, cred, l); inp->Fid = *fid; CNV_V2VV_ATTR(&inp->attr, va); inp->srcname = Isize; STRCPY(srcname, lnm, llen); /* increments Isize */ inp->tname = Isize; STRCPY(tname, nm, len); /* increments Isize */ error = coda_call(mdp, Isize, &Osize, (char *)inp); CODA_FREE(inp, coda_symlink_size); return error; } int venus_readdir(void *mdp, CodaFid *fid, int count, int offset, kauth_cred_t cred, struct lwp *l, /*out*/ char *buffer, int *len) { DECL(coda_readdir); /* sets Isize & Osize */ coda_readdir_size = VC_MAXMSGSIZE; ALLOC(coda_readdir); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_READDIR, cred, l); inp->Fid = *fid; inp->count = count; inp->offset = offset; Osize = VC_MAXMSGSIZE; error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { bcopy((char *)outp + (int)(long)outp->data, buffer, outp->size); *len = outp->size; } CODA_FREE(inp, coda_readdir_size); return error; } int venus_statfs(void *mdp, kauth_cred_t cred, struct lwp *l, /*out*/ struct coda_statfs *fsp) { DECL(coda_statfs); /* sets Isize & Osize */ ALLOC(coda_statfs); /* sets inp & outp */ /* send the open to venus. */ INIT_IN_L(&inp->ih, CODA_STATFS, cred, l); error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *fsp = outp->stat; } CODA_FREE(inp, coda_statfs_size); return error; } int venus_fhtovp(void *mdp, CodaFid *fid, kauth_cred_t cred, struct proc *p, /*out*/ CodaFid *VFid, int *vtype) { DECL(coda_vget); /* sets Isize & Osize */ ALLOC(coda_vget); /* sets inp & outp */ /* Send the open to Venus. */ INIT_IN(&inp->ih, CODA_VGET, cred, p); inp->Fid = *fid; error = coda_call(mdp, Isize, &Osize, (char *)inp); KASSERT(outp != NULL); if (!error) { *VFid = outp->Fid; *vtype = outp->vtype; } CODA_FREE(inp, coda_vget_size); return error; }