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