Annotation of freem/src/shmmgr.c, revision 1.5
1.1 snw 1: /*
1.5 ! snw 2: * $Id: shmmgr.c,v 1.4 2025/03/09 19:50:47 snw Exp $
1.1 snw 3: * shared memory manager
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: shmmgr.c,v $
! 27: * Revision 1.4 2025/03/09 19:50:47 snw
! 28: * Second 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 <stdlib.h>
36: #include <stdio.h>
37: #include <assert.h>
38: #include <string.h>
39: #include <unistd.h>
40: #include <errno.h>
41: #include <signal.h>
42:
43: #include "shmmgr.h"
44: #include "mpsdef.h"
45: #include "locktab.h"
46:
47: #include <sys/types.h>
48: #include <sys/ipc.h>
49: #include <sys/sem.h>
50:
1.5 ! snw 51: #if !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(__OS2__)
1.1 snw 52: union semun {
53: int val; /* Value for SETVAL */
54: struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
55: unsigned short *array; /* Array for GETALL, SETALL */
56: struct seminfo *__buf; /* Buffer for IPC_INFO
57: (Linux-specific) */
58: };
59: #endif
60:
61: int semid_shm;
62: extern int semid_locktab;
63: extern int semid_jobtab;
64: extern int semid_tp;
65: extern int semid_symtab;
66:
67: void shm_daemon_init(void);
68:
69: shm_config_t *shm_config = (shm_config_t *) NULL;
70:
71: short shm_init(const size_t seg_size)
72: {
73: union semun arg;
74: size_t alloc_map_size;
75: long pg_size;
76: register int i;
77: key_t shm_sk;
78:
79: shm_sk = ftok (config_file, 5);
80: pg_size = sysconf (_SC_PAGESIZE);
81:
82: shm_config = (shm_config_t *) malloc (sizeof (shm_config_t));
83: NULLPTRCHK(shm_config,"shm_init");
84:
85: /* figure out how many pages we can fit in the segment, accounting for header size */
86: shm_config->pgct = (seg_size / pg_size) - sizeof (shm_hdr_t);
87:
88: /* how big will the alloc map be? */
89: alloc_map_size = shm_config->pgct * sizeof (shm_page_t);
90:
91: shm_config->segsiz = seg_size + alloc_map_size + pg_size;
92: shm_config->key = ftok (config_file, 1);
93: shm_config->pgsiz = pg_size;
94:
95: shm_config->seg_id = shmget (shm_config->key, shm_config->segsiz, 0660 | IPC_CREAT);
96: if (shm_config->seg_id == -1) {
97: if (errno == 22) {
1.2 snw 98: fprintf (stderr, "shm_init: cannot get shared memory segment of %ld bytes\r\n\r\n", (unsigned long) shm_config->segsiz);
1.1 snw 99: fprintf (stderr, "You may need to tune your kernel parameters, or manually set a smaller shared memory segment size in both the FreeM daemon and each interpreter process by using the `-S` command-line flag.\r\n\r\nPlease refer to the FreeM Platform Notes for your operating system for details.\r\n\r\n");
100: }
101: return SHMS_GET_ERR;
102: }
103:
104: #if !defined(__arm__)
105: shm_config->dta = shmat (shm_config->seg_id, NULL, 0);
106: #else
107: shm_config->dta = shmat (shm_config->seg_id, (void *) 0x1000000, 0);
108: #endif
109:
110: if (shm_config->dta == (void *) -1) {
111: return SHMS_ATTACH_ERR;
112: }
113: /* view the first sizeof (shm_hdr_t) bytes of the data area as an shm_hdr_t */
114: shm_config->hdr = (shm_hdr_t *) shm_config->dta;
115:
116: if (shm_config->hdr->magic != shm_config->key) {
117:
118: /* the shm segment is brand new */
119: first_process = TRUE;
120:
121: shm_daemon_init ();
122:
123: }
124: else {
125:
126: /* this shared mem segment was initialized before */
127: int daemon_chk;
128:
129: /* check if the daemon recorded in the header is actually running */
130: daemon_chk = kill (shm_config->hdr->first_process, 0);
131:
132: if (daemon_chk == -1 && errno == ESRCH) {
133:
134: fprintf (stderr, "shm_init: recovering from crashed daemon pid %d\r\n", shm_config->hdr->first_process);
135:
136: first_process = TRUE;
137:
138: shm_daemon_init ();
139:
140: }
141: else {
142:
143:
144: first_process = FALSE;
145:
146: semid_shm = semget (shm_sk, 1, 0);
147: if (semid_shm == -1) {
148: fprintf (stderr, "shm_init: could not attach to shared memory semaphore\r\n");
149: exit (1);
150: }
151:
152: /* we are NOT the initial process. if addresses don't match, re-attach! */
153: /* (again, borrowed from RSM) */
154: if (shm_config->hdr->shmad != shm_config->dta) {
155:
156: /* grab the pointers we need */
157: void *old_addr = shm_config->dta;
158: void *new_addr = shm_config->hdr->shmad;
159:
160: /* detach and reattach */
161: if (shmdt (old_addr) == -1) {
162: fprintf (stderr, "shm_init: detach failed during detach/reattach [shmdt error %s]\r\n", strerror (errno));
163: exit (1);
164: }
165:
166: shm_config->dta = shmat (shm_config->seg_id, new_addr, 0);
167:
168: if (shm_config->dta == (void *) -1) {
169: fprintf (stderr, "shm_init: fatal error attaching shared memory segment [shmat error '%s']\r\n", strerror (errno));
170: exit (1);
171: }
172:
173: shm_config->hdr = (shm_hdr_t *) shm_config->dta;
174:
175: /* allocator buffer at the next page-aligned address after the header and allocation map */
176: shm_config->buf = SHMALIGN(shm_config->dta + (sizeof (shm_hdr_t) * shm_config->pgct));
177: }
178: else {
179: shm_config->buf = SHMALIGN(shm_config->dta + (sizeof (shm_hdr_t) * shm_config->pgct));
180: }
181:
182: }
183:
184: }
185:
186: locktab_init ();
187:
188: assert(shm_address_to_page_num(shm_page_num_to_address(20)) == 20);
189:
190:
191: return TRUE;
192: }
193:
194: void shm_daemon_init(void)
195: {
196: union semun arg;
197: size_t alloc_map_size;
198: key_t shm_sk;
199: register int i;
200:
201: shm_sk = ftok (config_file, 5);
202:
203: semid_shm = semget (shm_sk, 1, 0660 | IPC_CREAT);
204: if (semid_shm == -1) {
205: fprintf (stderr, "shm_init: failed to create shared memory semaphore\r\n");
206: exit (1);
207: }
208:
209: arg.val = 1;
210: if (semctl (semid_shm, 0, SETVAL, arg) == -1) {
211: fprintf (stderr, "shm_init: failed to initialize shared memory semaphore\r\n");
212: exit (1);
213: }
214:
215: /* zero out the segment */
216: memset (shm_config->dta, 0, shm_config->segsiz);
217:
218: /* we are the process that created the segment: initialize everything */
219: shm_config->hdr->magic = shm_config->key;
220: shm_config->hdr->first_process = pid;
221:
222: /* store the address we got into the shm_hdr (borrowed from RSM) */
223: shm_config->hdr->shmad = shm_config->dta;
224: shm_config->hdr->maintenance_mode = 0;
225:
226: /* alloc_map comes after the header */
227: /*
228: shm_config->alloc_map = (shm_page_t *) (shm_config->dta + sizeof (shm_hdr_t));
229: */
230: shm_config->buf = SHMALIGN(shm_config->dta + (sizeof (shm_hdr_t) * shm_config->pgct));
231: printf ("shm_daemon_init: allocator buffer aligned at %p (system page size %ld)\r\n", shm_config->buf, sysconf (_SC_PAGESIZE));
232:
233: for (i = 0; i < shm_config->pgct; i++) {
234: shm_config->hdr->alloc_map[i].is_first = FALSE;
235: shm_config->hdr->alloc_map[i].is_last = FALSE;
236: shm_config->hdr->alloc_map[i].pg_state = PG_FREE;
237: }
238:
239: }
240:
241: short shm_exit(void)
242: {
243: int res;
244: union semun arg;
245:
246: res = shmdt (shm_config->dta);
247:
248: if (res == -1) {
249: fprintf (stderr, "shm_exit: failure in shmdt()\r\n");
250: return FALSE;
251: }
252:
253: if (first_process) {
254:
255: res = shmctl (shm_config->seg_id, IPC_RMID, 0);
256:
257: if (res == -1) {
258: fprintf (stderr, "shm_exit: failure in shmctl()\r\n");
259: return FALSE;
260: }
261:
262: semctl (semid_shm, 0, IPC_RMID, arg);
263: semctl (semid_locktab, 0, IPC_RMID, arg);
264: semctl (semid_jobtab, 0, IPC_RMID, arg);
265: semctl (semid_tp, 0, IPC_RMID, arg);
266: semctl (semid_symtab, 0, IPC_RMID, arg);
267:
268: }
269:
270: return TRUE;
271:
272: }
273:
274: short shm_get_sem(void)
275: {
276:
277: int tries;
278: struct sembuf s = {0, -1, 0};
279:
280: for (tries = 0; tries < 3; tries++) {
281:
282: if (semop (semid_shm, &s, 1) != -1) {
283: return TRUE;
284: }
285:
286: sleep (1);
287:
288: }
289:
290: return FALSE;
291:
292: }
293:
294: short shm_release_sem(void)
295: {
296: struct sembuf s = {0, 1, 0};
297:
298: if (semop (semid_shm, &s, 1) != -1) {
299: return TRUE;
300: }
301:
302: return FALSE;
303: }
304:
305: void shm_set_maintenance_mode (const short maintenance_mode)
306: {
307: if (shm_get_sem () == TRUE) {
308: shm_config->hdr->maintenance_mode = maintenance_mode;
309:
310: shm_release_sem ();
311: }
312: }
313:
314: shm_page_t *shm_get_alloc_map_entry(const int page_number)
315: {
316: return &(shm_config->hdr->alloc_map[page_number]);
317: }
318:
319: void *shm_page_num_to_address(const int page_num)
320: {
321: return (void *) shm_config->buf + (shm_config->pgsiz * page_num);
322: }
323:
324: int shm_address_to_page_num(const void *address)
325: {
326: unsigned long val = (unsigned long) address - (unsigned long) shm_config->buf;
327: unsigned long new_val = val / shm_config->pgsiz;
328:
329: return (int) new_val;
330: }
331:
332: void *shm_alloc_pages(const int page_count)
333: {
334:
335: register int i;
336: register int j;
337:
338: int candidate_page = 0;
339: int free_pages_gotten = 0;
340:
341: shm_page_t *pg;
342:
343: if (shm_get_sem () == FALSE) {
344: fprintf (stderr, "shm_alloc_pages: could not get exclusive access to shared memory\r\n");
345: exit (1);
346: }
347:
348:
349: for (i = 0; i < shm_config->pgct; i++) {
350:
351: pg = shm_get_alloc_map_entry (i);
352: NULLPTRCHK(pg,"shm_alloc_pages");
353:
354: free_pages_gotten = 0;
355:
356: if (pg->pg_state == PG_FREE) {
357:
358: candidate_page = i;
359:
360: for (j = i; ((j < (i + page_count)) && (j < shm_config->pgct)); j++) {
361: pg = shm_get_alloc_map_entry (j);
362:
363: if (pg->pg_state == PG_FREE) free_pages_gotten++;
364:
365: }
366:
367: if (free_pages_gotten == page_count) {
368:
369: for (j = candidate_page; j < (candidate_page + page_count); j++) {
370: pg = shm_get_alloc_map_entry (j);
371:
372: pg->pg_state = PG_ALLOC;
373: pg->pid = pid;
374:
375: if (j == candidate_page) {
376: pg->is_first = TRUE;
377: }
378:
379: if (j == candidate_page + (page_count - 1)) {
380: pg->is_last = TRUE;
381: }
382:
383: }
384:
385: shm_release_sem ();
386:
387: return (void *) shm_config->buf + (shm_config->pgsiz * candidate_page);
388:
389: }
390:
391: }
392:
393: }
394:
395: shm_release_sem ();
396:
397: return (void *) NULL;
398:
399: }
400:
401:
402: void *shm_alloc(const size_t bytes)
403: {
404: int pages_needed = bytes / shm_config->pgsiz;
405: float extra = bytes % shm_config->pgsiz;
406:
407: if (extra > 0) {
408: pages_needed++;
409: }
410:
411: return shm_alloc_pages (pages_needed);
412: }
413:
414: void shm_free_page(const int page_number)
415: {
416: register int i;
417: shm_page_t *a = shm_get_alloc_map_entry (page_number);
418:
419: if (a->is_first == FALSE) {
420: fprintf (stderr, "shm_free_page: attempt to free page in the middle of allocation chain\r\n");
421: return;
422: }
423:
424: if (a->pg_state == PG_FREE) {
425: fprintf (stderr, "shm_free_page: double free attempted in page %d\r\n", page_number);
426: exit (1);
427: }
428:
429: if (shm_get_sem () == FALSE) {
430: fprintf (stderr, "shm_free_page: could not get exclusive access to shared memory\r\n");
431: exit (1);
432: }
433:
434:
435: for (i = page_number; i < shm_config->pgct; i++) {
436:
437: a = shm_get_alloc_map_entry (i);
438:
439: if (a->is_last) {
440: a->is_first = FALSE;
441: a->pg_state = PG_FREE;
442: a->pid = 0;
443: a->is_last = FALSE;
444:
445: shm_release_sem ();
446:
447: return;
448: }
449: else {
450: a->is_first = FALSE;
451: a->pg_state = PG_FREE;
452: a->pid = 0;
453: a->is_last = FALSE;
454: }
455:
456: }
457:
458: shm_release_sem ();
459:
460: }
461:
462: void shm_free(const void *addr)
463: {
464: shm_free_page (shm_address_to_page_num (addr));
465: }
466:
467: void shm_dump(void)
468: {
469:
470: printf ("SHARED MEMORY CONFIGURATION\r\n");
1.2 snw 471: printf (" pgsiz %ld\r\n", (unsigned long) shm_config->pgsiz);
1.1 snw 472: printf (" pgct %d\r\n", shm_config->pgct);
1.2 snw 473: printf (" key %ld\r\n", shm_config->key);
1.1 snw 474: printf (" segid %d\r\n", shm_config->seg_id);
1.2 snw 475: printf (" sizeof shm_page_t %ld\r\n", (long) sizeof (shm_page_t));
476: printf (" segsiz %ld\r\n", (long) shm_config->segsiz);
1.1 snw 477: printf (" shm address %p\r\n", shm_config->dta);
1.2 snw 478: printf (" alloc_map size %ld\r\n", (unsigned long) sizeof (shm_page_t) * shm_config->pgct);
1.1 snw 479: printf (" buf address %p\r\n", shm_config->buf);
480: }
481:
482: void shm_dump_pages(void)
483: {
484:
485: register int i;
486: shm_page_t *p;
487:
488: printf ("%-10s%-10s%-10s%-10s%-10s\r\n", "PAGE", "PID", "BMHEAD", "BMTAIL", "STATE");
489:
490: for (i = 0; i < shm_config->pgct; i++) {
491:
492: p = shm_get_alloc_map_entry (i);
493:
494: printf ("%-10d%-10d%-10s%-10s%-10s\r\n",
495: i,
496: p->pid,
497: (p->is_first == TRUE) ? "Y" : "N",
498: (p->is_last == TRUE) ? "Y" : "N",
499: (p->pg_state == PG_FREE) ? "PG_FREE" : "PG_ALLOC");
500:
501: }
502:
503: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to shmmgr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src