d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f73575dddd
freebsd-skq/sys/fs/procfs
History
jhb ce2d3f89af Rework how we store process times in the kernel such that we always store 
the raw values including for child process statistics and only compute the
system and user timevals on demand.

- Fix the various kern_wait() syscall wrappers to only pass in a rusage
  pointer if they are going to use the result.
- Add a kern_getrusage() function for the ABI syscalls to use so that they
  don't have to play stackgap games to call getrusage().
- Fix the svr4_sys_times() syscall to just call calcru() to calculate the
  times it needs rather than calling getrusage() twice with associated
  stackgap, etc.
- Add a new rusage_ext structure to store raw time stats such as tick counts
  for user, system, and interrupt time as well as a bintime of the total
  runtime.  A new p_rux field in struct proc replaces the same inline fields
  from struct proc (i.e. p_[isu]ticks, p_[isu]u, and p_runtime).  A new p_crux
  field in struct proc contains the "raw" child time usage statistics.
  ruadd() has been changed to handle adding the associated rusage_ext
  structures as well as the values in rusage.  Effectively, the values in
  rusage_ext replace the ru_utime and ru_stime values in struct rusage.  These
  two fields in struct rusage are no longer used in the kernel.
- calcru() has been split into a static worker function calcru1() that
  calculates appropriate timevals for user and system time as well as updating
  the rux_[isu]u fields of a passed in rusage_ext structure.  calcru() uses a
  copy of the process' p_rux structure to compute the timevals after updating
  the runtime appropriately if any of the threads in that process are
  currently executing.  It also now only locks sched_lock internally while
  doing the rux_runtime fixup.  calcru() now only requires the caller to
  hold the proc lock and calcru1() only requires the proc lock internally.
  calcru() also no longer allows callers to ask for an interrupt timeval
  since none of them actually did.
- calcru() now correctly handles threads executing on other CPUs.
- A new calccru() function computes the child system and user timevals by
  calling calcru1() on p_crux.  Note that this means that any code that wants
  child times must now call this function rather than reading from p_cru
  directly.  This function also requires the proc lock.
- This finishes the locking for rusage and friends so some of the Giant locks
  in exit1() and kern_wait() are now gone.
- The locking in ttyinfo() has been tweaked so that a shared lock of the
  proctree lock is used to protect the process group rather than the process
  group lock.  By holding this lock until the end of the function we now
  ensure that the process/thread that we pick to dump info about will no
  longer vanish while we are trying to output its info to the console.

Submitted by:	bde (mostly)
MFC after:	1 month
2004-10-05 18:51:11 +00:00
..
procfs_ctl.c Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
procfs_dbregs.c Don't PHOLD() the target process in procfs, since this is already done 2004-10-01 05:01:17 +00:00
procfs_fpregs.c Don't PHOLD() the target process in procfs, since this is already done 2004-10-01 05:01:17 +00:00
procfs_ioctl.c Minor whitespace and style issues. 2003-12-07 17:40:00 +00:00
procfs_map.c Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
procfs_mem.c Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
procfs_note.c Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
procfs_regs.c Don't PHOLD() the target process in procfs, since this is already done 2004-10-01 05:01:17 +00:00
procfs_rlimit.c Locking for the per-process resource limits structure. 2004-02-04 21:52:57 +00:00
procfs_status.c Rework how we store process times in the kernel such that we always store 2004-10-05 18:51:11 +00:00
procfs_type.c Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
procfs.c Lock p->p_textvp before calling vn_fullpath() on it. Note the 2004-01-07 17:58:51 +00:00
procfs.h Remove advertising clause from University of California Regent's 2004-04-07 20:46:16 +00:00
README

README 

saute procfs lyonnais

procfs supports two levels of directory.  the filesystem root
directory contains a representation of the system process table.
this consists of an entry for each active and zombie process, and
an additional entry "curproc" which always represents the process
making the lookup request.

each of the sub-directories contains several files.  these files
are used to control and interrogate processes.  the files implemented
are:

	file	- xxx.  the exec'ed file.

	status  - r/o.  returns process status.

	ctl	- w/o.  sends a control message to the process.
			for example:
				echo hup > /proc/curproc/note
			will send a SIGHUP to the shell.
			whereas
				echo attach > /proc/1293/ctl
			would set up process 1293 for debugging.
			see below for more details.

	mem	- r/w.  virtual memory image of the process.
			parts of the address space are readable
			only if they exist in the target process.
			a more reasonable alternative might be
			to return zero pages instead of an error.
			comments?

	note	- w/o.  writing a string here sends the
			equivalent note to the process.
			[ not implemented. ]

	notepg	- w/o.  the same as note, but sends to all
			members of the process group.
			[ not implemented. ]

	regs	- r/w.	process register set.  this can be read
			or written any time even if the process
			is not stopped.  since the bsd kernel
			is single-processor, this implementation
			will get the "right" register values.
			a multi-proc kernel would need to do some
			synchronisation.

this then looks like:

% ls -li /proc
total 0
   9 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 0
  17 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 1
  89 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 10
  25 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 2
2065 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 257
2481 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 309
 265 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 32
3129 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 390
3209 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 400
3217 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 401
3273 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 408
 393 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 48
 409 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 50
 465 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 57
 481 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 59
 537 dr-xr-xr-x  2 root  kmem   0 Sep 21 15:06 66
 545 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 67
 657 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 81
 665 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 82
 673 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 83
 681 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 84
3273 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 curproc
% ls -li /proc/curproc
total 408
3341 --w-------  1 jsp  staff       0 Sep 21 15:06 ctl
1554 -r-xr-xr-x  1 bin  bin     90112 Mar 29 04:52 file
3339 -rw-------  1 jsp  staff  118784 Sep 21 15:06 mem
3343 --w-------  1 jsp  staff       0 Sep 21 15:06 note
3344 --w-------  1 jsp  staff       0 Sep 21 15:06 notepg
3340 -rw-------  1 jsp  staff       0 Sep 21 15:06 regs
3342 -r--r--r--  1 jsp  staff       0 Sep 21 15:06 status
% df /proc/curproc /proc/curproc/file
Filesystem  512-blocks    Used   Avail Capacity  Mounted on
proc                 2       2       0   100%    /proc
/dev/wd0a        16186   13548    1018    93%    /
% cat /proc/curproc/status
cat 446 439 400 81 12,0 ctty 748620684 270000 0 0 0 20000 nochan 11 20 20 20 0 21 117



the basic sequence of commands written to "ctl" would be

	attach		- this stops the target process and
			  arranges for the sending process
			  to become the debug control process
	wait		- wait for the target process to come to
			  a steady state ready for debugging.
	step		- single step, with no signal delivery.
	run		- continue running, with no signal delivery,
			  until next trap or breakpoint.
	<signame>	- deliver signal <signame> and continue running.
	detach		- continue execution of the target process
			  and remove it from control by the debug process

in a normal debugging environment, where the target is fork/exec'd by
the debugger, the debugger should fork and the child should stop itself
(with a self-inflicted SIGSTOP).  the parent should do a "wait" then an
"attach".  as before, the child will hit a breakpoint on the first
instruction in any newly exec'd image.

$FreeBSD$