Attachment #28926 for bug #48471

Lines 1-9 Link Here

(-)usr.bin/ipcs/Makefile (-5 / +2 lines)
1	# $FreeBSD: src/usr.bin/ipcs/Makefile,v 1.5 1999/08/28 01:02:15 peter Exp $	1	# $FreeBSD$
2		2
3	PROG= ipcs	3	PROG= ipcs
4	BINGRP= kmem	4	BINMODE= 555
5	BINMODE= 2555
6	DPADD+= ${LIBKVM}
7	LDADD+= -lkvm
8		5
9	.include <bsd.prog.mk>	6	.include <bsd.prog.mk>





#ifndef lint
static const char rcsid[] =
  "$FreeBSD$";
#endif /* not lint */

#include <err.h>
#include <fcntl.h>
#include <kvm.h>
#include <nlist.h>
#include <paths.h>
#include <stdio.h>

#include <sys/param.h>
#include <sys/time.h>
#include <sys/proc.h>
#include <sys/sysctl.h>
#define _KERNEL
#include <sys/ipc.h>
#include <sys/sem.h>


void	usage __P((void));

static struct nlist symbols[] = {
	{"_sema"},
#define X_SEMA		0
	{"_seminfo"},
#define X_SEMINFO	1
	{"_semu"},
#define X_SEMU		2
	{"_msginfo"},
#define X_MSGINFO	3
	{"_msqids"},
#define X_MSQIDS	4
	{"_shminfo"},
#define X_SHMINFO	5
	{"_shmsegs"},
#define X_SHMSEGS	6
	{NULL}
};

static kvm_t *kd;

char   *
fmt_perm(mode)
	u_short mode;

{
	int     display = SHMINFO | MSGINFO | SEMINFO;
	int     option = 0;
	size_t	size;
	int     i;

	while ((i = getopt(argc, argv, "MmQqSsab:c:optT")) != -1)
		switch (i) {
		case 'M':
			display = SHMTOTAL;

		case 'b':
			option |= BIGGEST;
			break;
		case 'C':
			core = optarg;
			break;
		case 'c':
			option |= CREATOR;
			break;
		case 'N':
			namelist = optarg;
			break;
		case 'o':
			option |= OUTSTANDING;
			break;

			usage();
		}

	if (display & (MSGINFO | MSGTOTAL)) {
		size = sizeof(struct msginfo);
		if (sysctlbyname("kern.ipc.msginfo", &msginfo, &size, NULL,
		    NULL) != 0) {
			fprintf(stderr, "SVID messages facility not configured "
			    "in the system\n");
			goto shm;
		}
		exit(1);

	switch (kvm_nlist(kd, symbols)) {
	case 0:
		break;
	case -1:
		errx(1, "unable to read kernel symbol table");
	default:
#ifdef notdef		/* they'll be told more civilly later */
		warnx("nlist failed");
		for (i = 0; symbols[i].n_name != NULL; i++)
			if (symbols[i].n_value == 0)
				warnx("symbol %s not found",
				    symbols[i].n_name);
		break;
#endif
	}

	if ((display & (MSGINFO | MSGTOTAL)) &&
	    kvm_read(kd, symbols[X_MSGINFO].n_value, &msginfo, sizeof(msginfo))== sizeof(msginfo)) {

		if (display & MSGTOTAL) {
			printf("msginfo:\n");
			printf("\tmsgmax: %6d\t(max characters in a message)\n",

			printf("\tmsgseg: %6d\t(# of message segments in system)\n\n",
			    msginfo.msgseg);
		}
		if (display & MSGINFO) {
			struct msqid_ds *xmsqids;

		if (display & MSGINFO) {
			size = sizeof(struct msqid_ds) * msginfo.msgmni;
			msqids = malloc(size);
			if (msqids == NULL) {
				fprintf(stderr, "No memory.\n");
				exit(1);
			}
			if (sysctlbyname("kern.ipc.msqids", msqids, &size, NULL,
			    NULL) != 0) {
				fprintf(stderr, "SVID messages facility not "
				    "configured in the system\n");
				free(msqids);
				goto shm;
			}

			printf("Message Queues:\n");
			printf("T     ID     KEY        MODE       OWNER    GROUP");

				printf("   STIME    RTIME    CTIME");
			printf("\n");
			for (i = 0; i < msginfo.msgmni; i += 1) {
				if (msqids[i].msg_qbytes != 0) {
					char    stime_buf[100], rtime_buf[100],
					        ctime_buf[100];
					struct msqid_ds *msqptr = &msqids[i];

					cvt_time(msqptr->msg_stime, stime_buf);
					cvt_time(msqptr->msg_rtime, rtime_buf);


					printf("q %6d %10d %s %8s %8s",
					    IXSEQ_TO_IPCID(i, msqptr->msg_perm),
					    (int)msqptr->msg_perm.key,
					    fmt_perm(msqptr->msg_perm.mode),
					    user_from_uid(msqptr->msg_perm.uid, 0),
					    group_from_gid(msqptr->msg_perm.gid, 0));

						    group_from_gid(msqptr->msg_perm.cgid, 0));

					if (option & OUTSTANDING)
						printf(" %6ld %6ld",
						    msqptr->msg_cbytes,
						    msqptr->msg_qnum);

					if (option & BIGGEST)
						printf(" %6ld",
						    msqptr->msg_qbytes);

					if (option & PID)

			}
			printf("\n");
		}
	}
shm:
	if (display & (SHMINFO | SHMTOTAL)) {
		size = sizeof(struct shminfo);
		if (sysctlbyname("kern.ipc.shminfo", &shminfo, &size, NULL,
		    NULL) != 0) {
			fprintf(stderr, "SVID shared memory facility not "
			    "configured in the system\n");
			goto sem;
		}
	if ((display & (SHMINFO | SHMTOTAL)) &&
	    kvm_read(kd, symbols[X_SHMINFO].n_value, &shminfo, sizeof(shminfo))) {
		if (display & SHMTOTAL) {
			printf("shminfo:\n");
			printf("\tshmmax: %7d\t(max shared memory segment size)\n",

			    shminfo.shmall);
		}
		if (display & SHMINFO) {
			size = sizeof(struct shmid_ds) * shminfo.shmmni;
			shmsegs = malloc(size);
			if (shmsegs == NULL) {
				fprintf(stderr, "No memory.\n");
				exit(1);
			}
			if (sysctlbyname("kern.ipc.shmsegs", shmsegs, &size, NULL,
			    NULL) != 0) {
				fprintf(stderr, "SVID shared memory facility "
				    "not configured in the system\n");
				free(shmsegs);
				goto sem;
			}

			printf("Shared Memory:\n");
			printf("T     ID     KEY        MODE       OWNER    GROUP");

				printf("   ATIME    DTIME    CTIME");
			printf("\n");
			for (i = 0; i < shminfo.shmmni; i += 1) {
				if (shmsegs[i].shm_perm.mode & 0x0800) {
					char    atime_buf[100], dtime_buf[100],
					        ctime_buf[100];
					struct shmid_ds *shmptr = &shmsegs[i];

					cvt_time(shmptr->shm_atime, atime_buf);
					cvt_time(shmptr->shm_dtime, dtime_buf);


					printf("m %6d %10d %s %8s %8s",
					    IXSEQ_TO_IPCID(i, shmptr->shm_perm),
					    (int)shmptr->shm_perm.key,
					    fmt_perm(shmptr->shm_perm.mode),
					    user_from_uid(shmptr->shm_perm.uid, 0),
					    group_from_gid(shmptr->shm_perm.gid, 0));

			}
			printf("\n");
		}
	}
sem:
	if (display & (SEMINFO | SEMTOTAL)) {
		size = sizeof(struct seminfo);
		if (sysctlbyname("kern.ipc.seminfo", &seminfo, &size, NULL,
		    NULL) != 0) {
			fprintf(stderr, "SVID semaphores facility not "
			    "configured in the system\n");
			exit(0);
		}
	if ((display & (SEMINFO | SEMTOTAL)) &&
	    kvm_read(kd, symbols[X_SEMINFO].n_value, &seminfo, sizeof(seminfo))) {
		struct semid_ds *xsema;

		if (display & SEMTOTAL) {
			printf("seminfo:\n");
			printf("\tsemmap: %6d\t(# of entries in semaphore map)\n",

			printf("\tsemaem: %6d\t(adjust on exit max value)\n\n",
			    seminfo.semaem);
		}

		if (display & SEMINFO) {
			size = sizeof(struct semid_ds) * seminfo.semmni;
			sema = malloc(size);
			if (sema == NULL) {
				fprintf(stderr, "No memory.\n");
				exit(1);
			}
			if (sysctlbyname("kern.ipc.sema", sema, &size, NULL,
			    NULL) != 0) {
				fprintf(stderr, "SVID semaphores facility not "
				    "configured in the system\n");
				free(sema);
				exit(0);
			}

			printf("Semaphores:\n");
			printf("T     ID     KEY        MODE       OWNER    GROUP");

				printf("   OTIME    CTIME");
			printf("\n");
			for (i = 0; i < seminfo.semmni; i += 1) {
				if ((sema[i].sem_perm.mode & SEM_ALLOC) != 0) {
					char    ctime_buf[100], otime_buf[100];
					struct semid_ds *semaptr = &sema[i];

					cvt_time(semaptr->sem_otime, otime_buf);
					cvt_time(semaptr->sem_ctime, ctime_buf);

					printf("s %6d %10d %s %8s %8s",
					    IXSEQ_TO_IPCID(i, semaptr->sem_perm),
					    (int)semaptr->sem_perm.key,
					    fmt_perm(semaptr->sem_perm.mode),
					    user_from_uid(semaptr->sem_perm.uid, 0),
					    group_from_gid(semaptr->sem_perm.gid, 0));


			printf("\n");
		}
	}
		if (display & (SEMINFO | SEMTOTAL)) {
			fprintf(stderr, "SVID semaphores facility not configured in the system\n");
		}
	kvm_close(kd);

	exit(0);
}

Return to bug 48471

Lines 27-38 Link Here

(-)usr.bin/ipcs/ipcs.c (-103 / +83 lines)
27		27
28	#ifndef lint	28	#ifndef lint
29	static const char rcsid[] =	29	static const char rcsid[] =
30	"$FreeBSD: src/usr.bin/ipcs/ipcs.c,v 1.12.2.3 2001/07/30 10:16:41 dd Exp $";	30	"$FreeBSD$";
31	#endif /* not lint */	31	#endif /* not lint */
32		32
33	#include <err.h>	33	#include <err.h>
34	#include <fcntl.h>	34	#include <fcntl.h>
35	#include <kvm.h>
36	#include <nlist.h>	35	#include <nlist.h>
37	#include <paths.h>	36	#include <paths.h>
38	#include <stdio.h>	37	#include <stdio.h>
Lines 44-49 Link Here
44	#include <sys/param.h>	43	#include <sys/param.h>
45	#include <sys/time.h>	44	#include <sys/time.h>
46	#include <sys/proc.h>	45	#include <sys/proc.h>
		46	#include <sys/sysctl.h>
47	#define _KERNEL	47	#define _KERNEL
48	#include <sys/ipc.h>	48	#include <sys/ipc.h>
49	#include <sys/sem.h>	49	#include <sys/sem.h>
Lines 59-84 Link Here
59		59
60	void usage __P((void));	60	void usage __P((void));
61		61
62	static struct nlist symbols[] = {
63	{"_sema"},
64	#define X_SEMA 0
65	{"_seminfo"},
66	#define X_SEMINFO 1
67	{"_semu"},
68	#define X_SEMU 2
69	{"_msginfo"},
70	#define X_MSGINFO 3
71	{"_msqids"},
72	#define X_MSQIDS 4
73	{"_shminfo"},
74	#define X_SHMINFO 5
75	{"_shmsegs"},
76	#define X_SHMSEGS 6
77	{NULL}
78	};
79
80	static kvm_t *kd;
81
82	char *	62	char *
83	fmt_perm(mode)	63	fmt_perm(mode)
84	u_short mode;	64	u_short mode;
Lines 135-144 Link Here
135	{	115	{
136	int display = SHMINFO \| MSGINFO \| SEMINFO;	116	int display = SHMINFO \| MSGINFO \| SEMINFO;
137	int option = 0;	117	int option = 0;
138	char core = NULL, namelist = NULL;	118	size_t size;
139	int i;	119	int i;
140		120
141	while ((i = getopt(argc, argv, "MmQqSsabC:cN:optT")) != -1)	121	while ((i = getopt(argc, argv, "MmQqSsab:c:optT")) != -1)
142	switch (i) {	122	switch (i) {
143	case 'M':	123	case 'M':
144	display = SHMTOTAL;	124	display = SHMTOTAL;
Lines 167-181 Link Here
167	case 'b':	147	case 'b':
168	option \|= BIGGEST;	148	option \|= BIGGEST;
169	break;	149	break;
170	case 'C':
171	core = optarg;
172	break;
173	case 'c':	150	case 'c':
174	option \|= CREATOR;	151	option \|= CREATOR;
175	break;	152	break;
176	case 'N':
177	namelist = optarg;
178	break;
179	case 'o':	153	case 'o':
180	option \|= OUTSTANDING;	154	option \|= OUTSTANDING;
181	break;	155	break;
Lines 189-223 Link Here
189	usage();	163	usage();
190	}	164	}
191		165
192	/*	166	if (display & (MSGINFO \| MSGTOTAL)) {
193	* Discard setgid privileges if not the running kernel so that bad	167	size = sizeof(struct msginfo);
194	* guys can't print interesting stuff from kernel memory.	168	if (sysctlbyname("kern.ipc.msginfo", &msginfo, &size, NULL,
195	*/	169	NULL) != 0) {
196	if (namelist != NULL \|\| core != NULL)	170	fprintf(stderr, "SVID messages facility not configured "
197	setgid(getgid());	171	"in the system\n");
198		172	goto shm;
199	if ((kd = kvm_open(namelist, core, NULL, O_RDONLY, "ipcs")) == NULL)	173	}
200	exit(1);
201
202	switch (kvm_nlist(kd, symbols)) {
203	case 0:
204	break;
205	case -1:
206	errx(1, "unable to read kernel symbol table");
207	default:
208	#ifdef notdef /* they'll be told more civilly later */
209	warnx("nlist failed");
210	for (i = 0; symbols[i].n_name != NULL; i++)
211	if (symbols[i].n_value == 0)
212	warnx("symbol %s not found",
213	symbols[i].n_name);
214	break;
215	#endif
216	}
217
218	if ((display & (MSGINFO \| MSGTOTAL)) &&
219	kvm_read(kd, symbols[X_MSGINFO].n_value, &msginfo, sizeof(msginfo))== sizeof(msginfo)) {
220
221	if (display & MSGTOTAL) {	174	if (display & MSGTOTAL) {
222	printf("msginfo:\n");	175	printf("msginfo:\n");
223	printf("\tmsgmax: %6d\t(max characters in a message)\n",	176	printf("\tmsgmax: %6d\t(max characters in a message)\n",
Lines 233-244 Link Here
233	printf("\tmsgseg: %6d\t(# of message segments in system)\n\n",	186	printf("\tmsgseg: %6d\t(# of message segments in system)\n\n",
234	msginfo.msgseg);	187	msginfo.msgseg);
235	}	188	}
236	if (display & MSGINFO) {
237	struct msqid_ds *xmsqids;
238		189
239	kvm_read(kd, symbols[X_MSQIDS].n_value, &msqids, sizeof(msqids));	190	if (display & MSGINFO) {
240	xmsqids = malloc(sizeof(struct msqid_ds) * msginfo.msgmni);	191	size = sizeof(struct msqid_ds) * msginfo.msgmni;
241	kvm_read(kd, (u_long) msqids, xmsqids, sizeof(struct msqid_ds) * msginfo.msgmni);	192	msqids = malloc(size);
		193	if (msqids == NULL) {
		194	fprintf(stderr, "No memory.\n");
		195	exit(1);
		196	}
		197	if (sysctlbyname("kern.ipc.msqids", msqids, &size, NULL,
		198	NULL) != 0) {
		199	fprintf(stderr, "SVID messages facility not "
		200	"configured in the system\n");
		201	free(msqids);
		202	goto shm;
		203	}
242		204
243	printf("Message Queues:\n");	205	printf("Message Queues:\n");
244	printf("T ID KEY MODE OWNER GROUP");	206	printf("T ID KEY MODE OWNER GROUP");
Lines 254-263 Link Here
254	printf(" STIME RTIME CTIME");	216	printf(" STIME RTIME CTIME");
255	printf("\n");	217	printf("\n");
256	for (i = 0; i < msginfo.msgmni; i += 1) {	218	for (i = 0; i < msginfo.msgmni; i += 1) {
257	if (xmsqids[i].msg_qbytes != 0) {	219	if (msqids[i].msg_qbytes != 0) {
258	char stime_buf[100], rtime_buf[100],	220	char stime_buf[100], rtime_buf[100],
259	ctime_buf[100];	221	ctime_buf[100];
260	struct msqid_ds *msqptr = &xmsqids[i];	222	struct msqid_ds *msqptr = &msqids[i];
261		223
262	cvt_time(msqptr->msg_stime, stime_buf);	224	cvt_time(msqptr->msg_stime, stime_buf);
263	cvt_time(msqptr->msg_rtime, rtime_buf);	225	cvt_time(msqptr->msg_rtime, rtime_buf);
Lines 265-271 Link Here
265		227
266	printf("q %6d %10d %s %8s %8s",	228	printf("q %6d %10d %s %8s %8s",
267	IXSEQ_TO_IPCID(i, msqptr->msg_perm),	229	IXSEQ_TO_IPCID(i, msqptr->msg_perm),
268	msqptr->msg_perm.key,	230	(int)msqptr->msg_perm.key,
269	fmt_perm(msqptr->msg_perm.mode),	231	fmt_perm(msqptr->msg_perm.mode),
270	user_from_uid(msqptr->msg_perm.uid, 0),	232	user_from_uid(msqptr->msg_perm.uid, 0),
271	group_from_gid(msqptr->msg_perm.gid, 0));	233	group_from_gid(msqptr->msg_perm.gid, 0));
Lines 276-287 Link Here
276	group_from_gid(msqptr->msg_perm.cgid, 0));	238	group_from_gid(msqptr->msg_perm.cgid, 0));
277		239
278	if (option & OUTSTANDING)	240	if (option & OUTSTANDING)
279	printf(" %6d %6d",	241	printf(" %6ld %6ld",
280	msqptr->msg_cbytes,	242	msqptr->msg_cbytes,
281	msqptr->msg_qnum);	243	msqptr->msg_qnum);
282		244
283	if (option & BIGGEST)	245	if (option & BIGGEST)
284	printf(" %6d",	246	printf(" %6ld",
285	msqptr->msg_qbytes);	247	msqptr->msg_qbytes);
286		248
287	if (option & PID)	249	if (option & PID)
Lines 300-312 Link Here
300	}	262	}
301	printf("\n");	263	printf("\n");
302	}	264	}
303	} else	265	}
304	if (display & (MSGINFO \| MSGTOTAL)) {	266	shm:
305	fprintf(stderr,	267	if (display & (SHMINFO \| SHMTOTAL)) {
306	"SVID messages facility not configured in the system\n");	268	size = sizeof(struct shminfo);
		269	if (sysctlbyname("kern.ipc.shminfo", &shminfo, &size, NULL,
		270	NULL) != 0) {
		271	fprintf(stderr, "SVID shared memory facility not "
		272	"configured in the system\n");
		273	goto sem;
307	}	274	}
308	if ((display & (SHMINFO \| SHMTOTAL)) &&
309	kvm_read(kd, symbols[X_SHMINFO].n_value, &shminfo, sizeof(shminfo))) {
310	if (display & SHMTOTAL) {	275	if (display & SHMTOTAL) {
311	printf("shminfo:\n");	276	printf("shminfo:\n");
312	printf("\tshmmax: %7d\t(max shared memory segment size)\n",	277	printf("\tshmmax: %7d\t(max shared memory segment size)\n",
Lines 321-332 Link Here
321	shminfo.shmall);	286	shminfo.shmall);
322	}	287	}
323	if (display & SHMINFO) {	288	if (display & SHMINFO) {
324	struct shmid_ds *xshmids;	289	size = sizeof(struct shmid_ds) * shminfo.shmmni;
325		290	shmsegs = malloc(size);
326	kvm_read(kd, symbols[X_SHMSEGS].n_value, &shmsegs, sizeof(shmsegs));	291	if (shmsegs == NULL) {
327	xshmids = malloc(sizeof(struct shmid_ds) * shminfo.shmmni);	292	fprintf(stderr, "No memory.\n");
328	kvm_read(kd, (u_long) shmsegs, xshmids, sizeof(struct shmid_ds) *	293	exit(1);
329	shminfo.shmmni);	294	}
		295	if (sysctlbyname("kern.ipc.shmsegs", shmsegs, &size, NULL,
		296	NULL) != 0) {
		297	fprintf(stderr, "SVID shared memory facility "
		298	"not configured in the system\n");
		299	free(shmsegs);
		300	goto sem;
		301	}
330		302
331	printf("Shared Memory:\n");	303	printf("Shared Memory:\n");
332	printf("T ID KEY MODE OWNER GROUP");	304	printf("T ID KEY MODE OWNER GROUP");
Lines 342-351 Link Here
342	printf(" ATIME DTIME CTIME");	314	printf(" ATIME DTIME CTIME");
343	printf("\n");	315	printf("\n");
344	for (i = 0; i < shminfo.shmmni; i += 1) {	316	for (i = 0; i < shminfo.shmmni; i += 1) {
345	if (xshmids[i].shm_perm.mode & 0x0800) {	317	if (shmsegs[i].shm_perm.mode & 0x0800) {
346	char atime_buf[100], dtime_buf[100],	318	char atime_buf[100], dtime_buf[100],
347	ctime_buf[100];	319	ctime_buf[100];
348	struct shmid_ds *shmptr = &xshmids[i];	320	struct shmid_ds *shmptr = &shmsegs[i];
349		321
350	cvt_time(shmptr->shm_atime, atime_buf);	322	cvt_time(shmptr->shm_atime, atime_buf);
351	cvt_time(shmptr->shm_dtime, dtime_buf);	323	cvt_time(shmptr->shm_dtime, dtime_buf);
Lines 353-359 Link Here
353		325
354	printf("m %6d %10d %s %8s %8s",	326	printf("m %6d %10d %s %8s %8s",
355	IXSEQ_TO_IPCID(i, shmptr->shm_perm),	327	IXSEQ_TO_IPCID(i, shmptr->shm_perm),
356	shmptr->shm_perm.key,	328	(int)shmptr->shm_perm.key,
357	fmt_perm(shmptr->shm_perm.mode),	329	fmt_perm(shmptr->shm_perm.mode),
358	user_from_uid(shmptr->shm_perm.uid, 0),	330	user_from_uid(shmptr->shm_perm.uid, 0),
359	group_from_gid(shmptr->shm_perm.gid, 0));	331	group_from_gid(shmptr->shm_perm.gid, 0));
Lines 387-401 Link Here
387	}	359	}
388	printf("\n");	360	printf("\n");
389	}	361	}
390	} else	362	}
391	if (display & (SHMINFO \| SHMTOTAL)) {	363	sem:
392	fprintf(stderr,	364	if (display & (SEMINFO \| SEMTOTAL)) {
393	"SVID shared memory facility not configured in the system\n");	365	size = sizeof(struct seminfo);
		366	if (sysctlbyname("kern.ipc.seminfo", &seminfo, &size, NULL,
		367	NULL) != 0) {
		368	fprintf(stderr, "SVID semaphores facility not "
		369	"configured in the system\n");
		370	exit(0);
394	}	371	}
395	if ((display & (SEMINFO \| SEMTOTAL)) &&
396	kvm_read(kd, symbols[X_SEMINFO].n_value, &seminfo, sizeof(seminfo))) {
397	struct semid_ds *xsema;
398
399	if (display & SEMTOTAL) {	372	if (display & SEMTOTAL) {
400	printf("seminfo:\n");	373	printf("seminfo:\n");
401	printf("\tsemmap: %6d\t(# of entries in semaphore map)\n",	374	printf("\tsemmap: %6d\t(# of entries in semaphore map)\n",
Lines 419-428 Link Here
419	printf("\tsemaem: %6d\t(adjust on exit max value)\n\n",	392	printf("\tsemaem: %6d\t(adjust on exit max value)\n\n",
420	seminfo.semaem);	393	seminfo.semaem);
421	}	394	}
		395
422	if (display & SEMINFO) {	396	if (display & SEMINFO) {
423	kvm_read(kd, symbols[X_SEMA].n_value, &sema, sizeof(sema));	397	size = sizeof(struct semid_ds) * seminfo.semmni;
424	xsema = malloc(sizeof(struct semid_ds) * seminfo.semmni);	398	sema = malloc(size);
425	kvm_read(kd, (u_long) sema, xsema, sizeof(struct semid_ds) * seminfo.semmni);	399	if (sema == NULL) {
		400	fprintf(stderr, "No memory.\n");
		401	exit(1);
		402	}
		403	if (sysctlbyname("kern.ipc.sema", sema, &size, NULL,
		404	NULL) != 0) {
		405	fprintf(stderr, "SVID semaphores facility not "
		406	"configured in the system\n");
		407	free(sema);
		408	exit(0);
		409	}
426		410
427	printf("Semaphores:\n");	411	printf("Semaphores:\n");
428	printf("T ID KEY MODE OWNER GROUP");	412	printf("T ID KEY MODE OWNER GROUP");
Lines 434-449 Link Here
434	printf(" OTIME CTIME");	418	printf(" OTIME CTIME");
435	printf("\n");	419	printf("\n");
436	for (i = 0; i < seminfo.semmni; i += 1) {	420	for (i = 0; i < seminfo.semmni; i += 1) {
437	if ((xsema[i].sem_perm.mode & SEM_ALLOC) != 0) {	421	if ((sema[i].sem_perm.mode & SEM_ALLOC) != 0) {
438	char ctime_buf[100], otime_buf[100];	422	char ctime_buf[100], otime_buf[100];
439	struct semid_ds *semaptr = &xsema[i];	423	struct semid_ds *semaptr = &sema[i];
440		424
441	cvt_time(semaptr->sem_otime, otime_buf);	425	cvt_time(semaptr->sem_otime, otime_buf);
442	cvt_time(semaptr->sem_ctime, ctime_buf);	426	cvt_time(semaptr->sem_ctime, ctime_buf);
443		427
444	printf("s %6d %10d %s %8s %8s",	428	printf("s %6d %10d %s %8s %8s",
445	IXSEQ_TO_IPCID(i, semaptr->sem_perm),	429	IXSEQ_TO_IPCID(i, semaptr->sem_perm),
446	semaptr->sem_perm.key,	430	(int)semaptr->sem_perm.key,
447	fmt_perm(semaptr->sem_perm.mode),	431	fmt_perm(semaptr->sem_perm.mode),
448	user_from_uid(semaptr->sem_perm.uid, 0),	432	user_from_uid(semaptr->sem_perm.uid, 0),
449	group_from_gid(semaptr->sem_perm.gid, 0));	433	group_from_gid(semaptr->sem_perm.gid, 0));
Lines 468-478 Link Here
468		452
469	printf("\n");	453	printf("\n");
470	}	454	}
471	} else	455	}
472	if (display & (SEMINFO \| SEMTOTAL)) {
473	fprintf(stderr, "SVID semaphores facility not configured in the system\n");
474	}
475	kvm_close(kd);
476		456
477	exit(0);	457	exit(0);
478	}	458	}