SystemTap: SystemTap Runtime Library

00001 /* -*- linux-c -*- */
-00002 
-00003 static int map_sizes[] = {
-00004         sizeof(struct map_node_int64),
-00005         sizeof(struct map_node_stat),
-00006         sizeof(struct map_node_str),
-00007         0
-00008 };
-00009 
-00010 static inline unsigned string_hash(const char *key1, const char *key2)
-00011 {
-00012         int hash = 0, count = 0;
-00013         char *v1 = (char *)key1;
-00014         char *v2 = (char *)key2;
-00015         while (*v1 && count++ < 5) {
-00016                 hash += *v1++;
-00017         }
-00018         while (v2 && *v2 && count++ < 5) {
-00019                 hash += *v2++;
-00020         }
-00021         return hash_long((unsigned long)hash, HASH_TABLE_BITS);
-00022 }
-00023 
-00024 static inline unsigned mixed_hash(const char *key1, long key2)
-00025 {
-00026         int hash = 0, count = 0;
-00027         char *v = (char *)key1;
-00028         while (v && *v && count++ < 5)
-00029                 hash += *v++;
-00030         return hash_long((unsigned long)(hash ^ key2), HASH_TABLE_BITS);
-00031 }
-00032 
-00043 MAP _stp_map_new(unsigned max_entries, enum valtype type)
-00044 {
-00045         size_t size;
-00046         MAP m = (MAP) _stp_valloc(sizeof(struct map_root));
-00047         if (m == NULL)
-00048                 return NULL;
-00049 
-00050         INIT_LIST_HEAD(&m->head);
-00051 
-00052         m->maxnum = max_entries;
-00053         m->type = type;
-00054         if (type >= END) {
-00055                 dbug ("map_new: unknown type %d\n", type);
-00056                 return NULL;
-00057         }
-00058 
-00059         if (max_entries) {
-00060                 void *tmp;
-00061                 int i;
-00062                 struct list_head *e;
-00063 
-00064                 INIT_LIST_HEAD(&m->pool);
-00065                 size = map_sizes[type];
-00066                 tmp = _stp_valloc(max_entries * size);
+Main Page | Data Structures | Directories | File List | Data Fields | Globals | Related Pages
+map.c
Go to the documentation of this file.00001 /* -*- linux-c -*- */
+00002 /** @file map.c
+00003  * @brief Implements maps (associative arrays) and lists
+00004  */
+00005 
+00006 
+00007 static int map_sizes[] = {
+00008         sizeof(struct map_node_int64),
+00009         sizeof(struct map_node_stat),
+00010         sizeof(struct map_node_str),
+00011         0
+00012 };
+00013 
+00014 static unsigned string_hash(const char *key1, const char *key2)
+00015 {
+00016         int hash = 0, count = 0;
+00017         char *v1 = (char *)key1;
+00018         char *v2 = (char *)key2;
+00019         while (*v1 && count++ < 5) {
+00020                 hash += *v1++;
+00021         }
+00022         while (v2 && *v2 && count++ < 5) {
+00023                 hash += *v2++;
+00024         }
+00025         return hash_long((unsigned long)hash, HASH_TABLE_BITS);
+00026 }
+00027 
+00028 static unsigned mixed_hash(const char *key1, long key2)
+00029 {
+00030         int hash = 0, count = 0;
+00031         char *v = (char *)key1;
+00032         while (v && *v && count++ < 5)
+00033                 hash += *v++;
+00034         return hash_long((unsigned long)(hash ^ key2), HASH_TABLE_BITS);
+00035 }
+00036 
+00037 /** Create a new map.
+00038  * Maps must be created at module initialization time.
+00039  * @param max_entries The maximum number of entries allowed. Currently that number will
+00040  * be preallocated.  If more entries are required, the oldest ones will be deleted. This makes
+00041  * it effectively a circular buffer.  If max_entries is 0, there will be no maximum and entries
+00042  * will be allocated dynamically.
+00043  * @param type Type of values stored in this map. 
+00044  * @return A MAP on success or NULL on failure.
+00045  */
+00046 
+00047 MAP _stp_map_new(unsigned max_entries, enum valtype type)
+00048 {
+00049         size_t size;
+00050         MAP m = (MAP) _stp_valloc(sizeof(struct map_root));
+00051         if (m == NULL)
+00052                 return NULL;
+00053 
+00054         INIT_LIST_HEAD(&m->head);
+00055 
+00056         m->maxnum = max_entries;
+00057         m->type = type;
+00058         if (type >= END) {
+00059                 dbug ("map_new: unknown type %d\n", type);
+00060                 return NULL;
+00061         }
+00062 
+00063         if (max_entries) {
+00064                 void *tmp;
+00065                 int i;
+00066                 struct list_head *e;
 00067 
-00068                 for (i = max_entries - 1; i >= 0; i--) {
-00069                         e = i * size + tmp;
-00070                         dbug ("e=%lx\n", (long)e);
-00071                         list_add(e, &m->pool);
-00072                 }
-00073                 m->membuf = tmp;
-00074         }
-00075         return m;
-00076 }
-00077 
-00078 static void map_free_strings(MAP map, struct map_node *n)
-00079 {
-00080         struct map_node_str *m = (struct map_node_str *)n;
-00081         dbug ("n = %lx\n", (long)n);
-00082         if (map->type == STRING) {
-00083                 dbug ("val STRING %lx\n", (long)m->str);
-00084                 if (m->str)
-00085                         _stp_free(m->str);
-00086         }
-00087         if (m->n.key1type == STR) {
-00088                 dbug ("key1 STR %lx\n", (long)key1str(m));
-00089                 if (key1str(m))
-00090                         _stp_free(key1str(m));
-00091         }
-00092         if (m->n.key2type == STR) {
-00093                 dbug ("key2 STR %lx\n", (long)key2str(m));
-00094                 if (key2str(m))
-00095                         _stp_free(key2str(m));
-00096         }
-00097 }
-00098 
-00104 void _stp_map_key_del(MAP map)
-00105 {
-00106         struct map_node *m;
+00068                 INIT_LIST_HEAD(&m->pool);
+00069                 size = map_sizes[type];
+00070                 tmp = _stp_valloc(max_entries * size);
+00071 
+00072                 for (i = max_entries - 1; i >= 0; i--) {
+00073                         e = i * size + tmp;
+00074                         dbug ("e=%lx\n", (long)e);
+00075                         list_add(e, &m->pool);
+00076                 }
+00077                 m->membuf = tmp;
+00078         }
+00079         return m;
+00080 }
+00081 
+00082 static void map_free_strings(MAP map, struct map_node *n)
+00083 {
+00084         struct map_node_str *m = (struct map_node_str *)n;
+00085         dbug ("n = %lx\n", (long)n);
+00086         if (map->type == STRING) {
+00087                 dbug ("val STRING %lx\n", (long)m->str);
+00088                 if (m->str)
+00089                         _stp_free(m->str);
+00090         }
+00091         if (m->n.key1type == STR) {
+00092                 dbug ("key1 STR %lx\n", (long)key1str(m));
+00093                 if (key1str(m))
+00094                         _stp_free(key1str(m));
+00095         }
+00096         if (m->n.key2type == STR) {
+00097                 dbug ("key2 STR %lx\n", (long)key2str(m));
+00098                 if (key2str(m))
+00099                         _stp_free(key2str(m));
+00100         }
+00101 }
+00102 
+00103 /** Deletes the current element.
+00104  * If no current element (key) for this map is set, this function does nothing.
+00105  * @param map 
+00106  */
 00107 
-00108         dbug ("create=%d key=%lx\n", map->create, (long)map->key);
-00109         if (map == NULL)
-00110                 return;
+00108 void _stp_map_key_del(MAP map)
+00109 {
+00110         struct map_node *m;
 00111 
-00112         if (map->create) {
-00113                 map->create = 0;
-00114                 map->key = NULL;
-00115                 return;
-00116         }
-00117 
-00118         if (map->key == NULL)
+00112         dbug ("create=%d key=%lx\n", map->create, (long)map->key);
+00113         if (map == NULL)
+00114                 return;
+00115 
+00116         if (map->create) {
+00117                 map->create = 0;
+00118                 map->key = NULL;
 00119                 return;
-00120 
-00121         m = (struct map_node *)map->key;
-00122 
-00123         /* remove node from old hash list */
-00124         hlist_del_init(&m->hnode);
-00125 
-00126         /* remove from entry list */
-00127         list_del(&m->lnode);
-00128 
-00129         /* remove any allocated string storage */
-00130         map_free_strings(map, (struct map_node *)map->key);
-00131 
-00132         if (map->maxnum)
-00133                 list_add(&m->lnode, &map->pool);
-00134         else
-00135                 _stp_free(m);
-00136 
-00137         map->key = NULL;
-00138         map->num--;
-00139 }
+00120         }
+00121 
+00122         if (map->key == NULL)
+00123                 return;
+00124 
+00125         m = (struct map_node *)map->key;
+00126 
+00127         /* remove node from old hash list */
+00128         hlist_del_init(&m->hnode);
+00129 
+00130         /* remove from entry list */
+00131         list_del(&m->lnode);
+00132 
+00133         /* remove any allocated string storage */
+00134         map_free_strings(map, (struct map_node *)map->key);
+00135 
+00136         if (map->maxnum)
+00137                 list_add(&m->lnode, &map->pool);
+00138         else
+00139                 _stp_free(m);
 00140 
-00149 struct map_node *_stp_map_start(MAP map)
-00150 {
-00151         if (map == NULL)
-00152                 return NULL;
-00153 
-00154         dbug ("%lx\n", (long)map->head.next);
-00155 
-00156         if (list_empty(&map->head))
-00157                 return NULL;
-00158 
-00159         return (struct map_node *)map->head.next;
-00160 }
-00161 
-00172 struct map_node *_stp_map_iter(MAP map, struct map_node *m)
-00173 {
-00174         if (map == NULL)
-00175                 return NULL;
-00176 
-00177         dbug ("%lx next=%lx  prev=%lx  map->head.next=%lx\n", (long)m, (long)m->lnode.next, (long)m->lnode.prev, (long)map->head.next);
-00178 
-00179         if (m->lnode.next == &map->head)
-00180                 return NULL;
-00181 
-00182         return (struct map_node *)m->lnode.next;
-00183 }
-00184 
-00190 void _stp_map_del(MAP map)
-00191 {
-00192         if (map == NULL)
-00193                 return;
+00141         map->key = NULL;
+00142         map->num--;
+00143 }
+00144 
+00145 /** Get the first element in a map.
+00146  * @param map 
+00147  * @returns a pointer to the first element.
+00148  * This is typically used with _stp_map_iter().  See the foreach() macro
+00149  * for typical usage.  It probably does what you want anyway.
+00150  * @sa foreach
+00151  */
+00152 
+00153 struct map_node *_stp_map_start(MAP map)
+00154 {
+00155         if (map == NULL)
+00156                 return NULL;
+00157 
+00158         dbug ("%lx\n", (long)map->head.next);
+00159 
+00160         if (list_empty(&map->head))
+00161                 return NULL;
+00162 
+00163         return (struct map_node *)map->head.next;
+00164 }
+00165 
+00166 /** Get the next element in a map.
+00167  * @param map 
+00168  * @param m a pointer to the current element, returned from _stp_map_start()
+00169  * or _stp_map_iter().
+00170  * @returns a pointer to the next element.
+00171  * This is typically used with _stp_map_start().  See the foreach() macro
+00172  * for typical usage.  It probably does what you want anyway.
+00173  * @sa foreach
+00174  */
+00175 
+00176 struct map_node *_stp_map_iter(MAP map, struct map_node *m)
+00177 {
+00178         if (map == NULL)
+00179                 return NULL;
+00180 
+00181         dbug ("%lx next=%lx  prev=%lx  map->head.next=%lx\n", (long)m, 
+00182               (long)m->lnode.next, (long)m->lnode.prev, (long)map->head.next);
+00183 
+00184         if (m->lnode.next == &map->head)
+00185                 return NULL;
+00186 
+00187         return (struct map_node *)m->lnode.next;
+00188 }
+00189 
+00190 /** Deletes a map.
+00191  * Deletes a map, freeing all memory in all elements.  Normally done only when the module exits.
+00192  * @param map
+00193  */
 00194 
-00195         if (!list_empty(&map->head)) {
-00196                 struct map_node *ptr = (struct map_node *)map->head.next;
-00197                 while (ptr && ptr != (struct map_node *)&map->head) {
-00198                         map_free_strings(map, ptr);
-00199                         ptr = (struct map_node *)ptr->lnode.next;
-00200                 }
-00201         }
-00202         _stp_vfree(map->membuf);
-00203         _stp_vfree(map);
-00204 }
-00205 
-00206 /**********************  KEY FUNCTIONS *********************/
-00207 
-00208 
-00218 void _stp_map_key_long_long(MAP map, long key1, long key2)
-00219 {
-00220         unsigned hv;
-00221         struct hlist_head *head;
-00222         struct hlist_node *e;
-00223 
-00224         if (map == NULL)
-00225                 return;
-00226 
-00227         hv = hash_long(key1 ^ key2, HASH_TABLE_BITS);
-00228         head = &map->hashes[hv];
-00229 
-00230         dbug ("hash for %ld,%ld is %d\n", key1, key2, hv);
+00195 void _stp_map_del(MAP map)
+00196 {
+00197         if (map == NULL)
+00198                 return;
+00199 
+00200         if (!list_empty(&map->head)) {
+00201                 struct map_node *ptr = (struct map_node *)map->head.next;
+00202                 while (ptr && ptr != (struct map_node *)&map->head) {
+00203                         map_free_strings(map, ptr);
+00204                         ptr = (struct map_node *)ptr->lnode.next;
+00205                 }
+00206         }
+00207         _stp_vfree(map->membuf);
+00208         _stp_vfree(map);
+00209 }
+00210 
+00211 /**********************  KEY FUNCTIONS *********************/
+00212 
+00213 
+00214 /** Set the map's key to two longs.
+00215  * This sets the current element based on a key of two strings. If the keys are
+00216  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00217  * call.
+00218  * @param map
+00219  * @param key1 first key
+00220  * @param key2 second key
+00221  */
+00222 
+00223 void _stp_map_key_long_long(MAP map, long key1, long key2)
+00224 {
+00225         unsigned hv;
+00226         struct hlist_head *head;
+00227         struct hlist_node *e;
+00228 
+00229         if (map == NULL)
+00230                 return;
 00231 
-00232         hlist_for_each(e, head) {
-00233                 struct map_node *n =
-00234                         (struct map_node *)((long)e - sizeof(struct hlist_node));
-00235                 dbug ("n =%lx  key=%ld,%ld\n", (long)n, n->key1.val, n->key2.val);
-00236                 if (key1 == n->key1.val && key2 == n->key2.val) {
-00237                         map->key = n;
-00238                         dbug ("saving key %lx\n", (long)map->key);
-00239                         map->create = 0;
-00240                         return;
-00241                 }
-00242         }
-00243 
-00244         map->c_key1.val = key1;
-00245         map->c_key2.val = key2;
-00246         map->c_key1type = LONG;
-00247         map->c_key2type = LONG;
-00248         map->c_keyhead = head;
-00249         map->create = 1;
-00250 }
-00251 
-00261 void _stp_map_key_str_str(MAP map, char *key1, char *key2)
-00262 {
-00263         unsigned hv;
-00264         struct hlist_head *head;
-00265         struct hlist_node *e;
-00266 
-00267         if (map == NULL)
-00268                 return;
-00269 
-00270         if (key1 == NULL) {
-00271                 map->key = NULL;
-00272                 return;
-00273         }
+00232         hv = hash_long(key1 ^ key2, HASH_TABLE_BITS);
+00233         head = &map->hashes[hv];
+00234 
+00235         dbug ("hash for %ld,%ld is %d\n", key1, key2, hv);
+00236 
+00237         hlist_for_each(e, head) {
+00238                 struct map_node *n =
+00239                         (struct map_node *)((long)e - sizeof(struct hlist_node));
+00240                 dbug ("n =%lx  key=%ld,%ld\n", (long)n, n->key1.val, n->key2.val);
+00241                 if (key1 == n->key1.val && key2 == n->key2.val) {
+00242                         map->key = n;
+00243                         dbug ("saving key %lx\n", (long)map->key);
+00244                         map->create = 0;
+00245                         return;
+00246                 }
+00247         }
+00248 
+00249         map->c_key1.val = key1;
+00250         map->c_key2.val = key2;
+00251         map->c_key1type = LONG;
+00252         map->c_key2type = LONG;
+00253         map->c_keyhead = head;
+00254         map->create = 1;
+00255 }
+00256 
+00257 /** Set the map's key to two strings.
+00258  * This sets the current element based on a key of two strings. If the keys are
+00259  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00260  * call.
+00261  * @param map
+00262  * @param key1 first key
+00263  * @param key2 second key
+00264  */
+00265 
+00266 void _stp_map_key_str_str(MAP map, char *key1, char *key2)
+00267 {
+00268         unsigned hv;
+00269         struct hlist_head *head;
+00270         struct hlist_node *e;
+00271 
+00272         if (map == NULL)
+00273                 return;
 00274 
-00275         hv = string_hash(key1, key2);
-00276         head = &map->hashes[hv];
-00277 
-00278         dbug ("hash for %s,%s is %d\n", key1, key2, hv);
+00275         if (key1 == NULL) {
+00276                 map->key = NULL;
+00277                 return;
+00278         }
 00279 
-00280         hlist_for_each(e, head) {
-00281                 struct map_node *n =
-00282                         (struct map_node *)((long)e - sizeof(struct hlist_node));
-00283                 dbug ("e =%lx  key=%s,%s\n", (long)e, n->key1.str,n->key2.str);
-00284                 if (strcmp(key1, n->key1.str) == 0
-00285                     && (key2 == NULL || strcmp(key2, n->key2.str) == 0)) {
-00286                         map->key = n;
-00287                         dbug ("saving key %lx\n", (long)map->key);
-00288                         map->create = 0;
-00289                         return;
-00290                 }
-00291         }
-00292 
-00293         map->c_key1.str = key1;
-00294         map->c_key2.str = key2;
-00295         map->c_key1type = STR;
-00296         map->c_key2type = STR;
-00297         map->c_keyhead = head;
-00298         map->create = 1;
-00299 }
-00300 
-00310 void _stp_map_key_str_long(MAP map, char *key1, long key2)
-00311 {
-00312         unsigned hv;
-00313         struct hlist_head *head;
-00314         struct hlist_node *e;
-00315 
-00316         if (map == NULL)
-00317                 return;
-00318 
-00319         if (key1 == NULL) {
-00320                 map->key = NULL;
-00321                 return;
-00322         }
+00280         hv = string_hash(key1, key2);
+00281         head = &map->hashes[hv];
+00282 
+00283         dbug ("hash for %s,%s is %d\n", key1, key2, hv);
+00284 
+00285         hlist_for_each(e, head) {
+00286                 struct map_node *n =
+00287                         (struct map_node *)((long)e - sizeof(struct hlist_node));
+00288                 dbug ("e =%lx  key=%s,%s\n", (long)e, n->key1.str,n->key2.str);
+00289                 if (strcmp(key1, n->key1.str) == 0
+00290                     && (key2 == NULL || strcmp(key2, n->key2.str) == 0)) {
+00291                         map->key = n;
+00292                         dbug ("saving key %lx\n", (long)map->key);
+00293                         map->create = 0;
+00294                         return;
+00295                 }
+00296         }
+00297 
+00298         map->c_key1.str = key1;
+00299         map->c_key2.str = key2;
+00300         map->c_key1type = STR;
+00301         map->c_key2type = STR;
+00302         map->c_keyhead = head;
+00303         map->create = 1;
+00304 }
+00305 
+00306 /** Set the map's key to a string and a long.
+00307  * This sets the current element based on a key of a string and a long. If the keys are
+00308  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00309  * call.
+00310  * @param map
+00311  * @param key1 first key
+00312  * @param key2 second key
+00313  */
+00314 
+00315 void _stp_map_key_str_long(MAP map, char *key1, long key2)
+00316 {
+00317         unsigned hv;
+00318         struct hlist_head *head;
+00319         struct hlist_node *e;
+00320 
+00321         if (map == NULL)
+00322                 return;
 00323 
-00324         hv = mixed_hash(key1, key2);
-00325         head = &map->hashes[hv];
-00326 
-00327         dbug ("hash for %s,%ld is %d\n", key1, key2, hv);
+00324         if (key1 == NULL) {
+00325                 map->key = NULL;
+00326                 return;
+00327         }
 00328 
-00329         hlist_for_each(e, head) {
-00330                 struct map_node *n =
-00331                         (struct map_node *)((long)e - sizeof(struct hlist_node));
-00332                 dbug ("e =%lx  key=%s,%ld\n", (long)e, n->key1.str,(long)n->key2.val);
-00333                 if (strcmp(key1, n->key1.str) == 0 && key2 == n->key2.val) {
-00334                         map->key = n;
-00335                         dbug ("saving key %lx\n", (long)map->key);
-00336                         map->create = 0;
-00337                         return;
-00338                 }
-00339         }
-00340 
-00341         map->c_key1.str = key1;
-00342         map->c_key2.val = key2;
-00343         map->c_key1type = STR;
-00344         map->c_key2type = LONG;
-00345         map->c_keyhead = head;
-00346         map->create = 1;
-00347 }
-00348 
-00358 void _stp_map_key_long_str(MAP map, long key1, char *key2)
-00359 {
-00360         unsigned hv;
-00361         struct hlist_head *head;
-00362         struct hlist_node *e;
-00363 
-00364         if (map == NULL)
-00365                 return;
-00366 
-00367         hv = mixed_hash(key2, key1);
-00368         head = &map->hashes[hv];
-00369         dbug ("hash for %ld,%s is %d\n", key1, key2, hv);
-00370 
-00371         hlist_for_each(e, head) {
-00372                 struct map_node *n =
-00373                         (struct map_node *)((long)e - sizeof(struct hlist_node));
-00374                 dbug ("e =%lx  key=%ld,%s\n", (long)e, n->key1.val,n->key2.str);
-00375                 if (key1 == n->key1.val && strcmp(key2, n->key2.str) == 0) {
-00376                         map->key = n;
-00377                         dbug ("saving key %lx\n", (long)map->key);
-00378                         map->create = 0;
-00379                         return;
-00380                 }
-00381         }
-00382 
-00383         map->c_key1.val = key1;
-00384         map->c_key2.str = key2;
-00385         map->c_key1type = LONG;
-00386         map->c_key2type = STR;
-00387         map->c_keyhead = head;
-00388         map->create = 1;
-00389 }
-00390 
-00399 void _stp_map_key_str(MAP map, char *key)
-00400 {
-00401         if (map == NULL)
-00402                 return;
-00403         _stp_map_key_str_str(map, key, NULL);
-00404         map->c_key2type = NONE;
-00405 }
-00406 
-00415 void _stp_map_key_long(MAP map, long key)
-00416 {
-00417         if (map == NULL)
-00418                 return;
-00419         _stp_map_key_long_long(map, key, 0);
-00420         map->c_key2type = NONE;
-00421 }
-00422 
-00423 /**********************  SET/GET VALUES *********************/
-00424 
-00425 static void map_copy_keys(MAP map, struct map_node *m)
-00426 {
-00427         m->key1type = map->c_key1type;
-00428         m->key2type = map->c_key2type;
-00429         switch (map->c_key1type) {
-00430         case STR:
-00431                 m->key1.str = _stp_alloc(strlen(map->c_key1.str) + 1);
-00432                 strcpy(m->key1.str, map->c_key1.str);
-00433                 break;
-00434         case LONG:
-00435                 m->key1.val = map->c_key1.val;
-00436                 break;
-00437         case NONE:
-00438                 /* ERROR */
-00439                 break;
-00440         }
-00441         switch (map->c_key2type) {
-00442         case STR:
-00443                 m->key2.str = _stp_alloc(strlen(map->c_key2.str) + 1);
-00444                 strcpy(m->key2.str, map->c_key2.str);
-00445                 break;
-00446         case LONG:
-00447                 m->key2.val = map->c_key2.val;
-00448                 break;
-00449         case NONE:
+00329         hv = mixed_hash(key1, key2);
+00330         head = &map->hashes[hv];
+00331 
+00332         dbug ("hash for %s,%ld is %d\n", key1, key2, hv);
+00333 
+00334         hlist_for_each(e, head) {
+00335                 struct map_node *n =
+00336                         (struct map_node *)((long)e - sizeof(struct hlist_node));
+00337                 dbug ("e =%lx  key=%s,%ld\n", (long)e, n->key1.str,(long)n->key2.val);
+00338                 if (strcmp(key1, n->key1.str) == 0 && key2 == n->key2.val) {
+00339                         map->key = n;
+00340                         dbug ("saving key %lx\n", (long)map->key);
+00341                         map->create = 0;
+00342                         return;
+00343                 }
+00344         }
+00345 
+00346         map->c_key1.str = key1;
+00347         map->c_key2.val = key2;
+00348         map->c_key1type = STR;
+00349         map->c_key2type = LONG;
+00350         map->c_keyhead = head;
+00351         map->create = 1;
+00352 }
+00353 
+00354 /** Set the map's key to a long and a string.
+00355  * This sets the current element based on a key of a long and a string. If the keys are
+00356  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00357  * call.
+00358  * @param map
+00359  * @param key1 first key
+00360  * @param key2 second key
+00361  */
+00362 
+00363 void _stp_map_key_long_str(MAP map, long key1, char *key2)
+00364 {
+00365         unsigned hv;
+00366         struct hlist_head *head;
+00367         struct hlist_node *e;
+00368 
+00369         if (map == NULL)
+00370                 return;
+00371 
+00372         hv = mixed_hash(key2, key1);
+00373         head = &map->hashes[hv];
+00374         dbug ("hash for %ld,%s is %d\n", key1, key2, hv);
+00375 
+00376         hlist_for_each(e, head) {
+00377                 struct map_node *n =
+00378                         (struct map_node *)((long)e - sizeof(struct hlist_node));
+00379                 dbug ("e =%lx  key=%ld,%s\n", (long)e, n->key1.val,n->key2.str);
+00380                 if (key1 == n->key1.val && strcmp(key2, n->key2.str) == 0) {
+00381                         map->key = n;
+00382                         dbug ("saving key %lx\n", (long)map->key);
+00383                         map->create = 0;
+00384                         return;
+00385                 }
+00386         }
+00387 
+00388         map->c_key1.val = key1;
+00389         map->c_key2.str = key2;
+00390         map->c_key1type = LONG;
+00391         map->c_key2type = STR;
+00392         map->c_keyhead = head;
+00393         map->create = 1;
+00394 }
+00395 
+00396 /** Set the map's key to a string.
+00397  * This sets the current element based on a string key. If the key is
+00398  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00399  * call.
+00400  * @param map
+00401  * @param key
+00402  */
+00403 
+00404 void _stp_map_key_str(MAP map, char *key)
+00405 {
+00406         if (map == NULL)
+00407                 return;
+00408         _stp_map_key_str_str(map, key, NULL);
+00409         map->c_key2type = NONE;
+00410 }
+00411 
+00412 /** Set the map's key to a long.
+00413  * This sets the current element based on a long key. If the key is
+00414  * not found, a new element will not be created until a <i>_stp_map_set_xxx</i>
+00415  * call.
+00416  * @param map
+00417  * @param key 
+00418  */
+00419 
+00420 void _stp_map_key_long(MAP map, long key)
+00421 {
+00422         if (map == NULL)
+00423                 return;
+00424         _stp_map_key_long_long(map, key, 0);
+00425         map->c_key2type = NONE;
+00426 }
+00427 
+00428 /**********************  SET/GET VALUES *********************/
+00429 
+00430 static void map_copy_keys(MAP map, struct map_node *m)
+00431 {
+00432         m->key1type = map->c_key1type;
+00433         m->key2type = map->c_key2type;
+00434         switch (map->c_key1type) {
+00435         case STR:
+00436                 m->key1.str = _stp_alloc(strlen(map->c_key1.str) + 1);
+00437                 strcpy(m->key1.str, map->c_key1.str);
+00438                 break;
+00439         case LONG:
+00440                 m->key1.val = map->c_key1.val;
+00441                 break;
+00442         case NONE:
+00443                 /* ERROR */
+00444                 break;
+00445         }
+00446         switch (map->c_key2type) {
+00447         case STR:
+00448                 m->key2.str = _stp_alloc(strlen(map->c_key2.str) + 1);
+00449                 strcpy(m->key2.str, map->c_key2.str);
 00450                 break;
-00451         }
-00452 
-00453         /* add node to new hash list */
-00454         hlist_add_head(&m->hnode, map->c_keyhead);
-00455         
-00456         map->key = m;
-00457         map->create = 0;
-00458         map->num++;
-00459 }
-00460 
-00461 static void __stp_map_set_int64(MAP map, int64_t val, int add)
-00462 {
-00463         struct map_node_int64 *m;
-00464 
-00465         if (map == NULL)
-00466                 return;
-00467 
-00468         if (map->create) {
-00469                 if (val == 0)
-00470                         return;
-00471 
-00472                 if (map->maxnum) {
-00473                         if (list_empty(&map->pool)) {
-00474                                 if (map->no_wrap) {
-00475                                         /* ERROR. FIXME */
-00476                                         return;
-00477                                 }
-00478                                 m = (struct map_node_int64 *)map->head.next;
-00479                                 hlist_del_init(&m->n.hnode);
-00480                                 map_free_strings(map, (struct map_node *)m);
-00481                                 dbug ("got %lx off head\n", (long)m);
-00482                         } else {
-00483                                 m = (struct map_node_int64 *)map->pool.next;
-00484                                 dbug ("got %lx off pool\n", (long)m);
-00485                         }
-00486                         list_move_tail(&m->n.lnode, &map->head);
-00487                 } else {
-00488                         m = (struct map_node_int64 *)
-00489                             _stp_calloc(sizeof(struct map_node_int64));
-00490                         /* add node to list */
-00491                         list_add_tail(&m->n.lnode, &map->head);
-00492                 }
-00493 
-00494                 /* copy the key(s) */
-00495                 map_copy_keys(map, &m->n);
-00496 
-00497                 /* set the value */
-00498                 m->val = val;
-00499         } else {
-00500                 if (map->key == NULL)
-00501                         return;
-00502 
-00503                 if (val) {
-00504                         m = (struct map_node_int64 *)map->key;
-00505                         if (add)
-00506                                 m->val += val;
-00507                         else
-00508                                 m->val = val;
-00509                 } else if (!add) {
-00510                         /* setting value to 0 is the same as deleting */
-00511                         _stp_map_key_del(map);
-00512                 }
-00513         }
-00514 }
-00515 
-00525 void _stp_map_set_int64(MAP map, int64_t val)
-00526 {
-00527         __stp_map_set_int64 (map, val, 0);
-00528 }
-00529 
-00530 
-00541 void _stp_map_add_int64(MAP map, int64_t val)
-00542 {
-00543         __stp_map_set_int64 (map, val, 1);
-00544 }
-00545 
-00551 int64_t _stp_map_get_int64(MAP map)
-00552 {
-00553         struct map_node_int64 *m;
-00554         if (map == NULL || map->create || map->key == NULL)
-00555                 return 0;
-00556         dbug ("%lx\n", (long)map->key);
-00557         m = (struct map_node_int64 *)map->key;
-00558         return m->val;
-00559 }
-00560 
-00571 void _stp_map_set_str(MAP map, char *val)
-00572 {
-00573         struct map_node_str *m;
-00574 
-00575         if (map == NULL)
-00576                 return;
+00451         case LONG:
+00452                 m->key2.val = map->c_key2.val;
+00453                 break;
+00454         case NONE:
+00455                 break;
+00456         }
+00457 
+00458         /* add node to new hash list */
+00459         hlist_add_head(&m->hnode, map->c_keyhead);
+00460         
+00461         map->key = m;
+00462         map->create = 0;
+00463         map->num++;
+00464 }
+00465 
+00466 static void __stp_map_set_int64(MAP map, int64_t val, int add)
+00467 {
+00468         struct map_node_int64 *m;
+00469 
+00470         if (map == NULL)
+00471                 return;
+00472 
+00473         if (map->create) {
+00474                 if (val == 0)
+00475                         return;
+00476 
+00477                 if (map->maxnum) {
+00478                         if (list_empty(&map->pool)) {
+00479                                 if (map->no_wrap) {
+00480                                         /* ERROR. FIXME */
+00481                                         return;
+00482                                 }
+00483                                 m = (struct map_node_int64 *)map->head.next;
+00484                                 hlist_del_init(&m->n.hnode);
+00485                                 map_free_strings(map, (struct map_node *)m);
+00486                                 dbug ("got %lx off head\n", (long)m);
+00487                         } else {
+00488                                 m = (struct map_node_int64 *)map->pool.next;
+00489                                 dbug ("got %lx off pool\n", (long)m);
+00490                         }
+00491                         list_move_tail(&m->n.lnode, &map->head);
+00492                 } else {
+00493                         m = (struct map_node_int64 *)
+00494                             _stp_calloc(sizeof(struct map_node_int64));
+00495                         /* add node to list */
+00496                         list_add_tail(&m->n.lnode, &map->head);
+00497                 }
+00498 
+00499                 /* copy the key(s) */
+00500                 map_copy_keys(map, &m->n);
+00501 
+00502                 /* set the value */
+00503                 m->val = val;
+00504         } else {
+00505                 if (map->key == NULL)
+00506                         return;
+00507 
+00508                 if (val) {
+00509                         m = (struct map_node_int64 *)map->key;
+00510                         if (add)
+00511                                 m->val += val;
+00512                         else
+00513                                 m->val = val;
+00514                 } else if (!add) {
+00515                         /* setting value to 0 is the same as deleting */
+00516                         _stp_map_key_del(map);
+00517                 }
+00518         }
+00519 }
+00520 
+00521 /** Set the current element's value to an int64.
+00522  * This sets the current element's value to an int64. The map must have been created
+00523  * to hold int64s using _stp_map_new()
+00524  *
+00525  * If the element doesn't exist, it is created.  If no current element (key)
+00526  * is set for the map, this function does nothing.
+00527  * @param map
+00528  * @param val new value
+00529  * @sa _stp_map_add_int64
+00530  */
+00531 void _stp_map_set_int64(MAP map, int64_t val)
+00532 {
+00533         __stp_map_set_int64 (map, val, 0);
+00534 }
+00535 
+00536 
+00537 /** Adds an int64 to the current element's value.
+00538  * This adds an int64 to the current element's value. The map must have been created
+00539  * to hold int64s using _stp_map_new()
+00540  *
+00541  * If the element doesn't exist, it is created.  If no current element (key)
+00542  * is set for the map, this function does nothing.
+00543  * @param map
+00544  * @param val value
+00545  * @sa _stp_map_set_int64
+00546  */
+00547 
+00548 void _stp_map_add_int64(MAP map, int64_t val)
+00549 {
+00550         __stp_map_set_int64 (map, val, 1);
+00551 }
+00552 
+00553 /** Gets the current element's value.
+00554  * @param map
+00555  * @returns The value. If the current element is not set or doesn't exist, returns 0.
+00556  */
+00557 
+00558 int64_t _stp_map_get_int64(MAP map)
+00559 {
+00560         struct map_node_int64 *m;
+00561         if (map == NULL || map->create || map->key == NULL)
+00562                 return 0;
+00563         dbug ("%lx\n", (long)map->key);
+00564         m = (struct map_node_int64 *)map->key;
+00565         return m->val;
+00566 }
+00567 
+00568 /** Set the current element's value to a string.
+00569  * This sets the current element's value to an string. The map must have been created
+00570  * to hold int64s using <i>_stp_map_new(xxx, STRING)</i>
+00571  *
+00572  * If the element doesn't exist, it is created.  If no current element (key)
+00573  * is set for the map, this function does nothing.
+00574  * @param map
+00575  * @param val new string
+00576  */
 00577 
-00578         if (map->create) {
-00579                 if (val == NULL)
-00580                         return;
+00578 void _stp_map_set_str(MAP map, char *val)
+00579 {
+00580         struct map_node_str *m;
 00581 
-00582                 if (map->maxnum) {
-00583                         if (list_empty(&map->pool)) {
-00584                                 if (map->no_wrap) {
-00585                                         /* ERROR. FIXME */
-00586                                         return;
-00587                                 }
-00588                                 m = (struct map_node_str *)map->head.next;
-00589                                 hlist_del_init(&m->n.hnode);
-00590                                 map_free_strings(map, (struct map_node *)m);
-00591                                 dbug ("got %lx off head\n", (long)m);
-00592                         } else {
-00593                                 m = (struct map_node_str *)map->pool.next;
-00594                                 dbug ("got %lx off pool\n", (long)m);
-00595                         }
-00596                         list_move_tail(&m->n.lnode, &map->head);
-00597                 } else {
-00598                         m = (struct map_node_str *)
-00599                             _stp_calloc(sizeof(struct map_node_str));
-00600                         /* add node to list */
-00601                         list_add_tail(&m->n.lnode, &map->head);
-00602                 }
-00603 
-00604                 /* copy the key(s) */
-00605                 map_copy_keys(map, &m->n);
-00606 
-00607                 /* set the value */
-00608                 m->str = _stp_alloc(strlen(val) + 1);
-00609                 strcpy(m->str, val);
-00610         } else {
-00611                 if (map->key == NULL)
-00612                         return;
+00582         if (map == NULL)
+00583                 return;
+00584 
+00585         if (map->create) {
+00586                 if (val == NULL)
+00587                         return;
+00588 
+00589                 if (map->maxnum) {
+00590                         if (list_empty(&map->pool)) {
+00591                                 if (map->no_wrap) {
+00592                                         /* ERROR. FIXME */
+00593                                         return;
+00594                                 }
+00595                                 m = (struct map_node_str *)map->head.next;
+00596                                 hlist_del_init(&m->n.hnode);
+00597                                 map_free_strings(map, (struct map_node *)m);
+00598                                 dbug ("got %lx off head\n", (long)m);
+00599                         } else {
+00600                                 m = (struct map_node_str *)map->pool.next;
+00601                                 dbug ("got %lx off pool\n", (long)m);
+00602                         }
+00603                         list_move_tail(&m->n.lnode, &map->head);
+00604                 } else {
+00605                         m = (struct map_node_str *)
+00606                             _stp_calloc(sizeof(struct map_node_str));
+00607                         /* add node to list */
+00608                         list_add_tail(&m->n.lnode, &map->head);
+00609                 }
+00610 
+00611                 /* copy the key(s) */
+00612                 map_copy_keys(map, &m->n);
 00613 
-00614                 if (val) {
-00615                         m = (struct map_node_str *)map->key;
-00616                         if (m->str)
-00617                                 _stp_free(m->str);
-00618                         m->str = _stp_alloc(strlen(val) + 1);
-00619                         strcpy(m->str, val);
-00620                 } else {
-00621                         /* setting value to 0 is the same as deleting */
-00622                         _stp_map_key_del(map);
-00623                 }
-00624         }
-00625 }
-00626 
-00632 char *_stp_map_get_str(MAP map)
-00633 {
-00634         struct map_node_str *m;
-00635         if (map == NULL || map->create || map->key == NULL)
-00636                 return NULL;
-00637         dbug ("%lx\n", (long)map->key);
-00638         m = (struct map_node_str *)map->key;
-00639         return m->str;
-00640 }
-00641 
-00656 void _stp_map_set_stat(MAP map, stat * stats)
-00657 {
-00658         struct map_node_stat *m;
-00659 
-00660         if (map == NULL)
-00661                 return;
-00662         dbug ("set_stat %lx\n", (long)map->key);
-00663 
-00664         if (map->create) {
-00665                 if (stats == NULL)
-00666                         return;
-00667 
-00668                 if (map->maxnum) {
-00669                         if (list_empty(&map->pool)) {
-00670                                 if (map->no_wrap) {
-00671                                         /* ERROR. FIXME */
-00672                                         return;
-00673                                 }
-00674                                 m = (struct map_node_stat *)map->head.next;
-00675                                 hlist_del_init(&m->n.hnode);
-00676                                 map_free_strings(map, (struct map_node *)m);
-00677                                 dbug ("got %lx off head\n", (long)m);
-00678                         } else {
-00679                                 m = (struct map_node_stat *)map->pool.next;
-00680                                 dbug ("got %lx off pool\n", (long)m);
-00681                         }
-00682                         list_move_tail(&m->n.lnode, &map->head);
-00683                 } else {
-00684                         m = (struct map_node_stat *)
-00685                             _stp_calloc(sizeof(struct map_node_stat));
-00686                         /* add node to list */
-00687                         list_add_tail(&m->n.lnode, &map->head);
-00688                 }
-00689 
-00690                 /* copy the key(s) */
-00691                 map_copy_keys(map, &m->n);
-00692 
-00693                 /* set the value */
-00694                 memcpy(&m->stats, stats, sizeof(stat));
-00695         } else {
-00696                 if (map->key == NULL)
-00697                         return;
-00698 
-00699                 if (stats) {
-00700                         m = (struct map_node_stat *)map->key;
-00701                         memcpy(&m->stats, stats, sizeof(stat));
-00702                 } else {
-00703                         /* setting value to NULL is the same as deleting */
-00704                         _stp_map_key_del(map);
-00705                 }
-00706         }
-00707 }
-00708 
-00715 stat *_stp_map_get_stat(MAP map)
-00716 {
-00717         struct map_node_stat *m;
-00718         if (map == NULL || map->create || map->key == NULL)
-00719                 return NULL;
-00720         dbug ("%lx\n", (long)map->key);
-00721         m = (struct map_node_stat *)map->key;
-00722         return &m->stats;
-00723 }
-00724 
-00736 void _stp_map_stat_add(MAP map, int64_t val)
-00737 {
-00738         struct map_node_stat *m;
-00739         if (map == NULL)
-00740                 return;
-00741 
-00742         if (map->create) {
-00743                 stat st = { 1, val, val, val };
-00744                 /* histogram */
-00745                 _stp_map_set_stat(map, &st);
-00746                 return;
-00747         }
+00614                 /* set the value */
+00615                 m->str = _stp_alloc(strlen(val) + 1);
+00616                 strcpy(m->str, val);
+00617         } else {
+00618                 if (map->key == NULL)
+00619                         return;
+00620 
+00621                 if (val) {
+00622                         m = (struct map_node_str *)map->key;
+00623                         if (m->str)
+00624                                 _stp_free(m->str);
+00625                         m->str = _stp_alloc(strlen(val) + 1);
+00626                         strcpy(m->str, val);
+00627                 } else {
+00628                         /* setting value to 0 is the same as deleting */
+00629                         _stp_map_key_del(map);
+00630                 }
+00631         }
+00632 }
+00633 
+00634 /** Gets the current element's value.
+00635  * @param map
+00636  * @returns A string pointer. If the current element is not set or doesn't exist, returns NULL.
+00637  */
+00638 
+00639 char *_stp_map_get_str(MAP map)
+00640 {
+00641         struct map_node_str *m;
+00642         if (map == NULL || map->create || map->key == NULL)
+00643                 return NULL;
+00644         dbug ("%lx\n", (long)map->key);
+00645         m = (struct map_node_str *)map->key;
+00646         return m->str;
+00647 }
+00648 
+00649 /** Set the current element's value to a stat.
+00650  * This sets the current element's value to an stat struct. The map must have been created
+00651  * to hold stats using <i>_stp_map_new(xxx, STAT)</i>.  This function would only be used
+00652  * if we wanted to set stats to something other than the normal initial values (count = 0,
+00653  * sum = 0, etc).  It may be deleted if it doesn't turn out to be useful.
+00654  * @sa _stp_map_stat_add 
+00655  *
+00656  * If the element doesn't exist, it is created.  If no current element (key)
+00657  * is set for the map, this function does nothing.
+00658  * @param map
+00659  * @param stats pointer to stats struct.
+00660  * @todo Histograms don't work yet.
+00661  */
+00662 
+00663 void _stp_map_set_stat(MAP map, stat * stats)
+00664 {
+00665         struct map_node_stat *m;
+00666 
+00667         if (map == NULL)
+00668                 return;
+00669         dbug ("set_stat %lx\n", (long)map->key);
+00670 
+00671         if (map->create) {
+00672                 if (stats == NULL)
+00673                         return;
+00674 
+00675                 if (map->maxnum) {
+00676                         if (list_empty(&map->pool)) {
+00677                                 if (map->no_wrap) {
+00678                                         /* ERROR. FIXME */
+00679                                         return;
+00680                                 }
+00681                                 m = (struct map_node_stat *)map->head.next;
+00682                                 hlist_del_init(&m->n.hnode);
+00683                                 map_free_strings(map, (struct map_node *)m);
+00684                                 dbug ("got %lx off head\n", (long)m);
+00685                         } else {
+00686                                 m = (struct map_node_stat *)map->pool.next;
+00687                                 dbug ("got %lx off pool\n", (long)m);
+00688                         }
+00689                         list_move_tail(&m->n.lnode, &map->head);
+00690                 } else {
+00691                         m = (struct map_node_stat *)
+00692                             _stp_calloc(sizeof(struct map_node_stat));
+00693                         /* add node to list */
+00694                         list_add_tail(&m->n.lnode, &map->head);
+00695                 }
+00696 
+00697                 /* copy the key(s) */
+00698                 map_copy_keys(map, &m->n);
+00699 
+00700                 /* set the value */
+00701                 memcpy(&m->stats, stats, sizeof(stat));
+00702         } else {
+00703                 if (map->key == NULL)
+00704                         return;
+00705 
+00706                 if (stats) {
+00707                         m = (struct map_node_stat *)map->key;
+00708                         memcpy(&m->stats, stats, sizeof(stat));
+00709                 } else {
+00710                         /* setting value to NULL is the same as deleting */
+00711                         _stp_map_key_del(map);
+00712                 }
+00713         }
+00714 }
+00715 
+00716 /** Gets the current element's value.
+00717  * @param map
+00718  * @returns A pointer to the stats struct. If the current element is not set 
+00719  * or doesn't exist, returns NULL.
+00720  */
+00721 
+00722 stat *_stp_map_get_stat(MAP map)
+00723 {
+00724         struct map_node_stat *m;
+00725         if (map == NULL || map->create || map->key == NULL)
+00726                 return NULL;
+00727         dbug ("%lx\n", (long)map->key);
+00728         m = (struct map_node_stat *)map->key;
+00729         return &m->stats;
+00730 }
+00731 
+00732 /** Add to the current element's statistics.
+00733  * Increments the statistics counter by one and the sum by <i>val</i>.
+00734  * Adjusts minimum, maximum, and histogram.
+00735  *
+00736  * If the element doesn't exist, it is created.  If no current element (key)
+00737  * is set for the map, this function does nothing.
+00738  * @param map
+00739  * @param val value to add to the statistics
+00740  * @todo Histograms don't work yet.
+00741  */
+00742 
+00743 void _stp_map_stat_add(MAP map, int64_t val)
+00744 {
+00745         struct map_node_stat *m;
+00746         if (map == NULL)
+00747                 return;
 00748 
-00749         if (map->key == NULL)
-00750                 return;
-00751 
-00752         dbug ("add_stat %lx\n", (long)map->key);
-00753         m = (struct map_node_stat *)map->key;
-00754         m->stats.count++;
-00755         m->stats.sum += val;
-00756         if (val > m->stats.max)
-00757                 m->stats.max = val;
-00758         if (val < m->stats.min)
-00759                 m->stats.min = val;
-00760         /* histogram */
-00761 }
-00762 
-00763 /**********************  List Functions *********************/
-00764 
-00776 MAP _stp_list_new(unsigned max_entries, enum valtype type)
-00777 {
-00778   MAP map = _stp_map_new (max_entries, type);
-00779   map->no_wrap = 1;
-00780   return map;
-00781 }
+00749         if (map->create) {
+00750                 stat st = { 1, val, val, val };
+00751                 /* histogram */
+00752                 _stp_map_set_stat(map, &st);
+00753                 return;
+00754         }
+00755 
+00756         if (map->key == NULL)
+00757                 return;
+00758 
+00759         dbug ("add_stat %lx\n", (long)map->key);
+00760         m = (struct map_node_stat *)map->key;
+00761         m->stats.count++;
+00762         m->stats.sum += val;
+00763         if (val > m->stats.max)
+00764                 m->stats.max = val;
+00765         if (val < m->stats.min)
+00766                 m->stats.min = val;
+00767         /* histogram */
+00768 }
+00769 
+00770 /**********************  List Functions *********************/
+00771 
+00772 /** Create a new list.
+00773  * A list is a map that internally has an incrementing long key for each member.
+00774  * Lists do not wrap if elements are added to exceed their maximum size.
+00775  * @param max_entries The maximum number of entries allowed. Currently that number will
+00776  * be preallocated.  If max_entries is 0, there will be no maximum and entries
+00777  * will be allocated dynamically.
+00778  * @param type Type of values stored in this list. 
+00779  * @return A MAP on success or NULL on failure.
+00780  * @sa foreach
+00781  */
 00782 
-00788 inline void _stp_list_clear(MAP map)
-00789 {
-00790         if (map == NULL)
-00791                 return;
-00792 
-00793         if (!list_empty(&map->head)) {
-00794                 struct map_node *ptr = (struct map_node *)map->head.next;
-00795 
-00796                 while (ptr && ptr != (struct map_node *)&map->head) {
-00797                         struct map_node *next = (struct map_node *)ptr->lnode.next;
-00798 
-00799                         /* remove node from old hash list */
-00800                         hlist_del_init(&ptr->hnode);
-00801 
-00802                         /* remove from entry list */
-00803                         list_del(&ptr->lnode);
-00804                         
-00805                         /* remove any allocated string storage */
-00806                         map_free_strings(map, ptr);
-00807                         
-00808                         if (map->maxnum)
-00809                                 list_add(&ptr->lnode, &map->pool);
-00810                         else
-00811                                 _stp_free(ptr);
-00812 
-00813                         map->num--;
-00814                         ptr = next;
-00815                 }
-00816         }
-00817 
-00818         if (map->num != 0) {
-00819                 dlog ("ERROR: list is supposed to be empty (has %d)\n", map->num);
-00820         }
-00821 }
-00822 
-00828 inline void _stp_list_add_str(MAP map, char *str)
-00829 {
-00830         _stp_map_key_long(map, map->num);
-00831         _stp_map_set_str(map, str);
-00832 }
-00833 
-00839 inline void _stp_list_add_int64(MAP map, int64_t val)
-00840 {
-00841         _stp_map_key_long(map, map->num);
-00842         _stp_map_set_int64(map, val);
-00843 }
-00844 
-00850 inline int _stp_list_size(MAP map)
-00851 {
-00852         return map->num;
-00853 }
-
Generated on Mon Mar 21 13:29:45 2005 for SystemTap by 
-
- 1.4.1 
-
+00783 MAP _stp_list_new(unsigned max_entries, enum valtype type)
+00784 {
+00785   MAP map = _stp_map_new (max_entries, type);
+00786   map->no_wrap = 1;
+00787   return map;
+00788 }
+00789 
+00790 /** Clears a list.
+00791  * All elements in the list are deleted.
+00792  * @param map 
+00793  */
+00794 
+00795 void _stp_list_clear(MAP map)
+00796 {
+00797         if (map == NULL)
+00798                 return;
+00799 
+00800         if (!list_empty(&map->head)) {
+00801                 struct map_node *ptr = (struct map_node *)map->head.next;
+00802 
+00803                 while (ptr && ptr != (struct map_node *)&map->head) {
+00804                         struct map_node *next = (struct map_node *)ptr->lnode.next;
+00805 
+00806                         /* remove node from old hash list */
+00807                         hlist_del_init(&ptr->hnode);
+00808 
+00809                         /* remove from entry list */
+00810                         list_del(&ptr->lnode);
+00811                         
+00812                         /* remove any allocated string storage */
+00813                         map_free_strings(map, ptr);
+00814                         
+00815                         if (map->maxnum)
+00816                                 list_add(&ptr->lnode, &map->pool);
+00817                         else
+00818                                 _stp_free(ptr);
+00819 
+00820                         map->num--;
+00821                         ptr = next;
+00822                 }
+00823         }
+00824 
+00825         if (map->num != 0) {
+00826                 dlog ("ERROR: list is supposed to be empty (has %d)\n", map->num);
+00827         }
+00828 }
+00829 
+00830 /** Adds a string to a list.
+00831  * @param map
+00832  * @param str
+00833  */
+00834 
+00835 inline void _stp_list_add_str(MAP map, char *str)
+00836 {
+00837         _stp_map_key_long(map, map->num);
+00838         _stp_map_set_str(map, str);
+00839 }
+00840 
+00841 /** Adds an int64 to a list.
+00842  * @param map
+00843  * @param val
+00844  */
+00845 
+00846 inline void _stp_list_add_int64(MAP map, int64_t val)
+00847 {
+00848         _stp_map_key_long(map, map->num);
+00849         _stp_map_set_int64(map, val);
+00850 }
+00851 
+00852 /** Get the number of elements in a list.
+00853  * @param map
+00854  * @returns The number of elements in a list.
+00855  */
+00856 
+00857 inline int _stp_list_size(MAP map)
+00858 {
+00859         return map->num;
+00860 }
+