Otázky ke zkoušce z UNIXu ========================= A) Vývojové nástroje -------------------- 1. Popište činnost kompilátoru jazyka C a linkeru. 2. Vysvětlete princip utility make a napište příklad jednoduchého makefile pro překlad a slinkování programu v C. B) Jádro a C API UNIXu ---------------------- 1. Vysv ětlete význam parametr ů funkce main() a proměnné environ. Jak se zpracovávají argumenty programu pomocí funkce getopt()? Parametry i environ jsou pole ukončená NULL. getenv( name ), putenv( name=vlaue ) getop(argc(index), argv, ab: )!=1?unknown+optopt :missing value optarg-value 2. Vysvětlete význam pojm ů proces, vlákno (thread), program. Čím se liší proces a vlákno? 3. Vysvětlete pojmy knihovní funkce a systémové volání. Popište konvenci, podle které systémová volání a knihovní funkce oznamují úspěšné ukončení nebo chybu. 4. Co obsahují soubory /etc/passwd a /etc/group? Kdy a jak používá Unix informace z těchto soubor ů. 5. Jak se používá identifikace vlastníka a skupiny pro testování přístupových práv? Jaký je rozdíl mezi reálným a efektivním vlastníkem procesu? Nejprve UID=0, uid=uid, gid=gid, gid \in sgid, else C) Systém souborů ----------------- 1. Jaké objekty jsou v UNIXu přístupné pomocí rozhraní systému soubor ů? Jaký je rozdíl mezi znakovými a blokovými zařízeními? Všechno: sockety, zařízení, pojmenované roury, procesy, pamět...
bloková zařízení čtou bufferov ě (pevná velik. bloku), znaková po bytech 2. Popište strukturu svazku typu s5 a jeho vylepšení (ufs). Svazek=filesystem bloky délky 512, 1024, 2048B disk: 1. boot blok(zavaděč OS) 2. superblok(info o svazku, počet blok ů pro i-nodes, počet blok ů, seznam volných blok ů, volných i-nodes, další info) 3. oblast i-nodes 4. oblast datových blok ů (může i i-nodes) i-node: typ souboru, přístupová práva, vlastník, skupina, čas přístup, modif, mofif i-nody, počet odkaz ů na soubor, velikost souboru, 10 odkaz ů na datové bloky a 3 odkazy na napřímé bloky (další i-nody) hardlink-odkaz na stejný i-node symlink-odkaz na skutečnou cestu vylepšení členění na skupiny cylindr ů, každá skupina obsahuje: kopii superbloku řídící blok skupiny tabulku i-nodes bitmapy volných i-nodes a datových bloků datové bloky bloky velik 4-8kB, fragmenty bloků jména dlouhá až 255znaků 3. Vysvětlete princip navigace ve struktuře adresá řů, tj. jak jádro najde podle cesty k souboru příslušné datové bloky. Vysvětlete rozdíl mezi pevnými (hardlink) a symbolickými (symlink) odkazy na soubory. Koukne na i-node, data adresá řů obsahují seznam i-nodes podadresá řů a soubor ů, tam hledá dál. Symlink má jako data cestu, kam míří 4. Jaká jsou přístupová práva k souborům? Co je to propůjčování práv (set UID)? Suid sgid sticky rwxrwxrwx 421 proto octal 6=rw sgid pro soubor bez práva spuštění pro skupinu = kontrola zámk ů při každém spuštění...mandatory lock
sgid pro adresá ř = nové skupiny budou mít stejnou gid jako adresář sticky bit pro adresáře =právo mazat a přejmenovávat soubory mají jen vlastníci soubor ů. 5. Jak procesy přistupují k otevřeným souborům? Jak se liší deskriptor a otevření souboru? Více deskript. může sdílet jedno otevření souboru (mod r/w, pozice) read, write, open, close, dup, dup2, pipe, socket,... open(path, flags,...napr pristup prava) flags pro new: O_WRONLY O_CREAT O_TRUNC mknod vytvoří soubor zařízení mkfifo pojmenovaná roura lseek(fd, offsett, odkud) // lze tím i zvětšit soubor odkud: SEEK_SET SEEK_CUR SEEK_END současná pozice: lseek(fd, 0, SEEK_CUR) změna velikosti: truncate, ftruncate //zmenšení řízení: fcntl(fd, command,...) // řízení soubor ů, zámky, deskriptory,... ioctl(fd, request,...) // univerzální řídící rozhraní pro periferní zařízení (každé zařízení definuje svou skupinu známých příkaz ů) (f)stat(fd/path, struct stat *buf) vrátí info o souboru (i-node, device, uid, gid, velikost, časy, počet odkaz ů,...) access(path, mode) // test přístupových práv dle euid egid chmod(path, mode) // nastavení práv link(path1,path2) // hardlink path2->path1 unlink(path) // slouží i k smazání souboru!!!!!!!!! rename(old, new) symlink(p1, p2) readlink(path, buff, buffsize) // do buff dá max buffsize znak ů z cesty na kterou ukazuje symlink path. Vrátí počet znak ů. Neukončuje '\0' mkdir(path, mode) rmdir(path) DIR *opendir(path) struct dirent *readdir(dir *dirp) // prochází sekvečn ě všechny
spoubory v adresáři int closedir(dir *dirp) struct dirent obsahuje i-node, nazev souboru (f)chdir(path/fd) // nastv nový pracovní adresá ř procesu getcwd(buff, size) // get pra adresář 6. Co je to virtual file system? K čemu slouží a jaký je princip jeho fungování? Umožnuje přístup k souborům nezávislý na konkrétním fs. Každému souboru je příd ělena struktura file. Ta ukazuje na vnode, ta obsahuje část nezávislou na fs a i-node skutečného fs. Každý fs definuje tabulku fcí pro jednotlivé operace, kterou používá vfs k vlasním operacím. U speciálních zařízení file odkazuje na snode (shadow-special-node), který definuje operace se zařízením a odkauje na vlastní vnode zařízení pro spec. operace. Spec zařízení je identifikováno major a minor číslem. Při otevření souboru se bud použije existující snode nebo se vytvoří nové, pokud neex. Struct vfs info o fs, nezávislé na vlastním typu fs rootvfs - / fs vfsop tabulka operací pro daný fs 7. Jaký je vztah diskového oddílu a svazku? Jak probíhá vytvoření, kontrola konzistence, připojení a odpojení svazku? Běžn ě svazek (fs)= diskový oddílu nebo svazek = logica disk volume...i vice disk. oddlíl ů na různých discích stripping = za sebou následující bloky dat se ukládají paraleln ě na dva různé disky...zrychlení mirroring = 2 kpie na dva disky...bezpečnost dat paritní disky = tři disky. Na dva se ukládají data, na třetí XOR RAID zahrnuje tyto akce kontrola konzistence = fsck vícenasobné odkazy na stejný blok odkazy někam pryč z datové oblasti fs špatný počet odkazů nesprávná velikostineplatný formýt i-nodes neplatný obsah superbloku... žurnálove fs nepotřebují
D) Procesy a roury ---------------------------- 1. Popište paměťový prostor procesu v uživatelském režimu a v režimu jádra. USERMODE Text kod programu //uložené v data inicializované prom. // programu(spustitelném souboru) Bss neinicializované prom. Pamět volná stack uživatelský zásobník, prom. funkcí, parametry fcí,... - každý proc má 2 zásobníky, jeden pro běh v USERMODE a druhý v KERNELMODE user_area není adresovatelná z programu. Info o proc používané jádrem, které nejsou potřeba, když je proc.odložen na disk. Jádro vidí vždy jen tu user_area běžícího procesu. Ostatní přístupné přes strukturu proc. KERNELMODE text jádra data a bss jádra struktura user běžícího procesu zásobník jádra samostatný pro každý proc. Je prázdný, jestliže je proc v USERMODE proc se dostane do jádra bud příchodem přerušení (procesor, časovač,...) Přerušení vyvolá i systémové volání. Tak se dostane do jádra. Vlastn ě to vypadá tak, že sys volání nastaví nějaké prom a pak vyvolá přerušení. V paměti je pouze jedna kopie kodu jádra. 2. Nakreslete a popište stavový diagram procesu
3. Popište základy mechanismu plánování proces ů. Jaké jsou prioritní třídy? Preemptivní (základ je pravidelné přerušení od časovače, sebere procesor procesu a předá jej jádru aktivuje plánovač proces ů) procesy řazeny do front podle priority, procesor je přidělen prvnímu procesu z fronty s max prioritou prioritní třídy: system: 60-99, rezervováno pro systémové procesy, pevná priorita realtime: 100-159, pevná priorita, pro každou prioritu defin.čas kvant. Time-shared: 0-59, proměnnádvousložková priorita. Pevná uživatelská a proměnná systémová. Pokud proc hodn ě vytěžuje procesor, je mu snižovaná priorita a zvětšováno časové kvantum pokud je proces s time-shared prioritou uspán a čeká na událost, je mu dočasn ě přid ělena priorita system, po příchodu události se dostane dříve na řadu 4. Popište mechanismus mapování soubor ů do paměti. Popište, jak lze za běhu programu získat přístup k proměnným a funkcím definovaným v nějaké dynamické sdílené knihovn ě. MAPovani mmap(addr, len, prot, flags, fd, offsett) do pam an adresu adr namapuje len Bytu z fd pocinaje offsett a vrati tu adresu, kam namapoval nebo MAP_FAILED. Prot jsou pristupova prava PROT_READ,... flags dalsi prava: MAP_PRIVATE, MAP_SHARED, MAP_FIXED mapuje se po celych strankach, offsett a při MAP_FIXED i addr musi byt správn ě zarovnány munmap(addr, len) // zruš mapování o délce len od addr msync(addr, len, flags) // zapíše změny v úseku len B od addr flags MS_ASYNC, MS_SYNC, MS_INVALIADTE(zruš namapovana data, která se liší od obsahu souboru) mprotect(addr, len, prot) // změní přístupová práva k části namapovaného souboru LIBS dlopen(file, mode) zpřístupní knihovnu v souboru file, vratí handle nebo NULL mode: RTLD_NOW, RTLD_LAZY, RTLD_GLOBAL(symboly budou glob.dosyupné), RTLD_LOCAL(nebudou)
dlsym(handle, name) // vratí adresu symbolu zadaného jména z knihovny dlclose(handle) dlerror() // vrátí textový popis chyby při práci s knihovnami užití: pluginy, konflikty jmen v knihovnách E) Signály ---------- 1. Co jsou to signály? Jak může být pro proces vygenerován signál? Jaký je rozdíl mezi posláním signálu procesu a vláknu? Informují proces o vzniku určité události na uživatelské úrovni zpřístupnují mechanismy přerušení chybové události generované běžícím procesem asynchronní události vznik mimo proces nesou pouze informace o čísle signálu asynchronní zpracování kill(pid, sig) pid>0 proc s pid pid=0 všem procesům ve stej skupině pid=-1 všem mimo systémových pid < -1 procesům ve skupin ě -pid mohou být generovány pro proces (kill) nebo pro vlákno pthread_kill... chybové události nastavení obsluhovaných signál ů je stejné pro všechny vlákna, ale blokování má každé vlákno vlastní pthread_sigmask(how, const sigset_t *set, sigset_t *oset) how: SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK signál určený pro proces zpracuje práv ě jedno vlákno, které jej nemá zablokovaný lze vyhradit jedno vlákno pro synchronní příjem signál ů pomocí sigwait() a ostatním signály zablokovat pokud vlákno je ukončeno signálem(nap ř. SIGINT), končí celý proces. 2. Jaké jsou možnosti ošetření signál ů? Jak se nastavuje ošetření signál ů (handlery, blokování) pro proces a pro vlákna? Implicitní akce, ignorování, ošetření handlerem sigaction(sig, const str sigaction *act, *oact) nastaví obsluhu signálu sig podle act a původní vrátí v oact
struct sigaction *sa_handler = fce typu void f(int) sigset_t sa_mask = signály blokované v handleru, navíc je blokován sig sa_flags = SA_RESETHAND (po příchodu zruš ošetřování), SA_RESTART (restartuj přerušené sys.volání), SA_NODEFER (neblokuj sig během obsluhy) blokování sigprocmask(how, sigset_t *set, *oset) pthread_sigmask(---''---) //viz minulá otázka nastaví masku blokovaných sigs a vrátí původní pro manip s maskou: sigdelset(), sigemptyset(), sigfillset(), sigismember() sigpending(sigset*set) - vrátí čekající signály čekání na sig: pause() //čeká na lib signál, pak pokračuje sigsuspend(sigset_t *sigmask) // jako pause, ale po dobu čekání nahradí masku blokovaných sig maskou sigmask sigwait(sigset_t set, int*sig) // čeká signál z množiny set (tyto sig musí být předtím bloklé), číslo signálu vrátí v sig, nevolá handler F) Vlákna --------- 1. Co je to vlákno, jak se liší od procesu? Které atributy jsou společné pro proces, které jsou privátní pro každé vlákno? Jak je možné vytvořit globální proměnnou privátní pro jedno vlákno? Vlákno je implementováno bud v knihovnách nebo v jádře. Library-thread model, kernel-thread model, hybridní modely soukromé atributy vláken: instruction pointer stack pevná velikost, dynamicky se nezvětšuje! thread ID, dostupné funkcí pthread_self() plánovací priorita a politika errno klíčované hodnoty dvojice (pthread_key klic, void *ptr) klíč vytvořený voláním pthread_key_create() je viditelný ve všech vláknech procesu každé vlákno mu může dát jinou hodnotu pomocí pthread_setspecific()
2. Popište postup při vytvoření a zrušení vlákna. Jak fungují destruktory klíčovaných hodnot a zásobník úklidových handler ů? pthread_create(pthread_t *thread, *attr, *start_fce, *arg) start_fce typu void f(*void) do thread dá ID vlákna attr=null, default, jinak bere parametry (stacksize,...) spustí funkci s param arg s attr se manipuluje pomocí: pthread_attr_*, kde * je: init() destroy() getstackaddr() setstackaddr() pthread_once(pthread_once_t *oncectrl, init_fce) v param oncectrl se předá odkaz na staticky inicializovanou prom = PTHREAD_ONCE_INIT init_fce je typu void f(void) první vlákno provede funkci init_fce, ostatní ji už nedělají a pokud ješt ě neskončila, jsou pozastavena ostatní vlákna nap ř na glob. dynamickou inicializaci dat pthread_exit(void *value ptr) // jako exit procesu pthread_join(thread, **value_ptr) // čeká na ukončení threadu thread a získá jeho návratovou hodnotu pthread_detach(thread) // okamžit ě uvolní pamět po skončení vlákna, nelze s thread_join pthread_cancel(thread) // žádost o zrušení vlákna závisí na nastavení pthread_setcancelstate(int state, *old) PTHREAD_CANCEL_ENABLE/DISABLE pthread_setcanceltype(int type, *old) jestli okamžit ě nabo na určitých místech pthread_testcancel() Klíče pthread_key_create(*key, destruktor) key je tvořený klíč destruktor je fce typu void f(void *) destruktor je volán při rušení vlákna pro každý klič, jehož value není NULL, podle SUSv3 je před vstupem do destruktoru nastavena každá hodnota na null pthread_key_delete(key) // ruší klíč, nemění asociovaná data pthread_setspecific(key, *data) void *pthread_getspecific(key)
úklidové handlery volají se před destruktory organizovány v zásobníku handler ů (LIFO) pthread_cleanup_push(fce, void *arg) fce je tvaru void f(void *) pthread_cleanup_pop(int execute) vyjme naposled vložený a spustí ho, pokud execute!= 0 3. Uveďte nástroje pro synchronizaci vláken. Nevrací chyby při čekání na lock, pokud přijde signal!!! Mutex něco jako semafor pthread_mutex_init(*mutex, *attr) attr NULL default, jinak fce pthread_mutexattr...() pthread_mutex_destroy(*mutex) pthread_mutex_lock(*mutex) // uspává dokud nejde pthread_mutex_trylock(*mutex) // nuspí, vrátí chybu pthread_mutex_unlockl(*mutex) defaultn ě pouze pro jeden proces, při tvoření mutexu se pomocí attr dá nastavit, že k němu mužou i ostatní pomocí shared mem podmínkové proměné pthread_cond_init(*cond, *attr) inicializace pthread_cond_destroy(*cond) pthread_cond_wait(*cond, *mutex) čeká na podmínkové prom dokud jiné vlákno nezavolá pthread_cond_signal(*cond) nebo pthread_cond_broadcast(*cond) automaticky odemkne mutex a až když je probuzeno, tak mutex znovu zamkne a pak se až vrátí pthread_cond_timedwait(*cond, *mutex, *absolut_time) jako minulá, ale skončí v čase abs_time i bez signalizace podmínky když signalizuji, že se něco změnilo, musím to po wait ješt ě znovu otestovat...nap ř mohlo to už změnit jiné vlákno,... MUSIM znovu testovat Read-write zámky pthread_rwlock_init(*lock, *attr) pthread_rwlock_destroy(*lock) thread_rwlock_rdlock(*lock) // uspí thread_rwlock_tryrdlock(*lock) // chyba
totéž pro wrlock pthread_rwlock_unlock(*lock) G) Synchronizace a zamykání --------------------------- 1. Vysvětlete vznik konfliktu při přístupu ke sdíleným datům a jeho řešení pomocí zamykání. Jak může vzniknout deadlock? Popište zamykání soubor ů pomocí fcntl(). Zamykání pro přístup k souboru fcntl(fd, int cmd,...) cmd: F_GETLK vezme popis zámku z třetího arg a nahradí ho popisem existujícího zámku, který s ním koliduje F_SETLK(W) nastvení zámku podle třetího argumentu, při neúspěch ihned skončí W čeká třetí arg je typu struct flock: l_type: F_RDLOCK, F_WRLOCK, F_UNLOCK l_whence: jako u lseek, odkud je start počítán: SEEK_SET, SEEK_CUR, SEEK_END start, len pid procesu, který má zámek...jen u F_GETLK při skončení procesu se automaticky uvalní všechny jeho zámky Dva typy zámk ů: advisory locks procesy musí samy kontrolovat zámky před použitím read-write více používané mandatory locks je-li zamčeno, bude read/write pozdrženo, dokud se neodemkne nap ř na NFS (démon lockd) není podporováno nepoužívat 2. Vysvětlete zamykání pomocí lock soubor ů. Popište postup zamykání pro soubory sdílené pomocí NFS. Vytvoření souboru + test existence je atomická operace open( lockfile, O_RDWR O_CREAT O?EXCL, 0600) čekání ve smyčce (aktivní), problém s tím, když proces umře, vhodné do souboru zapsat PID, pak mohou ověřit, tím vznikne možnost vícenásobného zámku (test PID + smazání nejsou at.op.). Lze řešit samostatným procesem, který to kontroluje a jen maže
NFS problem nevrací korektn ě hned, ale až někdy vytvoříme jiný soubor (unikátní jméno pro každý proces!) a zkusíme na něj hardlinkovat lockfile (ve smyčce, dokud se nepovede) link(filename, lockfile) pak testneme statem, protože ani to nemusí vrátit korektní návratovou hodnotu stat(filename, &buff) A pokud je počet hardlink ů 2, pak máme přístup if(buf.st_nlink == 2) skonči smyčku a ješte zrušíme link unlink(filename) H) IPC ------ 1. Popište semafory, implementované v UNIX System V IPC. int semget(key, count, flags) vrati ident pole semafor ů ke klíči key key: cokoli nebo IPC_PRIVATE flags: IPC_CREAT, IPC_EXCL vraci id semctl(id, semnum, cmd,...) řídící fce, čtvrtý volit param je arg je typu union semun semnum je číslo semaforu v poli cmd: GETVAL, SETVAL, GETPID, GETNCNT(počet procesů čekajících na vyšší hodnotu), GETZCNT(čekajících na nulu), IPC_RMID zruší pole semafor ů!!! inicializace semaforu: semctl(id,num, SETVAL, arg) kde v arg je init_value semop(id, struct sembuf *sops, nsops) atomická operace sops pole operací o velikosti nsops sops: sem_num na jaký semafor v poli sem_op jaká změna -1 vstup do krit sekce (obecn ě -N) 1 vystup (N) 0 čekej na 0 sem_flg: IPC_NOWAIT, SEM_UNDO (při skončení procesu odemkni)
2. Popište sdílenou pam ěť, implementovanou v UNIX System V IPC. Fce začínají shm.. get(key, size, flags) shmat(id, *addr, flags) připojí na adresu addr (neboněkam, pokud NULL), vrací adresu flags: SHM_READONLY, SHM_RND(zaokrouhli adresu připojení) shmdt(*addr) odpoj shmctl(id, cmd, struct shmid_ds *buf) cmd: IPC_SET nastavení přístup. Práv IPC_STAT v buf vrátí informace IPS_RMID zrušení sdílené paměti odpojení neruší!!! 3. Popište fronty zpráv, implementované v UNIX System V IPC. Fce začínají msg... get(key, flags) flags: IPC_CREAT, IPC_EXCL spolu s přístup právy ctl(id, cmd, buf) jako vždy :)) msgsnd(id, *msgp, size, flags) pošle zprávu msgp o velikosti size do fronty id msgp lib typu, ale na začátku musí být kladný long identifikator typu. Size je uváděna bez tohoto identif typu!!! flags: IPCNOWAIT pokud je plna fronta, skonci s chybou msgrcv(id, *msgp, size, typ, flags) vrací velikost zprávy typ se nepočítá do velikosti vybere se z fronty první zpráva dle typu. == 0 libovolná > 0 přesn ě typu typ < 0 typ zprávy <= -typ I) Sítě ------- 1. Popište činnost serveru a klienta (posloupnost systémových volání) pro spojované síťové služby. Server: socket(domain(af_inet), type(sock_stream), protocol) bind(socket, address, sizeaddr)
listen(socket, int kolik muze cekat) accept(socket, address, addrlen) client: socket connect(socket, address, addrlen) send, recv, read, write,... - ješte jsou poll a select (testuje filedescriptory) 2. Popište činnost serveru a klienta (posloupnost systémových volání) pro nespojované síťové služby. Jako tcp, ale nema connect (jen pro omezeni adresy protistrany) a používá sendto a recvfrom sendto(socket, *msg, size, flags, addr, addrlen) recvfrom(--- ---) close zavře socket. Nemusí být okamžit ě, jaádro se ješt ě napozadí snaží přenést zbylá data... shutdown(socket, int how) zavře socket, neruší deskriptor how: SHUT_RD zavře pro čtení SHUT_WR pro zápis SHUT_RDWR pro oboje...jaký to má smysl??? 3. Co je to soket? Jaké jsou varianty adresace soket ů (v rámci jednoho stroje a po síti)? Jaké funkce (uveďte aspo ň některé) slouží pro převod mezi číselnými a symbolickými jmény protokol ů, port ů a IP adres? Proč se používají funkce pro konverzi mezi lokálním a síťovým pořadím bajt ů? Obousměrná pipe sockety z AF_UNIX jejich názvy jsou názvy speciálních soubor ů, které je reprezentují v sys soubor ů. Tedy lokal sockety jsou take soubory p evody: ř struct protoent* getprotobyname(name) struct servent* getservbyname(name, proto_name) struct hostent* gethostbyname(name) struct hostent* gethostbyaddr(addr, len, type)
4. Popište varianty sekvenční a paralelní obsluhy klient ů TCP serveru. 5. Jak lze čekat na příchod dat z několika deskriptor ů souborů zárove ň? Jak byste tuto funkci použili při implementaci síťového serveru, který obsluhuje několik klient ů zárove ň jedním procesem bez použití vláken? Select, poll J) Administrace --------------- 1. Jak probíhá start operačního systému UNIX? Co jsou to úrovně běhu systému? Jak se spouští startovací skripty? Načte a zavede se kernel mount / nový proces init a ten dělá zbytek v uživatelském režimu init spouští dle inittab id:úrovn ě:akce:proces akce je nap ř. Wait (počkej na dokončení), respawn,... 3. Jak probíhá přihlášení uživatele do systému? Init - fork + exec getty (načte login) exec login (suid user) exec shell 4. Jak se používá démon cron? Pravidelné spouštění akcí vypis crontab -1 zadani ze souboru crontab < file formát crontab: minuta hodina den měsíc den_v_týdnu (asi ješt ě suid?) command 5. Jak funguje síťový server inetd? Čeká na portech definovaných v inetd.conf a spouští servery formát inetd.conf: služba(dle services) socket(dgram, stream) proto čekání uid command + args
čekání: u stream wait: server si sám volá accept, jen jeden klient nowait: inetd volá accept a předá descriptor, server vlastn ě ani neví, že jede po síti 6. Jaké úkoly má správce Unixu?