dubbi sul pause()...sotto unix

[Ricky]

ragazzi non riesco a capire bene l utilizzo di questa funzione:quando metto un processo in pause, esso dovrebbe risvegliarsi alla ricezione di un segnale gestito da un apposita funzione ad esempio:


//da processo 1
...
signal(SIGUSR1,sveglio);
pause();
...

//da altro processo
...
kill(processo1,SIGUSR1);
...

//il sig_handler
...
void sveglio()
{
printf("mi sveglio\n");
return;
}

va bene cosi?dovrebbe ripartire il padre dove si era fermato? il fatto è che non sempre si sveglia...ad esempio, può succedere che quando va di nuovo in pausa nn si risveglia più!

c è qualcuno che può aiutarmi?

[Ricky]

UP!!

[ilsensine]

Posta un programmino completo e compilabile che consente di riprodurre il problema.

[Ricky]

http://forum.hwupgrade.it/showthread...hreadid=828647

una domandina facile facile...ma per fare ping pong tra due processi mi conviene usare i segnali? o meglio se faccio waitpid con un uso opportuno?

[Ricky]

per farla semplice non funziona neanche questo:

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void sveglio()
{
printf("sveglia\n");
// raise(SIGCONT);
}

int main(){
int figlio;


signal(SIGUSR1,sveglio);

printf(" proviamo i pause, se arrivo alla fine allora funge altrimenti uccidere con ctrl+c\n");
figlio=fork();
if (figlio==0){
pause();
kill(getppid(),SIGUSR1);
pause();
kill(getppid(),SIGUSR1);
pause();
exit(0);
}else{
sleep(1);

kill(figlio,SIGUSR1);
pause();
kill(figlio,SIGUSR1);
pause();
kill(figlio,SIGUSR1);
waitpid(figlio,NULL,NULL);
printf("finito\n");
}
}

[ilsensine]

Qui funziona, ma per pura fortuna.

Il programma è suscettibile di una ovvia race condition se avviene un context switch tra una kill() e la successiva pause(): in questa situazione, un processo esegue una kill mentre l'altro ancora non è nello stato di pause, rendendo la kill totalmente inefficace. Posso simulare la race inserendo una sched_yield() tra una kill e la pause successiva.

[ilsensine]

In parole povere:

p1			p2

pause
(switch su p2)
			kill
			(switch su p1??)
kill
pause
			pause
bye

Se questo capita, la race esplode. Dipende dallo scheduler se dopo le kill avviene il context switch o meno, sono liberi di decidere di farlo oppure no.

[Ricky]

in poche parole per far funzionare il ping pong fra i processi devo inserire degli sleep in modo tale da sincronizzare i due processi?...i

[ilsensine]

Il problema è concettuale, non tanto implementativo. Il tuo errore è eseguire la kill senza essere sicuro dello stato in cui si trova l'altro processo. Visto che l'esecuzione è totalmente asincrona, non puoi essere sicuro dello stato in alcun modo ovvio.
Se vuoi fare un semplice ping-pong, usa i messaggi (msgsnd/msgrcv).

[Ricky]

il problema è che questo esercizio è relativo alla parte di sistemi operativi mod a...quindi nello scritto nn posso usare nozioni di sistemi b...noi facciamo l IPC V solo al secondo modulo...
devo passare lo scritto di mod a ma nel frattempo sto seguendo il b all università....
perciò posso usare solo segnali, wait....capito?

ho provato ad usare delle sleep opportunamente messe e va tipo prima dei kill in modo tale che l altro processo vada in pause quando deve. E' sporco come metodo? considerando che i cambi di contesti avvengono sempre negli ordini di ms 1 secondo nella sleep è più che sufficiente non credi?

fammi sapere

ciao e grazie

P.S. scusa per il disturbo!!!

[ilsensine]

Originariamente inviato da Ricky
E' sporco come metodo?

E' più che sporco, è sbagliato per i motivi che ti ho detto.

Una soluzione più pulita (relativamente) può essere questa: imponi che, quando viene svegliato da kill, il processo invii un feedback a chi lo ha svegliato (ad es. tramite SIGUSR2). Se il feedback non arriva entro un certo timeout, ritenti il primo kill.

[ilsensine]

Qualcosa di questo tipo insomma: (negherò fino alla morte di aver scritto questa porcheria )

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

int killing;

void sveglio()
{
	printf("sveglia\n");
}

void ack()
{
	killing = 0;
}

void do_kill(pid_t pid)
{
	killing = 1;
	while(killing)
	{
		kill(pid, SIGUSR1);
// Se SIGUSR2 arriva durante usleep, questa si interrompe con EINTR
		if(killing)
			usleep(25000);
	}
}

int main(){
	int figlio;
	
	
		signal(SIGUSR1,sveglio);
		signal(SIGUSR2,ack);

	printf(" proviamo i pause, se arrivo alla fine allora funge altrimenti uccidere con ctrl+c\n");
	figlio=fork();
	if (figlio==0){
		pause();
		kill(getppid(), SIGUSR2);

		do_kill(getppid());
		pause();
		kill(getppid(), SIGUSR2);

		do_kill(getppid());
		pause();
		kill(getppid(), SIGUSR2);

		exit(0);
	}else{
		sleep(1);

		do_kill(figlio);
		pause();
		kill(figlio, SIGUSR2);

		do_kill(figlio);
		pause();
		kill(figlio, SIGUSR2);

		do_kill(figlio);
		waitpid(figlio,NULL,0);
		printf("finito\n");
	}
}

[Ricky]

secondo me la tua versione non è poi tanto diversa da quella con degli sleep opportunamente messi, in quanto a me gli sleep li fa sempre mentre a te solo nel caso in cui ti trovi a mandare il segnale prima che va in pause....giusto?
ti faccio vedere una mia versione funzionante anche se sporchissima!

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

void sveglio()
{
	printf("sveglia\n");
//	raise(SIGCONT);
}

int main(){
	int figlio;
	
	
	signal(SIGUSR1,sveglio);

	printf(" proviamo i pause, se arrivo alla fine allora funge altrimenti uccidere con ctrl+c\n");
	
        figlio=fork();
	if (figlio==0){					//temporalmente(Sequenze)
		pause();					/* 1 */
		sleep(1);					/* 3 */ //aspetto il padre(pause)	
		kill(getppid(),SIGUSR1);	   /* 4 */
		pause();					/* 5 */
		sleep(1);					/* 6 */
		kill(getppid(),SIGUSR1);			// e via dicendo
		pause();
		exit(0);
	}else{
		sleep(1);					
		
		kill(figlio,SIGUSR1);		        /* 2 */
		pause();					/* 3 */ //assicurato dallo sleep
		sleep(1);					/* 5 */
		kill(figlio,SIGUSR1);			/* 6 */
		pause();					
		sleep(1);
		kill(figlio,SIGUSR1);
		waitpid(figlio,NULL,NULL);
		printf("finito\n");
		exit(0);
	}
}