Use user memory for user packets

kernel/include/net/network.hpp

@@ -100,9 +100,9 @@ int64_t listen(size_t socket_fd, bool listen);
 /*!
  * \brief Wait for a packet
  * \param socket_fd The file descriptor of the packet
- * \return a tuple containing the packet index and payload
+ * \return the packet index
  */
-std::tuple<int64_t, char*> wait_for_packet(size_t socket_fd);
+int64_t wait_for_packet(char* buffer, size_t socket_fd);
 
 } // end of network namespace
 

kernel/src/net/network.cpp

@@ -39,7 +39,7 @@ void rx_thread(void* data){
 
         auto packet = interface.rx_queue.pop();
         network::ethernet::decode(interface, packet);
-        delete[] packet.payload;
+        //delete[] packet.payload;
     }
 }
 
@@ -230,15 +230,15 @@ int64_t network::listen(size_t socket_fd, bool listen){
     return 0;
 }
 
-std::tuple<int64_t, char*> network::wait_for_packet(size_t socket_fd){
+int64_t network::wait_for_packet(char* buffer, size_t socket_fd){
     if(!scheduler::has_socket(socket_fd)){
-        return {-std::ERROR_SOCKET_INVALID_FD, nullptr};
+        return -std::ERROR_SOCKET_INVALID_FD;
     }
 
     auto& socket = scheduler::get_socket(socket_fd);
 
     if(!socket.listen){
-        return {-std::ERROR_SOCKET_NOT_LISTEN, nullptr};
+        return -std::ERROR_SOCKET_NOT_LISTEN;
     }
 
     if(socket.listen_packets.empty()){
@@ -246,5 +246,7 @@ std::tuple<int64_t, char*> network::wait_for_packet(size_t socket_fd){
     }
 
     auto packet = socket.listen_packets.pop();
-    return {packet.index, packet.payload};
+    std::copy_n(packet.payload, packet.payload_size, buffer);
+    //TODO At this point we leak the memory of the packets
+    return packet.index;
 }

kernel/src/system_calls.cpp

@@ -382,14 +382,12 @@ void sc_listen(interrupt::syscall_regs* regs){
 
 void sc_wait_for_packet(interrupt::syscall_regs* regs){
     auto socket_fd = regs->rbx;
-    auto listen = bool(regs->rcx);
+    auto user_buffer = reinterpret_cast<char*>(regs->rcx);
 
-    int64_t index;
+    auto index = network::wait_for_packet(user_buffer, socket_fd);
-    char* buffer;
-    std::tie(index, buffer) = network::wait_for_packet(socket_fd);
 
     regs->rax = index;
-    regs->rbx = reinterpret_cast<size_t>(buffer);
+    regs->rbx = reinterpret_cast<size_t>(user_buffer);
 }
 
 } //End of anonymous namespace

programs/ping/src/main.cpp

@@ -79,6 +79,8 @@ int main(int argc, char* argv[]) {
         tlib::printf("reply received from %s\n", ip.c_str());
     }
 
+    tlib::release_packet(*p);
+
     status = tlib::listen(*socket, false);
     if (!status) {
         tlib::printf("ping: listen error: %s\n", std::error_message(status.error()));

tlib/include/tlib/net.hpp

@@ -30,6 +30,7 @@ std::expected<packet> prepare_packet(size_t socket_fd, void* desc);
 std::expected<void> finalize_packet(size_t socket_fd, packet p);
 std::expected<void> listen(size_t socket_fd, bool l);
 std::expected<packet> wait_for_packet(size_t socket_fd);
+void release_packet(packet& packet);
 
 } // end of namespace tlib
 

tlib/src/net.cpp

@@ -83,14 +83,17 @@ std::expected<void> tlib::listen(size_t socket_fd, bool l){
 }
 
 std::expected<tlib::packet> tlib::wait_for_packet(size_t socket_fd){
+    auto buffer = malloc(2048);
+
     int64_t code;
     uint64_t payload;
-    asm volatile("mov rax, 0x3005; mov rbx, %[socket]; int 50; mov %[code], rax; mov %[payload], rbx;"
+    asm volatile("mov rax, 0x3005; mov rbx, %[socket]; mov rcx, %[buffer]; int 50; mov %[code], rax; mov %[payload], rbx;"
         : [payload] "=m" (payload), [code] "=m" (code)
-        : [socket] "g" (socket_fd)
+        : [socket] "g" (socket_fd), [buffer] "g" (reinterpret_cast<size_t>(buffer))
         : "rax", "rbx", "rcx");
 
     if(code < 0){
+        free(buffer);
         return std::make_expected_from_error<packet, size_t>(-code);
     } else {
         tlib::packet p;
@@ -99,3 +102,9 @@ std::expected<tlib::packet> tlib::wait_for_packet(size_t socket_fd){
         return std::make_expected<packet>(p);
     }
 }
+
+void tlib::release_packet(packet& packet){
+    if(packet.payload){
+        free(packet.payload);
+    }
+}