Parsen des Linux-Quellcodes epoll

int init_reactor(int listen_fd,int worker_count){
	......
	// Mehrere Epoll-FDs erstellen, um die Multi-Core-Funktionalität voll auszunutzen for(i=0;i<worker_count;i++){
		Reaktor->Arbeiter_fd = epoll_create(EPOLL_MAX_EVENTS);
	}
	/* epoll fügt listen_fd hinzu und akzeptiert */
	// Fügen Sie die Ereignisse nach dem Akzeptieren zum entsprechenden Epoll fd hinzu int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
	// Registrieren Sie den Verbindungsdeskriptor beim entsprechenden Worker epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);
}
//Arbeitsthread des Reaktors static void* rw_thread_func(void* arg){
	......

	für(;;){
		  // epoll_wait wartet auf Ereignisauslöser int retval = epoll_wait(epfd,events,EPOLL_MAX_EVENTS,500);
        wenn(retval > 0){
        	für(j=0; j < retval; j++){
        		// Lese-Ereignisse verarbeiten if(event & EPOLLIN){
                 führe eine Verbindung mit einem Computer aus, der eine Verbindung mit einem Computer herstellt.
                 weitermachen;
             }
             /* Andere Ereignisse verarbeiten */
        	}
        }
	}
	......
}

SYSCALL_DEFINE1(epoll_create, int, Größe)
{
	wenn (Größe <= 0)
		Rückgabe -EINVAL;

	gibt sys_epoll_create1(0) zurück;
}

SYSCALL_DEFINE1(epoll_create1, int, flags)
{
	// kzalloc(sizeof(*ep), GFP_KERNEL), nutzt Kernelspeicherplatz error = ep_alloc(&ep);
	// Den nicht verwendeten Dateideskriptor abrufen, d. h. den Steckplatz im Deskriptor-Array fd = get_unused_fd_flags(O_RDWR | (flags & O_CLOEXEC));
	// Ordnen Sie einen Inode im anonymen Inode-Dateisystem zu und holen Sie sich seine Dateistruktur // und file->f_op = &eventpoll_fops
	// und Datei->private_Daten = ep;
	Datei = anon_inode_getfile("[eventpoll]", &eventpoll_fops, ep,
				 O_RDWR | (Flags & O_CLOEXEC));
	//Datei in den entsprechenden Slot des Dateideskriptor-Arrays einfügen fd_install(fd,file);			 
	ep->file = Datei;
	fd zurückgeben;
}

/*
 * Diese Struktur wird in Datei->private_daten*/ gespeichert.
Struktur eventpoll {
	// Spin Lock. Verwenden Sie Spin Lock zum Sperren innerhalb des Kernels, damit mehrere Threads (Prozesse) gleichzeitig an dieser Struktur arbeiten können. // Hauptsächlich ready_list schützen.
	Spinlock_t-Sperre;
	// Dieses Mutex soll sicherstellen, dass der Dateideskriptor nicht entfernt wird, wenn die Ereignisschleife den entsprechenden Dateideskriptor verwendet. struct mutex mtx;
	// Die von epoll_wait verwendete Warteschlange bezieht sich auf den Prozess-Wakeup-wait_queue_head_t wq;
	// Die von file->poll verwendete Warteschlange bezieht sich auf den Prozess-Wakeup-wait_queue_head_t poll_wait;
	// Deskriptor-Warteschlange bereit struct list_head rdllist;
	// Organisieren Sie die Datei-Deskriptoren, denen aktuell Epoll folgt, durch eine Rot-Schwarz-Baumstruktur rb_root rbr;
	// Wenn Sie das Ready-Ereignis an den Benutzerbereich übertragen, verknüpfen Sie den Dateideskriptor des Ereignisses, das gleichzeitig auftritt, mit dieser verknüpften Liste struct epitem *ovflist;
	// Entsprechender Benutzer
	Struktur user_struct *user;
	//Entsprechender Dateideskriptor struct file *file;
	// Die folgenden beiden sind Optimierungen zur Schleifenerkennung: int visited;
	Struktur list_head besuchte_Liste_Link;
};

SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
		Struktur epoll_event __user *, Ereignis)
{
	/* Prüfen, ob epfd der Epoll-Deskriptor ist*/
	// Der Mutex dient hier dazu, gleichzeitige Aufrufe von epoll_ctl zu verhindern, d. h. die interne Datenstruktur zu schützen. // Sie wird nicht durch gleichzeitige Hinzufügungen, Änderungen und Löschungen zerstört. mutex_lock_nested(&ep->mtx, 0);
	Schalter (op) {
		Fall EPOLL_CTL_ADD:
			...
			// In den Rot-Schwarz-Baum einfügen error = ep_insert(ep, &epds, tfile, fd);
			...
			brechen;
		......
	}
	mutex_unlock(&ep->mtx);	
}

statische int ep_insert(Struktur eventpoll *ep, Struktur epoll_event *event,
		     Strukturdatei *tfile, int fd)
{
	/* Epitem initialisieren */
	// &epq.pt->qproc = ep_ptable_queue_proc
	init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);
	// Fügen Sie hier die Rückruffunktion ein revents = tfile->f_op->poll(tfile, &epq.pt);
	// Wenn ein Ereignis bereit ist, wird es am Anfang zur Bereitschaftsliste hinzugefügt
	// Zum Beispiel schreibbare Ereignisse // Rufen Sie außerdem nach der internen TCP-Bestätigung tcp_check_space auf und rufen Sie schließlich sock_def_write_space auf, um den entsprechenden Prozess unter epoll_wait zu wecken, if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) {
		list_add_tail(&epi->rdllink, &ep->rdllist);
		// wake_up ep entspricht dem Prozess unter epoll_wait if (waitqueue_active(&ep->wq)){
			aufwachen_gesperrt(&ep->wq);
		}
		......
	}	
	//Epitem in den Rot-Schwarz-Baum einfügen ep_rbtree_insert(ep, epi);
	......
}

// Fügen Sie die Ereignisse nach dem Akzeptieren zum entsprechenden Epoll fd hinzu int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
// Registrieren Sie den Verbindungsdeskriptor beim entsprechenden Worker epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);

statisches void ep_ptable_queue_proc(Struktur Datei *Datei, wait_queue_head_t *whead,
				 poll_table *pt)
{
	// Holen Sie sich das Epitem, das dem aktuellen client_fd entspricht
	Struktur epitem *epi = ep_item_from_epqueue(pt);
	// &pwq->wait->func=ep_poll_callback, wird zum Aufwecken des Callbacks verwendet // Beachten Sie, dass dies kein init_waitqueue_entry ist, d. h. der aktuelle KSE (aktueller, aktueller Prozess/Thread) wird nicht in // wait_queue geschrieben, da er nicht unbedingt vom aktuell installierten KSE aufgeweckt wird, sondern der KSE sein sollte, der epoll_wait aufweckt
	init_waitqueue_func_entry(&pwq->warten, ep_poll_callback);
	// Der Whead ist hier sk->sk_sleep, verknüpfe die aktuelle Warteschlange mit der Ruheliste, die dem Socket entspricht add_wait_queue(whead, &pwq->wait);	
}

SYSCALL_DEFINE4(epoll_wait, int, epfd, Struktur epoll_event __user *, Ereignisse,
		int, MaxEvents, int, Timeout)
{
	/* Überprüfen Sie, ob epfd das von epoll_create erstellte fd ist */
	//ep_poll aufrufen
	Fehler = ep_poll(ep, Ereignisse, Max. Ereignisse, Timeout);
	...
}

statische int ep_poll(Struktur eventpoll *ep, Struktur epoll_event __user *events,
		   int maxevents, langes Timeout)
{
	......
wiederholen:
	// Spinlock abrufen
	spin_lock_irqsave(&ep->Sperre, Flags);
	// Schreibe die aktuelle Task-Struktur in die Warteschlange zum Aufwecken // wq_entry->func = default_wake_function;
	init_waitqueue_entry(&warten, aktuell);
	// WQ_FLAG_EXCLUSIVE, exklusives Aufwecken, Zusammenarbeit mit SO_REUSEPORT um das Accept-Panik-Problem zu lösen wait.flags |= WQ_FLAG_EXCLUSIVE;
	// Link zur Warteschlange von ep __add_wait_queue(&ep->wq, &wait);
	für (;;) {
		// Den aktuellen Prozessstatus auf unterbrechbar setzen set_current_state(TASK_INTERRUPTIBLE);
		//Überprüfen Sie, ob der aktuelle Thread ein zu verarbeitendes Signal hat. Wenn ja, geben Sie -EINTR zurück.
		wenn (signal_pending(current)) {
			res = -EINTR;
			brechen;
		}
		spin_unlock_irqrestore(&ep->Sperre, Flags);
		// Zeitplan planen, die CPU aufgeben
		jtimeout = Zeitplan_Timeout(jtimeout);
		spin_lock_irqsave(&ep->Sperre, Flags);
	}
	// Hier wird angezeigt, dass der Prozess aufgrund einer Zeitüberschreitung oder eines ausgelösten Ereignisses neu geplant wurde. __remove_wait_queue(&ep->wq, &wait);
	// Setzt den Prozessstatus auf „Läuft“
	setze_aktuellen_Zustand(AUFGABE_LÄUFT);
	......
	// Prüfen, ob Ereignisse verfügbar sind eavail = !list_empty(&ep->rdllist) || ep->ovflist != EP_UNACTIVE_PTR;
	......
	//Bereitige Ereignisse in den Benutzerbereich kopieren ep_send_events(ep, events, maxevents)
}

statische int ep_scan_ready_list(Struktur eventpoll *ep,
			      int (*sproc)(Struktur eventpoll *,
					   Struktur list_head *, void *),
			      void *priv,
			      int Tiefe)
{
	...
	// Verknüpfe epfds rdlist mit txlist
	list_splice_init(&ep->rdlist, &txlist);
	...
	/* sproc = ep_send_events_proc */
	Fehler = (*sproc)(ep, &txlist, priv);
	...
	// Verarbeiten Sie ovflist, also das Ereignis, das im obigen Sproc-Prozess auftritt ...
}

statische int ep_send_events_proc(Struktur eventpoll *ep, Struktur list_head *head,
			       void *priv)
{
	für (eventcnt = 0, uevent = esed->events;
	     !list_empty(head) && eventcnt < esed->maxevents;) {
	   // Durchlaufe die Bereitschaftsliste 
		epi = Liste_erster_Eintrag(Kopf, Struktur epitem, rdllink);
		list_del_init(&epi->rdlllink);
		// Readylist zeigt nur an, dass in der aktuellen Epi ein Ereignis vorliegt. Die spezifischen Ereignisinformationen müssen noch die Umfrage der entsprechenden Datei aufrufen
		// Die Umfrage hier ist tcp_poll, das die Maske und andere Informationen entsprechend den Informationen von TCP selbst festlegt und die Ereignismaske von Interesse festlegt, um zu wissen, ob das aktuelle Ereignis das Ereignis von Interesse für epoll_wait ist revents = epi->ffd.file->f_op->poll(epi->ffd.file, NULL) &
			epi->Ereignis.Ereignisse;
		wenn(Ereignisse){
			/* Das Ereignis in den Benutzerbereich setzen */
			/* ONESHOT-Logik verarbeiten */
			// Wenn es nicht durch die Flanke ausgelöst wird, fügen Sie das aktuelle Epi wieder zur verfügbaren Liste hinzu, damit die Umfrage beim nächsten Mal ausgelöst werden kann. Wenn die Ergebnisse der nächsten Umfrage nicht 0 sind, kann der Benutzerbereich sie immer noch wahrnehmen*/
			sonst wenn (!(epi->event.events & EPOLLET)){
				list_add_tail(&epi->rdllink, &ep->rdllist);
			}
			/* Wenn es durch die Flanke ausgelöst wird, wird es nicht wieder zur Liste der verfügbaren Ereignisse hinzugefügt. Daher wird das entsprechende Epi erst dann in die Liste der verfügbaren Ereignisse aufgenommen, wenn das nächste verfügbare Ereignis ausgelöst wird.*/
			Ereigniscnt++
		}
		/* Wenn epoll_wait nicht an dem abgefragten Revents-Ereignis interessiert ist (oder überhaupt kein Ereignis vorliegt), wird es nicht wieder zur Liste der verfügbaren Ereignisse hinzugefügt*/
		......
	}
	gibt eventcnt zurück;
}

statische int ep_poll_callback(wait_queue_t *warten, vorzeichenloser Modus, int sync, void *Schlüssel)
{
	// Holen Sie sich das Epitem, das dem Warten entspricht	
	Struktur epitem *epi = ep_item_from_wait(wait);
	// Eventpoll-Struktur entsprechend dem Epitem struct eventpoll *ep = epi->ep;
	// Holen Sie sich den Spinlock, um die Ready_List und andere Strukturen zu schützen spin_lock_irqsave(&ep->lock, flags);
	// Wenn das aktuelle Epi nicht mit der Liste der bereiten Ereignisse von EP verknüpft ist, dann verknüpfen Sie es. // Auf diese Weise werden die aktuell verfügbaren Ereignisse zur Liste der verfügbaren Ereignisse von Epoll hinzugefügt, wenn (!ep_is_linked(&epi->rdllink)).
		list_add_tail(&epi->rdllink, &ep->rdllist);
	// Wenn epoll_wait wartet, wecken Sie den epoll_wait-Prozess auf // Das entsprechende &ep->wq wird durch init_waitqueue_entry(&wait, current) generiert, wenn epoll_wait aufgerufen wird // Das aktuelle ist die Prozessinformation task_struct, die dem Aufruf von epoll_wait entspricht
	wenn (waitqueue_active(&ep->wq))
		aufwachen_gesperrt(&ep->wq);
}

void sk_stream_write_space(Struktur sock *sk)
{
	// Das heißt, das Schreibereignis wird nur ausgelöst, wenn 1/3 des Schreibspeicherplatzes vorhanden ist, if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
		: Clear_Bit (SOCK_NOSPACE, &sock->Flags);

		wenn (sk->sk_sleep und waitqueue_active(sk->sk_sleep))
			unterbrechungsfähige Aufwachumfrage(sk->sk_sleep, POLLOUT |
						POLLWRNORM | POLLWRBAND)
		......
	}
}