Lines Matching refs:un
13 Una classe di blocchi è un gruppo di blocchi che seguono le stesse regole di
15 decine di migliaia). Per esempio un blocco nella struttura inode è una classe,
16 mentre ogni inode sarà un'istanza di questa classe di blocco.
19 dipendenze con altre classi. L'uso di un blocco indica come quel blocco viene
20 usato rispetto al suo contesto d'interruzione, mentre le dipendenze di un blocco
22 che un processo cerca di acquisire L2 mentre già trattiene L1. Dal punto di
26 dipendenze, altrimenti ritornerà un errore.
34 succede quando si rimuove un modulo, o quando una *workqueue* viene eliminata.
61 graffe, per un totale di `2 * n` (`n`: bit STATO). Un esempio inventato::
69 Per un dato blocco, da sinistra verso destra, la posizione del bit indica l'uso
70 del blocco e di un eventuale blocco di lettura, per ognuno degli `n` STATI elencati
74 '.' acquisito con interruzioni disabilitate fuori da un contesto d'interruzione
84 ||| \-> softirq disabilitati e fuori da un contesto di softirq
85 || \--> acquisito in un contesto di softirq
86 | \---> hardirq disabilitati e fuori da un contesto di hardirq
87 \----> acquisito in un contesto di hardirq
89 Per un dato STATO, che il blocco sia mai stato acquisito in quel contesto di
107 un errore.
109 Regole dello stato per un blocco singolo
112 Avere un blocco sicuro in interruzioni (*irq-safe*) significa che è sempre stato
113 usato in un contesto d'interruzione, mentre un blocco insicuro in interruzioni
124 Questo perché se un blocco può essere usato in un contesto di interruzioni
147 cerca di trattenere i due blocchi in un ciclo in cui entrambe i contesti
159 La prima regola deriva dal fatto che un blocco sicuro in interruzioni può essere
160 trattenuto in un contesto d'interruzione che, per definizione, ha la possibilità
161 di interrompere un blocco insicuro in interruzioni; questo porterebbe ad uno
162 stallo da blocco inverso. La seconda, analogamente, ci dice che un blocco sicuro
163 in interruzioni software potrebbe essere trattenuto in un contesto di
164 interruzione software, dunque potrebbe interrompere un blocco insicuro in
173 - se viene trovato un nuovo blocco sicuro in interruzioni, verificheremo se
176 - se viene trovato un nuovo blocco sicuro in interruzioni software,
180 - se viene trovato un nuovo blocco insicuro in interruzioni, verificheremo se
183 - se viene trovato un nuovo blocco insicuro in interruzioni software,
187 (Di nuovo, questi controlli vengono fatti perché un contesto d'interruzione
222 In questo caso la sincronizzazione viene fatta su un *block-dev* sapendo che si
240 che un dato blocco in un dato momento deve essere trattenuto (altrimenti, verrà
241 generato un WARN()). Queste vengono usate abbondantemente nel kernel, per
256 solo per rq->lock ATM. Se per caso un blocco non viene trattenuto, queste
257 genereranno un WARN(). Questo si rivela particolarmente utile quando si deve
259 potrebbero assumere che un blocco rimanga trattenuto, ma livelli inferiori
288 ogni sequenza di sincronizzazione di un singolo processo che si verifichi almeno
299 riprodotto su un sistema a singolo processore.
315 assumiamo che un hash a 64-bit sia unico per ogni sequenza di
331 Per farlo, viene mantenuta una pila dei blocchi trattenuti, e viene calcolato un
346 Di base questo valore è 8191, e un classico sistema da ufficio ha meno di 1000
347 classi, dunque questo avviso è solitamente la conseguenza di un problema di
353 caricamento crea un nuovo insieme di classi di blocco per tutti i blocchi di
356 rimozione di un modulo non fa altro che aumentare il contatore di classi fino
359 2. Usare array con un gran numero di blocchi che non vengono esplicitamente
364 Sbagliare questa inizializzazione garantisce un esaurimento di classi di
365 blocco. Viceversa, un ciclo che invoca spin_lock_init() su tutti i blocchi li
388 allora c'è probabilmente un problema da qualche parte. Il seguente comando può
394 un'esecuzione successiva per identificare eventuali problemi. Questo stesso
427 sezione critica di un altro lettore. In altre parole, permette di annidare la
430 Dall'altro canto, lo stesso comportamento indurrebbe un lettore non ricorsivo ad
434 vengono bloccati solo dal trattenimento di un blocco di scrittura, mentre quelli
435 non ricorsivi possono essere bloccati dall'attesa di un blocco di scrittura.
447 un tipo lettore ricorsivo, l'attività A continuerà perché gli scrittori in
449 Tuttavia, se read_lock_2() è un lettore non ricorsivo, allora verrà bloccato
456 1. Uno scrittore blocca un altro scrittore.
492 aspettare perché si tratta di un lettore ricorsivo. Tuttavia, se read_lock()
493 fosse un lettore non ricorsivo, questo codice produrrebbe uno stallo.
496 particolare il valore del parametro 'read' in lock_acquire()), un blocco può
499 ricorsivo). In altre parole, per un'istanza di blocco esistono tre tipi di
536 In altre parole, vogliamo sapere se esiste un bloccatore L3 che viene bloccato
537 da L1 e un L2 che viene bloccato da L3. Dunque, siamo interessati a (1) quello
548 significa X -> Y, dove X è uno scrittore e Y un lettore ricorsivo.
553 o uno scrittore o un lettore non ricorsivo.
557 significa X -> Y, dove X è un lettore (ricorsivo o meno) e Y è un
562 "X -(SN)-> Y" significa X -> Y , dove X è un lettore (ricorsivo
563 o meno) e Y può essere o uno scrittore o un lettore non ricorsivo.
584 Un "percorso" in un grafo è una serie di nodi e degli archi che li congiungono.
585 Definiamo un percorso "forte", come il percorso che non ha archi (dipendenze) di
586 tipo -(xR)-> e -(Sx)->. In altre parole, un percorso "forte" è un percorso da un
587 blocco ad un altro attraverso le varie dipendenze, e se sul percorso abbiamo X
599 Se esiste un percorso chiuso forte (ciclo forte), allora esiste anche una
601 l'esistenza di un ciclo forte è sufficiente alla scoperta di uno stallo.
605 Se non esiste un percorso chiuso forte (ciclo forte), allora non esiste una
609 Con questi due lemmi possiamo facilmente affermare che un percorso chiuso forte
617 Immaginiamo d'avere un ciclo forte::
632 Per prima cosa facciamo sì che un processo/processore prenda L1 in L1 -> L2, poi
633 un altro prende L2 in L2 -> L3, e così via. Alla fine, tutti i Lx in Lx -> Lx+1
638 L2 è già trattenuto da un altro processo/processore, ed in più L1 -> L2 e L2 ->
640 in L1 -> L2 non è un bloccatore non ricorsivo (bloccabile da chiunque), e L2 in
646 L1, dunque si è creato un ciclo dal quale non possiamo uscire, quindi si ha uno
652 deve esiste un ciclo forte nel grafo delle dipendenze.
654 Secondo Wikipedia[1], se c'è uno stallo, allora deve esserci un ciclo di attese,
655 ovvero ci sono N processi/processori dove P1 aspetta un blocco trattenuto da P2,
660 significa che abbiamo un ciclo::
664 , ed ora dimostriamo d'avere un ciclo forte.
666 Per un blocco Lx, il processo Px contribuisce alla dipendenza Lx-1 -> Lx e Px+1
668 impossibile che Lx in Px+1 sia un lettore e che Lx in Px sia un lettore
671 -(xR)-> -(Sx)->. Questo è vero per ogni ciclo, dunque, questo è un ciclo forte.