Annotation of freem/src/locktab.c, revision 1.5
1.1 snw 1: /*
1.5 ! snw 2: * $Id: locktab.c,v 1.4 2025/03/09 19:14:25 snw Exp $
1.1 snw 3: * lock 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, 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.5 ! snw 26: * $Log: locktab.c,v $
! 27: * Revision 1.4 2025/03/09 19:14:25 snw
! 28: * First phase of REUSE compliance and header reformat
! 29: *
1.4 snw 30: *
31: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
32: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 33: **/
34:
35: #include <stdio.h>
36: #include <stdlib.h>
37: #include <unistd.h>
38: #include <time.h>
39: #include <string.h>
40:
41: #include "mpsdef.h"
42: #include "locktab.h"
43: #include "shmmgr.h"
44: #include "mref.h"
45: #include "transact.h"
46:
1.5 ! snw 47: #if !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(__OS2__)
1.1 snw 48: union semun {
49: int val; /* Value for SETVAL */
50: struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
51: unsigned short *array; /* Array for GETALL, SETALL */
52: struct seminfo *__buf; /* Buffer for IPC_INFO
53: (Linux-specific) */
54: };
55: #endif
56:
57: int semid_locktab;
58:
59: int locktab_list_count(char *key);
60:
61: void locktab_init(void)
62: {
63: union semun arg;
64: key_t lt_sk;
65:
66: lt_sk = ftok (config_file, 3);
67:
68: if (first_process) {
69:
70: semid_locktab = semget (lt_sk, 1, 0666 | IPC_CREAT);
71: if (semid_locktab == -1) {
72: fprintf (stderr, "locktab_init: failed to create lock table semaphore\r\n");
73: exit (1);
74: }
75:
76: arg.val = 1;
77: if (semctl (semid_locktab, 0, SETVAL, arg) == -1) {
78: fprintf (stderr, "locktab_init: failed to initialize lock table semaphore\r\n");
79: exit (1);
80: }
81:
82: }
83: else {
84:
85: semid_locktab = semget (lt_sk, 1, 0);
86: if (semid_locktab == -1) {
87: fprintf (stderr, "locktab_init: could not attach to lock table semaphore\r\n");
88: exit (1);
89: }
90:
91: }
92:
93: return;
94:
95: }
96:
97: short locktab_get_sem(void)
98: {
99: int tries;
100: struct sembuf s = {0, -1, 0};
101:
102: for (tries = 0; tries < 5; tries++) {
103:
104: if (semop (semid_locktab, &s, 1) != -1) {
105: return TRUE;
106: }
107:
108: sleep (1);
109:
110: }
111:
112: return FALSE;
113: }
114:
115: void locktab_release_sem(void)
116: {
117: struct sembuf s = {0, 1, 0};
118:
119: semop (semid_locktab, &s, 1);
120:
121: }
122:
123: void lock(char *lockarg, long time_out, char type)
124: {
125: char *key = &(lockarg[1]);
126: char a = lockarg[0];
127:
128: if (shm_config == NULL) {
129: fprintf (stderr, "lock: global LOCK operation attemped before shared memory available.\r\n");
130: return;
131: }
132:
133: switch (a) {
134:
135: case '+':
136: locktab_increment (key, time_out, FALSE);
137: break;
138:
139: case '-':
140: locktab_decrement (key, time_out);
141: break;
142:
143: case SP:
144: locktab_unlock_all ();
145: locktab_increment (key, time_out, TRUE);
146: break;
147:
148: default:
149: break;
150:
151: }
152:
153: return;
154:
155: }
156:
157: void locktab_increment(char *key, long lck_timeout, short old_lock)
158: {
159: short lck_action;
160: char chk_ns[256];
161: int nref_ct = locktab_list_count (key);
162:
163: if (old_lock) {
164: lck_action = lock_old;
165: }
166: else {
167: lck_action = lock_inc;
168: }
169:
170: strncpy (chk_ns, nsname, 256);
171:
172: switch (lck_timeout) {
173:
174: case -1: /* blocking lock (no timeout) */
175:
176: if (nref_ct > 1) {
177: /* this is a lock list */
178: char *nref;
179: char tmps[255];
180:
181: int i;
182: int successes = 0;
183: int attempts = 0;
184: int list_pos = 0;
185:
186: char *attempt_status = (char *) malloc (nref_ct * sizeof (char));
187: NULLPTRCHK(attempt_status,"locktab_increment");
188:
189: for (i = 0; i < nref_ct; i++) attempt_status[i] = (char) FALSE;
190:
191: stcpy (tmps, key);
192: stcnv_m2c (tmps);
193:
194: nref = strtok (tmps, "\001\201");
195:
196: do {
197:
198: list_pos = 0;
199: attempts = 0;
200: successes = 0;
201:
202: for (;;) {
203:
204: attempts++;
205:
206: if (attempt_status[list_pos] == FALSE) {
207:
208: if (locktab_insert (nref) != NULL) {
209: successes++;
210: attempt_status[list_pos] = TRUE;
211: }
212: else {
213: locktab_decrement (nref, -1L);
214: attempt_status[list_pos] = FALSE;
215: }
216:
217: }
218:
219: nref = strtok (NULL, "\001\201");
220: if (nref == NULL) break;
221:
222: list_pos++;
223:
224: }
225:
226: } while (successes < nref_ct);
227:
228: free (attempt_status);
229: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
230: return;
231:
232: }
233: else {
234: for (;;) {
235:
236: if (locktab_insert (key) != NULL) {
237: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
238: return;
239: }
240: else {
241: sleep (1);
242: }
243:
244: }
245: }
246:
247:
248: case 0: /* lock that returns immediately */
249:
250: if (nref_ct > 1) {
251: /* this is a lock list */
252: char *nref;
253: char tmps[255];
254:
255: int successes = 0;
256: int attempts = 0;
257:
258: stcpy (tmps, key);
259: stcnv_m2c (tmps);
260:
261: nref = strtok (tmps, "\001\201");
262:
263: for (;;) {
264: attempts++;
265:
266: if (locktab_insert (nref) != NULL) {
267: successes++;
268: }
269: else {
270: locktab_decrement (nref, 0L);
271: test = 0;
272: return;
273: }
274:
275: nref = strtok (NULL, "\001\201");
276: if (nref == NULL) break;
277: }
278:
279: test = 1;
280: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
281: return;
282:
283: }
284: else {
285:
286: if (locktab_insert (key) != NULL) {
287: test = 1;
288: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
289: }
290: else {
291: test = 0;
292: }
293:
294: }
295:
296: break;
297:
298: case 1: /* special case: lock with 1-second timeout */
299:
300: if (locktab_insert (key) != NULL) {
301: test = 1;
302: }
303: else {
304: sleep (1);
305:
306: if (locktab_insert (key) != NULL) {
307: test = 1;
308: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
309: }
310: else {
311: test = 0;
312: }
313: }
314:
315: return;
316:
317: default: /* lock with timeout */
318: {
319: time_t start_secs;
320: time_t end_secs;
321: time_t elapsed;
322: locktab_ent_t *lck = NULL;
323:
324: start_secs = time (NULL);
325:
326: if (nref_ct > 1) {
327: /* this is a lock-list */
328: printf ("lock-list with timeout\r\n");
329: }
330: else {
331:
332:
333: for (;;) {
334:
335:
336: lck = locktab_insert (key);
337:
338: end_secs = time (NULL);
339: elapsed = end_secs - start_secs;
340:
341: if (lck != NULL) {
342: test = 1;
343: return;
344: }
345:
346: if (elapsed >= lck_timeout) {
347:
348: if (lck == NULL) {
349: test = 0;
350: }
351: else {
352: if (tp_level > 0) tp_add_op (TRUE, lck_action, key, chk_ns);
353: test = 1;
354: }
355:
356: return;
357:
358: }
359:
360: sleep (1); /* prevent CPU pegging */
361:
362: } /* timeout loop */
363:
364: return;
365: }
366:
367: } /* lock with timeout */
368: } /* switch (timeout) */
369:
370:
371: }
372:
373: void locktab_decrement(char *key, long lck_timeout)
374: {
375:
376: locktab_ent_t *lck = locktab_find (key);
377:
378: if (lck != NULL) {
379:
380: if (tp_level > lck->tp_level) {
381: merr_raise (M41);
382: return;
383: }
384:
385: if (lck->ct > 0) lck->ct--;
386:
387: if (lck->ct == 0) {
388: lck->owner_job = 0;
389: strcpy (lck->namespace, "<REUSABLE>");
390:
391: ssvn_lock_remove (lck->nref);
392: }
393:
394: if (lck->owner_job != 0) {
395: ssvn_lock_add (lck->nref, lck->owner_job, lck->ct);
396: }
397:
398: }
399:
400: if (lck_timeout > -1) test = 1;
401:
402: }
403:
404: void locktab_unlock_all(void)
405: {
406: locktab_ent_t *lck;
407:
408: for (lck = shm_config->hdr->locktab_head; lck != NULL; lck = lck->next) {
409:
410: if (lck->owner_job == pid) {
411:
412: if (tp_level > lck->tp_level) {
413: merr_raise (M41);
414: return;
415: }
416:
417: lck->ct = 0;
418: lck->owner_job = 0;
419: strcpy (lck->namespace, "<REUSABLE>");
420:
421: ssvn_lock_remove (lck->nref);
422:
423: }
424:
425: }
426:
427: }
428:
429: locktab_ent_t *locktab_find(char *key)
430: {
431:
432: locktab_ent_t *lck;
433: char chk_ns[255];
434:
435: if (key[1] == '%') {
436: snprintf (chk_ns, 255, "SYSTEM");
437: }
438: else {
1.2 snw 439: snprintf (chk_ns, 255, "%s", nsname);
1.1 snw 440: }
441:
442: for (lck = shm_config->hdr->locktab_head; lck != NULL; lck = lck->next) {
443:
444: if ((stcmp (lck->nref, key) == 0) && (strcmp (lck->namespace, chk_ns) == 0)) {
445:
446: if (lck->owner_job != pid) {
447: return (locktab_ent_t *) NULL;
448: }
449: else {
450: return lck;
451: }
452:
453: }
454:
455: }
456:
457: return (locktab_ent_t *) NULL;
458:
459: }
460:
461: locktab_ent_t *locktab_insert(char *key)
462: {
463: locktab_ent_t *l;
464: char chk_ns[255];
465:
466: freem_ref_t *ik;
467: freem_ref_t *ok;
468:
469: ik = malloc (sizeof (freem_ref_t));
470: NULLPTRCHK(ik,"locktab_insert");
471:
472: ik = mref_init (ik, MREF_RT_GLOBAL, "");
473:
474: ok = malloc (sizeof (freem_ref_t));
475: NULLPTRCHK(ok,"locktab_insert");
476:
477: ik = internal_to_mref (ik, key);
478:
479: if (key[1] == '%') {
480: snprintf (chk_ns, 255, "SYSTEM");
481: }
482: else {
483: snprintf (chk_ns, 255, "%s", nsname);
484: }
485:
486: for (l = shm_config->hdr->locktab_head; l != NULL; l = l->next) {
487: ok = mref_init (ok, MREF_RT_GLOBAL, "");
488: ok = internal_to_mref (ok, l->nref);
489:
490: if (((stcmp (l->nref, key) == 0) || (mref_is_descendant (ok, ik) == TRUE)) && (strcmp (l->namespace, chk_ns) == 0)) {
491:
492: /* nref already owned by another job */
493: if ((l->owner_job != pid) && (l->ct > 0)) {
494: free (ik);
495: free (ok);
496: return NULL;
497: }
498: else {
499: if ((mref_is_descendant (ok, ik)) && (pid == l->owner_job)) {
500: if (locktab_find (key) == NULL) goto new_insert;
501: }
502:
503: /* increment the lock and return */
504: l->ct++;
505:
506: /* if this was a lock with a counter of zero belonging to another pid,
507: * re-use it and take ownership of it.
508: */
509: if (l->owner_job != pid) l->owner_job = pid;
510:
511: l->tp_level = tp_level;
512:
513: ssvn_lock_add (l->nref, l->owner_job, l->ct);
514:
515: free (ik);
516: free (ok);
517:
518: return l;
519: }
520:
521: }
522:
523: }
524:
525: new_insert:
526: /* no lock exists for key: this is a new insert */
527: l = (locktab_ent_t *) shm_alloc (sizeof (locktab_ent_t));
528: if (l == (locktab_ent_t *) NULL) {
529: free (ik);
530: free (ok);
531: return (locktab_ent_t *) NULL;
532: }
533:
534: stcpy (l->nref, key);
535: snprintf (l->namespace, 255, "%s", chk_ns);
536:
537: l->owner_job = pid;
538: l->ct = 1;
539:
540: l->next = shm_config->hdr->locktab_head;
541: shm_config->hdr->locktab_head = l;
542:
543: ssvn_lock_add (l->nref, l->owner_job, l->ct);
544:
545: free (ik);
546: free (ok);
547:
548: return l;
549: }
550:
551:
552: int locktab_count(char *key)
553: {
554: locktab_ent_t *l;
555: int ct = 0;
556:
557: for (l = shm_config->hdr->locktab_head; l != NULL; l = l->next) {
558: if (stcmp (l->nref, key) == 0) ct++;
559: }
560:
561: return ct;
562: }
563:
564: int locktab_list_count(char *key)
565: {
566: int i;
567: int lct = 0;
568:
569: for (i = 0; i < stlen (key); i++) {
570: if (key[i] == '\001') lct++;
571: }
572:
573: return lct;
574: }
575:
576: unsigned long locktab_pages(void)
577: {
578:
579: locktab_ent_t *l;
580: unsigned long bytes = 0;
581: unsigned long pages = 0;
582: float extra;
583:
584: for (l = shm_config->hdr->locktab_head; l != NULL; l = l->next) {
585: bytes += sizeof (locktab_ent_t);
586: }
587:
588: pages = bytes / PG_SIZE;
589: extra = bytes % PG_SIZE;
590:
591: if (extra > 0) {
592: pages++;
593: }
594:
595: return pages;
596:
597: }
598:
599: unsigned long locktab_bytes(void)
600: {
601:
602: locktab_ent_t *l;
603: unsigned int ct = 0;
604: unsigned long bytes = 0;
605:
606: for (l = shm_config->hdr->locktab_head; l != NULL; l = l->next) {
607: ct++;
608: bytes += sizeof (locktab_ent_t);
609: }
610:
611: return bytes;
612:
613: }
614:
615: void locktab_dump(void)
616: {
617:
618: locktab_ent_t *l;
619: unsigned long ct = 0;
620: unsigned long tot = 0;
621: freem_ref_t *r;
622: char *ref_ext;
623:
624: r = (freem_ref_t *) malloc (sizeof (freem_ref_t));
625: NULLPTRCHK(r,"locktab_dump");
626:
627: ref_ext = (char *) malloc (STRLEN * sizeof (char));
628: NULLPTRCHK(ref_ext,"locktab_dump");
629:
630: printf ("%-20s%-20s%-20s%s\r\n", "NAMESPACE", "PID", "COUNT", "KEY");
631: printf ("%-20s%-20s%-20s%s\r\n", "---------", "---", "-----", "---");
632:
633: if (shm_config->hdr->locktab_head == NULL) {
634: printf ("\r\n*** lock table empty ***\r\n");
635: free (r);
636: return;
637: }
638:
639:
640: for (l = shm_config->hdr->locktab_head; l != NULL; l = l->next) {
641:
642: mref_init (r, MREF_RT_GLOBAL, "");
643: internal_to_mref (r, l->nref);
644: mref_to_external (r, ref_ext);
645:
646: if (l->owner_job) {
647: printf ("%-20s%-20d%-20d%s\r\n", l->namespace, l->owner_job, l->ct, ref_ext);
648: ct++;
649: }
650:
651: tot++;
652:
653: }
654:
655: printf ("\r\n\tActive LOCK table entries: %ld\r\n", ct);
656: printf ( "\tReusable LOCK table entries: %ld\r\n", tot - ct);
657: printf ( "\tShared memory pages: %ld\r\n", locktab_pages ());
658: printf ( "\tShared memory bytes: %ld\r\n", locktab_bytes ());
659:
660: free (r);
661: free (ref_ext);
662:
663: return;
664:
665: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to locktab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src