64
65#include "opt_compat.h"
66#include "opt_sysvipc.h"
67
68#include <sys/param.h>
69#include <sys/systm.h>
70#include <sys/kernel.h>
71#include <sys/limits.h>
72#include <sys/lock.h>
73#include <sys/sysctl.h>
74#include <sys/shm.h>
75#include <sys/proc.h>
76#include <sys/malloc.h>
77#include <sys/mman.h>
78#include <sys/module.h>
79#include <sys/mutex.h>
80#include <sys/racct.h>
81#include <sys/resourcevar.h>
82#include <sys/rwlock.h>
83#include <sys/stat.h>
84#include <sys/syscall.h>
85#include <sys/syscallsubr.h>
86#include <sys/sysent.h>
87#include <sys/sysproto.h>
88#include <sys/jail.h>
89
90#include <security/mac/mac_framework.h>
91
92#include <vm/vm.h>
93#include <vm/vm_param.h>
94#include <vm/pmap.h>
95#include <vm/vm_object.h>
96#include <vm/vm_map.h>
97#include <vm/vm_page.h>
98#include <vm/vm_pager.h>
99
100FEATURE(sysv_shm, "System V shared memory segments support");
101
102static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments");
103
104static int shmget_allocate_segment(struct thread *td,
105 struct shmget_args *uap, int mode);
106static int shmget_existing(struct thread *td, struct shmget_args *uap,
107 int mode, int segnum);
108
109#define SHMSEG_FREE 0x0200
110#define SHMSEG_REMOVED 0x0400
111#define SHMSEG_ALLOCATED 0x0800
112
113static int shm_last_free, shm_nused, shmalloced;
114vm_size_t shm_committed;
115static struct shmid_kernel *shmsegs;
116
117struct shmmap_state {
118 vm_offset_t va;
119 int shmid;
120};
121
122static void shm_deallocate_segment(struct shmid_kernel *);
123static int shm_find_segment_by_key(key_t);
124static struct shmid_kernel *shm_find_segment(int, bool);
125static int shm_delete_mapping(struct vmspace *vm, struct shmmap_state *);
126static void shmrealloc(void);
127static int shminit(void);
128static int sysvshm_modload(struct module *, int, void *);
129static int shmunload(void);
130static void shmexit_myhook(struct vmspace *vm);
131static void shmfork_myhook(struct proc *p1, struct proc *p2);
132static int sysctl_shmsegs(SYSCTL_HANDLER_ARGS);
133
134/*
135 * Tuneable values.
136 */
137#ifndef SHMMAXPGS
138#define SHMMAXPGS 131072 /* Note: sysv shared memory is swap backed. */
139#endif
140#ifndef SHMMAX
141#define SHMMAX (SHMMAXPGS*PAGE_SIZE)
142#endif
143#ifndef SHMMIN
144#define SHMMIN 1
145#endif
146#ifndef SHMMNI
147#define SHMMNI 192
148#endif
149#ifndef SHMSEG
150#define SHMSEG 128
151#endif
152#ifndef SHMALL
153#define SHMALL (SHMMAXPGS)
154#endif
155
156struct shminfo shminfo = {
157 SHMMAX,
158 SHMMIN,
159 SHMMNI,
160 SHMSEG,
161 SHMALL
162};
163
164static int shm_use_phys;
165static int shm_allow_removed;
166
167SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0,
168 "Maximum shared memory segment size");
169SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0,
170 "Minimum shared memory segment size");
171SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RDTUN, &shminfo.shmmni, 0,
172 "Number of shared memory identifiers");
173SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RDTUN, &shminfo.shmseg, 0,
174 "Number of segments per process");
175SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0,
176 "Maximum number of pages available for shared memory");
177SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW,
178 &shm_use_phys, 0, "Enable/Disable locking of shared memory pages in core");
179SYSCTL_INT(_kern_ipc, OID_AUTO, shm_allow_removed, CTLFLAG_RW,
180 &shm_allow_removed, 0,
181 "Enable/Disable attachment to attached segments marked for removal");
182SYSCTL_PROC(_kern_ipc, OID_AUTO, shmsegs, CTLTYPE_OPAQUE | CTLFLAG_RD |
183 CTLFLAG_MPSAFE, NULL, 0, sysctl_shmsegs, "",
184 "Current number of shared memory segments allocated");
185
186static struct sx sysvshmsx;
187#define SYSVSHM_LOCK() sx_xlock(&sysvshmsx)
188#define SYSVSHM_UNLOCK() sx_xunlock(&sysvshmsx)
189#define SYSVSHM_ASSERT_LOCKED() sx_assert(&sysvshmsx, SA_XLOCKED)
190
191static int
192shm_find_segment_by_key(key_t key)
193{
194 int i;
195
196 for (i = 0; i < shmalloced; i++)
197 if ((shmsegs[i].u.shm_perm.mode & SHMSEG_ALLOCATED) &&
198 shmsegs[i].u.shm_perm.key == key)
199 return (i);
200 return (-1);
201}
202
203/*
204 * Finds segment either by shmid if is_shmid is true, or by segnum if
205 * is_shmid is false.
206 */
207static struct shmid_kernel *
208shm_find_segment(int arg, bool is_shmid)
209{
210 struct shmid_kernel *shmseg;
211 int segnum;
212
213 segnum = is_shmid ? IPCID_TO_IX(arg) : arg;
214 if (segnum < 0 || segnum >= shmalloced)
215 return (NULL);
216 shmseg = &shmsegs[segnum];
217 if ((shmseg->u.shm_perm.mode & SHMSEG_ALLOCATED) == 0 ||
218 (!shm_allow_removed &&
219 (shmseg->u.shm_perm.mode & SHMSEG_REMOVED) != 0) ||
220 (is_shmid && shmseg->u.shm_perm.seq != IPCID_TO_SEQ(arg)))
221 return (NULL);
222 return (shmseg);
223}
224
225static void
226shm_deallocate_segment(struct shmid_kernel *shmseg)
227{
228 vm_size_t size;
229
230 SYSVSHM_ASSERT_LOCKED();
231
232 vm_object_deallocate(shmseg->object);
233 shmseg->object = NULL;
234 size = round_page(shmseg->u.shm_segsz);
235 shm_committed -= btoc(size);
236 shm_nused--;
237 shmseg->u.shm_perm.mode = SHMSEG_FREE;
238#ifdef MAC
239 mac_sysvshm_cleanup(shmseg);
240#endif
241 racct_sub_cred(shmseg->cred, RACCT_NSHM, 1);
242 racct_sub_cred(shmseg->cred, RACCT_SHMSIZE, size);
243 crfree(shmseg->cred);
244 shmseg->cred = NULL;
245}
246
247static int
248shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s)
249{
250 struct shmid_kernel *shmseg;
251 int segnum, result;
252 vm_size_t size;
253
254 SYSVSHM_ASSERT_LOCKED();
255 segnum = IPCID_TO_IX(shmmap_s->shmid);
256 KASSERT(segnum >= 0 && segnum < shmalloced,
257 ("segnum %d shmalloced %d", segnum, shmalloced));
258
259 shmseg = &shmsegs[segnum];
260 size = round_page(shmseg->u.shm_segsz);
261 result = vm_map_remove(&vm->vm_map, shmmap_s->va, shmmap_s->va + size);
262 if (result != KERN_SUCCESS)
263 return (EINVAL);
264 shmmap_s->shmid = -1;
265 shmseg->u.shm_dtime = time_second;
266 if ((--shmseg->u.shm_nattch <= 0) &&
267 (shmseg->u.shm_perm.mode & SHMSEG_REMOVED)) {
268 shm_deallocate_segment(shmseg);
269 shm_last_free = segnum;
270 }
271 return (0);
272}
273
274static int
275kern_shmdt_locked(struct thread *td, const void *shmaddr)
276{
277 struct proc *p = td->td_proc;
278 struct shmmap_state *shmmap_s;
279#ifdef MAC
280 struct shmid_kernel *shmsegptr;
281#endif
282 int error, i;
283
284 SYSVSHM_ASSERT_LOCKED();
285 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
286 return (ENOSYS);
287 shmmap_s = p->p_vmspace->vm_shm;
288 if (shmmap_s == NULL)
289 return (EINVAL);
290 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) {
291 if (shmmap_s->shmid != -1 &&
292 shmmap_s->va == (vm_offset_t)shmaddr) {
293 break;
294 }
295 }
296 if (i == shminfo.shmseg)
297 return (EINVAL);
298#ifdef MAC
299 shmsegptr = &shmsegs[IPCID_TO_IX(shmmap_s->shmid)];
300 error = mac_sysvshm_check_shmdt(td->td_ucred, shmsegptr);
301 if (error != 0)
302 return (error);
303#endif
304 error = shm_delete_mapping(p->p_vmspace, shmmap_s);
305 return (error);
306}
307
308#ifndef _SYS_SYSPROTO_H_
309struct shmdt_args {
310 const void *shmaddr;
311};
312#endif
313int
314sys_shmdt(struct thread *td, struct shmdt_args *uap)
315{
316 int error;
317
318 SYSVSHM_LOCK();
319 error = kern_shmdt_locked(td, uap->shmaddr);
320 SYSVSHM_UNLOCK();
321 return (error);
322}
323
324static int
325kern_shmat_locked(struct thread *td, int shmid, const void *shmaddr,
326 int shmflg)
327{
328 struct proc *p = td->td_proc;
329 struct shmid_kernel *shmseg;
330 struct shmmap_state *shmmap_s;
331 vm_offset_t attach_va;
332 vm_prot_t prot;
333 vm_size_t size;
334 int error, i, rv;
335
336 SYSVSHM_ASSERT_LOCKED();
337 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
338 return (ENOSYS);
339 shmmap_s = p->p_vmspace->vm_shm;
340 if (shmmap_s == NULL) {
341 shmmap_s = malloc(shminfo.shmseg * sizeof(struct shmmap_state),
342 M_SHM, M_WAITOK);
343 for (i = 0; i < shminfo.shmseg; i++)
344 shmmap_s[i].shmid = -1;
345 KASSERT(p->p_vmspace->vm_shm == NULL, ("raced"));
346 p->p_vmspace->vm_shm = shmmap_s;
347 }
348 shmseg = shm_find_segment(shmid, true);
349 if (shmseg == NULL)
350 return (EINVAL);
351 error = ipcperm(td, &shmseg->u.shm_perm,
352 (shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
353 if (error != 0)
354 return (error);
355#ifdef MAC
356 error = mac_sysvshm_check_shmat(td->td_ucred, shmseg, shmflg);
357 if (error != 0)
358 return (error);
359#endif
360 for (i = 0; i < shminfo.shmseg; i++) {
361 if (shmmap_s->shmid == -1)
362 break;
363 shmmap_s++;
364 }
365 if (i >= shminfo.shmseg)
366 return (EMFILE);
367 size = round_page(shmseg->u.shm_segsz);
368 prot = VM_PROT_READ;
369 if ((shmflg & SHM_RDONLY) == 0)
370 prot |= VM_PROT_WRITE;
371 if (shmaddr != NULL) {
372 if ((shmflg & SHM_RND) != 0)
373 attach_va = (vm_offset_t)shmaddr & ~(SHMLBA-1);
374 else if (((vm_offset_t)shmaddr & (SHMLBA-1)) == 0)
375 attach_va = (vm_offset_t)shmaddr;
376 else
377 return (EINVAL);
378 } else {
379 /*
380 * This is just a hint to vm_map_find() about where to
381 * put it.
382 */
383 PROC_LOCK(p);
384 attach_va = round_page((vm_offset_t)p->p_vmspace->vm_daddr +
385 lim_max(p, RLIMIT_DATA));
386 PROC_UNLOCK(p);
387 }
388
389 vm_object_reference(shmseg->object);
390 rv = vm_map_find(&p->p_vmspace->vm_map, shmseg->object,
391 0, &attach_va, size, 0, shmaddr != NULL ? VMFS_NO_SPACE :
392 VMFS_OPTIMAL_SPACE, prot, prot, MAP_INHERIT_SHARE);
393 if (rv != KERN_SUCCESS) {
394 vm_object_deallocate(shmseg->object);
395 return (ENOMEM);
396 }
397
398 shmmap_s->va = attach_va;
399 shmmap_s->shmid = shmid;
400 shmseg->u.shm_lpid = p->p_pid;
401 shmseg->u.shm_atime = time_second;
402 shmseg->u.shm_nattch++;
403 td->td_retval[0] = attach_va;
404 return (error);
405}
406
407int
408kern_shmat(struct thread *td, int shmid, const void *shmaddr, int shmflg)
409{
410 int error;
411
412 SYSVSHM_LOCK();
413 error = kern_shmat_locked(td, shmid, shmaddr, shmflg);
414 SYSVSHM_UNLOCK();
415 return (error);
416}
417
418#ifndef _SYS_SYSPROTO_H_
419struct shmat_args {
420 int shmid;
421 const void *shmaddr;
422 int shmflg;
423};
424#endif
425int
426sys_shmat(struct thread *td, struct shmat_args *uap)
427{
428
429 return (kern_shmat(td, uap->shmid, uap->shmaddr, uap->shmflg));
430}
431
432static int
433kern_shmctl_locked(struct thread *td, int shmid, int cmd, void *buf,
434 size_t *bufsz)
435{
436 struct shmid_kernel *shmseg;
437 struct shmid_ds *shmidp;
438 struct shm_info shm_info;
439 int error;
440
441 SYSVSHM_ASSERT_LOCKED();
442
443 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
444 return (ENOSYS);
445
446 error = 0;
447 switch (cmd) {
448 /*
449 * It is possible that kern_shmctl is being called from the Linux ABI
450 * layer, in which case, we will need to implement IPC_INFO. It should
451 * be noted that other shmctl calls will be funneled through here for
452 * Linix binaries as well.
453 *
454 * NB: The Linux ABI layer will convert this data to structure(s) more
455 * consistent with the Linux ABI.
456 */
457 case IPC_INFO:
458 memcpy(buf, &shminfo, sizeof(shminfo));
459 if (bufsz)
460 *bufsz = sizeof(shminfo);
461 td->td_retval[0] = shmalloced;
462 return (0);
463 case SHM_INFO: {
464 shm_info.used_ids = shm_nused;
465 shm_info.shm_rss = 0; /*XXX where to get from ? */
466 shm_info.shm_tot = 0; /*XXX where to get from ? */
467 shm_info.shm_swp = 0; /*XXX where to get from ? */
468 shm_info.swap_attempts = 0; /*XXX where to get from ? */
469 shm_info.swap_successes = 0; /*XXX where to get from ? */
470 memcpy(buf, &shm_info, sizeof(shm_info));
471 if (bufsz != NULL)
472 *bufsz = sizeof(shm_info);
473 td->td_retval[0] = shmalloced;
474 return (0);
475 }
476 }
477 shmseg = shm_find_segment(shmid, cmd != SHM_STAT);
478 if (shmseg == NULL)
479 return (EINVAL);
480#ifdef MAC
481 error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, cmd);
482 if (error != 0)
483 return (error);
484#endif
485 switch (cmd) {
486 case SHM_STAT:
487 case IPC_STAT:
488 error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
489 if (error != 0)
490 return (error);
491 memcpy(buf, &shmseg->u, sizeof(struct shmid_ds));
492 if (bufsz != NULL)
493 *bufsz = sizeof(struct shmid_ds);
494 if (cmd == SHM_STAT) {
495 td->td_retval[0] = IXSEQ_TO_IPCID(shmid,
496 shmseg->u.shm_perm);
497 }
498 break;
499 case IPC_SET:
500 shmidp = (struct shmid_ds *)buf;
501 error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
502 if (error != 0)
503 return (error);
504 shmseg->u.shm_perm.uid = shmidp->shm_perm.uid;
505 shmseg->u.shm_perm.gid = shmidp->shm_perm.gid;
506 shmseg->u.shm_perm.mode =
507 (shmseg->u.shm_perm.mode & ~ACCESSPERMS) |
508 (shmidp->shm_perm.mode & ACCESSPERMS);
509 shmseg->u.shm_ctime = time_second;
510 break;
511 case IPC_RMID:
512 error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
513 if (error != 0)
514 return (error);
515 shmseg->u.shm_perm.key = IPC_PRIVATE;
516 shmseg->u.shm_perm.mode |= SHMSEG_REMOVED;
517 if (shmseg->u.shm_nattch <= 0) {
518 shm_deallocate_segment(shmseg);
519 shm_last_free = IPCID_TO_IX(shmid);
520 }
521 break;
522#if 0
523 case SHM_LOCK:
524 case SHM_UNLOCK:
525#endif
526 default:
527 error = EINVAL;
528 break;
529 }
530 return (error);
531}
532
533int
534kern_shmctl(struct thread *td, int shmid, int cmd, void *buf, size_t *bufsz)
535{
536 int error;
537
538 SYSVSHM_LOCK();
539 error = kern_shmctl_locked(td, shmid, cmd, buf, bufsz);
540 SYSVSHM_UNLOCK();
541 return (error);
542}
543
544
545#ifndef _SYS_SYSPROTO_H_
546struct shmctl_args {
547 int shmid;
548 int cmd;
549 struct shmid_ds *buf;
550};
551#endif
552int
553sys_shmctl(struct thread *td, struct shmctl_args *uap)
554{
555 int error = 0;
556 struct shmid_ds buf;
557 size_t bufsz;
558
559 /*
560 * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
561 * Linux binaries. If we see the call come through the FreeBSD ABI,
562 * return an error back to the user since we do not to support this.
563 */
564 if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
565 uap->cmd == SHM_STAT)
566 return (EINVAL);
567
568 /* IPC_SET needs to copyin the buffer before calling kern_shmctl */
569 if (uap->cmd == IPC_SET) {
570 if ((error = copyin(uap->buf, &buf, sizeof(struct shmid_ds))))
571 goto done;
572 }
573
574 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
575 if (error)
576 goto done;
577
578 /* Cases in which we need to copyout */
579 switch (uap->cmd) {
580 case IPC_STAT:
581 error = copyout(&buf, uap->buf, bufsz);
582 break;
583 }
584
585done:
586 if (error) {
587 /* Invalidate the return value */
588 td->td_retval[0] = -1;
589 }
590 return (error);
591}
592
593
594static int
595shmget_existing(struct thread *td, struct shmget_args *uap, int mode,
596 int segnum)
597{
598 struct shmid_kernel *shmseg;
599#ifdef MAC
600 int error;
601#endif
602
603 SYSVSHM_ASSERT_LOCKED();
604 KASSERT(segnum >= 0 && segnum < shmalloced,
605 ("segnum %d shmalloced %d", segnum, shmalloced));
606 shmseg = &shmsegs[segnum];
607 if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL))
608 return (EEXIST);
609#ifdef MAC
610 error = mac_sysvshm_check_shmget(td->td_ucred, shmseg, uap->shmflg);
611 if (error != 0)
612 return (error);
613#endif
614 if (uap->size != 0 && uap->size > shmseg->u.shm_segsz)
615 return (EINVAL);
616 td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
617 return (0);
618}
619
620static int
621shmget_allocate_segment(struct thread *td, struct shmget_args *uap, int mode)
622{
623 struct ucred *cred = td->td_ucred;
624 struct shmid_kernel *shmseg;
625 vm_object_t shm_object;
626 int i, segnum;
627 size_t size;
628
629 SYSVSHM_ASSERT_LOCKED();
630
631 if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax)
632 return (EINVAL);
633 if (shm_nused >= shminfo.shmmni) /* Any shmids left? */
634 return (ENOSPC);
635 size = round_page(uap->size);
636 if (shm_committed + btoc(size) > shminfo.shmall)
637 return (ENOMEM);
638 if (shm_last_free < 0) {
639 shmrealloc(); /* Maybe expand the shmsegs[] array. */
640 for (i = 0; i < shmalloced; i++)
641 if (shmsegs[i].u.shm_perm.mode & SHMSEG_FREE)
642 break;
643 if (i == shmalloced)
644 return (ENOSPC);
645 segnum = i;
646 } else {
647 segnum = shm_last_free;
648 shm_last_free = -1;
649 }
650 KASSERT(segnum >= 0 && segnum < shmalloced,
651 ("segnum %d shmalloced %d", segnum, shmalloced));
652 shmseg = &shmsegs[segnum];
653#ifdef RACCT
| 64
65#include "opt_compat.h"
66#include "opt_sysvipc.h"
67
68#include <sys/param.h>
69#include <sys/systm.h>
70#include <sys/kernel.h>
71#include <sys/limits.h>
72#include <sys/lock.h>
73#include <sys/sysctl.h>
74#include <sys/shm.h>
75#include <sys/proc.h>
76#include <sys/malloc.h>
77#include <sys/mman.h>
78#include <sys/module.h>
79#include <sys/mutex.h>
80#include <sys/racct.h>
81#include <sys/resourcevar.h>
82#include <sys/rwlock.h>
83#include <sys/stat.h>
84#include <sys/syscall.h>
85#include <sys/syscallsubr.h>
86#include <sys/sysent.h>
87#include <sys/sysproto.h>
88#include <sys/jail.h>
89
90#include <security/mac/mac_framework.h>
91
92#include <vm/vm.h>
93#include <vm/vm_param.h>
94#include <vm/pmap.h>
95#include <vm/vm_object.h>
96#include <vm/vm_map.h>
97#include <vm/vm_page.h>
98#include <vm/vm_pager.h>
99
100FEATURE(sysv_shm, "System V shared memory segments support");
101
102static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments");
103
104static int shmget_allocate_segment(struct thread *td,
105 struct shmget_args *uap, int mode);
106static int shmget_existing(struct thread *td, struct shmget_args *uap,
107 int mode, int segnum);
108
109#define SHMSEG_FREE 0x0200
110#define SHMSEG_REMOVED 0x0400
111#define SHMSEG_ALLOCATED 0x0800
112
113static int shm_last_free, shm_nused, shmalloced;
114vm_size_t shm_committed;
115static struct shmid_kernel *shmsegs;
116
117struct shmmap_state {
118 vm_offset_t va;
119 int shmid;
120};
121
122static void shm_deallocate_segment(struct shmid_kernel *);
123static int shm_find_segment_by_key(key_t);
124static struct shmid_kernel *shm_find_segment(int, bool);
125static int shm_delete_mapping(struct vmspace *vm, struct shmmap_state *);
126static void shmrealloc(void);
127static int shminit(void);
128static int sysvshm_modload(struct module *, int, void *);
129static int shmunload(void);
130static void shmexit_myhook(struct vmspace *vm);
131static void shmfork_myhook(struct proc *p1, struct proc *p2);
132static int sysctl_shmsegs(SYSCTL_HANDLER_ARGS);
133
134/*
135 * Tuneable values.
136 */
137#ifndef SHMMAXPGS
138#define SHMMAXPGS 131072 /* Note: sysv shared memory is swap backed. */
139#endif
140#ifndef SHMMAX
141#define SHMMAX (SHMMAXPGS*PAGE_SIZE)
142#endif
143#ifndef SHMMIN
144#define SHMMIN 1
145#endif
146#ifndef SHMMNI
147#define SHMMNI 192
148#endif
149#ifndef SHMSEG
150#define SHMSEG 128
151#endif
152#ifndef SHMALL
153#define SHMALL (SHMMAXPGS)
154#endif
155
156struct shminfo shminfo = {
157 SHMMAX,
158 SHMMIN,
159 SHMMNI,
160 SHMSEG,
161 SHMALL
162};
163
164static int shm_use_phys;
165static int shm_allow_removed;
166
167SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0,
168 "Maximum shared memory segment size");
169SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0,
170 "Minimum shared memory segment size");
171SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RDTUN, &shminfo.shmmni, 0,
172 "Number of shared memory identifiers");
173SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RDTUN, &shminfo.shmseg, 0,
174 "Number of segments per process");
175SYSCTL_ULONG(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0,
176 "Maximum number of pages available for shared memory");
177SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW,
178 &shm_use_phys, 0, "Enable/Disable locking of shared memory pages in core");
179SYSCTL_INT(_kern_ipc, OID_AUTO, shm_allow_removed, CTLFLAG_RW,
180 &shm_allow_removed, 0,
181 "Enable/Disable attachment to attached segments marked for removal");
182SYSCTL_PROC(_kern_ipc, OID_AUTO, shmsegs, CTLTYPE_OPAQUE | CTLFLAG_RD |
183 CTLFLAG_MPSAFE, NULL, 0, sysctl_shmsegs, "",
184 "Current number of shared memory segments allocated");
185
186static struct sx sysvshmsx;
187#define SYSVSHM_LOCK() sx_xlock(&sysvshmsx)
188#define SYSVSHM_UNLOCK() sx_xunlock(&sysvshmsx)
189#define SYSVSHM_ASSERT_LOCKED() sx_assert(&sysvshmsx, SA_XLOCKED)
190
191static int
192shm_find_segment_by_key(key_t key)
193{
194 int i;
195
196 for (i = 0; i < shmalloced; i++)
197 if ((shmsegs[i].u.shm_perm.mode & SHMSEG_ALLOCATED) &&
198 shmsegs[i].u.shm_perm.key == key)
199 return (i);
200 return (-1);
201}
202
203/*
204 * Finds segment either by shmid if is_shmid is true, or by segnum if
205 * is_shmid is false.
206 */
207static struct shmid_kernel *
208shm_find_segment(int arg, bool is_shmid)
209{
210 struct shmid_kernel *shmseg;
211 int segnum;
212
213 segnum = is_shmid ? IPCID_TO_IX(arg) : arg;
214 if (segnum < 0 || segnum >= shmalloced)
215 return (NULL);
216 shmseg = &shmsegs[segnum];
217 if ((shmseg->u.shm_perm.mode & SHMSEG_ALLOCATED) == 0 ||
218 (!shm_allow_removed &&
219 (shmseg->u.shm_perm.mode & SHMSEG_REMOVED) != 0) ||
220 (is_shmid && shmseg->u.shm_perm.seq != IPCID_TO_SEQ(arg)))
221 return (NULL);
222 return (shmseg);
223}
224
225static void
226shm_deallocate_segment(struct shmid_kernel *shmseg)
227{
228 vm_size_t size;
229
230 SYSVSHM_ASSERT_LOCKED();
231
232 vm_object_deallocate(shmseg->object);
233 shmseg->object = NULL;
234 size = round_page(shmseg->u.shm_segsz);
235 shm_committed -= btoc(size);
236 shm_nused--;
237 shmseg->u.shm_perm.mode = SHMSEG_FREE;
238#ifdef MAC
239 mac_sysvshm_cleanup(shmseg);
240#endif
241 racct_sub_cred(shmseg->cred, RACCT_NSHM, 1);
242 racct_sub_cred(shmseg->cred, RACCT_SHMSIZE, size);
243 crfree(shmseg->cred);
244 shmseg->cred = NULL;
245}
246
247static int
248shm_delete_mapping(struct vmspace *vm, struct shmmap_state *shmmap_s)
249{
250 struct shmid_kernel *shmseg;
251 int segnum, result;
252 vm_size_t size;
253
254 SYSVSHM_ASSERT_LOCKED();
255 segnum = IPCID_TO_IX(shmmap_s->shmid);
256 KASSERT(segnum >= 0 && segnum < shmalloced,
257 ("segnum %d shmalloced %d", segnum, shmalloced));
258
259 shmseg = &shmsegs[segnum];
260 size = round_page(shmseg->u.shm_segsz);
261 result = vm_map_remove(&vm->vm_map, shmmap_s->va, shmmap_s->va + size);
262 if (result != KERN_SUCCESS)
263 return (EINVAL);
264 shmmap_s->shmid = -1;
265 shmseg->u.shm_dtime = time_second;
266 if ((--shmseg->u.shm_nattch <= 0) &&
267 (shmseg->u.shm_perm.mode & SHMSEG_REMOVED)) {
268 shm_deallocate_segment(shmseg);
269 shm_last_free = segnum;
270 }
271 return (0);
272}
273
274static int
275kern_shmdt_locked(struct thread *td, const void *shmaddr)
276{
277 struct proc *p = td->td_proc;
278 struct shmmap_state *shmmap_s;
279#ifdef MAC
280 struct shmid_kernel *shmsegptr;
281#endif
282 int error, i;
283
284 SYSVSHM_ASSERT_LOCKED();
285 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
286 return (ENOSYS);
287 shmmap_s = p->p_vmspace->vm_shm;
288 if (shmmap_s == NULL)
289 return (EINVAL);
290 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) {
291 if (shmmap_s->shmid != -1 &&
292 shmmap_s->va == (vm_offset_t)shmaddr) {
293 break;
294 }
295 }
296 if (i == shminfo.shmseg)
297 return (EINVAL);
298#ifdef MAC
299 shmsegptr = &shmsegs[IPCID_TO_IX(shmmap_s->shmid)];
300 error = mac_sysvshm_check_shmdt(td->td_ucred, shmsegptr);
301 if (error != 0)
302 return (error);
303#endif
304 error = shm_delete_mapping(p->p_vmspace, shmmap_s);
305 return (error);
306}
307
308#ifndef _SYS_SYSPROTO_H_
309struct shmdt_args {
310 const void *shmaddr;
311};
312#endif
313int
314sys_shmdt(struct thread *td, struct shmdt_args *uap)
315{
316 int error;
317
318 SYSVSHM_LOCK();
319 error = kern_shmdt_locked(td, uap->shmaddr);
320 SYSVSHM_UNLOCK();
321 return (error);
322}
323
324static int
325kern_shmat_locked(struct thread *td, int shmid, const void *shmaddr,
326 int shmflg)
327{
328 struct proc *p = td->td_proc;
329 struct shmid_kernel *shmseg;
330 struct shmmap_state *shmmap_s;
331 vm_offset_t attach_va;
332 vm_prot_t prot;
333 vm_size_t size;
334 int error, i, rv;
335
336 SYSVSHM_ASSERT_LOCKED();
337 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
338 return (ENOSYS);
339 shmmap_s = p->p_vmspace->vm_shm;
340 if (shmmap_s == NULL) {
341 shmmap_s = malloc(shminfo.shmseg * sizeof(struct shmmap_state),
342 M_SHM, M_WAITOK);
343 for (i = 0; i < shminfo.shmseg; i++)
344 shmmap_s[i].shmid = -1;
345 KASSERT(p->p_vmspace->vm_shm == NULL, ("raced"));
346 p->p_vmspace->vm_shm = shmmap_s;
347 }
348 shmseg = shm_find_segment(shmid, true);
349 if (shmseg == NULL)
350 return (EINVAL);
351 error = ipcperm(td, &shmseg->u.shm_perm,
352 (shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
353 if (error != 0)
354 return (error);
355#ifdef MAC
356 error = mac_sysvshm_check_shmat(td->td_ucred, shmseg, shmflg);
357 if (error != 0)
358 return (error);
359#endif
360 for (i = 0; i < shminfo.shmseg; i++) {
361 if (shmmap_s->shmid == -1)
362 break;
363 shmmap_s++;
364 }
365 if (i >= shminfo.shmseg)
366 return (EMFILE);
367 size = round_page(shmseg->u.shm_segsz);
368 prot = VM_PROT_READ;
369 if ((shmflg & SHM_RDONLY) == 0)
370 prot |= VM_PROT_WRITE;
371 if (shmaddr != NULL) {
372 if ((shmflg & SHM_RND) != 0)
373 attach_va = (vm_offset_t)shmaddr & ~(SHMLBA-1);
374 else if (((vm_offset_t)shmaddr & (SHMLBA-1)) == 0)
375 attach_va = (vm_offset_t)shmaddr;
376 else
377 return (EINVAL);
378 } else {
379 /*
380 * This is just a hint to vm_map_find() about where to
381 * put it.
382 */
383 PROC_LOCK(p);
384 attach_va = round_page((vm_offset_t)p->p_vmspace->vm_daddr +
385 lim_max(p, RLIMIT_DATA));
386 PROC_UNLOCK(p);
387 }
388
389 vm_object_reference(shmseg->object);
390 rv = vm_map_find(&p->p_vmspace->vm_map, shmseg->object,
391 0, &attach_va, size, 0, shmaddr != NULL ? VMFS_NO_SPACE :
392 VMFS_OPTIMAL_SPACE, prot, prot, MAP_INHERIT_SHARE);
393 if (rv != KERN_SUCCESS) {
394 vm_object_deallocate(shmseg->object);
395 return (ENOMEM);
396 }
397
398 shmmap_s->va = attach_va;
399 shmmap_s->shmid = shmid;
400 shmseg->u.shm_lpid = p->p_pid;
401 shmseg->u.shm_atime = time_second;
402 shmseg->u.shm_nattch++;
403 td->td_retval[0] = attach_va;
404 return (error);
405}
406
407int
408kern_shmat(struct thread *td, int shmid, const void *shmaddr, int shmflg)
409{
410 int error;
411
412 SYSVSHM_LOCK();
413 error = kern_shmat_locked(td, shmid, shmaddr, shmflg);
414 SYSVSHM_UNLOCK();
415 return (error);
416}
417
418#ifndef _SYS_SYSPROTO_H_
419struct shmat_args {
420 int shmid;
421 const void *shmaddr;
422 int shmflg;
423};
424#endif
425int
426sys_shmat(struct thread *td, struct shmat_args *uap)
427{
428
429 return (kern_shmat(td, uap->shmid, uap->shmaddr, uap->shmflg));
430}
431
432static int
433kern_shmctl_locked(struct thread *td, int shmid, int cmd, void *buf,
434 size_t *bufsz)
435{
436 struct shmid_kernel *shmseg;
437 struct shmid_ds *shmidp;
438 struct shm_info shm_info;
439 int error;
440
441 SYSVSHM_ASSERT_LOCKED();
442
443 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
444 return (ENOSYS);
445
446 error = 0;
447 switch (cmd) {
448 /*
449 * It is possible that kern_shmctl is being called from the Linux ABI
450 * layer, in which case, we will need to implement IPC_INFO. It should
451 * be noted that other shmctl calls will be funneled through here for
452 * Linix binaries as well.
453 *
454 * NB: The Linux ABI layer will convert this data to structure(s) more
455 * consistent with the Linux ABI.
456 */
457 case IPC_INFO:
458 memcpy(buf, &shminfo, sizeof(shminfo));
459 if (bufsz)
460 *bufsz = sizeof(shminfo);
461 td->td_retval[0] = shmalloced;
462 return (0);
463 case SHM_INFO: {
464 shm_info.used_ids = shm_nused;
465 shm_info.shm_rss = 0; /*XXX where to get from ? */
466 shm_info.shm_tot = 0; /*XXX where to get from ? */
467 shm_info.shm_swp = 0; /*XXX where to get from ? */
468 shm_info.swap_attempts = 0; /*XXX where to get from ? */
469 shm_info.swap_successes = 0; /*XXX where to get from ? */
470 memcpy(buf, &shm_info, sizeof(shm_info));
471 if (bufsz != NULL)
472 *bufsz = sizeof(shm_info);
473 td->td_retval[0] = shmalloced;
474 return (0);
475 }
476 }
477 shmseg = shm_find_segment(shmid, cmd != SHM_STAT);
478 if (shmseg == NULL)
479 return (EINVAL);
480#ifdef MAC
481 error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, cmd);
482 if (error != 0)
483 return (error);
484#endif
485 switch (cmd) {
486 case SHM_STAT:
487 case IPC_STAT:
488 error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
489 if (error != 0)
490 return (error);
491 memcpy(buf, &shmseg->u, sizeof(struct shmid_ds));
492 if (bufsz != NULL)
493 *bufsz = sizeof(struct shmid_ds);
494 if (cmd == SHM_STAT) {
495 td->td_retval[0] = IXSEQ_TO_IPCID(shmid,
496 shmseg->u.shm_perm);
497 }
498 break;
499 case IPC_SET:
500 shmidp = (struct shmid_ds *)buf;
501 error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
502 if (error != 0)
503 return (error);
504 shmseg->u.shm_perm.uid = shmidp->shm_perm.uid;
505 shmseg->u.shm_perm.gid = shmidp->shm_perm.gid;
506 shmseg->u.shm_perm.mode =
507 (shmseg->u.shm_perm.mode & ~ACCESSPERMS) |
508 (shmidp->shm_perm.mode & ACCESSPERMS);
509 shmseg->u.shm_ctime = time_second;
510 break;
511 case IPC_RMID:
512 error = ipcperm(td, &shmseg->u.shm_perm, IPC_M);
513 if (error != 0)
514 return (error);
515 shmseg->u.shm_perm.key = IPC_PRIVATE;
516 shmseg->u.shm_perm.mode |= SHMSEG_REMOVED;
517 if (shmseg->u.shm_nattch <= 0) {
518 shm_deallocate_segment(shmseg);
519 shm_last_free = IPCID_TO_IX(shmid);
520 }
521 break;
522#if 0
523 case SHM_LOCK:
524 case SHM_UNLOCK:
525#endif
526 default:
527 error = EINVAL;
528 break;
529 }
530 return (error);
531}
532
533int
534kern_shmctl(struct thread *td, int shmid, int cmd, void *buf, size_t *bufsz)
535{
536 int error;
537
538 SYSVSHM_LOCK();
539 error = kern_shmctl_locked(td, shmid, cmd, buf, bufsz);
540 SYSVSHM_UNLOCK();
541 return (error);
542}
543
544
545#ifndef _SYS_SYSPROTO_H_
546struct shmctl_args {
547 int shmid;
548 int cmd;
549 struct shmid_ds *buf;
550};
551#endif
552int
553sys_shmctl(struct thread *td, struct shmctl_args *uap)
554{
555 int error = 0;
556 struct shmid_ds buf;
557 size_t bufsz;
558
559 /*
560 * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
561 * Linux binaries. If we see the call come through the FreeBSD ABI,
562 * return an error back to the user since we do not to support this.
563 */
564 if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
565 uap->cmd == SHM_STAT)
566 return (EINVAL);
567
568 /* IPC_SET needs to copyin the buffer before calling kern_shmctl */
569 if (uap->cmd == IPC_SET) {
570 if ((error = copyin(uap->buf, &buf, sizeof(struct shmid_ds))))
571 goto done;
572 }
573
574 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
575 if (error)
576 goto done;
577
578 /* Cases in which we need to copyout */
579 switch (uap->cmd) {
580 case IPC_STAT:
581 error = copyout(&buf, uap->buf, bufsz);
582 break;
583 }
584
585done:
586 if (error) {
587 /* Invalidate the return value */
588 td->td_retval[0] = -1;
589 }
590 return (error);
591}
592
593
594static int
595shmget_existing(struct thread *td, struct shmget_args *uap, int mode,
596 int segnum)
597{
598 struct shmid_kernel *shmseg;
599#ifdef MAC
600 int error;
601#endif
602
603 SYSVSHM_ASSERT_LOCKED();
604 KASSERT(segnum >= 0 && segnum < shmalloced,
605 ("segnum %d shmalloced %d", segnum, shmalloced));
606 shmseg = &shmsegs[segnum];
607 if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL))
608 return (EEXIST);
609#ifdef MAC
610 error = mac_sysvshm_check_shmget(td->td_ucred, shmseg, uap->shmflg);
611 if (error != 0)
612 return (error);
613#endif
614 if (uap->size != 0 && uap->size > shmseg->u.shm_segsz)
615 return (EINVAL);
616 td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
617 return (0);
618}
619
620static int
621shmget_allocate_segment(struct thread *td, struct shmget_args *uap, int mode)
622{
623 struct ucred *cred = td->td_ucred;
624 struct shmid_kernel *shmseg;
625 vm_object_t shm_object;
626 int i, segnum;
627 size_t size;
628
629 SYSVSHM_ASSERT_LOCKED();
630
631 if (uap->size < shminfo.shmmin || uap->size > shminfo.shmmax)
632 return (EINVAL);
633 if (shm_nused >= shminfo.shmmni) /* Any shmids left? */
634 return (ENOSPC);
635 size = round_page(uap->size);
636 if (shm_committed + btoc(size) > shminfo.shmall)
637 return (ENOMEM);
638 if (shm_last_free < 0) {
639 shmrealloc(); /* Maybe expand the shmsegs[] array. */
640 for (i = 0; i < shmalloced; i++)
641 if (shmsegs[i].u.shm_perm.mode & SHMSEG_FREE)
642 break;
643 if (i == shmalloced)
644 return (ENOSPC);
645 segnum = i;
646 } else {
647 segnum = shm_last_free;
648 shm_last_free = -1;
649 }
650 KASSERT(segnum >= 0 && segnum < shmalloced,
651 ("segnum %d shmalloced %d", segnum, shmalloced));
652 shmseg = &shmsegs[segnum];
653#ifdef RACCT
|
679#endif
680 return (ENOMEM);
681 }
682 shm_object->pg_color = 0;
683 VM_OBJECT_WLOCK(shm_object);
684 vm_object_clear_flag(shm_object, OBJ_ONEMAPPING);
685 vm_object_set_flag(shm_object, OBJ_COLORED | OBJ_NOSPLIT);
686 VM_OBJECT_WUNLOCK(shm_object);
687
688 shmseg->object = shm_object;
689 shmseg->u.shm_perm.cuid = shmseg->u.shm_perm.uid = cred->cr_uid;
690 shmseg->u.shm_perm.cgid = shmseg->u.shm_perm.gid = cred->cr_gid;
691 shmseg->u.shm_perm.mode = (mode & ACCESSPERMS) | SHMSEG_ALLOCATED;
692 shmseg->u.shm_perm.key = uap->key;
693 shmseg->u.shm_perm.seq = (shmseg->u.shm_perm.seq + 1) & 0x7fff;
694 shmseg->cred = crhold(cred);
695 shmseg->u.shm_segsz = uap->size;
696 shmseg->u.shm_cpid = td->td_proc->p_pid;
697 shmseg->u.shm_lpid = shmseg->u.shm_nattch = 0;
698 shmseg->u.shm_atime = shmseg->u.shm_dtime = 0;
699#ifdef MAC
700 mac_sysvshm_create(cred, shmseg);
701#endif
702 shmseg->u.shm_ctime = time_second;
703 shm_committed += btoc(size);
704 shm_nused++;
705 td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
706
707 return (0);
708}
709
710#ifndef _SYS_SYSPROTO_H_
711struct shmget_args {
712 key_t key;
713 size_t size;
714 int shmflg;
715};
716#endif
717int
718sys_shmget(struct thread *td, struct shmget_args *uap)
719{
720 int segnum, mode;
721 int error;
722
723 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
724 return (ENOSYS);
725 mode = uap->shmflg & ACCESSPERMS;
726 SYSVSHM_LOCK();
727 if (uap->key == IPC_PRIVATE) {
728 error = shmget_allocate_segment(td, uap, mode);
729 } else {
730 segnum = shm_find_segment_by_key(uap->key);
731 if (segnum >= 0)
732 error = shmget_existing(td, uap, mode, segnum);
733 else if ((uap->shmflg & IPC_CREAT) == 0)
734 error = ENOENT;
735 else
736 error = shmget_allocate_segment(td, uap, mode);
737 }
738 SYSVSHM_UNLOCK();
739 return (error);
740}
741
742static void
743shmfork_myhook(struct proc *p1, struct proc *p2)
744{
745 struct shmmap_state *shmmap_s;
746 size_t size;
747 int i;
748
749 SYSVSHM_LOCK();
750 size = shminfo.shmseg * sizeof(struct shmmap_state);
751 shmmap_s = malloc(size, M_SHM, M_WAITOK);
752 bcopy(p1->p_vmspace->vm_shm, shmmap_s, size);
753 p2->p_vmspace->vm_shm = shmmap_s;
754 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) {
755 if (shmmap_s->shmid != -1) {
756 KASSERT(IPCID_TO_IX(shmmap_s->shmid) >= 0 &&
757 IPCID_TO_IX(shmmap_s->shmid) < shmalloced,
758 ("segnum %d shmalloced %d",
759 IPCID_TO_IX(shmmap_s->shmid), shmalloced));
760 shmsegs[IPCID_TO_IX(shmmap_s->shmid)].u.shm_nattch++;
761 }
762 }
763 SYSVSHM_UNLOCK();
764}
765
766static void
767shmexit_myhook(struct vmspace *vm)
768{
769 struct shmmap_state *base, *shm;
770 int i;
771
772 base = vm->vm_shm;
773 if (base != NULL) {
774 vm->vm_shm = NULL;
775 SYSVSHM_LOCK();
776 for (i = 0, shm = base; i < shminfo.shmseg; i++, shm++) {
777 if (shm->shmid != -1)
778 shm_delete_mapping(vm, shm);
779 }
780 SYSVSHM_UNLOCK();
781 free(base, M_SHM);
782 }
783}
784
785static void
786shmrealloc(void)
787{
788 struct shmid_kernel *newsegs;
789 int i;
790
791 SYSVSHM_ASSERT_LOCKED();
792
793 if (shmalloced >= shminfo.shmmni)
794 return;
795
796 newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK);
797 for (i = 0; i < shmalloced; i++)
798 bcopy(&shmsegs[i], &newsegs[i], sizeof(newsegs[0]));
799 for (; i < shminfo.shmmni; i++) {
800 shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
801 shmsegs[i].u.shm_perm.seq = 0;
802#ifdef MAC
803 mac_sysvshm_init(&shmsegs[i]);
804#endif
805 }
806 free(shmsegs, M_SHM);
807 shmsegs = newsegs;
808 shmalloced = shminfo.shmmni;
809}
810
811static struct syscall_helper_data shm_syscalls[] = {
812 SYSCALL_INIT_HELPER(shmat),
813 SYSCALL_INIT_HELPER(shmctl),
814 SYSCALL_INIT_HELPER(shmdt),
815 SYSCALL_INIT_HELPER(shmget),
816#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
817 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
818 SYSCALL_INIT_HELPER_COMPAT(freebsd7_shmctl),
819#endif
820#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
821 SYSCALL_INIT_HELPER(shmsys),
822#endif
823 SYSCALL_INIT_LAST
824};
825
826#ifdef COMPAT_FREEBSD32
827#include <compat/freebsd32/freebsd32.h>
828#include <compat/freebsd32/freebsd32_ipc.h>
829#include <compat/freebsd32/freebsd32_proto.h>
830#include <compat/freebsd32/freebsd32_signal.h>
831#include <compat/freebsd32/freebsd32_syscall.h>
832#include <compat/freebsd32/freebsd32_util.h>
833
834static struct syscall_helper_data shm32_syscalls[] = {
835 SYSCALL32_INIT_HELPER_COMPAT(shmat),
836 SYSCALL32_INIT_HELPER_COMPAT(shmdt),
837 SYSCALL32_INIT_HELPER_COMPAT(shmget),
838 SYSCALL32_INIT_HELPER(freebsd32_shmsys),
839 SYSCALL32_INIT_HELPER(freebsd32_shmctl),
840#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
841 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
842 SYSCALL32_INIT_HELPER(freebsd7_freebsd32_shmctl),
843#endif
844 SYSCALL_INIT_LAST
845};
846#endif
847
848static int
849shminit(void)
850{
851 int i, error;
852
853#ifndef BURN_BRIDGES
854 if (TUNABLE_ULONG_FETCH("kern.ipc.shmmaxpgs", &shminfo.shmall) != 0)
855 printf("kern.ipc.shmmaxpgs is now called kern.ipc.shmall!\n");
856#endif
857 TUNABLE_ULONG_FETCH("kern.ipc.shmall", &shminfo.shmall);
858 if (!TUNABLE_ULONG_FETCH("kern.ipc.shmmax", &shminfo.shmmax)) {
859 /* Initialize shmmax dealing with possible overflow. */
860 for (i = PAGE_SIZE; i > 0; i--) {
861 shminfo.shmmax = shminfo.shmall * i;
862 if (shminfo.shmmax >= shminfo.shmall)
863 break;
864 }
865 }
866 TUNABLE_ULONG_FETCH("kern.ipc.shmmin", &shminfo.shmmin);
867 TUNABLE_ULONG_FETCH("kern.ipc.shmmni", &shminfo.shmmni);
868 TUNABLE_ULONG_FETCH("kern.ipc.shmseg", &shminfo.shmseg);
869 TUNABLE_INT_FETCH("kern.ipc.shm_use_phys", &shm_use_phys);
870
871 shmalloced = shminfo.shmmni;
872 shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK);
873 for (i = 0; i < shmalloced; i++) {
874 shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
875 shmsegs[i].u.shm_perm.seq = 0;
876#ifdef MAC
877 mac_sysvshm_init(&shmsegs[i]);
878#endif
879 }
880 shm_last_free = 0;
881 shm_nused = 0;
882 shm_committed = 0;
883 sx_init(&sysvshmsx, "sysvshmsx");
884 shmexit_hook = &shmexit_myhook;
885 shmfork_hook = &shmfork_myhook;
886
887 error = syscall_helper_register(shm_syscalls);
888 if (error != 0)
889 return (error);
890#ifdef COMPAT_FREEBSD32
891 error = syscall32_helper_register(shm32_syscalls);
892 if (error != 0)
893 return (error);
894#endif
895 return (0);
896}
897
898static int
899shmunload(void)
900{
901 int i;
902
903 if (shm_nused > 0)
904 return (EBUSY);
905
906#ifdef COMPAT_FREEBSD32
907 syscall32_helper_unregister(shm32_syscalls);
908#endif
909 syscall_helper_unregister(shm_syscalls);
910
911 for (i = 0; i < shmalloced; i++) {
912#ifdef MAC
913 mac_sysvshm_destroy(&shmsegs[i]);
914#endif
915 /*
916 * Objects might be still mapped into the processes
917 * address spaces. Actual free would happen on the
918 * last mapping destruction.
919 */
920 if (shmsegs[i].u.shm_perm.mode != SHMSEG_FREE)
921 vm_object_deallocate(shmsegs[i].object);
922 }
923 free(shmsegs, M_SHM);
924 shmexit_hook = NULL;
925 shmfork_hook = NULL;
926 sx_destroy(&sysvshmsx);
927 return (0);
928}
929
930static int
931sysctl_shmsegs(SYSCTL_HANDLER_ARGS)
932{
933 int error;
934
935 SYSVSHM_LOCK();
936 error = SYSCTL_OUT(req, shmsegs, shmalloced * sizeof(shmsegs[0]));
937 SYSVSHM_UNLOCK();
938 return (error);
939}
940
941#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
942struct oshmid_ds {
943 struct ipc_perm_old shm_perm; /* operation perms */
944 int shm_segsz; /* size of segment (bytes) */
945 u_short shm_cpid; /* pid, creator */
946 u_short shm_lpid; /* pid, last operation */
947 short shm_nattch; /* no. of current attaches */
948 time_t shm_atime; /* last attach time */
949 time_t shm_dtime; /* last detach time */
950 time_t shm_ctime; /* last change time */
951 void *shm_handle; /* internal handle for shm segment */
952};
953
954struct oshmctl_args {
955 int shmid;
956 int cmd;
957 struct oshmid_ds *ubuf;
958};
959
960static int
961oshmctl(struct thread *td, struct oshmctl_args *uap)
962{
963#ifdef COMPAT_43
964 int error = 0;
965 struct shmid_kernel *shmseg;
966 struct oshmid_ds outbuf;
967
968 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
969 return (ENOSYS);
970 if (uap->cmd != IPC_STAT) {
971 return (freebsd7_shmctl(td,
972 (struct freebsd7_shmctl_args *)uap));
973 }
974 SYSVSHM_LOCK();
975 shmseg = shm_find_segment(uap->shmid, true);
976 if (shmseg == NULL) {
977 SYSVSHM_UNLOCK();
978 return (EINVAL);
979 }
980 error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
981 if (error != 0) {
982 SYSVSHM_UNLOCK();
983 return (error);
984 }
985#ifdef MAC
986 error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, uap->cmd);
987 if (error != 0) {
988 SYSVSHM_UNLOCK();
989 return (error);
990 }
991#endif
992 ipcperm_new2old(&shmseg->u.shm_perm, &outbuf.shm_perm);
993 outbuf.shm_segsz = shmseg->u.shm_segsz;
994 outbuf.shm_cpid = shmseg->u.shm_cpid;
995 outbuf.shm_lpid = shmseg->u.shm_lpid;
996 outbuf.shm_nattch = shmseg->u.shm_nattch;
997 outbuf.shm_atime = shmseg->u.shm_atime;
998 outbuf.shm_dtime = shmseg->u.shm_dtime;
999 outbuf.shm_ctime = shmseg->u.shm_ctime;
1000 outbuf.shm_handle = shmseg->object;
1001 SYSVSHM_UNLOCK();
1002 error = copyout(&outbuf, uap->ubuf, sizeof(outbuf));
1003 return (error);
1004#else
1005 return (EINVAL);
1006#endif
1007}
1008
1009/* XXX casting to (sy_call_t *) is bogus, as usual. */
1010static sy_call_t *shmcalls[] = {
1011 (sy_call_t *)sys_shmat, (sy_call_t *)oshmctl,
1012 (sy_call_t *)sys_shmdt, (sy_call_t *)sys_shmget,
1013 (sy_call_t *)freebsd7_shmctl
1014};
1015
1016#ifndef _SYS_SYSPROTO_H_
1017/* XXX actually varargs. */
1018struct shmsys_args {
1019 int which;
1020 int a2;
1021 int a3;
1022 int a4;
1023};
1024#endif
1025int
1026sys_shmsys(struct thread *td, struct shmsys_args *uap)
1027{
1028 int error;
1029
1030 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
1031 return (ENOSYS);
1032 if (uap->which < 0 || uap->which >= nitems(shmcalls))
1033 return (EINVAL);
1034 error = (*shmcalls[uap->which])(td, &uap->a2);
1035 return (error);
1036}
1037
1038#endif /* i386 && (COMPAT_FREEBSD4 || COMPAT_43) */
1039
1040#ifdef COMPAT_FREEBSD32
1041
1042int
1043freebsd32_shmsys(struct thread *td, struct freebsd32_shmsys_args *uap)
1044{
1045
1046#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1047 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1048 switch (uap->which) {
1049 case 0: { /* shmat */
1050 struct shmat_args ap;
1051
1052 ap.shmid = uap->a2;
1053 ap.shmaddr = PTRIN(uap->a3);
1054 ap.shmflg = uap->a4;
1055 return (sysent[SYS_shmat].sy_call(td, &ap));
1056 }
1057 case 2: { /* shmdt */
1058 struct shmdt_args ap;
1059
1060 ap.shmaddr = PTRIN(uap->a2);
1061 return (sysent[SYS_shmdt].sy_call(td, &ap));
1062 }
1063 case 3: { /* shmget */
1064 struct shmget_args ap;
1065
1066 ap.key = uap->a2;
1067 ap.size = uap->a3;
1068 ap.shmflg = uap->a4;
1069 return (sysent[SYS_shmget].sy_call(td, &ap));
1070 }
1071 case 4: { /* shmctl */
1072 struct freebsd7_freebsd32_shmctl_args ap;
1073
1074 ap.shmid = uap->a2;
1075 ap.cmd = uap->a3;
1076 ap.buf = PTRIN(uap->a4);
1077 return (freebsd7_freebsd32_shmctl(td, &ap));
1078 }
1079 case 1: /* oshmctl */
1080 default:
1081 return (EINVAL);
1082 }
1083#else
1084 return (nosys(td, NULL));
1085#endif
1086}
1087
1088#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1089 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1090int
1091freebsd7_freebsd32_shmctl(struct thread *td,
1092 struct freebsd7_freebsd32_shmctl_args *uap)
1093{
1094 int error = 0;
1095 union {
1096 struct shmid_ds shmid_ds;
1097 struct shm_info shm_info;
1098 struct shminfo shminfo;
1099 } u;
1100 union {
1101 struct shmid_ds32_old shmid_ds32;
1102 struct shm_info32 shm_info32;
1103 struct shminfo32 shminfo32;
1104 } u32;
1105 size_t sz;
1106
1107 if (uap->cmd == IPC_SET) {
1108 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1109 sizeof(u32.shmid_ds32))))
1110 goto done;
1111 freebsd32_ipcperm_old_in(&u32.shmid_ds32.shm_perm,
1112 &u.shmid_ds.shm_perm);
1113 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1114 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1115 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1116 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1117 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1118 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1119 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1120 }
1121
1122 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1123 if (error)
1124 goto done;
1125
1126 /* Cases in which we need to copyout */
1127 switch (uap->cmd) {
1128 case IPC_INFO:
1129 CP(u.shminfo, u32.shminfo32, shmmax);
1130 CP(u.shminfo, u32.shminfo32, shmmin);
1131 CP(u.shminfo, u32.shminfo32, shmmni);
1132 CP(u.shminfo, u32.shminfo32, shmseg);
1133 CP(u.shminfo, u32.shminfo32, shmall);
1134 error = copyout(&u32.shminfo32, uap->buf,
1135 sizeof(u32.shminfo32));
1136 break;
1137 case SHM_INFO:
1138 CP(u.shm_info, u32.shm_info32, used_ids);
1139 CP(u.shm_info, u32.shm_info32, shm_rss);
1140 CP(u.shm_info, u32.shm_info32, shm_tot);
1141 CP(u.shm_info, u32.shm_info32, shm_swp);
1142 CP(u.shm_info, u32.shm_info32, swap_attempts);
1143 CP(u.shm_info, u32.shm_info32, swap_successes);
1144 error = copyout(&u32.shm_info32, uap->buf,
1145 sizeof(u32.shm_info32));
1146 break;
1147 case SHM_STAT:
1148 case IPC_STAT:
1149 freebsd32_ipcperm_old_out(&u.shmid_ds.shm_perm,
1150 &u32.shmid_ds32.shm_perm);
1151 if (u.shmid_ds.shm_segsz > INT32_MAX)
1152 u32.shmid_ds32.shm_segsz = INT32_MAX;
1153 else
1154 CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1155 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1156 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1157 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1158 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1159 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1160 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1161 u32.shmid_ds32.shm_internal = 0;
1162 error = copyout(&u32.shmid_ds32, uap->buf,
1163 sizeof(u32.shmid_ds32));
1164 break;
1165 }
1166
1167done:
1168 if (error) {
1169 /* Invalidate the return value */
1170 td->td_retval[0] = -1;
1171 }
1172 return (error);
1173}
1174#endif
1175
1176int
1177freebsd32_shmctl(struct thread *td, struct freebsd32_shmctl_args *uap)
1178{
1179 int error = 0;
1180 union {
1181 struct shmid_ds shmid_ds;
1182 struct shm_info shm_info;
1183 struct shminfo shminfo;
1184 } u;
1185 union {
1186 struct shmid_ds32 shmid_ds32;
1187 struct shm_info32 shm_info32;
1188 struct shminfo32 shminfo32;
1189 } u32;
1190 size_t sz;
1191
1192 if (uap->cmd == IPC_SET) {
1193 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1194 sizeof(u32.shmid_ds32))))
1195 goto done;
1196 freebsd32_ipcperm_in(&u32.shmid_ds32.shm_perm,
1197 &u.shmid_ds.shm_perm);
1198 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1199 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1200 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1201 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1202 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1203 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1204 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1205 }
1206
1207 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1208 if (error)
1209 goto done;
1210
1211 /* Cases in which we need to copyout */
1212 switch (uap->cmd) {
1213 case IPC_INFO:
1214 CP(u.shminfo, u32.shminfo32, shmmax);
1215 CP(u.shminfo, u32.shminfo32, shmmin);
1216 CP(u.shminfo, u32.shminfo32, shmmni);
1217 CP(u.shminfo, u32.shminfo32, shmseg);
1218 CP(u.shminfo, u32.shminfo32, shmall);
1219 error = copyout(&u32.shminfo32, uap->buf,
1220 sizeof(u32.shminfo32));
1221 break;
1222 case SHM_INFO:
1223 CP(u.shm_info, u32.shm_info32, used_ids);
1224 CP(u.shm_info, u32.shm_info32, shm_rss);
1225 CP(u.shm_info, u32.shm_info32, shm_tot);
1226 CP(u.shm_info, u32.shm_info32, shm_swp);
1227 CP(u.shm_info, u32.shm_info32, swap_attempts);
1228 CP(u.shm_info, u32.shm_info32, swap_successes);
1229 error = copyout(&u32.shm_info32, uap->buf,
1230 sizeof(u32.shm_info32));
1231 break;
1232 case SHM_STAT:
1233 case IPC_STAT:
1234 freebsd32_ipcperm_out(&u.shmid_ds.shm_perm,
1235 &u32.shmid_ds32.shm_perm);
1236 if (u.shmid_ds.shm_segsz > INT32_MAX)
1237 u32.shmid_ds32.shm_segsz = INT32_MAX;
1238 else
1239 CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1240 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1241 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1242 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1243 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1244 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1245 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1246 error = copyout(&u32.shmid_ds32, uap->buf,
1247 sizeof(u32.shmid_ds32));
1248 break;
1249 }
1250
1251done:
1252 if (error) {
1253 /* Invalidate the return value */
1254 td->td_retval[0] = -1;
1255 }
1256 return (error);
1257}
1258#endif
1259
1260#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1261 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1262
1263#ifndef CP
1264#define CP(src, dst, fld) do { (dst).fld = (src).fld; } while (0)
1265#endif
1266
1267#ifndef _SYS_SYSPROTO_H_
1268struct freebsd7_shmctl_args {
1269 int shmid;
1270 int cmd;
1271 struct shmid_ds_old *buf;
1272};
1273#endif
1274int
1275freebsd7_shmctl(struct thread *td, struct freebsd7_shmctl_args *uap)
1276{
1277 int error = 0;
1278 struct shmid_ds_old old;
1279 struct shmid_ds buf;
1280 size_t bufsz;
1281
1282 /*
1283 * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
1284 * Linux binaries. If we see the call come through the FreeBSD ABI,
1285 * return an error back to the user since we do not to support this.
1286 */
1287 if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
1288 uap->cmd == SHM_STAT)
1289 return (EINVAL);
1290
1291 /* IPC_SET needs to copyin the buffer before calling kern_shmctl */
1292 if (uap->cmd == IPC_SET) {
1293 if ((error = copyin(uap->buf, &old, sizeof(old))))
1294 goto done;
1295 ipcperm_old2new(&old.shm_perm, &buf.shm_perm);
1296 CP(old, buf, shm_segsz);
1297 CP(old, buf, shm_lpid);
1298 CP(old, buf, shm_cpid);
1299 CP(old, buf, shm_nattch);
1300 CP(old, buf, shm_atime);
1301 CP(old, buf, shm_dtime);
1302 CP(old, buf, shm_ctime);
1303 }
1304
1305 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
1306 if (error)
1307 goto done;
1308
1309 /* Cases in which we need to copyout */
1310 switch (uap->cmd) {
1311 case IPC_STAT:
1312 ipcperm_new2old(&buf.shm_perm, &old.shm_perm);
1313 if (buf.shm_segsz > INT_MAX)
1314 old.shm_segsz = INT_MAX;
1315 else
1316 CP(buf, old, shm_segsz);
1317 CP(buf, old, shm_lpid);
1318 CP(buf, old, shm_cpid);
1319 if (buf.shm_nattch > SHRT_MAX)
1320 old.shm_nattch = SHRT_MAX;
1321 else
1322 CP(buf, old, shm_nattch);
1323 CP(buf, old, shm_atime);
1324 CP(buf, old, shm_dtime);
1325 CP(buf, old, shm_ctime);
1326 old.shm_internal = NULL;
1327 error = copyout(&old, uap->buf, sizeof(old));
1328 break;
1329 }
1330
1331done:
1332 if (error) {
1333 /* Invalidate the return value */
1334 td->td_retval[0] = -1;
1335 }
1336 return (error);
1337}
1338
1339#endif /* COMPAT_FREEBSD4 || COMPAT_FREEBSD5 || COMPAT_FREEBSD6 ||
1340 COMPAT_FREEBSD7 */
1341
1342static int
1343sysvshm_modload(struct module *module, int cmd, void *arg)
1344{
1345 int error = 0;
1346
1347 switch (cmd) {
1348 case MOD_LOAD:
1349 error = shminit();
1350 if (error != 0)
1351 shmunload();
1352 break;
1353 case MOD_UNLOAD:
1354 error = shmunload();
1355 break;
1356 case MOD_SHUTDOWN:
1357 break;
1358 default:
1359 error = EINVAL;
1360 break;
1361 }
1362 return (error);
1363}
1364
1365static moduledata_t sysvshm_mod = {
1366 "sysvshm",
1367 &sysvshm_modload,
1368 NULL
1369};
1370
1371DECLARE_MODULE(sysvshm, sysvshm_mod, SI_SUB_SYSV_SHM, SI_ORDER_FIRST);
1372MODULE_VERSION(sysvshm, 1);
| 683#endif
684 return (ENOMEM);
685 }
686 shm_object->pg_color = 0;
687 VM_OBJECT_WLOCK(shm_object);
688 vm_object_clear_flag(shm_object, OBJ_ONEMAPPING);
689 vm_object_set_flag(shm_object, OBJ_COLORED | OBJ_NOSPLIT);
690 VM_OBJECT_WUNLOCK(shm_object);
691
692 shmseg->object = shm_object;
693 shmseg->u.shm_perm.cuid = shmseg->u.shm_perm.uid = cred->cr_uid;
694 shmseg->u.shm_perm.cgid = shmseg->u.shm_perm.gid = cred->cr_gid;
695 shmseg->u.shm_perm.mode = (mode & ACCESSPERMS) | SHMSEG_ALLOCATED;
696 shmseg->u.shm_perm.key = uap->key;
697 shmseg->u.shm_perm.seq = (shmseg->u.shm_perm.seq + 1) & 0x7fff;
698 shmseg->cred = crhold(cred);
699 shmseg->u.shm_segsz = uap->size;
700 shmseg->u.shm_cpid = td->td_proc->p_pid;
701 shmseg->u.shm_lpid = shmseg->u.shm_nattch = 0;
702 shmseg->u.shm_atime = shmseg->u.shm_dtime = 0;
703#ifdef MAC
704 mac_sysvshm_create(cred, shmseg);
705#endif
706 shmseg->u.shm_ctime = time_second;
707 shm_committed += btoc(size);
708 shm_nused++;
709 td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->u.shm_perm);
710
711 return (0);
712}
713
714#ifndef _SYS_SYSPROTO_H_
715struct shmget_args {
716 key_t key;
717 size_t size;
718 int shmflg;
719};
720#endif
721int
722sys_shmget(struct thread *td, struct shmget_args *uap)
723{
724 int segnum, mode;
725 int error;
726
727 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
728 return (ENOSYS);
729 mode = uap->shmflg & ACCESSPERMS;
730 SYSVSHM_LOCK();
731 if (uap->key == IPC_PRIVATE) {
732 error = shmget_allocate_segment(td, uap, mode);
733 } else {
734 segnum = shm_find_segment_by_key(uap->key);
735 if (segnum >= 0)
736 error = shmget_existing(td, uap, mode, segnum);
737 else if ((uap->shmflg & IPC_CREAT) == 0)
738 error = ENOENT;
739 else
740 error = shmget_allocate_segment(td, uap, mode);
741 }
742 SYSVSHM_UNLOCK();
743 return (error);
744}
745
746static void
747shmfork_myhook(struct proc *p1, struct proc *p2)
748{
749 struct shmmap_state *shmmap_s;
750 size_t size;
751 int i;
752
753 SYSVSHM_LOCK();
754 size = shminfo.shmseg * sizeof(struct shmmap_state);
755 shmmap_s = malloc(size, M_SHM, M_WAITOK);
756 bcopy(p1->p_vmspace->vm_shm, shmmap_s, size);
757 p2->p_vmspace->vm_shm = shmmap_s;
758 for (i = 0; i < shminfo.shmseg; i++, shmmap_s++) {
759 if (shmmap_s->shmid != -1) {
760 KASSERT(IPCID_TO_IX(shmmap_s->shmid) >= 0 &&
761 IPCID_TO_IX(shmmap_s->shmid) < shmalloced,
762 ("segnum %d shmalloced %d",
763 IPCID_TO_IX(shmmap_s->shmid), shmalloced));
764 shmsegs[IPCID_TO_IX(shmmap_s->shmid)].u.shm_nattch++;
765 }
766 }
767 SYSVSHM_UNLOCK();
768}
769
770static void
771shmexit_myhook(struct vmspace *vm)
772{
773 struct shmmap_state *base, *shm;
774 int i;
775
776 base = vm->vm_shm;
777 if (base != NULL) {
778 vm->vm_shm = NULL;
779 SYSVSHM_LOCK();
780 for (i = 0, shm = base; i < shminfo.shmseg; i++, shm++) {
781 if (shm->shmid != -1)
782 shm_delete_mapping(vm, shm);
783 }
784 SYSVSHM_UNLOCK();
785 free(base, M_SHM);
786 }
787}
788
789static void
790shmrealloc(void)
791{
792 struct shmid_kernel *newsegs;
793 int i;
794
795 SYSVSHM_ASSERT_LOCKED();
796
797 if (shmalloced >= shminfo.shmmni)
798 return;
799
800 newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK);
801 for (i = 0; i < shmalloced; i++)
802 bcopy(&shmsegs[i], &newsegs[i], sizeof(newsegs[0]));
803 for (; i < shminfo.shmmni; i++) {
804 shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
805 shmsegs[i].u.shm_perm.seq = 0;
806#ifdef MAC
807 mac_sysvshm_init(&shmsegs[i]);
808#endif
809 }
810 free(shmsegs, M_SHM);
811 shmsegs = newsegs;
812 shmalloced = shminfo.shmmni;
813}
814
815static struct syscall_helper_data shm_syscalls[] = {
816 SYSCALL_INIT_HELPER(shmat),
817 SYSCALL_INIT_HELPER(shmctl),
818 SYSCALL_INIT_HELPER(shmdt),
819 SYSCALL_INIT_HELPER(shmget),
820#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
821 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
822 SYSCALL_INIT_HELPER_COMPAT(freebsd7_shmctl),
823#endif
824#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
825 SYSCALL_INIT_HELPER(shmsys),
826#endif
827 SYSCALL_INIT_LAST
828};
829
830#ifdef COMPAT_FREEBSD32
831#include <compat/freebsd32/freebsd32.h>
832#include <compat/freebsd32/freebsd32_ipc.h>
833#include <compat/freebsd32/freebsd32_proto.h>
834#include <compat/freebsd32/freebsd32_signal.h>
835#include <compat/freebsd32/freebsd32_syscall.h>
836#include <compat/freebsd32/freebsd32_util.h>
837
838static struct syscall_helper_data shm32_syscalls[] = {
839 SYSCALL32_INIT_HELPER_COMPAT(shmat),
840 SYSCALL32_INIT_HELPER_COMPAT(shmdt),
841 SYSCALL32_INIT_HELPER_COMPAT(shmget),
842 SYSCALL32_INIT_HELPER(freebsd32_shmsys),
843 SYSCALL32_INIT_HELPER(freebsd32_shmctl),
844#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
845 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
846 SYSCALL32_INIT_HELPER(freebsd7_freebsd32_shmctl),
847#endif
848 SYSCALL_INIT_LAST
849};
850#endif
851
852static int
853shminit(void)
854{
855 int i, error;
856
857#ifndef BURN_BRIDGES
858 if (TUNABLE_ULONG_FETCH("kern.ipc.shmmaxpgs", &shminfo.shmall) != 0)
859 printf("kern.ipc.shmmaxpgs is now called kern.ipc.shmall!\n");
860#endif
861 TUNABLE_ULONG_FETCH("kern.ipc.shmall", &shminfo.shmall);
862 if (!TUNABLE_ULONG_FETCH("kern.ipc.shmmax", &shminfo.shmmax)) {
863 /* Initialize shmmax dealing with possible overflow. */
864 for (i = PAGE_SIZE; i > 0; i--) {
865 shminfo.shmmax = shminfo.shmall * i;
866 if (shminfo.shmmax >= shminfo.shmall)
867 break;
868 }
869 }
870 TUNABLE_ULONG_FETCH("kern.ipc.shmmin", &shminfo.shmmin);
871 TUNABLE_ULONG_FETCH("kern.ipc.shmmni", &shminfo.shmmni);
872 TUNABLE_ULONG_FETCH("kern.ipc.shmseg", &shminfo.shmseg);
873 TUNABLE_INT_FETCH("kern.ipc.shm_use_phys", &shm_use_phys);
874
875 shmalloced = shminfo.shmmni;
876 shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK);
877 for (i = 0; i < shmalloced; i++) {
878 shmsegs[i].u.shm_perm.mode = SHMSEG_FREE;
879 shmsegs[i].u.shm_perm.seq = 0;
880#ifdef MAC
881 mac_sysvshm_init(&shmsegs[i]);
882#endif
883 }
884 shm_last_free = 0;
885 shm_nused = 0;
886 shm_committed = 0;
887 sx_init(&sysvshmsx, "sysvshmsx");
888 shmexit_hook = &shmexit_myhook;
889 shmfork_hook = &shmfork_myhook;
890
891 error = syscall_helper_register(shm_syscalls);
892 if (error != 0)
893 return (error);
894#ifdef COMPAT_FREEBSD32
895 error = syscall32_helper_register(shm32_syscalls);
896 if (error != 0)
897 return (error);
898#endif
899 return (0);
900}
901
902static int
903shmunload(void)
904{
905 int i;
906
907 if (shm_nused > 0)
908 return (EBUSY);
909
910#ifdef COMPAT_FREEBSD32
911 syscall32_helper_unregister(shm32_syscalls);
912#endif
913 syscall_helper_unregister(shm_syscalls);
914
915 for (i = 0; i < shmalloced; i++) {
916#ifdef MAC
917 mac_sysvshm_destroy(&shmsegs[i]);
918#endif
919 /*
920 * Objects might be still mapped into the processes
921 * address spaces. Actual free would happen on the
922 * last mapping destruction.
923 */
924 if (shmsegs[i].u.shm_perm.mode != SHMSEG_FREE)
925 vm_object_deallocate(shmsegs[i].object);
926 }
927 free(shmsegs, M_SHM);
928 shmexit_hook = NULL;
929 shmfork_hook = NULL;
930 sx_destroy(&sysvshmsx);
931 return (0);
932}
933
934static int
935sysctl_shmsegs(SYSCTL_HANDLER_ARGS)
936{
937 int error;
938
939 SYSVSHM_LOCK();
940 error = SYSCTL_OUT(req, shmsegs, shmalloced * sizeof(shmsegs[0]));
941 SYSVSHM_UNLOCK();
942 return (error);
943}
944
945#if defined(__i386__) && (defined(COMPAT_FREEBSD4) || defined(COMPAT_43))
946struct oshmid_ds {
947 struct ipc_perm_old shm_perm; /* operation perms */
948 int shm_segsz; /* size of segment (bytes) */
949 u_short shm_cpid; /* pid, creator */
950 u_short shm_lpid; /* pid, last operation */
951 short shm_nattch; /* no. of current attaches */
952 time_t shm_atime; /* last attach time */
953 time_t shm_dtime; /* last detach time */
954 time_t shm_ctime; /* last change time */
955 void *shm_handle; /* internal handle for shm segment */
956};
957
958struct oshmctl_args {
959 int shmid;
960 int cmd;
961 struct oshmid_ds *ubuf;
962};
963
964static int
965oshmctl(struct thread *td, struct oshmctl_args *uap)
966{
967#ifdef COMPAT_43
968 int error = 0;
969 struct shmid_kernel *shmseg;
970 struct oshmid_ds outbuf;
971
972 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
973 return (ENOSYS);
974 if (uap->cmd != IPC_STAT) {
975 return (freebsd7_shmctl(td,
976 (struct freebsd7_shmctl_args *)uap));
977 }
978 SYSVSHM_LOCK();
979 shmseg = shm_find_segment(uap->shmid, true);
980 if (shmseg == NULL) {
981 SYSVSHM_UNLOCK();
982 return (EINVAL);
983 }
984 error = ipcperm(td, &shmseg->u.shm_perm, IPC_R);
985 if (error != 0) {
986 SYSVSHM_UNLOCK();
987 return (error);
988 }
989#ifdef MAC
990 error = mac_sysvshm_check_shmctl(td->td_ucred, shmseg, uap->cmd);
991 if (error != 0) {
992 SYSVSHM_UNLOCK();
993 return (error);
994 }
995#endif
996 ipcperm_new2old(&shmseg->u.shm_perm, &outbuf.shm_perm);
997 outbuf.shm_segsz = shmseg->u.shm_segsz;
998 outbuf.shm_cpid = shmseg->u.shm_cpid;
999 outbuf.shm_lpid = shmseg->u.shm_lpid;
1000 outbuf.shm_nattch = shmseg->u.shm_nattch;
1001 outbuf.shm_atime = shmseg->u.shm_atime;
1002 outbuf.shm_dtime = shmseg->u.shm_dtime;
1003 outbuf.shm_ctime = shmseg->u.shm_ctime;
1004 outbuf.shm_handle = shmseg->object;
1005 SYSVSHM_UNLOCK();
1006 error = copyout(&outbuf, uap->ubuf, sizeof(outbuf));
1007 return (error);
1008#else
1009 return (EINVAL);
1010#endif
1011}
1012
1013/* XXX casting to (sy_call_t *) is bogus, as usual. */
1014static sy_call_t *shmcalls[] = {
1015 (sy_call_t *)sys_shmat, (sy_call_t *)oshmctl,
1016 (sy_call_t *)sys_shmdt, (sy_call_t *)sys_shmget,
1017 (sy_call_t *)freebsd7_shmctl
1018};
1019
1020#ifndef _SYS_SYSPROTO_H_
1021/* XXX actually varargs. */
1022struct shmsys_args {
1023 int which;
1024 int a2;
1025 int a3;
1026 int a4;
1027};
1028#endif
1029int
1030sys_shmsys(struct thread *td, struct shmsys_args *uap)
1031{
1032 int error;
1033
1034 if (!prison_allow(td->td_ucred, PR_ALLOW_SYSVIPC))
1035 return (ENOSYS);
1036 if (uap->which < 0 || uap->which >= nitems(shmcalls))
1037 return (EINVAL);
1038 error = (*shmcalls[uap->which])(td, &uap->a2);
1039 return (error);
1040}
1041
1042#endif /* i386 && (COMPAT_FREEBSD4 || COMPAT_43) */
1043
1044#ifdef COMPAT_FREEBSD32
1045
1046int
1047freebsd32_shmsys(struct thread *td, struct freebsd32_shmsys_args *uap)
1048{
1049
1050#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1051 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1052 switch (uap->which) {
1053 case 0: { /* shmat */
1054 struct shmat_args ap;
1055
1056 ap.shmid = uap->a2;
1057 ap.shmaddr = PTRIN(uap->a3);
1058 ap.shmflg = uap->a4;
1059 return (sysent[SYS_shmat].sy_call(td, &ap));
1060 }
1061 case 2: { /* shmdt */
1062 struct shmdt_args ap;
1063
1064 ap.shmaddr = PTRIN(uap->a2);
1065 return (sysent[SYS_shmdt].sy_call(td, &ap));
1066 }
1067 case 3: { /* shmget */
1068 struct shmget_args ap;
1069
1070 ap.key = uap->a2;
1071 ap.size = uap->a3;
1072 ap.shmflg = uap->a4;
1073 return (sysent[SYS_shmget].sy_call(td, &ap));
1074 }
1075 case 4: { /* shmctl */
1076 struct freebsd7_freebsd32_shmctl_args ap;
1077
1078 ap.shmid = uap->a2;
1079 ap.cmd = uap->a3;
1080 ap.buf = PTRIN(uap->a4);
1081 return (freebsd7_freebsd32_shmctl(td, &ap));
1082 }
1083 case 1: /* oshmctl */
1084 default:
1085 return (EINVAL);
1086 }
1087#else
1088 return (nosys(td, NULL));
1089#endif
1090}
1091
1092#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1093 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1094int
1095freebsd7_freebsd32_shmctl(struct thread *td,
1096 struct freebsd7_freebsd32_shmctl_args *uap)
1097{
1098 int error = 0;
1099 union {
1100 struct shmid_ds shmid_ds;
1101 struct shm_info shm_info;
1102 struct shminfo shminfo;
1103 } u;
1104 union {
1105 struct shmid_ds32_old shmid_ds32;
1106 struct shm_info32 shm_info32;
1107 struct shminfo32 shminfo32;
1108 } u32;
1109 size_t sz;
1110
1111 if (uap->cmd == IPC_SET) {
1112 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1113 sizeof(u32.shmid_ds32))))
1114 goto done;
1115 freebsd32_ipcperm_old_in(&u32.shmid_ds32.shm_perm,
1116 &u.shmid_ds.shm_perm);
1117 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1118 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1119 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1120 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1121 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1122 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1123 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1124 }
1125
1126 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1127 if (error)
1128 goto done;
1129
1130 /* Cases in which we need to copyout */
1131 switch (uap->cmd) {
1132 case IPC_INFO:
1133 CP(u.shminfo, u32.shminfo32, shmmax);
1134 CP(u.shminfo, u32.shminfo32, shmmin);
1135 CP(u.shminfo, u32.shminfo32, shmmni);
1136 CP(u.shminfo, u32.shminfo32, shmseg);
1137 CP(u.shminfo, u32.shminfo32, shmall);
1138 error = copyout(&u32.shminfo32, uap->buf,
1139 sizeof(u32.shminfo32));
1140 break;
1141 case SHM_INFO:
1142 CP(u.shm_info, u32.shm_info32, used_ids);
1143 CP(u.shm_info, u32.shm_info32, shm_rss);
1144 CP(u.shm_info, u32.shm_info32, shm_tot);
1145 CP(u.shm_info, u32.shm_info32, shm_swp);
1146 CP(u.shm_info, u32.shm_info32, swap_attempts);
1147 CP(u.shm_info, u32.shm_info32, swap_successes);
1148 error = copyout(&u32.shm_info32, uap->buf,
1149 sizeof(u32.shm_info32));
1150 break;
1151 case SHM_STAT:
1152 case IPC_STAT:
1153 freebsd32_ipcperm_old_out(&u.shmid_ds.shm_perm,
1154 &u32.shmid_ds32.shm_perm);
1155 if (u.shmid_ds.shm_segsz > INT32_MAX)
1156 u32.shmid_ds32.shm_segsz = INT32_MAX;
1157 else
1158 CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1159 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1160 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1161 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1162 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1163 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1164 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1165 u32.shmid_ds32.shm_internal = 0;
1166 error = copyout(&u32.shmid_ds32, uap->buf,
1167 sizeof(u32.shmid_ds32));
1168 break;
1169 }
1170
1171done:
1172 if (error) {
1173 /* Invalidate the return value */
1174 td->td_retval[0] = -1;
1175 }
1176 return (error);
1177}
1178#endif
1179
1180int
1181freebsd32_shmctl(struct thread *td, struct freebsd32_shmctl_args *uap)
1182{
1183 int error = 0;
1184 union {
1185 struct shmid_ds shmid_ds;
1186 struct shm_info shm_info;
1187 struct shminfo shminfo;
1188 } u;
1189 union {
1190 struct shmid_ds32 shmid_ds32;
1191 struct shm_info32 shm_info32;
1192 struct shminfo32 shminfo32;
1193 } u32;
1194 size_t sz;
1195
1196 if (uap->cmd == IPC_SET) {
1197 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1198 sizeof(u32.shmid_ds32))))
1199 goto done;
1200 freebsd32_ipcperm_in(&u32.shmid_ds32.shm_perm,
1201 &u.shmid_ds.shm_perm);
1202 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1203 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1204 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1205 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1206 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1207 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1208 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1209 }
1210
1211 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1212 if (error)
1213 goto done;
1214
1215 /* Cases in which we need to copyout */
1216 switch (uap->cmd) {
1217 case IPC_INFO:
1218 CP(u.shminfo, u32.shminfo32, shmmax);
1219 CP(u.shminfo, u32.shminfo32, shmmin);
1220 CP(u.shminfo, u32.shminfo32, shmmni);
1221 CP(u.shminfo, u32.shminfo32, shmseg);
1222 CP(u.shminfo, u32.shminfo32, shmall);
1223 error = copyout(&u32.shminfo32, uap->buf,
1224 sizeof(u32.shminfo32));
1225 break;
1226 case SHM_INFO:
1227 CP(u.shm_info, u32.shm_info32, used_ids);
1228 CP(u.shm_info, u32.shm_info32, shm_rss);
1229 CP(u.shm_info, u32.shm_info32, shm_tot);
1230 CP(u.shm_info, u32.shm_info32, shm_swp);
1231 CP(u.shm_info, u32.shm_info32, swap_attempts);
1232 CP(u.shm_info, u32.shm_info32, swap_successes);
1233 error = copyout(&u32.shm_info32, uap->buf,
1234 sizeof(u32.shm_info32));
1235 break;
1236 case SHM_STAT:
1237 case IPC_STAT:
1238 freebsd32_ipcperm_out(&u.shmid_ds.shm_perm,
1239 &u32.shmid_ds32.shm_perm);
1240 if (u.shmid_ds.shm_segsz > INT32_MAX)
1241 u32.shmid_ds32.shm_segsz = INT32_MAX;
1242 else
1243 CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1244 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1245 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1246 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1247 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1248 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1249 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1250 error = copyout(&u32.shmid_ds32, uap->buf,
1251 sizeof(u32.shmid_ds32));
1252 break;
1253 }
1254
1255done:
1256 if (error) {
1257 /* Invalidate the return value */
1258 td->td_retval[0] = -1;
1259 }
1260 return (error);
1261}
1262#endif
1263
1264#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1265 defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1266
1267#ifndef CP
1268#define CP(src, dst, fld) do { (dst).fld = (src).fld; } while (0)
1269#endif
1270
1271#ifndef _SYS_SYSPROTO_H_
1272struct freebsd7_shmctl_args {
1273 int shmid;
1274 int cmd;
1275 struct shmid_ds_old *buf;
1276};
1277#endif
1278int
1279freebsd7_shmctl(struct thread *td, struct freebsd7_shmctl_args *uap)
1280{
1281 int error = 0;
1282 struct shmid_ds_old old;
1283 struct shmid_ds buf;
1284 size_t bufsz;
1285
1286 /*
1287 * The only reason IPC_INFO, SHM_INFO, SHM_STAT exists is to support
1288 * Linux binaries. If we see the call come through the FreeBSD ABI,
1289 * return an error back to the user since we do not to support this.
1290 */
1291 if (uap->cmd == IPC_INFO || uap->cmd == SHM_INFO ||
1292 uap->cmd == SHM_STAT)
1293 return (EINVAL);
1294
1295 /* IPC_SET needs to copyin the buffer before calling kern_shmctl */
1296 if (uap->cmd == IPC_SET) {
1297 if ((error = copyin(uap->buf, &old, sizeof(old))))
1298 goto done;
1299 ipcperm_old2new(&old.shm_perm, &buf.shm_perm);
1300 CP(old, buf, shm_segsz);
1301 CP(old, buf, shm_lpid);
1302 CP(old, buf, shm_cpid);
1303 CP(old, buf, shm_nattch);
1304 CP(old, buf, shm_atime);
1305 CP(old, buf, shm_dtime);
1306 CP(old, buf, shm_ctime);
1307 }
1308
1309 error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&buf, &bufsz);
1310 if (error)
1311 goto done;
1312
1313 /* Cases in which we need to copyout */
1314 switch (uap->cmd) {
1315 case IPC_STAT:
1316 ipcperm_new2old(&buf.shm_perm, &old.shm_perm);
1317 if (buf.shm_segsz > INT_MAX)
1318 old.shm_segsz = INT_MAX;
1319 else
1320 CP(buf, old, shm_segsz);
1321 CP(buf, old, shm_lpid);
1322 CP(buf, old, shm_cpid);
1323 if (buf.shm_nattch > SHRT_MAX)
1324 old.shm_nattch = SHRT_MAX;
1325 else
1326 CP(buf, old, shm_nattch);
1327 CP(buf, old, shm_atime);
1328 CP(buf, old, shm_dtime);
1329 CP(buf, old, shm_ctime);
1330 old.shm_internal = NULL;
1331 error = copyout(&old, uap->buf, sizeof(old));
1332 break;
1333 }
1334
1335done:
1336 if (error) {
1337 /* Invalidate the return value */
1338 td->td_retval[0] = -1;
1339 }
1340 return (error);
1341}
1342
1343#endif /* COMPAT_FREEBSD4 || COMPAT_FREEBSD5 || COMPAT_FREEBSD6 ||
1344 COMPAT_FREEBSD7 */
1345
1346static int
1347sysvshm_modload(struct module *module, int cmd, void *arg)
1348{
1349 int error = 0;
1350
1351 switch (cmd) {
1352 case MOD_LOAD:
1353 error = shminit();
1354 if (error != 0)
1355 shmunload();
1356 break;
1357 case MOD_UNLOAD:
1358 error = shmunload();
1359 break;
1360 case MOD_SHUTDOWN:
1361 break;
1362 default:
1363 error = EINVAL;
1364 break;
1365 }
1366 return (error);
1367}
1368
1369static moduledata_t sysvshm_mod = {
1370 "sysvshm",
1371 &sysvshm_modload,
1372 NULL
1373};
1374
1375DECLARE_MODULE(sysvshm, sysvshm_mod, SI_SUB_SYSV_SHM, SI_ORDER_FIRST);
1376MODULE_VERSION(sysvshm, 1);
|