<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:dc="http://purl.org/dc/elements/1.1/"
 xmlns:content="http://purl.org/rss/1.0/modules/content/"
 xmlns:atom="http://www.w3.org/2005/Atom"
>
	<channel>
		<copyright>Copyright 1998 - 2026 DPG Media B.V.</copyright>
		<pubDate>Thu, 23 Jul 2026 08:28:01 GMT</pubDate>
		<lastBuildDate>Thu, 23 Jul 2026 08:28:01 GMT</lastBuildDate>
		<description>GoT - list_messages</description>
		<image>
			<link>https://gathering.tweakers.net/</link>
			<title>Gathering of Tweakers</title>
			<url>https://tweakers.net/g/if/logo.gif</url>
		</image>
		<language>nl-nl</language>
		<link>https://gathering.tweakers.net/rss/list_messages/1420953</link>
		<atom:link href="https://gathering.tweakers.net/rss/list_messages/1420953" rel="self" type="application/rss+xml" />
		<title>[C Linux Kernel] Completion opnieuw initen - Softwareontwikkeling - GoT</title>
		<webMaster>gathering@tweakers.net (Administrator)</webMaster>
		<item>
			<title>farlane</title>
			<link>https://gathering.tweakers.net/forum/list_message/35859019#35859019</link>
			<description>farlane schreef op zondag 15 augustus 2010 @ 00:12:
ZoekendeBeter laat dan nooit : de situatie was iets anders ben ik nu achter : init_MUTEX was een macro om sem_init( .., 1 ),  maar die macro werd gedeprecated omdat er ook een &#039;echte&#039; mutex is.

Zie ook bv hier : http://www.cs.fsu.edu/~ba...ude/linux/semaphore.h#L39</description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34521639#34521639" rel="external" class="messagelink">farlane schreef op zondag 15 augustus 2010 @ 00:12</a>:</b><br>
Zoekende</div></blockquote>Beter laat dan nooit : de situatie was iets anders ben ik nu achter : init_MUTEX was een macro om sem_init( .., 1 ),  maar die macro werd gedeprecated omdat er ook een &#039;echte&#039; mutex is.<br>
<br>
Zie ook bv hier : <a href="http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/include/linux/semaphore.h#L39" rel="external nofollow" title="http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/include/linux/semaphore.h#L39">http://www.cs.fsu.edu/~ba...ude/linux/semaphore.h#L39</a>]]></content:encoded>
			<dc:creator>farlane</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/35859019#35859019</guid>
			<pubDate>Tue, 12 Apr 2011 17:38:35 GMT</pubDate>
		</item>
		<item>
			<title>farlane</title>
			<link>https://gathering.tweakers.net/forum/list_message/34521639#34521639</link>
			<description>H!GHGuY schreef op zaterdag 14 augustus 2010 @ 11:45:
In single-threaded heb je helemaal niets nodig... (Tenzij misschien wat memory barriers op architecturen met memory re-ordering).Ugh ... volgende keer zal ik m&#039;n brein weer aanzetten Mutex zal zeker niet deprecated worden, gezien de real-time patches en co. Mocht je me zo&#039;n driver kunnen tonen, please do so Zoekende</description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34518869#34518869" rel="external" class="messagelink">H!GHGuY schreef op zaterdag 14 augustus 2010 @ 11:45</a>:</b><br>
In single-threaded heb je helemaal niets nodig... (Tenzij misschien wat memory barriers op architecturen met memory re-ordering).</div></blockquote>Ugh ... volgende keer zal ik m&#039;n brein weer aanzetten <img src="https://tweakers.net/g/s/biggrin.svg" width="16" height="16" alt=":D"><blockquote><div class="message-quote-div">Mutex zal zeker niet deprecated worden, gezien de real-time patches en co. Mocht je me zo&#039;n driver kunnen tonen, please do so <img src="https://tweakers.net/g/s/wink.svg" width="16" height="16" alt=";)"></div></blockquote>Zoekende]]></content:encoded>
			<dc:creator>farlane</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34521639#34521639</guid>
			<pubDate>Sat, 14 Aug 2010 22:12:42 GMT</pubDate>
		</item>
		<item>
			<title>H!GHGuY</title>
			<link>https://gathering.tweakers.net/forum/list_message/34518869#34518869</link>
			<description>farlane schreef op vrijdag 13 augustus 2010 @ 23:04:
Raar, ook ik meende gezien te hebben ( in driver code )  dat de mutex functies deprecated waren en in semaphore termen werden geimplementeerd.

Als ik het goed begrijp moet dat in een single threaded omgeving dan ook mogelijk zijn?In single-threaded heb je helemaal niets nodig... (Tenzij misschien wat memory barriers op architecturen met memory re-ordering).

Mutex zal zeker niet deprecated worden, gezien de real-time patches en co. Mocht je me zo&#039;n driver kunnen tonen, please do so </description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34517592#34517592" rel="external" class="messagelink">farlane schreef op vrijdag 13 augustus 2010 @ 23:04</a>:</b><br>
Raar, ook ik meende gezien te hebben ( in driver code )  dat de mutex functies deprecated waren en in semaphore termen werden geimplementeerd.<br>
<br>
Als ik het goed begrijp moet dat in een single threaded omgeving dan ook mogelijk zijn?</div></blockquote>In single-threaded heb je helemaal niets nodig... (Tenzij misschien wat memory barriers op architecturen met memory re-ordering).<br>
<br>
Mutex zal zeker niet deprecated worden, gezien de real-time patches en co. Mocht je me zo&#039;n driver kunnen tonen, please do so <img src="https://tweakers.net/g/s/wink.svg" width="16" height="16" alt=";)">]]></content:encoded>
			<dc:creator>H!GHGuY</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34518869#34518869</guid>
			<pubDate>Sat, 14 Aug 2010 09:45:54 GMT</pubDate>
		</item>
		<item>
			<title>farlane</title>
			<link>https://gathering.tweakers.net/forum/list_message/34517592#34517592</link>
			<description>Raar, ook ik meende gezien te hebben ( in driver code )  dat de mutex functies deprecated waren en in semaphore termen werden geimplementeerd.

Als ik het goed begrijp moet dat in een single threaded omgeving dan ook mogelijk zijn?</description>
			<content:encoded><![CDATA[Raar, ook ik meende gezien te hebben ( in driver code )  dat de mutex functies deprecated waren en in semaphore termen werden geimplementeerd.<br>
<br>
Als ik het goed begrijp moet dat in een single threaded omgeving dan ook mogelijk zijn?]]></content:encoded>
			<dc:creator>farlane</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34517592#34517592</guid>
			<pubDate>Fri, 13 Aug 2010 21:04:07 GMT</pubDate>
		</item>
		<item>
			<title>H!GHGuY</title>
			<link>https://gathering.tweakers.net/forum/list_message/34516084#34516084</link>
			<description>Kijk maar even in kernel/semaphore.c en kernel/mutex.c.

De implementaties verschillen wel degelijk en zijn zelfs niet in termen van elkaar geimplementeerd.

Bovendien is een binaire semaphoor en een mutex niet hetzelfde. Een mutex heeft een owner-thread, waarbij lock en unlock door dezelfde thread moet gebeuren, terwijl dit bij een semaphoor niet zo is.

definieren gebeurt trouwens met
C:1
2
3
4
5
6
7
DEFINE_MUTEX(mutexname);
// of
DECLARE_MUTEX(mutexname);
void some_init(void)
{
  mutex_init(mutexname);
}</description>
			<content:encoded><![CDATA[Kijk maar even in <a href="http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;f=kernel/semaphore.c" rel="external nofollow">kernel/semaphore.c</a> en <a href="http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;f=kernel/mutex.c" rel="external nofollow">kernel/mutex.c</a>.<br>
<br>
De implementaties verschillen wel degelijk en zijn zelfs niet in termen van elkaar geimplementeerd.<br>
<br>
Bovendien is een binaire semaphoor en een mutex niet hetzelfde. Een mutex heeft een owner-thread, waarbij lock en unlock door dezelfde thread moet gebeuren, terwijl dit bij een semaphoor niet zo is.<br>
<br>
definieren gebeurt trouwens met<br>
<div class="code">C:<br><table class="phphighlight"><tr><td class="phphighlightline"><pre>1
2
3
4
5
6
7
</pre></td><td class="phphighlightcode"><div><pre><span class="code_n">DEFINE_MUTEX</span><span class="code_p">(</span><span class="code_n">mutexname</span><span class="code_p">);</span>
<span class="code_c1">// of</span>
<span class="code_n">DECLARE_MUTEX</span><span class="code_p">(</span><span class="code_n">mutexname</span><span class="code_p">);</span>
<span class="code_kt">void</span><span class="code_w"> </span><span class="code_nf">some_init</span><span class="code_p">(</span><span class="code_kt">void</span><span class="code_p">)</span>
<span class="code_p">{</span>
<span class="code_w">  </span><span class="code_n">mutex_init</span><span class="code_p">(</span><span class="code_n">mutexname</span><span class="code_p">);</span>
<span class="code_p">}</span></pre></div></td></tr></table></div>]]></content:encoded>
			<dc:creator>H!GHGuY</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34516084#34516084</guid>
			<pubDate>Fri, 13 Aug 2010 15:33:36 GMT</pubDate>
		</item>
		<item>
			<title>Enfer</title>
			<link>https://gathering.tweakers.net/forum/list_message/34514660#34514660</link>
			<description>H!GHGuY schreef op vrijdag 13 augustus 2010 @ 12:58:
[...]


Als ik me niet vergis worden semaphores in kernel land afgeraden. Als ik me niet vergis staan ze zelfs op de lijst van gewenste removals... Veel kernel developers raden aan om mutexes te gebruiken ipv semaphoren.

Maar wait_event() en wake_up_all() is inderdaad de correcte interface om te gebruiken voor dit soort dingen.Ermm, is een mutex niet gewoon een semaphore met size 1? Volgens mij wordt een mutex gedeclareerd als:
C:1
struct semaphore test;
En geinit met
C:1
DECLARE_MUTEX(test);</description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34514233#34514233" rel="external" class="messagelink">H!GHGuY schreef op vrijdag 13 augustus 2010 @ 12:58</a>:</b><br>
[...]<br>
<br>
<br>
Als ik me niet vergis worden semaphores in kernel land afgeraden. Als ik me niet vergis staan ze zelfs op de lijst van gewenste removals... Veel kernel developers raden aan om mutexes te gebruiken ipv semaphoren.<br>
<br>
Maar wait_event() en wake_up_all() is inderdaad de correcte interface om te gebruiken voor dit soort dingen.</div></blockquote>Ermm, is een mutex niet gewoon een semaphore met size 1? Volgens mij wordt een mutex gedeclareerd als:<br>
<div class="code">C:<br><table class="phphighlight"><tr><td class="phphighlightline"><pre>1
</pre></td><td class="phphighlightcode"><div><pre><span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">semaphore</span><span class="code_w"> </span><span class="code_n">test</span><span class="code_p">;</span></pre></div></td></tr></table></div><br>
En geinit met<br>
<div class="code">C:<br><table class="phphighlight"><tr><td class="phphighlightline"><pre>1
</pre></td><td class="phphighlightcode"><div><pre><span class="code_n">DECLARE_MUTEX</span><span class="code_p">(</span><span class="code_n">test</span><span class="code_p">);</span></pre></div></td></tr></table></div>]]></content:encoded>
			<dc:creator>Enfer</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34514660#34514660</guid>
			<pubDate>Fri, 13 Aug 2010 11:54:25 GMT</pubDate>
		</item>
		<item>
			<title>H!GHGuY</title>
			<link>https://gathering.tweakers.net/forum/list_message/34514233#34514233</link>
			<description>Soultaker schreef op woensdag 11 augustus 2010 @ 20:20:
Een completion is bedoelt als one time event. Een beetje als een condition variable die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.

Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een semaphore gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een condition variable (wait_event()/wake_up_all()) een betere optie.

In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.Als ik me niet vergis worden semaphores in kernel land afgeraden. Als ik me niet vergis staan ze zelfs op de lijst van gewenste removals... Veel kernel developers raden aan om mutexes te gebruiken ipv semaphoren.

Maar wait_event() en wake_up_all() is inderdaad de correcte interface om te gebruiken voor dit soort dingen.</description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34504192#34504192" rel="external" class="messagelink">Soultaker schreef op woensdag 11 augustus 2010 @ 20:20</a>:</b><br>
Een <i>completion</i> is bedoelt als <i>one time event</i>. Een beetje als een <i>condition variable</i> die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.<br>
<br>
Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een <i>semaphore</i> gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een <i>condition variable</i> (wait_event()/wake_up_all()) een betere optie.<br>
<br>
In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.</div></blockquote>Als ik me niet vergis worden semaphores in kernel land afgeraden. Als ik me niet vergis staan ze zelfs op de lijst van gewenste removals... Veel kernel developers raden aan om mutexes te gebruiken ipv semaphoren.<br>
<br>
Maar wait_event() en wake_up_all() is inderdaad de correcte interface om te gebruiken voor dit soort dingen.]]></content:encoded>
			<dc:creator>H!GHGuY</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34514233#34514233</guid>
			<pubDate>Fri, 13 Aug 2010 10:58:21 GMT</pubDate>
		</item>
		<item>
			<title>Enfer</title>
			<link>https://gathering.tweakers.net/forum/list_message/34506869#34506869</link>
			<description>Sappie schreef op woensdag 11 augustus 2010 @ 19:17:
Is het niet zo dat er een verschil bestaat tussen init_completion en INIT_COMPLETION? Als ik me niet vergis dient de laatste gebruikt te worden om de completion te herinitialiseren.

De init_completion call doet volgens mij namelijk wat meer dan de upper-case variant; het reset ook de onderliggende waitqueue (wat dan weer een soort linked list is). Ik ken de onderliggende implementatie van een completion niet, maar kan me voorstellen dat op deze manier de threads die wachten op completion niet meer ge-complete worden.Klopt, echter heb ik beide varianten geprobeerd, maar bij beide varianten blijft het probleem bestaan. INIT_blabla zet idd van een completion de &quot;done&quot; var weer op 0, terwijl bij init_completion inderdaad de waitqueue (oid) gereset hebt, dat klopt Soultaker schreef op woensdag 11 augustus 2010 @ 20:20:
Een completion is bedoelt als one time event. Een beetje als een condition variable die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.

Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een semaphore gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een condition variable (wait_event()/wake_up_all()) een betere optie.

In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.Thanks, ik zal direct even kijken naar de condition_variabele met wait e.d, daar kan ik wat mee 

Echter over je middelste opmerking, na een schrijfactie precies 1 leesactie, is het dan niet veiliger om een completion te gebruiken met &quot;gewoon&quot; complete? Van een completion ben je er zeker dat het FIFO is, van semaphore weet ik dat zo niet. Zo verklein je de kans op starvation?</description>
			<content:encoded><![CDATA[<blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34503884#34503884" rel="external" class="messagelink">Sappie schreef op woensdag 11 augustus 2010 @ 19:17</a>:</b><br>
Is het niet zo dat er een verschil bestaat tussen init_completion en INIT_COMPLETION? Als ik me niet vergis dient de laatste gebruikt te worden om de completion te herinitialiseren.<br>
<br>
De init_completion call doet volgens mij namelijk wat meer dan de upper-case variant; het reset ook de onderliggende waitqueue (wat dan weer een soort linked list is). Ik ken de onderliggende implementatie van een completion niet, maar kan me voorstellen dat op deze manier de threads die wachten op completion niet meer ge-complete worden.</div></blockquote>Klopt, echter heb ik beide varianten geprobeerd, maar bij beide varianten blijft het probleem bestaan. INIT_blabla zet idd van een completion de &quot;done&quot; var weer op 0, terwijl bij init_completion inderdaad de waitqueue (oid) gereset hebt, dat klopt <img src="https://tweakers.net/g/s/smile.svg" width="16" height="16" alt=":)"><blockquote><div class="message-quote-div"><b><a href="https://gathering.tweakers.net/forum/list_message/34504192#34504192" rel="external" class="messagelink">Soultaker schreef op woensdag 11 augustus 2010 @ 20:20</a>:</b><br>
Een <i>completion</i> is bedoelt als <i>one time event</i>. Een beetje als een <i>condition variable</i> die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.<br>
<br>
Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een <i>semaphore</i> gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een <i>condition variable</i> (wait_event()/wake_up_all()) een betere optie.<br>
<br>
In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.</div></blockquote>Thanks, ik zal direct even kijken naar de condition_variabele met wait e.d, daar kan ik wat mee <img src="https://tweakers.net/g/s/vork.svg" width="22" height="16" alt=":Y)"><br>
<br>
Echter over je middelste opmerking, na een schrijfactie precies 1 leesactie, is het dan niet veiliger om een completion te gebruiken met &quot;gewoon&quot; complete? Van een completion ben je er zeker dat het FIFO is, van semaphore weet ik dat zo niet. Zo verklein je de kans op starvation?]]></content:encoded>
			<dc:creator>Enfer</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34506869#34506869</guid>
			<pubDate>Thu, 12 Aug 2010 09:05:32 GMT</pubDate>
		</item>
		<item>
			<title>Soultaker</title>
			<link>https://gathering.tweakers.net/forum/list_message/34504192#34504192</link>
			<description>Een completion is bedoelt als one time event. Een beetje als een condition variable die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.

Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een semaphore gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een condition variable (wait_event()/wake_up_all()) een betere optie.

In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.</description>
			<content:encoded><![CDATA[Een <i>completion</i> is bedoelt als <i>one time event</i>. Een beetje als een <i>condition variable</i> die niet gereset wordt na het waiten. Als je &#039;m meer dan eens initialiseert ben je verkeerd bezig, zeker als je dat doet terwijl er nog readers op aan het wachten zijn.<br>
<br>
Ik denk dat je hier dus beter een ander soort synchronisatieprimitieve kunt gebruiken. Als elke schrijfctie correspondeert met precies één leesactie, dan kun je een <i>semaphore</i> gebruiken. Als na elke schrijfactie alle readers iets mogen lezen, is een <i>condition variable</i> (wait_event()/wake_up_all()) een betere optie.<br>
<br>
In elk geval is een completion in dit geval de verkeerde datastructuur voor wat je wil bereiken.]]></content:encoded>
			<dc:creator>Soultaker</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34504192#34504192</guid>
			<pubDate>Wed, 11 Aug 2010 18:20:23 GMT</pubDate>
		</item>
		<item>
			<title>Sappie</title>
			<link>https://gathering.tweakers.net/forum/list_message/34503884#34503884</link>
			<description>Is het niet zo dat er een verschil bestaat tussen init_completion en INIT_COMPLETION? Als ik me niet vergis dient de laatste gebruikt te worden om de completion te herinitialiseren.

De init_completion call doet volgens mij namelijk wat meer dan de upper-case variant; het reset ook de onderliggende waitqueue (wat dan weer een soort linked list is). Ik ken de onderliggende implementatie van een completion niet, maar kan me voorstellen dat op deze manier de threads die wachten op completion niet meer ge-complete worden.</description>
			<content:encoded><![CDATA[Is het niet zo dat er een verschil bestaat tussen init_completion en INIT_COMPLETION? Als ik me niet vergis dient de laatste gebruikt te worden om de completion te herinitialiseren.<br>
<br>
De init_completion call doet volgens mij namelijk wat meer dan de upper-case variant; het reset ook de onderliggende waitqueue (wat dan weer een soort linked list is). Ik ken de onderliggende implementatie van een completion niet, maar kan me voorstellen dat op deze manier de threads die wachten op completion niet meer ge-complete worden.]]></content:encoded>
			<dc:creator>Sappie</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34503884#34503884</guid>
			<pubDate>Wed, 11 Aug 2010 17:17:29 GMT</pubDate>
		</item>
		<item>
			<title>Enfer</title>
			<link>https://gathering.tweakers.net/forum/list_message/34503758#34503758</link>
			<description>Jup, het voorbeeld is natuurlijk vereenvoudigd maar het principe van completion is:
als je wait doet ga je wachten totdat je een signal krijgt (complete of complete_all), bij een complete maakt de schrijver 1 iemand wakker, bij een complete_all maakt de schrijver alle wachtenden wakker..

Wat betreft blocking IO, de bedoeling is dat als er een schrijver een bericht stuurt, dat alle wachtenden (0...N) wakker gemaakt worden. Dat kan nu 1x, maar na de complete_all is die completion onbruikbaar, en init_completion aanroepen reset alles waardoor de wachters uberhaupt nooit het signal van complete_all binnenkrijgen..</description>
			<content:encoded><![CDATA[Jup, het voorbeeld is natuurlijk vereenvoudigd maar het principe van completion is:<br>
als je wait doet ga je wachten totdat je een signal krijgt (complete of complete_all), bij een complete maakt de schrijver 1 iemand wakker, bij een complete_all maakt de schrijver alle wachtenden wakker..<br>
<br>
Wat betreft blocking IO, de bedoeling is dat als er een schrijver een bericht stuurt, dat alle wachtenden (0...N) wakker gemaakt worden. Dat kan nu 1x, maar na de complete_all is die completion onbruikbaar, en init_completion aanroepen reset alles waardoor de wachters uberhaupt nooit het signal van complete_all binnenkrijgen..]]></content:encoded>
			<dc:creator>Enfer</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34503758#34503758</guid>
			<pubDate>Wed, 11 Aug 2010 16:48:08 GMT</pubDate>
		</item>
		<item>
			<title>Elijan9</title>
			<link>https://gathering.tweakers.net/forum/list_message/34503497#34503497</link>
			<description>Dit klinkt mij meer alsof je blocking IO opnieuw wilt uitvinden, of mis ik iets? 
Verder moet je misschien nog voorkomen dat de lezers al opnieuw in rn_read komen voordat de rn_write klaar is met complete_all, maar misschien is dat al wel geregeld via complete_all?</description>
			<content:encoded><![CDATA[Dit klinkt mij meer alsof je blocking IO opnieuw wilt uitvinden, of mis ik iets? <br>
Verder moet je misschien nog voorkomen dat de lezers al opnieuw in rn_read komen voordat de rn_write klaar is met complete_all, maar misschien is dat al wel geregeld via complete_all?]]></content:encoded>
			<dc:creator>Elijan9</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34503497#34503497</guid>
			<pubDate>Wed, 11 Aug 2010 15:52:23 GMT</pubDate>
		</item>
		<item>
			<title>Enfer</title>
			<link>https://gathering.tweakers.net/forum/list_message/34496577#34496577</link>
			<description>Hi,

Ik zit met een klein probleempje.. Ik ben bezig een device driver voor linux te schrijven voor een character device. Er zijn bepaalde lezers die input kunnen lezen zodra schrijvers iets wegschrijven in het (virtuele device).

Echter wil ik graag dat lezers alleen input gaan lezen als dat er ook echt is, vandaar dat ik een completion gebruik, zodat een schrijver de lezers &quot;wakker&quot; maakt als er werkt te doen is.

Zo gezegd zo gedaan, kom je op het volgende stukje uit: (includes en inits daargelaten)
C:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include &lt;linux/completion.h&gt;

struct completion messagesAvailable; //voor lezers om te slapen als er geen berichten zijn

/File operation functies
int rn_open(struct inode *inode, struct file *filp){
    return 0;
}

ssize_t rn_read(struct file *filp, char __user *userBuff, size_t count, loff_t *offp){
    printk( KERN_INFO  &quot;waiting for: %p\n&quot;, &amp;messagesAvailable );
    wait_for_completion( &amp;messagesAvailable);   

    copy_to_user( userBuff, &quot;b&quot;, 1);
    (*offp) += 1;

    return 1;
}

ssize_t rn_write(struct file *filp, const char __user *userBuff, size_t count, loff_t *offp){
    complete_all( &amp;messagesAvailable);
    printk( KERN_INFO  &quot;inited complete for: %p\n&quot;, &amp;messagesAvailable );
    return count;
}

//deze functies worden doorgelinked door gebruikers van het device
struct file_operations fops =
{
    .open = rn_open,
    .release = rn_release,
    .read = rn_read,
    .write = rn_write,
};

// Module ingeladen door de kernel
static int hello_init(void)
{
    int result;

    printk( KERN_ALERT &quot;Kernelmodule completion: init_module() \n&quot; );

    init_completion(&amp;messagesAvailable);

    result  = register_chrdev(0, &quot;completion&quot;, &amp;fops);

    if( result &lt; 0) {
        printk(KERN_WARNING &quot;Error creating device\n&quot;);
        return result;
    }
    
    device = result;

    return 0;
}

Een schrijver maakt nu alle lezers wakker als er iets geschreven wordt. Echter vervolgens gaat een lezer weer iets lezen, maar wacht hij niet meer op de completion.

Nu ben ik er al achtergekomen dat dit komt omdat je de completion opnieuw moet initialiseren, echter zit daar ook mijn probleem.
Zodra ik de completion opnieuw initialiseer nadat de schrijver een complete_all() gedaan heeft(zo dus):
C:1
2
complete_all( &amp;messagesAvailable);
init_completion( &amp;messagesAvailable );
krijgen mijn lezers niet meer het bericht dat ze verder mogen lezen.

Ik heb een beetje lopen zoeken op internet, maar er zijn maar weinig cases waar ik complete_all echt gebruikt zie worden, terwijl dit mij op deze plek wel de oplossing lijkt.

Kunnen jullie me vertellen waar/hoe ik mijn completion opnieuw moet initen, of dat ik toch maar beter een ander concurrency-hulpmiddel kan gebruiken? </description>
			<content:encoded><![CDATA[Hi,<br>
<br>
Ik zit met een klein probleempje.. Ik ben bezig een device driver voor linux te schrijven voor een character device. Er zijn bepaalde lezers die input kunnen lezen zodra schrijvers iets wegschrijven in het (virtuele device).<br>
<br>
Echter wil ik graag dat lezers alleen input gaan lezen als dat er ook echt is, vandaar dat ik een completion gebruik, zodat een schrijver de lezers &quot;wakker&quot; maakt als er werkt te doen is.<br>
<br>
Zo gezegd zo gedaan, kom je op het volgende stukje uit: (includes en inits daargelaten)<br>
<div class="code">C:<br><table class="phphighlight"><tr><td class="phphighlightline"><pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
</pre></td><td class="phphighlightcode"><div><pre><span class="code_cp">#include</span><span class="code_w"> </span><span class="code_cpf">&lt;linux/completion.h&gt;</span>

<span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">completion</span><span class="code_w"> </span><span class="code_n">messagesAvailable</span><span class="code_p">;</span><span class="code_w"> </span><span class="code_c1">//voor lezers om te slapen als er geen berichten zijn</span>

<span class="code_o">/</span><span class="code_n">File</span><span class="code_w"> </span><span class="code_n">operation</span><span class="code_w"> </span><span class="code_n">functies</span>
<span class="code_kt">int</span><span class="code_w"> </span><span class="code_n">rn_open</span><span class="code_p">(</span><span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">inode</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">inode</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">file</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">filp</span><span class="code_p">){</span>
<span class="code_w">    </span><span class="code_k">return</span><span class="code_w"> </span><span class="code_mi">0</span><span class="code_p">;</span>
<span class="code_p">}</span>

<span class="code_kt">ssize_t</span><span class="code_w"> </span><span class="code_n">rn_read</span><span class="code_p">(</span><span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">file</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">filp</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_kt">char</span><span class="code_w"> </span><span class="code_n">__user</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">userBuff</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_kt">size_t</span><span class="code_w"> </span><span class="code_n">count</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_n">loff_t</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">offp</span><span class="code_p">){</span>
<span class="code_w">    </span><span class="code_n">printk</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_n">KERN_INFO</span><span class="code_w">  </span><span class="code_s">&quot;waiting for: %p</span><span class="code_se">\n</span><span class="code_s">&quot;</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_w"> </span><span class="code_p">);</span>
<span class="code_w">    </span><span class="code_n">wait_for_completion</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_p">);</span><span class="code_w">   </span>

<span class="code_w">    </span><span class="code_n">copy_to_user</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_n">userBuff</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_s">&quot;b&quot;</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_mi">1</span><span class="code_p">);</span>
<span class="code_w">    </span><span class="code_p">(</span><span class="code_o">*</span><span class="code_n">offp</span><span class="code_p">)</span><span class="code_w"> </span><span class="code_o">+=</span><span class="code_w"> </span><span class="code_mi">1</span><span class="code_p">;</span>

<span class="code_w">    </span><span class="code_k">return</span><span class="code_w"> </span><span class="code_mi">1</span><span class="code_p">;</span>
<span class="code_p">}</span>

<span class="code_kt">ssize_t</span><span class="code_w"> </span><span class="code_n">rn_write</span><span class="code_p">(</span><span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">file</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">filp</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_k">const</span><span class="code_w"> </span><span class="code_kt">char</span><span class="code_w"> </span><span class="code_n">__user</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">userBuff</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_kt">size_t</span><span class="code_w"> </span><span class="code_n">count</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_n">loff_t</span><span class="code_w"> </span><span class="code_o">*</span><span class="code_n">offp</span><span class="code_p">){</span>
<span class="code_w">    </span><span class="code_n">complete_all</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_p">);</span>
<span class="code_w">    </span><span class="code_n">printk</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_n">KERN_INFO</span><span class="code_w">  </span><span class="code_s">&quot;inited complete for: %p</span><span class="code_se">\n</span><span class="code_s">&quot;</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_w"> </span><span class="code_p">);</span>
<span class="code_w">    </span><span class="code_k">return</span><span class="code_w"> </span><span class="code_n">count</span><span class="code_p">;</span>
<span class="code_p">}</span>

<span class="code_c1">//deze functies worden doorgelinked door gebruikers van het device</span>
<span class="code_k">struct</span><span class="code_w"> </span><span class="code_nc">file_operations</span><span class="code_w"> </span><span class="code_n">fops</span><span class="code_w"> </span><span class="code_o">=</span>
<span class="code_p">{</span>
<span class="code_w">    </span><span class="code_p">.</span><span class="code_n">open</span><span class="code_w"> </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">rn_open</span><span class="code_p">,</span>
<span class="code_w">    </span><span class="code_p">.</span><span class="code_n">release</span><span class="code_w"> </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">rn_release</span><span class="code_p">,</span>
<span class="code_w">    </span><span class="code_p">.</span><span class="code_n">read</span><span class="code_w"> </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">rn_read</span><span class="code_p">,</span>
<span class="code_w">    </span><span class="code_p">.</span><span class="code_n">write</span><span class="code_w"> </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">rn_write</span><span class="code_p">,</span>
<span class="code_p">};</span>

<span class="code_c1">// Module ingeladen door de kernel</span>
<span class="code_k">static</span><span class="code_w"> </span><span class="code_kt">int</span><span class="code_w"> </span><span class="code_nf">hello_init</span><span class="code_p">(</span><span class="code_kt">void</span><span class="code_p">)</span>
<span class="code_p">{</span>
<span class="code_w">    </span><span class="code_kt">int</span><span class="code_w"> </span><span class="code_n">result</span><span class="code_p">;</span>

<span class="code_w">    </span><span class="code_n">printk</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_n">KERN_ALERT</span><span class="code_w"> </span><span class="code_s">&quot;Kernelmodule completion: init_module() </span><span class="code_se">\n</span><span class="code_s">&quot;</span><span class="code_w"> </span><span class="code_p">);</span>

<span class="code_w">    </span><span class="code_n">init_completion</span><span class="code_p">(</span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_p">);</span>

<span class="code_w">    </span><span class="code_n">result</span><span class="code_w">  </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">register_chrdev</span><span class="code_p">(</span><span class="code_mi">0</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_s">&quot;completion&quot;</span><span class="code_p">,</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">fops</span><span class="code_p">);</span>

<span class="code_w">    </span><span class="code_k">if</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_n">result</span><span class="code_w"> </span><span class="code_o">&lt;</span><span class="code_w"> </span><span class="code_mi">0</span><span class="code_p">)</span><span class="code_w"> </span><span class="code_p">{</span>
<span class="code_w">        </span><span class="code_n">printk</span><span class="code_p">(</span><span class="code_n">KERN_WARNING</span><span class="code_w"> </span><span class="code_s">&quot;Error creating device</span><span class="code_se">\n</span><span class="code_s">&quot;</span><span class="code_p">);</span>
<span class="code_w">        </span><span class="code_k">return</span><span class="code_w"> </span><span class="code_n">result</span><span class="code_p">;</span>
<span class="code_w">    </span><span class="code_p">}</span>
<span class="code_w">    </span>
<span class="code_w">    </span><span class="code_n">device</span><span class="code_w"> </span><span class="code_o">=</span><span class="code_w"> </span><span class="code_n">result</span><span class="code_p">;</span>

<span class="code_w">    </span><span class="code_k">return</span><span class="code_w"> </span><span class="code_mi">0</span><span class="code_p">;</span>
<span class="code_p">}</span></pre></div></td></tr></table></div><br>
<br>
Een schrijver maakt nu alle lezers wakker als er iets geschreven wordt. Echter vervolgens gaat een lezer weer iets lezen, maar wacht hij niet meer op de completion.<br>
<br>
Nu ben ik er al achtergekomen dat dit komt omdat je de completion opnieuw moet initialiseren, echter zit daar ook mijn probleem.<br>
Zodra ik de completion opnieuw initialiseer nadat de schrijver een complete_all() gedaan heeft(zo dus):<br>
<div class="code">C:<br><table class="phphighlight"><tr><td class="phphighlightline"><pre>1
2
</pre></td><td class="phphighlightcode"><div><pre><span class="code_n">complete_all</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_p">);</span>
<span class="code_n">init_completion</span><span class="code_p">(</span><span class="code_w"> </span><span class="code_o">&amp;</span><span class="code_n">messagesAvailable</span><span class="code_w"> </span><span class="code_p">);</span></pre></div></td></tr></table></div><br>
krijgen mijn lezers niet meer het bericht dat ze verder mogen lezen.<br>
<br>
Ik heb een beetje lopen zoeken op internet, maar er zijn maar weinig cases waar ik complete_all echt gebruikt zie worden, terwijl dit mij op deze plek wel <i>de</i> oplossing lijkt.<br>
<br>
Kunnen jullie me vertellen waar/hoe ik mijn completion opnieuw moet initen, of dat ik toch maar beter een ander concurrency-hulpmiddel kan gebruiken? <img src="https://tweakers.net/g/s/puh2.svg" width="16" height="16" alt=":P">]]></content:encoded>
			<dc:creator>Enfer</dc:creator>
			<guid isPermaLink="false">https://gathering.tweakers.net/forum/list_message/34496577#34496577</guid>
			<pubDate>Tue, 10 Aug 2010 15:19:48 GMT</pubDate>
		</item>
	</channel>
</rss>