common/devid/devid.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/types.h>
#include <sys/stropts.h>
#include <sys/debug.h>
#include <sys/isa_defs.h>
#include <sys/dditypes.h>
#include <sys/ddi_impldefs.h>
#include "devid_impl.h"

static int devid_str_decode_id(char *devidstr, ddi_devid_t *devidp,
    char **minor_namep, impl_devid_t *id);


/*
 * Validate device id.
 */
int
#ifdef  _KERNEL
ddi_devid_valid(ddi_devid_t devid)
#else   /* !_KERNEL */
devid_valid(ddi_devid_t devid)
#endif  /* _KERNEL */
{
    impl_devid_t    *id = (impl_devid_t *)devid;
    ushort_t    type;

    DEVID_ASSERT(devid != NULL);

    if (id->did_magic_hi != DEVID_MAGIC_MSB)
        return (DEVID_RET_INVALID);

    if (id->did_magic_lo != DEVID_MAGIC_LSB)
        return (DEVID_RET_INVALID);

    if (id->did_rev_hi != DEVID_REV_MSB)
        return (DEVID_RET_INVALID);

    if (id->did_rev_lo != DEVID_REV_LSB)
        return (DEVID_RET_INVALID);

    type = DEVID_GETTYPE(id);
    if ((type == DEVID_NONE) || (type > DEVID_MAXTYPE))
        return (DEVID_RET_INVALID);

    return (DEVID_RET_VALID);
}

/*
 * Return the sizeof a device id. If called with NULL devid it returns
 * the amount of space needed to determine the size.
 */
size_t
#ifdef  _KERNEL
ddi_devid_sizeof(ddi_devid_t devid)
#else   /* !_KERNEL */
devid_sizeof(ddi_devid_t devid)
#endif  /* _KERNEL */
{
    impl_devid_t    *id = (impl_devid_t *)devid;

    if (id == NULL)
        return (sizeof (*id) - sizeof (id->did_id));

    DEVID_ASSERT(DEVID_FUNC(devid_valid)(devid) == DEVID_RET_VALID);

    return (sizeof (*id) + DEVID_GETLEN(id) - sizeof (id->did_id));
}

/*
 * Compare two device id's.
 *  -1 - less than
 *  0  - equal
 *  1  - greater than
 */
int
#ifdef  _KERNEL
ddi_devid_compare(ddi_devid_t id1, ddi_devid_t id2)
#else   /* !_KERNEL */
devid_compare(ddi_devid_t id1, ddi_devid_t id2)
#endif  /* _KERNEL */
{
    int     rval;
    impl_devid_t    *i_id1  = (impl_devid_t *)id1;
    impl_devid_t    *i_id2  = (impl_devid_t *)id2;
    ushort_t    i_id1_type;
    ushort_t    i_id2_type;

    DEVID_ASSERT((id1 != NULL) && (id2 != NULL));
    DEVID_ASSERT(DEVID_FUNC(devid_valid)(id1) == DEVID_RET_VALID);
    DEVID_ASSERT(DEVID_FUNC(devid_valid)(id2) == DEVID_RET_VALID);

    /* magic and revision comparison */
    if ((rval = bcmp(id1, id2, 4)) != 0) {
        return (rval);
    }

    /* get current devid types */
    i_id1_type = DEVID_GETTYPE(i_id1);
    i_id2_type = DEVID_GETTYPE(i_id2);

    /*
     * Originaly all page83 devids used DEVID_SCSI3_WWN.
     * To avoid a possible uniqueness issue each type of page83
     * encoding supported is represented as a separate
     * devid type.  If comparing DEVID_SCSI3_WWN against
     * one of the new page83 encodings we assume that no
     * uniqueness issue exists (since we had apparently been
     * running with the old DEVID_SCSI3_WWN encoding without
     * a problem).
     */
    if ((i_id1_type == DEVID_SCSI3_WWN) ||
        (i_id2_type == DEVID_SCSI3_WWN)) {
        /*
         * Atleast one devid is using old scsi
         * encode algorithm.  Force devid types
         * to same scheme for comparison.
         */
        if (IS_DEVID_SCSI3_VPD_TYPE(i_id1_type)) {
            i_id1_type = DEVID_SCSI3_WWN;
        }
        if (IS_DEVID_SCSI3_VPD_TYPE(i_id2_type)) {
            i_id2_type = DEVID_SCSI3_WWN;
        }
    }

    /* type comparison */
    if (i_id1_type != i_id2_type) {
        return ((i_id1_type < i_id2_type) ? -1 : 1);
    }

    /* length comparison */
    if (DEVID_GETLEN(i_id1) != DEVID_GETLEN(i_id2)) {
        return (DEVID_GETLEN(i_id1) < DEVID_GETLEN(i_id2) ? -1 : 1);
    }

    /* id comparison */
    rval = bcmp(i_id1->did_id, i_id2->did_id, DEVID_GETLEN(i_id1));

    return (rval);
}

/*
 * Free a Device Id
 */
void
#ifdef  _KERNEL
ddi_devid_free(ddi_devid_t devid)
#else   /* !_KERNEL */
devid_free(ddi_devid_t devid)
#endif  /* _KERNEL */
{
    DEVID_ASSERT(devid != NULL);
    DEVID_FREE(devid, DEVID_FUNC(devid_sizeof)(devid));
}

/*
 * Encode a device id into a string.  See ddi_impldefs.h for details.
 */
char *
#ifdef  _KERNEL
ddi_devid_str_encode(ddi_devid_t devid, char *minor_name)
#else   /* !_KERNEL */
devid_str_encode(ddi_devid_t devid, char *minor_name)
#endif  /* _KERNEL */
{
    impl_devid_t    *id = (impl_devid_t *)devid;
    size_t      driver_len, devid_len, slen;
    char        *sbuf, *dsp, *dp, ta;
    int     i, n, ascii;

    /* "id0" is the encoded representation of a NULL device id */
    if (devid == NULL) {
        if ((sbuf = DEVID_MALLOC(4)) == NULL)
            return (NULL);
        *(sbuf+0) = DEVID_MAGIC_MSB;
        *(sbuf+1) = DEVID_MAGIC_LSB;
        *(sbuf+2) = '0';
        *(sbuf+3) = 0;
        return (sbuf);
    }

    /* verify input */
    if (DEVID_FUNC(devid_valid)(devid) != DEVID_RET_VALID)
        return (NULL);

    /* scan the driver hint to see how long the hint is */
    for (driver_len = 0; driver_len < DEVID_HINT_SIZE; driver_len++)
        if (id->did_driver[driver_len] == '\0')
            break;

    /* scan the contained did_id to see if it meets ascii requirements */
    devid_len = DEVID_GETLEN(id);
    for (ascii = 1, i = 0; i < devid_len; i++)
        if (!DEVID_IDBYTE_ISASCII(id->did_id[i])) {
            ascii = 0;
            break;
        }

    /* some types should always go hex even if they look ascii */
    if (DEVID_TYPE_BIN_FORCEHEX(id->did_type_lo))
        ascii = 0;

    /* set the length of the resulting string */
    slen = 2 + 1;                   /* <magic><rev> "id1" */
    slen += 1 + driver_len + 1 + 1;         /* ",<driver>@<type>" */
    slen += ascii ? devid_len : (devid_len * 2);    /* did_id field */
    if (minor_name) {
        slen += 1;              /* '/' */
        slen += strlen(minor_name);     /* len of minor_name */
    }
    slen += 1;                  /* NULL */

    /* allocate string */
    if ((sbuf = DEVID_MALLOC(slen)) == NULL)
        return (NULL);

    /* perform encode of id to hex string */
    dsp = sbuf;
    *dsp++ = id->did_magic_hi;
    *dsp++ = id->did_magic_lo;
    *dsp++ = DEVID_REV_BINTOASCII(id->did_rev_lo);
    *dsp++ = ',';
    for (i = 0; i < driver_len; i++)
        *dsp++ = id->did_driver[i];
    *dsp++ = '@';
    ta = DEVID_TYPE_BINTOASCII(id->did_type_lo);
    if (ascii)
        ta = DEVID_TYPE_SETASCII(ta);
    *dsp++ = ta;
    for (i = 0, dp = &id->did_id[0]; i < devid_len; i++, dp++) {
        if (ascii) {
            if (*dp == ' ')
                *dsp++ = '_';
            else if (*dp == 0x00)
                *dsp++ = '~';
            else
                *dsp++ = *dp;
        } else {
            n = ((*dp) >> 4) & 0xF;
            *dsp++ = (n < 10) ? (n + '0') : (n + ('a' - 10));
            n = (*dp) & 0xF;
            *dsp++ = (n < 10) ? (n + '0') : (n + ('a' - 10));
        }
    }

    if (minor_name) {
        *dsp++ = '/';
        (void) strcpy(dsp, minor_name);
    } else
        *dsp++ = 0;

    /* ensure that (strlen + 1) is correct length for free */
    DEVID_ASSERT((strlen(sbuf) + 1) == slen);
    return (sbuf);
}

/* free the string returned by devid_str_encode */
void
#ifdef  _KERNEL
ddi_devid_str_free(char *devidstr)
#else   /* !_KERNEL */
devid_str_free(char *devidstr)
#endif  /* _KERNEL */
{
    DEVID_FREE(devidstr, strlen(devidstr) + 1);
}

/*
 * given the string representation of a device id returned by calling
 * devid_str_encode (passed in as devidstr), return pointers to the
 * broken out devid and minor_name as requested. Devidstr remains
 * allocated and unmodified. The devid returned in *devidp should be freed by
 * calling devid_free.  The minor_name returned in minor_namep should
 * be freed by calling devid_str_free(minor_namep).
 *
 * See ddi_impldefs.h for format details.
 */
int
#ifdef  _KERNEL
ddi_devid_str_decode(
#else   /* !_KERNEL */
devid_str_decode(
#endif  /* _KERNEL */
    char *devidstr, ddi_devid_t *devidp, char **minor_namep)
{
    return (devid_str_decode_id(devidstr, devidp, minor_namep, NULL));
}

/* implementation for (ddi_)devid_str_decode */
static int
devid_str_decode_id(char *devidstr, ddi_devid_t *devidp,
    char **minor_namep, impl_devid_t *id)
{
    char        *str, *msp, *dsp, *dp, ta;
    int     slen, devid_len, ascii, i, n, c, pre_alloc = FALSE;
    unsigned short  id_len, type;       /* for hibyte/lobyte */

    if (devidp != NULL)
        *devidp = NULL;
    if (minor_namep != NULL)
        *minor_namep = NULL;
    if (id != NULL)
        pre_alloc = TRUE;

    if (devidstr == NULL)
        return (DEVID_FAILURE);

    /* the string must atleast contain the ascii two byte header */
    slen = strlen(devidstr);
    if ((slen < 3) || (devidstr[0] != DEVID_MAGIC_MSB) ||
        (devidstr[1] != DEVID_MAGIC_LSB))
        return (DEVID_FAILURE);

    /* "id0" is the encoded representation of a NULL device id */
    if ((devidstr[2] == '0') && (slen == 3))
        return (DEVID_SUCCESS);

    /* "id1,@S0" is the shortest possible, reject if shorter */
    if (slen <  7)
        return (DEVID_FAILURE);

    /* find the optional minor name, start after ',' */
    if ((msp = strchr(&devidstr[4], '/')) != NULL)
        msp++;

    /* skip devid processing if we are not asked to return it */
    if (devidp) {
        /* find the required '@' separator */
        if ((str = strchr(devidstr, '@')) == NULL)
            return (DEVID_FAILURE);
        str++;                  /* skip '@' */

        /* pick up <type> after the '@' and verify */
        ta = *str++;
        ascii = DEVID_TYPE_ISASCII(ta);
        type = DEVID_TYPE_ASCIITOBIN(ta);
        if (type > DEVID_MAXTYPE)
            return (DEVID_FAILURE);

        /* determine length of id->did_id field */
        if (msp == NULL)
            id_len = strlen(str);
        else
            id_len = msp - str - 1;

        /* account for encoding: with hex, binary is half the size */
        if (!ascii) {
            /* hex id field must be even length */
            if (id_len & 1)
                return (DEVID_FAILURE);
            id_len /= 2;
        }

        /* add in size of the binary devid header */
        devid_len = id_len + sizeof (*id) - sizeof (id->did_id);

        /*
         * Allocate space for devid if we are asked to decode it
         * decode it and space wasn't pre-allocated.
         */
        if (pre_alloc == FALSE) {
            if ((id = (impl_devid_t *)DEVID_MALLOC(
                devid_len)) == NULL)
            return (DEVID_FAILURE);
        }

        /* decode header portion of the string into the binary devid */
        dsp = devidstr;
        id->did_magic_hi = *dsp++;      /* <magic> "id" */
        id->did_magic_lo = *dsp++;
        id->did_rev_hi = 0;
        id->did_rev_lo =
            DEVID_REV_ASCIITOBIN(*dsp);     /* <rev> "1" */
        dsp++;                  /* skip "1" */
        dsp++;                  /* skip "," */
        for (i = 0; i < DEVID_HINT_SIZE; i++) { /* <driver>@ */
            if (*dsp == '@')
                break;
            id->did_driver[i] = *dsp++;
        }
        for (; i < DEVID_HINT_SIZE; i++)
            id->did_driver[i] = 0;

        /* we must now be at the '@' */
        if (*dsp != '@')
            goto efree;

        /* set the type and length */
        DEVID_FORMTYPE(id, type);
        DEVID_FORMLEN(id, id_len);

        /* decode devid portion of string into the binary */
        for (i = 0, dsp = str, dp = &id->did_id[0];
            i < id_len; i++, dp++) {
            if (ascii) {
                if (*dsp == '_')
                    *dp = ' ';
                else if (*dsp == '~')
                    *dp = 0x00;
                else
                    *dp = *dsp;
                dsp++;
            } else {
                c = *dsp++;
                if (c >= '0' && c <= '9')
                    n = (c - '0') & 0xFF;
                else if (c >= 'a' && c <= 'f')
                    n = (c - ('a' - 10)) & 0xFF;
                else
                    goto efree;
                n <<= 4;
                c = *dsp++;
                if (c >= '0' && c <= '9')
                    n |= (c - '0') & 0xFF;
                else if (c >= 'a' && c <= 'f')
                    n |= (c - ('a' - 10)) & 0xFF;
                else
                    goto efree;
                *dp = n;
            }
        }

        /* verify result */
        if (DEVID_FUNC(devid_valid)((ddi_devid_t)id) != DEVID_RET_VALID)
            goto efree;
    }

    /* duplicate minor_name if we are asked to decode it */
    if (minor_namep && msp) {
        if ((*minor_namep = DEVID_MALLOC(strlen(msp) + 1)) == NULL)
            goto efree;
        (void) strcpy(*minor_namep, msp);
    }

    /* return pointer to binary */
    if (devidp)
        *devidp = (ddi_devid_t)id;
    return (DEVID_SUCCESS);

efree:
    if ((pre_alloc == FALSE) && (id))
        DEVID_FREE(id, devid_len);
    return (DEVID_FAILURE);
}


/*
 * Compare two device id's in string form
 *  -1 - id1 less than id2
 *  0  - equal
 *  1  - id1 greater than id2
 */
int
#ifdef  _KERNEL
ddi_devid_str_compare(char *id1_str, char *id2_str)
#else   /* !_KERNEL */
devid_str_compare(char *id1_str, char *id2_str)
#endif  /* _KERNEL */
{
    int     rval    = DEVID_FAILURE;
    ddi_devid_t devid1;
    ddi_devid_t devid2;
#ifdef  _KERNEL
    /* kernel use static protected by lock. */
    static kmutex_t id_lock;
    static uchar_t  id1[sizeof (impl_devid_t) + MAXPATHLEN];
    static uchar_t  id2[sizeof (impl_devid_t) + MAXPATHLEN];
#else   /* !_KERNEL */
    /* userland place on stack, since malloc might fail */
    uchar_t     id1[sizeof (impl_devid_t) + MAXPATHLEN];
    uchar_t     id2[sizeof (impl_devid_t) + MAXPATHLEN];
#endif  /* _KERNEL */

#ifdef  _KERNEL
    mutex_enter(&id_lock);
#endif  /* _KERNEL */

    /*
     * encode string form of devid
     */
    if ((devid_str_decode_id(id1_str, &devid1, NULL, (impl_devid_t *)id1) ==
        DEVID_SUCCESS) &&
        (devid_str_decode_id(id2_str, &devid2, NULL, (impl_devid_t *)id2) ==
        DEVID_SUCCESS)) {
        rval = DEVID_FUNC(devid_compare)(devid1, devid2);
    }

#ifdef  _KERNEL
    mutex_exit(&id_lock);
#endif  /* _KERNEL */

    return (rval);
}