Logo Search packages:      
Sourcecode: pciutils version File versions  Download package

names.c

/*
 *    The PCI Library -- ID to Name Translation
 *
 *    Copyright (c) 1997--2006 Martin Mares <mj@ucw.cz>
 *
 *    Can be freely distributed and used under the terms of the GNU GPL.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>

#include "internal.h"

struct id_entry {
  struct id_entry *next;
  u32 id12, id34;
  byte cat; /* Actually an enum id_entry_type */
  char name[1];
};

enum id_entry_type {
  ID_UNKNOWN,
  ID_VENDOR,
  ID_DEVICE,
  ID_SUBSYSTEM,
  ID_GEN_SUBSYSTEM,
  ID_CLASS,
  ID_SUBCLASS,
  ID_PROGIF
};

struct id_bucket {
  struct id_bucket *next;
  unsigned int full;
};

#define MAX_LINE 1024
#define BUCKET_SIZE 8192
#define HASH_SIZE 4099

#ifdef __GNUC__
#define BUCKET_ALIGNMENT __alignof__(struct id_bucket)
#else
union id_align {
  struct id_bucket *next;
  unsigned int full;
};
#define BUCKET_ALIGNMENT sizeof(union id_align)
#endif
#define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)

static void *id_alloc(struct pci_access *a, unsigned int size)
{
  struct id_bucket *buck = a->current_id_bucket;
  unsigned int pos;
  if (!buck || buck->full + size > BUCKET_SIZE)
    {
      buck = pci_malloc(a, BUCKET_SIZE);
      buck->next = a->current_id_bucket;
      a->current_id_bucket = buck;
      buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
    }
  pos = buck->full;
  buck->full = BUCKET_ALIGN(buck->full + size);
  return (byte *)buck + pos;
}

static inline u32 id_pair(unsigned int x, unsigned int y)
{
  return ((x << 16) | y);
}

static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
{
  unsigned int h;

  h = id12 ^ (id34 << 3) ^ (cat << 5);
  return h % HASH_SIZE;
}

static byte *id_lookup(struct pci_access *a, enum id_entry_type cat, int id1, int id2, int id3, int id4)
{
  struct id_entry *n;
  u32 id12 = id_pair(id1, id2);
  u32 id34 = id_pair(id3, id4);

  if (!a->id_hash)
    return NULL;
  n = a->id_hash[id_hash(cat, id12, id34)];
  while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
    n = n->next;
  return n ? n->name : NULL;
}

static int id_insert(struct pci_access *a, enum id_entry_type cat, int id1, int id2, int id3, int id4, char *text)
{
  u32 id12 = id_pair(id1, id2);
  u32 id34 = id_pair(id3, id4);
  unsigned int h = id_hash(cat, id12, id34);
  struct id_entry *n = a->id_hash[h];
  int len = strlen(text);

  while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
    n = n->next;
  if (n)
    return 1;
  n = id_alloc(a, sizeof(struct id_entry) + len);
  n->id12 = id12;
  n->id34 = id34;
  n->cat = cat;
  memcpy(n->name, text, len+1);
  n->next = a->id_hash[h];
  a->id_hash[h] = n;
  return 0;
}

static int id_hex(char *p, int cnt)
{
  int x = 0;
  while (cnt--)
    {
      x <<= 4;
      if (*p >= '0' && *p <= '9')
      x += (*p - '0');
      else if (*p >= 'a' && *p <= 'f')
      x += (*p - 'a' + 10);
      else if (*p >= 'A' && *p <= 'F')
      x += (*p - 'A' + 10);
      else
      return -1;
      p++;
    }
  return x;
}

static inline int id_white_p(int c)
{
  return (c == ' ') || (c == '\t');
}

static const char *id_parse_list(struct pci_access *a, FILE *f, int *lino)
{
  char line[MAX_LINE];
  char *p;
  int id1=0, id2=0, id3=0, id4=0;
  int cat = -1;
  int nest;
  static const char parse_error[] = "Parse error";

  *lino = 0;
  while (fgets(line, sizeof(line), f))
    {
      (*lino)++;
      p = line;
      while (*p && *p != '\n' && *p != '\r')
      p++;
      if (!*p && !feof(f))
      return "Line too long";
      *p = 0;
      if (p > line && (p[-1] == ' ' || p[-1] == '\t'))
      *--p = 0;

      p = line;
      while (id_white_p(*p))
      p++;
      if (!*p || *p == '#')
      continue;

      p = line;
      while (*p == '\t')
      p++;
      nest = p - line;

      if (!nest)                          /* Top-level entries */
      {
        if (p[0] == 'C' && p[1] == ' ')         /* Class block */
          {
            if ((id1 = id_hex(p+2, 2)) < 0 || !id_white_p(p[4]))
            return parse_error;
            cat = ID_CLASS;
            p += 5;
          }
        else if (p[0] == 'S' && p[1] == ' ')
          {                               /* Generic subsystem block */
            if ((id1 = id_hex(p+2, 4)) < 0 || p[6])
            return parse_error;
            if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))
            return "Vendor does not exist";
            cat = ID_GEN_SUBSYSTEM;
            continue;
          }
        else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ')
          {                               /* Unrecognized block (RFU) */
            cat = ID_UNKNOWN;
            continue;
          }
        else                                    /* Vendor ID */
          {
            if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
            return parse_error;
            cat = ID_VENDOR;
            p += 5;
          }
        id2 = id3 = id4 = 0;
      }
      else if (cat == ID_UNKNOWN)               /* Nested entries in RFU blocks are skipped */
      continue;
      else if (nest == 1)                       /* Nesting level 1 */
      switch (cat)
        {
        case ID_VENDOR:
        case ID_DEVICE:
        case ID_SUBSYSTEM:
          if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
            return parse_error;
          p += 5;
          cat = ID_DEVICE;
          id3 = id4 = 0;
          break;
        case ID_GEN_SUBSYSTEM:
          if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
            return parse_error;
          p += 5;
          id3 = id4 = 0;
          break;
        case ID_CLASS:
        case ID_SUBCLASS:
        case ID_PROGIF:
          if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
            return parse_error;
          p += 3;
          cat = ID_SUBCLASS;
          id3 = id4 = 0;
          break;
        default:
          return parse_error;
        }
      else if (nest == 2)                       /* Nesting level 2 */
      switch (cat)
        {
        case ID_DEVICE:
        case ID_SUBSYSTEM:
          if ((id3 = id_hex(p, 4)) < 0 || !id_white_p(p[4]) || (id4 = id_hex(p+5, 4)) < 0 || !id_white_p(p[9]))
            return parse_error;
          p += 10;
          cat = ID_SUBSYSTEM;
          break;
        case ID_CLASS:
        case ID_SUBCLASS:
        case ID_PROGIF:
          if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
            return parse_error;
          p += 3;
          cat = ID_PROGIF;
          id4 = 0;
          break;
        default:
          return parse_error;
        }
      else                                /* Nesting level 3 or more */
      return parse_error;
      while (id_white_p(*p))
      p++;
      if (!*p)
      return parse_error;
      if (id_insert(a, cat, id1, id2, id3, id4, p))
      return "Duplicate entry";
    }
  return NULL;
}

int
pci_load_name_list(struct pci_access *a)
{
  FILE *f;
  int lino;
  const char *err;

  pci_free_name_list(a);
  a->hash_load_failed = 1;
  if (!(f = fopen(a->id_file_name, "r")))
    return 0;
  a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
  bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE);
  err = id_parse_list(a, f, &lino);
  if (!err && ferror(f))
    err = "I/O error";
  fclose(f);
  if (err)
    a->error("%s at %s, line %d\n", err, a->id_file_name, lino);
  a->hash_load_failed = 0;
  return 1;
}

void
pci_free_name_list(struct pci_access *a)
{
  pci_mfree(a->id_hash);
  a->id_hash = NULL;
  while (a->current_id_bucket)
    {
      struct id_bucket *buck = a->current_id_bucket;
      a->current_id_bucket = buck->next;
      pci_mfree(buck);
    }
}

static byte *
id_lookup_subsys(struct pci_access *a, int iv, int id, int isv, int isd)
{
  byte *d = NULL;
  if (iv > 0 && id > 0)                               /* Per-device lookup */
    d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);
  if (!d)                                       /* Generic lookup */
    d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
  if (!d && iv == isv && id == isd)                   /* Check for subsystem == device */
    d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
  return d;
}

static byte *
format_name(char *buf, int size, int flags, byte *name, byte *num, byte *unknown)
{
  int res;
  if ((flags & PCI_LOOKUP_NO_NUMBERS) && !name)
    return NULL;
  else if (flags & PCI_LOOKUP_NUMERIC)
    res = snprintf(buf, size, "%s", num);
  else if (!name)
    res = snprintf(buf, size, ((flags & PCI_LOOKUP_MIXED) ? "%s [%s]" : "%s %s"), unknown, num);
  else if (!(flags & PCI_LOOKUP_MIXED))
    res = snprintf(buf, size, "%s", name);
  else
    res = snprintf(buf, size, "%s [%s]", name, num);
  if (res < 0 || res >= size)
    return "<pci_lookup_name: buffer too small>";
  else
    return buf;
}

static byte *
format_name_pair(char *buf, int size, int flags, byte *v, byte *d, byte *num)
{
  int res;
  if ((flags & PCI_LOOKUP_NO_NUMBERS) && (!v || !d))
    return NULL;
  if (flags & PCI_LOOKUP_NUMERIC)
    res = snprintf(buf, size, "%s", num);
  else if (flags & PCI_LOOKUP_MIXED)
    {
      if (v && d)
      res = snprintf(buf, size, "%s %s [%s]", v, d, num);
      else if (!v)
      res = snprintf(buf, size, "Unknown device [%s]", num);
      else /* v && !d */
      res = snprintf(buf, size, "%s Unknown device [%s]", v, num);
    }
  else
    {
      if (v && d)
      res = snprintf(buf, size, "%s %s", v, d);
      else if (!v)
      res = snprintf(buf, size, "Unknown device %s", num);
      else /* v && !d */
      res = snprintf(buf, size, "%s Unknown device %s", v, num+5);
    }
  if (res < 0 || res >= size)
    return "<pci_lookup_name: buffer too small>";
  else
    return buf;
}

char *
pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, ...)
{
  va_list args;
  byte *v, *d, *cls, *pif;
  int iv, id, isv, isd, icls, ipif;
  byte numbuf[16], pifbuf[32];

  va_start(args, flags);

  if (!(flags & PCI_LOOKUP_NO_NUMBERS))
    {
      if (a->numeric_ids > 1)
      flags |= PCI_LOOKUP_MIXED;
      else if (a->numeric_ids)
      flags |= PCI_LOOKUP_NUMERIC;
    }
  if (flags & PCI_LOOKUP_MIXED)
    flags &= ~PCI_LOOKUP_NUMERIC;

  if (!a->id_hash && !(flags & PCI_LOOKUP_NUMERIC) && !a->hash_load_failed)
    pci_load_name_list(a);

  switch (flags & 0xffff)
    {
    case PCI_LOOKUP_VENDOR:
      iv = va_arg(args, int);
      sprintf(numbuf, "%04x", iv);
      return format_name(buf, size, flags, id_lookup(a, ID_VENDOR, iv, 0, 0, 0), numbuf, "Unknown vendor");
    case PCI_LOOKUP_DEVICE:
      iv = va_arg(args, int);
      id = va_arg(args, int);
      sprintf(numbuf, "%04x", id);
      return format_name(buf, size, flags, id_lookup(a, ID_DEVICE, iv, id, 0, 0), numbuf, "Unknown device");
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
      iv = va_arg(args, int);
      id = va_arg(args, int);
      sprintf(numbuf, "%04x:%04x", iv, id);
      v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);
      d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
      return format_name_pair(buf, size, flags, v, d, numbuf);
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
      isv = va_arg(args, int);
      sprintf(numbuf, "%04x", isv);
      v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
      return format_name(buf, size, flags, v, numbuf, "Unknown vendor");
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE:
      iv = va_arg(args, int);
      id = va_arg(args, int);
      isv = va_arg(args, int);
      isd = va_arg(args, int);
      sprintf(numbuf, "%04x", isd);
      return format_name(buf, size, flags, id_lookup_subsys(a, iv, id, isv, isd), numbuf, "Unknown device");
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
      iv = va_arg(args, int);
      id = va_arg(args, int);
      isv = va_arg(args, int);
      isd = va_arg(args, int);
      v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
      d = id_lookup_subsys(a, iv, id, isv, isd);
      sprintf(numbuf, "%04x:%04x", isv, isd);
      return format_name_pair(buf, size, flags, v, d, numbuf);
    case PCI_LOOKUP_CLASS:
      icls = va_arg(args, int);
      sprintf(numbuf, "%04x", icls);
      cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0);
      if (!cls && (cls = id_lookup(a, ID_CLASS, icls >> 8, 0, 0, 0)))
      {
        if (!(flags & PCI_LOOKUP_NUMERIC)) /* Include full class number */
          flags |= PCI_LOOKUP_MIXED;
      }
      return format_name(buf, size, flags, cls, numbuf, ((flags & PCI_LOOKUP_MIXED) ? "Unknown class" : "Class"));
    case PCI_LOOKUP_PROGIF:
      icls = va_arg(args, int);
      ipif = va_arg(args, int);
      sprintf(numbuf, "%02x", ipif);
      pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0);
      if (!pif && icls == 0x0101 && !(ipif & 0x70))
      {
        /* IDE controllers have complex prog-if semantics */
        sprintf(pifbuf, "%s%s%s%s%s",
              (ipif & 0x80) ? " Master" : "",
              (ipif & 0x08) ? " SecP" : "",
              (ipif & 0x04) ? " SecO" : "",
              (ipif & 0x02) ? " PriP" : "",
              (ipif & 0x01) ? " PriO" : "");
        pif = pifbuf;
        if (*pif)
          pif++;
      }
      return format_name(buf, size, flags, pif, numbuf, "ProgIf");
    default:
      return "<pci_lookup_name: invalid request>";
    }
}

Generated by  Doxygen 1.6.0   Back to index