Annotation of freem/src/transact.c, revision 1.6
1.1 snw 1: /*
1.6 ! snw 2: * $Id: transact.c,v 1.5 2025/03/24 02:54:47 snw Exp $
1.1 snw 3: * FreeM transaction processing support
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) 2020, 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: transact.c,v $
1.6 ! snw 27: * Revision 1.5 2025/03/24 02:54:47 snw
! 28: * Transaction compat fixes for OS/2
! 29: *
1.5 snw 30: * Revision 1.4 2025/03/09 19:50:47 snw
31: * Second phase of REUSE compliance and header reformat
32: *
1.4 snw 33: *
34: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
35: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 36: **/
37:
38: #include <string.h>
39: #include <stddef.h>
40: #include <stdio.h>
41: #include <stdlib.h>
42: #include <unistd.h>
43: #include <errno.h>
44:
45: #include "mpsdef.h"
46: #include "transact.h"
47: #include "iftab.h"
48: #include "journal.h"
49: #include "shmmgr.h"
50: #include "mref.h"
51: #include "tp_check.h"
52:
53: #define FALSE 0
54: #define TRUE 1
55:
1.5 snw 56: #if !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(__OS2__)
1.1 snw 57: union semun {
58: int val; /* Value for SETVAL */
59: struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
60: unsigned short *array; /* Array for GETALL, SETALL */
61: struct seminfo *__buf; /* Buffer for IPC_INFO
62: (Linux-specific) */
63: };
64: #endif
65:
66: void m_log (int, const char *);
67:
68: int semid_tp;
69: int tp_committing = FALSE;
70: int tp_level = 0;
71: tp_transaction transactions[TP_MAX_NEST];
72:
73:
74: void tp_init(void)
75: {
76: union semun arg;
77: char err[255];
78: key_t tp_sk;
79:
80: tp_sk = ftok (config_file, 4);
81:
82: if (first_process) {
83:
84: semid_tp = semget (tp_sk, 1, 0666 | IPC_CREAT);
85: if (semid_tp == -1) {
86: fprintf (stderr, "tp_init: failed to create transaction processing semaphore [errno %d]\r\n", errno);
87: exit (1);
88: }
89:
90: arg.val = 1;
91: if (semctl (semid_tp, 0, SETVAL, arg) == -1) {
92: fprintf (stderr, "tp_init: failed to initialize transaction processing semaphore\r\n");
93: exit (1);
94: }
95:
96: }
97: else {
98:
99: semid_tp = semget (tp_sk, 1, 0);
100: if (semid_tp == -1) {
101: fprintf (stderr, "tp_init: could not attach to transaction processing semaphore [errno %d]\r\n", errno);
102: exit (1);
103: }
104:
105: }
106:
107: return;
108:
109: }
110:
111: short tp_get_sem(void)
112: {
113: int tries;
114: struct sembuf s = {0, -1, 0};
115:
116: char msgbuf[100];
117:
118: snprintf (msgbuf, 99, "tp_get_sem: process %d attempting to acquire transaction processing semaphore", pid);
119: m_log (1, msgbuf);
120:
121:
122: /* our process already owns the semaphore */
123: if (shm_config->hdr->tp_owner == pid) {
124:
125: snprintf (msgbuf, 99, "tp_get_sem: process %d increments transaction processing semaphore counter", pid);
126: m_log (1, msgbuf);
127:
128:
129: if (first_process == TRUE) {
130: fprintf (stderr, "tp_get_sem: daemon process increments critical section counter\r\n");
131: }
132:
133:
134: shm_config->hdr->tp_semctr++;
135:
136: return TRUE;
137: }
138:
139: if (first_process == TRUE) {
140: fprintf (stderr, "tp_get_sem: daemon process enters critical section\r\n");
141: }
142:
143:
144: for (tries = 0; tries < 10; tries++) {
145:
146: if (semop (semid_tp, &s, 1) != -1) {
147: shm_config->hdr->tp_owner = pid;
148: shm_config->hdr->tp_semctr = 1;
149:
150: snprintf (msgbuf, 99, "tp_get_sem: process %d takes transaction processing semaphore", pid);
151: m_log (1, msgbuf);
152:
153:
154: if (first_process == TRUE) {
155: fprintf (stderr, "tp_get_sem: daemon process takes transaction processing semaphore\r\n");
156: }
157:
158: return TRUE;
159: }
160:
161: snprintf (msgbuf, 99, "tp_get_sem: process %d attempting to acquire transaction processing semaphore (tries = %d)", pid, tries);
162: m_log (1, msgbuf);
163:
164:
165: sleep (1);
166:
167: }
168:
169: return FALSE;
170:
171: }
172:
173: void tp_release_sem(void)
174: {
175:
176: char msgbuf[100];
177:
178: if (shm_config->hdr->tp_semctr == 1) {
179:
180: struct sembuf s = {0, 1, 0};
181:
182: if (first_process == TRUE) {
183: fprintf (stderr, "tp_release_sem: daemon process leaves critical section\r\n");
184: }
185:
186:
187: shm_config->hdr->tp_semctr = 0;
188: shm_config->hdr->tp_owner = 0;
189:
190: if (first_process == TRUE) {
191: fprintf (stderr, "tp_release_sem: daemon process relinquishes transaction processing semaphore\r\n");
192: }
193:
194:
195: snprintf (msgbuf, 99, "tp_get_sem: process %d releases transaction processing semaphore", pid);
196: m_log (1, msgbuf);
197:
198:
199: semop (semid_tp, &s, 1);
200:
201: }
202: else {
203:
204: if (first_process == TRUE) {
205: fprintf (stderr, "tp_release_sem: daemon process decrements critical section counter\r\n");
206: }
207:
208: snprintf (msgbuf, 99, "tp_get_sem: process %d decrements transaction processing semaphore counter", pid);
209: m_log (1, msgbuf);
210:
211: shm_config->hdr->tp_semctr--;
212: }
213:
214:
215: }
216:
217: int tp_tstart(char *tp_id, short serial, short restartable, char **sym_save)
218: {
219: if (tp_level == TP_MAX_NEST) {
220: char m[256];
221:
222: snprintf (m, 256, "Attempt to exceed TP_MAX_NEST. Transaction aborted.\r\n\201");
223: write_m (m);
224:
225: return FALSE;
226: }
227:
228: if (((serial == TRUE) && (tp_get_sem () == TRUE)) ||
229: (serial == FALSE)) {
230:
231: tp_level++;
232:
233: jnl_ent_write (JNLA_TSTART, "", "");
234:
235: strcpy (transactions[tp_level].tp_id, tp_id);
236:
237: transactions[tp_level].serial = serial;
238: transactions[tp_level].restartable = restartable;
239:
240: transactions[tp_level].opcount = 0;
241:
242: return TRUE;
243:
244: }
245: else {
246: fprintf (stderr, "tp_tstart: could not get transaction processing semaphore\r\n");
247: exit (1);
248: }
249:
250:
251: }
252:
253: int tp_add_op(short islock, short action, char *key, char *data)
254: {
255: int oc;
256: freem_ref_t *gr;
257:
258: gr = (freem_ref_t *) malloc (sizeof (freem_ref_t));
259: NULLPTRCHK(gr,"tp_add_op");
260:
261: mref_init (gr, MREF_RT_GLOBAL, "");
262: internal_to_mref (gr, key);
263:
264: if (transactions[tp_level].opcount == TP_MAX_OPS) {
265: char m[256];
266:
267: snprintf (m, 256, "Attempt to exceed TP_MAX_OPS at transaction level %d. Rolling back.\r\n\201", tp_level);
268: write_m (m);
269:
270: free (gr);
271:
272: tp_trollback (1);
273: tp_cleanup (1);
274:
275: if (transactions[tp_level].serial == TRUE) {
276: tp_release_sem();
277: }
278:
279: return FALSE;
280: }
281:
282: /* update transaction-in-flight symbol table */
283: switch (action) {
284:
285: case lock_inc:
286: case lock_dec:
287: case lock_old:
288: case set_sym:
289: iftab_insert (action, key, data, tp_level);
290: break;
291:
292: case kill_sym:
293: iftab_kill (key);
294: break;
295:
296: }
297:
298: if (transactions[tp_level].serial == TRUE) {
299: /* mark the global for checkpointing */
300: cptab_insert (tp_level, gr->name);
301: }
302:
303: free (gr);
304:
305: transactions[tp_level].opcount = transactions[tp_level].opcount + 1;
306:
307: oc = transactions[tp_level].opcount;
308:
309: transactions[tp_level].ops[oc].is_lock = islock;
310: transactions[tp_level].ops[oc].action = action;
311:
1.2 snw 312: stcpy ((char *) &transactions[tp_level].ops[oc].key, key);
313: stcpy ((char *) &transactions[tp_level].ops[oc].data, data);
1.1 snw 314:
315:
316: return TRUE;
317: }
318:
319: int tp_tcommit(void)
320: {
321: register int i;
322: short is_serial = transactions[tp_level].serial;
323:
324: tp_committing = TRUE;
325:
326: if (is_serial) {
327: /* checkpoint all globals involved in transaction */
328: cptab_precommit (tp_level);
329: }
330:
331: for(i = 1; i <= transactions[tp_level].opcount; i++) {
332:
333: if (transactions[tp_level].ops[i].is_lock == FALSE) {
334: global (transactions[tp_level].ops[i].action, transactions[tp_level].ops[i].key, transactions[tp_level].ops[i].data);
335:
336: if (merr () > OK) goto commit_error;
337:
338: }
339:
340: }
341:
342: jnl_ent_write (JNLA_TCOMMIT, "\201", "\201");
343:
344: if (is_serial) {
345: cptab_postcommit (tp_level);
346: }
347:
348: goto commit_done;
349:
350: commit_error:
351:
352: tp_trollback (1);
353:
354: commit_done:
355:
356: tp_cleanup (1);
357:
358: tp_committing = FALSE;
359:
360: if (is_serial) {
361: tp_release_sem ();
362: }
363:
364: return TRUE;
365: }
366:
367: int tp_cleanup(int levels)
368: {
369: register int i;
370:
371: for (i = tp_level; i >= (((tp_level - levels) >= 0) ? tp_level - levels : 0); i--) {
372: iftab_pop_tlevel (i);
373: }
374:
375: tp_level = ((tp_level - levels) >= 0) ? tp_level - levels : 0;
376:
377: return TRUE;
378: }
379:
380: int tp_trollback(int levels)
381: {
382: register int i;
383: register int j;
384:
385: // for (i = 0; i < levels; i++) {
386: for (i = tp_level; i >= (((tp_level - levels) >= 0) ? tp_level - levels : 0); i--) {
387:
388: for (j = 1; j <= transactions[i].opcount; j++) {
389:
390: if (transactions[i].ops[j].is_lock == TRUE) {
391: locktab_decrement (transactions[i].ops[j].key, -1);
392: }
393:
394: }
395:
396: if (transactions[i].serial == TRUE) {
397: cptab_rollback (i);
398: }
399:
400: }
401:
402:
403: return TRUE;
404: }
405:
406: int tp_trestart(void)
407: {
408: return 0;
409: }
410:
411: void tp_tdump(void)
412: {
413:
414: int i, j;
415:
416: char tkey[256];
417: char tdata[256];
418: char tact[256];
419:
420: set_io (UNIX);
421:
422: if (tp_level == 0) {
423: printf("No transaction is active.\n");
424:
425: return;
426: }
427:
428: for(i = 1; i <= tp_level; i++) {
429:
430: if(i == tp_level) {
431: printf(" $TLEVEL %d*\n", i);
432: }
433: else {
434: printf(" $TLEVEL %d\n", i);
435: }
436:
437: printf(" Operations for Transaction ID: %s [%s%s]\n",
438: transactions[i].tp_id,
439: ((transactions[i].restartable == TRUE) ? "RESTARTABLE" : "NON-RESTARTABLE"),
440: ((transactions[i].serial == TRUE) ? " SERIAL" : " BATCH"));
441:
442: printf ("\n %-10s%-15s%-15s\n", "OP. NO.", "ACTION", "KEY/DATA");
443: printf (" %-10s%-15s%-15s\n", "-------", "------", "--------");
444:
445:
446: for(j = 1; j <= transactions[i].opcount; j++) {
447: stcpy (tkey, transactions[i].ops[j].key);
448: stcnv_m2c (tkey);
449: stcpy (tdata, transactions[i].ops[j].data);
450: stcnv_m2c (tdata);
451:
452: tp_get_op_name (tact, transactions[i].ops[j].action);
453:
454: if (transactions[i].ops[j].action == set_sym) {
455: printf (" %-10d%-15s%s=%s\n", j, tact, tkey, tdata);
456: }
457: else {
458: printf (" %-10d%-15s%s\n", j, tact, tkey);
459: }
460:
461: }
462:
463: cptab_dump (i);
464:
465: }
466:
467:
468: set_io (MUMPS);
469: }
470:
471: void tp_get_op_name(char *buf, const short action)
472: {
473: switch (action) {
474:
475: case set_sym:
476: strcpy (buf, "SET");
477: break;
478:
479: case killone:
480: case kill_sym:
481: case kill_all:
482: case killexcl:
483: strcpy (buf, "KILL");
484: break;
485:
486: case new_sym:
487: case new_all:
488: case newexcl:
489: strcpy (buf, "NEW");
490: break;
491:
492: case get_sym:
493: strcpy (buf, "GET");
494: break;
495:
1.6 ! snw 496: case fra_dat:
1.1 snw 497: strcpy (buf, "$DATA");
498: break;
499:
500: case fra_order:
501: strcpy (buf, "$ORDER");
502: break;
503:
504: case fra_query:
505: case bigquery:
506: strcpy (buf, "$QUERY");
507: break;
508:
509: case getinc:
510: strcpy (buf, "$INCREMENT");
511: break;
512:
513: case getnext:
514: strcpy (buf, "$NEXT");
515: break;
516:
517: case lock_inc:
518: strcpy (buf, "LOCK (INCR)");
519: break;
520:
521: case lock_old:
522: strcpy (buf, "LOCK (TRAD)");
523: break;
524:
525: }
526:
527: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to transact.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src