ოპერაციული სისტემების შესავალი

ჰეი ჰაბრ! მინდა თქვენს ყურადღებას გავამახვილო ჩემი აზრით ერთი საინტერესო ლიტერატურის - OSTEP-ის სტატია-თარგმანის სერია. ეს მასალა საკმაოდ ღრმად განიხილავს unix-ის მსგავსი ოპერაციული სისტემების მუშაობას, კერძოდ, პროცესებთან, სხვადასხვა გრაფიკებთან, მეხსიერებასთან და სხვა მსგავს კომპონენტებთან მუშაობას, რომლებიც ქმნიან თანამედროვე OS-ს. ყველა მასალის ორიგინალი შეგიძლიათ ნახოთ აქ აქ. გთხოვთ გაითვალისწინოთ, რომ თარგმანი შესრულებულია არაპროფესიონალურად (საკმაოდ თავისუფლად), მაგრამ იმედია შევინარჩუნე ზოგადი მნიშვნელობა.

ამ თემაზე ლაბორატორიული სამუშაოები შეგიძლიათ იხილოთ აქ:

• ორიგინალი
• ორიგინალი
• ჩემი პირადი ადაპტაცია

სხვა ნაწილები:

• ნაწილი 1: შესავალი
• ნაწილი 2: აბსტრაქცია: პროცესი
• ნაწილი 3: შესავალი პროცესის API-ში

ასევე შეგიძლიათ ნახოთ ჩემი არხი აქ ტელეგრამა =)

განგაში! ამ ლექციისთვის არის ლაბორატორია! შეხედე github

პროცესის API

მოდით შევხედოთ UNIX სისტემაში პროცესის შექმნის მაგალითს. ეს ხდება ორი სისტემური ზარის საშუალებით ჩანგალი () и exec ().

Call fork()

განვიხილოთ პროგრამა, რომელიც ახდენს fork() ზარს. მისი შესრულების შედეგი იქნება შემდეგი.

უპირველეს ყოვლისა, შევდივართ main() ფუნქციას და ვბეჭდავთ სტრიქონს ეკრანზე. ხაზი შეიცავს პროცესის იდენტიფიკატორს, რომელსაც ორიგინალში ეწოდება PID ან პროცესის იდენტიფიკატორი. ეს იდენტიფიკატორი გამოიყენება UNIX-ში პროცესზე მითითებისთვის. შემდეგი ბრძანება გამოიძახებს fork(). ამ ეტაპზე იქმნება პროცესის თითქმის ზუსტი ასლი. OS-ისთვის, როგორც ჩანს, სისტემაზე მუშაობს ერთი და იმავე პროგრამის 2 ასლი, რომელიც თავის მხრივ გამოვა fork() ფუნქციიდან. ახლად შექმნილი შვილი პროცესი (მშობლის პროცესთან მიმართებაში, რომელმაც შექმნა იგი) აღარ შესრულდება, დაწყებული main() ფუნქციიდან. უნდა გვახსოვდეს, რომ შვილი პროცესი არ არის მშობელი პროცესის ზუსტი ასლი; კერძოდ, მას აქვს საკუთარი მისამართის სივრცე, საკუთარი რეგისტრები, შესრულებადი ინსტრუქციების საკუთარი მაჩვენებელი და მსგავსი. ამრიგად, fork() ფუნქციის გამომძახებელზე დაბრუნებული მნიშვნელობა განსხვავებული იქნება. კერძოდ, მშობელი პროცესი მიიღებს ბავშვის პროცესის PID მნიშვნელობას, როგორც დაბრუნების სახით, და ბავშვი მიიღებს მნიშვნელობას 0-ის ტოლი. ამ დაბრუნების კოდების გამოყენებით, თქვენ შეგიძლიათ განასხვავოთ პროცესები და აიძულოთ თითოეული მათგანი შეასრულოს საკუთარი სამუშაო. . თუმცა, ამ პროგრამის შესრულება არ არის მკაცრად განსაზღვრული. 2 პროცესად დაყოფის შემდეგ OS იწყებს მათ მონიტორინგს, ასევე მათი მუშაობის დაგეგმვას. თუ შესრულებულია ერთბირთვიან პროცესორზე, ერთ-ერთი პროცესი, ამ შემთხვევაში მშობელი, გააგრძელებს მუშაობას და შემდეგ ბავშვის პროცესი მიიღებს კონტროლს. გადატვირთვისას, სიტუაცია შეიძლება განსხვავებული იყოს.

ზარის მოლოდინი ()

განვიხილოთ შემდეგი პროგრამა. ამ პროგრამაში, ზარის არსებობის გამო დაელოდე () მშობელი პროცესი ყოველთვის ელოდება ბავშვის პროცესის დასრულებას. ამ შემთხვევაში ეკრანზე მივიღებთ მკაცრად განსაზღვრულ ტექსტს

exec() ზარი

განიხილეთ გამოწვევა exec (). ეს სისტემური ზარი გამოდგება მაშინ, როცა გვსურს სრულიად განსხვავებული პროგრამის გაშვება. აქ ჩვენ დავუძახებთ execvp () wc პროგრამის გასაშვებად, რომელიც არის სიტყვების დამთვლელი პროგრამა. რა ხდება exec()-ის გამოძახებისას? ამ ზარს არგუმენტად გადაეცემა შესრულებადი ფაილის სახელი და ზოგიერთი პარამეტრი. რის შემდეგაც კოდი და სტატიკური მონაცემები ამ შესრულებადი ფაილიდან იტვირთება და მისი სეგმენტი კოდით გადაიწერება. მეხსიერების დარჩენილი არეები, როგორიცაა სტეკი და გროვა, ხელახლა ინიცირებულია. რის შემდეგაც OS უბრალოდ ახორციელებს პროგრამას, გადასცემს მას არგუმენტების ერთობლიობას. ასე რომ, ჩვენ არ შევქმენით ახალი პროცესი, ჩვენ უბრალოდ გადავიყვანეთ ამჟამად გაშვებული პროგრამა სხვა გაშვებულ პროგრამად. Exec() ზარის შთამომავლში შესრულების შემდეგ, როგორც ჩანს, ორიგინალური პროგრამა საერთოდ არ მუშაობდა.

გაშვების ეს გართულება სრულიად ნორმალურია Unix ჭურვისთვის და საშუალებას აძლევს ამ გარსს შეასრულოს კოდი დარეკვის შემდეგ. ჩანგალი (), მაგრამ ზარის წინ exec (). ასეთი კოდის მაგალითი იქნება გარსის გარემოს მორგება გაშვებული პროგრამის საჭიროებებზე, მის გაშვებამდე.

შელი - უბრალოდ მომხმარებლის პროგრამა. ის გაჩვენებთ მოსაწვევის ხაზს და ელოდება, როდის დაწერთ მასში რაღაცას. უმეტეს შემთხვევაში, თუ იქ დაწერთ პროგრამის სახელს, ჭურვი იპოვის მის მდებარეობას, გამოიძახებს fork() მეთოდს და შემდეგ გამოიძახებს რაიმე ტიპის exec() ახალი პროცესის შესაქმნელად და დაელოდება მის დასრულებას. დაველოდოთ() ზარი. როდესაც ბავშვის პროცესი გადის, shell დაბრუნდება wait() ზარიდან და კვლავ დაბეჭდავს მოთხოვნას და დაელოდება შემდეგი ბრძანების შეყვანას.

fork() & exec() split საშუალებას აძლევს shell-ს გააკეთოს შემდეგი რამ, მაგალითად:
wc ფაილი > new_file.

ამ მაგალითში, wc პროგრამის გამომავალი გადამისამართებულია ფაილზე. ჭურვის მიღწევის გზა საკმაოდ მარტივია - დარეკვამდე ბავშვის პროცესის შექმნით exec (), ჭურვი ხურავს სტანდარტულ გამომავალს და ხსნის ფაილს ახალი_ფაილი, ამრიგად, ყველა გამომავალი შემდგომი გაშვებული პროგრამისგან wc ეკრანის ნაცვლად გადამისამართდება ფაილზე.

Unix მილი ხორციელდება ანალოგიურად, იმ განსხვავებით, რომ ისინი იყენებენ pipe() გამოძახებას. ამ შემთხვევაში, პროცესის გამომავალი ნაკადი დაუკავშირდება ბირთვში მდებარე მილების რიგს, რომელსაც დაუკავშირდება სხვა პროცესის შეყვანის ნაკადი.

წყარო: www.habr.com