Changeset 121b7e2
- Timestamp:
- 03/11/08 16:19:32 (14 years ago)
- Branches:
- 4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
- Children:
- a9a91d1
- Parents:
- 6033b99
- Location:
- lib
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
lib/dagformat.h
r4bd8a5b r121b7e2 5 5 6 6 /* GPP record type defines */ 7 #define TYPE_LEGACY 0 8 #define TYPE_HDLC_POS 1 9 #define TYPE_ETH 2 10 #define TYPE_ATM 3 11 #define TYPE_AAL5 4 7 #define TYPE_LEGACY 0 8 #define TYPE_HDLC_POS 1 9 #define TYPE_ETH 2 10 #define TYPE_ATM 3 11 #define TYPE_AAL5 4 12 #define TYPE_MC_HDLC 5 13 #define TYPE_MC_RAW 6 14 #define TYPE_MC_ATM 7 15 #define TYPE_MC_RAW_CHANNEL 8 16 #define TYPE_MC_AAL5 9 17 #define TYPE_COLOR_HDLC_POS 10 18 #define TYPE_COLOR_ETH 11 19 #define TYPE_MC_AAL2 12 20 #define TYPE_IP_COUNTER 13 21 #define TYPE_TCP_FLOW_COUNTER 14 22 #define TYPE_DSM_COLOR_HDLC_POS 15 23 #define TYPE_DSM_COLOR_ETH 16 24 #define TYPE_COLOR_MC_HDLC_POS 17 25 #define TYPE_AAL2 18 26 27 12 28 13 29 #ifdef WIN32 -
lib/format_dag24.c
r2b7750a r121b7e2 100 100 static int dag_init_input(libtrace_t *libtrace) { 101 101 struct stat buf; 102 libtrace->format_data = (struct dag_format_data_t *) 102 char *dag_dev_name = NULL; 103 char *scan = NULL; 104 105 /* Since DAG 2.5 has been changed to support a slightly different URI 106 * format, it's probably a good idea to deal with URIs specified in 107 * such a fashion even if we just end up ignoring the stream number */ 108 if ((scan = strchr(libtrace->uridata,',')) == NULL) { 109 dag_dev_name = strdup(libtrace->uridata); 110 } else { 111 dag_dev_name = (char *)strndup(libtrace->uridata, 112 (size_t)(scan - libtrace->uridata)); 113 } 114 115 116 if (stat(dag_dev_name, &buf) == -1) { 117 trace_set_err(libtrace,errno,"stat(%s)",dag_dev_name); 118 free(dag_dev_name); 119 return -1; 120 } 121 122 libtrace->format_data = (struct dag_format_data_t *) 103 123 malloc(sizeof(struct dag_format_data_t)); 104 if (stat(libtrace->uridata, &buf) == -1) {105 trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);106 return -1;107 }108 109 124 FORMAT_DATA->top = 0; 110 125 FORMAT_DATA->bottom = 0; 111 126 if (S_ISCHR(buf.st_mode)) { 112 127 /* DEVICE */ 113 if((FORMAT_DATA->fd = dag_open( libtrace->uridata)) < 0) {128 if((FORMAT_DATA->fd = dag_open(dag_dev_name)) < 0) { 114 129 trace_set_err(libtrace,errno,"Cannot open DAG %s", 115 libtrace->uridata); 130 dag_dev_name); 131 free(dag_dev_name); 116 132 return -1; 117 133 } 118 134 if((FORMAT_DATA->buf = (void *)dag_mmap(FORMAT_DATA->fd)) == MAP_FAILED) { 119 135 trace_set_err(libtrace,errno,"Cannot mmap DAG %s", 120 libtrace->uridata); 136 dag_dev_name); 137 free(dag_dev_name); 121 138 return -1; 122 139 } 123 140 } else { 124 141 trace_set_err(libtrace,errno,"Not a valid dag device: %s", 125 libtrace->uridata); 142 dag_dev_name); 143 free(dag_dev_name); 126 144 return -1; 127 145 } … … 132 150 DUCK.dummy_duck = NULL; 133 151 FORMAT_DATA->drops = 0; 152 free(dag_dev_name); 134 153 135 154 return 0; -
lib/format_dag25.c
r6033b99 r121b7e2 46 46 47 47 #include <sys/mman.h> 48 48 49 49 50 #ifdef WIN32 … … 58 59 # endif 59 60 # include <sys/ioctl.h> 61 # include <pthread.h> 60 62 #endif 63 61 64 62 65 #define DATA(x) ((struct dag_format_data_t *)x->format_data) … … 64 67 #define DUCK FORMAT_DATA->duck 65 68 static struct libtrace_format_t dag; 69 70 struct dag_dev_t { 71 //pthread_mutex_t dag_mutex; 72 char * dev_name; 73 int fd; 74 uint16_t ref_count; 75 struct dag_dev_t *next; 76 }; 66 77 67 78 struct dag_format_data_t { … … 73 84 } duck; 74 85 75 int fd;86 struct dag_dev_t *device; 76 87 unsigned int dagstream; 77 88 int stream_attached; … … 82 93 }; 83 94 84 static int dag_init_input(libtrace_t *libtrace) { 95 pthread_mutex_t open_dag_mutex; 96 struct dag_dev_t *open_dags = NULL; 97 98 static struct dag_dev_t *dag_find_open_device(char *dev_name) { 99 struct dag_dev_t *dag_dev; 100 101 pthread_mutex_lock(&open_dag_mutex); 102 dag_dev = open_dags; 103 104 /* XXX: Not exactly zippy, but how often are we going to be dealing 105 * with multiple dag cards? */ 106 while (dag_dev != NULL) { 107 if (strcmp(dag_dev->dev_name, dev_name) == 0) { 108 pthread_mutex_unlock(&open_dag_mutex); 109 return dag_dev; 110 111 } 112 dag_dev = dag_dev->next; 113 } 114 pthread_mutex_unlock(&open_dag_mutex); 115 return NULL; 116 117 118 } 119 120 static void dag_close_device(struct dag_dev_t *dev) { 121 /* Need to remove from the device list */ 122 struct dag_dev_t *prev, *d; 123 124 prev = NULL; 125 pthread_mutex_lock(&open_dag_mutex); 126 127 d = open_dags; 128 129 while (d != NULL) { 130 if (strcmp(dev->dev_name, d->dev_name) == 0) { 131 /* Found it! */ 132 if (prev == NULL) { 133 open_dags = d->next; 134 } else { 135 prev->next = d->next; 136 } 137 assert(d->ref_count == 0); 138 dag_close(d->fd); 139 free(d->dev_name); 140 free(d); 141 return; 142 } 143 prev = d; 144 d = d->next; 145 } 146 147 /* Not sure what we do here - we've been asked to close a 148 * device that isn't in our linked list - probably safest to 149 * just return. Is there anything else we can really do? */ 150 return; 151 } 152 153 static struct dag_dev_t *dag_open_device(libtrace_t *libtrace, char *dev_name) { 85 154 struct stat buf; 86 libtrace->format_data = (struct dag_format_data_t *) 87 malloc(sizeof(struct dag_format_data_t)); 88 if (stat(libtrace->uridata, &buf) == -1) { 89 trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata); 90 return -1; 91 } 92 93 /* For now, we don't offer the ability to select the stream */ 94 FORMAT_DATA->dagstream = 0; 95 155 int fd; 156 struct dag_dev_t *new_dev; 157 158 if (stat(dev_name, &buf) == -1) { 159 trace_set_err(libtrace,errno,"stat(%s)",dev_name); 160 return NULL; 161 } 162 96 163 if (S_ISCHR(buf.st_mode)) { 97 if(( FORMAT_DATA->fd = dag_open(libtrace->uridata)) < 0) {164 if((fd = dag_open(dev_name)) < 0) { 98 165 trace_set_err(libtrace,errno,"Cannot open DAG %s", 99 libtrace->uridata);100 return -1;166 dev_name); 167 return NULL; 101 168 } 102 169 } else { 103 170 trace_set_err(libtrace,errno,"Not a valid dag device: %s", 104 libtrace->uridata); 105 return -1; 106 } 171 dev_name); 172 return NULL; 173 } 174 175 new_dev = (struct dag_dev_t *)malloc(sizeof(struct dag_dev_t)); 176 new_dev->fd = fd; 177 new_dev->dev_name = dev_name; 178 new_dev->ref_count = 0; 179 180 pthread_mutex_lock(&open_dag_mutex); 181 new_dev->next = open_dags; 182 open_dags = new_dev; 183 pthread_mutex_unlock(&open_dag_mutex); 184 185 return new_dev; 186 } 187 188 189 static int dag_init_input(libtrace_t *libtrace) { 190 char *dag_dev_name = NULL; 191 char *scan = NULL; 192 int stream = 0; 193 struct dag_dev_t *dag_device = NULL; 194 195 if ((scan = strchr(libtrace->uridata,',')) == NULL) { 196 dag_dev_name = strdup(libtrace->uridata); 197 } else { 198 dag_dev_name = (char *)strndup(libtrace->uridata, 199 (size_t)(scan - libtrace->uridata)); 200 stream = atoi(++scan); 201 } 202 203 204 libtrace->format_data = (struct dag_format_data_t *) 205 malloc(sizeof(struct dag_format_data_t)); 206 207 /* For now, we don't offer the ability to select the stream */ 208 FORMAT_DATA->dagstream = stream; 209 210 dag_device = dag_find_open_device(dag_dev_name); 211 212 if (dag_device == NULL) { 213 /* Device not yet opened - open it ourselves */ 214 dag_device = dag_open_device(libtrace, dag_dev_name); 215 } else { 216 free(dag_dev_name); 217 dag_dev_name = NULL; 218 } 219 220 if (dag_device == NULL) { 221 if (dag_dev_name) 222 free(dag_dev_name); 223 return -1; 224 } 225 226 227 dag_device->ref_count ++; 107 228 108 229 DUCK.last_duck = 0; … … 110 231 DUCK.last_pkt = 0; 111 232 DUCK.dummy_duck = NULL; 233 FORMAT_DATA->device = dag_device; 112 234 FORMAT_DATA->stream_attached = 0; 113 235 FORMAT_DATA->drops = 0; … … 125 247 case TRACE_OPTION_SNAPLEN: 126 248 snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data); 127 if (dag_configure(FORMAT_DATA->fd, conf_str) != 0) { 249 if (dag_configure(FORMAT_DATA->device->fd, 250 conf_str) != 0) { 128 251 trace_set_err(libtrace, errno, "Failed to configure snaplen on DAG card: %s", libtrace->uridata); 129 252 return -1; … … 153 276 154 277 155 if (dag_attach_stream(FORMAT_DATA-> fd,278 if (dag_attach_stream(FORMAT_DATA->device->fd, 156 279 FORMAT_DATA->dagstream, 0, 0) < 0) { 157 280 trace_set_err(libtrace, errno, "Cannot attach DAG stream"); … … 159 282 } 160 283 161 if (dag_start_stream(FORMAT_DATA-> fd,284 if (dag_start_stream(FORMAT_DATA->device->fd, 162 285 FORMAT_DATA->dagstream) < 0) { 163 286 trace_set_err(libtrace, errno, "Cannot start DAG stream"); … … 166 289 FORMAT_DATA->stream_attached = 1; 167 290 /* We don't want the dag card to do any sleeping */ 168 dag_set_stream_poll(FORMAT_DATA-> fd,291 dag_set_stream_poll(FORMAT_DATA->device->fd, 169 292 FORMAT_DATA->dagstream, 0, &zero, 170 293 &nopoll); … … 173 296 174 297 do { 175 top = dag_advance_stream(FORMAT_DATA-> fd,298 top = dag_advance_stream(FORMAT_DATA->device->fd, 176 299 FORMAT_DATA->dagstream, 177 300 &bottom); … … 189 312 190 313 static int dag_pause_input(libtrace_t *libtrace) { 191 if (dag_stop_stream(FORMAT_DATA-> fd,314 if (dag_stop_stream(FORMAT_DATA->device->fd, 192 315 FORMAT_DATA->dagstream) < 0) { 193 316 trace_set_err(libtrace, errno, "Could not stop DAG stream"); 194 317 return -1; 195 318 } 196 if (dag_detach_stream(FORMAT_DATA-> fd,319 if (dag_detach_stream(FORMAT_DATA->device->fd, 197 320 FORMAT_DATA->dagstream) < 0) { 198 321 trace_set_err(libtrace, errno, "Could not detach DAG stream"); … … 206 329 if (FORMAT_DATA->stream_attached) 207 330 dag_pause_input(libtrace); 208 dag_close(FORMAT_DATA->fd); 331 FORMAT_DATA->device->ref_count --; 332 333 if (FORMAT_DATA->device->ref_count == 0) 334 dag_close_device(FORMAT_DATA->device); 209 335 if (DUCK.dummy_duck) 210 336 trace_destroy_dead(DUCK.dummy_duck); … … 231 357 /* No need to check if we can get DUCK or not - we're modern 232 358 * enough */ 233 if ((ioctl(FORMAT_DATA-> fd, DAGIOCDUCK, (duckinf_t *)packet->payload)234 359 if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK, 360 (duckinf_t *)packet->payload) < 0)) { 235 361 trace_set_err(libtrace, errno, "Error using DAGIOCDUCK"); 236 362 return -1; … … 251 377 if (diff >= dag_record_size && FORMAT_DATA->processed < 4 * 1024 * 1024) 252 378 return diff; 253 FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA-> fd,379 FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA->device->fd, 254 380 FORMAT_DATA->dagstream, 255 381 &(FORMAT_DATA->bottom)); … … 332 458 tv = trace_get_timeval(packet); 333 459 DUCK.last_pkt = tv.tv_sec; 334 DATA(libtrace)->drops += ntohs(erfptr->lctr); 460 461 /* No loss counter for DSM coloured records - have to use 462 * some other API */ 463 if (erfptr->type == TYPE_DSM_COLOR_ETH) { 464 465 } else { 466 DATA(libtrace)->drops += ntohs(erfptr->lctr); 467 } 335 468 return packet->payload ? htons(erfptr->rlen) : 336 469 erf_get_framing_length(packet); -
lib/format_erf.c
rf3f3558 r121b7e2 125 125 dag_record_t *erfptr = (dag_record_t *)packet->header; 126 126 switch(erfptr->type) { 127 case TYPE_ETH: return 2; 127 case TYPE_ETH: 128 case TYPE_DSM_COLOR_ETH: 129 return 2; 128 130 default: return 0; 129 131 } … … 131 133 else { 132 134 switch(trace_get_link_type(packet)) { 133 case T YPE_ETH:return 2;135 case TRACE_TYPE_ETH: return 2; 134 136 default: return 0; 135 137 } -
lib/linktypes.c
rdd06159 r121b7e2 126 126 case TYPE_ATM: return TRACE_TYPE_ATM; 127 127 case TYPE_AAL5: return TRACE_TYPE_AAL5; 128 case TYPE_DSM_COLOR_ETH:return TRACE_TYPE_ETH; 128 129 } 129 130 return ~0U;
Note: See TracChangeset
for help on using the changeset viewer.