libcfs/libcfs/libcfs_mem.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 021110-1307, USA
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  25  * Copyright (c) 2012, Intel Corporation.
  26  */
  27 /*
  28  * This file is part of Lustre, http://www.lustre.org/
  29  *
  30  * Author: liang@whamcloud.com
  31  */
  32
  33 #define DEBUG_SUBSYSTEM S_LNET
  34
  35 #include <linux/workqueue.h>
  36 #include <libcfs/libcfs.h>
  37 #include <lustre_compat.h>
  38
  39 struct cfs_var_array {
  40         unsigned int            va_count;       /* # of buffers */
  41         unsigned int            va_size;        /* size of each var */
  42         struct cfs_cpt_table    *va_cptab;      /* cpu partition table */
  43         void                    *va_ptrs[0];    /* buffer addresses */
  44 };
  45
  46 /*
  47  * free per-cpu data, see more detail in cfs_percpt_free
  48  */
  49 void
  50 cfs_percpt_free(void *vars)
  51 {
  52         struct  cfs_var_array *arr;
  53         int     i;
  54
  55         arr = container_of(vars, struct cfs_var_array, va_ptrs[0]);
  56
  57         for (i = 0; i < arr->va_count; i++) {
  58                 if (arr->va_ptrs[i] != NULL)
  59                         LIBCFS_FREE(arr->va_ptrs[i], arr->va_size);
  60         }
  61
  62         LIBCFS_FREE(arr, offsetof(struct cfs_var_array,
  63                                   va_ptrs[arr->va_count]));
  64 }
  65 EXPORT_SYMBOL(cfs_percpt_free);
  66
  67 /*
  68  * allocate per cpu-partition variables, returned value is an array of pointers,
  69  * variable can be indexed by CPU partition ID, i.e:
  70  *
  71  *      arr = cfs_percpt_alloc(cfs_cpu_pt, size);
  72  *      then caller can access memory block for CPU 0 by arr[0],
  73  *      memory block for CPU 1 by arr[1]...
  74  *      memory block for CPU N by arr[N]...
  75  *
  76  * cacheline aligned.
  77  */
  78 void *
  79 cfs_percpt_alloc(struct cfs_cpt_table *cptab, unsigned int size)
  80 {
  81         struct cfs_var_array    *arr;
  82         int                     count;
  83         int                     i;
  84
  85         count = cfs_cpt_number(cptab);
  86
  87         LIBCFS_ALLOC(arr, offsetof(struct cfs_var_array, va_ptrs[count]));
  88         if (arr == NULL)
  89                 return NULL;
  90
  91         arr->va_size    = size = L1_CACHE_ALIGN(size);
  92         arr->va_count   = count;
  93         arr->va_cptab   = cptab;
  94
  95         for (i = 0; i < count; i++) {
  96                 LIBCFS_CPT_ALLOC(arr->va_ptrs[i], cptab, i, size);
  97                 if (arr->va_ptrs[i] == NULL) {
  98                         cfs_percpt_free((void *)&arr->va_ptrs[0]);
  99                         return NULL;
 100                 }
 101         }
 102
 103         return (void *)&arr->va_ptrs[0];
 104 }
 105 EXPORT_SYMBOL(cfs_percpt_alloc);
 106
 107 /*
 108  * return number of CPUs (or number of elements in per-cpu data)
 109  * according to cptab of @vars
 110  */
 111 int
 112 cfs_percpt_number(void *vars)
 113 {
 114         struct cfs_var_array *arr;
 115
 116         arr = container_of(vars, struct cfs_var_array, va_ptrs[0]);
 117
 118         return arr->va_count;
 119 }
 120 EXPORT_SYMBOL(cfs_percpt_number);
 121
 122
 123 /*
 124  * This is opencoding of vfree_atomic from Linux kernel added in 4.10 with
 125  * minimum changes needed to work on older kernels too.
 126  */
 127
 128 #ifndef llist_for_each_safe
 129 #define llist_for_each_safe(pos, n, node)                       \
 130         for ((pos) = (node); (pos) && ((n) = (pos)->next, true); (pos) = (n))
 131 #endif
 132
 133 struct vfree_deferred {
 134         struct llist_head list;
 135         struct work_struct wq;
 136 };
 137 static DEFINE_PER_CPU(struct vfree_deferred, vfree_deferred);
 138
 139 static void free_work(struct work_struct *w)
 140 {
 141         struct vfree_deferred *p = container_of(w, struct vfree_deferred, wq);
 142         struct llist_node *t, *llnode;
 143
 144         llist_for_each_safe(llnode, t, llist_del_all(&p->list))
 145                 vfree((void *)llnode);
 146 }
 147
 148 void libcfs_vfree_atomic(const void *addr)
 149 {
 150         struct vfree_deferred *p = raw_cpu_ptr(&vfree_deferred);
 151
 152         if (!addr)
 153                 return;
 154
 155         if (llist_add((struct llist_node *)addr, &p->list))
 156                 schedule_work(&p->wq);
 157 }
 158 EXPORT_SYMBOL(libcfs_vfree_atomic);
 159
 160 void __init init_libcfs_vfree_atomic(void)
 161 {
 162         int i;
 163
 164         for_each_possible_cpu(i) {
 165                 struct vfree_deferred *p;
 166
 167                 p = &per_cpu(vfree_deferred, i);
 168                 init_llist_head(&p->list);
 169                 INIT_WORK(&p->wq, free_work);
 170         }
 171 }
 172
 173 void __exit exit_libcfs_vfree_atomic(void)
 174 {
 175         flush_scheduled_work();
 176 }