Annotation of freem/src/jobtab.c, revision 1.4
1.1 snw 1: /*
1.4 ! snw 2: * $Id$
1.1 snw 3: * job table implementation
4: *
5: *
1.3 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.4 ! snw 8: * Copyright (C) 2021, 2023, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.4 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31: #include <stdlib.h>
32: #include <string.h>
33: #include <time.h>
34: #include <unistd.h>
35:
36: #include "mpsdef.h"
37: #include "shmmgr.h"
38: #include "jobtab.h"
39:
40: #if !defined(__OpenBSD__) && !defined(__APPLE__)
41: union semun {
42: int val; /* Value for SETVAL */
43: struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
44: unsigned short *array; /* Array for GETALL, SETALL */
45: struct seminfo *__buf; /* Buffer for IPC_INFO
46: (Linux-specific) */
47: };
48: #endif
49:
50: int semid_jobtab;
51: short have_jobtab_sem = FALSE;
52:
53: void jobtab_init(void)
54: {
55: union semun arg;
56: key_t jt_sk;
57:
58: jt_sk = ftok (config_file, 2);
59: if (first_process) {
60:
61: semid_jobtab = semget (jt_sk, 1, 0666 | IPC_CREAT);
62: if (semid_jobtab == -1) {
63: fprintf (stderr, "jobtab_init: failed to create job table semaphore\r\n");
64: exit (1);
65: }
66: else {
67: fprintf (stderr, "jobtab_init: job table semaphore created with semid %d\r\n", semid_jobtab);
68: }
69:
70: arg.val = 1;
71: if (semctl (semid_jobtab, 0, SETVAL, arg) == -1) {
72: fprintf (stderr, "jobtab_init: failed to initialize job table semaphore\r\n");
73: exit (1);
74: }
75: else {
76: fprintf (stderr, "jobtab_init: job table semaphore initialized\r\n");
77: }
78:
79: }
80: else {
81:
82: semid_jobtab = semget (jt_sk, 1, 0);
83: if (semid_jobtab == -1) {
84: fprintf (stderr, "jobtab_init: could not attach to job table semaphore\r\n");
85: exit (1);
86: }
87:
88: }
89:
90: return;
91: }
92:
93: short jobtab_get_sem(void)
94: {
95: int tries;
96: struct sembuf s = {0, -1, IPC_NOWAIT};
97:
98: if (have_jobtab_sem) {
99: // fprintf (stderr, "jobtab_get_sem: this process already owns the job table semaphore\r\n");
100: return TRUE;
101: }
102:
103: for (tries = 0; tries < 5; tries++) {
104:
105: if (semop (semid_jobtab, &s, 1) != -1) {
106: have_jobtab_sem = TRUE;
107: return TRUE;
108: }
109:
110: /* fprintf (stderr, "jobtab_get_sem: sleeping for retry [tries = %d]\r\n", tries); */
111:
112: sleep (1);
113:
114: }
115: fprintf (stderr, "jobtab_get_sem: fail\r\n");
116:
117: have_jobtab_sem = FALSE;
118: return FALSE;
119: }
120:
121: void jobtab_release_sem(void)
122: {
123: struct sembuf s = {0, 1, 0};
124:
125: semop (semid_jobtab, &s, 1);
126:
127: have_jobtab_sem = FALSE;
128: }
129:
130:
131: job_slot_t *job_init(short is_fmadm)
132: {
133:
134: job_slot_t *s;
135:
136: if (jobtab_get_sem () == FALSE) {
137: fprintf (stderr, "job_init: failed to get job table semaphore\r\n");
138: exit (1);
139: }
140:
141: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
142:
143: if (((s->flags & JFLG_DEFUNCT) == JFLG_DEFUNCT) || (s->pid == pid)) {
144: goto skip_alloc;
145: }
146:
147: }
148:
149: s = (job_slot_t *) shm_alloc (sizeof (job_slot_t));
150: NULLPTRCHK(s,"job_init");
151:
152:
153: skip_alloc:
154:
155: s->pid = pid;
156: s->ipc_head = (ipc_slot_t *) NULL;
157: s->status = JSTAT_IDLE;
158: s->start_time = time (NULL);
159: s->stop_requested = 0;
160:
161: if (first_process) {
162: s->flags = JFLG_DAEMON | JFLG_NEW;
163: }
164: else {
165: if (is_fmadm == TRUE) {
166: s->flags = JFLG_NEW | JFLG_FMADM;
167: }
168: else {
169: s->flags = JFLG_NEW;
170: }
171: }
172:
173: s->next = shm_config->hdr->jobtab_head;
174: shm_config->hdr->jobtab_head = s;
175:
176: jobtab_release_sem ();
177:
178: return s;
179:
180: }
181:
182: void job_remove(const pid_t pid)
183: {
184:
185: job_slot_t *t = shm_config->hdr->jobtab_head;
186: job_slot_t *p = NULL;
187:
188: if (jobtab_get_sem() == FALSE) {
189: fprintf (stderr, "job_remove: failed to get job table semaphore\r\n");
190: exit (1);
191: }
192:
193: if ((t != (job_slot_t *) NULL) && (t->pid == pid)) {
194:
195: shm_config->hdr->jobtab_head = t->next;
196: shm_free (t);
197:
198: jobtab_release_sem ();
199:
200: return;
201:
202: }
203:
204: while ((t != NULL) && (t->pid != pid)) {
205: p = t;
206: t = t->next;
207: }
208:
209: if (t == NULL) {
210: jobtab_release_sem ();
211: return;
212: }
213:
214: p->next = t->next;
215: shm_free (t);
216:
217: jobtab_release_sem ();
218:
219: }
220:
221: void job_request_stop(const pid_t target_pid)
222: {
223:
224: job_slot_t *s;
225:
226: if (jobtab_get_sem() == FALSE) {
227: fprintf (stderr, "job_request_stop: failed to get job table semaphore\r\n");
228: exit (1);
229: }
230:
231: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
232:
233: if (s->pid == target_pid) {
234: s->stop_requested = pid;
235:
236: jobtab_release_sem ();
237: job_set_status (target_pid, JSTAT_SHUTDOWN);
238:
239: return;
240: }
241:
242: }
243:
244: jobtab_release_sem ();
245:
246: }
247:
248: void job_set_ecode(const pid_t target_pid, const char *ecode)
249: {
250:
251: job_slot_t *s;
252:
253: if (jobtab_get_sem() == FALSE) {
254: fprintf (stderr, "job_set_ecode: failed to get job table semaphore\r\n");
255: exit (1);
256: }
257:
258: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
259:
260: if (s->pid == target_pid) {
261: strncpy (s->last_ecode, ecode, 20);
262: jobtab_release_sem ();
263: return;
264: }
265:
266: }
267:
268: jobtab_release_sem ();
269:
270: }
271:
272: pid_t job_stop_requested (const pid_t target_pid)
273: {
274:
275: job_slot_t *s;
276:
277:
278: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
279: if (s->pid == target_pid) {
280: return s->stop_requested;
281: }
282: }
283:
284: return (pid_t) 0;
285:
286: }
287:
288: void job_request_all_stop(void)
289: {
290:
291: job_slot_t *s;
292:
293:
294: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
295:
296: if ((s->flags & JFLG_DAEMON) != JFLG_DAEMON) {
297: job_request_stop (s->pid);
298: }
299:
300: }
301:
302:
303: }
304:
305: void job_signal_all(const int sig)
306: {
307:
308: job_slot_t *s;
309:
310: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
311:
312: if ((s->flags & JFLG_DAEMON) != JFLG_DAEMON) {
313: kill (s->pid, sig);
314: }
315:
316: }
317:
318: }
319:
320:
321: int job_count(void)
322: {
323:
324: job_slot_t *s;
325: int ct = 0;
326:
327: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
328:
329: if ((s->flags & JFLG_DEFUNCT) != JFLG_DEFUNCT) {
330: ct++;
331: }
332:
333: }
334:
335: return ct;
336:
337: }
338:
339: job_slot_t *job_set_status(const pid_t target_pid, const unsigned short status)
340: {
341:
342: job_slot_t *s;
343:
344: if (jobtab_get_sem() == FALSE) {
345: fprintf (stderr, "job_set_status: failed to get job table semaphore\r\n");
346: exit (1);
347: }
348:
349: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
350:
351: if (s->pid == target_pid) {
352: s->status = status;
353: jobtab_release_sem ();
354: return s;
355: }
356:
357: }
358:
359: jobtab_release_sem ();
360:
361: return (job_slot_t *) NULL;
362:
363: }
364:
365: void job_gc_mark(void)
366: {
367:
368: job_slot_t *s;
369:
370: if (jobtab_get_sem () == FALSE) {
371: fprintf (stderr, "job_gc_mark: failed to get job table semaphore\r\n");
372: exit (1);
373: }
374:
375: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
376:
377: if (kill (s->pid, 0) != 0) {
1.2 snw 378: fprintf (stderr, "job_gc_mark: marking pid %ld DEFUNCT\r\n", (long) s->pid);
1.1 snw 379: s->flags = JFLG_DEFUNCT;
380: }
381:
382: if ((s->flags & JFLG_NEW) == JFLG_NEW) {
383: if ((s->flags & JFLG_DAEMON) == JFLG_DAEMON) {
1.2 snw 384: fprintf (stderr, "job_gc_mark: registering new daemon %ld\r\n", (long) s->pid);
1.1 snw 385: s->flags = JFLG_ALIVE | JFLG_DAEMON;
386: }
387: else {
388: if ((s->flags & JFLG_FMADM) == JFLG_FMADM) {
1.2 snw 389: fprintf (stderr, "job_gc_mark: registering new fmadm process %ld\r\n", (long) s->pid);
1.1 snw 390: s->flags = JFLG_ALIVE | JFLG_FMADM;
391: }
392: else {
1.2 snw 393: fprintf (stderr, "job_gc_mark: registering new interpreter process %ld\r\n", (long) s->pid);
1.1 snw 394: s->flags = JFLG_ALIVE;
395: }
396: }
397: }
398:
399: }
400:
401: jobtab_release_sem ();
402:
403: }
404:
405: void job_gc_sweep(void)
406: {
407:
408: job_slot_t *s;
409: char *k_buf = (char *) malloc (STRLEN * sizeof (char));
410: NULLPTRCHK(k_buf,"job_gc_sweep");
411:
412: if (jobtab_get_sem () == FALSE) {
413: fprintf (stderr, "job_gc_sweep: failed to get job table semaphore\r\n");
414: exit (1);
415: }
416:
417:
418: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
419:
420: if ((s->flags & JFLG_DEFUNCT) == JFLG_DEFUNCT) {
421:
1.2 snw 422: fprintf (stderr, "job_gc_sweep: sweeping DEFUNCT pid %ld\r\n", (long) s->pid);
1.1 snw 423:
424: snprintf (k_buf, STRLEN - 1, "^$JOB\202%d\201", s->pid);
425:
426: symtab_shm (kill_sym, k_buf, " \201");
427: merr_clear ();
428:
429: job_remove (s->pid);
430:
431: free (k_buf);
432:
433: jobtab_release_sem ();
434: return;
435:
436: }
437:
438: }
439:
440: free (k_buf);
441:
442: jobtab_release_sem ();
443:
444: }
445:
446: ipc_slot_t *job_send_ipc(const pid_t receiver_pid, const void *object)
447: {
448:
449: job_slot_t *j;
450: ipc_slot_t *s = (ipc_slot_t *) shm_alloc (sizeof (ipc_slot_t));
451: NULLPTRCHK(s,"job_send_ipc");
452:
453: if (jobtab_get_sem() == FALSE) {
454: fprintf (stderr, "job_send_ipc: failed to get job table semaphore\r\n");
455: exit (1);
456: }
457:
458:
459: for (j = shm_config->hdr->jobtab_head; j != NULL; j = j->next) {
460:
461: if (j->pid == receiver_pid) {
462:
463: s->flags = JIPCFLG_PENDING;
464: s->sender_pid = pid;
465: s->object = (void *) object;
466:
467: s->next = j->ipc_head;
468: j->ipc_head = s;
469:
470: jobtab_release_sem ();
471:
472: return s;
473:
474: }
475:
476: }
477:
478: shm_free (s);
479:
480: jobtab_release_sem ();
481:
482: return (ipc_slot_t *) NULL;
483:
484: }
485:
486: job_slot_t *job_get(const pid_t target_pid)
487: {
488:
489: job_slot_t *s;
490:
491: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
492: if (s->pid == target_pid) return s;
493: }
494:
495: return (job_slot_t *) NULL;
496:
497: }
498:
499: void job_dump(void)
500: {
501: char time_buf[20];
502: char *flag_s = (char *) malloc (256 * sizeof (char));
503: char *stat_s = (char *) malloc (256 * sizeof (char));
504:
505: job_slot_t *s;
506:
507: flag_s[0] = '\0';
508: stat_s[0] = '\0';
509:
510: printf ("%-10s%-15s%-20s%-22s%s\r\n", "PID", "STATUS", "LAST ECODE", "STARTED", "FLAGS");
511: printf ("%-10s%-15s%-20s%-22s%s\r\n", "---", "------", "----------", "-------", "-----");
512:
513: for (s = shm_config->hdr->jobtab_head; s != NULL; s = s->next) {
514:
515: strftime (time_buf, 20, "%Y-%m-%d %H:%M:%S", localtime (&(s->start_time)));
516:
517: flag_s[0] = '\0';
518: stat_s[0] = '\0';
519:
520: if ((s->flags & JFLG_ALIVE) == JFLG_ALIVE) strcat (flag_s, "ALIVE ");
521: if ((s->flags & JFLG_DEFUNCT) == JFLG_DEFUNCT) strcat (flag_s, "DEFUNCT ");
522: if ((s->flags & JFLG_REPLSENDER) == JFLG_REPLSENDER) strcat (flag_s, "REPLSENDER ");
523: if ((s->flags & JFLG_REPLRECEIVER) == JFLG_REPLRECEIVER) strcat (flag_s, "REPLRECEIVER ");
524: if ((s->flags & JFLG_FMADM) == JFLG_FMADM) strcat (flag_s, "FMADM ");
525: if ((s->flags & JFLG_NEW) == JFLG_NEW) strcat (flag_s, "NEW ");
526: if ((s->flags & JFLG_DAEMON) == JFLG_DAEMON) strcat (flag_s, "DAEMON ");
527:
528: if (s->status == JSTAT_IDLE) strcat (stat_s, "IDLE");
529: if (s->status == JSTAT_INTERPRETER) strcat (stat_s, "INTERPRETER");
530: if (s->status == JSTAT_HOUSEKEEPING) strcat (stat_s, "HOUSEKEEPING");
531: if (s->status == JSTAT_DIRECTMODE) strcat (stat_s, "DIRECTMODE");
532: if (s->status == JSTAT_ERROR) strcat (stat_s, "ERROR");
533: if (s->status == JSTAT_SHUTDOWN) strcat (stat_s, "SHUTDOWN");
534:
535: printf ("%-10d%-15s%-20s%-22s%s\r\n", s->pid, stat_s, s->last_ecode, time_buf, flag_s);
536:
537:
538: }
539:
540: free (stat_s);
541: free (flag_s);
542:
543: }
544:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jobtab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src