Detaillierte Erläuterung der Implementierung der Nginx-Prozesssperre

// Worker-Kerntransaktionsframework // ngx_event.c
Leere
ngx_process_events_and_timers(ngx_cycle_t *Zyklus)
{
    ngx_uint_t-Flags;
    ngx_msec_t-Zeitgeber, Delta;

    wenn (ngx_timer_resolution) {
        Timer = NGX_TIMER_INFINITE;
        Flaggen = 0;

    } anders {
        ngx_event_find_timer();
        Flags = NGX_UPDATE_TIME;

#wenn (NGX_WIN32)

        /* Signale vom Master im Falle einer Netzwerkinaktivität verarbeiten */

        wenn (Timer == NGX_TIMER_INFINITE || Timer > 500) {
            Zeitgeber = 500;
        }

#endif
    }

    wenn (ngx_use_accept_mutex) {
        // Um ​​Fairness zu gewährleisten, vermeiden Sie wiederholte Sperrkonflikte, wenn (ngx_accept_disabled > 0) {
            ngx_accept_disabled--;

        } anders {
            // Nur der Prozess, der die Sperre ergreift, führt die accept()-Operation auf dem Socket aus // Andere Worker verarbeiten zuvor verbundene Anfragen und Lese-/Schreiboperationen if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
                zurückkehren;
            }

            wenn (ngx_accept_mutex_held) {
                Flags |= NGX_POST_EVENTS;

            } anders {
                wenn (Timer == NGX_TIMER_INFINITE
                    || Timer > ngx_accept_mutex_delay)
                {
                    Zeitgeber = ngx_accept_mutex_delay;
                }
            }
        }
    }
    //Andere Kerntransaktionsverarbeitungif (!ngx_queue_empty(&ngx_posted_next_events)) {
        ngx_event_move_posted_next(Zyklus);
        Zeitgeber = 0;
    }

    delta = ngx_aktuelle_msec;

    (leer) ngx_process_events (Zyklus, Timer, Flags);

    delta = ngx_current_msec – delta;

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, Zyklus->Protokoll, 0,
                   „Timer-Delta: %M“, delta);

    ngx_event_process_posted(Zyklus, &ngx_posted_accept_events);

    wenn (ngx_accept_mutex_held) {
        ngx_shmtx_unlock(&ngx_accept_mutex);
    }

    wenn (Delta) {
        ngx_event_expire_timers();
    }

    ngx_event_process_posted(Zyklus, &ngx_posted_events);
}
// Holen Sie sich die Sperre und registrieren Sie den Socket-Accept()-Prozess wie folgt ngx_int_t
ngx_trylock_accept_mutex(ngx_cycle_t *Zyklus)
{
    wenn (ngx_shmtx_trylock(&ngx_accept_mutex)) {

        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, Zyklus->Protokoll, 0,
                       "akzeptiere Mutex gesperrt");

        wenn (ngx_accept_mutex_held && ngx_accept_events == 0) {
            gib NGX_OK zurück;
        }

        wenn (ngx_enable_accept_events(Zyklus) == NGX_ERROR) {
            // Entsperrvorgang ngx_shmtx_unlock(&ngx_accept_mutex);
            gib NGX_ERROR zurück;
        }

        ngx_accept_events = 0;
        ngx_accept_mutex_held = 1;

        gib NGX_OK zurück;
    }

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, Zyklus->Protokoll, 0,
                   „Akzeptieren der Mutex-Sperre fehlgeschlagen: %ui“, ngx_accept_mutex_held);

    wenn (ngx_accept_mutex_held) {
        wenn (ngx_disable_accept_events(cycle, 0) == NGX_ERROR) {
            gib NGX_ERROR zurück;
        }

        ngx_accept_mutex_held = 0;
    }

    gib NGX_OK zurück;
}

// Ereignis/ngx_event.c
//Globale Definition der Akzeptieren-Sperrvariablen ngx_shmtx_t ngx_accept_mutex;
// Dieses Schloss hat eine // atomare Implementierung mit dem volatilen Modifikator typedef volatile ngx_atomic_uint_t ngx_atomic_t;
typedef-Struktur {
#wenn (NGX_HAVE_ATOMIC_OPS)
    // Zum Implementieren von Sperren werden atomare Aktualisierungsvariablen verwendet, hinter denen sich der gemeinsam genutzte Speicherbereich befindet ngx_atomic_t *lock;
#wenn (NGX_HAVE_POSIX_SEM)
    ngx_atomic_t *warten;
    ngx_uint_t-Semaphor;
    sem_t sem;
#endif
#anders
    // FD wird verwendet, um die Sperre zu implementieren. Hinter FD steht eine Dateiinstanz ngx_fd_t fd;
    u_char *Name;
#endif
    ngx_uint_t drehen;
} ngx_shmtx_t;
// Definition der gemeinsam genutzten Speicherdatenstruktur typedef struct {
    u_char *Adresse;
    size_t Größe;
    ngx_str_t-Name;
    ngx_log_t *Protokoll;
    ngx_uint_t existiert; /* unsigned existiert:1; */
} ngx_shm_t;

// ngx_shmtx.c
ngx_uint_t
ngx_shmtx_trylock(ngx_shmtx_t *mtx)
{
    ngx_err_t Fehler;

    Fehler = ngx_trylock_fd(mtx->fd);

    wenn (err == 0) {
        Rückgabe 1;
    }

    wenn (err == NGX_EAGAIN) {
        gebe 0 zurück;
    }

#if __osf__ /* Tru64 UNIX */

    wenn (err == NGX_EACCES) {
        gebe 0 zurück;
    }

#endif

    ngx_log_abort(err, ngx_trylock_fd_n " %s fehlgeschlagen", mtx->name);

    gebe 0 zurück;
}
// core/ngx_shmtx.c
// 1. Sperrvorgang ngx_err_t
ngx_trylock_fd(ngx_fd_t fd)
{
    Struktur Herde fl;

    ngx_memzero(&fl, sizeof(Struktur flock));
    fl.l_type = F_WRLCK;
    fl.l_where = SEEK_SET;

    wenn (fcntl(fd, F_SETLK, &fl) == -1) {
        gib ngx_errno zurück;
    }

    gebe 0 zurück;
}
// os/unix/ngx_file.c
ngx_err_t
ngx_lock_fd(ngx_fd_t fd)
{
    Struktur Herde fl;

    ngx_memzero(&fl, sizeof(Struktur flock));
    fl.l_type = F_WRLCK;
    fl.l_where = SEEK_SET;
    // Rufe die vom System bereitgestellte Sperrmethode auf, if (fcntl(fd, F_SETLKW, &fl) == -1) {
        gib ngx_errno zurück;
    }

    gebe 0 zurück;
}

// 2. Implementierung freischalten // core/ngx_shmtx.c
Leere
ngx_shmtx_unlock(ngx_shmtx_t *mtx)
{
    ngx_err_t Fehler;

    Fehler = ngx_unlock_fd(mtx->fd);

    wenn (err == 0) {
        zurückkehren;
    }

    ngx_log_abort(err, ngx_unlock_fd_n " %s fehlgeschlagen", mtx->name);
}
// os/unix/ngx_file.c
ngx_err_t
ngx_unlock_fd(ngx_fd_t fd)
{
    Struktur Herde fl;

    ngx_memzero(&fl, sizeof(Struktur flock));
    fl.l_type = F_UNLCK;
    fl.l_where = SEEK_SET;

    wenn (fcntl(fd, F_SETLK, &fl) == -1) {
        gib ngx_errno zurück;
    }

    gebe 0 zurück;
}

// Die Initialisierung der gemeinsamen Sperre wird im NGX-Master durchgeführt, dann fork() zum Arbeitsprozess // event/ngx_event.c
statisches ngx_int_t
ngx_event_module_init(ngx_cycle_t *Zyklus)
{
    ungültig ***cf;
    u_char *geteilt;
    size_t Größe, cl;
    // Einen gemeinsam genutzten Speicher definieren ngx_shm_t shm;
    ngx_time_t *tp;
    ngx_core_conf_t *ccf;
    ngx_event_conf_t *ecf;

    cf = ngx_get_conf(Zyklus->conf_ctx, ngx_events_module);
    ecf = (*cf)[ngx_event_core_module.ctx_index];

    wenn (!ngx_test_config && ngx_process <= NGX_PROCESS_MASTER) {
        ngx_log_error(NGX_LOG_NOTICE, Zyklus->Protokoll, 0,
                      "unter Verwendung der Ereignismethode \"%s\"", ecf->name);
    }

    ccf = (ngx_core_conf_t *) ngx_get_conf(Zyklus->conf_ctx, ngx_core_module);

    ngx_timer_resolution = ccf->timer_auflösung;

#wenn !(NGX_WIN32)
    {
    ngx_int_t-Grenze;
    Struktur rlimit rlmt;

    wenn (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
        ngx_log_error(NGX_LOG_ALERT, Zyklus->Protokoll, ngx_errno,
                      "getrlimit(RLIMIT_NOFILE) fehlgeschlagen, ignoriert");

    } anders {
        wenn (ecf->Verbindungen > (ngx_uint_t) rlmt.rlim_cur
            && (ccf->rlimit_nofile == NGX_CONF_UNSET
                || ecf->Verbindungen > (ngx_uint_t) ccf->rlimit_nofile))
        {
            Limit = (ccf->rlimit_nofile == NGX_CONF_UNSET)?
                         (ngx_int_t) rlmt.rlim_cur: ccf->rlimit_nofile;

            ngx_log_error(NGX_LOG_WARN, Zyklus->Protokoll, 0,
                          „%ui worker_connections überschreiten“
                          "Ressourcenlimit für geöffnete Dateien: %i",
                          ecf->Verbindungen, Limit);
        }
    }
    }
#endif /* !(NGX_WIN32) */


    wenn (ccf->master == 0) {
        gib NGX_OK zurück;
    }

    wenn (ngx_accept_mutex_ptr) {
        gib NGX_OK zurück;
    }


    /* cl sollte gleich oder größer als die Cache-Zeilengröße sein */

    cl = 128;

    Größe = cl /* ngx_accept_mutex */
           + cl /* ngx_connection_counter */
           + cl; /* ngx_temp_nummer */

#wenn (NGX_STAT_STUB)

    Größe += cl /* ngx_stat_accepted */
           + cl /* ngx_stat_handled */
           + cl /* ngx_stat_requests */
           + cl /* ngx_stat_active */
           + cl /* ngx_stat_reading */
           + cl /* ngx_stat_writing */
           + cl; /* ngx_stat_waiting */

#endif

    shm.size = Größe;
    ngx_str_set(&shm.name, "nginx_shared_zone");
    shm.log = Zyklus->Protokoll;
    // Gemeinsam genutzten Speicherplatz zuordnen, mmap zur Implementierung verwenden, if (ngx_shm_alloc(&shm) != NGX_OK) {
        gib NGX_ERROR zurück;
    }

    geteilt = shm.Adresse;

    ngx_accept_mutex_ptr = (ngx_atomic_t *) geteilt;
    ngx_accept_mutex.spin = (ngx_uint_t) -1;
    // Basierend auf gemeinsam genutzten Dateien oder Speicherzuweisungsprozesssperren kann eine Mehrprozesssteuerung erreicht werden, wenn (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) gemeinsam genutzt wird,
                         Zyklus->Lock_File.Data)
        != NGX_OK)
    {
        gib NGX_ERROR zurück;
    }

    ngx_connection_counter = (ngx_atomic_t *) (geteilt + 1 * cl);

    (leer) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1);

    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, Zyklus->Protokoll, 0,
                   "Zähler: %p, %uA",
                   ngx_connection_counter, *ngx_connection_counter);

    ngx_temp_number = (ngx_atomic_t *) (geteilt + 2 * cl);

    tp = ngx_timeofday();

    ngx_random_number = (tp->msec << 16) + ngx_pid;

#wenn (NGX_STAT_STUB)

    ngx_stat_accepted = (ngx_atomic_t *) (geteilt + 3 * cl);
    ngx_stat_handled = (ngx_atomic_t *) (geteilt + 4 * cl);
    ngx_stat_requests = (ngx_atomic_t *) (geteilt + 5 * cl);
    ngx_stat_active = (ngx_atomic_t *) (geteilt + 6 * cl);
    ngx_stat_reading = (ngx_atomic_t *) (geteilt + 7 * cl);
    ngx_stat_writing = (ngx_atomic_t *) (geteilt + 8 * cl);
    ngx_stat_waiting = (ngx_atomic_t *) (geteilt + 9 * cl);

#endif

    gib NGX_OK zurück;
}
// core/ngx_shmtx.c
// 1. Verwenden Sie fd basierend auf dem gemeinsam genutzten Speicherplatz des Dateiprozesses
ngx_int_t
ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *Adresse, u_char *Name)
{
    // Wird vom Masterprozess erstellt, ist also eine prozesssichere Operation und jeder Worker kann sie direkt verwenden if (mtx->name) {
        // Wenn es erstellt wurde, wurde fd zugewiesen und kann nicht erstellt werden. Teile fd einfach direkt. // Hinter fd steht eine Dateiinstanz if (ngx_strcmp(name, mtx->name) == 0) {
            mtx->name = Name;
            gib NGX_OK zurück;
        }

        ngx_shmtx_destroy(mtx);
    }
    // Verwenden Sie die Dateierstellung, um die Freigabe zu sperren mtx->fd = ngx_open_file(name, NGX_FILE_RDWR, NGX_FILE_CREATE_OR_OPEN,
                            NGX_FILE_DEFAULT_ACCESS);

    wenn (mtx->fd == NGX_INVALID_FILE) {
        ngx_log_error(NGX_LOG_EMERG, ngx_cycle->log, ngx_errno,
                      ngx_open_file_n " \"%s\" fehlgeschlagen", Name);
        gib NGX_ERROR zurück;
    }
    // Sobald es erstellt wurde, kann es gelöscht werden. Nachfolgende Sperrvorgänge werden nur basierend auf dieser fd-Instanz ausgeführt, wenn (ngx_delete_file(name) == NGX_FILE_ERROR) {
        ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
                      ngx_delete_file_n " \"%s\" fehlgeschlagen", Name);
    }

    mtx->name = Name;

    gib NGX_OK zurück;
}

// 2. Erstellen einer gemeinsamen Sperre basierend auf dem gemeinsamen Speicher // ngx_shmtx.c
ngx_int_t
ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *Adresse, u_char *Name)
{
    mtx->lock = &addr->lock;

    wenn (mtx->spin == (ngx_uint_t) -1) {
        gib NGX_OK zurück;
    }

    mtx->spin = 2048;

#wenn (NGX_HAVE_POSIX_SEM)

    mtx->wait = &Adresse->wait;

    wenn (sem_init(&mtx->sem, 1, 0) == -1) {
        ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
                      "sem_init() ist fehlgeschlagen");
    } anders {
        mtx->Semaphor = 1;
    }

#endif

    gib NGX_OK zurück;
}
// os/unix/ngx_shmem.c
ngx_int_t
ngx_shm_alloc(ngx_shm_t *shm)
{
    shm->Adresse = (u_char *) mmap(NULL, shm->Größe,
                                PROT_READ|PROT_WRITE,
                                MAP_ANON|MAP_SHARED, -1, 0);

    wenn (shm->addr == MAP_FAILED) {
        ngx_log_error(NGX_LOG_ALERT, shm->log, ngx_errno,
                      „mmap(MAP_ANON|MAP_SHARED, %uz) ist fehlgeschlagen“, shm->Größe);
        gib NGX_ERROR zurück;
    }

    gib NGX_OK zurück;
}

// ngx_shmtx.c
ngx_uint_t
ngx_shmtx_trylock(ngx_shmtx_t *mtx)
{
    // Den Wert des gemeinsam genutzten Speicherbereichs direkt ändern // Eine erfolgreiche CAS-Änderung bedeutet eine erfolgreiche Sperre.
    Rückgabe (*mtx->lock == 0 und ngx_atomic_cmp_set (mtx->lock, 0, ngx_pid));
}

// Entsperren Sie den Vorgang der SHM-Version, CAS-Parsing, mit der Benachrichtigung void
ngx_shmtx_unlock(ngx_shmtx_t *mtx)
{
    wenn (mtx->spin != (ngx_uint_t) -1) {
        ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "shmtx entsperren");
    }

    wenn (ngx_atomic_cmp_set(mtx->lock, ngx_pid, 0)) {
        ngx_shmtx_wakeup(mtx);
    }
}
//Benachrichtigen Sie den wartenden Prozess static void
ngx_shmtx_wakeup(ngx_shmtx_t *mtx)
{
#wenn (NGX_HAVE_POSIX_SEM)
    ngx_atomic_uint_t warte;

    wenn (!mtx->semaphore) {
        zurückkehren;
    }

    für ( ;; ) {

        warten = *mtx->warten;

        wenn ((ngx_atomic_int_t) warte <= 0) {
            zurückkehren;
        }

        wenn (ngx_atomic_cmp_set(mtx->warten, warten, warten - 1)) {
            brechen;
        }
    }

    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
                   „shmtx wake %uA“, warte);

    wenn (sem_post(&mtx->sem) == -1) {
        ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
                      "sem_post() ist beim Wake shmtx fehlgeschlagen");
    }

#endif
}