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