Add semaphore.h to kernel_lock.c
[linux-2.6.git] / arch / mn10300 / kernel / semaphore.c
1 /* MN10300 Semaphore implementation
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public Licence
8  * as published by the Free Software Foundation; either version
9  * 2 of the Licence, or (at your option) any later version.
10  */
11 #include <linux/sched.h>
12 #include <linux/module.h>
13 #include <asm/semaphore.h>
14
15 struct sem_waiter {
16         struct list_head        list;
17         struct task_struct      *task;
18 };
19
20 #if SEMAPHORE_DEBUG
21 void semtrace(struct semaphore *sem, const char *str)
22 {
23         if (sem->debug)
24                 printk(KERN_DEBUG "[%d] %s({%d,%d})\n",
25                        current->pid,
26                        str,
27                        atomic_read(&sem->count),
28                        list_empty(&sem->wait_list) ? 0 : 1);
29 }
30 #else
31 #define semtrace(SEM, STR) do { } while (0)
32 #endif
33
34 /*
35  * wait for a token to be granted from a semaphore
36  * - entered with lock held and interrupts disabled
37  */
38 void __down(struct semaphore *sem, unsigned long flags)
39 {
40         struct task_struct *tsk = current;
41         struct sem_waiter waiter;
42
43         semtrace(sem, "Entering __down");
44
45         /* set up my own style of waitqueue */
46         waiter.task = tsk;
47         get_task_struct(tsk);
48
49         list_add_tail(&waiter.list, &sem->wait_list);
50
51         /* we don't need to touch the semaphore struct anymore */
52         spin_unlock_irqrestore(&sem->wait_lock, flags);
53
54         /* wait to be given the semaphore */
55         set_task_state(tsk, TASK_UNINTERRUPTIBLE);
56
57         for (;;) {
58                 if (!waiter.task)
59                         break;
60                 schedule();
61                 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
62         }
63
64         tsk->state = TASK_RUNNING;
65         semtrace(sem, "Leaving __down");
66 }
67 EXPORT_SYMBOL(__down);
68
69 /*
70  * interruptibly wait for a token to be granted from a semaphore
71  * - entered with lock held and interrupts disabled
72  */
73 int __down_interruptible(struct semaphore *sem, unsigned long flags)
74 {
75         struct task_struct *tsk = current;
76         struct sem_waiter waiter;
77         int ret;
78
79         semtrace(sem, "Entering __down_interruptible");
80
81         /* set up my own style of waitqueue */
82         waiter.task = tsk;
83         get_task_struct(tsk);
84
85         list_add_tail(&waiter.list, &sem->wait_list);
86
87         /* we don't need to touch the semaphore struct anymore */
88         set_task_state(tsk, TASK_INTERRUPTIBLE);
89
90         spin_unlock_irqrestore(&sem->wait_lock, flags);
91
92         /* wait to be given the semaphore */
93         ret = 0;
94         for (;;) {
95                 if (!waiter.task)
96                         break;
97                 if (unlikely(signal_pending(current)))
98                         goto interrupted;
99                 schedule();
100                 set_task_state(tsk, TASK_INTERRUPTIBLE);
101         }
102
103  out:
104         tsk->state = TASK_RUNNING;
105         semtrace(sem, "Leaving __down_interruptible");
106         return ret;
107
108  interrupted:
109         spin_lock_irqsave(&sem->wait_lock, flags);
110         list_del(&waiter.list);
111         spin_unlock_irqrestore(&sem->wait_lock, flags);
112
113         ret = 0;
114         if (!waiter.task) {
115                 put_task_struct(current);
116                 ret = -EINTR;
117         }
118         goto out;
119 }
120 EXPORT_SYMBOL(__down_interruptible);
121
122 /*
123  * release a single token back to a semaphore
124  * - entered with lock held and interrupts disabled
125  */
126 void __up(struct semaphore *sem)
127 {
128         struct task_struct *tsk;
129         struct sem_waiter *waiter;
130
131         semtrace(sem, "Entering __up");
132
133         /* grant the token to the process at the front of the queue */
134         waiter = list_entry(sem->wait_list.next, struct sem_waiter, list);
135
136         /* We must be careful not to touch 'waiter' after we set ->task = NULL.
137          * It is an allocated on the waiter's stack and may become invalid at
138          * any time after that point (due to a wakeup from another source).
139          */
140         list_del_init(&waiter->list);
141         tsk = waiter->task;
142         smp_mb();
143         waiter->task = NULL;
144         wake_up_process(tsk);
145         put_task_struct(tsk);
146
147         semtrace(sem, "Leaving __up");
148 }
149 EXPORT_SYMBOL(__up);