/* ipcs.c - provide information on ipc facilities

 *

 * Copyright (C) 2012 FUJITSU LIMITED

 * Auther: Qiao Nuohan <qiaonuohan@cn.fujitsu.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include "defs.h"    /* From the crash source top-level directory */

#define SPECIFIED_NOTHING 0x0

#define SPECIFIED_ID      0x1

#define SPECIFIED_ADDR    0x2

#define IPCS_INIT  0x1

#define IDR_ORIG   0x2

#define IDR_RADIX  0x4

#define IDR_XARRAY 0x8

#define MAX_ID_SHIFT (sizeof(int)*8 - 1)

#define MAX_ID_BIT (1U << MAX_ID_SHIFT)

#define MAX_ID_MASK (MAX_ID_BIT - 1)

#define SHM_DEST   01000

#define SHM_LOCKED 02000

struct shm_info {

	ulong shmid_kernel;

	int key;

	int shmid;

	ulong rss;

	ulong swap;

	unsigned int uid;

	unsigned int perms;

	ulong bytes;

	ulong nattch;

	ulong shm_inode;

	int deleted;

};

struct sem_info {

	ulong sem_array;

	int key;

	int semid;

	unsigned int uid;

	unsigned int perms;

	ulong nsems;

	int deleted;

};

struct msg_info {

	ulong msg_queue;

	int key;

	int msgid;

	unsigned int uid;

	unsigned int perms;

	ulong bytes;

	ulong messages;

	int deleted;

};

struct ipcs_table {

	int idr_bits;

	ulong init_flags;

	ulong hugetlbfs_f_op_addr;

	ulong shm_f_op_addr;

	ulong shm_f_op_huge_addr;

	int use_shm_f_op;

	int seq_multiplier;

	int cnt;

	struct list_pair *lp;

};

/*

 * function declaration

 */

static int dump_shared_memory(int, ulong, int, ulong);

static int dump_semaphore_arrays(int, ulong, int, ulong);

static int dump_message_queues(int, ulong, int, ulong);

static int ipc_search_idr(ulong, int, ulong, int (*)(ulong, int, ulong, int, int), int);

static int ipc_search_array(ulong, int, ulong, int (*)(ulong, int, ulong, int, int), int);

static int dump_shm_info(ulong, int, ulong, int, int);

static int dump_sem_info(ulong, int, ulong, int, int);

static int dump_msg_info(ulong, int, ulong, int, int);

static void get_shm_info(struct shm_info *, ulong, int);

static void get_sem_info(struct sem_info *, ulong, int);

static void get_msg_info(struct msg_info *, ulong, int);

static void add_rss_swap(ulong, int, ulong *, ulong *);

static int is_file_hugepages(ulong);

static void gather_radix_tree_entries(ulong);

static void gather_xarray_entries(ulong);

/*

 * global data

 */

static struct ipcs_table ipcs_table = { 0 };

void

ipcs_init(void)

{

	if (ipcs_table.init_flags & IPCS_INIT) {

		return;

	}

	ipcs_table.init_flags |= IPCS_INIT;

	MEMBER_OFFSET_INIT(file_f_op, "file", "f_op");

	MEMBER_OFFSET_INIT(file_private_data, "file", "private_data");

	MEMBER_OFFSET_INIT(hstate_order, "hstate", "order");

	MEMBER_OFFSET_INIT(hugetlbfs_sb_info_hstate, "hugetlbfs_sb_info",

			"hstate");

	MEMBER_OFFSET_INIT(idr_layers, "idr", "layers");

	MEMBER_OFFSET_INIT(idr_layer_layer, "idr_layer", "layer");

	MEMBER_OFFSET_INIT(idr_layer_ary, "idr_layer", "ary");

	MEMBER_OFFSET_INIT(idr_top, "idr", "top");

	MEMBER_OFFSET_INIT(idr_cur, "idr", "cur");

	MEMBER_OFFSET_INIT(ipc_id_ary_p, "ipc_id_ary", "p");

	MEMBER_OFFSET_INIT(ipc_ids_entries, "ipc_ids", "entries");

	MEMBER_OFFSET_INIT(ipc_ids_max_id, "ipc_ids", "max_id");

	MEMBER_OFFSET_INIT(ipc_ids_in_use, "ipc_ids", "in_use");

	MEMBER_OFFSET_INIT(ipc_ids_ipcs_idr, "ipc_ids", "ipcs_idr");

	MEMBER_OFFSET_INIT(ipc_namespace_ids, "ipc_namespace", "ids");

	MEMBER_OFFSET_INIT(kern_ipc_perm_key, "kern_ipc_perm", "key");

	MEMBER_OFFSET_INIT(kern_ipc_perm_id, "kern_ipc_perm", "id");

	MEMBER_OFFSET_INIT(kern_ipc_perm_uid, "kern_ipc_perm", "uid");

	MEMBER_OFFSET_INIT(kern_ipc_perm_mode, "kern_ipc_perm", "mode");

	MEMBER_OFFSET_INIT(kern_ipc_perm_deleted, "kern_ipc_perm",

			"deleted");

	MEMBER_OFFSET_INIT(kern_ipc_perm_seq, "kern_ipc_perm", "seq");

	MEMBER_OFFSET_INIT(nsproxy_ipc_ns, "nsproxy", "ipc_ns");

	MEMBER_OFFSET_INIT(shmem_inode_info_vfs_inode, "shmem_inode_info",

			"vfs_inode");

	MEMBER_OFFSET_INIT(shmem_inode_info_swapped, "shmem_inode_info",

			"swapped");

	if (INVALID_MEMBER(shmem_inode_info_swapped))

		ANON_MEMBER_OFFSET_INIT(shmem_inode_info_swapped,

				"shmem_inode_info", "swapped");

	MEMBER_OFFSET_INIT(shm_file_data_file, "shm_file_data", "file");

	MEMBER_OFFSET_INIT(shmid_kernel_shm_perm, "shmid_kernel",

			"shm_perm");

	MEMBER_OFFSET_INIT(shmid_kernel_shm_segsz, "shmid_kernel",

			"shm_segsz");

	MEMBER_OFFSET_INIT(shmid_kernel_shm_nattch, "shmid_kernel",

			"shm_nattch");

	MEMBER_OFFSET_INIT(shmid_kernel_shm_file, "shmid_kernel",

			"shm_file");

	MEMBER_OFFSET_INIT(shmid_kernel_id, "shmid_kernel", "id");

	MEMBER_OFFSET_INIT(sem_array_sem_perm, "sem_array", "sem_perm");

	MEMBER_OFFSET_INIT(sem_array_sem_id, "sem_array", "sem_id");

	MEMBER_OFFSET_INIT(sem_array_sem_nsems, "sem_array", "sem_nsems");

	MEMBER_OFFSET_INIT(msg_queue_q_perm, "msg_queue", "q_perm");

	MEMBER_OFFSET_INIT(msg_queue_q_id, "msg_queue", "q_id");

	MEMBER_OFFSET_INIT(msg_queue_q_cbytes, "msg_queue", "q_cbytes");

	MEMBER_OFFSET_INIT(msg_queue_q_qnum, "msg_queue", "q_qnum");

	MEMBER_OFFSET_INIT(super_block_s_fs_info, "super_block",

			"s_fs_info");

	/*

	 * struct size

	 */

	STRUCT_SIZE_INIT(ipc_ids, "ipc_ids");

	STRUCT_SIZE_INIT(shmid_kernel, "shmid_kernel");

	STRUCT_SIZE_INIT(sem_array, "sem_array");

	STRUCT_SIZE_INIT(msg_queue, "msg_queue");

	STRUCT_SIZE_INIT(hstate, "hstate");

	if (symbol_exists("hugetlbfs_file_operations"))

		ipcs_table.hugetlbfs_f_op_addr =

			symbol_value("hugetlbfs_file_operations");

	if (symbol_exists("is_file_shm_hugepages")) {

		ipcs_table.use_shm_f_op = TRUE;

		ipcs_table.shm_f_op_addr =

			symbol_value("shm_file_operations");

		if (symbol_exists("shm_file_operations_huge")) {

			ipcs_table.shm_f_op_huge_addr =

				symbol_value("shm_file_operations_huge");

		} else {

			ipcs_table.shm_f_op_huge_addr = -1;

		}

	} else {

		ipcs_table.use_shm_f_op = FALSE;

		ipcs_table.shm_f_op_addr = -1;

		ipcs_table.shm_f_op_huge_addr = -1;

	}

	if (VALID_MEMBER(idr_layer_ary) && 

	    get_array_length("idr_layer.ary", NULL, 0) > 64)

		ipcs_table.idr_bits = 8;

	else if (BITS32())

		ipcs_table.idr_bits = 5;

	else if (BITS64())

		ipcs_table.idr_bits = 6;

	else

		error(FATAL, "machdep->bits is not 32 or 64");

	if (VALID_MEMBER(idr_idr_rt)) {

		if (STREQ(MEMBER_TYPE_NAME("idr", "idr_rt"), "xarray"))

			ipcs_table.init_flags |= IDR_XARRAY;

		else {

			if (MEMBER_EXISTS("radix_tree_root", "rnode"))

				ipcs_table.init_flags |= IDR_RADIX;

			else if (MEMBER_EXISTS("radix_tree_root", "xa_head"))

				ipcs_table.init_flags |= IDR_XARRAY;

		}

	} else

		ipcs_table.init_flags |= IDR_ORIG;

	ipcs_table.seq_multiplier = 32768;

}

/* 

 *  Arguments are passed to the command functions in the global args[argcnt]

 *  array.  See getopt(3) for info on dash arguments.  Check out defs.h and

 *  other crash commands for usage of the myriad of utility routines available

 *  to accomplish what your task.

 */

void

cmd_ipcs(void)

{

	int specified;

	char *specified_value[MAXARGS];

	int value_index;

	int c;

	int shm, sem, msg, verbose;

	int i;

	ulong value, task;

	int found;

	struct task_context *tc;

	char buf[BUFSIZE];

	value_index = 0;

	specified = SPECIFIED_NOTHING;

	shm = 0;

	sem = 0;

	msg = 0;

	verbose = 0;

	tc = NULL;

	while ((c = getopt(argcnt, args, "smMqn:")) != EOF) {

		switch(c) {

			case 's':

				sem = 1;

				break;

			case 'm':

				shm = 1;

				break;

			case 'M':

				shm = 1;

				verbose = 1;

				break;

			case 'q':

				msg = 1;

				break;

			case 'n':

				switch (str_to_context(optarg, &value, &tc)) {

		        	case STR_PID:

                        	case STR_TASK:

                               		break;

                        	case STR_INVALID:

                               		error(FATAL, "invalid task or pid value: %s\n",

                                        	optarg);

                               		break;

				}

				break;

			default:

				cmd_usage(pc->curcmd, SYNOPSIS);;

				return;

		}

	}

	while (args[optind]) {

		if (value_index >= MAXARGS)

			error(FATAL, "too many id/member specified\n");

		specified |= SPECIFIED_ID | SPECIFIED_ADDR;

		specified_value[value_index] = args[optind];

		stol(args[optind], FAULT_ON_ERROR, NULL);

		optind++;

		value_index++;

	}

	if (THIS_KERNEL_VERSION < LINUX(2,6,0))

		command_not_supported();

	ipcs_init();

	if (!shm && !sem && !msg)

		shm = sem = msg = 1;

	task = tc ? tc->task : pid_to_task(0);

	if (!value_index) {

		if (shm)

			dump_shared_memory(specified, 0, verbose, task);

		if (sem)

			dump_semaphore_arrays(specified, 0, 0, task);

		if (msg)

			dump_message_queues(specified, 0, 0, task);

	} else {

		open_tmpfile();

		i = 0;

		while (i < value_index) {

			found = 0;

			value = stol(specified_value[i], FAULT_ON_ERROR, NULL);

			if (shm)

				found += dump_shared_memory(specified,

					value, verbose, task);

			if (sem)

				found += dump_semaphore_arrays(specified,

					value, 0, task);

			if (msg)

				found += dump_message_queues(specified,

					value, 0, task);

			if (!found)

				fprintf(pc->saved_fp, "invalid id or address: %s\n\n",

					specified_value[i]);

			i++;

		}

		fflush(fp);

		rewind(fp);

		while (fgets(buf, BUFSIZE, fp))

			fprintf(pc->saved_fp, "%s", buf);

		close_tmpfile();

	}

}

static int

dump_shared_memory(int specified, ulong specified_value, int verbose, ulong task)

{

	ulong nsproxy_p, ipc_ns_p;

	ulong ipc_ids_p;

	int (*ipc_search)(ulong, int, ulong, int (*)(ulong, int, ulong, int, int), int);

	int (*dump_shm)(ulong, int, ulong, int, int);

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	char buf6[BUFSIZE];

	char buf7[BUFSIZE];

	if (!verbose && specified == SPECIFIED_NOTHING) {

		fprintf(fp, "%s %s %s %s %s %s %s %s\n",

			mkstring(buf0, VADDR_PRLEN<=12?12:VADDR_PRLEN,

				LJUST, "SHMID_KERNEL"),

			mkstring(buf1, 8, LJUST, "KEY"),

			mkstring(buf2, 10, LJUST, "SHMID"),

			mkstring(buf3, 5, LJUST, "UID"),

			mkstring(buf4, 5, LJUST, "PERMS"),

			mkstring(buf5, 10, LJUST, "BYTES"),

			mkstring(buf6, 6, LJUST, "NATTCH"),

			mkstring(buf7, 6, LJUST, "STATUS"));

	}

	dump_shm = dump_shm_info;

	if (VALID_MEMBER(kern_ipc_perm_id)) {

		ipc_search = ipc_search_idr;

	} else {

		ipc_search = ipc_search_array;

	}

	if (symbol_exists("shm_ids")) {

		ipc_ids_p = symbol_value("shm_ids");

	} else {

		readmem(task + OFFSET(task_struct_nsproxy), KVADDR,

			&nsproxy_p, sizeof(ulong), "task_struct.nsproxy",

			FAULT_ON_ERROR);

		if (!readmem(nsproxy_p + OFFSET(nsproxy_ipc_ns), KVADDR,

			&ipc_ns_p, sizeof(ulong), "nsproxy.ipc_ns",

			RETURN_ON_ERROR|QUIET))

			error(FATAL,

				"cannot determine ipc_namespace location!\n");

		if (MEMBER_SIZE("ipc_namespace","ids") == sizeof(ulong) * 3)

			readmem(ipc_ns_p + OFFSET(ipc_namespace_ids) +

				sizeof(ulong) * 2, KVADDR, &ipc_ids_p,

				sizeof(ulong), "ipc_namespace.ids[2]",

				FAULT_ON_ERROR);

		else

			ipc_ids_p = ipc_ns_p + OFFSET(ipc_namespace_ids) +

				2 * SIZE(ipc_ids);

	}

	if (ipc_search(ipc_ids_p, specified, specified_value, dump_shm, verbose)) {

		return 1;

	} else {

		if (verbose && specified == SPECIFIED_NOTHING) {

			fprintf(fp, "%s %s %s %s %s %s %s %s\n",

				mkstring(buf0, VADDR_PRLEN<=12?12:VADDR_PRLEN,

					LJUST, "SHMID_KERNEL"),

				mkstring(buf1, 8, LJUST, "KEY"),

				mkstring(buf2, 10, LJUST, "SHMID"),

				mkstring(buf3, 5, LJUST, "UID"),

				mkstring(buf4, 5, LJUST, "PERMS"),

				mkstring(buf5, 10, LJUST, "BYTES"),

				mkstring(buf6, 6, LJUST, "NATTCH"),

				mkstring(buf7, 6, LJUST, "STATUS"));

			fprintf(fp, "(none allocated)\n\n");

		}

		return 0;

	}

}

static int

dump_semaphore_arrays(int specified, ulong specified_value, int verbose, ulong task)

{

	ulong nsproxy_p, ipc_ns_p;

	ulong ipc_ids_p;

	int (*ipc_search)(ulong, int, ulong, int (*)(ulong, int, ulong, int, int), int);

	int (*dump_sem)(ulong, int, ulong, int, int);

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	if (specified == SPECIFIED_NOTHING) {

		fprintf(fp, "%s %s %s %s %s %s\n",

			mkstring(buf0, VADDR_PRLEN<=10?10:VADDR_PRLEN,

				LJUST, "SEM_ARRAY"),

			mkstring(buf1, 8, LJUST, "KEY"),

			mkstring(buf2, 10, LJUST, "SEMID"),

			mkstring(buf3, 5, LJUST, "UID"),

			mkstring(buf4, 5, LJUST, "PERMS"),

			mkstring(buf5, 10, LJUST, "NSEMS"));

	}

	dump_sem = dump_sem_info;

	if (VALID_MEMBER(kern_ipc_perm_id)) {

		ipc_search = ipc_search_idr;

	} else {

		ipc_search = ipc_search_array;

	}

	if (symbol_exists("sem_ids")) {

		ipc_ids_p = symbol_value("sem_ids");

	} else {

		readmem(task + OFFSET(task_struct_nsproxy), KVADDR,

			&nsproxy_p, sizeof(ulong), "task_struct.nsproxy",

			FAULT_ON_ERROR);

		if (!readmem(nsproxy_p + OFFSET(nsproxy_ipc_ns), KVADDR,

			&ipc_ns_p, sizeof(ulong), "nsproxy.ipc_ns",

			FAULT_ON_ERROR|QUIET))

			error(FATAL,

				"cannot determine ipc_namespace location!\n");

		if (MEMBER_SIZE("ipc_namespace","ids") == sizeof(ulong) * 3)

			readmem(ipc_ns_p + OFFSET(ipc_namespace_ids),

				KVADDR,	&ipc_ids_p, sizeof(ulong),

				"ipc_namespace.ids[2]",	FAULT_ON_ERROR);

		else

			ipc_ids_p = ipc_ns_p + OFFSET(ipc_namespace_ids);

	}

	return ipc_search(ipc_ids_p, specified, specified_value, dump_sem, verbose);

}

static int

dump_message_queues(int specified, ulong specified_value, int verbose, ulong task)

{

	ulong nsproxy_p, ipc_ns_p;

	ulong ipc_ids_p;

	int (*ipc_search)(ulong, int, ulong, int (*)(ulong, int, ulong, int, int), int);

	int (*dump_msg)(ulong, int, ulong, int, int);

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	char buf6[BUFSIZE];

	if (specified == SPECIFIED_NOTHING) {

		fprintf(fp, "%s %s %s %s %s %s %s\n",

			mkstring(buf0, VADDR_PRLEN<=10?10:VADDR_PRLEN,

				LJUST, "MSG_QUEUE"),

			mkstring(buf1, 8, LJUST, "KEY"),

			mkstring(buf2, 10, LJUST, "MSQID"),

			mkstring(buf3, 5, LJUST, "UID"),

			mkstring(buf4, 5, LJUST, "PERMS"),

			mkstring(buf5, 12, LJUST, "USED-BYTES"),

			mkstring(buf6, 12, LJUST, "MESSAGES"));

	}

	dump_msg = dump_msg_info;

	if (VALID_MEMBER(kern_ipc_perm_id)) {

		ipc_search = ipc_search_idr;

	} else {

		ipc_search = ipc_search_array;

	}

	if (symbol_exists("msg_ids")) {

		ipc_ids_p = symbol_value("msg_ids");

	} else {

		readmem(task + OFFSET(task_struct_nsproxy), KVADDR,

			&nsproxy_p, sizeof(ulong), "task_struct.nsproxy",

			FAULT_ON_ERROR);

		if (!readmem(nsproxy_p + OFFSET(nsproxy_ipc_ns), KVADDR,

			&ipc_ns_p, sizeof(ulong), "nsproxy.ipc_ns",

			FAULT_ON_ERROR|QUIET))

			error(FATAL,

				"cannot determine ipc_namespace location!\n");

		if (MEMBER_SIZE("ipc_namespace","ids") == sizeof(ulong) * 3)

			readmem(ipc_ns_p + OFFSET(ipc_namespace_ids) +

				sizeof(ulong), KVADDR, &ipc_ids_p,

				sizeof(ulong), "ipc_namespace.ids[2]",

				FAULT_ON_ERROR);

		else

			ipc_ids_p = ipc_ns_p + OFFSET(ipc_namespace_ids) +

				SIZE(ipc_ids);

	}

	return ipc_search(ipc_ids_p, specified, specified_value, dump_msg, verbose);

}

/*

 * if shared memory information is stored in an array, use this function.

 */

static int

ipc_search_array(ulong ipc_ids_p, int specified, ulong specified_value, int (*fn)(ulong, int, ulong, int, int), int verbose)

{

	ulong entries_p;

	int max_id, i;

	ulong *array;

	int found = 0;

	int allocated = 0;

	readmem(ipc_ids_p + OFFSET(ipc_ids_entries), KVADDR, &entries_p,

		sizeof(ulong), "ipc_ids.entries", FAULT_ON_ERROR);

	readmem(ipc_ids_p + OFFSET(ipc_ids_max_id), KVADDR, &max_id,

		sizeof(int), "ipc_ids.max_id", FAULT_ON_ERROR);

	if (max_id < 0) {

		if (specified == SPECIFIED_NOTHING && !verbose)

			fprintf(fp, "(none allocated)\n\n");

		return 0;

	}

	array = (ulong *)GETBUF(sizeof(ulong *) * (max_id + 1));

	if (VALID_MEMBER(ipc_id_ary_p))

		readmem(entries_p + OFFSET(ipc_id_ary_p), KVADDR, array,

			sizeof(ulong *) * (max_id + 1), "ipc_id_ary.p",

			FAULT_ON_ERROR);

	else

		readmem(entries_p, KVADDR, array, sizeof(ulong *)*(max_id+1),

				"ipc_id array", FAULT_ON_ERROR);

	for (i=0; i<=max_id; i++) {

		if (array[i] == 0)

			continue;

		if (fn(array[i], specified, specified_value, i, verbose)) {

			allocated++;

			found = 1;

			if (specified != SPECIFIED_NOTHING)

				break;

		}

	}

	if (specified == SPECIFIED_NOTHING && !verbose) {

		if (!allocated)

			fprintf(fp, "(none allocated)\n");

		fprintf(fp, "\n");

	}

	FREEBUF(array);

	if (found)

		return 1;

	else

		return 0;

}

/*

 * if shared memory information is stored by using idr, use this function to

 * get data.

 */

static int

ipc_search_idr(ulong ipc_ids_p, int specified, ulong specified_value, int (*fn)(ulong, int, ulong, int, int), int verbose)

{

	int i, in_use;

	ulong ipcs_idr_p;

	ulong ipc;

	int next_id, total;

	int found = 0;

	readmem(ipc_ids_p + OFFSET(ipc_ids_in_use), KVADDR, &in_use, 

		sizeof(int), "ipc_ids.in_use", FAULT_ON_ERROR);

	ipcs_idr_p = ipc_ids_p + OFFSET(ipc_ids_ipcs_idr);

	if (!in_use) {

		if (specified == SPECIFIED_NOTHING && !verbose)

			fprintf(fp, "(none allocated)\n\n");

		return 0;

	}

	if (VALID_MEMBER(idr_idr_rt)) {

		switch (ipcs_table.init_flags & (IDR_RADIX|IDR_XARRAY))

		{

		case IDR_RADIX: 

			gather_radix_tree_entries(ipcs_idr_p);

			break;

		case IDR_XARRAY:

			gather_xarray_entries(ipcs_idr_p);

			break;

		}

		for (i = 0; i < ipcs_table.cnt; i++) {

			ipc = (ulong)ipcs_table.lp[i].value;

			if (fn(ipc, specified, specified_value, UNUSED, verbose)) {

				found = 1;

				if (specified != SPECIFIED_NOTHING)

					break;

			}

		}

		if (ipcs_table.lp)

			FREEBUF(ipcs_table.lp);

	} else {

		for (total = 0, next_id = 0; total < in_use; next_id++) {

			ipc = idr_find(ipcs_idr_p, next_id);

			if (ipc == 0)

				continue;

			total++;

			if (fn(ipc, specified, specified_value, next_id, verbose)) {

				found = 1;

				if (specified != SPECIFIED_NOTHING)

					break;

			}

		}

	}

	if (!verbose && specified == SPECIFIED_NOTHING)

		fprintf(fp, "\n");

	if (found || specified == SPECIFIED_NOTHING)

		return 1;

	else

		return 0;

}

/*

 * search every idr_layer

 */

ulong

idr_find(ulong idp, int id)

{

	ulong idr_layer_p;

	int layer;

	int idr_layers;

	int n;

	int index;

	readmem(idp + OFFSET(idr_top), KVADDR, &idr_layer_p,

		sizeof(ulong), "idr.top", FAULT_ON_ERROR);

	if (!idr_layer_p)

		return 0;

	if (VALID_MEMBER(idr_layer_layer)) {

		readmem(idr_layer_p + OFFSET(idr_layer_layer), KVADDR,

			&layer,	sizeof(int), "idr_layer.layer",

			FAULT_ON_ERROR);

		n = (layer + 1) * ipcs_table.idr_bits;

	} else {

		readmem(idp + OFFSET(idr_layers), KVADDR, &idr_layers,

			sizeof(int), "idr.layers", FAULT_ON_ERROR);

		n = idr_layers * ipcs_table.idr_bits;

	}

	id &= MAX_ID_MASK;

	if (id >= (1 << n))

		return 0;

	while (n > 0 && idr_layer_p) {

		n -= ipcs_table.idr_bits;

		index = (id >> n) & ((1 << ipcs_table.idr_bits) - 1);

		readmem(idr_layer_p + OFFSET(idr_layer_ary) +

			sizeof(ulong) * index, KVADDR, &idr_layer_p,

			sizeof(ulong), "idr_layer.ary", FAULT_ON_ERROR);

	}

	return idr_layer_p;

}

/*

 * only specified is not SPECIFIED_NOTHIND, and the specified_value is found,

 * then return 1

 */

static int

dump_shm_info(ulong shp, int specified, ulong specified_value, int id, int verbose)

{

	struct shm_info shm_info;

	char buf[BUFSIZE];

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	char buf6[BUFSIZE];

	char buf7[BUFSIZE];

	get_shm_info(&shm_info, shp, id);

	if (shm_info.deleted)

		return 0;

	if (((specified & SPECIFIED_ID) && shm_info.shmid == specified_value) ||

		((specified & SPECIFIED_ADDR) && shm_info.shmid_kernel ==

		 specified_value) || specified == SPECIFIED_NOTHING) {

		if (verbose || specified != SPECIFIED_NOTHING) {

			fprintf(fp, "%s %s %s %s %s %s %s %s\n",

				mkstring(buf0, VADDR_PRLEN<=12?12:VADDR_PRLEN,

					LJUST, "SHMID_KERNEL"),

				mkstring(buf1, 8, LJUST, "KEY"),

				mkstring(buf2, 10, LJUST, "SHMID"),

				mkstring(buf3, 5, LJUST, "UID"),

				mkstring(buf4, 5, LJUST, "PERMS"),

				mkstring(buf5, 10, LJUST, "BYTES"),

				mkstring(buf6, 6, LJUST, "NATTCH"),

				mkstring(buf7, 6, LJUST, "STATUS"));

		}

		fprintf(fp, "%s %08x %-10d %-5d %-5o %-10ld %-6ld %-s %-s\n",

			mkstring(buf, VADDR_PRLEN <= 12 ? 12 : VADDR_PRLEN,

				LJUST|LONG_HEX,	(char *)shm_info.shmid_kernel),

			shm_info.key,

			shm_info.shmid,

			shm_info.uid,

			shm_info.perms & 0777,

			shm_info.bytes,

			shm_info.nattch,

			shm_info.perms & SHM_DEST ? "dest" : "",

			shm_info.perms & SHM_LOCKED ? "locked" : "");

		if (verbose) {

			fprintf(fp, "PAGES ALLOCATED/RESIDENT/SWAPPED: %ld/%ld/%ld\n",

				(shm_info.bytes+PAGESIZE()-1) >> PAGESHIFT(),

				shm_info.rss, shm_info.swap);

			fprintf(fp, "INODE: %lx\n", shm_info.shm_inode);

		}

		if (verbose || specified != SPECIFIED_NOTHING)

			fprintf(fp, "\n");

		return 1;

	} else

		return 0;

}

/*

 * only specified is not SPECIFIED_NOTHIND, and the specified_value is found,

 * then return 1

 */

static int

dump_sem_info(ulong shp, int specified, ulong specified_value, int id, int verbose)

{

	struct sem_info sem_info;

	char buf[BUFSIZE];

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	get_sem_info(&sem_info, shp, id);

	if (sem_info.deleted)

		return 0;

	if (((specified & SPECIFIED_ID) && sem_info.semid == specified_value) ||

		((specified & SPECIFIED_ADDR) && sem_info.sem_array ==

		 specified_value) || specified == SPECIFIED_NOTHING) {

		if (specified != SPECIFIED_NOTHING) {

			fprintf(fp, "%s %s %s %s %s %s\n",

				mkstring(buf0, VADDR_PRLEN<=10?10:VADDR_PRLEN,

					LJUST, "SEM_ARRAY"),

				mkstring(buf1, 8, LJUST, "KEY"),

				mkstring(buf2, 10, LJUST, "SEMID"),

				mkstring(buf3, 5, LJUST, "UID"),

				mkstring(buf4, 5, LJUST, "PERMS"),

				mkstring(buf5, 10, LJUST, "NSEMS"));

		}

		fprintf(fp, "%s %08x %-10d %-5d %-5o %-10ld\n",

			mkstring(buf, VADDR_PRLEN <= 10 ? 10 : VADDR_PRLEN,

				LJUST|LONG_HEX,	(char *)sem_info.sem_array),

			sem_info.key,

			sem_info.semid,

			sem_info.uid,

			sem_info.perms & 0777,

			sem_info.nsems);

		if (specified != SPECIFIED_NOTHING)

			fprintf(fp, "\n");

		return 1;

	} else

		return 0;

}

/*

 * only specified is not SPECIFIED_NOTHIND, and the specified_value is found,

 * then return 1

 */

static int

dump_msg_info(ulong shp, int specified, ulong specified_value, int id, int verbose)

{

	struct msg_info msg_info;

	char buf[BUFSIZE];

	char buf0[BUFSIZE];

	char buf1[BUFSIZE];

	char buf2[BUFSIZE];

	char buf3[BUFSIZE];

	char buf4[BUFSIZE];

	char buf5[BUFSIZE];

	char buf6[BUFSIZE];

	get_msg_info(&msg_info, shp, id);

	if (msg_info.deleted)

		return 0;

	if (((specified & SPECIFIED_ID) && msg_info.msgid == specified_value) ||

		((specified & SPECIFIED_ADDR) && msg_info.msg_queue ==

		 specified_value) || specified == SPECIFIED_NOTHING) {

		if (specified != SPECIFIED_NOTHING) {

			fprintf(fp, "%s %s %s %s %s %s %s\n",

				mkstring(buf0, VADDR_PRLEN<=10?10:VADDR_PRLEN,

					LJUST, "MSG_QUEUE"),

				mkstring(buf1, 8, LJUST, "KEY"),

				mkstring(buf2, 10, LJUST, "MSQID"),

				mkstring(buf3, 5, LJUST, "UID"),

				mkstring(buf4, 5, LJUST, "PERMS"),

				mkstring(buf5, 12, LJUST, "USED-BYTES"),

				mkstring(buf6, 12, LJUST, "MESSAGES"));

		}

		fprintf(fp, "%s %08x %-10d %-5d %-5o %-12ld %-12ld\n",

			mkstring(buf, VADDR_PRLEN <= 10 ? 10 : VADDR_PRLEN,

				LJUST|LONG_HEX,	(char *)msg_info.msg_queue),

			msg_info.key,

			msg_info.msgid,

			msg_info.uid,

			msg_info.perms & 0777,

			msg_info.bytes,

			msg_info.messages);

		if (specified != SPECIFIED_NOTHING)

			fprintf(fp, "\n");

		return 1;

	} else

		return 0;

}

static void

get_shm_info(struct shm_info *shm_info, ulong shp, int id)