Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- Generalni pregled UNIX sistema
- Pojavio se 1969
- Od svoje pojave , UNIX je postao krajnje popularan
- funkcioniše na velikom broju računara - CPU
- sa različitom procesorskom snagom
- od mikroprocesora
- do mainframe mašina
- OS2 će obuhvatiti pregled UNIX System V + (Linux)
- 1965 Bell + General Electric Company + Project MAC
- razvijali su novi operativni system MULTICS
- (Multiplexed Information and Computing Service)
- sa ciljem da to bude moćan OS za veliki broj korisnika.
- Iz tog projekta nastao je OS UNIX, 1969,
- Ken Thomson, Dennis Ritchie
- najpre za processor PDP-7,
- a potom za PDP-11 1971,
- sa skromnim hardverskim mogućnostima.
- (16K za UNIX, 8K za korisničke programe, disk veličine 512K, file limit 64K)
- Dennis Ritchie
- je napisao novi PL koga je nazvao C,
- koji realizuje mašinski kod, deklaraciju tipova podataka i definiciju struktura podataka.
- 1973. godine, prepisali su UNIX na C.
- Kasnije se UNIX razvijao:
- UNIX System III
- UNIX System V
- BSD UNIX (paralelna generacija UNIX-a)
- Ovde će se uglavnom obrađivati UNIX System V
- DEC PDP-11 - A 16-bit successor to the PDP-8 also utilizing byte addressable memory. The PDP series was an extremely popular computer due to low cost and good performance. Its 16-bit address space caused it to decline in popularity as large memories became cheaply available with the introduction of VSLI technology. This picture is of Dennis Ritchie and Kenneth Thompson, creators of the UNIX operating system, at a PDP-11. (1970)
- WASHINGTON, D.C. (April 27, 1999) -- Dennis Ritchie and Ken Thompson of Bell Labs received the U.S. National Medal of Technology today from President Bill Clinton at ceremonies televised at the White House.
- MULTICS
- Multiplexed Information and Computing Service
- UNICS
- Uniplexed Information and Computing Service
- UNIX
- Radi lakšeg izgovora i pisanja
- ime UNICS je kasnije evoluiralo u UNIX
- Prvi UNIX razvijen 1969
- glavni kreatori: Ken Thompson & Dennis Ritchie
- Research Group iz Bell Laboratories
- sa ugrađenim funkcijama drugih OS
- posebno MULTICS OS
- III UNIX verzija napisana u C jeziku
- koji je takođe razvijen u Bell Labs
- sa posebnom podrškom za UNIX
- Najuticajniji UNIX
- koji ne pripada Bell LAbs (non-Bell Labs) and
- koji ne spada u familiju AT&T UNIX (non-AT&T UNIX development groups)
- je BSD UNIX, University of California at Berkeley (Berkeley Software Distributions)
- 4BSD UNIX je nastao iz DARPA zahteva
- da se razvije standard UNIX OS
- koji će se koristiti za SAD vladu (USA for government)
- Razvijen za VAX CPU
- 4.3BSD je jedna od najuticajnijih verzija
- portiran je na mnoge druge platforme.
- Prvu verziju UNIX-a je 1969. godine
- razvio Ken Thompson iz istraživačke grupe Bellovih laboratorija,
- da bi se koristio na računaru PDP-7
- (računar koji nije imao neku naročitu primenu u to vreme).
- Ubrzo, njemu se pridružio Dennis Ritchie.
- Thompson, Ritchie i drugi članovi istraživačke grupe su napravili prvu verziju UNIX-a.
- Ritchie je predhodno radio na MULTICS projektu, I MULTICS je imao veliki uticaj na novonastali operativni sistem. Čak je i ime UNIX igrom reči nastao od MULTICS.
- Osnovna organizacija fajl sistema
- ideja da komandni interpretator bude korisnički proces
- korišćenje zasebnog procesa sa svaku komandu
- originalni način editovanja karaktera
- (# da se izbriše poslednji karakter a @ za brisanje celog reda)
- brojne druge osobine dolaze dirketno od MULTICS-a
- Takođe su korišćene ideje iz nekih drugih operativnih sistema, kao npr. MIT-ov CTSS i XDS-940.
- Ritchie i Thompson su radili na UNIX-u bez publiciteta godinama. Njihov rad na prvoj verziji im je omogućio da ga prebace na PDP-11/20 u drugoj verziji.
- U trećoj verziji, ponovo su pisali većinu koda, ali sad na programskom jeziku C, a ne kao pre u asembleru. C je razvijen u Bellovim laboratorijama zbog UNIX-a. UNIX je prebačen na veće PDP-11 modele, kao što su 11/45 i 11/70. Multiprogramiranje i ostale prednosti su dodate kad je sistem ponovo napisan u C-u, i prebačen na sisteme (kao npr. 11/45) koji su imali hardversku podršku za multiprogramiranje.
- Kako se UNIX razvijao, postao je široko upotrebljivan u Bellovim laboratorijama i postepeno se preneo na nekoliko univerziteta. Prva verzija koja je bila puštena van Bellovih laboratorija je verzija 6, izbačena 1976. (Broj Verzije za prve UNIX sisteme odgovara broju UNIX-ovog programerskog uputstva – UNIX Programmer’s Manual, koji je bio aktuelan u trenutku distribucije izdanja; kod i uputstva su razvijani nezavisno).
- U 1978 je izbačena verzija 7, koja je radila na PDP-11/70 i na Interdati 8/32, i to je predak većine modernih UNIX sistema. Tačnije, verzija 7 je uskoro puštena na ostale PDP-11 modele i na VAX kompjutere. Verzija za VAX je nosila oznaku 32V. Posle toga je nastavljen rad na UNIX projektu.
- Posle distribucije verzije 7 u 1978. godini, UNIX Support Group (USG) je preuzela kontrolu i odgovornost za UNIX. UNIX sad postaje proizvod, a ne samo alat za istraživanje. Ipak, istraživačka grupa nastavlja da pravi svoje verzije UNIX-a, za svoje unutrašnje potrebe.
- Nastaje verzija 8, koja ima nešto što se zove stream I/O system, koji omogućuje fleksibilnu konfiguraciju kernelovih IPC modula. Ova verzija sadrži i RFS (remote file system), sličan Sun-ovom NFS-u. Posle toga dolaze verzija 9 i 10 (poslednja verzija postoji samo u Bellovim laboratorijama).
- USG je uglavnom pružao podršku za UNIX unutar AT&T.
- Prva spoljna distribucija USG grupe je UNIX Sistem III, 1982 godine. Sistemu III su pridružene mogućnosti iz verzija 7 i 32V, i još nekih verzija UNIX-a koji su se nezavisno razvijali. U Sistem III su uključene mogućnosti UNIX/RT, real-time UNIX sistema, kao i velikog dela PWB softverskih paketa (Programmer’s Work Bench).
- 1983, USG izbacuje Sistem V, koji je uglavnom nastao iz UNIX Sistem III. Izlazak raznih Bellovih kompanija iz AT&T-a, su naterali da AT&T agresivno marketinški gura Sistem V. Od USG-a nastaje USDL, UNIX System Development Laboratory, koji izbacuje verziju Sistema V, drugo izdanje (V.2), u 1984. A verzija Sistema V, V.2.4 dodaje novu implementaciju virtualne memorije sa copy-on-write paging i deljenom memorijom. UDSL postaje ATTIS (AT&T Information Systems), koji izbacuje V.3 verziju Sistema V, u 1987. V.3 prilagođava implementaciju iz verzije 8, ondosno stream I/O system, koji je sad dostupan kao STREAMS. On takođe sadrži RFS – remote file system.
- Mala veličina, modularnost, i čist dizajn ranih UNIX sistema dovodi do UNIX baziranog rada na mnogim drugim naučno-kompjuterskim organizacijama, kao što su Rand, BBN, Univerzitet Illinoisa, Harvard, Purdue i DEC. Najveći uticaj među njima je imao Kalifornijski Univerzitet u Berkliju.
- Prvi Berkley VAX UNIX nastaje 1978. kao skup sledećih mogućnosti:
- virtualne memorije
- straničenja po zahtevu
- zamenu stranica kao kod 32V
- ovo su odradili Bill Joy i Ozalp Babaoglu, da bi nastao 3BSD UNIX.
- 3BSD je bila prva verzija UNIX-a koji je imao neku od ovih mogućnosti. Veliki prostor virtualne memorije, omogućuje razvoj veoma velikih programa, kao što je Berkley Franz LISP.
- BSD upravljanje memorijom je ubedilo DARPA agenciju (Defense Advanced Research Projecr Agency), da finansira Berkley za razvoj UNIX sistema za vladine institucije; 4BSD UNIX je rezultat toga.
- U razvoju 4BSD sistema uticali su brojni poznati ljudi iz poznavanja UNIX-a i mreža. Jedan od ciljeva ovog rada je bio da se napravi podrška za DARPA Internet protokol (TCP/IP). Ova podrška je urađena generalno.
- Omogućeno je da 4.2BSD komunicira između različitih tipova mreža, uključujući
- LAN mreže (kao Ethernet i token ring) i
- WAN mreže (kao NSFNET).
- Ta implementacija je glavni razlog za današnju popularnost ovih protokola.
- Korišćen je kao osnova
- za neke druge implementacije drugih izdanja UNIX-a,
- čak i za druge operativne sisteme.
- Omogućio je da Internet poraste sa 60 povezanih mreža 1984. na više od 8000 mreža, a po proceni 10 miliona korisnika u 1993.
- UNIX softver kreiran na Berkley-u dobija ime BSD UNIX (Berkley Software Distributions.
- Obično se kaže da Berklijev VAX UNIX prate 3BSD i 4BSD, iako su zapravo postojala nekoliko specificnih izdanja, a glavna među njima su 4.1BSD i 4.2BSD.
- Oznake 2.x BSD sistema se koriste za PDP-11
- oznake 4.xBSD za VAX distribucije Berklijevog UNIX-a
- 4.2BSD, izbačen 1983. godine, je bio kulminacija originalnog Berklijevog DARPA UNIX projekta. 2.9BSD je ekvivalentan verziji za PDP-11 sisteme.
- 4.3 BSD
- U 1986. godini izašao je 4.3BSD. On je bio toliko sličan 4.2BSD-u, tako da je njegovo uputstvo jasnije objašnjavalo 4.2BSD, nego uputstva od 4.2BSD-a.
- Na njemu nisu radili na nekim brojim unutrašnjim promenama,
- već na ispravljanju bagova, i na unapređenju performansi.
- Dodate su neke nove mogućnost, uključujući podršku za Xerox Network System protokole.
- Sledeća verzija nosila je naziv 4.3BSD Tahoe, a puštena je 1988. Obuhvatala je brojne nove mogućnosti, kao:
- poboljšanu kontrolu mrežnog zagušenja
- i
- TCP/IP performansi
- Takođe konfiguracije diskova su odvojene od drajvera uređaja, tako da se sada čitaju direktno sa diskova.
- Dodata je i podrška za vremenske zone
- 4.3BSD Tahoe je ustvari razvijen za CCI Tahoe System (Computer Console, Inc., Power 5 computer) a ne za uobičajenu VAX bazu.
- Paralelno izdanje za PDP-11 je 2.10.1BSD, koje distribuira USENIX Asocijacija, koja je i izdala uputstva za 4.3BSD.
- U verziji 4.32BSD Renoe je dodata implementacija ISO/OSI mrežnog modela
- Poslednje Berklijevo izdanje 4.4BSD je završeno Juna 1993. Ukljčuje podršku
- za novi X.25 mrežni protokol
- za POSIX standard
- Takođe ima radikalno promenjenu organizaciju fajl sistema,
- sa novim interfesjom prema virtuelnoj memoriji i
- podršku za stack-bazirani fajl sistem,
- koji omogućuje fajl sistemu da bude u slojevima za lako ubacivanje novih mogućnosti.
- Dodata je i implementacija NFS, kao i novi fajl sistem sa dnevnikom.
- Još nekoliko promena je dodato
- kao poboljšana sigurnost
- poboljšana struktura kernela
- Sa ovim izdanjem Berkli obustavlja rad na ovom projektu.
- 4BSD operativni sistem je bio izbor za VAX CPU od njegovog prvog izdanja (1979) do pojave Ultrix-a, DEC-ove BSD implementacije.
- 4BSD je i dalje najbolji izbor za mnoge istraživačke i mrežne oraganizacije.
- Mnogo organizacije su kupile 32V licencu i naručile 4BSD od Berklija.
- Trenutni skup verzija UNIX operativnih sistema nije ograničen samo na one iz Bellovih laboratorija (čiji je vlasnik Lucent Technology) i iz Berklija.
- Sun Microsystems je pomogao u popularizaciji BSD verzije UNIX-a, tako što je isporučivao svoje radne stanice za njim.
- UNIX je rastao u populaciji, i bio je instaliran na mnogo različitih računara i računarskih sistema.
- Kreirana je široka lepeza UNIX i UNIX bazirnih operatinih sistema.
- DEC ima svoj UNIX (zvan Ultrix) na radnim stanicama, i njegovog nastavljača OSF/1, koji je takođe nastao od UNIX-a.
- Microsoft je preradio UNIX za Intel 8080 familiju i nazvao ga XENIX, a i Windows NT operativni sistem je nastao pod jakim uticajem UNIX-a.
- IBM koristi UNIX (AIX) na svojim PC-jevima i na serverima.
- Praktično, UNIX je dostupan na gotovo svim vrstama računara za opštu upotrebu, ima ga na personalnim računarima, radnim stanicama, miniračunarima, serverima i superračunarima, od Applovog Mekitoša do Cray-a.
- Zbog široke raspoložinosti, on se koristi na raznim mestima, počev od akademskih i vojnih organizacija, do fabrika. Većina ovih sistema je bazirano na Verziji 7, Sistemu III, 4.2BSD-u, ili Sistemu V.
- MAC OS X
- Široka popularnost UNIX-a je dovela do toga da UNIX bude najrašireniji operativni sistem, i da korisnici očekuju da UNIX okruženje bude nezavisno u odnosu na specifičnost hardvera.
- Ali veliki broj njegovih implementacija doveo je do toga da postoje razne varijacije u programiranju i korisničkom interfejsu, koji je distribuiran od izdavača.
- Za pravu nezavisnost, oni koji razvijaju programe treba da imaju konzistentan interfejs.
- Takav interfejs bi omogućio da sve “UNIX” aplikacije rade na svim UNIX sistemima, što svakako nije trenutna situacija.
- Ovo je postalo veoma važno kako je UNIX postao omiljena platforma za razvoj programa pocevši od baza preko grafičkih programa, pa sve do mrežnih aplikacija, i zato je tržište zahtevalo da se postavi standard za UNIX.
- Postoje nekoliko projekata standardizacije u toku,
- počevši od /usr/group 1984 Standard koga finansira UniForum industry users’ group.
- Od tada, mnoga tela za standardizaciju se bave tim problemom, uključujući IEEE i ISO (POSIX standard).
- Grupa pod imenom X/Open Group internacionalni konzorcijum je napravila XPG3, koji je tipično okruženja za aplikacije (Common Application Enviroment), koji podvodi pod širu kategoriju IEEE standarde interfejsa.
- Nažalost, XPG3 je baziran na skici ANSI C standarda, a ne na konačnoj specifikaciji i zato je morao da se preradi. XPG4 je završen 1993.
- U 1989., telo za ANSI standardizaciju, pravi ANSI C standard, kome se proizvođači lako prilagođavaju. Dok se rad na ovim projektima nastavlja, razna izdanja UNIX-a nastaju a postoji samo jedan programerski interfejs za UNIX i zato UNIX postaje sve popularniji.
- Praktično postoje dva različita seta moćnih UNIX proizvođača koji rade na ovom problemu. AT&T-guided UNIX International (UI) i Open Software Foundation (OSF), koji su se oboje složili da prate POSIX standard.
- Nedavno, mnogi proizvođači iz ove dve grupe su se složili oko dalje standardizacije (COSE sporazum) na Motif okruženju prozora, i ONC+ (koji uključuje Sun RPC i NFS), kao i DCE mrežne kapacitete (koji uključuju AFS i RPC paket).
- ATA&T 1989,
- zamenio ATTIS grupu sa USO (UNIX Software Organization),
- koja isporučuje prvi spojeni-merged UNIX
- UNIX System V, Release 4.
- Ovaj sistem kombinuje funkcionalnost
- UNIX Sistema V
- 4.3BSD
- Sun-ovog SunOS,
- uključuje duga imena za datoteke, Berkeley fajl sistem,
- menadžment sa virtualnom memorijom,
- simboličke linkove,
- višekorisniče grupe,
- kontrolu poslova, i sigurne signale;
- takođe poštuje POSIX standard, POSIX.1.
- Nakon toga USO pravi SVR4 i postaje nezavisan od ATA&T,
- pod imenom Unix System Laboratories (USL);
- 1993, USL kupuje Novell, Inc
- UNIX sistem je porastao od ličnog projekta dvojce saradnika Bell laboratorija do operativnog sistema koji je definisan međunarodnim standardizacionim telima.
- Ipak, ovaj sistem je i dalje interesantan akademskim institucijama. Verujemo da je UNIX postao i da će ostati važan deo teorije i prakse o operativnim sistemima.
- UNIX je odličan OS za akademske studije. Na primer:
- Tunis operativni sistem
- Xinu operativni sistem
- Minix operativni sistem
- su bazirani na konceptima UNIX-a, ali su razvijai eksplicitno za učionice.
- Preobilje je aktuelnih istraživačkih OS baziranih na UNIX-OSu, uključujući Mach, Chorus, Comandos i Roisin.
- Originalni tvorci, Riči i Tompson, su nagrađeni 1983. od Asociation for Computing Machinery, nagradom Turing, za njihov rad na UNIX-u.
- Verzija UNIX-a korišćena u ovom poglavlju je Intelova verzija Free BSD-a. Sistem je koršćen zato što implementira razne interesantne koncepte operativnih sistema, kao što je zahtev za straničenjem sa klasterovanjem, i umrežavanje.
- FreeBSD projekat je počeo 1993.
- kako bi napravio snimak 386BSD-a i
- rešio problem koje je bilo nemoguće rešiti koristeći postojeći patch mehanizam.
- 386BSD je nastao od 4.3BSD-Lite (Net/2) i originalno je izbačen u junu 1992 od strane Williama Jolitza.
- FreeBSD (David Greenman) 1.0 je izbačen decembra 1993.
- FreeBSD 1.1 je pušten maja 1994. i obe verzije su bile bazirane na 4.3BSD-Lite.
- Zbog nekih ugovora između UCB-a i Novella, bilo je potrebno je da se kod iz 4.3BSD više ne koristi, tako da je konačan 4.3BSD-Lite izbačen jula 1994. (FreeBSD 1.1.5.1).
- FreeBSD je ponovo napravljen,
- bazirano na kodu 4.4BSD-Lite-a,
- koja je nepotpuna, i izdat je novembra 1994,
- pod oznakom FreeBSD 2.0.
- Kasnija izdanja su
- 2.0.2 u junu 1995,
- 2.1.5 i avgustu 1996,
- 2.1.7 u februaru 1997,
- 2.2.1 u aprilu 1997,
- 2.2.8 u novembru 1998,
- 3.0 u oktobru 1998, 3.1 u februaru 1999,
- 3.2 u maju 1999,
- 3.3 u septembru 1999,
- 3.4 u decembru 1999,
- 3.5 u junu 2000,
- 4.0 u martu 2000,
- 4.1 u julu 2000 i
- 4.2 u novembru 2000.
- Cilj celog FreeBSD projekta je da omogući softverski alat koji bi mogao da se koristi za svaku svrhu bez bilo kakvih obaveza.
- Ideja je da se kod maksimalno koristi i da pruži najviše koristi.
- Osnova je ista kao ona opisana u McKusick et al. [1984],
- sa dodatkom povezane virtualne memorije i
- fajlsistemskog baferovanog keša,
- kernelskih upita, i
- softverskih update-a za fajlsistem.
- Trenutno, FreeBSD radi prvenstveno na Intelovim platformama, iako su Alpha platfome podržane.
- U toku je rad na tome da se podrže i druge procesorske platforme.
- sistem je napisan na high level PL, sto mu omogućava
- da bude lakši za čitanje
- razumevanje
- modifikaciju
- prenos na druge računarske konfiguracije.
- Ritchie je procenio da je na prvom UNIX-u C napravio
- povećanje koda i usporenje
- od 20 do 40%
- u odnosu na assembler realizaciju,
- ali su prednosti višeg PL kasnije došle do izražaja
- UNIX poseduje jednostavni korisnički interfejs
- koji userima omogućava sve što žele
- UNIX obezbeđuje primitive
- koje omogućavaju kompleksnijim programima
- da se realiziju iz jednostavnijih programa
- UNIX koristi hijerarhijski FS koji omogućava
- lako održavanje
- efikasno korišćenje i realizaciju
- UNIX koristi konzistentan format za datoteke i nizove bajtova,
- što omogućava lakše pisanje programa
- UNIX obezbeđuje jednostavan konzistetan intefejs za periferijske uređaje
- UNIX je multi-user, multi-task OS:
- svaki user može izvršavati više programa istovremeno
- UNIX apstrakuje mašinsku arhitekturu od korisnika
- što omogućava lakšu realizaciju programa
- na različitim hardverskim arhitekturama
- Mada su OS i većina komandi realizovana na C PL-u,
- UNIX podržava masu drugih jezika kao što su
- Fortran, basic, Pascal, Ada, Cobol, Lisp, Prolog...
- Napisan u visokom programskom jeziku (high-level language).
- Distribucija izvornog koda (Distributed in source form).
- Obezbeđuje
- moćan skup OS baziranih primitiva
- na jeftinim hardverskim platformama
- Poseduje
- malu veličinu
- modularan i jasan dizajn
- Unix je bio napravljen
- od programera
- za programere
- Projektovan da bude time-sharing system.
- Poseduje
- standardni user interface (shell)
- koji se lako može zameniti
- FS (File system)
- sa multilevel tree-structured direktorijumima.
- Kernel
- podržava datoteke
- kao nestruktuiranu sekvecu bajtova
- UNIX je multitask OS
- procesi mogu jednostavno da kreiraju nove procese
- Mehanizam se naziva fork
- Kao i većina OS, UNIX se sastoji od 2 odvojena dela :
- 1. Kernel:
- kernel je sve
- ispod SC (system-call) interface
- i
- iznad fizičkog hardvera
- Kernel obezbeđuje:
- file system upravljanje (management)
- upravljanje raspoređivanje procesa process management and CPU scheduling
- upravljanje memorijom memory management
- druge OS funkcije preko SC (system calls)
- 2. Sistemski programi:
- koriste kernel-supported SC (system calls)
- obezeđuju korisne funkcije, kao što su
- prevođenje (compilation)
- file manipulacija
- 1. Hardver
- 2. Kernel i SC interfejs
- 3. System programs
- cc:
- sastoji se od:
- C preprocessor,
- two-pass compiler,
- assembler and
- loader (link-editor)
- 4. Other application programs
- 1. SC interface: definiše programerski interface za UNIX OS
- 2. user interface :
- set sistemskih programa
- koji su raspoloživi korisnicima
- definiše korisnički-user interface.
- programerski i user interface
- definišu kontext koji
- kernel mora podržavati
- Postoje 3 kategorije sistem calls na UNIX OS:
- 1. Rad sa datotekama (File manipulation)
- 2. Kotrola procesa (Process control)
- 3. Informacije (Information manipulation)
- UNIX FS se karakteriše sa sledećim osobinama:
- hijerarhijska struktura
- konzistetno tretiranje podataka
- mogućnost kreiranja i brisanja datoteka
- mogućnost dinaničkog rasta datoteka
- zaštita datoteka preko prava pristupa
- tretiranje periferijskih uređaja kao datoteka
- FS je organizovan kao stablo
- sa jednim korenskim direktorijumom
- koji se zove root i obeležava kao /
- Sve ostalo u stablu su direktorijumi, regularne i specijalne datoteke
- ime datoteke uključuje i putanju koja joj određuju mesto u stablu
- Direktorijumi su specijalni nizovi bajtova podataka koji sadrže opis datoteka
- Uređaji se tretiraju kao datoteke,
- istim komandama se radi sa uređajem kao sa datotekom (cp, mv, ls, cat)
- na isti način imaju zaštitu i kontrolu pristupa (rwx) kao datoteke
- datoteka je sekvenca bajtova
- UNIX kernel ne nameće strukturu za datoteke.
- Datoteke se organizuju u direktorijume koji imaju strukturu stabla (tree-structured directories)
- Direktorijumi su datoteke
- koje sadrže informacije
- kako da se pronađu druge daoteke
- Putanja (Path name): identifikuje datoteku
- specificiranjem putanje kroz direktorijumsku strukturu do datoteke
- a) apsolutna putanja počinje od korenskog direktorijuma
- b) relativna putanja startuje u tekućem direktorijumu
- SC pozivi za osnovnu manipulaciju sa datotekama :
- create
- open
- read
- write
- close
- unlink
- truncate.
- Proces je jedna istanca programa u izvršavanju.
- Pod UNIX OS, proces je celina kreirana fork sistemskim pozivom.
- 4 SC su karateristična za kreiranje procesa pod UNIX-om
- 1. fork: kreira novi proces
- kopira adresni prostor od roditelja za proces dete
- i svakome dodeli pid {0 za dete, !=0 za roditelja).
- 2. exec: izvršava novi proces
- SC pomoću kojeg dete proces puni (overlay) odgovarajući program
- u svoj adresni prostor.
- Kada se dogodi execl, roditelj i dete nisu više isto.
- Dete se više ne vraća na početni kod jer ga je prepisalo sa execl SC
- 3. exit: proces završava aktivnosti
- dete mora imati sistemski poziv exit
- koji znači da je obavilo svoje
- i da se ukida, osobađajući resurse
- 4. wait: roditelj čeka na dete
- SC koji omogućava procesu roditelju da se blokira i
- čeka da dete obavi svoje
- main (argc, argv)
- int argc;
- char *argv[];
- {
- /* assume 2 args; source file and target file*/
- if ( fork() == 0) execl("cp", "cp", argv[1],argv[2], 0)
- wait ((int *) 0 );
- printf("copy done\n")
- }
- UNIX shell dozvoljava 3 tipa komandi:
- execulable binarne datoteke koje sadrže object code nastao kompilacijom source koda
- shell script datoteke koje nastaju kao programske konstrukcije sastavljene od shell komandnih linija
- interne komande shell-a koje omogućavaju shell programske konstrukcija tipa if, while ... for, ali i neke komande tipa cd...
- Shell radi na principu fork-a za foreground procese
- čekajući ih da se završe
- to je sinhroni rad
- Shell može raditi i asinhrono
- da napravi procese
- ali da ih postavi u background
- ne čekajući da se završe.
- To je asinhroni rad shell-a a postiže se sledećom sintaksom:
- command &
- Svaki proces ima svoju radnu okolinu, a jedan od jako bitnih parametara je radni direktorijum
- Shell nije deo kernela može se lako modifikovati i promeniti.
- Tipicani search path:
- .
- /home/prof/avi/bin
- /usr/local/bin
- /usr/ucb
- /bin
- /usr/bin
- shell
- obicno suspenduje svoje aktivnosti (its own execution)
- dok se komanda ne kompletira
- Foreground process
- Background process [&]
- UNIX obezbeđuje blok primitive koje omogućavaju korisnicima
- da pišu male, modularne programe
- koji se koriste za za realizaciju kompleksnijih programa.
- Jedna tipična blok primitiva je redirekcija ulaza i izlaza. Svaki proces ima konvencionalno 3 datoteke ili 3 file descriptora:
- standard input
- standard output
- error output
- Tipični primeri su:
- ls >output
- mail mjb <letternroff -mm <doc1 >doc1.out 2>errors
- Druga blok primitiva je pipe, mehanizam
- koji obezbeđuje da se niz podataka prosledi
- između procesa čitaoca i procesa pisca.
- Proces pisac redirektuje svoj standardni izlaz na pipe,
- dok proces čitaoc redirektuje svoj standardni ulaz na pipe.
- Tipičan primer je:
- grep main a.c b.c c.c | wc -l
- Vecina procesa ocekuje
- da 3 fd (file descriptors)
- budu otvoreni, kada se startuju:
- standard input – fd=0
- program can read what the user types
- standard output – fd=1
- program can send output to user’s screen
- standard error – fd=2
- error output
- Vecina procesa
- moze takodje da prihvati datoteku (rather than a terminal)
- za standard input i standard output.
- Shells imaju jednostavnu sintaksu za
- I/O redirection.
- Command Meaning of command
- % ls > filea direct output of ls to file filea
- % pr < filea > fileb input from filea and output to fileb
- % lpr < fileb input from fileb
- %% make program > & errs save both standard output and
- standard error in a file
- Mogu se udruziti individualne comande
- preko vertical bar
- koji kaze shell-u
- da prosledi output prethodne komande
- kao input za sledecu komandu $ ls | pr | lpr
- Filter:
- komadne kao pr
- prosledjuju svoj standard input na svoj standard output,
- obavljajuci neko procesiranje na njemu.
- Pisanje novog shell-a sa razlicitom sintaksom i semantikom
- mogu promeniti korisniki pristup (user view),
- ali ne menjaju kernel i programmer interface.
- Shell programming
- Shell variables
- Program structure: if-then-else, for, while, until, case….
- X Window System is a widely accepted iconic interface for UNIX
- Ovde je reč o servisima kernela:
- 1. upravljanje procesima koje omogućava njihovu
- kreaciju
- terminaciju
- suspenziju
- komunikaciju
- 2. raspoređivanje procesa (CPU scheduling)
- 3. alokaciju memorije procesima i swapping
- 4. alokaciju sekundarne memorije (FS services)
- 5. dozvoljavanje procesima da kontrolišu periferale (I/O system)
- Izvršavanje UNIX procesa se deli na 2 nivoa:
- kernelski (kernel mode)
- korisnički (user mode)
- Kada proces izvršava SC
- izvršni mod procesa se menja sa user mode u kernel mode
- a OS pokušava da zadovolji korisnički zahtev
- i vraća status da li je uspeo ili se dogodila greška
- No bez obzira da li će user proces da obavi SC ili ne,
- OS obavlja masu aktivnosti kao što su
- interrupt handling, CPU scheduling, ...
- Neke procesorske arhitekture dozvoljavaju više nivoa, ali UNIX se zadovoljava sa 2:
- korisnicki nivo: procesi u korisničkom modu
- mogu pristupati samo svojim instrukcijama i podacima
- ali ne i kernelskim instrukcijama i podacima.
- kernelski nivo: procesi u kernelskom modu
- mnoge instrukcije su privilegovane i
- mogu se izvršavati samo u kernelskom modu
- Hadverski prekid je mehanizam kojim se
- označava neki događaj (I/O completion)
- omogućava I/O uređajima
- da prekinu CPU asinhrono.
- Po prijemu prekida
- izvrši se poslednja instrukcija koja se obavljala u trenutku prekida
- a kernel će sačuvati stanje prekinutog procesa
- odrediti uzrok prekida
- pozvati prekidnu rutinu
- Nakon toga kernel obavlja po pravilu novi CPU scheduling
- Za vreme obrade prekida, mogući su novi prekidi,
- ali se to obavlja prioritetno
- niži prekidi ne prekidaju
- više prekide.
- Izuzeci (exception) su neočekivani događaji
- koje je izazvao sam proces
- kao što je page fault
- illegal memory
- izvršavanje privilegovane instrukcije
- deljenje sa 0
- po tome se razlikuju od prekida
- koje izazivaju neki eksterni događaji, van procesa.
- Jedino se obrađuju slično, jer se
- prekida instrukcija
- kernel određuje vrstu trapa i trap rutinu
- ***ako ima smisla***
- obavlja se restart instrukcije koja je napravila izuzetak.
- Kernel mora da se zaštiti od prekida
- za vreme nekih kritičnih operacija,
- na primer, da ne dozvoljava disk prekid
- dok ažurira povezane liste.
- Računari koriste skup privilegovanih instrukcija koje postavljaju
- CPU nivo izvršenja ili kako se nazivaju
- prekidni nivoi (CPU execution level)
- Kada se postavi neki nivo izvršenja,
- svi prekidi koji su ispod tog nivoa
- se neće dozvoljavati kao na slici
- Kernel je rezidentno u memoriji
- ili
- bar deo njega.
- Većina OS pa i UNIX
- koristi princip virtuelne memorije,
- čija je fundamentalna osobina
- mapiranje logičkih u fizičke adrese
- Sadžaj direktorijuma /etc
- izlistati
- i
- upisati u datoteku etc.txt,
- na direktorijumu /tmp
- Proveriti sadržaj datoteke
- Izlaz se česće preusmerava od ulaza.
- Za redirekciju se koristi znak > (veće od)
- Ukoliko se redirekcija vrši u postojeću datoteku, datoteka se briše, a zatim
- se kreira nova u koju se smešta rezultat izvršenja komande.
- Ukoliko korisnik želi da se rezultat izvršenja doda na postojeću datoteku bez brisanja njenog sadržaja, za redirekciju izlaza se koristi znak >>.
- Sledeći primer ilustruje redirekciju izlaza na štampač, u novu datoteku i postojeću datoteku i kreiranje prazne datoteke.
- $ sort kyuss.txt > /dev/lp0
- $ ls -l /home/jsmith > myfile
- $ ls -l /tmp/jsmith >> myfile
- $ >emptyfile
- Standardni izlaz za greške se preusmerava ukoliko korisnik želi da sačuva rezultat izvršenja komande u nekoj datoteci radi kasnije analize grešaka (na primer, debagovanje programa u fazi razvoja).
- Izlaz za greške se preusmerava u tekstualne datoteke pomoću znaka 2>.
- $ ./testprogram 2> debugging.txt
- Vratimo se na naš problem.
- Sadžaj direktorijuma /etc izlistati i upisati u datoteku etc.txt, na direktorijumu /tmp
- Da bi smo listali sadržaj direktorijuma, moramo znati Linux komandu ls
- Korisnik može na ekranu pomoću komande ls (list) prikazati sadržaj bilo kog direktorijuma aktivnog UNIX stabla.
- Sintaksa komande ls je:
- $ ls [options] [dir][filespec]
- Komanda ls će na ekranu prikazati spisak objekata direktorijuma dir definisanih argumentom filespec. Argument filespec se formira pomoću džoker karaktera i nije obavezan. Ukoliko se ne navede, podrazumevaju se svi objekti u direktorijumu. Argument dir takođe nije obavezan, i ako se ne navede, prikazuje se sadržaj tekućeg direktorijuma. Ukoliko se ne navedu dodatne opcije, ls funkcioniše prikazuje samo imena objekata sortiranih u abecednom redu. Od značajnijih opcija komande ls navode se sledeće:
- -a prikazuju se i imena skrivenih objekata
- -B imena rezervnih kopija datoteka se ne prikazuju
- -d prikazuje se kontekst direktorijuma umesto sadržaja-
- -i prikazuje se i-node broj datoteke
- -R rekurzivno se prikazuje sadržaj svih poddirektorijuma
- -L dereferenciranje (umesto simboličkih linkova se prikazuju imena datoteka na koje linkovi upućuju)
- -h veličine datoteka se prikazuju u čitljivom formatu (1K, 234M, 2G)
- -k veličine datoteka se prikazuju u kilobajtima
- -l osim imena objekata, prikazuju se i informacije upisane u i-node (prava pristupa, vlasnik, grupa, datum, vreme)
- -1 prikazuje samo imena objekata (jedno ime u jednoj liniji)
- -r imena objekata se prikazuju sortirana u opadajućem redosledu
- Da bi smo videli sadžaj direktorijuma /etc uradićemo sledeće komande
- $cd /etc
- $ls
- ili
- $ls /etc
- Ukoliko želimo da sadržaj direktorijuma, umesto na ekran prebacimo u datoteku, primenićemo redirekciju izlaza sa znakom >, tj uradićemo sledeću komandu
- $ls /etc >/tmp/etc.txt
- Proveravamo sadržaj datoteke sa komandom less
- $less /tmp/etc.txt
- Imate sistem sa sa 2 diska,
- /dev/hda kao primarni master sa Linux OS
- izmenljivi disk ZIP od 1GB na poziciji od sekundarnog mastera /dev/hdc
- Potrebno je primpremiti novi ZIP medijum, sa fdisk programom ali bez intervencije korisnika.
- Interaktivni program fdisk izvršiti automatski, tj neinteraktivno bez upotrebe tastature
- Ulaz komande se preusmerava pomoću znaka < (manje od) na sledeći način:
- $ command < inputdevice
- Inputdevice može biti datoteka ili ulazni uređaj (preusmeriti ulaz na izlazni uređaj kao što je štampač nema nikakvog smisla).
- Na primer, moguće je standardni ulaz sa tastature zameniti nekom tekstualnom datotekom:
- $ wc -l < /tmp/jsnmith.dat
- Vratimo se na problem
- Imate sistem sa sa 2 diska,
- /dev/hda kao primarni master sa Linux OS
- izmenljivi disk ZIP od 1GB kao sekundarni mastera/dev/hdc
- Potrebno je primpremiti novi ZIP medijum, sa fdisk programom ali bez intervencije korisnika. Interaktivni program fdisk izvršiti automatski, tj neinteraktivno bez upotrebe tastature
- Da bi smo rešili problem, upotrebićemo program fdisk sa redirekcijom ulaza. Opišimo prvo program fdisk. Program za particionisanje diskova koji se isporučuje uz Linux je fdisk (istiomeni program se isporučivao uz DOS i Windows 9x/ME). Detalji o njegovom korišćenju mogu se naći u on-line dokumentaciji (man pages).
- Program fdisk se pokreće na sledeći način:
- # fdisk device
- gde je device nod blok uređaja (diska) koga treba particionisati.
- # fdisk /dev/sda
- Command (m for help): m
- Command action
- a toggle a bootable flag
- b edit bsd disklabel
- c toggle the dos compatibility flag
- d delete a partition
- l list known partition types
- m print this menu
- n add a new partition
- o create a new empty DOS partition table
- p print the partition table
- q quit without saving changes
- s create a new empty Sun disklabel
- t change a partition's system id
- u change display/entry units
- v verify the partition table
- w write table to disk and exit
- x extra functionality (experts only)
- fdisk omogućava korisniku da uradi sledeće stvari:
- prikazivanje particione tabele (p - print the partition table)
- pregled podržanih tipova particija (l - list known partition types)
- kreiranje primarnih, extended i logičkih particija (n - add a new partition)
- brisanje particija (d - delete a partition)
- promena tipa particija (t - change a partition's system id)
- postavljanje flega aktivne particije (a - toggle a bootable flag)
- Pri tome, promene se ne upisuju na disk dok korisnik ne napusti program pomoću opcije w - write table to disk and exit.
- Napuštanje programa pomoću opcije q - quit without saving changes ne povlači upisivanje promena na disk.
- U našem slučaju mi bismo pozvali fdisk i u njemu otkucali njegove interne komande
- #fdisk /dev/hdc
- n kreiranje nove particije
- 0 početak particije
- 1.1G veličina particije
- w upis u MPT
- q izlazak iz programa
- To bi bio interaktivni način rada. Da bi realizovali ne-interaktivni način rada, moramo formirati tekstualnu datoteku, na primer fdisk.txt, gde bi smo za svaku komandu kreirali posebnu liniju
- Izgled datoteke fdisk.txt bio bi
- dev/hdc
- n
- 0
- 1.1G
- w
- q
- Nakon toga rešenje našeg problema je
- #fdisk </tmp/fdisk.txt
- Analizirajte sistemski direktorijum /bin.
- Obavite prebrojavanje svih objekata u njemu,
- uz pomoć samo jedne komande
- Pođimo prvo od povezivanja komandi u pipeline
- Prebrojavanje datoteka u direktorijumu /etc može realizovati pomoću pipeline sprege komandi ls i wc:
- $ ls -l /etc | wc -l
- 145
- Opšta sintaksa pipeline sprege je sledeća:
- $ command1 | command2 | .... | commandN
- To znači da se u pipeline može povezati veći broj komandi (maksimalan broj zavisi od konkretnog UNIX sistema, a obično se kreće od 20 do 30).
- Vratimo se na problem
- Analizirajte sistemski direktorijum /bin. Obavite prebrojavanje svih objekata u njemu, uz pomoć samo jedne komande.
- a ovaj problem potrebne su nam 2 Linux komande,
- ls
- wc.
- Komandu ls smo već opisali, a za komandu, a sada dajemo kratak opis komande wc.
- Komanda wc (word count) se koristi za brojanje karaktera, reči i linija u datoteci. Sintaksa komande je:
- $ wc [-cwl] filename
- Bez opcija komanda prikazuje sve tri vrednosti, dok se opcijama -c, -w i -l specifira prebrojavanje karaktera (bajtova), reči ili linija.
- Datoteka /etc/protocols je iskorišćena radi ilustracije upotrebe komande wc:
- $ wc -c /etc/protocols
- 1748 /etc/protocols
- $ wc -w /etc/protocols
- 297 /etc/protocols
- $ wc -l /etc/protocols
- 44 /etc/protocols
- $ wc /etc/protocols
- 44 297 1748 /etc/protocols
- U našem slučaju, problem ćemo da rešimo primenom povezivanja komandi u pipeline:
- $ls –R /bin | wc -l
- Otkucajte tekst programa koji štampa rečenicu Hello, world ma ekranu.
- Program prevedite i linkujte
- Program izvršite
- Rešenje
- Pođimo najpre od editora teksta. Editor je program koji koristite za uređivanje teksta izvornog koda.
- Mnoštvo različitih editora je raspoloživo na Linux sistemu, ali najpopularniji i najfunkcionalniji je verovatno GNU Emacs.
- Imate takođe program vi, joe....
- Kreiranje datoteke
- #include <stdio.h>
- int main (int argc, char **argv)
- {
- printf ("Hello, world\n");
- return 0;
- }
- Prevođenje pojedinačne datoteke izvornog koda
- Naziv C prevodioca je gcc. Da bismo preveli C datoteku izvornog koda, koristimo -c opciju. Tako se, na primer, zadavanjem sledeće naredbe u komandnoj liniji prevodi main.c datoteka izvornog koda:
- % gcc -c main.c
- Rezultujuća objektna datoteka se zove main.o.
- Povezivanje objektnih datoteka
- Sada, kada ste preveli main.c, treba da je linkujete. Uvek koristite g++ prevodilac kada povezujete program koji sadrži C++ kod, čak i onda kada on sadrži i C kod. Ako vaš program sadrži isključivo C kod, koristite gcc prevodilac.
- Kako ovaj program sadrži i C i C++ kod, koristićete g++ prevodilac i to na sledeći način:
- $ gcc -o main main.o
- Opcijom -o se definiše naziv datoteke koja će biti rezultat povezivanja.
- Izvršavanje programa
- Sada možete pokrenuti main na sledeći način:
- $ ./main
- Hello, world
- Arhitektura UNIX operativnog sistema
- user level
- kernel level
- hardware level
- Dva entiteta, datoteke i procesi su
- 2 centralna koncepta u UNIX sistem modelu.
- Imamo 3 nivoa arhitekture:
- korisnički nivo
- kernelski nivo
- hardverski nivo
- SC intefejs i library interfejs predstavljaju granicu
- između korisničkog programa i kernela.
- SC liče na obične pozive funkcije u C programu,
- a biblioteke mapiraju ove funkcijske pozive
- u primitive neophodne da se uđe u OS.
- Asemblerski programi mogu pozvati SC direktno
- bez poziva sistemskih biblioteka.
- Programi često koriste pozive za sistemske biblioteke
- koji se linkuju sa programom
- in compile time
- in execution time
- FS (File Subsystem)
- upravlja datotekama
- alocira prostor za datoteke
- administrira slobodan prostor
- kontroliše pristup datotekama
- obezbeđuje podatke iz datoteka korisnicima.
- Interakcija procesa sa FS se odvija preko skupa sledećih SC:
- open (open file for reading and writing)
- close
- read
- write
- lseek
- stat (querry the attribute of file)
- chmod
- chown
- FS pristupa podacima na 2 načina:
- 1. buffered access
- preko cache bafera (sve ide kroz kes)
- FS ima specifični interakciju
- sa I/O block uređajima kroz keš,
- keš bafer reguliše protok podataka
- između kernela i I/O uređaja.
- 2. raw access
- bez cache bafera
- FS pristupa blok I/O uređajima direktno, bez keš bafera
- ovaj pristup se naziva raw.
- na isti način se upravlja svim uređajima koji nisu blok orijentisani.
- Device drivers su kernelski moduli koji upravljaju radom I/O uređaja.
- Proces control subsystem(PCS) je odgovoran za
- sinhronizaciju procesa
- IPC
- za upravljanje memorijom
- za CPU scheduling.
- PCS i FS komuniciraju
- kada se puni program iz FS u memoriju radi izvršenja,
- kada PCS čita executable file u memoriju pre nego što je izvrši.
- SC iz PCS su:
- fork (create a new process)
- exec (overlay the image of a program onto running process)
- exit (finishing executing process)
- wait (synchronize process execution with the exit of a previosly forked process)
- brk (control the size of memory allocated to a process)
- signal (control process response to extraordinary events)
- 1. Memory Management module
- kontroliše alokaciju memorije.
- Tu svakako spadaju i dodatne funkcije
- vezane za virtuelnu menoriju, kao što su swaping i DP.
- 2. CPU Scheduler: alocira CPU procesima:
- nastupa posle blokiranja procesa ili
- posle isteka time quantuma
- 3. IPC: postoji više formi IPCa: počevši od
- asinhronog signaliziranja događaja,
- do sinhronih prenosa poruka između njih
- 4. Hardverska kontrola: je odgovorna
- za upravljanje prekidima i
- za komunikaciju sa hardverom-mašinom.
- Prekidni programi se ne servisiraju kao specijalni procesi
- već kao specijalne funkcije u kernelu
- a u kontekstu procesa koji se izvršavaju.
- Interna repreznetacija datoteke je definisana preko inode strukture koja opisuje
- layout datoteke na disku
- druge informacije kao što je vlasništvo, prava pristupa i vremena pristupa.
- Svaka datoteka ima jedan unikatni inode,
- ali može imati više imena (hard links).
- Kada proces traži neku datoteku po imenu,
- kernel analizira svaku komponentu u pathname,
- proverava da li proces ima prava da pretražuje u toj grani,
- a ako dođe do poslednje grane otvara traženi inode.
- Kada proces kreira novu datoteku,
- kernel mora da dodeli novi,
- slobodni inode.
- Inodes se čuvaju u inode tabelu na disku,
- ali radi ubrzanja rada
- kernel otvorene inodes
- čuva u memorijskoj (in-core) inode tabeli.
- Kernel sadrži još 2 dotatne strukture podataka,
- FT=file table
- FT je globalna kernelska struktura
- UFDT = user file descrpitor table.
- UFDT je tabela koja se dodeljuje svakom procesu.
- Kada proces otvara ili kreira novu datoteku,
- kernel alocira po jedan ulaz
- iz svake od ove 2 tabele.
- Stanje "live" datoteke i korisničkog pristupa toj datoteci je dato preko 3 tabele:
- 1. inode table
- 2. FT: čuva zapis o offsetu u datoteci
- gde će se sledeći upis ili čitanje startovati i
- prava pristupa koje ima openning proces
- 3. UFDT: identifikuje sve otvorene datoteke za taj proces
- Kada se otvori ili keira datoteka, kernel vraća deskriptor koji je index u UFTD.
- Kada se potom obavlja read ili write,
- na bazi deskriptora se ulazi u UFDT,
- iz koga se čita ulaz u FT, a
- onda se preko inode tabele realizuje odgovarajući read ili write.
- Disk može biti izdeljen na više sistema datoteka od kojih ima svoj logički broj. Konverzija između logičke adrese <FS, logical_number> i fizičke adrese <cyl, head, sector> je zadatak disk drajvera.
- Diskovi se sastoje of fizičkih blokova = 512. FS se sastoji od logičkih sistemskih blokova veličine 1K, 2K, 4K, 8K.
- FS se sastoji od više komponenti:
- Boot block okupira početak FS-a, obično je to prvi sektor, i sadrži boot code za inicijalno podizanje operativnog sistema.
- Super block opisuje stanje FS-a,
- koliko je veliki,
- koliko maksimalno datoteka može sadržavati,
- gde se nalazi informacija o slobodnom prostoru u FS i razne druge informacije.
- Inode list je tabela koja sledi iza superbloka, administratori specificiraju veličinu ove tabele kada konfigurišu FS.
- Kernel pronalazi inodes indeksiranjem u inode tabelu.
- Specijalan inode je root inode za taj FS:
- to je onaj inode preko kojeg je direktorijumska struktura tog FS
- raspoloživa nakon uspešne mount komande
- data area: počinje odmah iza inode tabele i sadrži datoteke i direktorijume
- Proces je program u izvršavanju i sastoji se od 3 funkcionalne celine
- text
- data
- stack
- U princupu nema preklapanja ovih delova sa drugim procesima a sva komunikacija između procesa se odvija preko IPC-a. Postoje izuzeci od ovog kao što su deljivi kod segmenti (shared code segment) i deljiva memorija (shared memory).
- Praktično, proces na UNIX sistemu je celina kreirana preko fork SC. Svaki proces izuzev procesa 0 se kreira kada neki drugi proces izvrši fork sistemski poziv, pri čemu se taj proces naziva roditelj, a kreirani proces se naziva dete. Svako dete ima samo jednog roditelja, a jedan roditelj može imati puno dece. Kernel svakom procesu dodeljuje jedinstveni broj PID.
- Proces sa PID=0 je specijalan proces koji se kreira ručno kada se UNIX podiže, a potom taj proces forkuje svoje prvo dete koje postaje proces init sa PID=1, dok proces sa PID=0 postaje swapper process. Proces init je predak svih procesa na UNIX-u i svi ostali procesi imaju specijalnu vezu sa njim.
- Izvršni prgoram se sastoji od više funkcionalnih delova:
- skup zaglavlja „header“ koji opisuju atribute datoteke
- text = programski kod
- data sekciju inicijalizovanu (varijable koje imaju početnu vrednost kada se program startuje)
- data sekciju koja se ne inicijalizuje bss
- razne sekcije kao što je simbolička tabela na primer
- Kada se program puni u memoriju preko exec SC,
- minimalno 3 memorijska regiona moraju mu se dodeliti:
- text
- data
- stack
- Text i data sekcija odgovaraju text i databss samog programa
- stack automatski kreira i njegova veličinu kernel automatski prilagođava u runtime.
- Stack se sastoji od logičkih stack frame-ova, koji se
- guraju na stek (push) kada se funkcija pozove i
- skidaju sa steka (pop) kada se obavlja povratak iz funkcije.
- Stack frame sadrži
- adresu samog frame,
- povratnu adresu funkcije,
- parametre funkcije,
- njene lokalne varijable,
- podatke potrebne za regeneraciju prethodnog stek frame uključujući PC i SP u vreme funkcijskog poziva.
- Kako proces na UNIXu može da se izvršava u 2 moda, kernelski i korisnički, za svaki mod mora da se koristi poseban stek.
- Kernelski stek se sastoji od stek frames za funkcije koje se izvršavaju u kernelskom modu i sve je isto kao u korisničkom steku po strukturi .
- Ukoliko nema sistemskih poziva, trapova i prekida, kernelski stek za proces = 0..
- Svaki proces ima 2 ulaza:
- ulaz u kernelskoj tabeli procesa PT
- ulaz u u-area (u = user) a to je područje kojim manipuliše isključivo kernel
- PT ulazi sadrže odnosno ukazuju na per proces region table PPRT, čiji ulazi ukazuju na region tabelu. Region je kontunalni adresni prostor za jedan proces, kao što je text, data ili stek. Region tabela (RT), u svojim ulazima opisuje atribute regiona (text-data, private-sharable) i lokaciju regiona u memoriji. Upotreba RT i PPRT omogućava efikasno deljenje regiona.
- Objasnimo vezu između ovih tabela.
- PT ukazuje na PPRT,
- PPRT ima ukazivače na glavnu RT
- RT opisuje regione
- Ulaz u PT i ulaz u u-area
- sadrže kontrolne i statusne informacije
- o svakom procesu.
- Polja u PT ulazu su:
- polje stanja (state fileld)
- UID: identifikatore koji opisuju koji user je vlasnik procesa
- (user ID odnosno UID)
- skup opisivača događaja kada se proces suspenduje
- (in the sleep state)
- Ulaz u u-area sadrži informacije o procesu koje su potrebne jedino kada se proces izvršava:
- u-area:
- polja u njemu su:
- ukazivač na PT ulaz za proces koji se trenutno izvršava
- parametre tekućeg SC, povratne vrednosti i error kodove
- file deskriptore za sve otvorene datoteke
- tekući direktorijum i tekući root
- limiti za veličinu procesa i veličinu datoteka
- Kernel uvek direktno pristupa poljima u u-area samo za proces koji se tekuće izvršava
- Po pitanju SC i regiona važe sledeća pravila:
- fork SC:
- kernel duplicira adresni prostor od procesa roditelja,
- dozvoljavajući da oba procesa dele regione uvek kad je moguće
- i praveći kopije kada se to mora
- exec SC:
- kernel alocira regione za text, data i stek,
- a prethodno oslobođa sve regione koje je proces imao pre exec SC
- exit SC:
- kernel oslobođa sve regione koje je proces posedovao
- Kontekst procesa je njegovo stanje koje se definiše:
- CPU context
- vrednost registara CPU koje proces koristi
- memory context
- njegov text
- vrednost globalnih promenljivih i data struktura
- sadržina korisničkog i kernelskog steka
- IO context
- all open files
- Kernel structures
- vrednosti ulaza i u PT i ulaza iz u-area
- OS izvršava proces, preciznije OS izvršava kontekst procesa.
- Kontekst procesa se čuva u 3 situacije:
- 1. CSw
- Kada kernel odluči da izvršava neki drugi proces, mora se obaviti kontext switch, CSw.
- Kernel dozvoljava prebacivanje konteksta samo pod određenim uslovima.
- Kada obavlja CSw, kernel mora da sačuva dovoljno informacija o procesu koji se suspenduje kako bi kasnije mogao da ga nastavi.
- 2. user->kernel mod
- prilikom prebacivanja iz user moda u kernelski mod, kernel mora sačuvati dovljno informacija kako bi proces nastavio izvršavanje tamo gde je stao, nakon povratka u user mod.
- Naravno u ovom slučaju se ne menja kontekst procesa već samo mod.
- 3. Interrupt
- Kernel opslužuje prekide u kontekstu jednog istog procesa koji se prekida, pa se nastavi.
- Opsluživanje prekida se ne realizuje preko novih procesa, ali se radi uvek u kernelskom modu.
- Prekinuti proces može biti i u user modu i u kernelskom modu, a prilikom prekida mora se sačuvati dovoljno informacija da prekinuti proces može da se nastavi.
- Proces se može naći u nekoliko stanja:
- (running in user mode)
- Proces se trenutno izvršava u korisničkom modu
- (running in kernel mode)
- Proces se trenutno izvršava u kernelskom modu
- (ready)
- Proces je ready: ne izvršava se, nego čeka da scheduler prozove
- (asleep in memory)
- Proces je uspavan: proces blokira svoje izvršavanje zato što ne može dalje da nastavi čekajući na nešto, na primer na I/O da se završi
- Zato što procesor može izvršava samo jedan proces u vremenu, samo jedan proces može biti u stanju 1 ili 2. Svi ostali procesi, osim CPU aktivnog, su u stanju 3 ili 4.
- Procesi često menjaju svoja stanja po dobro poznatim pravilima, koja su prikazana na sledećoj slici, gde krug predstavlja stanje, a ivica sa strelicom predstavlja događaj koji izaziva da se proces pomeri iz jednog stanja u drugo.
- Više procesa mogu biti u memoriji, a takođe više njih mogu raditi u kernelskom modu. Da ne bi došlo do narušavanja kernelskih struktura podataka, kernel ne dozvoljava bilo kakvo prebacivanje konteksta a takođe kontroliše i prekide.
- Kernel dozvoljava prebacivanje konteksta samo kada se proces prebacuje iz stanja kernel running u stanje asleep in memory.
- Proces koji radi u kernelskom modu ne može biti preemptovan od bilo kog drugog procesa, tako da se za kernel kaže da je non-preemptive i na taj način se rešava problem ME u kernelskom modu (samo jedan proces izvršava CS u kerneskom modu i ne može biti preempteed).
- Čak i prekidi mogu biti suspendovani ako mogu da dovedu do problema inkozistencije podataka u kernelu. Takav deo koda se naziva CriticalSection u kernelu i tada kernel podiže CPU nivo da su većina prekida blokirana, samo dok je proces u CS (naravno u kernel modu).
- UNIX kernel sebe štiti tako što dozvolava CSwitch samo na jednom mestu i što blokira prekide koji su opasni u svojim CS (na primer, dok ažurira buffer queue pointere, blokiraće disk prekidi).
- Proces koji radi u kernelskom modu ima veliku autonomiju da odluči kako će da reaguje na sistemske događaje. Ako već mora da čeka na nešto, poželjno je da se uspava-blokira, ali to je odluka samog procesa.
- Na drugoj strani, interrupt handler ne sme da se uspavljuje, jer ako to učini, prekinuti proces bi bio uspavan po defaultu.
- Procesi se uspavljuju zato što čekaju da se neki događaj desi: završetak I/O operacije, čekanje na drugi proces da se završi, čekanje da resurs postane raspoloživ. Procesi se blokiraju na događaj, i kada se on desi prelaze u ready to run. Mnogi procesi mogu biti uspavani na isti događaj, a kada se on desi svi se bude i prelaze u ready queue, nema neposrednog izvršavanja.
- Na primer, proces koji se izvršava u kernelskom modu može lock-ovati neke data strukture pre nego što ode na spavanje. Svi drugi moraju da čekaju na unlock, a dotle i oni idu na spavanje.
- Kernel implementira locks na sledeći način:
- lock
- while(condition is true)
- sleep (event: the condition becomes false)
- set condition true
- Proces obavlja unlock i budi sve procese koji to čekaju:
- unlock
- set condition false;
- wakeup(event: condition is false)
- Većina struktura podataka kernela zauzima
- tabele fiksnih veličina
- radije
- nego dinamički alocirani prostor
- To ima prednosti jer uprošćava kernelski kod,
- ali limitira broj ulaza u kernelskim strukturama.
- Ako se prekorači broj ulaza, korisnik mora da čeka i šalje mu se poruka o grešci, za njegov proces nema ulaza u kernelskoj strukturi.
- Postoje i kerneli koji se mogu adaptirati, ali to se kosi sa efikasnošću i jednostavnošću kernela.
- Postoje razni adminstativni procesi koji obavlja razne funkcije,
- formatiranje diska,
- kreiranje FS,
- podešavanje parametara kernela.
- Za takve procese,
- kernel zahteva root privileguju,
- odnosno da takve procese izvodi specijalni account sa atributima superuser-a.
- Linux = Linus + Unix
- Linux = Unix made by Linus Torvalds
- Jedna od poslednjih varijanti UNIX operativnih sistema,
- razvoj započeo Linus Torvalds
- 1991. godine na Unverzitetu u Helsinkiju,
- Torvalds je svoj operativni sistem koji objedinjuje oba standarda, SRV4 i BSD, objavio na Internetu i podsticao druge programere širom sveta da se priključe njegovom daljem razvoju.
- Ubrzo, Linux je postao veoma popularan među računarskim entuzijastima, koji su tražili alternativno rešenje za postojeće operativne sisteme za PC računare (DOS, Windows).
- Linux je svojom koncepcijom, stabilnog a jeftinog operativnog sistema doživeo veliku ekspanziju i popularnost.
- Linux je raspoloživ kao besplatan operativni sistem
- pod GNU GPL licencom (GNU General Public License),
- što važi i za neke druge vrste UNIX sistema,
- kao što su FreeBSD i NetBSD.
- Linux je softver sa otvorenim izvornim kodom (Open Source), što znači da je mu je izvorni kod javno raspoloživ i može biti modifikovan tako da odgovara specifičnim potrebama.
- Linux se može slobodno distribuirati među korisnicima.
- Ovakav koncept je potpuno suprotan konceptu komercijalnog softvera, gde izvorni kod nije dostupan i svaki korisnik mora da plati licencu za korišćenje. Komercijalni softver je baziran na autorskim pravima (copyright laws), koja preciziraju limite koje korisnici softvera imaju u odnosu na izvorni kod, korišćenje i dalje distribuiranje softvera.
- Linux se besplatno može preuzeti sa različitih web-sajtova.
- GNU stands for “GNU's Not Unix”
- Simbol Linux sistema je mali pingvin (Tux), prikakazan na slici
- Linux je raspoloživ kao besplatan operativni sistem
- pod GNU GPL licencom (GNU General Public License),
- što važi i za neke druge vrste UNIX sistema,
- kao što su FreeBSD i NetBSD.
- Linux je softver sa otvorenim izvornim kodom (Open Source), što znači da je mu je izvorni kod javno raspoloživ i može biti modifikovan tako da odgovara specifičnim potrebama.
- Linux se može slobodno distribuirati među korisnicima.
- Ovakav koncept je potpuno suprotan konceptu komercijalnog softvera, gde izvorni kod nije dostupan i svaki korisnik mora da plati licencu za korišćenje. Komercijalni softver je baziran na autorskim pravima (copyright laws), koja preciziraju limite koje korisnici softvera imaju u odnosu na izvorni kod, korišćenje i dalje distribuiranje softvera.
- Linux se besplatno može preuzeti sa različitih web-sajtova.
- GNU stands for “GNU's Not Unix”
- Brojne profit-orijentisane i neprofitne organizacije čine Linux raspoloživim u formi distribucija, odnosno različitih kombinacija kernela, sistemskog softvera i korisničkih aplikacija. Većina distribicuja sadrži kolekciju CD/DVD medijuma na kojima se nalazi operativni sistem, izvorni kod, detaljna dokumentacija, kao i štampana uputstva za instalaciju i upotrebu sistema. Cene ovakvih distribucija su u većini slučajeva simbolične, osim ako se u distribuciji nalazi komercijalan softver ili je distribucija specifične namene.
- Osnovna komponenta svake Linux distribucije je kernel operativnog sistema.
- Osim kernela i sistemskog softvera, u distribuciji se nalaze:
- instalacioni alati, softver za podizanje operatvnog sistema (boot loader)
- razne korisničke aplikacije (kacelarijski paketi - office suite
- softver za manipulaciju bit-mapiranih slika)
- serverski paketi
- Većina distribucija je poput Windows sistema, grafički orijentisana prema korisniku, dok su neke distribucije namenjene za sistemske administratore i programere familijarne sa tradicionalnim UNIX okruženjem.
- U poznatije Linux distribucije spadaju:
- Debian GNU/Linux (http://www.debian.org),
- Linux Mandrake (http://linux-mandrake.com/en),
- Red Hat Linux (http://www.redhat.com),
- Slackware Linux (http://www.slackware.com) i
- SuSE Linux (http://www.suse.com).
- Ubuntu Linux (http://ubuntu.suse.com)
- Linux je višekorisnički,
- višeprocesni operativni sistem
- sa potpunim skupom UNIX kompatibilnih alata,
- projektovan tako da poštuje relevantne POSIX standarde.
- Linux sistemi podržavaju tradicionalnu UNIX semantiku i potpuno implementiraju standardni UNIX mrežni model.
- Linux operativni sistem sastoji se od:
- kernela
- sistemskog softvera
- korisničkih aplikacija
- programskih prevodioca i njihovih odgovarajućih biblioteka (GCC - GNU C Compiler i C biblioteka za Linux) i
- dokumentacije
- Sadržaj konkretne Linux distribucije definisan je sadržajem instalacionih medijuma, koji u slučaju nekih Linux sistema uključuju razne FTP sajtove širom sveta.
- Kernel je srce operativnog sistema - on omogućava konkurentno izvršavanje procesa, dodeljuje im memoriju i druge resurse i obezbeđuje mehanizam za ostvarivanje servisa operativnog sistema.
- Kernel štiti korisničke procese od direktnog pristupa hardveru - procesi pristupaju hardveru korišćenjem sistemskih poziva kernela, čime se obezbeđuje jedna vrsta zaštite između samih korisnika.
- Sistemski programi koriste kernel u cilju implemetacije različitih servisa operativnog sistema.
- Svi programi, uključujući i sistemske, funkcionišu na nivou iznad kernela, što se naziva korisnički režim rada, dok se sistemske aktivnosti poput pristupa hardveru obavljaju na nivou kernela, odnosno u kernelskom režimu rada.
- Razlika između sistemskih i aplikativnih programa je u njihovoj nameni: aplikacije su namenjene za razne korisne aktivnosti (kao što su obrada teksta i slike), dok su sistemski programi namenjeni za rad sa sistemom i administraciju.
- Na primer tekst procesor je korisnička aplikacija, dok je komanda mount sistemski program. Razlike između korisničkih i sistemskih programa su ponekad veoma male i značajne samo za stroge kategorizacije softvera.
- Tri osnovne verzije Linux kernela su početna verzija, verzija 1.x i verzija 2.x.
- Početna verzija 0.01, koju je 1991. godine kreirao Linus Torvalds, podržavala je samo Intel 80386 kompatibilne procesore, mali broj hardverskih uređaja i Minix sistem datoteka. Mrežni servisi nisu imali kernelsku podršku.
- Verzija 1.0, nastala u martu 1994. godine, uključivala je podršku za standardne TCP/IP mrežne protokole, BSD-kompatibilni socket interfejs za mrežno programiranje i drajversku podršku za mrežne kartice. Ova verzija je dodatno podržavala ext i ext2 sisteme datoteka, široku klasu SCSI disk kontrolera, kao i brojne hardverske uređaje. Verzija 1.2 (mart 1995) je poslednja verzija Linux kernela namenjena isključivo PC arhitekturi.
- U verziji 2.0 (jun 1996) uvedena je podrška za više arhitektura (Motorola i Intel procesori, Sun Sparc i PowerMac sistemi), kao i podrška za višeprocesorsku arhitekturu (SMP). Dodatno, poboljšano je upravljanje memorijom i uvećane se performanse TCP/IP protokol steka, a ugrađena je i podrška za unutrašnje kernelske niti (internal kernel threads). Kernel je modularizovan, odnosno uvedena je mikro-kernel struktura sa izmenljivim drajverskim modulima (loadable kernel modules), a standardizovan je i konfiguracioni interfejs.
- Osnovu Linux sistema čine:
- kernel
- sistemske biblioteke
- sistemski programi
- Kernel je odgovoran za najznačajnije funkcije operativnog sistema.
- Dve osnovne karakteristike kernela su:
- kernel kod se izvršava u kernelskom modu u kome je jedino moguće pristupati svim komponentama hardvera
- kompletan kernel kod i sve kelnel strukture podataka se čuvaju u istom adresnom prostoru (monolithic)
- Kod većine UNIX sistema, aplikacije se preko SC direktno obraćaju kernelu
- Kod Linux sistema, sistemski pozivi se upućuju kernelu preko sistemskih biblioteka,
- koje definišu standardni set funkcija
- preko kojih aplikacije komuniciraju sa kernelom
- Moduli kernela su delovi kernelskog koda koji može da se prevede, napuni u memoriju ili izbaci iz memorije nezavisno od ostatatka kernela.
- Kernelski moduli implemetiraju:
- drajvere za hardverske uređaje
- novi sistem datoteka
- mrežne protokole
- Moduli omogućavaju raznim programerima da napišu i distribuiraju drajvere koji ne moraju da prođu GPL licencu.
- Moduli kernela omogućavaju micro-kernel arhitekturu,
- odnosno realizaciju minimalne stabilne konfiguracije kernela
- bez dodatnih drajvera.
- Potrebni drajveri pune se u memoriju kao moduli kernela.
- Module Linux kernela čine 3 komponente:
- 1. upravljanje modulom, koja omogućava punjenje modula u kernelsku memoriju i komunikaciju modula sa ostatkom kernela, proveru da li je modul u memoriji i da li se koristi i izbacivanje modula iz memorije (pod uslovom da se modul ne koristi).
- 2. registracija drajvera, koja omogućava modulu da objavi ostatku kernela da je novi drajver u memoriji i da je raspoloživ za korišćenje. Kernel održava dinamičku tabelu drajvera, koji se pomoću posebnog seta programa mogu napuniti ili izbaci iz memorije u svakom trenutku,
- 3. rezolucija konflikata, odnosno mehanizam koji služi da spreči hardverske konflikte, tako što omogućava drajveru da rezerviše hardverske resurse (IRQ, DMA, ports) i time spreči druge drajvere ili autoprobe funkciju da ih koriste.
- #lsmod #modprobe #depmod #insmod #rmmod
- Podešavanje putem menija je lakši i pregledniji način izrade konfiguracione datoteke (human-friendly interfejs za konfigurisanje).
- Okruženje sa menijima se pokreće tako što se
- na sistem prijavi root,
- zatim pređe u direktorijum u kome se nalazi izvorni kod kernela
- (na primer /usr/src/kernel-source-2.4.19) i
- pokrene komandu make menuconfig.
- Alat za podešavanje putem menija zahteva da je na sistem instalirana biblioteka ncurses.
- # cd /usr/src/kernel-source-2.4.19
- # make menuconfig
- Podešavanje putem menija počinje spiskom kategorlja u kojima se biraju opcije kernela.:
- Za navigaciju po menijima koriste se kursorski tasteri (strelice),
- za ulazak u podmeni taster Enter.
- Taster Tab služi za prelazak u deo ekrana sa dugmadima
- Select (prikazuje podmeni opcija pridruženih istaknutoj stavci),
- Exit (vraća se na prethodni meni, završavajući podešavanje ukoliko je izabrano sa najvišeg nivoa) i
- Help (prikazuje pomoćni ekran pun informacija o istaknutoj stavci menija).
- Stavke menija koje odreduju neku opciju jezgra, a ne mogu biti modularne, sa leve strane imaju jednu od sledećih oznaka:
- [*] opcija je deo jezgra
- [ ] opcija nije deo jezgra
- Stavke menija koje odreduju neku opciju jezgra, a mogu biti deo jezgra ili realizovane kao modul, sa leve strane imaju jednu od sledećih oznaka:
- < > opcija nije uključena kao deo jezgra, niti napravijena kao modul koji može kasnije da se učita
- <*> opcija je deo jezgra i samim tim je uvek deo sistema.
- <M> opcija je uključena kao modul, ali nije deo samog jezgra. Modul je kasnije po potrebi može učitati ili ukloniti iz jezgra koje se izvršava.
- Oznake sa leve strane ukazuju na trenutno stanje opcije.
- Stanje se može izmeniti jednim od sledećih tastera:
- Y (uključi opciju u jezgro)
- M (uključi opciju kao modul)
- N (opcija se ne uključuje, niti realizuje kao modul).
- Dodatno, pomoću tastera ? se za tekuću opciju na ekranu prikazuje detaljan opis.
- Nakon postavljanja svih opcija na željenu vrednost, potrebno je iz glavnog menija odabrati dugme Exit, nakon čega će se na ekranu pojaviti pitanje da li želite da snimite izmenjenu konfiguracionu datoteku.
- Prevođenje i testiranje novog jezgra
- Nakon kreiranja nove konfiguracione datoteke potrebno je prevesti izvorni kod kernela.
- Zavisno od konfiguracije računara (brzina procesora, količina memorije, tip i brzina diskova) i verzije kernela, prevođenje i sklapanje jezgra traje od nekoliko minuta do nekoliko sati.
- Kernel može biti
- nekomrimovan (image) i
- komprimovan progrogramom gzip ili bzip2 (zlmage, bzimage), koji je manji, ali se sporije učitava.
- Komande za prevođenje variraju sa konkretnom Linux distribucijom, ali su u svakom slučaju jednostavne i mogu izvršavati jedna za drugom zadate iz jedne komandne linije. Komande se mogu zadavati i odvojeno, jedna za drugom.
- Prevođenje i testiranje novog jezgra
- Sledeće komande
- prevode izvorni kod,
- prave novo jezgro i sklapaju sve module jezgra,
- smeštajući ih u odgovarajuće sistemske direktorijume,
- čime se obezbeđuje njihova dostupnost pomoću standardnih komandi za rad sa modulima:
- # make dep; make clean; make zImage; make modules; make modules_install
- Linux kernel čini nekoliko značajnih komponenti:
- upravljanje procesima
- upravljanje memorijom
- upravljanje sistemima datoteka (VFS)
- apstrakcija mrežnih servisa
- podrška za hardverske uređaje
- podrška za različite sisteme datoteka
- podrška za TCP/IP
- Linux koristi standardni UNIX proces mehanizam (fork)
- koji razdvaja kreiranje procesa i
- njegovo izvršenje u dve različite operacije:
- 1. sistemski poziv fork, koji kreira novi proces
- 2. sistemski poziv exec, koji izvršava program u resursima novostvorenog procesa
- Pod UNIX sistemom sve informacije koje operativni sistem mora
- čuvati da bi kontrolisao jedan proces
- predstavljaju kontekst tog procesa.
- Pod Linux operativnim sistemom, svaki proces je u potpunosti opisan sa 3 informacije:
- identitet
- okolina
- kontekst
- Identitet procesa obuhvata sledeće informacije:
- Identifikator procesa (Process ID - PID), pomoću kog Linix kontroliše proces.
- Akreditivi (Credentials). Svaki proces pripada jednom korisniku koji ima svoj user ID i jedan ili više grupnih IDs, koji određuju prava pristupa procesu u radu sa datotekama.
- Ličnost (Personality). Ova informacija se ne koristi kod drugih UNIX sistema, a Linux svakom procesu dodeljuje lični identifikator koji može imati uticaja za neke sistemske pozive.
- Okolina procesa se nasleđuje od procesa roditelja. U okolinu procesa spadaju vektor argumenata koje proces roditelj prosleđuje programu i vektor okoline, odnosno lista promenljivih koje definišu okolinu procesa (environment).
- Kontekst procesa je stanje procesa u datom trenutku vremena.
- Kontekst procesa čine sledeće komponente:
- kontekts za raspoređivanje (scheduling context), koji služi za
- efikasnu suspenziju ili ponovni start procesa. Obuhvata sve CPU registre, prioritet procesa i kernelski stek procesa.
- statistički kontekst, koji sadrži informacije o resursima koje proses koriste u jednom trenutku, kao i kompletnu upotrebu resursa za vreme trajanja jednog procesa (accounting information)
- tabela datoteka (file table), tj. polje ukazivača na kernelske strukture datoteka
- kontekst sistema datoteka (file-system context)
- tabela za upravljanje signalima (signal-handler table), koja definiše ukazivače na programe koji se pozivaju nakon određenog signala
- kontekst virtulene memorije (virtual-memory context), koji potpuno opisuje korišćenje memorije od strane procesa
- Linux koristi istu internu reprezentaciju za procese i niti –
- nit (thread) je jednostavno novi proces
- koji deli adresni prostor roditelja.
- Za razliku od novog procesa koji pomoću sistemskog poziva fork formira novi kontekst sa unikatnim adresnim prostorom,
- nit nastaje pomoću sistemskog poziva clone,
- koji kreira novi kontekst, ali dozvoljava novom procesu da deli adresni prostor roditelja.
- Linux koristi 2 algoritma za dodelu procesora procesima (process-scheduling algorithms):
- 1. time-sharing algoritam za korektno raspoređivanje između procesa (fair preemptive scheduling).
- Dodela se vrši na osnovu prioriteta procesa koji definiše korisnik i kredita (efektivni prioritet) koji raste s porastom vremena čekanja na procesor po sledećoj rekurzivnoj formuli:
- kredit = kredit/2 + prioritet
- 2. real-time algoritam za procese gde su apsolutni prioriteti mnogo značajniji od ravnomerne raspodele. Linux je ipak soft-real time operativni sistem.
- Interprocesna komunikacija obuhvata
- obaveštavanje procesa o događaju i
- prenos podataka s jednog procesa na drugi.
- Kao i UNIX sistem, Linux informiše procese u korisničkom režimu o događaju putem signala.
- Procesi u kernel modu umesto signala,
- koriste specijalnu vrstu deljive memorije
- (wait.queue struktura)
- za interprocesnu komunikaciju.
- Za prosleđivanje podataka između procesa koristi se
- 1. pipe mehanizam, koji omogućava jednosmernu razmenu podataka putem komunikacionog kanala koji proces nasleđuje od roditelja, i
- 2. deljiva memorija, koja je brza i fleksibilna, ali zahteva sinhronizaciju
- Upravljanje memorijom obuhvata
- upravljanje operativnom (RAM) memorijom i
- upravljanje virtuelnom memorijom.
- Upravljanje fizičkom memorijom se bavi alokacijom i oslobađanjem stranice (pages, normal extent), grupe stranica (large extent) i malih memorijskih blokova (small extent).
- Upravljanje fizičkom memorijom se obavlja po sistemu drugova (Buddy heap).
- Cela fizička memorija se deli na udružene blokove čije su veličine stepeni broja 2.
- Blokovi se prema potrebi alokacije dalje razbijaju na manje blokove ili se parovi udružuju u veće celine.
- Linux podržava brojne formate za punjenje i izvršavanje programa. Među njima svakako treba istaći stari UNIX format a.out i novi elf format, koji je maksimalno prilagođen konceptu virtulene memorije.
- ELF format se sastoji od zaglavlja, koje opisuje sekcije programa.
- Sekcije programa su po veličini prilagođenje veličini stanice virtulene memorije.
- Program kod koga su funkcije iz sistemske biblioteke direktno ugrađene u kod programa je program sa statičkim linkovanjem. Glavni nedostatak ovakvog linkovanja je povećanje veličine koda, jer svaki poziv funkcije iz biblioteke kopira celu funkciju u kod. Takođe čim je kod veći, veća je količina memorije potrebna za njegovo izvršavanje.
- Na drugoj strani, dinamičko linkovanje je efikasnije i modernije, sama funkcija se ne kopira u kod, a i manja količina memorije je potrebna za izvršenje.
- Linux deli uređaje u tri klase:
- blok uređaje (poput diskova i CD-ROM uređaja)
- karakter uređaje (poput štampača)
- mrežne uređaje
- Svaki uređaj je predstavljen specijalnom datotekom (device node, device file) koja se nalazi u direktorijumu /dev root sistema datoteka.
- Kada korisnik upisuje podatke u datoteku koja predstavlja neki uređaj ili čita iz te datoteke, vrši se neka ulazno-izlazna operacija, odnosno sistem šalje ili prima podatke sa uređaja koji je predstavljen tom datotekom.
- Time se ukida potreba za postojanjem posebnih programa (a samim tim i posebnom metodologijom programiranja ulazno-izlaznih operacija) neophodnih za rad sa uređajima.
- Na primer, korisnik može da odštampa tekst na štampaču jednostavnom redirekcijom standardnog izlaza na datoteku /dev/lp1 koji predstavlja štampač:
- # cat izvestaj.txt > /dev/lp1
- Ova komanda će korektno odštampati datoteku izvestaj.txt ukoliko je ona u obliku koji štampač razume (npr. tekstualna datoteka).
- Direktorijum /dev nastaje prilikom instalacije Linux sistema i
- u njemu se nalaze sve specijalne datoteke,
- bez obzira na to da li je uređaj instaliran na sistem ili ne –
- postojanje datoteke /dev/sda ne znači da je na sistem instaliran SCSI disk.
- Postojanje svih datoteka olakšava proces instalacije novog hardvera, tj. oslobađa administratora sistema potrebe za kreiranjem specijalnih datoteka sa korektnim parametrima.
- Linux sistemi datoteka koriste hijerarhijsku strukturu stabla i semantku UNIX sistema datoteka.
- Interno, kernel sakriva detalje i upravlja različitim sistemima datoteka preko jednog nivoa apstrakcije, koji se naziva virtuleni sistem datoteka VFS.
- Aktivno Linux stablo datoteka čini jedan ili više sistema datoteka koji su montirani na odgovarajuće direktorijume preko kojih im se pristupa.
- Osnovu aktivnog stabla datoteka čini korenski sistem datoteka (root filesystem), čiji root direktorijum ujedno predstavlja i root direktorijum aktivnog stabla datoteka.
- Zavisno od hardverske konfiguracije i odluke administratora sistema, struktura aktivnog Linux stabla može biti jednostavna (aktivno stablo realizovano jednim sistemom datoteka), ili složena (aktivno stablo realizovano većim brojem sistema datoteka - root, /boot, /var, /usr, /home ...)
- Umrežavanje je ključno područje funkcionalnosti Linux sistema.
- Linux koristi standardni TCP/IP protokol stek
- kao osnovni komunikacioni protokol,
- a dodatno podržava i brojne druge protokole
- koji nisu uobičajeni za komunikaciju dva UNIX sistema (AppleTalk, IPX, Samba).
- Interno, umrežavanje pod Linux sistemom obuhvata tri softverska nivoa:
- socket interfejs
- protokol drajvere
- drajvere za mrežne kartice
- Lesson III: Buffer cache
- Kernel pokusava da smanji broj disk pristupa preko baferskog kesa,
- a to je skup internih bafera podataka
- koji sadrzi podatke nedavno korisüenih disk blokova.
- (read) Kada se proces obraüa datoteci za itanje,
- kernel pokusava da je locira u kesu,
- ako je u kesu ne ita je sa diska (read hit),
- a ako nije prvo se dovede u kes (read miss),
- uvajuüi u kesu one podatke za koje algoritam smatra da su najkorisniji.
- (write) Po pitanju upisa, kes je vrlo beneficijalan,
- moze da kompenzuje visestruka upisivanje ili
- da potpuno elimise upis na disk, (ako usledi proces brisanja datoteke)
- takoe vise odlozenih upisa se mogu kombinovati u optimalnom redosledu.
- Kes algoritam izdaje instrukcije za
- pre-cache (read-ahead) i
- delayed-write da bi se maksimizovao kes efekat.
- Lesson III Slide 1 of 27
- Baferi (Buffers)
- Za vreme sistemske inicijalizacije,
- kernel alocira prostor za odreeni broj bafera (total cache size),
- a taj prostor zavisi od memorijske veliine i sistemskih performansi.
- Bafer se sastoji od 2 dela-komponente:
- bafer: memorijsko polje koje sadrzi podatke, na nivou logikog bloka FS
- bafersko zaglavlje (header) koje identifikuje bafer
- Kernel ispituju zaglavlja kako bi analizirao sadrzaj kes bafera.
- tag data
- memory cache
- memory
- Lesson III Slide 2 of 27
- Baferska zaglavlja (Buffer headers)
- Bafer zaglavlje sadrzi sledeüa polja:
- device number
- block number
- data pointer: ukaziva na blok iz data-area (mora da pokrije sve
- blokove iz data area)
- status:
- locked: bafer je trenutno locked sto znai da je zauzet (puni se ..)
- valid: bafer sadzi validne podatke
- delayed write: kernel mora upisati sadrzaj bafera na disk pre nego sto
- obavi ponovnu dodelu bafera
- in reading/writing: kernel trenutno ita ili pise po baferu
- wait for be free: proces eka da bafer postane slobodan
- set pointera za alokaciju bafera koje koristi kes algoritam
- Lesson III Slide 3 of 27
- Buffer header
- Lesson III Slide 4 of 27
- Struktura bafera (Buffer pool)
- Baferi se opsluzuju po LRU algoritmu:
- kada se bafer dodeli disk bloku,
- taj blok üe ostati tu
- sve dok ne postane najstariji u baferu po pitanju obraüanja.
- Kernel odrzava listu slobodnih bafera u LRU redosledu.
- Slobodna lista je duplo linkovana cirkularna lista sa header-om na
- poetku.
- U poetku, svi su baferi slobodni:
- Buffer is free?
- kernel uzima bafer koji je na poetku free liste
- tada ga izbacuje iz slobodne liste,
- a po povratku ga stavlja na kraj free liste.
- Lesson III Slide 5 of 27
- Struktura bafera (Buffer pool)
- Lesson III Slide 6 of 27
- Struktura bafera (Buffer pool)
- Kada kernel prisitupa disk bloku,
- on pretrazuje sve headers za odgovarajuüu kombinaciju
- <device, block number>
- Da ne bi pretrazivao sva zaglavlja,
- kernel organizuje cache-bafer u odvojene redove (hash queue)
- na bazi hash funkcije od device-block broja.
- Kernel povezuje bafere na duplo linkovani hash redove ekanja, u slinu
- strukturu kao za listu slobodnih blokova.
- Broj bafera za jedan hash queue je promenljiv i zavisno od obraüanja disku.
- Kernel korsiti hash funkciju za raspodelu baferu izmeu hash redova, koja
- mora biti dovoljna brza.
- Broj hash redova se odreuje prilikom podizanja sistema i to moze po
- default-u ili sistem administrator odreuje.
- Lesson III Slide 7 of 27
- hash queue example
- Na levoj strani su headeri, blokovi se rasporeuju u hash redove po funkciji
- LBA mod 4.
- Isprekidane linije ukazuju na hash pointere u oba smera.
- Svaki bafer je u nekom od hash queue, ali moze se dogoditi da bude i u
- slobodnoj listi (never allocated).
- Lesson III Slide 8 of 27
- Tehnike za dobijanje podataka iz bafera
- Kes algoritam upravlja baferskim kesom. Za svako itanje sa diska kernel
- mora prvo da odredi da li je blok u kesu (cache buffer pool) i ako nije tamo
- mora da mu dodeli slobodan bafer. To se isto desava i prilikom upisa, oba
- algoritma i za itanje i za upis koriste uveni UNIX getblk algoritam koji
- fukcionise na sledeüi nain.
- Algoritam getblk ima 5 moguüih scenarija prilikom dodele baferu u kesu:
- #1 Kernel pronalazi bafer u njegovom hash queue i bafer je slobodan (hit&free)
- #2 Kernel ne nalazi bafer u njegovom hash queue, zato moze da alocira bafer iz
- free liste (miss&there is free)
- #3 Kernel ne nalazi bafer u njegovom hash queue, zato moze da alocira bafer iz
- free liste ali taj bafer ima atribut delayed write, sto znai da mora prvo da se upise
- na disk (miss&there is free, dirty)
- #4Kernel ne nalazi bafer u njegovom hash queue, ali i free lista je prazna
- (miss&there is no free)
- #5 Kernel nalazi bafer u njegovom hash queue, ali je taj bafer locked (busy), neko
- drugi ga je vec da ga ita (hit&busy)
- Paznja: blok je free, ako je u free listi, koja znai da ga niko ne koristi pri emu
- moze biti u hash listi ili ne..
- Lesson III Slide 9 of 27
- getblk (block is in the cache)
- algoritam getblk
- input: FS number, block number
- output: locked buffer that can now be used for block
- {
- while (buffer not found)
- {
- if (buffer in hash queue)
- {
- if (buffer busy) /*scenario 5*/
- {
- sleep (event buffer becomes free);
- continue; /* back to while lop*/
- }
- mark buffer busy; /*scenario 1*/
- remove buffer from free list; /*lock*/
- return buffer;
- }
- Lesson III Slide 10 of 27
- getblk (block is not in the cache)
- else /*block not on hash queue*/
- {
- if (there are no buffers on free list) /*scenario 4*/
- {
- sleep (event any buffer becomes free);
- continue; /* back to while lop*/
- }
- remove buffer from free list; /*lock*/
- if (buffer marked for delayed write) /*scenario 3*/
- {
- asynchronous write buffer to disk;
- continue; /* back to while loop*/
- }
- /* scenario 2 found a free buffer*/
- remove buffer from old hash queue;
- put buffer onto new hash queue;
- return buffer;
- }/*else*/ }/*while*/ }/*main*/.
- Lesson III Slide 11 of 27
- scenario #1 (searching)
- Trazimo blok 4, blok 4 se nalazi u hash queue 0 i slobodan je
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3 35 99
- freelist header
- Lesson III Slide 12 of 27
- scenario #1 (allocating)
- Blok 4 je naen, izbacuje se iz free liste
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3 35 99
- freelist header
- Lesson III Slide 13 of 27
- after allocating
- Pre nego sto objasnimo ostale scenarije, demonstrirajmo sta se desava kada
- se bafer dodeli.
- Svaki proces posle getblk dobija bafer koga kernel je locked samo za njega.
- Iza toga blok moze da se ita da se upisuje i
- sve dok mu kernel drzi lock, nijedan proces ne moze pristupiti tom baferu.
- Kada proces obavi svoje, bafer se mora osloboditi preko algoritma brelse.
- Uvek kada se azurira free lista, prekidi moraju biti blokirani.
- Lesson III Slide 14 of 27
- algoritam brelse
- algoritam brelse
- input: locked buffer
- output: none
- {
- wakeup all procs: event, waiting for any buffer to become free;
- wakeup all procs: event, waiting for this buffer to become free;
- raise CPU execution level to block interrupts;
- if (buffer contents valid and buffer not old)
- enqueue buffer at the end of free list
- else
- enqueue buffer at the beginning of free list
- lower CPU execution level to allow interrupts;
- unlock(buffer);
- }/*main*/.
- Lesson III Slide 15 of 27
- scenario 2. a) Trazimo blok 18, nije u kesu
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3 35 99
- freelist header
- Lesson III Slide 16 of 27
- scenario 2. b) Uklanja se prvi blok iz free liste i
- dodeljuje novom bloku 18
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10 18
- block number 3 mod 4 35 99
- freelist header
- Lesson III Slide 17 of 27
- scenario 3. a) Trazimo blok 18, nije u kesu, ali 3 i 5
- moraju da se upisu na disk
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5delay 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3delay 35 99
- freelist header
- Lesson III Slide 18 of 27
- cenario 3. b) Blokovi 3 i 5 se upisuju a prvi
- slobodni se dodeljuje za 18, a to je 4
- hash queue headers
- block number 0 mod 4 28 64
- block number 1 mod 4 17 5-write 97
- block number 2 mod 4 98 50 10 18
- block number 3 mod 4 3-write 35 99
- freelist header
- Lesson III Slide 19 of 27
- scenario 4. a) Trazimo blok 18, nije u kesu, nema
- ni jednog slobodnog bloka
- free list je prazna
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3 35 99
- freelist header
- Proces mora otiüi na spavanje sve dok neko ne obavi algoritam brelse koji üe
- osloboditi bar jedan bafer.
- ak i da je u kesu hit, proces mora na spavanje.
- Lesson III Slide 20 of 27
- scenario 5. a) Trazimo blok 99, u kesu je,
- ali je trenutno zauzet (locked)
- Proces mora da eka da blok bude osloboen.
- hash queue headers
- block number 0 mod 4 28 4 64
- block number 1 mod 4 17 5 97
- block number 2 mod 4 98 50 10
- block number 3 mod 4 3 35 99
- busy
- freelist header
- Lesson III Slide 21 of 27
- itanje i upis kroz bafer bread
- Algoritam za itanje je bread.
- Kod njega su 2 glavne karaktersitike, a cache hit i cache miss.
- algorthm bread() /* block */
- input: file system block number
- output: buffer containing data
- {
- get buffer for block (algorithm getblk);
- if (buffer data valid) return (buffer); /*hit*/
- else
- initiate disk read; /*miss*/
- sleep (event disk read complete);
- return (buffer);
- }
- Lesson III Slide 22 of 27
- read-ahead (breada)
- Za poveüanje performansi koristi se read-ahead tehnika:
- algoritam breada /* block read and read ahead*/
- input:
- (1) file system block number for immediate read
- (2) file system block number for asynchronous read
- output: buffer containing data for immediate read
- {
- if (first block not in the cache) /*cache miss*/
- {
- get buffer for first block (algorithm getblk);
- if (buffer data not valid) initiate disk read;
- }
- if (second block not in the cache)
- {
- get buffer for second block (algorithm getblk);
- if (buffer data valid) release buffer (algorithm brelse)
- else initiate disk read;
- }
- Lesson III Slide 23 of 27
- read-ahead (breada)
- if (first block was originally in the cache)
- {
- read first block (algorithm bread);
- return buffer;
- }
- sleep (event first buffer contains valid data)
- return buffer
- }/*main*/
- miss (2 read=read normal + read ahead)
- Ako prvi blok nije u kesu odvija se sinhrono disk itanje sa sleep-om,
- a ako je u kesu zadaje je neposredno prosleivanje bafera.
- Odmah se obavlja asinhroni read-ahead, proveri se da li je sledeüi
- sekvencijalni blok u kesu.
- Ako jeste nikom nista, ali ako nije nae se blok u kesu (getblk) i ako je
- dodeljeni bafer prazan, inicira se asinhrono disk itanje.
- hit (no disk reading)
- Ako dodeljeni bafer veü ima validne podatke read-ahead se ne izvrsava,
- veü se bafer otpusta (to je hit za read-ahead).
- Lesson III Slide 24 of 27
- upis kroz bafer (bwrite)
- Algoritam za upis je bwrite. 2 glavne karaktersitike, cache hit i cache miss.
- algorthm bwrite() /* block */
- input: buffer to be written
- output: none
- {
- initiate disk write; /* ovaj I/O mozda se obavlja ili sihrono ili delayed */
- if(I/O synchronous)
- {
- sleep (event I/O complete)
- release buffer (algorithm brelse);
- }
- else if (buffer marked for delayed write);
- mark buffer to put at head of free list;
- }
- Lesson III Slide 25 of 27
- upis kroz bafer (bwrite)
- Pretpostavimo da je upis hit(in_cache) i kernel daje nalog za upis na disk.
- Taj nalog moze biti sinhroni i DW.
- Ako je sinhroni write, kernel upisuje blok na disk i eka da se I/O zavrsi.
- Ako delayed write, to se markira za taj bafer i ne vrsi se I/O, a bafer se
- osloboa.
- Upis se inicira u getblk algoritmu po scenariju 3 kada je DW blok u free listi, a
- dodeljen je novi blok iz free liste.
- Ti DW baferi se iniciraju za write, odnosno praznjenje.
- DW blokovi se potiskuju na poetak free liste kako bi se praznili na svaki kes
- miss.
- Lesson III Slide 26 of 27
- Prednosti i nedostaci baferskog kesa
- Prednosti:
- Smanjuje disk trafic
- DW je izrazita prednost
- kes je kernelska memorija koja je zastiüena i dobro sinhronizovana,
- nije podlozna programerskim ili korisnikim greskama
- Nedostaci:
- meutransfer, sa diska u kes, pa u user buffer
- DW moze dovesti do gubitka podataka, sto se ublazava sa
- journaling tehnikom
- Lesson III Slide 27 of 27
- PREDAVANJE 4:
- Svaka datoteka na UNIX sistemu ima jedinstveni inode,
- inode sadrži sve informacije potrebne da odrede prava pristupa datoteci, kao što su vlasništvo, prava pristupa, veličina datoteke, lokacija datoteke na disku.
- Procesi pristupaju datoteci preko jasno definisanog skupa sistemskih poziva.
- Algoritmi koje obrađujemo se nalaze na nivou iznad baferskog keša.
- To su:
- iget: vraća vrednost prethodno identifikovanog inoda, (moguće je čitanje iz inode tabele preko baferskog keša)
- iput: otpušta inode
- bmap: postavlja kernelske parametre za pristupanje datoteci
- namei: konvertuje ime datoteke u inode koristeći algoritme iget, iput i bmap.
- alloc i free alociraju i oslobađaju slobodne disk blokove za datoteku
- ialloc i ifree alociraju i oslobađaju slobodne inode-ove za datoteke
- INODES
- Definicija:
- struktura koja potpuno opisuje datoteku
- sve osim imena
- Postoje 2 strukture:
- -disk inode
- to su inodes u statičkoj formi na disku (in inode table)
- pasive files
- -in-core inode.
- disk inode kernel čita u memorijsku strukturu koja se naziva nazvati in-core inode
- active files
- Disk inode se sastoji od sledećih polja:
- vlasništvo se deli na 2 komponente, na korisničko vlasništvo i grupno vlasništvo i ta dva identifikatora određuju vlasničke odnose grupe prema datoteci
- vlasnik datoteke (UID identifikator).
- grupa kojoj pripada datoteka (GID identifikator)
- tip datoteke: datoteka može biti regularna, direktorijum, karakter ili blok specijalna datoteka, FIFO (pipe)
- prava pristupa za datoteku: definišu se preko
- 3 vlasničke kategorije (owner, group, other)
- 3 prava pristupa za njih (read, write, execute) koja imaju precizno značenje, a nezavisno se deklarišu
- vremena pristupa datoteke: ima 3 karakteristična vremena (vreme poslednje modifikacije, vreme poslednjeg pristupa, i vreme kad je inode poslednji put modifikovan)
- broj linkova na datoteku: predstavlja broj različitih imena za isti prostor na disku
- tabela koja opisuje alokaciju datoteke na disku
- veličina datoteke
- Inode ne opisuje path imena već svaka path komponenta ima poseban inode.
- U ovom primeru imamo regularnu datoteku veličine 6030 bajtova čiji je vlasnik user mjb sa pravima pristupa rwx, datoteka pripada grupi os i svi članovi grupe imaju r i x pravo bez w prava, dok svi ostali useri imaju r i x pravo bez w prava. Poslednji put je neko pristupao i to samo čitao datoteku 23. oktobra 2004 u 1:45 PM, a posledni put je neko upisao nešto u datoteku 22. oktobra 2004 u 10:30 AM. Inode je promenjen zadnji put 23. oktobra u 1:30 PM.
- Postoji razlika između upisa u datoteku i upisa u inode, svaka promena u datoteci se reflektuje u inode, dok postoje promene koje idu samo u inode a nemaju veze sa upisom datoteku, kao što je promena vlasništva, grupe, prava pristupa ili link setovanje.
- n-core inode sadrži dodatne informacije u odnosu na polja disk inode::
- Status in-core inoda koji pokazuje:
- da li inode zaključan (locked)
- da li proces čeka da inode postane otključan (unlocked)
- da li se in-core inode razlikuje od svoje disk kopije kao rezultat promene polja u inode
- da li se in-core inode razlikuje od svoje disk kopije kao rezultat promene podataka u datoteci
- da li je ta datoteka postala mountpoint
- FS descriptor(opis FS): u vidu logičkog broja koji sadrži tu datoteku, odnosno iz kog FS je taj inode
- inode broj: in-core inode poseduje i ovo polje zato što na disku se pozicija inode određuje u polju fiksnog formata, zna se offset, a u memoriji polje nije fiksno i mora da se zna koji je inode u in-core tabeli
- ukazivači na druge in-core inodove. Kernel povezuje in-core inode-ove u hash queue liste i slobodne liste na sličan način kao kod baferskog keširanja. Hash queue se idetifikuje na osnovu FS i inoda broja. Kernel sadrži najviše jednu kopiju disk inoda, a ona može biti ili u hash queue ili u slobodnoj listi.
- broj referenci, pokazuje broj aktivnih instanci na tu datoteku, broj procesa koji su otvorili datoteku, odnosno taj inode
- Mnoga polja u in-core(inode) su analogna poljima u baferskom zaglavlju
- upravljanje incore inodovima je slično kao i kod baferskog keša.
- Kada se inode zaključa, ostali procesi ne mogu da ga otvore, a ostali procesi postave svoje flagove da su zainteresovani za taj inode i da ih treba probuditi kada se inode otključa.
- Kernel postavlja i druge flagove koji ukazuju na razliku između disk inode i njegove in-core kopije, kako bi na bazi tih flagova sravnjuje(destage) stanje inoda na disku.
- Najveća razlika između incore inoda i bafer zaglavlja je u broju referenci za in-core inode koga uopšte nema kod baferskog keš zaglavlja.
- Svaki proces koji pristupa in-core inodu povećava mu reference count
- inode može biti u free listi samo ako je RC=0.
- Samo takav inode može napustiti in-core,
- dok kod baferskog keša, bafer je free listi samo ako je otključan (unlocked)
- algorithm iget
- input: file system and inode number
- output: locked inode
- {
- while(not done)
- {
- if(inode in inode cache) /* if #1*/ /*in-core hit*/
- {
- if(inode locked) /* if #2*/
- {
- sleep (event inode becomes unlocked);
- continue; /* loop back to while*/
- }/* if #2*/
- }/*if #1*/
- /*special processing for mount point directory*/
- if(inode on inode free list) remove from free list; #if inode on the free list, incore inode used by no processes
- increment inode reference count;
- return (inode);
- /* inode not in inode cache*/ /*in-core miss*/
- if(no inodes on free list) return(error) #table is full, no chance
- #creation of new incore inode
- remove new inode from free list; # in inode cache
- reset inode number in free list; # in inode cache
- remove inode from old hash queue, place on new one;
- read inode from disk(algorithm bread);
- initialize inode (eg. reference count to 1) (RC=1)
- return(inode)
- }/*while*/
- }/*main*/
- Pristupanje inodovima
- Kernel identifikuje partikularni inode preko:
- FS number
- inode number
- a alocira incore inode preko iget algoritma koji veoma podseća na getblk algoritam.
- Kernel mapira FS broj i inode broj u hash queue i traži inode u odgovarajući hash queue.
- Moguće su 2 situacije:
- in-core hit: RC++; lock of inode;
- in-core miss
- Ako ne može da ga nađe, alocira slobodan inode iz free liste, lockuje ga i počinje čitanje disk inode u svoju in-core kopiju.
- Pristupanje disk-inode-ovima:
- disk inode se određuje prema formuli:
- block num=
- ((inode number - 1 )/ number of inodes per block)
- +
- start block of inode list)
- taj blok se čita pomoću algoritma bread.
- Kako je inode tipična struktura od 64 ili 128 bajtova, offset unutar bloka se određuje:
- offset =
- ((inode number - 1 ) % number of inodes per block))
- * size of disk inode
- Kernel manipulira sa inode lock i RC nezavisno.
- Kernel lock inode svaki put kad treba da zaštiti inode od drugih procesa,
- Reference Count (RC)
- svaki open SC povećava RC,
- svaki close SC dekrementira RC.
- Nikada se inode ne lockuje sa posebnim SC,
- lock i unlock of inode se obavljaju u toku SC
- (iget: lock by iget, unlock by status field in incore),
- (iput: lock and unlock by iput)
- Kada kernel oslobađa inode,
- prvo se dekrementira incore RC za taj inode.
- Ako RC padne na 0,
- kernel upisuje incore inode na disk inode samo ako ima promena.
- incore inode ide u free listu.
- ako i LC padne na 0, kernel takođe može oslobadja blokove podataka datoteke (brisanje)
- Incore inode je i dalje tu (u kešu) ali se može izbaciti ako nema više mesta u inode cache memoriji.
- IPUT
- algorithm iput /* access to in core inode*/
- input: pointer to incore inode
- output: none
- {
- lock inode if not already locked;
- decrement inode reference count; RC- -;
- if(reference count == 0)
- {
- if(link count == 0) {
- free disk blocks for file (algorithm free);
- set file type to 0;
- free inode (algorithm ifree) }
- if (file accessed or inode changed or file changed) update disk inode;
- put inode on free list;
- } /*RC is not 0*/
- release inode lock;
- }/*main*/
- Struktura regularne datoteke
- Svaki blok na disku ima unikatnu adresu, i može pripadati samo jednoj datoteci.
- Svi blokovi koji pripadaju datoteci moraju se naći u inodu te datoteke.
- Da bi inode imao malu veličinu, ali da bi mogao opisivati efikasno i male ali i veoma velike datoteke, koriste se inode šema uvedena na UNIX System V na primer sa 13 ulaza.
- Broj ulaza može biti proizvoljan kao i broj stepena indirekcije.
- File max
- Sa 32 bitnim pointerima, 1K blokovima = 256 pointers per block
- 10 direct blocks with 1K bytes each = 10K bytes
- 1indirect block with 256 direct blocks = 256K bytes
- 1double indirect block with 256 indirect blocks = 64M bytes
- 1triple indirect block with 256 double indirect blocks= 16G bytes
- algorithm bmap
- /*block map of logical file byte offset to file system block*/
- byte offset ->FS block
- algorithm bmap
- input:
- (1) inode
- (2) byte offset
- output:
- (1) block number in file system
- (2) byte offset into block
- (3) bytes of I/O in block
- (4) read ahead block number
- {
- calculate logical block number in file from byte offset; (byte_offset/1K)
- calculate start byte in block for I/O; (byte_offset%1K) /* output 2*/
- calculate number of bytes to copy to user; /* output 3*/
- check if read – ahead applicable, mark inode; /*output 4/*
- determine level of indirection;
- while (not at necessary level of indirection)
- {
- calculate index into inode or indirect block from logical block number in file;
- get disk block number from inode or indirect block;
- release buffer from previous disk read, if any (algorithm brelse);
- if (no more levels of indirections) return(block number);
- read indirect disk block (algorithm bread)
- adjust logical block in file according to level of indirection;
- }
- }
- Moguće su 0 u pointerima,
- to znači da proces nije nikada ništa upisao na tom offsetu i
- ti blokovi ostaju na 0, tj sadrže 0-le
- a ne troše prostor na disku.
- BSD uvodi veće sistemske blokove 4K, 8K i
- uvodi pojam block/fragment,
- gde jedan sistemski blok može sadržavati fragmente
- koji pripadaju različitim datotekama.
- To zahteva modifikaciju inode strukture.
- Direktorijumi
- To su specijalne datoteke koje imaju značajne uloge za UNIX stablo.
- Sastoje se od specijalnh struktura FCB,
- od kojih svaka odgovara jednoj datoteci, a
- sadrže ime datoteke i inode koji joj pripada.
- UNIX System V ima maksimum 14 bajtova za ime i 2 bajta za inode.
- Evo jednog isečka etc direktorijuma:
- prvi ulaz . predstavlja sam taj direktorijum, drugi ulaz .. odgovara roditelskoj grani, ostalo su grane i datoteke
- Mada se direktorijumi tretiraju kao datoteke,
- kernel ne dozvoljava direktan upis u direktorijume
- upis u diride preko SC poziva, creat, mknod, link i unlink SC.
- Program mkfs kreira root direktorijum koji ima 2 ulaza . i .. koji dele isti inode i to je root direktorijum.
- Inicijalni pristup datoteci se odvija preko njenog path imena u SC kao što su open, chdir ili link.
- Kernel interno radi sa inodovima, radije nego sa path imenima, (ovo su brojevi, a ovo su imena različitih veličina).
- Algoritam namei konvertuje path imena u inodove preko kojih se pristupa datoteci.
- Algoritam namei razbija pathname
- na jednu pojedinačnu komponentu iz imena
- u jednom trenutku,
- konvertujući to ime u njegov inode,
- tako što nalazi FCB tog imena u roditeljskom direktorijumu.
- Svaki proces ima svoj tekući direktorijum čiji se inode upisuje u u-area za taj proces.
- Proces dobija tekući direktorijum od svog procesa roditelja, a može ga promeniti preko chdir SC.
- Sve path komponente startuju od tekućeg direktorijuma, osim ako nemaju leading /, koji ukazuju da sve počinje od root direktorijuma.
- Kernel to zna da identifikuje, a u-area sadrži tekući direktorijum
- dok se root inode čuva u globalnoj varijabli.
- Algoritam namei koristi među-inodove ili srednje inodove ili working inodove, a ima iterativnu petlju u čijem svakom prolazu se analizira jedna grana, za koju user mora imati r i x pravo.
- Svaki proces ima svoj tekući direktorijum čiji se inode upisuje u u-area za taj proces.
- Proces dobija tekući direktorijum od svog procesa roditelja, a može ga promeniti preko chdir SC.
- Sve path komponente startuju od tekućeg direktorijuma, osim ako nemaju leading /, koji ukazuju da sve počinje od root direktorijuma.
- Kernel to zna da identifikuje, a u-area sadrži tekući direktorijum
- dok se root inode čuva u globalnoj varijabli.
- Algoritam namei koristi među-inodove ili srednje inodove ili working inodove, a ima iterativnu petlju u čijem svakom prolazu se analizira jedna grana, za koju user mora imati r i x pravo.
- algorithm namei /* convert path name to inode*/
- input: path name
- output: locked inode = locked incore inode)
- {
- if (path name starts from root)
- working inode = root inode (algorithm iget);
- else
- working inode = current directory inode (algorithm iget);
- while (there is more path name)
- {
- read next path name component from input;
- verify that working inode is of directory, access permissions OK;
- if (working inode is of root and component is “..”) continue;
- /*loop back to while*/
- read directory (working inode)
- by repeated use of algorithms bmap, bread and brelse
- if (component matches an entry in directory (working inode))
- {
- get inode number for matched component;
- release working inode (algorithm iput);
- working inode = inode of matched component (algorithm iget)
- }
- else
- return (no inode);
- }/* while */
- return (working inode);
- }
- namei
- Kernel obavlja linearno pretraživanje datoteka
- koje se nalaze u working inodu,
- pokušavajući da nađu sledeću path komponentu,
- startujući u offsetu 0,
- Preko bmap se određuje blok na disku
- koji se čita preko bread,
- a kada se blok dobije on se otpušta preko brelse.
- Potom se direktorijumski blok pretražuje za path komponentu i
- ako je nađe iz FCB se dobija njen inode,
- a oslobađa se stari working inode,
- uzima novi sa iget.
- Ako ne nađe podudarenje,
- mora pročitati sve direktorijumske blokove dok ne nađe FCB,
- a može se dogoditi slučaj da ga uopšte ne nađe.
- Super Block
- Superblock se sastoji od sledećih polja:
- veličina FS
- broj slobodnih blokova u FS
- lista slobodnih blokova raspoloživih u FS
- Index/ukazivač na sledeći slobodan blok u free block listi
- veličina inode tabele
- broj slobodnih inodova u FS
- lista slobodnih inodova raspoloživih u FS
- index/ukazivač na sledeći slobodan inode u free inode listi
- lock polja za liste slobodnih blokova i za liste slobodnih inodova
- dirty flag koji ukazuju da je superblock modifikovan i da mora da se sravni sa disk super-blokom
- Dodeljivanje inoda za novu datoteku
- Algoritam ialloc obavlja dodeljivanje disk inoda za novo kreiranu datoteku.
- FS sadrži linearnu listu inodova, a inode je slobodan ako je njegov sadržaj nula.
- Kada se kreira nova datoteka mora se naći slobodan inode,
- a to zahteva intenzivno pretraživanje inode tabele što može dugo da traje zbog višestrukih disk čitanja.
- Da bi se to ubrzalo, superblock sadrži keširano polje koje sadrži listu slobodnih inodova.
- ialloc
- algorithm ialloc /* allocate inode */
- input: FS
- output: locked inode
- {
- while (not done) {
- if (super block locked)
- { sleep (event super block becomes free); continue; /*loop back to while*/ }
- if (inode list in superblock is empty) /*empty SB list*/
- { lock super block;
- get remembered inode for free inode search;
- search disk for free inodes until super block full, or no more free inodes
- (algorithms bread i brelse)
- unlock superblock; wake up (event superblock becomes free);
- if(no free inodes found on disk) return(no inode);
- set remembered inode for next free inode search; }
- /* there are inode in superblock inode list*/
- get inode number from super block list;
- get inode (algorithm iget);
- if(inode not free after all) /* !!! */
- {
- write inode to disk;
- release inode (algorithm iput);
- continue /* while loop*/
- }
- /* inode is free*/
- initialize inode;
- write inode to disk;
- decrement FS free inode count;
- return(inode);
- }/* while */
- }
- Kernel prvo mora da proveri da li je superblock locked,
- jer se u njemu nalazi free inode lista.
- Ako lista nije prazna, kernel uzima sledeći inode,
- alocira novi in-core inode (algoritam iget),
- popunjava oba inodes (disk inode i in-core inode) i
- vraća locked inode.
- Ako je superblock lista prazna,
- kernel mora čitati inode tabelu sa diska i
- popuniti superblock listu,
- naravno pamteći koji je zadnji inode detektovao i
- koji je to blok tabele zadnji čitao,
- da bi sledeći put ponovo čitao
- (remembered inode, remembered block).
- ifree
- Algoritam za oslobađanje inode je mnogo jednostavniji.
- algorithm ifree /* inode free */
- input: FS, inode number
- output: none
- {
- increment FS free inode count;
- if (super block locked) return;
- if (inode list full)
- {
- if( inode number less than remebered inode for search)
- set remebered inode for search = input inode number;
- }
- else
- store inode number in inode list;
- return;
- }
- Pravila:
- lista je sređena po opadajućim brojevima, osetno je manja nego inode tabela.
- sadrži svoje ulaze koji se indeksiraju od najvišeg do najnižeg
- poslednji inode (index 1) uvek predstavlja zapamćeni inode (remembered)
- u slučaju potpuno prazne liste (svi inodes free) ako se pojavi novi free inode, doći će do promene na head tabele samo ako je novi inode manji od zapamćenog u protivnom se ne ubacuje u listu.
- Alokacije disk blokova
- Svakoj datoteci mora biti prvo dodeljen blok iz liste slobodnih blokova,
- a svi njeni dodeljeni blokovi se upisuju u inode u direktne i indirektne ukazivače.
- In-core superblok sadrži ograničenu listu slobodnih blokova sa ukazivačem na blokove na disku koje sadrže listu sledećih blokova.
- Kada kernel želi da dodeli blok iz FS,
- kernel prvo analizira keširanu listu iz superbloka i
- uzima prvi slobodan blok.
- Samo ako je to zadnji slobodan blok iz superblok keša,
- tada se prelazi na listu sa diska,
- čita se blok iz linkovane liste i popunjava superblok free list keš
- iz koga se uzima prvi slobodan blok,
- kome se dodeljuje mesto u kešu (getblk) i puni se nulama.
- Program mkfs i se trudi da liste slobodnih blokova sadži blokove sa sličnim adresama, naravno iz razloga performansi.
- Međutim, ta harmonija se brzo narušava jer se free blokovi često izbacuju i vraćaju u listu sasvim slučajno.
- Kernel pokušava povremeno da sortira free liste.
- alloc
- algorithm alloc /* FS block allocation*/
- input: FS number
- output: buffer for new block {
- while (super block locked) sleep (event super block not locked);
- remove block from super block free list;
- if (removed last block from free list)
- {
- lock superblock;
- read block just taken from free list (algorithm bread);
- copy block numbers in block into super block;
- release block buffer (algorithm brelse);
- unlock superblock;
- wakeup processes (event superblock not locked);
- }
- /* cache buffer allocation*/
- get buffer for block removed from superblock list (algorithm getblk);
- zero buffer contents;
- decrement total count of free blocks;
- mark superblock modified;
- return buffer;
- }
- Program mkfs kreira ovu linkovanu listu of free blocks čiji je početak u superblocku.
- free
- Algoritam free radi povratak bloka u free listu.
- Ako keširana superblok lista nije puna,
- blok se umeće u keširanu superblok listu.
- Ako je puna,
- lista se upisuje u neki blok na disku
- blok se stavlja u linkovanu listu,
- superblok lista postaje prazna
- u nju se smešta novo-oslobođeni blok.
- Veoma je zanimljivo primetiti da se linkovane liste ne primenju za slobodne inodove.
- Ima 3 glavna razloga za drukčiji tretman blok free listi i inode free listi:
- Kernel može odrediti da li je inode slobodan ispitivanjem njegovog sadržaja, ako type polje slobodno i inode je slobodan. Međutim, nema nikakvog načina da se odredi da li je blok slobodan ili nije na osnovu njegovog sadržaja. Zato, podrška cele free liste za blokove neophodna.
- Disk blokovi su veoma povoljni za povezane liste zato što jedan disk blok može sadržati veliki broj pointera na slobodne blokove. Na drugoj strani mnogo je veći broj blokova nego broj inodova.
- Procesi mnogo više teže da koriste slobodne blokove nego slobodne inodove, tako da je mnogo bitnije optimizovati performanse za liste slobodnih blokova nego za inode liste.
- UNIX sistem podržava još 2 tipa datoteka:
- pipe
- specijalne datoteke.
- Pipe datoteka koja se zove još i FIFO razlikuje se od obične datoteke po tranzijentnim podacima:
- kada se podaci jedanput pročitaju iz pipe datoteke, ne mogu se ponovo pročitati,
- takođe podaci se čitaju onim redosledom kojim u upisivani,
- nema promene poretka.
- Kernel upisuje pipe datoteku na disk na isti način kao i obične s tim što korisiti isključivo direktne pointere a ne indirektne.
- Specijalne datoteke su
- blok specijalne
- karakter specijalne datoteke
- koji specificraju uređaje i njihov inode ne ukazuje na nikakve podatke na disku, već njihov inode sadrži 2 broja: major i minor number.
- major broj selektuje klasu uređaja kao što je disk
- minor broj ukazuje uređaj unutar klase.
- SC za postojeće datoteke:
- open
- read
- write
- lseek
- close
- SC za kreiranje novih datoteka kao što su:
- creat
- mknod
- SC koji manipulišu inodovima i FS kao celinom kao što su:
- chdir, chroot, chown, chmod, stat, fsstat
- advanced SC:
- pipe and dup koji su značajni za implementaciju pipeline komandi u shell-u.
- mount i umount SC
- link i unlink SC
- Uvešćemo kernelske strukture podataka:
- FT (file table)
- UFDT (user file descriptor table)
- MT (mount table)
- SC za postojeće datoteke
- open
- read
- write
- lseek
- close
- SC za kreiranje novih datoteka kao što su:
- creat
- mknod
- SC koji manipulišu inodovima i FS kao celinom kao što su:
- chdir, chroot, chown, chmod, stat, fstat
- SC se mogu klasifikovati u sledeće kategorije:
- SC koji vraćaju fajl deskriptore koje mogu da koriste drugi SC
- SC koji koriste namei algoritam da razbija path name do inode
- SC koji dodeljuju i oslobađaju inodove preko algoritama ialloc i ifree
- SC koji setuju ili menjaju atribute datoteke
- SC koji obavljaju I/O operacije preko algoritama alloc, free i baferskih alokacionih algoritama
- SC koji menjaju strukturu FS
- SC koji omogućavaju procesu da promeni svoj izgled stabla
- Open je SC je prvi korak koji proces mora obaviti da bi pristupio datoteci.
- Sintaksa za open SC je:
- fd = open(pathname, flags, modes)
- pathname ime datoteke,
- flags ukazuju na tipove otvaranja (za čitanje ili upis)
- modes daje ACL ako se datoteka kreira
- SC open daje jedan integer fd koji se naziva user file descriptor i koji se kasnije koristi za druge file operacije kao što su:
- reading
- writing
- seeking
- duplicating of file descriptors
- setting a file I/O parameters
- određivanje file statusa
- zatvaranje datoteke
- algorithm open
- inputs: {filename, type of open, file permissions (for creation type of open)}
- output: file descriptor
- {
- convert file name to inode (algorithm namei) #iget produce in-core inode
- if(file does not exist or not permitted access) return(error);
- allocate file table entry for inode, initialize count, offset; #FT
- allocate user file descriptor entry, set pointer to file table entry; #UFTD
- if (type of open specifies truncate file) free all file blocks (algorithm free)
- unlock(inode);
- return(user file descriptor);
- }
- Kernel pretražuje FS za zadatu datoteku preko algoritma namei,
- koji ako nađe datoteku kroz sve path grane
- proverava ACL
- otvara inode u memoriju, kreira in-core inode
- open SC otvara jedan ulaz u FT za tu otvorenu datoteku.
- Taj ulaz u FT sadrži sledeće informacije:
- pointer na in-core inode
- offset gde kernel očekuje da bude sledeći upis ili čitanje iz datoteke.
- Ovo polje kernel prilikom open SC postavlja na 0, a kasnije akcije sa datotekom ga modifikuju.
- Proces može otvoriti datoteku u write-append modu u kom slučaju kernel inicijalizuje offset na kraj datoteke = filesize.
- Pored globalne FT, kernel preko u-area inicijalizuje i UFDT, a pointer na UFDT postavlja u u-area. Naravno da UFDT mora ukazivati na datoteku u FT.
- Pretpostavimo da se dogode 3 open SC:
- fd1= open("/etc/passwd", O_RDONLY)
- fd2 = open("/etc/local", O_RDWR)
- fd3 = open("/etc/passwd", O_WRONLY)
- Svaki openSC vraća poseban FD procesu u odgovarajući ulaz u UFDT koji ukazuje na odgovarajući ulaz u FT i u slučaju da je datoteka otvorena više puta. Sve otvorene instance za istu datoteku ukazuju na jedinstveni in-core inode.
- Pretpostavimo da drugi proces B izvršava sledeći kod:
- fd1= open("/etc/passwd", O_RDONLY)
- fd2 = open("private", O_RDONLY)
- FT v UFDT
- Opet a slike vidimo da svaki open ima
- jedinstveni ulaz u UFDT za proces
- jedinstveni ulaz u kernelovoj FT
- a samo jedan in-core inode za svaku otvorenu datoteku.
- UFDT ulazi bi mogli da sadrže
- offset za sledeće file I/O operacije i
- pointer na in-core inode,
- tako da FT ne bi trebalo da postoji,
- međutimFT prisustvo je opravdano jer omogućava
- deljenje file descriptora fd
- deljenje pointera
- što se koristi u dup i fork SC.
- Prva 3 korisnička fd su (0, 1 i 2) i predstavljaju:
- standarni ulaz stdin
- standarni izlaz stdout
- izlaz za greške stderr
- Sintaksa za read SC je:
- number = read(fd, buffer, count)
- pri čemu je:
- fd file descriptor dobijen od open SC
- buffer je adresa memorijskog bafera koje je proces dobio za čitanje
- count je broj bajtova koji se čita iz datoteke
- number je broj koji se upravo pročitao preko ovog read SC
- algorirthm read
- inputs:
- {user file descriptor, address of buffer in user process, number of byte to be read }
- output: count of bytes copied into user space
- {
- get file table entry from user file descriptor;
- check file accessibility;
- set parameters in u area for user address, byte count, I/O to user;
- get inode from FT; #in-core inode
- lock inode;
- set byte offset in u-area from file table offset;
- while (count not satisfied)
- {
- convert file offset to disk block (algorithm bmap)
- calculate offset into block, number of byte to read;
- if (number of bytes to read is 0) break; /* end of file*/
- read block (algorithm breada if with read ahead, bread otherwise);
- copy data from system buffer to user address;
- update u area fields for file
- byte offset,
- read count,
- address to write into user space
- release buffer /* locked in bread*/
- }
- unlock inode;
- update FT offset for next read;
- return (total number of bytes read);
- }
- Kernel prvo na bazi fd uzima ulaz UFTD. Tada se setuju I/O parametri u u-arei, konkretno kod read SC poziva, se postavlja da je read I/O, count i postavlja se user bafer adresa, a iz njega čita ulaz u FT, iz koga se dobija offset u file koji se takođe setuje u u-arei.
- Polja koja se postavljaju u u-arei su:
- Pored offseta, kernel iz FT čita ukazivač na in-core inode, pronalazi taj inode, lock-uje ga i počinje kroz keš da čita datoteku.
- Čitanje se odvija u petlji na sledeći način:
- na bazi offseta se određuje broj bloka preko algoritma bmap
- blok se čita u keš preko bread algoritma
- modifikuju se polja u u-arei, count i offset
- petlja se ponavlja sve dok se ne pročita zahtevani broj bajtova
- Na kraju se setuje novi offset za datoteku u FT, koji se može sa lseek() SC modifikovati
- #include <fcntl.h>
- main()
- {
- int fd;
- char litlbuf[20], bigbuf[1024];
- fd = open("/etc/passwd", O_RDONLY);
- read (fd, litlbuf, 20);
- read (fd, bigbuf, 1024);
- read (fd, litlbuf, 20);
- }
- Prvi open će otvoriti datoteku i postavti offset na 0.
- Prvi read će pročitati 20 bajtova i postaviti ofset na 20. Naravno u keš ide 1K, a iz keša 20 bajtova. U u-arei se setuje count=0 (read je zadovoljen), offset 20, a potom se ukupan broj pročitanih bajtova setuje na 20.
- Drugi read čita 1K ali u offsetu 20, i skoro sve je u kešu (ako je malo vremena proteklo između prvog i drugog read-a) ali tu ima samo 1004 potrebna podatka, opet se ide na inode na sledeći direktni blok, pa se sa diska čita sledeći blok datoteke i u kešu se nalaze 2 bloka datoteke. U bigbuf se u 2 iteracije prebacuju 1024 bajta, offset = 1044.
- Treći read čita 20 bajta na ofsetu 1044 koji je u kešu (najverovatnije) i postavlja finalni offset na 1064.
- Kernel će na bazi read count-a da proceni da li da radi bread ili breada.
- Ukoliko vrednost pointera inodu = 0, tada nema čitanja sa diska već se korisnički bafer puni nulama (sparse file)
- Inode je locked dok traje read, jer bi moglo doći do inkonzistenicje podataka.
- Pored toga uvodi se pojam lock-ovanja file/record, da vi obezbedila konzistentnost podataka
- kao u primeru gde su 2 procesa, koja su istovremeno otvorila istu datoteku, a jedan ima 2 read-a a drugi 2 write.
- Šta će da pročitati prvi proces, zavisi od redosleda rd1, rd2, wr1, wr2 ili rd1, wr1, rd2, wr2, ili rd, wr1, wr2, rd2. Zato se pored otvaranja datoteke uvodi lock na record, tako da jedan proces ne može otvoriti locked file.
- #include <fcntl.h>
- /*process A*/
- main()
- {
- int fd; char buf[512];
- fd = open("/etc/passwd", O_RDONLY)
- read (fd, buf, sizeof(buf)) /*read 1*/
- read (fd, buf, sizeof(buf)) /*read 2*/
- }
- /*process B*/
- main()
- {
- int fd,i; char buf[512];
- for (i=0; i<sizeof(buf); i++) buf[i] = ‘a’;
- fd = open("/etc/passwd", O_WRONLY)
- write (fd, buf, sizeof(buf)) /*write 1*/
- write (fd, buf, sizeof(buf)) /*write 2*/
- }
- Na sledećem primeru proces može otvoriti datoteku 2 puta i čitati je preko 2 različita deskriptora sa nezavisnim file offsetima.
- #include <fcntl.h>
- main()
- {
- int fd1, fd2;
- char buf1[512], buf2[512];
- fd1 = open("/etc/passwd", O_RDONLY)
- fd2 = open("/etc/passwd", O_RDONLY)
- read (fd1, buf1, sizeof(buf1)) /*read 1*/
- read (fd2, buf2, sizeof(buf2)) /*read 2*/
- }
- Sintaksa za write SC je:
- number = write(fd, buffer, count)
- pri čemu su parametri isti ako za read SC
- fd file descriptor dobijen od open SC
- buffer je adresa memorijskog bafera koje je proces dobio za upis
- count je broj bajtova koji se upisuje u datoteku
- number je broj koji se upravo upisan preko ovog read SC
- Algoritam za write SC je sličan algoritmu za read SC,
- izuzev ako datoteka ne sadrži blok koji odgovara file offsetu za upis,
- tada kernel alocira novi blok preko algoritma alloc i
- podešava inode.
- Ako je file offset odgovara indirektnom bloku, kernel mora dodeliti više blokova koji će se koristiti za indirektne i data blokove.
- Inode is locked za vreme write(SC), zato što kernel može promeniti inode u toku write SC. Kada se upis završi, kernel ažurira inode pointere i filesize polje ako je došlo do promene veličine.
- Kada kernel obavlja upis, dešava se kao kod read ciklusa pri čemu su moguće sledeće situacije.
- Jedna potencijalna situacija je da se upisuje ceo blok u jednoj u iteraciji.
- Druga situacija je da se u nekoj iteraciji upisuje deo bloka, tada prvo blok mora da se učita u memoriju u keš blok, pa se prepiše deo bloka, a onda ceo blok se upisuje.
- Treća situacija je kada mora prvo da se alocira indirektni blok pa tek onda upis.
- Koriste se delayed write kroz kernelski keš koji je efikasan za pipe datoteke i i datoteke koje se privremeno kreiraju i čitaju se veoma skoro posle toga, kao što su privremene datoteke koje kreira editor teksta i briše ih. Dakle najveći uspeh se postiže za upis koji će živeti samo u kešu i nikada neće dostići disk.
- Originalni UNIX od Thomsona i Ritchija nije imao interni mehanizam koji obezbeđuje eksluzivni pristup datoteci. Locking mehamizam se nije koristio, jer kako kaže Ritchie, nisu imali na svom sistemu veliku bazu sa više nezavisnih procesa.
- Da bi UNIX prililižila database serverima, UNIX System V sadrži u sebi file i record locking mehanizam.
- file locking mehanizam zabranjuje pristup (r/w) datoteci ostalim procesima, osim tom jednom koji je lock-ovao datoteku
- record locking mehanizam zabranjuje pristup (r/w) recordu ostalim procesima, osim tom jednom koji je lock-ovao record.
- Record je logička celina u datoteci, može biti bilo koji deo datoteke, ima svoj offset i veličinu.
- Podešavanje pozicije u datoteci - lseek
- Obično korišćenje read i write SC obezbeđuje sekvencijalni pristup datoteci, dok lseek SC omogućava random pristup datoteci.
- Sintaksa za lseek SC je:
- position = lseek(fd, offset, reference)
- pri čemu su parametri:
- fd file descriptor dobijen od open SC
- offset je je relativni bajt offset
- reference ukazuje u odnosu na na šta je offset:
- u odnosu na početak datoteke (0)
- u odnosu na tekuću poziciju (1)
- u odnosu na kraj datoteke (2)
- position je offset u kome će sledeće čitanje ili upis da se dogode
- #include <fcntl.h>
- /*process A*/
- main(argc, argv)
- int argc
- char *argv[]
- {
- int fd, skval;
- char c;
- if (argc != 2) exit();
- fd = open(argv[1], O_RDONLY);
- if (fd == -1) exit();
- while ((skval = read(fd, &c, 1)) == 1)
- {
- printf("char %c\n",c)
- skval = lseek(fd, 1023L, 1);
- printf("new seek val %d \n",skval)
- }
- Program čita svaki 1024 bajt datoteke, tako što prvo pročita jedan bajt, onda obavi lseek za 1023. SC lseek praktično ne radi ništa sa diskom, on jednostavno podesi offset u FT, koji će se korisititi u sledećoj r/w instanci.
- close SC
- Proces zatvara otvorenu datoteku kada više ne želi da joj pristupa, preko close SC.
- Sintaksa za close SC je krajnje jednostavna:
- close(fd);
- Kernel obavlja close operaciju tako što obavi manipulacije u UFDT, FT i in-core inode.
- Ako je reference count u FT veći od 1, zbog dup ili fork SC, kernel će dekremenirati broj u FT.
- Ako taj broj posle dekrementa padne na 0, kernel oslobađa ulaz u FT i otpušta in-core inode (iput), originalno kreiran nakon open SC.
- Ako ostali procesi takođe koriste taj in-core inode, broj RC se dekrementira.
- Nakon toga se se briše ulaz u UFDT.
- Kada proces obavi exit(SC) sve njegove otvorene datoteke se moraju zatvoriti.
- Za in-core inode za private datoteku, RC pada na nulu čime se otpušta taj inode, /etc/passwd datoteku FC pada na 2, oslobađaju se 2 ulaza u FT koja su pripadala procesu B, a njegovi UFTD ulazi se anuliraju.
- viši SC
- fopen
- fprintf, fputc, fputs i fwrite koje upisuju podatke u datoteku (stream)
- fscanf, fgetc, fgets i fread koje ucitavaju podatke.
- Datoteka (stream) je predstavljena kao FILE* pokazivac. Kada otvorite datoteku sa fopen vi dobijate FILE* pokazivac. Kada zavrsite mozete je zatvoriti sa fclose.
- low-level SC
- Sa Linux-ovim operacijama nizeg nivoa, koristimo postupak nazvan deskriptor datoteke umesto FILE* pokazivaca.
- Deskriptor datoteke je celobrojna vrednost koja upucuje na odredjenu datoteku u pojedinacnom procedu.
- Moze biti otvoren za citanje, za pisanje ili i za citanje i za pisanje.
- Deskriptor datoteke ne mora da upucuje na otvorenu datoteku; moze predstavljati vezu sa drugom sistemskom komponentom koja moze da prima i salje podatke.
- SC open na Linux OS - flagovi
- fd=open (pathname, flags, modes)
- flags
- O_RDONLY, datoteka je otvorena samo za citanje
- O_WRONLY stvara da bude samo za upis.
- O_RDWR deskriptor datoteke se navodi da bude upotrebljena i za upis i za citanje.
- Mozete navesti dodatne funkcije koriscenjem bita operacija ili sa ovom vrednoscu sa jednim ili vise indikatora. Ovo su najcesce koriscene vrednosti:
- O_TRUNC da anulirate datoteku, ako prethodno postoji. Podatci upisani u deskriptor datoteke ce zameniti prethodni sadrzaj datoteke.
- O_APPEND da dodate u postojecu datoteku. Podatci upisani u deskriptor datoteke ce biti dodati na kraj datoteke.
- O_CREAT da kreirate novu datoteku. Ako ime datoteke koje navedete ne postoji, nova datoteka ce biti kreirana. Ako datoteka vec postoji, onda ce se samo otvoriti.
- O_EXCL sa O_CREAT da nasilno kreirate novu datoteku. Ako datoteka vec postoji, poziv open ce biti bezuspesan.
- SC open na Linux OS (modovi)
- Ako pozovete open sa O_CREAT, dodajte treci dodatni argument zadajuci dozvole za novu datoteku.
- Umasks
- Kada kreirate novu datoteku sa open, neki bitovi prava pristupa koje ste predhodno namestili mogu biti iskljuceni. To je zato sto je vasa umaska podesena na ne nulte vrednost. Procesov umask odredjuje bitove koji su maskirani van svih novokreiranih dozvola. Aktuelna koriscena prava prtistupa su nivoi bita i pristipna prava koja odredimo za otvaranje i nivoi bita dopunjeni sa umask.
- Da bi promenili vas umask iz komandnog interpretera, koristite umask komandu, i odredite numericku vrednost maske, u oktalnom sistemu. Da bi promenili umask za tekuci proces, koristite funkciju umask, prosledjujuci mu zeljenu vrednost kako bi je koristili za sledecu open funkciju.
- Na primer, pozivanjem ovog reda u programu
- umask (S_IRWXO | S_IWGRP);
- ili pozivajuci ovu komandu
- $ umask 027
- odredjujete dozvolu za pisanje za clanove grupe i citanje, pisanje i pristup drugima ce uvek biti maskiran van novih dozvola.
- (create-file.c) Kreiranje nove datoteke
- #include <fcntl.h>
- #include <stdio.h>
- #include <sys/stat.h>
- #include <sys/types.h>
- #include <unistd.h>
- int main (int argc, char* argv[])
- {
- /* Putanja gde ce se kreirati nova datoteka. */
- char* path = argv[1];
- /* Dozvole za novu datoteku. */
- mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
- /* Kreira datoteku. */
- int fd = open (path, O_WRONLY | O_EXCL | O_CREAT, mode);
- if (fd == -1) {
- /* Dolazi do greske. Ispisuje se poruka o gresci. */
- perror (“open”);
- return 1;
- }
- return 0;
- }
- program u akciji:
- $ ./create-file testfile
- $ ls -l testfile
- -rw-rw-r-- 1 samuel users 0 Feb 1 22:47 testfile
- $ ./create-file testfile
- open: File exists
- Primetite da je velicina nove datoteke 0 zato sto program nije upisao nikakve podatke u nju.
- Listing hexdump prikazuje prostu demonstraciju funkcije read.
- Program ispisuje heksadecimalne ostatke sadrzaja datoteke, precizirane na comandnoj liniji.
- Svaki red prikazuje
- pomeraj u datoteci
- i
- sledecih 16 bajtova.
- #include <fcntl.h>
- #include <stdio.h>
- #include <sys/stat.h>
- #include <sys/types.h>
- #include <unistd.h>
- int main (int argc, char* argv[])
- {
- unsigned char buffer[16];
- size_t offset = 0;
- size_t bytes_read;
- int i;
- /*Otvara datoteku za citanje*/
- int fd = open (argv[1], O_RDONLY);
- do { /*Citanje bafera. */
- bytes_read = read (fd, buffer, sizeof (buffer));
- /*Pisanje pomeraja u datoteku, pracen je sa samim bajtovima*/
- printf (“0x%06x : “, offset);
- for (i = 0; i < bytes_read; ++i)
- printf (“%02x “, buffer[i]);
- printf (“\n”);
- /*Pamti nasu poziciju u datoteci */
- offset += bytes_read;
- } while (bytes_read == sizeof (buffer));
- /*Sve gotovo.*/
- return 0;
- }
- hexdump u akciji.
- Prikazuje ispis izvrsne datoteke hexdump:
- $ ./hexdump hexdump
- 0x000000 : 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
- 0x000010 : 02 00 03 00 01 00 00 00 c0 83 04 08 34 00 00 00
- 0x000020 : e8 23 00 00 00 00 00 00 34 00 20 00 06 00 28 00
- 0x000030 : 1d 00 1a 00 06 00 00 00 34 00 00 00 34 80 04 08
- ...
- Vas izlaz moze igledati drugacije,
- u zavisnosti od prevodioca koji koristite
- da prevedete hexdump
- i prevedenih(kompajliranih) indikatora (flags) za prevodjenje koje ste selektovali.
- write SC: timestamp.c
- Program u timestamp.c dodaje tekuce vreme u datu datoteku.
- Ako datoteka ne postoji, kreirace se.
- Ovaj program takodje koristi
- time
- localtime
- asctime
- funkcije za dobijanje i formatiranje tekuceg vremena.
- #include <fcntl.h>
- #include <stdio.h>
- #include <string.h>
- #include <sys/stat.h>
- #include <sys/types.h>
- #include <time.h>
- #include <unistd.h>
- /* Vraca string koji predstavlja tekuci datum i vreme. */
- char* get_timestamp ()
- {
- time_t now = time (NULL);
- return asctime (localtime (&now));
- }
- int main (int argc, char* argv[]) {
- /* Datoteka u koju treba da se doda vremenska oznaka. */
- char* filename = argv[1];
- /* Uzima tekucu vremensku oznaku */
- char* timestamp = get_timestamp ();
- /* Otvara datoteku za upis. Ako postoji, pristupa joj. */
- int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);
- /* Racuna duzinu timestamp stringa. */
- size_t length = strlen (timestamp);
- /* Upisuje timestamp u datoteku. */
- write(fd, timestamp, length);
- /* Sve gotovo. */
- close (fd);
- return 0; }
- Evo kako timestamp program radi:
- $ ./timestamp tsfile
- $ cat tsfile
- Thu Feb 1 23:25:20 2001
- $ ./timestamp tsfile
- $ cat tsfile
- Thu Feb 1 23:25:20 2001
- Thu Feb 1 23:25:47 2001
- Zapamtite da prvi put kad pozovemo timestamp,
- on kreira tsfile,
- dok kad drugi put pozovemo taj program
- on mu samo dodaje vreme.
- lseek
- off_t position = lseek (file_descriptor, offset, SEEK_xxx);
- lseek funkcija vam omogucava da pozicionirate deskriptor datoteke u datoteci. Prosledite ga deskriptoru datoteke i dva dodatna argumenta, offset i SEEK_SET, koji odredjujuci novu poziciju.
- Ako je treci argument
- SEEK_SET, lseek tumaci drugi argument kao poziciju, u bajtovima, od pocetka datoteke.
- SEEK_CUR, lseek tumaci drugi argument kao pomeraj , koji moze biti pozitivan ili negativan, od trenutne pozicije.
- SEEK_END, lseek tumaci drugi argument kao pomeraj od kraja datoteke. Pozitivna vrednost pokazuje poziciju izvan kraja datoteke.
- Funkcija lseek vraca novu poziciju, kao pomeraj od pocetka datoteke.
- tip pomeraja je off_t.
- Ako se pojavi greska, lseek vraca -1.
- lseek ne mozete koristit sa nekim vrstama deskriptora datoteka, kao sto je uticnica(socket) deskriptor datoteke.
- Linux vam omogucava da lseek funkcijom pozicionirate deskriptor datoteke izvan datoteke.
- Normalno, ako je deskriptor datoteke pozicioniran na kraju datoteke i vi nesto upisujete u njega, Linux ce automatski da produzi datoteku kako bi napravio mesta za nove podatke. Ako pozicionirate deskriptor datoteke izvan datoteke i onda nesto upisujete u njega:
- Linux prvo prosiruje datoteku kako bi prilagodio rupu koju ste napravili sa lseek operacijom i onda upisuje na kraj datoteke.
- Ova praznina, kako bilo, ne zauzima mesto na disku; naprotiv, Linux samo pravi poruku koliko je to veliko.
- Ako kasnije pokusate da procitate do iz datoteke, vasem programu ce izgledati kao da je ta praznina popunjena sa 0 bajtovima.
- Koriscenjem ovog ponasanja lseek,
- moguce je kreirati veoma velike datoteke
- koje ne zauzimaju skoro nikakav prostor na disku.
- Program lseek-huge radi to.
- On uzima sa komandne linije
- ime datoteke i
- velicinu trazene datoteke u MB.
- Program otvara novu datoteku,
- pozicinira se do kraja datoteke koristeci lseek,
- i
- onda upise jedinstveni 0 bajt pre nego sto ga zatvori.
- #include <fcntl.h>
- #include <stdlib.h>
- #include <sys/stat.h>
- #include <sys/types.h>
- #include <unistd.h>
- int main (int argc, char* argv[])
- {
- int zero = 0;
- const int megabyte = 1024 * 1024;
- char* filename = argv[1];
- size_t length = (size_t) atoi (argv[2]) * megabyte;
- /*Otvaranje nove datoteke */
- int fd = open (filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
- /* Prelazimo na 1 bajt manje od mesta gde hocemo da bude kraj datoteke. */
- lseek (fd, length - 1, SEEK_SET);
- /* Pisemo jedinstven 0 bajt*/
- write (fd, &zero, 1);
- /*Sve gotovo.*/
- close (fd);
- return 0;
- }
- Koriscenjem lseek-huge, napravicemo datoteku od 1 GB(1024MB).
- Proverite slobodno mesto na disku pre i posle operacije.
- $ df -h .
- Filesystem Size Used Avail Use% Mounted on
- /dev/hda5 2.9G 2.1G 655M 76% /
- $ ./lseek-huge bigfile 1024
- % ls -l bigfile
- -rw-r----- 1 samuel samuel 1073741824 Feb 5 16:29 bigfile
- $ df -h .
- Filesystem Size Used Avail Use% Mounted on
- /dev/hda5 2.9G 2.1G 655M 76% /
- Neprimetna kolicina memorije na disku je potrosena, uprkos nenormalnoj velicini bigfile.
- Opet, iako otvorimo bigfile i citamo iz njega, on ce izgledati kao da je popunjen sa nulama u vrednosti od 1GB.
- Za primer, mozemo da testiramo njegov sadrzaj sa hexdump programom iz predhodnog primera.
- $ ./hexdump bigfile | head -10
- 0x000000 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 0x000010 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 0x000020 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 0x000030 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 0x000040 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 0x000050 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- ...
- -end of Linux examples
- File Creation
- Dok open SC otvara postojeće datoteke, creat SC kreira novu datoteku.
- Sintaksa za creat SC je:
- fd = creat(pathname, modes)
- gde svi parametri imaju isto značenje kao i kod open SC.
- Ako takva datoteka ne postoji, kernel kreira novu datoteku 0-te veličine, pod zadatim imenom i sa zadatim pravima.
- Ako datoteka postoji, kernel odseca datoteku na veličinu 0, oslobađjući sve data blokove.
- algorithm creat
- inputs: {filename, file permissions (for creation type of open)}
- output: file descriptor
- {
- get inode for file name (algorithm namei);
- if (file already exists)
- {
- if (not permitted access)
- {
- release inode (algorithm iput);
- return(error)
- }
- }
- else /*file does not exist yet*/
- {
- assign free inode from FS (algorithm ialloc);
- create new directory entry in parent directory: include new file name and newly assigned inode number
- }
- allocate file table entry for inode, initialize count, offset; #FT
- allocate user file descriptor entry, set pointer to file table entry; #UFTD
- if (file did exist at time of create) free all file blocks (algorithm free)
- unlock(inode);
- return(user file descriptor);
- }
- SC create može da se izvede sa open SC koristeći 2 flag-a:
- O_CREAT (create)
- O_TRUNC(truncate)
- Kernel razbija pathname koristeći algoritam namei, dok ne naiđe na zadnju komponentu.
- Ukoliko u zadnjoj grani nađe zadnje ime ono se mora odseći na 0.
- U protivnom dešava se kreacija novog objekta u direktorijumu, novi FCB.
- Ako ima mesta u direktorijumskom bloku, dobro u protivnom, direktorijum se mora proširiti sa novim blokom što izaziva brojne akcije (alokaciju, inode promenu..).
- Potom se pronalazi slobodan inode za novi datoteku (ialloc) koji se inicijalizuje i upisuje na disk preko bwrite algoritma.
- Ukoliko je datoteka postojala, kernel zahteva od procesa da ima write pravo na nju da bi mogao da je odseče na 0, svi data blokovi se oslobađaju (free algoritam), ali se ne menja vlasništvo i grupa datoteke.
- Na kraju se inicijaliziju po jedan ulaz u UDFT i FT, kao kod open SC.
- Kreiranje specijanih datoteka, kao što su device files, named pipes i direktorijumi se odvija preko mknod SC, koji ima sličnosti sa create tako što dodeljuje novi inode za datoteku.
- Sintaksa za mknod SC je:
- mknod (pathname, type and permissions, dev)
- pri čemu je
- pathname ime specijalne datoteke,
- type and permissions daju tip specijalne datoteke (node, pipe, directory) i prava pristupa koja joj se dodeljuju
- dev specificira major i minor broj za specijalne blok i karakter datoteke
- algorithm mknod
- inputs: {filename, file type, permissions, major and minor device number}
- output: none
- {
- if (new node not name pipe and user not super user) return (error);
- get inode for file name (algorithm namei);
- if (new node already exist)
- {
- release parent inode (algorithm iput);
- return(error)
- }
- else /* file does not exist yet*/
- {
- assign free inode from FS (algorithm ialloc);
- create new directory entry in parent directory: include new node name and newly assigned inode number;
- release parent inode (algorithm iput);
- }
- if (new node is block or character special file) write major and minor numbers into inode structure;
- release new node inode (algorithm iput);
- }
- Kernel u direktorijumskoj strukturi traži ime specijalne datoteke koju treba da kreira i
- ako ime ne postoji, dodeljuje se novi inode,
- u direktorijumu se upisuje novi FCB.
- u inode se upisuje tip datoteke (node, pipe, directory) i prava pristupa.
- Ukoliko je nod u pitanju, upisuju se major i minor number u inode.
- Za direktorijum se moraju alocirati data blok i popuniti sa prva dva ulaza
- . (itself)
- .. (parent)
- Na kraju se radi iput za novu specjilanu datoteku
- Change directory, change root
- Kada se sistem podiže,
- prvi proces koji se kreira,
- uzima root direktorijum za svoj tekući direktorijum,
- tako što obavi iget za /,
- pa pa ga čuva u u-area kao svoj tekući direktorijum,
- i obavlja inode unlock (iput).
- Kada proces kreira svoje dete sa fork SC,
- novi proces nasleđuje tekući direktorijum od procesa roditelja,
- a kernel povećava RC za inode tekućeg direktorijuma.
- Algoritam chdir menja tekući direktorijum procesa. Sintkasa za chdir SC je:
- chdir(pathname)
- gde je pathname ime direktorijuma koji će postati novi tekući direktorijum procesa.
- Kernel razbija pathname po granama preko namei algoritma
- dok ne dođe do zadnje komponente,
- kada proverava prava pristupa na tu granu.
- Ako ima prava pristupa,
- uzima se inode te grane (iget) i inkremetira RC za novi direktorijum,
- oslobađa se (iput), izbacuju se stari inode a RC--,
- a upisuje nov u u-areu procesa.
- Pošto proces promeni tekući direktorijum, njegov inode je polazna tačka za sva pretraživanja (namei) za sve reference koje ne počinju sa apsolutnom putanjom /....
- Inode za tekući direktorijum se otpušta i RC--, samo ako nastupi novi chdir ili proces završi aktivnosti (exit)
- algorithm change directory (chdir)
- input: new directory name
- output: none
- {
- get inode for new directory name (algorithm namei);
- if(inode not that of directory or process not permitted access to file)
- {
- release inode (algorithm iput);
- return(error);
- }
- unlock inode;
- release "old" current directory inode (algorithm iput);
- place new inode into current directory slot in u-area
- }
- Procesi podrazumevaju da / označava root direktorijum celog UNIX stabla
- to je globalna sistemska varijabla koja sadrži inode root direktorijuma,
- koji se dobija preko iget SC prilikom podizanja UNIX-a.
- Procesi mogu promeniti
- svoju oznaku za FS root direktorijum preko chroot SC
- to je korisno kada procesi simulairaju sopstvenu FS hijerarhiju.
- Sintaksa za chroot SC je
- chroot(pathname)
- pathname ime direktorijuma koji će se tretirati kao root direktorijum procesa.
- Algoritmam za chroot je praktično isti kao i za chdir.
- Preko namei se dobija inode novog root direktorijima koji se upisuje u u-areu procesa.
- Novi inode je logički root za sve reference koje počinju sa /.
- Change owner, change mode
- Promena vlasništva ili prava pristupa su operacije koje se obavljaju isključivo nad inodom, ništa se sa datotekom ne radi.
- Sintakse su:
- chown(pathname, owner, group)
- chmod(pathname, mode)
- Da bi promenio vlasništvo, kernel konvertuje pathname u inode preko namei algoritma.
- Proces mora biti sa root privilegijom ili da bude vlasnik datoteke, u protivnom ne može.
- Nakon dobijanja inode, kernel modifikuje UID i GID polje, briše set user i set group flagove, a potom otpušta inode sa iput.
- Potpuno ista procedura se radi i za chmod, gde se modifikuju prava pristupa.
- stat, fstat
- SC stat i fstat omogućavaju procesu da
- postavi upit za status datoteke, a
- upit će vratiti informaciju o
- tipu datoteke,
- vlasništvu,
- ACL,
- broju linkova,
- broju inoda i
- vremenima pristupa.
- Sintakse su:
- stat(pathname, statbuffer)
- fstat(fd, statbuffer)
- gde je
- pathname ime datoteke, fd je file descriptor koji je vratio prethodni open SC,
- statbuffer je korisnikov bafer za prijem podataka o statusu datoteke gde će stat i fsfstat da napune podatke.
- Pipes
- Pipes dozvoljavaju prenos podataka
- između procesa na FIFO način,
- a takođe omogućavaju sinhronizaciju procesa.
- Postoje 2 vrste pipes:
- named pipes
- unamed pipes
- Obe vrste su identične
- osim pri inicijalnom pristupu pipe, pri čemu se
- za named pipe koristi open SC kao read, write i close,
- dok se unamed pipes kreiraju preko pipe SC
- Pravila su da samo deca procesa koji je otpočeo pipe SC mogu deliti pristup unamed pipes.
- Sintaksa za pipe SC je
- pipe(fdptr)
- gde je fdptr ukazivač na integer polje koje će sadržavati 2 file deskriptora za čitanje i upis pipe-a.
- Kako su pipes u stvari datoteke, koje ne postoje pre korišćenja, kernel mora dodeliti jedan inode prilikom kreiranja pipe-a.
- Kernel dodeljuje par file deskriptora
- read descriptor za čitanje iz pipe
- write descriptor za upis u pipe
- Takođe se dodeljuje:
- 2 FT ulaza za pipe
- kod obične datoteke, samo jedan ulaz
- čim se kreira pipe, svi SC (read, write) važe kao i za običnu datoteku.
- algorithm pipe
- input: none
- output: read file descriptor
- write file descriptor
- {
- assign new inode for pipe device (algorithm ialloc);
- allocate 2 FT: entry for reading, another for writing;
- initialize FT entries to point to new inode;
- allocate 2 UDFT:
- for reading and for writing,
- initialize to point to respective FT entries;
- set inode RC to 2;
- initialize reference count RC of inode readers, writers to 1;
- }
- Kernel dodeljuje inode za pipe device preko algoritma ialloc.
- Pipe device je onaj FS u kome se dodeljuje inode i data blocks za taj pipe.
- Kada je pipe aktivan, kernel ne obavlja reassign pipe-ovog inoda i data blokova.
- Kernel zatim dodeljuje 2 FT ulaza: za read i write descriptor i ažurira informacije u in-core inodu.
- Svaki FT ulaz čuva informaciju koliko instanci pipe-a je otvoreno za čitanje i upis, a inicijalno se postavljaju na 1.
- U in-core inodu, RC pokazuje koliko puta je pipe otvoren a inicijalno je 2.
- Takođe inode čuva informaciju o bajt offsetu gde će sledeći upis ili čitanje da se događa kroz pipe.
- Tu je osnovna razlika između pipe i obične datoteke,
- kod pipe je offset u in-core inodu,
- kod obične datoteke je offset u FT ulazu.
- Proces ne može sam da podešava offset kao kod obične datoteke,
- lseek ne važi za pipe.
- nema radnom pristupa kroz pipe, isključivo sekvencijalno=FIFO.
- Imenovani pipe je datoteka čija je semantika potpuna ista kao kod unamed pipes, osim što ima FCB u direktorijumu i pristupa joj se po pathname.
- named pipes se
- otvaraju kao obične datoteke
- permanetno postoje u FS
- brišu se sa unlink SC
- unamed pipes tranzijentni,
- kada svi procesi završe sa korišćenjem pipe-a,
- kernel oslobađa inode.
- Algoritam za open of named pipe-a je skoro isti kao kod obične datoteke.
- Međutim, pre završetka open SC, kernel inkremetira read i write count u inodu, ukazujući koliko procesa je otvorilo named pipe za čitanje i upis.
- Proces koji otvori named pipe za čitanje ostaje uspavan sve dok drugi proces ne otvori pipe za upis i obrnuto.
- Kernel će probuditi proces koji uspavan na pipe-u, kada se dogodi neki događaj upis ili čitanje.
- Reading and Writing Pipes
- Proces pristupa podacima u pipe na FIFO način, koji znači da podaci moraju da se čitaju o onom poretku u kome su se upisali. Nije neophodno da broj čitaoca bude jednak broju pisaca u pipe, ako je broj pisaca i čitaoca veći od 1, mora se obezbediti sinhronizacija.
- Kernel pristupa podacima u pipe kao kod obične datoteke, blokovi se dodeljuju i pune u toku write SC. Razliku u alokaciji prostora između pipe i obične datoteke što pipe koristi isključivo direktne pointere, što povećava performanse ali ograničava veličinu pipes.
- Kernel manipuliše direktnim blokovima pipe-a kao sa kružnim queue, kontrolišući interne read i write ukazivače da poštuju FIFO poredak.
- Postoje sledeća 4 slučaja čitanja i upisa u pipe:
- I upis u pipe kada ima mesta za upis
- II čitanje iz pipe kada se u pipe nalaze svi potrebni podaci koje čitaoc zahteva
- III čitanje iz pipe kada nema svih traženih podataka
- IV upis u pipe kada nema mesta za upis
- WRITE
- Prvi slučaj nastupa kada proces upisuje u pipe tako da je suma podataka koji se upisuje + količina podataka koja je već u pipe mora da bude manja od kapaciteta pipe-a.
- Qnew_data+ Qexisting_data < PIPE_capacity
- Kernel, tada upisuje podatke kao kod obične datoteke
- za svaki takav upis inkremetira se pipe size i write pointer
- budi sve read procese koji čekaju da se nešto upiše u pipe.
- Kada se dođe do kraj pipe, iscrpe se svi direktni pointeri, ide se na početak pipe-a (byte offset 0).
- Upis je uvek u rastućem redu.
- Kod obične datoteke veličina ažurira samo ako se upis dešava iza kraja datoteke.
- READ
- Kada proces čita pipe, proverava se da li je pipe prazan ili nije.
- Ako nije, read se dešava ali poštujući strogo offset koji je u inodu of pipe.
- Posle čitanja svakog bloka,
- kernel dekremetira veličinu pipe-a,
- ažurira read pointer (read offset) i
- budi eventualne writer procese koji čekaju na prazno mesto.
- Proces koji čita pipe će se uspavati ako je pipe prazan ili nema dovoljno podataka. Postoje i no delay opcije koje odmah vraćaju bez čekanja ako read ne može da se zadovolji.
- Ako proces želi da nešto upiše u pipe, a nema mesta, mora da ide na spavanje dok reader proces ne isprazni pipe.
- Ukoliko proces upisuju podatke koji prevazilaze kapacitet pipe-a,
- tada proces ne može da čeka jer nikada neće dočekati,
- već upisuje samo onaj deo koji može da stane,
- u najboljem slučaju kapacitet pipe-a,
- pa čeka da se potpuno ili delimični isprazni.
- Još jedanput, pipe
- liči na regularnu datoteku
- ali read i write offset nisu kontrolabilni od strane procesa
- već se kontrolišu pomoću kernela i nalaze se u inode a ne u FT
- to su offseti zajednički za sve procese koji dele pipe.
- Kada se zatvara (close) pipe,
- proces obavlja sličnu proceduru kao kod obicne datoteke,
- ali kernel mora obaviti specijalnu proceduru prilikom zatvaranja pipe, odnosno otpuštanja pipe-ovog inoda.
- Kernel dekrementira broj pipe-ovih reader-a i writer-a na svako zatvaranje.
- Ako broj writera padne na 0, a ima uspavanih readera, kernel in budi i vraća im read SC bez pročitanih podataka.
- Ako broj readera padne na 0, a ima uspavanih writera, kernel ih budi i salje im signal greške.
- U oba slučaja čekalo bi se na nešto što nije sigurno da će se dogoditi,
- a u slučaju named pipe mogao bi se pojaviti novi proces
- ali ih kernel i named i unamed pipe tretira na isti način.
- Ako nema ni reader ni writer procesa,
- kernel oslobađa sve data blokove od pipe-a
- markira inode da je pipe prazan.
- Ovaj program ilustruje veštačko korišćenje pipes.
- Proces kreira pipe i ide u beskonačnu petlju,
- upisuje string „hello“ u pipe i čita ga iz pipe.
- Kernel ne kontroliše stanje ako isti proces čita ili piše pipe.
- char string [] = “hello”
- main
- {
- char buf[1024];
- char *cp1, cp2*;
- int fds[2];
- cp1= string;
- cp2=buf;
- while (*cp1) *cp2++ = *cp1++; /* popuna bafera "buf" sa stringom hello */
- pipe(fds);
- for (;;)
- {
- write(fds[1], buf, 6);
- read(fds[0], buf, 6);
- }
- }
- #include <fcntl.h>
- char string [] = “hello”
- main(argc, argv)
- int argc;
- char *argv[]
- {
- int fd;
- char buf[256]
- /*create named pipe with read/write permission for all users*/
- mknod (“fifo”, 010777,0)
- if (argc == 2) fd = open (“fifo”, O_WRONLY);
- else fd = open (“fifo”, O_RDONLY);
- for (;;)
- {
- if (argc == 2) write(fd,string,6);
- else read(fd,buf,6);
- }
- }
- Proces kreira pipe, a zatim
- ako je pozvan sa 2 argumenta onda kontinualno upisuje string hello u pipe fifo.
- Ako se pozove bez drugog argumenta on kontinualno čita named pipe.
- Ako se od ovog programa kreiraju 2 procesa
- oni će komunicirati kroz isti pipe fifo,
- a može se više procesa uključiti na isti način.
- DUP
- SC dup
- kopira file descriptor
- u prvi slobodan slot u UFDT,
- pri čemu vraća novi descriptor korisniku.
- Ovaj SC radi za sve tipove datoteka i ima sledeću sintaksu
- newfd = dup(fd);
- pri čemu je fd descriptor datoteke koji se duplicira,
- newfd je novi descritor datoteke.
- S obzirom da dup duplicira file descriptor,
- dup će inkrementirati count odgovarajućeg FT ulaza,
- FT ulaz sada ima još jedan UFDT ulaz koji na taj FT ulaz ukazuje
- Ovde smo imali sitaciju UFDT(1) je otvorio datoteku /etc/passwd fd 1, UFDT(3) fd3 je otvorio local, UFDT(5) fd5 je ponovo otvorio /etc/passwd. Potom je obavljen newfd=dup(fd1) i upisan u slot 6.
- SC dup ne izgleda elegantan na prvi pogled, ali je zgodan za razne sofisticirane zadatke u programiranju kao što su shell pipeline
- Posmatrajmo sledeći program
- #include <fcntl.h>
- main()
- {
- int i,j; char buf1[512], buf2[512];
- i = open(”/etc/passwd”, O_RDONLY)
- j = dup (i);
- read (i, buf1, sizeof(buf1));
- read (j, buf2, sizeof(buf2));
- close(i);
- read (j, buf2, sizeof(buf2));
- }
- Najpre je urađen open SC na /etc/passwd, dobijen je fd=i kreiran jedan ulaz sa njim u UFDT, kreiran ulaz u FT sa offsetom 0.
- Sa dup je kreiran još jedan fd=j, još jedan slot u UFDT koji ukazuje na isti FT ulaz to znači sa istim offsetom.
- Prva 2 read SC će pročitati prva dva disk bloka datoteke, a onda se zatvori jedan fd a to je fd=i, ali se datoteka ne zatvara već samo jedan ulaz u UFDT nestaje, ali tu je drugi fd=j sa kojim se nastavlja čitanje iz datoteke. Ovo može da se radi i sa standardnim file descriptorima 0, 1, 2, mogu se duplicirati, zatvarati itd.
- Mounting and Umounting FS
- Fizička disk jedinica se sastoji od više logičkih sekcija, i svaka sekcija ima svoje ime (device file name).
- Proces može pristupati podacima u sekciji kao sa datotekom, prvo se otvori device filename, a potom se disk sekcija tretira kao datoteka, po njoj se čita i piše.
- SC mount povezuje FS koji se nalazi u odgovarjućoj sekciji na disku u stablo, dok SC umount izbacuje FS iz stabla.
- SC mount omogućava korisnicima da pristupaju sekciji diska kao FS a ne kao sekvenci disk blokova.
- Sintaksa za mount SC je:
- mount(special pathname, directory pathname, options)
- pri čemu je:
- special pathname ime specijalne datoteke koja se refencira na deo diska koji sadrži FS koji će biti mountovan
- directory pathname je direktorijum u postojećem stablu gde će FS biti mountovan (mount-point)
- option pokazuju kako će FS biti mountovan (read-only će blokirati svaki creat ili write SC u njemu
- Na primer ako proces pošalje sledeći SC
- mount("/dev/dsk1", "/usr", 0)
- kernel će priključiti FS koji se nalazi u delu diska koji se naziva /dev/dsk1 ka direktorijum /usr u postojećem UNIX stablu.
- Datoteka /dev/dsk1 je blok specijalna datoteka i po pravilu predstavlja deo diska, a da bi taj deo diska mogao da se mount-uje, on mora da sadrži FS, odnosno da sadrži superblock, inode listu i root inode.
- Kada se kompletira mount SC, root direktorijum mountovanog FS je raspoloživ preko MPD direktorijuma (/usr u ovom slučaju).
- Proces pristupa datotekama na mountovanom FS sasvim normalno bez obzira što su one uklonjive. Jedino link SC kontroliše tu činjenicu jer ne dozvoljava linkovanje između 2 FS.
- Kernel održava mount tabelu (MT) sa ulazom za svaki mountovani FS.
- Svaki ulaz u mount tabeli sadrži:
- device number koji identifikuje mountovani FS
- ukazivač na bafer koji sadrži superblock za taj FS
- ukazivač na root inode mountovanog FS (/ of /dev/dsk1)
- ukazivač na inode of MPD (usr of root FS)
- Asocijacija MPD inoda i root inoda mountovanog FS, dozvoljava kernelu da prostiru (traverse) FS vrlo efikasno.
- algorithm mount
- input:
- file name of block special file
- MPD
- options
- output: none
- {
- if(not superuser) return (error);
- get inode of block special file (algorithm namei);
- make legality check;
- get inode of MPD (algorithm namei);
- if(not directory, or reference count > 1)
- {
- release inodes (algorithm iput); return (error);
- }
- find empty slot in MT;
- invoke block device driver open routine;
- get free buffer from buffer cache;
- read superblock into free buffer;
- initialize superblock fields;
- get root inode of mounted device (algorithm iget), save in mount table;
- mark inode of MPD as mount point;
- release special file inode (algorithm iput);
- unlock inode of MPD;
- }
- Kernel dozvoljava samo procesu sa superuser privilegijama da obave mount i umount SC, kako se ne bi dozvoljavao haos u sistemu.
- Kernel pronalazi inode block specijalne datoteke koja predstavlja FS za mounting, izvlači major i minor number, pomoću kojih se identifikuje sekcija na disku koja sadrži taj FS i nalazi inode za MPD.
- RC za taj MPD ne sme da bude veći od jedan, jer se ne sme mountovati više FS na isti MPD.
- Kernel zatim alocira slobodan slot u MT, markira slot da je zauzet i dodeljuje device number.
- Potom se otvara node, pozivajući open proceduru za block-special node, koja proverava da li je node legalan, inicijalizuje driver data strukture i šalje komande hardveru preko disk drajvera.
- Kernel alocira free blok u bafer kešu (getblk) u koji će se čitati superblok i preko read algortima čita superblok u njega. Kernel memoriše pionter na inode MPD, čime se praktično obezbeđuje informacija na roditeljsku granu (..).
- Kernel pronalazi root inode FS koji će biti mountovan, i memoriše ga u MT tabeli. Za korisnika, MPD i root of FS su logički ekvivalentni i kernel uspostavlja njihovu ekvivalenciju u istom ulazu u MT.
- Iza mount-a procesi više ne pristupaju inodu of MPD.
- Kernel inicijalizuje polja u superblocku, brišući lock za free block listu i free inode listu i postavlja broj free inodova na 0. To se radi da bi se sprečilo oštećenje FS prilikom mountovanja posle sistem crash-a, što će naterati kernel da pretraži slobodne inodove sa ialloc. Nažalost ako su povezane liste free blokova oštećene, kernel ne popravlja, to se postiže sa fsck.
- Ukoliko mount sadrži read-only opciju, kernel će postaviti flag u superblock-u.
- Na kraju, kernel će markirati inode(MPD) kao mountpoint, tako da svi procesi mogu da to identifikuju, što je ilustrovano na sledećoj slici.
- Razmatrajmo šta se dešava ako pathname prolazi preko MPD, kako se ponašaju namei i iget algoritmi. Postoje 2 slučaja prelaska preko mount pointa:
- prolazak sa mounted-on na mounted FS (u dubinu)
- prolazak sa mounted FS na mounted-on (iz dubine)
- To se sledeće 2 sekvence nakon komande
- mount /dev/dsk1 /usr
- cd /usr/src/ust
- cd ../../..
- Prva komanda obavlja mount SC koji mountuje FS(/dev/dsk1) na MPD(/usr).
- Prva cd komanda obavlja chdir SC koji na svom putu prolazi preko mountpoint-a /usr.
- Druga cd komanda ide na 3 roditeljske grane opet prolazeći mountpoint /usr.
- U prvom slučaju, prolazak sa mounted-on na mounted FS (u dubinu), imamo modifikovani iget algoritam, koji je sličan kao osnovni algoritam iget, osim što proverava da li je inode mountpoint, koji se označava kao mounted-on ako je to MPD.
- Za svaki takav inode se pronalazi ulaz u MT, iz koga čita device number i root inode, na osnovu kojih kojih može pristupiti root inode mountovanog FS i vratiti sadržaj tog inoda.
- U prvoj cd komandi, kernel pristupa /usr inodu u mounted-on FS i detektuje da je to mountpoint, pronalazi se iz MT device number i root inode.
- algorithm iget
- input: file system and inode number
- output: locked inode {
- while(not done)
- {
- if(inode in inode cache) /* if #1*/
- {
- if(inode locked) /* if #2*/
- {
- sleep (event inode becomes unlocked);
- continue; /* loop back to while*/
- }/* if #2*/
- /*special processing for mount point directory*/
- if(inode a mount point)
- {
- find mount table entry for mount point;
- get new FS number from MT;
- use root inode number in search;
- continue
- }
- if(inode on inode free list) remove from free list;
- increment inode reference count;
- return (inode);
- }/*if #1*/
- /* inode not in inode cache*/
- if(no inodes on free list) return(error)
- remove new inode from free list;
- reset inode number in free list;
- remove inode from old hash queue, place on new one;
- read inode from disk(algorithm bread)
- initialize inode (eg. reference count to 1)
- return(inode) }/*while*/
- }/*main*/
- Za drugi slučaj posmatajmo modifikovani namei algoritam
- algorithm namei /* convert path name to inode*/
- input: path name
- output: locked inode
- {
- if (path name starts from root)
- working inode = root inode (algorithm iget);
- else
- working inode = current directory inode (algorithm iget);
- while (there is more path name)
- {
- read next path name component from input;
- verify that working inode is of directory, access permissions OK;
- if (working inode is of root and component is “..”) continue; /*loop back to while*/
- read directory (working inode) by repeated use of algorithms bmap, bread and brelse
- if (component matches an entry in directory (working inode))
- {
- get inode number for matched component;
- if(found inode of root and working inode is root and component name is ..)
- /*crossing mount point*/
- {
- get MT entry for working inode;
- release working inode (algorithm iput);
- working inode = mounted on inode; (MPD inode)
- lock MPD inode;
- increment reference count of working inode;
- go to component search for ..;
- }
- release working inode (algorithm iput);
- working inode = inode of matched component (algorithm iget)
- }
- else
- return (no inode);
- }/* while */
- return(working inode);
- }
- Kernel za svaki nađeni inode proverava
- da li je root inode i
- ako je working inode root i
- ako je path komponenta je .., tada je to prolazak kroz mountpoint.
- Tada se working inode zamenjuje sa inode(MPD) koji se čita iz MT.
- Praktično imaš 2 inode za svaki MPD direktorijum i kada ga namei prolazi, mora doći do zamene working inoda.
- Unmounting FS
- Sintaksa za umount SC je:
- umount(special filename)
- gde special filename ukazuje na FS koga treba otkačiti.
- Kernel mora prvo proveriti da nema otvorenih datoteka i DW blokova u kešu da taj u FS koji će se otkačiti.
- Pretražuje se FT za sve potencijalne datoteke koje imaju FS number.
- algorithm umount
- input: file name of block special file
- output: none
- {
- if(not superuser) return (error);
- get inode of block special file (algorithm namei);
- extract major, minor number of FS;
- ger mount table entry, based on major and minor number;
- release special file inode (algorithm iput);
- remove shared text entries from region tables for files belonging FS;
- update superblock, inodes, flush buffer;
- if (files from FS still in use) return (error);
- get root inode of mounted FS from MT;
- lock inode;
- release inode (algorithm iput); /*iget was in mount*/
- invoke close routine for special device;
- invalidate buffers in pool from unmounted FS;
- get inode of MPD from MT;
- lock inode;
- clear flag marking it as mountpoint;
- release inode (algorithm iput); /*iget was in mount*/
- free buffer used for super block;
- free mount table slot;
- }
- Kernel uzima inode za FS,
- ažurira
- superblock,
- inodes i flush buffer,
- oslobađa njegov root inode, zatvara device.
- Potom uzima MPD, briše mu mount point flag, oslobađa ga.
- Na kraju briše ulaz u MT i bafer za superblock.
- link
- Link SC linkuje datoteku sa novim imenom u stablu, tako što
- kreira novi FCB
- sa postojećim inode.
- Sintaksa za link SC je:
- link(source file name, target file name)
- gde je source file name ime postojeće datoteke, a target file name nova datoteka koja će se kreirati ako link SC uspe.
- FS sadrži path imena za sve linkove koje datoteka ima, i proces može pristupati datoteci po bilo kom path name.
- Kernel ne zna koja je prva odnosno originalna datoteka, tako da su sva imena ravnopravna.
- Na primer posle izvršenja 2 SC, dogodiće se situacija kao na slici:
- link ("/usr/src/uts/sys", "/usr/inlcude/sys")
- link ("/usr/inlcude/realife.h","/usr/src/uts/sys/testfile.h")
- Kernel dozvoljava samo superuser,
- zbog mogućnosti beskonačnih petlji kada korisnik linkuje direktorijume koji su na istoj grani. a ide se unazad.
- Za superuser-a se pretpostavlja da je oprezniji.
- Potreba za linkovanjem direktorijuma je bila na starim UNIX sistemima,
- zato što mkdir komanda radila preko link SC,
- ali je sve to razrešeno preko uvođenjem mkdir SC,
- čime više nema potrebe da se linkuju direktorijumi.
- algorithm link
- input: {existing file name, new file name}
- output: none
- {
- get inode for existing file name (algorithm namei);
- if (too many links on file or linking directory without super user permission)
- {
- release inode (algorithm iput);
- return (error);
- }
- increment link count on inode;
- update disk copy of inode;
- unlock inode;
- get parent inode for directory to contain new file name (algorithm namei);
- if (new file name already exists or existing/new file name on different FS)
- {
- undo update done above;
- return (error);
- }
- create new FCB-directory entry in parent directory of new file name:
- FCB include new file name, but inode number of existing file
- release parent directory inode (algorithm iput);
- release inode of existing file (algorithm iput);
- }
- Kernel prvo locira inode originalne datoteke, preko algoritma namei,
- inkrementira link count,
- ažurira disk kopiju inoda (iz razloga konzistencije),
- a na kraju unlock-uje inode.
- Zatim se traži target file,
- ako target file postoji link otkazuje, link count se dekrementira jer je prethodno inkremetiran.
- Ako ne postoji, dodeli novi FCB slot u target direktorijumu,
- upisuje se filename i inode broj originalne datoteke,
- oslobađa se inode parent direktorijuma za target file preko iput.
- Potom se oslobađa inode postojeće datoteke čiji link count uvećan za 1.
- deadlock - possibility
- Prilikom linkovanja datoteka mogući su deadlocks.
- Obradićemo 2 moguće situacije za deadlock i oba potiču zbog ne-oslobađanja inoda nakon inkrementiranja link count.
- Pažnja: uvek se lock-uje poslednji inode originala.
- Ako kernel ne oslobađa inode, 2 procesa bi mogla da uđu u deadlock situaciju, kao na primeru 2 simultana procesa:
- proces A: link("a/b/c/d", "e/f/g");
- proces B: link("e/f ", "a/b/c/d/ee");
- Pretpostavimo da proces A nađe inode za "a/b/c/d" u isto vreme kada proces B nađe inode za "e/f " i oba postaju locked.
- Kada proces A pokuša da nađe inode za "e/f", on mora da čeka da inode za e postane free.
- Na drugoj strani proces B mora da čeka da inode za da postane slosoban, i tako su oba procesa uletela u deadlock.
- Sve se to sprečava tako što kernel otpusti inode nakon LC++;
- Unlink
- unlink SC uklanja FCB datoteke iz direktorijuma.
- Sintaksa za unlink SC je:
- unlink(pathname);
- gde je pathname ime koje će biti izbačeno iz UNIX stabla.
- Na primer u sledećoj sekvenci, open SC će otkazati jer je datoteka prethodno obrisana:
- unlink("myfile");
- fd=open("myfile", O_RDONLY)
- Ako se datoteka unlink-uje kao poslednji ili jedini link na datoteku, tada će unlink osloboditi inode i sve blokove datoteke.
- Ako postoji više linkova,
- nestaje samo to ime i LC--;
- dok je datoteka raspoloživa preko svih ostalih imena.
- algorithm unlink
- input: file name
- output: none
- {
- get parent inode for directory to contain file to be unlinked (algorithm namei);
- /* if unlinking the current directory…*/
- if (last component of file name “.”)
- increment inode reference count;
- else
- get inode of file to be unlinked (algorithm iget);
- if(file is directory but user is not super-user)
- {
- release inodes (algorithm iput);
- return (error);
- }
- if (shared text file and link count currently 1) remove from region table;
- write parent directory: zero inode number of unlinked file;
- release inode parent directory (algorithm iput);
- decrement file link count;
- release file inode (algorithm iput);
- /* iput checks if link count is 0: if so,
- release file blocks (algorithm free) and
- frees inode (algorithm ifree)
- */
- }
- Kernel prvo preko namei nalazi
- ali ne datoteku,
- već inode roditeljskog direktorijuma.
- Pristupa se in-core inode datoteke koja će brisati, preko iget.
- Potom se obave testovi,
- da li to shared text i
- da li LC=1, i
- kernel briše FCB iz direktorijuma, tako što na mestu inode broja upiše 0, a to se sinhrono upiše na disk i parent inode se oslobađa preko iput.
- Za datoteku koja se briše LC--; i oslobađa se in-core file inode.
- Ako prilikom otpuštanja in-core inode, LC padne na 0,
- ta datoteka više ne postoji na disku,
- iput tada oslobađa sve data blocks sa free,
- tako što oslobađa sve direktne i sve indirektne blokove i
- oslobađa inode sa ifree tako što upiše filetype=0 u inode.
- FS Consistency
- Kernel obavlja svoje upise u poretku kako bi minimizovao šanse za FS oštećenje u slučaju otkaza sistema.
- Na primer, kada se briše filename iz svog direktorijuma (FCB),
- to se se sinhrono upisuje na disk u roditeljski direktorijum,
- pre nego što se oslobode blokovi datoteke i inode.
- Ako se dogodi system crash dok se oslobođaju data blokovi, nije strašno, nema FCB koji ukazuje na taj inode.
- Ako unos ne bi bio sinhron a dogodi se crash, FCB koji nije upisan može ukazivati na potpuno prazan inode ili na pogešan inode što je ozbiljnije oštećenje FS.
- Mnogo je lakše očistiti inode za koga nema FCB, nego ispraviti pogrešan FCB.
- Evo primera:
- Pretpostavimo da imamo 2 linka sa imenima a i b i obavimo unlink a.
- Kernel poštuje poredak write operacija,
- pa prvo anulira FCB u direktorijumu za link-a i upiše ga na disk.
- Ako tada sistem pukne, LC=2, a ostao je samo b, tako da će sistem imati problema jedino ako se briše b, a svi ostalim slučajevima je sve ispravno.
- Pretpostavimo drugi poredak write operacija.
- Kernel prvo uradi LC--; i dogodi se crash pre nego što je obrisan FCB(a).
- Posle butiranja sistema, imamo 2 FCB na isti inode, a LC=1 i ako se obavi brisanje a ili b, datoteka će fizićki nestati,
- a ostaje FCB koji postaje neregularan, jer ukazuje ili na prazan inode ili na inode koji se kasnije dodeli za neku drugu datoteku, koja će opet imati LC=1, a dva imena.
- Kernel takođe oslobađa inode i disk blokove u poretku,
- mogu se prvo oslobađati data blocks pa tek onda inode ili obrnuto,
- ali uticaj crash-a je sasvim različit.
- Pretpostavimo da kernel oslobađa disk blokove i da se dogodi crash. Nakon podizanja sistema imamo inode koji ukazuje na oslobođene blokove a to je prilično neregularna situacija.
- Ako se prvo oslobodi inode, pa sistem pukne, blokovi koji su pripadali datoteci su neupotrebljivi jer nisu vraćeni u free listu, ali sve ostalo je sasvim regularno, nema inode i nema pogrešnog pristupa. Program fsck lakše oslobađa disk blokove nego što ih čisti.
- Race Condition
- Race condition je prisutan u unlink SC, osobito kada se brišu direktorijumi sa rmdir koji briše direktorijum, samo ako je prazan, a to će konstatovati samo ako svi direktorijumski ulazi-FCB imaju vrednost inoda = 0.
- Kako se rmdir ne obavlja atomski, a to znači da može da se dogodi context switch između čitanja za proveru direktorijumskih blokova i brisanja samog direktorijuma.
- Na primer može drugi proces da obavi create, a ovaj prvi konstatovao da je već prazan. Jedini način da se ovo spreči je record locking. Kada proces izvršava unlink call, nijedan drugi proces ne može da pristupa roditeljskom direktorijumu jer mu je inode locked zbog inoda.
- Podsetimo da algoritam za link SC oslobađa inode pre kraja poziva, ali ako drugi proces pokušava da obriše datoteku, to je moguće jer je link oslobodio inode, ali će brisanje samo decrementirati LC, a datoteka ostaje.
- Drugi RC se dešava kada jedan proces konvertuje file pathname u inode preko namei algoritma, a drugi proces uklanja granu u toj putanji.
- Pretpostavimo da proces A razbija pathname "a/b/c/d" i odlazi na spavanje dok se ne oslobodi in-core inode za c.
- Proces B na primer želi da obavi unlink c i on odlazi na spavanje.
- Kada se on oslobodi i ako kernel da prednost procesu B, tada će B obrisati granu c, ako je prazna naravno.
- Kada A dobije procesor, namei više ne nalazi in-core c, jer je obrisan a na njega je čekao i mora da se završi sa porukom o grešci.
- Može da se dogodi i 3 situacija da novi proces C, dobije inode koji je pripadao grani c, napravi novu granu ili datoteku, a da proces a nastavi sa izmenjenom siutacijom, pa će pristupiti pogrešnoj datoteci, što nije dobro.
- brisanje otvorene datoteke
- Proces može obrisati datoteku čak i kada je otvorena od strane nekog drugog procesa.
- Pošto open SC, oslobađa inode na kraju, unlink će biti uspešan.
- Kernel prati unlink agoritam kao da datoteka nije otvorena i uklanja FCB, tako da datoteci više niko ne može da priđe.
- Međutim kako je open SC inkrementirao RC, kernel ne briše datoteku oslobađajući data blocks i inode, u iput algoritmu kod unlink SC.
- Svi procesi koji su otvorili datoteku rade sa njom (FD). Tek kada se dogodi close SC, tada kernel preko iput algoritma briše sadržaj datoteke.
- Ovo se često dešava, proces kreira tmp file, pa ga otvorenog odmah obriše, ali se pravo brisanje dogodi tek na zadnji close SC.
- Evo primera: prvo se otvori datoteka, zatim se briše, III stat puca jer napada datoteku koje više nema, ali fstat radi jer ide preko file descriptora
- #include <sys/types.h>
- #include <sys/stat.h>
- #include <fcntl.h>
- main(argc, argv)
- int argc;
- char *argv[];
- {
- int fd;
- char buf[1024];
- struct stat, statbuf;
- if(argc != 2) exit (); /*need parameter*/
- fd = open(argv[1], O_RDONLY)
- if (fd == -1) exit (); /*open fails */
- if(unlink(argv[1], == -1) exit (); /*unlink just opened */
- if( (stat(argv[1],&statbuf == -1) /*stat the file by name */
- printf("stat %s fails as it should\n", argv[1]);
- else
- printf("stat %s succeded!!!!! \n", argv[1]);
- if( (fstat(fd,&statbuf == -1) /*fstat the file by fd */
- printf("fstat %s fails !!!!!\n", argv[1]);
- else
- printf("fstat %s succeded as it should\n", argv[1]);
- while (read(fd, buf, sizeof(buf)>0) /*read open/unlinked file*/
- printf("%1024s n", buf); /*prints 1K byte field*/
- )
- FS Abstractions
- Weinberg je uveo FS tipove-types da bi obezbedio podršku za njegov network filesystem, što je implemetirano na UNIX System V.
- FS tipovi omogućavaju kernelu da simultano podržava više FS tipova kao što su mrežni FS ili FS različitih operatvnih sistema.
- Procesi koriste normalan open SC, a kernel mapira generički skup I/O operacija u operacija za specifični tip FS.
- Inode je interfejs između apstraktnog FS i specifičnog FS.
- Generički in-core inode sadrži podatke koji su nezavisni od specifičnog FS i ukazuju na file-specifični inode koji sadrži file-specific podatke.
- File-specific inode uključuje informacije kao što su ACL, block layout itd.
- Generic inode sadrži informacije kao što su
- device number,
- inode number,
- file type,
- size,
- vlasnik, i
- RC.
- Drugi podaci koji su FS-specific sadržani u superblocku i direktorijumskim strukturama.
- Na slici je prikazana generička in-core inode tabela i 2 tabele sa FS-specific inodovima,
- jedna za UNIX System V FS a
- druga za remote inode,
- koja sadrži dovoljno informacija da identifikuju datoteku na udaljenom FS.
- Taj udaljeni FS možda i nema inode baziranu strukturu, međutim sve se to preko generičke inode tabele i FS-specific tabele mapira u inode-like strukturu, tako da se sve radi apstraktno sa open, close, read, write, dobijanje inode za datoteku kao namei i iget, oslobađanje inoda kao iput, ažuriranja inoda, provera prava, setovanje prava, mount i umount FS.
- FS Maintenance-data blocks
- Kernel održava konzistenciju FS za vreme normalne operacije, ali neobične okolnosti kao što je power-fail, mogu ostaviti FS u nekonzistetno stanje.
- Komanda fsck proverava FS i ispravlja nepravilnosti, pristupajući preko block ili character interfejsa, zaobilazeći regularni file pristup.
- Za disk blokove, pravila su jasna, prvo su svi blokovi slobodni, potom se blok izbaci iz liste a dodeli samo jednom inodu, a da bi se dodelio drugom inodu mora se prvo vratiti listu. Prema tome disk blok ili je u free listi ili je u samo jednom inodu.
- Tipične neregularnosti su
- da disk blokovi pripadaju više od jednog inoda
- ili se istovremeno nalaze u listi slobodnih blokova i inodu.
- Tipična situacija koja se dešava je kada kernel oslobodi blok iz datoteke, upiše ga in-core free listu superbloka, dodeli ga u in-core druge datoteke.
- Potom treba ažurirati superblock na disku i oba inoda, i ako se pre tih ažuriranja dogodi crash,
- može se blok naći u inodovima obe datoteke,
- a takođe može završiti i free listi i u inodu.
- Postoji još jedna neregularna situacija kada blok nije ni u free listi ni u datoteci, na primer blok se izbaci iz free liste upiše u in-core inode, ali se ne ažurira a dogodi se crash, pa ga nema nigde.
- Takođe, inodovi mogu imati non-0 link count, a da taj inode ne postoji u nijednom FCB, što se dešava kada sistem ako se dogodi crash kada se dodeli inode za pipe ili new-file a ne upiše se FCB. Slična sitacija može da se dogodi ako se neregulano obriše grana koja nije prazna.
- I druga polja u inodu mogu biti neregularna, na primer file type, ako se mountuje nepravilno formatirani FS.
- Neregularnosti se pojavljuju u slobodnim i zauzetim inodovima jer se zbog crash inode može naći i u FCB i u listi slobodnih inodova.
- Neregularnost je kada broj slobodnih blokova i broj slobodnih inodova u superbloku ne odgovara realnom stanju na disku, zato što kompletna informacija u superbloku mora biti veoma tačna.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement