usr/src/common/devid/devid.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <sys/types.h>
  29 #include <sys/stropts.h>
  30 #include <sys/debug.h>
  31 #include <sys/isa_defs.h>
  32 #include <sys/dditypes.h>
  33 #include <sys/ddi_impldefs.h>
  34 #include "devid_impl.h"
  35
  36 static int devid_str_decode_id(char *devidstr, ddi_devid_t *devidp,
  37     char **minor_namep, impl_devid_t *id);
  38
  39
  40 /*
  41  * Validate device id.
  42  */
  43 int
  44 #ifdef  _KERNEL
  45 ddi_devid_valid(ddi_devid_t devid)
  46 #else   /* !_KERNEL */
  47 devid_valid(ddi_devid_t devid)
  48 #endif  /* _KERNEL */
  49 {
  50         impl_devid_t    *id = (impl_devid_t *)devid;
  51         ushort_t        type;
  52
  53         DEVID_ASSERT(devid != NULL);
  54
  55         if (id->did_magic_hi != DEVID_MAGIC_MSB)
  56                 return (DEVID_RET_INVALID);
  57
  58         if (id->did_magic_lo != DEVID_MAGIC_LSB)
  59                 return (DEVID_RET_INVALID);
  60
  61         if (id->did_rev_hi != DEVID_REV_MSB)
  62                 return (DEVID_RET_INVALID);
  63
  64         if (id->did_rev_lo != DEVID_REV_LSB)
  65                 return (DEVID_RET_INVALID);
  66
  67         type = DEVID_GETTYPE(id);
  68         if ((type == DEVID_NONE) || (type > DEVID_MAXTYPE))
  69                 return (DEVID_RET_INVALID);
  70
  71         return (DEVID_RET_VALID);
  72 }
  73
  74 /*
  75  * Return the sizeof a device id. If called with NULL devid it returns
  76  * the amount of space needed to determine the size.
  77  */
  78 size_t
  79 #ifdef  _KERNEL
  80 ddi_devid_sizeof(ddi_devid_t devid)
  81 #else   /* !_KERNEL */
  82 devid_sizeof(ddi_devid_t devid)
  83 #endif  /* _KERNEL */
  84 {
  85         impl_devid_t    *id = (impl_devid_t *)devid;
  86
  87         if (id == NULL)
  88                 return (sizeof (*id) - sizeof (id->did_id));
  89
  90         DEVID_ASSERT(DEVID_FUNC(devid_valid)(devid) == DEVID_RET_VALID);
  91
  92         return (sizeof (*id) + DEVID_GETLEN(id) - sizeof (id->did_id));
  93 }
  94
  95 /*
  96  * Compare two device id's.
  97  *      -1 - less than
  98  *      0  - equal
  99  *      1  - greater than
 100  */
 101 int
 102 #ifdef  _KERNEL
 103 ddi_devid_compare(ddi_devid_t id1, ddi_devid_t id2)
 104 #else   /* !_KERNEL */
 105 devid_compare(ddi_devid_t id1, ddi_devid_t id2)
 106 #endif  /* _KERNEL */
 107 {
 108         int             rval;
 109         impl_devid_t    *i_id1  = (impl_devid_t *)id1;
 110         impl_devid_t    *i_id2  = (impl_devid_t *)id2;
 111         ushort_t        i_id1_type;
 112         ushort_t        i_id2_type;
 113
 114         DEVID_ASSERT((id1 != NULL) && (id2 != NULL));
 115         DEVID_ASSERT(DEVID_FUNC(devid_valid)(id1) == DEVID_RET_VALID);
 116         DEVID_ASSERT(DEVID_FUNC(devid_valid)(id2) == DEVID_RET_VALID);
 117
 118         /* magic and revision comparison */
 119         if ((rval = bcmp(id1, id2, 4)) != 0) {
 120                 return (rval);
 121         }
 122
 123         /* get current devid types */
 124         i_id1_type = DEVID_GETTYPE(i_id1);
 125         i_id2_type = DEVID_GETTYPE(i_id2);
 126
 127         /*
 128          * Originaly all page83 devids used DEVID_SCSI3_WWN.
 129          * To avoid a possible uniqueness issue each type of page83
 130          * encoding supported is represented as a separate
 131          * devid type.  If comparing DEVID_SCSI3_WWN against
 132          * one of the new page83 encodings we assume that no
 133          * uniqueness issue exists (since we had apparently been
 134          * running with the old DEVID_SCSI3_WWN encoding without
 135          * a problem).
 136          */
 137         if ((i_id1_type == DEVID_SCSI3_WWN) ||
 138             (i_id2_type == DEVID_SCSI3_WWN)) {
 139                 /*
 140                  * Atleast one devid is using old scsi
 141                  * encode algorithm.  Force devid types
 142                  * to same scheme for comparison.
 143                  */
 144                 if (IS_DEVID_SCSI3_VPD_TYPE(i_id1_type)) {
 145                         i_id1_type = DEVID_SCSI3_WWN;
 146                 }
 147                 if (IS_DEVID_SCSI3_VPD_TYPE(i_id2_type)) {
 148                         i_id2_type = DEVID_SCSI3_WWN;
 149                 }
 150         }
 151
 152         /* type comparison */
 153         if (i_id1_type != i_id2_type) {
 154                 return ((i_id1_type < i_id2_type) ? -1 : 1);
 155         }
 156
 157         /* length comparison */
 158         if (DEVID_GETLEN(i_id1) != DEVID_GETLEN(i_id2)) {
 159                 return (DEVID_GETLEN(i_id1) < DEVID_GETLEN(i_id2) ? -1 : 1);
 160         }
 161
 162         /* id comparison */
 163         rval = bcmp(i_id1->did_id, i_id2->did_id, DEVID_GETLEN(i_id1));
 164
 165         return (rval);
 166 }
 167
 168 /*
 169  * Free a Device Id
 170  */
 171 void
 172 #ifdef  _KERNEL
 173 ddi_devid_free(ddi_devid_t devid)
 174 #else   /* !_KERNEL */
 175 devid_free(ddi_devid_t devid)
 176 #endif  /* _KERNEL */
 177 {
 178         DEVID_ASSERT(devid != NULL);
 179         DEVID_FREE(devid, DEVID_FUNC(devid_sizeof)(devid));
 180 }
 181
 182 /*
 183  * Encode a device id into a string.  See ddi_impldefs.h for details.
 184  */
 185 char *
 186 #ifdef  _KERNEL
 187 ddi_devid_str_encode(ddi_devid_t devid, char *minor_name)
 188 #else   /* !_KERNEL */
 189 devid_str_encode(ddi_devid_t devid, char *minor_name)
 190 #endif  /* _KERNEL */
 191 {
 192         impl_devid_t    *id = (impl_devid_t *)devid;
 193         size_t          driver_len, devid_len, slen;
 194         char            *sbuf, *dsp, *dp, ta;
 195         int             i, n, ascii;
 196
 197         /* "id0" is the encoded representation of a NULL device id */
 198         if (devid == NULL) {
 199                 if ((sbuf = DEVID_MALLOC(4)) == NULL)
 200                         return (NULL);
 201                 *(sbuf+0) = DEVID_MAGIC_MSB;
 202                 *(sbuf+1) = DEVID_MAGIC_LSB;
 203                 *(sbuf+2) = '0';
 204                 *(sbuf+3) = 0;
 205                 return (sbuf);
 206         }
 207
 208         /* verify input */
 209         if (DEVID_FUNC(devid_valid)(devid) != DEVID_RET_VALID)
 210                 return (NULL);
 211
 212         /* scan the driver hint to see how long the hint is */
 213         for (driver_len = 0; driver_len < DEVID_HINT_SIZE; driver_len++)
 214                 if (id->did_driver[driver_len] == '\0')
 215                         break;
 216
 217         /* scan the contained did_id to see if it meets ascii requirements */
 218         devid_len = DEVID_GETLEN(id);
 219         for (ascii = 1, i = 0; i < devid_len; i++)
 220                 if (!DEVID_IDBYTE_ISASCII(id->did_id[i])) {
 221                         ascii = 0;
 222                         break;
 223                 }
 224
 225         /* some types should always go hex even if they look ascii */
 226         if (DEVID_TYPE_BIN_FORCEHEX(id->did_type_lo))
 227                 ascii = 0;
 228
 229         /* set the length of the resulting string */
 230         slen = 2 + 1;                                   /* <magic><rev> "id1" */
 231         slen += 1 + driver_len + 1 + 1;                 /* ",<driver>@<type>" */
 232         slen += ascii ? devid_len : (devid_len * 2);    /* did_id field */
 233         if (minor_name) {
 234                 slen += 1;                              /* '/' */
 235                 slen += strlen(minor_name);             /* len of minor_name */
 236         }
 237         slen += 1;                                      /* NULL */
 238
 239         /* allocate string */
 240         if ((sbuf = DEVID_MALLOC(slen)) == NULL)
 241                 return (NULL);
 242
 243         /* perform encode of id to hex string */
 244         dsp = sbuf;
 245         *dsp++ = id->did_magic_hi;
 246         *dsp++ = id->did_magic_lo;
 247         *dsp++ = DEVID_REV_BINTOASCII(id->did_rev_lo);
 248         *dsp++ = ',';
 249         for (i = 0; i < driver_len; i++)
 250                 *dsp++ = id->did_driver[i];
 251         *dsp++ = '@';
 252         ta = DEVID_TYPE_BINTOASCII(id->did_type_lo);
 253         if (ascii)
 254                 ta = DEVID_TYPE_SETASCII(ta);
 255         *dsp++ = ta;
 256         for (i = 0, dp = &id->did_id[0]; i < devid_len; i++, dp++) {
 257                 if (ascii) {
 258                         if (*dp == ' ')
 259                                 *dsp++ = '_';
 260                         else if (*dp == 0x00)
 261                                 *dsp++ = '~';
 262                         else
 263                                 *dsp++ = *dp;
 264                 } else {
 265                         n = ((*dp) >> 4) & 0xF;
 266                         *dsp++ = (n < 10) ? (n + '0') : (n + ('a' - 10));
 267                         n = (*dp) & 0xF;
 268                         *dsp++ = (n < 10) ? (n + '0') : (n + ('a' - 10));
 269                 }
 270         }
 271
 272         if (minor_name) {
 273                 *dsp++ = '/';
 274                 (void) strcpy(dsp, minor_name);
 275         } else
 276                 *dsp++ = 0;
 277
 278         /* ensure that (strlen + 1) is correct length for free */
 279         DEVID_ASSERT((strlen(sbuf) + 1) == slen);
 280         return (sbuf);
 281 }
 282
 283 /* free the string returned by devid_str_encode */
 284 void
 285 #ifdef  _KERNEL
 286 ddi_devid_str_free(char *devidstr)
 287 #else   /* !_KERNEL */
 288 devid_str_free(char *devidstr)
 289 #endif  /* _KERNEL */
 290 {
 291         DEVID_FREE(devidstr, strlen(devidstr) + 1);
 292 }
 293
 294 /*
 295  * given the string representation of a device id returned by calling
 296  * devid_str_encode (passed in as devidstr), return pointers to the
 297  * broken out devid and minor_name as requested. Devidstr remains
 298  * allocated and unmodified. The devid returned in *devidp should be freed by
 299  * calling devid_free.  The minor_name returned in minor_namep should
 300  * be freed by calling devid_str_free(minor_namep).
 301  *
 302  * See ddi_impldefs.h for format details.
 303  */
 304 int
 305 #ifdef  _KERNEL
 306 ddi_devid_str_decode(
 307 #else   /* !_KERNEL */
 308 devid_str_decode(
 309 #endif  /* _KERNEL */
 310     char *devidstr, ddi_devid_t *devidp, char **minor_namep)
 311 {
 312         return (devid_str_decode_id(devidstr, devidp, minor_namep, NULL));
 313 }
 314
 315 /* implementation for (ddi_)devid_str_decode */
 316 static int
 317 devid_str_decode_id(char *devidstr, ddi_devid_t *devidp,
 318     char **minor_namep, impl_devid_t *id)
 319 {
 320         char            *str, *msp, *dsp, *dp, ta;
 321         int             slen, devid_len, ascii, i, n, c, pre_alloc = FALSE;
 322         unsigned short  id_len, type;           /* for hibyte/lobyte */
 323
 324         if (devidp != NULL)
 325                 *devidp = NULL;
 326         if (minor_namep != NULL)
 327                 *minor_namep = NULL;
 328         if (id != NULL)
 329                 pre_alloc = TRUE;
 330
 331         if (devidstr == NULL)
 332                 return (DEVID_FAILURE);
 333
 334         /* the string must atleast contain the ascii two byte header */
 335         slen = strlen(devidstr);
 336         if ((slen < 3) || (devidstr[0] != DEVID_MAGIC_MSB) ||
 337             (devidstr[1] != DEVID_MAGIC_LSB))
 338                 return (DEVID_FAILURE);
 339
 340         /* "id0" is the encoded representation of a NULL device id */
 341         if ((devidstr[2] == '0') && (slen == 3))
 342                 return (DEVID_SUCCESS);
 343
 344         /* "id1,@S0" is the shortest possible, reject if shorter */
 345         if (slen <  7)
 346                 return (DEVID_FAILURE);
 347
 348         /* find the optional minor name, start after ',' */
 349         if ((msp = strchr(&devidstr[4], '/')) != NULL)
 350                 msp++;
 351
 352         /* skip devid processing if we are not asked to return it */
 353         if (devidp) {
 354                 /* find the required '@' separator */
 355                 if ((str = strchr(devidstr, '@')) == NULL)
 356                         return (DEVID_FAILURE);
 357                 str++;                                  /* skip '@' */
 358
 359                 /* pick up <type> after the '@' and verify */
 360                 ta = *str++;
 361                 ascii = DEVID_TYPE_ISASCII(ta);
 362                 type = DEVID_TYPE_ASCIITOBIN(ta);
 363                 if (type > DEVID_MAXTYPE)
 364                         return (DEVID_FAILURE);
 365
 366                 /* determine length of id->did_id field */
 367                 if (msp == NULL)
 368                         id_len = strlen(str);
 369                 else
 370                         id_len = msp - str - 1;
 371
 372                 /* account for encoding: with hex, binary is half the size */
 373                 if (!ascii) {
 374                         /* hex id field must be even length */
 375                         if (id_len & 1)
 376                                 return (DEVID_FAILURE);
 377                         id_len /= 2;
 378                 }
 379
 380                 /* add in size of the binary devid header */
 381                 devid_len = id_len + sizeof (*id) - sizeof (id->did_id);
 382
 383                 /*
 384                  * Allocate space for devid if we are asked to decode it
 385                  * decode it and space wasn't pre-allocated.
 386                  */
 387                 if (pre_alloc == FALSE) {
 388                         if ((id = (impl_devid_t *)DEVID_MALLOC(
 389                             devid_len)) == NULL)
 390                         return (DEVID_FAILURE);
 391                 }
 392
 393                 /* decode header portion of the string into the binary devid */
 394                 dsp = devidstr;
 395                 id->did_magic_hi = *dsp++;              /* <magic> "id" */
 396                 id->did_magic_lo = *dsp++;
 397                 id->did_rev_hi = 0;
 398                 id->did_rev_lo =
 399                     DEVID_REV_ASCIITOBIN(*dsp);         /* <rev> "1" */
 400                 dsp++;                                  /* skip "1" */
 401                 dsp++;                                  /* skip "," */
 402                 for (i = 0; i < DEVID_HINT_SIZE; i++) { /* <driver>@ */
 403                         if (*dsp == '@')
 404                                 break;
 405                         id->did_driver[i] = *dsp++;
 406                 }
 407                 for (; i < DEVID_HINT_SIZE; i++)
 408                         id->did_driver[i] = 0;
 409
 410                 /* we must now be at the '@' */
 411                 if (*dsp != '@')
 412                         goto efree;
 413
 414                 /* set the type and length */
 415                 DEVID_FORMTYPE(id, type);
 416                 DEVID_FORMLEN(id, id_len);
 417
 418                 /* decode devid portion of string into the binary */
 419                 for (i = 0, dsp = str, dp = &id->did_id[0];
 420                     i < id_len; i++, dp++) {
 421                         if (ascii) {
 422                                 if (*dsp == '_')
 423                                         *dp = ' ';
 424                                 else if (*dsp == '~')
 425                                         *dp = 0x00;
 426                                 else
 427                                         *dp = *dsp;
 428                                 dsp++;
 429                         } else {
 430                                 c = *dsp++;
 431                                 if (c >= '0' && c <= '9')
 432                                         n = (c - '0') & 0xFF;
 433                                 else if (c >= 'a' && c <= 'f')
 434                                         n = (c - ('a' - 10)) & 0xFF;
 435                                 else
 436                                         goto efree;
 437                                 n <<= 4;
 438                                 c = *dsp++;
 439                                 if (c >= '0' && c <= '9')
 440                                         n |= (c - '0') & 0xFF;
 441                                 else if (c >= 'a' && c <= 'f')
 442                                         n |= (c - ('a' - 10)) & 0xFF;
 443                                 else
 444                                         goto efree;
 445                                 *dp = n;
 446                         }
 447                 }
 448
 449                 /* verify result */
 450                 if (DEVID_FUNC(devid_valid)((ddi_devid_t)id) != DEVID_RET_VALID)
 451                         goto efree;
 452         }
 453
 454         /* duplicate minor_name if we are asked to decode it */
 455         if (minor_namep && msp) {
 456                 if ((*minor_namep = DEVID_MALLOC(strlen(msp) + 1)) == NULL)
 457                         goto efree;
 458                 (void) strcpy(*minor_namep, msp);
 459         }
 460
 461         /* return pointer to binary */
 462         if (devidp)
 463                 *devidp = (ddi_devid_t)id;
 464         return (DEVID_SUCCESS);
 465
 466 efree:
 467         if ((pre_alloc == FALSE) && (id))
 468                 DEVID_FREE(id, devid_len);
 469         return (DEVID_FAILURE);
 470 }
 471
 472
 473 /*
 474  * Compare two device id's in string form
 475  *      -1 - id1 less than id2
 476  *      0  - equal
 477  *      1  - id1 greater than id2
 478  */
 479 int
 480 #ifdef  _KERNEL
 481 ddi_devid_str_compare(char *id1_str, char *id2_str)
 482 #else   /* !_KERNEL */
 483 devid_str_compare(char *id1_str, char *id2_str)
 484 #endif  /* _KERNEL */
 485 {
 486         int             rval    = DEVID_FAILURE;
 487         ddi_devid_t     devid1;
 488         ddi_devid_t     devid2;
 489 #ifdef  _KERNEL
 490         /* kernel use static protected by lock. */
 491         static kmutex_t id_lock;
 492         static uchar_t  id1[sizeof (impl_devid_t) + MAXPATHLEN];
 493         static uchar_t  id2[sizeof (impl_devid_t) + MAXPATHLEN];
 494 #else   /* !_KERNEL */
 495         /* userland place on stack, since malloc might fail */
 496         uchar_t         id1[sizeof (impl_devid_t) + MAXPATHLEN];
 497         uchar_t         id2[sizeof (impl_devid_t) + MAXPATHLEN];
 498 #endif  /* _KERNEL */
 499
 500 #ifdef  _KERNEL
 501         mutex_enter(&id_lock);
 502 #endif  /* _KERNEL */
 503
 504         /*
 505          * encode string form of devid
 506          */
 507         if ((devid_str_decode_id(id1_str, &devid1, NULL, (impl_devid_t *)id1) ==
 508             DEVID_SUCCESS) &&
 509             (devid_str_decode_id(id2_str, &devid2, NULL, (impl_devid_t *)id2) ==
 510             DEVID_SUCCESS)) {
 511                 rval = DEVID_FUNC(devid_compare)(devid1, devid2);
 512         }
 513
 514 #ifdef  _KERNEL
 515         mutex_exit(&id_lock);
 516 #endif  /* _KERNEL */
 517
 518         return (rval);
 519 }