root/xfs/xfs_syscalls-common.c

DEFINITIONS

1. xfs_crcopy
2. sys_xfspioctl
3. xfs_is_pag
4. xfs_get_pag
5. store_pag
6. xfs_setpag_call
7. xfs_unpag
8. xfs_setgroups
9. lookup_node
10. getfh_compat
11. trad_fhget
12. fhget_call
13. fhopen_call
14. remote_pioctl
15. xfs_debug
16. xfs_pioctl_call

    1 /*
    2  * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan
    3  * (Royal Institute of Technology, Stockholm, Sweden).
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  *
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  *
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * 3. Neither the name of the Institute nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  */
   34 #include <xfs/xfs_locl.h>
RCSID("$arla: xfs_syscalls-common.c,v 1.72 2003/01/19 20:53:49 lha Exp $");
   38 /*
   39  * NNPFS system calls.
   40  */
   42 #include <xfs/xfs_syscalls.h>
   43 #include <xfs/xfs_message.h>
   44 #include <xfs/xfs_fs.h>
   45 #include <xfs/xfs_dev.h>
   46 #include <xfs/xfs_node.h>
   47 #include <xfs/xfs_vfsops.h>
   48 #include <xfs/xfs_deb.h>
   50 /* Misc syscalls */
   51 #ifdef HAVE_SYS_IOCCOM_H
   52 #include <sys/ioccom.h>
   53 #elif defined(HAVE_SYS_IOCTL_H)
   54 #include <sys/ioctl.h>
   55 #endif
   56 /*
   57  * XXX - horrible kludge.  If we are openbsd and not building an lkm,
   58  *     then use their headerfile.
   59  */
   60 #if (defined(__OpenBSD__) || defined(__NetBSD__)) && !defined(_LKM)
   61 #define NNPFS_NOT_LKM 1
   62 #elif defined(__FreeBSD__) && !defined(KLD_MODULE)
   63 #define NNPFS_NOT_LKM 1
   64 #endif
   66 #ifdef NNPFS_NOT_LKM
   67 #include <xfs/xfs_pioctl.h>
   68 #else
   69 #include <kafs.h>
   70 #endif
   72 int (*old_setgroups_func)(syscall_d_thread_t *p, void *v, register_t *retval);
   74 #if defined(__FreeBSD__) && __FreeBSD_version >= 500026
   75 /*
   76  * XXX This is wrong
   77  */
   78 static struct ucred *
xfs_crcopy(struct ucred *cr)
   80 {
   81     struct ucred *ncr;
   83     if (crshared(cr)) {
ncr = crdup(cr);
crfree(cr);
   86         return ncr;
   87     }
   88     return cr;
   89 }
   90 #else
   91 #define xfs_crcopy crcopy
   92 #endif
   95 /*
   96  * the syscall entry point
   97  */
   99 #ifdef NNPFS_NOT_LKM
  100 int
sys_xfspioctl(syscall_d_thread_t *proc, void *varg, register_t *return_value)
  102 #else
  103 int
xfspioctl(syscall_d_thread_t *proc, void *varg, register_t *return_value)
  105 #endif
  106 {
  107 #ifdef NNPFS_NOT_LKM
  108     struct sys_xfspioctl_args *arg = (struct sys_xfspioctl_args *) varg;
  109 #else
  110     struct sys_pioctl_args *arg = (struct sys_pioctl_args *) varg;
  111 #endif
  112     int error = EINVAL;
  114     switch (SCARG(arg, operation)) {
  115     case AFSCALL_PIOCTL:
error = xfs_pioctl_call(syscall_thread_to_thread(proc),
varg, return_value);
  118         break;
  119     case AFSCALL_SETPAG:
  120 #ifdef HAVE_FREEBSD_THREAD
error = xfs_setpag_call(&xfs_thread_to_cred(proc));
  122 #else
error = xfs_setpag_call(&xfs_proc_to_cred(syscall_thread_to_thread(proc)));
  124 #endif
  125         break;
  126     default:
NNPFSDEB(XDEBSYS, ("Unimplemeted xfspioctl: %d\n",
SCARG(arg, operation)));
error = EINVAL;
  130         break;
  131     }
  133     return error;
  134 }
  136 /*
  137  * Def pag:
  138  *  33536 <= g0 <= 34560
  139  *  32512 <= g1 <= 48896
  140  */
  142 #define NNPFS_PAG1_LLIM 33536
  143 #define NNPFS_PAG1_ULIM 34560
  144 #define NNPFS_PAG2_LLIM 32512
  145 #define NNPFS_PAG2_ULIM 48896
  147 static gid_t pag_part_one = NNPFS_PAG1_LLIM;
  148 static gid_t pag_part_two = NNPFS_PAG2_LLIM;
  150 /*
  151  * Is `cred' member of a PAG?
  152  */
  154 static int
xfs_is_pag(struct ucred *cred)
  156 {
  157     /* The first group is the gid of the user ? */
  159     if (cred->cr_ngroups >= 3 &&
cred->cr_groups[1] >= NNPFS_PAG1_LLIM &&
cred->cr_groups[1] <= NNPFS_PAG1_ULIM &&
cred->cr_groups[2] >= NNPFS_PAG2_LLIM &&
cred->cr_groups[2] <= NNPFS_PAG2_ULIM)
  164         return 1;
  165     else
  166         return 0;
  167 }
  169 /*
  170  * Return the pag used by `cred'
  171  */
xfs_pag_t
xfs_get_pag(struct ucred *cred)
  175 {
  176     if (xfs_is_pag(cred)) {
  178         return (((cred->cr_groups[1] << 16) & 0xFFFF0000) |
  179                 ((cred->cr_groups[2] & 0x0000FFFF)));
  181     } else
  182         return cred->cr_uid;           /* XXX */
  183 }
  185 /*
  186  * Set the pag in `ret_cred' and return a new cred.
  187  */
  189 static int
store_pag (struct ucred **ret_cred, gid_t part1, gid_t part2)
  191 {
  192     struct ucred *cred = *ret_cred;
  194     if (!xfs_is_pag (cred)) {
  195         int i;
  197         if (cred->cr_ngroups + 2 >= NGROUPS)
  198             return E2BIG;
cred = xfs_crcopy (cred);
  202         for (i = cred->cr_ngroups - 1; i > 0; i--) {
cred->cr_groups[i + 2] = cred->cr_groups[i];
  204         }
cred->cr_ngroups += 2;
  206     } else {
cred = xfs_crcopy (cred);
  208     }
cred->cr_groups[1] = part1;
cred->cr_groups[2] = part2;
  211     *ret_cred = cred;
  213     return 0;
  214 }
  216 /*
  217  * Acquire a new pag in `ret_cred'
  218  */
  220 int
xfs_setpag_call(struct ucred **ret_cred)
  222 {
  223     int ret;
ret = store_pag (ret_cred, pag_part_one, pag_part_two++);
  226     if (ret)
  227         return ret;
  229     if (pag_part_two > NNPFS_PAG2_ULIM) {
pag_part_one++;
pag_part_two = NNPFS_PAG2_LLIM;
  232     }
  233     return 0;
  234 }
  236 #ifndef NNPFS_NOT_LKM
  237 /*
  238  * remove a pag
  239  */
  241 static int
xfs_unpag (struct ucred *cred)
  243 {
  244     while (xfs_is_pag (cred)) {
  245         int i;
  247         for (i = 0; i < cred->cr_ngroups - 2; ++i)
cred->cr_groups[i] = cred->cr_groups[i+2];
cred->cr_ngroups -= 2;
  250     }
  251     return 0;
  252 }
  254 /*
  255  * A wrapper around setgroups that preserves the pag.
  256  */
  258 int
xfs_setgroups (syscall_d_thread_t *p,
  260                void *varg,
register_t *retval)
  262 {
  263     struct xfs_setgroups_args *uap = (struct xfs_setgroups_args *)varg;
  264 #ifdef HAVE_FREEBSD_THREAD
  265     struct ucred **cred = &xfs_thread_to_cred(p);
  266 #else
  267     struct ucred **cred = &xfs_proc_to_cred(syscall_thread_to_thread(p));
  268 #endif
  270     if (xfs_is_pag (*cred)) {
gid_t part1, part2;
  272         int ret;
  274         if (SCARG(uap,gidsetsize) + 2 > NGROUPS)
  275             return EINVAL;
part1 = (*cred)->cr_groups[1];
part2 = (*cred)->cr_groups[2];
ret = (*old_setgroups_func) (p, uap, retval);
  280         if (ret)
  281             return ret;
  282         return store_pag (cred, part1, part2);
  283     } else {
  284         int ret;
ret = (*old_setgroups_func) (p, uap, retval);
  287         /* don't support setting a PAG */
  288         if (xfs_is_pag (*cred)) {
xfs_unpag (*cred);
  290             return EINVAL;
  291         }
  292         return ret;
  293     }
  294 }
  295 #endif /* !NNPFS_NOT_LKM */
  297 /*
  298  * Return the vnode corresponding to `pathptr'
  299  */
  301 static int
lookup_node (const char *pathptr,
  303              int follow_links_p,
  304              struct vnode **res,
d_thread_t *proc)
  306 {
  307     int error;
  308     char path[MAXPATHLEN];
  309 #ifdef __osf__
  310     struct nameidata *ndp = &u.u_nd;
  311 #else
  312     struct nameidata nd, *ndp = &nd;
  313 #endif
  314     struct vnode *vp;
size_t count;
NNPFSDEB(XDEBSYS, ("xfs_syscall: looking up: %lx\n",
  318                      (unsigned long)pathptr));
error = copyinstr((char *) pathptr, path, MAXPATHLEN, &count);
NNPFSDEB(XDEBSYS, ("xfs_syscall: looking up: %s, error: %d\n", path, error));
  324     if (error)
  325         return error;
NDINIT(ndp, LOOKUP,
follow_links_p ? FOLLOW : 0,
UIO_SYSSPACE, path, proc);
error = namei(ndp);
  333     if (error != 0) {
NNPFSDEB(XDEBSYS, ("xfs_syscall: error during namei: %d\n", error));
  335         return EINVAL;
  336     }
vp = ndp->ni_vp;
  340     *res = vp;
  341     return 0;
  342 }
  344 /*
  345  * implement xfs fhget in a way that should be compatible with the native
  346  * getfh
  347  */
  349 static int
getfh_compat (d_thread_t *p,
  351               struct ViceIoctl *vice_ioctl,
  352               struct vnode *vp)
  353 {
  354     /* This is to be same as getfh */
fhandle_t fh;
  356     int error;
bzero((caddr_t)&fh, sizeof(fh));
fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
  360 #if __osf__
VFS_VPTOFH(vp, &fh.fh_fid, error);
  362 #else
error = VFS_VPTOFH(vp, &fh.fh_fid);
  364 #endif
  365     if (error)
  366         return error;
  368     if (vice_ioctl->out_size < sizeof(fh))
  369         return EINVAL;
  371     return copyout((caddr_t)&fh, vice_ioctl->out, sizeof (fh));
  372 }
  374 /*
  375  * implement xfs fhget by combining (dev, ino, generation)
  376  */
  378 #ifndef __OpenBSD__
  379 static int
trad_fhget (d_thread_t *p,
  381             struct ViceIoctl *vice_ioctl,
  382             struct vnode *vp)
  383 {
  384     int error;
  385     struct mount *mnt;
  386     struct vattr vattr;
size_t len;
  388     struct xfs_fhandle_t xfs_handle;
  389     struct xfs_fh_args fh_args;
  391 #ifdef HAVE_FREEBSD_THREAD
xfs_vop_getattr(vp, &vattr, xfs_thread_to_cred(p), p, error);
  393 #else
xfs_vop_getattr(vp, &vattr, xfs_proc_to_cred(p), p, error);
  395 #endif
  396     if (error)
  397         return error;
mnt = vp->v_mount;
SCARG(&fh_args, fsid)   = mnt->mnt_stat.f_fsid;
SCARG(&fh_args, fileid) = vattr.va_fileid;
SCARG(&fh_args, gen)    = vattr.va_gen;
xfs_handle.len = sizeof(fh_args);
memcpy (xfs_handle.fhdata, &fh_args, sizeof(fh_args));
len = sizeof(xfs_handle);
  409     if (vice_ioctl->out_size < len)
  410         return EINVAL;
error = copyout (&xfs_handle, vice_ioctl->out, len);
  413     if (error) {
NNPFSDEB(XDEBSYS, ("fhget_call: copyout failed: %d\n", error));
  415     }
  416     return error;
  417 }
  418 #endif  /* ! __OpenBSD__ */
  420 /*
  421  * return file handle of `vp' in vice_ioctl->out
  422  * vp is vrele:d
  423  */
  425 static int
fhget_call (d_thread_t *p,
  427             struct ViceIoctl *vice_ioctl,
  428             struct vnode *vp)
  429 {
  430     int error;
NNPFSDEB(XDEBSYS, ("fhget_call\n"));
  434     if (vp == NULL)
  435         return EBADF;
  437 #if defined(__APPLE__) || defined(__osf__)
error = EINVAL; /* XXX: Leaks vnodes if fhget/fhopen is used */
  439     goto out;
  440 #endif
error = xfs_suser (p);
  443     if (error)
  444         goto out;
  446 #if (defined(HAVE_GETFH) && defined(HAVE_FHOPEN)) || defined(__osf__)
error = getfh_compat (p, vice_ioctl, vp);
  448 #else
error = trad_fhget (p, vice_ioctl, vp);
  450 #endif /* HAVE_GETFH && HAVE_FHOPEN */
out:
vrele(vp);
  453     return error;
  454 }
  456 /*
  457  * open the file specified in `vice_ioctl->in'
  458  */
  460 static int
fhopen_call (d_thread_t *p,
  462              struct ViceIoctl *vice_ioctl,
  463              struct vnode *vp,
  464              int flags,
register_t *retval)
  466 {
NNPFSDEB(XDEBSYS, ("fhopen_call: flags = %d\n", flags));
  470     if (vp != NULL) {
vrele (vp);
  472         return EINVAL;
  473     }
  475 #if defined(__APPLE__) || defined(__osf__)
  476     return EINVAL; /* XXX: Leaks vnodes if fhget/fhopen is used */
  477 #endif
  479     return xfs_fhopen (p,
  480                        (struct xfs_fhandle_t *)vice_ioctl->in,
flags,
retval);
  483 }
  485 /*
  486  * Send the pioctl to arlad
  487  */
  489 static int
remote_pioctl (d_thread_t *p,
  491                struct sys_pioctl_args *arg,
  492                struct ViceIoctl *vice_ioctl,
  493                struct vnode *vp)
  494 {
  495     int error = 0;
  496     struct xfs_message_pioctl *msg = NULL;
  497     struct xfs_message_wakeup_data *msg2;
msg = malloc(sizeof(struct xfs_message_symlink), M_TEMP, M_WAITOK);
  500     if (msg == NULL) {
error = ENOMEM;
  502         goto done;
  503     }
memset(msg, 0, sizeof(*msg));
  506     if (vp != NULL) {
  507         struct xfs_node *xn;
  509         if (vp->v_tag != VT_XFS) {
NNPFSDEB(XDEBSYS, ("xfs_syscall: file is not in afs\n"));
vrele(vp);
error = EINVAL;
  513             goto done;
  514         }
xn = VNODE_TO_XNODE(vp);
msg->handle = xn->handle;
vrele(vp);
  520     }
  522     if (vice_ioctl->in_size < 0) {
printf("xfs: remote pioctl: got a negative data size: opcode: %d",
SCARG(arg, a_opcode));
error = EINVAL;
  526         goto done;
  527     }
  529     if (vice_ioctl->in_size > NNPFS_MSG_MAX_DATASIZE) {
printf("xfs_pioctl_call: got a humongous in packet: opcode: %d",
SCARG(arg, a_opcode));
error = EINVAL;
  533         goto done;
  534     }
  535     if (vice_ioctl->in_size != 0) {
error = copyin(vice_ioctl->in, msg->msg, vice_ioctl->in_size);
  537         if (error)
  538           goto done;
  539     }
msg->header.opcode = NNPFS_MSG_PIOCTL;
msg->header.size = sizeof(*msg);
msg->opcode = SCARG(arg, a_opcode);
msg->insize = vice_ioctl->in_size;
msg->outsize = vice_ioctl->out_size;
  547 #ifdef HAVE_FREEBSD_THREAD
msg->cred.uid = xfs_thread_to_euid(p);
msg->cred.pag = xfs_get_pag(xfs_thread_to_cred(p));
  550 #else
msg->cred.uid = xfs_proc_to_euid(p);
msg->cred.pag = xfs_get_pag(xfs_proc_to_cred(p));
  553 #endif
error = xfs_message_rpc(0, &(msg->header), sizeof(*msg), p); /* XXX */
msg2 = (struct xfs_message_wakeup_data *) msg;
  558     if (error == 0)
error = msg2->error;
  560     if (error == ENODEV)
error = EINVAL;
  563     if (error == 0 && msg2->header.opcode == NNPFS_MSG_WAKEUP_DATA) {
  564         int len;
len = msg2->len;
  567         if (len > vice_ioctl->out_size)
len = vice_ioctl->out_size;
  569         if (len > NNPFS_MSG_MAX_DATASIZE)
len = NNPFS_MSG_MAX_DATASIZE;
  571         if (len < 0)
len = 0;
error = copyout(msg2->msg, vice_ioctl->out, len);
  575     }
done:
free(msg, M_TEMP);
  578     return error;
  579 }
  581 static int
xfs_debug (d_thread_t *p,
  583            struct ViceIoctl *vice_ioctl)
  584 {
int32_t flags;
  586     int error;
  588     if (vice_ioctl->in_size != 0) {
  589         if (vice_ioctl->in_size < sizeof(int32_t))
  590             return EINVAL;
error = xfs_suser (p);
  593         if (error)
  594             return error;
error = copyin (vice_ioctl->in,
  597                         &flags,
  598                         sizeof(flags));
  599         if (error)
  600             return error;
xfsdeb = flags;
  603     }
  605     if (vice_ioctl->out_size != 0) {
  606         if (vice_ioctl->out_size < sizeof(int32_t))
  607             return EINVAL;
error = copyout (&xfsdeb,
vice_ioctl->out,
  611                          sizeof(int32_t));
  612         if (error)
  613             return error;
  614     }
  616     return 0;
  617 }
  620 /*
  621  * Handle `pioctl'
  622  */
  624 int
xfs_pioctl_call(d_thread_t *proc,
  626                 struct sys_pioctl_args *arg,
register_t *return_value)
  628 {
  629     int error;
  630     struct ViceIoctl vice_ioctl;
  631     char *pathptr;
  632     struct vnode *vp = NULL;
NNPFSDEB(XDEBSYS, ("xfs_syscall(%d, %lx, %d, %lx, %d)\n", 
SCARG(arg, operation),
  636                      (unsigned long)SCARG(arg, a_pathP),
SCARG(arg, a_opcode),
  638                      (unsigned long)SCARG(arg, a_paramsP),
SCARG(arg, a_followSymlinks)));
  641     /* Copy in the data structure for us */
error = copyin(SCARG(arg, a_paramsP),
  644                    &vice_ioctl,
  645                    sizeof(vice_ioctl));
  647     if (error)
  648         return error;
pathptr = SCARG(arg, a_pathP);
  652     if (pathptr != NULL) {
error = lookup_node (pathptr, SCARG(arg, a_followSymlinks), &vp,
proc);
  655         if(error)
  656             return error;
  657     }
  659     switch (SCARG(arg, a_opcode)) {
  660     case VIOC_FHGET :
  661         return fhget_call (proc, &vice_ioctl, vp);
  662     case VIOC_FHOPEN :
  663         return fhopen_call (proc, &vice_ioctl, vp,
SCARG(arg, a_followSymlinks), return_value);
  665     case VIOC_XFSDEBUG :
  666         if (vp != NULL)
vrele (vp);
  668         return xfs_debug (proc, &vice_ioctl);
  669     default :
NNPFSDEB(XDEBSYS, ("a_opcode = %x\n", SCARG(arg, a_opcode)));
  671         return remote_pioctl (proc, arg, &vice_ioctl, vp);
  672     }
  673 }