Return to names-hash.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pciutils / lib

Annotation of embedaddon/pciutils/lib/names-hash.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     The PCI Library -- ID to Name Hash
        !             3:  *
        !             4:  *     Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
        !             5:  *
        !             6:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             7:  */
        !             8: 
        !             9: #include <string.h>
        !            10: 
        !            11: #include "internal.h"
        !            12: #include "names.h"
        !            13: 
        !            14: struct id_bucket {
        !            15:   struct id_bucket *next;
        !            16:   unsigned int full;
        !            17: };
        !            18: 
        !            19: #ifdef __GNUC__
        !            20: #define BUCKET_ALIGNMENT __alignof__(struct id_bucket)
        !            21: #else
        !            22: union id_align {
        !            23:   struct id_bucket *next;
        !            24:   unsigned int full;
        !            25: };
        !            26: #define BUCKET_ALIGNMENT sizeof(union id_align)
        !            27: #endif
        !            28: #define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)
        !            29: 
        !            30: static void *id_alloc(struct pci_access *a, unsigned int size)
        !            31: {
        !            32:   struct id_bucket *buck = a->current_id_bucket;
        !            33:   unsigned int pos;
        !            34: 
        !            35:   if (!a->id_hash)
        !            36:     {
        !            37:       a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
        !            38:       memset(a->id_hash, 0, sizeof(struct id_entry *) * HASH_SIZE);
        !            39:     }
        !            40: 
        !            41:   if (!buck || buck->full + size > BUCKET_SIZE)
        !            42:     {
        !            43:       buck = pci_malloc(a, BUCKET_SIZE);
        !            44:       buck->next = a->current_id_bucket;
        !            45:       a->current_id_bucket = buck;
        !            46:       buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
        !            47:     }
        !            48:   pos = buck->full;
        !            49:   buck->full = BUCKET_ALIGN(buck->full + size);
        !            50:   return (byte *)buck + pos;
        !            51: }
        !            52: 
        !            53: static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
        !            54: {
        !            55:   unsigned int h;
        !            56: 
        !            57:   h = id12 ^ (id34 << 3) ^ (cat << 5);
        !            58:   return h % HASH_SIZE;
        !            59: }
        !            60: 
        !            61: int
        !            62: pci_id_insert(struct pci_access *a, int cat, int id1, int id2, int id3, int id4, char *text, enum id_entry_src src)
        !            63: {
        !            64:   u32 id12 = id_pair(id1, id2);
        !            65:   u32 id34 = id_pair(id3, id4);
        !            66:   unsigned int h = id_hash(cat, id12, id34);
        !            67:   struct id_entry *n = a->id_hash ? a->id_hash[h] : NULL;
        !            68:   int len = strlen(text);
        !            69: 
        !            70:   while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
        !            71:     n = n->next;
        !            72:   if (n)
        !            73:     return 1;
        !            74:   n = id_alloc(a, sizeof(struct id_entry) + len);
        !            75:   n->id12 = id12;
        !            76:   n->id34 = id34;
        !            77:   n->cat = cat;
        !            78:   n->src = src;
        !            79:   memcpy(n->name, text, len+1);
        !            80:   n->next = a->id_hash[h];
        !            81:   a->id_hash[h] = n;
        !            82:   return 0;
        !            83: }
        !            84: 
        !            85: char
        !            86: *pci_id_lookup(struct pci_access *a, int flags, int cat, int id1, int id2, int id3, int id4)
        !            87: {
        !            88:   struct id_entry *n, *best;
        !            89:   u32 id12 = id_pair(id1, id2);
        !            90:   u32 id34 = id_pair(id3, id4);
        !            91: 
        !            92:   if (a->id_hash)
        !            93:     {
        !            94:       n = a->id_hash[id_hash(cat, id12, id34)];
        !            95:       best = NULL;
        !            96:       for (; n; n=n->next)
        !            97:         {
        !            98:          if (n->id12 != id12 || n->id34 != id34 || n->cat != cat)
        !            99:            continue;
        !           100:          if (n->src == SRC_LOCAL && (flags & PCI_LOOKUP_SKIP_LOCAL))
        !           101:            continue;
        !           102:          if (n->src == SRC_NET && !(flags & PCI_LOOKUP_NETWORK))
        !           103:            continue;
        !           104:          if (n->src == SRC_CACHE && !(flags & PCI_LOOKUP_CACHE))
        !           105:            continue;
        !           106:          if (!best || best->src < n->src)
        !           107:            best = n;
        !           108:        }
        !           109:       if (best)
        !           110:        return best->name;
        !           111:     }
        !           112:   return NULL;
        !           113: }
        !           114: 
        !           115: void
        !           116: pci_id_hash_free(struct pci_access *a)
        !           117: {
        !           118:   pci_mfree(a->id_hash);
        !           119:   a->id_hash = NULL;
        !           120:   while (a->current_id_bucket)
        !           121:     {
        !           122:       struct id_bucket *buck = a->current_id_bucket;
        !           123:       a->current_id_bucket = buck->next;
        !           124:       pci_mfree(buck);
        !           125:     }
        !           126: }