I converted some of the document to reflect mutex usage instead of

semaphore usage. Since we shouldin't be promoting semaphore usage when

it's on it's way out..
Signed-Off-By: Daniel Walker <dwalker@mvista.com>
---

 Documentation/DocBook/kernel-locking.tmpl |   32 +++++++++++++++---------------

 1 file changed, 16 insertions(+), 16 deletions(-)
Index: linux-2.6.23/Documentation/DocBook/kernel-locking.tmpl

===================================================================

--- linux-2.6.23.orig/Documentation/DocBook/kernel-locking.tmpl

+++ linux-2.6.23/Documentation/DocBook/kernel-locking.tmpl

@@ -717,7 +717,7 @@ used, and when it gets full, throws out

     <para>

 For our first example, we assume that all operations are in user

 context (ie. from system calls), so we can sleep.  This means we can

-use a semaphore to protect the cache and all the objects within

+use a mutex to protect the cache and all the objects within

 it.  Here's the code:

     </para>
@@ -725,7 +725,7 @@ it.  Here's the code:

 #include &lt;linux/list.h&gt;

 #include &lt;linux/slab.h&gt;

 #include &lt;linux/string.h&gt;

-#include &lt;asm/semaphore.h&gt;

+#include &lt;linux/mutex.h&gt;

 #include &lt;asm/errno.h&gt;
 struct object

@@ -737,7 +737,7 @@ struct object

 };
 /* Protects the cache, cache_num, and the objects within it */

-static DECLARE_MUTEX(cache_lock);

+static DEFINE_MUTEX(cache_lock);

 static LIST_HEAD(cache);

 static unsigned int cache_num = 0;

 #define MAX_CACHE_SIZE 10

@@ -789,17 +789,17 @@ int cache_add(int id, const char *name)

         obj-&gt;id = id;

         obj-&gt;popularity = 0;
-        down(&amp;cache_lock);

+        mutex_lock(&amp;cache_lock);

         __cache_add(obj);

-        up(&amp;cache_lock);

+        mutex_unlock(&amp;cache_lock);

         return 0;

 }
 void cache_delete(int id)

 {

-        down(&amp;cache_lock);

+        mutex_lock(&amp;cache...
[ message continues ]