From: Rao Shoaib <[email protected]>
Signed-off-by: Rao Shoaib <[email protected]>
---
include/linux/rcupdate.h | 43 +++----------------------------------------
include/linux/rcutree.h | 2 --
include/linux/slab.h | 44 ++++++++++++++++++++++++++++++++++++++++++++
kernel/rcu/tree.c | 24 ++++++++++--------------
mm/slab_common.c | 10 ++++++++++
5 files changed, 67 insertions(+), 56 deletions(-)
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index a6ddc42..23ed728 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -55,6 +55,9 @@ void call_rcu(struct rcu_head *head, rcu_callback_t func);
#define call_rcu call_rcu_sched
#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
+/* only for use by kfree_call_rcu() */
+void call_rcu_lazy(struct rcu_head *head, rcu_callback_t func);
+
void call_rcu_bh(struct rcu_head *head, rcu_callback_t func);
void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
void synchronize_sched(void);
@@ -838,45 +841,6 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
#define __is_kfree_rcu_offset(offset) ((offset) < 4096)
/*
- * Helper macro for kfree_rcu() to prevent argument-expansion eyestrain.
- */
-#define __kfree_rcu(head, offset) \
- do { \
- BUILD_BUG_ON(!__is_kfree_rcu_offset(offset)); \
- kfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
- } while (0)
-
-/**
- * kfree_rcu() - kfree an object after a grace period.
- * @ptr: pointer to kfree
- * @rcu_head: the name of the struct rcu_head within the type of @ptr.
- *
- * Many rcu callbacks functions just call kfree() on the base structure.
- * These functions are trivial, but their size adds up, and furthermore
- * when they are used in a kernel module, that module must invoke the
- * high-latency rcu_barrier() function at module-unload time.
- *
- * The kfree_rcu() function handles this issue. Rather than encoding a
- * function address in the embedded rcu_head structure, kfree_rcu() instead
- * encodes the offset of the rcu_head structure within the base structure.
- * Because the functions are not allowed in the low-order 4096 bytes of
- * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
- * If the offset is larger than 4095 bytes, a compile-time error will
- * be generated in __kfree_rcu(). If this error is triggered, you can
- * either fall back to use of call_rcu() or rearrange the structure to
- * position the rcu_head structure into the first 4096 bytes.
- *
- * Note that the allowable offset might decrease in the future, for example,
- * to allow something like kmem_cache_free_rcu().
- *
- * The BUILD_BUG_ON check must not involve any function calls, hence the
- * checks are done in macros here.
- */
-#define kfree_rcu(ptr, rcu_head) \
- __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
-
-
-/*
* Place this after a lock-acquisition primitive to guarantee that
* an UNLOCK+LOCK pair acts as a full barrier. This guarantee applies
* if the UNLOCK and LOCK are executed by the same CPU or if the
@@ -888,5 +852,4 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
#define smp_mb__after_unlock_lock() do { } while (0)
#endif /* #else #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
-
#endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 37d6fd3..7746b19 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -48,8 +48,6 @@ void synchronize_rcu_bh(void);
void synchronize_sched_expedited(void);
void synchronize_rcu_expedited(void);
-void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func);
-
/**
* synchronize_rcu_bh_expedited - Brute-force RCU-bh grace period
*
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 50697a1..a71f6a78 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -342,6 +342,50 @@ void *__kmalloc(size_t size, gfp_t flags) __assume_kmalloc_alignment __malloc;
void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags) __assume_slab_alignment __malloc;
void kmem_cache_free(struct kmem_cache *, void *);
+void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func);
+
+/* Helper macro for kfree_rcu() to prevent argument-expansion eyestrain. */
+#define __kfree_rcu(head, offset) \
+ do { \
+ unsigned long __o = (unsigned long)offset; \
+ BUILD_BUG_ON(!__is_kfree_rcu_offset(__o)); \
+ kfree_call_rcu(head, (rcu_callback_t)(__o)); \
+ } while (0)
+
+/**
+ * kfree_rcu() - kfree an object after a grace period.
+ * @ptr: pointer to kfree
+ * @rcu_head: the name of the struct rcu_head within the type of @ptr.
+ *
+ * Many rcu callbacks functions just call kfree() on the base structure.
+ * These functions are trivial, but their size adds up, and furthermore
+ * when they are used in a kernel module, that module must invoke the
+ * high-latency rcu_barrier() function at module-unload time.
+ *
+ * The kfree_rcu() function handles this issue. Rather than encoding a
+ * function address in the embedded rcu_head structure, kfree_rcu() instead
+ * encodes the offset of the rcu_head structure within the base structure.
+ * Because the functions are not allowed in the low-order 4096 bytes of
+ * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
+ * If the offset is larger than 4095 bytes, a compile-time error will
+ * be generated in __kfree_rcu(). If this error is triggered, you can
+ * either fall back to use of call_rcu() or rearrange the structure to
+ * position the rcu_head structure into the first 4096 bytes.
+ *
+ * Note that the allowable offset might decrease in the future, for example,
+ * to allow something like kmem_cache_free_rcu().
+ *
+ * The BUILD_BUG_ON check must not involve any function calls, hence the
+ * checks are done in macros here.
+ */
+#define kfree_rcu(ptr, rcu_head_name) \
+ do { \
+ typeof(ptr) __ptr = ptr; \
+ unsigned long __off = offsetof(typeof(*(__ptr)), \
+ rcu_head_name); \
+ struct rcu_head *__rptr = (void *)__ptr + __off; \
+ __kfree_rcu(__rptr, __off); \
+ } while (0)
/*
* Bulk allocation and freeing operations. These are accelerated in an
* allocator specific way to avoid taking locks repeatedly or building
diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
index f9c0ca2..7d2830f 100644
--- a/kernel/rcu/tree.c
+++ b/kernel/rcu/tree.c
@@ -3180,6 +3180,16 @@ void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
}
EXPORT_SYMBOL_GPL(call_rcu_sched);
+/* Queue an RCU callback for lazy invocation after a grace period.
+ * Currently there is no way of tagging the lazy RCU callbacks in the
+ * list of pending callbacks. Until then, this function may only be
+ * called from kfree_call_rcu().
+ */
+void call_rcu_lazy(struct rcu_head *head, rcu_callback_t func)
+{
+ __call_rcu(head, func, &rcu_sched_state, -1, 1);
+}
+
/**
* call_rcu_bh() - Queue an RCU for invocation after a quicker grace period.
* @head: structure to be used for queueing the RCU updates.
@@ -3209,20 +3219,6 @@ void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
EXPORT_SYMBOL_GPL(call_rcu_bh);
/*
- * Queue an RCU callback for lazy invocation after a grace period.
- * This will likely be later named something like "call_rcu_lazy()",
- * but this change will require some way of tagging the lazy RCU
- * callbacks in the list of pending callbacks. Until then, this
- * function may only be called from __kfree_rcu().
- */
-void kfree_call_rcu(struct rcu_head *head,
- rcu_callback_t func)
-{
- __call_rcu(head, func, rcu_state_p, -1, 1);
-}
-EXPORT_SYMBOL_GPL(kfree_call_rcu);
-
-/*
* Because a context switch is a grace period for RCU-sched and RCU-bh,
* any blocking grace-period wait automatically implies a grace period
* if there is only one CPU online at any point time during execution
diff --git a/mm/slab_common.c b/mm/slab_common.c
index c8cb367..0d8a63b 100644
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -1483,6 +1483,16 @@ void kzfree(const void *p)
}
EXPORT_SYMBOL(kzfree);
+/*
+ * Queue Memory to be freed by RCU after a grace period.
+ */
+void kfree_call_rcu(struct rcu_head *head,
+ rcu_callback_t func)
+{
+ call_rcu_lazy(head, func);
+}
+EXPORT_SYMBOL_GPL(kfree_call_rcu);
+
/* Tracepoints definitions. */
EXPORT_TRACEPOINT_SYMBOL(kmalloc);
EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc);
--
2.7.4
From: Rao Shoaib <[email protected]>
Signed-off-by: Rao Shoaib <[email protected]>
---
include/linux/mm.h | 5 ++
include/linux/rcutiny.h | 8 ++-
kernel/sysctl.c | 40 ++++++++++++
mm/slab.h | 23 +++++++
mm/slab_common.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++-
5 files changed, 235 insertions(+), 2 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index ea818ff..8ae4f25 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2669,5 +2669,10 @@ void __init setup_nr_node_ids(void);
static inline void setup_nr_node_ids(void) {}
#endif
+extern int sysctl_kfree_rcu_drain_limit;
+extern int sysctl_kfree_rcu_poll_limit;
+extern int sysctl_kfree_rcu_empty_limit;
+extern int sysctl_kfree_rcu_caching_allowed;
+
#endif /* __KERNEL__ */
#endif /* _LINUX_MM_H */
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index b3dbf95..af28107 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -84,10 +84,16 @@ static inline void synchronize_sched_expedited(void)
synchronize_sched();
}
+static inline void call_rcu_lazy(struct rcu_head *head,
+ rcu_callback_t func)
+{
+ call_rcu(head, func);
+}
+
static inline void kfree_call_rcu(struct rcu_head *head,
rcu_callback_t func)
{
- call_rcu(head, func);
+ call_rcu_lazy(head, func);
}
#define rcu_note_context_switch(preempt) \
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 557d467..47b48f7 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -1655,6 +1655,46 @@ static struct ctl_table vm_table[] = {
.extra2 = (void *)&mmap_rnd_compat_bits_max,
},
#endif
+ {
+ .procname = "kfree_rcu_drain_limit",
+ .data = &sysctl_kfree_rcu_drain_limit,
+ .maxlen = sizeof(sysctl_kfree_rcu_drain_limit),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &one,
+ .extra2 = &one_hundred,
+ },
+
+ {
+ .procname = "kfree_rcu_poll_limit",
+ .data = &sysctl_kfree_rcu_poll_limit,
+ .maxlen = sizeof(sysctl_kfree_rcu_poll_limit),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &one,
+ .extra2 = &one_hundred,
+ },
+
+ {
+ .procname = "kfree_rcu_empty_limit",
+ .data = &sysctl_kfree_rcu_empty_limit,
+ .maxlen = sizeof(sysctl_kfree_rcu_empty_limit),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &zero,
+ .extra2 = &four,
+ },
+
+ {
+ .procname = "kfree_rcu_caching_allowed",
+ .data = &sysctl_kfree_rcu_caching_allowed,
+ .maxlen = sizeof(sysctl_kfree_rcu_caching_allowed),
+ .mode = 0644,
+ .proc_handler = proc_dointvec_minmax,
+ .extra1 = &zero,
+ .extra2 = &one,
+ },
+
{ }
};
diff --git a/mm/slab.h b/mm/slab.h
index ad657ff..2541f70 100644
--- a/mm/slab.h
+++ b/mm/slab.h
@@ -78,6 +78,29 @@ extern const struct kmalloc_info_struct {
unsigned long size;
} kmalloc_info[];
+#define RCU_MAX_ACCUMULATE_SIZE 25
+
+struct rcu_bulk_free_container {
+ struct rcu_head rbfc_rcu;
+ int rbfc_entries;
+ void *rbfc_data[RCU_MAX_ACCUMULATE_SIZE];
+ struct rcu_bulk_free *rbfc_rbf;
+};
+
+struct rcu_bulk_free {
+ struct rcu_head rbf_rcu; /* used to schedule monitor process */
+ spinlock_t rbf_lock;
+ struct rcu_bulk_free_container *rbf_container;
+ struct rcu_bulk_free_container *rbf_cached_container;
+ struct rcu_head *rbf_list_head;
+ int rbf_list_size;
+ int rbf_cpu;
+ int rbf_empty;
+ int rbf_polled;
+ bool rbf_init;
+ bool rbf_monitor;
+};
+
unsigned long calculate_alignment(slab_flags_t flags,
unsigned long align, unsigned long size);
diff --git a/mm/slab_common.c b/mm/slab_common.c
index 0d8a63b..8987737 100644
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -20,6 +20,7 @@
#include <asm/tlbflush.h>
#include <asm/page.h>
#include <linux/memcontrol.h>
+#include <linux/types.h>
#define CREATE_TRACE_POINTS
#include <trace/events/kmem.h>
@@ -1483,13 +1484,171 @@ void kzfree(const void *p)
}
EXPORT_SYMBOL(kzfree);
+static DEFINE_PER_CPU(struct rcu_bulk_free, cpu_rbf);
+
+/* drain if atleast these many objects */
+int sysctl_kfree_rcu_drain_limit __read_mostly = 10;
+
+/* time to poll if fewer than drain_limit */
+int sysctl_kfree_rcu_poll_limit __read_mostly = 5;
+
+/* num of times to check bfr exit */
+int sysctl_kfree_rcu_empty_limit __read_mostly = 2;
+
+int sysctl_kfree_rcu_caching_allowed __read_mostly = 1;
+
+/* RCU call back function. Frees the memory */
+static void __rcu_bulk_free_impl(struct rcu_head *rbfc_rcu)
+{
+ struct rcu_bulk_free *rbf = NULL;
+ struct rcu_bulk_free_container *rbfc = container_of(rbfc_rcu,
+ struct rcu_bulk_free_container, rbfc_rcu);
+
+ kfree_bulk(rbfc->rbfc_entries, rbfc->rbfc_data);
+
+ rbf = rbfc->rbfc_rbf;
+ if (!sysctl_kfree_rcu_caching_allowed ||
+ cmpxchg(&rbf->rbf_cached_container, NULL, rbfc)) {
+ kfree(rbfc);
+ }
+}
+
+/* processes list of rcu structures
+ * used when conatiner can not be allocated
+ */
+static void __rcu_bulk_schedule_list(struct rcu_bulk_free *rbf)
+{
+ int i;
+
+ for (i = 0; i < rbf->rbf_list_size; i++) {
+ struct rcu_head *free_head;
+
+ free_head = rbf->rbf_list_head;
+ rbf->rbf_list_head = free_head->next;
+ free_head->next = NULL;
+ call_rcu(free_head, free_head->func);
+ }
+ rbf->rbf_list_size = 0;
+}
+
+/* RCU monitoring function -- submits elements for RCU reclaim */
+static void __rcu_bulk_free_monitor(struct rcu_head *rbf_rcu)
+{
+ struct rcu_bulk_free *rbf = NULL;
+ struct rcu_bulk_free_container *rbfc = NULL;
+
+ rbf = container_of(rbf_rcu, struct rcu_bulk_free, rbf_rcu);
+
+ spin_lock(&rbf->rbf_lock);
+
+ rbfc = rbf->rbf_container;
+
+ rbf->rbf_polled++;
+ if (rbf->rbf_list_size > 0) {
+ if (rbf->rbf_list_size >= sysctl_kfree_rcu_drain_limit ||
+ rbf->rbf_polled >= sysctl_kfree_rcu_poll_limit) {
+ rbf->rbf_polled = 0;
+ __rcu_bulk_schedule_list(rbf);
+ }
+ } else if (rbfc) {
+ if (rbfc->rbfc_entries >= sysctl_kfree_rcu_drain_limit ||
+ rbf->rbf_polled >= sysctl_kfree_rcu_poll_limit) {
+ rbf->rbf_polled = 0;
+ call_rcu(&rbfc->rbfc_rcu, __rcu_bulk_free_impl);
+ rbf->rbf_container = NULL;
+ }
+ } else if (rbf->rbf_polled >= sysctl_kfree_rcu_empty_limit) {
+ rbf->rbf_monitor = false;
+ rbf->rbf_polled = 0;
+ }
+
+ spin_unlock(&rbf->rbf_lock);
+
+ if (rbf->rbf_monitor)
+ call_rcu(&rbf->rbf_rcu, __rcu_bulk_free_monitor);
+}
+
+/* Main RCU function that is called to free RCU structures */
+static void __rcu_bulk_free(struct rcu_head *head, rcu_callback_t func)
+{
+ unsigned long offset;
+ void *ptr;
+ struct rcu_bulk_free *rbf;
+ struct rcu_bulk_free_container *rbfc = NULL;
+
+ rbf = this_cpu_ptr(&cpu_rbf);
+
+ if (unlikely(!rbf->rbf_init)) {
+ spin_lock_init(&rbf->rbf_lock);
+ rbf->rbf_cpu = smp_processor_id();
+ rbf->rbf_init = true;
+ }
+
+ /* hold lock to protect against other cpu's */
+ spin_lock_bh(&rbf->rbf_lock);
+
+ rbfc = rbf->rbf_container;
+
+ if (!rbfc) {
+ if (!rbf->rbf_cached_container) {
+ rbf->rbf_container =
+ kmalloc(sizeof(struct rcu_bulk_free_container),
+ GFP_ATOMIC);
+ } else {
+ rbf->rbf_container =
+ READ_ONCE(rbf->rbf_cached_container);
+ cmpxchg(&rbf->rbf_cached_container,
+ rbf->rbf_container, NULL);
+ }
+
+ if (unlikely(!rbf->rbf_container)) {
+ /* Memory allocation failed maintain a list */
+
+ head->func = (void *)func;
+ head->next = rbf->rbf_list_head;
+ rbf->rbf_list_head = head;
+ rbf->rbf_list_size++;
+ if (rbf->rbf_list_size == RCU_MAX_ACCUMULATE_SIZE)
+ __rcu_bulk_schedule_list(rbf);
+
+ goto done;
+ }
+
+ rbfc = rbf->rbf_container;
+ rbfc->rbfc_rbf = rbf;
+ rbfc->rbfc_entries = 0;
+
+ if (!rbf->rbf_list_head)
+ __rcu_bulk_schedule_list(rbf);
+ }
+
+ offset = (unsigned long)func;
+ ptr = (void *)head - offset;
+
+ rbfc->rbfc_data[rbfc->rbfc_entries++] = ptr;
+ if (rbfc->rbfc_entries == RCU_MAX_ACCUMULATE_SIZE) {
+ rbf->rbf_container = NULL;
+ spin_unlock_bh(&rbf->rbf_lock);
+ call_rcu_lazy(&rbfc->rbfc_rcu, __rcu_bulk_free_impl);
+ return;
+ }
+
+done:
+ if (!rbf->rbf_monitor) {
+ call_rcu_lazy(&rbf->rbf_rcu, __rcu_bulk_free_monitor);
+ rbf->rbf_monitor = true;
+ }
+
+ spin_unlock_bh(&rbf->rbf_lock);
+}
+
/*
* Queue Memory to be freed by RCU after a grace period.
*/
void kfree_call_rcu(struct rcu_head *head,
rcu_callback_t func)
{
- call_rcu_lazy(head, func);
+ __rcu_bulk_free(head, func);
}
EXPORT_SYMBOL_GPL(kfree_call_rcu);
--
2.7.4
On Tue, Jan 02, 2018 at 12:11:37PM -0800, [email protected] wrote:
> -#define kfree_rcu(ptr, rcu_head) \
> - __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
> +#define kfree_rcu(ptr, rcu_head_name) \
> + do { \
> + typeof(ptr) __ptr = ptr; \
> + unsigned long __off = offsetof(typeof(*(__ptr)), \
> + rcu_head_name); \
> + struct rcu_head *__rptr = (void *)__ptr + __off; \
> + __kfree_rcu(__rptr, __off); \
> + } while (0)
I feel like you're trying to help people understand the code better,
but using longer names can really work against that. Reverting to
calling the parameter 'rcu_head' lets you not split the line:
+#define kfree_rcu(ptr, rcu_head) \
+ do { \
+ typeof(ptr) __ptr = ptr; \
+ unsigned long __off = offsetof(typeof(*(__ptr)), rcu_head); \
+ struct rcu_head *__rptr = (void *)__ptr + __off; \
+ __kfree_rcu(__rptr, __off); \
+ } while (0)
Also, I don't understand why you're bothering to create __ptr here.
I understand the desire to not mention the same argument more than once,
but you have 'ptr' twice anyway.
And it's good practice to enclose macro arguments in parentheses in case
the user has done something really tricksy like pass in "p + 1".
In summary, I don't see anything fundamentally better in your rewrite
of kfree_rcu(). The previous version is more succinct, and to my
mind, easier to understand.
> +void call_rcu_lazy(struct rcu_head *head, rcu_callback_t func)
> +{
> + __call_rcu(head, func, &rcu_sched_state, -1, 1);
> +}
> -void kfree_call_rcu(struct rcu_head *head,
> - rcu_callback_t func)
> -{
> - __call_rcu(head, func, rcu_state_p, -1, 1);
> -}
You've silently changed this. Why? It might well be the right change,
but it at least merits mentioning in the changelog.
On 01/02/2018 02:23 PM, Matthew Wilcox wrote:
> On Tue, Jan 02, 2018 at 12:11:37PM -0800, [email protected] wrote:
>> -#define kfree_rcu(ptr, rcu_head) \
>> - __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
>> +#define kfree_rcu(ptr, rcu_head_name) \
>> + do { \
>> + typeof(ptr) __ptr = ptr; \
>> + unsigned long __off = offsetof(typeof(*(__ptr)), \
>> + rcu_head_name); \
>> + struct rcu_head *__rptr = (void *)__ptr + __off; \
>> + __kfree_rcu(__rptr, __off); \
>> + } while (0)
> I feel like you're trying to help people understand the code better,
> but using longer names can really work against that. Reverting to
> calling the parameter 'rcu_head' lets you not split the line:
I think it is a matter of preference, what is the issue with line
splitting ?
Coming from a background other than Linux I find it very annoying that
Linux allows variables names that are meaning less. Linux does not even
enforce adding a prefix for structure members, so trying to find out
where a member is used or set is impossible using cscope.
I can not change the Linux requirements so I will go ahead and make the
change in the next rev.
>
> +#define kfree_rcu(ptr, rcu_head) \
> + do { \
> + typeof(ptr) __ptr = ptr; \
> + unsigned long __off = offsetof(typeof(*(__ptr)), rcu_head); \
> + struct rcu_head *__rptr = (void *)__ptr + __off; \
> + __kfree_rcu(__rptr, __off); \
> + } while (0)
>
> Also, I don't understand why you're bothering to create __ptr here.
> I understand the desire to not mention the same argument more than once,
> but you have 'ptr' twice anyway.
>
> And it's good practice to enclose macro arguments in parentheses in case
> the user has done something really tricksy like pass in "p + 1".
>
> In summary, I don't see anything fundamentally better in your rewrite
> of kfree_rcu(). The previous version is more succinct, and to my
> mind, easier to understand.
I did not want to make thins change but it is required due to the new
tests added for macro expansion where the same name as in the macro can
not be used twice. It takes care of the 'p + 1' hazard that you refer to
above.
>
>> +void call_rcu_lazy(struct rcu_head *head, rcu_callback_t func)
>> +{
>> + __call_rcu(head, func, &rcu_sched_state, -1, 1);
>> +}
>> -void kfree_call_rcu(struct rcu_head *head,
>> - rcu_callback_t func)
>> -{
>> - __call_rcu(head, func, rcu_state_p, -1, 1);
>> -}
> You've silently changed this. Why? It might well be the right change,
> but it at least merits mentioning in the changelog.
This was to address a comment about me not changing the tiny
implementation to be same as the tree implementation.
Shoaib
>
> --
> To unsubscribe, send a message with 'unsubscribe linux-mm' in
> the body to [email protected]. For more info on Linux MM,
> see: http://www.linux-mm.org/ .
> Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Hi Shoaib,
Good to see you set out a patchset ;-)
On Tue, Jan 02, 2018 at 02:49:25PM -0800, Rao Shoaib wrote:
>
>
> On 01/02/2018 02:23 PM, Matthew Wilcox wrote:
> > On Tue, Jan 02, 2018 at 12:11:37PM -0800, [email protected] wrote:
> > > -#define kfree_rcu(ptr, rcu_head) \
> > > - __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
> > > +#define kfree_rcu(ptr, rcu_head_name) \
> > > + do { \
> > > + typeof(ptr) __ptr = ptr; \
> > > + unsigned long __off = offsetof(typeof(*(__ptr)), \
> > > + rcu_head_name); \
> > > + struct rcu_head *__rptr = (void *)__ptr + __off; \
> > > + __kfree_rcu(__rptr, __off); \
> > > + } while (0)
> > I feel like you're trying to help people understand the code better,
> > but using longer names can really work against that. Reverting to
> > calling the parameter 'rcu_head' lets you not split the line:
> I think it is a matter of preference, what is the issue with line splitting
> ?
> Coming from a background other than Linux I find it very annoying that Linux
> allows variables names that are meaning less. Linux does not even enforce
> adding a prefix for structure members, so trying to find out where a member
> is used or set is impossible using cscope.
> I can not change the Linux requirements so I will go ahead and make the
> change in the next rev.
>
> >
> > +#define kfree_rcu(ptr, rcu_head) \
> > + do { \
> > + typeof(ptr) __ptr = ptr; \
> > + unsigned long __off = offsetof(typeof(*(__ptr)), rcu_head); \
> > + struct rcu_head *__rptr = (void *)__ptr + __off; \
> > + __kfree_rcu(__rptr, __off); \
> > + } while (0)
> >
> > Also, I don't understand why you're bothering to create __ptr here.
> > I understand the desire to not mention the same argument more than once,
> > but you have 'ptr' twice anyway.
> >
> > And it's good practice to enclose macro arguments in parentheses in case
> > the user has done something really tricksy like pass in "p + 1".
> >
> > In summary, I don't see anything fundamentally better in your rewrite
> > of kfree_rcu(). The previous version is more succinct, and to my
> > mind, easier to understand.
> I did not want to make thins change but it is required due to the new tests
> added for macro expansion where the same name as in the macro can not be
> used twice. It takes care of the 'p + 1' hazard that you refer to above.
> >
> > > +void call_rcu_lazy(struct rcu_head *head, rcu_callback_t func)
> > > +{
> > > + __call_rcu(head, func, &rcu_sched_state, -1, 1);
> > > +}
> > > -void kfree_call_rcu(struct rcu_head *head,
> > > - rcu_callback_t func)
> > > -{
> > > - __call_rcu(head, func, rcu_state_p, -1, 1);
> > > -}
> > You've silently changed this. Why? It might well be the right change,
> > but it at least merits mentioning in the changelog.
> This was to address a comment about me not changing the tiny implementation
> to be same as the tree implementation.
>
But you introduced a bug here, you should use rcu_state_p instead of
&rcu_sched_state as the third parameter for __call_rcu().
Please re-read:
https://marc.info/?l=linux-mm&m=151390529209639
, and there are other comments, which you still haven't resolved in this
version. You may want to write a better commit log to explain the
reasons of each modifcation and fix bugs or typos in your previous
version. That's how review process works ;-)
Regards,
Boqun
> Shoaib
> >
> > --
> > To unsubscribe, send a message with 'unsubscribe linux-mm' in
> > the body to [email protected]. For more info on Linux MM,
> > see: http://www.linux-mm.org/ .
> > Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
>
> --
> To unsubscribe, send a message with 'unsubscribe linux-mm' in
> the body to [email protected]. For more info on Linux MM,
> see: http://www.linux-mm.org/ .
> Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Hi Boqun,
Thanks a lot for all your guidance and for catching the cut and paster
error. Please see inline.
On 01/03/2018 05:38 PM, Boqun Feng wrote:
>
> But you introduced a bug here, you should use rcu_state_p instead of
> &rcu_sched_state as the third parameter for __call_rcu().
>
> Please re-read:
>
> https://marc.info/?l=linux-mm&m=151390529209639
>
> , and there are other comments, which you still haven't resolved in this
> version. You may want to write a better commit log to explain the
> reasons of each modifcation and fix bugs or typos in your previous
> version. That's how review process works ;-)
>
> Regards,
> Boqun
>
This is definitely a serious error. Thanks for catching this.
As far as your previous comments are concerned, only the following one
has not been addressed. Can you please elaborate as I do not understand
the comment. The code was expanded because the new macro expansion check
fails. Based on Matthew Wilcox's comment I have reverted rcu_head_name
back to rcu_head.
> +#define kfree_rcu(ptr, rcu_head_name) \
> + do { \
> + typeof(ptr) __ptr = ptr; \
> + unsigned long __off = offsetof(typeof(*(__ptr)), \
> + rcu_head_name); \
> + struct rcu_head *__rptr = (void *)__ptr + __off; \
> + __kfree_rcu(__rptr, __off); \
> + } while (0)
why do you want to open code this?
Does the following text for the commit log looks better.
kfree_rcu() should use the new kfree_bulk() interface for freeing rcu
structures
The newly implemented kfree_bulk() interfaces are more efficient, using
the interfaces for freeing rcu structures has shown performance
improvements in synthetic benchmarks that allocate and free rcu
structures at a high rate.
Shoaib
On 01/04/2018 12:35 PM, Rao Shoaib wrote:
> Hi Boqun,
>
> Thanks a lot for all your guidance and for catching the cut and paster
> error. Please see inline.
>
>
> On 01/03/2018 05:38 PM, Boqun Feng wrote:
>>
>> But you introduced a bug here, you should use rcu_state_p instead of
>> &rcu_sched_state as the third parameter for __call_rcu().
>>
>> Please re-read:
>>
>> ????https://marc.info/?l=linux-mm&m=151390529209639
>>
>> , and there are other comments, which you still haven't resolved in this
>> version. You may want to write a better commit log to explain the
>> reasons of each modifcation and fix bugs or typos in your previous
>> version. That's how review process works ;-)
>>
>> Regards,
>> Boqun
>>
> This is definitely a serious error. Thanks for catching this.
>
> As far as your previous comments are concerned, only the following one
> has not been addressed. Can you please elaborate as I do not
> understand the comment. The code was expanded because the new macro
> expansion check fails. Based on Matthew Wilcox's comment I have
> reverted rcu_head_name back to rcu_head.
It turns out I did not remember the real reason for the change. With the
macro rewritten, using rcu_head as a macro argument does not work
because it conflicts with the name of the type 'struct rcu_head' used in
the macro. I have renamed the macro argument to rcu_name.
Shoaib
>
>> +#define kfree_rcu(ptr, rcu_head_name) \
>> +??? do { \
>> +??????? typeof(ptr) __ptr = ptr;??? \
>> +??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
>> +????????????????????????????? rcu_head_name); \
>> +??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
>> +??????? __kfree_rcu(__rptr, __off); \
>> +??? } while (0)
>
> why do you want to open code this?
>
> Does the following text for the commit log looks better.
>
> kfree_rcu() should use the new kfree_bulk() interface for freeing rcu
> structures
>
> The newly implemented kfree_bulk() interfaces are more efficient,
> using the interfaces for freeing rcu structures has shown performance
> improvements in synthetic benchmarks that allocate and free rcu
> structures at a high rate.
>
> Shoaib
>
> --
> To unsubscribe, send a message with 'unsubscribe linux-mm' in
> the body to [email protected].? For more info on Linux MM,
> see: http://www.linux-mm.org/ .
> Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
On Thu, Jan 04, 2018 at 01:27:49PM -0800, Rao Shoaib wrote:
> On 01/04/2018 12:35 PM, Rao Shoaib wrote:
> > As far as your previous comments are concerned, only the following one
> > has not been addressed. Can you please elaborate as I do not understand
> > the comment. The code was expanded because the new macro expansion check
> > fails. Based on Matthew Wilcox's comment I have reverted rcu_head_name
> > back to rcu_head.
> It turns out I did not remember the real reason for the change. With the
> macro rewritten, using rcu_head as a macro argument does not work because it
> conflicts with the name of the type 'struct rcu_head' used in the macro. I
> have renamed the macro argument to rcu_name.
>
> Shoaib
> >
> > > +#define kfree_rcu(ptr, rcu_head_name) \
> > > +??? do { \
> > > +??????? typeof(ptr) __ptr = ptr;??? \
> > > +??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
> > > +????????????????????????????? rcu_head_name); \
> > > +??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
> > > +??????? __kfree_rcu(__rptr, __off); \
> > > +??? } while (0)
> >
> > why do you want to open code this?
But why are you changing this macro at all? If it was to avoid the
double-mention of "ptr", then you haven't done that.
On 01/04/2018 01:46 PM, Matthew Wilcox wrote:
> On Thu, Jan 04, 2018 at 01:27:49PM -0800, Rao Shoaib wrote:
>> On 01/04/2018 12:35 PM, Rao Shoaib wrote:
>>> As far as your previous comments are concerned, only the following one
>>> has not been addressed. Can you please elaborate as I do not understand
>>> the comment. The code was expanded because the new macro expansion check
>>> fails. Based on Matthew Wilcox's comment I have reverted rcu_head_name
>>> back to rcu_head.
>> It turns out I did not remember the real reason for the change. With the
>> macro rewritten, using rcu_head as a macro argument does not work because it
>> conflicts with the name of the type 'struct rcu_head' used in the macro. I
>> have renamed the macro argument to rcu_name.
>>
>> Shoaib
>>>> +#define kfree_rcu(ptr, rcu_head_name) \
>>>> + do { \
>>>> + typeof(ptr) __ptr = ptr; \
>>>> + unsigned long __off = offsetof(typeof(*(__ptr)), \
>>>> + rcu_head_name); \
>>>> + struct rcu_head *__rptr = (void *)__ptr + __off; \
>>>> + __kfree_rcu(__rptr, __off); \
>>>> + } while (0)
>>> why do you want to open code this?
> But why are you changing this macro at all? If it was to avoid the
> double-mention of "ptr", then you haven't done that.
I have -- I do not get the error because ptr is being assigned only one.
If you have a better way than let me know and I will be happy to make
the change.
Shoaib.
On Thu, Jan 04, 2018 at 02:18:50PM -0800, Rao Shoaib wrote:
> > > > > +#define kfree_rcu(ptr, rcu_head_name) \
> > > > > +??? do { \
> > > > > +??????? typeof(ptr) __ptr = ptr;??? \
> > > > > +??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
> > > > > +????????????????????????????? rcu_head_name); \
> > > > > +??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
> > > > > +??????? __kfree_rcu(__rptr, __off); \
> > > > > +??? } while (0)
> > > > why do you want to open code this?
> > But why are you changing this macro at all? If it was to avoid the
> > double-mention of "ptr", then you haven't done that.
> I have -- I do not get the error because ptr is being assigned only one. If
> you have a better way than let me know and I will be happy to make the
> change.
But look at the original:
#define kfree_rcu(ptr, rcu_head) \
__kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
^^^ ^^^
versus your version:
+#define kfree_rcu(ptr, rcu_head_name) \
+??? do { \
+??????? typeof(ptr) __ptr = ptr;??? \
^^^ ^^^
+??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
+????????????????????????????? rcu_head_name); \
+??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
+??????? __kfree_rcu(__rptr, __off); \
+??? } while (0)
I don't see the difference.
On Thu, Jan 04, 2018 at 03:13:07PM -0800, Matthew Wilcox wrote:
> On Thu, Jan 04, 2018 at 02:18:50PM -0800, Rao Shoaib wrote:
> > > > > > +#define kfree_rcu(ptr, rcu_head_name) \
> > > > > > +??? do { \
> > > > > > +??????? typeof(ptr) __ptr = ptr;??? \
> > > > > > +??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
> > > > > > +????????????????????????????? rcu_head_name); \
> > > > > > +??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
> > > > > > +??????? __kfree_rcu(__rptr, __off); \
> > > > > > +??? } while (0)
> > > > > why do you want to open code this?
> > > But why are you changing this macro at all? If it was to avoid the
> > > double-mention of "ptr", then you haven't done that.
> > I have -- I do not get the error because ptr is being assigned only one. If
> > you have a better way than let me know and I will be happy to make the
> > change.
>
> But look at the original:
>
> #define kfree_rcu(ptr, rcu_head) \
> __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
> ^^^ ^^^
>
> versus your version:
>
> +#define kfree_rcu(ptr, rcu_head_name) \
> +??? do { \
> +??????? typeof(ptr) __ptr = ptr;??? \
> ^^^ ^^^
> +??????? unsigned long __off = offsetof(typeof(*(__ptr)), \
> +????????????????????????????? rcu_head_name); \
> +??????? struct rcu_head *__rptr = (void *)__ptr + __off; \
> +??????? __kfree_rcu(__rptr, __off); \
> +??? } while (0)
>
> I don't see the difference.
I was under the impression that typeof did not actually evaluate its
argument, but rather only returned its type. And there are a few macros
with this pattern in mainline.
Or am I confused about what typeof does?
Thanx, Paul
On Thu, Jan 04, 2018 at 03:47:32PM -0800, Paul E. McKenney wrote:
> I was under the impression that typeof did not actually evaluate its
> argument, but rather only returned its type. And there are a few macros
> with this pattern in mainline.
>
> Or am I confused about what typeof does?
I think checkpatch is confused by the '*' in the typeof argument:
$ git diff |./scripts/checkpatch.pl --strict
CHECK: Macro argument reuse 'ptr' - possible side-effects?
#29: FILE: include/linux/rcupdate.h:896:
+#define kfree_rcu(ptr, rcu_head) \
+ __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
If one removes the '*', the warning goes away.
I'm no perlista, but Joe, would this regexp modification make sense?
+++ b/scripts/checkpatch.pl
@@ -4957,7 +4957,7 @@ sub process {
next if ($arg =~ /\.\.\./);
next if ($arg =~ /^type$/i);
my $tmp_stmt = $define_stmt;
- $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
+ $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\**\(*\s*$arg\s*\)*\b//g;
$tmp_stmt =~ s/\#+\s*$arg\b//g;
$tmp_stmt =~ s/\b$arg\s*\#\#//g;
my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
On 01/04/2018 04:07 PM, Matthew Wilcox wrote:
> On Thu, Jan 04, 2018 at 03:47:32PM -0800, Paul E. McKenney wrote:
>> I was under the impression that typeof did not actually evaluate its
>> argument, but rather only returned its type. And there are a few macros
>> with this pattern in mainline.
>>
>> Or am I confused about what typeof does?
> I think checkpatch is confused by the '*' in the typeof argument:
Yup.
>
> $ git diff |./scripts/checkpatch.pl --strict
> CHECK: Macro argument reuse 'ptr' - possible side-effects?
> #29: FILE: include/linux/rcupdate.h:896:
> +#define kfree_rcu(ptr, rcu_head) \
> + __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
>
> If one removes the '*', the warning goes away.
>
> I'm no perlista, but Joe, would this regexp modification make sense?
>
> +++ b/scripts/checkpatch.pl
> @@ -4957,7 +4957,7 @@ sub process {
> next if ($arg =~ /\.\.\./);
> next if ($arg =~ /^type$/i);
> my $tmp_stmt = $define_stmt;
> - $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
> + $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\**\(*\s*$arg\s*\)*\b//g;
> $tmp_stmt =~ s/\#+\s*$arg\b//g;
> $tmp_stmt =~ s/\b$arg\s*\#\#//g;
> my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
>
Thanks a lot for digging into this. I had to try several variations for
the warning to go away and don't remember the reason for each change. I
am not perl literate and the regular expression sacred me ;-).
Shoaib
On Thu, 2018-01-04 at 16:07 -0800, Matthew Wilcox wrote:
> On Thu, Jan 04, 2018 at 03:47:32PM -0800, Paul E. McKenney wrote:
> > I was under the impression that typeof did not actually evaluate its
> > argument, but rather only returned its type. And there are a few macros
> > with this pattern in mainline.
> >
> > Or am I confused about what typeof does?
>
> I think checkpatch is confused by the '*' in the typeof argument:
>
> $ git diff |./scripts/checkpatch.pl --strict
> CHECK: Macro argument reuse 'ptr' - possible side-effects?
> #29: FILE: include/linux/rcupdate.h:896:
> +#define kfree_rcu(ptr, rcu_head) \
> + __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
>
> If one removes the '*', the warning goes away.
>
> I'm no perlista, but Joe, would this regexp modification make sense?
>
> +++ b/scripts/checkpatch.pl
> @@ -4957,7 +4957,7 @@ sub process {
> next if ($arg =~ /\.\.\./);
> next if ($arg =~ /^type$/i);
> my $tmp_stmt = $define_stmt;
> - $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
> + $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\**\(*\s*$arg\s*\)*\b//g;
I supposed ideally it'd be more like
$tmp_stmt =~ s/\b(?:typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*(?:\s*\*\s*)*\s*\(*\s*$arg\s*\)*\b//g;
Adding ?: at the start to not capture and
(?:\s*\*\s*)* for any number of * with any
surrounding spacings.
Folks,
Is anyone working on resolving the check patch issue as I am waiting to
resubmit my patch. Will it be fine if I submitted the patch with the
original macro as the check is in-correct.
I do not speak perl but I can do the process work. If folks think Joe's
fix is fine I can submit it and perhaps someone can review it ?
Regards,
Shoaib
On 01/04/2018 10:46 PM, Joe Perches wrote:
> On Thu, 2018-01-04 at 16:07 -0800, Matthew Wilcox wrote:
>> On Thu, Jan 04, 2018 at 03:47:32PM -0800, Paul E. McKenney wrote:
>>> I was under the impression that typeof did not actually evaluate its
>>> argument, but rather only returned its type. And there are a few macros
>>> with this pattern in mainline.
>>>
>>> Or am I confused about what typeof does?
>> I think checkpatch is confused by the '*' in the typeof argument:
>>
>> $ git diff |./scripts/checkpatch.pl --strict
>> CHECK: Macro argument reuse 'ptr' - possible side-effects?
>> #29: FILE: include/linux/rcupdate.h:896:
>> +#define kfree_rcu(ptr, rcu_head) \
>> + __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
>>
>> If one removes the '*', the warning goes away.
>>
>> I'm no perlista, but Joe, would this regexp modification make sense?
>>
>> +++ b/scripts/checkpatch.pl
>> @@ -4957,7 +4957,7 @@ sub process {
>> next if ($arg =~ /\.\.\./);
>> next if ($arg =~ /^type$/i);
>> my $tmp_stmt = $define_stmt;
>> - $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
>> + $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\**\(*\s*$arg\s*\)*\b//g;
> I supposed ideally it'd be more like
>
> $tmp_stmt =~ s/\b(?:typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*(?:\s*\*\s*)*\s*\(*\s*$arg\s*\)*\b//g;
>
> Adding ?: at the start to not capture and
> (?:\s*\*\s*)* for any number of * with any
> surrounding spacings.
On Mon, 2018-03-26 at 18:56 -0700, Rao Shoaib wrote:
> Folks,
>
> Is anyone working on resolving the check patch issue as I am waiting to
> resubmit my patch. Will it be fine if I submitted the patch with the
> original macro as the check is in-correct.
Yes. Of course. Anytime a person knows better,
checkpatch output should be ignored.
> I do not speak perl but I can do the process work. If folks think Joe's
> fix is fine I can submit it and perhaps someone can review it ?
I think it's fine too ;)
Submit away...