Ich versuche etwas Arbeit mit inotify zu machen und C im Allgemeinen besser zu verstehen. Ich bin sehr Neuling. Ich schaute über die Inotify-Man-Seite und ich sah ein Beispiel für Inotify. Ich habe einige Fragen darüber, wie genau sie Puffer verwenden. Der Code ist hier:Kannst du erklären, wie diese Pufferlogik funktioniert?
http://man7.org/linux/man-pages/man7/inotify.7.html
Der Block Ich bin am meisten interessiert ist:
char buf[4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;
/* Loop while events can be read from inotify file descriptor. */
for (;;) {
/* Read some events. */
len = read(fd, buf, sizeof buf);
if (len == -1 && errno != EAGAIN) {
perror("read");
exit(EXIT_FAILURE);
}
/* If the nonblocking read() found no events to read, then
it returns -1 with errno set to EAGAIN. In that case,
we exit the loop. */
if (len <= 0)
break;
/* Loop over all events in the buffer */
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len) {
event = (const struct inotify_event *) ptr;
Was ich versuche zu verstehen, wie genau die Verarbeitung der Bits in diesem Puffer sind. Das ist was ich weiß:
Wir definieren eine char buf von 4096, was bedeutet, dass wir einen Puffer nur über 4 kb Größe haben. Wenn der Anruf read(fd, buf, sizeof buf) und len wird irgendwo von 0 bis 4096 sein (Teillesevorgänge können auftreten).
Wir tun einige asynchrone Überprüfung, das ist offensichtlich.
Jetzt kommen wir zur for-Schleife, hier bin ich ein wenig verwirrt. Wir setzen ptr gleich buf und vergleichen dann ptr s Größe zu buff + len.
An diesem Punkt entspricht ptr dem Wert '4096'? Und wenn ja, sagen wir; ist ptr: 4096 < buf: 4096 + len: [0-4096]. Ich verwende hier einen Doppelpunkt, um anzuzeigen, was ich denke, der Wert der Variablen ist und [] bedeutet einen Bereich.
Wir dann als Iterator Ausdruck, erhöhen ptr+= die Größe eines Inotify-Ereignisses.
Ich bin an höhere OOP-Sprachen gewöhnt, in denen ich einen Puffer von 'inotify_event'-Objekten deklarieren würde. Allerdings nehme ich an, da wir gerade ein Byte-Array von 'read' zurückholen müssen, müssen wir die Bissen an der 'inotify_event'-Grenze abziehen und geben diese Bits in ein Event-Objekt ein. Klingt das richtig?
Auch ich bin mir nicht genau sicher, wie Vergleich mit einem buf[4096] Werte funktioniert. Wir haben kein Konzept, um die aktuelle Größe eines Arrays zu überprüfen (allozierte Indizes), also nehme ich an, wenn wir im Vergleich dazu die Größe des zugewiesenen Speicherplatzes '4096' in diesem Fall vergleichen?
Danke für die Hilfe, das ist mein erstes Mal wirklich mit der Verarbeitung von Bits aus einem Puffer. Ich versuche, all das in den Kopf zu bekommen. Jede weitere Lektüre wäre hilfreich! Ich habe eine Menge gelesen über C als Sprache, eine gute Menge über Linux-Systeme Programmierung, aber ich kann nicht scheinen, Themen wie "Arbeiten mit Puffern" oder die Grauzone zwischen den beiden zu finden.