Operációs rendszerek: POSIX programozásbas.web.elte.hu/oprendszerekgyak/posix3.pdfOperációs...

Operációs rendszerek ‐ POSIX programozás 2007. szeptemer 17‐december 14.

Balogh Ádám ([email protected]) 1. oldal

ső félév

Operációs rendszerek:POSIX programozás

Balogh Ádám: Operációs rendszerek –2009–2010. els

Balogh ÁdámEötvös Loránd Tudományegyetem

Informatikai Kar

Algoritmusok és Alkalmazásaik Tanszék

ső félév

Gyakorlatok

• Gyakorlatvezető:– Balogh Ádám, tanársegéd ([email protected])

• Honlap: http://bas.web.elte.hu/oprendszerekgyak


2008. február 12‐május 18. POSIX programozás 2. oldal

ső félév

Tematika

Memóriakezelés8.

Folyamatközi kommunikáció5‐7.

Folyamatkezelés3‐4.

C nyelv, POSIX kezdőlépések1‐2.

TémakörHét



Programok bemutatása12‐13.

Háttértár és állományok kezelése9‐11.

Memóriakezelés8.



ső félév

Ajánlott irodalom

Pere LászlóUNIX – GNU/Linux



Programozás C nyelvenKiskapu, 2003

ső félév

Fellelhető segédanyagok

• http://www.unix.org/ ISO/IEC 9945 Register...Register... System Interfaces System Interfaces

• Unix shell‐ben: man 2 <függvénynév> vagy man 3 <függvénynév>



ső félév

Fordítás, szerkesztés, futtatás

• Fordítás és szerkesztés:gcc –Wall –W –pedantic –o programnév programnév.c

• Futtatás:./programnév





ső félév

Deklarációk helye C‐ben

• Változódeklarációk csak blokk elején szerepelhetnek, a végrehajtó utasítások előtt!

• Helyes:int a, b; int i;meghatároz(&a); for(i = ...meghatároz(&b);



• Helytelen:int a; for(int i = ...meghatároz(&a);int b;meghatároz(&b);

ső félév

Struktúrák (1)

• Struktúra önálló definíciója:struct név {

<mezők>};

• Ekkor egy ilyen típusú változó deklarációja:struct név változó;



• Mutató egy ilyen típusú változóra:struct név *mutató;

• Lehet a definícióval összevonva is:struct név {

<mezők>} változó, *mutató;

ső félév

Struktúrák (2)

• Struktúra, mint új típus:typedef struct {

<mezők>} név;

• Ekkor egy ilyen típusú változó deklarációja:név változó;



• Mutató egy ilyen típusú változóra:név *mutató;



ső félév

Kimenő paraméterek

• Kimenő paraméterekhez cím vagy eredmény szerinti paraméterátadás szükséges

• C‐ben minden paraméter átadása érték szerint történik

• Kimenő paraméter csak úgy valósítható meg, ha a változó címét adjuk illetve vesszük át érték szerint

• Példa:



• Példa:void ketszer(int* i) {

(*i) = 2*(*i);}

• Használata:int n;...ketszer(&n);

ső félév

Karakterláncok, tömbök, mint visszatérési értékek

• Példa:char* valami(void);

• Használata:char *s;...s = valami();

• Fontos, hogy ekkor s egy mutató, amihez a hívás előtt



Fontos, hogy ekkor s egy mutató, amihez a hívás előtt nem tartozik mutatott terület

• Ha tartozik hozzá mutatott terület, akkor az elveszik, amennyiben nincs rá másik mutató (hiszen ez a mutató új értéket kap)

• Előfordulhat az is, hogy a függvény egy lokális, statikus változóra ad vissz mutatót, így a függ‐vény újbóli hívásakor az előző érték felülíródik!

ső félév

Karakterláncok, tömbök, mint kimenő paraméterek

• Példa:void valami(char* str);

• Használata:char s[20];...valami(s);



• Fontos, hogy ekkor s egy érvényes területre mutat, amely megfelelő méretű a visszatérési érték fogadásához

• A függvény az értéket az s által mutatott területre másolja, így ha más paraméterrel újra meghívjuk, nem íródik felül az előző



ső félév

Parancssori argumentumok

• A main függvény:int main(int argc, char* argv[], char* envp[]);

• Másképp:int main(int argc, char** argv, char** envp );

• Paraméterek:argc – parancssori argumentumok száma



argc parancssori argumentumok száma

argv – parancssori argumentumok; a 0. konvenciószerint magának a programnak a neve

envp – környezeti változók

• Visszatérési érték: státuszkód – ha páros, akkor a program sikeres volt, ha páratlan, akkor nem

ső félév

Hibakezelés

• Hiba esetén a függvények valamilyen extremális értékkel térnek vissza– Egész visszatérési érték esetén tipikusan ‐1– Mutató visszatérési érték esetén tipikusan NULL– Vannak kivételes esetek, ahol más érték jelzi a hibát

• Hibakód az errno globális változóba kerül, amely az errno h fejállományban van deklarálva



errno.h fejállományban van deklarálva• Az egyes hibakódokhoz E‐vel kezdődő konstansok tartoznak, mint például EINVAL, EACCESS, ENOENT stb.

• Hiba megjelenítése:int perror(const char* text);

• Kiírja a paraméterben megadott szöveget, majd egy kettősponttal elválasztva a hiba okát a szabványos hibakimenetre (stderr)

ső félév

Hibakezelés – példák

• Visszatérési érték kizárólag a hibakezeléshez kell:if(waitpid(child, NULL, 0)<0) {

perror(”waitpid()”);exit(1);

}

• Visszatérési értékre szükség van később is:id t hild



pid_t child;if((child = fork())<0) {

perror(”fork()”);exit(1);

}



ső félév

Kiírás a képernyőre: printf

• Fejállomány(ok): stdio.h

• Szintaxis:int printf(const char* format, ...);

• Paraméterek:format – meghatározza, hogy hogyan kell kiírni az

utána következő kifejezések értékét: szó



jszerint kiírandó szövegrészletek és vezérlő‐karaktersorozatok váltják egymást

... – kifejezések, melyek értékét ki szeretnénk írni

• Visszatérési érték: kiírt bájtok száma

• Hibák:EINVAL – kevesebb argumentumot adtunk, mint

amennyit a formatmeghatároz

ső félév

A printf vezérlő karaktersorozata

• Vezérlő karaktersorozat mindig % jellel kezdődik

• Következő karakterek opcionális jelzők

• Ezeket az opcionális mezőszélesség követi– A *mezőszélesség azt jelenti, hogy a mező tényleges szélességét külön paraméter tartalmazza

• Majd opcionálisan egy ponttal elválasztva a pontosság



j p gy p p gkövetkezik– A * pontosság azt jelenti, hogy a tényleges pontosságot külön paraméter tartalmazza

• Ezután egy opcionális méretmódosító áll

• Az utolsó karakter pedig a kötelező konverziós karakter

ső félév

A printf konverziós karakterei

d, i – decimális, előjeles egész

o – oktális, előjel nélküli egész

u – decimális, előjel nélküli egész

x – hexadecimális, előjel nélküli egész

X – ugyanaz, mint x, csak nagy számjegybetűk



betűk

f, F – decimális fixpontos

e, E – decimális lebegőpontos

g, G – decimális fixpontos, nullák nélkül a végén

a, A – hexadecimális lebegőpontos

c – karakter

s – karakterlánc



ső félév

A printf módosítói

• Jelzők:- – Balra rendezés

+ – Előjel minden esetben megjelenik

<szóköz> – Pozitív előjel helyén szóköz

# – Alternatív konverzió

0 – Elejére nullák szóközök helyett



• Méretmódosítók:hh – egész helyett karakter (mint egész)

h – egész helyett rövid egész

l – egész helyett hosszú egész

ll – egész helyett nagyon hosszú egész

L – lebegőpontos helyett hosszú lebegőpontos

j, z, t – egész helyett (u)intmax_t, size_t vagyptrdiff_t

ső félév

A printf függvénycsalád többi tagja

• Írás adatállományba:int fprintf(FILE* stream, const char* format,

...);

• Írás karakterláncba:int sprintf(char* s, const char* format, ...);

• Írás karakterláncba maximált hosszon:



int snprintf(char* s, size_t n,const char* format, ...);

ső félév

Szöveg kiírása: putchar és puts


• Szintaxis:int putchar(int c);

• Paraméterek:

c – a kiírandó karakter

• Visszatérési érték: a kiírt karakter



• Visszatérési érték: a kiírt karakter


• Szintaxis:int puts(const char* s);

• Paraméterek:s – a kiírandó karakterlánc (újsor nélkül!)

• Visszatérési érték: nem negatív



ső félév

Szöveg kiírása: egyéb függvények

• Karakter kiírása állományba:int putc(int c, FILE* stream);int fputc(int c, FILE* stream);

• Karakterlánc kiírása állományba:int fputs(const char* s, FILE* stream);– Ez nem ír automatikusan újsor karaktert!



ső félév

Beolvasás a billentyűzetről: scanf


• Szintaxis:int scanf(const char* format, ...);

• Paraméterek:format – meghatározza, hogy hogyan kell értelmezni a

beírtakat: betű szerint beírandó karakterek



és vezérlő‐karaktersorozatok váltják egymást

... – mutatók változókra, melyekben a beolvasottértékeket szeretnénk tárolni

• Visszatérési érték: beolvasott bájtok száma

• Hibák:EINVAL – kevesebb argumentumot adtunk, mint

amennyit a formatmeghatároz

ső félév

A scanf vezérlő karaktersorozata

• Vezérlő karaktersorozat mindig % jellel kezdődik

• Következő karakter egy opcionális *, ami azt jelenti, hogy az adott mezőt nem kell változóba olvasni

• Ezeket az opcionális maximális mezőszélesség követi

• Ezután egy opcionális méretmódosító áll (ld. printf)

• Az utolsó karakter pedig a kötelező konverziós



• Az utolsó karakter pedig a kötelező konverziós karakter



ső félév

A scanf konverziós karakterei

i – előjeles egész

d – decimális, előjeles egész

o – oktális, előjel nélküli egész

u – decimális, előjel nélküli egész

x – hexadecimális, előjel nélküliegész



egész

a, e, f, g – valós

c – karakter

s – karakterlánc

[<karakterek>] – a karakterhalmaz elemeiből álló karakterlánc

ső félév

A scanf függvénycsalád többi tagja

• Olvasás adatállományból:int fscanf(FILE* stream, const char* format,

...);

• Olvasás karakterláncból:int sscanf(char* s, const char* format, ...);



ső félév

Szöveg beolvasása: getchar és gets


• Szintaxis:int getchar(void);

• Visszatérési érték: a beolvasott karakter




• Szintaxis:char* gets(char* s);

• Paraméterek:

s – a karakterlánc, amibe olvasni szeretnénk

• Visszatérési érték: mutató az s‐re



ső félév

Szöveg beolvasása: egyéb függvények

• Karakter beolvasása állományból:int getc(FILE* stream);int fgetc(FILE* stream);

• Karakterlánc beolvasása állományból:char* fgets(char* s, int n, FILE* stream);



ső félév

Széles karakterek

• Széles karakterek típusa: wchar_t

• Majdnem az összes eddig látott függvénynek van széles változata a wchar fejállományban:int *wprintf(<ld. fent>, const wchar_t* format, ...);int *wscanf(<ld. fent>, const wchar_t* format, ...);int putwchar(wchar_t* wc);int putwc(wchar t wc, FILE* stream);



p ( _ , );int fputwc(wchar_t wc, FILE* stream);int fputws(wchar_t wc, FILE* stream);wint_t getwchar(void);wint_t getwc(wchar_t wc, FILE* stream);wint_t fgetwc(FILE* stream);wchar_t fgetws(wchar_t* wc, int n, FILE* stream);

ső félév

0. feladat

Gyakorold a fent leírtakat, hogy az elkövetkező gyakorlatokon ezek már ne okozzanak nehézségeket!





ső félév

Követelmények a programokkal szemben

• Minden programot új forrásállományba írj, ne írd felül az előzőt!

• Amennyiben az új program a régi folytatása, előbb készíts a régiről másolatot!

• A felesleges sorokat töröld, ne kommentezd! A kommentezés megjegyzések írására és sorok ideiglenesfelfüggesztésére valók!



felfüggesztésére valók!• A program warning‐ok nélkül forduljon az előírt kapcsolók mellett is!

• A program neve egyezzen meg a forrásállomány nevével .c nélkül, ne pedig a.out legyen!

• Gyakorlat végén mentsd el a programot olyan helyre, ahonnan később is eléred!

• A program első sora kommentként tartalmazza a teljes neved és az ETR azonosítód!

ső félév

Idő és dátum lekérdezése: time

• Fejállomány(ok): time.h

• Szintaxis:time_t time(time_t* tloc);

• Paraméterek:tloc – az aktuális idő 1970 január 1. óta eltelt

másodpercben (lehet NULL, ekkor nem tárolódik)



p ( )

• Visszatérési érték: az aktuális idő 1970 január 1. óta eltelt másodpercben

• Hibák (visszatérési érték ‐1):EFAULT – érvénytelen cím a paraméterben

ső félév

Idő felbontása: localtime


• Szintaxis:struct tm* localtime(const time_t* timer);

• Paraméterek:timer – idő 1970 január 1. óta eltelt másodpercben

• Visszatérési érték: a felbontott idő (ld. következő dia)



Visszatérési érték: a felbontott idő (ld. következő dia)

• Hibák (visszatérési érték NULL):EOVERFLOW – nem bontható fel az idő túlcsordulás miatt



ső félév

A tm struktúra

struct tm {int tm_sec; /* másodperc */int tm_min; /* perc */int tm_hour; /* óra */int tm_mday; /* hónap napja */int tm_mon; /* hónap */i t t /* é */



int tm_year; /* év */int tm_wday; /* hét napja */int tm_yday; /* év napja */int tm_isdst; /* nyári időszámítás */

};

ső félév

1. feladat

Írj programot, amely kiírja az aktuális időt következő formátumban:

2007. november 28. szerda, 12:45:02

Használd a time() és a localtime() függvényeket!



ső félév

Pontos idő lekérdezése: gettimeofday

• Fejállomány(ok): sys/time.h

• Szintaxis:int gettimeofday(struct timeval* tv,

struct timezone* tz);

• Paraméterek:tv – az aktuális idő (ld. következő dia)



tz – az aktuális időzóna (általában lényegtelen)

• Visszatérési érték: 0

• Hibák (visszatérési érték ‐1):EFAULT – érvénytelen cím valamelyik paraméterben



ső félév

A timeval struktúra

struct timeval {long tv_sec; /* seconds */long tv_usec; /* microseconds */

};



ső félév

2. feladat

Módosítsd az előző programot, hogy a következő formátumban írja ki az aktuális időt:

2007. november 28. szerda, 12:55:04,89

Használd a gettimeofday() és a localtime()függvényeket! Ne használd a time() függvényt!



ső félév

Feldolgozási idő mérése: clock


• Szintaxis:clock_t clock(void);

• Visszatérési érték: a folyamat eddig felhasznált processzorideje a másodperc CLOCKS_PER_SEC‐ed részében (eleje definiálatlan)



részében (eleje definiálatlan)

• Hibák (visszatérési érték ‐1): nincsenek definiálva (de lehetségesek, ha az adat nem áll rendelkezésre vagy nem ábrázolható)



ső félév

3. feladat

Írj programot, amely valamilyen hosszú számítást végez (pl. üres ciklus), és megméri ennek a processzoron eltöltött idejét! Használd a clock() függvényt!



ső félév

Előzetes: folyamatok

• Folyamat (process): futó program az összes adatával együtt (ld. következő előadás)

• Minden folyamatnak egyedi azonosítója van: folyamatazonosító (pid)

• Folyamatok hierarchiája: szülő és gyerekfolyamatok

• Új folyamat keletkezése: folyamat lemásolódik régi



• Új folyamat keletkezése: folyamat lemásolódik, régi lesz a szülő, új a gyerek

• Egy folyamatban egyszerre egy program futhat: új törli a régit

ső félév

PID lekérdezése: getpid

• Fejállomány(ok): unistd.h

• Szintaxis:pid_t getpid(void);

• Visszatérési érték: aktuális folyamat PID‐je





ső félév

4. feladat

Kérdezd le az aktuális folyamat azonosítóját, és írd ki a képernyőre (beszédes formában)! Használd a getpid()rendszerhívást!



ső félév

Folyamat lemásolása: fork


• Szintaxis:pid_t fork(void);

• Visszatérési érték:– gyerek folyamatban: 0

– szülő folyamatban: gyerek PID‐je (pozitív)



y gy j (p )

• Működés: másolatot készít a folyamatról, majd visszatér mind a régi (szülő), mind az új (gyerek) folyamatban

• Hibák (negatív visszatérési érték):EAGAIN – felhasználó folyamatainak száma korlátozott

ENOMEM – nincs elég memória

ső félév

Folyamat befejezése: exit

• Fejállomány(ok): stdlib.h

• Szintaxis:void exit(int status);

• Működés: megszakítja a folyamatot, és a megadott állapotkóddal visszatér a szülő folyamathoz

• Visszatérési érték: nem tér vissza



Visszatérési érték: nem tér vissza

• Megjegyzés: ha a main() függvényben adjuk ki, hasonló eredményt kapunk, mint a return utasítás esetén



ső félév

Fontos figyelmeztetés!

Többfelhasználós gépen soha ne hívd a fork()‐ot végtelen ciklusban egymás után (pláne úgy, hogy ezt mind a gyerekben, mind a szülőben megteszed)! Az exponenciálisan szaporodó folyamatok l k h k é őf á bb



leköthetik a gép erőforrásait a többi felhasználó elől, ami még nagy teljesítményű gépen is érezhető lassulást okoz. Ezen kívül magadnak is ártasz, mert az üzemeltetés rövid úton megvonja a felhasználói jogaidat érte!

ső félév

5. feladat

Hozzunk létre másolatot a folyamatról, majd ha ez sikeres volt, mind az eredeti, mind az újonnan létrejött folyamat írja ki, hogy szülő vagy gyerek‐e, valamint emellett jelenítse meg a saját folyamatazonosítóját (beszédes formában), ezen kívül a szülő a gyerekét is! Használd a fork() rendszerhívást!



ső félév

Szülő PID‐jének lekérdezése: getppid


• Szintaxis:pid_t getppid(void);

• Visszatérési érték: aktuális folyamat szülő folyamatának PID‐je





ső félév

6. feladat

Egészítsd ki az előző programot úgy, hogy a gyerekfolyamat saját folyamatazonosítója mellett a szülőjének folyamatazonosítóját is írja ki (beszédes formában)! Használd a getppid() rendszerhívást!



ső félév

Várakozás adott ideig: usleep


• Szintaxis:unsigned usleep(unsigned useconds);

• Paraméterek:useconds – várakozási idő milliomod másodpercben

• Visszatérési érték: várakozásból megmaradt idő (ami 0,



Visszatérési érték: várakozásból megmaradt idő (ami 0, kivéve, ha szignál miatt fejeződött be)

• Működés: vár az előírt ideig

• Másodpercekig való várakozás:unsigned sleep(unsigned seconds);

ső félév

7. feladat előkészítése

Módosítsd az előző programot úgy, hogy a gyerekfolyamat várjon egy milliomod másodpercet, mielőtt kiírná az adatokat! Használd az usleep()rendszerhívást! Miben változott a program működése? Mi lehet a változás oka?





ső félév

Várakozás gyerek befejeződésére: waitpid

• Fejállomány(ok): sys/wait.h

• Szintaxis:pid_t waitpid(pid_t pid, int *stat_loc,

int options);

• Paraméterek:pid – gyerekfolyamat azonosítója



stat_loc – statisztikák (lehet NULL)

options – különféle opciók (lehet 0)

• Visszatérési érték: megegyezik a pid paraméterrel

• Működés: vár, amíg a gyerek be nem fejeződik

• Hibák (visszatérési érték negatív):ECHILD – a pid nem egy gyerekfolyamat azonosítója

EINVAL – érvénytelen options paraméter

ső félév

7. feladat

Javítsd ki az előző programot úgy, hogy a szülő csak akkor fejeződjön be, ha a gyerek is már befejeződött! Használd a waitpid() rendszerhívást!



ső félév

Gyerek állapota: ismét waitpid

• Ha az option paraméter értéke a WNOHANG konstans, akkor nem vár

• Ha a waitpid() olyankor tér vissza, amikor még fut a gyerek, a visszatérési értéke 0





ső félév

8. feladat

Egészítsük ki az előző programot úgy, hogy a szülő másodpercenként vizsgálja a gyereket, hogy befejeződött‐e már, és ha még nem, akkor írjon ki egy pontot a képernyőre (soremelés nélkül)! A kiegészítéshez is használd a sleep() és a waitpid() rendszerhívásokat!



ső félév

Program indítása: execle (1)


• Szintaxis:int execle( const char* path,

const char* arg0, ... /*,char* NULL,const char* envp[] */);

P ét k



• Paraméterek:path – indítandó program elérési útvonala

arg0, arg1, ... – parancssori argumentumok

envp – környezeti változók

• Működése: elindítja a megadott útvonalon található programot saját maga helyett, és átadja neki megadott argumentumokat és környezetet

• Visszatérési érték: nem tér vissza

ső félév

Program indítása: execle (2)

• Hibák (visszatér negatív visszatérési értékkel):EACCES – a programra nincsen végrehajtási jogunk

EINVAL – a program a rendszeren nem végrehajtható

ENOENT – a program nem található az adott útvonalon

ENOTDIR – az útvonal egyik könyvtára nem könyvtár

• Fontos megjegyzés: első argumentum kötelezően



azonos a program elérési útvonalával!



ső félév

Program indítása másképp

• Argumentumok tömbkéntint execve( const char* path,

const char* argv[],const char* envp[]);

• Környezet nélkül:int execl( const char* path,

const char* arg0, ... /*,( h *) NULL */ )



(char*) NULL */ );int execv( const char* path,

const char* argv[]);• A PATH környezeti változó figyelembe vételével:

int execlp( const char* file,const char* arg0, ..., /*(char*) NULL */);

int execvp( const char * file,const char * argv []);

ső félév

9. feladat

Írj programot, amely elindít egy tetszőleges programot maga helyett! (Csak ne önmagát ) Használd valamelyik exec*() függvényt, tetszés szerint!



ső félév

10. feladat

Írj programot, amely elindít egy tetszőleges programot maga helyett, majd amikor az lefutott, kiír egy üzenetet a képernyőre (például szögletes zárójelek között a lefutott program nevét)! Használd a gyakorlaton szereplő függvények közül azokat, amelyekre szükséged van!





ső félév

1. házi feladat

Írj egy egyszerű parancsértelmezőt (shell‐t)! Egy tetszőleges prompt‐nál fogadd a parancsokat, amelyek mindegyike külső parancs, azaz egy‐egy programot kell elindítanod. A programoknak természetesen argumentumaik is lehetnek, amelyeket szintén át kell adnod, a környezettel együtt. A környezet legyen azonos



, y gy y gyazzal, amit a programod kap!

ső félév

Jelzés küldése másik folyamatnak: kill

• Fejállomány(ok): signal.h

• Szintaxis:int kill(pid_t pid, int sig);

• Paraméterek:pid – folyamat azonosítója (saját folyamat!)

sig – jelzés fajtája



j j j


• Működés: elküldi a jelzést a megadott folyamatnak

• Hibák (visszatérési érték negatív):EINVAL – érvénytelen jelzésfajta

EPERM – a pid nem saját folyamat azonosítója

ESRCH – a pid nem létezik, mint folyamat azonosítója

ső félév

Néhány jelzésfajta

SIGTERM – folyamat leállítása

SIGKILL – folyamat azonnali leállítása

SIGSTOP – folyamat megállítása

SIGCONT – folyamat folytatása

SIGCHLD – gyerekfolyamat küldi, ha véget ért vagy megállt



megálltSIGALRM – ébresztőóra küldi, ha csörög

SIGUSR1 – felhasználó által definiált jelzés

SIGUSR2 – felhasználó által definiált jelzés

SIGSEGV – rendszer küldi hibásmemóriahivatkozáskor

SIGFPE – rendszer küldi aritmetikai hiba esetén



ső félév

11. feladat

Módosítsd a 8. feladat programját úgy, hogy ha a gyerekfolyamat nem ér véget három másodpercen belül, akkor a szülő állítsa le erőszakkal! Használd a kill()függvényt a SIGTERM jelzéssel!



ső félév

Jelzések kezelése: signal

• Fejállomány(ok): signal.h

• Szintaxis:void (*signal(int sig, void(*func)(int)))(int);

• Paraméterek:sig – kezelendő jelzés fajtája

func – kezelő függvény vagy SIG DFL vagy SIG IGN



gg y gy _ gy _

• Visszatérési érték: előző jelzéskezelő függvény címe

• Hibák (visszatérési érték SIG_ERR):EINVAL – érvénytelen jelzésfajta

ső félév

12. feladat

Egészítsd ki az előző programot azzal, hogy a gyerekfolyamat még kiír valamit, mielőtt leállna a szülője által küldött jelzés hatására. Használd a signal()függvényt!





ső félév

2. házi feladat

Egészítsd ki az előző házi feladatban elkészített parancsértelmezőt úgy, hogy ha a paraméterek mögő egy & jelet írunk, akkor ne várja meg, hogy az elindított program véget ér, hanem azonnal adja vissza a prompt‐ot! Vigyázz! Ha egy gyerekfolyamat előbb ér véget, mint a szülője, akkor küld a szülőjének egy SIGCHLD jelzést, és



j j gy jzombivá válik. Akkor szűnik csak meg, ha a szülő is véget ér, vagy waitpid() segítségével lekérdezi a visszatérési értékét. Egy shell hibás, ha sorozatban gyártja a zombi gyerekfolyamatokat.

ső félév

Nem kezelhető jelzések

• Két jelzés nem kezelhető:SIGKILL – folyamat azonnali leállítása

SIGSTOP – folyamat megállítása

• Ekkor a beállított kezelő függvény soha nem hívódik meg



ső félév

13. feladat

Próbáld ki az előző programot úgy, hogy SIGTERM helyett SIGKILL‐t használsz! Mi történik?





ső félév

Ébresztőóra beállítása: alarm


• Szintaxis:unsigned alarm(unsigned seconds);

• Paraméterek:seconds – ébresztésig hátrelevő idő másodpercben

• Visszatérési érték: ha az ébresztőóra már be volt állítva,



Visszatérési érték: ha az ébresztőóra már be volt állítva, akkor az az idő, ami még hátra lett volna, különben 0

• Működés: beállítja az ébresztőórát, hogy adott idő eltelte után küldjön egy SIGALRM jelzést

• Hibák: soha nem lehetnek hibák ennél a függvénynél

ső félév

Várakozás első jelzésig: pause


• Szintaxis:int pause(void);

• Visszatérési érték: nem térhet vissza sikeresen

• Működés: felfüggeszti a folyamat végrehajtását addig, amíg valamilyen jelzés nem érkezik



amíg valamilyen jelzés nem érkezik

• Hibák (visszatérési érték negatív):EINTR – várakozás közben jelzés érkezett

• Ez a hiba sok más (eddig látott) függvénynél is lehetséges!

ső félév

14. feladat

Módosítsd a 8. feladat programját úgy, hogy a sleep()függvény helyett egy saját függvényt használsz, amelyben szintén nem használod a sleep()‐et! Helyette használd az alarm() és a pause() függvényeket, meg még amire szükséged van!





ső félév

3. házi feladat

Írj egy egyszerű kétszemélyes csevegőprogramot! A programot két példányban kell elindítania a felhasználónak, az első példányt parancssori argumentum nélkül, a másodikat pedig az első folyamat azonosítójával, mint parancssori argumentummal. Ezután a két program kérjen be egy‐egy sort a felhasználótól



p g j gy gyfelváltva, küldje el a másiknak SIGUSR1 és SIGUSR2 segítségével bitenként, majd olvassa ki ugyanígy a választ. Az egyik írással kezdje, a másik olvasással, attól függően, hogy melyiket hívták parancssori argumentummal, és melyiket anélkül. Az elején, a másodszor elindított program ugyanilyen módon küldje át a saját folyamatazonosítóját az először indítottnak.

ső félév

Csővezeték létrehozása: pipe


• Szintaxis:int pipe(int filedes[2]);

• Paraméterek:filedes – két állományleíró egy tömbben:

filedes[0] – olvasásra



[ ]filedes[1] – írásra


• Hibák (visszatérési érték negatív):EMFILE – a folyamat már nem nyithat meg több állományt

ENFILE – a rendszerben már nem nyitható meg több állomány

ső félév

Írás állományleíróba: write


• Szintaxis:ssize_t write(int fildes, const void *buf,

size_t nbyte);

• Paraméterek:filedes – állomány leírója



buf – kiírandó adatok kezdőcíme

nbyte – kiírandó adatok mennyisége byte‐ban

• Visszatérési érték: kiírt adatok mennyisége (byte)

• Hibák (visszatérési érték negatív):EBADF – érvénytelen állományleíró

EPIPE – a csővezeték másik végét senki nem olvassa



ső félév

Olvasás állományleíróból: read


• Szintaxis:ssize_t read(int fildes, void *buf,

size_t nbyte);

• Paraméterek:filedes – állomány leírója



buf – beolvasandó adatok helyének kezdőcíme

nbyte – beolvasandó adatok mennyiségének maximuma byte‐ban

• Visszatérési érték: beolvasott adatok mennyisége


ső félév

15. feladat

Írj programot, amely létrehoz egy csővezetéket, majd a folyamat kettéágazik. Ezután az egyik folyamat írjon egy „Hello!” üzenetet a csőbe, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! Használd a pipe(), a write() és a read() függvényeket!



ső félév

FIFO létrehozása: mkfifo

• Fejállomány(ok): sys/stat.h

• Szintaxis:int mkfifo(const char *path, mode_t mode);

• Paraméterek:path – a FIFO, mint állomány elérési útvonala

mode – a FIFO, mint állomány hozzáférési jogai



, y j g


• Hibák (visszatérési érték negatív):EACCES – a megadott útvonalon nincs jogunk írni

EEXIST – a megadott állomány már létezik

ENOENT – az útvonal egyik könyvtára nem létezik




ső félév

Hozzáférési jogok

• Általános formátum: S_IXYYY, ahol X:R – olvasás

W – írás

X – végrehajtás

és Y:USR – felhasználó



GRP – felhasználócsoport

OTH – többi felhasználó

ső félév

Állomány megnyitása: open

• Fejállomány(ok): fcntl.h

• Szintaxis:int open(const char *path, int oflag, ...);

• Paraméterek:path – állomány elérési útvonala

oflag – állomány hozzáférési módja



g y j

• Visszatérési érték: megnyitott állomány leírója

• Hibák (visszatérési érték negatív):EACCES – a megadott módban nincs jogunk megnyitni

EEXIST – létező állományt próbálunk újra létrehozni

EISDIR – könyvtárat próbálunk megnyitni írásra

ENOENT – nem létező állományt próbálunk megnyitni


ső félév

Hozzáférési módok

• Alapvető módok (pontosan egyet kell megadni):O_RDONLY – csak olvasás

O_WRONLY – csak írás

O_RDWR – olvasás és írás egyszerre (módosítás)

• Kiegészítő módok (opcionálisak):O_CREAT – ha nem létezik, létrehozandó



O_EXCL – ha meg van adva O_CREAT, és létezik, hibaO_TRUNC – ha létezik, nullázandó (FIFO‐nál nem számít)

O_APPEND – ha létezik, bővítendő (FIFO‐nál nem számít)



ső félév

Állomány lezárása: close


• Szintaxis:int close(int fildes);

• Paraméterek:fildes – állomány leírója




Visszatérési érték: 0

• Hibák (visszatérési érték negatív):EBADF – a megadott állományleíró érvénytelen

ső félév

Állomány törlése: unlink


• Szintaxis:int unlink(const char *path);

• Paraméterek:path – állomány elérési útvonala





• Hibák (visszatérési érték negatív):EACCES – az állományt nincs jogunk törölni

ENOENT – az állomány nem létezik


ső félév

16. feladat

Írj programot, amely rögtön az elején kettéágazik! Ezután mindkét folyamat próbálja meg létrehozni ugyanazt a FIFO‐t, nyissa meg, és az egyik írjon bele egy „Hello!” üzenetet, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! Írás illetve olvasás után minkét folyamat zárja le a FIFO‐t, és a végén a szülő, miután megvárta a



j , g , ggyerek befejeződését törölje is le. Használd az mkfifo(), az open(), a write(), a read() és a close()függvényeket!



ső félév

4. házi feladat

Írj egy egyszerű kétszemélyes csevegőprogramot! A program parancssori argumentuma egy állomány elérési útvonala legyen. Ha létezik az állomány, akkor feltételezhetjük, hogy FIFO, és nyissuk meg. Ha nem, akkor hozzuk létre FIFO‐ként, és szintén nyissuk meg. Így ha a programot két példányban indítjuk, pontosan az



p g p y j , pegyik hozza majd létre (kezdetben ne legyen ott semmi). A két program kérjen be egy‐egy sort a felhasználótól felváltva, írja a FIFO‐ba, majd olvassa ki onnan a választ. Az egyik írással kezdje, a másik olvasással, attól függően, hogy melyik hozta létre.

ső félév

Foglalat létrehozása: socket

• Fejállományok: sys/socket.h

• Szintaxis:int socket(int domain, int type, int protocol);

• Paraméterek:domain – foglalat fajtája (most: AF_UNIX)type – foglalat típusa (most: SOCK DGRAM)



yp g p ( _ )

protocol – speciális protokoll (lehet 0)

• Visszatérési érték: foglalatleíró

• Hibák:EAFNOSUPPORT – nem támogatott foglalatfajta

EPROTONOSUPPORT – nem támogatott speciális protokoll

EPROTONTYPE – nem támogatott foglalattípus

ső félév

Foglalathoz új cím rendelése: bind

• Fejállomány(ok): sys/socket.h

• Szintaxis:int bind( int socket,

const struct sockaddr *address,socklen_t address_len);

• Paraméterek:



socket – foglalat leírója

address – cím, amit a foglalathoz kell rendelni

address_len – cím mérete


• Hibák:EADDRINUSE – már használatban levő cím

EBADF – hibás foglalatleíró



ső félév

Egy unix foglalat címe

• A bind() eredetileg egy struct sockaddr címét várja

• Mi struct sockaddr_un‐ra adunk át neki mutatót típuskényszerítés kell!

• Ez a sys/un.h fejállományban található

• Mezői:sa family t sun family;



sa_family_t sun_family;char sun_path[UNIX_MAX_PATH];

• A sun_family helyére AF_UNIX‐ot kell írni

• A sun_path‐ba egy állománynév kerül (Unix foglalat egy speciális állomány, mint a FIFO)

ső félév

Foglalathoz létező cím rendelése: connect


• Szintaxis:int connect( int socket,

const struct sockaddr *address,socklen_t address_len);

• Paraméterek:



socket – foglalat leírója

address – cím, amit a foglalathoz kell rendelni

address_len – cím mérete


• Hibák:EADDRNOTAVAIL – nem létező cím

EBADF – hibás foglalatleíró

ső félév

Küldés foglalaton keresztül: send

• Fejállomány(ok): sys/socket.h• Szintaxis:

ssize_t send( int socket, const void *bufer,size_t length, int flags);

• Paraméterek:socket – foglalatleíró, amibe küldeni szeretnénkbuffer – átküldendő adatok kezdőcíme



buffer átküldendő adatok kezdőcímelength – átküldendő adatok hossza byte‐banflags – egyéb opciók (lehet 0)

• Visszatérési érték: átküldött adatok hossza (byte)• Hibák (visszatérési érték negatív):

EBADF – érvénytelen foglalatleíróENOTSOCK – a foglalatleíró nem foglalatot ír leENOTCONN – a foglalatleíróhoz nincs cím rendelve



ső félév

Fogadás foglalaton keresztül: recv

• Fejállomány(ok): sys/socket.h• Szintaxis:

ssize_t recv( int socket, void *bufer,size_t length, int flags);

• Paraméterek:socket – foglalatleíró, amiből fogadni szeretnénkbuffer – fogadott adatok helyének kezdőcíme



buffer fogadott adatok helyének kezdőcímelength – fogadandó adatok maximális hossza byte‐banflags – egyéb opciók (lehet 0)

• Visszatérési érték: átküldött adatok hossza (byte)• Hibák (visszatérési érték negatív):

EBADF – érvénytelen foglalatleíróENOTSOCK – a foglalatleíró nem foglalatot író leENOTCONN – a foglalatleíróhoz nincs cím rendelve

ső félév

17. feladat

Írj programot, amely rögtön az elején kettéágazik! Ezután az egyik folyamat próbáljon meg létrehozni egy Unix‐foglalatot, a másik pedig kapcsolódjon hozzá, írjon bele egy „Hello!” üzenetet, az első pedig olvassa ki azt onnan, és írja ki a képernyőre! Írás illetve olvasás után minkét folyamat zárja le a foglalatot, és a végén a szülő, miután



y j g gmegvárta a gyerek befejeződését törölje is le. Használd a socket(), bind(), connect(), send(), recv() és close()függvényeket!

ső félév

Kapcsolatorientált foglalat létrehozása

• A socket() függvény type paramétere: SOCK_STREAM

• Kapcsolódó fél azonosítható

• Fogadás nem közvetlenül a foglalatról, hanem egy al‐foglalaltról történik





ső félév

Várakozás kapcsolatra: listen


• Szintaxis:int listen(int socket, int backlog);

• Paraméterek:socket – főfoglalat leírója

backlog – várakozási sor hoszza (lehet 0)



• Működés: vár, amíg a foglalaton keresztül kapcsolódás történik


• Hibák:EBADF – hibás foglalatleíró

EOPNOTSUPP – nem lehet várakozni kapcsolatra (pl. kapcsolatmentes)

ső félév

Kapcsolat fogadása: accept


• Szintaxis:int accept( int socket,

struct sockaddr *address,socklen_t *address_len);

• Paraméterek:



socket – főfoglalat leírója

address – kapcsolódó fél címe (lehet NULL)address_len – kapcsolódó fél címének mérete (lehet NULL)

• Visszatérési érték: alfoglalat leírója

• Hibák:EBADF – hibás foglalatleíró

EOPNOTSUPP – nem fogadható kapcsolat (pl. kapcsolatmentes)

ső félév

18. feladat

Módosítsd az előző programot úgy, hogy kapcsolatmentes foglalt helyett, kapcsolatorientált foglalatot használjon. A fogadó oldal előbb várakozon a kapcsolatra, majd fogadja azt, és rajta keresztül az üzenetet. Használd a socket(), bind(), connect(), listen(), accept(), send(), recv(), close() és unlink()



függvényeket!



ső félév

5. házi feladat

Írd meg az előző házi feladatban specifikált csevegőprogramot úgy, hogy FIFO helyett Unix foglalatot használsz!



ső félév

Üzenetsor használata: msgget

• Fejállomány(ok): sys/msg.h és sys/ipc.h• Szintaxis:

int msgget(key_t key, int msgflg);• Paraméterek:

key – kulcs az üzenetsorhoz• egyedi azonosító• IPC PRIVATE



_msgflg – hozzáférési jogok, valamint módosítók:

• IPC_CREAT– új üzenetsor létrezohása, ha nem létezik• IPC_EXCL – ha létezik, és IPC_CREAT van, akkor hiba

• Visszatérési érték: üzenetsor azonosítója• Hibák (negatív visszatérési érték):

EACCES – már létezik, de nincs jogunk hozzáEEXIST – létezik, és IPC_EXCL‐t adtunk megENOSPC – nem lehet többet létrehozni

ső félév

Üzenet küldése üzenetsorba: msgsnd

• Fejállomány(ok): sys/msg.h• Szintaxis:

int msgsnd(int msqid, const void *msp,size_t msgsz, int msgflg);

• Paraméterek:msqid – üzenetsor azonosítójamsp – üzenet kezdőcíme



msp üzenet kezdőcíme msgsz – üzenet tartalmának méretemsgflg – módosítók

• Visszatérési érték: 0• Hibák (negatív visszatérési érték):

EACCES – nincs jogunk írni beleEIDRM – törlés alatt vanEINVAL – üzenetsor vagy üzenet azonosítója hibás



ső félév

Egy üzenet formátuma

• Egy üzenetnek a következő formátumúnak kell lennie:struct msgbuf {

long mtype; /* üzenet típusa, pozitív */char mtext[1]; /* üzenet tartalma */

};

• Ez struktúra egyetlen fejállományban sincs így d fi iál k k k ll lét h k h lót



definiálva, magunknak kell létrehoznunk egy hasonlót

• Az üzenet tartalma tetszőleges típusú és méretű

ső félév

Üzenet fogadása üzenetsorból: msgrcv

• Fejállomány(ok): sys/msg.h

• Szintaxis:ssize_t msgrcv( int msqid, const void *msp,

size_t msgsz, long msgtyp,int msgflg);

• Paraméterek:



msqid – üzenetsor azonosítója

msp – üzenet kezdőcíme

msgsz – üzenet tartalmának mérete

msgtyp – üzenet típusa

msgflg – módosítók

• Visszatérési érték: fogadott bájtok száma

• Hibák: lásd msgsnd!

ső félév

Üzenetsor kezelése: msgctl

• Fejállomány(ok): sys/msg.h és sys/ipc.h

• Szintaxis:int msgctl(int msqid, int cmd,

struct msqid_ds *buf);

• Paraméterek:msqid – üzenetsor azonosítója



j

cmd – parancs

buf – parancs argumentuma


• Hibák:EACCES – nincs jogunk a kívánt művelethez

EIDRM – törlés alatt van

EINVAL – üzenetsor azonosítója hibás



ső félév

System V IPC kezelőparancsok

IPC_STAT – kommunikációs erőforrás adatainak lekérdezése– argumentuma: struct msqid_ds * buf

IPC_SET – kommunikációs erőforrás hozzáférési jogainak beállítása– argumentuma: struct msqid ds * buf



g q _

IPC_RMID – kommunikációs erőforrás törlése– argumentuma: NULL

ső félév

19. a) feladat

Írj programot, amely létrehoz egy üzenetsort, majd a folyamat kettéágazik. Ezután az egyik folyamat írjon egy „Hello!” üzenetet az üzenetsorba, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! A végén a szülő, miután megvárta a gyerek befejeződését törölje is le az üzenetsort. Használd az msgget(), msgsnd(), msgrcv() és



msgctl() függvényeket!

ső félév

19. b) feladat

Írj programot, amely rögtön az elején kettéágazik! Ezután mindkét folyamat próbálja meg létrehozni ugyanazt az üzenetsort, az egyik írjon bele egy „Hello!” üzenetet, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! A végén a szülő, miután megvárta a gyerek befejeződését törölje is le az üzenetsort. Használd az msgget(),



jmsgsnd(), msgrcv() és msgctl() függvényeket!



ső félév

6. házi feladat

Írd meg a 3. házi feladatban specifikált csevegőprogramot úgy, hogy FIFO helyett System V üzenetsort használsz!



ső félév

Osztott terület használata: shmget

• Fejállomány(ok): sys/shm.h és sys/ipc.h

• Szintaxis:int shmget(key_t key, size_t size, int shmflg);

• Paraméterek:key – kulcs az osztott területhez (ld. üzenetsorok)

size – osztott terület mérete



shmflg – hozzáférési jogok, valamint módosítók (ld. üzenetsorok)

• Visszatérési érték: osztott terület azonosítója

• Hibák (negatív visszatérési érték): (ld. üzenetsorok)

ső félév

Osztott terület leképezése: shmat

• Fejállomány(ok): sys/shm.h

• Szintaxis:void *shmat(int shmid, const void *shmaddr,

int shmflg);

• Paraméterek:shmid – osztott terület azonosítója



j

shmaddr – kezdőcím, amire le kell képezni, vagy NULLshmflg – módosítók

• Visszatérési érték: kezdőcím, amire le lett képzve

• Hibák (visszatérési érték (void *) -1):EACCES – nincs jogunk leképezni

EINVAL – osztott terület azonosítója vagy a kezdőcím, amire le szeretnénk képezni hibás



ső félév

Osztott terület elengedése: shmdt

• Fejállomány(ok): sys/shm.h

• Szintaxis:int shmdt(const void *shmaddr);

• Paraméterek:shmaddr – kezdőcím, amire egy osztott terület le van képezve





• Hibák (negatív visszatérési érték):EINVAL – hibás kezdőcím, vagy nincs rá osztott terület

leképezve

ső félév

Osztott terület kezelése: shmctl

• Fejállomány(ok): sys/shm.h és sys/ipc.h

• Szintaxis:int shmctl(int shmid, int cmd,

struct shmid_ds *buf);

• Paraméterek:shmid – osztott terület azonosítója



j

cmd – parancs

buf – parancs argumentuma


• Hibák:EACCES – nincs jogunk a kívánt művelethez

EIDRM – törlés alatt van

EINVAL – osztott terület azonosítója hibás

ső félév

20. a) feladat

Írj programot, amely létrehoz egy osztott memóriaterületet, majd a folyamat kettéágazik. Ezután az egyik folyamat írjon egy „Hello!” üzenetet az osztott memóriaterületre, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! A végén a szülő, miután megvárta a gyerek befejeződését törölje is le az osztott



gy j jmemóriaterületet. Használd az shmget(), shmat(), shmdt() és shmctl() függvényeket!



ső félév

20. b) feladat

Írj programot, amely rögtön az elején kettéágazik! Ezután mindkét folyamat próbálja meg létrehozni ugyanazt az osztott memóriaterületet, az egyik írjon bele egy „Hello!” üzenetet, a másik pedig olvassa ki azt onnan, és írja ki a képernyőre! A végén a szülő, miután megvárta a gyerek befejeződését törölje is le az osztott memóriaterületet.



j jHasználd az shmget(), shmat(), shmdt() és shmctl()függvényeket!

ső félév

Szemafortömb használata: semget

• Fejállomány(ok): sys/sem.h és sys/ipc.h

• Szintaxis:int semget(key_t key, int nsems, int semflg);

• Paraméterek:key – kulcs szemafortömbhöz (ld. üzenetsorok)

nsems – szemaforok száma a tömbben



semflg – hozzáférési jogok, valamint módosítók (ld. üzenetsorok)

• Visszatérési érték: szemafortömb azonosítója

• Hibák (negatív visszatérési érték): (ld. üzenetsorok)

ső félév

Szemafortömb kezelése: semctl

• Fejállomány(ok): sys/sem.h és sys/ipc.h• Szintaxis:

int semctl(int semid, int semnum, int cmd,union semun arg);

• Paraméterek:semid – szemafortömb azonosítójasemnum – szemafor indexe



semnum szemafor indexecmd – parancsarg – parancs argumentuma

• Visszatérési érték: 0• Hibák:

EACCES – nincs jogunk a kívánt művelethezEIDRM – törlés alatt vanEINVAL – szemafortömb azonosítója hibás



ső félév

Szemaforkezelő‐parancsok

SETVAL – szemafor értékének beállítása– argumentumának típusa:

union semun arg {int val;struct semid_ds *buf;unsigned short *array;

};



};– Ez a parancs a valmezőt használja

SETALL – összes szemafor értékének beállítása– ez a parancs is a valmezőt használja

GETVAL – szemafor értékének lekérdezése– ez a parancs nem használja egyik mezőt sem

GETALL – szemafor értékének lekérdezése– ez a parancs az arraymezőt használja

ső félév

Művelet szemafortömbön: semop

• Fejállomány(ok): sys/sem.h• Szintaxis:

int semop(int semid, struct sembuf *sops,unsigned nsops);

• Paraméterek:semid – szemafortömb azonosítójasops – szemaforműveletek leírása



sops szemaforműveletek leírásansops – szemaforműveletek száma

• Visszatérési érték: 0• Hibák:

EACCES – nincs jogunk a kívánt művelethezEIDRM – törlés alatt vanEFBIG – egy szemador indexe hibásEINVAL – szemafortömb azonosítója, vagy a műveletek száma

hibás

ső félév

Szemaforműveletek

• Műveleteket egy tömbben adjuk meg

• A tömb elemei:struct sembuf {

short sem_num; /* szemafor indexe */short sem_op; /* művelet a szemadoron */short sem_flg; /* művelet módosítója */

};



};

• A művelet nem más, mint egy előjeles egész, amit a szemafor értékéhez kell adni– Ha negatív lenne az eredmény, felfüggesztődik

• Módosító lehet 0, vagy SEM_UNDO, ami azt jelenti, hogy a folyamat befejeződésekor a művelet visszavonásra kerül



ső félév

21. feladat

Javítsd ki az előző programot egy szemafor segítségével, nehogy az olvasó folyamat azelőtt olvassa ki az üzenetet, hogy az író beleírta volna! Az eddigieken kívül használd a semget(), semop() és semctl() függvényeket!



ső félév

7. házi feladat

Írd meg a 3. házi feladatban specifikált csevegőprogramot úgy, hogy FIFO helyett System V osztott területet és System V szemafortömböt használsz!



ső félév

Memória lefoglalása: malloc

• Fejállomány(ok): stdlib.h• Szintaxis:

void *malloc(size_t size);• Paraméterek:

size – a lefoglalandó terület mérete

• Visszatérési érték: a lefoglalt terület kezdőcíme• Hibák



• Hibák:ENOMEM – nincs elég memória



ső félév

Memória felszabadítása: free

• Fejállomány(ok): stdlib.h• Szintaxis:

void free(void *ptr);• Paraméterek:

ptr – a felszabadítandó terület kezdőcíme

• Visszatérési érték: nincs• Hibák i k d fi iál d hibá k dő í té



• Hibák: nincsenek definiálva, de hibás kezdőcím esetén meghatározatlan viselkedés

ső félév

Memória feltöltése: memset

• Fejállomány(ok): string.h• Szintaxis:

void *memset(void* s, int c, size_t n);• Paraméterek:

s – a feltöltendő terület kezdőcímec – a bájt, amivel fel kell töltenin – a feltöltés hossza



n – a feltöltés hossza

• Visszatérési érték: s• Hibák: nincsenek definiálva

ső félév

Memória másolása: memcpy


void *memcpy(void *s1, void *s2, size_t n);• Paraméterek:

s1 – a terület kezdőcíme, ahova másolni kells2 – a terület kezdőcíme, ahonnan másolni kell (átfedés

nélkül)



nélkül)n – az átmásolandó bájtok száma

• Visszatérési érték: s1• Hibák: nincsenek definiálva



ső félév

Memória összehasonlítása: memcmp


int memcmp(void *s1, void *s2, size_t n);• Paraméterek:

s1 – az egyik összehasonlítandó terület kezdőcímes2 – a másik összehasonlítandó terület kezdőcímen – az az összehasonlítandó területek hossza



n – az az összehasonlítandó területek hossza

• Visszatérési érték: negatív, ha az első argumentum lexikografikusan kisebb, mint a másik, pozitív, ha fordítva és 0, ha egyenlők

• Hibák: nincsenek definiálva

ső félév

22. feladat

Hozz létre egy 1 kB méretű memóriaterületet, és töltsd fel egyesekkel! Majd hozz létre még egyet, és másold át oda az előzőt! Ellenőrizd, hogy sikeres volt‐e a másolás, valóban ugyanaz van‐e mindkét területen! Használd a malloc(), memset(), memcpy(), memcmp() és free()függvényeket!



gg y

ső félév

Állomány adatainak lekérdezése: stat

• Fejállomány(ok): sys/stat.h• Szintaxis:

int stat(const char *path, struct stat *buf);• Paraméterek:

path – az állomány elérési útvonalabuf – az adatok (ld. következő dia)




• Visszatérési érték: 0• Hibák (visszatérési érték negatív):

ENOENT – nem létező állományENOTDIR – útvonal egyik könyvtára nem könyvtárENAMETOOLONG – túl hosszú állománynévEACCES – nincs jogunk az állományra



ső félév

A struct stat mezői

struct stat {dev_t st_dev;ino_t st_ino;mode_t st_mode;nlink_t st_nlink;uid_t st_uid;gid t st gid;



g _ _gdev_t st_rdev;off_t st_size;unsigned long st_blksize;unsigned long st_blocks;time_t st_atime;time_t st_mtime;time_t st_ctime;

};

ső félév

23. feladat

Írj programot, amely egy – a parancssorban megadott –állománynak kiírja a méretét a képernyőre! Használd a stat() függvényt!



ső félév

Könyvtár megnyitása: opendir

• Fejállomány(ok): dirent.h

• Szintaxis:DIR *opendir(const char *name);

• Paraméterek:name – a könyvtár elérési útvonala

• Visszatérési érték: mutató a könyvtár folyamleírójára



Visszatérési érték: mutató a könyvtár folyamleírójára

• Hibák (visszatérési érték NULL):EACCES – a megadott módban nincs jogunk megnyitni

ENOENT – nem létező könyvtárat próbálunk megnyitni

ENOTDIR – a könyvtár nem könyvtár



ső félév

Könyvtár olvasása: readdir


• Szintaxis:struct dirent *readdir(DIR *dir);

• Paraméterek:dir – a könyvtár folyamatleírója

• Visszatérési érték: mutató egy könyvtárbejegyzésre (ld.



Visszatérési érték: mutató egy könyvtárbejegyzésre (ld. következő dia), vagy NULL, ha nincs több bejegyzés

• Hibák (visszatérési érték NULL):EBADF – érvénytelen folyamleíró

ső félév

A struct dirent mezői

struct dirent {long d_ino;off_t d_off;unsigned short d_reclen;unsigned char d_type;char d_name[256];

};



ső félév

Könyvtár bezárása: closedir


• Szintaxis:int closedir(DIR *dir);

• Paraméterek:dir – a könyvtár folyamleírója





• Hibák (visszatérési érték negatív):EBADF – érvénytelen folyamleíró



ső félév

24. feladat

Írj programot, amely egy – a parancssorban megadott –könyvtárnak kiírja a tartalmát! Használd az opendir(), a readdir() és a closedir() függvényt!



ső félév

8. házi feladat

Írj fejlett könyvtárlistázó programot! Parancssori opciókban lehessen megadni, hogy a könyvtár állományainak milyen adataira vagyunk kíváncsiak! Sőt, ha a parancssorban megadott állomány nem könyvtár, akkor se adjon hibaüzenetet, hanem akkor írja ki annak az egy állománynak az adatait, mint a valódi ls parancs!



gy y p

ső félév

Állományok figyelése: select (1)

• Fejállomány(ok): sys/select.h• Szintaxis:

int select(int nfds, fd_set *readfds,fd_set *writefds, fd_set *errorfds,const struct timeval *timeout);

• Paraméterek:nfds – legnagyobb állományleírónál eggyel nagyobb



nfds legnagyobb állományleírónál eggyel nagyobbreadfds – olvasásra figyelt állományok leíróiwritefds – írásra figyelt állományok leíróierrorfds – hibára figyelt állományoktimeout – időkorlát

• Visszatérési érték: azon állományok száma, ahol a figyelt esemény megtörtént



ső félév

Állományok figyelése: select (2)

• Paraméterek visszatéréskor:readfds – olvasható állományok leírói

writefds – írható állományok leírói

exceptfds – hibás állományok leírói



ső félév

Segédfüggvények a select‐hez

void FD_ZERO(fd_set *fdset);– Üríti az fdset halmazt

void FD_SET(int fd, fd_set *fdset);– Hozzáadja az fd állományleírót az fdset halmazhoz

void FD_CLR(int fd, fd_set *fdset);– Törli az fd állományleírót az fdset halmazból

i t FD ISSET(i t fd fd t *fd t)



int FD_ISSET(int fd, fd_set *fdset);– Megadja, hogy az fd állományleíró az fdset halmaz tagja‐e

ső félév

25. feladat

Írj programot, amely beolvas egy szöveget a billentyűzetről, és kiírja a képernyőre! A beolvasás legyen időkorlátos, amennyiben a program 5 másodpercen belül nem kapja meg a szöveget, álljon le hibaüzenettel! Használd a select() függvényt!





ső félév

9. házi feladat

Módosítsd a FIFO‐t vagy a Unix foglalatot használó csevegőprogramodat úgy, hogy a két csevegő partner ne csak felváltva kommunikálhasson, hanem bármelyik írhasson bármikor üzenetet, azonban egy perc inaktivitás után lépjen ki!



ső félév

26. feladat előkészítése

Töltsd le a következő programot, fordítsd le, és próbáld ki!

http://bas.web.elte.hu/oprendszerekgyak/badputs.c



ső félév

Állomány vezérlése: fcntl


• Szintaxis:int fcntl(int fildes, int cmd, ...);

• Paraméterek:fildes – állomány leírója

cmd – vezérlőparancs



p

• Visszatérési érték: parancsfüggő


(egyéb hibák parancsfüggőek)



ső félév

Állomány zárolása (1)

• fcntl() függvényhez parancs: F_SETLKW

• Argumentuma:struct flock {

short l_type;short l_whence;off_t l_start;off t l len;



off_t l_len;pid_t l_pid;

};• Zártípusok (l_type):

F_RDLCK – olvasási zárF_WRLCK – írási zárF_UNLCK – zár feloldása

ső félév

Állomány zárolása (2)

• Zár kezdetének viszonyítása (l_whence):SEEK_SET – állomány elejétől

SEEK_END – állomány végétől

SEEK_CUR – jelenlegi pozíciótól



ső félév

26. feladat

Javítsd ki az előző programot úgy, hogy a badputs() függvény a ciklus idejére zárolja a standard output‐ot! Használd az fctnl() függvényt az F_SETLKW paranccsal!





ső félév

10. házi feladat

Írj egy leegyszerűsített többfelhasználós raktárkezelő rendszert! A raktárkészletet nem más, mint egy bináris állomány, mely az egyes árufajták mennyiségét tartalmazza. A cikkszám az állománybeli pozíció. Írj egy programot, amellyel tetszőleges két cikkszám közötti áruk mennyiségét listázhatjuk cikkszám‐mennyiség



y g j y gformátumban, és egy másikat, amellyel egy adott áru mennyiségét módosíthatjuk. A programokat egyszerre többen is használhatják, így ügyelj a megfelelő zárolásra, a teljesítmény lehetőség szerinti maximális megőrzése mellett!

ső félév

Lineáris keresés: lfind

• Fejállomány(ok): search.h

• Szintaxis:void *lfind(const void *key, const void *base,

const size_t *nmemb, size_t size,int(*compar)(const void*, const void*));

• Paraméterek:



key – keresendő elem

base – tömb kezdőcíme

nmemb – elemek száma

size – elemek mérete

compar – összehasonlító függvény

• Visszatérési érték: keresett elem címe a tömbben (ha megvan) vagy NULL (ha nincs meg)

ső félév

27. feladat

Töltsd le a következő programrészletet!

http://bas.web.elte.hu/oprendszerekgyak/numsearch.c

Írj main() függvényt, amely megkeresi a 4‐es számot a tömbben, az lfind() függvény segítségével, és kiírja, hogy há dik í ió l (1 l k d í iók



hányadik pozíción szerepel (1‐gyel kezdve a pozíciók számozását)!



ső félév

Logaritmikus (bináris) keresés: bsearch


• Szintaxis:void *bsearch(const void *key, void *base,

size_t nmemb, size_t size,int(*compar)(const void*, const void*));

• Paraméterek:



key – keresendő elem

base – növekvően rendezett tömb kezdőcíme




• Visszatérési érték: keresett elem címe a tömbben (ha megvan) vagy NULL (ha nincs meg)

ső félév

28. feladat

Írd át az előző main() függvényt, hogy a bsearch()függvény segítségével keressen!



ső félév

Hasítótábla létrehozása: hcreate


• Szintaxis:int hcreate(size_t nel);

• Paraméterek:nel – elemek száma

• Működés: létrehoz egy hasítótáblát (folyamatonként



Működés: létrehoz egy hasítótáblát (folyamatonként legfeljebb egy tábla)

• Visszatérési érték: nem 0, ha sikeres volt, 0, ha sikertelen



ső félév

Keresés hasítótáblában: hsearch


• Szintaxis:ENTRY *hsearch(ENTRY item, ACTION action);

• Paraméterek:item – keresndő elem

struct entry {



y {char *key;void *data;

} ENTRY;action – ENTER: beszúrás, FIND: keresés

• Visszatérési érték: keresett elem címe a táblában (ha megvan vagy most szúrtuk be) vagy NULL (ha nincs meg és nem is szúrtuk be)

ső félév

Hasítótábla megszüntetése: hdestroy


• Szintaxis:void hdestroy(void);



ső félév

29. feladat


http://bas.web.elte.hu/oprendszerekgyak/fruitsearch.c

Írj main() függvényt, amely betölti az összes gyümölcsöt az árával együtt egy hasítótáblába, majd megkeresi ott a il a á át a h h() fü é y e ít é é el!



szilva árát, a hsearch() függvény segítségével!



ső félév

Gyorsrendezés: qsort


• Szintaxis:void qsort(void *base, size_t nmemb, size_t size,

int(*compar)(const void*, const void*));

• Paraméterek:base –rendezendő tömb kezdőcíme






ső félév

30. feladat


http://bas.web.elte.hu/oprendszerekgyak/numsort.c

Írj main() függvényt, amely rendezi a tömböt, a qsort()függvény segítségével, és kiírja sorban a rendezett tömb l it!



elemeit!

ső félév

Keresés és beszúrás bináris keresőfába: tsearch


• Szintaxis:void *tsearch(const void *key, void **rootp,

int(*compar)(const void*, const void*));

• Paraméterek:key – keresendő elem



rootp – fa gyökerének címe (kezdetben void* NULL)compar – összehasonlító függvény

• Visszatérési érték: keresett elem címe a fában



ső félév

Keresőfa bejárása: twalk


• Szintaxis:void twalk(const void *root,

void(*action)(const void* nodep,const VISIT which,const int depth));

é k



• Paraméterek:rootp – fa gyökere

action – minden elemre meghívandó függvény (belső elemekre háromszor!)

ső félév

31. feladat

Írd át az előző main() függvényt, hogy a tsearch() és a twalk() függvények segítségével egy bináris keresőfát felhasználva írja ki növekvő sorrendben az elemeket!



Operációs rendszerek: POSIX programozásbas.web.elte.hu/oprendszerekgyak/posix3.pdfOperációs...

Documents

Transcript of Operációs rendszerek: POSIX programozásbas.web.elte.hu/oprendszerekgyak/posix3.pdfOperációs...