void user_z( void ) {
int n;
int pid, ppid;
char buf1[16], buf2[16];
pid = get_process_info( INFO_PID, 0 );
ppid = get_process_info( INFO_PPID, 0 );
n = itos10( buf1, pid );
pid = n;
n = itos10( buf2, ppid );
ppid = n;
write( FD_CONSOLE, "User Z running, PID ", 0 );
write( FD_CONSOLE, buf1, pid );
write( FD_CONSOLE, " PPID ", 0 );
write( FD_CONSOLE, buf2, ppid );
write( FD_CONSOLE, "\n", 1 );
for( int i = 0; i < 10 ; ++i ) {
write( FD_SIO, "Z", 1 );
for( int j = 0; j < DELAY_STD; ++j )
continue;
}
write( FD_CONSOLE, "User Z exiting, PID ", 0 );
write( FD_CONSOLE, buf1, pid );
write( FD_CONSOLE, " PPID ", 0 );
write( FD_CONSOLE, buf2, ppid );
write( FD_CONSOLE, "\n", 1 );
exit();
}
void user_x( void ) {
int i, j;
int pid, ppid;
char buf1[16], buf2[16];
pid = get_process_info( INFO_PID, 0 );
ppid = get_process_info( INFO_PPID, 0 );
i = itos10( buf1, pid );
j = itos10( buf2, ppid );
write( FD_CONSOLE, "User X running, PID ", 0 );
write( FD_CONSOLE, buf1, i );
write( FD_CONSOLE, " PPID ", 0 );
write( FD_CONSOLE, buf2, j );
write( FD_CONSOLE, "\n", 1 );
for( int k = 0; k < 20 ; ++k ) {
write( FD_SIO, "X", 1 );
for( int k2 = 0; k2 < DELAY_STD; ++k2 )
continue;
}
write( FD_CONSOLE, "User X exiting, PID ", 0 );
write( FD_CONSOLE, buf1, i );
write( FD_CONSOLE, " PPID ", 0 );
write( FD_CONSOLE, buf2, j );
write( FD_CONSOLE, "\n", 1 );
exit();
}
int main() {
int n;
int arr[10];
get_process_info(&n,arr);
int i;
for(i=0; i<n; i++) {
printf("%d::%d\n",i,arr[i]);
}
printf("=====>[%d]\n",get_gpu_id());
#if 0
int nid;
while(1) {
nid=get_next_gpuid();
printf("Next GPUID :%d\n",nid);
sleep(1);
}
#endif
return 0;
}
void user_g( void ) {
int i;
char buf[16];
write( FD_CONSOLE, "User G (pid ", 0 );
i = itos10( buf, get_process_info( INFO_PID, 0 ) );
write( FD_CONSOLE, buf, i );
write( FD_CONSOLE, ") running\n", 0 );
write( FD_SIO, "G", 1 );
for( i = 0; i < 5; ++i ) {
sleep( SECONDS_TO_MS(15) );
write( FD_SIO, "G", 1 );
}
write( FD_CONSOLE, "User G exiting\n", 0 );
exit();
}
void user_n( void ) {
int i, j;
int prio;
char buf[16];
prio = get_process_info( INFO_PRIO, 0 );
i = itos10( buf, prio );
write( FD_CONSOLE, "User N running @ ", 0 );
write( FD_CONSOLE, buf, i );
write( FD_CONSOLE, "\n", 1 );
write( FD_SIO, "N", 1 );
for( i = 0; i < 30; ++i ) {
for( j = 0; j < DELAY_STD; ++j )
continue;
write( FD_SIO, "N", 1 );
}
write( FD_CONSOLE, "User N exiting\n", 0 );
exit();
}
int get_gpu_id_proc()
{
unsigned int ncores;
unsigned int gpuarray[NDEV];
int ret=get_process_info(&ncores,gpuarray);
if(ret<0) {
fprintf(stderr,"Can not Get Next GPU ID Correctly..\n");
return 0;
}
int i;
int ind;
int val=1000;
for(i=0; i<ncores; i++) {
if(gpuarray[i]<val) {
val=gpuarray[i];
ind=i;
}
}
return ind;
}
static int read_request(int fd, debugger_request_t* out_request) {
ucred cr;
socklen_t len = sizeof(cr);
int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
if (status != 0) {
ALOGE("cannot get credentials\n");
return -1;
}
ALOGV("reading tid\n");
fcntl(fd, F_SETFL, O_NONBLOCK);
pollfd pollfds[1];
pollfds[0].fd = fd;
pollfds[0].events = POLLIN;
pollfds[0].revents = 0;
status = TEMP_FAILURE_RETRY(poll(pollfds, 1, 3000));
if (status != 1) {
ALOGE("timed out reading tid (from pid=%d uid=%d)\n", cr.pid, cr.uid);
return -1;
}
debugger_msg_t msg;
memset(&msg, 0, sizeof(msg));
status = TEMP_FAILURE_RETRY(read(fd, &msg, sizeof(msg)));
if (status < 0) {
ALOGE("read failure? %s (pid=%d uid=%d)\n", strerror(errno), cr.pid, cr.uid);
return -1;
}
if (status != sizeof(debugger_msg_t)) {
ALOGE("invalid crash request of size %d (from pid=%d uid=%d)\n", status, cr.pid, cr.uid);
return -1;
}
out_request->action = msg.action;
out_request->tid = msg.tid;
out_request->pid = cr.pid;
out_request->uid = cr.uid;
out_request->gid = cr.gid;
out_request->abort_msg_address = msg.abort_msg_address;
out_request->original_si_code = msg.original_si_code;
if (msg.action == DEBUGGER_ACTION_CRASH) {
// Ensure that the tid reported by the crashing process is valid.
char buf[64];
struct stat s;
snprintf(buf, sizeof buf, "/proc/%d/task/%d", out_request->pid, out_request->tid);
if (stat(buf, &s)) {
ALOGE("tid %d does not exist in pid %d. ignoring debug request\n",
out_request->tid, out_request->pid);
return -1;
}
} else if (cr.uid == 0
|| (cr.uid == AID_SYSTEM && msg.action == DEBUGGER_ACTION_DUMP_BACKTRACE)) {
// Only root or system can ask us to attach to any process and dump it explicitly.
// However, system is only allowed to collect backtraces but cannot dump tombstones.
status = get_process_info(out_request->tid, &out_request->pid,
&out_request->uid, &out_request->gid);
if (status < 0) {
ALOGE("tid %d does not exist. ignoring explicit dump request\n", out_request->tid);
return -1;
}
if (!selinux_action_allowed(fd, out_request->tid, out_request->action))
return -1;
} else {
// No one else is allowed to dump arbitrary processes.
return -1;
}
return 0;
}
inline process_id_t getn_process(int n) { return get_process_info(n, NULL); }
int
main(int argc, char *argv[])
{
char *env_top;
char **preset_argv;
int preset_argc = 0;
void *mask;
int need_mini = 1;
struct statics statics;
globalstate *gstate;
/* get our name */
if (argc > 0)
{
if ((myname = strrchr(argv[0], '/')) == 0)
{
myname = argv[0];
}
else
{
myname++;
}
}
/* binary compatibility check */
#ifdef HAVE_UNAME
{
struct utsname uts;
if (uname(&uts) == 0)
{
if (strcmp(uts.machine, UNAME_HARDWARE) != 0)
{
fprintf(stderr, "%s: incompatible hardware platform\n",
myname);
exit(EX_UNAVAILABLE);
}
}
}
#endif
/* initialization */
gstate = (globalstate *)calloc(1, sizeof(globalstate));
gstate->statics = &statics;
time_mark(NULL);
/* preset defaults for various options */
gstate->show_usernames = Yes;
gstate->topn = DEFAULT_TOPN;
gstate->delay = DEFAULT_DELAY;
gstate->fulldraw = Yes;
gstate->use_color = Yes;
gstate->interactive = Maybe;
/* preset defaults for process selection */
gstate->pselect.idle = Yes;
gstate->pselect.system = No;
gstate->pselect.fullcmd = No;
gstate->pselect.command = NULL;
gstate->pselect.uid = -1;
gstate->pselect.mode = 0;
/* use a large buffer for stdout */
#ifdef HAVE_SETVBUF
setvbuf(stdout, stdoutbuf, _IOFBF, BUFFERSIZE);
#else
#ifdef HAVE_SETBUFFER
setbuffer(stdout, stdoutbuf, BUFFERSIZE);
#endif
#endif
/* get preset options from the environment */
if ((env_top = getenv("TOP")) != NULL)
{
preset_argv = argparse(env_top, &preset_argc);
preset_argv[0] = myname;
do_arguments(gstate, preset_argc, preset_argv);
}
/* process arguments */
do_arguments(gstate, argc, argv);
#ifdef ENABLE_COLOR
/* If colour has been turned on read in the settings. */
env_top = getenv("TOPCOLOURS");
if (!env_top)
{
env_top = getenv("TOPCOLORS");
}
/* must do something about error messages */
color_env_parse(env_top);
color_activate(gstate->use_color);
#endif
/* in order to support forward compatability, we have to ensure that
the entire statics structure is set to a known value before we call
machine_init. This way fields that a module does not know about
will retain their default values */
memzero((void *)&statics, sizeof(statics));
statics.boottime = -1;
/* call the platform-specific init */
if (machine_init(&statics) == -1)
{
exit(EX_SOFTWARE);
}
/* create a helper list of sort order names */
gstate->order_namelist = string_list(statics.order_names);
/* look up chosen sorting order */
if (gstate->order_name != NULL)
{
int i;
if (statics.order_names == NULL)
{
message_error(" This platform does not support arbitrary ordering");
}
else if ((i = string_index(gstate->order_name,
statics.order_names)) == -1)
{
message_error(" Sort order `%s' not recognized", gstate->order_name);
message_error(" Recognized sort orders: %s", gstate->order_namelist);
}
else
{
gstate->order_index = i;
}
}
/* initialize extensions */
init_username();
/* initialize termcap */
gstate->smart_terminal = screen_readtermcap(gstate->interactive);
/* determine interactive state */
if (gstate->interactive == Maybe)
{
gstate->interactive = smart_terminal;
}
/* if displays were not specified, choose an appropriate default */
if (gstate->displays == 0)
{
gstate->displays = gstate->smart_terminal ? Infinity: 1;
}
/* we don't need a mini display when delay is less than 2
seconds or when we are not on a smart terminal */
if (gstate->delay <= 1 || !smart_terminal)
{
need_mini = 0;
}
/* set constants for username/uid display */
if (gstate->show_usernames)
{
gstate->header_text = format_header("USERNAME");
gstate->get_userid = username;
}
else
{
gstate->header_text = format_header(" UID ");
gstate->get_userid = itoa7;
}
gstate->pselect.usernames = gstate->show_usernames;
/* initialize display */
if ((gstate->max_topn = display_init(&statics)) == -1)
{
fprintf(stderr, "%s: can't allocate sufficient memory\n", myname);
exit(EX_OSERR);
}
/* check for infinity and for overflowed screen */
if (gstate->topn == Infinity)
{
gstate->topn = INT_MAX;
}
else if (gstate->topn > gstate->max_topn)
{
#if 0
message_error(" This terminal can only display %d processes",
gstate->max_topn);
#endif
}
#ifdef ENABLE_COLOR
/* producing a list of color tags is easy */
if (gstate->show_tags)
{
color_dump(stdout);
exit(EX_OK);
}
#endif
/* hold all signals while we initialize the screen */
mask = hold_signals();
screen_init();
/* set the signal handlers */
set_signals();
/* longjmp re-entry point */
/* set the jump buffer for long jumps out of signal handlers */
if (setjmp(jmp_int) != 0)
{
/* this is where we end up after processing sigwinch or sigtstp */
/* tell display to resize its buffers, and get the new length */
if ((gstate->max_topn = display_resize()) == -1)
{
/* thats bad */
quit(EX_OSERR);
/*NOTREACHED*/
}
/* set up for a full redraw, and get the current line count */
gstate->fulldraw = Yes;
/* safe to release the signals now */
release_signals(mask);
}
else
{
/* release the signals */
release_signals(mask);
/* some systems require a warmup */
/* always do a warmup for batch mode */
if (gstate->interactive == 0 || statics.flags.warmup)
{
struct system_info system_info;
struct timeval timeout;
time_mark(&(gstate->now));
get_system_info(&system_info);
(void)get_process_info(&system_info, &gstate->pselect, 0);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
select(0, NULL, NULL, NULL, &timeout);
/* if we've warmed up, then we can show good states too */
gstate->show_cpustates = Yes;
need_mini = 0;
}
}
/* main loop */
while ((gstate->displays == -1) || (--gstate->displays > 0))
{
do_display(gstate);
if (gstate->interactive)
{
if (need_mini)
{
do_minidisplay(gstate);
need_mini = 0;
}
do_command(gstate);
}
else
{
do_wait(gstate);
}
}
/* do one last display */
do_display(gstate);
quit(EX_OK);
/* NOTREACHED */
return 1; /* Keep compiler quiet. */
}
void
do_display(globalstate *gstate)
{
int active_procs;
int i;
time_t curr_time;
caddr_t processes;
struct system_info system_info;
char *hdr;
/* get the time */
time_mark(&(gstate->now));
curr_time = (time_t)(gstate->now.tv_sec);
/* get the current stats */
get_system_info(&system_info);
/* get the current processes */
processes = get_process_info(&system_info, &(gstate->pselect), gstate->order_index);
/* determine number of processes to actually display */
if (gstate->topn > 0)
{
/* this number will be the smallest of: active processes,
number user requested, number current screen accomodates */
active_procs = system_info.P_ACTIVE;
if (active_procs > gstate->topn)
{
active_procs = gstate->topn;
}
if (active_procs > gstate->max_topn)
{
active_procs = gstate->max_topn;
}
}
else
{
/* dont show any */
active_procs = 0;
}
hdr = gstate->header_text;
/* full screen or update? */
if (gstate->fulldraw)
{
display_clear();
i_loadave(system_info.last_pid, system_info.load_avg);
i_uptime(&(gstate->statics->boottime), &curr_time);
i_timeofday(&curr_time);
i_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads);
if (gstate->show_cpustates)
{
i_cpustates(system_info.cpustates);
}
else
{
if (smart_terminal)
{
z_cpustates();
}
gstate->show_cpustates = Yes;
}
i_kernel(system_info.kernel);
i_memory(system_info.memory);
i_swap(system_info.swap);
i_message(&(gstate->now));
i_header(hdr);
for (i = 0; i < active_procs; i++)
{
i_process(i, format_next_process(processes, gstate->get_userid));
}
i_endscreen();
if (gstate->smart_terminal)
{
gstate->fulldraw = No;
}
}
else
{
u_loadave(system_info.last_pid, system_info.load_avg);
u_uptime(&(gstate->statics->boottime), &curr_time);
i_timeofday(&curr_time);
u_procstates(system_info.p_total, system_info.procstates, gstate->pselect.threads);
u_cpustates(system_info.cpustates);
u_kernel(system_info.kernel);
u_memory(system_info.memory);
u_swap(system_info.swap);
u_message(&(gstate->now));
u_header(hdr);
for (i = 0; i < active_procs; i++)
{
u_process(i, format_next_process(processes, gstate->get_userid));
}
u_endscreen();
}
}
