![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to shm1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386|
Return to shm1.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 root 1: /*
2: * File: shm1.c
3: *
4: * Purpose: System V Compatible Shared Memory Device Driver
5: *
6: * $Log: shm1.c,v $
7: * Revision 2.3 93/08/09 13:46:24 bin
8: * Kernel 82 changes
9: *
10: * Revision 2.2 93/07/26 15:32:18 nigel
11: * Nigel's R80
12: *
13: * Revision 1.3 93/04/14 10:23:10 root
14: * r75
15: *
16: */
17:
18: /*
19: * ----------------------------------------------------------------------
20: * Includes.
21: */
22: #include <sys/coherent.h>
23: #include <sys/types.h>
24: #include <sys/proc.h>
25: #include <sys/ipc.h>
26: #include <sys/shm.h>
27: #include <sys/errno.h>
28:
29: /*
30: * ----------------------------------------------------------------------
31: * Definitions.
32: * Constants.
33: * Macros with argument lists.
34: * Typedefs.
35: * Enums.
36: */
37: #define SHMBASE 0x80000000 /* Base shared memory address */
38: /* These macros should be somewhere in the headers ???*/
39: #define DATAST 0x400000 /* Start of the data virtual address */
40: #define DATAEND 0x7FFFFF /* End of the data virtual address */
41: #define STACKST 0x7C000000 /* Start of the stack */
42: #define STACKEN 0x7FFFFFFF /* End of the stack virtual address */
43:
44: /*
45: * ----------------------------------------------------------------------
46: * Functions.
47: * Import Functions.
48: * Export Functions.
49: * Local Functions.
50: */
51: extern SEG *shmAlloc(); /* shm0.c */
52: char *ushmat();
53: int ushmdt();
54: int ushmctl();
55: int ushmget();
56: int iShmPerm(); /* Check permissions */
57: caddr_t vCheckReqAdd(); /* Check attach address for shmat */
58: /*
59: * ----------------------------------------------------------------------
60: * Global Data.
61: * Import Variables.
62: * Export Variables.
63: * Local Variables.
64: */
65:
66: /* Configurable variables - see /etc/conf/mtune. */
67: extern int SHMMNI;
68: extern int SHMMAX;
69:
70: struct shmid_ds *shmids = NULL; /* Array of shared memory segments */
71: SEG **shmsegs; /* Array of pointers to segments */
72: /*
73: * ----------------------------------------------------------------------
74: * Code.
75: */
76:
77: /*
78: * Shmctl - Shared Memory Control Operations.
79: */
80: int
81: ushmctl(iShmId, iCmd, pstShmId)
82: int iShmId, /* Shared memory id */
83: iCmd; /* Command */
84: struct shmid_ds *pstShmId; /* User shmid_ds buffer */
85: {
86: register struct shmid_ds *rstIdp;
87: int iRet = 0;
88:
89: /* Check if id is in proper range. */
90: if (iShmId >= SHMMNI || iShmId < 0) {
91: u.u_error = EINVAL;
92: return;
93: }
94: /* Check we did alloc. All allocatable arrays are alloced after
95: * the first ~correct usage of shmget.
96: */
97: if (shmids == NULL) {
98: u.u_error = EINVAL;
99: return;
100: }
101: rstIdp = &shmids[iShmId]; /* Requested segment */
102:
103: /* Check if segment is in used */
104: if ((rstIdp->shm_perm.mode & IPC_ALLOC) == 0) {
105: u.u_error = EINVAL;
106: return;
107: }
108:
109: switch (iCmd) {
110: case IPC_STAT:
111: /* Check read permission for stat. */
112: if (iShmPerm((rstIdp), SHM_R)) {
113: u.u_error = EACCES;
114: return;
115: }
116: /* Check if user gives a valid buffer */
117: if (!useracc(pstShmId, sizeof(struct shmid_ds), 1)) {
118: u.u_error = EFAULT;
119: return;
120: }
121: /* kucopy will set u_error if error occurs */
122: kucopy(rstIdp, pstShmId, sizeof(struct shmid_ds));
123: break;
124:
125: case IPC_SET:
126: if ((u.u_uid != 0) && (u.u_uid != rstIdp->shm_perm.uid) &&
127: (u.u_uid != rstIdp->shm_perm.cuid)) {
128: u.u_error = EPERM;
129: iRet = -1;
130: break;
131: }
132: rstIdp->shm_perm.uid = getuwd(&(pstShmId->shm_perm.uid));
133: rstIdp->shm_perm.gid = getuwd(&(pstShmId->shm_perm.gid));
134: rstIdp->shm_perm.mode &= ~0777;
135: rstIdp->shm_perm.mode |= getuwd(&(pstShmId->shm_perm.mode))
136: & 0777;
137: break;
138:
139: case IPC_RMID:
140: if ((u.u_uid != 0) && (u.u_uid != rstIdp->shm_perm.uid) &&
141: (u.u_uid != rstIdp->shm_perm.cuid)) {
142: u.u_error = EPERM;
143: iRet = -1;
144: break;
145: }
146:
147: /* SVR3 allows removing an attached segment. Even worse, the
148: * process that has the segment attached can keep using it.
149: * Some buggy third party software uses this "feature".
150: * So, we have to make it available too;-(
151: */
152: rstIdp->shm_perm.seq = 0;
153: rstIdp->shm_perm.mode = 0;
154:
155: /* If segment is attached, set flag to be removed */
156: if (rstIdp->shm_nattch > 0)
157: shmsegs[iShmId]->s_flags |= SRFBERM;
158: else /* remove it otherwise */
159: shmFree(shmsegs[iShmId]);
160: shmsegs[iShmId] = NULL;
161: break;
162:
163: /* SHM_LOCK and SHM_UNLOCK: lock/unlock shared memory segement
164: * in core. Is not a part of iBCS2.
165: * Has no meaning for current 4.0.* release of COHERENT.
166: * Have been done for binary portability.
167: */
168: case SHM_LOCK:
169: if (!u.u_uid) {
170: u.u_error = EPERM;
171: return;
172: }
173: break;
174: case SHM_UNLOCK:
175: if (!u.u_uid) {
176: u.u_error = EPERM;
177: return;
178: }
179: break;
180:
181: default:
182: u.u_error = EINVAL;
183: iRet = -1;
184: }
185:
186: return iRet;
187: }
188:
189: /*
190: * Shmget - Get Shared Memory Segment
191: * Return shared memory id if succed, -1 and set u_error otheriwse.
192: */
193: int
194: ushmget(kShmKey, iShmSize, iShmFlg)
195: key_t kShmKey; /* Shared memory key */
196: int iShmSize; /* Shared memory segment size */
197: int iShmFlg; /* Flags */
198: {
199: register struct shmid_ds *rstShmId; /* Work pointer */
200: register struct shmid_ds *rstOldest = 0;/* Oldest free segment */
201: register int i; /* Loop index */
202: SEG *pstSeg;
203:
204: /* Check the requested segment size */
205: if (iShmSize < 0 || iShmSize > SHMMAX) {
206: u.u_error = EINVAL;
207: return;
208: }
209: /* Init the shared memory on the first shmget. */
210: if (shmids == NULL)
211: if (shminit()) {
212: u.u_error = ENOSPC;
213: return;
214: }
215:
216: /* Search for desire shared memory segment. */
217: for (rstShmId = shmids, i = 0; i < SHMMNI; i++, rstShmId++) {
218: /* If segment is not alloced, we will look for the oldest
219: * free segment. We will use it to create a new one.
220: * The "oldest" will increase (a little) system reliability.
221: */
222: if ((rstShmId->shm_perm.mode & IPC_ALLOC) == 0) {
223: if ((rstOldest == NULL) ||
224: (rstOldest->shm_ctime > rstShmId->shm_ctime))
225: rstOldest = rstShmId;
226: continue;
227: }
228: /* Do we need a new segment? */
229: if (kShmKey == IPC_PRIVATE)
230: continue;
231: /* Keep going if key is different. The key is an element
232: * number of shmids
233: */
234: if (kShmKey != rstShmId->shm_perm.key)
235: continue;
236:
237: /* We found the segment with requested key. */
238:
239: /* Request was for the exclusive segment should fail. */
240: if ((iShmFlg & IPC_CREAT) && (iShmFlg & IPC_EXCL)) {
241: u.u_error = EEXIST;
242: return;
243: }
244:
245: /* Check the requested size */
246: if (rstShmId->shm_segsz < iShmSize) {
247: u.u_error = EINVAL;
248: return;
249: }
250:
251: /* Check permissions */
252: if (iShmPerm(rstShmId, iShmFlg))
253: return;
254: return i;
255: }
256:
257: /* We need to create a new segment */
258: if (rstOldest == 0) { /* Check system limits */
259: u.u_error = ENOSPC;
260: return;
261: }
262: if (!(iShmFlg & IPC_CREAT)) {
263: u.u_error = ENOENT;
264: return;
265: }
266: rstShmId = rstOldest;
267: /* Allocate a new shared memory segment */
268: pstSeg = shmAlloc(iShmSize);
269: if (pstSeg == NULL) {
270: u.u_error = ENOSPC;
271: return;
272: }
273: /* Save it in shmsegs */
274: shmsegs[rstShmId - shmids] = pstSeg;
275:
276: rstShmId->shm_perm.seq = (unsigned short) (rstShmId - shmids);
277: rstShmId->shm_segsz = iShmSize;
278: rstShmId->shm_atime = 0;
279: rstShmId->shm_dtime = 0;
280: rstShmId->shm_ctime = timer.t_time;
281: rstShmId->shm_cpid = SELF->p_pid;
282: rstShmId->shm_perm.cuid = rstShmId->shm_perm.uid = u.u_uid;
283: rstShmId->shm_perm.cgid = rstShmId->shm_perm.gid = u.u_gid;
284: rstShmId->shm_perm.mode = (iShmFlg & 0777) | IPC_ALLOC;
285: rstShmId->shm_perm.key = kShmKey;
286:
287: if (kShmKey == IPC_PRIVATE)
288: rstShmId->shm_perm.mode |= SHM_DEST;
289:
290: return rstShmId - shmids;
291: }
292:
293: /*
294: * Allocate space for shared memory data structures.
295: */
296: int
297: shminit()
298: {
299: shmids = (struct shmid_ds *) kalloc(sizeof(struct shmid_ds) * SHMMNI);
300: if (shmids == NULL)
301: return -1;
302:
303: /* Allocate array of shared memory segments. We do not have to
304: * initalise it
305: */
306: shmsegs = (SEG *) kalloc(sizeof(SEG *) * SHMMNI);
307: if (shmsegs == NULL)
308: return -1;
309: return 0;
310: }
311:
312: /*
313: * Attach shared memory segment.
314: */
315: char *
316: ushmat(iSysId, pcShmAddr, iShmFlg)
317: int iSysId; /* System segment id */
318: char *pcShmAddr; /* Address to attach */
319: int iShmFlg; /* Flags */
320: {
321: register PROC *rpstProc; /* Current process */
322: register struct sr *rpstSr; /* Shared memory segments */
323: struct sr *pstSrTmp;
324: SEG *pstSegSh; /* Segment to attach */
325: struct shmid_ds *pstShmId; /* Pointer to a system segment*/
326: unsigned int uSegId; /* Segment id */
327: caddr_t vAttAddr; /* Address to attach */
328: int i; /* Loop index */
329: int iReadOnly = 0; /* 1 - read only, 0 - rw */
330:
331: /* Check if iSysId is a valid shared memory id. */
332: if (iSysId < 0 || iSysId > SHMMNI) {
333: u.u_error = EINVAL;
334: return;
335: }
336: /* Do we really have this segment? */
337: pstShmId = shmids + iSysId;
338: if (pstShmId->shm_perm.seq != iSysId) {
339: u.u_error = EINVAL;
340: return;
341: }
342: /* Check permissions. */
343: if (iShmFlg & SHM_RDONLY)
344: iReadOnly = 1;
345: if (iReadOnly) {
346: if (iShmPerm(pstShmId, 0444)) {
347: u.u_error = EACCES;
348: return;
349: }
350: } else {
351: if (iShmPerm(pstShmId, 0666)) {
352: u.u_error = EACCES;
353: return;
354: }
355: }
356: /* Check if process has free shm index. */
357: rpstProc = SELF;
358: /* We will go through all NSHMSEG segments to see if any is free. */
359: for (rpstSr = rpstProc->p_shmsr; rpstSr < rpstProc->p_shmsr + NSHMSEG;
360: rpstSr++)
361: if (rpstSr->sr_segp == NULL)
362: break;
363: /* The segment id is just an element number. */
364: uSegId = rpstSr - rpstProc->p_shmsr;
365: /* If segment id is >= NSHMSEG we cannot attach any new segment. */
366: if (uSegId >= NSHMSEG) {
367: u.u_error = EMFILE;
368: return;
369: }
370: /* Get the pointer to the shared memory segment */
371: pstSegSh = shmsegs[iSysId];
372:
373: /* Find an address to attach.
374: * There are two cases: process does not request the address,
375: * process requests the address.
376: * In the first case we have to take the first available free address.
377: * We will try to put a free page between the segments.
378: * In the second case we have to check if address is an available and
379: * attach to this address.
380: */
381: /* First case. We have to find a free address. */
382: if (pcShmAddr == NULL) {
383: /* Find a free space to attach. */
384: for (pstSrTmp = rpstProc->p_shmsr, i = 0; i < NSHMSEG;
385: i++, pstSrTmp++)
386: if (pstSrTmp->sr_base == NULL)
387: break;
388: /* Check limit of attaches per process */
389: if (i >= NSHMSEG) {
390: u.u_error = EINVAL;
391: return;
392: }
393: /* We will use the addresses starting from SHMBASE.
394: * Each new address can be SHMMAX + NBPC appart.
395: */
396: vAttAddr = (caddr_t) (SHMBASE + i * (SHMMAX + NBPC));
397: } else {
398: /* Requst attach to a specific address. This is none portable
399: * way to use a shared memory.
400: */
401: if ((vAttAddr = vCheckReqAdd(pcShmAddr, iReadOnly)) < 0) {
402: printf("%s: attempt attach to 0x%x\n",
403: u.u_comm, pcShmAddr);
404: u.u_error = EINVAL;
405: return;
406: }
407: }
408:
409: if (!shmAtt(uSegId, vAttAddr, pstSegSh, iReadOnly)) {
410: u.u_error = EINVAL;
411: return;
412: }
413: pstShmId->shm_lpid = SELF->p_pid;
414: pstShmId->shm_atime = timer.t_time;
415: pstShmId->shm_dtime = 0;
416: pstShmId->shm_nattch = pstSegSh->s_urefc - 1;
417: /* Keep all attached addresses. We will need them for detach */
418: return (char *) vAttAddr;
419: }
420:
421: /*
422: * Check requested address for attach.
423: * Just fail for the first release.
424: */
425: caddr_t
426: vCheckReqAdd(pcAdd, iFlg)
427: char *pcAdd; /* Address to atatch */
428: int iFlg; /* Mode flag */
429: {
430: return (caddr_t) -1;
431: }
432:
433: /*
434: * Check permissions of the shared memory segment.
435: * Return 0 on success, -1 and set errno on error.
436: */
437: int
438: iShmPerm(pstShmId, iShmFlg)
439: struct shmid_ds *pstShmId;
440: int iShmFlg;
441: {
442: int iShmMode;
443:
444: /* We need 9 lower order bits. There is a question what we have to do
445: * if someone sets an execute bits on. At this point we just ignore
446: * them.
447: */
448: iShmMode = iShmFlg & 0666;
449:
450: /* For superuser or if mode is 0 */
451: if (u.u_uid == 0 || !iShmMode)
452: return 0;
453: /* For owner or creator */
454: if (u.u_uid == pstShmId->shm_perm.uid || u.u_uid
455: == pstShmId->shm_perm.cuid) {
456: if ((iShmMode & pstShmId->shm_perm.mode) & 0600)
457: return 0;
458: else {
459: u.u_error = EACCES;
460: return -1;
461: }
462: }
463: /* For group */
464: if (u.u_gid == pstShmId->shm_perm.gid
465: || u.u_gid == pstShmId->shm_perm.cgid) {
466: if ((iShmMode & pstShmId->shm_perm.mode) & 060)
467: return 0;
468: else {
469: u.u_error = EACCES;
470: return -1;
471: }
472: }
473: /* For the rest of the world */
474: if ((iShmMode & pstShmId->shm_perm.mode) & 06)
475: return 0;
476: else {
477: u.u_error = EACCES;
478: return -1;
479: }
480: /* We should never come here */
481: u.u_error = EACCES;
482: return -1;
483: }
484:
485: /*
486: * ushmdt() - Detach shared memory segment.
487: * Find segment number and call shmDetach() (shm0.c).
488: */
489: int
490: ushmdt(cpShmAddr)
491: char *cpShmAddr; /* Pointer to a segment */
492: {
493: register PROC *rpstProc; /* Current process */
494: register struct sr *rpstSr; /* Shared memory segments */
495: int i; /* Loop indexe */
496:
497: rpstProc = SELF; /* Get pointer to our process */
498:
499: /* Go through all segments. */
500: for (rpstSr = rpstProc->p_shmsr, i = 0; i < NSHMSEG; i++, rpstSr++) {
501: if (rpstSr->sr_base == (caddr_t) cpShmAddr) {
502: shmDetach(i);
503: return 0;
504: }
505: }
506:
507: /* We can come here only if we have invalid address */
508: u.u_error = EINVAL;
509: return;
510: }
511:
512: /*
513: * shmSetDs(). Called from shm0.c.
514: *
515: * Given a pointer to shared memory segment, set shmid_ds.
516: */
517: void
518: shmSetDs(rpstSeg)
519: register SEG *rpstSeg;
520: {
521: struct shmid_ds *pstShmId; /* Shared memory structure */
522: int iShmId; /* Shared memory id */
523: int j; /* Loop indexe */
524:
525: for (j = 0; j < SHMMNI; j++)
526: if (shmsegs[j] == rpstSeg)
527: break;
528:
529: /* We should have this segment. */
530: if (j >= SHMMNI) {
531: u.u_error = EINVAL;
532: return;
533: }
534:
535: iShmId = j;
536: pstShmId = shmids + iShmId;
537:
538: /* Set proper values */
539: pstShmId->shm_lpid = SELF->p_pid;
540: pstShmId->shm_dtime = timer.t_time;
541: pstShmId->shm_nattch = rpstSeg->s_urefc - 1;
542: return;
543: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.