4. Prosessinhallinta

• 4 Prosessinhallinta
  • 4.1 Prosessin luonti
  • 4.2 Prosessin päättyminen
  • 4.3 Prosessin koodin vaihto
  • 4.4 Prosessin ominaisuudet
  • 4.5 Prosessin tunnistus
  • 4.6 Prosessin kuluttama aika
  • 4.7 Prosessien sukulais- ja omistussuhteet

4 Prosessinhallinta

• uuden prosessin luonti fork()
• prosessin koodinvaihto exec()
• prosessin lopettaminen exit()
• prosessin päättymisen odotus wait(), waitpid()

4.1 Prosession luonti

• yhteinen koodi
• samat muuttujien arvot
• samat prosessinkuvaajan perustiedot
• yhteiset avoimet tiedostot

Kummallakin on kuitenkin:

• oma data-alue
• oma prosessinkuvaaja

fork()-kutsun jälkeen ei voi olla varma siitä kumpi prosessi (äiti vai lapsi) jatkaa aiemmin suoritustaan. Jos järjestys tärkeää, on ohjelmoitava itse synkronointi ( Esim 1.

#include    < sys/types.h >                                             
#include    < unistd.h >

int  glob = 6;                      /* external variable in initialized data */
char buf[] = "a write to stdout\n";

int
main(void)
{
      int      var;                       /* automatic variable on the stack */
      pid_t pid;

      var = 88;
      if (write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf)-1)
            perror("write error");
      printf("before fork\n");                      /* we don't flush stdout */

      if ( (pid = fork()) < 0)
            perror("fork error");
      else if (pid == 0) {                                          /* child */
            glob++;                                      /* modify variables */
            var++;
      } else
          sleep(2);                                                /* parent */

      printf("pid=%d,glob=%d,var=%d\n",getpid(), glob, var);
      exit(0);
} 

Lapsiprosessi luodaan, kun:

• halutaan suorittaa äiti- ja lapsiprosessissa erillinen osa samassa tiedostossa olevasta koodista. Esim. verkkosovelluksissa on tavallista, että palvelija luo lapsiprosessin antamaan palvelua ja jää itse odottamaan uusia palvelupyyntöjä.
• halutaan suorittaa kokonaan toinen ohjelma. Tällöin fork()-kutsun jälkeen on lapsiprosessissa myös exec()-kutsu, eli se vaihtaa suoritettavaa koodia. Esim. komentotulkit käyttävät tätä menetelmää.

Lapsi perii äidiltä kaikki avoimet tiedostokuvaajat. Sekä äiti että lapsi käyttävät yhteistä avoimet tiedostot taulun alkiota niillä on yhteinen luku / kirjoituspositio.

4.2 Prosession päättyminen

• funktiossa main() funktio return(status)
• funktio exit(status) tai
• funktio _exit(status)

exit() kutsuu funktiolla atexit() rekisteröityjä funktioita ja purkaa stdio:n puskurit (vrt. funktio flush()). _exit() hoitelee Unix-spesifiset lopputoimet Prosessin suoritus voi päättyä myös 'epänormaalisti', kun kutsutaan funktiota abort() tai prosessi saa signaalin, johon se ei varautunut tai ei voi varautua. Epänormaaleissa päättymisissä generoi ydin paluuarvon.

Unix-spesifisiin lopputoimiin kuuluu tiedostojen sulkeminen, muistitilan vapauttaminen sekä äitiprosessin signalointi, mutta prosessinkuvaaja jää vielä olemaan ("zombie"). Koska paluuarvon välittäminen äitiprosessille ja laskutustietojen kokoaminen on vielä kesken.

Jos äitiprosessi on päättynyt ennen lapsiprosessia, merkitsee ydin zombien äidiksi prosessin 1 (init). Se kokoaa laskutustiedot ja vapauttaa prosessinkuvaajan.

Kun prosessi päättyy, saa äiti aina signaalin SIGCHLD. Oletusarvo on, että äiti ei välitä tästä signaalista. Äiti voi pysähtyä odottamaan lapsen päättymistä funktioon wait() tai waitpid():

#include < sys/types.h >
#include < sys/wait.h >
      
pid_t wait(int *status);         
pid_t waitpid(pid_t pid, int *status, int options);
                                  Palauttaa: päättyneen prosessin pid, 
                      parametrissa statloc on päättyneen lapsen status 

• pid == -1 odota mitä tahansa lapsiprosessia
• pid > 0 odota lasta, jolla ko. pid
• pid == 0 odota mitä tahansa äidin kanssa samaan prosessiryhmän kuuluvaa lasta
• pid < -1 odota prosessiryhmään |pid| kuuluvaa prosessia

4.3 Prosessin koodin vaihto

Koodille voi välittää komentoriviargumentteja joko listana (execl()) tai vektorina (execv()). Koodille voi välittää edellisten lisäksi myös haluamansa ympäristömuuttujat aina vektorina execle() tai execve() tai äidin ympäristömuuttujat periytyvät lapselle sellaisenaan environ-muuttujasta.

#include < unistd.h >
      
int execl(const char *pathname, const char *arg0, ... /* NULL */);
int execv(const char *pathname, char *const argv[]);

int execle(const char *pathname, const char *arg0, ... /* NULL, char *const envp[] */);
int execve(const char *pathname, char *const argv[], char *const envp[]);

int execlp(const char *filename, const char *arg0, ... /* NULL */)
int execvp(const char *filename, char *const argv[]);

#include    < sys/types.h >                                            
#include    < sys/wait.h >
#include    < unistd.h >

char  *env_init[] = { "USER=unknown", "PATH=/tmp", NULL };

int
main(void)
{
      pid_t pid;

      if ( (pid = fork()) < 0)
             perror("fork error");
      else if (pid == 0) {          /* specify pathname, specify environment */
             if (execle("/bin",
                        "echo", "myarg1", "MY ARG2", (char *) 0,
                         env_init) < 0)
               perror("execle error");
      }
      if (waitpid(pid, NULL, 0) < 0)
          perror("wait error");

      if ( (pid = fork()) < 0)
            perror("fork error");
      else if (pid == 0) {          /* specify filename, inherit environment */
              if (execlp("echo",
                           "echo", "only 1 arg", (char *) 0) < 0)
                   perror("execlp error");
      }
      exit(0);
}

4.4 Prosessin ominaisuudet

4.5 Prosessin tunnistus

Todellinen (real) käyttäjä uid ja todelliset ryhmät gid ja groups saadaan istuntoa käynnistettäessä salasanatiedostosta. Vain root voi muuttaa näitä. Omistaja- ja ryhmänumeroita voi muuttaa tietyin edellytyksin funktioilla:

#include 
#include 
  
int setuid(uid_t uid);
int setgid(gid_t gid);
  
int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t rgid, gid_t egid);
  
int seteuid(uid_t uid);
int setegid(gid_t gid);

root saa tietenkin käyttää kaikkia uid ja gid arvoja. Prosessin todellinen omistaja voi aina asettaa funktioilla setuid() ja setgid(). Funktiot seteuid() ja setegid() toimivat tavallisilla käyttäjillä kuten setuid() ja setgid(). rootin käytössä setuid() asettaa aina:

• uid = annettu uid
• euid = annettu uid
• saved-uid = annettu uid

Kun taas seteuid() asettaa vain euid = annettu uid. Ryhmäjutut vastaavasti.

4.6 Prosessin kuluttama aika

#include < sys/times.h >
  
struct tms {
     clock_t tms_utime;  käyttäjätilassa
     clock_t tms_stime;  etuoikeutetussa tilassa
     clock_t tms_cutime; summa lasten ajoista
     clock_t tms_cutime; summa lasten ajoista
};
  
clock_t times(struct tms *buf);     
                                      Palauttaa: reaaliaika tiksauksina

#include    < stdio.h >
#include    < sys/times.h >                                           
#include    < unistd.h >

static void pr_times(clock_t, struct tms *, struct tms *);
static void do_cmd(char *);

int main(int argc, char *argv[])
{     int         i;

      for (i = 1; i < argc; i++)
            do_cmd(argv[i]);               /* once for each command-line arg */
      exit(0);
}

static void do_cmd(char *cmd)                  /* execute and time the "cmd" */
{
      struct tms  tmsstart, tmsend;
      clock_t     start, end;
      int         status;

      fprintf(stderr, "\ncommand: %s\n", cmd);

      if ( (start = times(&tmsstart)) == -1)              /* starting values */
            perror("times error");

      if ( (status = system(cmd)) < 0)                    /* execute command */
            perror("system() error");

      if ( (end = times(&tmsend)) == -1)              /* ending values */
            perror("times error");

      pr_times(end-start, &tmsstart, &tmsend);
      exit(status);
} 

static void pr_times(clock_t real,  struct tms *tmsstart, struct tms *tmsend)
{  
    static long clktck = 0;

    if (clktck == 0)              /* fetch clock ticks per second first time */
         if ( (clktck = sysconf(_SC_CLK_TCK)) < 0)
           perror("sysconf error");

    fprintf(stderr, "  real:  %7.2f\n", real / (double) clktck);
    fprintf(stderr, "  user:  %7.2f\n",
         (tmsend->tms_utime - tmsstart->tms_utime) / (double) clktck);
    fprintf(stderr, "  sys:   %7.2f\n",
         (tmsend->tms_stime - tmsstart->tms_stime) / (double) clktck);
    fprintf(stderr, "  child user:  %7.2f\n",
         (tmsend->tms_cutime - tmsstart->tms_cutime) / (double) clktck);
    fprintf(stderr, "  child sys:   %7.2f\n",
         (tmsend->tms_cstime - tmsstart->tms_cstime) / (double) clktck);
}

4.7 Prosessien sukulais- ja omistussuhteet

  
      $ kill %1

#include 
#include 
  
pid_t tcgetpgrp(int filedes);
                               Palauttaa: edustaprosessin prosessiryhmä
int tcsetpgrp(int filedes, pid_t pgrpid);