Branch data     Line data    Source code

       1                 :            : #include <linux/export.h>
       2                 :            : #include <linux/kernel.h>
       3                 :            : #include <linux/mm.h>
       4                 :            : #include <linux/slab.h>
       5                 :            : #include <linux/vmalloc.h>
       6                 :            : 
       7                 :            : /* Allocate an array of spinlocks to be accessed by a hash. Two arguments
       8                 :            :  * indicate the number of elements to allocate in the array. max_size
       9                 :            :  * gives the maximum number of elements to allocate. cpu_mult gives
      10                 :            :  * the number of locks per CPU to allocate. The size is rounded up
      11                 :            :  * to a power of 2 to be suitable as a hash table.
      12                 :            :  */
      13                 :            : 
      14                 :          0 : int __alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *locks_mask,
      15                 :            :                              size_t max_size, unsigned int cpu_mult, gfp_t gfp,
      16                 :            :                              const char *name, struct lock_class_key *key)
      17                 :            : {
      18                 :            :         spinlock_t *tlocks = NULL;
      19                 :            :         unsigned int i, size;
      20                 :            : #if defined(CONFIG_PROVE_LOCKING)
      21                 :            :         unsigned int nr_pcpus = 2;
      22                 :            : #else
      23                 :          0 :         unsigned int nr_pcpus = num_possible_cpus();
      24                 :            : #endif
      25                 :            : 
      26                 :          0 :         if (cpu_mult) {
      27                 :          0 :                 nr_pcpus = min_t(unsigned int, nr_pcpus, 64UL);
      28                 :          0 :                 size = min_t(unsigned int, nr_pcpus * cpu_mult, max_size);
      29                 :            :         } else {
      30                 :            :                 size = max_size;
      31                 :            :         }
      32                 :            : 
      33                 :            :         if (sizeof(spinlock_t) != 0) {
      34                 :          0 :                 tlocks = kvmalloc_array(size, sizeof(spinlock_t), gfp);
      35                 :          0 :                 if (!tlocks)
      36                 :            :                         return -ENOMEM;
      37                 :          0 :                 for (i = 0; i < size; i++) {
      38                 :          0 :                         spin_lock_init(&tlocks[i]);
      39                 :            :                         lockdep_init_map(&tlocks[i].dep_map, name, key, 0);
      40                 :            :                 }
      41                 :            :         }
      42                 :            : 
      43                 :          0 :         *locks = tlocks;
      44                 :          0 :         *locks_mask = size - 1;
      45                 :            : 
      46                 :          0 :         return 0;
      47                 :            : }
      48                 :            : EXPORT_SYMBOL(__alloc_bucket_spinlocks);
      49                 :            : 
      50                 :          0 : void free_bucket_spinlocks(spinlock_t *locks)
      51                 :            : {
      52                 :          0 :         kvfree(locks);
      53                 :          0 : }
      54                 :            : EXPORT_SYMBOL(free_bucket_spinlocks);