Re: Using list_for_each_entry() in place of list_for_each_entry_rcu() ?

["Paul E. McKenney" <paulmck@linux.vnet.ibm.com>]

On Tue, Nov 04, 2014 at 08:18:03PM +0900, Tetsuo Handa wrote:
> Paul E. McKenney wrote:
> > But if you only ever add it to the list that one time, then the
> > list_for_each_entry_rcu() could become list_for_each_entry(), and
> > rcu_read_lock() and rcu_read_unlock() are not needed.  Again, this
> > assumes that the memory is never reused after being removed from the list.
> 
> That is what I wanted to confirm. v1, v2, v3 are added to the list only
> once, and mymodule.ko containing v1, v2, v3 are not unload-able.

Good enough, then.  ;-)

> > Note that in this case module unload followed by module reload is tricky.
> > You have to "wait long enough" between unload and load.  Or you need an
> > orderly teardown of some sort.
> 
> Yes, I'm aware of that.
> 
> > > Assumptions are:
> > > 
> > >   (1) v1, v2, v3 are statically allocated variables inside module,
> > >       while my_lock, my_list, add_entry(), del_entry(), reader()
> > >       are built-in.
> > 
> > When you say that my_lock and my_list are built-in, you mean that they
> > are defined in the base kernel rather than in the module?  (I was assuming
> > that they were defined in the module.)
> 
> I meant built-in as built into vmlinux. That is, my_lock, my_list,
> add_entry(), del_entry(), reader() are defined in vmlinux , and v1, v2, v3
> are defined in mymodule.ko .

OK, even more straightforward, then.

> > >   (2) v1, v2, v3 are added to my_list only once upon module load
> > > 
> > >   (3) v1, v2, v3 might be removed from my_list some time later after
> > >       module was loaded
> > 
> > Again, module unload followed by module load will be a bit dicey.  Other
> > than that, it should work.
> > 
> > 							Thanx, Paul
> > 
> 
> If someone really needs to implement unload-able modules, he/she can
> split such modules into non unload-able component and unload-able
> component.

Yep, that works also.

							Thanx, Paul

> -------- non unload-able component --------
> static DEFINE_SRCU(my_srcu_lock);
> static int (*do_getvalue)(void);
> 
> static int mywrapper_getvalue(void)
> {
>     const int idx = srcu_read_lock(&my_srcu_lock);
>     const typeof(do_getvalue) func = do_getvalue;
>     const int ret = func ? func() : 0;
>     srcu_read_unlock(&my_srcu_lock, idx);
>     return ret;
> }
> 
> void mywrapper_register(typeof(do_getvalue) func)
> {
>     do_getvalue = func;
> }
> EXPORT_SYMBOL_GPL(mywrapper_register);
> 
> void mywrapper_unregister(void)
> {
>     do_getvalue = NULL;
>     synchronize_srcu(&my_srcu_lock);
> }
> EXPORT_SYMBOL_GPL(mywrapper_unregister);
> 
> struct my_struct {
>     struct list_head list;
>     const int (*func)(void);
> } v1 = { .func = mywrapper_getvalue };
> 
> static int __init mywrapper_init(void)
> {
>     add_entry(&v1);
>     return 0;
> }
> module_init(mywrapper_init);
> -------- non unload-able component --------
> 
> -------- unload-able component --------
> static int do_getvalue(void)
> {
>     return (...snipped...);
> }
> 
> static int __init mymodule_init(void)
> {
>     mywrapper_register(do_getvalue);
>     return 0;
> }
> module_init(mymodule_init);
> 
> static void mymodule_exit(void)
> {
>     mywrapper_unregister();
> }
> module_exit(mymodule_exit);
> -------- unload-able component --------
> 
> Thank you.
>