Thank you for attending the meeting, this has been today, so I'm going to be basically
just playing how did I get into EPPF for us and so forth, and why rust.
I'm basically a Python developer, or you know, so I spend a lot of time working in open
stack, which is an open source for you may know.
So you may wonder why the hell did I switch from Python to Rust and so on, but first of
all, go with me, I just have some quick intro about EPPF how it does it work, if it's
going to be quick.
So basically, EPPF started out as a new backend for some package filtering, and
DLDR is a way to run user space code within the kernel, which makes it so much more efficient.
So how does it work?
Yes, super quick here, we got a user or a developer writing an EPPF program or an application,
then it gets compiled using a compiler such as LVM or whatsoever, and that gets into
a bad code, and then by code gets into, gets loaded by your EPPF library, and then it gets
too very far with what's heavily covered in the previous session, and it gets to adjust in
time compiler, which makes it so much more efficient, and that's why we get basically
like a machine code really, it's much more efficient here.
We also, then we attach our EPPF program to what it's called a hook, and a hook is basically
a set of system events such as thinking about like a sillium, a hook would be something
has happened in our sneak or something has happened in our system whatsoever, and then
we can call a series of what we call helper programs, such as for instance, I got an incoming
packet, and I just want to forward that to another sneak or whatsoever.
In order to sell, I also have like a set of maps, which is basically shared a structure
of memory in between the kernel space and the user space.
We're copying this a little bit, this is basically like we attach in a kernel space,
we attach to a BPM hook, network events, it's called whatsoever, we may write data into
maps, and the user space we deploy the program to the kernel, we may refer them up, and
they may map it itself, it's used to basically start, and the structure space is limited.
And then we here, you can see some super quick, then dirty, like a space, there we got
a topop program, it may use them up, this is an example, written up why some go library,
and then we got their compiler by fire and so forth, and this is fine so far, but I'm
going to be a developer, why should I use Rust or Python or go, or I guess there's even
some J about EDPF libraries, so we're last, we copy this a little bit, as I told
you before, I am already a Python developer, so I try using Python, people of BPM, because
what didn't work well, because first of all there is a BPM compiler for Python, called
BCC, which is BPM compiler collection, but the thing is that you need to basically go and
create your BPM programmer program as a string in Python, again, as you may know, Python
is not a compile language, so it's interpreted, and this is working a way, so whenever
it gets interpreted, it did go, compile a thing, and go along, and also this is some hobby
in the pre-cated, and then we got CF course, which may be the main language to use for
a lot of people when running and doing BPM, so we got BPM, it works, I'm not a CD developer,
I go lost a lot, so I decided this is not a good thing to use for others for me, and then
we got go, in the beginning I started using the BPM, I think what's cool to have, until
I realized that it's probably the first one that was in the terms of library, so also
the vocabulary, next, we got CD BPM, this one's very cool, so thank you for the
isolation guys, it's really one of my time, it works well, I can also do go development,
but I'm also working in some period, which I'll be speaking about later, called BPM, which
was already written in Rust, so I just said, okay, let's give it a try, so we got a couple
of libraries, lead BPM for AS, red BPM, if it's another one, which is no longer else
to maintain it, and A, so why A, so this is a really real native Rust-based BPM library,
so you may think about, hey, that's okay, but you probably be happy that it is dependent
on the BPM anyway, so why others?
We don't use that, this is using lip-cid, the dependencies are likely, and one of the things
that we would like about that is that, well, first of all, it allows you to do what it's called
BPM Core, in case you don't know what this is, it's compiled once, run everywhere,
so based, and also supports what most modern kernel in Linux distribution allow you, which
is like a BPM type system, which in between these two basically, they allow you to go
and create your programs, and run these in every Linux, which has the modern kernel, which
is very cool, so for example, the door of supports that, and you can get both CsFS calls
from their directly under all.
What else?
It does support ASync, for instance, Tokyo and ASync, if you don't know, they'll start
them, they'll start basically ASync to our libraries, so it was really cool, also, but besides
that, which you may think it's going to be cool, and it works well, so I'm happy with
ASync, what did you try to do ASync?
ASync has a lot of support in terms of templating, what do I call for templating?
Is there a kernel type of people, is there anybody here familiar with Gingertu?
Thank you so much, so if you're familiar with Gingertu, this is pretty much the same
or both templating, so we can create basically a BPM program in seconds, and I'll be
a demo, and if the network doesn't betray me, then you'll be seeing some XDP programs
in.
As I was saying, basically, we just need to install Rust, so if you depend on ASync, such
as SSL, that's all for us.
So let's take a look at that.
But let me know if you've found this big enough, and otherwise, I'll maximize it.
Is it okay?
Maybe we go?
How about now?
Mobby?
Now, I think so.
More?
Okay, now I'll make it up, so you need to go and start Rust, of course, and also
have an open SSL that's on the season so forth, and I'll go and besides Cargo and Cargo
Generate.
What the hell is this?
Cargo Generate 10?
So coming back here, here with me, this is what an A, a template looks like, if you're
familiar with any kind of templating languages, such as Gingertu, both templates and so forth,
you'll see that this is totally straightforward, so basically, substitute it, so we are going
to be pointing our Cargo Generate to this repo, and if then it works work, it will work
as well.
Okay, so let's be cognizant, oh no, EVPF, and you can select which kind of EVPF program you
like to trust.
So those are a couple of those, and you can also add your own if you're interested in
today's.
So I guess the most historical one, if you're going to be one XTP, which is done for
express data path, basically, some kind of network and thing.
Okay, so we just created one, which is called EVPF, but for the record, and I say it and
trust the laptop, and then network here, I created one just before hand, just in case.
So let me show you a good one.
Okay, this is what it looks like, and if you're interested in knowing what does it do,
getting back to the slides, again, I guess, then trust that, but basically it creates all
this can fall in for a program, which will be testing, let's see.
So let's start the program itself.
You can see that this is not working here, but basically you can also, the closing of the
AI, it's not only AI, but it's a capital of products that goes along with that.
So for instance, login in EVPF, it's maybe tough, and it's something you may need to
write on your AI, offers quite a couple of different surprises, as is AI log.
So we will be able to see a lot of login here for free, which it's also cool, specifically
for somebody who has never written any kind of EVPF program, and maybe not trust anymore.
Let's see here.
We can see with VPF tool that we are having one XTP program running here, if you can see
the upper most window, let's do something here, let's be a little bit, it works.
So congratulations.
We have been triggering our first VPF program in Rust in how much, to me, it's maybe five.
I think this is really cool, and I really encourage you to give it a try.
Let's speak all you need more about how does it works in the hood.
This all, of course, depends on how the template is being done.
This is open source, so you can create your own template and modify that, this is, for instance,
it requires you to use examples, you also got your entry points for, basically, the kind of
space in the user space, and of course, cargo and so forth, and also it offers a default
formatting file for Rust format, right in the way.
How done, well, I forgot to compare this, trick is I did it before hand, but let's give it a try anyway.
So this was precompiled, let's go to the other one, what was done before.
I was called ETPF, so try to build, we just do the trick for you, and just go and, well,
well, actually, networking here is quite decent, so thank you for them, it's requested me.
Anyway, so it'll just go build everything, you can do cargo check, and you'll see that you get
all the listing anyway.
So this is how, like the main application looks like, I'm running on XCP application, you can
see, of other, that it's just loading the Microsoft XCP in the binders for a year, it's also
using a lot of ETPF, and it's super simple, it's just basically a skin for a packet, okay,
versatile packet, then do that action, which would be called one of those helper function, I just go
beforehand. So also, getting back, you may want to say something more real, so we use that for
simple XCP program, which is doing nothing, it's pretty much like a hello world, but we are
also using this in BPM, which is a BPM loader, which I'll be speaking about tomorrow in the
distribution spectrum, you are interested, but this is using the for real, and you can see
sure that they're most of the. Besides that, we are trying to increase it to us, I'm being part of
the Fedora, EPPF's group, if you are not there, I really encourage to give you the try, please join us,
so far we have been in the identifier and BPM minus one of the first programs you package into Fedora,
Rust is coming with a lot of drawbacks in terms of packaging, because basically it's tough,
building all the dependencies, so for instance, we have a year-half like more than 200
dependencies, which weren't packets in Fedora, so there's no realistic way to handle that,
but anyway, we are interested, but I'll be happy to also speak with anybody who would be interested
into that not only for BPM model, but also for another BPM furniture.
And we just found that this last year, but I think it's really annoying. So, so far, I spoke a lot,
I showed you some examples, I spoke about the C group, but questions about that.
Go ahead.
Is it functional in the LX series with BPM particular?
Yeah, it aims to be, it's still not least 100 percent, but the ADS for AIA to be matching like a
feature compatibility with that, yeah.
Oh, yeah. Well, not use NAIA, AIA doesn't use BPM, but you can say switch over to another,
you know, Rust, library who uses like, LibbyPFRs.
Can also be, for example, if you have program written in C, and I sell older users,
but so vice versa, you can also write, if you have program in Rust,
I'll love it for another level of user experience.
I'm not sure if I can go on your main, but basically you'll be AIA,
I'll love you to use also parts of that. You can use the loader, and I'll also have
your NABPM program that you might like to be. I hope that as well as your question.
Yeah, go ahead.
Yeah, sorry. So he's asking about AIA, is having templates for any other events rather than network?
Yes, where is he? Yeah, there is a full repo about templates, so I mean, I'm more
infinite working, so that's what I was looking for, but it's not limited to that.
So you can just find templates for K probes, for U probes, for traffic control, and for a lot of
those, and if it's not there, we are encouraging you to try to build your own, of course.
Besides start, there's an annoying project called the AIA book, which covers the API and the
library and I think it's pretty cool.
So okay, if no more questions, and thank you so much for attending, I'll be enjoyed it,
and I'll do a part of that.