timestamp of the IP packet acquired in the fast path

Author: DavideAG

src/services/pcn-packetcapture/src/Packetcapture.cpp

@@ -21,12 +21,16 @@
 #include <iostream>
 #include <ctime>
 #include <fstream>
+#include <chrono>
 #include "unistd.h"
 #include "Packetcapture.h"
 #include "Packetcapture_dp_ingress.h"
 #include "Packetcapture_dp_egress.h"
 #define ON_T 0
 #define OFF_T 1
+#define BILLION 1000000000
+#define MILLION 1000000
+#define ONE_THOUSAND 1000
 
 
 typedef int bpf_int32; 
@@ -52,6 +56,14 @@ struct pcap_pkthdr {
 Packetcapture::Packetcapture(const std::string name, const PacketcaptureJsonObject &conf)
   : TransparentCube(conf.getBase(), { packetcapture_code_ingress }, { packetcapture_code_egress }),
     PacketcaptureBase(name) {
+  
+  gettimeofday(&ts, NULL);              //getting actual time
+  std::uint64_t uptime = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+  time_t sec_off = uptime / BILLION;
+  ts.tv_sec -= sec_off;
+  uptime -= sec_off * BILLION;
+  ts.tv_usec -= uptime;
+
   logger()->info("Creating Packetcapture instance");
     setCapture(conf.getCapture());
     setAnomimize(conf.getAnomimize());
@@ -79,7 +91,6 @@ void Packetcapture::writeDump(const std::vector<uint8_t> &packet){
 
   PacketJsonObject pj;
   auto p = std::shared_ptr<Packet>(new Packet(*this, pj));
-  struct timeval tp;
   std::streamsize len;
 
   if (dt == "") {
@@ -105,7 +116,17 @@ void Packetcapture::writeDump(const std::vector<uint8_t> &packet){
     myFile.write(reinterpret_cast<const char*>(pcap_header), sizeof(*pcap_header));
     writeHeader = false;
   }
-  gettimeofday(&tp, NULL);
+  struct timeval tp;
+  tp.tv_sec = ts.tv_sec;
+  tp.tv_usec = ts.tv_usec;
+  time_t sec_off = temp_offset/BILLION;     /* from nanoseconds to seconds */
+  temp_offset -= sec_off*BILLION;
+  tp.tv_usec += temp_offset/ONE_THOUSAND;   /* from nanoseconds to microseconds */
+  tp.tv_sec += sec_off;
+  sec_off = tp.tv_usec/MILLION;             /* from microseconds to seconds */
+  tp.tv_usec -= sec_off*MILLION;
+  tp.tv_sec += sec_off;
+
   p->setTimestampSeconds((uint32_t) tp.tv_sec);
   p->setTimestampMicroseconds((uint32_t) tp.tv_usec);
   p->setPacketlen((uint32_t) packet.size());
@@ -140,13 +161,15 @@ void Packetcapture::packet_in(polycube::service::Direction direction,
 
   switch (direction) {
     case polycube::service::Direction::INGRESS:
+    temp_offset = get_array_table<uint64_t>("packet_timestamp", 0, ProgramType::INGRESS).get(0x0);    
     if (getNetworkmode() == true) {
       addPacket(packet);    /* store the packet in the FIFO queue*/
     } else {
       writeDump(packet);
     }
     break;
     case polycube::service::Direction::EGRESS:
+    temp_offset = get_array_table<uint64_t>("packet_timestamp", 0, ProgramType::EGRESS).get(0x0);
     if (getNetworkmode() == true) {
       addPacket(packet);    /* store the packet in the FIFO queue*/
     } else {

src/services/pcn-packetcapture/src/Packetcapture.h

@@ -44,6 +44,8 @@ class Packetcapture : public PacketcaptureBase {
  bool writeHeader;
  std::ofstream myFile;
  std::string dt;
+ struct timeval ts;
+ uint64_t temp_offset;
 
   void addPacket(const std::vector<uint8_t> &packet);
 

src/services/pcn-packetcapture/src/Packetcapture_dp_egress.c

@@ -77,6 +77,11 @@ struct packetHeaders {
  */
 BPF_ARRAY(pkt_header, struct packetHeaders, 1);
 
+/*
+ * BPF map where a single element, packet timestamp
+ */
+BPF_ARRAY(packet_timestamp, uint64_t, 1);
+
 /*
  * BPF map where a single element, working mode [ON | OFF]
  */
@@ -193,6 +198,13 @@ static __always_inline int handle_rx(struct CTXTYPE *ctx, struct pkt_metadata *m
 
   }
 
+  /* Getting packet timestamp */
+  uint64_t *pkt_timestamp = packet_timestamp.lookup(&key);
+  if (!pkt_timestamp){
+      return RX_DROP;
+  }
+  *pkt_timestamp = bpf_ktime_get_ns();
+
   /*TODO: Now the traffic will be sent to the controller and will be processed in the slow path.
    *      This solution will have a big impact on performance.
    *      Currently, non-IP traffic is also sent to the controller, if this type of traffic is to be excluded

src/services/pcn-packetcapture/src/Packetcapture_dp_ingress.c

@@ -77,6 +77,11 @@ struct packetHeaders {
  */
 BPF_ARRAY(pkt_header, struct packetHeaders, 1);
 
+/*
+ * BPF map where a single element, packet timestamp
+ */
+BPF_ARRAY(packet_timestamp, uint64_t, 1);
+
 /*
  * BPF map where a single element, working mode [ON | OFF]
  */
@@ -186,7 +191,14 @@ static __always_inline int handle_rx(struct CTXTYPE *ctx, struct pkt_metadata *m
     }
 
   }
-
+  
+  /* Getting packet timestamp */
+  uint64_t *pkt_timestamp = packet_timestamp.lookup(&key);
+  if (!pkt_timestamp){
+      return RX_DROP;
+  }
+  *pkt_timestamp = bpf_ktime_get_ns();
+  
   /*TODO: Now the traffic will be sent to the controller and will be processed in the slow path.
    *      This solution will have a big impact on performance.
    *      Currently, non-IP traffic is also sent to the controller, if this type of traffic is to be excluded