8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / avs / nsctl / nskernd.c

/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/resource.h>
#include <sys/priocntl.h>
#include <sys/rtpriocntl.h>
#include <sys/tspriocntl.h>
#include <sys/wait.h>
#include <sys/stat.h>

#include <strings.h>
#include <thread.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <locale.h>
#include <unistd.h>
#include <syslog.h>

#include <sys/nsctl/cfg.h>
#include <sys/nsctl/nsctl.h>
#include <sys/nsctl/nsc_ioctl.h>
#include <sys/nskernd.h>
#include <nsctl.h>

#include <sys/mkdev.h>
#include <sys/nsctl/sv_efi.h>

static const char *rdev = "/dev/nsctl";

/*
 * Define a minimal user stack size in bytes over and above the
 * libthread THR_STACK_MIN minimum value.
 *
 * This stack size needs to be sufficient to run _newlwp() and then
 * ioctl() down into the kernel.
 */
#define NSK_STACK_SIZE  512

/*
 * LWP scheduling control switches.
 *
 * allow_pri    - set to non-zero to enable priocntl() manipulations of
 *              created LWPs.
 * allow_rt     - set to non-zero to use the RT rather than the TS
 *              scheduling class when manipulating the schduling
 *              parameters for an LWP.  Only used if allow_pri is
 *              non-zero.
 */
static int allow_pri = 1;
static int allow_rt = 0;        /* disallow - bad interactions with timeout() */

static int nsctl_fd = -1;
static int sigterm;

static int nthreads;            /* number of threads in the kernel */
static int exiting;             /* shutdown in progress flag */
static mutex_t thr_mutex = DEFAULTMUTEX;
static mutex_t cfg_mutex = DEFAULTMUTEX;

static int cl_nodeid = -1;

static int display_msg = 0;
static int delay_time = 30;

static void
usage(void)
{
        (void) fprintf(stderr, gettext("usage: nskernd\n"));
        exit(255);
}


static void
sighand(int sig)
{
        if (sig == SIGTERM) {
                sigterm++;
        }
}


/*
 * Returns: 1 - can enter kernel; 0 - shutdown in progress, do not enter kernel
 */
int
nthread_inc(void)
{
        (void) mutex_lock(&thr_mutex);
        if (exiting) {
                /* cannot enter kernel as nskernd is being shutdown - exit */
                (void) mutex_unlock(&thr_mutex);
                return (0);
        }
        nthreads++;
        (void) mutex_unlock(&thr_mutex);
        return (1);
}


void
nthread_dec(void)
{
        (void) mutex_lock(&thr_mutex);
        nthreads--;
        (void) mutex_unlock(&thr_mutex);
}


/*
 * returns: 1 - can shutdown; 0 - unable to shutdown
 */
int
canshutdown(void)
{
        int rc = 1;
        time_t  start_delay;

        (void) mutex_lock(&thr_mutex);
        if (nthreads > 0) {
                if (display_msg) {
                        (void) fprintf(stderr,
                            gettext("nskernd: unable to shutdown: "
                            "%d kernel threads in use\n"), nthreads);
                }
                start_delay = time(0);
                while (nthreads > 0 && (time(0) - start_delay) < delay_time) {
                        (void) mutex_unlock(&thr_mutex);
                        (void) sleep(1);
                        (void) mutex_lock(&thr_mutex);
                        (void) fprintf(stderr,
                            gettext("nskernd:   delay shutdown: "
                            "%d kernel threads in use\n"), nthreads);
                }
                if (nthreads > 0) {
                        rc = 0;
                } else {
                        exiting = 1;
                }
        } else {
                /* flag shutdown in progress */
                exiting = 1;
        }
        (void) mutex_unlock(&thr_mutex);

        return (rc);
}


/*
 * returns: 1 - shutdown successful; 0 - unable to shutdown
 */
int
shutdown(void)
{
        struct nskernd data;
        int rc;

        if (nsctl_fd < 0)
                return (1);

        bzero(&data, sizeof (data));
        data.command = NSKERND_STOP;

        if (!canshutdown()) {
                return (0);
        }

        rc = ioctl(nsctl_fd, NSCIOC_NSKERND, &data);
        if (rc < 0) {
                if (errno != EINTR || !sigterm) {
                        (void) fprintf(stderr,
                            gettext("nskernd: NSKERND_STOP failed\n"));
                }
        }

        return (1);
}


/*
 * First function run by a NSKERND_NEWLWP thread.
 *
 * Determines if it needs to change the scheduling priority of the LWP,
 * and then calls back into the kernel.
 */
static void *
_newlwp(void *arg)
{
        struct nskernd nsk;
        pcparms_t pcparms;
        pcinfo_t pcinfo;

        /* copy arguments onto stack and free heap memory */
        bcopy(arg, &nsk, sizeof (nsk));
        free(arg);

        if (nsk.data2 && allow_pri) {
                /* increase the scheduling priority of this LWP */

                bzero(&pcinfo, sizeof (pcinfo));
                (void) strcpy(pcinfo.pc_clname, allow_rt ? "RT" : "TS");

                if (priocntl(0, 0, PC_GETCID, (char *)&pcinfo) < 0) {
                        (void) fprintf(stderr,
                            gettext(
                            "nskernd: priocntl(PC_GETCID) failed: %s\n"),
                            strerror(errno));
                        goto pri_done;
                }

                bzero(&pcparms, sizeof (pcparms));
                pcparms.pc_cid = pcinfo.pc_cid;

                if (allow_rt) {
                        ((rtparms_t *)pcparms.pc_clparms)->rt_pri =
                                (pri_t)0; /* minimum RT priority */
                        ((rtparms_t *)pcparms.pc_clparms)->rt_tqsecs =
                                (uint_t)RT_TQDEF;
                        ((rtparms_t *)pcparms.pc_clparms)->rt_tqnsecs =
                                RT_TQDEF;
                } else {
                        ((tsparms_t *)pcparms.pc_clparms)->ts_uprilim =
                                ((tsinfo_t *)&pcinfo.pc_clinfo)->ts_maxupri;
                        ((tsparms_t *)pcparms.pc_clparms)->ts_upri =
                                ((tsinfo_t *)&pcinfo.pc_clinfo)->ts_maxupri;
                }

                if (priocntl(P_LWPID, P_MYID,
                    PC_SETPARMS, (char *)&pcparms) < 0) {
                        (void) fprintf(stderr,
                            gettext(
                            "nskernd: priocntl(PC_SETPARMS) failed: %s\n"),
                            strerror(errno));
                }
        }

pri_done:
        if (nthread_inc()) {
                (void) ioctl(nsctl_fd, NSCIOC_NSKERND, &nsk);
                nthread_dec();
        }
        return (NULL);
}


/*
 * Start a new thread bound to an LWP.
 *
 * This is the user level side of nsc_create_process().
 */
static void
newlwp(struct nskernd *req)
{
        struct nskernd *nskp;
        thread_t tid;
        int rc;

        nskp = malloc(sizeof (*nskp));
        if (!nskp) {
#ifdef DEBUG
                (void) fprintf(stderr, gettext("nskernd: malloc(%d) failed\n"),
                    sizeof (*nskp));
#endif
                req->data1 = (uint64_t)ENOMEM;
                return;
        }

        /* copy args for child */
        bcopy(req, nskp, sizeof (*nskp));

        rc = thr_create(NULL, (THR_MIN_STACK + NSK_STACK_SIZE),
                _newlwp, nskp, THR_BOUND|THR_DETACHED, &tid);

        if (rc != 0) {
                /* thr_create failed */
#ifdef DEBUG
                (void) fprintf(stderr,
                    gettext("nskernd: thr_create failed: %s\n"),
                    strerror(errno));
#endif
                req->data1 = (uint64_t)errno;
                free(nskp);
        } else {
                /* success - _newlwp() will free nskp */
                req->data1 = (uint64_t)0;
        }
}

static int
log_iibmp_err(char *set, int flags)
{
        CFGFILE *cfg;
        char key[CFG_MAX_KEY];
        char buf[CFG_MAX_BUF];
        char newflags[CFG_MAX_BUF];
        char outbuf[CFG_MAX_BUF];
        char *mst, *shd, *bmp, *mode, *ovr, *cnode, *opt, *grp;
        int setno, found = 0;
        int setlen;
        int rc = 0;
        pid_t pid = -1;

        if (set && *set) {
                setlen = strlen(set);
        } else {
                return (EINVAL);
        }

        (void) mutex_lock(&cfg_mutex);
        cfg = cfg_open("");
        if (!cfg) {
                (void) mutex_unlock(&cfg_mutex);
                return (ENXIO);
        }

        if (!cfg_lock(cfg, CFG_WRLOCK)) {

                (void) mutex_unlock(&cfg_mutex);
                cfg_close(cfg);

                pid = fork();

                if (pid == -1) {
                        (void) fprintf(stderr, gettext(
                            "nskernd: Error forking\n"));
                        return (errno);
                } else if (pid > 0) {
                        (void) fprintf(stdout, gettext(
                            "nskernd: Attempting deferred bitmap error\n"));
                        return (0);
                }

                (void) mutex_lock(&cfg_mutex);
                cfg = cfg_open("");
                if (!cfg) {
                        (void) mutex_unlock(&cfg_mutex);
                        (void) fprintf(stderr, gettext(
                            "nskernd: Failed cfg_open, deferred bitmap\n"));
                        return (ENXIO);
                }

                /* Sooner or later, this lock will be free */
                while (!cfg_lock(cfg, CFG_WRLOCK))
                        (void) sleep(2);
        }

        /* find the proper set number */
        for (setno = 1; !found; setno++) {
                (void) snprintf(key, CFG_MAX_KEY, "ii.set%d", setno);
                if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
                        break;
                }

                mst = strtok(buf, " ");
                shd = strtok(NULL, " ");
                if (strncmp(shd, set, setlen) == 0) {
                        found = 1;

                        bmp = strtok(NULL, " ");
                        mode = strtok(NULL, " ");
                        ovr = strtok(NULL, " ");
                        cnode = strtok(NULL, " ");
                        opt = strtok(NULL, " ");
                        grp = strtok(NULL, " ");
                        break;
                }
        }

        if (found) {
                /* were there flags in the options field already? */
                (void) snprintf(newflags, CFG_MAX_BUF, "%s=0x%x",
                    NSKERN_II_BMP_OPTION, flags);
                if (opt && strcmp(opt, "-") != 0) {
                        bzero(newflags, CFG_MAX_BUF);
                        opt = strtok(opt, ";");
                        while (opt) {
                                if (strncmp(opt, NSKERN_II_BMP_OPTION,
                                    strlen(NSKERN_II_BMP_OPTION)) != 0) {
                                        (void) strcat(newflags, ";");
                                        (void) strcat(newflags, opt);
                                }
                        }
                }
                (void) snprintf(key, CFG_MAX_KEY, "ii.set%d", setno);
                (void) snprintf(outbuf, CFG_MAX_BUF, "%s %s %s %s %s %s %s %s",
                    mst, shd, bmp, mode, ovr, cnode, newflags, grp);
                if (cfg_put_cstring(cfg, key, outbuf, CFG_MAX_BUF) < 0) {
                        (void) printf("Failed to put [%s]\n", outbuf);
                        rc = ENXIO;
                } else {
                        (void) cfg_commit(cfg);
                        rc = 0;
                }
        } else {
                (void) fprintf(stderr, gettext(
                    "nskernd: Failed deferred bitmap [%s]\n"), set);
                rc = EINVAL;
        }
        cfg_unlock(cfg);
        cfg_close(cfg);
        (void) mutex_unlock(&cfg_mutex);

        /*
         * if we are the fork'ed client, just exit, if parent just return
         */
        if (pid == 0) {
                exit(rc);
                /*NOTREACHED*/
        } else {
                return (rc);
        }
}

/*
 * First function run by a NSKERND_LOCK thread.
 *
 * Opens dscfg and locks it,
 * and then calls back into the kernel.
 *
 * Incoming:
 *      data1 is the kernel address of the sync structure.
 *      data2 is read(0)/write(1) lock mode.
 *
 * Returns:
 *      data1 as incoming.
 *      data2 errno.
 */
static void *
_dolock(void *arg)
{
        struct nskernd nsk;
        CFGFILE *cfg;
        int locked;
        int mode;
        int rc = 0;

        /* copy arguments onto stack and free heap memory */
        bcopy(arg, &nsk, sizeof (nsk));
        free(arg);

        (void) mutex_lock(&cfg_mutex);
        cfg = cfg_open("");
        if (cfg == NULL) {
#ifdef DEBUG
                (void) fprintf(stderr,
                    gettext("nskernd: cfg_open failed: %s\n"),
                    strerror(errno));
#endif
                rc = ENXIO;
        }

        if (nsk.data2 == 0) {
                mode = CFG_RDLOCK;
        } else {
                mode = CFG_WRLOCK;
        }

        locked = 0;
        if (rc == 0) {
                if (cfg_lock(cfg, mode)) {
                        locked = 1;
                } else {
#ifdef DEBUG
                        (void) fprintf(stderr,
                            gettext("nskernd: cfg_lock failed: %s\n"),
                            strerror(errno));
#endif
                        rc = EINVAL;
                }
        }

        /* return to kernel */

        nsk.data2 = (uint64_t)rc;
        if (nthread_inc()) {
                (void) ioctl(nsctl_fd, NSCIOC_NSKERND, &nsk);
                nthread_dec();
        }

        /* cleanup */

        if (locked) {
                cfg_unlock(cfg);
                locked = 0;
        }

        if (cfg != NULL) {
                cfg_close(cfg);
                cfg = NULL;
        }
        (void) mutex_unlock(&cfg_mutex);

        return (NULL);
}


/*
 * Inter-node lock thread.
 *
 * This is the user level side of nsc_rmlock().
 */
static void
dolock(struct nskernd *req)
{
        struct nskernd *nskp;
        thread_t tid;
        int rc;

        /* create a new thread to do the lock and return to kernel */

        nskp = malloc(sizeof (*nskp));
        if (!nskp) {
#ifdef DEBUG
                (void) fprintf(stderr,
                    gettext("nskernd:dolock: malloc(%d) failed\n"),
                    sizeof (*nskp));
#endif
                req->data1 = (uint64_t)ENOMEM;
                return;
        }

        /* copy args for child */
        bcopy(req, nskp, sizeof (*nskp));

        rc = thr_create(NULL, (THR_MIN_STACK + NSK_STACK_SIZE),
            _dolock, nskp, THR_BOUND|THR_DETACHED, &tid);

        if (rc != 0) {
                /* thr_create failed */
#ifdef DEBUG
                (void) fprintf(stderr,
                    gettext("nskernd: thr_create failed: %s\n"),
                    strerror(errno));
#endif
                req->data1 = (uint64_t)errno;
                free(nskp);
        } else {
                /* success - _dolock() will free nskp */
                req->data1 = (uint64_t)0;
        }
}


/*
 * Convenience code for engineering test of multi-terabyte volumes.
 *
 * zvol (part of zfs) does not support DKIOCPARTITION but does use EFI
 * labels.  This code allocates a simple efi label structure and ioctls
 * to extract the size of a zvol.  It only handles the minimal EFI ioctl
 * implementation in zvol.
 */

static void
zvol_bsize(char *path, uint64_t *size, const int pnum)
{
        struct stat64 stb1, stb2;
        struct dk_minfo dkm;
        int fd = -1;
        int rc;

        if (cl_nodeid || pnum != 0)
                return;

        if ((fd = open(path, O_RDONLY)) < 0) {
                return;
        }

        if (stat64("/devices/pseudo/zfs@0:zfs", &stb1) != 0 ||
            fstat64(fd, &stb2) != 0 ||
            !S_ISCHR(stb1.st_mode) ||
            !S_ISCHR(stb2.st_mode) ||
            major(stb1.st_rdev) != major(stb2.st_rdev)) {
                (void) close(fd);
                return;
        }

        rc = ioctl(fd, DKIOCGMEDIAINFO, (void *)&dkm);
        if (rc >= 0) {
                *size = LE_64(dkm.dki_capacity) *
                        (dkm.dki_lbsize) / 512;
        }

        (void) close(fd);
}

/* ARGSUSED */
static void
get_bsize(uint64_t raw_fd, uint64_t *size, int *partitionp, char *path)
{
        struct nscioc_bsize bsize;
#ifdef DKIOCPARTITION
        struct partition64 p64;
#endif
        struct dk_cinfo dki_info;
        struct vtoc vtoc;
        int fd;

        *partitionp = -1;
        *size = (uint64_t)0;

        dki_info.dki_partition = (ushort_t)-1;
        bsize.dki_info = (uint64_t)(unsigned long)&dki_info;
        bsize.vtoc = (uint64_t)(unsigned long)&vtoc;
        bsize.raw_fd = raw_fd;
        bsize.efi = 0;

        fd = open(rdev, O_RDONLY);
        if (fd < 0)
                return;

        if (ioctl(fd, NSCIOC_BSIZE, &bsize) < 0) {
                if (dki_info.dki_partition != (ushort_t)-1) {
                        /* assume part# is ok and just the size failed */
                        *partitionp = (int)dki_info.dki_partition;

#ifdef DKIOCPARTITION
                        /* see if this is an EFI label */
                        bzero(&p64, sizeof (p64));
                        p64.p_partno = (uint_t)*partitionp;
                        if ((ioctl(fd, DKIOCPARTITION, &p64)) > 0) {
                                *size = (uint64_t)p64.p_size;
                        } else {
                                bsize.p64 = (uint64_t)(unsigned long)&p64;
                                bsize.efi = 1;

                                if (ioctl(fd, NSCIOC_BSIZE, &bsize) < 0) {
                                        /* see if this is a zvol */
                                        zvol_bsize(path, size, *partitionp);
                                } else {
                                        *size = (uint64_t)p64.p_size;
                                }
                        }
#endif  /* DKIOCPARTITION */
                }

                (void) close(fd);
                return;
        }

        (void) close(fd);

        *partitionp = (int)dki_info.dki_partition;

        if (vtoc.v_sanity != VTOC_SANE)
                return;

        if (vtoc.v_version != V_VERSION && vtoc.v_version != 0)
                return;

        if (dki_info.dki_partition > V_NUMPAR)
                return;

        *size = (uint64_t)vtoc.v_part[(int)dki_info.dki_partition].p_size;
}


static int
iscluster(void)
{
        /*
         * Find out if we are running in a cluster
         */
        cl_nodeid = cfg_iscluster();
        if (cl_nodeid > 0) {
                return (TRUE);
        } else if (cl_nodeid == 0) {
                return (FALSE);
        }

        (void) fprintf(stderr, "%s\n",
            gettext("nskernd: unable to ascertain environment"));
        exit(1);
        /* NOTREACHED */
}

/*
 * Runtime Solaris release checking - build release == runtime release
 * is always considered success, so only keep entries in the map for
 * the special cases.
 */
static nsc_release_t nskernd_rel_map[] = {
/*      { "5.10", "5.10" },                     */
        { "5.11", "5.10" },
        { NULL, NULL }
};


#ifdef lint
#define main    nskernd_main
#endif
/* ARGSUSED1 */
int
main(int argc, char *argv[])
{
        const char *dir = "/";
        struct nskernd data;
        struct rlimit rl;
        int i, run, rc;
        int partition;
        char *reqd;
        int syncpipe[2];
        int startup;

        (void) setlocale(LC_ALL, "");
        (void) textdomain("nskernd");

        rc = nsc_check_release(BUILD_REV_STR, nskernd_rel_map, &reqd);
        if (rc < 0) {
                (void) fprintf(stderr,
                    gettext("nskernd: unable to determine the current "
                    "Solaris release: %s\n"), strerror(errno));
                exit(1);
        } else if (rc == FALSE) {
                (void) fprintf(stderr,
                    gettext("nskernd: incorrect Solaris release "
                    "(requires %s)\n"), reqd);
                exit(1);
        }

        rc = 0;

        if (argc != 1)
                usage();

        /*
         * Usage: <progname> [-g] [-d <seconds to delay>]
         */
        while ((i = getopt(argc, argv, "gd:")) != EOF) {
                switch (i) {
                        case 'g':
                                display_msg = 1;
                                break;
                        case 'd':
                                delay_time = atoi(optarg);
                                if (delay_time <= 0) {
                                        delay_time = 30;
                                }
                                break;
                        default:
                                syslog(LOG_ERR,
                                "Usage: nskernd [-g] [-d <seconds to delay>]");
                                exit(1);
                                break;
                }
        }

        if (chroot(dir) < 0) {
                (void) fprintf(stderr, gettext("nskernd: chroot failed: %s\n"),
                    strerror(errno));
                exit(1);
        }

        if (chdir(dir) < 0) {
                (void) fprintf(stderr, gettext("nskernd: chdir failed: %s\n"),
                    strerror(errno));
                exit(1);
        }

        /*
         * Determine if we are in a Sun Cluster or not, before fork'ing
         */
        (void) iscluster();

        /*
         * create a pipe to synchronise the parent with the
         * child just before it enters its service loop.
         */
        if (pipe(syncpipe) < 0) {
                (void) fprintf(stderr,
                    gettext("nskernd: cannot create pipe: %s\n"),
                    strerror(errno));
                exit(1);
        }
        /*
         * Fork off a child that becomes the daemon.
         */

        if ((rc = fork()) > 0) {
                char c;
                int n;
                (void) close(syncpipe[1]);
                /*
                 * wait for the close of the pipe.
                 * If we get a char back, indicates good
                 * status from child, so exit 0.
                 * If we get a zero length read, then the
                 * child has failed, so we do too.
                 */
                n = read(syncpipe[0], &c, 1);
                exit((n <= 0) ? 1 : 0);
        } else if (rc < 0) {
                (void) fprintf(stderr, gettext("nskernd: cannot fork: %s\n"),
                    strerror(errno));
                exit(1);
        }

        /*
         * In child - become daemon.
         */

        /* use closefrom(3C) from PSARC/2000/193 when possible */
        for (i = 0; i < syncpipe[1]; i++) {
                (void) close(i);
        }
        closefrom(syncpipe[1] + 1);

        (void) open("/dev/console", O_WRONLY|O_APPEND);
        (void) dup(0);
        (void) dup(0);
        (void) close(0);

        (void) setpgrp();

        /*
         * Ignore all signals apart from SIGTERM.
         */

        for (i = 1; i < _sys_nsig; i++)
                (void) sigset(i, SIG_IGN);

        (void) sigset(SIGTERM, sighand);

        /*
         * Increase the number of fd's that can be open.
         */

        rl.rlim_cur = RLIM_INFINITY;
        rl.rlim_max = RLIM_INFINITY;
        if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
                (void) fprintf(stderr,
                    gettext("nskernd: could not increase RLIMIT_NOFILE: %s\n"),
                    strerror(errno));
                (void) fprintf(stderr,
                    gettext("nskernd: the maximum number of nsctl open "
                    "devices may be reduced\n"));
        }

        /*
         * Open /dev/nsctl and startup.
         */

        nsctl_fd = open(rdev, O_RDONLY);
        if (nsctl_fd < 0) {
                (void) fprintf(stderr, gettext("nskernd: unable to open %s\n"),
                    rdev);
                exit(1);
        }

        bzero(&data, sizeof (data));

        data.command = NSKERND_START;
        data.data1 = (uint64_t)cl_nodeid;
        run = 1;

        startup = 1;
        while (run) {
                rc = ioctl(nsctl_fd, NSCIOC_NSKERND, &data);
                if (rc < 0) {
                        /* try and do kernel cleanup and exit */
                        if (shutdown()) {
                                run = 0;
                        } else {
                                sigterm = 0;
                        }

                        (void) fprintf(stderr,
                            gettext("nskernd: NSCIOC_NSKERND failed: %s\n"),
                            strerror(errno));
                        continue;
                } else if (sigterm) {
                        /* SIGTERM received - terminate */
                        if (data.command != NSKERND_START &&
                            (data.command != NSKERND_STOP ||
                            data.data1 != (uint64_t)1)) {
                                /* need to do kernel cleanup */
                                if (shutdown()) {
                                        run = 0;
                                } else {
                                        sigterm = 0;
                                        data.command = NSKERND_START;
                                        data.data1 = (uint64_t)cl_nodeid;
                                }
                        } else {
                                /* just quit */
                                if (canshutdown()) {
                                        run = 0;
                                } else {
                                        /* cannot shutdown - threads active */
                                        sigterm = 0;
                                        data.command = NSKERND_START;
                                        data.data1 = (uint64_t)cl_nodeid;
                                }
                        }
                        continue;
                }
                if (startup) {
                        char c = 0;
                        (void) write(syncpipe[1], &c, 1);
                        (void) close(syncpipe[1]);
                        startup = 0;
                }
                switch (data.command) {
                case NSKERND_START:     /* (re)start completion */
                        if (rc == 1) {
                                (void) fprintf(stderr,
                                    gettext("nskernd: already started\n"));
                                run = 0;
                        } else if (rc == 2) {
                                (void) fprintf(stderr,
                                    gettext("nskernd: stopped by kernel\n"));
                                run = 0;
                        }
                        data.command = NSKERND_WAIT;
                        break;

                case NSKERND_STOP:      /* kernel telling daemon to stop */
                        if (data.data1 != (uint64_t)1) {
                                (void) shutdown();
                                run = 0;
                        }
                        break;

                case NSKERND_BSIZE:
                        /*
                         * kernel requesting partsize
                         * data1 - size return
                         * data2 - raw_fd (entry)
                         *       - partition number (return)
                         */
                        partition = -1;
                        get_bsize(data.data2, &data.data1,
                            &partition, data.char1);
                        data.data2 = (uint64_t)partition;
                        data.command = NSKERND_WAIT;
                        break;

                case NSKERND_NEWLWP:    /* kernel requesting a new LWP */
                        newlwp(&data);
                        data.command = NSKERND_WAIT;
                        break;

                case NSKERND_LOCK:      /* kernel requesting lock */
                        dolock(&data);
                        data.command = NSKERND_WAIT;
                        break;

                case NSKERND_WAIT:      /* kernel retrying wait */
                        /*
                         * the kernel thread can be woken by the dr config
                         * utilities (ie cfgadm) therefore we just reissue
                         * the wait.
                         */
                        break;

                case NSKERND_IIBITMAP:
                        rc = log_iibmp_err(data.char1, (int)data.data1);
                        data.data1 = (uint64_t)rc;
                        data.command = NSKERND_WAIT;
                        break;

                default:
                        (void) fprintf(stderr,
                                gettext("nskernd: unknown command %d"),
                                data.command);
                        data.command = NSKERND_WAIT;
                        break;
                }
        }

        (void) close(nsctl_fd);

        return (rc);
}