xref: /unit/src/nxt_process.c (revision 1240:656d544a94e5)
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) NGINX, Inc.
5  */
6 
7 #include <nxt_main.h>
8 #include <nxt_main_process.h>
9 
10 #if (NXT_HAVE_CLONE)
11 #include <nxt_clone.h>
12 #endif
13 
14 #include <signal.h>
15 
16 static void nxt_process_start(nxt_task_t *task, nxt_process_t *process);
17 static nxt_int_t nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc);
18 static nxt_int_t nxt_process_worker_setup(nxt_task_t *task,
19     nxt_process_t *process, int parentfd);
20 
21 /* A cached process pid. */
22 nxt_pid_t  nxt_pid;
23 
24 /* An original parent process pid. */
25 nxt_pid_t  nxt_ppid;
26 
27 nxt_bool_t  nxt_proc_conn_matrix[NXT_PROCESS_MAX][NXT_PROCESS_MAX] = {
28     { 1, 1, 1, 1, 1 },
29     { 1, 0, 0, 0, 0 },
30     { 1, 0, 0, 1, 0 },
31     { 1, 0, 1, 0, 1 },
32     { 1, 0, 0, 0, 0 },
33 };
34 
35 nxt_bool_t  nxt_proc_remove_notify_matrix[NXT_PROCESS_MAX][NXT_PROCESS_MAX] = {
36     { 0, 0, 0, 0, 0 },
37     { 0, 0, 0, 0, 0 },
38     { 0, 0, 0, 1, 0 },
39     { 0, 0, 1, 0, 1 },
40     { 0, 0, 0, 1, 0 },
41 };
42 
43 
44 static nxt_int_t
45 nxt_process_worker_setup(nxt_task_t *task, nxt_process_t *process, int parentfd)
46 {
47     pid_t               rpid, pid;
48     ssize_t             n;
49     nxt_int_t           parent_status;
50     nxt_process_t       *p;
51     nxt_runtime_t       *rt;
52     nxt_process_init_t  *init;
53     nxt_process_type_t  ptype;
54 
55     pid  = getpid();
56     rpid = 0;
57     rt   = task->thread->runtime;
58     init = process->init;
59 
60     /* Setup the worker process. */
61 
62     n = read(parentfd, &rpid, sizeof(rpid));
63     if (nxt_slow_path(n == -1 || n != sizeof(rpid))) {
64         nxt_alert(task, "failed to read real pid");
65         return NXT_ERROR;
66     }
67 
68     if (nxt_slow_path(rpid == 0)) {
69         nxt_alert(task, "failed to get real pid from parent");
70         return NXT_ERROR;
71     }
72 
73     nxt_pid = rpid;
74 
75     /* Clean inherited cached thread tid. */
76     task->thread->tid = 0;
77 
78     process->pid = nxt_pid;
79 
80     if (nxt_pid != pid) {
81         nxt_debug(task, "app \"%s\" real pid %d", init->name, nxt_pid);
82         nxt_debug(task, "app \"%s\" isolated pid: %d", init->name, pid);
83     }
84 
85     n = read(parentfd, &parent_status, sizeof(parent_status));
86     if (nxt_slow_path(n == -1 || n != sizeof(parent_status))) {
87         nxt_alert(task, "failed to read parent status");
88         return NXT_ERROR;
89     }
90 
91     if (nxt_slow_path(parent_status != NXT_OK)) {
92         return parent_status;
93     }
94 
95     ptype = init->type;
96 
97     nxt_port_reset_next_id();
98 
99     nxt_event_engine_thread_adopt(task->thread->engine);
100 
101     /* Remove not ready processes. */
102     nxt_runtime_process_each(rt, p) {
103 
104         if (nxt_proc_conn_matrix[ptype][nxt_process_type(p)] == 0) {
105             nxt_debug(task, "remove not required process %PI", p->pid);
106 
107             nxt_process_close_ports(task, p);
108 
109             continue;
110         }
111 
112         if (!p->ready) {
113             nxt_debug(task, "remove not ready process %PI", p->pid);
114 
115             nxt_process_close_ports(task, p);
116 
117             continue;
118         }
119 
120         nxt_port_mmaps_destroy(&p->incoming, 0);
121         nxt_port_mmaps_destroy(&p->outgoing, 0);
122 
123     } nxt_runtime_process_loop;
124 
125     nxt_runtime_process_add(task, process);
126 
127     nxt_process_start(task, process);
128 
129     process->ready = 1;
130 
131     return NXT_OK;
132 }
133 
134 
135 nxt_pid_t
136 nxt_process_create(nxt_task_t *task, nxt_process_t *process)
137 {
138     int                 pipefd[2];
139     nxt_int_t           ret;
140     nxt_pid_t           pid;
141     nxt_process_init_t  *init;
142 
143     if (nxt_slow_path(pipe(pipefd) == -1)) {
144         nxt_alert(task, "failed to create process pipe for passing rpid");
145         return -1;
146     }
147 
148     init = process->init;
149 
150 #if (NXT_HAVE_CLONE)
151     pid = nxt_clone(SIGCHLD | init->isolation.clone.flags);
152     if (nxt_slow_path(pid < 0)) {
153         nxt_alert(task, "clone() failed while creating \"%s\" %E",
154                   init->name, nxt_errno);
155         goto cleanup;
156     }
157 #else
158     pid = fork();
159     if (nxt_slow_path(pid < 0)) {
160         nxt_alert(task, "fork() failed while creating \"%s\" %E",
161                   init->name, nxt_errno);
162         goto cleanup;
163     }
164 #endif
165 
166     if (pid == 0) {
167         /* Child. */
168 
169         if (nxt_slow_path(close(pipefd[1]) == -1)) {
170             nxt_alert(task, "failed to close writer pipe fd");
171         }
172 
173         ret = nxt_process_worker_setup(task, process, pipefd[0]);
174         if (nxt_slow_path(ret != NXT_OK)) {
175             exit(1);
176         }
177 
178         if (nxt_slow_path(close(pipefd[0]) == -1)) {
179             nxt_alert(task, "failed to close writer pipe fd");
180         }
181 
182         /*
183          * Explicitly return 0 to notice the caller function this is the child.
184          * The caller must return to the event engine work queue loop.
185          */
186         return 0;
187     }
188 
189     /* Parent. */
190 
191     /*
192      * At this point, the child process is blocked reading the
193      * pipe fd to get its real pid (rpid).
194      *
195      * If anything goes wrong now, we need to terminate the child
196      * process by sending a NXT_ERROR in the pipe.
197      */
198 
199 #if (NXT_HAVE_CLONE)
200     nxt_debug(task, "clone(\"%s\"): %PI", init->name, pid);
201 #else
202     nxt_debug(task, "fork(\"%s\"): %PI", init->name, pid);
203 #endif
204 
205     if (nxt_slow_path(write(pipefd[1], &pid, sizeof(pid)) == -1)) {
206         nxt_alert(task, "failed to write real pid");
207         goto fail;
208     }
209 
210 #if (NXT_HAVE_CLONE_NEWUSER)
211     if ((init->isolation.clone.flags & CLONE_NEWUSER) == CLONE_NEWUSER) {
212         ret = nxt_clone_proc_map(task, pid, &init->isolation.clone);
213         if (nxt_slow_path(ret != NXT_OK)) {
214             goto fail;
215         }
216     }
217 #endif
218 
219     ret = NXT_OK;
220 
221     if (nxt_slow_path(write(pipefd[1], &ret, sizeof(ret)) == -1)) {
222         nxt_alert(task, "failed to write status");
223         goto fail;
224     }
225 
226     process->pid = pid;
227 
228     nxt_runtime_process_add(task, process);
229 
230     goto cleanup;
231 
232 fail:
233 
234     ret = NXT_ERROR;
235 
236     if (nxt_slow_path(write(pipefd[1], &ret, sizeof(ret)) == -1)) {
237         nxt_alert(task, "failed to write status");
238     }
239 
240     waitpid(pid, NULL, 0);
241 
242     pid = -1;
243 
244 cleanup:
245 
246     if (nxt_slow_path(close(pipefd[0]) != 0)) {
247         nxt_alert(task, "failed to close pipe: %E", nxt_errno);
248     }
249 
250     if (nxt_slow_path(close(pipefd[1]) != 0)) {
251         nxt_alert(task, "failed to close pipe: %E", nxt_errno);
252     }
253 
254     return pid;
255 }
256 
257 
258 static void
259 nxt_process_start(nxt_task_t *task, nxt_process_t *process)
260 {
261     nxt_int_t                    ret;
262     nxt_port_t                   *port, *main_port;
263     nxt_thread_t                 *thread;
264     nxt_runtime_t                *rt;
265     nxt_process_init_t           *init;
266     nxt_event_engine_t           *engine;
267     const nxt_event_interface_t  *interface;
268 
269     init = process->init;
270 
271     nxt_log(task, NXT_LOG_INFO, "%s started", init->name);
272 
273     nxt_process_title(task, "unit: %s", init->name);
274 
275     thread = task->thread;
276     rt     = thread->runtime;
277 
278     nxt_random_init(&thread->random);
279 
280     if (rt->capabilities.setid && init->user_cred != NULL) {
281         ret = nxt_user_cred_set(task, init->user_cred);
282         if (ret != NXT_OK) {
283             goto fail;
284         }
285     }
286 
287     rt->type = init->type;
288 
289     engine = thread->engine;
290 
291     /* Update inherited main process event engine and signals processing. */
292     engine->signals->sigev = init->signals;
293 
294     interface = nxt_service_get(rt->services, "engine", rt->engine);
295     if (nxt_slow_path(interface == NULL)) {
296         goto fail;
297     }
298 
299     if (nxt_event_engine_change(engine, interface, rt->batch) != NXT_OK) {
300         goto fail;
301     }
302 
303     ret = nxt_runtime_thread_pool_create(thread, rt, rt->auxiliary_threads,
304                                          60000 * 1000000LL);
305     if (nxt_slow_path(ret != NXT_OK)) {
306         goto fail;
307     }
308 
309     main_port = rt->port_by_type[NXT_PROCESS_MAIN];
310 
311     nxt_port_read_close(main_port);
312     nxt_port_write_enable(task, main_port);
313 
314     port = nxt_process_port_first(process);
315 
316     nxt_port_write_close(port);
317 
318     ret = init->start(task, init->data);
319 
320     if (nxt_slow_path(ret != NXT_OK)) {
321         goto fail;
322     }
323 
324     nxt_port_enable(task, port, init->port_handlers);
325 
326     ret = nxt_port_socket_write(task, main_port, NXT_PORT_MSG_PROCESS_READY,
327                                 -1, init->stream, 0, NULL);
328 
329     if (nxt_slow_path(ret != NXT_OK)) {
330         nxt_log(task, NXT_LOG_ERR, "failed to send READY message to main");
331 
332         goto fail;
333     }
334 
335     return;
336 
337 fail:
338 
339     exit(1);
340 }
341 
342 
343 #if (NXT_HAVE_POSIX_SPAWN)
344 
345 /*
346  * Linux glibc 2.2 posix_spawn() is implemented via fork()/execve().
347  * Linux glibc 2.4 posix_spawn() without file actions and spawn
348  * attributes uses vfork()/execve().
349  *
350  * On FreeBSD 8.0 posix_spawn() is implemented via vfork()/execve().
351  *
352  * Solaris 10:
353  *   In the Solaris 10 OS, posix_spawn() is currently implemented using
354  *   private-to-libc vfork(), execve(), and exit() functions.  They are
355  *   identical to regular vfork(), execve(), and exit() in functionality,
356  *   but they are not exported from libc and therefore don't cause the
357  *   deadlock-in-the-dynamic-linker problem that any multithreaded code
358  *   outside of libc that calls vfork() can cause.
359  *
360  * On MacOSX 10.5 (Leoprad) and NetBSD 6.0 posix_spawn() is implemented
361  * as syscall.
362  */
363 
364 nxt_pid_t
365 nxt_process_execute(nxt_task_t *task, char *name, char **argv, char **envp)
366 {
367     nxt_pid_t  pid;
368 
369     nxt_debug(task, "posix_spawn(\"%s\")", name);
370 
371     if (posix_spawn(&pid, name, NULL, NULL, argv, envp) != 0) {
372         nxt_alert(task, "posix_spawn(\"%s\") failed %E", name, nxt_errno);
373         return -1;
374     }
375 
376     return pid;
377 }
378 
379 #else
380 
381 nxt_pid_t
382 nxt_process_execute(nxt_task_t *task, char *name, char **argv, char **envp)
383 {
384     nxt_pid_t  pid;
385 
386     /*
387      * vfork() is better than fork() because:
388      *   it is faster several times;
389      *   its execution time does not depend on private memory mapping size;
390      *   it has lesser chances to fail due to the ENOMEM error.
391      */
392 
393     pid = vfork();
394 
395     switch (pid) {
396 
397     case -1:
398         nxt_alert(task, "vfork() failed while executing \"%s\" %E",
399                   name, nxt_errno);
400         break;
401 
402     case 0:
403         /* A child. */
404         nxt_debug(task, "execve(\"%s\")", name);
405 
406         (void) execve(name, argv, envp);
407 
408         nxt_alert(task, "execve(\"%s\") failed %E", name, nxt_errno);
409 
410         exit(1);
411         nxt_unreachable();
412         break;
413 
414     default:
415         /* A parent. */
416         nxt_debug(task, "vfork(): %PI", pid);
417         break;
418     }
419 
420     return pid;
421 }
422 
423 #endif
424 
425 
426 nxt_int_t
427 nxt_process_daemon(nxt_task_t *task)
428 {
429     nxt_fd_t      fd;
430     nxt_pid_t     pid;
431     const char    *msg;
432 
433     fd = -1;
434 
435     /*
436      * fork() followed by a parent process's exit() detaches a child process
437      * from an init script or terminal shell process which has started the
438      * parent process and allows the child process to run in background.
439      */
440 
441     pid = fork();
442 
443     switch (pid) {
444 
445     case -1:
446         msg = "fork() failed %E";
447         goto fail;
448 
449     case 0:
450         /* A child. */
451         break;
452 
453     default:
454         /* A parent. */
455         nxt_debug(task, "fork(): %PI", pid);
456         exit(0);
457         nxt_unreachable();
458     }
459 
460     nxt_pid = getpid();
461 
462     /* Clean inherited cached thread tid. */
463     task->thread->tid = 0;
464 
465     nxt_debug(task, "daemon");
466 
467     /* Detach from controlling terminal. */
468 
469     if (setsid() == -1) {
470         nxt_alert(task, "setsid() failed %E", nxt_errno);
471         return NXT_ERROR;
472     }
473 
474     /*
475      * Reset file mode creation mask: any access
476      * rights can be set on file creation.
477      */
478     umask(0);
479 
480     /* Redirect STDIN and STDOUT to the "/dev/null". */
481 
482     fd = open("/dev/null", O_RDWR);
483     if (fd == -1) {
484         msg = "open(\"/dev/null\") failed %E";
485         goto fail;
486     }
487 
488     if (dup2(fd, STDIN_FILENO) == -1) {
489         msg = "dup2(\"/dev/null\", STDIN) failed %E";
490         goto fail;
491     }
492 
493     if (dup2(fd, STDOUT_FILENO) == -1) {
494         msg = "dup2(\"/dev/null\", STDOUT) failed %E";
495         goto fail;
496     }
497 
498     if (fd > STDERR_FILENO) {
499         nxt_fd_close(fd);
500     }
501 
502     return NXT_OK;
503 
504 fail:
505 
506     nxt_alert(task, msg, nxt_errno);
507 
508     if (fd != -1) {
509         nxt_fd_close(fd);
510     }
511 
512     return NXT_ERROR;
513 }
514 
515 
516 void
517 nxt_nanosleep(nxt_nsec_t ns)
518 {
519     struct timespec  ts;
520 
521     ts.tv_sec = ns / 1000000000;
522     ts.tv_nsec = ns % 1000000000;
523 
524     (void) nanosleep(&ts, NULL);
525 }
526 
527 
528 nxt_int_t
529 nxt_user_cred_get(nxt_task_t *task, nxt_user_cred_t *uc, const char *group)
530 {
531     struct group   *grp;
532     struct passwd  *pwd;
533 
534     nxt_errno = 0;
535 
536     pwd = getpwnam(uc->user);
537 
538     if (nxt_slow_path(pwd == NULL)) {
539 
540         if (nxt_errno == 0) {
541             nxt_alert(task, "getpwnam(\"%s\") failed, user \"%s\" not found",
542                       uc->user, uc->user);
543         } else {
544             nxt_alert(task, "getpwnam(\"%s\") failed %E", uc->user, nxt_errno);
545         }
546 
547         return NXT_ERROR;
548     }
549 
550     uc->uid = pwd->pw_uid;
551     uc->base_gid = pwd->pw_gid;
552 
553     if (group != NULL && group[0] != '\0') {
554         nxt_errno = 0;
555 
556         grp = getgrnam(group);
557 
558         if (nxt_slow_path(grp == NULL)) {
559 
560             if (nxt_errno == 0) {
561                 nxt_alert(task,
562                           "getgrnam(\"%s\") failed, group \"%s\" not found",
563                           group, group);
564             } else {
565                 nxt_alert(task, "getgrnam(\"%s\") failed %E", group, nxt_errno);
566             }
567 
568             return NXT_ERROR;
569         }
570 
571         uc->base_gid = grp->gr_gid;
572     }
573 
574     return nxt_user_groups_get(task, uc);
575 }
576 
577 
578 /*
579  * nxt_user_groups_get() stores an array of groups IDs which should be
580  * set by the initgroups() function for a given user.  The initgroups()
581  * may block a just forked worker process for some time if LDAP or NDIS+
582  * is used, so nxt_user_groups_get() allows to get worker user groups in
583  * main process.  In a nutshell the initgroups() calls getgrouplist()
584  * followed by setgroups().  However Solaris lacks the getgrouplist().
585  * Besides getgrouplist() does not allow to query the exact number of
586  * groups while NGROUPS_MAX can be quite large (e.g. 65536 on Linux).
587  * So nxt_user_groups_get() emulates getgrouplist(): at first the function
588  * saves the super-user groups IDs, then calls initgroups() and saves the
589  * specified user groups IDs, and then restores the super-user groups IDs.
590  * This works at least on Linux, FreeBSD, and Solaris, but does not work
591  * on MacOSX, getgroups(2):
592  *
593  *   To provide compatibility with applications that use getgroups() in
594  *   environments where users may be in more than {NGROUPS_MAX} groups,
595  *   a variant of getgroups(), obtained when compiling with either the
596  *   macros _DARWIN_UNLIMITED_GETGROUPS or _DARWIN_C_SOURCE defined, can
597  *   be used that is not limited to {NGROUPS_MAX} groups.  However, this
598  *   variant only returns the user's default group access list and not
599  *   the group list modified by a call to setgroups(2).
600  *
601  * For such cases initgroups() is used in worker process as fallback.
602  */
603 
604 static nxt_int_t
605 nxt_user_groups_get(nxt_task_t *task, nxt_user_cred_t *uc)
606 {
607     int        nsaved, ngroups;
608     nxt_int_t  ret;
609     nxt_gid_t  *saved;
610 
611     nsaved = getgroups(0, NULL);
612 
613     if (nsaved == -1) {
614         nxt_alert(task, "getgroups(0, NULL) failed %E", nxt_errno);
615         return NXT_ERROR;
616     }
617 
618     nxt_debug(task, "getgroups(0, NULL): %d", nsaved);
619 
620     if (nsaved > NGROUPS_MAX) {
621         /* MacOSX case. */
622 
623         uc->gids = NULL;
624         uc->ngroups = 0;
625 
626         return NXT_OK;
627     }
628 
629     saved = nxt_malloc(nsaved * sizeof(nxt_gid_t));
630 
631     if (saved == NULL) {
632         return NXT_ERROR;
633     }
634 
635     ret = NXT_ERROR;
636 
637     nsaved = getgroups(nsaved, saved);
638 
639     if (nsaved == -1) {
640         nxt_alert(task, "getgroups(%d) failed %E", nsaved, nxt_errno);
641         goto free;
642     }
643 
644     nxt_debug(task, "getgroups(): %d", nsaved);
645 
646     if (initgroups(uc->user, uc->base_gid) != 0) {
647         if (nxt_errno == NXT_EPERM) {
648             nxt_log(task, NXT_LOG_NOTICE,
649                     "initgroups(%s, %d) failed %E, ignored",
650                     uc->user, uc->base_gid, nxt_errno);
651 
652             ret = NXT_OK;
653 
654             goto free;
655 
656         } else {
657             nxt_alert(task, "initgroups(%s, %d) failed %E",
658                       uc->user, uc->base_gid, nxt_errno);
659             goto restore;
660         }
661     }
662 
663     ngroups = getgroups(0, NULL);
664 
665     if (ngroups == -1) {
666         nxt_alert(task, "getgroups(0, NULL) failed %E", nxt_errno);
667         goto restore;
668     }
669 
670     nxt_debug(task, "getgroups(0, NULL): %d", ngroups);
671 
672     uc->gids = nxt_malloc(ngroups * sizeof(nxt_gid_t));
673 
674     if (uc->gids == NULL) {
675         goto restore;
676     }
677 
678     ngroups = getgroups(ngroups, uc->gids);
679 
680     if (ngroups == -1) {
681         nxt_alert(task, "getgroups(%d) failed %E", ngroups, nxt_errno);
682         goto restore;
683     }
684 
685     uc->ngroups = ngroups;
686 
687 #if (NXT_DEBUG)
688     {
689         u_char      *p, *end;
690         nxt_uint_t  i;
691         u_char      msg[NXT_MAX_ERROR_STR];
692 
693         p = msg;
694         end = msg + NXT_MAX_ERROR_STR;
695 
696         for (i = 0; i < uc->ngroups; i++) {
697             p = nxt_sprintf(p, end, "%uL:", (uint64_t) uc->gids[i]);
698         }
699 
700         nxt_debug(task, "user \"%s\" cred: uid:%uL base gid:%uL, gids:%*s",
701                   uc->user, (uint64_t) uc->uid, (uint64_t) uc->base_gid,
702                   p - msg, msg);
703     }
704 #endif
705 
706     ret = NXT_OK;
707 
708 restore:
709 
710     if (setgroups(nsaved, saved) != 0) {
711         nxt_alert(task, "setgroups(%d) failed %E", nsaved, nxt_errno);
712         ret = NXT_ERROR;
713     }
714 
715 free:
716 
717     nxt_free(saved);
718 
719     return ret;
720 }
721 
722 
723 nxt_int_t
724 nxt_user_cred_set(nxt_task_t *task, nxt_user_cred_t *uc)
725 {
726     nxt_debug(task, "user cred set: \"%s\" uid:%d base gid:%d",
727               uc->user, uc->uid, uc->base_gid);
728 
729     if (setgid(uc->base_gid) != 0) {
730 
731 #if (NXT_HAVE_CLONE)
732         if (nxt_errno == EINVAL) {
733             nxt_log(task, NXT_LOG_ERR, "The gid %d isn't valid in the "
734                     "application namespace.", uc->base_gid);
735             return NXT_ERROR;
736         }
737 #endif
738 
739         nxt_alert(task, "setgid(%d) failed %E", uc->base_gid, nxt_errno);
740         return NXT_ERROR;
741     }
742 
743     if (uc->gids != NULL) {
744         if (setgroups(uc->ngroups, uc->gids) != 0) {
745 
746 #if (NXT_HAVE_CLONE)
747             if (nxt_errno == EINVAL) {
748                 nxt_log(task, NXT_LOG_ERR, "The user \"%s\" (uid: %d) has "
749                         "supplementary group ids not valid in the application "
750                         "namespace.", uc->user, uc->uid);
751                 return NXT_ERROR;
752             }
753 #endif
754 
755             nxt_alert(task, "setgroups(%i) failed %E", uc->ngroups, nxt_errno);
756             return NXT_ERROR;
757         }
758 
759     } else {
760         /* MacOSX fallback. */
761         if (initgroups(uc->user, uc->base_gid) != 0) {
762             nxt_alert(task, "initgroups(%s, %d) failed %E",
763                       uc->user, uc->base_gid, nxt_errno);
764             return NXT_ERROR;
765         }
766     }
767 
768     if (setuid(uc->uid) != 0) {
769 
770 #if (NXT_HAVE_CLONE)
771         if (nxt_errno == EINVAL) {
772             nxt_log(task, NXT_LOG_ERR, "The uid %d (user \"%s\") isn't "
773                     "valid in the application namespace.", uc->uid, uc->user);
774             return NXT_ERROR;
775         }
776 #endif
777 
778         nxt_alert(task, "setuid(%d) failed %E", uc->uid, nxt_errno);
779         return NXT_ERROR;
780     }
781 
782     return NXT_OK;
783 }
784 
785 
786 void
787 nxt_process_port_add(nxt_task_t *task, nxt_process_t *process, nxt_port_t *port)
788 {
789     nxt_assert(port->process == NULL);
790 
791     port->process = process;
792     nxt_queue_insert_tail(&process->ports, &port->link);
793 
794     nxt_process_use(task, process, 1);
795 }
796 
797 
798 nxt_process_type_t
799 nxt_process_type(nxt_process_t *process)
800 {
801     return nxt_queue_is_empty(&process->ports) ? 0 :
802         (nxt_process_port_first(process))->type;
803 }
804 
805 
806 void
807 nxt_process_close_ports(nxt_task_t *task, nxt_process_t *process)
808 {
809     nxt_port_t  *port;
810 
811     nxt_process_port_each(process, port) {
812 
813         nxt_port_close(task, port);
814 
815         nxt_runtime_port_remove(task, port);
816 
817     } nxt_process_port_loop;
818 }
819 
820 
821 void
822 nxt_process_connected_port_add(nxt_process_t *process, nxt_port_t *port)
823 {
824     nxt_thread_mutex_lock(&process->cp_mutex);
825 
826     nxt_port_hash_add(&process->connected_ports, port);
827 
828     nxt_thread_mutex_unlock(&process->cp_mutex);
829 }
830 
831 
832 void
833 nxt_process_connected_port_remove(nxt_process_t *process, nxt_port_t *port)
834 {
835     nxt_thread_mutex_lock(&process->cp_mutex);
836 
837     nxt_port_hash_remove(&process->connected_ports, port);
838 
839     nxt_thread_mutex_unlock(&process->cp_mutex);
840 }
841 
842 
843 nxt_port_t *
844 nxt_process_connected_port_find(nxt_process_t *process, nxt_pid_t pid,
845     nxt_port_id_t port_id)
846 {
847     nxt_port_t  *res;
848 
849     nxt_thread_mutex_lock(&process->cp_mutex);
850 
851     res = nxt_port_hash_find(&process->connected_ports, pid, port_id);
852 
853     nxt_thread_mutex_unlock(&process->cp_mutex);
854 
855     return res;
856 }
857