SystemTap: SystemTap Runtime Library

00001 /* -*- linux-c -*- */
 00002 
 00003 static int map_sizes[] = {
@@ -35,21 +35,21 @@
 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);
+00030         return hash_long((unsigned long)(hash ^ key2), HASH_TABLE_BITS);
 00031 }
 00032 
-00043 MAP _stp_map_new(unsigned max_entries, enum valtype type)
+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));
+00046         MAP m = (MAP) _stp_valloc(sizeof(struct map_root));
 00047         if (m == NULL)
 00048                 return NULL;
 00049 
-00050         INIT_LIST_HEAD(&m->head);
+00050         INIT_LIST_HEAD(&m->head);
 00051 
-00052         m->maxnum = max_entries;
-00053         m->type = type;
-00054         if (type >= END) {
+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         }
@@ -59,16 +59,16 @@
 00061                 int i;
 00062                 struct list_head *e;
 00063 
-00064                 INIT_LIST_HEAD(&m->pool);
+00064                 INIT_LIST_HEAD(&m->pool);
 00065                 size = map_sizes[type];
-00066                 tmp = _stp_valloc(max_entries * size);
+00066                 tmp = _stp_valloc(max_entries * size);
 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);
+00071                         list_add(e, &m->pool);
 00072                 }
-00073                 m->membuf = tmp;
+00073                 m->membuf = tmp;
 00074         }
 00075         return m;
 00076 }
@@ -77,41 +77,41 @@
 00079 {
 00080         struct map_node_str *m = (struct map_node_str *)n;
 00081         dbug ("n = %lx\n", (long)n);
-00082         if (map->type == STRING) {
+00082         if (map->type == STRING) {
 00083                 dbug ("val STRING %lx\n", (long)m->str);
 00084                 if (m->str)
-00085                         _stp_free(m->str);
+00085                         _stp_free(m->str);
 00086         }
-00087         if (m->n.key1type == STR) {
+00087         if (m->n.key1type == STR) {
 00088                 dbug ("key1 STR %lx\n", (long)key1str(m));
 00089                 if (key1str(m))
-00090                         _stp_free(key1str(m));
+00090                         _stp_free(key1str(m));
 00091         }
-00092         if (m->n.key2type == STR) {
+00092         if (m->n.key2type == STR) {
 00093                 dbug ("key2 STR %lx\n", (long)key2str(m));
 00094                 if (key2str(m))
-00095                         _stp_free(key2str(m));
+00095                         _stp_free(key2str(m));
 00096         }
 00097 }
 00098 
-00104 void _stp_map_key_del(MAP map)
+00104 void _stp_map_key_del(MAP map)
 00105 {
 00106         struct map_node *m;
 00107 
-00108         dbug ("create=%d key=%lx\n", map->create, (long)map->key);
+00108         dbug ("create=%d key=%lx\n", map->create, (long)map->key);
 00109         if (map == NULL)
 00110                 return;
 00111 
-00112         if (map->create) {
-00113                 map->create = 0;
-00114                 map->key = NULL;
+00112         if (map->create) {
+00113                 map->create = 0;
+00114                 map->key = NULL;
 00115                 return;
 00116         }
 00117 
-00118         if (map->key == NULL)
+00118         if (map->key == NULL)
 00119                 return;
 00120 
-00121         m = (struct map_node *)map->key;
+00121         m = (struct map_node *)map->key;
 00122 
 00123         /* remove node from old hash list */
 00124         hlist_del_init(&m->hnode);
@@ -120,15 +120,15 @@
 00127         list_del(&m->lnode);
 00128 
 00129         /* remove any allocated string storage */
-00130         map_free_strings(map, (struct map_node *)map->key);
+00130         map_free_strings(map, (struct map_node *)map->key);
 00131 
-00132         if (map->maxnum)
-00133                 list_add(&m->lnode, &map->pool);
+00132         if (map->maxnum)
+00133                 list_add(&m->lnode, &map->pool);
 00134         else
-00135                 _stp_free(m);
+00135                 _stp_free(m);
 00136 
-00137         map->key = NULL;
-00138         map->num--;
+00137         map->key = NULL;
+00138         map->num--;
 00139 }
 00140 
 00149 struct map_node *_stp_map_start(MAP map)
@@ -136,12 +136,12 @@
 00151         if (map == NULL)
 00152                 return NULL;
 00153 
-00154         dbug ("%lx\n", (long)map->head.next);
+00154         dbug ("%lx\n", (long)map->head.next);
 00155 
-00156         if (list_empty(&map->head))
+00156         if (list_empty(&map->head))
 00157                 return NULL;
 00158 
-00159         return (struct map_node *)map->head.next;
+00159         return (struct map_node *)map->head.next;
 00160 }
 00161 
 00172 struct map_node *_stp_map_iter(MAP map, struct map_node *m)
@@ -149,12 +149,12 @@
 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);
+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)
+00179         if (m->lnode.next == &map->head)
 00180                 return NULL;
 00181 
-00182         return (struct map_node *)m->lnode.next;
+00182         return (struct map_node *)m->lnode.next;
 00183 }
 00184 
 00190 void _stp_map_del(MAP map)
@@ -162,15 +162,15 @@
 00192         if (map == NULL)
 00193                 return;
 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) {
+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);
+00202         _stp_vfree(map->membuf);
+00203         _stp_vfree(map);
 00204 }
 00205 
 00206 /**********************  KEY FUNCTIONS *********************/
@@ -186,7 +186,7 @@
 00225                 return;
 00226 
 00227         hv = hash_long(key1 ^ key2, HASH_TABLE_BITS);
-00228         head = &map->hashes[hv];
+00228         head = &map->hashes[hv];
 00229 
 00230         dbug ("hash for %ld,%ld is %d\n", key1, key2, hv);
 00231 
@@ -195,19 +195,19 @@
 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;
+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;
+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)
@@ -220,12 +220,12 @@
 00268                 return;
 00269 
 00270         if (key1 == NULL) {
-00271                 map->key = NULL;
+00271                 map->key = NULL;
 00272                 return;
 00273         }
 00274 
 00275         hv = string_hash(key1, key2);
-00276         head = &map->hashes[hv];
+00276         head = &map->hashes[hv];
 00277 
 00278         dbug ("hash for %s,%s is %d\n", key1, key2, hv);
 00279 
@@ -235,19 +235,19 @@
 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;
+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;
+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)
@@ -260,12 +260,12 @@
 00317                 return;
 00318 
 00319         if (key1 == NULL) {
-00320                 map->key = NULL;
+00320                 map->key = NULL;
 00321                 return;
 00322         }
 00323 
 00324         hv = mixed_hash(key1, key2);
-00325         head = &map->hashes[hv];
+00325         head = &map->hashes[hv];
 00326 
 00327         dbug ("hash for %s,%ld is %d\n", key1, key2, hv);
 00328 
@@ -274,19 +274,19 @@
 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;
+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;
+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)
@@ -299,7 +299,7 @@
 00365                 return;
 00366 
 00367         hv = mixed_hash(key2, key1);
-00368         head = &map->hashes[hv];
+00368         head = &map->hashes[hv];
 00369         dbug ("hash for %ld,%s is %d\n", key1, key2, hv);
 00370 
 00371         hlist_for_each(e, head) {
@@ -307,19 +307,19 @@
 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;
+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;
+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)
@@ -327,7 +327,7 @@
 00401         if (map == NULL)
 00402                 return;
 00403         _stp_map_key_str_str(map, key, NULL);
-00404         map->c_key2type = NONE;
+00404         map->c_key2type = NONE;
 00405 }
 00406 
 00415 void _stp_map_key_long(MAP map, long key)
@@ -335,327 +335,341 @@
 00417         if (map == NULL)
 00418                 return;
 00419         _stp_map_key_long_long(map, key, 0);
-00420         map->c_key2type = NONE;
+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) {
+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);
+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;
+00435                 m->key1.val = map->c_key1.val;
 00436                 break;
 00437         case NONE:
 00438                 /* ERROR */
 00439                 break;
 00440         }
-00441         switch (map->c_key2type) {
+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);
+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;
+00447                 m->key2.val = map->c_key2.val;
 00448                 break;
 00449         case NONE:
 00450                 break;
 00451         }
 00452 
 00453         /* add node to new hash list */
-00454         hlist_add_head(&m->hnode, map->c_keyhead);
+00454         hlist_add_head(&m->hnode, map->c_keyhead);
 00455         
-00456         map->key = m;
-00457         map->create = 0;
-00458         map->num++;
+00456         map->key = m;
+00457         map->create = 0;
+00458         map->num++;
 00459 }
 00460 
-00471 void _stp_map_set_int64(MAP map, int64_t val)
-00472 {
-00473         struct map_node_int64 *m;
-00474 
-00475         if (map == NULL)
-00476                 return;
-00477 
-00478         if (map->create) {
-00479                 if (val == 0)
-00480                         return;
-00481 
-00482                 if (map->maxnum) {
-00483                         if (list_empty(&map->pool)) {
-00484                                 if (map->no_wrap) {
-00485                                         /* ERROR. FIXME */
-00486                                         return;
-00487                                 }
-00488                                 m = (struct map_node_int64 *)map->head.next;
-00489                                 hlist_del_init(&m->n.hnode);
-00490                                 map_free_strings(map, (struct map_node *)m);
-00491                                 dbug ("got %lx off head\n", (long)m);
-00492                         } else {
-00493                                 m = (struct map_node_int64 *)map->pool.next;
-00494                                 dbug ("got %lx off pool\n", (long)m);
-00495                         }
-00496                         list_move_tail(&m->n.lnode, &map->head);
-00497                 } else {
-00498                         m = (struct map_node_int64 *)
-00499                             _stp_calloc(sizeof(struct map_node_int64));
-00500                         /* add node to list */
-00501                         list_add_tail(&m->n.lnode, &map->head);
-00502                 }
-00503 
-00504                 /* copy the key(s) */
-00505                 map_copy_keys(map, &m->n);
-00506 
-00507                 /* set the value */
-00508                 m->val = val;
-00509         } else {
-00510                 if (map->key == NULL)
-00511                         return;
-00512 
-00513                 if (val) {
-00514                         m = (struct map_node_int64 *)map->key;
-00515                         m->val = val;
-00516                 } else {
-00517                         /* setting value to 0 is the same as deleting */
-00518                         _stp_map_key_del(map);
-00519                 }
-00520         }
-00521 }
-00522 
-00528 int64_t _stp_map_get_int64(MAP map)
-00529 {
-00530         struct map_node_int64 *m;
-00531         if (map == NULL || map->create || map->key == NULL)
-00532                 return 0;
-00533         dbug ("%lx\n", (long)map->key);
-00534         m = (struct map_node_int64 *)map->key;
-00535         return m->val;
-00536 }
-00537 
-00548 void _stp_map_set_str(MAP map, char *val)
-00549 {
-00550         struct map_node_str *m;
-00551 
-00552         if (map == NULL)
-00553                 return;
-00554 
-00555         if (map->create) {
-00556                 if (val == NULL)
-00557                         return;
-00558 
-00559                 if (map->maxnum) {
-00560                         if (list_empty(&map->pool)) {
-00561                                 if (map->no_wrap) {
-00562                                         /* ERROR. FIXME */
-00563                                         return;
-00564                                 }
-00565                                 m = (struct map_node_str *)map->head.next;
-00566                                 hlist_del_init(&m->n.hnode);
-00567                                 map_free_strings(map, (struct map_node *)m);
-00568                                 dbug ("got %lx off head\n", (long)m);
-00569                         } else {
-00570                                 m = (struct map_node_str *)map->pool.next;
-00571                                 dbug ("got %lx off pool\n", (long)m);
-00572                         }
-00573                         list_move_tail(&m->n.lnode, &map->head);
-00574                 } else {
-00575                         m = (struct map_node_str *)
-00576                             _stp_calloc(sizeof(struct map_node_str));
-00577                         /* add node to list */
-00578                         list_add_tail(&m->n.lnode, &map->head);
-00579                 }
-00580 
-00581                 /* copy the key(s) */
-00582                 map_copy_keys(map, &m->n);
-00583 
-00584                 /* set the value */
-00585                 m->str = _stp_alloc(strlen(val) + 1);
-00586                 strcpy(m->str, val);
-00587         } else {
-00588                 if (map->key == NULL)
-00589                         return;
-00590 
-00591                 if (val) {
-00592                         m = (struct map_node_str *)map->key;
-00593                         if (m->str)
-00594                                 _stp_free(m->str);
-00595                         m->str = _stp_alloc(strlen(val) + 1);
-00596                         strcpy(m->str, val);
+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;
+00577 
+00578         if (map->create) {
+00579                 if (val == NULL)
+00580                         return;
+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                         /* setting value to 0 is the same as deleting */
-00599                         _stp_map_key_del(map);
-00600                 }
-00601         }
-00602 }
+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 
-00609 char *_stp_map_get_str(MAP map)
-00610 {
-00611         struct map_node_str *m;
-00612         if (map == NULL || map->create || map->key == NULL)
-00613                 return NULL;
-00614         dbug ("%lx\n", (long)map->key);
-00615         m = (struct map_node_str *)map->key;
-00616         return m->str;
-00617 }
-00618 
-00633 void _stp_map_set_stat(MAP map, stat * stats)
-00634 {
-00635         struct map_node_stat *m;
-00636 
-00637         if (map == NULL)
-00638                 return;
-00639         dbug ("set_stat %lx\n", (long)map->key);
-00640 
-00641         if (map->create) {
-00642                 if (stats == NULL)
-00643                         return;
-00644 
-00645                 if (map->maxnum) {
-00646                         if (list_empty(&map->pool)) {
-00647                                 if (map->no_wrap) {
-00648                                         /* ERROR. FIXME */
-00649                                         return;
-00650                                 }
-00651                                 m = (struct map_node_stat *)map->head.next;
-00652                                 hlist_del_init(&m->n.hnode);
-00653                                 map_free_strings(map, (struct map_node *)m);
-00654                                 dbug ("got %lx off head\n", (long)m);
-00655                         } else {
-00656                                 m = (struct map_node_stat *)map->pool.next;
-00657                                 dbug ("got %lx off pool\n", (long)m);
-00658                         }
-00659                         list_move_tail(&m->n.lnode, &map->head);
-00660                 } else {
-00661                         m = (struct map_node_stat *)
-00662                             _stp_calloc(sizeof(struct map_node_stat));
-00663                         /* add node to list */
-00664                         list_add_tail(&m->n.lnode, &map->head);
-00665                 }
-00666 
-00667                 /* copy the key(s) */
-00668                 map_copy_keys(map, &m->n);
-00669 
-00670                 /* set the value */
-00671                 memcpy(&m->stats, stats, sizeof(stat));
-00672         } else {
-00673                 if (map->key == NULL)
-00674                         return;
-00675 
-00676                 if (stats) {
-00677                         m = (struct map_node_stat *)map->key;
-00678                         memcpy(&m->stats, stats, sizeof(stat));
-00679                 } else {
-00680                         /* setting value to NULL is the same as deleting */
-00681                         _stp_map_key_del(map);
-00682                 }
-00683         }
-00684 }
-00685 
-00692 stat *_stp_map_get_stat(MAP map)
-00693 {
-00694         struct map_node_stat *m;
-00695         if (map == NULL || map->create || map->key == NULL)
-00696                 return NULL;
-00697         dbug ("%lx\n", (long)map->key);
-00698         m = (struct map_node_stat *)map->key;
-00699         return &m->stats;
-00700 }
-00701 
-00713 void _stp_map_stat_add(MAP map, int64_t val)
-00714 {
-00715         struct map_node_stat *m;
-00716         if (map == NULL)
-00717                 return;
-00718 
-00719         if (map->create) {
-00720                 stat st = { 1, val, val, val };
-00721                 /* histogram */
-00722                 _stp_map_set_stat(map, &st);
-00723                 return;
-00724         }
-00725 
-00726         if (map->key == NULL)
-00727                 return;
-00728 
-00729         dbug ("add_stat %lx\n", (long)map->key);
-00730         m = (struct map_node_stat *)map->key;
-00731         m->stats.count++;
-00732         m->stats.sum += val;
-00733         if (val > m->stats.max)
-00734                 m->stats.max = val;
-00735         if (val < m->stats.min)
-00736                 m->stats.min = val;
-00737         /* histogram */
-00738 }
-00739 
-00740 /**********************  List Functions *********************/
+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;
+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 
-00753 MAP _stp_list_new(unsigned max_entries, enum valtype type)
-00754 {
-00755   MAP map = _stp_map_new (max_entries, type);
-00756   map->no_wrap = 1;
-00757   return map;
-00758 }
-00759 
-00765 inline void _stp_list_clear(MAP map)
-00766 {
-00767         if (map == NULL)
-00768                 return;
-00769 
-00770         if (!list_empty(&map->head)) {
-00771                 struct map_node *ptr = (struct map_node *)map->head.next;
-00772 
-00773                 while (ptr && ptr != (struct map_node *)&map->head) {
-00774                         struct map_node *next = (struct map_node *)ptr->lnode.next;
-00775 
-00776                         /* remove node from old hash list */
-00777                         hlist_del_init(&ptr->hnode);
-00778 
-00779                         /* remove from entry list */
-00780                         list_del(&ptr->lnode);
-00781                         
-00782                         /* remove any allocated string storage */
-00783                         map_free_strings(map, ptr);
-00784                         
-00785                         if (map->maxnum)
-00786                                 list_add(&ptr->lnode, &map->pool);
-00787                         else
-00788                                 _stp_free(ptr);
-00789 
-00790                         map->num--;
-00791                         ptr = next;
-00792                 }
-00793         }
-00794 
-00795         if (map->num != 0) {
-00796                 dlog ("ERROR: list is supposed to be empty (has %d)\n", map->num);
-00797         }
-00798 }
-00799 
-00805 inline void _stp_list_add_str(MAP map, char *str)
-00806 {
-00807         _stp_map_key_long(map, map->num);
-00808         _stp_map_set_str(map, str);
-00809 }
-00810 
-00816 inline void _stp_list_add_int64(MAP map, int64_t val)
-00817 {
-00818         _stp_map_key_long(map, map->num);
-00819         _stp_map_set_int64(map, val);
-00820 }
-00821 
-00827 inline int _stp_list_size(MAP map)
-00828 {
-00829         return map->num;
-00830 }
-

Enumerations
enum	errorcode { ERR_NONE = 0, -ERR_NO_MEM +
enum	errorcode { ERR_NONE = 0, +ERR_NO_MEM }
Functions
void *	_stp_alloc (size_t len)
void *	_stp_alloc (size_t len)
	Allocates memory within a probe.
void *	_stp_calloc (size_t len)
	Allocates memory within a probe.
void *	_stp_calloc (size_t len)
	Allocates and clears memory within a probe.
void *	_stp_valloc (size_t len)
	Allocates and clears memory within a probe.
void *	_stp_valloc (size_t len)
	Allocates and clears memory outside a probe.
void	_stp_free (void *ptr)
	Allocates and clears memory outside a probe.
void	_stp_free (void *ptr)
	Frees memory allocated by _stp_alloc or _stp_calloc.
void	_stp_vfree (void *ptr)
	Frees memory allocated by _stp_alloc or _stp_calloc.
void	_stp_vfree (void *ptr)
	Frees memory allocated by _stp_valloc.
Variables
enum errorcode	_stp_error = ERR_NONE
	Frees memory allocated by _stp_valloc.
ERR_NONE	+
ERR_NONE
ERR_NO_MEM	+
ERR_NO_MEM
README

README File Reference

alloc.h

alloc.h

alloc.h File Reference

Enumerations

Functions

Variables

Enumeration Type Documentation

Function Documentation

Variable Documentation

SystemTap Data Structures

copy.c

copy.c File Reference

Function Documentation

SystemTap File List

SystemTap Runtime Library

0.1

+A list is a special map which has internally ascending long integer keys. Adding a value to a list does not require setting a key first. See _stp_list_add_str() and _stp_list_add_int64().

io.c

io.c File Reference

Defines

Functions

Define Documentation

Function Documentation

map.c

map.c File Reference

Function Documentation

map.h

map.h File Reference

Data Structures

Defines

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Variable Documentation

SystemTap Related Pages

probes.c

probes.c File Reference

Functions

Function Documentation

runtime.h

runtime.h File Reference

Define Documentation

stack.c

stack.c File Reference

Functions

Function Documentation

map_node Struct Reference

Field Documentation

map_node_int64 Struct Reference

Field Documentation

map_node_stat Struct Reference

Field Documentation

map_node_str Struct Reference

Field Documentation

map_root Struct Reference

Data Fields

Field Documentation

stat Struct Reference

Field Documentation

key_data Union Reference

Field Documentation
