7712 mandoc -Tlint does always exit with error code 0

[unleashed.git] / usr / src / cmd / lvm / util / metainit.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * initialize metadevices
 */

#include <meta.h>

#include <sdssc.h>
#include <sys/lvm/md_mirror.h>
#include <syslog.h>
#include "meta_set_prv.h"

/*
 * try to initialize devices
 */
#define DO_AGAIN        0
#define DONT_DO         1
#define IS_DONE         2

/*
 * mn_send_command
 *
 * generate a command of the form "metainit -s setname [-n] [-f] ....."
 *
 * If -n option is *not* set, send the metainit command *with -n set* to
 * all nodes first. Do this with MD_MSGF_STOP_ON_ERROR set.
 * That means if it fails on one node, it'll return immediately,
 * reporting the error.
 * By doing so, we have a dryrun first that has to succeed on every node
 * before we start the command for real.
 * This saves us from backing out a metainit command that succeeded on
 * some nodes but failed on one.
 */
static int
mn_send_command(
        mdsetname_t     **spp,
        int             argc,
        char            **argv,
        mdcmdopts_t     options,
        int             flags,
        char            *context,
        md_error_t      *ep
)
{
        int             newargc;
        char            **newargv;
        int             i;
        int             ret;
        int             dryrun_only = 0;


        newargv = calloc(argc+5, sizeof (char *));
        newargv[0] = "metainit";
        newargv[1] = "-s";
        newargv[2] = (*spp)->setname;
        newargv[3] = "-n"; /* always do "-n" first */
        newargc = 4;
        if ((options & MDCMD_DOIT) == 0) {
                dryrun_only = 1;
        }
        if ((options & MDCMD_FORCE) != 0) {
                newargv[newargc] = "-f";
                newargc++;
        }
        for (i = 0; i < argc; i++, newargc++)
                newargv[newargc] = argv[i];
        ret = meta_mn_send_command(*spp, newargc, newargv,
            flags | MD_DRYRUN | MD_NOLOG, context, ep);

        if ((dryrun_only == 0) && (ret == 0)) {
                /*
                 * Do it for real now. Remove "-n" from the arguments and
                 * MD_DRYRUN from the flags. If we fail this time the master
                 * must panic as the mddbs may be inconsistent.
                 */
                newargv[3] = ""; /* this was "-n" before */
                ret = meta_mn_send_command(*spp, newargc, newargv,
                    flags | MD_RETRY_BUSY | MD_PANIC_WHEN_INCONSISTENT,
                    context,  ep);
        }

        free(newargv);
        return (ret);
}

static int
init_entries(
        mdsetname_t     **spp,
        md_tab_t        *tabp,
        mdcmdopts_t     options,
        uint_t          flags,
        bool_t          called_thru_rpc,
        md_error_t      *ep
)
{
        uint_t          cnt = 0;
        uint_t          line;
        int             rval = 0;
        int             ret;

        /* for all matching entries, which haven't already been done */
        for (line = 0; (line < tabp->nlines); ++line) {
                md_tab_line_t   *linep = &tabp->lines[line];
                char            *uname = linep->argv[0];

                /* see if already done */
                if (linep->flags != DO_AGAIN)
                        continue;

                /* clear the metadev/hsp caches between inits */
                metaflushmetanames();

                /* try it */
                if ((called_thru_rpc == FALSE) &&
                    meta_is_mn_name(spp, uname, ep)) {
                        /*
                         * MN set, send command to all nodes
                         * Note that is sp is NULL, meta_is_mn_name() derives
                         * sp from linep->argv which is the metadevice arg
                         */
                        ret = mn_send_command(spp, linep->argc, linep->argv,
                            options, flags, linep->context, ep);
                } else {
                        char            *cname = NULL;

                        cname = meta_name_getname(spp, uname, META_DEVICE, ep);
                        if (cname == NULL) {
                                mde_perror(ep, "");
                                mdclrerror(ep);
                        } else {

                                ret = meta_init_name(spp, linep->argc,
                                    linep->argv, cname, options, ep);
                                Free(cname);

                                if (ret != 0) {
                                        if (!(flags & MD_IGNORE_STDERR)) {
                                            mderrorextra(ep, linep->context);
                                            mde_perror(ep, "");
                                            rval = -1;
                                        }
                                        mdclrerror(ep);
                                }
                        }
                }
                if (ret == 0) {
                        linep->flags = IS_DONE;
                        ++cnt;
                }
        }

        /* return success */
        if (rval != 0)
                return (rval);
        return (cnt);
}

/*
 * initialize all devices in set
 */
static int
init_all(
        mdsetname_t     **spp,
        mdcmdopts_t     options,
        bool_t          called_thru_rpc,
        md_error_t      *ep
)
{
        md_tab_t        *tabp = NULL;
        size_t          setlen;
        uint_t          more;
        int             done;
        int             eval = -1;

        /*
         * Only take the lock if this is not a MN set
         * We can only enter this code for a MN set if we are the initiator
         * and in this case, we don't want to take locks.
         */
        if (meta_is_mn_set((*spp), ep) == 0) {
                /* grab set lock */
                if (meta_lock(*spp, TRUE, ep)) {
                        mde_perror(ep, "");
                        mdclrerror(ep);
                        return (eval);
                }

                /* check for ownership */
                if (meta_check_ownership(*spp, ep) != 0) {
                        mde_perror(ep, "");
                        mdclrerror(ep);
                        return (eval);
                }

                /* lock is held across init_entries */
                options |= MDCMD_NOLOCK;
        }

        /* get md.tab, preen entries */
        if ((tabp = meta_tab_parse(NULL, ep)) == NULL) {
                mde_perror(ep, "");
                mdclrerror(ep);
                return (eval);
        }

        setlen = strlen((*spp)->setname);
        for (more = 0; (more < tabp->nlines); ++more) {
                md_tab_line_t   *linep = &tabp->lines[more];
                char            *cname = linep->cname;
                char            *p;
                size_t          len;

                /* better have args */
                assert((linep->argc > 0) && (linep->argv[0] != NULL));

                /* only do metadevices and hotspare pools in set */
                if (linep->type & TAB_MD_HSP) {
                        if ((p = strrchr(cname, '/')) == NULL) {
                                len = 0;
                        } else {
                                len = p - cname;
                        }
                        if ((len == setlen) &&
                            (strncmp(cname, (*spp)->setname, len) == 0)) {
                                linep->flags = DO_AGAIN;
                        } else {
                                linep->flags = DONT_DO;
                        }

                } else {
                        linep->flags = DONT_DO;
                }
        }

        eval = 1;

        /* while more devices get made */
        do {
                done = init_entries(spp, tabp, options,
                    MD_IGNORE_STDERR|MD_RETRY_BUSY, called_thru_rpc, ep);
        } while (done > 0);

        /* now do it and report errors */
        if (init_entries(spp, tabp, options, MD_RETRY_BUSY,
            called_thru_rpc, ep) >= 0)
                eval = 0;       /* success */
        mdclrerror(ep);

        /* cleanup, return success */
out:
        meta_tab_free(tabp);
        return (eval);
}

/*
 * initialize named device or hotspare pool
 */
static int
init_name(
        mdsetname_t     **spp,
        int             argc,
        char            *argv[],
        mdcmdopts_t     options,
        int             called_thru_rpc,
        md_error_t      *ep
)
{
        md_tab_t        *tabp = NULL;
        md_tab_line_t   *linep = NULL;
        int             rval = -1;
        int             ret;
        char            *uname = argv[0];

        /* look in md.tab */
        if (argc == 1) {
                /* get md.tab entries */
                if ((tabp = meta_tab_parse(NULL, ep)) == NULL) {
                        if (! mdissyserror(ep, ENOENT))
                                return (-1);
                }

                /* look in md.tab */
                if ((linep = meta_tab_find(*spp, tabp, uname, TAB_MD_HSP))
                                                                != NULL) {
                        argc = linep->argc;
                        argv = linep->argv;
                }
        }

        if ((called_thru_rpc == FALSE) &&
            meta_is_mn_name(spp, uname, ep)) {
                /*
                 * MN set, send command to all nodes
                 */
                ret = mn_send_command(spp, argc, argv, options,
                    MD_DISP_STDERR, NO_CONTEXT_STRING, ep);
        } else {
                char            *cname = NULL;

                cname = meta_name_getname(spp, uname, META_DEVICE, ep);
                if (cname == NULL) {
                        goto out;
                }

                /* check for ownership */
                if (meta_check_ownership(*spp, ep) != 0) {
                        Free(cname);
                        goto out;
                }

                ret = meta_init_name(spp, argc, argv, cname, options, ep);
                Free(cname);
        }

        if (ret != 0) {
                if (linep != NULL)
                        mderrorextra(ep, linep->context);
                goto out;
        }
        rval = 0;       /* success */

        /* cleanup, return error */
out:
        if (tabp != NULL)
                meta_tab_free(tabp);
        return (rval);
}

/*
 * print usage message
 */
static void
usage(
        mdsetname_t     *sp,
        int             eval
)
{
#ifndef lint
        (void) fprintf(stderr, gettext("\
usage:  %s [-s setname] [-n] [-f] concat/stripe numstripes\n\
                width component... [-i interlace]\n\
                [width component... [-i interlace]] [-h hotspare_pool]\n\
        %s [-s setname] [-n] [-f] mirror -m submirror...\n\
                [read_options] [write_options] [pass_num]\n\
        %s [-s setname] [-n] [-f] RAID -r component...\n\
                [-i interlace] [-h hotspare_pool]\n\
                [-k] [-o original_column_count]\n\
        %s [-s setname] [-n] [-f] hotspare_pool [hotspare...]\n\
        %s [-s setname] [-n] [-f] softpart -p [-A alignment]\n\
                [-e] device size|all\n\
        %s [-s setname] [-n] [-f] md.tab_entry\n\
        %s [-s setname] [-n] [-f] -a\n\
        %s -r\n"), myname, myname, myname, myname, myname, myname, myname,
            myname);
#endif  /* ! lint */
        md_exit(sp, eval);
}

/*
 * If we fail during the attempt to take the auto-take disksets
 * we need to tell the kernel to cleanup the in-core set struct
 * so that we have a chance to take the set again later.
 */
static void
auto_take_cleanup(mdsetname_t *sp, side_t sideno)
{
        mddb_config_t   c;

        (void) memset(&c, 0, sizeof (c));
        c.c_setno = sp->setno;
        c.c_sideno = sideno;

        if (metaioctl(MD_RELEASE_SET, &c, &c.c_mde, NULL) != 0) {
                mde_perror(&c.c_mde, "auto_take_cleanup");
                return;
        }
}

/*
 * Take the diskset.
 *
 * This is a clean auto-take set, so do the work to take it.
 * This is a streamlined version of the code in meta_set_take.  We avoid the
 * need for talking to the rpc.metad since that can't run this early during the
 * boot.  We don't need to talk to the metad for this diskset since we're the
 * only host in the set.
 */
static void
take_set(md_set_record *sr)
{
        mdsetname_t             sn;
        md_drive_desc           *dd;
        md_error_t              error = mdnullerror;
        md_replicalist_t        *rlp = NULL;
        md_replicalist_t        *rl;
        daddr_t                 nblks = 0;
        md_drive_record         *dr;
        side_t                  sideno;

        /*
         * Several of the functions we call take a sp param so
         * construct one from the set record.
         */
        sn.setname = sr->sr_setname;
        sn.setno = sr->sr_setno;
        sn.setdesc = sr2setdesc(sr);
        sn.lockfd = MD_NO_LOCK;

        if (sr->sr_flags & MD_SR_MB_DEVID)
                dd = metaget_drivedesc(&sn, MD_BASICNAME_OK | PRINT_FAST,
                    &error);
        else
                dd = metaget_drivedesc(&sn, MD_BASICNAME_OK, &error);

        if (dd == NULL) {
            mde_perror(&error, "");
            mdclrerror(&error);
            return;
        }

        /*
         * Skip call to tk_own_bydd.  This talks to rpc.metamhd (which we can't
         * do yet) and is not needed for auto-take disksets since we are not
         * doing SCSI reservations on these drives.
         */

        if (setup_db_bydd(&sn, dd, 0, &error) != 0) {
            if (! mdismddberror(&error, MDE_DB_ACCOK) &&
                ! mdismddberror(&error, MDE_DB_TAGDATA)) {
                /*
                 * Skip call to rel_own_bydd since that really just
                 * calls rpc.metamhd which we don't need to do,
                 * so there really isn't anything to rollback here.
                 */
                mde_perror(&error, "");
                mdclrerror(&error);
                return;
            }
            mdclrerror(&error);
        }

        if ((sideno = getmyside(&sn, &error)) == MD_SIDEWILD) {
            mde_perror(&error, "");
            return;
        }

        if (snarf_set(&sn, FALSE, &error) != 0) {
            if (mdismddberror(&error, MDE_DB_STALE) ||
                mdismddberror(&error, MDE_DB_TAGDATA) ||
                ! mdismddberror(&error, MDE_DB_NODB) &&
                ! mdismddberror(&error, MDE_DB_NOTOWNER)) {
                /*
                 * rollback
                 * Normally MDE_DB_STALE or MDE_DB_TAGDATA
                 * would still keep the set but in this case we don't
                 * want to do that.  This will probably result in the
                 * boot going in to single-user since we won't have the
                 * set so any attempted mounts using the set's metadevices
                 * will fail.  However, that is a "good thing" so the
                 * sysadmin can fix the set.  Normally they would see
                 * all of these problems when they ran the take and be
                 * able to immediately fix the problem.
                 */
                mde_perror(&error, "");
                auto_take_cleanup(&sn, sideno);
                return;
            }
        }

        /*
         * Call metareplicalist and upd_dr_dbinfo.
         * Most of that code is only needed to synchronize amongst the multiple
         * hosts in a set, which is not applicable in our case.  But we do a
         * subset here to handle the case when the user had been
         * adding/deleting/balancing mddbs when this node panic'd.  We are
         * synchronizing the ondisk mddbs to the list of drive records stored
         * in the local mddb.
         */
        if (metareplicalist(&sn, (MD_BASICNAME_OK | PRINT_FAST), &rlp, &error)
            < 0) {
            /* rollback */
            mde_perror(&error, "");
            auto_take_cleanup(&sn, sideno);
            return;
        }

        /*
         * The following code is equivalent to upd_dr_dbinfo for syncronizing
         * the local host only.  That function is normally run through the
         * metad with a local and daemon side but we'll do all of the work
         * here.
         */

        /* find the smallest existing replica */
        for (rl = rlp; rl != NULL; rl = rl->rl_next) {
            md_replica_t *r;

            r = rl->rl_repp;
            nblks = ((nblks == 0) ? r->r_nblk : min(r->r_nblk, nblks));
        }

        if (nblks <= 0)
            nblks = MD_DBSIZE;

        for (dr = sr->sr_drivechain; dr; dr = dr->dr_next) {
            int                 dbcnt;
            mddrivename_t       *dnp;
            md_replicalist_t    *rl;

                /*
                 * The cname style for dnp and replica list will be same since
                 * both use the the same flags MD_BASICNAME_OK|PRINT_FAST which
                 * will always provide the cached value.
                 */
            if ((dnp = metadrivename_withdrkey(&sn, sideno, dr->dr_key,
                MD_BASICNAME_OK | PRINT_FAST, &error)) == NULL) {
                mde_perror(&error, "");
                metafreereplicalist(rlp);
                auto_take_cleanup(&sn, sideno);
                return;
            }

            dbcnt = 0;
            /* see how many replicas are on this drive */
            for (rl = rlp; rl != NULL; rl = rl->rl_next) {
                if (strcmp(rl->rl_repp->r_namep->drivenamep->cname, dnp->cname)
                    == 0)
                    dbcnt++;
            }

            /* Adjust the fields in the copy */
            dr->dr_dbcnt = dbcnt;
            dr->dr_dbsize = dbcnt > 0 ? nblks : 0;
        }

        /*
         * If the set doesn't have the MD_SR_MB_DEVID bit set, i.e
         * the drives in the set don't have the device id information,
         * then stick it in if possible.
         *
         * If updating the master block fails for whatever reason, it's
         * okay. It just means the disk(s) in the diskset won't be self
         * identifying.
         */
        if (!(sr->sr_flags & MD_SR_MB_DEVID)) {
                if (meta_update_mb(&sn, dd, &error) == 0) {
                        sr->sr_flags |= MD_SR_MB_DEVID;
                        mdclrerror(&error);
                }
        }

        commitset(sr, FALSE, &error);

        metafreereplicalist(rlp);

        /*
         * This finishes up the logical equivalent of meta_set_take.
         */
        if (meta_resync_all(&sn, MD_DEF_RESYNC_BUF_SIZE, &error) != 0) {
            mde_perror(&error, "");
            mdclrerror(&error);
        }
}

/*
 * Take the disksets that are marked to be taken at boot time.
 */
static void
auto_take_sets()
{
        int             max_sets;
        int             i;
        md_error_t      error = mdnullerror;
        char            *hostname;

        if ((max_sets = get_max_sets(&error)) == 0)
            return;

        if (!mdisok(&error)) {
            mde_perror(&error, "");
            return;
        }

        /* set up so auto-take errors also go to syslog */
        openlog("metainit", LOG_ODELAY, LOG_USER);
        metasyslog = 1;

        hostname = mynode();

        /*
         * For each possible set number (skip set 0 which is the unnamed local
         * set), see if we really have a diskset.  If so, check if auto-take
         * is enabled.
         *
         * In order to take the set it must have drives and it must not be
         * stuck in mid-add.  The sr_validate routine within rpc.metad will
         * delete sets that are in mid-add when it runs.
         */
        for (i = 1; i < max_sets; i++) {
            md_set_record       *sr;

            if ((sr = metad_getsetbynum(i, &error)) == NULL) {
                mdclrerror(&error);
                continue;
            }

            if (sr->sr_flags & MD_SR_AUTO_TAKE && !(sr->sr_flags & MD_SR_ADD)) {
                int     j;
                int     cnt = 0;
                int     host_mismatch = 0;
                int     take = 0;
                md_drive_record *dr;

                /* check for host renames or multiple hosts in set */
                for (j = 0; j < MD_MAXSIDES; j++) {
                    /* Skip empty slots */
                    if (sr->sr_nodes[j][0] == '\0')
                        continue;

                    cnt++;
                    if (strcmp(sr->sr_nodes[j], hostname) != 0)
                        host_mismatch = 1;
                }

                /* paranoid check that we're the only host in the set */
                if (cnt > 1) {
                        md_eprintf(gettext(
                "diskset %s: auto-take enabled and multiple hosts in set\n"),
                            sr->sr_setname);
                        continue;
                }

                if (host_mismatch) {
                        /* The host was renamed, repair the set. */
                        for (j = 0; j < MD_MAXSIDES; j++) {
                                /* Skip empty slots */
                                if (sr->sr_nodes[j][0] == '\0')
                                        continue;

                                (void) strncpy(sr->sr_nodes[j], hostname,
                                    sizeof (sr->sr_nodes[j]));
                                commitset(sr, FALSE, &error);
                                if (!mdisok(&error)) {
                                        mde_perror(&error, "");
                                        mdclrerror(&error);
                                } else {
                                        md_eprintf(gettext(
                        "new hostname %s, update auto-take diskset %s\n"),
                                                hostname, sr->sr_setname);
                                }
                                break;
                        }
                }

                /* set must have at least one drive to be taken */
                for (dr = sr->sr_drivechain; dr != NULL; dr = dr->dr_next) {
                        /* ignore drives in mid-add */
                        if (!(dr->dr_flags & MD_DR_ADD)) {
                            take = 1;
                            break;
                        }
                }

                if (take)
                        take_set(sr);
                else
                        md_eprintf(gettext(
                "diskset %s: auto-take enabled but set has no drives\n"),
                            sr->sr_setname);
            }
        }
}

/*
 * mainline. crack command line arguments.
 */
int
main(
        int             argc,
        char            *argv[]
)
{
        char            *sname = MD_LOCAL_NAME;
        mdsetname_t     *sp = NULL;
        enum action {
                NONE,
                INIT,
                ALL
        }               todo = NONE;
        mdcmdopts_t     options = (MDCMD_DOIT | MDCMD_PRINT);
        int             c;
        md_error_t      status = mdnullerror;
        md_error_t      *ep = &status;

        md_error_t      dummystatus = mdnullerror;
        md_error_t      *dummyep = &dummystatus;
        int             eval = 1;
        int             error;
        bool_t          called_thru_rpc = FALSE;
        char            *cp;
        pid_t           pid;

        /*
         * Get the locale set up before calling any other routines
         * with messages to ouput.  Just in case we're not in a build
         * environment, make sure that TEXT_DOMAIN gets set to
         * something.
         */
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void) setlocale(LC_ALL, "");
        (void) textdomain(TEXT_DOMAIN);
        if ((cp = strstr(argv[0], ".rpc_call")) != NULL) {
                *cp = '\0'; /* cut off ".rpc_call" */
                called_thru_rpc = TRUE;
        } else {
                if (sdssc_bind_library() == SDSSC_OKAY)
                        if (sdssc_cmd_proxy(argc, argv, SDSSC_PROXY_PRIMARY,
                                                &error) == SDSSC_PROXY_DONE)
                                exit(error);
        }

        /* initialize */
        if (md_init(argc, argv, 0, 1, ep) != 0 ||
                        meta_check_root(ep) != 0) {
                mde_perror(ep, "");
                md_exit(sp, 1);
        }

        /* parse args */
        optind = 1;
        opterr = 1;
        while ((c = getopt(argc, argv, "afhnrs:?")) != -1) {
                switch (c) {

                /* help */
                case 'h':
                        usage(sp, 0);
                        break;

                /* set name */
                case 's':
                        sname = optarg;
                        break;

                /* all devices in md.tab */
                case 'a':
                        if (todo != NONE)
                                usage(sp, 1);
                        todo = ALL;
                        options |= MDCMD_ALLOPTION;
                        break;
                /* check for validity, but don't really init */
                case 'n':
                        options &= ~MDCMD_DOIT;
                        break;

                /* for recovery */
                case 'r':
                        if (todo != NONE)
                                usage(sp, 1);
                        todo = INIT;
                        break;

                /* mounted and swapped components are OK */
                case 'f':
                        options |= MDCMD_FORCE;
                        break;

                case '?':
                        if (optopt == '?')
                                usage(sp, 0);
                        /*FALLTHROUGH*/
                default:
                        usage(sp, 1);
                        break;
                }
        }

        /* sname is MD_LOCAL_NAME if not specified on the command line */
        if ((sp = metasetname(sname, ep)) == NULL) {
                mde_perror(ep, "");
                md_exit(sp, 1);
        }

        argc -= optind;
        argv += optind;
        if (todo == NONE) {
                if (argc <= 0) {
                        usage(sp, 1);
                }
        } else if (argc > 0) {
                usage(sp, 1);
        }


        /* setup database locations */
        if (meta_setup_db_locations(ep) != 0) {
                mde_perror(ep, "");
                if (mdismddberror(ep, MDE_DB_STALE))
                        md_exit(sp, 66);
                if (! mdiserror(ep, MDE_MDDB_CKSUM))    /* relatively benign */
                        md_exit(sp, 1);
        }
        if (todo == INIT) {             /* load and take auto-take sets */
                auto_take_sets();

                /*
                 * During the boot sequence we need to update the mediator
                 * records, however this depends upon the rpc.metamedd
                 * running. So, in order to not introduce a delay in the
                 * boot time, fork a new process to do this work in the
                 * background.
                 */
                pid = fork1();
                if (pid == (pid_t)-1) {
                        /*
                         * We could not fork a child process to udpate mediator
                         * information on this node. There is no need to panic.
                         * We shall simply return 1.
                         */
                        mde_perror(ep, "Could not fork a child process to"
                            " update mediator record");
                        md_exit(sp, 1);
                } else if (pid == (pid_t)0) {
                        /* child */
                        if (meta_mediator_info_from_file(NULL, 0, ep) == 1) {
                                /*
                                 * No need to print any error messages.
                                 * All the errors messages are printed in the
                                 * library routine itself.
                                 */
                                md_exit(sp, 1);
                        } else {
                                md_exit(sp, 0);
                        }
                } else {
                        /* Parent process */
                        md_exit(sp, 0);
                }
        } else if (todo == ALL) {       /* initialize all devices in md.tab */
                eval = init_all(&sp, options, called_thru_rpc, ep);
        } else {                        /* initialize the named device */
                eval = 0;
                if (init_name(&sp, argc, argv, options, called_thru_rpc,
                    ep) != 0) {
                        /*
                         * If we're dealing with MN metadevices and we are
                         * directly called, then the appropriate error message
                         * has already been displayed. So just exit.
                         */
                        if (meta_is_mn_set(sp, dummyep) && (!called_thru_rpc)) {
                                md_exit(sp, 1);
                        }
                        mde_perror(ep, "");
                        mdclrerror(ep);
                        eval = 1;
                        goto nomdcf;
                }
        }

domdcf:
        /* update md.cf, return success */
        if (meta_update_md_cf(sp, ep) != 0) {
                mde_perror(ep, "");
                eval = 1;
        }

nomdcf:
        md_exit(sp, eval);
        /*NOTREACHED*/
        return (eval);
}