ksplice-patch/ksplice-shadow.h

   1 #include <linux/list.h>
   2 #include <linux/gfp.h>
   3 #include "ksplice-patch.h"
   4
   5 struct shadow_field {
   6         void *obj;
   7         void *data;
   8         int *key;
   9         struct list_head list;
  10 };
  11
  12 LIST_HEAD(shadow_list);
  13 DEFINE_SPINLOCK(shadow_lock);
  14
  15 int init_shadow_field_type(int *shadow_key, typeof(GFP_KERNEL) gfp_flags)
  16 {
  17         return 0;
  18 }
  19
  20 void *init_shadow_field(int *shadow_key, void *obj, int size,
  21                         typeof(GFP_KERNEL) gfp_flags)
  22 {
  23         struct shadow_field *shadow = kmalloc(sizeof(*shadow), gfp_flags);
  24         if (shadow == NULL)
  25                 return NULL;
  26         shadow->obj = obj;
  27         shadow->key = shadow_key;
  28         shadow->data = kmalloc(size, gfp_flags);
  29         if (shadow->data == NULL) {
  30                 kfree(shadow);
  31                 return NULL;
  32         }
  33         spin_lock(&shadow_lock);
  34         list_add(&shadow->list, &shadow_list);
  35         spin_unlock(&shadow_lock);
  36         return shadow->data;
  37 }
  38
  39 void cleanup_shadow_field(int *shadow_key, void *obj)
  40 {
  41         struct shadow_field *shadow;
  42         spin_lock(&shadow_lock);
  43         list_for_each_entry(shadow, &shadow_list, list) {
  44                 if (shadow->obj == obj && shadow->key == shadow_key) {
  45                         list_del(&shadow->list);
  46                         kfree(shadow->data);
  47                         kfree(shadow);
  48                         goto out;
  49                 }
  50         }
  51 out:
  52         spin_unlock(&shadow_lock);
  53 }
  54
  55 void *get_shadow_field(int *shadow_key, void *obj)
  56 {
  57         struct shadow_field *shadow;
  58         void *data = NULL;
  59         spin_lock(&shadow_lock);
  60         list_for_each_entry(shadow, &shadow_list, list) {
  61                 if (shadow->obj == obj && shadow->key == shadow_key) {
  62                         data = shadow->data;
  63                         goto out;
  64                 }
  65         }
  66 out:
  67         spin_unlock(&shadow_lock);
  68         return data;
  69 }
  70
  71 void cleanup_shadow_field_type(int *shadow_key)
  72 {
  73         struct shadow_field *shadow, *n;
  74         spin_lock(&shadow_lock);
  75         list_for_each_entry_safe(shadow, n, &shadow_list, list) {
  76                 if (shadow->key == shadow_key) {
  77                         list_del(&shadow->list);
  78                         kfree(shadow->data);
  79                         kfree(shadow);
  80                 }
  81         }
  82         spin_unlock(&shadow_lock);
  83 }