Annotation of freem/src/journal.c, revision 1.5
1.1 snw 1: /*
1.5 ! snw 2: * $Id: journal.c,v 1.4 2025/03/09 19:14:25 snw Exp $
1.1 snw 3: * Implementation of FreeM journaling
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: journal.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 <string.h>
37: #include <stdlib.h>
38:
39: #include <sys/types.h>
40: #include <sys/stat.h>
41: #include <fcntl.h>
42: #include <time.h>
43:
44: #include <unistd.h>
45: #include <errno.h>
46:
47: #include "mpsdef.h"
48: #include "journal.h"
49: #include "transact.h"
50: #include "iniconf.h"
51: #include "shmmgr.h"
52:
53: unsigned long jnl_tran_id; /* transaction id for journaling */
54: unsigned long jnl_cut_threshold; /* byte limit of journal file before cutting new */
55: char jnl_file_path[PATH_MAX]; /* path to journal file */
56: char jnl_host_id[256]; /* host ID (configured at install time) */
57: short jnl_locked = FALSE; /* is the journal locked? */
58: int jnl_desc = 0; /* journal file descriptor */
59:
60: short jnl_enabled = FALSE;
61:
62: void jnl_cut(void);
63: void jnl_panic(char *msg);
64: void jnl_update_tid(void);
65: void jnl_lock(void);
66: void jnl_unlock(void);
67:
68: short jnl_init(char *jnlfile, char *hostid, unsigned long cut_threshold, unsigned long tran_id)
69: {
70:
71: jnl_hdr_t hdr;
72: char tmsg[256];
73:
74: char m[5] = "FRMJL";
75:
76: strncpy (jnl_host_id, hostid, 255);
77: jnl_cut_threshold = cut_threshold;
78:
79: /* cannot re-init in a running process */
80: if ((jnl_desc) && (tran_id == 0)) return FALSE;
81:
82: strncpy (jnl_file_path, jnlfile, PATH_MAX - 1);
83:
84: if (!file_exists (jnl_file_path)) {
85:
86: /* this is a new journal file */
87: jnl_tran_id = tran_id;
88:
89: jnl_desc = open (jnl_file_path, O_CREAT | O_APPEND | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);
90:
1.5 ! snw 91: snprintf (tmsg, 255, "error creating new journal file '%s' [errno %d: '%s']", jnl_file_path, errno, strerror (errno));
! 92: if (jnl_desc == -1) jnl_panic (tmsg);
1.1 snw 93:
94: jnl_lock ();
95:
96: memcpy (hdr.magic, m, 5);
97: hdr.fmt_version = FRM_JNL_VERSION;
98: snprintf (hdr.host_triplet, 40, "%s", HOST);
99:
100: if (write (jnl_desc, &hdr, sizeof (jnl_hdr_t)) == -1) {
101: snprintf (tmsg, 255, "error %d writing to journal file", errno);
102: jnl_panic (tmsg);
103: }
104:
105: jnl_unlock ();
106:
107: close (jnl_desc);
108:
109: }
110: else {
111:
112: /* this journal file already exists */
113:
114: jnl_desc = open (jnl_file_path, O_APPEND | O_RDWR);
115:
116: lseek (jnl_desc, 0L, SEEK_SET);
117:
118: jnl_lock ();
119:
120: read (jnl_desc, &hdr, sizeof (jnl_hdr_t));
121:
122: if (strncmp (hdr.magic, m, 5) != 0) {
123:
124: set_io (UNIX);
125: fprintf (stderr, "%s is not a valid FreeM journal file.\n", jnl_file_path);
126: set_io (MUMPS);
127:
128: return FALSE;
129:
130: }
131:
132: if (hdr.fmt_version != FRM_JNL_VERSION) {
133:
134: set_io (UNIX);
135: fprintf (stderr, "Journal file version mismatch.\n");
136: set_io (MUMPS);
137:
138: return FALSE;
139:
140: }
141:
142: //strncpy (jnl_host_id, hdr.)
143:
144: jnl_unlock ();
145:
146: close (jnl_desc);
147:
148: }
149:
150: jnl_desc = open (jnl_file_path, O_APPEND | O_RDWR);
151:
152: lseek (jnl_desc, 0L, SEEK_END);
153:
154: jnl_lock ();
155: jnl_update_tid ();
156: jnl_unlock ();
157:
158: jnl_enabled = TRUE;
159:
160: return TRUE;
161:
162: }
163:
164: void jnl_cleanup(void)
165: {
166:
167: if (jnl_desc) {
168: jnl_unlock ();
169: close (jnl_desc);
170: }
171:
172: return;
173:
174: }
175:
176: short jnl_ent_write(short action, char *key, char *data)
177: {
178:
179: jnl_ent_t ent;
180: size_t siz;
181: char msg[256];
182:
183: jnl_lock ();
184:
185: if ((tp_level == 0) && (action != JNLA_TSTART)) {
186: /* make sure we have the latest transaction ID */
187: jnl_update_tid ();
188: }
189:
190: siz = lseek (jnl_desc, 0L, SEEK_END);
191:
192: if ((siz + sizeof (jnl_ent_t)) >= jnl_cut_threshold) jnl_cut ();
193:
194: /* only increment the transaction ID if we're NOT in a transaction
195: or this action begins one. */
196: if ((tp_level == 0) || action == JNLA_TSTART) {
197: if (tp_get_sem () == FALSE) {
198: jnl_panic ("could not get transaction processing semaphore");
199: }
200: else {
201: jnl_tran_id++;
202: shm_config->hdr->tp_serial_number = jnl_tran_id;
203:
204: tp_release_sem ();
205: }
206: }
207:
208: ent.tran_id = jnl_tran_id;
209: ent.ts = time (NULL);
210: ent.pid = (pid_t) pid;
211: ent.action = action;
212:
213: strncpy (ent.host_id, jnl_host_id, 255);
214: strncpy (ent.key, key, 1023);
215: strncpy (ent.data, data, 1023);
216:
217: lseek (jnl_desc, 0L, SEEK_END);
218:
219: errno = 0;
220: if ((siz = write (jnl_desc, &ent, sizeof (jnl_ent_t))) < sizeof (jnl_ent_t)) {
221:
222: switch (errno) {
223:
224: case ENOSPC:
225: snprintf (msg, 255, "ran out of disk space while attempting journal write");
226: break;
227:
228: default:
1.2 snw 229: snprintf (msg, 255, "%s", strerror (errno));
1.1 snw 230: break;
231:
232: }
233:
234: jnl_panic (msg);
235:
236: }
237:
238: jnl_unlock ();
239:
240: return 1;
241:
242: }
243:
244: void jnl_update_tid(void)
245: {
246: jnl_ent_t ent;
247:
248: if (tp_get_sem () == TRUE) {
249:
250: if (first_process == TRUE) {
251:
252: if (!jnl_desc) return;
253:
254: lseek (jnl_desc, 0L, SEEK_END);
255: lseek (jnl_desc, -sizeof (jnl_ent_t), SEEK_CUR);
256:
257: read (jnl_desc, &ent, sizeof (jnl_ent_t));
258:
259: jnl_tran_id = ent.tran_id;
260:
261: shm_config->hdr->tp_serial_number = ent.tran_id;
262:
263: }
264: else {
265: jnl_tran_id = shm_config->hdr->tp_serial_number;
266: }
267:
268: tp_release_sem ();
269:
270: }
271: else {
272: jnl_panic ("jnl_update_tid: could not acquire transaction processing sempahore");
273: }
274:
275: }
276:
277: inline void jnl_lock(void)
278: {
279: struct flock lock;
280:
281: lock.l_type = F_WRLCK;
282: lock.l_whence = SEEK_SET;
283: lock.l_start = 0;
284: lock.l_len = 0;
285:
286: fcntl (jnl_desc, F_SETLK, &lock);
287:
288: jnl_locked = TRUE;
289:
290: return;
291: }
292:
293: inline void jnl_unlock(void)
294: {
295: struct flock lock;
296:
297: lock.l_type = F_UNLCK;
298: lock.l_whence = SEEK_SET;
299: lock.l_start = 0;
300: lock.l_len = 0;
301:
302: fcntl (jnl_desc, F_SETLK, &lock);
303:
304: jnl_locked = FALSE;
305:
306: return;
307: }
308:
309: void jnl_cut(void)
310: {
311: char cutname[PATH_MAX];
312:
313:
314: if (jnl_desc) {
315:
316: jnl_lock ();
317:
318: jnl_update_tid ();
319:
320: snprintf (cutname, PATH_MAX - 1, "%s.%ld", jnl_file_path, jnl_tran_id);
321: close (jnl_desc);
322:
323: rename (jnl_file_path, cutname);
324:
325: if(tp_level == 0) {
326: jnl_init (jnl_file_path, jnl_host_id, jnl_cut_threshold, ++jnl_tran_id);
327: }
328: else {
329: jnl_init (jnl_file_path, jnl_host_id, jnl_cut_threshold, jnl_tran_id);
330: }
331:
332: jnl_unlock();
333:
334: }
335:
336: return;
337:
338: }
339:
340: void jnl_panic(char *msg)
341: {
342: set_io (UNIX);
343:
344: if (tp_level > 0) {
345: fprintf (stderr, "journal error: [%s] (rolling back all transactions)\n", msg);
346: tp_trollback (tp_level);
347: }
348: else {
349: fprintf (stderr, "journal error: [%s]\n", msg);
350: }
351:
352: jnl_cleanup ();
353:
354: exit (1);
355: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to journal.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src