X-Git-Url: https://git.saurik.com/apple/libc.git/blobdiff_plain/224c70764cab4e0e39a26aaf3ad3016552f62f55..ad3c9f2af814c84582fdd1649e49ec4f68572c5a:/darwin/libproc.c diff --git a/darwin/libproc.c b/darwin/libproc.c index ba2305c..9879aaa 100644 --- a/darwin/libproc.c +++ b/darwin/libproc.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2006, 2010 Apple Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * @@ -28,10 +28,14 @@ #include #include #include +#define CONFIG_EMBEDDED 1 +#include -#include "libproc.h" +#include "libproc_internal.h" int __proc_info(int callnum, int pid, int flavor, uint64_t arg, void * buffer, int buffersize); +__private_extern__ int proc_setthreadname(void * buffer, int buffersize); +int __process_policy(int scope, int action, int policy, int policy_subtype, proc_policy_attribute_t * attrp, pid_t target_pid, uint64_t target_threadid); @@ -40,7 +44,7 @@ proc_listpids(uint32_t type, uint32_t typeinfo, void *buffer, int buffersize) { int retval; - if ((type == PROC_ALL_PIDS) || (type == PROC_PGRP_ONLY) || (type == PROC_TTY_ONLY) || (type == PROC_UID_ONLY) || (type == PROC_RUID_ONLY)) { + if ((type >= PROC_ALL_PIDS) || (type <= PROC_PPID_ONLY)) { if ((retval = __proc_info(1, type, typeinfo,(uint64_t)0, buffer, buffersize)) == -1) return(0); } else { @@ -51,6 +55,41 @@ proc_listpids(uint32_t type, uint32_t typeinfo, void *buffer, int buffersize) } +int +proc_listallpids(void * buffer, int buffersize) +{ + int numpids; + numpids = proc_listpids(PROC_ALL_PIDS, (uint32_t)0, buffer, buffersize); + + if (numpids == -1) + return(-1); + else + return(numpids/sizeof(int)); +} + +int +proc_listpgrppids(pid_t pgrpid, void * buffer, int buffersize) +{ + int numpids; + numpids = proc_listpids(PROC_PGRP_ONLY, (uint32_t)pgrpid, buffer, buffersize); + if (numpids == -1) + return(-1); + else + return(numpids/sizeof(int)); +} + +int +proc_listchildpids(pid_t ppid, void * buffer, int buffersize) +{ + int numpids; + numpids = proc_listpids(PROC_PPID_ONLY, (uint32_t)ppid, buffer, buffersize); + if (numpids == -1) + return(-1); + else + return(numpids/sizeof(int)); +} + + int proc_pidinfo(int pid, int flavor, uint64_t arg, void *buffer, int buffersize) { @@ -75,6 +114,16 @@ proc_pidfdinfo(int pid, int fd, int flavor, void * buffer, int buffersize) } +int +proc_pidfileportinfo(int pid, uint32_t fileport, int flavor, void *buffer, int buffersize) +{ + int retval; + + if ((retval = __proc_info(6, pid, flavor, (uint64_t)fileport, buffer, buffersize)) == -1) + return (0); + return (retval); +} + int proc_name(int pid, void * buffer, uint32_t buffersize) @@ -83,15 +132,19 @@ proc_name(int pid, void * buffer, uint32_t buffersize) struct proc_bsdinfo pbsd; - if (buffersize < 2*MAXCOMLEN) { + if (buffersize < sizeof(pbsd.pbi_name)) { errno = ENOMEM; return(0); } retval = proc_pidinfo(pid, PROC_PIDTBSDINFO, (uint64_t)0, &pbsd, sizeof(struct proc_bsdinfo)); - if (retval != -1) { - bcopy(&pbsd.pbi_name, buffer, 2* 2*MAXCOMLEN); - len = strlen(&pbsd.pbi_name[0]); + if (retval != 0) { + if (pbsd.pbi_name[0]) { + bcopy(&pbsd.pbi_name, buffer, sizeof(pbsd.pbi_name)); + } else { + bcopy(&pbsd.pbi_comm, buffer, sizeof(pbsd.pbi_comm)); + } + len = strlen(buffer); return(len); } return(0); @@ -156,7 +209,8 @@ proc_pidpath(int pid, void * buffer, uint32_t buffersize) } -int proc_libversion(int *major, int * minor) +int +proc_libversion(int *major, int * minor) { if (major != NULL) @@ -166,3 +220,313 @@ int proc_libversion(int *major, int * minor) return(0); } +int +proc_setpcontrol(const int control) +{ + int retval ; + + if (control < PROC_SETPC_NONE || control > PROC_SETPC_TERMINATE) + return(EINVAL); + + if ((retval = __proc_info(5, getpid(), PROC_SELFSET_PCONTROL, (uint64_t)control, NULL, 0)) == -1) + return(errno); + + return(0); +} + + +__private_extern__ int +proc_setthreadname(void * buffer, int buffersize) +{ + int retval; + + retval = __proc_info(5, getpid(), PROC_SELFSET_THREADNAME, (uint64_t)0, buffer, buffersize); + + if (retval == -1) + return(errno); + else + return(0); +} + +int +proc_track_dirty(pid_t pid, uint32_t flags) +{ + if (__proc_info(8, pid, PROC_DIRTYCONTROL_TRACK, flags, NULL, 0) == -1) { + return errno; + } + + return 0; +} + +int +proc_set_dirty(pid_t pid, bool dirty) +{ + if (__proc_info(8, pid, PROC_DIRTYCONTROL_SET, dirty, NULL, 0) == -1) { + return errno; + } + + return 0; +} + +int +proc_get_dirty(pid_t pid, uint32_t *flags) +{ + int retval; + + if (!flags) { + return EINVAL; + } + + retval = __proc_info(8, pid, PROC_DIRTYCONTROL_GET, 0, NULL, 0); + if (retval == -1) { + return errno; + } + + *flags = retval; + + return 0; +} + +int +proc_terminate(pid_t pid, int *sig) +{ + int retval; + + if (!sig) { + return EINVAL; + } + + retval = __proc_info(7, pid, 0, 0, NULL, 0); + if (retval == -1) { + return errno; + } + + *sig = retval; + + return 0; +} + +#if TARGET_OS_EMBEDDED + +int +proc_setcpu_percentage(pid_t pid, int action, int percentage) +{ + proc_policy_cpuusage_attr_t attr; + + bzero(&attr, sizeof(proc_policy_cpuusage_attr_t)); + attr.ppattr_cpu_attr = action; + attr.ppattr_cpu_percentage = percentage; + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_RESOURCE_USAGE, PROC_POLICY_RUSAGE_CPU, &attr, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); +} + +int +proc_setcpu_deadline(pid_t pid, int action, uint64_t deadline) +{ + proc_policy_cpuusage_attr_t attr; + + bzero(&attr, sizeof(proc_policy_cpuusage_attr_t)); + attr.ppattr_cpu_attr = action; + attr.ppattr_cpu_attr_deadline = deadline; + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_RESOURCE_USAGE, PROC_POLICY_RUSAGE_CPU, &attr, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); + +} + + +int +proc_setcpu_percentage_withdeadline(pid_t pid, int action, int percentage, uint64_t deadline) +{ + proc_policy_cpuusage_attr_t attr; + + bzero(&attr, sizeof(proc_policy_cpuusage_attr_t)); + attr.ppattr_cpu_attr = action; + attr.ppattr_cpu_percentage = percentage; + attr.ppattr_cpu_attr_deadline = deadline; + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_RESOURCE_USAGE, PROC_POLICY_RUSAGE_CPU, &attr, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); +} + +int +proc_clear_cpulimits(pid_t pid) +{ + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_RESTORE, PROC_POLICY_RESOURCE_USAGE, PROC_POLICY_RUSAGE_CPU, NULL, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); + + +} + +int +proc_appstate(int pid, int * appstatep) +{ + int state; + + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_GET, PROC_POLICY_APP_LIFECYCLE, PROC_POLICY_APPLIFE_STATE, (int *)&state, pid, (uint64_t)0) != -1) { + if (appstatep != NULL) + *appstatep = state; + return(0); + } else + return(errno); + +} + + +int +proc_setappstate(int pid, int appstate) +{ + int state = appstate; + + switch (state) { + case PROC_APPSTATE_NONE: + case PROC_APPSTATE_ACTIVE: + case PROC_APPSTATE_INACTIVE: + case PROC_APPSTATE_BACKGROUND: + case PROC_APPSTATE_NONUI: + break; + default: + return(EINVAL); + } + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_APP_LIFECYCLE, PROC_POLICY_APPLIFE_STATE, (int *)&state, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); +} + +int +proc_devstatusnotify(int devicestatus) +{ + int state = devicestatus; + + switch (devicestatus) { + case PROC_DEVSTATUS_SHORTTERM: + case PROC_DEVSTATUS_LONGTERM: + break; + default: + return(EINVAL); + } + + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_APP_LIFECYCLE, PROC_POLICY_APPLIFE_DEVSTATUS, (int *)&state, getpid(), (uint64_t)0) != -1) { + return(0); + } else + return(errno); + +} + +int +proc_pidbind(int pid, uint64_t threadid, int bind) +{ + int state = bind; + pid_t passpid = pid; + + switch (bind) { + case PROC_PIDBIND_CLEAR: + passpid = getpid(); /* ignore pid on clear */ + break; + case PROC_PIDBIND_SET: + break; + default: + return(EINVAL); + } + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_APPLY, PROC_POLICY_APP_LIFECYCLE, PROC_POLICY_APPLIFE_PIDBIND, (int *)&state, passpid, threadid) != -1) + return(0); + else + return(errno); +} + +#else /* TARGET_OS_EMBEDDED */ + +int +proc_clear_vmpressure(pid_t pid) +{ + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_RESTORE, PROC_POLICY_RESOURCE_STARVATION, PROC_POLICY_RS_VIRTUALMEM, NULL, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); +} + +/* set the current process as one who can resume suspended processes due to low virtual memory. Need to be root */ +int +proc_set_owner_vmpressure(void) +{ + int retval; + + if ((retval = __proc_info(5, getpid(), PROC_SELFSET_VMRSRCOWNER, (uint64_t)0, NULL, 0)) == -1) + return(errno); + + return(0); +} + +/* mark yourself to delay idle sleep on disk IO */ +int +proc_set_delayidlesleep(void) +{ + int retval; + + if ((retval = __proc_info(5, getpid(), PROC_SELFSET_DELAYIDLESLEEP, (uint64_t)1, NULL, 0)) == -1) + return(errno); + + return(0); +} + +/* Reset yourself to delay idle sleep on disk IO, if already set */ +int +proc_clear_delayidlesleep(void) +{ + int retval; + + if ((retval = __proc_info(5, getpid(), PROC_SELFSET_DELAYIDLESLEEP, (uint64_t)0, NULL, 0)) == -1) + return(errno); + + return(0); +} + +/* disable the launch time backgroudn policy and restore the process to default group */ +int +proc_disable_apptype(pid_t pid, int apptype) +{ + switch (apptype) { + case PROC_POLICY_OSX_APPTYPE_TAL: + case PROC_POLICY_OSX_APPTYPE_DASHCLIENT: + break; + default: + return(EINVAL); + + } + + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_DISABLE, PROC_POLICY_APPTYPE, apptype, NULL, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); + +} + +/* re-enable the launch time background policy if it had been disabled. */ +int +proc_enable_apptype(pid_t pid, int apptype) +{ + switch (apptype) { + case PROC_POLICY_OSX_APPTYPE_TAL: + case PROC_POLICY_OSX_APPTYPE_DASHCLIENT: + break; + default: + return(EINVAL); + + } + + if (__process_policy(PROC_POLICY_SCOPE_PROCESS, PROC_POLICY_ACTION_ENABLE, PROC_POLICY_APPTYPE, apptype, NULL, pid, (uint64_t)0) != -1) + return(0); + else + return(errno); + +} + +#endif /* TARGET_OS_EMBEDDED */ +