ns/rdc/rdcsrv.c

	rdcsrv.c revision fcf3ce441efd61da9bb2884968af01cb7c1452cc
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/ksynch.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/cred.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/errno.h>

#include <sys/unistat/spcs_s.h>
#include <sys/unistat/spcs_s_k.h>
#include <sys/unistat/spcs_errors.h>

#ifdef _SunOS_2_6
/*
 * on 2.6 both dki_lock.h and rpc/types.h define bool_t so we
 * define enum_t here as it is all we need from rpc/types.h
 * anyway and make it look like we included it. Yuck.
 */
#define _RPC_TYPES_H
typedef int enum_t;
#else
#ifndef DS_DDICT
#include <rpc/types.h>
#endif
#endif /* _SunOS_2_6 */

#ifndef DS_DDICT
#include <rpc/auth.h>
#include <rpc/svc.h>
#include <rpc/xdr.h>
#else
#include "../contract.h"
#endif

#include <sys/ddi.h>

#include <sys/nsc_thread.h>
#include <sys/nsctl/nsctl.h>

#include <sys/nsctl/nsvers.h>

#include "rdc_io.h"
#include "rdc_stub.h"
#include "rdc_ioctl.h"
#include "rdcsrv.h"

#if defined(_SunOS_5_6) || defined(_SunOS_5_7)
static void rdcsrv_xprtclose(const SVCXPRT *xprt);
#else   /* SunOS 5.8 or later */
/*
 * SunOS 5.8 or later.
 *
 * RDC callout table
 *
 * This table is used by svc_getreq to dispatch a request with a given
 * prog/vers pair to an approriate service provider.
 */

static SVC_CALLOUT rdcsrv_sc[] = {
    { RDC_PROGRAM, RDC_VERS_MIN, RDC_VERS_MAX, rdcstub_dispatch }
};

static SVC_CALLOUT_TABLE rdcsrv_sct = {
    sizeof (rdcsrv_sc) / sizeof (rdcsrv_sc[0]), FALSE, rdcsrv_sc
};
#endif  /* SunOS 5.8 or later */

static kmutex_t rdcsrv_lock;

static int rdcsrv_dup_error;
static int rdcsrv_registered;
static int rdcsrv_closing;
static int rdcsrv_refcnt;
long rdc_svc_count = 0;
static rdcsrv_t *rdcsrv_disptab;

/*
 * Solaris module setup.
 */

extern struct mod_ops mod_miscops;

static struct modlmisc modlmisc = {
    &mod_miscops,   /* Type of module */
    "nws:Remote Mirror kRPC:" ISS_VERSION_STR
};

static struct modlinkage modlinkage = {
    MODREV_1,
    &modlmisc,
    NULL
};


int
_init(void)
{
    int rc;

    mutex_init(&rdcsrv_lock, NULL, MUTEX_DRIVER, NULL);

    if ((rc = mod_install(&modlinkage)) != DDI_SUCCESS)
        mutex_destroy(&rdcsrv_lock);

    return (rc);
}


int
_fini(void)
{
    int rc;

    if ((rc = mod_remove(&modlinkage)) == DDI_SUCCESS)
        mutex_destroy(&rdcsrv_lock);

    return (rc);
}


int
_info(struct modinfo *modinfop)
{
    return (mod_info(&modlinkage, modinfop));
}


/*
 * RDC kRPC server stub.
 */

void
rdcsrv_noproc(void)
{
    ;
}


static int
rdcsrv_dispdup(struct svc_req *req, SVCXPRT *xprt)
{
    rdc_disptab_t *disp;
    struct dupreq *dr;
    rdcsrv_t *srvp;
    void (*fn)();
    int dupstat;

    srvp = &rdcsrv_disptab[req->rq_vers - RDC_VERS_MIN];
    disp = &srvp->disptab[req->rq_proc];
    fn = disp->dispfn;

    dupstat = SVC_DUP(xprt, req, 0, 0, &dr);

    switch (dupstat) {
    case DUP_ERROR:
        /* svcerr_systemerr does a freeargs */
        svcerr_systemerr(xprt);
        rdcsrv_dup_error++;
        break;

    case DUP_INPROGRESS:
        rdcsrv_dup_error++;
        break;

    case DUP_NEW:
    case DUP_DROP:
        (*fn)(xprt, req);
        SVC_DUPDONE(xprt, dr, 0, 0, DUP_DONE);
        break;

    case DUP_DONE:
        break;
    }

    return (dupstat);
}


/*
 * rdcsrv_dispatch is the dispatcher routine for the RDC RPC protocol
 */
void
rdcsrv_dispatch(struct svc_req *req, SVCXPRT *xprt)
{
    rdc_disptab_t *disp;
    rdcsrv_t *srvp;

    mutex_enter(&rdcsrv_lock);
    rdcsrv_refcnt++;

    if (!rdcsrv_registered || rdcsrv_closing || !rdcsrv_disptab) {
        mutex_exit(&rdcsrv_lock);
        goto outdisp;
    }

    mutex_exit(&rdcsrv_lock);

    if ((req->rq_vers < RDC_VERS_MIN) || (req->rq_vers > RDC_VERS_MAX)) {
        svcerr_noproc(xprt);
        cmn_err(CE_NOTE,
            "rdcsrv_dispatch: unknown version %d",
            req->rq_vers);
        /* svcerr_noproc does a freeargs on xprt */
        goto done;
    }

    srvp = &rdcsrv_disptab[req->rq_vers - RDC_VERS_MIN];
    disp = &srvp->disptab[req->rq_proc];

    if (req->rq_proc >= srvp->nprocs ||
        disp->dispfn == rdcsrv_noproc) {
        svcerr_noproc(xprt);
        cmn_err(CE_NOTE,
            "rdcsrv_dispatch: bad proc number %d",
            req->rq_proc);
        /* svcerr_noproc does a freeargs on xprt */
        goto done;
    } else if (disp->clone) {
        switch (rdcsrv_dispdup(req, xprt)) {
        case DUP_ERROR:
            goto done;
            /* NOTREACHED */
        case DUP_INPROGRESS:
            goto outdisp;
            /* NOTREACHED */
        default:
            break;
        }
    } else {
        (*disp->dispfn)(xprt, req);
        rdc_svc_count++;
    }

outdisp:
    if (!SVC_FREEARGS(xprt, (xdrproc_t)0, (caddr_t)0))
        cmn_err(CE_NOTE, "rdcsrv_dispatch: bad freeargs");
done:
    mutex_enter(&rdcsrv_lock);
    rdcsrv_refcnt--;
    mutex_exit(&rdcsrv_lock);
}


static int
rdcsrv_create(file_t *fp, rdc_svc_args_t *args, int mode)
{
    /*LINTED*/
    int rc, error = 0;
    /*LINTED*/
    rpcvers_t vers;
    struct netbuf addrmask;

#if defined(_SunOS_5_6) || defined(_SunOS_5_7)
    SVCXPRT *xprt;
#else
    SVCMASTERXPRT *xprt;
#endif
    STRUCT_HANDLE(rdc_svc_args, uap);

    STRUCT_SET_HANDLE(uap, mode, args);

    addrmask.len = STRUCT_FGET(uap, addrmask.len);
    addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen);
    addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP);
    error = ddi_copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf,
            addrmask.len, mode);
    if (error) {
        kmem_free(addrmask.buf, addrmask.maxlen);
#ifdef DEBUG
        cmn_err(CE_WARN, "copyin of addrmask failed %p", (void *) args);
#endif
        return (error);
    }

    /*
     * Set rdcstub's dispatch handle to rdcsrv_dispatch
     */
    rdcstub_set_dispatch(rdcsrv_dispatch);

    /*
     * Create a transport endpoint and create one kernel thread to run the
     * rdc service loop
     */
#if defined(_SunOS_5_6) || defined(_SunOS_5_7)
    error = svc_tli_kcreate(fp, RDC_RPC_MAX,
        STRUCT_FGETP(uap, netid), &addrmask,
        STRUCT_FGET(uap, nthr), &xprt);
#else
    {
#if defined(_SunOS_5_8)
        struct svcpool_args p;
        p.id = RDC_SVCPOOL_ID;
        p.maxthreads = STRUCT_FGET(uap, nthr);
        p.redline = 0;
        p.qsize =  0;
        p.timeout = 0;
        p.stksize = 0;
        p.max_same_xprt = 0;

        error = svc_pool_create(&p);
        if (error) {
            cmn_err(CE_NOTE,
                "rdcsrv_create: svc_pool_create failed %d",
                error);
            return (error);
        }
#endif
        error = svc_tli_kcreate(fp, RDC_RPC_MAX,
                STRUCT_FGETP(uap, netid), &addrmask,
                &xprt, &rdcsrv_sct, NULL, RDC_SVCPOOL_ID,
                FALSE);
    }
#endif

    if (error) {
        cmn_err(CE_NOTE,
            "rdcsrv_create: svc_tli_kcreate failed %d",
            error);
        return (error);
    }

#if defined(_SunOS_5_6) || defined(_SunOS_5_7)
    if (xprt == NULL) {
        cmn_err(CE_NOTE, "xprt in rdcsrv_create is NULL");
    } else {
        /*
         * Register a cleanup routine in case the transport gets
         * destroyed.  If the registration fails for some reason,
         * it means that the transport is already being destroyed.
         * This shouldn't happen, but it's probably not worth a
         * panic.
         */
        if (!svc_control(xprt, SVCSET_CLOSEPROC,
            (void *)rdcsrv_xprtclose)) {
            cmn_err(
#ifdef DEBUG
                CE_PANIC,
#else
                CE_WARN,
#endif
                "rdcsrv_create: couldn't set xprt callback");

            error = EBADF;
            goto done;
        }
    }

    for (vers = RDC_VERS_MIN; vers <= RDC_VERS_MAX; vers++) {
        rc = svc_register(xprt, (ulong_t)RDC_PROGRAM, vers,
                rdcstub_dispatch, 0);
        if (!rc) {
            cmn_err(CE_NOTE,
                "rdcsrv_create: svc_register(%d, %lu) failed",
                RDC_PROGRAM, vers);

            if (!error) {
                error = EBADF;
            }
        }
    }
#endif /* 5.6 or 5.7 */

    if (!error) {
        /* mark as registered with the kRPC subsystem */
        rdcsrv_registered = 1;
    }

done:
    return (error);
}


#if defined(_SunOS_5_6) || defined(_SunOS_5_7)
/*
 * Callback routine for when a transport is closed.
 */
static void
rdcsrv_xprtclose(const SVCXPRT *xprt)
{
}
#endif


/*
 * Private interface from the main RDC module.
 */

int
rdcsrv_load(file_t *fp, rdcsrv_t *disptab,  rdc_svc_args_t *args, int mode)
{
    int rc = 0;

    mutex_enter(&rdcsrv_lock);

    rc = rdcsrv_create(fp, args, mode);
    if (rc == 0) {
        rdcsrv_disptab = disptab;
    }

    mutex_exit(&rdcsrv_lock);
    return (rc);
}


void
rdcsrv_unload(void)
{
    mutex_enter(&rdcsrv_lock);

    /* Unset rdcstub's dispatch handle */
    rdcstub_unset_dispatch();

    rdcsrv_closing = 1;

    while (rdcsrv_refcnt > 0) {
        mutex_exit(&rdcsrv_lock);
        delay(drv_usectohz(25));
        mutex_enter(&rdcsrv_lock);
    }

    rdcsrv_closing = 0;
    rdcsrv_disptab = 0;

    mutex_exit(&rdcsrv_lock);
}