1: /*
2: * *
3: * * *
4: * * *
5: * ***************
6: * * * * *
7: * * MUMPS *
8: * * * * *
9: * ***************
10: * * *
11: * * *
12: * *
13: *
14: * events.c
15: * event framework
16: *
17: *
18: * Author: Serena Willis <jpw@coherent-logic.com>
19: * Copyright (C) 1998 MUG Deutschland
20: * Copyright (C) 2020 Coherent Logic Development LLC
21: *
22: *
23: * This file is part of FreeM.
24: *
25: * FreeM is free software: you can redistribute it and/or modify
26: * it under the terms of the GNU Affero Public License as published by
27: * the Free Software Foundation, either version 3 of the License, or
28: * (at your option) any later version.
29: *
30: * FreeM is distributed in the hope that it will be useful,
31: * but WITHOUT ANY WARRANTY; without even the implied warranty of
32: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33: * GNU Affero Public License for more details.
34: *
35: * You should have received a copy of the GNU Affero Public License
36: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
37: *
38: **/
39:
40: #include <stdlib.h>
41: #include <string.h>
42:
43: #include "mpsdef.h"
44: #include "events.h"
45: #include "freem.h"
46: #include "mref.h"
47:
48:
49: short evt_async_enabled = FALSE;
50: short evt_async_restore = FALSE;
51: short evt_async_initial = FALSE;
52:
53: short evt_queue_rear = -1;
54: short evt_queue_front = -1;
55:
56: evt_entry *evt_queue[EVT_QLENGTH];
57: short evt_status[EVT_MAX];
58: int evt_blocks[EVT_MAX];
59: int evt_depth;
60:
61: void evt_init (void)
62: {
63: register int i;
64:
65: for(i = 0; i < EVT_MAX; i++) {
66: evt_status[i] = EVT_S_DISABLED;
67: evt_blocks[i] = 0;
68: }
69:
70: evt_async_enabled = FALSE;
71: evt_depth = 0;
72: }
73:
74: int evt_ablock (short evt_class)
75: {
76: register int i;
77: int unblocked_evt_count = 0;
78:
79: evt_blocks[evt_class]++;
80:
81: for (i = 0; i < EVT_MAX; i++) {
82: if (evt_blocks[i] == 0) unblocked_evt_count++;
83: }
84:
85: if (unblocked_evt_count == 0) evt_async_enabled = FALSE;
86:
87: return evt_blocks[evt_class];
88: }
89:
90: int evt_aunblock (short evt_class)
91: {
92: register int i;
93: int unblocked_evt_count = 0;
94:
95: if (evt_blocks[evt_class]) evt_blocks[evt_class]--;
96:
97: for (i = 0; i < EVT_MAX; i++) {
98: if (evt_blocks[i] == 0) unblocked_evt_count++;
99: }
100:
101: if (unblocked_evt_count) evt_async_enabled = TRUE;
102:
103: return evt_blocks[i - 1];
104: }
105:
106: int evt_enqueue (char *event_id, short evt_class, short interrupt)
107: {
108: evt_entry *e = malloc (sizeof (evt_entry));
109: NULLPTRCHK(e,"evt_enqueue");
110:
111: if (!evt_registered (event_id, evt_class)) {
112: free (e);
113: return -1;
114: }
115:
116: strncpy (e->event_id, event_id, 256);
117: e->evt_class = evt_class;
118:
119: if (evt_queue_rear == EVT_QLENGTH - 1) {
120: /* queue overflow */
121: free (e);
122: return -1;
123: }
124:
125: if (evt_queue_front == -1) evt_queue_front = 0;
126:
127: evt_queue[++evt_queue_rear] = e;
128:
129: if (interrupt && (evt_blocks[evt_class] == 0)) {
130: merr_raise (ASYNC);
131: }
132:
133: return evt_queue_rear;
134: }
135:
136: evt_entry *evt_dequeue (void)
137: {
138: evt_entry *e;
139:
140: if (evt_queue_front == -1 || evt_queue_front > evt_queue_rear) {
141: /* queue underflow */
142: return NULL;
143: }
144:
145: e = evt_queue[evt_queue_front++];
146:
147: return e;
148: }
149:
150:
151: char *evt_class_name (evt_entry *e) {
152:
153: char *evt_name = malloc (15 * sizeof (char));
154: NULLPTRCHK(evt_name,"evt_class_name");
155:
156: switch (e->evt_class) {
157:
158: case EVT_CLS_COMM:
159: strcpy (evt_name, "COMM");
160: break;
161:
162: case EVT_CLS_HALT:
163: strcpy (evt_name, "HALT");
164: break;
165:
166: case EVT_CLS_IPC:
167: strcpy (evt_name, "IPC");
168: break;
169:
170: case EVT_CLS_INTERRUPT:
171: strcpy (evt_name, "INTERRUPT");
172: break;
173:
174: case EVT_CLS_POWER:
175: strcpy (evt_name, "POWER");
176: break;
177:
178: case EVT_CLS_TIMER:
179: strcpy (evt_name, "TIMER");
180: break;
181:
182: case EVT_CLS_USER:
183: strcpy (evt_name, "USER");
184: break;
185:
186: case EVT_CLS_WAPI:
187: strcpy (evt_name, "WAPI");
188: break;
189:
190: case EVT_CLS_TRIGGER:
191: strcpy (evt_name, "TRIGGER");
192: break;
193:
194: }
195:
196: return evt_name;
197:
198: }
199:
200: char *evt_class_name_c (int c) {
201:
202: char *evt_name = malloc (15 * sizeof (char));
203: NULLPTRCHK(evt_name,"evt_class_name_c");
204:
205: switch (c) {
206:
207: case EVT_CLS_COMM:
208: strcpy (evt_name, "COMM");
209: break;
210:
211: case EVT_CLS_HALT:
212: strcpy (evt_name, "HALT");
213: break;
214:
215: case EVT_CLS_IPC:
216: strcpy (evt_name, "IPC");
217: break;
218:
219: case EVT_CLS_INTERRUPT:
220: strcpy (evt_name, "INTERRUPT");
221: break;
222:
223: case EVT_CLS_POWER:
224: strcpy (evt_name, "POWER");
225: break;
226:
227: case EVT_CLS_TIMER:
228: strcpy (evt_name, "TIMER");
229: break;
230:
231: case EVT_CLS_USER:
232: strcpy (evt_name, "USER");
233: break;
234:
235: case EVT_CLS_WAPI:
236: strcpy (evt_name, "WAPI");
237: break;
238:
239: case EVT_CLS_TRIGGER:
240: strcpy (evt_name, "TRIGGER");
241: break;
242:
243: }
244:
245: return evt_name;
246:
247: }
248:
249: int evt_get_handlers (char *buf) {
250:
251: char *t_key;
252: char *class_name;
253: char *t_buf;
254: freem_ref_t *r;
255: freem_ref_t *rs;
256: char pid_s[10];
257: int ct;
258: evt_entry *e;
259:
260: class_name = malloc (256 * sizeof (char));
261: NULLPTRCHK(class_name,"evt_get_handlers");
262:
263: t_buf = malloc (STRLEN * sizeof (char));
264: NULLPTRCHK(t_buf,"evt_get_handlers");
265:
266: r = malloc (sizeof (freem_ref_t));
267: NULLPTRCHK(r,"evt_get_handlers");
268:
269: rs = malloc (sizeof (freem_ref_t));
270: NULLPTRCHK(rs,"evt_get_handlers");
271:
272: ct = 0;
273: t_buf[0] = '\201';
274:
275: mref_init (r, MREF_RT_SSVN, "^$JOB");
276: mref_init (rs, MREF_RT_SSVN, "^$SYSTEM");
277:
278: snprintf (pid_s, 9, "%d", pid);
279:
280:
281: while ((e = evt_dequeue ()) != NULL) {
282:
283: if (evt_status[e->evt_class] > EVT_S_DISABLED) {
284: class_name = evt_class_name (e);
285:
286: mref_set_subscript (r, 0, pid_s);
287: mref_set_subscript (r, 1, "EVENT");
288: mref_set_subscript (r, 2, class_name);
289: mref_set_subscript (r, 3, e->event_id);
290:
291: t_key = mref_to_internal (r);
292: ssvn (get_sym, t_key, t_buf);
293: free (t_key);
294: stcnv_m2c (t_buf);
295:
296: if (strlen (t_buf) > 0) {
297:
298: ct++;
299:
300: strcat (buf, t_buf);
301: strcat (buf, ",");
302: }
303:
304: mref_set_subscript (rs, 0, "EVENT");
305: mref_set_subscript (rs, 1, class_name);
306: mref_set_subscript (rs, 2, e->event_id);
307:
308: t_key = mref_to_internal (rs);
309: ssvn (get_sym, t_key, t_buf);
310: free (t_key);
311: stcnv_m2c (t_buf);
312:
313: if (strlen (t_buf) > 0) {
314:
315: ct++;
316:
317: strcat (buf, t_buf);
318: strcat (buf, ",");
319: }
320:
321: }
322:
323: free (e);
324:
325: }
326:
327: if (ct) {
328: buf[strlen (buf) - 1] = NUL;
329: }
330: else {
331: buf[0] = NUL;
332: }
333:
334: free (r);
335: free (rs);
336: free (class_name);
337: free (t_buf);
338:
339: return ct;
340: }
341:
342: short evt_registered (char *event_id, short evt_class)
343: {
344: char *t_key;
345: char *class_name;
346: char *t_buf;
347: freem_ref_t *r;
348: freem_ref_t *rs;
349: char pid_s[10];
350: int ct;
351:
352: t_key = malloc (256 * sizeof (char));
353: NULLPTRCHK(t_key,"evt_registered");
354:
355: class_name = malloc (256 * sizeof (char));
356: NULLPTRCHK(class_name,"evt_registered");
357:
358: t_buf = malloc (STRLEN * sizeof (char));
359: NULLPTRCHK(t_buf,"evt_registered");
360:
361:
362: r = malloc (sizeof (freem_ref_t));
363: NULLPTRCHK(r,"evt_registered");
364:
365: rs = malloc (sizeof (freem_ref_t));
366: NULLPTRCHK(rs,"evt_registered");
367:
368: ct = 0;
369: t_buf[0] = '\201';
370:
371: mref_init (r, MREF_RT_SSVN, "^$JOB");
372:
373: snprintf (pid_s, 9, "%d", pid);
374:
375: class_name = evt_class_name_c (evt_class);
376:
377: mref_set_subscript (r, 0, pid_s);
378: mref_set_subscript (r, 1, "EVENT");
379: mref_set_subscript (r, 2, class_name);
380: mref_set_subscript (r, 3, event_id);
381:
382: t_key = mref_to_internal (r);
383:
384: ssvn (get_sym, t_key, t_buf);
385: stcnv_m2c (t_buf);
386:
387: if (strlen (t_buf) > 0) ct++;
388:
389: mref_init (rs, MREF_RT_SSVN, "^$SYSTEM");
390:
391: mref_set_subscript (rs, 0, "EVENT");
392: mref_set_subscript (rs, 1, class_name);
393: mref_set_subscript (rs, 2, event_id);
394:
395: t_key = mref_to_internal (rs);
396:
397: ssvn (get_sym, t_key, t_buf);
398: stcnv_m2c (t_buf);
399:
400: if (strlen (t_buf) > 0) ct++;
401:
402: free (r);
403: free (rs);
404: free (t_key);
405: free (class_name);
406: free (t_buf);
407:
408: return (ct > 0) ? TRUE : FALSE;
409: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to events.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src