Nginx-Quellcode-Studiennotizen (20) – Ereignismodul eins – Initialisierung

Nachdem ich die vorherigen Studiennotizen gelesen habe, glaube ich, dass ich ein gewisses Verständnis für den Startvorgang von Nginx habe. Von diesem Abschnitt an möchten wir uns eingehend mit den einzelnen Modulen befassen und die Hauptoperationen in jedem Modul erlernen.

Dieser Artikel stammt von: http://blog.csdn.net/lengzijian/article/details/7598996

Lass uns heute lernen. Lass uns Laden Sie das Ereignismodul herunter. Im vorherigen Start haben wir den Aufruf der Hook-Funktionen jedes Moduls mehrfach erwähnt. Erinnern wir uns zunächst an die Ausführung der Hook-Funktion des Ereignismoduls, die auch der Schritt zum Starten des Ereignismoduls ist:

1. Conf(create_conf) erstellen:

ngx_event_create_conf()

Diese Methode erstellt hauptsächlich eine ngx_event_conf_t-Struktur und weist Speicherplatz zu.

2. Lesen Sie die Konfigurationsdatei:

Die gelesene Datei enthält beispielsweise die folgenden Zeilen:

[cpp]-Ansicht Klartext?

1. Ereignisse 
2. { 
3. use epoll;
4. worker_connections 10240;
5. } Lokale Ereignisse sind eine Blockanweisung, die in geschweiften Klammern konfiguriert werden kann /event/ngx_event.c

[cpp] Ansicht Klartext?

statisch

ngx_command_t ngx_event_core_commands[] = {

1. { ngx_string(
"worker_connections"
2. ),
3. NGX_EVENT_CONF|NGX_CONF_TAKE1, ngx_event_connections,
4. 0,
5. 0,
6. NULL } ,
7. ...(hier weggelassen)
9. { ngx_string(
"connections"
10. ),
11. NGX_EVENT_CONF|NGX_CONF_TAKE1, ngx_event_connections,
12. 0,
13. 0,
14. NULL },
16. { ngx_string(
"use"
17. ),
18. NGX_EVENT_CONF|NGX_CONF_TAKE1, ngx_event_use,
19. 0,
20. 0,
21. NULL },
22. ngx_null_command
23. };
25. Wenn Ereignisse analysiert werden, wird die folgende Funktion zurückgerufen:

[cpp] view Klartext?

1. src/event/ngx_event.c  
2. statisch  char *  
3. ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)  
4. {  
5.     char                 *rv;  
6.     void               ***ctx;  
7.     ngx_uint_t            i;  
8.     ngx_conf_t            pcf;  
9.     ngx_event_module_t   *m;  
10.   
11.     /* zähle die Anzahl der Ereignismodule und richte deren Indizes ein.*/  
12.     //计算event模块数量，并且记录  
13.     ngx_event_max _module = 0 ;  
14.     for (i = 0; ngx_modules[i]; i++) {  
15. if (ngx_modules[i]->type != NGX_EVENT_MODULE) {  
16.             Weiter;  
17.         }  
18.   
19.         ngx_modules[i]->ctx_index = ngx_event_max_module++ ;  
20.     }  
21.   
22.     ctx = ngx_pcalloc(cf->pool,  sizeof(void *));  
23.     if (ctx == NULL) {  
24.          return NGX_CONF_ERROR;  
25.     }  
26.     //为每一个event模块分配空间，用来保存响应配置结构的地址  
27.     //共分配了ngx_event_max_module个空间  
28.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));  
29.     if (*ctx == NULL) {  
30.         return NGX_CONF_ERROR;  
31.     }  
32.   
33.     *(void **) conf = ctx;  
34.   
35.     for (i = 0; ngx_modules[i]; i++) {
36.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {  
37.             weiter;  
38.         }
40. m = ngx_modules[i]->ctx;
41. //Rufen Sie die Hook-Funktion creat_conf jedes Moduls in einer Schleife auf, um die Konfigurationsstruktur zu erstellen
42. ->create_conf) { (*ctx)[ngx_modules[i]->ctx_index] = m->create_conf(cf->cycle);
if
44. ((*ctx)[ngx_modules[i]->ctx_index] == NULL) {                                                                                                    >                                                                          
45. }
46. pcf = *cf;
47. cf->ctx = ctx;
48. cf->module_type = NGX_EVENT_MODULE; F; eine Blockanweisung, viele andere Anweisungen können unter der Ereignisdomäne konfiguriert werden,
50. //Zum Beispiel die zuvor erwähnte Verwendung usw ., beginnen Sie nun mit dem Parsen der Anweisungen im Ereignisblock und schließen Sie die Initialisierungsarbeit ab.
rv = ngx_conf_parse(cf, NULL);
*cf = pcf;
55. if (rv != NGX_CONF_OK)
56. Rückgabe rv;
58.  für
(i = 0; ngx_modules[i]; i++) {
60.  if (ngx_modules[i]-> Typ != NGX_EVENT_MODULE) {
61. }                                                    Die Funktion init_conf eines Ereignismoduls initialisiert die Konfigurationsstruktur
62. if
63. (m->init_conf) { rv = m->init_conf (cf->cycle, (*ctx)[ngx_modules[i]->ctx_index]);
64.                                                                                                              > rv;
                                                                                             >
65. zurück NGX_CONF_OK
}
67. 
    

    Der wichtigste Prozess in der Funktion ngx_events_block() ist der Aufruf von ngx_conf_parse(cf, NULL). Die Funktion des Aufrufs von ngx_conf_parse() besteht darin, die Analyse des Blocks events{} abzuschließen Konfigurationsdatei, also Rufen Sie die Rückruffunktionen aller Konfigurationsanweisungen darunter auf, um die Initialisierung des Parsens der Konfigurationsdatei abzuschließen. Aber hier habe ich eine persönliche Frage. Nachdem ich die Senioren gefragt habe, werde ich die Frage und Antwort angeben******.

    2. Initialisierung conf(init_conf)

    ngx_event_init_conf()
    

    Die Methode, die hauptsächlich die Struktur ngx_event_conf_t initialisiert.
    

    3.ngx_event_module_init

    Aus dem Namen geht hervor, dass es sich um den Initialisierungsvorgang des Moduls handelt, aber wenn man sich die Quelle ansieht Im Code jedes Moduls haben wir festgestellt, dass es viele gibt. Keines der Module verfügt über eine Init-Rückruffunktion. Ich habe auch Probleme mit dem Warum hier und hoffe, dass ich die Antwort finden kann, nachdem ich den gesamten Code gelernt habe.

    [cpp]-Ansicht Klartext?

1. src/event/ngx_event.c  
2. statisch ngx_int_t  
3. ngx_event_module_init(ngx_cycle_t *cycle)  
4. {  
5.     void              ***cf;  
6.     u_char              *shared;  
7.     size_t               size, cl;  
8.     ngx_shm_t            shm;  
9.     ngx_time_t          *tp;  
10.     ngx_core_conf_t     *ccf;  
11.     ngx_event_conf_t    *ecf;  
12.       
13.     //判断ngx_events_module是否调用过初始化conf操作  
14.     cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);  
15.   
16.     if (cf == NULL) {  
17.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,  
18.                       „kein Abschnitt „Ereignisse“ in der Konfiguration“);  
19.         return NGX_ERROR;  
20.     }  
21.       
22.     //获取ngx_event_core_module模块的配置结构  
23.     ecf = (*cf)[ngx_event_core_module.ctx_index];  
24.       
25.     //查看是否是event中的模块，例如use 。。。。
26. if (!ngx_test_config && ngx_process <= NGX_PROCESS_MASTER) { > ngx_log_error (NGX_LOG_NOTICE, Cycle->log, 0,
27. 🎜>
, ecf->name); > }
28. //Erhalten Sie die Konfigurationsstruktur des ngx_core_module-Moduls
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
31. // Holen Sie sich den timer_resolution-Parameter aus dem Konfigurationsstruktur des Moduls ngx_core_module
ngx_timer_resolution = ccf-> ;timer_resolution;
34. #if !(NGX_WIN32)
{
36. ngx_int_t limit;
38. //Ermitteln Sie die maximale Anzahl von Dateien, die der aktuelle Prozess öffnen kann getrlimit
39.  if
(getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
41. ngx_log_error(NGX_LOG_ALERT, Cycle->log, ngx_errno,                                                             );
42. }else {
43. //Wenn die Anzahl der ngx_event_core_module-Modulverbindungen größer als das aktuelle (weiche) Limit ist
44.                                                                                                        /Oder die Anzahl der ngx_event_core_module-Verbindungen ist größer als die maximale Anzahl der Verbindungen von ngx_core_module
45. if (ecf->connections > ( ngx_uint_t) rlmt.rlim_cur.
46.                                                          || ecf-> ;connections > ; (ngx_uint_t) ccf->rlimit_nofile)) {
47. limit = (ccf->rlimit_nofile == NGX_ CONF_UNSET) ?
48. (ngx_int_t) rlmt.rlim_cur : ccf->rlimit_nofile; 🎜> ngx_log_error (ngx_log_warn, cycle- & gt; log, 0,
ecf- & gt; Verbindungen, Limit);
50.                                                                    >#endif /* !(NGX_WIN32) */
53. //Wenn Sie nach dem Schließen des Master-Prozesses zu
zurückkehren
54. //Da das Schließen des Master-Prozesses ein Einzelprozess ist Arbeitsmodus,
55. // Nach dem Betrieb sind keine Implementierungssperren und andere Aufgaben für den gemeinsamen Speicher erforderlich.
56. if (ccf->master == 0) {
57.                                                                        , es ist nicht erforderlich, es erneut zu erstellen
58. if
(ngx_accept_mutex_ptr) {
60. return NGX_OK;
61. }
62. /* cl sollte gleich oder größer als die Cache-Zeilengröße sein */
65. cl = 128;
66. //Dieser gemeinsame Speicher wird in drei Abschnitte unterteilt size = cl
/* ngx_accept_mutex */
68. + cl
/ * ngx_connection_counter * /
69.                                                              🎜 >
70. // Gemeinsamen Speicher vorbereiten, die Größe ist size, benannt nginx_shared_zone,
71. shm.size = size; 🎜> shm.name.data = (u_char * ) "nginx_shared_zone"
72. ; shm.log =cycle->log; > shm.addr
74. if (ngx_shm_alloc(&shm) != NGX_OK) {                                                                                                                      🎜>//Startadresse abrufen und speichern
76. shared = shm.addr; //accept mutex ruft den ersten CL-Speicher des Shared Memory ab
77. ngx_accept_mutex_ptr = (ngx_atomic_t *) shared; >
79. Die Implementierung von Accept Mutex hängt davon ab, ob es atomare Operationen unterstützt
80. Der erhaltene gemeinsame Speicher wird zur Implementierung des Accept-Mutex verwendet; andernfalls wird die Dateisperre verwendet
81. um den Accept-Mutex zu implementieren.
82. Die Funktion des Accept-Mutex besteht darin, Panikgruppen zu vermeiden und Arbeiter zu implementieren Prozesslastausgleich.
84. */
85.  if (ngx_shmtx_create(&ngx_accept_mutex, shared, Cycle->lock_file.data) 
86.                    = NGX_OK)
87. {
88. 🎜> } >
ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);
91. ( void) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1); , Cycle->log, 0,
"counter: %p, %d"
93. ,
94. ngx_connection_counter, *ngx_connection_counter); 🎜> ngx_temp_number = (ngx_atomic_t *) (shared + 2 * cl); >
95. tp = ngx_timeofday(); 🎜>
97. returnNGX_OK;
98. }
99. 4.ngx_event_process_init
100. wurde in der vorherigen Worker-Prozessanalyse erwähnt. Nach dem Erstellen eines Worker-Prozesses initialisiert der Worker-Prozess zunächst den Prozess und ruft zu diesem Zeitpunkt die Funktion ngx_event_process_init auf.
101. [cpp]-Ansicht Klartext?
1. src/event/ngx_event.c
2. statischngx_int_t >
ngx_event_process_init(ngx_cycle_t *cycle)
{
ngx_uint_t m, i;
ngx_event_t *rev, *wev;
ngx_listening_t *ls;
ngx_connection_t *c, *next, *old; >
8. ngx_core_conf_t *ccf; ngx_event_module_t *module ;
//Wie zuvor, Holen Sie sich die Konfigurationsstruktur des Antwortmoduls
12. ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
13. ecf = ngx_event_get_conf(cycle-&g t;conf_ctx, ngx_event_core_module);
14. >
16. //Öffnen Sie einfach den Accept-Mutex
17. if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
18. ngx_use_accept_mutex = 1; // Mutex verwenden
19. ngx_accept_mutex_held = 0; //Ob Mutex akzeptiert werden soll
20. ngx_accept_mutex_delay = ecf->accept_mutex_delay;//Nachdem die Konkurrenz um den Mutex fehlgeschlagen ist, warten Sie auf das nächste Konkurrenzintervall
}
22. else {
ngx_use_accept_mutex = 0;
} (NGX_THREADS)
//Reden wir vorerst nicht über Threads
25. >
#endif
//
28. Zähler initialisieren, wobei a Ein rot-schwarzer Baum zur Wartung des Timers, der später ausführlich erläutert wird
if
29. (ngx_event_timer_init(cycle- >log ).  for (m = 0; ngx_modules[m]; m++) { 
30. //Wie hier bereits erwähnt, überspringen Sie Nicht-NGX_EVENT_MODULE-Module
31. if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
 
32. weiter;
}
33.  //Module, die durch Nichtverwendungskonfigurationsanweisungen angegeben werden, werden übersprungen, Linux verwendet standardmäßig epoll
34. > ; 🎜> Weil Nginx viele Ereignismodule implementiert, wie zum Beispiel: epoll, poll, select, dqueue, aio
35. (Diese Module befinden sich im Verzeichnis src/event/modules), sodass Nginx das Zeitmodul abstrahiert,
36. , um verschiedene Systeme zu erleichtern. Die Verwendung verschiedener Ereignismodelle erleichtert auch die Erweiterung neuer Zeit Unser Fokus sollte auf Epoll liegen.
39. Der Init-Callback hier ruft tatsächlich die Funktion ngx_epoll_init auf. Die Struktur module->actions kapselt alle Schnittstellenfunktionen von epoll. Nginx registriert Epoll über die Aktionsstruktur in der Ereignisabstraktionsschicht.
40. Der Aktionstyp ist ngx_event_action_t, befindet sich in src/event/ngx_event.h
42. Diese spezifischen Inhalte werden im nächsten Abschnitt erläutert.
 
44. if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
                                                                                              }  
45.  
                                                                        
46. //Einige Inhalte hier weglassen
48. //Global erstellen Das Array ngx_connection_t speichert alle Verbindungen
50. //Da dieser Prozess in jedem Worker-Prozess ausgeführt wird, hat jeder Worker jeweils sein eigenes Verbindungsarray
cycle->connections =
ngx_alloc(
52. sizeof(ngx_connection_t) *cycle ->connection_n,cycle->log);
53. if (cycle->connections == NULL) {
                                          🎜> } 
54.  
c =. Zyklus ->Verbindungen; 
 
56. //Erstellen Sie eine Reihe von Leseereignissen
57. Cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * Cycle->connection_n,
58. 🎜> if
59. (cycle->read_events == NULL) {
60.  return
61. NGX_ERROR;
62. }
63. rev = Cycle->read_events ;
64.  für (i = 0; i connection_n; i++) {
65. rev[i].closed = 1;
66. rev[i].instance = 1; #if ( NGX_THREADS)
67. rev[i].lock = &c[i].lock
68. rev [i].own_lock = &c[i].lock;
69. #endif
70. > }  
71.     //创建一个写事件数组  
72.     cycle->write_events = ngx_alloc (sizeof(ngx_event_t) * cycle->connection_n,  
73.                                    cycle->log);  
74.     if (cycle->write_events == NULL) {  
75.         return NGX_ERROR;  
76.     }  
77.   
78.     wev = cycle->write_events;  
79.     for (i = 0; i < cycle->connection_n; i++) {  
80.         wev[i].closed = 1;  
81. #if (NGX_THREADS)  
82.         wev[i].lock = &c[ i].lock;  
83.         wev[i].own_lock = &c[i].lock;  
84. #endif  
85.     }  
86.   
87.     i = cycle->connection_n;  
88.     next = NULL;  
89.     //初始化整个connection数组  
90.     tun {  
91.         i--;  
92.   
93.         c[i].data = next;  
94.         c[i].read = &cycle->read_events[i];  
95.         c[i].write = &cycle->write_events[i];  
96.         c[i].fd = (ngx_socket_t) -1;  
97.   
98.         next = &c[i];  
99.   
100. #if (NGX_THREADS)  
101.         c[i].lock = 0;  
102. #endif  
103.     }while (i);
104. 🎜>
105. Cycle->free_connection_n = Cycle-> Verbindung_n;
107. /* für jede Hörbuchse */
108. //Weisen Sie für jeden Listening-Socket, also einen Steckplatz, eine Verbindung aus dem Verbindungsarray zu
109. ls =cycle->listening.elts;
110. for
(i = 0; i listening.nelts; i++) {
111. //Holen Sie sich ein neues von conneciton Connection solt
112. c = ngx_get_connection(ls[i].fd,cycle->log);
113.  
114.  if
(c == NULL) {
115.              >return NGX_ERROR;
116. }
118. c->log = &ls[i].log
120. c->listening = &ls[i]; 🎜> 
121. rev = c->read;
122. ->log = c->log
123. rev->accept = 1;
//Lesezeit auftritt, Anrufannahme
126. #if (NGX_HAVE_DEFERRED_ACCEPT)
127.                                                                                   >
128. if (!(ngx_event_flags & NGX_USE_
IOC
129. P_EVENT)) {  if
130. (ls[i]. previous) {
131.                                                                                                        
132. * das alte Zyklusleseereignis-Array */
134. old = ls[i]. previous->connection;
135. if
136. (ngx_del_event (old-& gt; read, ngx_read_event, ngx_close_event) == ngx_error)
137.                                                                                                     ) -1;
                                 🎜>
138. }
140. //Registrieren Sie die Rückruffunktion, um auf Socket-Poisoning-Ereignisse zu warten ngx_event_accept
141. rev->handler = ngx_event_accept;
142. /Accept_mutex verwendet, den Listening-Socket vorerst nicht in epoll einfügen, sondern
143. //Warten Sie, bis der Arbeiter den Accept-Mutex ergreift, und fügen Sie dann Epoll ein, um Panikattacken zu vermeiden
144. if
(ngx_use_accept_mutex) { 🎜>
145.                                                                                                                   >  
146.  if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
147.                                                                                                                                        turn
148. NGX_ERROR; 
149.                                       >                                                                                                                         
151. 🎜> }  
152. #endif 
154. }
155. return
156. NGX_OK; }
157. Bis jetzt ist die ereignisgesteuerte Initialisierung abgeschlossen.
Das Obige stellt die Nginx-Quellcode-Studiennotizen (20) vor – Ereignismodul 1 – Initialisierung, einschließlich IOC und Zählerinhalt. Ich hoffe, dass es für Freunde hilfreich sein wird, die an PHP-Tutorials interessiert sind.