Newsgroup: it.comp.os.linux.development
Titolo: add_wait queue per task diversi da current !!

Puo' apparire strano, ma vorrei sapere se e' possibile
eseguire una cosa del genere! 
In pratica dovrei realizzare un modulo, e in parte l'ho gia'
fatto, che deve bloccare un certo task a seconda dei casi. 
Per ora l'unico modo che ho trovato e' con kill_proc SIGSTOP, che
blocca un certo task! Il problema e' che per risvegliarlo dovrei 
testare una condizione che non so quando si verifica! L'ideale 
sarebbe bloccarlo su di una wait_queue, ma a quanto ho capito questa
chiamata la puo' fare solo il task su se stesso. 
A me servirebbe una cosa del genere: 
DECLARE_WAIT_QUEUE(coda,task_da_bloccare)
set_task_state(....)
add_wait_queue(coda,task_da_bloccare)
e poi sperare che il task si svegli da solo quando scatta una certa
condizione! 
Ma mi sa che e' fantascienza...
-- 
______________________________
Per scrivermi Togli l'anno
(^_^) Simone

 condizione!
...
Ciao,
Spero due cose:
1) Di avere capito bene che cosa ti serve.
2) Di ricordare bene quello che sto per scrivere perchč non mi trovo mai ad
usare questa tecnica.
a)Nel task che deve essere sospeso e successivamente lasciato continuare,
puoi bloccare un segnale ( ad es. SIGUSR1) con una chiamata sigaction().
b)Il sa_handler della struct sigaction deve indirizzare una funzione (detto
appunto handler) che lancia una pause().
c)La pause() attende indefinitamente fino a che arriva un nuovo segnale che
la fa ritornare e quindi l'esecuzione riprende.
Puoi fare in modo che sia lo stesso segnale SIGUSR1 ad interrompere e
risvegliare, ma in questo caso si deve controllare se ci si trova al primo o
al secondo segnale ricevuto, oppure usare due differenti segnali come
SIGUSR1 e SIGUSR2.
In ogni caso controlla sul sistema:
	man sigaction, man pause.
Se le cose non stanno esattamente cosě, invito chiunque a rinfrescarmi la
memoria perchč potrebbe servire pure a me usare qualcosa del genere.
Comunque non c'č bisogno di ricorrere alla fantascienza, come proposto da
Simone, e gli ricordo che "...Ci sono piů cose dentro un sistema Unix/Linux
di quante ne possa immaginare la tua filosofia, mio buon Orazio...".
Ciao,
FabioMDF
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 	man sigaction, man pause.
In realta' una cosa del genere l'ho gia' fatta, sto parlando di un
modulo, che dunque gira in spazio kernel, a cui passo come parametro il
pid del processo con il quale mi interessa interagire:
     int sec=10;
     struct task_struct *test_proc;
     ....
     test_proc = find_process_by_pid(pid);
     kill_proc(test_proc->pid,SIGSTOP,1);
     set_current_state(TASK_INTERRUPTIBLE);
     schedule_timeout(sec*HZ);
     kill_proc(test_proc->pid,SIGCONT,1);
     return 0;
In questo modo all'inserimento del modulo il task che dico io si blocca
immediatemente, per poi risvegliarsi dopo 10 secondi. Ovviamente la
condizione di blocco e di risveglio puo' essere una qualsiasi! 
Questa soluzione ha due difetti: si introduce un sacco di overhead dovuto
alla gestione dei segnali, poi sono costretto a fermare il modulo, cioe'
deschedularlo, in attesa di una condizione che non so quando si puo'
verificare.
Per farla breve io voglio bypassare il meccanismo di scheduling del kernel
2.6 bloccando i task che dico io e quando voglio io. Purtroppo il modulo 
cosi' com'e' non e' detto che riesca a fare il suo lavoro, cioe'
riattivare un task che era stato bloccato, servirebbe un meccanismo che
riattivi il task in modo autonomo. 
L'unica cosa che mi era venuta in mente era una coda, che allo scattare di
una condizione sveglia tutti i processi accodati, un po' come si fa nei
driver di periferica. Ma non credo sia fattibile!
