Add structures and skeleton code for a new system call called syslink()
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 6 Aug 2006 18:56:46 +0000 (18:56 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 6 Aug 2006 18:56:46 +0000 (18:56 +0000)
which will support the kernel syslink API.  This is the link protocol that
will be used for user<->kernel (e.g. user VFS) and kernel<->kernel (cluster)
communications.

Syslink-based protocols will be used for DEV, VFS, CCMS, and other
cluster-related operations.

14 files changed:
sys/conf/files
sys/kern/init_sysent.c
sys/kern/kern_syslink.c [new file with mode: 0644]
sys/kern/makesyscalls.sh
sys/kern/syscalls.c
sys/kern/syscalls.master
sys/sys/file.h
sys/sys/syscall-hide.h
sys/sys/syscall.h
sys/sys/syscall.mk
sys/sys/syslink.h
sys/sys/syslink_msg.h
sys/sys/sysproto.h
sys/sys/sysunion.h

index 2ae61ad..48aed70 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/sys/conf/files,v 1.340.2.137 2003/06/04 17:10:30 sam Exp $
-# $DragonFly: src/sys/conf/files,v 1.133 2006/08/06 10:32:23 sephe Exp $
+# $DragonFly: src/sys/conf/files,v 1.134 2006/08/06 18:56:42 dillon Exp $
 #
 # The long compile-with and dependency lines are required because of
 # limitations in config: backslash-newline doesn't work in strings, and
@@ -519,6 +519,7 @@ kern/kern_resource.c        standard
 kern/kern_plimit.c     standard
 kern/kern_slaballoc.c  standard
 kern/kern_systimer.c   standard
+kern/kern_syslink.c    standard
 kern/kern_cputimer.c   standard
 kern/kern_mpipe.c      standard
 kern/kern_shutdown.c   standard
index b41bb65..e4be5de 100644 (file)
@@ -2,8 +2,8 @@
  * System call switch table.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/kern/init_sysent.c,v 1.42 2006/06/13 21:04:16 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/kern/init_sysent.c,v 1.43 2006/08/06 18:56:44 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 #include "opt_compat.h"
@@ -518,4 +518,5 @@ struct sysent sysent[] = {
        { AS(usched_set_args), (sy_call_t *)sys_usched_set },   /* 481 = usched_set */
        { AS(__accept_args), (sy_call_t *)sys___accept },       /* 482 = __accept */
        { AS(__connect_args), (sy_call_t *)sys___connect },     /* 483 = __connect */
+       { AS(syslink_args), (sy_call_t *)sys_syslink }, /* 484 = syslink */
 };
diff --git a/sys/kern/kern_syslink.c b/sys/kern/kern_syslink.c
new file mode 100644 (file)
index 0000000..b721b3e
--- /dev/null
@@ -0,0 +1,663 @@
+/*
+ * Copyright (c) 2006 The DragonFly Project.  All rights reserved.
+ * 
+ * This code is derived from software contributed to The DragonFly Project
+ * by Matthew Dillon <dillon@backplane.com>
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name of The DragonFly Project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific, prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $DragonFly: src/sys/kern/kern_syslink.c,v 1.1 2006/08/06 18:56:44 dillon Exp $
+ */
+/*
+ * This module implements the syslink() system call and protocol which
+ * is used to glue clusters together as well as to interface userland
+ * devices and filesystems to the kernel.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/file.h>
+#include <sys/proc.h>
+#include <sys/lock.h>
+#include <sys/uio.h>
+#include <sys/thread.h>
+#include <sys/sysctl.h>
+#include <sys/sysproto.h>
+#include <sys/syslink.h>
+#include <sys/syslink_msg.h>
+
+#include <sys/thread2.h>
+
+/*
+ * fileops interface.  slbuf and sldata are also used in conjunction with a
+ * normal file descriptor.
+ */
+
+struct slbuf {
+    char       *buf;
+    int                bufsize;        /* must be a power of 2 */
+    int                bufmask;        /* (bufsize - 1) */
+    int                rindex;         /* tail-chasing FIFO indices */
+    int                windex;
+};
+
+struct sldata {
+    struct slbuf rbuf;
+    struct slbuf wbuf;
+    struct file        *xfp;           /* external file pointer */
+    struct lock rlock;         /* synchronizing lock */
+    struct lock wlock;         /* synchronizing lock */
+    struct thread *rthread;    /* xfp -> rbuf & process */
+    struct thread *wthread;    /* wbuf -> xfp */
+    int flags;
+    int refs;
+};
+
+#define SLF_RQUIT      0x0001
+#define SLF_WQUIT      0x0002
+#define SLF_RDONE      0x0004
+#define SLF_WDONE      0x0008
+
+#define SYSLINK_BUFSIZE        (128*1024)
+
+static int syslink_read (struct file *fp, struct uio *uio,
+                        struct ucred *cred, int flags);
+static int syslink_write (struct file *fp, struct uio *uio,
+                        struct ucred *cred, int flags);
+static int syslink_close (struct file *fp);
+static int syslink_stat (struct file *fp, struct stat *sb, struct ucred *cred);
+static int syslink_shutdown (struct file *fp, int how);
+static int syslink_ioctl (struct file *fp, u_long cmd, caddr_t data,
+                        struct ucred *cred);
+static int syslink_poll (struct file *fp, int events, struct ucred *cred);
+static int syslink_kqfilter(struct file *fp, struct knote *kn);
+
+static void syslink_rthread(void *arg);
+static void syslink_wthread(void *arg);
+static void slbuf_alloc(struct slbuf *buf, int bytes);
+static void slbuf_free(struct slbuf *buf);
+static void sldata_rels(struct sldata *sldata);
+static int process_syslink_msg(struct sldata *sldata, struct syslink_msg *head);
+static int syslink_validate(struct syslink_msg *head, int bytes);
+
+static struct fileops syslinkops = {
+    .fo_read =         syslink_read,
+    .fo_write =                syslink_write,
+    .fo_ioctl =                syslink_ioctl,
+    .fo_poll =         syslink_poll,
+    .fo_kqfilter =     syslink_kqfilter,
+    .fo_stat =         syslink_stat,
+    .fo_close =                syslink_close,
+    .fo_shutdown =     syslink_shutdown
+};
+
+MALLOC_DEFINE(M_SYSLINK, "syslink", "syslink manager");
+
+static int syslink_enabled;
+SYSCTL_INT(_kern, OID_AUTO, syslink_enabled,
+           CTLFLAG_RW, &syslink_enabled, 0, "Enable SYSLINK");
+
+/*
+ * Kernel mask and match bits.  These may be modified during early boot,
+ * before any syslink services have been established, but must remain fixed
+ * after that.  Note that the match value is only used if a message leaves
+ * the machine's domain.  '0' is used for unmasked match bits to indicate
+ * transport within the machine.
+ */
+static sysid_t sl_mask  = 0x00000000FFFFFFFFLL;
+static sysid_t sl_match = 0x0000000100000000LL;
+
+/*
+ * Primary system call interface - associate a full-duplex stream
+ * (typically a pipe or a connected socket) with a sysid namespace,
+ * or create a direct link.
+ *
+ * syslink(int fd, int cmd, sysid_t *mask, sysid_t *match)
+ */
+
+int
+sys_syslink(struct syslink_args *uap)
+{
+    int error;
+    struct file *fp;
+    struct sldata *sldata;
+
+    /*
+     * System call is under construction and disabled by default
+     */
+    if (syslink_enabled == 0)
+       return (EAUTH);
+
+    switch(uap->cmd) {
+    case SYSLINK_ESTABLISH:
+       error = suser(curthread);
+       if (error)
+           break;
+       sldata = malloc(sizeof(struct sldata), M_SYSLINK, M_WAITOK|M_ZERO);
+       lockinit(&sldata->rlock, "slread", 0, 0);
+       lockinit(&sldata->wlock, "slwrite", 0, 0);
+
+       if (uap->fd < 0) {
+           /*
+            * We create a direct syslink descriptor.  Only the reader thread
+            * is needed.
+            */
+           error = falloc(curproc, &fp, &uap->fd);
+           if (error == 0) {
+               fp->f_type = DTYPE_SYSLINK;
+               fp->f_flag = FREAD | FWRITE;
+               fp->f_ops = &syslinkops;
+               fp->f_data = sldata;
+               slbuf_alloc(&sldata->rbuf, SYSLINK_BUFSIZE);
+               slbuf_alloc(&sldata->wbuf, SYSLINK_BUFSIZE);
+               sldata->refs = 2;
+               sldata->flags = SLF_WQUIT | SLF_WDONE;
+               lwkt_create(syslink_rthread, sldata,
+                           &sldata->rthread, NULL,
+                           0, -1, "syslink_r");
+           }
+       } else {
+           sldata->xfp = holdfp(curproc->p_fd, uap->fd, -1);
+           if (sldata->xfp != NULL) {
+               slbuf_alloc(&sldata->rbuf, SYSLINK_BUFSIZE);
+               slbuf_alloc(&sldata->wbuf, SYSLINK_BUFSIZE);
+               sldata->refs = 2;
+               lwkt_create(syslink_rthread, sldata,
+                           &sldata->rthread, NULL,
+                           0, -1, "syslink_r");
+               lwkt_create(syslink_wthread, sldata,
+                           &sldata->wthread, NULL,
+                           0, -1, "syslink_w");
+           } else {
+               error = EBADF;
+           }
+       }
+       if (error)
+               free(sldata, M_SYSLINK);
+       break;
+    case SYSLINK_GETSYSMASK:
+       error = copyout(&sl_mask, uap->mask, sizeof(sl_mask));
+       if (error == 0)
+               error = copyout(&sl_match, uap->match, sizeof(sl_match));
+       break;
+    default:
+       error = ENOTSUP;
+       break;
+    }
+    return(error);
+}
+
+/*
+ * This thread reads from an external descriptor into rbuf, then parses and
+ * dispatches syslink messages from rbuf.
+ */
+static
+void
+syslink_rthread(void *arg)
+{
+    struct sldata *sldata = arg;
+    struct slbuf *slbuf = &sldata->rbuf;
+    struct syslink_msg *head;
+    const int min_msg_size = offsetof(struct syslink_msg, src_sysid);
+
+    while ((sldata->flags & SLF_RQUIT) == 0) {
+       int count;
+       int used;
+       int error;
+
+       /*
+        * Calculate contiguous space available to read and read as much
+        * as possible.
+        *
+        * If the entire buffer is used there's probably a format error
+        * of some sort and we terminate the link.
+        */
+       used = slbuf->windex - slbuf->rindex;
+       error = 0;
+
+       /*
+        * Read some data, terminate the link if an error occurs or if EOF
+        * is encountered.  xfp can be NULL, indicating that the data was
+        * injected by other means.
+        */
+       if (sldata->xfp) {
+               count = slbuf->bufsize - (slbuf->windex & slbuf->bufmask);
+               if (count > slbuf->bufsize - used)
+                   count = slbuf->bufsize - used;
+               if (count == 0)
+                   break;
+               error = fp_read(sldata->xfp,
+                               slbuf->buf + (slbuf->windex & slbuf->bufmask), count,
+                               &count, 0);
+               if (error)
+                   break;
+               if (count == 0)
+                   break;
+               slbuf->windex += count;
+               used += count;
+       } else {
+               tsleep(slbuf, 0, "fiford", 0);
+       }
+
+       /*
+        * Process as many syslink messages as we can.  The record length
+        * must be at least a minimal PAD record (8 bytes).  A msgid of 0
+        * is PAD.
+        */
+       while (slbuf->windex - slbuf->rindex >= min_msg_size) {
+           int aligned_reclen;
+
+           head = (void *)(slbuf->buf + (slbuf->rindex & slbuf->bufmask));
+           if (head->reclen < min_msg_size) {
+               error = EINVAL;
+               break;
+           }
+           aligned_reclen = SLMSG_ALIGN(head->reclen);
+
+           /*
+            * Disallow wraps
+            */
+           if ((slbuf->rindex & slbuf->bufmask) >
+               ((slbuf->rindex + aligned_reclen) & slbuf->bufmask)
+           ) {
+               error = EINVAL;
+               break;
+           }
+
+           /*
+            * Insufficient data read
+            */
+           if (slbuf->windex - slbuf->rindex < aligned_reclen)
+               break;
+
+           /*
+            * Process non-pad messages.  Non-pad messages have to be at
+            * least the size of the syslink_msg structure.
+            */
+           if (head->msgid) {
+               if (head->reclen < sizeof(struct syslink_msg)) {
+                   error = EINVAL;
+                   break;
+               }
+               error = process_syslink_msg(sldata, head);
+               if (error)
+                   break;
+           }
+           cpu_sfence();
+           slbuf->rindex += aligned_reclen;
+       }
+       if (error)
+           break;
+    }
+
+    /*
+     * Mark us as done and deref sldata.  Tell the writer to terminate as
+     * well.
+     */
+    sldata->flags |= SLF_RDONE;
+    if ((sldata->flags & SLF_WDONE) == 0) {
+           sldata->flags |= SLF_WQUIT;
+           wakeup(&sldata->wbuf);
+    }
+    sldata_rels(sldata);
+}
+
+/*
+ * This thread takes outgoing syslink messages queued to wbuf and writes them
+ * to the descriptor.  PAD is stripped.  PAD is also added as required to
+ * conform to the outgoing descriptor's buffering requirements.
+ */
+static
+void
+syslink_wthread(void *arg)
+{
+    struct sldata *sldata = arg;
+    struct slbuf *slbuf = &sldata->wbuf;
+    struct syslink_msg *head;
+    int error;
+
+    while ((sldata->flags & SLF_WQUIT) == 0) {
+       error = 0;
+       for (;;) {
+           int aligned_reclen;
+           int used;
+           int count;
+
+           used = slbuf->windex - slbuf->rindex;
+           if (used < offsetof(struct syslink_msg, src_sysid))
+               break;
+
+           head = (void *)(slbuf->buf + (slbuf->rindex & slbuf->bufmask));
+           if (head->reclen < offsetof(struct syslink_msg, src_sysid)) {
+               error = EINVAL;
+               break;
+           }
+           aligned_reclen = SLMSG_ALIGN(head->reclen);
+
+           /*
+            * Disallow wraps
+            */
+           if ((slbuf->rindex & slbuf->bufmask) >
+               ((slbuf->rindex + aligned_reclen) & slbuf->bufmask)
+           ) {
+               error = EINVAL;
+               break;
+           }
+
+           /*
+            * Insufficient data read
+            */
+           if (used < aligned_reclen)
+               break;
+
+           /*
+            * Write it out whether it is PAD or not.   XXX re-PAD for output
+            * here.
+            */
+           error = fp_write(sldata->xfp, head, aligned_reclen, &count);
+           if (error)
+               break;
+           if (count != aligned_reclen) {
+               error = EIO;
+               break;
+           }
+           slbuf->rindex += aligned_reclen;
+       }
+       if (error)
+           break;
+       tsleep(slbuf, 0, "fifowt", 0);
+    }
+    sldata->flags |= SLF_WDONE;
+    sldata_rels(sldata);
+}
+
+static
+void
+slbuf_alloc(struct slbuf *slbuf, int bytes)
+{
+    bzero(slbuf, sizeof(*slbuf));
+    slbuf->buf = malloc(bytes, M_SYSLINK, M_WAITOK);
+    slbuf->bufsize = bytes;
+    slbuf->bufmask = bytes - 1;
+}
+
+static
+void
+slbuf_free(struct slbuf *slbuf)
+{
+    free(slbuf->buf, M_SYSLINK);
+    slbuf->buf = NULL;
+}
+
+static
+void
+sldata_rels(struct sldata *sldata)
+{
+    if (--sldata->refs == 0) {
+       slbuf_free(&sldata->rbuf);
+       slbuf_free(&sldata->wbuf);
+       free(sldata, M_SYSLINK);
+    }
+}
+
+/*
+ * fileops for an established syslink when the kernel is asked to create a
+ * descriptor (verses one being handed to it).  No threads are created in
+ * this case.
+ */
+
+/*
+ * Transfer zero or more messages from the kernel to userland.  Only complete
+ * messages are returned.  If the uio has insufficient space then EMSGSIZE
+ * is returned.  The kernel feeds messages to wbuf so we use wlock (structures
+ * are relative to the kernel).
+ */
+static
+int
+syslink_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
+{
+    struct sldata *sldata = fp->f_data;
+    struct slbuf *slbuf = &sldata->wbuf;
+    struct syslink_msg *head;
+    int bytes;
+    int contig;
+    int error;
+    int nbio;
+
+    if (flags & O_FBLOCKING)
+       nbio = 0;
+    else if (flags & O_FNONBLOCKING)
+       nbio = 1;
+    else if (fp->f_flag & O_NONBLOCK)
+       nbio = 1;
+    else
+       nbio = 0;
+
+    lockmgr(&sldata->wlock, LK_EXCLUSIVE | LK_RETRY);
+
+    /*
+     * Calculate the number of bytes we can transfer in one shot.  Transfers
+     * do not wrap the FIFO.
+     */
+    contig = slbuf->bufsize - (slbuf->rindex & slbuf->bufmask);
+    for (;;) {
+       bytes = slbuf->windex - slbuf->rindex;
+       if (bytes)
+           break;
+       if (nbio) {
+           error = EAGAIN;
+           goto done;
+       }
+       tsleep(slbuf, 0, "fiford", 0);
+    }
+    if (bytes > contig)
+       bytes = contig;
+
+    /*
+     * The uio must be able to accomodate the transfer.
+     */
+    if (uio->uio_resid < bytes) {
+       error = ENOSPC;
+       goto done;
+    }
+
+    /*
+     * Copy the data to userland and update rindex.
+     */
+    head = (void *)(slbuf->buf + (slbuf->rindex & slbuf->bufmask));
+    error = uiomove((caddr_t)head, bytes, uio);
+    if (error == 0)
+       slbuf->rindex += bytes;
+
+    /*
+     * Cleanup
+     */
+done:
+    lockmgr(&sldata->wlock, LK_RELEASE);
+    return (error);
+}
+
+/*
+ * Transfer zero or more messages from userland to the kernel.  Only complete
+ * messages may be written.  The kernel processes from rbuf so that is where
+ * we have to copy the messages.
+ */
+static
+int
+syslink_write (struct file *fp, struct uio *uio, struct ucred *cred, int flags)
+{
+    struct sldata *sldata = fp->f_data;
+    struct slbuf *slbuf = &sldata->rbuf;
+    struct syslink_msg *head;
+    int bytes;
+    int contig;
+    int nbio;
+    int error;
+
+    if (flags & O_FBLOCKING)
+       nbio = 0;
+    else if (flags & O_FNONBLOCKING)
+       nbio = 1;
+    else if (fp->f_flag & O_NONBLOCK)
+       nbio = 1;
+    else
+       nbio = 0;
+
+    lockmgr(&sldata->rlock, LK_EXCLUSIVE | LK_RETRY);
+
+    /* 
+     * Calculate the maximum number of contiguous bytes that may be available.
+     * Caller is required to not wrap our FIFO.
+     */
+    contig = slbuf->bufsize - (slbuf->windex & slbuf->bufmask);
+    if (uio->uio_resid > contig) {
+       error = ENOSPC;
+       goto done;
+    }
+
+    /*
+     * Truncate based on actual unused space available in the FIFO.  If
+     * the uio does not fit, block and loop.
+     */
+    for (;;) {
+       bytes = slbuf->bufsize - (slbuf->windex - slbuf->rindex);
+       if (bytes > contig)
+           bytes = contig;
+       if (uio->uio_resid <= bytes)
+           break;
+       if (nbio) {
+           error = EAGAIN;
+           goto done;
+       }
+       tsleep(slbuf, 0, "fifowr", 0);
+    }
+    bytes = uio->uio_resid;
+    head = (void *)(slbuf->buf + (slbuf->windex & slbuf->bufmask));
+    error = uiomove((caddr_t)head, bytes, uio);
+    if (error == 0)
+       error = syslink_validate(head, bytes);
+    if (error == 0)
+       slbuf->windex += bytes;
+done:
+    lockmgr(&sldata->rlock, LK_RELEASE);
+    return(error);
+}
+
+static
+int
+syslink_close (struct file *fp)
+{
+    struct sldata *sldata;
+
+    sldata = fp->f_data;
+    fp->f_data = NULL;
+    sldata_rels(sldata);
+    return(0);
+}
+
+static
+int
+syslink_stat (struct file *fp, struct stat *sb, struct ucred *cred)
+{
+    return(EINVAL);
+}
+
+static
+int
+syslink_shutdown (struct file *fp, int how)
+{
+    return(EINVAL);
+}
+
+static
+int
+syslink_ioctl (struct file *fp, u_long cmd, caddr_t data, struct ucred *cred)
+{
+    return(EINVAL);
+}
+
+static
+int
+syslink_poll (struct file *fp, int events, struct ucred *cred)
+{
+    return(0);
+}
+
+static
+int
+syslink_kqfilter(struct file *fp, struct knote *kn)
+{
+    return(0);
+}
+
+/*
+ * Process a syslink message
+ */
+static
+int
+process_syslink_msg(struct sldata *sldata, struct syslink_msg *head)
+{
+    printf("process syslink msg %08x %04x\n", head->msgid, head->cid);
+    return(0);
+}
+
+/*
+ * Validate that the syslink message header(s) are correctly sized.
+ */
+static
+int
+syslink_validate(struct syslink_msg *head, int bytes)
+{
+    const int min_msg_size = offsetof(struct syslink_msg, src_sysid);
+    int aligned_reclen;
+
+    while (bytes) {
+       /*
+        * Message size and alignment
+        */
+       if (bytes < min_msg_size)
+           return (EINVAL);
+       if (bytes & SL_ALIGNMASK)
+           return (EINVAL);
+       if (head->msgid && bytes < sizeof(struct syslink_msg))
+           return (EINVAL);
+
+       /*
+        * Buffer must contain entire record
+        */
+       aligned_reclen = SLMSG_ALIGN(head->reclen);
+       if (bytes < aligned_reclen)
+           return (EINVAL);
+       bytes -= aligned_reclen;
+       head = (void *)((char *)head + aligned_reclen);
+    }
+    return(0);
+}
+
index bd2d94a..c8f3bdc 100644 (file)
@@ -1,7 +1,7 @@
 #! /bin/sh -
 #      @(#)makesyscalls.sh     8.1 (Berkeley) 6/10/93
 # $FreeBSD: src/sys/kern/makesyscalls.sh,v 1.39.2.4 2001/10/20 09:01:24 marcel Exp $
-# $DragonFly: src/sys/kern/makesyscalls.sh,v 1.15 2006/06/30 20:41:08 eirikn Exp $
+# $DragonFly: src/sys/kern/makesyscalls.sh,v 1.16 2006/08/06 18:56:44 dillon Exp $
 
 set -e
 
@@ -134,6 +134,7 @@ s/\$//g
                printf "#include <sys/acl.h>\n\n" > sysarg
                printf "#include <sys/msgport.h>\n\n" > sysarg
                printf "#include <sys/sysmsg.h>\n\n" > sysarg
+               printf "#include <sys/syslink.h>\n\n" > sysarg
                printf "#define\tPAD_(t)\t(sizeof(register_t) <= sizeof(t) ? \\\n" > sysarg
                printf "\t\t0 : sizeof(register_t) - sizeof(t))\n\n" > sysarg
 
index db093cf..94dca64 100644 (file)
@@ -2,8 +2,8 @@
  * System call names.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/kern/syscalls.c,v 1.41 2006/06/13 21:04:16 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/kern/syscalls.c,v 1.42 2006/08/06 18:56:44 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 char *syscallnames[] = {
@@ -493,4 +493,5 @@ char *syscallnames[] = {
        "usched_set",                   /* 481 = usched_set */
        "__accept",                     /* 482 = __accept */
        "__connect",                    /* 483 = __connect */
+       "syslink",                      /* 484 = syslink */
 };
index 217e197..f6a1080 100644 (file)
@@ -1,4 +1,4 @@
- $DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp $
+ $DragonFly: src/sys/kern/syscalls.master,v 1.41 2006/08/06 18:56:44 dillon Exp $
 
 ; @(#)syscalls.master  8.2 (Berkeley) 1/13/94
 ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
                                int bytes); }
 482    STD     BSD     { int __accept(int s, int flags, caddr_t name, int *anamelen); }
 483    STD     BSD     { int __connect(int s, int flags, caddr_t name, int namelen); }
+484    STD     BSD     { int syslink(int fd, int cmd, sysid_t *mask, sysid_t *match); }
index fdbb769..e164dce 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)file.h      8.3 (Berkeley) 1/9/95
  * $FreeBSD: src/sys/sys/file.h,v 1.22.2.7 2002/11/21 23:39:24 sam Exp $
- * $DragonFly: src/sys/sys/file.h,v 1.22 2006/08/02 01:25:27 dillon Exp $
+ * $DragonFly: src/sys/sys/file.h,v 1.23 2006/08/06 18:56:46 dillon Exp $
  */
 
 #ifndef _SYS_FILE_H_
@@ -121,6 +121,7 @@ struct file {
 #define        DTYPE_FIFO      4       /* fifo (named pipe) */
 #define        DTYPE_KQUEUE    5       /* event queue */
 #define DTYPE_CRYPTO   6       /* crypto */
+#define DTYPE_SYSLINK  7       /* syslink */
 
 LIST_HEAD(filelist, file);
 
index 70bd912..e7c1415 100644 (file)
@@ -2,8 +2,8 @@
  * System call hiders.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/sys/syscall-hide.h,v 1.42 2006/06/13 21:04:17 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/sys/syscall-hide.h,v 1.43 2006/08/06 18:56:46 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 #ifdef COMPAT_43
@@ -314,3 +314,4 @@ HIDE_BSD(getdents)
 HIDE_BSD(usched_set)
 HIDE_BSD(__accept)
 HIDE_BSD(__connect)
+HIDE_BSD(syslink)
index da517d8..7e69509 100644 (file)
@@ -2,8 +2,8 @@
  * System call numbers.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/sys/syscall.h,v 1.42 2006/06/13 21:04:17 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/sys/syscall.h,v 1.43 2006/08/06 18:56:46 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 #define        SYS_syscall     0
 #define        SYS_usched_set  481
 #define        SYS___accept    482
 #define        SYS___connect   483
-#define        SYS_MAXSYSCALL  484
+#define        SYS_syslink     484
+#define        SYS_MAXSYSCALL  485
index 7a1cae5..5199a67 100644 (file)
@@ -1,7 +1,7 @@
 # DragonFly system call names.
 # DO NOT EDIT-- this file is automatically generated.
-# $DragonFly: src/sys/sys/syscall.mk,v 1.42 2006/06/13 21:04:17 dillon Exp $
-# created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+# $DragonFly: src/sys/sys/syscall.mk,v 1.43 2006/08/06 18:56:46 dillon Exp $
+# created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
 MIASM =  \
        syscall.o \
        exit.o \
@@ -265,4 +265,5 @@ MIASM =  \
        getdents.o \
        usched_set.o \
        __accept.o \
-       __connect.o
+       __connect.o \
+       syslink.o
index abe989a..d98985f 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/syslink.h,v 1.2 2006/08/01 16:21:19 dillon Exp $
+ * $DragonFly: src/sys/sys/syslink.h,v 1.3 2006/08/06 18:56:46 dillon Exp $
  */
 
 /*
@@ -205,7 +205,7 @@ typedef struct syslink_proto *syslink_proto_t;
 typedef struct syslink_generic_args *syslink_generic_args_t;
 
 #if !defined(_KERNEL)
-int syslink(int, int, sysid_t, sysid_t);
+int syslink(int, int, sysid_t *, sysid_t *);
 #endif
 
 #endif
index ee2509d..a3eb55f 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/syslink_msg.h,v 1.1 2006/08/01 16:21:19 dillon Exp $
+ * $DragonFly: src/sys/sys/syslink_msg.h,v 1.2 2006/08/06 18:56:46 dillon Exp $
  */
 /*
  * The syslink infrastructure implements an optimized RPC mechanism across a 
@@ -137,6 +137,7 @@ struct syslink_msg {
        /* one or more embedded syslink_item structures */
 };
 
+#define SLMSG_ALIGN(bytes)     (((bytes) + 7) & ~7)
 #define SLMSGF_RESPONSE        ((sl_msgid_t)0x80000000)
 
 /*
index 96c7cf9..fd6b642 100644 (file)
@@ -2,8 +2,8 @@
  * System call prototypes.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/sys/sysproto.h,v 1.42 2006/06/13 21:04:17 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/sys/sysproto.h,v 1.43 2006/08/06 18:56:46 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 #ifndef _SYS_SYSPROTO_H_
@@ -17,6 +17,8 @@
 
 #include <sys/sysmsg.h>
 
+#include <sys/syslink.h>
+
 #define        PAD_(t) (sizeof(register_t) <= sizeof(t) ? \
                0 : sizeof(register_t) - sizeof(t))
 
@@ -1975,6 +1977,15 @@ struct   __connect_args {
        caddr_t name;   char name_[PAD_(caddr_t)];
        int     namelen;        char namelen_[PAD_(int)];
 };
+struct syslink_args {
+#ifdef _KERNEL
+       struct sysmsg sysmsg;
+#endif
+       int     fd;     char fd_[PAD_(int)];
+       int     cmd;    char cmd_[PAD_(int)];
+       sysid_t *       mask;   char mask_[PAD_(sysid_t *)];
+       sysid_t *       match;  char match_[PAD_(sysid_t *)];
+};
 
 #ifdef COMPAT_43
 
@@ -2539,6 +2550,7 @@ int       sys_getdents (struct getdents_args *);
 int    sys_usched_set (struct usched_set_args *);
 int    sys___accept (struct __accept_args *);
 int    sys___connect (struct __connect_args *);
+int    sys_syslink (struct syslink_args *);
 
 #endif /* !_SYS_SYSPROTO_H_ */
 #undef PAD_
index d0441b8..47fd90c 100644 (file)
@@ -2,8 +2,8 @@
  * Union of syscall args for messaging.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * $DragonFly: src/sys/sys/sysunion.h,v 1.39 2006/06/13 21:04:17 dillon Exp $
- * created from DragonFly: src/sys/kern/syscalls.master,v 1.39 2006/06/13 08:12:03 dillon Exp 
+ * $DragonFly: src/sys/sys/sysunion.h,v 1.40 2006/08/06 18:56:46 dillon Exp $
+ * created from DragonFly: src/sys/kern/syscalls.master,v 1.40 2006/06/13 21:04:16 dillon Exp 
  */
 
 union sysunion {
@@ -370,4 +370,5 @@ union sysunion {
        struct  usched_set_args usched_set;
        struct  __accept_args __accept;
        struct  __connect_args __connect;
+       struct  syslink_args syslink;
 };