RepoMirrors
/
crash
mirror of https://github.com/crash-utility/crash
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
crash/ipcs.c

1164 lines
32 KiB
C
Raw Permalink Blame History

/* 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)
{
char buf[BUFSIZE];
ulong filep, dentryp, inodep;
shm_info->shmid_kernel = shp - OFFSET(shmid_kernel_shm_perm);
/*
* cache shmid_kernel
*/
readmem(shm_info->shmid_kernel, KVADDR, buf, SIZE(shmid_kernel),
"shmid_kernel", FAULT_ON_ERROR);
shm_info->key = INT(buf + OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_key));
if (VALID_MEMBER(shmid_kernel_id))
shm_info->shmid = INT(buf + OFFSET(shmid_kernel_id));
else
shm_info->shmid = INT(buf +
OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_id));
shm_info->uid = UINT(buf + OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_uid));
if (BITS32())
shm_info->perms = USHORT(buf +
OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_mode));
else
shm_info->perms = UINT(buf +
OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_mode));
shm_info->bytes = ULONG(buf + OFFSET(shmid_kernel_shm_segsz));
shm_info->nattch = ULONG(buf + OFFSET(shmid_kernel_shm_nattch));
filep = ULONG(buf + OFFSET(shmid_kernel_shm_file));
readmem(filep + OFFSET(file_f_dentry), KVADDR, &dentryp, sizeof(ulong),
"file.f_dentry", FAULT_ON_ERROR);
readmem(dentryp + OFFSET(dentry_d_inode), KVADDR, &inodep,
sizeof(ulong), "dentry.d_inode", FAULT_ON_ERROR);
/*
* shm_inode here is the vfs_inode of struct shmem_inode_info
*/
shm_info->shm_inode = inodep;
shm_info->rss = 0;
shm_info->swap = 0;
add_rss_swap(inodep, is_file_hugepages(filep), &shm_info->rss,
&shm_info->swap);
shm_info->deleted = UCHAR(buf + OFFSET(shmid_kernel_shm_perm) +
OFFSET(kern_ipc_perm_deleted));
}
static void
get_sem_info(struct sem_info *sem_info, ulong shp, int id)
{
char buf[BUFSIZE];
sem_info->sem_array = shp - OFFSET(sem_array_sem_perm);
/*
* cache sem_array
*/
readmem(sem_info->sem_array, KVADDR, buf, SIZE(sem_array),
"sem_array", FAULT_ON_ERROR);
sem_info->key = INT(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_key));
if (VALID_MEMBER(sem_array_sem_id))
sem_info->semid = INT(buf + OFFSET(sem_array_sem_id));
else if (VALID_MEMBER(kern_ipc_perm_id))
sem_info->semid = INT(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_id));
else {
ulong seq;
seq = ULONG(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_seq));
sem_info->semid = ipcs_table.seq_multiplier * seq + id;
}
sem_info->uid = UINT(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_uid));
if (BITS32())
sem_info->perms = USHORT(buf +
OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_mode));
else
sem_info->perms = UINT(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_mode));
sem_info->nsems = ULONG(buf + OFFSET(sem_array_sem_nsems));
sem_info->deleted = UCHAR(buf + OFFSET(sem_array_sem_perm) +
OFFSET(kern_ipc_perm_deleted));
}
static void
get_msg_info(struct msg_info *msg_info, ulong shp, int id)
{
char buf[BUFSIZE];
msg_info->msg_queue = shp - OFFSET(msg_queue_q_perm);
/*
* cache msg_queue
*/
readmem(msg_info->msg_queue, KVADDR, buf, SIZE(msg_queue),
"msg_queue", FAULT_ON_ERROR);
msg_info->key = INT(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_key));
if (VALID_MEMBER(msg_queue_q_id))
msg_info->msgid = INT(buf + OFFSET(msg_queue_q_id));
else if (VALID_MEMBER(kern_ipc_perm_id))
msg_info->msgid = INT(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_id));
else {
ulong seq;
seq = ULONG(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_seq));
msg_info->msgid = ipcs_table.seq_multiplier * seq + id;
}
msg_info->uid = UINT(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_uid));
if (BITS32())
msg_info->perms = USHORT(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_mode));
else
msg_info->perms = UINT(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_mode));
msg_info->bytes = ULONG(buf + OFFSET(msg_queue_q_cbytes));
msg_info->messages = ULONG(buf + OFFSET(msg_queue_q_qnum));
msg_info->deleted = UCHAR(buf + OFFSET(msg_queue_q_perm) +
OFFSET(kern_ipc_perm_deleted));
}
/*
* get rss & swap related to every shared memory, and get the total number of rss
* & swap
*/
static void
add_rss_swap(ulong inode_p, int hugepage, ulong *rss, ulong *swap)
{
unsigned long mapping_p, nr_pages;
readmem(inode_p + OFFSET(inode_i_mapping), KVADDR, &mapping_p,
sizeof(ulong), "inode.i_mapping", FAULT_ON_ERROR);
readmem(mapping_p + OFFSET(address_space_nrpages), KVADDR, &nr_pages,
sizeof(ulong), "address_space.nrpages",
FAULT_ON_ERROR);
if (hugepage) {
unsigned long pages_per_hugepage;
if (VALID_SIZE(hstate)) {
unsigned long i_sb_p, hsb_p, hstate_p;
unsigned int order;
readmem(inode_p + OFFSET(inode_i_sb), KVADDR, &i_sb_p,
sizeof(ulong), "inode.i_sb",
FAULT_ON_ERROR);
readmem(i_sb_p + OFFSET(super_block_s_fs_info),
KVADDR, &hsb_p, sizeof(ulong),
"super_block.s_fs_info", FAULT_ON_ERROR);
readmem(hsb_p + OFFSET(hugetlbfs_sb_info_hstate),
KVADDR, &hstate_p, sizeof(ulong),
"hugetlbfs_sb_info.hstate", FAULT_ON_ERROR);
readmem(hstate_p + OFFSET(hstate_order), KVADDR,
&order, sizeof(uint), "hstate.order",
FAULT_ON_ERROR);
pages_per_hugepage = 1 << order;
} else {
unsigned long hpage_shift;
/*
* HPAGE_SHIFT is 21 after commit 83a5101b
* (kernel > 2.6.24)
*/
if (THIS_KERNEL_VERSION > LINUX(2, 6, 24)) {
hpage_shift = 21;
} else {
/*
* HPAGE_SHIFT:
* x86(PAE): 21
* x86(no PAE): 22
* x86_64: 21
*/
if ((machine_type("X86") &&
!(machdep->flags & PAE)))
hpage_shift = 22;
else
hpage_shift = 21;
}
pages_per_hugepage = (1 << hpage_shift) / PAGESIZE();
}
*rss += pages_per_hugepage * nr_pages;
} else {
unsigned long swapped;
*rss += nr_pages;
readmem(inode_p - OFFSET(shmem_inode_info_vfs_inode) +
OFFSET(shmem_inode_info_swapped), KVADDR,
&swapped, sizeof(ulong), "shmem_inode_info.swapped",
FAULT_ON_ERROR);
*swap += swapped;
}
}
static int
is_file_hugepages(ulong file_p)
{
unsigned long f_op, sfd_p;
again:
readmem(file_p + OFFSET(file_f_op), KVADDR, &f_op, sizeof(ulong),
"file.f_op", FAULT_ON_ERROR);
if (f_op == ipcs_table.hugetlbfs_f_op_addr)
return 1;
if (ipcs_table.use_shm_f_op) {
if (ipcs_table.shm_f_op_huge_addr != -1) {
if (f_op == ipcs_table.shm_f_op_huge_addr)
return 1;
} else {
if (f_op == ipcs_table.shm_f_op_addr) {
readmem(file_p +
OFFSET(file_private_data),
KVADDR, &sfd_p, sizeof(ulong),
"file.private_data", FAULT_ON_ERROR);
readmem(sfd_p +
OFFSET(shm_file_data_file),
KVADDR, &file_p, sizeof(ulong),
"shm_file_data.file", FAULT_ON_ERROR);
goto again;
}
}
}
return 0;
}
static void
gather_radix_tree_entries(ulong ipcs_idr_p)
{
long len;
ipcs_table.cnt = do_radix_tree(ipcs_idr_p, RADIX_TREE_COUNT, NULL);
if (ipcs_table.cnt) {
len = sizeof(struct list_pair) * (ipcs_table.cnt+1);
ipcs_table.lp = (struct list_pair *)GETBUF(len);
ipcs_table.lp[0].index = ipcs_table.cnt;
ipcs_table.cnt = do_radix_tree(ipcs_idr_p, RADIX_TREE_GATHER, ipcs_table.lp);
} else
ipcs_table.lp = NULL;
}
static void
gather_xarray_entries(ulong ipcs_idr_p)
{
long len;
ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_COUNT, NULL);
if (ipcs_table.cnt) {
len = sizeof(struct list_pair) * (ipcs_table.cnt+1);
ipcs_table.lp = (struct list_pair *)GETBUF(len);
ipcs_table.lp[0].index = ipcs_table.cnt;
ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_GATHER, ipcs_table.lp);
} else
ipcs_table.lp = NULL;
}
Reference in New Issue View Git Blame Copy Permalink