ЗМІСТ
ВСТУП
Аналіз завдання і розробка алгоритму
Теоретичні відомості
Лістинг програми
Тестування
ВИСНОВКИ
ЛІТЕРАТУРА
ВСТУП
Метою виконання роботи є закріплення знань умінь і навичок у сфері взаємодії модулів, використання системних викликів і бібліотечних функцій управління процесами і файлами сучасних операційних систем для створення системних і призначених для користувача програм, процедур і функцій на прикладі ОС сімейства UNIX / Linux. У ході виконання роботи студенту необхідно продемонструвати знання функцій, алгоритмів, механізмів управління процесами, розділяютьсяресурсами, файлами, введенням-виводом.
Процес - поняття, яке визначається по-різному. Це може бути - "впорядкований набір команд і належних йому ресурсів". З точки зору ОС Unix процес - це об'єкт, зареєстрований в спеціальній таблиці процесів.
Тілом процесу називається набір команд і даних, якими оперує процес.
Контекст процесу - атрибут, який присутній практично у всіх ОС, в різних ОС він може називатися по-різному. Контексти всіх процесів розміщуються в адресному просторі ОС і містять оперативну інформацію про стан процесу та поточну інформацію, пов'язану з процесом і його запуском.
1 АНАЛІЗ ЗАВДАННЯ ТА РОЗРОБКА АЛГОРИТМУ
За завданням згідно варіанту за списком необхідно організувати копіювання вмісту з файлу 1 в інші файли (1 -> 2, 1 -> 3, 1 -> 4).
Основні принципи за якими буде створюватися програма:
Будуть створені 4-е процесу, а саме перший процес породить 2-ий процес, 1-ий процес, у свою чергу породить третій процес, 1-ий процес породить 4-тий процес.
Кожен процес буде мати файл з відповідними іменами - file1, file2, file3, file4.
Процеси будуть обмінюватися через поділювану пам'ять і тимчасовий файл.
Обмін вмістом файлів буде відбуватися за сигналом, семафори та обміну повідомленнями.
Процеси Process 1 і Process 4 обмінюються користувацькими сигналами, за якими виконується запис процесом P rocess 1 у тимчасовий файл Temp f ile, після чого Process 4 зчитує з нього дані, видаляє тимчасовий файл, потім записує інформацію в File4, чекає завершення обміну між процесами Process 2, Process 3, закриває поділювану пам'ять і знищує всю групу процесів.
Процеси Process 1 і Process 2 взаємодіють за допомогою семафорів. Process 1 записує до колективної пам'ять вміст файлу File1, після цього по семафору Process 2 зчитує з пам'яті дані і пише в File2.
Процеси Process 2 і Process 3 взаємодіють за допомогою черги повідомлень. Коли дані вже записані процесом Process 2 в File2, він відсилає повідомлення своєму нащадку, після чого Process 3 зчитує з пам'яті, що розділяється дані, пише у свій файл File3, відсилає повідомлення назад і завершується, після чого припиняється, і його батько Process 2.
Рис.1 Схема взаємодії процесів
2 ТЕОРЕТИЧНІ ВІДОМОСТІ
З використанням функцій у мові СІ пов'язані три поняття - визначення функції (опис дій, виконуваних функцією), оголошення функції (завдання форми звертання до функції) і виклик функції.
Визначення функції задає тип значення, що повертається, ім'я функції, типи і кількість формальних параметрів, а також оголошення змінних і оператори, звані тілом функції, і визначають дію функції. У визначенні функції також може бути заданий клас пам'яті.
Функція fork:
int fork ()
Виклик fork приводить до створення нового процесу (породженого процесу) - точної копії процесу, зробив виклик (батьківського процесу). Точніше, породжений процес успадковує біля батьківського процесу такі характеристики:
Оточення.
Прапор "закрити при виконанні виклику exec"
Способи обробки сигналів (тобто SIG_DFL, SIG_IGN, SIG_HOLD, адреси функцій обробки сигналів).
Дозвіл перевстановлювати діючий ідентифікатор користувача.
Дозвіл перевстановлювати діючий код групи.
Стан профілювання (включено / вимкнено).
Значення поправки до пріоритету.
Усі приєднані сегменти пам'яті.
Ідентифікатор групи процесів.
Ідентифікатор групи терміналу.
Поточний робочий каталог.
Кореневий каталог.
Маска режиму створення файло ст.
Обмеження на розмір файлу.
Породжений процес відрізняється від батьківського процесу наступним:
Породжений процес має свій унікальний ідентифікатор процесу.
Породжений процес має інший ідентифікатор батьківського процесу, рівний ідентифікатором, його породив.
Породжений процес має свої власні копії батьківських дескрипторів файлів. Кожен дескриптор файлу породженого процесу розділяє з відповідним батьківським дескриптором файлу загального покажчик поточної позиції у файлі.
Всі semadj значення скидаються.
Породжений процес не успадковує у батьківського процесу ознак утримання в пам'яті сегменту команд, даних або всього процесу цілком.
Обнуляються лічильники часу, витраченого на обслуговування цього процесу (tms_utime, tms_stime, tms_cutime, tms_cstime). Скасовується запит до будильника.
3 Лістинг програм
Програма складається з головного модуля rgr. C:
# Include <sys/types.h>
# Include <sys/ipc.h>
# Include <sys/shm.h>
# Include <sys/sem.h>
# Include <unistd.h>
# Include <signal.h>
# Include <fcntl.h>
# Include <stdio.h>
# Include <errno.h>
# Define SHMKEY 5
# Define SEMKEY 5
# Define K 32
# Define Count 4
# Define InitVal {1,0,0,0}
# Define MSGKEY 5
# Define InitT 3
void creat_mem (void);
void creat_sem (void);
void prss1 (void);
void prss2 (void);
void prss3 (void);
void prss4 (void);
int pid1; int pid2; int pid3; int pid4; int pid; int ppid;
int fd; int st;
extern int p14 (int), p41 (int);
/ / Mem
int shmid;
int * pint;
char * addr;
/ / Sem
int semid;
short initarray [Count] = InitVal;
struct sembuf p, v;
/ / Message:
int prnum;
int msgid;
long nextT;
struct {
long mtype;
int Data;
} Message;
int main (void)
{
remove ("file2");
remove ("file3");
remove ("file4");
creat_mem ();
creat_sem ();
pid1 = getpid ();
pid = fork ();
if (! pid) prss2 ();
else prss1 ();
sleep (2);
wait (& st);
}
void creat_mem (void)
{
printf ("--- func creat_mem (): memory creating:% dbytes --- pid =% d \ n ", K, getpid ());
shmid = shmget (SHMKEY, 1 * K, 0777 | IPC_CREAT);
addr = shmat (shmid, 0, 0);
pint = (int *) addr;
}
void creat_sem (void)
{
printf ("--- func creat_sem (): semaphor creating: --- pid =% d \ n ", getpid ());
semid = semget (SEMKEY, Count, 0777 | IPC_CREAT);
semctl (semid, Count, SETALL, initarray);
p.sem_op = -1;
p.sem_flg = SEM_UNDO;
v.sem_op = 1;
v.sem_flg = SEM_UNDO;
}
void creat_mesg (void)
{
msgid = msgget (MSGKEY, 0666 | IPC_CREAT);
msgsnd (msgid, (struct msgbuf *) & Message, 8, 0);
}
void prss1 (void)
{
int i;
char buf [32] = "";
prnum = 1;
p.sem_num = 0;
v.sem_num = 1;
ppid = getppid ();
printf ("= I = prss% d, pid =% d, parent:% d \ n", prnum, pid1, ppid);
pid = fork ();
if (! pid) prss4 ();
else
{
fd = open ("file1", O_RDONLY);
read (fd, buf, strlen (buf));
close (fd);
printf ("I: reading from FILE1: \ t% s \ n", buf);
signal (SIGUSR2, p41);
sleep (1); / / ojidanie priema signala ot prssa4
kill (pid1 +2, SIGUSR1);
printf ("================== prss1: writing to memory \ n ");
for (i = 0; i <= 31; + + i) pint [i] = buf [i];
semop (semid, & p, 1);
semop (semid, & v, 1);
sleep (2);
wait (& st);
wait (& st);
printf ("= I = __eto konec prssa% d \ n", prnum);
}
}
void prss2 (void)
{
int i;
char buf_2 [32] = "";
prnum = 2;
p.sem_num = 1;
pid2 = getpid ();
ppid = getppid ();
printf ("= II = prss% d, pid =% d, parent:% d \ n", prnum, pid2, ppid);
creat ("file2", fd);
pid = fork ();
if (! pid) prss3 ();
else
{
semop (semid, & p, 1);
printf ("================== prss% d: file2 editing / Semaphor / \ n ", prnum);
fd = open ("file2", O_WRONLY);
for (i = 0; i <= 31; + + i) buf_2 [i] = pint [i];
write (fd, buf_2, strlen (buf_2));
printf ("II: writing to FILE2: \ t% s \ n", buf_2);
printf ("--- func creat_mesg (): message creating: --- pid =% d \ n ", pid2);
Message.mtype = InitT;
Message.Data = 3;
creat_mesg ();
printf ("= II = __eto konec prssa% d \ n", prnum);
fclose (fd);
}
}
void prss3 (void)
{
int i;
char buf_3 [32] = "";
prnum = 3;
pid3 = getpid ();
ppid = getppid ();
printf ("= III = prss% d, pid =% d, parent:% d \ n", prnum, pid3, ppid);
creat ("file3", fd);
msgrcv (msgid, (struct msgbuf *) (& Message), 8, prnum, 0);
if (Message.Data == 3)
{
printf ("================== prss% d: file3 editing / Message / \ n ", prnum);
fd = open ("file3", O_WRONLY);
for (i = 0; i <= 31; + + i) buf_3 [i] = pint [i];
write (fd, buf_3, strlen (buf_3));
printf ("III: writing to FILE3: \ t% s \ n", buf_3);
printf ("= III = __eto konec prssa% d \ n", prnum);
fclose (fd);
}
}
void prss4 (void)
{
int i;
prnum = 4;
pid4 = getpid ();
ppid = getppid ();
printf ("= IV = prss% d, pid =% d, parent:% d \ n", prnum, pid4, ppid);
creat ("file4", fd);
signal (SIGUSR1, p14);
kill (pid1, SIGUSR2);
sleep (1);
printf ("= IV = __eto konec prssa% d \ n", prnum);
shmctl (shmid, IPC_RMID, 0);
printf ("================== prss4: memory closed \ n ");
kill (0, SIGKILL);
}
int p14 (int signum) / / 2-oj sig
{
char temp_buf4 [32] = "";
signal (SIGUSR1, p14);
printf ("*** SIGUSR1 ***: prss 4 (% d) has got a signal from prss 1 (% d) \ n ", pid4, pid1);
fd = open ("temp_file", O_RDONLY);
read (fd, temp_buf4, strlen (temp_buf4));
close (fd);
creat ("file4", fd);
printf ("* * SIGUSR1 * *: writing from temp_file to file4 \ n");
fd = open ("file4", O_WRONLY);
write (fd, temp_buf4, strlen (temp_buf4));
close (fd);
printf ("IV: writing to FILE4: \ t% s \ n", temp_buf4);
remove ("temp_file");
printf ("* * SIGUSR1 * *: temp_file was removed \ n");
printf ("*** SIGUSR1 ***: end \ n ");
}
int p41 (int signum) / / 1-ij sig
{
char temp_buf1 [32] = "";
signal (SIGUSR2, p41);
printf ("*** SIGUSR2 *** prss 1 (% d) has got a signal from prss 4 (% d) \ n ", pid1, pid1 +2);
fd = open ("file1", O_RDONLY);
read (fd, temp_buf1, strlen (temp_buf1));
close (fd);
creat ("temp_file", fd);
printf ("* * SIGUSR2 * *: temp_file was created \ n");
fd = open ("temp_file", O_WRONLY);
write (fd, temp_buf1, strlen (temp_buf1));
close (fd);
printf ("*** SIGUSR2 ***: end \ n ");
}
4 ТЕСТУВАННЯ
Результат виконання програми в консолі:
yuna @ YunieHost: / media/8_Gb_hard_ONPU/LINUX/rgr 28march $. / rgr
--- Func creat_mem (): memory creating: 32bytes --- pid = 6798
--- Func creat_sem (): semaphor creating: --- pid = 6798
= II = prss2, pid = 6799, parent: 6798
= I = prss1, pid = 6798, parent: 6655
= III = prss3, pid = 6801, parent: 6799
= IV = prss4, pid = 6800, parent: 6798
I: reading from FILE1: <<RGR sPO by yuna 18.05.2008>>
*** SIGUSR2 *** prss 1 (6798) has got a signal from prss 4 (6800)
* * SIGUSR2 * *: temp_file was created
*** SIGUSR2 ***: end
================== Prss1: writing to memory
================== Prss2: file2 editing / Semaphor /
II: writing to FILE2: <<RGR sPO by yuna 18.05.2008>>
--- Func creat_mesg (): message creating: --- pid = 6799
= II = __eto konec prssa2
*** SIGUSR1 ***: prss 4 (6800) has got a signal from prss 1 (6798)
================== Prss3: file3 editing / Message /
III: writing to FILE3: <<RGR sPO by yuna 18.05.2008>>
= III = __eto konec prssa3
* * SIGUSR1 * *: writing from temp_file to file4
IV: writing to FILE4: <<RGR sPO by yuna 18.05.2008>>
* * SIGUSR1 * *: temp_file was removed
*** SIGUSR1 ***: end
= IV = __eto konec prssa4
================== Prss4: memory closed
Killed
Рис.2 Результат роботи програми (вміст із file 1 було скопійовано в інші файли)
Отже, програма працює коректно і поставлена на дану розрахунково-графічну роботу задача була вирішена.
ВИСНОВКИ
У даній роботі частково описана структура системи UNIX, взаємини між процесами, що виконуються в режимі завдання і в режимі ядра. Процеси виконуються в режимі завдання або в режимі ядра, в якому вони користуються послугами системи завдяки наявності набору звернень до операційної системи.
Архітектура системи підтримує такий стиль програмування, при якому з невеликих програм, що виконують тільки окремі функції, але добре, складаються більш складні програми, що використовують механізм каналів і перепризначення введення-виведення.
Звернення до операційної системи дозволяють процесам здійснювати операції, які інакше не виконуються. На додаток до обробки подібних звернень ядро операційної системи здійснює спільні облікові операції, управляє плануванням процесів, розподілом пам'яті та захистом процесів в оперативній пам'яті, обслуговує переривання, управляє файлами та пристроями і обробляє особливі ситуації, що виникають в системі.
У функції ядра системи UNIX навмисно не включено багато функцій, що є частиною інших операційних систем, оскільки набір звернень до системи дозволяє процесам виконувати всі необхідні операції на рівні користувача.
ЛІТЕРАТУРА
Дж. Такете (мол.), С. Барнет. Використання Linux / Спеціальне видання.: 5-е вид.: Пер. з англ.: Уч.пос. - М.: Видавничий дім «Вільямс», 2000. - 784 с.
Максимальний захист Linux. Мистецтво налаштування.: Пер. з англ. / под.ред. Дж.Рея - СПб.: ТОВ «ДіаСофтЮП», 2002. - 752 с.
Браун С. Операційна система UNIX - М.: Світ, 1986 - 463 с.