Question

I’m taking a FreeBSD course and am reading the implementation of system call kill(2).

http://fxr.watson.org/fxr/source/kern/kern_sig.c?v=FREEBSD82#L1687

Part of the code:

 1717         switch (uap->pid) {
 1718         case -1:                /* broadcast signal */
 1719                 return (killpg1(td, uap->signum, 0, 1, &ksi));
 1720         case 0:                 /* signal own process group */
 1721                 return (killpg1(td, uap->signum, 0, 0, &ksi));
 1722         default:                /* negative explicit process group */
 1723                 return (killpg1(td, uap->signum, -uap->pid, 0, &ksi));
 1724         }
 1725         /* NOTREACHED */
 1726 }

1) Is the pid manually set to 0 and -1 to indicate a process group or sth when calling the system call?

2) why does “signum” get involved?

3) how to understand the code that kills a single process? What does the code do?

I might be asking very stupid questions but please help.

Answer 1

1) Is the pid manually set to 0 and -1
to indicate a process group or sth
when calling the system call?

• If the pid is 0 the signal is sent to
  all the processes in the same process
  group as the sender.
• If the pid is -1 the signal is sent
  to everyone (including the sender).
  The sender must have privileges to do
  this.

2) why does “signum” get involved?

• signum is the signal sent. There
  are lots of signals that do different
  stuff; try kill -l.

3) how to understand the code that
kills a single process? What does the
code do?

First the process is searched and ESRCH is returned if it can’t be found (for example if you try to send a signal to some nonexistent pid).

if ((p = pfind(uap->pid)) == NULL) {
    if ((p = zpfind(uap->pid)) == NULL)
    return (ESRCH);
}

It is checked to see if we are allowed to signal it (with that signal):

error = p_cansignal(td, p, uap->signum);

If we are allowed to signal it, pksignal (tdsignal) is sent.

if (error == 0 && uap->signum)
    pksignal(p, uap->signum, &ksi);

Now we need to return from the function so we should drop locks

PROC_UNLOCK(p);
    return (error);

I might be asking very stupid
questions but please help.

The kernel code is pretty obvious (no fancy algorithms are used). The only problem is that it’s very large and you need patience.