Very Computer

        This question pertains to stream modules on a Sun Sparc 1 running
        SunOS4.1.1

        I'm currently writing an application that requires me to do some
        processing of raw data that comes across a serial line.  I've
        decided that the appropriate way of dealing with this (and
        hiding the horrors from the application level program) is to
        insert a module into the stream.

        Using that brilliant piece of documentation, known as "STREAMS
        Programming" in the Sun documentation set, I've run into
        problems when I come to push (ioctl(fd, I_PUSH, "modname"))
        my module.  It returns an error indicating that I have an
        invalid arguement to my ioctl call.  Okay, I think, it obviously
        doesn't know of the existance of my module.

        Now it strikes me that I can add my module information into
        the fmodsw structure in /sys/sun/str_conf.c and remake a
        kernel that knows the module name and the variable name
        of my streamtab structure.  Unfortunately I'm not root
        and the sys-op is not interested in creating a new kernel
        for me.

        My alternative is to use modload to dynamically load the
        module into the kernel when I need it.  The only documentation
        on this is in the device drive section of the manual set.
        It is as good a document as streams manual (which doesn't
        tell you how to register a module to load - argh).  I
        have written a wrapper program that sets up the vdldrv struct
        (not being able to figure out what things should be set to
        I set pointers to NULL as I don't want to define character
        or block device entry points or controller information, and
        any variables to 0).  The wrapper also defines a xxxinit for
        modload.

        Modload successfull loads the compiled wrapper (-DKERNEL -Dsun4c)
        and gives an address where the (I assume) xxxinit resides and the
        module id.  Using adb I debug the kernel and look at fmodsw struct.
        You've guessed it: my module information isn't there.  When I try
        to run my program, it again can not find my module name and blows
        up on the I_PUSH.

        What I would like to know is what am I doing wrong.  Has anyone
        got streams to work in the manner that I have described above?
        Does anyone have any other suggestions/alternatives.

                        advTHANKSance

--
                                      ,
"A storm breaks trees,             Mark -%)

           Solzhenitsyn                 ...!{uunet!ubc-cs, utai}!calgary!msw

Unfortunately, Sun in their infinite wisdom decided that nobody would want to
dynamically load Streams modules, so there's no way to tell the dynamic
loader that your code has a fmodsw structure, so it's not linked into
fmodsw automatically, so you have to do it yourself. Code snippet follows.

I usually call the load procedure "XXXload". "XXXinit" is used to do the
actual device initialization. (Some kernel autoconfiguration systems, e.g.
A/UX, automatically include XXXinit in the list of routines which are called
at kernel startup time if they see it.)

#ifdef sun
#include <sys/conf.h>
#include <sys/buf.h>
#include <sundev/mbvar.h>
#include <sun/autoconf.h>
#include <sun/vddrv.h>

static struct vdldrv vd =
{
    VDMAGIC_PSEUDO,
    "XXX",
    NULL, NULL, NULL, 0, 0, NULL, NULL, 0, 0,

Quote:};

XXXload (fc, vdp, vdi, vds)
    unsigned int fc;
    struct vddrv *vdp;
    addr_t vdi;
    struct vdstat *vds;
{
    switch (fc) {
    case VDLOAD:
        {
            int dev, i;

            /* Find free entry in fmodsw */
            for (dev = 0; dev < fmodcnt; dev++) {
                if (fmodsw[dev].f_str == NULL)
                    break;
            }
            if (dev == fmodcnt)
                return (ENODEV);
            XXX_fmod = &fmodsw[dev];

            /* If you think a kernel would have strcpy() you're mistaken. */
            for (i = 0; i <= FMNAMESZ; i++)
                XXX_fmod->f_name[i] = something_minfo.mi_idname[i];

            XXX_fmod->f_str = &something_streamtab;
        }
        vdp->vdd_vdtab = (struct vdlinkage *) & vd;

        XXXinit();
        return 0;
    case VDUNLOAD:
        {
            int dev;

            for (dev = 0; dev < NSOMETHING; dev++)
                if (XXX_data[dev]->q != NULL) {
                    /* One of the modules is still open */
                    return (EIO);
                }
        }
        XXX_fmod->f_name[0] = '\0';
        XXX_fmod->f_str = NULL;
        return 0;
    case VDSTAT:
        return 0;
    default:
        return EIO;
    }

Quote:}