libioth
Davoli, Renzo
Goldweber, Mikey
Microkernels, partial virtual machines and internet of threads are not unrelated. The challenge of this talk is to show that the new libioth providing an effective and flexible support for the internet of threads can open interesting perspectives for a wider range of applications. A network protocol stack can be implemented as a library. There are several examples: lwip/lwipv6, picoxnet, lkl. These libraries can be used to implement processes connected as network nodes (the so called "Internet of Thread" processes) or to implement network protocol stack servers for microkernels. The main goal of libioth is to provide a convenient API to interoperate with different network stack implementations. Libioth is also an infrastructure where the actual implementations can be loaded as plug-ins. Libioth's API is minimal: it includes the complete set of Berkeley Sockets functions, some functions to add or delete a stack and 'msocket', an extended version of 'socket' providing one more leading argument to select which stack should manage the communication. Libioth does not provide in its API any specific function to set up the network configuration, e.g. to configure the IP addresses/routes etc. These features are provided through netlink (see RFC3549). "nlinline" is a simple and effective set of inline functions to manage the network configuration. The data link layer infratructure used by libioth is VDE, Virtual Distributed Ethernet. Although libioth has been primarily designed for the Internet of Threads, the way it is used in the vunetioth module of vuos has many similarities with the network protocol stack servers for the microkernels. Several concepts and many building blocks of libioth can be useful in microkernel development. The design of the minimal API itself can be used to reuse existing stack implementations in network protocol stack servers. Libnlq (a sibling project of libioth) is a library able to process netlink requests, and can be used to add the netlink support to those stack implementations providing configuration through a custom specific API.
 Good morning. My name is Reynzo Davoli. I'm my affiliation is the University of Bologna. This is a joint work with the Virtusqr team, which is an international group working on virtualization. And my co-author is Michael Kulweber, who is at the Soviet University of Cincinnati, Ohio, USA. It's a pleasure to be here at FOSTA again, also in this online format, new format for the pandemic disease. This talk would be about Libyat, a library providing, I say, a definitive API for the Internet of Threads. The attempt of this talk is to make some concept closer, so to contaminate knowledge coming from different groups, from different experience, like those talking about virtualization, namespaces, microcarnals, networking, and so on. The concept of Internet of Threads is not a novel one. I introduced the term Internet of Threads back in 2012 here at FOSTA. And I used this kind of metaphor. So a telephone line, if it's a fixed telephone line, is related to a place, to a room. So it is common to dial a number and ask, is there Mario at home? Because we have not dialed Mario's number, but Mario's house number. Instead nowadays using portable mobile phones, we can reach directly people, because it's common to have portable phone sets associated one to one to two people. So one person to one, portable phone to one number. So it's easier to get in touch with a specific person. Relating this concept to the Internet, we have to consider what's the end point of an Internet connection. So what is addressed by an IP address? The original design of the Internet, the end points were hardware controllers. So each hardware controller had its own IP address. Now maybe this constraint has been a bit lighter, because we have namespace, virtual machines, but we are still addressing virtual interfaces of the counterpart of the ancient hosts. It would be more consistent, so more efficient to have IP addresses assigned to processes, threads, because the idea is that likewise with portable phones, we wanted to talk with a specific person, now we want to reach a specific service. So the idea is that if you have an IP address assigned to a process, it's easier to get in touch with that specific service. Actually, as you can see in the previous slide, there is a difference in the idea of IP address, because IPv4 provides a very limited number of addresses, so it's unrealistic to think to give IP addresses to each process or to each thread. But talking about IPv6 addresses, the range, the other space is so large that it is a viable solution. So we can talk from one side to Internet of Threads, IOS, on the other side there is a funny acronym, Internet of Legacy Devices, so we can talk about Iold, which gives the idea of what is old and what is new. Let me tell you a story about my childhood, about a juvenile stress I had. It happened that I had two different building sets when I was a child, and they were incompatible. And it was stressful, because it was hard to build constructions, including building sets, building blocks from both sets. So maybe from this being, now I am a computer scientist, and I want to have everything compatible and each block may be integrated with the others. So the idea is partial virtual machine Internet of Threads microcarnes, build blocks, like the ones of the different building sets. The idea of this talk is to provide means to make them compatible and integrateables. We are what we have in common, for sure we are all against monolithic implementations, we want to create so blocks. The common call is to create independent code implementing services, so the idea is the idea of these blocks. The basic block we are talking about in this speech is a TCP-IP stack. It's a block, it's a given OSI model, it's composed by two layers, network and transport. So it can be seen as a block which has two interfaces to the outside world, one in the upper side, the API to the application layer, and one to the data link layer. The idea here, the idea of this talk, it was to see if there is a well-defined set of APIs to the upper layer, to the lower layer, that makes this block a very useful block exploitable in many situations. So what does it matter with microcarnals? This block could be used inside user processes, so we can pick it back, the TCP-IP stack in the user process, and then we can deal with a server, the data link network server, in the meaning of server of microcarnals, so we can have the TCP-IP stack as a library inside the user process. So this is a way in which we can use this element in the idea of microcarnals, but we can also think to a TCP-IP process embedding this TCP-IP stack, and what is new, that this concept about lib-iOS makes this standard, and then different implementations can be loaded inside this block that in this way becomes a general-purpose TCP-IP stack block. So given that the problem is to provide an API or rather two APIs in the way that this API must be complete, usable and minimal, what can we talk about, how can we design this API to the app player? So just to resume which are the goals, it must be complete, so it must provide all the operations currently available, and I add that this services should be provided in already known mannerings so that existing code could be easily ported to the new environment. Usable, so the syntax function consists of a bunch of standards and minimal, so we need to avoid duplicate operations, we need to have this interface as simple as possible. Given this API, which are the requirements, from one way we have to provide cause function for configuration, more specifically to create or delete stack instances and to configure parameters, so we need to have entries to create a stack to provide IP addresses, parameters for the interfaces, routing definitions, before using the stack for communicating. At the end, or if you want to change the stack we used, we need to have a call to delete the stack. When the stack is configured, the stack can be used for communicating, so we have to open, close communication and points, send, receive, pack, set options and so on. Let us have a closer look to the Libyous design. This is a very common case, we decided to use a structure, a programming structure, a C structure and a pack structure. At the user level it is just a pointer, like the file all capital letters for the Libyous C when we use fopen. We use this as the identifier of a stack, so the way to open to create a stack is Ios NeoStack. The first parameter is the implementation, so the actual stack implementation will be loaded as a plugin, so we can use this API for several implementations. The second option, the second parameter, is the virtual network locator, because we use the lowest API, the API to the data link layer, VDE, virtual distributed data net, and given that the most common case is to have one stack with one interface, provided we are talking about processes using directed networking, the simplest call is NeoStack, but the most common factor, in some cases you may need to have several interfaces, those that are calls, there are new stack L and new stack V, the syntax is similar to exact L, exact V, that provides the programmer with means to create several interfaces stacks. The counterpart of NeoStack is DelStack. Then for communication, for communication there is a well known standard, the difference between Ios, Libyous, and the standard networking is that in monolithic kernels it is common to have the networking provided by the kernel, so the configuration is carried out by commons, there is not an API for configuration, while it is common to have the communication API, Verkissockets is a very common API for communication using TCP-IP stacks, so the only difference between Ios and Verkissockets is Msockets, because when one creates a communication endpoint using socket, it implicitly is talking about the kernel stack, now we have several stacks, so socket is not enough, we need Msockets with extra heading argument, which is the structure Ios, so they identify all the stack, apart from this, all the other Verkissockets entries are then implemented keeping the same signature and functionalities, so the semantics of all these entries is the same. What's this mean thing? We have talked about creating and deleting stacks, how to communicate, now the problem is how can we configure the stack, I mean add IP addresses, bring an interface up and down, set the routes, that's the point, instead of creating another interface, a part of the API for configuration, we decided to exploit the definition of RFC3549 using netlinksockets, this is very common and this is the way the Linux kernel uses for configuring the physical interfaces, so the most natural way to implement an API for natural configuration is to add nothing, given that there is Msockets that can be used to create netlinksockets, all the configuration can be carried on using this kind of socket, that is the RFC defines a set of packet formats to have all the service, to provide all the service for configuring IP address routes interfaces, so we decided to use this way, the problem is that there are commands providing this kind of services, there are client commands like IP, IP route, IP address or the ancient if config, there were not, there was not a library providing this kind of services as programming resources, as functions, we created this libraries, so the interface does not provide specific entries because we are using netlink, but we provide libraries that can be used to configure the stack using netlink, let us examine, let us see together a simple example to make clear what I am talking about, there is I think the simplest example of a program using networking by Berkley Sockets, is a program which opens a socket, a datagram socket, UDP and sends a message to a destination address, this is how the program appears using just plain Berkley Sockets and the kernel implementation of the stack, in this slide I am showing highlighted in yellow the changes I have implemented to have an Internet of threads implementation of the same program, given that we are not using the kernel stack we have to create the stack, so there is IOS new stack, the implementation is VD stack and it is connected to the network data link letter identified by the virtual network locator, VD colon slash slash the path so another slash temp hub, prior to communicate we have to provide the stack with a suitable configuration so we have to set an IP address to the only interface, so and we have to bring the interface up, IOS IFNameToIndex is the counterpart of IFNameToIndex, it is not an entry of the API but it is an entry of provided by a library and an inline that is able to translate that request in netlink messages, the same for IP address add and links at the top down, once the stack has been configured we can do the actual communication, so we can use msocket to create the socket and send to a close to send a message and close, apart from the the prefix and msocket instead of socket the actual problem solving implementation of the program does not change, so the final part of this example is an example of how applications could be ported to Internet of Threats just by changing just the prefix of the communication function and msocket instead of socket, but in order to reach these results there has been a long way because we had to develop a number of concepts and tools libraries to provide these abstractions, the idea in virto2 and the idea due to my journey stress for the building set is that each tool must do one thing and we tried to create tools making it well, doing it well and all the tool and libraries have been designed to interoperate, I think I missed one point about the API, here it's a very important point, all the file descriptor created by msocket are real file descriptor, that's an important point because we can use IELTS bind, IELTS connect saying this file descriptor is a specific file for Internet of Threats, but if we want to use POSselect, POSselect work on a set of file descriptors that may come from different implementations, one can be a real file descriptor of a device, one can be an Internet of Threats socket and maybe in the future we can have several file descriptor coming from other virtualization, other implementation, so the idea is that file descriptor can be used in POSselect, but even if this result is not costless we had to design libraries and tools to provide this kind of feature, Vienta distributed Internet is a support we are using for the data link layer and then many other, if they use data view poll and inline net link view as now in the following slides we can pass very quickly through these tools that have been created to create as a final point the bias, many others are under development. Next, Vienta distributed Internet, Vienta distributed Internet is still back I think 2006, it's a general support for Vienta distributed networking at data link layer originally designed for virtual machines, now VDE has evolved in two different directions, one is to provide support for namespaces, for user space implemented stacks for partial virtual machines, on the other side another development of Vienta distributed Internet is about the modularity, so instead of having one way to implement virtual Internet now the actor implementation can be loaded as plugin, again we can see the building block metaphor, the API of VDE is straightforward, this is the API used at the lowest layer of the TCP-IP stack block provided by Libyat, we have an NOPAC type VDEcon as the identifier and then we have open, receive, send, close and we have the way to have file descriptor to check for new messages arriving. Plugins, there are several plugins, these are just some examples, we can connect virtual machines, virtual user implemented stacks to the switches using this kind of plugin, we can create a street using this kind, we can use a slip to create an emulation, providing client side access to the Internet using a simple process, we can connect to the tap to the hosting machine itself, we can use this VXVDE to create a local cloud using multicast IP, this is an implementation of distributed switch, so you can start virtual machines on several hosts of the local network just providing the same address, they metamagically create a virtual Internet among them. Now in this talk I cannot go through all the details, but there is a tutorial section in the virtual square's wiki, so you can try and see the example at work, this is an example of a geometry you can create using the new VDE plug 4, you can have virtual machines connected to a switch, you can have the switch connected to the tap interface to the hosting machine, as you can see all the plugins have an identifier that is similar to URL, VNL is a way to identify a virtual network and the part that would be the protocol part in a URL is the implementation, so here the switch is loaded as a plugin, so as a shared library for this application, we have a VDNS that can create namespaces connected to the virtual distributed Internet, in this idea what Internet of Trades is can be implemented in this way, we have at the left hand side the implementation, the legacy implementation of the TCPAP stack in the kernel, so here there is the line of the boundary user kernel space, instead using Internet of Trades we can load the stack into the application and have an interface to VDE so we can create the application connected, here there is the socket, meaning this pattern, styling pattern to connect a VDE implementation, and Leviath and here the metaphor of building blocks as it's maximum, we have the application instead of loading, of having the library linked inside, we have just the Leviath linked inside the application and then we can load the actual implementation of the stack, either the kernel stack if you want, VD stack, Pycox net or in the future we can adapt other implementations and these implementations, stack implementations are connected to VDE, so there are several building blocks, one into the other blocks, now let us pass very quickly through the other tools we have created, FD user data, because we wanted to have the Berkeley Sockets functions with the same signature, so we had to pick it back information to the file descriptor, FD user data is able to provide a way to write libraries that can retrieve information using the file descriptor as the key, Vipoll is the library that allows to create file descriptors where events can be emulated, can be created as needed, actually Vipoll cannot be implemented completely as a library because we have no system causing Linux to provide this kind of feature, so there is an emulation that can be implemented in any system or there is a kernel model providing a device, in this way it is possible to have the complete emulation of Poll events, so it is a general purpose feature, the Poll Vipoll P-select, E-Poll and even if in the future new kind of system cause to wait for events will be created it will be compatible, and then inline is a library, very light library made of inline functions that provide programmers with tools to configure the network, the most common configuration request like add an address, delete an address, add a route, delete a route, etc. the MAC address is provided as functions, that was missing because it is not common given that the idea that the kernel provides the single stack you can have, it was not the requirement to have programs configuring the network interfaces, NLQ is a library providing forging and decoding of netlink messages, there are several libraries but the new point of this library is that there has been designed to provide also the support for the server side of netlink communication, again it is not common to have programs that need to understand and process the requests for stack configurations because it is a service provided by the kernel implementation of the stack, instead if we want to create stacks able to get requests VNnetlink and perform the operation requested, we need the library is able to decode the request call specific function of the stack to perform the requested operation and forward the reply method, VOS is a part of it, in some sense we can say that it gives a abstraction of a namespace that is entirely implemented in the user space, so this is an idea if this is the Linux kernel API and usually we have processes using the Linux kernel for the services, so the Linux kernel processes and libraries uses system calls to have services by the Linux kernel, VOS provides the same interface to user processes but the request path through an hypervisor that can decide whether to pass the request to the kernel or to process the request using modules that then can provide different answers to the system call, so we can provide the processes with different view of the execution environment, so it is a partial virtual machine not all the system calls are processed by the virtual machine, some are processed by the kernel, others are processed by the modules, the actual implementation is in this way, the virtual processes, the partially virtualized processes actually do the system call but the kernel can decide to divert the call to the hypervisor, there are different modules, the module to virtualize the file system, fuse the file system in user space, there is the counterpart that provides the same services but in user space, virtual devices, virtual networking, virtual name time, but the most important now is virtual networking, just to have a taste of how VOS works, the idea to add the module for the virtual file system and mount the entire file system slash mount, so the entire contents of the file system can be seen both as the real content and replicated because of this in slash mount, so it's something like a bind mount but it's entirely implemented in user space. Actually, LeBuyers can be used as a module in VUNET, so we can add a network, say using mount, that we want this stack to be mounted as devnet my stack and then we can enter using this command view stack into this start a process using this stack implementation and then we can see the interfaces provided in this case by LeBuyVD plug, excuse me, LeBuyVD stack, VD stack, which is a trick actually, it's an example of user space implemented, can be used as an example of user space implemented stack but it's not really a user implemented stack because it uses a namespace in the kernel as it was a box because all the requests are forwarded to the namespace in the kernel and using a tap interface, the request to the data link layer is captured and diverted to the VDE. Instead, PeacoxNet is an extra stack based on Peacot TCP generation in NG designed for Internet of Thread. Support multiple stacks is implemented by the Stainberg and Sock API, it has the support for the configuration via netlink and uses V-Poll to provide real-fight descriptors. Now let's finish this talk with the future, we're working on IOSConf, a support for auto-configuration and configuration using so it's not done to LeBuyVD to configure the network. So, returning back to the example, instead of using all the functions from an NLine to configure the IP address route and so on, we can have the configuration as a string and it's quite simple but here instead of this string I could have written something like DHCP and so it means that we wanted to get the IP address using the ACP auto-configuration or the ACPv6 RD which means router discovery and so on. So, these are examples, this is the way to configure using static configuration for IPv4, IPv6 or via DHCP or using DHCP using purely qualified domain name using hash-based assign of the address. This library provides also a way to configure the name resolution functions and another project we're working on is the name resolution support for LeBuyVD so the way to provide name resolution. All the effort is on the way to enter Debian, VDE, FD, Ethernet and NLine is already in Debian so there are packages to install these supports, we are working to package and to add all the other ties of this big project regarding virtual square tools. So, I thank you for your attention and now there should be a session for questions and other answers. Thank you very much. Okay, I hope you can hear me. Let's give it a few seconds for the stream to switch to us. Yeah, I think we are live and we are being broadcasted. So, thanks very much for the talk, it was very interesting. There were some questions and I'll repeat them here for the people who cannot join the matrix. So, one question was can I hope work with VirtioNet, could you please elaborate on that? Yes, not yet, even because Virtio is for the integration with actual interfaces and networking. So, it's a good idea but VDE would benefit from this feature just for in the boundary between virtual and real networking because in all other cases, directly communicating virtual machines or main spaces or internal thread processes would not benefit because they don't need to access the real networking directly. They use many other ways, unisockets for features or they use embed the packages into TCPIP, unicast and multicast messages like for example VXVD. So, it's just for the in the top implementation of VDE that would be a benefit but it's a good idea. We are planning to work on it too. Okay, thank you very much. Just as I know, I'm wondering why the stream is showing primarily me and not you. I think that something is still not working quite well but I mean, maybe problems probably. So, I would have another question. So, since we are in the microkernel lab room, do you have any experience of using IOP on a microkernel by system? Not yet. The idea is theoretical but by now, these black boxes that can embed in implementation are stuck and moreover, it is possible to inherit the implementation from other sources can be used in the general idea of microkernel. I've not tried it at the moment. Okay, thank you. And maybe another question. If I understood correctly from your talk, your implementation is sort of monolithic in the sense that the whole networking stack is one component or did I miss something? The two layers are usually implemented as a block but nothing blocks from having further model implementation in the future. The whole idea of virtual square is a bunch of blocks that can be plugged together. So, now the block is just one but we can define internal API and create plugins for each layer. If in one of the last slides, there was an implementation, a complete implementation of IOP using VDE and so on. So, you could see that it's really like a building set of tools that are loaded as plugins or shared library one with the other. So, you can have the actual implementation you want, you need, just by combining this. Nothing stops from having this communicating by messages instead of from function calls. So, to switch in an even more microkernel way to implement things. Wonderful, that's great. I'm looking on the chat whether there are some additional questions. I don't see any yet but let's wait for a few minutes or maybe my connection is not working. I don't know. Do you see any other questions? I have the problem that the only way to keep on with both I have, I need two different windows and I have to play with one to another to the other, one on which I'm transmitting and the other on which I'm getting. Yeah, I see your pain, definitely. Okay. Do you consider implementing protocol like multiple parts? I think it can be done. Sorry for interrupting. I would just like you to read the whole question for the people who are watching the stream because they don't. Okay, sure. Do you consider implementing protocols like multiple disappear alternative API like TAPS on top of using the virtual square components? I've created the infrastructure so over this infrastructure any other protocol can be added. Moreover, it's very nice of these architectures that you can add implementations at runtime. You don't need to have kernel support because all these support is at user level. So from this point of view, we are very close to the microkernel community. Other questions? Can you see other questions? Somebody is typing but it's not a question yet. So again, let's wait for a couple of minutes. Maybe somebody will get a question. As it's useful in the conference, I have to say thank you, Mr. Chairman. This sounds like a good amount of fun. For me, it is. It's a project I'm working on for I think more than 10 years now. Okay, so I don't see any more questions in the chat but of course after this session is over, the room which is associated with this talk will be open to everyone. So people can join, people can chat using text or even join the video conference. So okay, let's wait for one extra minute. Anyway, I'm at the post. I think today for the whole day and maybe the of the time tomorrow and my email addresses and contacts are available. So feel free to ask me questions anytime. I see that the bottom is typing. Let's see if some... Yeah, and I'm on two different windows. I can see that there is a delay between one and the other. Yes, there is definitely some latency in both in the stream and in the chat. The infrastructure is really struggling but at least we have the first live Q&A which is good. I was really anxious that we won't have anything live this year. We have to take into account that the FOSTA organization has done a great work to have this all this infrastructure working. It's not toy. Yes, definitely. I mean it's a huge effort and done mostly by volunteers so we are very grateful to everyone who contributed to this. Okay, I agree. I cannot agree more with Baudon. These components look great for network experimentation. Yes, it's wonderful. I see that I can combine all the components I need just by adding these elements one to the other. The problem is typing. Just to be clear, not yet IOT has been used by a project named Marionette by two professors Italian at Paris to Lotto and I can't remember the other name. They have created a graphical user interface to put virtual machines and switches and people can draw the infrastructure and given VDA the infrastructure became an actual virtual infrastructure just by typing start. So it's an example of experimenting. I've taken internet working quite a lot but working only with Linux. This works on Linux but it's another dimension on networking that you cannot do to the kernel networking support you actually have. Okay, thank you very much. I think we will wrap up this Q&A session. Thanks for all the questions. Thanks for your answers as well. People can surely reach you by multiple means. So thanks again and in about 10 minutes so at five past one we will have another talk from Normand Feske from Genome Labs. Thank you. Thank you so far and lots of good work. Bye. Bye.
 Good morning.  My name is Reynzo Davoli.  I'm my affiliation is the University of Bologna.  This is a joint work with the Virtusqr team, which is an international group working on  virtualization.  And my co-author is Michael Kulweber, who is at the Soviet University of Cincinnati,  Ohio, USA.  It's a pleasure to be here at FOSTA again, also in this online format, new format for  the pandemic disease.  This talk would be about Libyat, a library providing, I say, a definitive API for the  Internet of Threads.  The attempt of this talk is to make some concept closer, so to contaminate knowledge  coming from different groups, from different experience, like those talking about virtualization,  namespaces, microcarnals, networking, and so on.  The concept of Internet of Threads is not a novel one.  I introduced the term Internet of Threads back in 2012 here at FOSTA.  And I used this kind of metaphor.  So a telephone line, if it's a fixed telephone line, is related to a place, to a room.  So it is common to dial a number and ask, is there Mario at home?  Because we have not dialed Mario's number, but Mario's house number.  Instead nowadays using portable mobile phones, we can reach directly people, because it's  common to have portable phone sets associated one to one to two people.  So one person to one, portable phone to one number.  So it's easier to get in touch with a specific person.  Relating this concept to the Internet, we have to consider what's the end point of an  Internet connection.  So what is addressed by an IP address?  The original design of the Internet, the end points were hardware controllers.  So each hardware controller had its own IP address.  Now maybe this constraint has been a bit lighter, because we have namespace, virtual machines,  but we are still addressing virtual interfaces of the counterpart of the ancient hosts.  It would be more consistent, so more efficient to have IP addresses assigned to processes,  threads, because the idea is that likewise with portable phones, we wanted to talk with  a specific person, now we want to reach a specific service.  So the idea is that if you have an IP address assigned to a process, it's easier to get  in touch with that specific service.  Actually, as you can see in the previous slide, there is a difference in the idea of IP address,  because IPv4 provides a very limited number of addresses, so it's unrealistic to think  to give IP addresses to each process or to each thread.  But talking about IPv6 addresses, the range, the other space is so large that it is a viable  solution.  So we can talk from one side to Internet of Threads, IOS, on the other side there is  a funny acronym, Internet of Legacy Devices, so we can talk about Iold, which gives the  idea of what is old and what is new.  Let me tell you a story about my childhood, about a juvenile stress I had.  It happened that I had two different building sets when I was a child, and they were incompatible.  And it was stressful, because it was hard to build constructions, including building  sets, building blocks from both sets.  So maybe from this being, now I am a computer scientist, and I want to have everything compatible  and each block may be integrated with the others.  So the idea is partial virtual machine Internet of Threads microcarnes, build blocks, like  the ones of the different building sets.  The idea of this talk is to provide means to make them compatible and integrateables.  We are what we have in common, for sure we are all against monolithic implementations,  we want to create so blocks.  The common call is to create independent code implementing services, so the idea is the  idea of these blocks.  The basic block we are talking about in this speech is a TCP-IP stack.  It's a block, it's a given OSI model, it's composed by two layers, network and transport.  So it can be seen as a block which has two interfaces to the outside world, one in the  upper side, the API to the application layer, and one to the data link layer.  The idea here, the idea of this talk, it was to see if there is a well-defined set of  APIs to the upper layer, to the lower layer, that makes this block a very useful block  exploitable in many situations.  So what does it matter with microcarnals?  This block could be used inside user processes, so we can pick it back, the TCP-IP stack in  the user process, and then we can deal with a server, the data link network server, in  the meaning of server of microcarnals, so we can have the TCP-IP stack as a library  inside the user process.  So this is a way in which we can use this element in the idea of microcarnals, but we  can also think to a TCP-IP process embedding this TCP-IP stack, and what is new, that  this concept about lib-iOS makes this standard, and then different implementations can be  loaded inside this block that in this way becomes a general-purpose TCP-IP stack block.  So given that the problem is to provide an API or rather two APIs in the way that this  API must be complete, usable and minimal, what can we talk about, how can we design  this API to the app player?  So just to resume which are the goals, it must be complete, so it must provide all the  operations currently available, and I add that this services should be provided in already  known mannerings so that existing code could be easily ported to the new environment.  Usable, so the syntax function consists of a bunch of standards and minimal, so we need  to avoid duplicate operations, we need to have this interface as simple as possible.  Given this API, which are the requirements, from one way we have to provide cause function  for configuration, more specifically to create or delete stack instances and to configure  parameters, so we need to have entries to create a stack to provide IP addresses, parameters  for the interfaces, routing definitions, before using the stack for communicating.  At the end, or if you want to change the stack we used, we need to have a call to delete  the stack.  When the stack is configured, the stack can be used for communicating, so we have to open,  close communication and points, send, receive, pack, set options and so on.  Let us have a closer look to the Libyous design.  This is a very common case, we decided to use a structure, a programming structure, a  C structure and a pack structure.  At the user level it is just a pointer, like the file all capital letters for the Libyous  C when we use fopen.  We use this as the identifier of a stack, so the way to open to create a stack is Ios  NeoStack.  The first parameter is the implementation, so the actual stack implementation will be  loaded as a plugin, so we can use this API for several implementations.  The second option, the second parameter, is the virtual network locator, because we use  the lowest API, the API to the data link layer, VDE, virtual distributed data net, and given  that the most common case is to have one stack with one interface, provided we are talking  about processes using directed networking, the simplest call is NeoStack, but the most  common factor, in some cases you may need to have several interfaces, those that are  calls, there are new stack L and new stack V, the syntax is similar to exact L, exact  V, that provides the programmer with means to create several interfaces stacks.  The counterpart of NeoStack is DelStack.  Then for communication, for communication there is a well known standard, the difference  between Ios, Libyous, and the standard networking is that in monolithic kernels it is common  to have the networking provided by the kernel, so the configuration is carried out by commons,  there is not an API for configuration, while it is common to have the communication API,  Verkissockets is a very common API for communication using TCP-IP stacks, so the only difference  between Ios and Verkissockets is Msockets, because when one creates a communication  endpoint using socket, it implicitly is talking about the kernel stack, now we have several  stacks, so socket is not enough, we need Msockets with extra heading argument, which is the  structure Ios, so they identify all the stack, apart from this, all the other Verkissockets  entries are then implemented keeping the same signature and functionalities, so the semantics  of all these entries is the same. What's this mean thing? We have talked about creating  and deleting stacks, how to communicate, now the problem is how can we configure the stack,  I mean add IP addresses, bring an interface up and down, set the routes, that's the point,  instead of creating another interface, a part of the API for configuration, we decided to  exploit the definition of RFC3549 using netlinksockets, this is very common and this is the way the  Linux kernel uses for configuring the physical interfaces, so the most natural way to implement  an API for natural configuration is to add nothing, given that there is Msockets that  can be used to create netlinksockets, all the configuration can be carried on using  this kind of socket, that is the RFC defines a set of packet formats to have all the service,  to provide all the service for configuring IP address routes interfaces, so we decided  to use this way, the problem is that there are commands providing this kind of services,  there are client commands like IP, IP route, IP address or the ancient if config, there  were not, there was not a library providing this kind of services as programming resources,  as functions, we created this libraries, so the interface does not provide specific entries  because we are using netlink, but we provide libraries that can be used to configure the  stack using netlink, let us examine, let us see together a simple example to make clear  what I am talking about, there is I think the simplest example of a program using networking  by Berkley Sockets, is a program which opens a socket, a datagram socket, UDP and sends  a message to a destination address, this is how the program appears using just plain  Berkley Sockets and the kernel implementation of the stack, in this slide I am showing  highlighted in yellow the changes I have implemented to have an Internet of threads implementation  of the same program, given that we are not using the kernel stack we have to create the  stack, so there is IOS new stack, the implementation is VD stack and it is connected to the network  data link letter identified by the virtual network locator, VD colon slash slash the  path so another slash temp hub, prior to communicate we have to provide the stack with a suitable  configuration so we have to set an IP address to the only interface, so and we have to bring  the interface up, IOS IFNameToIndex is the counterpart of IFNameToIndex, it is not an  entry of the API but it is an entry of provided by a library and an inline that is able to  translate that request in netlink messages, the same for IP address add and links at the  top down, once the stack has been configured we can do the actual communication, so we  can use msocket to create the socket and send to a close to send a message and close, apart  from the the prefix and msocket instead of socket the actual problem solving implementation  of the program does not change, so the final part of this example is an example of how  applications could be ported to Internet of Threats just by changing just the prefix  of the communication function and msocket instead of socket, but in order to reach these  results there has been a long way because we had to develop a number of concepts and  tools libraries to provide these abstractions, the idea in virto2 and the idea due to my  journey stress for the building set is that each tool must do one thing and we tried to  create tools making it well, doing it well and all the tool and libraries have been designed  to interoperate, I think I missed one point about the API, here it's a very important  point, all the file descriptor created by msocket are real file descriptor, that's an important  point because we can use IELTS bind, IELTS connect saying this file descriptor is a specific  file for Internet of Threats, but if we want to use POSselect, POSselect work on a set  of file descriptors that may come from different implementations, one can be a real file descriptor  of a device, one can be an Internet of Threats socket and maybe in the future we can have  several file descriptor coming from other virtualization, other implementation, so the  idea is that file descriptor can be used in POSselect, but even if this result is not  costless we had to design libraries and tools to provide this kind of feature, Vienta distributed  Internet is a support we are using for the data link layer and then many other, if they  use data view poll and inline net link view as now in the following slides we can pass  very quickly through these tools that have been created to create as a final point the  bias, many others are under development.  Next, Vienta distributed Internet, Vienta distributed Internet is still back I think  2006, it's a general support for Vienta distributed networking at data link layer originally designed  for virtual machines, now VDE has evolved in two different directions, one is to provide  support for namespaces, for user space implemented stacks for partial virtual machines, on the  other side another development of Vienta distributed Internet is about the modularity,  so instead of having one way to implement virtual Internet now the actor implementation  can be loaded as plugin, again we can see the building block metaphor, the API of VDE  is straightforward, this is the API used at the lowest layer of the TCP-IP stack block  provided by Libyat, we have an NOPAC type VDEcon as the identifier and then we have  open, receive, send, close and we have the way to have file descriptor to check for new  messages arriving.  Plugins, there are several plugins, these are just some examples, we can connect virtual  machines, virtual user implemented stacks to the switches using this kind of plugin, we  can create a street using this kind, we can use a slip to create an emulation, providing  client side access to the Internet using a simple process, we can connect to the tap  to the hosting machine itself, we can use this VXVDE to create a local cloud using multicast  IP, this is an implementation of distributed switch, so you can start virtual machines  on several hosts of the local network just providing the same address, they metamagically  create a virtual Internet among them.  Now in this talk I cannot go through all the details, but there is a tutorial section  in the virtual square's wiki, so you can try and see the example at work, this is an example  of a geometry you can create using the new VDE plug 4, you can have virtual machines  connected to a switch, you can have the switch connected to the tap interface to the hosting  machine, as you can see all the plugins have an identifier that is similar to URL, VNL  is a way to identify a virtual network and the part that would be the protocol part in  a URL is the implementation, so here the switch is loaded as a plugin, so as a shared library  for this application, we have a VDNS that can create namespaces connected to the virtual  distributed Internet, in this idea what Internet of Trades is can be implemented in this way,  we have at the left hand side the implementation, the legacy implementation of the TCPAP stack  in the kernel, so here there is the line of the boundary user kernel space, instead using  Internet of Trades we can load the stack into the application and have an interface to VDE  so we can create the application connected, here there is the socket, meaning this pattern,  styling pattern to connect a VDE implementation, and Leviath and here the metaphor of building  blocks as it's maximum, we have the application instead of loading, of having the library  linked inside, we have just the Leviath linked inside the application and then we can load  the actual implementation of the stack, either the kernel stack if you want, VD stack, Pycox  net or in the future we can adapt other implementations and these implementations, stack implementations  are connected to VDE, so there are several building blocks, one into the other blocks,  now let us pass very quickly through the other tools we have created, FD user data, because  we wanted to have the Berkeley Sockets functions with the same signature, so we had to pick  it back information to the file descriptor, FD user data is able to provide a way to write  libraries that can retrieve information using the file descriptor as the key, Vipoll is  the library that allows to create file descriptors where events can be emulated, can be created  as needed, actually Vipoll cannot be implemented completely as a library because we have no  system causing Linux to provide this kind of feature, so there is an emulation that  can be implemented in any system or there is a kernel model providing a device, in this  way it is possible to have the complete emulation of Poll events, so it is a general purpose  feature, the Poll Vipoll P-select, E-Poll and even if in the future new kind of system  cause to wait for events will be created it will be compatible, and then inline is a  library, very light library made of inline functions that provide programmers with tools  to configure the network, the most common configuration request like add an address,  delete an address, add a route, delete a route, etc. the MAC address is provided as functions,  that was missing because it is not common given that the idea that the kernel provides  the single stack you can have, it was not the requirement to have programs configuring  the network interfaces, NLQ is a library providing forging and decoding of netlink  messages, there are several libraries but the new point of this library is that there  has been designed to provide also the support for the server side of netlink communication,  again it is not common to have programs that need to understand and process the requests  for stack configurations because it is a service provided by the kernel implementation of the  stack, instead if we want to create stacks able to get requests VNnetlink and perform  the operation requested, we need the library is able to decode the request call specific  function of the stack to perform the requested operation and forward the reply method, VOS  is a part of it, in some sense we can say that it gives a abstraction of a namespace  that is entirely implemented in the user space, so this is an idea if this is the Linux kernel  API and usually we have processes using the Linux kernel for the services, so the Linux  kernel processes and libraries uses system calls to have services by the Linux kernel,  VOS provides the same interface to user processes but the request path through an hypervisor  that can decide whether to pass the request to the kernel or to process the request using  modules that then can provide different answers to the system call, so we can provide the  processes with different view of the execution environment, so it is a partial virtual machine  not all the system calls are processed by the virtual machine, some are processed by  the kernel, others are processed by the modules, the actual implementation is in this way,  the virtual processes, the partially virtualized processes actually do the system call but  the kernel can decide to divert the call to the hypervisor, there are different modules,  the module to virtualize the file system, fuse the file system in user space, there  is the counterpart that provides the same services but in user space, virtual devices,  virtual networking, virtual name time, but the most important now is virtual networking,  just to have a taste of how VOS works, the idea to add the module for the virtual file  system and mount the entire file system slash mount, so the entire contents of the file  system can be seen both as the real content and replicated because of this in slash mount,  so it's something like a bind mount but it's entirely implemented in user space.  Actually, LeBuyers can be used as a module in VUNET, so we can add a network, say using  mount, that we want this stack to be mounted as devnet my stack and then we can enter using  this command view stack into this start a process using this stack implementation and  then we can see the interfaces provided in this case by LeBuyVD plug, excuse me, LeBuyVD  stack, VD stack, which is a trick actually, it's an example of user space implemented,  can be used as an example of user space implemented stack but it's not really a user implemented  stack because it uses a namespace in the kernel as it was a box because all the requests are  forwarded to the namespace in the kernel and using a tap interface, the request to the  data link layer is captured and diverted to the VDE. Instead, PeacoxNet is an extra stack  based on Peacot TCP generation in NG designed for Internet of Thread. Support multiple stacks  is implemented by the Stainberg and Sock API, it has the support for the configuration via  netlink and uses V-Poll to provide real-fight descriptors. Now let's finish this talk with  the future, we're working on IOSConf, a support for auto-configuration and configuration using  so it's not done to LeBuyVD to configure the network. So, returning back to the example,  instead of using all the functions from an NLine to configure the IP address route and  so on, we can have the configuration as a string and it's quite simple but here instead  of this string I could have written something like DHCP and so it means that we wanted to  get the IP address using the ACP auto-configuration or the ACPv6 RD which means router discovery  and so on. So, these are examples, this is the way to configure using static configuration  for IPv4, IPv6 or via DHCP or using DHCP using purely qualified domain name using hash-based  assign of the address. This library provides also a way to configure the name resolution  functions and another project we're working on is the name resolution support for LeBuyVD  so the way to provide name resolution. All the effort is on the way to enter Debian,  VDE, FD, Ethernet and NLine is already in Debian so there are packages to install these  supports, we are working to package and to add all the other ties of this big project  regarding virtual square tools. So, I thank you for your attention and now there should  be a session for questions and other answers. Thank you very much.  Okay, I hope you can hear me. Let's give it a few seconds for the stream to switch to  us. Yeah, I think we are live and we are being broadcasted. So, thanks very much for the talk,  it was very interesting. There were some questions and I'll repeat them here for the people who  cannot join the matrix. So, one question was can I hope work with VirtioNet, could you  please elaborate on that? Yes, not yet, even because Virtio is for the integration with  actual interfaces and networking. So, it's a good idea but VDE would benefit from this  feature just for in the boundary between virtual and real networking because in all  other cases, directly communicating virtual machines or main spaces or internal thread  processes would not benefit because they don't need to access the real networking directly.  They use many other ways, unisockets for features or they use embed the packages into  TCPIP, unicast and multicast messages like for example VXVD. So, it's just for the in  the top implementation of VDE that would be a benefit but it's a good idea. We are planning  to work on it too. Okay, thank you very much. Just as I know, I'm wondering why the stream  is showing primarily me and not you. I think that something is still not working quite well  but I mean, maybe problems probably. So, I would have another question. So, since we  are in the microkernel lab room, do you have any experience of using IOP on a microkernel  by system? Not yet. The idea is theoretical but by now, these black boxes that can embed  in implementation are stuck and moreover, it is possible to inherit the implementation  from other sources can be used in the general idea of microkernel. I've not tried it at  the moment. Okay, thank you. And maybe another question. If I understood correctly from your  talk, your implementation is sort of monolithic in the sense that the whole networking stack  is one component or did I miss something? The two layers are usually implemented as a  block but nothing blocks from having further model implementation in the future. The whole  idea of virtual square is a bunch of blocks that can be plugged together. So, now the  block is just one but we can define internal API and create plugins for each layer. If  in one of the last slides, there was an implementation, a complete implementation of IOP using VDE  and so on. So, you could see that it's really like a building set of tools that are loaded  as plugins or shared library one with the other. So, you can have the actual implementation  you want, you need, just by combining this. Nothing stops from having this communicating  by messages instead of from function calls. So, to switch in an even more microkernel  way to implement things. Wonderful, that's great. I'm looking on the chat whether there  are some additional questions. I don't see any yet but let's wait for a few minutes or  maybe my connection is not working. I don't know. Do you see any other questions? I have  the problem that the only way to keep on with both I have, I need two different windows  and I have to play with one to another to the other, one on which I'm transmitting and  the other on which I'm getting. Yeah, I see your pain, definitely. Okay. Do you consider  implementing protocol like multiple parts? I think it can be done. Sorry for interrupting.  I would just like you to read the whole question for the people who are watching the stream  because they don't. Okay, sure. Do you consider implementing protocols like multiple disappear  alternative API like TAPS on top of using the virtual square components? I've created  the infrastructure so over this infrastructure any other protocol can be added. Moreover,  it's very nice of these architectures that you can add implementations at runtime. You  don't need to have kernel support because all these support is at user level. So from  this point of view, we are very close to the microkernel community. Other questions? Can  you see other questions? Somebody is typing but it's not a question yet. So again, let's  wait for a couple of minutes. Maybe somebody will get a question. As it's useful in the  conference, I have to say thank you, Mr. Chairman. This sounds like a good amount of fun. For  me, it is. It's a project I'm working on for I think more than 10 years now.  Okay, so I don't see any more questions in the chat but of course after this session is over,  the room which is associated with this talk will be open to everyone. So people can join,  people can chat using text or even join the video conference. So okay, let's wait for one extra minute.  Anyway, I'm at the post. I think today for the whole day and maybe  the of the time tomorrow and my email addresses and contacts are available. So feel free to ask  me questions anytime. I see that the bottom is typing. Let's see if some...  Yeah, and I'm on two different windows. I can see that there is a delay between one and the other.  Yes, there is definitely some latency in both in the stream and in the chat. The infrastructure  is really struggling but at least we have the first live Q&A which is good. I was really  anxious that we won't have anything live this year. We have to take into account that the  FOSTA organization has done a great work to have this all this infrastructure working. It's not  toy. Yes, definitely. I mean it's a huge effort and done mostly by volunteers so we are very  grateful to everyone who contributed to this. Okay, I agree. I cannot agree more with Baudon.  These components look great for network experimentation. Yes, it's wonderful. I see that I can  combine all the components I need just by adding these elements one to the other.  The problem is typing.  Just to be clear, not yet IOT has been used by a project named Marionette  by two professors Italian at Paris to Lotto and I can't remember the other name. They have created  a graphical user interface to put virtual machines and switches and people can draw the  infrastructure and given VDA the infrastructure became an actual virtual infrastructure just  by typing start. So it's an example of experimenting. I've taken internet working quite a lot but  working only with Linux. This works on Linux but it's another dimension on networking that you  cannot do to the kernel networking support you actually have. Okay, thank you very much. I think  we will wrap up this Q&A session. Thanks for all the questions. Thanks for your answers as well.  People can surely reach you by multiple means. So thanks again and in about 10 minutes so  at five past one we will have another talk from Normand Feske from Genome Labs. Thank you. Thank  you so far and lots of good work. Bye. Bye.
microkernel_libioth_0_179.png microkernel_libioth_180_2363.png microkernel_libioth_2364_2447.png microkernel_libioth_2448_4631.png microkernel_libioth_4632_7199.png microkernel_libioth_7200_8183.png microkernel_libioth_8184_8771.png microkernel_libioth_8772_10835.png microkernel_libioth_10836_11519.png microkernel_libioth_11520_13487.png microkernel_libioth_13488_15551.png microkernel_libioth_15552_17603.png microkernel_libioth_17604_19415.png microkernel_libioth_19416_23327.png microkernel_libioth_23328_26939.png microkernel_libioth_26940_30491.png microkernel_libioth_30492_30539.png microkernel_libioth_30540_31751.png microkernel_libioth_31752_31799.png microkernel_libioth_31800_31847.png microkernel_libioth_31848_36239.png microkernel_libioth_36240_37859.png microkernel_libioth_37860_38015.png microkernel_libioth_38016_39743.png microkernel_libioth_39744_39791.png microkernel_libioth_39792_40283.png microkernel_libioth_40284_40331.png microkernel_libioth_40332_41207.png microkernel_libioth_41208_41363.png microkernel_libioth_41364_43175.png microkernel_libioth_43176_44255.png microkernel_libioth_44256_46547.png microkernel_libioth_46548_47183.png microkernel_libioth_47184_48767.png microkernel_libioth_48768_48995.png microkernel_libioth_48996_50447.png microkernel_libioth_50448_50711.png microkernel_libioth_50712_51983.png microkernel_libioth_51984_52043.png microkernel_libioth_52044_53099.png microkernel_libioth_53100_54983.png microkernel_libioth_54984_56195.png microkernel_libioth_56196_58583.png microkernel_libioth_58584_60803.png microkernel_libioth_60804_61355.png microkernel_libioth_61356_61979.png microkernel_libioth_61980_62651.png microkernel_libioth_62652_62999.png microkernel_libioth_63000_63851.png microkernel_libioth_63852_64007.png microkernel_libioth_64008_64091.png microkernel_libioth_64092_65315.png microkernel_libioth_65316_65999.png microkernel_libioth_66000_66623.png microkernel_libioth_66624_67871.png microkernel_libioth_67872_68075.png microkernel_libioth_68076_68183.png microkernel_libioth_68184_68243.png microkernel_libioth_68244_68615.png microkernel_libioth_68616_68819.png microkernel_libioth_68820_69203.png microkernel_libioth_69204_70151.png microkernel_libioth_70152_70559.png microkernel_libioth_70560_70835.png microkernel_libioth_70836_70895.png microkernel_libioth_70896_71279.png microkernel_libioth_71280_71543.png microkernel_libioth_71544_72407.png microkernel_libioth_72408_72695.png microkernel_libioth_72696_73019.png microkernel_libioth_73020_76127.png microkernel_libioth_76128_76271.png microkernel_libioth_76272_76319.png microkernel_libioth_76320_81803.png microkernel_libioth_81804_86315.png microkernel_libioth_86316_89099.png microkernel_libioth_89100_89216.png
Good morning. My name is Reynzo Davoli. I'm my affiliation is the University of Bologna. This is a joint work with the Virtusqr team, which is an international group working on virtualization. And my co-author is Michael Kulweber, who is at the Soviet University of Cincinnati, Ohio, USA. It's a pleasure to be here at FOSTA again, also in this online format, new format for the pandemic disease. This talk would be about Libyat, a library providing, I say, a definitive API for the Internet of Threads. The attempt of this talk is to make some concept closer, so to contaminate knowledge coming from different groups, from different experience, like those talking about virtualization, namespaces, microcarnals, networking, and so on. The concept of Internet of Threads is not a novel one. I introduced the term Internet of Threads back in 2012 here at FOSTA. And I used this kind of metaphor. So a telephone line, if it's a fixed telephone line, is related to a place, to a room. So it is common to dial a number and ask, is there Mario at home? Because we have not dialed Mario's number, but Mario's house number. Instead nowadays using portable mobile phones, we can reach directly people, because it's common to have portable phone sets associated one to one to two people. So one person to one, portable phone to one number. So it's easier to get in touch with a specific person. Relating this concept to the Internet, we have to consider what's the end point of an Internet connection. So what is addressed by an IP address? The original design of the Internet, the end points were hardware controllers. So each hardware controller had its own IP address. Now maybe this constraint has been a bit lighter, because we have namespace, virtual machines, but we are still addressing virtual interfaces of the counterpart of the ancient hosts. It would be more consistent, so more efficient to have IP addresses assigned to processes, threads, because the idea is that likewise with portable phones, we wanted to talk with a specific person, now we want to reach a specific service. So the idea is that if you have an IP address assigned to a process, it's easier to get in touch with that specific service. Actually, as you can see in the previous slide, there is a difference in the idea of IP address, because IPv4 provides a very limited number of addresses, so it's unrealistic to think to give IP addresses to each process or to each thread. But talking about IPv6 addresses, the range, the other space is so large that it is a viable solution. So we can talk from one side to Internet of Threads, IOS, on the other side there is a funny acronym, Internet of Legacy Devices, so we can talk about Iold, which gives the idea of what is old and what is new. Let me tell you a story about my childhood, about a juvenile stress I had. It happened that I had two different building sets when I was a child, and they were incompatible. And it was stressful, because it was hard to build constructions, including building sets, building blocks from both sets. So maybe from this being, now I am a computer scientist, and I want to have everything compatible and each block may be integrated with the others. So the idea is partial virtual machine Internet of Threads microcarnes, build blocks, like the ones of the different building sets. The idea of this talk is to provide means to make them compatible and integrateables. We are what we have in common, for sure we are all against monolithic implementations, we want to create so blocks. The common call is to create independent code implementing services, so the idea is the idea of these blocks. The basic block we are talking about in this speech is a TCP-IP stack. It's a block, it's a given OSI model, it's composed by two layers, network and transport. So it can be seen as a block which has two interfaces to the outside world, one in the upper side, the API to the application layer, and one to the data link layer. The idea here, the idea of this talk, it was to see if there is a well-defined set of APIs to the upper layer, to the lower layer, that makes this block a very useful block exploitable in many situations. So what does it matter with microcarnals? This block could be used inside user processes, so we can pick it back, the TCP-IP stack in the user process, and then we can deal with a server, the data link network server, in the meaning of server of microcarnals, so we can have the TCP-IP stack as a library inside the user process. So this is a way in which we can use this element in the idea of microcarnals, but we can also think to a TCP-IP process embedding this TCP-IP stack, and what is new, that this concept about lib-iOS makes this standard, and then different implementations can be loaded inside this block that in this way becomes a general-purpose TCP-IP stack block. So given that the problem is to provide an API or rather two APIs in the way that this API must be complete, usable and minimal, what can we talk about, how can we design this API to the app player? So just to resume which are the goals, it must be complete, so it must provide all the operations currently available, and I add that this services should be provided in already known mannerings so that existing code could be easily ported to the new environment. Usable, so the syntax function consists of a bunch of standards and minimal, so we need to avoid duplicate operations, we need to have this interface as simple as possible. Given this API, which are the requirements, from one way we have to provide cause function for configuration, more specifically to create or delete stack instances and to configure parameters, so we need to have entries to create a stack to provide IP addresses, parameters for the interfaces, routing definitions, before using the stack for communicating. At the end, or if you want to change the stack we used, we need to have a call to delete the stack. When the stack is configured, the stack can be used for communicating, so we have to open, close communication and points, send, receive, pack, set options and so on. Let us have a closer look to the Libyous design. This is a very common case, we decided to use a structure, a programming structure, a C structure and a pack structure. At the user level it is just a pointer, like the file all capital letters for the Libyous C when we use fopen. We use this as the identifier of a stack, so the way to open to create a stack is Ios NeoStack. The first parameter is the implementation, so the actual stack implementation will be loaded as a plugin, so we can use this API for several implementations. The second option, the second parameter, is the virtual network locator, because we use the lowest API, the API to the data link layer, VDE, virtual distributed data net, and given that the most common case is to have one stack with one interface, provided we are talking about processes using directed networking, the simplest call is NeoStack, but the most common factor, in some cases you may need to have several interfaces, those that are calls, there are new stack L and new stack V, the syntax is similar to exact L, exact V, that provides the programmer with means to create several interfaces stacks. The counterpart of NeoStack is DelStack. Then for communication, for communication there is a well known standard, the difference between Ios, Libyous, and the standard networking is that in monolithic kernels it is common to have the networking provided by the kernel, so the configuration is carried out by commons, there is not an API for configuration, while it is common to have the communication API, Verkissockets is a very common API for communication using TCP-IP stacks, so the only difference between Ios and Verkissockets is Msockets, because when one creates a communication endpoint using socket, it implicitly is talking about the kernel stack, now we have several stacks, so socket is not enough, we need Msockets with extra heading argument, which is the structure Ios, so they identify all the stack, apart from this, all the other Verkissockets entries are then implemented keeping the same signature and functionalities, so the semantics of all these entries is the same. What's this mean thing? We have talked about creating and deleting stacks, how to communicate, now the problem is how can we configure the stack, I mean add IP addresses, bring an interface up and down, set the routes, that's the point, instead of creating another interface, a part of the API for configuration, we decided to exploit the definition of RFC3549 using netlinksockets, this is very common and this is the way the Linux kernel uses for configuring the physical interfaces, so the most natural way to implement an API for natural configuration is to add nothing, given that there is Msockets that can be used to create netlinksockets, all the configuration can be carried on using this kind of socket, that is the RFC defines a set of packet formats to have all the service, to provide all the service for configuring IP address routes interfaces, so we decided to use this way, the problem is that there are commands providing this kind of services, there are client commands like IP, IP route, IP address or the ancient if config, there were not, there was not a library providing this kind of services as programming resources, as functions, we created this libraries, so the interface does not provide specific entries because we are using netlink, but we provide libraries that can be used to configure the stack using netlink, let us examine, let us see together a simple example to make clear what I am talking about, there is I think the simplest example of a program using networking by Berkley Sockets, is a program which opens a socket, a datagram socket, UDP and sends a message to a destination address, this is how the program appears using just plain Berkley Sockets and the kernel implementation of the stack, in this slide I am showing highlighted in yellow the changes I have implemented to have an Internet of threads implementation of the same program, given that we are not using the kernel stack we have to create the stack, so there is IOS new stack, the implementation is VD stack and it is connected to the network data link letter identified by the virtual network locator, VD colon slash slash the path so another slash temp hub, prior to communicate we have to provide the stack with a suitable configuration so we have to set an IP address to the only interface, so and we have to bring the interface up, IOS IFNameToIndex is the counterpart of IFNameToIndex, it is not an entry of the API but it is an entry of provided by a library and an inline that is able to translate that request in netlink messages, the same for IP address add and links at the top down, once the stack has been configured we can do the actual communication, so we can use msocket to create the socket and send to a close to send a message and close, apart from the the prefix and msocket instead of socket the actual problem solving implementation of the program does not change, so the final part of this example is an example of how applications could be ported to Internet of Threats just by changing just the prefix of the communication function and msocket instead of socket, but in order to reach these results there has been a long way because we had to develop a number of concepts and tools libraries to provide these abstractions, the idea in virto2 and the idea due to my journey stress for the building set is that each tool must do one thing and we tried to create tools making it well, doing it well and all the tool and libraries have been designed to interoperate, I think I missed one point about the API, here it's a very important point, all the file descriptor created by msocket are real file descriptor, that's an important point because we can use IELTS bind, IELTS connect saying this file descriptor is a specific file for Internet of Threats, but if we want to use POSselect, POSselect work on a set of file descriptors that may come from different implementations, one can be a real file descriptor of a device, one can be an Internet of Threats socket and maybe in the future we can have several file descriptor coming from other virtualization, other implementation, so the idea is that file descriptor can be used in POSselect, but even if this result is not costless we had to design libraries and tools to provide this kind of feature, Vienta distributed Internet is a support we are using for the data link layer and then many other, if they use data view poll and inline net link view as now in the following slides we can pass very quickly through these tools that have been created to create as a final point the bias, many others are under development. Next, Vienta distributed Internet, Vienta distributed Internet is still back I think 2006, it's a general support for Vienta distributed networking at data link layer originally designed for virtual machines, now VDE has evolved in two different directions, one is to provide support for namespaces, for user space implemented stacks for partial virtual machines, on the other side another development of Vienta distributed Internet is about the modularity, so instead of having one way to implement virtual Internet now the actor implementation can be loaded as plugin, again we can see the building block metaphor, the API of VDE is straightforward, this is the API used at the lowest layer of the TCP-IP stack block provided by Libyat, we have an NOPAC type VDEcon as the identifier and then we have open, receive, send, close and we have the way to have file descriptor to check for new messages arriving. Plugins, there are several plugins, these are just some examples, we can connect virtual machines, virtual user implemented stacks to the switches using this kind of plugin, we can create a street using this kind, we can use a slip to create an emulation, providing client side access to the Internet using a simple process, we can connect to the tap to the hosting machine itself, we can use this VXVDE to create a local cloud using multicast IP, this is an implementation of distributed switch, so you can start virtual machines on several hosts of the local network just providing the same address, they metamagically create a virtual Internet among them. Now in this talk I cannot go through all the details, but there is a tutorial section in the virtual square's wiki, so you can try and see the example at work, this is an example of a geometry you can create using the new VDE plug 4, you can have virtual machines connected to a switch, you can have the switch connected to the tap interface to the hosting machine, as you can see all the plugins have an identifier that is similar to URL, VNL is a way to identify a virtual network and the part that would be the protocol part in a URL is the implementation, so here the switch is loaded as a plugin, so as a shared library for this application, we have a VDNS that can create namespaces connected to the virtual distributed Internet, in this idea what Internet of Trades is can be implemented in this way, we have at the left hand side the implementation, the legacy implementation of the TCPAP stack in the kernel, so here there is the line of the boundary user kernel space, instead using Internet of Trades we can load the stack into the application and have an interface to VDE so we can create the application connected, here there is the socket, meaning this pattern, styling pattern to connect a VDE implementation, and Leviath and here the metaphor of building blocks as it's maximum, we have the application instead of loading, of having the library linked inside, we have just the Leviath linked inside the application and then we can load the actual implementation of the stack, either the kernel stack if you want, VD stack, Pycox net or in the future we can adapt other implementations and these implementations, stack implementations are connected to VDE, so there are several building blocks, one into the other blocks, now let us pass very quickly through the other tools we have created, FD user data, because we wanted to have the Berkeley Sockets functions with the same signature, so we had to pick it back information to the file descriptor, FD user data is able to provide a way to write libraries that can retrieve information using the file descriptor as the key, Vipoll is the library that allows to create file descriptors where events can be emulated, can be created as needed, actually Vipoll cannot be implemented completely as a library because we have no system causing Linux to provide this kind of feature, so there is an emulation that can be implemented in any system or there is a kernel model providing a device, in this way it is possible to have the complete emulation of Poll events, so it is a general purpose feature, the Poll Vipoll P-select, E-Poll and even if in the future new kind of system cause to wait for events will be created it will be compatible, and then inline is a library, very light library made of inline functions that provide programmers with tools to configure the network, the most common configuration request like add an address, delete an address, add a route, delete a route, etc. the MAC address is provided as functions, that was missing because it is not common given that the idea that the kernel provides the single stack you can have, it was not the requirement to have programs configuring the network interfaces, NLQ is a library providing forging and decoding of netlink messages, there are several libraries but the new point of this library is that there has been designed to provide also the support for the server side of netlink communication, again it is not common to have programs that need to understand and process the requests for stack configurations because it is a service provided by the kernel implementation of the stack, instead if we want to create stacks able to get requests VNnetlink and perform the operation requested, we need the library is able to decode the request call specific function of the stack to perform the requested operation and forward the reply method, VOS is a part of it, in some sense we can say that it gives a abstraction of a namespace that is entirely implemented in the user space, so this is an idea if this is the Linux kernel API and usually we have processes using the Linux kernel for the services, so the Linux kernel processes and libraries uses system calls to have services by the Linux kernel, VOS provides the same interface to user processes but the request path through an hypervisor that can decide whether to pass the request to the kernel or to process the request using modules that then can provide different answers to the system call, so we can provide the processes with different view of the execution environment, so it is a partial virtual machine not all the system calls are processed by the virtual machine, some are processed by the kernel, others are processed by the modules, the actual implementation is in this way, the virtual processes, the partially virtualized processes actually do the system call but the kernel can decide to divert the call to the hypervisor, there are different modules, the module to virtualize the file system, fuse the file system in user space, there is the counterpart that provides the same services but in user space, virtual devices, virtual networking, virtual name time, but the most important now is virtual networking, just to have a taste of how VOS works, the idea to add the module for the virtual file system and mount the entire file system slash mount, so the entire contents of the file system can be seen both as the real content and replicated because of this in slash mount, so it's something like a bind mount but it's entirely implemented in user space. Actually, LeBuyers can be used as a module in VUNET, so we can add a network, say using mount, that we want this stack to be mounted as devnet my stack and then we can enter using this command view stack into this start a process using this stack implementation and then we can see the interfaces provided in this case by LeBuyVD plug, excuse me, LeBuyVD stack, VD stack, which is a trick actually, it's an example of user space implemented, can be used as an example of user space implemented stack but it's not really a user implemented stack because it uses a namespace in the kernel as it was a box because all the requests are forwarded to the namespace in the kernel and using a tap interface, the request to the data link layer is captured and diverted to the VDE. Instead, PeacoxNet is an extra stack based on Peacot TCP generation in NG designed for Internet of Thread. Support multiple stacks is implemented by the Stainberg and Sock API, it has the support for the configuration via netlink and uses V-Poll to provide real-fight descriptors. Now let's finish this talk with the future, we're working on IOSConf, a support for auto-configuration and configuration using so it's not done to LeBuyVD to configure the network. So, returning back to the example, instead of using all the functions from an NLine to configure the IP address route and so on, we can have the configuration as a string and it's quite simple but here instead of this string I could have written something like DHCP and so it means that we wanted to get the IP address using the ACP auto-configuration or the ACPv6 RD which means router discovery and so on. So, these are examples, this is the way to configure using static configuration for IPv4, IPv6 or via DHCP or using DHCP using purely qualified domain name using hash-based assign of the address. This library provides also a way to configure the name resolution functions and another project we're working on is the name resolution support for LeBuyVD so the way to provide name resolution. All the effort is on the way to enter Debian, VDE, FD, Ethernet and NLine is already in Debian so there are packages to install these supports, we are working to package and to add all the other ties of this big project regarding virtual square tools. So, I thank you for your attention and now there should be a session for questions and other answers. Thank you very much. Okay, I hope you can hear me. Let's give it a few seconds for the stream to switch to us. Yeah, I think we are live and we are being broadcasted. So, thanks very much for the talk, it was very interesting. There were some questions and I'll repeat them here for the people who cannot join the matrix. So, one question was can I hope work with VirtioNet, could you please elaborate on that? Yes, not yet, even because Virtio is for the integration with actual interfaces and networking. So, it's a good idea but VDE would benefit from this feature just for in the boundary between virtual and real networking because in all other cases, directly communicating virtual machines or main spaces or internal thread processes would not benefit because they don't need to access the real networking directly. They use many other ways, unisockets for features or they use embed the packages into TCPIP, unicast and multicast messages like for example VXVD. So, it's just for the in the top implementation of VDE that would be a benefit but it's a good idea. We are planning to work on it too. Okay, thank you very much. Just as I know, I'm wondering why the stream is showing primarily me and not you. I think that something is still not working quite well but I mean, maybe problems probably. So, I would have another question. So, since we are in the microkernel lab room, do you have any experience of using IOP on a microkernel by system? Not yet. The idea is theoretical but by now, these black boxes that can embed in implementation are stuck and moreover, it is possible to inherit the implementation from other sources can be used in the general idea of microkernel. I've not tried it at the moment. Okay, thank you. And maybe another question. If I understood correctly from your talk, your implementation is sort of monolithic in the sense that the whole networking stack is one component or did I miss something? The two layers are usually implemented as a block but nothing blocks from having further model implementation in the future. The whole idea of virtual square is a bunch of blocks that can be plugged together. So, now the block is just one but we can define internal API and create plugins for each layer. If in one of the last slides, there was an implementation, a complete implementation of IOP using VDE and so on. So, you could see that it's really like a building set of tools that are loaded as plugins or shared library one with the other. So, you can have the actual implementation you want, you need, just by combining this. Nothing stops from having this communicating by messages instead of from function calls. So, to switch in an even more microkernel way to implement things. Wonderful, that's great. I'm looking on the chat whether there are some additional questions. I don't see any yet but let's wait for a few minutes or maybe my connection is not working. I don't know. Do you see any other questions? I have the problem that the only way to keep on with both I have, I need two different windows and I have to play with one to another to the other, one on which I'm transmitting and the other on which I'm getting. Yeah, I see your pain, definitely. Okay. Do you consider implementing protocol like multiple parts? I think it can be done. Sorry for interrupting. I would just like you to read the whole question for the people who are watching the stream because they don't. Okay, sure. Do you consider implementing protocols like multiple disappear alternative API like TAPS on top of using the virtual square components? I've created the infrastructure so over this infrastructure any other protocol can be added. Moreover, it's very nice of these architectures that you can add implementations at runtime. You don't need to have kernel support because all these support is at user level. So from this point of view, we are very close to the microkernel community. Other questions? Can you see other questions? Somebody is typing but it's not a question yet. So again, let's wait for a couple of minutes. Maybe somebody will get a question. As it's useful in the conference, I have to say thank you, Mr. Chairman. This sounds like a good amount of fun. For me, it is. It's a project I'm working on for I think more than 10 years now. Okay, so I don't see any more questions in the chat but of course after this session is over, the room which is associated with this talk will be open to everyone. So people can join, people can chat using text or even join the video conference. So okay, let's wait for one extra minute. Anyway, I'm at the post. I think today for the whole day and maybe the of the time tomorrow and my email addresses and contacts are available. So feel free to ask me questions anytime. I see that the bottom is typing. Let's see if some... Yeah, and I'm on two different windows. I can see that there is a delay between one and the other. Yes, there is definitely some latency in both in the stream and in the chat. The infrastructure is really struggling but at least we have the first live Q&A which is good. I was really anxious that we won't have anything live this year. We have to take into account that the FOSTA organization has done a great work to have this all this infrastructure working. It's not toy. Yes, definitely. I mean it's a huge effort and done mostly by volunteers so we are very grateful to everyone who contributed to this. Okay, I agree. I cannot agree more with Baudon. These components look great for network experimentation. Yes, it's wonderful. I see that I can combine all the components I need just by adding these elements one to the other. The problem is typing. Just to be clear, not yet IOT has been used by a project named Marionette by two professors Italian at Paris to Lotto and I can't remember the other name. They have created a graphical user interface to put virtual machines and switches and people can draw the infrastructure and given VDA the infrastructure became an actual virtual infrastructure just by typing start. So it's an example of experimenting. I've taken internet working quite a lot but working only with Linux. This works on Linux but it's another dimension on networking that you cannot do to the kernel networking support you actually have. Okay, thank you very much. I think we will wrap up this Q&A session. Thanks for all the questions. Thanks for your answers as well. People can surely reach you by multiple means. So thanks again and in about 10 minutes so at five past one we will have another talk from Normand Feske from Genome Labs. Thank you. Thank you so far and lots of good work. Bye. Bye.
API for the Internet of Threads. The attempt of sets. The idea of this talk is to provide means useful block exploitable in many situations. So implementations can be loaded inside this block and I add that this services should be provided configured, the stack can be used for the identifier of a stack, so the way to open to natural way to implement an API for natural interface does not provide specific entries libraries that can be used to configure the stack have implemented to have an Internet of threads the network data link letter identified by the suitable configuration so we have to set an IP library and an inline that is able to translate instead of socket the actual problem solving communication function and msocket instead of number of concepts and tools libraries to provide designed to interoperate, I think I missed one design libraries and tools to provide this kind support we are using for the data link layer and implemented stacks for partial virtual machines, there are several plugins, these are just some examples, we can connect virtual machines, Internet using a simple process, we can connect these implementations, stack implementations are connected to VDE, so there are several building the Berkeley Sockets functions with the same provide a way to write libraries that can this way it is possible to have the complete light library made of inline functions that route, delete a route, etc. the MAC address is library providing forging and decoding of netlink messages, there are several libraries but the new designed to provide also the support for the understand and process the requests for stack the request call specific function of the stack or to process the request using modules that then so we can provide the processes with different which is a trick actually, it's an example of designed for Internet of Thread. Support multiple usually implemented as a block but nothing blocks loaded as plugins or shared library one with the the infrastructure so over this infrastructure see any more questions in the chat but of course be clear, not yet IOT has been used by a project