Bestand wählen
Merken

May contain DTraces of FreeBSD

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
that was the end
of this and and the have to have a sorry about that on the merits of all predictors of like the 1 that so this is a little had some of this is going to be the only slide i'm going to stories they so slide on because I think doing stuff like that and eternal might be a little bit more interesting for you but sadly something is getting cut off so we have to improvise a little bit but anyway so so they'll be able to talk about 2 of my favorite things right now which are of previously in the trace but this targeting got down to 30 minutes so we focusing a little more on the distress part so there will be a little bit less busy than I anticipated and also I just everything a little bit to fit better into the resilience so for you enjoy that so before you begin on who years actually using the trace I'll more than I expected but still not as many of them would like to see so hopefully after the start you will think this is a really awesome tool I because totally love it to change the way I the last so for those of you don't know what the traces 1st let me show you know stuff so as source it originated on Flores and been developed early on in the most which is a fork from OpenSolaris has imported to previous the net is the always acts on there is also a powerful Linux called the trees Linus's figures of personal Paul Fox of imported to QNX and on the open you see folks a currently doing some work to get that signal at the technology like the trees on their systems the and offered their support for Windows 7 of this is actually true but it is it's can cool because then that means it's basically everywhere so most of you would probably know static tools like S. trace we have a very similar to on previously let us call trust and what trust industries are doing is you can attach into process and will get the system call that the cost of this process is emitting thinking something's going wrong you can walk look inside of the program which can be become a useful when you're trying to find a problem the on it's it's can any but is also pretty limited is 1st of all it really really slows down the process that you can't get looking at so if you wanna debugger performance issue you pretty much a lot there and on also it's it's it can like narrow down you can just look at 1 process which is also like a bad thing because the system that we currently have all these systems or there are very complex we have a lot of layers you virtual file systems you have version memory you network you have databases processes communicating with each other in case you're using a high-level programming language you might also have a runtime system so it's a little operating system on top of your operating system so if something goes wrong in a system that has set such large complexity something happens that we call the binding in the blame game but it's never your fault it's always someone else's so what we wanna be able to do is when you look at the system as a whole so we can correlate all the data and come up with some meaningful answers when something is really going on and also we don't want we don't wanna switch out all the processes for debug processes to make that happen because as these things are all every problem happens in production and never happens on the development box so like switching out all the processes that totally of picture on so to do that in an arbitrary way to like instrument the system in an arbitrary way we saw like a new programming language so we need to describe when that happens please in the data so I can see what's going on so that this kind of implies a programming language and the fish comes with such a programming language it's a little bit reminiscent of park across with C O is very simple to learn you can pick it at 20 up the pick it up and 20 minutes and again sort turning out 1st the transcripts the so like all Augustino OCR arc can be used to analyze large bodies of text is the phrases primitive thing before system behavior so will that mind-boggling but probably attend can show you what I mean by that but it also as a bonus we don't wanna slow down the system so we wanna be able to do things like performance divide things says that said I 1st
approached this little demo here and on so since we have sentence issues you're probably this is not I have to play around a little bit some 1 of them to do is I'm going to look at a very very naive way to of excuse me for a 2nd very naive way in to the so all so the anyway to authenticate a user and there's a lot of wrong with this code but like what we're going to do is we're going to take you use a string as input and then we're going to discuss and compare it to on others to secret so I know that this figure is in year is like in plain text and uh this is a problem but this is a little bit artificial but out just wanna get my point across so from an algorithmic perspective this check function is correct so we take a string with a kind of string and we compare the everything's fine and he's so as you look at the way string compare works and what it does is it it's essentially in taking these 2 strings and is comparing every character it by the so when it finds the 1st pair of characters that do not match up it's going to stop so we can consider we can conclude something about from that so if it takes very short if if this function this check function takes a very short amount of time then what will happen is it will terminate earlier and of our POWs would guess is better it will take a while it will take longer and then measure that we can basically extract information from that running over so I wrote a little driver program in Haskell so that basically just iterates over an alphabet and just see this 1 letter into into that program and I'm going to use the phrase to get some time information the so let me start the driver so this is now just running in the background and cannot see with taking there but don't worry the scripts will all be but I will put some of my get up so the phrase now produces this nice little distribution so if you rule areas were able to see the entire alphabet you would see that everything except the behaves differently so if you squint a little what you see there is the trace of the letter takes a couple of nanoseconds seconds longer this is the precision they're measuring here 10 to the minus 9 seconds really precise and the takes longer than everything else take full account of their but trust me the and know gonna trumpets and so on yeah and from that was just the enter a letter and now but cost were and now the strip clears everything is going to guess next of sadly this is cut off because on you will see that this distribution radically changed it'll it looks completely different and so we we we can play a game little bit so let's just let's us role that and I every 3 seconds descriptors going to recompute on that looking at the new distribution and you can probably see where this is going so here the see OK and notice to it just takes about like 3 seconds for me to guess on the next letter so and this is not a problem that is that that is the only of something that happens when you think about this can happen with with basically everything so it's a especially in things like cryptographic stuff where you don't wanna have some information leaked out so on this is what we call a tiny side-channel attacks so are mind I could spend I could is we use the phrase to analyze the real binary so I didn't change the binary did have some some the bucket there this is like the actual binary that I would put into production so what's important about that stint take the actual binary is some of these these times sigh gentlest might be introduced by compiler optimizations and when you insert the buck rode into that but into that code there might actually go away so you wanna look at the real cold that you're putting into production I I will show you the script that I
came up with to write that so there are 3 interesting things In the script so and and the worry this is this is the more complicated example I just wanna like inspire you ideas because the the the things that you can do with the face of pretty much the sky's the limit can cannot come up with the weirdest ideas and I so there's more complicated example I'm going to show you simple was so to demonstrate how we got 3 interesting things in this case the first one is something that we call approach so probe is a point of instrumentation in the system so whenever a certain event happens in the system the spread is going to fire and in this case the begin probe white marks the state and those are the moment when the script starts so the 2nd interesting thing is this class so this clause is basically what this probe is going to execute what was going to be executed once that probe fires so it's a little is a little block of current ends this this probable but more interesting because of it is tells us something about the structure of how such a probe looks like because every every probe is uniquely identified by a for topic so it's like 4 components that uniquely identifies approach and the first one the scope of the 1st part of this this multiple got the provider I'm going to talk about providers and couple seconds what they are the 2nd is called the module for 1 is called the function and the last 1 is called the name so these 4 the pieces of data of like they they they identify approximately so the 3rd thing that is interesting here is sadly something that I don't have time to talk about today and this is called an aggregation and on this single line that you see here is essentially responsible for accumulating all this data to print out these distributions to to generate this distribution so this is this is built into detracts you don't have to do that yourself as as it is when you will get the descriptors dislike like it's 42 lines of code and and I came up with the 1st prototype after 5 minutes so it's it's it's not a lot of stuff to do to get something out of it so it's very useful to have things you will use that if you use the distress you will use this a lot for performance debugging so kind of neat that we have so yeah I was struggling with about
providers and this will probably be also will be cut off so I'm going to choose a
little bit here just going to double that so let's talk about providers so there are a couple
providers all that any on so I get 27 providers here and the number of providers vary from operating systems operating system blood on so these are the ones that I can see right now the other providers they can be our come into existence when you demand them so have these 27 providers and we're going to look at the syscall provider and the FPT provider 1st so every provider knows how to instrument a specific part of the system so this is called provider knows how to instrument this is called table that's not very surprising so if you you can look at the skull provided and here you can see essentially every system call entry and return that is in that of previously office so on theory can see this for sample like the providers all the this is the module and so on so these are all the system calls that I have in my system and the the other
provided a look at is the so-called FPT provider and that is pretty astonishing the FPT provide FPT central function boundary tracer and what it allows us to do it allows us to trace every single function in the current so you look at the entire kernel and functions as they are being called so to illustrate that I wrote a little very simple the transcript and this is probably so you will get the upper half please so this is probably 1 of the 1st depressed strips you will come up it's it's fairly simple example breakdown so I'm going to instrument the and that's system call for those of you don't know what the end system call is what you can do with it it's again so you can take a file and map that into the other space space of the process so very dumbed down version and so whenever we enter the EMEP system call we're going to set the variable follow to what and what this self at means is essentially a threat local variable and we're going to associate that variable with the threat that were currently inspecting then I'm going to do something pretty that that that sounds scary but I'm going to instrument the entire kernel every function entry and every function return and Empty instrument that and say please and data when you do that and this is what we call a predicate so this would be talking this of of the defense programming was coming comes and so this is a predicate and what when ever that evaluates to true then the proper going to 5 so in this case when we're are in the threat that record of tracing we're going to image data and this is just an empty clause and we just wanna know hey we got here so when we enter the exit the emic system and the predicate is set we're going to set
the variable followed to 0 because every uninitialized variable in the trace is set to 0 and so this pretty much announced the allocating that variable and then we're going to exit so around that and so it
takes a couple seconds and boom the solid pause here that was when the to does the interface got reverted the driver that the that the kernel so now you can see it every function
call that happens inside the and accessible as a little bit hard on the eyes so
let me pass the like here and now we can have a nice and nice to read annotation so now you might say like that you're injecting code into the kernel that is that something dress and yellow and but my blemishes something that I find really interesting so this I'm not going to much into depth here but on this is a biker for every teacher strips gets compiled to bytecode In this by code gets into the kernel and in the kernel give a virtual machine that interprets that biker so in case you write a script that for some reason I go rogue on your kernel types allocates too much memory takes too much time on this version machine can just say OK uh stop at the and just going to revert all the changes that happened to kernel and that's kind and is not a new idea city using tcpdump it's basically the same approach they also have this kind of by so this just a little excursion use call PDF worked packet of so if it's not in and not an entirely new idea so everything I show you until
now was on pay I'd I can look when function call that happen that's not very much information so we're going to increase the amount of information that we get out of the system I'm with every example so let me look at the actual kernel so I had to restart machine so my set of is basically gone now so let's look at the
SVM-Fold function so this is on this is the source code of the operating system them running right now this is previously current lot 12 and under the V unfold function on the remember the and that's a so called and told you see without the them via maps system call you at all you can bring like not a file into your address this and it doesn't necessarily have to load the entire file so whenever we are touching the page and the system like memory page that's and this machine is for kilobytes since it's of no no supra pages here so um whenever touches a piece of memory that you didn't bring into memory and we generate something that's called a page fault and then this function it's called yeah so you're us look at the arguments and I'm going to skip the zeroth argument form to will get the 1st argument so this is address that provoked that's on that page fault is the type and these are the flights and going to show you something to to make that more readable so what this was so this is the it's a pointer and this is a big structure so we won't be able to look at that structure and um
induced of a problem which do this so let's look at 3 and 4 of script so services the and this so this is don't pay too much attention to this curve this this is basically just boilerplate play to make makes of readable and this is where the actual action is happening so this this on so what I'm doing there is on on instrumenting the VM function and leverage whenever we enter it that we're going to use some information that the traces of free so this is X acclaim this is the name of the currently running executable that provoke a page fault this is the process ID and here we have a bunch of argument variables so the SPARQL 1 . 2 . 3 that are essentially just integers so nothing too fancy there the net we wanna look we wanna be able to look at that structure the in here are going to use this this this artist rate and this art arrays can a special because it has typing information about the arguments so when you run that so when you
referencing that pointer there with the stock thank you ends this is right but and maybe registered to start that the so this is this is an in kernel data structure that we can now look
at so the face enabled us to look at in memory data structures as the system runs it is really really really top of all in the defense could I could use all these fields like I'm and I can manipulate this array this value in there just like just like every hour and every other variable can pretty much work like I was in so I was doing that and there is something that's called CTF that's not capture looks like it's from this is that the shape of the on complexity tracing format frequency see that but there's a man patent-free BSD and there's a little segment in the kernel binary where all this typing information is stored and allow that compares to modern dwarf but yet this this is what the trace working so now you might ask yourself why most where do that 1 of well look at version memory you see out on this surface safe that the numbers in there except when they
are of and when members of a the Member State account so this was a very
nasty vulnerability in other external and that that that was a problem in virtual memory management so it allowed you to write to file that you did known as a regular user answer you could essentially just write a binary that have set UID set on very unpleasant but I'm not going to best what folks here this is just as well as to these things are hard on and the 1st fix for this problem was in 2005 and then came back in 2016 for that fixed and then
they came back with usually gallon 2070 so on this is I mean this this was there and therefore way over a decade these things are hard to debug and um this is what I like about the system so not having not having tools like the trace to to to figure out what's going on inside the system sum up to me amounts to secured about obscurity and I have heard that some people are developing exploits for systems that the trees they say all I really like developer export from these systems because that doing so great but yes to be honest with school because what is it about their exploit proof of concept and coming up with these exp was quickly is very usable because you know what's going on you can't show hate this is going wrong I had had situations where people were telling me all is this this is not a problem with our program does this weird operating system that you're using white Solaris weird operating system and on the up and then I turned out some teachers tips and notes it's actually you probably old now to on my Linux boxes magic so everything
that show young so now from was very very much related to function calls and on we want we want have a little more semantics here because you might wanna write those strip that on inspects like protocols stuff for TCP UDP stuff like that so you don't wanna know which function inside of the kernel is responsible for handling your TCP IP such so the
trace comes with some something that's called static providers and on
skin show the operable here so these are also every static provider has a man page which is kind of any documentation who on and you can see there is an I provider if you are interested in looking at this guy OIP for looking at I P V 4 keep seeks tcp in this was
pretty cool if some about scheduling behavior so what does my skinny audio and if you look at that and see some some interesting stuff like Borland priority if you ever saw things like priority inversion stuff like and now you can see that happen unmanured offenders interesting for some reason of some it was a pretty interesting to what figure out what what's what's going on when y is this getting the scaled all the time so some interesting things going on that so um I'm running a little runtime Yearbook of I I I just putting on a show you something is all kinds of stuff for him can we do that with you space course so there was 1 provider that didn't show up when I had my provide a listing but was in the D-tree strips where that this timing Texas and that's called the PAT provided and the PD provider generates proves on demand because process might have a lot of frogs and you will surely see why and this is why I'm going to use a very small program which is called true and true just Texas exits with Mexico 0 so into exciting going on here and this was a dollar a target gets us up to and we get the process ID and this is everything that happens when and
executing this program is a little more fine-grained than the FET provider because now we can trace every single instruction inside of that function which is kind of any axis is is a scriptable debugger and so these numbers are the instruction offsets inside of that function we can also look at so this is
everything in the true segment also look at libraries that government and and so
there's a lot of stuff happening in that force when you run through so 1 last thing I want to show you because it consumes like a week of my life um am
using a lot of Haskell and the Mac OS people but they also have the phrase and they have a GHC Haskell different support so the Glasgow Haskell compiler and on glorious excuse me um they have probes to analyze what's going on inside of the runtime system so I thought I 1 have that i the trace why does that work on on the BST so but after a week of fighting with files and linkers on those words if you check out the reasons are due to repository and build its on previously you get all the nice stuff only to show you know so this is very boring program just starts on 30 to print threats and skidoos them all over the place and I can do something like this I can bring the telephone no you the interesting thing is also on use wildcards and not S the name of the probe and this is what was going on inside of GC Dorotea covers collection and always and I can look at this and write useful the transcripts that also take my are right system into account so and stuff like that exists for I think Python I'm not so sure because it and use it I know JS same on post press I use this but not with the federal and where vanishing Firefox arm when you run the just strips in your Firefox on it actually has a provider so can trace John strips running in your browser with the trace so after everything I just showed you that might there might be some stuff going on there 3 officers this is basically everything I wanted to show you think I'm going to wrap out because otherwise we're not going to have a lot of time for questions and maybe have some so now thanks if
you have information that we or actually time already but we have 2 more minutes because we started 3 minutes late so there are any really quick questions mostly from the internet there is 1 the a of says let's hear it yeah hi animal the question is now which changes actually necessary to do in the kernel of an operating system to support the trees that have lower so it's not something like a during weekend on this so on those of personal story the work and for abuse the ocelli pathway now of God on that I think they it took a couple years to have everything in place so you have to have stuff like the city of the thing that I showed you which is what you see is currently working on and then you have new you all those those magic is most likely kernel modules and stuff like that so it it takes a lot of time but it is important to most operating systems that are available and in use for now fourier optics answers the question excellent and there are no more questions here in the room my I will thank i cool and you can find my side of the room and also on Twitter and RAID ch below it and if you have an awful question was what is that that
it is and the and the the at at
Bit
Prozess <Physik>
Gewicht <Mathematik>
Virtualisierung
Existenzaussage
Quader
Versionsverwaltung
Komplex <Algebra>
Kreisbogen
Hydrostatik
Netzwerktopologie
Geschlossenes System
Spieltheorie
Netzbetriebssystem
Bildschirmfenster
Dateiverwaltung
Primitive <Informatik>
Optimierung
Softwareentwickler
Figurierte Zahl
Programmiersprache
Datenhaltung
Laufzeitsystem
Systemaufruf
Quellcode
Biprodukt
Quick-Sort
Teilbarkeit
Rechenschieber
Höhere Programmiersprache
Festspeicher
Debugging
Mereologie
Ablaufverfolgung
Distributionstheorie
Bit
Demo <Programm>
Punkt
Momentenproblem
Minimierung
Compiler
Klasse <Mathematik>
Information-Retrieval-System
Zeichenvorrat
Binärcode
Service provider
Code
Pufferspeicher
Geschlossenes System
Authentifikation
Spieltheorie
Perspektive
Kryptologie
LASER <Mikrocomputer>
Inverser Limes
Skript <Programm>
Seitenkanalattacke
Datenstruktur
Optimierung
Figurierte Zahl
Gerade
Prototyping
Lineares Funktional
Zwei
Strömungsrichtung
p-Block
Ein-Ausgabe
Biprodukt
Modul
Ereignishorizont
Druckertreiber
Flächeninhalt
Komponente <Software>
Mereologie
Ruhmasse
Information
Aggregatzustand
Neuronales Netz
Zeichenkette
Bit
Systemaufruf
Zahlenbereich
Modul
Systemaufruf
Steuerwerk
Service provider
Physikalische Theorie
Eins
Office-Paket
Netzwerktopologie
Geschlossenes System
Existenzsatz
Mereologie
Stichprobenumfang
Computerschach
Tabelle <Informatik>
Zentralisator
Lineares Funktional
Prozess <Physik>
Profil <Strömung>
Versionsverwaltung
Systemaufruf
Elektronische Publikation
Systemaufruf
Service provider
Raum-Zeit
Kernel <Informatik>
Arithmetisches Mittel
Mapping <Computergraphik>
Prädikat <Logik>
Datensatz
System F
Geschlossenes System
Optimierung
Ganze Funktion
Bildgebendes Verfahren
Magnetbandlaufwerk
NP-hartes Problem
Lineares Funktional
Zwei
Mathematisierung
Versionsverwaltung
Systemaufruf
Dichte <Stochastik>
Marketinginformationssystem
Code
Kernel <Informatik>
Virtuelle Maschine
Druckertreiber
Fahne <Mathematik>
Latent-Class-Analyse
Festspeicher
Datentyp
Skript <Programm>
Verband <Mathematik>
Schnittstelle
Lineares Funktional
Parametersystem
Maschinenschreiben
Adressraum
sinc-Funktion
Systemaufruf
Quellcode
Elektronische Publikation
Homepage
Kernel <Informatik>
Mapping <Computergraphik>
Virtuelle Maschine
Bildschirmmaske
Geschlossenes System
Menge
Netzbetriebssystem
Festspeicher
Datentyp
Information
Zeiger <Informatik>
Datenstruktur
Magnetbandlaufwerk
Parametersystem
Lineares Funktional
Prozess <Physik>
Gewicht <Mathematik>
Dezimalbruch
Gruppenoperation
Summengleichung
Bitrate
Ausgleichsrechnung
Steuerwerk
Kernel <Informatik>
Homepage
Dienst <Informatik>
Variable
Videospiel
Skript <Programm>
Strebe
Information
Zeiger <Informatik>
Datenstruktur
Kurvenanpassung
Textbaustein
Benutzerführung
Array <Informatik>
Shape <Informatik>
Programm/Quellcode
Versionsverwaltung
Zahlenbereich
Binärcode
Komplex <Algebra>
Frequenz
Kernel <Informatik>
Motion Capturing
Variable
Datenfeld
Geschlossenes System
Festspeicher
Dateiformat
Information
Datenstruktur
Aggregatzustand
Metropolitan area network
Humanoider Roboter
Server
Gewichtete Summe
Quader
E-Funktion
Patch <Software>
Information
Exploit
Sichtenkonzept
Binärcode
Netzwerktopologie
Datenmanagement
Exploit
Regulärer Graph
Geschlossenes System
Netzbetriebssystem
Beweistheorie
Softwareschwachstelle
Mehrrechnersystem
Virtuelle Adresse
Softwareentwickler
Optimierung
Versionsverwaltung
Beobachtungsstudie
Inklusion <Mathematik>
Familie <Mathematik>
Eindringerkennung
Unterring
Protokoll <Datenverarbeitungssystem>
Programm/Quellcode
Menge
Kernel <Informatik>
Formale Semantik
Datenstruktur
Zustandsdichte
COM
Typentheorie
Strebe
Chipkarte
Kernel <Informatik>
Stellenring
Unterring
Prozess <Physik>
Raum-Zeit
Service provider
TUNIS <Programm>
CLI
Typentheorie
Strebe
Umkehrung <Mathematik>
Flächeninhalt
Optimierung
Figurierte Zahl
Ereignishorizont
Zehn
Inklusion <Mathematik>
Prozess <Informatik>
Programm/Quellcode
Rechenzeit
Volumenvisualisierung
Mailing-Liste
Gerade
Scheduling
System F
Wurzel <Mathematik>
Mini-Disc
Compiler
Bitrate
Benutzerführung
Lineares Funktional
Unterring
Prozess <Informatik>
Programm/Quellcode
Zahlenbereich
Kartesische Koordinaten
Service provider
TUNIS <Programm>
Typentheorie
Debugging
Statistische Analyse
Programmbibliothek
Evolutionsstabile Strategie
Optimierung
Benutzerführung
Objekt <Kategorie>
Subtraktion
Unterring
Browser
Compiler
Hochdruck
Programmschema
Service provider
Homepage
TUNIS <Programm>
Geschlossenes System
Typentheorie
Statistische Analyse
Ordnungsbegriff
Optimierung
Airy-Funktion
Inklusion <Mathematik>
Videospiel
Lipschitz-Bedingung
Schreib-Lese-Kopf
Programm/Quellcode
Laufzeitsystem
Abstimmung <Frequenz>
Binder <Informatik>
Elektronische Publikation
Gesetz <Physik>
Office-Paket
Portscanner
Thread
Forcing
Rechter Winkel
Dynamisches RAM
Wort <Informatik>
Persönliche Identifikationsnummer
Ablaufverfolgung
Inklusion <Mathematik>
Objekt <Kategorie>
Prozess <Informatik>
Disk-Array
Programm/Quellcode
Programmschema
Modul
Technische Optik
Isolation <Informatik>
Kernel <Informatik>
Internetworking
Portscanner
Netzwerktopologie
Hypermedia
Medianwert
Systemprogrammierung
Twitter <Softwareplattform>
Geschlossenes System
Typentheorie
Netzbetriebssystem
Bildschirmschoner
Grundsätze ordnungsmäßiger Datenverarbeitung
Information

Metadaten

Formale Metadaten

Titel May contain DTraces of FreeBSD
Serientitel 34th Chaos Communication Congress
Autor raichoo
Lizenz CC-Namensnennung 4.0 International:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.
DOI 10.5446/34892
Herausgeber Chaos Computer Club e.V.
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Systems are getting increasingly complex and it's getting harder to understand what they are actually doing. Even though they are built by human individuals they often surprise us with seemingly bizarre behavior. DTrace lights a candle in the darkness that is a running production system giving us unprecedented insight into the system helping us to understand what is actually going on. We are going implement `strace`-like functionality, trace every function call in the kernel, watch the scheduler to its thing, observer how FreeBSD manages resources and even peek into runtime systems of high level programming languages. If you ever wondered what software is doing when you are not looking, this talk is for you.
Schlagwörter Resilience

Zugehöriges Material

Folgende Ressource ist Begleitmaterial zum Video
Video wird in der folgenden Ressource zitiert

Ähnliche Filme

Loading...
Feedback