Merge remote-tracking branch 'upstream/master' into polycube_on_bcc_v0.12.0

sebymiano · sebymiano · commit 117e319729ac · 2020-02-24T10:40:31.000+01:00
diff --git a/src/libs/polycube/CMakeLists.txt b/src/libs/polycube/CMakeLists.txt
@@ -2,6 +2,18 @@ add_subdirectory(src)
 
 configure_file(libpolycube.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libpolycube.pc @ONLY)
 
+# In order to use the TableDesc class inside the BaseCube and let Polycube services
+# to be compiled outside of the base polycube services location,
+# we need these BCC header files to be present on the host filesystem.
+# By copying these source files from the BCC submodule to /usr/include/polycube,
+# we ensure to have them updated to the last BCC submodule version used in polycube.
+file(COPY
+            ../bcc/src/cc/table_desc.h
+            ../bcc/src/cc/file_desc.h
+            ../bcc/src/cc/bcc_exception.h
+        DESTINATION
+            ${CMAKE_CURRENT_SOURCE_DIR}/include/polycube/services)
+
 install(DIRECTORY include/ DESTINATION /usr/include)
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpolycube.pc
diff --git a/src/libs/polycube/include/polycube/services/base_cube.h b/src/libs/polycube/include/polycube/services/base_cube.h
@@ -29,6 +29,7 @@
 #include "polycube/services/cube_iface.h"
 #include "polycube/services/table.h"
 #include "polycube/services/utils.h"
+#include "polycube/services/table_desc.h"
 
 namespace polycube {
 namespace service {
@@ -71,6 +72,9 @@ class BaseCube {
       const std::string &table_name, int index = 0,
       ProgramType type = ProgramType::INGRESS);
 
+  const ebpf::TableDesc &get_table_desc(const std::string &table_name, int index,
+                                     ProgramType type);
+                                     
   virtual void datapath_log_msg(const LogMsg *msg);
 
   void set_log_level(LogLevel level);
diff --git a/src/libs/polycube/include/polycube/services/cube.h b/src/libs/polycube/include/polycube/services/cube.h
@@ -77,6 +77,7 @@ Cube<PortType>::Cube(const nlohmann::json &conf,
 
     auto &p = *ports_by_id_.at(md->port_id);
     PacketInMetadata md_;
+    md_.traffic_class = md->traffic_class;
     md_.reason = md->reason;
     md_.metadata[0] = md->metadata[0];
     md_.metadata[1] = md->metadata[1];
diff --git a/src/libs/polycube/include/polycube/services/cube_factory.h b/src/libs/polycube/include/polycube/services/cube_factory.h
@@ -31,17 +31,20 @@ class TransparentCubeIface;
 enum class CubeType;
 
 struct PacketInMetadata {
+  uint32_t traffic_class;
   uint32_t reason;
   uint32_t metadata[3];
 };
 
 struct __attribute__((__packed__)) PacketIn {
-  uint16_t cube_id;    /**< Index of the Cube within the patchpanel */
-  uint16_t port_id;    /**< Port where the packet was received */
-  uint32_t packet_len; /**< Total length of the packet */
-  uint16_t reason;     /**< Internal code between dataplane and control plane */
-  uint32_t metadata[3]; /**< Buffer that can be used by the dataplane to send
-                           additional information to the control plane */
+  uint16_t cube_id;       /**< Index of the Cube within the patchpanel */
+  uint16_t port_id;       /**< Port where the packet was received */
+  uint32_t packet_len;    /**< Total length of the packet */
+  uint32_t traffic_class; /**< Traffic class the packet belongs to */
+  uint16_t reason;        /**< Internal code between dataplane and control
+                               plane */
+  uint32_t metadata[3];   /**< Buffer that can be used by the dataplane to send
+                               additional information to the control plane */
 };
 
 typedef std::function<void(const PacketIn *md,
diff --git a/src/libs/polycube/include/polycube/services/cube_iface.h b/src/libs/polycube/include/polycube/services/cube_iface.h
@@ -21,6 +21,7 @@
 #include "polycube/services/port_iface.h"
 #include "polycube/services/table.h"
 #include "polycube/services/types.h"
+#include "polycube/services/table_desc.h"
 
 #include <map>
 #include <string>
@@ -63,7 +64,9 @@ class BaseCubeIface {
   virtual uint16_t get_index(ProgramType type) const = 0;
   virtual int get_table_fd(const std::string &table_name, int index,
                            ProgramType type) = 0;
-
+  virtual const ebpf::TableDesc &get_table_desc(const std::string &table_name, int index,
+                                     ProgramType type) = 0;
+                                     
   virtual void set_log_level(LogLevel level) = 0;
   virtual LogLevel get_log_level() const = 0;
 
diff --git a/src/libs/polycube/src/base_cube.cpp b/src/libs/polycube/src/base_cube.cpp
@@ -43,6 +43,11 @@ int BaseCube::get_table_fd(const std::string &table_name, int index,
   return cube_->get_table_fd(table_name, index, type);
 }
 
+const ebpf::TableDesc &BaseCube::get_table_desc(const std::string &table_name, int index,
+                               ProgramType type) {
+  return cube_->get_table_desc(table_name, index, type);
+}
+
 void BaseCube::reload(const std::string &code, int index, ProgramType type) {
   cube_->reload(code, index, type);
 }
diff --git a/src/libs/polycube/src/transparent_cube.cpp b/src/libs/polycube/src/transparent_cube.cpp
@@ -35,6 +35,7 @@ TransparentCube::TransparentCube(const nlohmann::json &conf,
 
     Direction direction = static_cast<Direction>(md->port_id);
     PacketInMetadata md_;
+    md_.traffic_class = md->traffic_class;
     md_.reason = md->reason;
     md_.metadata[0] = md->metadata[0];
     md_.metadata[1] = md->metadata[1];
diff --git a/src/polycubectl/prettyprint.go b/src/polycubectl/prettyprint.go
@@ -296,6 +296,10 @@ func formatValue(data interface{}) string {
 	buf := ""
 	buf = fmt.Sprintf("%v", data)
 
+    if reflect.ValueOf(data).Kind() == reflect.String {
+        return buf
+    }
+
 	_, erri := strconv.ParseInt(buf, 10, 64)
 	if erri != nil {
 		f, errf := strconv.ParseFloat(buf, 64)
diff --git a/src/polycubed/src/base_cube.cpp b/src/polycubed/src/base_cube.cpp
@@ -140,6 +140,16 @@ int BaseCube::get_table_fd(const std::string &table_name, int index,
   }
 }
 
+const ebpf::TableDesc &BaseCube::get_table_desc(const std::string &table_name,
+                                         int index, ProgramType type) {
+  switch (type) {
+  case ProgramType::INGRESS:
+    return ingress_programs_[index]->get_table(table_name).getTableDescription();
+  case ProgramType::EGRESS:
+    return egress_programs_[index]->get_table(table_name).getTableDescription();
+  }
+}
+
 void BaseCube::reload(const std::string &code, int index, ProgramType type) {
   std::lock_guard<std::mutex> cube_guard(cube_mutex_);
   return do_reload(code, index, type);
@@ -422,9 +432,10 @@ enum {
 };
 
 struct pkt_metadata {
-  u16 cube_id;      //__attribute__((deprecated)) // use CUBE_ID instead
-  u16 in_port;      // The interface on which a packet was received.
-  u32 packet_len;   //__attribute__((deprecated)) // Use ctx->len
+  u16 cube_id;        //__attribute__((deprecated)) // use CUBE_ID instead
+  u16 in_port;        // The interface on which a packet was received.
+  u32 packet_len;     //__attribute__((deprecated)) // Use ctx->len
+  u32 traffic_class;  // The traffic class the packet belongs to
 
   // used to send data to controller
   u16 reason;
@@ -457,11 +468,19 @@ void call_ingress_program(struct CTXTYPE *skb, int index) {
   ingress_programs.call(skb, index);
 }
 
+static __always_inline
+void call_ingress_program_with_metadata(struct CTXTYPE *skb,
+                                        struct pkt_metadata *md, int index);
+
 static __always_inline
 void call_egress_program(struct CTXTYPE *skb, int index) {
   egress_programs.call(skb, index);
 }
 
+static __always_inline
+void call_egress_program_with_metadata(struct CTXTYPE *skb,
+                                       struct pkt_metadata *md, int index);
+
 /* checksum related */
 
 // those functions have different implementations for XDP and TC
diff --git a/src/polycubed/src/base_cube.h b/src/polycubed/src/base_cube.h
@@ -76,6 +76,8 @@ class BaseCube : virtual public BaseCubeIface {
   const Guid &uuid() const;
 
   int get_table_fd(const std::string &table_name, int index, ProgramType type);
+  const ebpf::TableDesc &get_table_desc(const std::string &table_name, int index,
+                             ProgramType type);
 
   void set_log_level(LogLevel level);
   LogLevel get_log_level() const;
diff --git a/src/polycubed/src/controller.cpp b/src/polycubed/src/controller.cpp
@@ -40,6 +40,7 @@ struct metadata {
   u16 cube_id;
   u16 port_id;
   u32 packet_len;
+  u32 traffic_class;
   u16 reason;
   u32 md[3];  // generic metadata
 } __attribute__((packed));
@@ -69,6 +70,7 @@ int controller_module_tx(struct __sk_buff *ctx) {
   md.cube_id = module_index;
   md.port_id = in_port;
   md.packet_len = ctx->len;
+  md.traffic_class = ctx->mark;
   md.reason = reason;
 
   x = ctx->cb[2];
@@ -173,6 +175,7 @@ struct pkt_metadata {
   u16 cube_id;
   u16 in_port;
   u32 packet_len;
+  u32 traffic_class;
 
   // used to send data to controller
   u16 reason;
@@ -199,6 +202,7 @@ int controller_module_tx(struct xdp_md *ctx) {
   md.cube_id = int_md->cube_id;
   md.in_port = int_md->in_port;
   md.packet_len = (u32)(data_end - data);
+  md.traffic_class = int_md->traffic_class;
   md.reason = int_md->reason;
 
   x = int_md->md[0];
@@ -239,6 +243,7 @@ struct pkt_metadata {
   u16 module_index;
   u16 in_port;
   u32 packet_len;
+  u32 traffic_class;
 
   // used to send data to controller
   u16 reason;
diff --git a/src/polycubed/src/cube_tc.cpp b/src/polycubed/src/cube_tc.cpp
@@ -245,6 +245,26 @@ int pcn_pkt_controller_with_metadata(struct CTXTYPE *skb,
   skb->cb[4] = metadata[2];
   return pcn_pkt_controller(skb, md, reason);
 }
+
+static __always_inline
+void call_ingress_program_with_metadata(struct CTXTYPE *skb,
+                                        struct pkt_metadata *md, int index) {
+  // Save the traffic class for the next program in case it was changed
+  // by the current one
+  skb->mark = md->traffic_class;
+
+  call_ingress_program(skb, index);
+}
+
+static __always_inline
+void call_egress_program_with_metadata(struct CTXTYPE *skb,
+                                       struct pkt_metadata *md, int index) {
+  // Save the traffic class for the next program in case it was changed
+  // by the current one
+  skb->mark = md->traffic_class;
+
+  call_egress_program(skb, index);
+}
 )";
 
 const std::string CubeTC::CUBETC_HELPERS = R"(
@@ -327,6 +347,7 @@ int handle_rx_wrapper(struct CTXTYPE *skb) {
   md.in_port = x >> 16;
   md.cube_id = CUBE_ID;
   md.packet_len = skb->len;
+  md.traffic_class = skb->mark;
   skb->cb[0] = md.in_port << 16 | CUBE_ID;
 
   // Check if the cube is shadow and the in_port has odd index
@@ -343,6 +364,10 @@ int handle_rx_wrapper(struct CTXTYPE *skb) {
 
   int rc = handle_rx(skb, &md);
 
+  // Save the traffic class for the next program in case it was changed
+  // by the current one
+  skb->mark = md.traffic_class;
+
   switch (rc) {
     case RX_REDIRECT:
       // FIXME: reason is right, we are reusing the field
diff --git a/src/polycubed/src/cube_xdp.cpp b/src/polycubed/src/cube_xdp.cpp
@@ -185,6 +185,30 @@ int pcn_pkt_controller_with_metadata(struct CTXTYPE *pkt, struct pkt_metadata *m
 
   return pcn_pkt_controller(pkt, md, reason);
 }
+
+static __always_inline
+void call_ingress_program_with_metadata(struct CTXTYPE *skb,
+                                        struct pkt_metadata *md, int index) {
+  u32 inport_key = 0;
+
+  // Save the metadata for the next program in case they were changed by the
+  // current one
+  port_md.update(&inport_key, md);;
+
+  call_ingress_program(skb, index);
+}
+
+static __always_inline
+void call_egress_program_with_metadata(struct CTXTYPE *skb,
+                                       struct pkt_metadata *md, int index) {
+  u32 inport_key = 0;
+
+  // Save the metadata for the next program in case they were changed by the
+  // current one
+  port_md.update(&inport_key, md);;
+
+  call_egress_program(skb, index);
+}
 )";
 
 const std::string CubeXDP::CUBEXDP_WRAPPER = R"(
@@ -198,9 +222,14 @@ int handle_rx_xdp_wrapper(struct CTXTYPE *ctx) {
     md.cube_id = CUBE_ID;
     md.in_port = int_md->in_port;
     md.packet_len = int_md->packet_len;
+    md.traffic_class = int_md->traffic_class;
 
     int rc = handle_rx(ctx, &md);
 
+    // Save the traffic class for the next program in case it was changed
+    // by the current one
+    int_md->traffic_class = md.traffic_class;
+
     switch (rc) {
     case RX_DROP:
       return XDP_DROP;
diff --git a/src/polycubed/src/extiface_xdp.cpp b/src/polycubed/src/extiface_xdp.cpp
@@ -80,6 +80,7 @@ struct pkt_metadata {
   u16 module_index;
   u16 in_port;
   u32 packet_len;
+  u32 traffic_class;
   // used to send data to controller
   u16 reason;
   u32 md[3];
diff --git a/src/polycubed/src/polycubed.cpp b/src/polycubed/src/polycubed.cpp
@@ -274,14 +274,15 @@ int main(int argc, char *argv[]) {
 
   // setup rest server
   int thr = 4;
+  size_t max_payload_size = 1024*1024; // 1MB
   Address addr(config.getServerIP(), Pistache::Port(config.getServerPort()));
 
   // logger->info("Cores = {0}", hardware_concurrency());
   // logger->info("Using {0} threads", thr);
 
   // start rest server
   restserver = new RestServer(addr, *core);
-  restserver->init(thr, config.getCertPath(), config.getKeyPath(),
+  restserver->init(thr, max_payload_size, config.getCertPath(), config.getKeyPath(),
                    config.getCACertPath(), config.getCertWhitelistPath(),
                    config.getCertBlacklistPath());
   core->set_rest_server(restserver);
diff --git a/src/polycubed/src/rest_server.cpp b/src/polycubed/src/rest_server.cpp
@@ -116,15 +116,19 @@ int RestServer::client_verify_callback(int preverify_ok, void *ctx) {
   return preverify_ok;
 }
 
-void RestServer::init(size_t thr, const std::string &server_cert,
+void RestServer::init(size_t thr,
+                      size_t max_payload_size,
+                      const std::string &server_cert,
                       const std::string &server_key,
                       const std::string &root_ca_cert,
                       const std::string &whitelist_cert_path_,
                       const std::string &blacklist_cert_path_) {
   logger->debug("rest server will use {0} thread(s)", thr);
-  auto opts = Pistache::Http::Endpoint::options().threads(thr).flags(
-      Pistache::Tcp::Options::InstallSignalHandler |
-      Pistache::Tcp::Options::ReuseAddr);
+  auto opts = Pistache::Http::Endpoint::options()
+                  .threads(thr)
+                  .maxPayload(max_payload_size)
+                  .flags(Pistache::Tcp::Options::InstallSignalHandler |
+                         Pistache::Tcp::Options::ReuseAddr);
   httpEndpoint_->init(opts);
 
   if (!server_cert.empty()) {
diff --git a/src/polycubed/src/rest_server.h b/src/polycubed/src/rest_server.h
@@ -52,7 +52,9 @@ class RestServer {
 
   static const std::string base;
 
-  void init(size_t thr = 1, const std::string &server_cert = "",
+  void init(size_t thr = 1,
+            size_t max_payload_size = 64*1024,
+            const std::string &server_cert = "",
             const std::string &server_key = "",
             const std::string &root_ca_cert = "",
             const std::string &white_cert_list_path = "",
diff --git a/src/polycubed/src/transparent_cube_tc.cpp b/src/polycubed/src/transparent_cube_tc.cpp
@@ -93,8 +93,14 @@ const std::string TransparentCubeTC::TRANSPARENTCUBETC_WRAPPER = R"(
 int handle_rx_wrapper(struct CTXTYPE *skb) {
   struct pkt_metadata md = {};
   md.packet_len = skb->len;
+  md.traffic_class = skb->mark;
+  
   int rc = handle_rx(skb, &md);
 
+  // Save the traffic class for the next program in case it was changed
+  // by the current one
+  skb->mark = md.traffic_class;
+
   switch (rc) {
     case RX_DROP:
       return TC_ACT_SHOT;
diff --git a/src/polycubed/src/transparent_cube_xdp.cpp b/src/polycubed/src/transparent_cube_xdp.cpp
diff --git a/src/services/pcn-packetcapture/client/packetcapture.py b/src/services/pcn-packetcapture/client/packetcapture.py

Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,11 @@ int BaseCube::get_table_fd(const std::string &table_name, int index,`
`43`	`43`	`return cube_->get_table_fd(table_name, index, type);`
`44`	`44`	`}`
`45`	`45`
	`46`	`+const ebpf::TableDesc &BaseCube::get_table_desc(const std::string &table_name, int index,`
	`47`	`+ ProgramType type) {`
	`48`	`+ return cube_->get_table_desc(table_name, index, type);`
	`49`	`+}`
	`50`	`+`
`46`	`51`	`void BaseCube::reload(const std::string &code, int index, ProgramType type) {`
`47`	`52`	`cube_->reload(code, index, type);`
`48`	`53`	`}`