510 lines
16 KiB
C
510 lines
16 KiB
C
|
/* This file contains information dump procedures. During the initialization
|
||
|
* of the Information Service 'known' function keys are registered at the TTY
|
||
|
* server in order to receive a notification if one is pressed. Here, the
|
||
|
* corresponding dump procedure is called.
|
||
|
*
|
||
|
* The entry points into this file are
|
||
|
* handle_fkey: handle a function key pressed notification
|
||
|
*/
|
||
|
|
||
|
|
||
|
/* Several header files from the kernel are included here so that we can use
|
||
|
* the constants, macros, and types needed to make the debugging dumps.
|
||
|
*/
|
||
|
#include "is.h"
|
||
|
#include <timers.h>
|
||
|
#include <string.h>
|
||
|
#include <ibm/interrupt.h>
|
||
|
#include "../../kernel/const.h"
|
||
|
#include "../../kernel/type.h"
|
||
|
#include "../../kernel/proc.h"
|
||
|
#include "../../kernel/sendmask.h"
|
||
|
|
||
|
#define click_to_round_k(n) \
|
||
|
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
|
||
|
|
||
|
|
||
|
/* Declare some local dump procedures. */
|
||
|
FORWARD _PROTOTYPE( char *proc_name, (int proc_nr) );
|
||
|
FORWARD _PROTOTYPE( void proctab_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void memmap_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void sendmask_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void image_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void irqtab_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void kmessages_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void diagnostics_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void sched_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void monparams_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void kenviron_dmp, (void) );
|
||
|
FORWARD _PROTOTYPE( void memchunks_dmp, (void) );
|
||
|
|
||
|
/* Some global data that is shared among several dumping procedures.
|
||
|
* Note that the process table copy has the same name as in the kernel
|
||
|
* so that most macros and definitions from proc.h also apply here.
|
||
|
*/
|
||
|
struct proc proc[NR_TASKS + NR_PROCS];
|
||
|
struct system_image image[IMAGE_SIZE];
|
||
|
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* handle_fkey *
|
||
|
*===========================================================================*/
|
||
|
PUBLIC int do_fkey_pressed(message *m)
|
||
|
{
|
||
|
if (F1 <= m->FKEY_CODE && m->FKEY_CODE <= F12) {
|
||
|
switch(m->FKEY_CODE) {
|
||
|
case F1: proctab_dmp(); break;
|
||
|
case F2: memmap_dmp(); break;
|
||
|
case F3: image_dmp(); break;
|
||
|
case F4: sendmask_dmp(); break;
|
||
|
case F5: monparams_dmp(); break;
|
||
|
case F6: irqtab_dmp(); break;
|
||
|
case F7: kmessages_dmp(); break;
|
||
|
case F9: diagnostics_dmp(); break;
|
||
|
case F10: kenviron_dmp(); break;
|
||
|
case F11: memchunks_dmp(); break;
|
||
|
case F12: sched_dmp(); break;
|
||
|
default:
|
||
|
printf("IS: unhandled notification for F%d\n", m->FKEY_NUM);
|
||
|
}
|
||
|
}
|
||
|
return(EDONTREPLY);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* diagnostics_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void diagnostics_dmp()
|
||
|
{
|
||
|
char print_buf[DIAG_BUF_SIZE+1]; /* buffer used to print */
|
||
|
int start; /* calculate start of messages */
|
||
|
int size, r;
|
||
|
|
||
|
/* Try to print the kernel messages. First determine start and copy the
|
||
|
* buffer into a print-buffer. This is done because the messages in the
|
||
|
* copy may wrap (the kernel buffer is circular).
|
||
|
*/
|
||
|
start = ((diag_next + DIAG_BUF_SIZE) - diag_size) % DIAG_BUF_SIZE;
|
||
|
r = 0;
|
||
|
size = diag_size;
|
||
|
while (size > 0) {
|
||
|
print_buf[r] = diag_buf[(start+r) % DIAG_BUF_SIZE];
|
||
|
r ++;
|
||
|
size --;
|
||
|
}
|
||
|
print_buf[r] = 0; /* make sure it terminates */
|
||
|
printf("Dump of diagnostics from device drivers and servers.\n\n");
|
||
|
printf(print_buf); /* print the messages */
|
||
|
}
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* kmessages_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void kmessages_dmp()
|
||
|
{
|
||
|
struct kmessages kmess; /* get copy of kernel messages */
|
||
|
char print_buf[KMESS_BUF_SIZE+1]; /* this one is used to print */
|
||
|
int next, size; /* vars returned by sys_kmess() */
|
||
|
int start; /* calculate start of messages */
|
||
|
int r;
|
||
|
|
||
|
/* Try to get a copy of the kernel messages. */
|
||
|
if ((r = sys_getkmessages(&kmess)) != OK) {
|
||
|
report("warning: couldn't get copy of kmessages", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* Try to print the kernel messages. First determine start and copy the
|
||
|
* buffer into a print-buffer. This is done because the messages in the
|
||
|
* copy may wrap (the kernel buffer is circular).
|
||
|
*/
|
||
|
start = ((kmess.km_next + KMESS_BUF_SIZE) - kmess.km_size) % KMESS_BUF_SIZE;
|
||
|
r = 0;
|
||
|
while (kmess.km_size > 0) {
|
||
|
print_buf[r] = kmess.km_buf[(start+r) % KMESS_BUF_SIZE];
|
||
|
r ++;
|
||
|
kmess.km_size --;
|
||
|
}
|
||
|
print_buf[r] = 0; /* make sure it terminates */
|
||
|
printf("Dump of all messages generated by the kernel.\n\n");
|
||
|
printf(print_buf); /* print the messages */
|
||
|
}
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* monparams_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void monparams_dmp()
|
||
|
{
|
||
|
char val[1024];
|
||
|
char *e;
|
||
|
int r;
|
||
|
|
||
|
/* Try to get a copy of the boot monitor parameters. */
|
||
|
if ((r = sys_getmonparams(val, sizeof(val))) != OK) {
|
||
|
report("warning: couldn't get copy of monitor params", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* Append new lines to the result. */
|
||
|
e = val;
|
||
|
do {
|
||
|
e += strlen(e);
|
||
|
*e++ = '\n';
|
||
|
} while (*e != 0);
|
||
|
|
||
|
/* Finally, print the result. */
|
||
|
printf("Dump of kernel environment strings set by boot monitor.\n");
|
||
|
printf("\n%s\n", val);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* irqtab_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void irqtab_dmp()
|
||
|
{
|
||
|
int i,j,r;
|
||
|
struct irqtab irqtab[NR_IRQ_VECTORS];
|
||
|
struct irqtab *e; /* irq tab entry */
|
||
|
int p; /* policy */
|
||
|
char *irq[] = {
|
||
|
"clock", /* 00 */
|
||
|
"keyboard", /* 01 */
|
||
|
"cascade", /* 02 */
|
||
|
"eth/rs232", /* 03 */
|
||
|
"rs232", /* 04 */
|
||
|
"xt_wini", /* 05 */
|
||
|
"floppy", /* 06 */
|
||
|
"printer", /* 07 */
|
||
|
"", /* 08 */
|
||
|
"", /* 09 */
|
||
|
"", /* 10 */
|
||
|
"", /* 11 */
|
||
|
"", /* 12 */
|
||
|
"", /* 13 */
|
||
|
"at_wini_0", /* 14 */
|
||
|
"at_wini_1", /* 15 */
|
||
|
};
|
||
|
|
||
|
if ((r = sys_getirqtab(irqtab)) != OK) {
|
||
|
report("warning: couldn't get copy of irqtab", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("IRQ table dump showing hardware interrupt policies for each IRQ vector.\n");
|
||
|
printf("-irq name/nr- -pnr- --port-- msk_val --addr-- -type-rdp-str-ech-wrp-ena- \n");
|
||
|
for (i=0; i<NR_IRQ_VECTORS; i++) {
|
||
|
e = &irqtab[i];
|
||
|
p = e->policy;
|
||
|
printf("%9s %2d ", irq[i], i);
|
||
|
if (e->proc_nr!=NONE) printf("%4d ", e->proc_nr);
|
||
|
else printf(" ");
|
||
|
printf(" 0x%06x 0x%05x 0x%06x %c%c%c %d %d %d %d %d\n",
|
||
|
e->port, e->mask_val, e->addr,
|
||
|
(p&IRQ_BYTE)?'B':'-', (p&IRQ_WORD)?'W':'-', (p&IRQ_LONG)?'L':'-',
|
||
|
((p&IRQ_READ_PORT) != 0),
|
||
|
((p&IRQ_STROBE) != 0),
|
||
|
((p&IRQ_ECHO_VAL) != 0),
|
||
|
((p&IRQ_WRITE_PORT) != 0),
|
||
|
((p&IRQ_REENABLE) != 0)
|
||
|
);
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* image_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void image_dmp()
|
||
|
{
|
||
|
int i,j,r;
|
||
|
struct system_image *ip;
|
||
|
char maskstr[NR_TASKS + NR_PROCS] = "mask";
|
||
|
char* types[] = {"task", "system","driver", "server", "user", "idle"};
|
||
|
char* priorities[] = {"task", "higher","high", "normal", "low", "lower", "user","idle"};
|
||
|
|
||
|
if ((r = sys_getimage(image)) != OK) {
|
||
|
report("warning: couldn't get copy of image table", r);
|
||
|
return;
|
||
|
}
|
||
|
printf("Image table dump showing all processes included in system image.\n");
|
||
|
printf("---name-- -nr- --type- -priority- ----pc- -stack- ------sendmask-------\n");
|
||
|
for (i=0; i<IMAGE_SIZE; i++) {
|
||
|
ip = &image[i];
|
||
|
for (j=-NR_TASKS; j<LOW_USER+2; j++)
|
||
|
maskstr[j+NR_TASKS] = (isallowed(ip->sendmask, j)) ? '1' : '0';
|
||
|
maskstr[j+NR_TASKS] = '\0';
|
||
|
printf("%8s %4d %7s %10s %7lu %7lu %s\n",
|
||
|
ip->name, ip->proc_nr, types[ip->type], priorities[ip->priority],
|
||
|
(long)ip->initial_pc, ip->stksize, maskstr);
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* sched_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void sched_dmp()
|
||
|
{
|
||
|
struct proc *rdy_head[NR_SCHED_QUEUES];
|
||
|
char *types[] = {"task","higher","high","normal","low","lower","user","idle"};
|
||
|
struct kenviron kenviron;
|
||
|
register struct proc *rp;
|
||
|
vir_bytes ptr_diff;
|
||
|
int r;
|
||
|
|
||
|
/* First obtain a scheduling information. */
|
||
|
if ((r = sys_getschedinfo(proc, rdy_head)) != OK) {
|
||
|
report("warning: couldn't get copy of process table", r);
|
||
|
return;
|
||
|
}
|
||
|
/* Then obtain kernel addresses to correct pointer information. */
|
||
|
if ((r = sys_getkenviron(&kenviron)) != OK) {
|
||
|
report("warning: couldn't get kernel addresses", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/* Update all pointers. Nasty pointer algorithmic ... */
|
||
|
ptr_diff = (vir_bytes) proc - (vir_bytes) kenviron.proc_addr;
|
||
|
for (r=0;r<NR_SCHED_QUEUES; r++)
|
||
|
if (rdy_head[r] != NIL_PROC)
|
||
|
rdy_head[r] =
|
||
|
(struct proc *)((vir_bytes) rdy_head[r] + ptr_diff);
|
||
|
for (rp=BEG_PROC_ADDR; rp < END_PROC_ADDR; rp++)
|
||
|
if (rp->p_nextready != NIL_PROC)
|
||
|
rp->p_nextready =
|
||
|
(struct proc *)((vir_bytes) rp->p_nextready + ptr_diff);
|
||
|
|
||
|
/* Now show scheduling queues. */
|
||
|
printf("Dumping scheduling queues.\n");
|
||
|
|
||
|
for (r=0;r<NR_SCHED_QUEUES; r++) {
|
||
|
printf("* %6s: ", types[r]);
|
||
|
rp = rdy_head[r];
|
||
|
while (rp != NIL_PROC) {
|
||
|
printf("%3d, ", rp->p_nr);
|
||
|
rp = rp->p_nextready;
|
||
|
}
|
||
|
printf("NIL\n");
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* kenviron_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void kenviron_dmp()
|
||
|
{
|
||
|
struct kenviron kenv;
|
||
|
int r;
|
||
|
if ((r = sys_getkenviron(&kenv)) != OK) {
|
||
|
report("warning: couldn't get copy of kernel env", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("Dump of kernel variables based on the environment set by the boot loader.\n");
|
||
|
printf("- pc_at: %3d\n", kenv.pc_at);
|
||
|
printf("- ps_mca: %3d\n", kenv.ps_mca);
|
||
|
printf("- processor: %3d\n", kenv.processor);
|
||
|
printf("- protected: %3d\n", kenv.protected);
|
||
|
printf("- ega: %3d\n", kenv.ega);
|
||
|
printf("- vga: %3d\n", kenv.vga);
|
||
|
printf("- params_base:%5u\n", kenv.params_base);
|
||
|
printf("- params_size:%5u\n", kenv.params_size);
|
||
|
printf("- kmem_base:%5u\n", kenv.kmem_base);
|
||
|
printf("- kmem_size:%5u\n", kenv.kmem_size);
|
||
|
printf("- bootfs_base:%5u\n", kenv.bootfs_base);
|
||
|
printf("- bootfs_size:%5u\n", kenv.bootfs_size);
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* memchunks_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void memchunks_dmp()
|
||
|
{
|
||
|
int i,r;
|
||
|
struct memory mem[NR_MEMS];
|
||
|
if ((r = sys_getmemchunks(mem)) != OK) {
|
||
|
report("warning: couldn't get copy of mem chunks", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("Memory chunks:\n");
|
||
|
for (i=0; i<NR_MEMS; i++) {
|
||
|
printf("chunk %d: base %u, size %u\n", i, mem[i].base, mem[i].size);
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* sendmask_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void sendmask_dmp()
|
||
|
{
|
||
|
register struct proc *rp;
|
||
|
static struct proc *oldrp = BEG_PROC_ADDR;
|
||
|
int r, i,j, n = 0;
|
||
|
|
||
|
/* First obtain a fresh copy of the current process table. */
|
||
|
if ((r = sys_getproctab(proc)) != OK) {
|
||
|
report("warning: couldn't get copy of process table", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("\n\n");
|
||
|
printf("Sendmask dump for process table. User processes (*) don't have [].");
|
||
|
printf("\n");
|
||
|
printf("The rows of bits indicate to which processes each process may send.");
|
||
|
printf("\n\n");
|
||
|
|
||
|
printf(" ");
|
||
|
for (j=proc_number(BEG_PROC_ADDR); j< LOW_USER+1; j++) {
|
||
|
printf("%3d", j);
|
||
|
}
|
||
|
printf(" *\n");
|
||
|
|
||
|
for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
|
||
|
if (isemptyp(rp)) continue;
|
||
|
if (++n > 20) break;
|
||
|
|
||
|
printf("%8s ", rp->p_name);
|
||
|
j = proc_number(rp);
|
||
|
switch(rp->p_type) {
|
||
|
case P_IDLE: printf("/%3d/ ", proc_number(rp)); break;
|
||
|
case P_TASK: printf("[%3d] ", proc_number(rp)); break;
|
||
|
case P_SYSTEM: printf("<%3d> ", proc_number(rp)); break;
|
||
|
case P_DRIVER: printf("{%3d} ", proc_number(rp)); break;
|
||
|
case P_SERVER: printf("(%3d) ", proc_number(rp)); break;
|
||
|
default: printf(" %3d ", proc_number(rp));
|
||
|
}
|
||
|
|
||
|
for (j=proc_number(BEG_PROC_ADDR); j<LOW_USER+2; j++) {
|
||
|
if (isallowed(rp->p_sendmask, j)) printf(" 1 ");
|
||
|
else printf(" 0 ");
|
||
|
}
|
||
|
printf("\n");
|
||
|
}
|
||
|
if (rp == END_PROC_ADDR) { printf("\n"); rp = BEG_PROC_ADDR; }
|
||
|
else printf("--more--\r");
|
||
|
oldrp = rp;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* proctab_dmp *
|
||
|
*===========================================================================*/
|
||
|
#if (CHIP == INTEL)
|
||
|
PRIVATE void proctab_dmp()
|
||
|
{
|
||
|
/* Proc table dump */
|
||
|
|
||
|
register struct proc *rp;
|
||
|
static struct proc *oldrp = BEG_PROC_ADDR;
|
||
|
int r, n = 0;
|
||
|
phys_clicks text, data, size;
|
||
|
|
||
|
/* First obtain a fresh copy of the current process table. */
|
||
|
if ((r = sys_getproctab(proc)) != OK) {
|
||
|
report("warning: couldn't get copy of process table", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("\n-pid- -pri- --pc-- --sp-- -user- -sys- -text- -data- -size- -flags- -command-\n");
|
||
|
|
||
|
for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
|
||
|
if (isemptyp(rp)) continue;
|
||
|
if (++n > 23) break;
|
||
|
text = rp->p_memmap[T].mem_phys;
|
||
|
data = rp->p_memmap[D].mem_phys;
|
||
|
size = rp->p_memmap[T].mem_len
|
||
|
+ ((rp->p_memmap[S].mem_phys + rp->p_memmap[S].mem_len) - data);
|
||
|
switch(rp->p_type) {
|
||
|
case P_IDLE: printf("/%3d/ ", proc_number(rp)); break;
|
||
|
case P_TASK: printf("[%3d] ", proc_number(rp)); break;
|
||
|
case P_SYSTEM: printf("<%3d> ", proc_number(rp)); break;
|
||
|
case P_DRIVER: printf("{%3d} ", proc_number(rp)); break;
|
||
|
case P_SERVER: printf("(%3d) ", proc_number(rp)); break;
|
||
|
default: printf(" %3d ", proc_number(rp));
|
||
|
}
|
||
|
printf("%3u %7lx%7lx %6lu%6lu%6uK%6uK%6uK %3x",
|
||
|
rp->p_priority,
|
||
|
(unsigned long) rp->p_reg.pc,
|
||
|
(unsigned long) rp->p_reg.sp,
|
||
|
rp->user_time, rp->sys_time,
|
||
|
click_to_round_k(text), click_to_round_k(data),
|
||
|
click_to_round_k(size),
|
||
|
rp->p_flags);
|
||
|
if (rp->p_flags & RECEIVING) {
|
||
|
printf(" %-7.7s", proc_name(rp->p_getfrom));
|
||
|
} else
|
||
|
if (rp->p_flags & SENDING) {
|
||
|
printf(" S:%-5.5s", proc_name(rp->p_sendto));
|
||
|
} else
|
||
|
if (rp->p_flags == 0) {
|
||
|
printf(" ");
|
||
|
}
|
||
|
printf(" %s\n", rp->p_name);
|
||
|
}
|
||
|
if (rp == END_PROC_ADDR) rp = BEG_PROC_ADDR; else printf("--more--\r");
|
||
|
oldrp = rp;
|
||
|
}
|
||
|
#endif /* (CHIP == INTEL) */
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* memmap_dmp *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE void memmap_dmp()
|
||
|
{
|
||
|
register struct proc *rp;
|
||
|
static struct proc *oldrp = cproc_addr(HARDWARE);
|
||
|
int r, n = 0;
|
||
|
phys_clicks size;
|
||
|
|
||
|
/* First obtain a fresh copy of the current process table. */
|
||
|
if ((r = sys_getproctab(proc)) != OK) {
|
||
|
report("warning: couldn't get copy of process table", r);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
printf("\n--proc name- -----text----- -----data----- ----stack----- -size-\n");
|
||
|
for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
|
||
|
if (isemptyp(rp)) continue;
|
||
|
if (++n > 23) break;
|
||
|
size = rp->p_memmap[T].mem_len
|
||
|
+ ((rp->p_memmap[S].mem_phys + rp->p_memmap[S].mem_len)
|
||
|
- rp->p_memmap[D].mem_phys);
|
||
|
printf("%3d %-7.7s %4x %4x %4x %4x %4x %4x %4x %4x %4x %5uK\n",
|
||
|
proc_number(rp),
|
||
|
rp->p_name,
|
||
|
rp->p_memmap[T].mem_vir, rp->p_memmap[T].mem_phys, rp->p_memmap[T].mem_len,
|
||
|
rp->p_memmap[D].mem_vir, rp->p_memmap[D].mem_phys, rp->p_memmap[D].mem_len,
|
||
|
rp->p_memmap[S].mem_vir, rp->p_memmap[S].mem_phys, rp->p_memmap[S].mem_len,
|
||
|
click_to_round_k(size));
|
||
|
}
|
||
|
if (rp == END_PROC_ADDR) rp = cproc_addr(HARDWARE);
|
||
|
else printf("--more--\r");
|
||
|
oldrp = rp;
|
||
|
}
|
||
|
|
||
|
/*===========================================================================*
|
||
|
* proc_name *
|
||
|
*===========================================================================*/
|
||
|
PRIVATE char *proc_name(proc_nr)
|
||
|
int proc_nr;
|
||
|
{
|
||
|
if (proc_nr == ANY) return "ANY";
|
||
|
return cproc_addr(proc_nr)->p_name;
|
||
|
}
|
||
|
|
||
|
|