Въведение в операционните системи

Хей Хабр! Бих искал да предложа на вашето внимание поредица от статии-преводи на една интересна според мен литература - OSTEP. Този материал обсъжда доста дълбоко работата на unix-подобни операционни системи, а именно работата с процеси, различни планировчици, памет и други подобни компоненти, които съставляват съвременна операционна система. Можете да видите оригинала на всички материали тук тук. Моля, имайте предвид, че преводът е направен непрофесионално (съвсем свободно), но се надявам да съм запазил общия смисъл.

Лабораторните работи по темата можете да намерите тук:

• оригинала
• оригинала
• моята лична адаптация

Други части:

• Част 1: Въведение
• Част 2: Абстракция: Процесът
• Част 3: Въведение в API на процеса

Можете също да разгледате канала ми на телеграма =)

Аларма! За тази лекция има лаборатория! Виж github

API за процеси

Нека да разгледаме пример за създаване на процес в UNIX система. Това се случва чрез две системни повиквания вилица () и exec().

Call fork()

Помислете за програма, която прави fork() повикване. Резултатът от неговото изпълнение ще бъде следният.

Първо, влизаме във функцията main() и отпечатваме низа на екрана. Редът съдържа идентификатора на процеса, който в оригинала се извиква PID или идентификатор на процеса. Този идентификатор се използва в UNIX за обозначаване на процес. Следващата команда ще извика fork(). В този момент се създава почти точно копие на процеса. За операционната система изглежда, че има 2 копия на една и съща програма, работещи в системата, която от своя страна ще излезе от функцията fork(). Новосъздаденият дъщерен процес (по отношение на родителския процес, който го е създал) вече няма да се изпълнява, като се започне от функцията main(). Трябва да се помни, че дъщерният процес не е точно копие на родителския процес; по-специално той има свое собствено адресно пространство, свои собствени регистри, свой собствен указател към изпълними инструкции и други подобни. По този начин стойността, върната на извикващия функцията fork(), ще бъде различна. По-специално, родителският процес ще получи PID стойността на дъщерния процес като връщане, а дъщерният процес ще получи стойност, равна на 0. Използвайки тези кодове за връщане, можете след това да разделите процесите и да принудите всеки от тях да върши собствената си работа . Изпълнението на тази програма обаче не е строго дефинирано. След като се раздели на 2 процеса, ОС започва да ги наблюдава, както и да планира тяхната работа. Ако се изпълни на едноядрен процесор, един от процесите, в този случай родителят, ще продължи да работи и след това дъщерният процес ще получи контрол. При рестартиране ситуацията може да е различна.

Изчакване на повикване()

Помислете за следната програма. В тази програма, поради наличието на обаждане изчакайте() Родителският процес винаги ще чака дъщерния процес да завърши. В този случай ще получим строго определен текстов изход на екрана

извикване exec().

Помислете за предизвикателството exec(). Това системно извикване е полезно, когато искаме да стартираме напълно различна програма. Тук ще се обадим execvp() за да стартирате програмата wc, която е програма за броене на думи. Какво се случва, когато се извика exec()? На това извикване се предава името на изпълнимия файл и някои параметри като аргументи. След което кодът и статичните данни от този изпълним файл се зареждат и неговият собствен сегмент с кода се презаписва. Останалите области на паметта, като стека и купчината, се инициализират отново. След което ОС просто изпълнява програмата, като й предава набор от аргументи. Така че ние не създадохме нов процес, ние просто трансформирахме текущо изпълняваната програма в друга работеща програма. След изпълнение на извикването exec() в наследника, изглежда, че оригиналната програма изобщо не е стартирана.

Това усложнение при стартиране е напълно нормално за Unix shell и позволява на този shell да изпълни код след извикване вилица (), но преди обаждането exec(). Пример за такъв код би бил коригирането на средата на обвивката към нуждите на програмата, която се стартира, преди да я стартирате.

Черупка - просто потребителска програма. Тя ви показва реда с поканите и ви чака да напишете нещо в него. В повечето случаи, ако напишете името на програма там, обвивката ще намери нейното местоположение, ще извика метода fork() и след това ще извика някакъв тип exec(), за да създаде нов процес и да изчака да завърши с помощта на изчакване() повикване. Когато дъщерният процес излезе, обвивката ще се върне от извикването на wait() и ще отпечата отново подканата и ще изчака въвеждането на следващата команда.

Разделянето на fork() & exec() позволява на обвивката да прави следните неща, например:
wc файл > нов_файл.

В този пример изходът на програмата wc е пренасочен към файл. Начинът, по който шелът постига това е доста прост - чрез създаване на дъщерен процес преди извикване exec(), обвивката затваря стандартния изход и отваря файла нов_файл, по този начин, целият изход от по-нататъшната изпълнявана програма wc ще бъдат пренасочени към файл вместо към екран.

Unix тръба се изпълняват по подобен начин, с тази разлика, че използват извикване pipe(). В този случай изходният поток на процеса ще бъде свързан към опашка от канали, разположена в ядрото, към която ще бъде свързан входният поток на друг процес.

Източник: www.habr.com