Removing the completion from klist_node reduces its size from 64 bytes
to 28 on x86-64. To maintain the semantics of klist_remove(), we add
a single list of klist nodes which are pending deletion and scan them.
Signed-off-by: Matthew Wilcox <[email protected]>
include/linux/klist.h | 2 --
lib/klist.c | 48 ++++++++++++++++++++++++++++++++++++++++++++----
2 files changed, 44 insertions(+), 6 deletions(-)
diff --git a/include/linux/klist.h b/include/linux/klist.h
index 06c338e..989a335 100644
--- a/include/linux/klist.h
+++ b/include/linux/klist.h
@@ -13,7 +13,6 @@
#define _LINUX_KLIST_H
#include <linux/spinlock.h>
-#include <linux/completion.h>
#include <linux/kref.h>
#include <linux/list.h>
@@ -41,7 +40,6 @@ struct klist_node {
struct klist *n_klist;
struct list_head n_node;
struct kref n_ref;
- struct completion n_removed;
};
extern void klist_add_tail(struct klist_node *n, struct klist *k);
diff --git a/lib/klist.c b/lib/klist.c
index cca37f9..2b609ee 100644
--- a/lib/klist.c
+++ b/lib/klist.c
@@ -36,7 +36,7 @@
#include <linux/klist.h>
#include <linux/module.h>
-
+#include <linux/sched.h>
/**
* klist_init - Initialize a klist structure.
@@ -77,7 +77,6 @@ static void add_tail(struct klist *k, struct klist_node *n)
static void klist_node_init(struct klist *k, struct klist_node *n)
{
INIT_LIST_HEAD(&n->n_node);
- init_completion(&n->n_removed);
kref_init(&n->n_ref);
n->n_klist = k;
if (k->get)
@@ -140,12 +139,36 @@ void klist_add_before(struct klist_node *n, struct klist_node *pos)
}
EXPORT_SYMBOL_GPL(klist_add_before);
+struct klist_waiter {
+ struct klist_waiter *next;
+ struct klist_node *node;
+ struct task_struct *process;
+ int woken;
+};
+
+static DEFINE_SPINLOCK(klist_remove_lock);
+static struct klist_waiter *klist_remove_waiters;
+
static void klist_release(struct kref *kref)
{
+ struct klist_waiter **pprev, *this;
struct klist_node *n = container_of(kref, struct klist_node, n_ref);
list_del(&n->n_node);
- complete(&n->n_removed);
+ spin_lock(&klist_remove_lock);
+ pprev = &klist_remove_waiters;
+ while ((this = *pprev)) {
+ if (this->node != n) {
+ pprev = &this->next;
+ continue;
+ }
+
+ this->woken = 1;
+ mb();
+ wake_up_process(this->process);
+ *pprev = this->next;
+ }
+ spin_unlock(&klist_remove_lock);
n->n_klist = NULL;
}
@@ -178,8 +201,25 @@ EXPORT_SYMBOL_GPL(klist_del);
*/
void klist_remove(struct klist_node *n)
{
+ struct klist_waiter waiter;
+
+ waiter.node = n;
+ waiter.process = current;
+ waiter.woken = 0;
+ spin_lock(&klist_remove_lock);
+ waiter.next = klist_remove_waiters;
+ klist_remove_waiters = &waiter;
+ spin_unlock(&klist_remove_lock);
+
klist_del(n);
- wait_for_completion(&n->n_removed);
+
+ for (;;) {
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ if (waiter.woken)
+ break;
+ schedule();
+ }
+ __set_current_state(TASK_RUNNING);
}
EXPORT_SYMBOL_GPL(klist_remove);
--
Matthew Wilcox Intel Open Source Technology Centre
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours. We can't possibly take such
a retrograde step."
On Thu, Oct 02, 2008 at 03:43:08PM -0600, Matthew Wilcox wrote:
>
> Removing the completion from klist_node reduces its size from 64 bytes
> to 28 on x86-64. To maintain the semantics of klist_remove(), we add
> a single list of klist nodes which are pending deletion and scan them.
>
> Signed-off-by: Matthew Wilcox <[email protected]>
>
> include/linux/klist.h | 2 --
> lib/klist.c | 48 ++++++++++++++++++++++++++++++++++++++++++++----
> 2 files changed, 44 insertions(+), 6 deletions(-)
>
> diff --git a/include/linux/klist.h b/include/linux/klist.h
> index 06c338e..989a335 100644
> --- a/include/linux/klist.h
> +++ b/include/linux/klist.h
> @@ -13,7 +13,6 @@
> #define _LINUX_KLIST_H
>
> #include <linux/spinlock.h>
> -#include <linux/completion.h>
> #include <linux/kref.h>
> #include <linux/list.h>
>
> @@ -41,7 +40,6 @@ struct klist_node {
> struct klist *n_klist;
> struct list_head n_node;
> struct kref n_ref;
> - struct completion n_removed;
> };
>
> extern void klist_add_tail(struct klist_node *n, struct klist *k);
> diff --git a/lib/klist.c b/lib/klist.c
> index cca37f9..2b609ee 100644
> --- a/lib/klist.c
> +++ b/lib/klist.c
> @@ -36,7 +36,7 @@
>
> #include <linux/klist.h>
> #include <linux/module.h>
> -
> +#include <linux/sched.h>
>
> /**
> * klist_init - Initialize a klist structure.
> @@ -77,7 +77,6 @@ static void add_tail(struct klist *k, struct klist_node *n)
> static void klist_node_init(struct klist *k, struct klist_node *n)
> {
> INIT_LIST_HEAD(&n->n_node);
> - init_completion(&n->n_removed);
> kref_init(&n->n_ref);
> n->n_klist = k;
> if (k->get)
> @@ -140,12 +139,36 @@ void klist_add_before(struct klist_node *n, struct klist_node *pos)
> }
> EXPORT_SYMBOL_GPL(klist_add_before);
>
> +struct klist_waiter {
> + struct klist_waiter *next;
> + struct klist_node *node;
> + struct task_struct *process;
> + int woken;
> +};
Why not use the built-in list.h functions here?
Other than that, looks good, thanks.
greg k-h
On Thu, Oct 02, 2008 at 03:17:45PM -0700, Greg KH wrote:
> > +struct klist_waiter {
> > + struct klist_waiter *next;
> > + struct klist_node *node;
> > + struct task_struct *process;
> > + int woken;
> > +};
>
> Why not use the built-in list.h functions here?
I'm somewhat averse to using data structures when they do more than I
need them to. list_heads are great for when you need to remove an entry
from the middle of a list, but there are no advantages to using a
doubly-linked list here -- we always walk it from the start to the end,
and a singly linked list is fine for this purpose. Maybe we need a set
of 'slist' macros so we can use singly-linked-lists without thinking
terribly hard, but I'd hate to see this patch get stuck behind
infrastructure improvements.
--
Matthew Wilcox Intel Open Source Technology Centre
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours. We can't possibly take such
a retrograde step."
On Fri, Oct 03, 2008 at 08:06:19AM -0600, Matthew Wilcox wrote:
> On Thu, Oct 02, 2008 at 03:17:45PM -0700, Greg KH wrote:
> > > +struct klist_waiter {
> > > + struct klist_waiter *next;
> > > + struct klist_node *node;
> > > + struct task_struct *process;
> > > + int woken;
> > > +};
> >
> > Why not use the built-in list.h functions here?
>
> I'm somewhat averse to using data structures when they do more than I
> need them to.
But part of the point is that if you use them, no one has to audit your
logic to make sure you got it all correct.
> list_heads are great for when you need to remove an entry
> from the middle of a list, but there are no advantages to using a
> doubly-linked list here -- we always walk it from the start to the end,
> and a singly linked list is fine for this purpose. Maybe we need a set
> of 'slist' macros so we can use singly-linked-lists without thinking
> terribly hard, but I'd hate to see this patch get stuck behind
> infrastructure improvements.
Is size an issue here? I don't think so and I'd prefer it to be changed
to use the standard list implementation and not roll your own. You
never know who will cut-and-paste you code these days :)
Care to respin this?
thanks,
greg k-h
On Fri, Oct 03, 2008 at 01:41:24PM -0700, Greg KH wrote:
> Care to respin this?
Done:
--------
Removing the completion from klist_node reduces its size from 64 bytes
to 28 on x86-64. To maintain the semantics of klist_remove(), we add
a single list of klist nodes which are pending deletion and scan them.
Signed-off-by: Matthew Wilcox <[email protected]>
diff --git a/include/linux/klist.h b/include/linux/klist.h
index 06c338e..989a335 100644
--- a/include/linux/klist.h
+++ b/include/linux/klist.h
@@ -13,7 +13,6 @@
#define _LINUX_KLIST_H
#include <linux/spinlock.h>
-#include <linux/completion.h>
#include <linux/kref.h>
#include <linux/list.h>
@@ -41,7 +40,6 @@ struct klist_node {
struct klist *n_klist;
struct list_head n_node;
struct kref n_ref;
- struct completion n_removed;
};
extern void klist_add_tail(struct klist_node *n, struct klist *k);
diff --git a/lib/klist.c b/lib/klist.c
index cca37f9..50a6b30 100644
--- a/lib/klist.c
+++ b/lib/klist.c
@@ -36,7 +36,7 @@
#include <linux/klist.h>
#include <linux/module.h>
-
+#include <linux/sched.h>
/**
* klist_init - Initialize a klist structure.
@@ -77,7 +77,6 @@ static void add_tail(struct klist *k, struct klist_node *n)
static void klist_node_init(struct klist *k, struct klist_node *n)
{
INIT_LIST_HEAD(&n->n_node);
- init_completion(&n->n_removed);
kref_init(&n->n_ref);
n->n_klist = k;
if (k->get)
@@ -140,12 +139,33 @@ void klist_add_before(struct klist_node *n, struct klist_node *pos)
}
EXPORT_SYMBOL_GPL(klist_add_before);
+struct klist_waiter {
+ struct list_head list;
+ struct klist_node *node;
+ struct task_struct *process;
+ int woken;
+};
+
+static DEFINE_SPINLOCK(klist_remove_lock);
+static LIST_HEAD(klist_remove_waiters);
+
static void klist_release(struct kref *kref)
{
+ struct klist_waiter *waiter, *tmp;
struct klist_node *n = container_of(kref, struct klist_node, n_ref);
list_del(&n->n_node);
- complete(&n->n_removed);
+ spin_lock(&klist_remove_lock);
+ list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {
+ if (waiter->node != n)
+ continue;
+
+ waiter->woken = 1;
+ mb();
+ wake_up_process(waiter->process);
+ list_del(&waiter->list);
+ }
+ spin_unlock(&klist_remove_lock);
n->n_klist = NULL;
}
@@ -178,8 +198,24 @@ EXPORT_SYMBOL_GPL(klist_del);
*/
void klist_remove(struct klist_node *n)
{
+ struct klist_waiter waiter;
+
+ waiter.node = n;
+ waiter.process = current;
+ waiter.woken = 0;
+ spin_lock(&klist_remove_lock);
+ list_add(&waiter.list, &klist_remove_waiters);
+ spin_unlock(&klist_remove_lock);
+
klist_del(n);
- wait_for_completion(&n->n_removed);
+
+ for (;;) {
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ if (waiter.woken)
+ break;
+ schedule();
+ }
+ __set_current_state(TASK_RUNNING);
}
EXPORT_SYMBOL_GPL(klist_remove);
--
Matthew Wilcox Intel Open Source Technology Centre
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours. We can't possibly take such
a retrograde step."