/* The type proc_stat_t, which holds information about a hurd process. Copyright (C) 1995 Free Software Foundation, Inc. Written by Miles Bader 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, 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. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include "ps.h" #include "common.h" /* ---------------------------------------------------------------- */ /* These directly correspond to the bits in a state, starting from 0. See ps.h for an explanation of what each of these means. */ char *proc_stat_state_tags = "RTHDSIWNrun_state) { case TH_STATE_RUNNING: state |= PSTAT_STATE_RUNNING; break; case TH_STATE_STOPPED: state |= PSTAT_STATE_STOPPED; break; case TH_STATE_UNINTERRUPTIBLE: state |= PSTAT_STATE_WAIT; break; case TH_STATE_HALTED: state |= PSTAT_STATE_HALTED; break; case TH_STATE_WAITING: /* Act like unix: waits of less than 20 seconds means a process is `sleeping' and >= 20 seconds means it's `idle' */ state |= bi->sleep_time < 20 ? PSTAT_STATE_SLEEPING : PSTAT_STATE_IDLE; break; } if (bi->base_priority < 12) state |= PSTAT_STATE_PRIORITY; else if (bi->base_priority > 12) state |= PSTAT_STATE_NICED; if (bi->flags & TH_FLAGS_SWAPPED) state |= PSTAT_STATE_SWAPPED; return state; } /* ---------------------------------------------------------------- */ /* Add FLAGS to PS's flags, fetching information as necessary to validate the corresponding fields in PS. Afterwards you must still check the flags field before using new fields, as something might have failed. Returns a system error code if a fatal error occurred, or 0 if none. */ error_t proc_stat_set_flags(proc_stat_t ps, int flags) { error_t err; int have = ps->flags; /* flags set in ps */ int need; /* flags not set in ps, but desired to be */ process_t server = ps_context_server(ps->context); /* Implement any inter-flag dependencies: if the new flags in FLAGS depend on some other set of flags to be set, make sure those are also in FLAGS. */ if (flags & PSTAT_TTY) flags |= PSTAT_CTTYID; if (flags & PSTAT_STATE) flags |= PSTAT_EXEC_FLAGS; /* For the traced bit. */ if (flags & (PSTAT_CTTYID | PSTAT_CWDIR | PSTAT_AUTH | PSTAT_UMASK | PSTAT_EXEC_FLAGS)) { flags |= PSTAT_MSGPORT; flags |= PSTAT_TASK; /* for authentication */ } if (flags & (PSTAT_THREAD_INFO | PSTAT_STATE | PSTAT_OWNER)) flags |= PSTAT_INFO; if (flags & PSTAT_TASK_EVENTS_INFO) flags |= PSTAT_TASK; need = flags & ~have; /* MGET: If we're trying to set FLAG, and the preconditions PRECOND are set in the flags already, then eval CALL and set ERR to the result. If the resulting ERR is 0 add FLAG to the set of valid flags. ERR is returned. */ #define MGET(flag, precond, call) \ ((!(need & (flag)) || (have & (precond)) != (precond)) \ ? 0 \ : ((((err = (call)) == 0) \ ? (have |= (flag)) \ : 0), \ err)) /* The process's process port. */ MGET(PSTAT_PROCESS, PSTAT_PID, proc_pid2proc(server, ps->pid, &ps->process)); /* The process's task port. */ MGET(PSTAT_TASK, PSTAT_PID, proc_pid2task(server, ps->pid, &ps->task)); /* The process's libc msg port (see ). */ MGET(PSTAT_MSGPORT, PSTAT_PID, proc_getmsgport(server, ps->pid, &ps->msgport)); /* the process's struct procinfo as returned by proc_getprocinfo. */ if ((need & PSTAT_INFO) && (have & PSTAT_PID)) { ps->info_size = 0; if (proc_getprocinfo(server, ps->pid, (int **)&ps->info, &ps->info_size) == 0) have |= PSTAT_INFO; } /* A summary of the proc's thread_{basic,sched}_info_t structures: sizes and cumulative times are summed, prioritys and delta time are averaged. The run_states are added by having running thread take precedence over waiting ones, and if there are any other incompatible states, simply using a bogus value of -1 */ if ((need & PSTAT_THREAD_INFO) && (have & PSTAT_INFO)) { int i; struct procinfo *pi = ps->info; thread_sched_info_t tsi = &ps->thread_sched_info; thread_basic_info_t tbi = &ps->thread_basic_info; bzero(tbi, sizeof *tbi); bzero(tsi, sizeof *tsi); for (i = 0; i < pi->nthreads; i++) { thread_basic_info_t bi = &pi->threadinfos[i].pis_bi; thread_sched_info_t si = &pi->threadinfos[i].pis_si; int thread_run_state = bi->run_state; /* Construct some aggregate run-state for the process: besides the defined thread run_states, we use 0 to mean no threads, and -1 to mean two threads have conflicting run_stats. */ if (tbi->run_state == 0) /* No prior state, just copy this thread's. */ tbi->run_state = thread_run_state; else if (tbi->run_state == TH_STATE_RUNNING || thread_run_state == TH_STATE_RUNNING) /* If any thread is running, mark the process as running. */ tbi->run_state = TH_STATE_RUNNING; else if (tbi->run_state != bi->run_state) /* Otherwise there are two conflicting non-running states, so just give up and say we don't know. */ tbi->run_state = -1; tsi->base_priority += si->base_priority; tsi->cur_priority += si->cur_priority; tbi->cpu_usage += bi->cpu_usage; tbi->sleep_time += bi->sleep_time; tbi->user_time.seconds += bi->user_time.seconds; tbi->user_time.microseconds += bi->user_time.microseconds; tbi->system_time.seconds += bi->system_time.seconds; tbi->system_time.microseconds += bi->system_time.microseconds; } if (pi->nthreads > 0) { tsi->base_priority /= pi->nthreads; tsi->cur_priority /= pi->nthreads; tbi->sleep_time /= pi->nthreads; } tbi->user_time.seconds += tbi->user_time.microseconds / 1000000; tbi->user_time.microseconds %= 1000000; tbi->system_time.seconds += tbi->system_time.microseconds / 1000000; tbi->system_time.microseconds %= 1000000; have |= PSTAT_THREAD_INFO; } /* VM statistics for the task. See . */ if ((need & PSTAT_TASK_EVENTS_INFO) && (have & PSTAT_TASK)) { ps->task_events_info = &ps->task_events_info_buf; ps->task_events_info_size = TASK_EVENTS_INFO_COUNT; if (task_info(ps->task, TASK_EVENTS_INFO, (task_info_t)&ps->task_events_info, &ps->task_events_info_size) == 0) have |= PSTAT_TASK_EVENTS_INFO; } /* Get the process's exec flags (see ). */ MGET(PSTAT_EXEC_FLAGS, PSTAT_MSGPORT | PSTAT_TASK, msg_get_exec_flags(ps->msgport, ps->task, &ps->exec_flags)); /* PSTAT_STATE_ bits for the process and all its threads. */ if ((need & PSTAT_STATE) && (have & PSTAT_INFO)) { int i; int state = 0; struct procinfo *pi = ps->info; int pi_flags = pi->state; /* The union of all thread state bits... */ for (i = 0; i < pi->nthreads; i++) state |= thread_state(&pi->threadinfos[i].pis_bi); /* ... and process-only state bits. */ if (pi_flags & PI_ZOMBIE) state |= PSTAT_STATE_ZOMBIE; if (pi_flags & PI_SESSLD) state |= PSTAT_STATE_SESSLDR; if (pi_flags & PI_EXECED) state |= PSTAT_STATE_EXECED; if (pi_flags & PI_NOMSG) state |= PSTAT_STATE_NOMSG; if (pi_flags & PI_NOPARENT) state |= PSTAT_STATE_NOPARENT; if (pi_flags & PI_ORPHAN) state |= PSTAT_STATE_ORPHANED; if ((have & PSTAT_EXEC_FLAGS) & (ps->exec_flags & EXEC_TRACED)) state |= PSTAT_STATE_TRACED; ps->state = state; have |= PSTAT_STATE; } /* The process's exec arguments */ if ((need & PSTAT_ARGS) && (have & PSTAT_PID)) { ps->args_len = 0; if (proc_getprocargs(server, ps->pid, &ps->args, &ps->args_len)) ps->args_len = 0; else have |= PSTAT_ARGS; } /* The ctty id port; note that this is just a magic cookie; we use it to fetch a port to the actual terminal -- it's not useful for much else. */ MGET(PSTAT_CTTYID, PSTAT_MSGPORT | PSTAT_TASK, msg_get_init_port(ps->msgport, ps->task, INIT_PORT_CTTYID, &ps->cttyid)); /* A port to the process's current working directory. */ MGET(PSTAT_CWDIR, PSTAT_MSGPORT | PSTAT_TASK, msg_get_init_port(ps->msgport, ps->task, INIT_PORT_CWDIR, &ps->cwdir)); /* The process's auth port, which we can use to determine who the process is authenticated as. */ MGET(PSTAT_AUTH, PSTAT_MSGPORT | PSTAT_TASK, msg_get_init_port(ps->msgport, ps->task, INIT_PORT_AUTH, &ps->auth)); /* The process's umask, which controls which protection bits won't be set when creating a file. */ MGET(PSTAT_UMASK, PSTAT_MSGPORT | PSTAT_TASK, msg_get_init_int(ps->msgport, ps->task, INIT_UMASK, &ps->umask)); /* A ps_user_t object for the process's owner. */ if ((need & PSTAT_OWNER) && (have & PSTAT_INFO)) if (ps_context_find_user(ps->context, ps->info->owner, &ps->owner) == 0) have |= PSTAT_OWNER; /* A ps_tty_t for the process's controlling terminal, or NULL if it doesn't have one. */ if ((need & PSTAT_TTY) && (have & PSTAT_CTTYID)) if (ps_context_find_tty_by_cttyid(ps->context, ps->cttyid, &ps->tty) == 0) have |= PSTAT_TTY; ps->flags = have; return 0; } /* ---------------------------------------------------------------- */ /* Discard PS and any resources it holds. */ void _proc_stat_free(ps) proc_stat_t ps; { /* Free the mach port PORT if FLAG is set in PS's flags. */ #define MFREEPORT(flag, port) \ ((ps->flags & (flag)) \ ? mach_port_deallocate(mach_task_self(), (ps->port)) : 0) /* If FLAG is set in PS's flags, vm_deallocate MEM, consisting of SIZE elements of type ELTYPE, *unless* MEM == SBUF, which usually means that MEM points to a static buffer somewhere instead of vm_alloc'd memory. */ #define MFREEVM(flag, mem, size, sbuf, eltype) \ (((ps->flags & (flag)) && ps->mem != sbuf) \ ? (VMFREE(ps->mem, ps->size * sizeof(eltype))) : 0) /* free PS's ports */ MFREEPORT(PSTAT_PROCESS, process); MFREEPORT(PSTAT_TASK, task); MFREEPORT(PSTAT_MSGPORT, msgport); MFREEPORT(PSTAT_CTTYID, cttyid); MFREEPORT(PSTAT_CWDIR, cwdir); MFREEPORT(PSTAT_AUTH, auth); /* free any allocated memory pointed to by PS */ MFREEVM(PSTAT_INFO, info, info_size, 0, char); MFREEVM(PSTAT_ARGS, args, args_len, 0, char); MFREEVM(PSTAT_TASK_EVENTS_INFO, task_events_info, task_events_info_size, &ps->task_events_info_buf, char); FREE(ps); } /* Returns in PS a new proc_stat_t for the process PID at the process context CONTEXT. If a memory allocation error occurs, ENOMEM is returned, otherwise 0. */ error_t _proc_stat_create(int pid, ps_context_t context, proc_stat_t *ps) { *ps = NEW(struct proc_stat); if (*ps == NULL) return ENOMEM; (*ps)->pid = pid; (*ps)->flags = PSTAT_PID; (*ps)->context = context; return 0; } /* ---------------------------------------------------------------- */ /* Returns in THREAD_PS a proc_stat_t for the Nth thread in the proc_stat_t PS (N should be between 0 and the number of threads in the process). The resulting proc_stat_t isn't fully functional -- most flags can't be set in it. It also contains a pointer to PS, so PS shouldn't be freed without also freeing THREAD_PS. If N was out of range, EINVAL is returned. If a memory allocation error occured, ENOMEM is returned. Otherwise, 0 is returned. */ error_t proc_stat_thread_create(proc_stat_t ps, int index, proc_stat_t *thread_ps) { error_t err = proc_stat_set_flags(ps, PSTAT_THREAD_INFO); if (err) return err; else if (index < 0 || index >= ps->info->nthreads) return EINVAL; else { proc_stat_t tps = NEW(struct proc_stat); if (tps == NULL) return ENOMEM; /* A value of -1 for the PID indicates that this is a thread. */ tps->pid = -1; /* TPS is initialized with these values; any attempts to set other flags will fail because PSTAT_PID isn't one of them. */ tps->flags = PSTAT_THREAD | PSTAT_THREAD_INFO | PSTAT_STATE; bcopy(&ps->info->threadinfos[index].pis_bi, &tps->thread_basic_info, sizeof(thread_basic_info_data_t)); bcopy(&ps->info->threadinfos[index].pis_si, &tps->thread_sched_info, sizeof(thread_sched_info_data_t)); /* Construct the state with only the per-thread bits. */ tps->state = thread_state(&tps->thread_basic_info); tps->thread_origin = ps; tps->thread_index = index; tps->context = ps->context; *thread_ps = tps; return 0; } }