handler.c 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132
  1. /*
  2. * net/tipc/handler.c: TIPC signal handling
  3. *
  4. * Copyright (c) 2000-2006, Ericsson AB
  5. * Copyright (c) 2005, Wind River Systems
  6. * All rights reserved.
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions are met:
  10. *
  11. * 1. Redistributions of source code must retain the above copyright
  12. * notice, this list of conditions and the following disclaimer.
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. * notice, this list of conditions and the following disclaimer in the
  15. * documentation and/or other materials provided with the distribution.
  16. * 3. Neither the names of the copyright holders nor the names of its
  17. * contributors may be used to endorse or promote products derived from
  18. * this software without specific prior written permission.
  19. *
  20. * Alternatively, this software may be distributed under the terms of the
  21. * GNU General Public License ("GPL") version 2 as published by the Free
  22. * Software Foundation.
  23. *
  24. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34. * POSSIBILITY OF SUCH DAMAGE.
  35. */
  36. #include "core.h"
  37. struct queue_item {
  38. struct list_head next_signal;
  39. void (*handler) (unsigned long);
  40. unsigned long data;
  41. };
  42. static struct kmem_cache *tipc_queue_item_cache;
  43. static struct list_head signal_queue_head;
  44. static DEFINE_SPINLOCK(qitem_lock);
  45. static int handler_enabled = 0;
  46. static void process_signal_queue(unsigned long dummy);
  47. static DECLARE_TASKLET_DISABLED(tipc_tasklet, process_signal_queue, 0);
  48. unsigned int tipc_k_signal(Handler routine, unsigned long argument)
  49. {
  50. struct queue_item *item;
  51. if (!handler_enabled) {
  52. err("Signal request ignored by handler\n");
  53. return -ENOPROTOOPT;
  54. }
  55. spin_lock_bh(&qitem_lock);
  56. item = kmem_cache_alloc(tipc_queue_item_cache, GFP_ATOMIC);
  57. if (!item) {
  58. err("Signal queue out of memory\n");
  59. spin_unlock_bh(&qitem_lock);
  60. return -ENOMEM;
  61. }
  62. item->handler = routine;
  63. item->data = argument;
  64. list_add_tail(&item->next_signal, &signal_queue_head);
  65. spin_unlock_bh(&qitem_lock);
  66. tasklet_schedule(&tipc_tasklet);
  67. return 0;
  68. }
  69. static void process_signal_queue(unsigned long dummy)
  70. {
  71. struct queue_item *__volatile__ item;
  72. struct list_head *l, *n;
  73. spin_lock_bh(&qitem_lock);
  74. list_for_each_safe(l, n, &signal_queue_head) {
  75. item = list_entry(l, struct queue_item, next_signal);
  76. list_del(&item->next_signal);
  77. spin_unlock_bh(&qitem_lock);
  78. item->handler(item->data);
  79. spin_lock_bh(&qitem_lock);
  80. kmem_cache_free(tipc_queue_item_cache, item);
  81. }
  82. spin_unlock_bh(&qitem_lock);
  83. }
  84. int tipc_handler_start(void)
  85. {
  86. tipc_queue_item_cache =
  87. kmem_cache_create("tipc_queue_items", sizeof(struct queue_item),
  88. 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
  89. if (!tipc_queue_item_cache)
  90. return -ENOMEM;
  91. INIT_LIST_HEAD(&signal_queue_head);
  92. tasklet_enable(&tipc_tasklet);
  93. handler_enabled = 1;
  94. return 0;
  95. }
  96. void tipc_handler_stop(void)
  97. {
  98. struct list_head *l, *n;
  99. struct queue_item *item;
  100. if (!handler_enabled)
  101. return;
  102. handler_enabled = 0;
  103. tasklet_disable(&tipc_tasklet);
  104. tasklet_kill(&tipc_tasklet);
  105. spin_lock_bh(&qitem_lock);
  106. list_for_each_safe(l, n, &signal_queue_head) {
  107. item = list_entry(l, struct queue_item, next_signal);
  108. list_del(&item->next_signal);
  109. kmem_cache_free(tipc_queue_item_cache, item);
  110. }
  111. spin_unlock_bh(&qitem_lock);
  112. kmem_cache_destroy(tipc_queue_item_cache);
  113. }