ten SIGKILL - mozne reseni

[Divacky Roman]

Tak jsem se na to tsleep()ovani poradne podival a prisel jsem na nasledujici:

endtsleep nam v podstate nepomuze pac ony "kriticke" tsleepy se odehravaji v
necem jako je:
while(libovolna_podminka)
    tslep(neco);
takze i kdy prerusime ten tsleep tak nam nabehne znova takze veskera snaha v
tomto smeru je marna...

napadlo mne ovsem toto reseni, imho by melo fungovat, ma ovsem tu nevyhodu,
zeje docela pracne a trosku nesikovne (nerikam ze nejde vylepsit) ;(

predelat tsleep z
tsleep(ident, priority, wmesg, timo)
{
  ....
}

na

tsleep(ident, priority, wmesg, timo, func, param, cond, type)
...
void (*func)(*void);
void *param1;
int (*cond)(*void);
void *param2;
int type;
{
switch (type) {
WHILE: while (cond(param2)) {
          int err;
          func (param);
          err = old_tsleep(ident, priority, wmesg, timo);
       }
       return err;       
IF: if (cond(param2)) { 
       func(param);
       err = old_tsleep(ident, priority, wmesg, timo);
    }
    return err;
...
}
/* NOT REACH */
}

kde cond je ona libovolna podminka a type je typ smycky a func je funkce kterou
chceme vykonavat s parametrem param

toto by melo nasledujici vyhody:
1) jasny zpusob jak se vykonava blok kolem tsleep()
   a z toho plynouci jednoduchost implementace naseho SIGKILLu
2) unifikace kodu

a nevyhody:
1) nutna zmena vsech volani tsleep - toto by se dalo nahradit nejakym skriptem
inteligentne nahrazujicim tsleep za old_tsleep
2) nejspise i nutna zmena (popr. vubec definovani) funkci func
z duvodu redefinice jejich n-arity na unarnost (int, int, int -> struct neco
{int, int, int})
3) jista debilita v nutne definici predavanych parametru funkce, ie. nejde
zapsat tsleep(.., a > b ,..) s tim ze se "a > b" preda jako funkce
tj. je nutne specifikovat funkce a jeji parametry zvlast aby nedoslo k
vyhodnoceni. toto by snad slo obejit pomoci nejakeho nehezkeho carovani s
preprocesorem...
4) neni jiste jestli by byl old_tsleep() posledni funkci bloku... za nim by
mohli nasledovat jeste nejake splx()y popr. ruzne uvolnovani zamku atd.
tj. bylo by nutno predavat pre_func() a post_func() cimz se nam reseni dale
zeskaredi... -> slo by to dat do nejake struktury

struct tsleep_args {
	void (*pre_func)(*void);	/* call BEFORE old_tsleep */
	void *param1;			/* its params within a structure */
	void (*post_func)(*void);	/* call AFTER old_tsleep */
	void *param2;			/* its params within a structure*/
	int (*cond)(*void);		/* condition */
	void *param3;			/* its params within a structure */
	int type;			/* the used control structure */
#define	WHILE	1
#define IF 	2
#define	REPEAT	3
}

ale to uz mi prijde trosku moc (misto par radek mame najednou obrovske monstrum
ktere dela vlastne to same)

nevim, osobne mi pripada, ze by to tak slo, nicmene je otazka jestli by to
stalo zato... domnivam se ze nejspis ne :-(

pripominky ocenim (ani ne tak kritiku, jako navrhy na zlepseni :-) )

r.d.