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