diff options
Diffstat (limited to 'net/rxrpc/krxiod.c')
-rw-r--r-- | net/rxrpc/krxiod.c | 262 |
1 files changed, 0 insertions, 262 deletions
diff --git a/net/rxrpc/krxiod.c b/net/rxrpc/krxiod.c deleted file mode 100644 index bbbcd6c24048..000000000000 --- a/net/rxrpc/krxiod.c +++ /dev/null | |||
@@ -1,262 +0,0 @@ | |||
1 | /* krxiod.c: Rx I/O daemon | ||
2 | * | ||
3 | * Copyright (C) 2002 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 License | ||
8 | * as published by the Free Software Foundation; either version | ||
9 | * 2 of the License, or (at your option) any later version. | ||
10 | */ | ||
11 | |||
12 | #include <linux/sched.h> | ||
13 | #include <linux/completion.h> | ||
14 | #include <linux/spinlock.h> | ||
15 | #include <linux/init.h> | ||
16 | #include <linux/freezer.h> | ||
17 | #include <rxrpc/krxiod.h> | ||
18 | #include <rxrpc/transport.h> | ||
19 | #include <rxrpc/peer.h> | ||
20 | #include <rxrpc/call.h> | ||
21 | #include "internal.h" | ||
22 | |||
23 | static DECLARE_WAIT_QUEUE_HEAD(rxrpc_krxiod_sleepq); | ||
24 | static DECLARE_COMPLETION(rxrpc_krxiod_dead); | ||
25 | |||
26 | static atomic_t rxrpc_krxiod_qcount = ATOMIC_INIT(0); | ||
27 | |||
28 | static LIST_HEAD(rxrpc_krxiod_transportq); | ||
29 | static DEFINE_SPINLOCK(rxrpc_krxiod_transportq_lock); | ||
30 | |||
31 | static LIST_HEAD(rxrpc_krxiod_callq); | ||
32 | static DEFINE_SPINLOCK(rxrpc_krxiod_callq_lock); | ||
33 | |||
34 | static volatile int rxrpc_krxiod_die; | ||
35 | |||
36 | /*****************************************************************************/ | ||
37 | /* | ||
38 | * Rx I/O daemon | ||
39 | */ | ||
40 | static int rxrpc_krxiod(void *arg) | ||
41 | { | ||
42 | DECLARE_WAITQUEUE(krxiod,current); | ||
43 | |||
44 | printk("Started krxiod %d\n",current->pid); | ||
45 | |||
46 | daemonize("krxiod"); | ||
47 | |||
48 | /* loop around waiting for work to do */ | ||
49 | do { | ||
50 | /* wait for work or to be told to exit */ | ||
51 | _debug("### Begin Wait"); | ||
52 | if (!atomic_read(&rxrpc_krxiod_qcount)) { | ||
53 | set_current_state(TASK_INTERRUPTIBLE); | ||
54 | |||
55 | add_wait_queue(&rxrpc_krxiod_sleepq, &krxiod); | ||
56 | |||
57 | for (;;) { | ||
58 | set_current_state(TASK_INTERRUPTIBLE); | ||
59 | if (atomic_read(&rxrpc_krxiod_qcount) || | ||
60 | rxrpc_krxiod_die || | ||
61 | signal_pending(current)) | ||
62 | break; | ||
63 | |||
64 | schedule(); | ||
65 | } | ||
66 | |||
67 | remove_wait_queue(&rxrpc_krxiod_sleepq, &krxiod); | ||
68 | set_current_state(TASK_RUNNING); | ||
69 | } | ||
70 | _debug("### End Wait"); | ||
71 | |||
72 | /* do work if been given some to do */ | ||
73 | _debug("### Begin Work"); | ||
74 | |||
75 | /* see if there's a transport in need of attention */ | ||
76 | if (!list_empty(&rxrpc_krxiod_transportq)) { | ||
77 | struct rxrpc_transport *trans = NULL; | ||
78 | |||
79 | spin_lock_irq(&rxrpc_krxiod_transportq_lock); | ||
80 | |||
81 | if (!list_empty(&rxrpc_krxiod_transportq)) { | ||
82 | trans = list_entry( | ||
83 | rxrpc_krxiod_transportq.next, | ||
84 | struct rxrpc_transport, | ||
85 | krxiodq_link); | ||
86 | |||
87 | list_del_init(&trans->krxiodq_link); | ||
88 | atomic_dec(&rxrpc_krxiod_qcount); | ||
89 | |||
90 | /* make sure it hasn't gone away and doesn't go | ||
91 | * away */ | ||
92 | if (atomic_read(&trans->usage)>0) | ||
93 | rxrpc_get_transport(trans); | ||
94 | else | ||
95 | trans = NULL; | ||
96 | } | ||
97 | |||
98 | spin_unlock_irq(&rxrpc_krxiod_transportq_lock); | ||
99 | |||
100 | if (trans) { | ||
101 | rxrpc_trans_receive_packet(trans); | ||
102 | rxrpc_put_transport(trans); | ||
103 | } | ||
104 | } | ||
105 | |||
106 | /* see if there's a call in need of attention */ | ||
107 | if (!list_empty(&rxrpc_krxiod_callq)) { | ||
108 | struct rxrpc_call *call = NULL; | ||
109 | |||
110 | spin_lock_irq(&rxrpc_krxiod_callq_lock); | ||
111 | |||
112 | if (!list_empty(&rxrpc_krxiod_callq)) { | ||
113 | call = list_entry(rxrpc_krxiod_callq.next, | ||
114 | struct rxrpc_call, | ||
115 | rcv_krxiodq_lk); | ||
116 | list_del_init(&call->rcv_krxiodq_lk); | ||
117 | atomic_dec(&rxrpc_krxiod_qcount); | ||
118 | |||
119 | /* make sure it hasn't gone away and doesn't go | ||
120 | * away */ | ||
121 | if (atomic_read(&call->usage) > 0) { | ||
122 | _debug("@@@ KRXIOD" | ||
123 | " Begin Attend Call %p", call); | ||
124 | rxrpc_get_call(call); | ||
125 | } | ||
126 | else { | ||
127 | call = NULL; | ||
128 | } | ||
129 | } | ||
130 | |||
131 | spin_unlock_irq(&rxrpc_krxiod_callq_lock); | ||
132 | |||
133 | if (call) { | ||
134 | rxrpc_call_do_stuff(call); | ||
135 | rxrpc_put_call(call); | ||
136 | _debug("@@@ KRXIOD End Attend Call %p", call); | ||
137 | } | ||
138 | } | ||
139 | |||
140 | _debug("### End Work"); | ||
141 | |||
142 | try_to_freeze(); | ||
143 | |||
144 | /* discard pending signals */ | ||
145 | rxrpc_discard_my_signals(); | ||
146 | |||
147 | } while (!rxrpc_krxiod_die); | ||
148 | |||
149 | /* and that's all */ | ||
150 | complete_and_exit(&rxrpc_krxiod_dead, 0); | ||
151 | |||
152 | } /* end rxrpc_krxiod() */ | ||
153 | |||
154 | /*****************************************************************************/ | ||
155 | /* | ||
156 | * start up a krxiod daemon | ||
157 | */ | ||
158 | int __init rxrpc_krxiod_init(void) | ||
159 | { | ||
160 | return kernel_thread(rxrpc_krxiod, NULL, 0); | ||
161 | |||
162 | } /* end rxrpc_krxiod_init() */ | ||
163 | |||
164 | /*****************************************************************************/ | ||
165 | /* | ||
166 | * kill the krxiod daemon and wait for it to complete | ||
167 | */ | ||
168 | void rxrpc_krxiod_kill(void) | ||
169 | { | ||
170 | rxrpc_krxiod_die = 1; | ||
171 | wake_up_all(&rxrpc_krxiod_sleepq); | ||
172 | wait_for_completion(&rxrpc_krxiod_dead); | ||
173 | |||
174 | } /* end rxrpc_krxiod_kill() */ | ||
175 | |||
176 | /*****************************************************************************/ | ||
177 | /* | ||
178 | * queue a transport for attention by krxiod | ||
179 | */ | ||
180 | void rxrpc_krxiod_queue_transport(struct rxrpc_transport *trans) | ||
181 | { | ||
182 | unsigned long flags; | ||
183 | |||
184 | _enter(""); | ||
185 | |||
186 | if (list_empty(&trans->krxiodq_link)) { | ||
187 | spin_lock_irqsave(&rxrpc_krxiod_transportq_lock, flags); | ||
188 | |||
189 | if (list_empty(&trans->krxiodq_link)) { | ||
190 | if (atomic_read(&trans->usage) > 0) { | ||
191 | list_add_tail(&trans->krxiodq_link, | ||
192 | &rxrpc_krxiod_transportq); | ||
193 | atomic_inc(&rxrpc_krxiod_qcount); | ||
194 | } | ||
195 | } | ||
196 | |||
197 | spin_unlock_irqrestore(&rxrpc_krxiod_transportq_lock, flags); | ||
198 | wake_up_all(&rxrpc_krxiod_sleepq); | ||
199 | } | ||
200 | |||
201 | _leave(""); | ||
202 | |||
203 | } /* end rxrpc_krxiod_queue_transport() */ | ||
204 | |||
205 | /*****************************************************************************/ | ||
206 | /* | ||
207 | * dequeue a transport from krxiod's attention queue | ||
208 | */ | ||
209 | void rxrpc_krxiod_dequeue_transport(struct rxrpc_transport *trans) | ||
210 | { | ||
211 | unsigned long flags; | ||
212 | |||
213 | _enter(""); | ||
214 | |||
215 | spin_lock_irqsave(&rxrpc_krxiod_transportq_lock, flags); | ||
216 | if (!list_empty(&trans->krxiodq_link)) { | ||
217 | list_del_init(&trans->krxiodq_link); | ||
218 | atomic_dec(&rxrpc_krxiod_qcount); | ||
219 | } | ||
220 | spin_unlock_irqrestore(&rxrpc_krxiod_transportq_lock, flags); | ||
221 | |||
222 | _leave(""); | ||
223 | |||
224 | } /* end rxrpc_krxiod_dequeue_transport() */ | ||
225 | |||
226 | /*****************************************************************************/ | ||
227 | /* | ||
228 | * queue a call for attention by krxiod | ||
229 | */ | ||
230 | void rxrpc_krxiod_queue_call(struct rxrpc_call *call) | ||
231 | { | ||
232 | unsigned long flags; | ||
233 | |||
234 | if (list_empty(&call->rcv_krxiodq_lk)) { | ||
235 | spin_lock_irqsave(&rxrpc_krxiod_callq_lock, flags); | ||
236 | if (atomic_read(&call->usage) > 0) { | ||
237 | list_add_tail(&call->rcv_krxiodq_lk, | ||
238 | &rxrpc_krxiod_callq); | ||
239 | atomic_inc(&rxrpc_krxiod_qcount); | ||
240 | } | ||
241 | spin_unlock_irqrestore(&rxrpc_krxiod_callq_lock, flags); | ||
242 | } | ||
243 | wake_up_all(&rxrpc_krxiod_sleepq); | ||
244 | |||
245 | } /* end rxrpc_krxiod_queue_call() */ | ||
246 | |||
247 | /*****************************************************************************/ | ||
248 | /* | ||
249 | * dequeue a call from krxiod's attention queue | ||
250 | */ | ||
251 | void rxrpc_krxiod_dequeue_call(struct rxrpc_call *call) | ||
252 | { | ||
253 | unsigned long flags; | ||
254 | |||
255 | spin_lock_irqsave(&rxrpc_krxiod_callq_lock, flags); | ||
256 | if (!list_empty(&call->rcv_krxiodq_lk)) { | ||
257 | list_del_init(&call->rcv_krxiodq_lk); | ||
258 | atomic_dec(&rxrpc_krxiod_qcount); | ||
259 | } | ||
260 | spin_unlock_irqrestore(&rxrpc_krxiod_callq_lock, flags); | ||
261 | |||
262 | } /* end rxrpc_krxiod_dequeue_call() */ | ||