Definizione nuova sezione per clone, prctl, ptrace. Correzioni varie e
[gapil.git] / sources / SharedMem.c
1 /* SharedMem.c
2  * 
3  * Copyright (C) 2002 Simone Piccardi
4  * 
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or (at
8  * your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 /***************************************************************
20  *
21  * File SharedMem.c 
22  * Routines for Shared Memory use. 
23  *
24  * Define two interfaces, the first one use SysV shared memory, the
25  * second POSIX shared memory.
26  *
27  * Author: S. Piccardi
28  *
29  ***************************************************************/
30 #include <sys/shm.h>     /* SysV shared memory */
31 #include <sys/types.h>   /* primitive system data types */
32 #include <sys/stat.h>    /* file characteristics constants and functions */
33 #include <stdio.h>       /* standard I/O library */
34 #include <fcntl.h>       /* file control functions */
35 #include <signal.h>      /* signal constants, types and functions */
36 #include <unistd.h>      /* unix standard library */
37 #include <sys/mman.h>
38 #include <string.h>      /* C strings library */
39 #include <errno.h>       /* error definitions and routines */
40
41 #include "macros.h"
42 /* *************************************************************************
43  *
44  *  Functions for SysV shared memory
45  *
46  * ************************************************************************* */
47 /*
48  * Function ShmCreate:
49  * Create and attach a SysV shared memory segment to the current process.
50  *
51  * First call get a shared memory segment with KEY key access and size SIZE,
52  * by creating it with R/W privilege for the user (this is the meaning of
53  * the ored flags). The function return an identifier shmid used for any 
54  * further reference to the shared memory segment. 
55  * Second call attach the shared memory segment to this process and return a
56  * pointer to it (of void * type). 
57  * Then initialize shared memory to the given value
58  *
59  * Input:  an IPC key value
60  *         the shared memory segment size
61  *         the permissions
62  *         the fill value
63  * Return: the address of the shared memory segment (NULL on error)
64  */
65 void * ShmCreate(key_t ipc_key, int shm_size, int perm, int fill) 
66 {
67     void * shm_ptr;
68     int shm_id;                       /* ID of the IPC shared memory segment */
69     shm_id = shmget(ipc_key, shm_size, IPC_CREAT|perm);        /* get shm ID */
70     if (shm_id < 0) { 
71         return NULL;
72     }
73     shm_ptr = shmat(shm_id, NULL, 0);                  /* map it into memory */
74     if (shm_ptr < 0) {
75         return NULL;
76     }
77     memset((void *)shm_ptr, fill, shm_size);                 /* fill segment */
78     return shm_ptr;
79 }
80 /*
81  * Function ShmFind:
82  * Find a SysV shared memory segment 
83  * Input:  an IPC key value
84  *         the shared memory segment size
85  * Return: the address of the segment (NULL on error)
86  */
87 void * ShmFind(key_t ipc_key, int shm_size) 
88 {
89     void * shm_ptr;
90     int shm_id;                      /* ID of the SysV shared memory segment */
91     shm_id = shmget(ipc_key, shm_size, 0);          /* find shared memory ID */
92     if (shm_id < 0) {
93         return NULL;
94     }
95     shm_ptr = shmat(shm_id, NULL, 0);                  /* map it into memory */
96     if (shm_ptr < 0) {
97         return NULL;
98     }
99     return shm_ptr;
100 }
101 /*
102  * Function ShmRemove:
103  * Schedule removal for a SysV shared memory segment 
104  * Input:  an IPC key value
105  *         the shared memory segment size
106  * Return: 0 on success, -1 on error
107  */
108 int ShmRemove(key_t ipc_key, void * shm_ptr) 
109 {
110     int shm_id;                      /* ID of the SysV shared memory segment */
111     /* first detach segment */
112     if (shmdt(shm_ptr) < 0) {
113         return -1;
114     }
115     /* schedule segment removal */
116     shm_id = shmget(ipc_key, 0, 0);                 /* find shared memory ID */
117     if (shm_id < 0) {
118         if (errno == EIDRM) return 0;
119         return -1;
120     }
121     if (shmctl(shm_id, IPC_RMID, NULL) < 0) {             /* ask for removal */
122         if (errno == EIDRM) return 0;
123         return -1;
124     }
125     return 0;
126 }
127 /* *************************************************************************
128  *
129  *  Functions for POSIX shared memory
130  *
131  * ************************************************************************* */
132 /*
133  * Function CreateShm:
134  * Create a POSIX shared memory segment and map it to the current process.
135  *
136  *
137  * Input:  a pathname
138  *         the shared memory segment size
139  *         the permissions
140  *         the fill value
141  * Return: the address of the shared memory segment (NULL on error)
142  */
143 void * CreateShm(char * shm_name, off_t shm_size, mode_t perm, int fill) 
144 {
145     void * shm_ptr;
146     int fd;
147     int flag;
148     /* first open the object, creating it if not existent */
149     flag = O_CREAT|O_EXCL|O_RDWR;
150     fd = shm_open(shm_name, flag, perm);    /* get object file descriptor */
151     if (fd < 0) { 
152         perror("errore in shm_open");
153         return NULL;
154     }
155     /* set the object size */
156     if (ftruncate(fd, shm_size)) {
157         perror("errore in ftruncate");
158         return NULL;
159     }
160     /* map it in the process address space */
161     shm_ptr = mmap(NULL, shm_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
162     if (shm_ptr == MAP_FAILED) {
163         perror("errore in mmap");
164         return NULL;
165     }
166     memset((void *) shm_ptr, fill, shm_size);                /* fill segment */
167     return shm_ptr;
168 }
169 /*
170  * Function FindShm:
171  * Find a POSIX shared memory segment 
172  * Input:  a name
173  *         the shared memory segment size
174  * Return: the address of the segment (NULL on error)
175  */
176 void * FindShm(char * shm_name, off_t shm_size) 
177 {
178     void * shm_ptr;
179     int fd;                           /* ID of the IPC shared memory segment */
180     /* find shared memory ID */
181     if ((fd = shm_open(shm_name, O_RDWR|O_EXCL, 0)) < 0) {
182         debug("Cannot open %s\n", shm_name);
183         return NULL;
184     }
185     /* take the pointer to it */
186     shm_ptr = mmap(NULL, shm_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
187     if (shm_ptr == MAP_FAILED) {
188         return NULL;
189     }
190     return shm_ptr;
191 }
192 /*
193  * Function RemoveShm:
194  * Remove a POSIX shared memory segment 
195  * Input:  the object name
196  * Return: 0 on success, -1 on error
197  */
198 int RemoveShm(char * shm_name)
199 {
200     return shm_unlink(shm_name);
201 }