Coverage Report

Created: 2023-09-25 07:18

/src/unit/src/nxt_runtime.c
Line
Count
Source (jump to first uncovered line)
1
2
/*
3
 * Copyright (C) Igor Sysoev
4
 * Copyright (C) Valentin V. Bartenev
5
 * Copyright (C) NGINX, Inc.
6
 */
7
8
#include <nxt_main.h>
9
#include <nxt_runtime.h>
10
#include <nxt_port.h>
11
#include <nxt_main_process.h>
12
#include <nxt_router.h>
13
#include <nxt_regex.h>
14
15
16
static nxt_int_t nxt_runtime_inherited_listen_sockets(nxt_task_t *task,
17
    nxt_runtime_t *rt);
18
static nxt_int_t nxt_runtime_systemd_listen_sockets(nxt_task_t *task,
19
    nxt_runtime_t *rt);
20
static nxt_int_t nxt_runtime_event_engines(nxt_task_t *task, nxt_runtime_t *rt);
21
static nxt_int_t nxt_runtime_thread_pools(nxt_thread_t *thr, nxt_runtime_t *rt);
22
static void nxt_runtime_start(nxt_task_t *task, void *obj, void *data);
23
static void nxt_runtime_initial_start(nxt_task_t *task, nxt_uint_t status);
24
static void nxt_runtime_close_idle_connections(nxt_event_engine_t *engine);
25
static void nxt_runtime_stop_all_processes(nxt_task_t *task, nxt_runtime_t *rt);
26
static void nxt_runtime_exit(nxt_task_t *task, void *obj, void *data);
27
static nxt_int_t nxt_runtime_event_engine_change(nxt_task_t *task,
28
    nxt_runtime_t *rt);
29
static nxt_int_t nxt_runtime_conf_init(nxt_task_t *task, nxt_runtime_t *rt);
30
static nxt_int_t nxt_runtime_conf_read_cmd(nxt_task_t *task, nxt_runtime_t *rt);
31
static nxt_int_t nxt_runtime_hostname(nxt_task_t *task, nxt_runtime_t *rt);
32
static nxt_int_t nxt_runtime_log_files_init(nxt_runtime_t *rt);
33
static nxt_int_t nxt_runtime_log_files_create(nxt_task_t *task,
34
    nxt_runtime_t *rt);
35
static nxt_int_t nxt_runtime_pid_file_create(nxt_task_t *task,
36
    nxt_file_name_t *pid_file);
37
static void nxt_runtime_thread_pool_destroy(nxt_task_t *task, nxt_runtime_t *rt,
38
    nxt_runtime_cont_t cont);
39
static void nxt_runtime_thread_pool_init(void);
40
static void nxt_runtime_thread_pool_exit(nxt_task_t *task, void *obj,
41
    void *data);
42
static nxt_process_t *nxt_runtime_process_get(nxt_runtime_t *rt, nxt_pid_t pid);
43
static void nxt_runtime_port_add(nxt_task_t *task, nxt_port_t *port);
44
45
46
nxt_int_t
47
nxt_runtime_create(nxt_task_t *task)
48
0
{
49
0
    nxt_mp_t               *mp;
50
0
    nxt_int_t              ret;
51
0
    nxt_array_t            *listen_sockets;
52
0
    nxt_runtime_t          *rt;
53
0
    nxt_app_lang_module_t  *lang;
54
55
0
    mp = nxt_mp_create(1024, 128, 256, 32);
56
0
    if (nxt_slow_path(mp == NULL)) {
57
0
        return NXT_ERROR;
58
0
    }
59
60
0
    rt = nxt_mp_zget(mp, sizeof(nxt_runtime_t));
61
0
    if (nxt_slow_path(rt == NULL)) {
62
0
        goto fail;
63
0
    }
64
65
0
    task->thread->runtime = rt;
66
0
    rt->mem_pool = mp;
67
68
0
    nxt_thread_mutex_create(&rt->processes_mutex);
69
70
0
    rt->services = nxt_services_init(mp);
71
0
    if (nxt_slow_path(rt->services == NULL)) {
72
0
        goto fail;
73
0
    }
74
75
0
    rt->languages = nxt_array_create(mp, 1, sizeof(nxt_app_lang_module_t));
76
0
    if (nxt_slow_path(rt->languages == NULL)) {
77
0
        goto fail;
78
0
    }
79
80
    /* Should not fail. */
81
0
    lang = nxt_array_add(rt->languages);
82
0
    lang->type = NXT_APP_EXTERNAL;
83
0
    lang->version = (u_char *) "";
84
0
    lang->file = NULL;
85
0
    lang->module = &nxt_external_module;
86
87
0
    lang->mounts = nxt_array_create(mp, 1, sizeof(nxt_fs_mount_t));
88
0
    if (nxt_slow_path(lang->mounts == NULL)) {
89
0
        goto fail;
90
0
    }
91
92
0
    listen_sockets = nxt_array_create(mp, 1, sizeof(nxt_listen_socket_t));
93
0
    if (nxt_slow_path(listen_sockets == NULL)) {
94
0
        goto fail;
95
0
    }
96
97
0
    rt->listen_sockets = listen_sockets;
98
99
0
    ret = nxt_runtime_inherited_listen_sockets(task, rt);
100
0
    if (nxt_slow_path(ret != NXT_OK)) {
101
0
        goto fail;
102
0
    }
103
104
0
    if (nxt_runtime_hostname(task, rt) != NXT_OK) {
105
0
        goto fail;
106
0
    }
107
108
0
    if (nxt_slow_path(nxt_runtime_log_files_init(rt) != NXT_OK)) {
109
0
        goto fail;
110
0
    }
111
112
0
    if (nxt_runtime_event_engines(task, rt) != NXT_OK) {
113
0
        goto fail;
114
0
    }
115
116
0
    if (nxt_slow_path(nxt_runtime_thread_pools(task->thread, rt) != NXT_OK)) {
117
0
        goto fail;
118
0
    }
119
120
0
    rt->start = nxt_runtime_initial_start;
121
122
0
    if (nxt_runtime_conf_init(task, rt) != NXT_OK) {
123
0
        goto fail;
124
0
    }
125
126
0
    if (nxt_port_rpc_init() != NXT_OK) {
127
0
        goto fail;
128
0
    }
129
130
0
    if (nxt_slow_path(nxt_http_register_variables() != NXT_OK)) {
131
0
        goto fail;
132
0
    }
133
134
0
    if (nxt_slow_path(nxt_var_index_init() != NXT_OK)) {
135
0
        goto fail;
136
0
    }
137
138
0
    nxt_work_queue_add(&task->thread->engine->fast_work_queue,
139
0
                       nxt_runtime_start, task, rt, NULL);
140
141
0
    return NXT_OK;
142
143
0
fail:
144
145
0
    nxt_mp_destroy(mp);
146
147
0
    return NXT_ERROR;
148
0
}
149
150
151
static nxt_int_t
152
nxt_runtime_inherited_listen_sockets(nxt_task_t *task, nxt_runtime_t *rt)
153
0
{
154
0
    u_char               *v, *p;
155
0
    nxt_int_t            type;
156
0
    nxt_array_t          *inherited_sockets;
157
0
    nxt_socket_t         s;
158
0
    nxt_listen_socket_t  *ls;
159
160
0
    v = (u_char *) getenv("NGINX");
161
162
0
    if (v == NULL) {
163
0
        return nxt_runtime_systemd_listen_sockets(task, rt);
164
0
    }
165
166
0
    nxt_alert(task, "using inherited listen sockets: %s", v);
167
168
0
    inherited_sockets = nxt_array_create(rt->mem_pool,
169
0
                                         1, sizeof(nxt_listen_socket_t));
170
0
    if (inherited_sockets == NULL) {
171
0
        return NXT_ERROR;
172
0
    }
173
174
0
    rt->inherited_sockets = inherited_sockets;
175
176
0
    for (p = v; *p != '\0'; p++) {
177
178
0
        if (*p == ';') {
179
0
            s = nxt_int_parse(v, p - v);
180
181
0
            if (nxt_slow_path(s < 0)) {
182
0
                nxt_alert(task, "invalid socket number \"%s\" "
183
0
                          "in NGINX environment variable, "
184
0
                          "ignoring the rest of the variable", v);
185
0
                return NXT_ERROR;
186
0
            }
187
188
0
            v = p + 1;
189
190
0
            ls = nxt_array_zero_add(inherited_sockets);
191
0
            if (nxt_slow_path(ls == NULL)) {
192
0
                return NXT_ERROR;
193
0
            }
194
195
0
            ls->socket = s;
196
197
0
            ls->sockaddr = nxt_getsockname(task, rt->mem_pool, s);
198
0
            if (nxt_slow_path(ls->sockaddr == NULL)) {
199
0
                return NXT_ERROR;
200
0
            }
201
202
0
            type = nxt_socket_getsockopt(task, s, SOL_SOCKET, SO_TYPE);
203
0
            if (nxt_slow_path(type == -1)) {
204
0
                return NXT_ERROR;
205
0
            }
206
207
0
            ls->sockaddr->type = (uint16_t) type;
208
0
        }
209
0
    }
210
211
0
    return NXT_OK;
212
0
}
213
214
215
static nxt_int_t
216
nxt_runtime_systemd_listen_sockets(nxt_task_t *task, nxt_runtime_t *rt)
217
0
{
218
0
    u_char               *nfd, *pid;
219
0
    nxt_int_t            n;
220
0
    nxt_array_t          *inherited_sockets;
221
0
    nxt_socket_t         s;
222
0
    nxt_listen_socket_t  *ls;
223
224
    /*
225
     * Number of listening sockets passed.  The socket
226
     * descriptors start from number 3 and are sequential.
227
     */
228
0
    nfd = (u_char *) getenv("LISTEN_FDS");
229
0
    if (nfd == NULL) {
230
0
        return NXT_OK;
231
0
    }
232
233
    /* The pid of the service process. */
234
0
    pid = (u_char *) getenv("LISTEN_PID");
235
0
    if (pid == NULL) {
236
0
        return NXT_OK;
237
0
    }
238
239
0
    n = nxt_int_parse(nfd, nxt_strlen(nfd));
240
0
    if (n < 0) {
241
0
        return NXT_OK;
242
0
    }
243
244
0
    if (nxt_pid != nxt_int_parse(pid, nxt_strlen(pid))) {
245
0
        return NXT_OK;
246
0
    }
247
248
0
    nxt_log(task, NXT_LOG_INFO, "using %i systemd listen sockets", n);
249
250
0
    inherited_sockets = nxt_array_create(rt->mem_pool,
251
0
                                         n, sizeof(nxt_listen_socket_t));
252
0
    if (inherited_sockets == NULL) {
253
0
        return NXT_ERROR;
254
0
    }
255
256
0
    rt->inherited_sockets = inherited_sockets;
257
258
0
    for (s = 3; s < n; s++) {
259
0
        ls = nxt_array_zero_add(inherited_sockets);
260
0
        if (nxt_slow_path(ls == NULL)) {
261
0
            return NXT_ERROR;
262
0
        }
263
264
0
        ls->socket = s;
265
266
0
        ls->sockaddr = nxt_getsockname(task, rt->mem_pool, s);
267
0
        if (nxt_slow_path(ls->sockaddr == NULL)) {
268
0
            return NXT_ERROR;
269
0
        }
270
271
0
        ls->sockaddr->type = SOCK_STREAM;
272
0
    }
273
274
0
    return NXT_OK;
275
0
}
276
277
278
static nxt_int_t
279
nxt_runtime_event_engines(nxt_task_t *task, nxt_runtime_t *rt)
280
0
{
281
0
    nxt_thread_t                 *thread;
282
0
    nxt_event_engine_t           *engine;
283
0
    const nxt_event_interface_t  *interface;
284
285
0
    interface = nxt_service_get(rt->services, "engine", NULL);
286
287
0
    if (nxt_slow_path(interface == NULL)) {
288
        /* TODO: log */
289
0
        return NXT_ERROR;
290
0
    }
291
292
0
    engine = nxt_event_engine_create(task, interface,
293
0
                                     nxt_main_process_signals, 0, 0);
294
295
0
    if (nxt_slow_path(engine == NULL)) {
296
0
        return NXT_ERROR;
297
0
    }
298
299
0
    thread = task->thread;
300
0
    thread->engine = engine;
301
#if 0
302
    thread->fiber = &engine->fibers->fiber;
303
#endif
304
305
0
    engine->id = rt->last_engine_id++;
306
0
    engine->mem_pool = nxt_mp_create(1024, 128, 256, 32);
307
308
0
    nxt_queue_init(&rt->engines);
309
0
    nxt_queue_insert_tail(&rt->engines, &engine->link);
310
311
0
    return NXT_OK;
312
0
}
313
314
315
static nxt_int_t
316
nxt_runtime_thread_pools(nxt_thread_t *thr, nxt_runtime_t *rt)
317
0
{
318
0
    nxt_int_t    ret;
319
0
    nxt_array_t  *thread_pools;
320
321
0
    thread_pools = nxt_array_create(rt->mem_pool, 1,
322
0
                                    sizeof(nxt_thread_pool_t *));
323
324
0
    if (nxt_slow_path(thread_pools == NULL)) {
325
0
        return NXT_ERROR;
326
0
    }
327
328
0
    rt->thread_pools = thread_pools;
329
0
    ret = nxt_runtime_thread_pool_create(thr, rt, 2, 60000 * 1000000LL);
330
331
0
    if (nxt_slow_path(ret != NXT_OK)) {
332
0
        return NXT_ERROR;
333
0
    }
334
335
0
    return NXT_OK;
336
0
}
337
338
339
static void
340
nxt_runtime_start(nxt_task_t *task, void *obj, void *data)
341
0
{
342
0
    nxt_runtime_t  *rt;
343
344
0
    rt = obj;
345
346
0
    nxt_debug(task, "rt conf done");
347
348
0
    task->thread->log->ctx_handler = NULL;
349
0
    task->thread->log->ctx = NULL;
350
351
0
    if (nxt_runtime_log_files_create(task, rt) != NXT_OK) {
352
0
        goto fail;
353
0
    }
354
355
0
    if (nxt_runtime_event_engine_change(task, rt) != NXT_OK) {
356
0
        goto fail;
357
0
    }
358
359
    /*
360
     * Thread pools should be destroyed before starting worker
361
     * processes, because thread pool semaphores will stick in
362
     * locked state in new processes after fork().
363
     */
364
0
    nxt_runtime_thread_pool_destroy(task, rt, rt->start);
365
366
0
    return;
367
368
0
fail:
369
370
0
    nxt_runtime_quit(task, 1);
371
0
}
372
373
374
static void
375
nxt_runtime_initial_start(nxt_task_t *task, nxt_uint_t status)
376
0
{
377
0
    nxt_int_t                    ret;
378
0
    nxt_thread_t                 *thr;
379
0
    nxt_runtime_t                *rt;
380
0
    const nxt_event_interface_t  *interface;
381
382
0
    thr = task->thread;
383
0
    rt = thr->runtime;
384
385
0
    if (rt->inherited_sockets == NULL && rt->daemon) {
386
387
0
        if (nxt_process_daemon(task) != NXT_OK) {
388
0
            goto fail;
389
0
        }
390
391
        /*
392
         * An event engine should be updated after fork()
393
         * even if an event facility was not changed because:
394
         * 1) inherited kqueue descriptor is invalid,
395
         * 2) the signal thread is not inherited.
396
         */
397
0
        interface = nxt_service_get(rt->services, "engine", rt->engine);
398
0
        if (interface == NULL) {
399
0
            goto fail;
400
0
        }
401
402
0
        ret = nxt_event_engine_change(task->thread->engine, interface,
403
0
                                      rt->batch);
404
0
        if (ret != NXT_OK) {
405
0
            goto fail;
406
0
        }
407
0
    }
408
409
0
    ret = nxt_runtime_pid_file_create(task, rt->pid_file);
410
0
    if (ret != NXT_OK) {
411
0
        goto fail;
412
0
    }
413
414
0
    if (nxt_runtime_event_engine_change(task, rt) != NXT_OK) {
415
0
        goto fail;
416
0
    }
417
418
0
    thr->engine->max_connections = rt->engine_connections;
419
420
0
    if (nxt_main_process_start(thr, task, rt) != NXT_ERROR) {
421
0
        return;
422
0
    }
423
424
0
fail:
425
426
0
    nxt_runtime_quit(task, 1);
427
0
}
428
429
430
void
431
nxt_runtime_quit(nxt_task_t *task, nxt_uint_t status)
432
0
{
433
0
    nxt_bool_t          done;
434
0
    nxt_runtime_t       *rt;
435
0
    nxt_event_engine_t  *engine;
436
437
0
    rt = task->thread->runtime;
438
0
    rt->status |= status;
439
0
    engine = task->thread->engine;
440
441
0
    nxt_debug(task, "exiting");
442
443
0
    done = 1;
444
445
0
    if (!engine->shutdown) {
446
0
        engine->shutdown = 1;
447
448
0
        if (!nxt_array_is_empty(rt->thread_pools)) {
449
0
            nxt_runtime_thread_pool_destroy(task, rt, nxt_runtime_quit);
450
0
            done = 0;
451
0
        }
452
453
0
        if (rt->type == NXT_PROCESS_MAIN) {
454
0
            nxt_runtime_stop_all_processes(task, rt);
455
0
            done = 0;
456
0
        }
457
0
    }
458
459
0
    nxt_runtime_close_idle_connections(engine);
460
461
0
    if (done) {
462
0
        nxt_work_queue_add(&engine->fast_work_queue, nxt_runtime_exit,
463
0
                           task, rt, engine);
464
0
    }
465
0
}
466
467
468
static void
469
nxt_runtime_close_idle_connections(nxt_event_engine_t *engine)
470
0
{
471
0
    nxt_conn_t        *c;
472
0
    nxt_queue_t       *idle;
473
0
    nxt_queue_link_t  *link, *next;
474
475
0
    nxt_debug(&engine->task, "close idle connections");
476
477
0
    idle = &engine->idle_connections;
478
479
0
    for (link = nxt_queue_first(idle);
480
0
         link != nxt_queue_tail(idle);
481
0
         link = next)
482
0
    {
483
0
        next = nxt_queue_next(link);
484
0
        c = nxt_queue_link_data(link, nxt_conn_t, link);
485
486
0
        if (!c->socket.read_ready) {
487
0
            nxt_queue_remove(link);
488
0
            nxt_conn_close(engine, c);
489
0
        }
490
0
    }
491
0
}
492
493
494
void
495
nxt_runtime_stop_app_processes(nxt_task_t *task, nxt_runtime_t *rt)
496
0
{
497
0
    nxt_port_t          *port;
498
0
    nxt_process_t       *process;
499
0
    nxt_process_init_t  *init;
500
501
0
    nxt_runtime_process_each(rt, process) {
502
503
0
        init = nxt_process_init(process);
504
505
0
        if (init->type == NXT_PROCESS_APP
506
0
            || init->type == NXT_PROCESS_PROTOTYPE)
507
0
        {
508
509
0
            nxt_process_port_each(process, port) {
510
511
0
                (void) nxt_port_socket_write(task, port, NXT_PORT_MSG_QUIT, -1,
512
0
                                             0, 0, NULL);
513
514
0
            } nxt_process_port_loop;
515
0
        }
516
517
0
    } nxt_runtime_process_loop;
518
0
}
519
520
521
static void
522
nxt_runtime_stop_all_processes(nxt_task_t *task, nxt_runtime_t *rt)
523
0
{
524
0
    nxt_port_t     *port;
525
0
    nxt_process_t  *process;
526
527
0
    nxt_runtime_process_each(rt, process) {
528
529
0
        nxt_process_port_each(process, port) {
530
531
0
            nxt_debug(task, "%d sending quit to %PI", rt->type, port->pid);
532
533
0
            (void) nxt_port_socket_write(task, port, NXT_PORT_MSG_QUIT, -1, 0,
534
0
                                         0, NULL);
535
536
0
        } nxt_process_port_loop;
537
538
0
    } nxt_runtime_process_loop;
539
0
}
540
541
542
static void
543
nxt_runtime_exit(nxt_task_t *task, void *obj, void *data)
544
0
{
545
0
    int                 status, engine_count;
546
0
    nxt_runtime_t       *rt;
547
0
    nxt_process_t       *process;
548
0
    nxt_event_engine_t  *engine;
549
550
0
    rt = obj;
551
0
    engine = data;
552
553
0
    nxt_debug(task, "thread pools: %d", rt->thread_pools->nelts);
554
555
0
    if (!nxt_array_is_empty(rt->thread_pools)) {
556
0
        return;
557
0
    }
558
559
0
    if (rt->type == NXT_PROCESS_MAIN) {
560
0
        if (rt->pid_file != NULL) {
561
0
            nxt_file_delete(rt->pid_file);
562
0
        }
563
564
0
#if (NXT_HAVE_UNIX_DOMAIN)
565
0
        {
566
0
            size_t           i;
567
0
            nxt_sockaddr_t   *sa;
568
0
            nxt_file_name_t  *name;
569
570
0
            sa = rt->controller_listen;
571
572
0
            if (sa->u.sockaddr.sa_family == AF_UNIX) {
573
0
                name = (nxt_file_name_t *) sa->u.sockaddr_un.sun_path;
574
0
                (void) nxt_file_delete(name);
575
0
            }
576
577
0
            for (i = 0; i < rt->listen_sockets->nelts; i++) {
578
0
                nxt_listen_socket_t  *ls;
579
580
0
                ls = (nxt_listen_socket_t *) rt->listen_sockets->elts + i;
581
0
                sa = ls->sockaddr;
582
583
0
                if (sa->u.sockaddr.sa_family != AF_UNIX
584
0
                    || sa->u.sockaddr_un.sun_path[0] == '\0')
585
0
                {
586
0
                    continue;
587
0
                }
588
589
0
                name = (nxt_file_name_t *) sa->u.sockaddr_un.sun_path;
590
0
                (void) nxt_file_delete(name);
591
0
            }
592
0
        }
593
0
#endif
594
0
    }
595
596
0
    if (!engine->event.signal_support) {
597
0
        nxt_event_engine_signals_stop(engine);
598
0
    }
599
600
0
    nxt_runtime_process_each(rt, process) {
601
602
0
        nxt_runtime_process_remove(rt, process);
603
0
        nxt_process_close_ports(task, process);
604
605
0
    } nxt_runtime_process_loop;
606
607
0
    status = rt->status;
608
609
0
    engine_count = 0;
610
611
0
    nxt_queue_each(engine, &rt->engines, nxt_event_engine_t, link) {
612
613
0
        engine_count++;
614
615
0
    } nxt_queue_loop;
616
617
0
    if (engine_count <= 1) {
618
0
        if (rt->port_by_type[rt->type] != NULL) {
619
0
            nxt_port_use(task, rt->port_by_type[rt->type], -1);
620
0
        }
621
622
0
        nxt_thread_mutex_destroy(&rt->processes_mutex);
623
624
0
        nxt_mp_destroy(rt->mem_pool);
625
0
    }
626
627
0
    nxt_debug(task, "exit: %d", status);
628
629
0
    exit(status);
630
0
    nxt_unreachable();
631
0
}
632
633
634
static nxt_int_t
635
nxt_runtime_event_engine_change(nxt_task_t *task, nxt_runtime_t *rt)
636
0
{
637
0
    nxt_event_engine_t           *engine;
638
0
    const nxt_event_interface_t  *interface;
639
640
0
    engine = task->thread->engine;
641
642
0
    if (engine->batch == rt->batch
643
0
        && nxt_strcmp(engine->event.name, rt->engine) == 0)
644
0
    {
645
0
        return NXT_OK;
646
0
    }
647
648
0
    interface = nxt_service_get(rt->services, "engine", rt->engine);
649
650
0
    if (interface != NULL) {
651
0
        return nxt_event_engine_change(engine, interface, rt->batch);
652
0
    }
653
654
0
    return NXT_ERROR;
655
0
}
656
657
658
void
659
nxt_runtime_event_engine_free(nxt_runtime_t *rt)
660
0
{
661
0
    nxt_queue_link_t    *link;
662
0
    nxt_event_engine_t  *engine;
663
664
0
    link = nxt_queue_first(&rt->engines);
665
0
    nxt_queue_remove(link);
666
667
0
    engine = nxt_queue_link_data(link, nxt_event_engine_t, link);
668
0
    nxt_event_engine_free(engine);
669
0
}
670
671
672
nxt_int_t
673
nxt_runtime_thread_pool_create(nxt_thread_t *thr, nxt_runtime_t *rt,
674
    nxt_uint_t max_threads, nxt_nsec_t timeout)
675
0
{
676
0
    nxt_thread_pool_t   *thread_pool, **tp;
677
678
0
    tp = nxt_array_add(rt->thread_pools);
679
0
    if (tp == NULL) {
680
0
        return NXT_ERROR;
681
0
    }
682
683
0
    thread_pool = nxt_thread_pool_create(max_threads, timeout,
684
0
                                         nxt_runtime_thread_pool_init,
685
0
                                         thr->engine,
686
0
                                         nxt_runtime_thread_pool_exit);
687
688
0
    if (nxt_fast_path(thread_pool != NULL)) {
689
0
        *tp = thread_pool;
690
0
    }
691
692
0
    return NXT_OK;
693
0
}
694
695
696
static void
697
nxt_runtime_thread_pool_destroy(nxt_task_t *task, nxt_runtime_t *rt,
698
    nxt_runtime_cont_t cont)
699
0
{
700
0
    nxt_uint_t         n;
701
0
    nxt_thread_pool_t  **tp;
702
703
0
    rt->continuation = cont;
704
705
0
    n = rt->thread_pools->nelts;
706
707
0
    if (n == 0) {
708
0
        cont(task, 0);
709
0
        return;
710
0
    }
711
712
0
    tp = rt->thread_pools->elts;
713
714
0
    do {
715
0
        nxt_thread_pool_destroy(*tp);
716
717
0
        tp++;
718
0
        n--;
719
0
    } while (n != 0);
720
0
}
721
722
723
static void
724
nxt_runtime_thread_pool_init(void)
725
0
{
726
0
}
727
728
729
static void
730
nxt_runtime_thread_pool_exit(nxt_task_t *task, void *obj, void *data)
731
0
{
732
0
    nxt_uint_t           i, n;
733
0
    nxt_runtime_t        *rt;
734
0
    nxt_thread_pool_t    *tp, **thread_pools;
735
0
    nxt_thread_handle_t  handle;
736
737
0
    tp = obj;
738
739
0
    if (data != NULL) {
740
0
        handle = (nxt_thread_handle_t) (uintptr_t) data;
741
0
        nxt_thread_wait(handle);
742
0
    }
743
744
0
    rt = task->thread->runtime;
745
746
0
    thread_pools = rt->thread_pools->elts;
747
0
    n = rt->thread_pools->nelts;
748
749
0
    nxt_debug(task, "thread pools: %ui", n);
750
751
0
    for (i = 0; i < n; i++) {
752
753
0
        if (tp == thread_pools[i]) {
754
0
            nxt_array_remove(rt->thread_pools, &thread_pools[i]);
755
756
0
            nxt_free(tp);
757
758
0
            if (n == 1) {
759
                /* The last thread pool. */
760
0
                rt->continuation(task, 0);
761
0
            }
762
763
0
            return;
764
0
        }
765
0
    }
766
0
}
767
768
769
static nxt_int_t
770
nxt_runtime_conf_init(nxt_task_t *task, nxt_runtime_t *rt)
771
0
{
772
0
    nxt_int_t                    ret;
773
0
    nxt_str_t                    control;
774
0
    nxt_uint_t                   n;
775
0
    nxt_file_t                   *file;
776
0
    const char                   *slash;
777
0
    nxt_sockaddr_t               *sa;
778
0
    nxt_file_name_str_t          file_name;
779
0
    const nxt_event_interface_t  *interface;
780
781
0
    rt->daemon = 1;
782
0
    rt->engine_connections = 256;
783
0
    rt->auxiliary_threads = 2;
784
0
    rt->user_cred.user = NXT_USER;
785
0
    rt->group = NXT_GROUP;
786
0
    rt->pid = NXT_PID;
787
0
    rt->log = NXT_LOG;
788
0
    rt->modules = NXT_MODULESDIR;
789
0
    rt->state = NXT_STATEDIR;
790
0
    rt->control = NXT_CONTROL_SOCK;
791
0
    rt->tmp = NXT_TMPDIR;
792
793
0
    nxt_memzero(&rt->capabilities, sizeof(nxt_capabilities_t));
794
795
0
    if (nxt_runtime_conf_read_cmd(task, rt) != NXT_OK) {
796
0
        return NXT_ERROR;
797
0
    }
798
799
0
    if (nxt_capability_set(task, &rt->capabilities) != NXT_OK) {
800
0
        return NXT_ERROR;
801
0
    }
802
803
0
    if (rt->capabilities.setid) {
804
0
        ret = nxt_credential_get(task, rt->mem_pool, &rt->user_cred,
805
0
                                rt->group);
806
807
0
        if (nxt_slow_path(ret != NXT_OK)) {
808
0
            return NXT_ERROR;
809
0
        }
810
811
0
    } else {
812
0
        nxt_log(task, NXT_LOG_WARN, "Unit is running unprivileged, then it "
813
0
                "cannot use arbitrary user and group.");
814
0
    }
815
816
    /* An engine's parameters. */
817
818
0
    interface = nxt_service_get(rt->services, "engine", rt->engine);
819
0
    if (interface == NULL) {
820
0
        return NXT_ERROR;
821
0
    }
822
823
0
    rt->engine = interface->name;
824
825
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%Z", rt->pid);
826
0
    if (nxt_slow_path(ret != NXT_OK)) {
827
0
        return NXT_ERROR;
828
0
    }
829
830
0
    rt->pid_file = file_name.start;
831
832
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%Z", rt->log);
833
0
    if (nxt_slow_path(ret != NXT_OK)) {
834
0
        return NXT_ERROR;
835
0
    }
836
837
0
    file = nxt_list_first(rt->log_files);
838
0
    file->name = file_name.start;
839
840
0
    slash = "";
841
0
    n = nxt_strlen(rt->modules);
842
843
0
    if (n > 1 && rt->modules[n - 1] != '/') {
844
0
        slash = "/";
845
0
    }
846
847
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%s*.unit.so%Z",
848
0
                               rt->modules, slash);
849
0
    if (nxt_slow_path(ret != NXT_OK)) {
850
0
        return NXT_ERROR;
851
0
    }
852
853
0
    rt->modules = (char *) file_name.start;
854
855
0
    slash = "";
856
0
    n = nxt_strlen(rt->state);
857
858
0
    if (n > 1 && rt->state[n - 1] != '/') {
859
0
        slash = "/";
860
0
    }
861
862
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%sversion%Z",
863
0
                               rt->state, slash);
864
0
    if (nxt_slow_path(ret != NXT_OK)) {
865
0
        return NXT_ERROR;
866
0
    }
867
868
0
    rt->ver = (char *) file_name.start;
869
870
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s.tmp%Z", rt->ver);
871
0
    if (nxt_slow_path(ret != NXT_OK)) {
872
0
        return NXT_ERROR;
873
0
    }
874
875
0
    rt->ver_tmp = (char *) file_name.start;
876
877
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%sconf.json%Z",
878
0
                               rt->state, slash);
879
0
    if (nxt_slow_path(ret != NXT_OK)) {
880
0
        return NXT_ERROR;
881
0
    }
882
883
0
    rt->conf = (char *) file_name.start;
884
885
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s.tmp%Z", rt->conf);
886
0
    if (nxt_slow_path(ret != NXT_OK)) {
887
0
        return NXT_ERROR;
888
0
    }
889
890
0
    rt->conf_tmp = (char *) file_name.start;
891
892
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%scerts/%Z",
893
0
                               rt->state, slash);
894
0
    if (nxt_slow_path(ret != NXT_OK)) {
895
0
        return NXT_ERROR;
896
0
    }
897
898
0
    ret = mkdir((char *) file_name.start, S_IRWXU);
899
900
0
    if (nxt_fast_path(ret == 0 || nxt_errno == EEXIST)) {
901
0
        rt->certs.length = file_name.len;
902
0
        rt->certs.start = file_name.start;
903
904
0
    } else {
905
0
        nxt_alert(task, "Unable to create certificates storage directory: "
906
0
                  "mkdir(%s) failed %E", file_name.start, nxt_errno);
907
0
    }
908
909
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "%s%sscripts/%Z",
910
0
                               rt->state, slash);
911
0
    if (nxt_slow_path(ret != NXT_OK)) {
912
0
        return NXT_ERROR;
913
0
    }
914
915
0
    ret = mkdir((char *) file_name.start, S_IRWXU);
916
917
0
    if (nxt_fast_path(ret == 0 || nxt_errno == EEXIST)) {
918
0
        rt->scripts.length = file_name.len;
919
0
        rt->scripts.start = file_name.start;
920
921
0
    } else {
922
0
        nxt_alert(task, "Unable to create scripts storage directory: "
923
0
                  "mkdir(%s) failed %E", file_name.start, nxt_errno);
924
0
    }
925
926
0
    control.length = nxt_strlen(rt->control);
927
0
    control.start = (u_char *) rt->control;
928
929
0
    sa = nxt_sockaddr_parse(rt->mem_pool, &control);
930
0
    if (nxt_slow_path(sa == NULL)) {
931
0
        return NXT_ERROR;
932
0
    }
933
934
0
    sa->type = SOCK_STREAM;
935
936
0
    rt->controller_listen = sa;
937
938
0
    if (nxt_runtime_controller_socket(task, rt) != NXT_OK) {
939
0
        return NXT_ERROR;
940
0
    }
941
942
0
    return NXT_OK;
943
0
}
944
945
946
static nxt_int_t
947
nxt_runtime_conf_read_cmd(nxt_task_t *task, nxt_runtime_t *rt)
948
0
{
949
0
    char    *p, **argv;
950
0
    u_char  *end;
951
0
    u_char  buf[1024];
952
953
0
    static const char  version[] =
954
0
        "unit version: " NXT_VERSION "\n"
955
0
        "configured as ./configure" NXT_CONFIGURE_OPTIONS "\n";
956
957
0
    static const char  no_control[] =
958
0
                       "option \"--control\" requires socket address\n";
959
0
    static const char  no_user[] = "option \"--user\" requires username\n";
960
0
    static const char  no_group[] = "option \"--group\" requires group name\n";
961
0
    static const char  no_pid[] = "option \"--pid\" requires filename\n";
962
0
    static const char  no_log[] = "option \"--log\" requires filename\n";
963
0
    static const char  no_modules[] =
964
0
                       "option \"--modulesdir\" requires directory\n";
965
0
    static const char  no_state[] =
966
0
                       "option \"--statedir\" requires directory\n";
967
0
    static const char  no_tmp[] = "option \"--tmpdir\" requires directory\n";
968
969
0
    static const char  modules_deprecated[] =
970
0
           "option \"--modules\" is deprecated; use \"--modulesdir\" instead\n";
971
0
    static const char  state_deprecated[] =
972
0
           "option \"--state\" is deprecated; use \"--statedir\" instead\n";
973
0
    static const char  tmp_deprecated[] =
974
0
           "option \"--tmp\" is deprecated; use \"--tmpdir\" instead\n";
975
976
0
    static const char  help[] =
977
0
        "\n"
978
0
        "unit options:\n"
979
0
        "\n"
980
0
        "  --version            print unit version and configure options\n"
981
0
        "\n"
982
0
        "  --no-daemon          run unit in non-daemon mode\n"
983
0
        "\n"
984
0
        "  --control ADDRESS    set address of control API socket\n"
985
0
        "                       default: \"" NXT_CONTROL_SOCK "\"\n"
986
0
        "\n"
987
0
        "  --pid FILE           set pid filename\n"
988
0
        "                       default: \"" NXT_PID "\"\n"
989
0
        "\n"
990
0
        "  --log FILE           set log filename\n"
991
0
        "                       default: \"" NXT_LOG "\"\n"
992
0
        "\n"
993
0
        "  --modulesdir DIR     set modules directory name\n"
994
0
        "                       default: \"" NXT_MODULESDIR "\"\n"
995
0
        "\n"
996
0
        "  --statedir DIR       set state directory name\n"
997
0
        "                       default: \"" NXT_STATEDIR "\"\n"
998
0
        "\n"
999
0
        "  --tmpdir DIR         set tmp directory name\n"
1000
0
        "                       default: \"" NXT_TMPDIR "\"\n"
1001
0
        "\n"
1002
0
        "  --modules DIR        [deprecated] synonym for --modulesdir\n"
1003
0
        "  --state DIR          [deprecated] synonym for --statedir\n"
1004
0
        "  --tmp DIR            [deprecated] synonym for --tmpdir\n"
1005
0
        "\n"
1006
0
        "  --user USER          set non-privileged processes to run"
1007
0
                                " as specified user\n"
1008
0
        "                       default: \"" NXT_USER "\"\n"
1009
0
        "\n"
1010
0
        "  --group GROUP        set non-privileged processes to run"
1011
0
                                " as specified group\n"
1012
0
        "                       default: ";
1013
1014
0
    static const char  group[] = "\"" NXT_GROUP "\"\n\n";
1015
0
    static const char  primary[] = "user's primary group\n\n";
1016
1017
0
    argv = &nxt_process_argv[1];
1018
1019
0
    while (*argv != NULL) {
1020
0
        p = *argv++;
1021
1022
0
        if (nxt_strcmp(p, "--control") == 0) {
1023
0
            if (*argv == NULL) {
1024
0
                write(STDERR_FILENO, no_control, nxt_length(no_control));
1025
0
                return NXT_ERROR;
1026
0
            }
1027
1028
0
            p = *argv++;
1029
1030
0
            rt->control = p;
1031
1032
0
            continue;
1033
0
        }
1034
1035
0
        if (nxt_strcmp(p, "--user") == 0) {
1036
0
            if (*argv == NULL) {
1037
0
                write(STDERR_FILENO, no_user, nxt_length(no_user));
1038
0
                return NXT_ERROR;
1039
0
            }
1040
1041
0
            p = *argv++;
1042
1043
0
            rt->user_cred.user = p;
1044
1045
0
            continue;
1046
0
        }
1047
1048
0
        if (nxt_strcmp(p, "--group") == 0) {
1049
0
            if (*argv == NULL) {
1050
0
                write(STDERR_FILENO, no_group, nxt_length(no_group));
1051
0
                return NXT_ERROR;
1052
0
            }
1053
1054
0
            p = *argv++;
1055
1056
0
            rt->group = p;
1057
1058
0
            continue;
1059
0
        }
1060
1061
0
        if (nxt_strcmp(p, "--pid") == 0) {
1062
0
            if (*argv == NULL) {
1063
0
                write(STDERR_FILENO, no_pid, nxt_length(no_pid));
1064
0
                return NXT_ERROR;
1065
0
            }
1066
1067
0
            p = *argv++;
1068
1069
0
            rt->pid = p;
1070
1071
0
            continue;
1072
0
        }
1073
1074
0
        if (nxt_strcmp(p, "--log") == 0) {
1075
0
            if (*argv == NULL) {
1076
0
                write(STDERR_FILENO, no_log, nxt_length(no_log));
1077
0
                return NXT_ERROR;
1078
0
            }
1079
1080
0
            p = *argv++;
1081
1082
0
            rt->log = p;
1083
1084
0
            continue;
1085
0
        }
1086
1087
0
        if (nxt_strcmp(p, "--modules") == 0) {
1088
0
            write(STDERR_FILENO, modules_deprecated,
1089
0
                  nxt_length(modules_deprecated));
1090
0
            goto modulesdir;
1091
0
        }
1092
1093
0
        if (nxt_strcmp(p, "--modulesdir") == 0) {
1094
0
modulesdir:
1095
0
            if (*argv == NULL) {
1096
0
                write(STDERR_FILENO, no_modules, nxt_length(no_modules));
1097
0
                return NXT_ERROR;
1098
0
            }
1099
1100
0
            p = *argv++;
1101
1102
0
            rt->modules = p;
1103
1104
0
            continue;
1105
0
        }
1106
1107
0
        if (nxt_strcmp(p, "--state") == 0) {
1108
0
            write(STDERR_FILENO, state_deprecated,
1109
0
                  nxt_length(state_deprecated));
1110
0
            goto statedir;
1111
0
        }
1112
1113
0
        if (nxt_strcmp(p, "--statedir") == 0) {
1114
0
statedir:
1115
0
            if (*argv == NULL) {
1116
0
                write(STDERR_FILENO, no_state, nxt_length(no_state));
1117
0
                return NXT_ERROR;
1118
0
            }
1119
1120
0
            p = *argv++;
1121
1122
0
            rt->state = p;
1123
1124
0
            continue;
1125
0
        }
1126
1127
0
        if (nxt_strcmp(p, "--tmp") == 0) {
1128
0
            write(STDERR_FILENO, tmp_deprecated, nxt_length(tmp_deprecated));
1129
0
            goto tmpdir;
1130
0
        }
1131
1132
0
        if (nxt_strcmp(p, "--tmpdir") == 0) {
1133
0
tmpdir:
1134
0
            if (*argv == NULL) {
1135
0
                write(STDERR_FILENO, no_tmp, nxt_length(no_tmp));
1136
0
                return NXT_ERROR;
1137
0
            }
1138
1139
0
            p = *argv++;
1140
1141
0
            rt->tmp = p;
1142
1143
0
            continue;
1144
0
        }
1145
1146
0
        if (nxt_strcmp(p, "--no-daemon") == 0) {
1147
0
            rt->daemon = 0;
1148
0
            continue;
1149
0
        }
1150
1151
0
        if (nxt_strcmp(p, "--version") == 0) {
1152
0
            write(STDERR_FILENO, version, nxt_length(version));
1153
0
            exit(0);
1154
0
        }
1155
1156
0
        if (nxt_strcmp(p, "--help") == 0 || nxt_strcmp(p, "-h") == 0) {
1157
0
            write(STDOUT_FILENO, help, nxt_length(help));
1158
1159
0
            if (sizeof(NXT_GROUP) == 1) {
1160
0
                write(STDOUT_FILENO, primary, nxt_length(primary));
1161
1162
0
            } else {
1163
0
                write(STDOUT_FILENO, group, nxt_length(group));
1164
0
            }
1165
1166
0
            exit(0);
1167
0
        }
1168
1169
0
        end = nxt_sprintf(buf, buf + sizeof(buf), "unknown option \"%s\", "
1170
0
                          "try \"%s -h\" for available options\n",
1171
0
                          p, nxt_process_argv[0]);
1172
1173
0
        write(STDERR_FILENO, buf, end - buf);
1174
1175
0
        return NXT_ERROR;
1176
0
    }
1177
1178
0
    return NXT_OK;
1179
0
}
1180
1181
1182
nxt_listen_socket_t *
1183
nxt_runtime_listen_socket_add(nxt_runtime_t *rt, nxt_sockaddr_t *sa)
1184
0
{
1185
0
    nxt_mp_t             *mp;
1186
0
    nxt_listen_socket_t  *ls;
1187
1188
0
    ls = nxt_array_zero_add(rt->listen_sockets);
1189
0
    if (ls == NULL) {
1190
0
        return NULL;
1191
0
    }
1192
1193
0
    mp = rt->mem_pool;
1194
1195
0
    ls->sockaddr = nxt_sockaddr_create(mp, &sa->u.sockaddr, sa->socklen,
1196
0
                                       sa->length);
1197
0
    if (ls->sockaddr == NULL) {
1198
0
        return NULL;
1199
0
    }
1200
1201
0
    ls->sockaddr->type = sa->type;
1202
1203
0
    nxt_sockaddr_text(ls->sockaddr);
1204
1205
0
    ls->socket = -1;
1206
0
    ls->backlog = NXT_LISTEN_BACKLOG;
1207
1208
0
    return ls;
1209
0
}
1210
1211
1212
static nxt_int_t
1213
nxt_runtime_hostname(nxt_task_t *task, nxt_runtime_t *rt)
1214
0
{
1215
0
    size_t  length;
1216
0
    char    hostname[NXT_MAXHOSTNAMELEN + 1];
1217
1218
0
    if (gethostname(hostname, NXT_MAXHOSTNAMELEN) != 0) {
1219
0
        nxt_alert(task, "gethostname() failed %E", nxt_errno);
1220
0
        return NXT_ERROR;
1221
0
    }
1222
1223
    /*
1224
     * Linux gethostname(2):
1225
     *
1226
     *    If the null-terminated hostname is too large to fit,
1227
     *    then the name is truncated, and no error is returned.
1228
     *
1229
     * For this reason an additional byte is reserved in the buffer.
1230
     */
1231
0
    hostname[NXT_MAXHOSTNAMELEN] = '\0';
1232
1233
0
    length = nxt_strlen(hostname);
1234
0
    rt->hostname.length = length;
1235
1236
0
    rt->hostname.start = nxt_mp_nget(rt->mem_pool, length);
1237
1238
0
    if (rt->hostname.start != NULL) {
1239
0
        nxt_memcpy_lowcase(rt->hostname.start, (u_char *) hostname, length);
1240
0
        return NXT_OK;
1241
0
    }
1242
1243
0
    return NXT_ERROR;
1244
0
}
1245
1246
1247
static nxt_int_t
1248
nxt_runtime_log_files_init(nxt_runtime_t *rt)
1249
0
{
1250
0
    nxt_file_t  *file;
1251
0
    nxt_list_t  *log_files;
1252
1253
0
    log_files = nxt_list_create(rt->mem_pool, 1, sizeof(nxt_file_t));
1254
1255
0
    if (nxt_fast_path(log_files != NULL)) {
1256
0
        rt->log_files = log_files;
1257
1258
        /* Preallocate the main log.  This allocation cannot fail. */
1259
0
        file = nxt_list_zero_add(log_files);
1260
1261
0
        file->fd = NXT_FILE_INVALID;
1262
0
        file->log_level = NXT_LOG_ALERT;
1263
1264
0
        return NXT_OK;
1265
0
    }
1266
1267
0
    return NXT_ERROR;
1268
0
}
1269
1270
1271
nxt_file_t *
1272
nxt_runtime_log_file_add(nxt_runtime_t *rt, nxt_str_t *name)
1273
0
{
1274
0
    nxt_int_t            ret;
1275
0
    nxt_file_t           *file;
1276
0
    nxt_file_name_str_t  file_name;
1277
1278
0
    ret = nxt_file_name_create(rt->mem_pool, &file_name, "V%Z", name);
1279
1280
0
    if (nxt_slow_path(ret != NXT_OK)) {
1281
0
        return NULL;
1282
0
    }
1283
1284
0
    nxt_list_each(file, rt->log_files) {
1285
1286
        /* STUB: hardecoded case sensitive/insensitive. */
1287
1288
0
        if (file->name != NULL
1289
0
            && nxt_file_name_eq(file->name, file_name.start))
1290
0
        {
1291
0
            return file;
1292
0
        }
1293
1294
0
    } nxt_list_loop;
1295
1296
0
    file = nxt_list_zero_add(rt->log_files);
1297
1298
0
    if (nxt_slow_path(file == NULL)) {
1299
0
        return NULL;
1300
0
    }
1301
1302
0
    file->fd = NXT_FILE_INVALID;
1303
0
    file->log_level = NXT_LOG_ALERT;
1304
0
    file->name = file_name.start;
1305
1306
0
    return file;
1307
0
}
1308
1309
1310
static nxt_int_t
1311
nxt_runtime_log_files_create(nxt_task_t *task, nxt_runtime_t *rt)
1312
0
{
1313
0
    nxt_int_t   ret;
1314
0
    nxt_file_t  *file;
1315
1316
0
    nxt_list_each(file, rt->log_files) {
1317
1318
0
        ret = nxt_file_open(task, file, O_WRONLY | O_APPEND, O_CREAT,
1319
0
                            NXT_FILE_OWNER_ACCESS);
1320
1321
0
        if (ret != NXT_OK) {
1322
0
            return NXT_ERROR;
1323
0
        }
1324
1325
0
    } nxt_list_loop;
1326
1327
0
    file = nxt_list_first(rt->log_files);
1328
1329
0
    return nxt_file_stderr(file);
1330
0
}
1331
1332
1333
nxt_int_t
1334
nxt_runtime_listen_sockets_create(nxt_task_t *task, nxt_runtime_t *rt)
1335
0
{
1336
0
    nxt_int_t            ret;
1337
0
    nxt_uint_t           c, p, ncurr, nprev;
1338
0
    nxt_listen_socket_t  *curr, *prev;
1339
1340
0
    curr = rt->listen_sockets->elts;
1341
0
    ncurr = rt->listen_sockets->nelts;
1342
1343
0
    if (rt->inherited_sockets != NULL) {
1344
0
        prev = rt->inherited_sockets->elts;
1345
0
        nprev = rt->inherited_sockets->nelts;
1346
1347
0
    } else {
1348
0
        prev = NULL;
1349
0
        nprev = 0;
1350
0
    }
1351
1352
0
    for (c = 0; c < ncurr; c++) {
1353
1354
0
        for (p = 0; p < nprev; p++) {
1355
1356
0
            if (nxt_sockaddr_cmp(curr[c].sockaddr, prev[p].sockaddr)) {
1357
1358
0
                ret = nxt_listen_socket_update(task, &curr[c], &prev[p]);
1359
0
                if (ret != NXT_OK) {
1360
0
                    return NXT_ERROR;
1361
0
                }
1362
1363
0
                goto next;
1364
0
            }
1365
0
        }
1366
1367
0
        if (nxt_listen_socket_create(task, rt->mem_pool, &curr[c]) != NXT_OK) {
1368
0
            return NXT_ERROR;
1369
0
        }
1370
1371
0
    next:
1372
1373
0
        continue;
1374
0
    }
1375
1376
0
    return NXT_OK;
1377
0
}
1378
1379
1380
nxt_int_t
1381
nxt_runtime_listen_sockets_enable(nxt_task_t *task, nxt_runtime_t *rt)
1382
0
{
1383
0
    nxt_uint_t           i, n;
1384
0
    nxt_listen_socket_t  *ls;
1385
1386
0
    ls = rt->listen_sockets->elts;
1387
0
    n = rt->listen_sockets->nelts;
1388
1389
0
    for (i = 0; i < n; i++) {
1390
0
        if (ls[i].flags == NXT_NONBLOCK) {
1391
0
            if (nxt_listen_event(task, &ls[i]) == NULL) {
1392
0
                return NXT_ERROR;
1393
0
            }
1394
0
        }
1395
0
    }
1396
1397
0
    return NXT_OK;
1398
0
}
1399
1400
1401
nxt_str_t *
1402
nxt_current_directory(nxt_mp_t *mp)
1403
0
{
1404
0
    size_t     length;
1405
0
    u_char     *p;
1406
0
    nxt_str_t  *name;
1407
0
    char       buf[NXT_MAX_PATH_LEN];
1408
1409
0
    length = nxt_dir_current(buf, NXT_MAX_PATH_LEN);
1410
1411
0
    if (nxt_fast_path(length != 0)) {
1412
0
        name = nxt_str_alloc(mp, length + 1);
1413
1414
0
        if (nxt_fast_path(name != NULL)) {
1415
0
            p = nxt_cpymem(name->start, buf, length);
1416
0
            *p = '/';
1417
1418
0
            return name;
1419
0
        }
1420
0
    }
1421
1422
0
    return NULL;
1423
0
}
1424
1425
1426
static nxt_int_t
1427
nxt_runtime_pid_file_create(nxt_task_t *task, nxt_file_name_t *pid_file)
1428
0
{
1429
0
    ssize_t     length;
1430
0
    nxt_int_t   n;
1431
0
    nxt_file_t  file;
1432
0
    u_char      pid[NXT_INT64_T_LEN + nxt_length("\n")];
1433
1434
0
    nxt_memzero(&file, sizeof(nxt_file_t));
1435
1436
0
    file.name = pid_file;
1437
1438
0
    nxt_fs_mkdir_parent(pid_file, 0755);
1439
1440
0
    n = nxt_file_open(task, &file, O_WRONLY, O_CREAT | O_TRUNC,
1441
0
                      NXT_FILE_DEFAULT_ACCESS);
1442
1443
0
    if (n != NXT_OK) {
1444
0
        return NXT_ERROR;
1445
0
    }
1446
1447
0
    length = nxt_sprintf(pid, pid + sizeof(pid), "%PI%n", nxt_pid) - pid;
1448
1449
0
    if (nxt_file_write(&file, pid, length, 0) != length) {
1450
0
        return NXT_ERROR;
1451
0
    }
1452
1453
0
    nxt_file_close(task, &file);
1454
1455
0
    return NXT_OK;
1456
0
}
1457
1458
1459
void
1460
nxt_runtime_process_release(nxt_runtime_t *rt, nxt_process_t *process)
1461
0
{
1462
0
    nxt_process_t  *child;
1463
1464
0
    if (process->registered == 1) {
1465
0
        nxt_runtime_process_remove(rt, process);
1466
0
    }
1467
1468
0
    if (process->link.next != NULL) {
1469
0
        nxt_queue_remove(&process->link);
1470
0
    }
1471
1472
0
    nxt_queue_each(child, &process->children, nxt_process_t, link) {
1473
0
        nxt_queue_remove(&child->link);
1474
0
        child->link.next = NULL;
1475
0
    } nxt_queue_loop;
1476
1477
0
    nxt_assert(process->use_count == 0);
1478
0
    nxt_assert(process->registered == 0);
1479
0
    nxt_assert(nxt_queue_is_empty(&process->ports));
1480
1481
0
    nxt_port_mmaps_destroy(&process->incoming, 1);
1482
1483
0
    nxt_thread_mutex_destroy(&process->incoming.mutex);
1484
1485
    /* processes from nxt_runtime_process_get() have no memory pool */
1486
0
    if (process->mem_pool != NULL) {
1487
0
        nxt_mp_destroy(process->mem_pool);
1488
0
    }
1489
1490
0
    nxt_mp_free(rt->mem_pool, process);
1491
0
}
1492
1493
1494
static nxt_int_t
1495
nxt_runtime_lvlhsh_pid_test(nxt_lvlhsh_query_t *lhq, void *data)
1496
0
{
1497
0
    nxt_process_t  *process;
1498
1499
0
    process = data;
1500
1501
0
    if (lhq->key.length == sizeof(nxt_pid_t)
1502
0
        && *(nxt_pid_t *) lhq->key.start == process->pid)
1503
0
    {
1504
0
        return NXT_OK;
1505
0
    }
1506
1507
0
    return NXT_DECLINED;
1508
0
}
1509
1510
static const nxt_lvlhsh_proto_t  lvlhsh_processes_proto  nxt_aligned(64) = {
1511
    NXT_LVLHSH_DEFAULT,
1512
    nxt_runtime_lvlhsh_pid_test,
1513
    nxt_lvlhsh_alloc,
1514
    nxt_lvlhsh_free,
1515
};
1516
1517
1518
nxt_inline void
1519
nxt_runtime_process_lhq_pid(nxt_lvlhsh_query_t *lhq, nxt_pid_t *pid)
1520
0
{
1521
0
    lhq->key_hash = nxt_murmur_hash2(pid, sizeof(*pid));
1522
0
    lhq->key.length = sizeof(*pid);
1523
0
    lhq->key.start = (u_char *) pid;
1524
0
    lhq->proto = &lvlhsh_processes_proto;
1525
0
}
1526
1527
1528
nxt_process_t *
1529
nxt_runtime_process_find(nxt_runtime_t *rt, nxt_pid_t pid)
1530
0
{
1531
0
    nxt_process_t       *process;
1532
0
    nxt_lvlhsh_query_t  lhq;
1533
1534
0
    process = NULL;
1535
1536
0
    nxt_runtime_process_lhq_pid(&lhq, &pid);
1537
1538
0
    nxt_thread_mutex_lock(&rt->processes_mutex);
1539
1540
0
    if (nxt_lvlhsh_find(&rt->processes, &lhq) == NXT_OK) {
1541
0
        process = lhq.value;
1542
1543
0
    } else {
1544
0
        nxt_thread_log_debug("process %PI not found", pid);
1545
0
    }
1546
1547
0
    nxt_thread_mutex_unlock(&rt->processes_mutex);
1548
1549
0
    return process;
1550
0
}
1551
1552
1553
static nxt_process_t *
1554
nxt_runtime_process_get(nxt_runtime_t *rt, nxt_pid_t pid)
1555
0
{
1556
0
    nxt_process_t       *process;
1557
0
    nxt_lvlhsh_query_t  lhq;
1558
1559
0
    nxt_runtime_process_lhq_pid(&lhq, &pid);
1560
1561
0
    nxt_thread_mutex_lock(&rt->processes_mutex);
1562
1563
0
    if (nxt_lvlhsh_find(&rt->processes, &lhq) == NXT_OK) {
1564
0
        nxt_thread_log_debug("process %PI found", pid);
1565
1566
0
        nxt_thread_mutex_unlock(&rt->processes_mutex);
1567
1568
0
        process = lhq.value;
1569
0
        process->use_count++;
1570
1571
0
        return process;
1572
0
    }
1573
1574
0
    process = nxt_process_new(rt);
1575
0
    if (nxt_slow_path(process == NULL)) {
1576
1577
0
        nxt_thread_mutex_unlock(&rt->processes_mutex);
1578
1579
0
        return NULL;
1580
0
    }
1581
1582
0
    process->pid = pid;
1583
1584
0
    lhq.replace = 0;
1585
0
    lhq.value = process;
1586
0
    lhq.pool = rt->mem_pool;
1587
1588
0
    switch (nxt_lvlhsh_insert(&rt->processes, &lhq)) {
1589
1590
0
    case NXT_OK:
1591
0
        if (rt->nprocesses == 0) {
1592
0
            rt->mprocess = process;
1593
0
        }
1594
1595
0
        rt->nprocesses++;
1596
1597
0
        process->registered = 1;
1598
1599
0
        nxt_thread_log_debug("process %PI insert", pid);
1600
0
        break;
1601
1602
0
    default:
1603
0
        nxt_thread_log_debug("process %PI insert failed", pid);
1604
0
        break;
1605
0
    }
1606
1607
0
    nxt_thread_mutex_unlock(&rt->processes_mutex);
1608
1609
0
    return process;
1610
0
}
1611
1612
1613
void
1614
nxt_runtime_process_add(nxt_task_t *task, nxt_process_t *process)
1615
0
{
1616
0
    nxt_port_t          *port;
1617
0
    nxt_runtime_t       *rt;
1618
0
    nxt_lvlhsh_query_t  lhq;
1619
1620
0
    nxt_assert(process->registered == 0);
1621
1622
0
    rt = task->thread->runtime;
1623
1624
0
    nxt_runtime_process_lhq_pid(&lhq, &process->pid);
1625
1626
0
    lhq.replace = 0;
1627
0
    lhq.value = process;
1628
0
    lhq.pool = rt->mem_pool;
1629
1630
0
    nxt_thread_mutex_lock(&rt->processes_mutex);
1631
1632
0
    switch (nxt_lvlhsh_insert(&rt->processes, &lhq)) {
1633
1634
0
    case NXT_OK:
1635
0
        if (rt->nprocesses == 0) {
1636
0
            rt->mprocess = process;
1637
0
        }
1638
1639
0
        rt->nprocesses++;
1640
1641
0
        nxt_process_port_each(process, port) {
1642
1643
0
            port->pid = process->pid;
1644
1645
0
            nxt_runtime_port_add(task, port);
1646
1647
0
        } nxt_process_port_loop;
1648
1649
0
        process->registered = 1;
1650
1651
0
        nxt_debug(task, "process %PI added", process->pid);
1652
0
        break;
1653
1654
0
    default:
1655
0
        nxt_alert(task, "process %PI failed to add", process->pid);
1656
0
        break;
1657
0
    }
1658
1659
0
    nxt_thread_mutex_unlock(&rt->processes_mutex);
1660
0
}
1661
1662
1663
void
1664
nxt_runtime_process_remove(nxt_runtime_t *rt, nxt_process_t *process)
1665
0
{
1666
0
    nxt_pid_t           pid;
1667
0
    nxt_lvlhsh_query_t  lhq;
1668
1669
0
    nxt_assert(process->registered != 0);
1670
1671
0
    pid = process->pid;
1672
1673
0
    nxt_runtime_process_lhq_pid(&lhq, &pid);
1674
1675
0
    lhq.pool = rt->mem_pool;
1676
1677
0
    nxt_thread_mutex_lock(&rt->processes_mutex);
1678
1679
0
    switch (nxt_lvlhsh_delete(&rt->processes, &lhq)) {
1680
1681
0
    case NXT_OK:
1682
0
        nxt_assert(lhq.value == process);
1683
1684
0
        rt->nprocesses--;
1685
1686
0
        process->registered = 0;
1687
1688
0
        nxt_thread_log_debug("process %PI removed", pid);
1689
0
        break;
1690
1691
0
    default:
1692
0
        nxt_thread_log_alert("process %PI remove failed", pid);
1693
0
        break;
1694
0
    }
1695
1696
0
    nxt_thread_mutex_unlock(&rt->processes_mutex);
1697
0
}
1698
1699
1700
nxt_process_t *
1701
nxt_runtime_process_first(nxt_runtime_t *rt, nxt_lvlhsh_each_t *lhe)
1702
0
{
1703
0
    nxt_lvlhsh_each_init(lhe, &lvlhsh_processes_proto);
1704
1705
0
    return nxt_runtime_process_next(rt, lhe);
1706
0
}
1707
1708
1709
nxt_port_t *
1710
nxt_runtime_process_port_create(nxt_task_t *task, nxt_runtime_t *rt,
1711
    nxt_pid_t pid, nxt_port_id_t id, nxt_process_type_t type)
1712
0
{
1713
0
    nxt_port_t     *port;
1714
0
    nxt_process_t  *process;
1715
1716
0
    process = nxt_runtime_process_get(rt, pid);
1717
0
    if (nxt_slow_path(process == NULL)) {
1718
0
        return NULL;
1719
0
    }
1720
1721
0
    port = nxt_port_new(task, id, pid, type);
1722
0
    if (nxt_slow_path(port == NULL)) {
1723
0
        nxt_process_use(task, process, -1);
1724
0
        return NULL;
1725
0
    }
1726
1727
0
    nxt_process_port_add(task, process, port);
1728
1729
0
    nxt_process_use(task, process, -1);
1730
1731
0
    nxt_runtime_port_add(task, port);
1732
1733
0
    nxt_port_use(task, port, -1);
1734
1735
0
    return port;
1736
0
}
1737
1738
1739
static void
1740
nxt_runtime_port_add(nxt_task_t *task, nxt_port_t *port)
1741
0
{
1742
0
    nxt_int_t      res;
1743
0
    nxt_runtime_t  *rt;
1744
1745
0
    rt = task->thread->runtime;
1746
1747
0
    res = nxt_port_hash_add(&rt->ports, port);
1748
1749
0
    if (res != NXT_OK) {
1750
0
        return;
1751
0
    }
1752
1753
0
    rt->port_by_type[port->type] = port;
1754
1755
0
    nxt_port_use(task, port, 1);
1756
0
}
1757
1758
1759
void
1760
nxt_runtime_port_remove(nxt_task_t *task, nxt_port_t *port)
1761
0
{
1762
0
    nxt_int_t      res;
1763
0
    nxt_runtime_t  *rt;
1764
1765
0
    rt = task->thread->runtime;
1766
1767
0
    res = nxt_port_hash_remove(&rt->ports, port);
1768
1769
0
    if (res != NXT_OK) {
1770
0
        return;
1771
0
    }
1772
1773
0
    if (rt->port_by_type[port->type] == port) {
1774
0
        rt->port_by_type[port->type] = NULL;
1775
0
    }
1776
1777
0
    nxt_port_use(task, port, -1);
1778
0
}
1779
1780
1781
nxt_port_t *
1782
nxt_runtime_port_find(nxt_runtime_t *rt, nxt_pid_t pid,
1783
    nxt_port_id_t port_id)
1784
0
{
1785
0
    return nxt_port_hash_find(&rt->ports, pid, port_id);
1786
0
}