killing processes thru' C programs

[Jonathan I. Kamens]

I just sent this to Steve Hayman and suggested he include something like it in
the comp.unix.questions FAQ.  It's pretty BSD-oriented (since that's what I
work on); if you can expand on it to make it more generally applicable, please
post corrections here or send them to me and I'll forward them to Steve.

  It seems to me that, considering how many times people have asked
this month about finding the pid of a process given its name, it's
about time to add it to the FAQ.  There should be two questions in the
FAQ, one of them talking about shell scripts and one of them talking
about C programs.  Something like this:

*) How do I find out the process ID of a program with a particular
   name from inside a shell script?

There is no utility specifically designed to map between program names
and process IDs.  Furthermore, such mappings are often unreliable,
since it's possible for more than one process to have the same name,
and since it's possible for a process to change its name once it
starts running.  However, a pipeline like this can often be used to
get a list of processes (owned by you) with a particular name:

	ps ux | awk '/name/ && !/awk/ {print $2}'

You replace "name" with the name of the process for which you are
searching.

The general idea is to parse the output of ps, using awk or grep or
other utilities, to search for the lines with the specified name on
them, and print the PID's for those lines.  Note that the "!/awk/"
above prevents the awk process for being listed.

You may have to change the arguments to ps, depending on what kind of
Unix you are using.

*) How do I find out the process ID of a program with a particular name
   from inside a C program?

Just as there is no utility specifically designed to map between
program names and process IDs, there are no (portable) C library
functions to do it either.

However, some vendors provide functions for reading Kernel memory; for
example, Sun provides the "kvm_" functions, and Data General provides
the "dg_" functions.  It may be possible for any user to use these, or
they may only be useable by the super-user (or a user in group "kmem")
if read-access to kernel memory on your system is restricted.
Furthermore, these functions are often not documented or documented
badly, and might change from release to release.

Some vendors provide a "/proc" filesystem, which appears as a
directory with a bunch of filenames in it.  Each filename is a number,
corresponding to a process ID, and you can open the file and read it
to get information about the process.  Once again, access to this may
be restricted, and the interface to it may change from system to
system.

If you can't use vendor-specific library functions, and you don't have
/proc, and you still want to do this completely in C, you are going to
have to do the grovelling through kernel memory yourself.  For a good
example of how to do this on many systems, see the sources to
"ofiles", available in the comp.sources.unix archives.

If all else fails, you can call popen() on "ps" and parse its output.

-- 
Jonathan Kamens			              USnail:
MIT Project Athena				11 Ashford Terrace
jik at Athena.MIT.EDU				Allston, MA  02134
Office: 617-253-8085			      Home: 617-782-0710