Zarządzanie procesami,

Cześć,
mam do napisania program, lecz facet nic nie tłumaczy na zajęciach a z dostępnych źródeł nic nie rozumiem... do tej pory napisałem tyle:

#include <fcntl.h>
#include<unistd.h>

int main(int argc, int *argv[1])
{
int ppm, mapipp, mipdpp, mapdpp;
if (argc<6)
{printf("za malo parametrow\n");exit(-1);}
if(argc>6)
{printf("za duzo parametrow\n");exit(-1);}
argv[1]=ppm;
argv[2]=mipipp;
argv[3]=mapipp;
argv[4]=mipdpp;
argv[5]=mapdpp;

return(0);
}

I na tym stanąłem... nie wiem, co dalej... nie rozumiem treści zadania nawet. Pomoże ktoś

Proszę napisać program tworzący i zarządzający procesami oraz wykorzystujący elementarne operacje Uniksa dostępu do pliku. Program powinien realizować następujące zadania:
1. Program powinien byd uruchamiany z 5 parametrami: 
1 – priorytet procesu macierzystego 
2 – 3 minimalny i maksymalny priorytet pierwszego procesu potomnego 
4 – 5 minimalny i maksymalny priorytet drugiego procesu potomnego
2. Utworzyć proces tworzący kopie pliku monalisa.bmp (zastosować funkcję system)
3. Utworzyć 2 procesy różnymi technikami (fork, fork exec , spawn) i nadać im priorytet z zadanego przy uruchomieniu programu przedziału liczb. Procesy realizują następujące (identyczne) zadania:
a) Odczytują liczbę wierszy i liczbę pikseli w wierszu bitmapy
b) Odczytują jedną linię bitmapy (konieczna znajomość liczby pikseli w wierszu)
c) Dokonują dowolnego przekształcenia liniowego lub nieliniowego wartości RGB pikseli w odczytanej linii obrazka
d) Zapisują przekształconą linię obrazka do kopii bitmapy
e) Zmieniają losowo priorytet procesu w granicach podanych przy uruchomieniu
f) Przechodzą do punktu b odczytując kolejną linię obrazka
4. Proces główny wyświetla informację o PID utworzonych procesów i kończy się po zakończeniu działania procesów potomnych.
W trakcie odczytu i zapisu jednej linii obrazka zastosować dowolny algorytm wykluczania (ochrony sekcji krytycznej) niekorzystający z mechanizmów systemu operacyjnego (semafory, muteksy).

Z góry dzięki za jakąkolwiek pomoc.

argv[1]=ppm;
argv[2]=mipipp;
argv[3]=mapipp;
argv[4]=mipdpp;
argv[5]=mapdpp;

chyba odwrotnie??

ppm=atoi(argv[1]);
mipipp=atoi(argv[2]);

etc.

Mam jedno pytanie:

int main(int argc, int *argv[1])

Co to, prostytutka, jest?

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdbool.h>
#include <sched.h>
#include <sys/mman.h>
#define B_SIZE 60

typedef struct {
int z;
int chce1;
int chce2;
int kto_czeka;
} bufor_t;

int main (int argc, char argv[] )
{
bufor_t buf;
struct sched_param par;
pid_t pid;
int stat;
int fd, size;
int chce1=0;
int chce2=0;
int kto_czeka=1;
int potomny1, potomny2, macierzysty;
int k=0;
int z,q=0;
unsigned char buf_naglowek[54];
unsigned char bufor;
int fd1,fd2, i=0, w_pliku=0, wysokosc=0, szerokosc=0, l_pix=0, bufsize;
ssize_t nread, nwrite;
off_t newpos;
charprioryt1 =argv[1];
charprioryt2 =argv[2];
charprioryt3 =argv[3];
charprioryt4 =argv[4];
charprioryt5 =argv[5];
int priorytet1=(int)prioryt1;
int priorytet2=(int)prioryt2;
int priorytet3=(int)prioryt3;
int priorytet4=(int)prioryt4;
int priorytet5=(int)prioryt5;
int pp1 = rand()%priorytet3 + priorytet2 + 1;
int pp2 = rand()%priorytet5 + priorytet4 + 1;

// Tworzenie pamieci wspolnej

if((fd=shm_open("bufo",O_RDWR | O_CREAT, 07774)) == -1)
{	perror("open");
	exit(-1); }

size = ftruncate (fd, sizeof(bufor_t));
if (size < 0)
{	perror("trunc");
	exit(-1); }
	
buf = (bufor_t*) mmap(0, sizeof(bufor_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (buf == NULL)
{	perror("map");
	exit(-1); }


	// Sprawdzanie parametrow


if (argc < 6)
{
 printf(" Nie podales za mao parametru \n"); 
 exit (1); 
 }

if (argc > 6)

{
printf(" Podales zbyt duzo paramterow \n");
exit (1); 
}


// Sprawdzanie i otwieranie pliku monalisa

if (access("monalisa.bmp", F_OK) == -1)
{
perror("monalis.bmp nie istnieje \n");
exit(1);
}
system("cp /tmp/Cei/pr2/monalisa.bmp /tmp/Cei/pr2/monalisa-kopia.bmp");  
if ((fd1 = open ("monalisa-kopia.bmp", O_RDWR)) == -1)
{
 perror (" Nie idzie otworzyc pliku monalisa-kopia.bmp\n"); 
 exit(1);
 }

 //Sprawdzanie obrazka

newpos = lseek (fd1, (off_t)2, SEEK_SET);	// od 2 bajtu wielkosc pliku - 4 bajtowa dana
nread = read (fd1, buf_naglowek, 4);	
for (i=3;i>=0;i--)
w_pliku=w_pliku<<8 | (int) buf_naglowek[i];

newpos = lseek (fd1, (off_t)18, SEEK_SET);	// od 18 bajtu szerokosc obrazka - 4 bajtowa dana
nread = read (fd1, buf_naglowek, 4);	
for (i=3;i>=0;i--)
szerokosc=szerokosc<<8 | (int) buf_naglowek[i];

nread = read (fd1, buf_naglowek, 4);	// od 22 bajtu wysokosc obrazka - 4 bajtowa dana
for (i=3;i>=0;i--)
wysokosc=wysokosc<<8 | (int) buf_naglowek[i];

newpos = lseek (fd1, (off_t)28, SEEK_SET);	// od 28 bajtu liczba bajtow na piksel - 2 bajtowa dana
nread = read (fd1, buf_naglowek, 2);
for (i=1;i>=0;i--)
l_pix=l_pix<<8 | (int) buf_naglowek[i];

printf(" szerokosc obrazka= %d \n wysokosc obrazka = %d \n liczba bitow na piksel = %d \n wilekosc pliku = %d bajtow \n",szerokosc, wysokosc, l_pix, w_pliku);

bufsize = szerokosc * l_pix / 8;

• unsigned char bufor[bufsize]; * pamiec powinna byc przydzielona dynamicznie
  bufor = malloc (bufsize * sizeof (unsigned char));

newpos = lseek (fd1, (off_t)54, SEEK_SET); // od 54 bajtu piksele obrazka (po 3 bajty na piksel) zaczynajac od ostaniej linii

par.sched_priority=priorytet1;
sched_setparam(0,&par);
macierzysty = getpid();

buf->chce1=0;
buf->chce2=0;
buf->kto_czeka=1;
// Potomny1
pid = fork();

if (pid==0)

{
potomny1 = getpid();
par.sched_priority=pp1;
sched_setparam(0,&par);
printf("PID procesu1 = %d\n",potomny1);

// Potomny 2
pid = fork();

  if (pid==0)
  {
  potomny2 = getpid();
  par.sched_priority=pp2;
  sched_setparam(0,&par);
 printf("PID procesu2 = %d\n",potomny2);

        }

}

if (getpid()==potomny1)
{

while (z<=wysokosc)
{

buf->chce1=1;
buf->kto_czeka=1;
while ((buf->kto_czeka==1) &&( buf->chce2==1))
{
}
nread = read (fd1, bufor, bufsize); //odczytaj linie do bufora

newpos = lseek (fd1, -nread, SEEK_CUR); // cofnij sie o ile odczytane
buf->chce1=0;
for (i=0; i<szerokosc; i++)
{

		bufor[(3*i)]=255-bufor[3*i];
		bufor[(3*i)+1]=255- bufor[3*i+1];
		bufor[(3*i)+2]=255- bufor[3*i+2];
		}

		

z++;

buf->chce1=1;
buf->kto_czeka=1;

while ((buf->kto_czeka==1) &&( buf->chce2==1))
{
}

nwrite = write (fd1, bufor, (ssize_t)bufsize );
buf->chce1=0;
pp1 = rand()%priorytet3 + priorytet2 + 1;
par.sched_priority=pp1;
sched_setparam(0,&par);
sleep(0.9);
}
}

if (getpid()==potomny2)

{
while (z<=wysokosc)
{

buf->chce2=1;
buf->kto_czeka=2;

while (buf->kto_czeka==2 && buf->chce1==1)
{
}
nread = read (fd1, bufor, bufsize); //odczytaj linie do bufora
newpos = lseek (fd1, -nread, SEEK_CUR); // cofnij sie o ile odczytane
buf->chce2=0;

		for (i=0; i<szerokosc; i++)
			{
			
		bufor[(3*i)]=255-bufor[3*i];
		bufor[(3*i)+1]=255- bufor[3*i+1];
		bufor[(3*i)+2]=255- bufor[3*i+2];
		}

		

z++;

buf->chce2=1;
buf->kto_czeka=2;

while (buf->kto_czeka==2 && buf->chce1==1)
{
}

nwrite = write (fd1, bufor, (ssize_t)bufsize ); 

buf->chce2=0;
}
pp2 = rand()%priorytet5 + priorytet5 + 1;
par.sched_priority=pp2;
sched_setparam(0,&par);
sleep(0.9);
}

if(pid!=0)
{

wait (&stat);
shm_unlink("bufo");
printf("macierzysty = %d\n",macierzysty);

}
exit(0);
}

witam... ja mam na zaliczenie podobny temat jak w poscie ale z tym, ze musze zrobic funkcja i) Proces 1 – spawn, Proces 2 - exec ... Z tego materialu juz ogarnalem 3 pierwsze punkty a dalej juz nie wiem co sie dzieje, o tu zrobione jest fork fork

Proszę napisać program tworzący i zarządzający procesami oraz wykorzystujący elementarne operacje Uniksa dostępu do pliku. Program powinien realizować następujące zadania:

1. Program powinien być uruchamiany z 5 parametrami:
    1 – priorytet procesu macierzystego
    2 – 3 minimalny i maksymalny priorytet pierwszego procesu potomnego
    4 – 5 minimalny i maksymalny priorytet drugiego procesu potomnego
2. Utworzyć proces tworzący kopie pliku monalisa.bmp (zastosować funkcję system)
3. Odczytać liczbę wierszy bitmapy oraz liczbę pikseli w wierszu bitmapy (parametry przekazać procesom potomnym).
4. Utworzyć 2 procesy potomne następującymi technikami:
   a) Proces 1 – fork, Proces 2 – fork
   b) Proces 1 – exec , Proces 2 - fork
   c) Proces 1 – fork, Proces 2 – exec
   d) Proces 1 – exec, Proces 2 - exec
   e) Proces 1 – fork, Proces 2 - spawn
   f) Proces 1 – spawn, Proces 2 - fork
   g) Proces 1 – spawn, Proces 2 - spawn
   h) Proces 1 – exec, Proces 2 - spawn
   i) Proces 1 – spawn, Proces 2 - exec
5. Oba utworzone procesy tworzą dodatkowy wątek którego zadaniem jest losowa zmiana priorytetu wątku głównego tego procesu w granicach podanych przy uruchomieniu. Zmiana priorytetu powinna odbywać się co 1 sek.
6. Wątki główne procesów realizują następujące (identyczne) zadania:
   a) Odczytują jedną linię bitmapy (konieczna znajomość liczby pikseli w wierszu oraz liczba bitów na jeden piksel bitmapy)
   b) Dokonują dowolnego przekształcenia liniowego lub nieliniowego wartości RGB pikseli w odczytanej linii obrazka
   c) Zapisują przekształconą linię obrazka do kopii bitmapy
   d) Jeśli nie odczytano wszystkich linii obrazka przechodzą do punktu a
   e) Gdy wszystkie linie odczytane usuwają wątek zmieniający priorytet, a następnie wyświetlają informację o liczbie linii obrazka jaką przekształciły i kończą swoje działanie
7. Proces macierzysty wyświetla informację o PID utworzonych procesów, a następnie czeka na zakończenie procesów potomnych.
8. Po zakończeniu procesów potomnych proces macierzysty kończy swoje działanie.
   W trakcie odczytu i zapisu jednej linii obrazka zastosować dowolny algorytm wykluczania. Zmienne (semafory, muteksy, inne zmienne), które muszą być dostępne w obu procesach potomnych umieścić w pamięci współdzielonej.
   prosze o pomoc kogos kto ogarnia

Udało mi już stworzyć taki oto kod:
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <sched.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <pthread.h>

typedef struct {
int liczg, liczsp, liczex;
int ml, bufsize;
int w_pliku;
int wysokosc;
int szerokosc;
int l_pix;
//int tpar[5];
pid_t xpidsp, xpidex;
int pidsp, pidex;
off_t newpos;
sem_t sem;
} bufor_dziel;
int main (int argc, char *argv[] )
{
printf("1 \n");
bufor_dziel buf;
sem_init (&buf->sem, 1, 1);
int pam_dziel, size; // pamiec dzielona
struct sched_param par;
ssize_t nread, nwrite;
off_t newpos;
pid_t xpid;
int i=0, status;
int pidmacierzysty;
unsigned char buf_naglowek[54];
buf->w_pliku=0;
buf->wysokosc=0;
buf->szerokosc=0;
buf->l_pix=0;
/buf->tpar[0]=atoi(argv[1]);
buf->tpar[1]=atoi(argv[2]);
buf->tpar[2]=atoi(argv[3]);
buf->tpar[3]=atoi(argv[4]);
buf->tpar[4]=atoi(argv[5]);/
printf("2 \n");
//////////////////////////// przydzielenie paieci dzilonej *//////////////////

if((pam_dziel=shm_open("bufo",O_RDWR | O_CREAT, 07774)) == -1)
{	perror("open");
	exit(-1); }
printf("3 \n");
size = ftruncate (pam_dziel, sizeof(bufor_dziel));
if (size < 0)
{	perror("trunc");
	exit(-1); }
printf("4 \n");
buf = (bufor_dziel*) mmap(0, sizeof(bufor_dziel), PROT_READ | PROT_WRITE, MAP_SHARED, pam_dziel, 0);
if (buf == NULL)
{	perror("map");
	exit(-1); }
printf("5 \n");



if (argc < 6)
{
 printf(" Błąd - za mało parametrów \n");
 exit (1);
 }

if (argc > 6)

{
printf(" Błąd - za dużo parametrów \n");
exit (1);
}
printf("6 \n");
////////////////////////////*kopiuj monalisa*//////////////////

printf ("\n");

pid_t xpidcp = fork();
if (xpidcp > 0)
	wait(&status);
if (xpidcp == 0)
{
	if (access("monalisaorg.bmp", F_OK) == -1)
	{
		perror(" Plik monalisaorg.bmp \n");
		exit(1);
	}
	else
	{
	system("cp /tmp/Projekt1/monalisaorg.bmp /tmp/Projekt1/monalisacopy.bmp");
	exit(0);
	}
}
if ((buf->ml = open ("monalisacopy.bmp", O_RDWR)) == -1)
{
 perror (" Brak możliwości otwarcia \n");
 exit(1);
}


////////////////////////////* sprawdzanie i wpisanie parametrow obrazka *//////////////////

newpos = lseek (buf->ml, (off_t)2, SEEK_SET);	// od 2 bajtu wielkosc pliku - 4 bajtowa dana
nread = read (buf->ml, buf_naglowek, 4);
for (i=3;i>=0;i--)
buf->w_pliku=buf->w_pliku<<8 | (int) buf_naglowek[i];

newpos = lseek (buf->ml, (off_t)18, SEEK_SET);	// od 18 bajtu szerokosc obrazka - 4 bajtowa dana
nread = read (buf->ml, buf_naglowek, 4);
for (i=3;i>=0;i--)
buf->szerokosc=buf->szerokosc<<8 | (int) buf_naglowek[i];

nread = read (buf->ml, buf_naglowek, 4);	// od 22 bajtu wysokosc obrazka - 4 bajtowa dana
for (i=3;i>=0;i--)
buf->wysokosc=buf->wysokosc<<8 | (int) buf_naglowek[i];

newpos = lseek (buf->ml, (off_t)28, SEEK_SET);	// od 28 bajtu liczba bajtow na piksel - 2 bajtowa dana
nread = read (buf->ml, buf_naglowek, 2);
for (i=1;i>=0;i--)
buf->l_pix=buf->l_pix<<8 | (int) buf_naglowek[i];

printf(" szerokosc obrazka= %d \n wysokosc obrazka = %d \n liczba bitow na piksel = %d "
"\n wilekosc pliku = %d bajtow \n",buf->szerokosc, buf->wysokosc, buf->l_pix, buf->w_pliku);

buf->newpos = lseek (buf->ml, (off_t)54, SEEK_SET);
buf->bufsize = buf->szerokosc * buf->l_pix / 8;

//par.sched_priority=buf->tpar[1];
//sched_setparam(0,&par);
pidmacierzysty = getpid();
printf("PID macierzystego= %d \n","Priorytet macierzystego= %d \n",pidmacierzysty,sched_getparam(pidmacierzysty,&par));

////////////////////////////* 1 proces spawnl *//////////////////

buf->xpidsp=spawnl(P_NOWAIT,"./funspawnl","funspawnl",NULL);
if (buf->xpidsp>0)
buf->pidsp=buf->xpidsp;
////////////////////////////* 2 proces execl *//////////////////
xpid=fork();
if (xpid > 0)
{
printf("Jestem procesem macierzystym po fork. Moj PID = %d, PID potomka = %d \n",pidmacierzysty,xpid);
}

if (xpid==0)
	{
		buf->pidex=getpid();
		printf("Jestem procesem potomnym przed execl. Moj PID = %d",buf->pidex);
		execl("./funexecl","funexecl",NULL);
	}
waitpid(buf->pidsp,NULL,NULL);
waitpid(buf->pidex,NULL,NULL);

exit(0);
}

jednak program po kompilacji i próbie uruchomienia wyświetla: memory fault (core dumped). Obojętnie czy podaje 2,3 czy 5 parametrów dalej to samo.
Program ma być dla środowiska QNX