> i'm not convinced that you've explained why this change is > correct or why it could solve the problem. after all, the > NNOTED array is only 5 entries long. what if one gets 5 > user notes before the system note? > do you kill the process (isn't this how it works now?), > make notes unreliable or block the sender? none of these > options seems like an improvement to me.
Hm, i think here would be a better way to handle it without losing user notes while make sure internal system notes get posted (and handled) in any case. What if we change postnote to: int postnote(Proc *p, int dolock, char *n, int flag) { int x, s, ret; Rendez *r; Proc *d, **l; if(dolock) qlock(&p->debug); if(flag != NUser){ x = 0; if(p->nnote < NNOTE){ if(p->nnote) memmove(&p->note[0], &p->note[1], p->nnote * sizeof(p->note[0])); p->nnote++; } } else { x = -1; if(p->nnote+1 < NNOTE) x = p->nnote++; } ret = 0; if(x >= 0) { strcpy(p->note[x].msg, n); p->note[x].flag = flag; ret = 1; } p->notepending = 1; if(dolock) qunlock(&p->debug); ... In that case, if a external note is posted, we make sure here is always room for one further internal note in the array. (see the p->nnote+1 < NNOTE) On arrival of a internal note, we move the rest down the array and put our note in the first entry. So the following conditions hold true: - internal notes get *always* posted (so the process gets terminated if its not handled or while in the note handler) - we do not drop external notes on internal note arrival and the sender can detect if posting the note failed. - internal notes get not queued after external notes so they will be handled by the next call to notify() and not tick notify() to think that while processing a previous user note, that this caused an internal note and kill the process before it has a chance to see the that note. Anything wrong here? -- cinap