daemon/cqueue.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains interface to the command queue
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "cmd.h"
  28
  29 void ladish_cqueue_init(struct ladish_cqueue * queue_ptr)
  30 {
  31   queue_ptr->cancel = false;
  32   INIT_LIST_HEAD(&queue_ptr->queue);
  33 }
  34
  35 void ladish_cqueue_run(struct ladish_cqueue * queue_ptr)
  36 {
  37   struct list_head * node_ptr;
  38   struct ladish_command * cmd_ptr;
  39
  40 loop:
  41   if (list_empty(&queue_ptr->queue))
  42   {
  43     return;
  44   }
  45
  46   node_ptr = queue_ptr->queue.next;
  47   cmd_ptr = list_entry(node_ptr, struct ladish_command, siblings);
  48
  49   ASSERT(cmd_ptr->run != NULL);
  50   ASSERT(cmd_ptr->state == LADISH_COMMAND_STATE_PENDING || cmd_ptr->state == LADISH_COMMAND_STATE_WAITING);
  51
  52   if (cmd_ptr->state == LADISH_COMMAND_STATE_PENDING)
  53   { /* if this is a new command, put a separator so its impact is clearly visible in the log */
  54     log_info("-------");
  55   }
  56
  57   if (!cmd_ptr->run(cmd_ptr->context))
  58   {
  59     ladish_cqueue_clear(queue_ptr);
  60     return;
  61   }
  62
  63   switch (cmd_ptr->state)
  64   {
  65   case LADISH_COMMAND_STATE_DONE:
  66     break;
  67   case LADISH_COMMAND_STATE_WAITING:
  68     return;
  69   default:
  70     log_error("unexpected cmd state %u after run()", cmd_ptr->state);
  71     ASSERT_NO_PASS;
  72     ladish_cqueue_clear(queue_ptr);
  73     return;
  74   }
  75
  76   list_del(node_ptr);
  77
  78   if (cmd_ptr->destructor != NULL)
  79   {
  80     cmd_ptr->destructor(cmd_ptr->context);
  81   }
  82
  83   free(cmd_ptr);
  84
  85   if (queue_ptr->cancel && list_empty(&queue_ptr->queue));
  86   {
  87     queue_ptr->cancel = false;
  88   }
  89
  90   goto loop;
  91 }
  92
  93 void ladish_cqueue_cancel(struct ladish_cqueue * queue_ptr)
  94 {
  95   struct list_head * node_ptr;
  96   struct ladish_command * cmd_ptr;
  97
  98   if (list_empty(&queue_ptr->queue))
  99   { /* nothing to cancel */
 100     return;
 101   }
 102
 103   node_ptr = queue_ptr->queue.next; /* current command */
 104   cmd_ptr = list_entry(node_ptr, struct ladish_command, siblings);
 105   if (cmd_ptr->state != LADISH_COMMAND_STATE_WAITING)
 106   {
 107     ladish_cqueue_clear(queue_ptr);
 108     return;
 109   }
 110
 111   /* clear all commands except currently waiting one */
 112   while (queue_ptr->queue.next != queue_ptr->queue.prev)
 113   {
 114     node_ptr = queue_ptr->queue.prev;
 115     list_del(node_ptr);
 116
 117     cmd_ptr = list_entry(node_ptr, struct ladish_command, siblings);
 118
 119     if (cmd_ptr->destructor != NULL)
 120     {
 121       cmd_ptr->destructor(cmd_ptr->context);
 122     }
 123
 124     free(cmd_ptr);
 125   }
 126
 127   queue_ptr->cancel = true;
 128   cmd_ptr->cancel = true;
 129 }
 130
 131 bool ladish_cqueue_add_command(struct ladish_cqueue * queue_ptr, struct ladish_command * cmd_ptr)
 132 {
 133   ASSERT(cmd_ptr->run != NULL);
 134
 135   if (queue_ptr->cancel)
 136   {
 137     return false;
 138   }
 139
 140   ASSERT(cmd_ptr->state == LADISH_COMMAND_STATE_PREPARE);
 141   cmd_ptr->state = LADISH_COMMAND_STATE_PENDING;
 142
 143   list_add_tail(&cmd_ptr->siblings, &queue_ptr->queue);
 144   return true;
 145 }
 146
 147 void ladish_cqueue_clear(struct ladish_cqueue * queue_ptr)
 148 {
 149   struct list_head * node_ptr;
 150   struct ladish_command * cmd_ptr;
 151
 152   while (!list_empty(&queue_ptr->queue))
 153   {
 154     node_ptr = queue_ptr->queue.next;
 155     list_del(node_ptr);
 156
 157     cmd_ptr = list_entry(node_ptr, struct ladish_command, siblings);
 158
 159     if (cmd_ptr->destructor != NULL)
 160     {
 161       cmd_ptr->destructor(cmd_ptr->context);
 162     }
 163
 164     free(cmd_ptr);
 165   }
 166
 167   queue_ptr->cancel = false;
 168 }
 169
 170 void ladish_cqueue_drop_command(struct ladish_cqueue * queue_ptr)
 171 {
 172   struct list_head * node_ptr;
 173   struct ladish_command * cmd_ptr;
 174
 175   ASSERT(!list_empty(&queue_ptr->queue)); /* there is nothing to drop */
 176
 177   /* remove the last command from the queue */
 178   node_ptr = queue_ptr->queue.prev;
 179   list_del(node_ptr);
 180   cmd_ptr = list_entry(node_ptr, struct ladish_command, siblings);
 181
 182   ASSERT(cmd_ptr->run != NULL);
 183
 184   /* waiting commands are not supposed to be dropped */
 185   /* commands that are not yet prepared and those that are already processed are not supposed to be in the queue */
 186   ASSERT(cmd_ptr->state == LADISH_COMMAND_STATE_PENDING);
 187
 188   if (cmd_ptr->destructor != NULL)
 189   {
 190     cmd_ptr->destructor(cmd_ptr->context);
 191   }
 192
 193   free(cmd_ptr);
 194 }
 195
 196 void * ladish_command_new(size_t size)
 197 {
 198   struct ladish_command * cmd_ptr;
 199
 200   ASSERT(size >= sizeof(struct ladish_command));
 201
 202   cmd_ptr = malloc(size);
 203   if (cmd_ptr == NULL)
 204   {
 205     log_error("malloc failed to allocate command with size %zu", size);
 206     return NULL;
 207   }
 208
 209   cmd_ptr->state = LADISH_COMMAND_STATE_PREPARE;
 210   cmd_ptr->cancel = false;
 211
 212   cmd_ptr->context = cmd_ptr;
 213   cmd_ptr->run = NULL;
 214   cmd_ptr->destructor = NULL;
 215
 216   return cmd_ptr;
 217 }