allocpercpu.c 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130
  1. /*
  2. * linux/mm/allocpercpu.c
  3. *
  4. * Separated from slab.c August 11, 2006 Christoph Lameter <clameter@sgi.com>
  5. */
  6. #include <linux/mm.h>
  7. #include <linux/module.h>
  8. /**
  9. * percpu_depopulate - depopulate per-cpu data for given cpu
  10. * @__pdata: per-cpu data to depopulate
  11. * @cpu: depopulate per-cpu data for this cpu
  12. *
  13. * Depopulating per-cpu data for a cpu going offline would be a typical
  14. * use case. You need to register a cpu hotplug handler for that purpose.
  15. */
  16. void percpu_depopulate(void *__pdata, int cpu)
  17. {
  18. struct percpu_data *pdata = __percpu_disguise(__pdata);
  19. kfree(pdata->ptrs[cpu]);
  20. pdata->ptrs[cpu] = NULL;
  21. }
  22. EXPORT_SYMBOL_GPL(percpu_depopulate);
  23. /**
  24. * percpu_depopulate_mask - depopulate per-cpu data for some cpu's
  25. * @__pdata: per-cpu data to depopulate
  26. * @mask: depopulate per-cpu data for cpu's selected through mask bits
  27. */
  28. void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask)
  29. {
  30. int cpu;
  31. for_each_cpu_mask(cpu, *mask)
  32. percpu_depopulate(__pdata, cpu);
  33. }
  34. EXPORT_SYMBOL_GPL(__percpu_depopulate_mask);
  35. /**
  36. * percpu_populate - populate per-cpu data for given cpu
  37. * @__pdata: per-cpu data to populate further
  38. * @size: size of per-cpu object
  39. * @gfp: may sleep or not etc.
  40. * @cpu: populate per-data for this cpu
  41. *
  42. * Populating per-cpu data for a cpu coming online would be a typical
  43. * use case. You need to register a cpu hotplug handler for that purpose.
  44. * Per-cpu object is populated with zeroed buffer.
  45. */
  46. void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu)
  47. {
  48. struct percpu_data *pdata = __percpu_disguise(__pdata);
  49. int node = cpu_to_node(cpu);
  50. BUG_ON(pdata->ptrs[cpu]);
  51. if (node_online(node)) {
  52. /* FIXME: kzalloc_node(size, gfp, node) */
  53. pdata->ptrs[cpu] = kmalloc_node(size, gfp, node);
  54. if (pdata->ptrs[cpu])
  55. memset(pdata->ptrs[cpu], 0, size);
  56. } else
  57. pdata->ptrs[cpu] = kzalloc(size, gfp);
  58. return pdata->ptrs[cpu];
  59. }
  60. EXPORT_SYMBOL_GPL(percpu_populate);
  61. /**
  62. * percpu_populate_mask - populate per-cpu data for more cpu's
  63. * @__pdata: per-cpu data to populate further
  64. * @size: size of per-cpu object
  65. * @gfp: may sleep or not etc.
  66. * @mask: populate per-cpu data for cpu's selected through mask bits
  67. *
  68. * Per-cpu objects are populated with zeroed buffers.
  69. */
  70. int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
  71. cpumask_t *mask)
  72. {
  73. cpumask_t populated = CPU_MASK_NONE;
  74. int cpu;
  75. for_each_cpu_mask(cpu, *mask)
  76. if (unlikely(!percpu_populate(__pdata, size, gfp, cpu))) {
  77. __percpu_depopulate_mask(__pdata, &populated);
  78. return -ENOMEM;
  79. } else
  80. cpu_set(cpu, populated);
  81. return 0;
  82. }
  83. EXPORT_SYMBOL_GPL(__percpu_populate_mask);
  84. /**
  85. * percpu_alloc_mask - initial setup of per-cpu data
  86. * @size: size of per-cpu object
  87. * @gfp: may sleep or not etc.
  88. * @mask: populate per-data for cpu's selected through mask bits
  89. *
  90. * Populating per-cpu data for all online cpu's would be a typical use case,
  91. * which is simplified by the percpu_alloc() wrapper.
  92. * Per-cpu objects are populated with zeroed buffers.
  93. */
  94. void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask)
  95. {
  96. void *pdata = kzalloc(sizeof(struct percpu_data), gfp);
  97. void *__pdata = __percpu_disguise(pdata);
  98. if (unlikely(!pdata))
  99. return NULL;
  100. if (likely(!__percpu_populate_mask(__pdata, size, gfp, mask)))
  101. return __pdata;
  102. kfree(pdata);
  103. return NULL;
  104. }
  105. EXPORT_SYMBOL_GPL(__percpu_alloc_mask);
  106. /**
  107. * percpu_free - final cleanup of per-cpu data
  108. * @__pdata: object to clean up
  109. *
  110. * We simply clean up any per-cpu object left. No need for the client to
  111. * track and specify through a bis mask which per-cpu objects are to free.
  112. */
  113. void percpu_free(void *__pdata)
  114. {
  115. if (unlikely(!__pdata))
  116. return;
  117. __percpu_depopulate_mask(__pdata, &cpu_possible_map);
  118. kfree(__percpu_disguise(__pdata));
  119. }
  120. EXPORT_SYMBOL_GPL(percpu_free);