pipemod.c

7号信令功能代码,为开源代码

/*
 *  pipemod.c - "pipemod" module
 *
 *  pipemod's only function is to facilitate flush handling at the
 *  midpoint of pipes by switching the sense of the flush flags in
 *  M_FLUSH messages.  In this implementation, we also do flush
 *  handling as well (since this is a module, and modules are expected
 *  to do flush handling...).
 *
 *  Copyright (C) 2000  John A. Boyd Jr.  protologos, LLC
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 * 
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 * 
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the
 *  Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
 *  MA 02139, USA.
 */

#ident "@(#) LiS pipemod.c 1.7 09/24/03"

#ifdef LINUX
#include <linux/config.h>
#include <linux/version.h>
#ifdef CONFIG_MODVERSIONS
#include <linux/modversions.h>
#endif
#include <linux/module.h>
#endif

#include <sys/LiS/config.h>

#include <sys/stream.h>
#include <sys/stropts.h>
#ifdef LINUX
#include <linux/errno.h>
#else
#include <sys/errno.h>
#endif
#include <sys/cmn_err.h>
#include <sys/osif.h>

/*
 *  Some configuration sanity checks
 */
#ifndef PIPEMOD_
#error Not configured
#endif

#ifndef PIPEMOD__ID
#define PIPEMOD__ID 0x8888
#endif

#define  MOD_ID   PIPEMOD__ID
#define  MOD_NAME "pipemod"

/*
 *  function prototypes
 */
static int  pipemod_open(queue_t *, dev_t*, int, int, cred_t *);
static int  pipemod_close(queue_t *, int, cred_t *);
static int  pipemod_put(queue_t *, mblk_t *);

static void flush_module(queue_t *, mblk_t *);

/*
 *  module structure
 */
static struct module_info pipemod_minfo =
{ 
    MOD_ID,            /* id */
    MOD_NAME,          /* name */
    0,                 /* min packet size accepted */
    INFPSZ,            /* max packet size accepted */
    10240L,            /* highwater mark */
    512L               /* lowwater mark */
};

static struct qinit pipemod_rinit = {
    pipemod_put,       /* put */
    NULL,              /* service */
    pipemod_open,      /* open */
    pipemod_close,     /* close */
    NULL,              /* admin */
    &pipemod_minfo,    /* info */
    NULL               /* stat */
};

static struct qinit pipemod_winit = { 
    pipemod_put,       /* put */
    NULL,              /* service */
    NULL,              /* open */
    NULL,              /* close */
    NULL,              /* admin */
    &pipemod_minfo,    /* info */
    NULL               /* stat */
};

struct streamtab pipemod_info =
{
    &pipemod_rinit,        /* read queue init */
    &pipemod_winit,        /* write queue init */
    NULL,                  /* lower mux read queue init */
    NULL                   /* lower mux write queue init */
};

/*
 *  open
 */
static int pipemod_open( q, devp, flag, sflag, credp )
queue_t *q;
dev_t *devp;
int flag, sflag;
cred_t *credp;
{
#ifdef PIPE_DEBUG
    cmn_err( CE_CONT,
	     "%s_open( 0x%p, 0x%x, 0x%x, 0x%x, ... )\n",
	     MOD_NAME, q, *devp, flag, sflag );
#endif

    if (!(((char *)RD(q)->q_ptr)++))  MOD_INC_USE_COUNT;
    WR(q)->q_ptr = RD(q)->q_ptr;

    qprocson(q);

    return 0;	/* success */
}

/*
 *  close
 */
static int pipemod_close( q, flag, credp )
queue_t *q;
int flag;
cred_t *credp;
{
#ifdef PIPE_DEBUG
    cmn_err( CE_CONT,
	     "%s_close( 0x%p, 0x%x, ... )\n", MOD_NAME, q, flag );
#endif
    
    RD(q)->q_ptr = WR(q)->q_ptr = NULL;
    MOD_DEC_USE_COUNT;
    qprocsoff(q);

    return 0;	/* success */
}
 
/*
 *  canonical module flush handling - this could be used in any module
 */
static void flush_module( q, mp )
queue_t *q;
mblk_t *mp;
{
    queue_t *rq = RD(q), *wq = WR(q);

    if (*(mp->b_rptr) & FLUSHW) {
	if (*(mp->b_rptr) & FLUSHBAND)
	    flushband( wq, FLUSHDATA, *(mp->b_rptr + 1) );
	else
	    flushq( wq, FLUSHDATA );
    }
    if (*(mp->b_rptr) & FLUSHR) {
	if (*(mp->b_rptr) & FLUSHBAND)
	    flushband( rq, FLUSHDATA, *(mp->b_rptr + 1) );
	else
	    flushq( rq, FLUSHDATA );
    }
    if (!SAMESTR(q)) {
	char flush = *(mp->b_rptr) & FLUSHRW;
	
	switch (flush & FLUSHRW) {
	case FLUSHR:
	case FLUSHW:
	    *(mp->b_rptr) = (flush & ~FLUSHRW) | (flush ^ FLUSHRW);
	default:
	    break;
	}
    }
    putnext( q, mp );
}
/*
 *  put
 */
static int pipemod_put( q, mp )
queue_t *q;
mblk_t *mp;
{
#ifdef PIPE_DEBUG
    cmn_err( CE_CONT,
	     "%s_wput( 0x%08x, 0x%08x )\n", MOD_NAME, q, mp );
#endif

    switch (mp->b_datap->db_type) {
    case M_FLUSH:
	flush_module( q, mp );
	break;
    default:
	putnext( q, mp );
	break;
    }
    return(0) ;
}

#ifdef MODULE

/*
 *  Linux loadable module interface
 */

int init_module(void)
{
    int ret = lis_register_strmod( &pipemod_info, MOD_NAME );
    if (ret < 0) {
	cmn_err( CE_CONT,
		 "%s - unable to register module.\n",
		 MOD_NAME );
	return ret;
    }

    return 0;
}

void cleanup_module(void)
{
    if (lis_unregister_strmod(&pipemod_info) < 0)
	cmn_err( CE_CONT,
		 "%s - unable to unregister module.\n",
		 MOD_NAME );
    return;
}

#endif

#if defined(LINUX)			/* linux kernel */
#if defined(MODULE_LICENSE)
MODULE_LICENSE("GPL and additional rights");
#endif
#if defined(MODULE_AUTHOR)
MODULE_AUTHOR("John A. Boyd Jr");
#endif
#if defined(MODULE_DESCRIPTION)
MODULE_DESCRIPTION("STREAMS Pipe Module");
#endif
#endif