Ilias Apalodimas(apalos) replied on github web page:
platform/linux-generic/odp_packet_io.c
line 237
@@ -89,6 +96,274 @@ int odp_pktio_init_local(void)
return odp_pktio_ops_init_local(true);
}
+static int write_pcapng_hdr(pktio_entry_t *entry, int qidx)
+{
+ size_t len;
+ pcapng_section_hdr_block_t shb;
+ pcapng_interface_description_block_s idb;
+ int fd = entry->s.pcapng_info.pcapng_fd[qidx];
+
+ memset(&shb, 0, sizeof(shb));
+ memset(&idb, 0, sizeof(idb));
+
+ shb.block_type = PCAPNG_BLOCK_TYPE_SHB;
+ shb.block_total_length = sizeof(shb);
+ shb.block_total_length2 = sizeof(shb);
+ shb.magic = PCAPNG_ENDIAN_MAGIC;
+ shb.version_major = 0x1;
+ shb.version_minor = 0x0;
+ shb.section_len = -1;
+
+ len = write(fd, &shb, sizeof(shb));
+ fsync(fd);
+ /* fail to write shb/idb means the pcapng is unreadable */
+ if (!len) {
+ ODP_ERR("Failed to write pcapng section hdr\n");
+ close(fd);
+ return -1;
+ }
+
+ idb.block_type = PCAPNG_BLOCK_TYPE_IDB;
+ idb.block_total_length = sizeof(idb);
+ idb.block_total_length2 = sizeof(idb);
+ idb.linktype = 0x1; /* LINKTYPE_ETHERNET */
+ idb.snaplen = 0x0; /* unlimited */
+ len = write(fd, &idb, sizeof(idb));
+ if (!len) {
+ ODP_ERR("Failed to write pcapng interface description\n");
+ close(fd);
+ return -1;
+ }
+ fsync(fd);
+
+ entry->s.pcapng_info.state[qidx] = PCAPNG_WR_HDR;
+
+ return 0;
+}
+
+static int write_pcapng_pkts(pktio_entry_t *entry, int qidx,
+ const odp_packet_t packets[], int num)
+{
+ int i = 0;
+ struct iovec packet_iov[3 * num];
+ pcapng_enhanced_packet_block_t epb;
+ int iovcnt = 0;
+ ssize_t len = 0;
+ int fd = entry->s.pcapng_info.pcapng_fd[qidx];
+
+ for (i = 0; i < num; i++) {
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(packets[i]);
+ uint32_t pkt_len = _odp_packet_len(packets[i]);
+ char *buf = (char *)odp_packet_data(packets[i]);
+
+ epb.block_type = PCAPNG_BLOCK_TYPE_EPB;
+ epb.block_total_length = sizeof(epb) +
+ ROUNDUP_ALIGN(pkt_len, PCAP_DATA_ALIGN) +
+ PCAP_DATA_ALIGN;
+ epb.interface_idx = 0;
+ epb.timestamp_high = (uint32_t)(pkt_hdr->timestamp.u64 >> 32);
+ epb.timestamp_low = (uint32_t)(pkt_hdr->timestamp.u64);
+ epb.captured_len = pkt_len;
+ epb.packet_len = pkt_len;
+
+ /* epb */
+ packet_iov[iovcnt].iov_base = &epb;
+ packet_iov[iovcnt].iov_len = sizeof(epb);
+ iovcnt++;
+
+ /* data */
+ packet_iov[iovcnt].iov_base = buf;
+ packet_iov[iovcnt].iov_len =
+ ROUNDUP_ALIGN(pkt_len, PCAP_DATA_ALIGN);
+ iovcnt++;
+
+ /* trailing */
+ packet_iov[iovcnt].iov_base = &epb.block_total_length;
+ packet_iov[iovcnt].iov_len = sizeof(uint32_t);
+ iovcnt++;
+ }
+
+ /* we don't really care if we manage to write *all* data */
+ len = writev(fd, packet_iov, iovcnt);
+ if (!len)
+ ODP_ERR("Failed to write pcapng data\n");
+ fsync(fd);
+
+ return len;
+}
+
+static void pcapng_drain_fifo(int fd)
+{
+ char c;
+ ssize_t len;
+
+ do {
+ len = read(fd, &c, sizeof(c));
+ } while (len > 0 && len != -1);
+ ODP_DBG("Drain pcap fifo %d\n", len);
+}
+
+static void *inotify_update(void *arg)
+{
+ pktio_entry_t *entry = (pktio_entry_t *)arg;
+ struct timeval time;
+ int ret;
+ ssize_t rdlen;
+ int i;
+ char buffer[INOTIFY_BUF_LEN];
+ unsigned int max_queue =
+ MAX(entry->s.num_in_queue, entry->s.num_out_queue);
+ fd_set rfds;
+
+ while (1) {
+ i = 0;
+ FD_ZERO(&rfds);
+ FD_SET(entry->s.pcapng_info.inotify_pcapng_fd, &rfds);
+ time.tv_sec = 2;
+ time.tv_usec = 0;
+ select(entry->s.pcapng_info.inotify_pcapng_fd + 1, &rfds, NULL,
+ NULL, &time);
+ if (FD_ISSET(entry->s.pcapng_info.inotify_pcapng_fd, &rfds)) {
+ rdlen = read(entry->s.pcapng_info.inotify_pcapng_fd,
+ buffer, INOTIFY_BUF_LEN);
+ while (i < rdlen) {
+ char *e;
+ unsigned int qidx;
+ struct inotify_event *event =
+ (struct inotify_event *)(void *)
+ &buffer[i];
+
+ e = strrchr(event->name, '-');
+ e++;
+ if (!e)
+ continue;
+ qidx = atoi(e);
+ if (qidx > max_queue) {
+ ODP_ERR("Invalid queue number\n");
+ i += INOTIFY_EVENT_SIZE + event->len;
+ continue;
+ }
+
+ if (entry->s.pcapng_info.state[qidx] ==
+ PCAPNG_WR_INVALID)
+ continue;
+
+ if (event->mask & IN_OPEN) {
+ int fd =
entry->s.pcapng_info.pcapng_fd[qidx];
+
+ pcapng_drain_fifo(fd);
+ ret = write_pcapng_hdr(entry, i);
+ if (ret)
+
entry->s.pcapng_info.state[qidx] =
+ PCAPNG_WR_STOP;
+ else
+
entry->s.pcapng_info.state[qidx] =
+ PCAPNG_WR_PKT;
+ ODP_DBG("Open %s for pcap tracing\n",
+ event->name);
+ } else if (event->mask & IN_CLOSE) {
+ entry->s.pcapng_info.state[qidx] =
+ PCAPNG_WR_STOP;
+ ODP_DBG("Close %s for pcap tracing\n",
+ event->name);
+ } else {
+ ODP_ERR("Unknown inotify event
0x%08x\n",
+ event->mask);
+ }
+ i += INOTIFY_EVENT_SIZE + event->len;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static void pcapng_destroy(pktio_entry_t *entry)
+{
+ int ret;
+ unsigned int i;
+ unsigned int max_queue =
+ MAX(entry->s.num_in_queue, entry->s.num_out_queue);
+
+ ret = pthread_cancel(entry->s.pcapng_info.inotify_thread);
+ if (ret)
+ ODP_ERR("can't cancel inotify thread %s\n", strerror(errno));
+
+ /* fd's will be -1 in case of any failure */
+ ret = inotify_rm_watch(entry->s.pcapng_info.inotify_pcapng_fd,
+ entry->s.pcapng_info.inotify_watch_fd);
+ if (ret)
+ ODP_ERR("can't deregister inotify %s\n", strerror(errno));
+
+ close(entry->s.pcapng_info.inotify_pcapng_fd);
+
+ for (i = 0; i < max_queue; i++) {
+ entry->s.pcapng_info.state[i] = PCAPNG_WR_INVALID;
+ close(entry->s.pcapng_info.pcapng_fd[i]);
+ }
+}
+
+static int pcapng_prepare(pktio_entry_t *entry)
+{
+ int ret = -1, fd;
+ pthread_attr_t attr;
+ unsigned int i;
+ unsigned int max_queue =
+ MAX(entry->s.num_in_queue, entry->s.num_out_queue);
+
+ for (i = 0; i < max_queue; i++) {
+ char pcap_entry[256];
+
+ snprintf(pcap_entry, sizeof(pcap_entry),
+ "%s/%s-flow-%d", PCAPNG_WATCH_DIR, entry->s.name, i);
Comment:
will update
> Ilias Apalodimas(apalos) wrote:
> This essentially "reads" the inotify triggers for opening/closing the fifos
> and sets the appropriate variables for starting/stopping the pcapng dump on
> fifos. Will try to make it easier to read on the final PR
>> Ilias Apalodimas(apalos) wrote:
>> will fix
>>> Ilias Apalodimas(apalos) wrote:
>>> will fix
>>>> Ilias Apalodimas(apalos) wrote:
>>>> I'll check and update for the final PR
>>>>> Bill Fischofer(Bill-Fischofer-Linaro) wrote:
>>>>> General cleanup should be part of `odp_term_global()` processing.
>>>>> Presumably `odp_pktio_close()` should also do cleanup for specific pktios.
>>>>>> Bill Fischofer(Bill-Fischofer-Linaro) wrote:
>>>>>> A few comments about what this routine is doing would be very helpful
>>>>>> here. This is not easy code to follow. Modularizing it into some
>>>>>> `static inline` helpers might also make the logic simpler.
>>>>>>> Bill Fischofer(Bill-Fischofer-Linaro) wrote:
>>>>>>> This is redundant. If `len > 0` then by definition `len != -1`.
>>>>>>>> Bill Fischofer(Bill-Fischofer-Linaro) wrote:
>>>>>>>> This fails for multi-segment packets. `odp_packet_data(pkt)` is
>>>>>>>> shorthand for `odp_packet_offset(pkt, 0, NULL, NULL)` so you don't
>>>>>>>> know how long the first segment really is. First cut would be to only
>>>>>>>> dump the first segment, so correct code is:
>>>>>>>> ```
>>>>>>>> uint32_t seg_len;
>>>>>>>> char *buf = (char *)odp_packet_offset(packets[i], 0, &seg_len, NULL);
>>>>>>>> ```
>>>>>>>> And use `seg_len` rather than `pkt_len` in this routine.
>>>>>>>>> Bill Fischofer(Bill-Fischofer-Linaro) wrote:
>>>>>>>>> Does pcapng not supply a `.h` file for these "magic numbers" and
>>>>>>>>> associated structs?
>>>>>>>>>> Ilias Apalodimas(apalos) wrote:
>>>>>>>>>> Will fix. This will also remove the requirement of manually deleting
>>>>>>>>>> the fifos
>>>>>>>>>>> muvarov wrote
>>>>>>>>>>> odp_global_data_s->main_pid needs to be here.
https://github.com/Linaro/odp/pull/435#discussion_r165572186
updated_at 2018-02-02 07:15:58
