00001 #ifndef _MAP_H_
-00002 #define _MAP_H_
-00003 /* -*- linux-c -*- */
-00004 
-00005 /** @file map.h
-00006  * @brief Header file for maps and lists 
-00007  */
-00008 /** @addtogroup maps 
+Main Page | Modules | Directories | File List | Globals | Related Pages
+map.h
Go to the documentation of this file.00001 #ifndef _MAP_H_ /* -*- linux-c -*- */
+00002 #define _MAP_H_
+00003 
+00004 /** @file map.h
+00005  * @brief Header file for maps and lists 
+00006  */
+00007 /** @addtogroup maps 
+00008  * @todo Needs to be made SMP-safe for when the big lock is removed from kprobes.
 00009  * @{ 
 00010  */
 00011 
 00012 #include <linux/types.h>
-00013 
-00014 /** Statistics are stored in this struct */
-00015 typedef struct {
+00013 
+00014 /* Statistics are stored in this struct */
+00015 typedef struct {
 00016         int64_t count;
 00017         int64_t sum;
 00018         int64_t min, max;
 00019         int64_t histogram[BUCKETS];
-00020 } stat;
-00021 
-00022 /** Keys are either longs or char * */
-00023 union key_data {
+00020 } stat;
+00021 
+00022 /* Keys are either longs or char * */
+00023 union key_data {
 00024         long val;
 00025         char *str;
 00026 };
 00027 
 00028 /** keys can be longs or strings */
-00029 enum keytype { NONE, LONG, STR } __attribute__ ((packed));
+00029 enum keytype { NONE, LONG, STR } __attribute__ ((packed));
 00030 /** values can be either int64, stats or strings */
-00031 enum valtype { INT64, STAT, STRING, END };
+00031 enum valtype { INT64, STAT, STRING, END };
 00032 
-00033 
-00034 /** basic map element */
-00035 struct map_node {
-00036         /** list of other nodes in the map */
-00037         struct list_head lnode;
-00038         /** list of nodes with the same hash value */
-00039         struct hlist_node hnode; 
-00040         union key_data key1;
-00041         union key_data key2;
-00042         enum keytype key1type;
-00043         enum keytype key2type;
+00033 
+00034 /* basic map element */
+00035 struct map_node {
+00036         /* list of other nodes in the map */
+00037         struct list_head lnode;
+00038         /* list of nodes with the same hash value */
+00039         struct hlist_node hnode; 
+00040         union key_data key1;
+00041         union key_data key2;
+00042         enum keytype key1type;
+00043         enum keytype key2type;
 00044 };
-00045 
-00046 /** map element containing int64 */
-00047 struct map_node_int64 {
-00048         struct map_node n;
+00045 
+00046 /* map element containing int64 */
+00047 struct map_node_int64 {
+00048         struct map_node n;
 00049         int64_t val;
 00050 };
-00051 
-00052 /** map element containing string */
-00053 struct map_node_str {
-00054         struct map_node n;
+00051 
+00052 /* map element containing string */
+00053 struct map_node_str {
+00054         struct map_node n;
 00055         char *str;
 00056 };
-00057 
-00058 /** map element containing stats */
-00059 struct map_node_stat {
-00060         struct map_node n;
-00061         stat stats;
+00057 
+00058 /* map element containing stats */
+00059 struct map_node_stat {
+00060         struct map_node n;
+00061         stat stats;
 00062 };
-00063 
-00064 /** This structure contains all information about a map.
+00063 
+00064 /* This structure contains all information about a map.
 00065  * It is allocated once when _stp_map_new() is called. 
 00066  */
-00067 struct map_root {
-00068         /** type of the values stored in the array */
-00069         enum valtype type;
-00070         
-00071         /** maximum number of elements allowed in the array. */
-00072         int maxnum;
-00073 
-00074         /** current number of used elements */
-00075         int num;
-00076 
-00077         /** when more than maxnum elements, wrap or discard? */
-00078         int no_wrap;
-00079 
-00080         /** linked list of current entries */
-00081         struct list_head head;
-00082 
-00083         /** pool of unused entries.  Used only when entries are statically allocated
+00067 struct map_root {
+00068         /* type of the values stored in the array */
+00069         enum valtype type;
+00070         
+00071         /* maximum number of elements allowed in the array. */
+00072         int maxnum;
+00073 
+00074         /* current number of used elements */
+00075         int num;
+00076 
+00077         /* when more than maxnum elements, wrap or discard? */
+00078         int no_wrap;
+00079 
+00080         /* linked list of current entries */
+00081         struct list_head head;
+00082 
+00083         /* pool of unused entries.  Used only when entries are statically allocated
 00084             at startup. */
-00085         struct list_head pool;
-00086 
-00087         /** saved key entry for lookups */
-00088         struct map_node *key;
+00085         struct list_head pool;
+00086 
+00087         /* saved key entry for lookups */
+00088         struct map_node *key;
 00089 
 00090         /** this is the creation data saved between the key functions and the
 00091             set/get functions 
 00092             @todo Needs to be per-cpu data for SMP support */
-00093         u_int8_t create;
-00094         enum keytype c_key1type;
-00095         enum keytype c_key2type;
+00093         u_int8_t create;
+00094         enum keytype c_key1type;
+00095         enum keytype c_key2type;
 00096         struct hlist_head *c_keyhead;
-00097         union key_data c_key1;
-00098         union key_data c_key2;
+00097         union key_data c_key1;
+00098         union key_data c_key2;
 00099 
 00100         /** the hash table for this array */
-00101         struct hlist_head hashes[HASH_TABLE_SIZE];
+00101         struct hlist_head hashes[HASH_TABLE_SIZE];
 00102 
 00103         /** pointer to allocated memory space. Used for freeing memory. */
-00104         void *membuf;
+00104         void *membuf;
 00105 };
 00106 
 00107 /** All maps are of this type. */
-00108 typedef struct map_root *MAP;
+00108 typedef struct map_root *MAP;
 00109 
 00110 /** Extracts string from key1 union */
-00111 #define key1str(ptr) (ptr->n.key1.str)
+00111 #define key1str(ptr) (ptr->n.key1.str)
 00112 /** Extracts string from key2 union */
-00113 #define key2str(ptr) (ptr->n.key2.str)
+00113 #define key2str(ptr) (ptr->n.key2.str)
 00114 /** Extracts int from key1 union */
-00115 #define key1int(ptr) (ptr->n.key1.val)
+00115 #define key1int(ptr) (ptr->n.key1.val)
 00116 /** Extracts int from key2 union */
-00117 #define key2int(ptr) (ptr->n.key2.val)
+00117 #define key2int(ptr) (ptr->n.key2.val)
 00118 
 00119 /** Macro to call the proper _stp_map_key functions based on the
 00120  * types of the arguments. 
 00121  * @note May cause compiler warning on some GCCs 
 00122  */
-00123 #define _stp_map_key2(map, key1, key2)                          \
+00123 #define _stp_map_key2(map, key1, key2)                          \
 00124   ({                                                            \
 00125     if (__builtin_types_compatible_p (typeof (key1), char[]))   \
 00126       if (__builtin_types_compatible_p (typeof (key2), char[])) \
@@ -145,7 +145,7 @@
 00138  * type of the argument. 
 00139  * @note May cause compiler warning on some GCCs 
 00140  */
-00141 #define _stp_map_key(map, key)                          \
+00141 #define _stp_map_key(map, key)                          \
 00142   ({                                                            \
 00143     if (__builtin_types_compatible_p (typeof (key), char[]))    \
 00144       _stp_map_key_str (map, (char *)(key));                            \
@@ -157,41 +157,45 @@
 00150  * type of the argument. 
 00151  * @note May cause compiler warning on some GCCs 
 00152  */
-00153 #define _stp_map_set(map, val)                          \
+00153 #define _stp_map_set(map, val)                                  \
 00154   ({                                                            \
-00155     if (__builtin_types_compatible_p (typeof (val), char[]))    \
+00155     if (__builtin_types_compatible_p (typeof (val), char[]))            \
 00156       _stp_map_set_str (map, (char *)(val));                            \
-00157     else                                                        \
-00158       _stp_map_set_int64 (map, (int64_t)(val));                 \
-00159   })
-00160 
-00161 /** Loop through all elements of a map or list.
-00162  * @param map 
-00163  * @param ptr pointer to a map_node_stat, map_node_int64 or map_node_str
-00164  *
-00165  * @b Example:
-00166  * @include foreach.c
-00167  */
-00168 
-00169 #define foreach(map, ptr)                               \
-00170   for (ptr = (typeof(ptr))_stp_map_start(map); ptr; \
-00171        ptr = (typeof(ptr))_stp_map_iter (map, (struct map_node *)ptr))
-00172 
-00173 /** @} */
-00174 
-00175 /** @ingroup lists
-00176  * @brief Macro to call the proper _stp_list_add function based on the
-00177  * types of the argument. 
-00178  *
-00179  * @note May cause compiler warning on some GCCs 
-00180  */
-00181 #define _stp_list_add(map, val)                         \
-00182   ({                                                            \
-00183     if (__builtin_types_compatible_p (typeof (val), char[]))    \
-00184       _stp_list_add_str (map, (char *)(val));                           \
-00185     else                                                        \
-00186       _stp_list_add_int64 (map, (int64_t)(val));                        \
-00187   })
-00188 
-00189 #endif /* _MAP_H_ */
+00157     else  if (__builtin_types_compatible_p (typeof (val), String))      \
+00158       _stp_map_set_string (map, (String)(val));                         \
+00159     else                                                                \
+00160       _stp_map_set_int64 (map, (int64_t)(val));                         \
+00161   })
+00162 
+00163 /** Loop through all elements of a map or list.
+00164  * @param map 
+00165  * @param ptr pointer to a map_node_stat, map_node_int64 or map_node_str
+00166  *
+00167  * @b Example:
+00168  * @include foreach.c
+00169  */
+00170 
+00171 #define foreach(map, ptr)                               \
+00172   for (ptr = (typeof(ptr))_stp_map_start(map); ptr; \
+00173        ptr = (typeof(ptr))_stp_map_iter (map, (struct map_node *)ptr))
+00174 
+00175 /** @} */
+00176 
+00177 /** @ingroup lists
+00178  * @brief Macro to call the proper _stp_list_add function based on the
+00179  * types of the argument. 
+00180  *
+00181  * @note May cause compiler warning on some GCCs 
+00182  */
+00183 #define _stp_list_add(map, val)                                 \
+00184   ({                                                                    \
+00185     if (__builtin_types_compatible_p (typeof (val), char[]))            \
+00186       _stp_list_add_str (map, (char *)(val));                           \
+00187     else if (__builtin_types_compatible_p (typeof (val), String))       \
+00188       _stp_list_add_string (map, (String)(val));                        \
+00189     else                                                                \
+00190       _stp_list_add_int64 (map, (int64_t)(val));                        \
+00191   })
+00192 
+00193 #endif /* _MAP_H_ */
 
-- 
cgit