lib: introduce call_once()

This patch defers mounting tmpfs till shmem_file_setup() is called first time by using call_once().

Quoted 2 lines

This patch defers mounting tmpfs till shmem_file_setup() is called first time by using call_once().

Please explain why we might need this patch: is something changing
elsewhere? Or are you misled by that "module_init(init_tmpfs)" into thinking that mm/shmem.c is sometimes built modular?

2008/3/11, Hugh Dickins <[email protected]>:

Quoted 7 lines · Akinobu Mita

Quoted 2 lines

This patch defers mounting tmpfs till shmem_file_setup() is called first time by using call_once().

Please explain why we might need this patch: is something changing
elsewhere? Or are you misled by that "module_init(init_tmpfs)" into thinking that mm/shmem.c is sometimes built modular?

If no processes call shmem_file_setup() (via shm_get(2)), it is unnecessary

to do vfs_kern_mount(&tmpfs_fs_type, ...) unconditionary in boot-time. So I thought it is suitable example to demonstrate how to use "call_once()" in this patch set.

include/linux/once.h line 9

Quoted 5 lines

+++ 2.6-rc/include/linux/once.h

include/linux/once.h new file +3 -0

+struct once_control {
+     struct mutex lock;
+     int done;

bool?

include/linux/once.h line 17

Quoted 8 lines

include/linux/once.h new file +8 -0

+};
+
+#define __ONCE_INITIALIZER(name) {                                   \
+             .lock           = __MUTEX_INITIALIZER(name.lock),       \
+             .done           = 0,                                    \
+     }
+
+#define DEFINE_ONCE(name) struct once_control name = __ONCE_INITIALIZER(name)

static?

include/linux/once.h line 20

Quoted 3 lines

include/linux/once.h new file +3 -0

+
+extern int call_once_slow(struct once_control *once_control,
+                       int (*init_rouine)(void));

return bool?

spelling: s/rouine/routine/g

call_once() is an utility function which has similar functionality of pthread_once().

include/linux/once.h new file +9 -0

+/*
+ * call_once - call the initialization function only once
+ *
+ * @once_control: guarantee that the init_routine will be called only once
+ * @init_routine: initialization function
+ *
+ * The first call to call_once(), with a given once_control, shall call the
+ * init_routine with no arguments and return the value init_routine returned.
+ * If the init_routine returns zero which indicates the initialization

On Mon, 10 Mar 2008 23:57:05 +0900 Akinobu Mita <[email protected]>

Quoted 15 lines

call_once() is an utility function which has similar functionality of pthread_once().

+/*
+ * call_once - call the initialization function only once
+ *
+ * @once_control: guarantee that the init_routine will be called only once + * @init_routine: initialization function
+ *
+ * The first call to call_once(), with a given once_control, shall call the + * init_routine with no arguments and return the value init_routine returned. + * If the init_routine returns zero which indicates the initialization + * succeeded, subsequent calls of call_once() with the same once_control shall + * not call the init_routine and return zero.
+ */

include/linux/once.h line 40

Quoted 7 lines

include/linux/once.h new file +7 -0

+
+static inline int call_once(struct once_control *once_control,
+			    int (*init_rouine)(void))
+{
+	return likely(once_control->done) ? 0
+			: call_once_slow(once_control, init_rouine);
+}

I don't believe that this shold be described in terms of an "init_routine". This mechanism can be used for things other than initialisation routines.

It is spelled "routine", not "rouine".

Would it not be simpler and more general to do:

#define ONCE()						\
	({						\
		static long flag;			\
							\
		return !test_and_set_bit(0, flag);	\
	})

and then callers can do

	if (ONCE())
		do_something();

?

Quoted 1 line · Andrew Morton

On Mon, 10 Mar 2008 23:57:05 +0900 Akinobu Mita <[email protected]>

Quoted 40 lines · wrote:

Quoted 15 lines

call_once() is an utility function which has similar functionality of pthread_once().

+/*
+ * call_once - call the initialization function only once
+ *
+ * @once_control: guarantee that the init_routine will be called only once + * @init_routine: initialization function
+ *
+ * The first call to call_once(), with a given once_control, shall call the + * init_routine with no arguments and return the value init_routine returned. + * If the init_routine returns zero which indicates the initialization + * succeeded, subsequent calls of call_once() with the same once_control shall + * not call the init_routine and return zero.
+ */

include/linux/once.h line 40

Quoted 7 lines

include/linux/once.h new file +7 -0

+
+static inline int call_once(struct once_control *once_control,
+			    int (*init_rouine)(void))
+{
+	return likely(once_control->done) ? 0
+			: call_once_slow(once_control, init_rouine);
+}

I don't believe that this shold be described in terms of an "init_routine". This mechanism can be used for things other than initialisation routines.

It is spelled "routine", not "rouine".

Would it not be simpler and more general to do:

#define ONCE()						\
	({						\
		static long flag;			\
							\
		return !test_and_set_bit(0, flag);	\
	})

and then callers can do

Quoted 4 lines

	if (ONCE())
		do_something();

?

Isn't this usually going to be buggy if you have concurrent access here? I'd prefer to keep synchronisation details in the caller and not have this call_once at all.

Quoted 42 lines · Andrew Morton

Quoted 1 line

On Mon, 10 Mar 2008 23:57:05 +0900 Akinobu Mita <[email protected]>

Quoted 38 lines · wrote:

Quoted 15 lines

call_once() is an utility function which has similar functionality of pthread_once().

+/*
+ * call_once - call the initialization function only once
+ *
+ * @once_control: guarantee that the init_routine will be called only once + * @init_routine: initialization function
+ *
+ * The first call to call_once(), with a given once_control, shall call the + * init_routine with no arguments and return the value init_routine returned. + * If the init_routine returns zero which indicates the initialization + * succeeded, subsequent calls of call_once() with the same once_control shall + * not call the init_routine and return zero.
+ */

include/linux/once.h line 40

Quoted 7 lines

include/linux/once.h new file +7 -0

+
+static inline int call_once(struct once_control *once_control,
+                     int (*init_rouine)(void))
+{
+ return likely(once_control->done) ? 0
+                 : call_once_slow(once_control, init_rouine);
+}

I don't believe that this shold be described in terms of an "init_routine". This mechanism can be used for things other than initialisation routines.

It is spelled "routine", not "rouine".

Would it not be simpler and more general to do:

#define ONCE()                                              \
    ({                                              \
            static long flag;                       \
                                                    \
            return !test_and_set_bit(0, flag);      \
    })

Quoted 6 lines

Quoted 6 lines

and then callers can do

    if (ONCE())
            do_something();

?

Quoted 3 lines

Isn't this usually going to be buggy if you have concurrent access here? I'd prefer to keep synchronisation details in the caller and not have this call_once at all.

Well, I'm a bit dubious about the calue of all of this (althoug I didn't
review the callers).

2008/3/11, Andrew Morton <[email protected]>:

Quoted 11 lines · On Tue, 11 Mar 2008 15:10:52 +1100 Nick Piggin <[email protected]> wrote:

Quoted 10 lines

Quoted 10 lines

#define ONCE()                                              \
    ({                                              \
            static long flag;                       \
                                                    \
            return !test_and_set_bit(0, flag);      \
    })

and then callers can do

Quoted 4 lines

Quoted 4 lines

Quoted 4 lines

    if (ONCE())
            do_something();

?

This cannot be used directly in the conversions of patch 2 - 5. Because the callers of call_once() in patch 2 - 5 need to wait for the complition of "init_routine". Some blocking mechanism is needed.

#define ONCE()                                              \
    ({                                              \
            static long flag;                       \
                                                    \
            return !test_and_set_bit(0, flag);      \
    })

Quoted 6 lines · Andrew Morton

#define ONCE()                                              \
    ({                                              \
            static long flag;                       \
                                                    \
            return !test_and_set_bit(0, flag);      \
    })

test_and_set_bit takes an address

Perhaps:

#define DO_ONCE(x) \
	({ static long flag; if (test_and_set_bit(0, &flag)) x; 1; })

DO_ONCE(foo);

Of course it can be used in those places. Here's the idr.c conversion:

lib/idr.c renamed from lib/idr.c~a +0 -8

@@ -585,14 +585,6 @@ static void idr_cache_ctor(struct kmem_c
 	memset(idr_layer, 0, sizeof(struct idr_layer));
 }
 
-static  int init_id_cache(void)
-{
-	if (!idr_layer_cache)
-		idr_layer_cache = kmem_cache_create("idr_layer_cache",
-			sizeof(struct idr_layer), 0, 0, idr_cache_ctor);
-	return 0;
-}
-
 /**
  * idr_init - initialize idr handle
  * @idp:	idr handle

include/linux/once.h new file +8 -0

+static inline int call_once(struct once_control *once_control,
+			    int (*init_rouine)(void))
+{
+	return likely(once_control->done) ? 0
+			: call_once_slow(once_control, init_rouine);
+}
+
+#endif /* __LINUX_ONCE_H */

Index: 2.6-rc/lib/once.c
===================================================================

lib/once.c new file +4 -0

@@ -0,0 +1,18 @@
+#include <linux/module.h>
+#include <linux/once.h>
+
+int call_once_slow(struct once_control *once_control, int

(*init_rouine)(void)) +{

lib/once.c new file +3 -0

+	int err = 0;
+
+	mutex_lock(&once_control->lock);