git.oblomov.eu Git - linux-2.6/blob - net/rxrpc/krxiod.c

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