src_frescan/frescan_bwres_threads.c

   1 /*!
   2  * @file frescan_bwres_threads.c
   3  *
   4  * @brief FRESCAN bandwidth reservation layer: negotiation threads
   5  *
   6  * This module contains the acceptor threads and the master thread for local
   7  * negotiations, with functions to create them.
   8  *
   9  * @version 0.01
  10  *
  11  * @date 2-Apr-2008
  12  *
  13  * @author Daniel Sangorrin <daniel.sangorrin@unican.es>
  14  *
  15  */
  16
  17 #include <assert.h>
  18 #include "fosa_threads_and_signals.h" // fosa_thread_attr_init...
  19 #include "frescan_bwres_threads.h"
  20 #include "frescan_bwres_messages.h"
  21 #include "frescan_bwres_requests.h"
  22 #include "frescan_config.h"
  23 #include "frescan_debug.h"
  24 #include "frescan_data.h"
  25 #include "frescan_servers.h"
  26
  27 /**
  28  * frescan_manager_thread_create()
  29  *
  30  * This call creates the manager thread at each node which will be waiting
  31  * in a request queue for LOCAL or EXTERNAL requests.
  32  */
  33
  34 static void *frescan_manager_thread(void *arg);
  35
  36 int frescan_manager_thread_create(frescan_network_t net)
  37 {
  38         int ret;
  39         fosa_thread_attr_t attr;
  40
  41         ret = fosa_thread_attr_init(&attr);
  42         if (ret != 0) return ret;
  43
  44         ret = fosa_thread_attr_set_prio(&attr, FRESCAN_NEG_THREAD_PRIO);
  45         if (ret != 0) return ret;
  46
  47         ret = fosa_thread_create(&the_networks[net].manager_thread_id,
  48                                  &attr,
  49                                  frescan_manager_thread,
  50                                  (void *)(uint32_t)net);
  51         if (ret != 0) return ret;
  52
  53         ret = fosa_thread_attr_destroy(&attr);
  54         if (ret != 0) return ret;
  55
  56         return 0;
  57 }
  58
  59 /**
  60  * frescan_acceptor_thread_create()
  61  *
  62  * This call creates the acceptor thread which will be waiting negotiation
  63  * messages from the network and converting them into requests.
  64  */
  65
  66 static void *frescan_acceptor_thread(void *arg);
  67
  68 int frescan_acceptor_thread_create(frescan_network_t net)
  69 {
  70         int ret;
  71         fosa_thread_attr_t attr;
  72
  73         ret = fosa_thread_attr_init(&attr);
  74         if (ret != 0) return ret;
  75
  76         ret = fosa_thread_attr_set_prio(&attr, FRESCAN_ACCEPTOR_THREAD_PRIO);
  77         if (ret != 0) return ret;
  78
  79         ret = fosa_thread_create(&the_networks[net].acceptor_thread_id,
  80                                  &attr,
  81                                  frescan_acceptor_thread,
  82                                  (void *)(uint32_t)net);
  83         if (ret != 0) return ret;
  84
  85         ret = fosa_thread_attr_destroy(&attr);
  86         if (ret != 0) return ret;
  87
  88         return 0;
  89 }
  90
  91 /**
  92  * frescan_manager_thread
  93  */
  94
  95 static int frescan_manager_neg(frescan_request_data_t *req_data);
  96 static int frescan_manager_reneg(frescan_request_data_t *req_data);
  97 static int frescan_manager_cancel(frescan_request_data_t *req_data);
  98 static int frescan_manager_repneg(frescan_request_data_t *req_data);
  99
 100 static void *frescan_manager_thread(void *arg)
 101 {
 102         int ret;
 103         frescan_request_id_t   req;
 104         frescan_request_data_t *req_data;
 105         frescan_network_t net = (uint32_t)arg;
 106
 107         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "manager thread starts\n");
 108
 109         while(1) {
 110                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "wait for a request\n");
 111
 112                 ret = frescan_requests_dequeue(&req);
 113                 assert(ret == 0);
 114
 115                 ret = frescan_requests_get_data(req, &req_data);
 116                 assert(ret == 0);
 117
 118                 switch(req_data->type) {
 119                         case FRESCAN_REQ_NEG:
 120                                 ret = frescan_manager_neg(req_data);
 121                                 assert(ret == 0);
 122                                 break;
 123                         case FRESCAN_REQ_RENEG:
 124                                 ret = frescan_manager_reneg(req_data);
 125                                 assert(ret == 0);
 126                                 break;
 127                         case FRESCAN_REQ_CANCEL:
 128                                 ret = frescan_manager_cancel(req_data);
 129                                 assert(ret == 0);
 130                                 break;
 131                         case FRESCAN_REP_NEG:
 132                                 ret = frescan_manager_repneg(req_data);
 133                                 assert(ret == 0);
 134                                 break;
 135                         default:
 136                                 ERROR("request type not supported\n");
 137                                 assert(0);
 138                 }
 139
 140                 if(req_data->request_node != the_networks[net].local_node) {
 141                         ret = frescan_requests_free(req);
 142                         assert(ret == 0);
 143                 }
 144         }
 145 }
 146
 147 /**
 148  * frescan_acceptor_thread()
 149  */
 150
 151 static void *frescan_acceptor_thread(void *arg)
 152 {
 153         int ret;
 154         frescan_recv_params_t recv_params;
 155         uint8_t msg[2000]; // TODO: use a constant with the max neg message size
 156         size_t recv_bytes;
 157         frescan_node_t from;
 158         frescan_prio_t prio;
 159         frescan_request_id_t req;
 160         frescan_request_data_t *req_data;
 161
 162         DEBUG(FRESCAN_ACCEPTOR_THREAD_ENABLE_DEBUG, "acceptor th starts\n");
 163
 164         recv_params.net     = (frescan_network_t)(uint32_t)arg;
 165         recv_params.channel = FRESCAN_NEG_CHANNEL;
 166         recv_params.flags   = FRESCAN_SYNC;
 167
 168         while(1) {
 169                 DEBUG(FRESCAN_ACCEPTOR_THREAD_ENABLE_DEBUG,
 170                       "waiting for a msg, net:%u chan:%u flags:%u\n",
 171                       recv_params.net, recv_params.channel, recv_params.flags);
 172
 173                 ret = frescan_recv(&recv_params,
 174                                    msg,
 175                                    sizeof(msg),
 176                                    &recv_bytes,
 177                                    &from,
 178                                    &prio);
 179                 assert(ret == 0);
 180
 181                 DEBUG(FRESCAN_ACCEPTOR_THREAD_ENABLE_DEBUG,
 182                       "msg received, from:%u size:%u prio:%u\n",
 183                       from, recv_bytes, prio);
 184
 185                 ret = frescan_requests_alloc(&req);
 186                 assert(ret == 0);
 187
 188                 ret = frescan_requests_get_data(req, &req_data);
 189                 assert(ret == 0);
 190
 191                 ret = frescan_message_to_request(msg, req_data);
 192                 assert(ret == 0);
 193
 194                 req_data->request_node = from;
 195
 196                 ret = frescan_requests_enqueue(req);
 197                 assert(ret == 0);
 198         }
 199
 200         return NULL;
 201 }
 202
 203 /**
 204  * frescan_manager_neg
 205  */
 206
 207 static int frescan_manager_neg(frescan_request_data_t *req_data)
 208 {
 209         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "negotiation request\n");
 210         return 0;
 211 }
 212
 213 /**
 214  * frescan_manager_neg
 215  */
 216
 217 static int frescan_manager_reneg(frescan_request_data_t *req_data)
 218 {
 219         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "renegotiation request\n");
 220         return 0;
 221 }
 222
 223 /**
 224  * frescan_manager_neg
 225  */
 226
 227 static int frescan_manager_cancel(frescan_request_data_t *req_data)
 228 {
 229         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "cancel request\n");
 230         return 0;
 231 }
 232
 233 /**
 234  * frescan_manager_neg
 235  */
 236
 237 static int frescan_manager_repneg(frescan_request_data_t *req_data)
 238 {
 239         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "reply to neg request\n");
 240         return 0;
 241 }