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           0 :         spinlock_t *tlocks = NULL;
      19           0 :         unsigned int i, size;
      20             : #if defined(CONFIG_PROVE_LOCKING)
      21           0 :         unsigned int nr_pcpus = 2;
      22             : #else
      23             :         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           0 :                 size = max_size;
      31             :         }
      32             : 
      33           0 :         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           0 :                         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);