20090428のHomeWork

1. This week we have talked about processes. Write a program to call fork() repeatedly. Eventually, the call will fail in one of the children. When it does, print out the depth of the process tree: how many times have you succeeded in calling fork()? What was the reason for the failure (use perror())?

[実行結果]
fork error:: Resource temporarily unavailable
final i is 15986


2. Now modify that program to collect timing information for a given number of processes, giving the number of processes as an argument to the program (no argument should do the same as above, run until the fork fails). How long does it take to create and delete a thousand processes? Two thousand?

[1000の実行結果]
i is 1000
時間：0.154197931289672851562500000000

[2000の実行結果]
i is 2000
時間：0.278687000274658203125000000000


3.
a. Find the Linux kernel code for fork() and post it on your blog. If your machine is Linux, you may want to learn where the source code is stored on your machine (you may have to install it); if you are not using Linux, you may use one of the browsable Linux kernel source archives on the web (there are several; pick one).

[ソース]
long do_fork(unsigned long clone_flags,
unsigned long stack_start,
struct pt_regs *regs,
unsigned long stack_size,
int __user *parent_tidptr,
int __user *child_tidptr)
{
struct task_struct *p;
int trace = 0;
long nr;

if (unlikely(current->ptrace)) {
trace = fork_traceflag (clone_flags);
if (trace)
clone_flags |= CLONE_PTRACE;
}

p = copy_process(clone_flags, stack_start, regs, stack_size,
child_tidptr, NULL);
/*
* Do this prior waking up the new thread - the thread pointer
* might get invalid after that point, if the thread exits quickly.
*/
if (!IS_ERR(p)) {
struct completion vfork;

/*
* this is enough to call pid_nr_ns here, but this if
* improves optimisation of regular fork()
*/
nr = (clone_flags & CLONE_NEWPID) ?
task_pid_nr_ns(p, current->nsproxy->pid_ns) :
task_pid_vnr(p);
if (clone_flags & CLONE_PARENT_SETTID)
put_user(nr, parent_tidptr);

if (clone_flags & CLONE_VFORK) {
p->vfork_done = &vfork;
init_completion(&vfork);
}

if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
/*
* We'll start up with an immediate SIGSTOP.
*/
sigaddset(&p->pending.signal, SIGSTOP);
set_tsk_thread_flag(p, TIF_SIGPENDING);
}

if (!(clone_flags & CLONE_STOPPED))
wake_up_new_task(p, clone_flags);
else
p->state = TASK_STOPPED;

if (unlikely (trace)) {
current->ptrace_message = nr;
ptrace_notify ((trace << 8) | SIGTRAP);
}

if (clone_flags & CLONE_VFORK) {
freezer_do_not_count();
wait_for_completion(&vfork);
freezer_count();
if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
current->ptrace_message = nr;
ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
}
}
} else {
nr = PTR_ERR(p);
}
return nr;
}


b. Find the definition of the process or task structure from another operating system, either in a book or online. Post it on your blog. Over the next few weeks, we will compare this structure to Linux. You can find the definition for BSD, Windows, Symbian, NACHOS, Minix, or any other OS of your choice.

[FreeBSD 8-CURRENT]

/sys/proc.h

  /*
   * Process structure.
   */
  struct proc {
          LIST_ENTRY(proc) p_list;        /* (d) List of all processes. */
          TAILQ_HEAD(, thread) p_threads; /* (c) all threads. */
          struct mtx      p_slock;        /* process spin lock */
          struct ucred    *p_ucred;       /* (c) Process owner's identity. */
          struct filedesc *p_fd;          /* (b) Open files. */
          struct filedesc_to_leader *p_fdtol; /* (b) Tracking node */
          struct pstats   *p_stats;       /* (b) Accounting/statistics (CPU). */
          struct plimit   *p_limit;       /* (c) Process limits. */
          struct callout  p_limco;        /* (c) Limit callout handle */
          struct sigacts  *p_sigacts;     /* (x) Signal actions, state (CPU). */
 
          /*
           * The following don't make too much sense.
           * See the td_ or ke_ versions of the same flags.
           */
          int             p_flag;         /* (c) P_* flags. */
          enum {
                  PRS_NEW = 0,            /* In creation */
                  PRS_NORMAL,             /* threads can be run. */
                  PRS_ZOMBIE
          } p_state;                      /* (j/c) S* process status. */
          pid_t           p_pid;          /* (b) Process identifier. */
          LIST_ENTRY(proc) p_hash;        /* (d) Hash chain. */
          LIST_ENTRY(proc) p_pglist;      /* (g + e) List of processes in pgrp. */
          struct proc     *p_pptr;        /* (c + e) Pointer to parent process. */
          LIST_ENTRY(proc) p_sibling;     /* (e) List of sibling processes. */
          LIST_HEAD(, proc) p_children;   /* (e) Pointer to list of children. */
          struct mtx      p_mtx;          /* (n) Lock for this struct. */
          struct ksiginfo *p_ksi; /* Locked by parent proc lock */
          sigqueue_t      p_sigqueue;     /* (c) Sigs not delivered to a td. */
  #define p_siglist       p_sigqueue.sq_signals
 
  /* The following fields are all zeroed upon creation in fork. */
  #define p_startzero     p_oppid
          pid_t           p_oppid;        /* (c + e) Save ppid in ptrace. XXX */
          struct vmspace  *p_vmspace;     /* (b) Address space. */
          u_int           p_swtick;       /* (c) Tick when swapped in or out. */
          struct itimerval p_realtimer;   /* (c) Alarm timer. */
          struct rusage   p_ru;           /* (a) Exit information. */
          struct rusage_ext p_rux;        /* (cj) Internal resource usage. */
          struct rusage_ext p_crux;       /* (c) Internal child resource usage. */
          int             p_profthreads;  /* (c) Num threads in addupc_task. */
          volatile int    p_exitthreads;  /* (j) Number of threads exiting */
          int             p_traceflag;    /* (o) Kernel trace points. */
          struct vnode    *p_tracevp;     /* (c + o) Trace to vnode. */
          struct ucred    *p_tracecred;   /* (o) Credentials to trace with. */
          struct vnode    *p_textvp;      /* (b) Vnode of executable. */
          u_int           p_lock;         /* (c) Proclock (prevent swap) count. */
          struct sigiolst p_sigiolst;     /* (c) List of sigio sources. */
          int             p_sigparent;    /* (c) Signal to parent on exit. */
          int             p_sig;          /* (n) For core dump/debugger XXX. */
          u_long          p_code;         /* (n) For core dump/debugger XXX. */
          u_int           p_stops;        /* (c) Stop event bitmask. */
          u_int           p_stype;        /* (c) Stop event type. */
          char            p_step;         /* (c) Process is stopped. */
          u_char          p_pfsflags;     /* (c) Procfs flags. */
          struct nlminfo  *p_nlminfo;     /* (?) Only used by/for lockd. */
          struct kaioinfo *p_aioinfo;     /* (c) ASYNC I/O info. */
          struct thread   *p_singlethread;/* (c + j) If single threading this is it */
          int             p_suspcount;    /* (j) Num threads in suspended mode. */
          struct thread   *p_xthread;     /* (c) Trap thread */
          int             p_boundary_count;/* (c) Num threads at user boundary */
          int             p_pendingcnt;   /* how many signals are pending */
          struct itimers  *p_itimers;     /* (c) POSIX interval timers. */
  /* End area that is zeroed on creation. */
  #define p_endzero       p_magic
 
  /* The following fields are all copied upon creation in fork. */
  #define p_startcopy     p_endzero
          u_int           p_magic;        /* (b) Magic number. */
          int             p_osrel;        /* (x) osreldate for the
                                                 binary (from ELF note, if any) */
          char            p_comm[MAXCOMLEN + 1];  /* (b) Process name. */
          struct pgrp     *p_pgrp;        /* (c + e) Pointer to process group. */
          struct sysentvec *p_sysent;     /* (b) Syscall dispatch info. */
          struct pargs    *p_args;        /* (c) Process arguments. */
          rlim_t          p_cpulimit;     /* (c) Current CPU limit in seconds. */
          signed char     p_nice;         /* (c) Process "nice" value. */
          int             p_fibnum;       /* in this routing domain XXX MRT */
  /* End area that is copied on creation. */
  #define p_endcopy       p_xstat
 
          u_short         p_xstat;        /* (c) Exit status; also stop sig. */
          struct knlist   p_klist;        /* (c) Knotes attached to this proc. */
          int             p_numthreads;   /* (c) Number of threads. */
          struct mdproc   p_md;           /* Any machine-dependent fields. */
          struct callout  p_itcallout;    /* (h + c) Interval timer callout. */
          u_short         p_acflag;       /* (c) Accounting flags. */
          struct proc     *p_peers;       /* (r) */
          struct proc     *p_leader;      /* (b) */
          void            *p_emuldata;    /* (c) Emulator state data. */
          struct label    *p_label;       /* (*) Proc (not subject) MAC label. */
          struct p_sched  *p_sched;       /* (*) Scheduler-specific data. */
          STAILQ_HEAD(, ktr_request)      p_ktr;  /* (o) KTR event queue. */
          LIST_HEAD(, mqueue_notifier)    p_mqnotifier; /* (c) mqueue notifiers.*/
          struct kdtrace_proc     *p_dtrace; /* (*) DTrace-specific data. */
          struct cv       p_pwait;        /* (*) wait cv for exit/exec */
  };
 
  #define p_session       p_pgrp->pg_session
  #define p_pgid          p_pgrp->pg_id
 
  #define NOCPU   0xff            /* For when we aren't on a CPU. */
 
  #define PROC_SLOCK(p)   mtx_lock_spin(&(p)->p_slock)
  #define PROC_SUNLOCK(p) mtx_unlock_spin(&(p)->p_slock)
  #define PROC_SLOCK_ASSERT(p, type)      mtx_assert(&(p)->p_slock, (type))

4. Determine how many processes have been created on your computer
since the last time it was booted.  Describe any caveats on your knowledge.

26531