LIBPROC(3LIB) Interface Libraries LIBPROC(3LIB)


libprocprocess control library


Process Control Library (libproc, -lproc)
#include <libproc.h>


The libproc library provides consumers a general series of interfaces to inspect and control both live processes and core files. It is intended for introspection tools such as debuggers by providing a high-level interface to the /proc file system (proc(4)).
The libproc library provides interfaces that focus on:

Live Processes

The libproc library can be used to manipulate running processes and to create new ones. To manipulate an existing process first grab it with the Pgrab() function. A process is generally stopped as a side effect of grabbing it. Callers must exercise caution, as if they do not use the library correctly, or they terminate unexpectedly, a process may remain stopped.
Unprivileged users may only grab their own processes. Users with the privilege {PRIV_PROC_OWNER} may manipulate processes that they do not own; however, additional restrictions as described in privileges(5) apply.
In addition, the Pcreate() and Pxcreate() functions may be used to create processes which are always controlled by the library.

Core Files

The libproc library has the ability to open and interpret core files produced by processes on the system. Process core dump generation is controlled by the coreadm(1M) command. In addition, the library has the ability to understand and interpret core dumps generated by Linux kernel and can provide a subset of its functionality on such core files, provided the original binary is also present.
Not all functions in the libproc library are valid for core files. In general, none of the commands which manipulate the current state of a process or thread or that try to force system calls on a victim process will work. Furthermore several of the information and iteration interfaces are limited based on the data that is available in the core file. For example, if the core file is of a process that omits the frame pointer, the ability to iterate the stack will be limited.
Use the Pgrab_core() or Pfgrab_core() function to open a core file. Use the Pgrab_file() function to open an ELF object file. This is useful for obtaining information stored in ELF headers and sections.

Debug Information

Many of the operations in the library rely on debug information being present in a process and its associated libraries. The library leverages symbol table information, CTF data (ctf(4)) sections, and frame unwinding information based on the use of an ABI defined frame pointer, e.g. %ebp and %rbp on x86 systems.
Some software providers strip programs of this information or build their executables such that the information will not be present in a core dump. To deal with this fact, the library is able to consume information that is not present in the core file or the running process. It can both consume it from the underlying executable and it also supports finding it from related ELF objects that are linked to it via the .gnu_debuglink and the ELF sections.

Iteration Interfaces

The libproc library provides the ability to iterate over the following aspects of a process or core file:
  • Active threads
  • Active and zombie threads
  • All non-system processes
  • All process mappings
  • All objects in a process
  • The environment
  • The symbol table
  • Stack frames
  • File Descriptors

System Call Injection

The libproc library allows the caller to force system calls to be executed in the context of the running process. This can be used both as a tool for introspection, allowing one to get information outside its current context as well as performing modifications to a process.
These functions run in the context of the calling process. This is often an easier way of getting non-exported information about a process from the system. For example, the pfiles(1) command uses this interface to get more detailed information about a process's open file descriptors, which it would not have access to otherwise.


The shared object provides the public interfaces defined below. See Intro(3) for additional information on shared object interfaces. Functions are organized into categories that describe their purpose. Individual functions are documented in their own manual pages.

Creation, Grabbing, and Releasing

The following routines are related to creating library handles, grabbing cores, processes, and threads, and releasing those resources.
Lfree Lgrab
Lgrab_error Pcreate
Pcreate_agent Pcreate_callback
Pcreate_error Pdestroy_agent
Pfgrab_core Pfree
Pgrab Pgrab_core
Pgrab_error Pgrab_file
Pgrab_ops Prelease
Preopen Pxcreate

Process interrogation and manipulation

The following routines obtain information about a process and allow manipulation of the process itself.
Paddr_to_ctf Paddr_to_loadobj
Paddr_to_map Paddr_to_text_map
Pasfd Pclearfault
Pclearsig Pcontent
Pcred Pctlfd
Pdelbkpt Pdelwapt
Pdstop Pexecname
Pfault Pfgcore
Pgcore Pgetareg
Pgetauxval Pgetauxvec
Pgetenv Pisprocdir
Pissyscall_prev Plmid
Plmid_to_loadobj Plmid_to_map
Plookup_by_addr Plookup_by_name
Plwp_alt_stack Plwp_getfpregs
Plwp_getname Plwp_getpsinfo
Plwp_getregs Plwp_getspymaster
Plwp_main_stack Plwp_setfpregs
Plwp_setregs Plwp_stack
Pname_to_ctf Pname_to_loadobj
Pname_to_map Pobjname
Pobjname_resolved Pplatform
Ppltdest Ppriv
Ppsinfo Pputareg
Prd_agent Pread
Pread_string Preset_maps
Psetbkpt Psecflags
Psetcred Psetfault
Psetflags Psetpriv
Psetrun Psetsignal
Psetsysentry Psetsysexit
Psetwapt Psetzoneid
Psignal Pstate
Pstatus Pstop
Pstopstatus Psync
Psysentry Psysexit
Puname Punsetflags
Pupdate_maps Pupdate_syms
Pwait Pwrite
Pxecbkpt Pxecwapt
Pxlookup_by_addr Pxlookup_by_addr_resolved
Pxlookup_by_name Pzonename
Pzonepath Pzoneroot

Thread interrogation and manipulation

The following routines obtain information about a thread and allow manipulation of the thread itself.
Lalt_stack Lclearfault
Lclearsig Lctlfd
Ldstop Lgetareg
Lmain_stack Lprochandle
Lpsinfo Lputareg
Lsetrun Lstack
Lstate Lstatus
Lstop Lsync
Lwait Lxecbkpt

System Call Injection

The following routines are used to inject specific system calls and have them run in the context of a process.
pr_access pr_close
pr_creat pr_door_info
pr_exit pr_fcntl
pr_fstat pr_fstat64
pr_fstatvfs pr_getitimer
pr_getpeername pr_getpeerucred
pr_getprojid pr_getrctl
pr_getrlimit pr_getrlimit64
pr_getsockname pr_getsockopt
pr_gettaskid pr_getzoneid
pr_ioctl pr_link
pr_llseek pr_lseek
pr_lstat pr_lstat64
pr_memcntl pr_meminfo
pr_mmap pr_munmap
pr_open pr_processor_bind
pr_rename pr_setitimer
pr_setrctl pr_setrlimit
pr_setrlimit64 pr_settaskid
pr_sigaction pr_stat
pr_stat64 pr_statvfs
pr_unlink pr_waitid

Iteration routines

These routines are used to iterate over the contents of a process.
Penv_iter Plwp_iter
Plwp_iter_all Pmapping_iter
Pmapping_iter_resolved Pobject_iter
Pobject_iter_resolved Pstack_iter
Psymbol_iter Psymbol_iter_by_addr
Psymbol_iter_by_lmid Psymbol_iter_by_name
Pxsymbol_iter Pfdinfo_iter

Utility routines

The following routines are utilities that are useful to consumers of the library.
Perror_printf proc_arg_grab
proc_arg_psinfo proc_arg_xgrab
proc_arg_xpsinfo proc_content2str
proc_finistdio proc_fltname
proc_fltset2str proc_flushstdio
proc_get_auxv proc_get_cred
proc_get_priv proc_get_psinfo
proc_get_status proc_initstdio
proc_lwp_in_set proc_lwp_range_valid
proc_signame proc_sigset2str
proc_str2content proc_str2flt
proc_str2fltset proc_str2sig
proc_str2sigset proc_str2sys
proc_str2sysset proc_sysname
proc_sysset2str proc_unctrl_psinfo

x86 Specific Routines

The following routines are specific to the x86, 32-bit and 64-bit, versions of the libproc library.
Pldt proc_get_ldt

SPARC specific Routines

The following functions are specific to the SPARC, 32-bit and 64-bit, versions of the libproc library.
Plwp_getgwindows Plwp_getxregs
The following functions are specific to the 64-bit SPARC version of the libproc library.
Plwp_getasrs Plwp_setasrs


Every process handle that exists in libproc has a state. In some cases, such as for core files, these states are static. In other cases, such as handles that correspond to a running process or a created process, these states are dynamic and change based on actions taken in the library. The state can be obtained with the Pstate(3PROC) function.
The various states are:
An actively running process. This may be a process that was obtained by creating it with functions such as Pcreate(3PROC) or by grabbing an existing process such as Pgrab(3PROC).
An active process that is no longer executing. A process may stop for many reasons such as an explicit stop request (through pstop(1) for example) or if a tracing event is hit.
The reason a process is stopped may be obtained through the thread's lwpstatus_t structure read directly from /proc or obtained through the Lstatus(3PROC) function.
Control over the process has been lost. This may happen when the process executes a new image requiring a different set of privileges. To resume control call Preopen(3PROC). For more information on losing control of a process, see proc(4).
A zombie process. It has terminated, but it has not been cleaned up yet by its parent. For more on the conditions of becoming a zombie, see exec(2).
Processes in this state are always core files. See the earlier section Core Files for more information on working with core files.
A process that has never been run. This is always the case for handles that refer to files as the files cannot be executed. Those process handles are obtained through calling Pgrab_file(3PROC).
Many functions relating to tracing processes, for example Psignal(3PROC), Psetsignal(3PROC), Psetfault(3PROC), Psysentry(3PROC), and others, mention that they only act upon Active Processes. This specifically refers to processes whose state are in PS_RUN and PS_STOP. Process handles in the other states have no notion of settable tracing flags, though core files (type PS_DEAD) may have a read-only snapshot of their tracing settings available.


The libproc library uses many types that come from the /proc file system (proc(4)) and the ELF format (elf(3ELF)). However, it also defines the following types:
struct ps_prochandle
The struct ps_prochandle is an opaque handle to the library and the core element of control for a process. Consumers obtain pointers to a handle through the use of the Pcreate(), Pgrab(), and related functions. When a caller is done with a handle, then it should call one of the Pfree() and Prelease() functions to relinquish the handle, release associated resources, and potentially set the process to run again.
struct ps_lwphandle
The struct ps_lwphandle is analogous to the struct ps_prochandle, but it represents the control of an individual thread, rather than a process. Consumers obtain pointers to a handle through the Lgrab() function and relinquish it with the Lfree() function.
The core_content_t is a value which describes the various content types of core files. These are used in functions such as Pcontent(3PROC) and Pgcore(3PROC) to describe and control the types of content that get included. Various content types may be included together through a bitwise-inclusive-OR. The default system core contents are controlled with the coreadm(1M) tool. The following table lists the current set of core contents in the system, though the set may increase over time. The string after the macro is the human readable string that corresponds with the constant and is used by coreadm(1M), proc_content2str(3PROC), and proc_str2content(3PROC).
The contents include the process stack. Note, this only covers the main thread's stack. The stack of other threads is covered by CC_CONTENT_ANON.
The contents include the process heap.
The contents include shared mappings that are backed by files (e.g. mapped through mmap(2) with the MAP_SHARED flag).
The contents include shared mappings that are backed by anonymous memory (e.g. mapped through mmap(2) with the MAP_SHARED and MAP_ANON flags).
The contents include private read-only file mappings, such as shared library text.
The contents include private anonymous mappings. This includes the stacks of threads which are not the main thread.
The contents include system V shared memory.
The contents include ISM (intimate shared memory) mappings.
The contents include DISM (dynamic shared memory) mappings.
The contents include ctf(4) (Compact C Type Format) information. Note, not all objects in the process may have CTF information available.
The contents include the symbol table. Note, not all objects in the process may have a symbol table available.
This value indicates that all of the above content values are present. Note that additional values may be added in the future, in which case the value of the symbol will be updated to include them. Comparisons with CC_CONTENT_ALL should validate all the expected bits are set by an expression such as (c & CC_CONTENT_ALL) == CC_CONTENT_ALL.
This value indicates that there is no content present.
The content includes the following set of default values: CC_CONTENT_STACK, CC_CONTENT_HEAP, CC_CONTENT_ISM, CC_CONTENT_DISM, CC_CONTENT_SHM, CC_CONTENT_SHANON, CC_CONTENT_TEXT, CC_CONTENT_DATA, CC_CONTENT_RODATA, CC_CONTENT_ANON, CC_CONTENT_CTF, and CC_CONTENT_SYMTAB. Note that the default may change. Comparisons with CC_CONTENT_DEFAULT should validate that all of the expected bits are set with an expression such as (c & CC_CONTENT_DEFAULT) == CC_CONTENT_DEFAULT.
This indicates that the contents are invalid.
The prfdinfo_t structure is used with the Pfdinfo_iter() function which describes information about a file descriptor. The structure is defined as follows:
typedef struct prfdinfo { 
	int		pr_fd; 
	mode_t		pr_mode; 
	uid_t		pr_uid; 
	gid_t		pr_gid; 
	major_t		pr_major;	/* think stat.st_dev */ 
	minor_t		pr_minor; 
	major_t		pr_rmajor;	/* think stat.st_rdev */ 
	minor_t		pr_rminor; 
	ino64_t		pr_ino; 
	off64_t		pr_offset; 
	off64_t		pr_size; 
	int		pr_fileflags;	/* fcntl(F_GETXFL), etc */ 
	int		pr_fdflags;	/* fcntl(F_GETFD), etc. */ 
	char		pr_path[MAXPATHLEN]; 
} prfdinfo_t;
The structure has similar information to that found in the stat structure that's used as part of the stat family of system calls, defined in stat(2). The member pr_fd contains the number of the file descriptor of the file. The members pr_mode, pr_uid, pr_gid, pr_ino, and pr_size are the same as the members st_mode, st_uid, st_gid, st_ino, and st_size in the stat structure.
The pr_major and pr_minor members contain the major and minor numbers of the device containing the directory for this file. This is similar to the st_dev member of the stat structure, except that it is broken out into its major and minor components. The pr_rmajor and pr_rminor members are similar in spirit to pr_major and pr_minor; however, they are equivalent to the st_rdev member of the stat structure and thus have meaning for special character and block files.
The pr_offset member contains the current seek offset of the file descriptor. The pr_fileflags and pr_fdflags members contain the flags that would have been returned by a call to fcntl(2) with the arguments F_GETXFL and F_GETFD respectively.
The prsyminfo_t structure is used with the various symbol look up functions Pxlookup_by_name(), Pxlookup_by_addr(), and Pxlookup_by_addr_resolved() which describes additional information about a symbol. The structure is defined as follows:
typedef struct prsyminfo { 
        const char      *prs_object;            /* object name */ 
        const char      *prs_name;              /* symbol name */ 
        Lmid_t          prs_lmid;               /* link map id */ 
        uint_t          prs_id;                 /* symbol id */ 
        uint_t          prs_table;              /* symbol table id */ 
} prsyminfo_t;
The member prs_object points to a string that contains the name of the object file, if known, that the symbol comes from. The member prs_name points to the name of the symbol, if known. This may be unknown due to a stripped binary that contains no symbol table. The member prs_lmid indicates the link map identifier that the symbol was found on. For more information on link map identifiers refer to the Linker and Libraries Guide and dlopen(3C).
The members prs_id and prs_table can be used to determine both the symbol table that the entry came from and which entry in the table it corresponds to. If the value of prs_table is PR_SYMTAB then it came from the ELF standard symbol table. However, if it is instead PR_DYNSYM, then that indicates that it comes from the process's dynamic section.
The proc_lwp_f is a function pointer type that is used with the Plwp_iter() function. It is defined as typedef int proc_lwp_f(void *, const lwpstatus_t *);. The first argument is a pointer to an argument that the user specifies, while the second has the thread's status information and is defined in proc(4). For additional information on using this type, see Plwp_iter(3PROC).
The proc_lwp_all_f is a function pointer type that is used with the Plwp_iter_all() function. It is defined as typedef int proc_lwp_all_f(void *, const lwpstatus_t *, const lwpsinfo_t *);. The first argument is a pointer to an argument that the user specifies. The second and third arguments contain the thread's status and thread-specific ps(1) information respectively. Both structures are defined in proc(4). For additional information on using this type, see Plwp_iter_all(3PROC).
The proc_walk_f is a function pointer type that is used with the proc_walk() function. It is defined as typedef int proc_walk_f(psinfo_t *, lwpsinfo_t *, void *);. The first argument contains the process ps(1) information and the second argument contains the representative thread's ps(1) information. Both structures are defined in proc(4). The final argument is a pointer to an argument that the user specifies. For more information on using this, see proc_walk(3PROC).
The proc_map_f is a function pointer type that is used with the Pmapping_iter(), Pmapping_iter_resolved(), Pobject_iter(), and Pobject_iter_resolved() functions. It is defined as typedef int proc_map_f(void *, const prmap_t *, const char *);. The first argument is a pointer to an argument that the user specifies. The second argument is describes the mapping information and is defined in proc(4). The final argument contains the name of the mapping or object file in question. For additional information on using this type, see Pmapping_iter(3PROC).
The proc_env_f is a function pointer type that is used with the Penv_iter() function. It is defined as typedef int proc_env_f(void *, struct ps_prochandle *, uintptr_t, const char *);. The first argument is a pointer to an argument that the user specifies. The second argument is a pointer to the struct ps_prochandle that the callback was passed to. The third argument is the address of the environment variable in the process. The fourth argument is the environment variable. Values in the environment follow the convention of the form variable=value. For more information on environment variables see exec(2) and environ(5). For additional information on using this type, see Penv_iter(3PROC).
The proc_sym_f is a function pointer type that is used with the Psmbol_iter(), Psymbol_iter_by_addr(), Psymbol_iter_by_name(), and Psymbol_iter_by_lmid() functions. It is defined as typedef int proc_sym_f(void *, const GElf_Sym *, const char *);. The first argument is a pointer to an argument that the user supplies. The second argument is a pointer to the ELF symbol information in a 32-bit and 64-bit neutral form. See elf(3ELF) and gelf(3ELF) for more information on it. The final argument points to a character string that has the name of the symbol. For additional information on using this type, see Psymbol_iter(3PROC), Psymbol_iter_by_addr(3PROC), Psymbol_iter_by_name(3PROC), and Psymbol_iter_by_lmid(3PROC).
The proc_xsym_f is a function pointer type that is used with the Pxsymbol_iter() function. It is defined as typedef int proc_xsym_f(void *, const GElf_Sym *, const char *, const prsyminfo_t *);. The first three arguments are identical to those of proc_sym_f. The final argument contains additional information about the symbol itself. The members of the prsyminfo_t are defined earlier in this section. For additional information on using this type, see Pxsymbol_iter(3PROC).
The proc_stack_f is a function pointer type that is used with the Pstack_iter() function. It is defined as typedef int proc_stack_f(void *, prgregset_t, uint_t, const long *);. The first argument is a pointer to an argument that the user specifies. The second argument's contents are platform specific. The registers that contain stack information, usually the stack pointer and frame pointer, will be filled in to point to an entry. The prgregset_t is defined in proc(4).
The third argument contains the number of arguments to the current stack frame and the fourth argument contains an array of addresses that correspond to the arguments to that stack function. The value of the third argument dictates the number of entries in the fourth argument. For additional information on using this type, see Pstack_iter(3PROC).
The proc_fdinfo_f is a function pointer type that is used with the Pfdinfo_iter() function. It is defined as typedef int proc_fdinfo_f(void *, prfdinfo_t *);. The first argument is a pointer to an argument that the user specifies. The second argument contains information about an open file descriptor. The members of the prfdinfo_t are defined earlier in this section. For additional information on using this type, see Pfdinfo_iter(3PROC).


When working with live processes, whether from the Pgrab(3PROC) or Pcreate(3PROC) family of functions, there are some additional considerations. Importantly, if a process calls any of the exec(2) suite of functions, much of the state information that is obtained, particularly that about mappings in the process will be invalid. Callers must ensure that they call Preset_maps(3PROC) when they hold a process handle across an exec. In addition, users of the library should familiarize themselves with the PROGRAMMING NOTES section of the proc(4) manual page, which discusses issues of privileges and security.


The library provides a means for obtaining additional debugging information. The output itself is not part of the libproc library's stable interface. Setting the environment variable LIBPROC_DEBUG to some value will print information to standard error. For example, LIBPROC_DEBUG=please.


Most functions operate on a handle to a process in the form of a struct ps_prochandle *. Unless otherwise indicated, the library does not provide any synchronization for different routines that are operating on the same libproc library handle. It is up to the caller to ensure that only a single thread is using a handle at any given time. Multiple threads may call libproc library routines at the same time as long as each thread is using a different handle.
Each individual function notes its MT-Level section. The MT-Level of a routine that matches the above description will refer to this manual page. If it does not, then it refers to the standard attributes in attributes(5).


While the library is considered an uncommitted interface, and is still evolving, changes that break compatibility have been uncommon and this trend is expected to continue. It is documented to allow consumers, whether part of illumos or outside of it, to understand the libarary and make use of it with the understanding that changes may occur which break both source and binary compatibility.


gcore(1), mdb(1), proc(1), ps(1), coreadm(1M), exec(2), fcntl(2), stat(2), Intro(3), dlopen(3C), elf(3ELF), ctf(4), proc(4), attributes(5), environ(5), privileges(5)
Linkers and Libraries Guide.
Lfree(3PROC), Lgrab(3PROC), Lgrab_error(3PROC), Pcreate(3PROC), Pcreate_agent(3PROC), Pcreate_callback(3PROC), Pcreate_error(3PROC), Pdestroy_agent(3PROC), Pfgrab_core(3PROC), Pfree(3PROC), Pgrab(3PROC), Pgrab_core(3PROC), Pgrab_error(3PROC), Pgrab_file(3PROC), Pgrab_ops(3PROC), Prelease(3PROC), Preopen(3PROC), Pxcreate(3PROC)
Paddr_to_ctf(3PROC), Paddr_to_loadobj(3PROC), Paddr_to_map(3PROC), Paddr_to_text_map(3PROC), Pasfd(3PROC), Pclearfault(3PROC), Pclearsig(3PROC), Pcontent(3PROC), Pcred(3PROC), Pctlfd(3PROC), Pdelbkpt(3PROC), Pdelwapt(3PROC), Pdstop(3PROC), Pexecname(3PROC), Pfault(3PROC), Pfgcore(3PROC), Pgcore(3PROC), Pgetareg(3PROC), Pgetauxval(3PROC), Pgetauxvec(3PROC), Pgetenv(3PROC), Pisprocdir(3PROC), Pissyscall_prev(3PROC), Plmid(3PROC), Plmid_to_loadobj(3PROC), Plmid_to_map(3PROC), Plookup_by_addr(3PROC), Plookup_by_name(3PROC), Plwp_alt_stack(3PROC), Plwp_getfpregs(3PROC), Plwp_getpsinfo(3PROC), Plwp_getregs(3PROC), Plwp_getspymaster(3PROC), Plwp_main_stack(3PROC), Plwp_setfpregs(3PROC), Plwp_setregs(3PROC), Plwp_stack(3PROC), Pname_to_ctf(3PROC), Pname_to_loadobj(3PROC), Pname_to_map(3PROC), Pobjname(3PROC), Pobjname_resolved(3PROC), Pplatform(3PROC), Ppltdest(3PROC), Ppriv(3PROC), Ppsinfo(3PROC), Pputareg(3PROC), Prd_agent(3PROC), Pread(3PROC), Pread_string(3PROC), Preset_maps(3PROC), Psecflags(3PROC), Psetbkpt(3PROC), Psetcred(3PROC), Psetfault(3PROC), Psetflags(3PROC), Psetpriv(3PROC), Psetrun(3PROC), Psetsignal(3PROC), Psetsysentry(3PROC), Psetsysexit(3PROC), Psetwapt(3PROC), Psetzoneid(3PROC), Psignal(3PROC), Pstate(3PROC), Pstatus(3PROC), Pstop(3PROC), Pstopstatus(3PROC), Psync(3PROC), Psysentry(3PROC), Psysexit(3PROC), Puname(3PROC), Punsetflags(3PROC), Pupdate_maps(3PROC), Pupdate_syms(3PROC), Pwait(3PROC), Pwrite(3PROC), Pxecbkpt(3PROC), Pxecwapt(3PROC), Pxlookup_by_addr(3PROC), Pxlookup_by_addr_resolved(3PROC), Pxlookup_by_name(3PROC), Pzonename(3PROC), Pzonepath(3PROC), Pzoneroot(3PROC)
Lalt_stack(3PROC), Lclearfault(3PROC), Lclearsig(3PROC), Lctlfd(3PROC), Ldstop(3PROC), Lgetareg(3PROC), Lmain_stack(3PROC), Lprochandle(3PROC), Lpsinfo(3PROC), Lputareg(3PROC), Lsetrun(3PROC), Lstack(3PROC), Lstate(3PROC), Lstatus(3PROC), Lstop(3PROC), Lsync(3PROC), Lwait(3PROC), Lxecbkpt(3PROC), Lxecwapt(3PROC)
pr_access(3PROC), pr_close(3PROC), pr_creat(3PROC), pr_door_info(3PROC), pr_exit(3PROC), pr_fcntl(3PROC), pr_fstat(3PROC), pr_fstat64(3PROC), pr_fstatvfs(3PROC), pr_getitimer(3PROC), pr_getpeername(3PROC), pr_getpeerucred(3PROC), pr_getprojid(3PROC), pr_getrctl(3PROC), pr_getrlimit(3PROC), pr_getrlimit64(3PROC), pr_getsockname(3PROC), pr_getsockopt(3PROC), pr_gettaskid(3PROC), pr_getzoneid(3PROC), pr_ioctl(3PROC), pr_link(3PROC), pr_llseek(3PROC), pr_lseek(3PROC), pr_lstat(3PROC), pr_lstat64(3PROC), pr_memcntl(3PROC), pr_meminfo(3PROC), pr_mmap(3PROC), pr_munmap(3PROC), pr_open(3PROC), pr_processor_bind(3PROC), pr_rename(3PROC), pr_setitimer(3PROC), pr_setrctl(3PROC), pr_setrlimit(3PROC), pr_setrlimit64(3PROC), pr_settaskid(3PROC), pr_sigaction(3PROC), pr_stat(3PROC), pr_stat64(3PROC), pr_statvfs(3PROC), pr_unlink(3PROC), pr_waitid(3PROC),
Penv_iter(3PROC), Plwp_iter(3PROC), Plwp_iter_all(3PROC), Pmapping_iter(3PROC), Pmapping_iter_resolved(3PROC), Pobject_iter(3PROC), Pobject_iter_resolved(3PROC), Pstack_iter(3PROC), Psymbol_iter(3PROC), Psymbol_iter_by_addr(3PROC), Psymbol_iter_by_lmid(3PROC), Psymbol_iter_by_name(3PROC), Pxsymbol_iter(3PROC), Pfdinfo_iter(3PROC)
Perror_printf(3PROC), proc_arg_grab(3PROC), proc_arg_psinfo(3PROC), proc_arg_xgrab(3PROC), proc_arg_xpsinfo(3PROC), proc_content2str(3PROC), proc_finistdio(3PROC), proc_fltname(3PROC), proc_fltset2str(3PROC), proc_flushstdio(3PROC), proc_get_auxv(3PROC), proc_get_cred(3PROC), proc_get_priv(3PROC), proc_get_psinfo(3PROC), proc_get_status(3PROC), proc_initstdio(3PROC), proc_lwp_in_set(3PROC), proc_lwp_range_valid(3PROC), proc_signame(3PROC), proc_sigset2str(3PROC), proc_str2content(3PROC), proc_str2flt(3PROC), proc_str2fltset(3PROC), proc_str2sig(3PROC), proc_str2sigset(3PROC), proc_str2sys(3PROC), proc_str2sysset(3PROC), proc_sysname(3PROC), proc_sysset2str(3PROC), proc_unctrl_psinfo(3PROC), proc_walk(3PROC)
Pldt(3PROC), proc_get_ldt(3PROC),
Plwp_getgwindows(3PROC), Plwp_getxregs(3PROC), Plwp_setxregs(3PROC),
Plwp_getasrs(3PROC), Plwp_setasrs(3PROC)
September 15, 2018 illumos