i UNIX read!filhantering!read!write!open!close!creat!lseek!dup!fcntl!pipe!processhantering!exec!exit!fork!getpid!kill!signal!wait! Funktionen read läser från en fildeskriptor och returnerar antalet lästa tecken. int antal_tkn, fd, count; char buffer[size]; antal_tkn = read(fd, buffer, count);! antal_tkn: Antal tecken som lästs! fd: Fildeskriptor! count: Antal tecken som skall läsas åt gången! buffer: Teckenbuffer 1 2 write Exempel med read & write! Funktionen write skriver till en fildeskriptor och returnerar antalet skrivna tecken. int antal_tkn, fd, count; char buffer[size]; antal_tkn = write(fd, buffer, count);! antal_tkn: Antal tecken som skrivits! fd: Fildeskriptor! count: Antal tecken som skall skrivas åt gången! buffer: Teckenbuffer #include <unistd.h> #define COUNT 1024 #define STDIN 0 #define STDOUT 1 int main(void) { int antal_tkn; char buffer[count]; while((antal_tkn = read(stdin, buffer, COUNT)) > 0) write(stdout, buffer, antal_tkn); return 0; 3 4!1
open! Funktionen open öppnar och möjligtvis även skapar en fil och returnerar den nya fildescriporn. int fd, flaggor, mode; char *sökväg; fd = open(sökväg, flaggor, mode);! Mode anger accessrättigheter, exempelvis 0644! Flaggor anger hur filen skall öppnas, exempelvis:! O_CREAT Om filen inte finns, skapas den! O_TRUNC Om filen finns trunkeras den! O_RDONLY Öppna endast för läsning! O_RDWR Öppna för läsning och skrivning creat! Funktionen creat är ekvivalent att använda open med flaggorna satta till! O_CREAT O_WRONLY O_TRUNC int fd = creat(char *namn, int PERMS);! PERMS anger accessrättigheter som kan anges:! Oktalt exempelvis 0644! Bitvist separerade med OR, exempelvis! S_IWUSR Ägaren har write-rättighet! S_IRGRP Gruppen har read-rättighet! S_IROTH Alla andra har read-rättighet 5 6 Prestandatest med buffersize #define COUNT 1 /* eller 1024 */ int num, in_fd, ut_fd; in_fd = open("in_data.txt", O_RDONLY); ut_fd = open("ut_data.txt",o_wronly); while((num = read(in_fd, buffer, COUNT)) > 0) write(ut_fd, buffer, num); close(in_fd); close(ut_fd); 7 Resultat av prestandatest! Efter kopiering av 5Mb uppmättes följande resultat: 100 90 80 70 60 50 40 30 20 10 0 1024 bytes 1 byte! Vi kan alltså konstatera stora skillnader! I ett stort system blir detta exponentiellt värre!! Slutsats: Kodeffektivisering är mycket viktigt! Tid CPU Utnyttjande 8!2
unlink! Funktionen unlink tar bort en fil genom att räkna ner antalet referenser (link count) till filen. När antalet referenser är 0 är filen borttagen.! Om två personer har samma fil öppen tas den med andra ord inte bort förrän båda personerna gjort unlink på filen. char *filnamn; unlink(filnamn); lseek! Funktionen lseek används för att förflytta filpekaren i en fil. int fd, startpos; long offset, nypos; nypos = lseek(fd, offset, startpos);! Offset: anger förflyttningen i bytes relativt origin! startpos: anger utgångspositionen! 0 = filens början! 1 = aktuell position! 2 = filens slut 9 10 fork! et fork används för att starta upp en ny process.! Den nya processen kallas barnprocess och ursprungsprocessen för föräldraprocess.! Barnprocessen är en kopia av föräldraprocessen! Dessa två kommer att exekvera samtidigt och deras exekvering brukar styras av if-satser fork() Föräldraprocess Barnprocess Exempel 1 med fork #include <stdio.h> #include <unistd.h> int pid; pid = fork(); printf("pid: %d\n", pid); if(pid == 0) printf( Jag är ett barn.\n ); if(pid > 0) printf( Jag är en förälder.\n ); if(pid < 0) printf( Anropet misslyckat.\n ); return 0; 11 12!3
Exempel 2 med fork #include <stdio.h> #include <unistd.h> int pid; pid = fork(); pid = fork(); Exempel 3 med fork #include <stdio.h> #include <unistd.h> int pid, i=0; if((pid = fork()) == 0) i=1; printf("pid: %d\n", pid); return 0; printf("pid: %d, i=%d\n", pid, i); return 0; 13 14 Exempel 4 med fork #include <stdio.h> #include <unistd.h> Exempel 5 med fork int fd, stat; char buffer[10]; while(1) fork(); return 0; Gör (helst) inte detta experiment eftersom datorn blir sänkt redan efter ett par sekunder! fd = open("datafile", O_RDONLY); read(fd, buff, 10); printf("före fork(): %d\n", lseek(fd, 0L, SEEK_CUR)); switch(fork()) { case 0: printf("barn före read: %d\n", lseek(fd, 0L, SEEK_CUR)); read(fd, buff, 10); printf("barn efter read: %d\n", lseek(fd, 0L, SEEK_CUR)); default: break; wait(&stat); printf("förälder efter wait: %d\n", lseek(fd, 0L, SEEK_CUR)); 15 16!4
getpid! Funktionen getpid returnerar det process-id som den aktuella processen har. Exempel med getpid int pid; int pid; pid = getpid();! Getpid kan bland annat användas för att generera temporära filnamn. pid = fork(); if(pid == 0) printf( Barnets PID=%d\n", getpid()); else if(pid > 0) printf( Förälderns PID=%d\n", getpid()); else perror( Kunde inte skapa en ny process"); 17 18 execl Exempel 1 med execl! et execl ersätter exekveringen av nuvarande process med en ny process.! execl används för att starta upp ett program. #include <stdio.h> #include <unistd.h> execl( path/to/program, argument, NULL)! Olika varianter på execl är:! execlp execl ("/bin/date", "date", --help", NULL); perror ( Kunde ej skapa process");! execle! execv! execvp! execve 19 20!5
Exempel 2 med execl int pid, status; if((pid = fork()) == 0) { execl("/usr/bin/cal", "cal", "10", "2000", NULL); perror("kunde inte skapa process\n"); else if(pid > 0) { wait(&status); printf("föräldern har avslutat\n"); wait! Funktionen wait används för att få en föräldraprocess att vänta på att dess barn skall avsluta sin exekvering. int pid, status; pid = wait(&status);! pid: Process-id på barnet som avslutade! status: Barnprocessens exit-status, som exempelvis kan vara terminate, abort, core-dump osv 21 22 waitpid Exempel med waitpid! Till skillnad från wait används waitpid till att invänta en specifik barnprocess. int pid, status, options waitpid(pid1, &status, options);! pid: Process-ID som skall väntas in! status: Barnprocessens exit-status! options: Tillval definierade i filen sys/wait.h Normalt används WNOHANG int pid, status; switch(pid = fork()) { case 0: puts("barnet sover"); sleep(5); puts("barnet terminerar"); default: break; while(waitpid(pid, &status, WNOHANG) == 0) { puts("föräldern väntar..."); sleep(1); puts("föräldern terminerar"); 23 24!6
Processgrupper! Varje process har inte bara ett process-id, utan även ett process-grupps-id, pgid.! Detta ID-nummer berättar vilken processgrupp som processen tillhör.! Processer kan via kommandoraden grupperas med hjälp av pipes ( )! Det är ibland bra att använda sig av processernas grupp-id eftersom man kan behandla hela processgruppen som en enhet, om man exempelvis vill skicka en signal till den.! I normalfallet går en signal bara till en process. Exempel med processgrupper prog1 prog2 & prog3 prog4 prog5 Login-skal prog1 prog2 prog3 prog4 Processgrupp Processgrupp prog5 Processgrupp Session 25 26 getpgrp! Funktionen getpgrp returnerar det processgrupps- ID en process tillhör. int pgid = getpgrp(); eller int pgid = getpgid(0);! pgid: Den processgrupp processen tillhör setpgid! Funktionen setpgid ändrar processgrupps-id för en process. setpgid(int pid, int pgid);! pid: Processen man vill byta grupp på! pgid: Den nya processgruppen! Om pid=0 Används den anropade processens pid! Om pgid=0 Blir pgid samma som pid! Om pid=pgid Blir processen group leader 27 28!7
Exempel: Processers returvärden nice int pid, status, exit_status; switch(fork()) { case 0: exit(99); default: break; pid = wait(&status); if(wifexited(status)) { exit_status = WEXITSTATUS(status); printf("exit-status från %d var %d\n", pid, exit_status); printf("processgrupp: %d\n", getpgrp());! Funktionen nice ändrar prioriteten på en process nice(int priority);! Priority är den prioritetsändring som processen skall få.! Detta är ett värde mellan 0 och 99.! Högre tal=lägre prioritet! Endast root kan sätta negativ prioritet, dvs öka processens prioritet. 29 30 chdir! Med systemanropet chdir kan man förflytta sig i filsystemet. char *dir = "/usr/bin/"; chdir(dir); fd = open( testfil, O_RDWR O_CREAT); write(fd, "Hej", 3); close(fd);! dir Anger sökvägen till den katalog dit man vill förflytta sig. Miljövariabler! Miljövariabler används av systemet för att samla in data om sig själv.! En annan tillämpning är installationsprogram som kan behöva information om systemet, eller om man i ett program behöver viss information.! För att få fram miljövariablerna: int main(int argc, char *argv[], char *envp[]){ while(**envp) printf("envp: %s\n", *envp++); 31 32!8
Exempel: Miljövariabler! Några av alla miljövariabler som finns är: envp: PWD=/crille/C_Unix/environment envp: HOSTNAME=spock.cs.kau.se envp: MACHTYPE=i386-redhat-linux-gnu envp: LANG=sv_SE envp: SHELL=/bin/bash envp: USERNAME=crille envp: HOME=/home/crille envp: PATH=/usr/local/sbin:/usr/sbin:/usr/bin: getenv och setenv! Funktionerna getenv och setenv hämtar in respektive lägger till miljövariabler. char *värde = getenv(char *namn); setenv( VARIABELNAMN, värde, overwrite);! Exempel: setenv("frukost", "flingor", 1); printf("path = %s\n", getenv("path")); printf("frukost = %s\n", getenv("frukost")); 33 34 pipe pipe i en process! Funktionen pipe skapar ett rör där data kan transporteras.! Detta rör har, som så många andra rör, två ändar.! I den ena änden skrivs data och i den andra läses det.! En pipe fungerar enligt FIFO. int pipe_fd[2]; pipe(pfd); pfd[0]: Pfd[1]: Fildescriptor för läsning Fildescriptor för skrivning write pipe read 35 36!9
Ex1: pipe i en process #define SIZE 17 char buffer[size]; int pfd[2], i; pipe(pfd); Ex2: pipe i en process #define MSG "Meddelande\n" int pfd[2], n; char buffer[100]; write(pfd[1], "Meddelande nr: 1\0", SIZE); write(pfd[1], "Meddelande nr: 2\0", SIZE); write(pfd[1], "Meddelande nr: 3\0", SIZE); for(i=0 ; i<3 ; i++) { read(pfd[0], buffer, SIZE); puts(buffer); pipe(pfd); printf( Läs fd:%d, skriv fd:%d\n", pfd[0], pfd[1]); write(pfd[1], MSG, sizeof(msg)); n = read(pfd[0], buffer, sizeof(msg)); write(1, buffer, n); 37 38 pipe mellan två processer Ex1: pipe mellan två processer förälder barn int pfd[2]; char buffer[size]; write pipe read pipe(pfd); switch(fork()) { case 0: write(pfd[1], "Meddelande nr:1\0", 17); read(pfd[0], buffer, 17); printf("barn-buffer: %s\n", buffer); default: break; write(pfd[1], "Meddelande nr:2\0", 17); read(pfd[0], buffer, 17); printf("föräldra-buffer: %s\n", buffer); 39 40!10
Ex2: pipe mellan två processer int pfd[2]; char buffer[size]; pipe(pfd); switch(fork()) { case 0: close(pfd[0]); write(pfd[1], "Meddelande nr:1\0", 17); default: break; close(pfd[1]); read(pfd[0], buffer, 17); printf("föräldra-buffer: %s\n", buffer); Ex med oblockerad pipe void barn(int p[2]) { close(p[0]); for(i=0 ; i<3 ; i++) { write(p[1], Hejsan\0", 7); sleep(3); write(p[1], Hejdå\0", 6); pipe(pfd); fcntl(pfd[0], F_SETFL, O_NONBLOCK); switch(fork()) { case 0: barn(pfd); default: foralder(pfd); 41 42 Ex med oblockerad pipe forts select void foralder(int p[2]) { int nread; char buffer[size]; close(p[1]); while(1) { switch(nread = read(p[0], buffer, 6)) { case -1: if(errno == EAGAIN) { printf("pipe'n är tom\n"); sleep(1); break; else exit(-1); case 0: printf("quit\n"); default: printf("msg=%s\n", buffer); 43! et select används för att söka efter förändringar på olika fildeskriptorer, ofta tillsammans med oblockerade pipes. int num_fds; fd_set *read_fds, write_fds, error_fds; struct timeval *timeout; select(num_fds, read_fds, write_fds, error_fds, timeout); 44!11
select fortsättning Exempel med select num_fds read_fds write_fds error_fds timeout Antalet fildeskriptorer vi vill lyssna på Kontrollerar om någon pipe vill läsa Kontrollerar om någon pipe vill skriva Kontrollerar om någon pipe har ett fel att rapportera Den tid (sek, eller millisek) select skall vänta innan den skall returnera. Om denna sätts till NULL väntar select tills något kommer. int fd1, fd2, n_fds; fd_set read_fds; fd1 = open( file1, O_RDONLY); fd2 = open( file2, O_RDONLY); n_fds = 5; //stdin + stdout + stderr + fd1 + fd2 FD_ZERO(&readset); FD_SET (fd1, &readset); FD_SET (fd2, &readset); switch(select(n_fds, &readset, NULL,NULL,NULL)) { 45 46 dup! Kommandot dup används för att duplicera en fildeskriptor. Både den gamla och den nya fildeskriptorn refererar till samma fil efter anropet.! Den nya fildeskriptorn kommer att få det lägsta lediga numret. Första gången dup görs kommer den nya fildeskriptorn att få numret 3.! STDIN(0), STDOUT(1), STDERR(2). int old_fd, new_fd; new_fd = dup(old_fd); Exempel med dup int fd, stat; creat(utfil, PERMS); if(fork() == 0) { close(stdout); dup(fd); puts("hejsan!"); close(fd); wait(&stat); puts("föräldern avslutar"); 47 48!12
dup2! et dup2 skapar även den en kopia av en fildeskriptor.! Skillnaden mellan dup och dup2 är att dup2 även stänger den gamla fildeskriptorn om det är nödvändigt. int old_fd, new_fd; dup2(old_fd, new_fd); Exempel med dup2 int fd, stat; creat(utfil, PERMS); if(fork() == 0) { dup(fd, STDOUT); puts("hejsan!"); close(fd); wait(&stat); puts("föräldern avslutar"); 49 50 fcntl! et fcntl används för att manipulera och ändra egenskaper för öppnade fildeskriptorer. fcntl(int fd, int CMD, int arg);! CMD anger kommandot som skall göras. Flera finns:! F_DUPFD Duplicera fildeskriptorer! F_GETFD Hämta fildeskriptorns flaggor! F_SETFD Sätt fildeskriptorns flaggor! F_SETLK Sätt lås på fildeskriptorn! F_GETLK Lås upp fildeskriptorn Exempel med fcntl int fd, stat, ny_ut; creat(utfil, PERMS); if(fork() == 0) { ny_ut = dup(stdout); close(stdout); dup2(fd, STDOUT); puts("hejsan!"); fflush(stdout); close(stdout); fcntl(ny_ut, F_DUPFD, STDOUT); puts("barnet avslutar"); wait(&stat); puts("föräldern avslutar"); 51 52!13
signal! En signal kan ses som ett meddelande till en process att en händelse har inträffat.! Signaler kallas även för Software interrupts.! Alla signaler har ett namn, se man-sidan eller <signal.h> int sig, hanterare; signal(sig, hanterare);! sig Signalen som skall skickas! hanterare Kan vara SIG_IGN, som talar om att ignorera signalen, eller en egen funktion att hantera signalen. Signal-genererare! Signaler kan genereras på ett flertal olika sätt! kill! Kommando kill! Tangentbord CTRL+C (SIGINT) CTRL+\ (SIGQUIT) CTRL+Z (SIGSTF)! Hårdvara Referens utanför minne (SIGEGV)! Mjukvara Out-of-bound data (SIGURG) 53 54 Exempel med signal #define SEC 1 void hanterare() { puts("du har tryckt CTRL+\"); signal(sigint, SIG_IGN); signal(sigquit, hanterare); while(1) sleep(sec); return 0; zombie! En zombie är en process som ingen längre har kontroll över.! Zombies skapas då! Ett barn dör och föräldern inte väntar på barnet! En förälder terminerar då dess barn fortfarande exekverar! Hur man undviker att få zombies:! waitpid waitpid(pid, &status, WNOHANG);! signaler olika beroende på implementation, exempelvis SysV signal(sigcld, SIG_IGN) POSIX signal(sigchld, SIG_IGN); 55 56!14
kill! et kill används för att skicka en signal till en process. kill(int pid, int signal); Om pid = 0 Skickas signalen till hela processgruppen Om pid =-1 USER=root Skickas signalen till alla processer annars Skickas signalen till användarens alla processer. Om pid <-1 Skickas signalen till hela processgruppen, utom avsändarprocessen Exempel med kill int pid, status, sig_nummer; switch(pid = fork()) { case 0: sleep(10); default: break; kill(pid, SIGTERM); pid = wait(&status); if(wifsignaled(status)) { sig_number = WTERMSIG(status); printf("signal %d terminerade barnet %d",sig_nummer, pid); 57 58 Andra signalfunktioner! raise skickar en signal till sig själv. Ekvivalent med kill(getpid(), signal). Exempel: raise(int sig);! alarm används för att starta en timer som skickar iväg en signal efter en viss tid. Alarm fungerar som sleep, med den skillnaden att systemet under tiden kan nyttjas. Exempel: alarm(3);! pause suspenderar en process (för att inte slösa CPU) till dess att en signal mottages. Exempel: pause(); 59!15