Re: inode-based dlopen caching

[Adhemerval Zanella <adhemerval.zanella@linaro.org>]

On 07/06/2021 19:50, Soni L. wrote:
> 
> 
> On 2021-06-07 6:53 p.m., Adhemerval Zanella wrote:
>>
>>
>> On 05/06/2021 10:59, Soni L. via Libc-help wrote:
>>> Currently dlopen caching is based on filenames, it'd be nice if it was
>>> based on inodes to support better "re"loading (aka loading a new module
>>> with the same name because unloading modules with threads is never a
>>> good idea). This is good for stuff that deals with plugins.
>>>
>>
>> What do you mean by 'caching' in this scenario? glibc does not maintain
>> a cache of loaded libraries, different than other implementation it
>> does try to unload the library on dlclose (there are cases where it
>> is not readily possible due dependency chains). 
>>
>> And I am not seeing how inote-bases dlopen really helps here, if inode 
>> changes means that file was potentially changed (so you will need to 
>> proper dclose it).  I think using filenames is in fact the proper way
>> here, since Linux does the hard lifting of the inode cache and provide
>> fast file access and mmap support for shared libraries.
>>
> You can't unload a dlopen that uses threads, at least not safely. So for
> all intents and purposes you can't unload it. Instead you need to tell
> it you're done with it, but not unload it, and load the new one. But
> that's the problem - the filename-based stuff means you can't load the
> new one.
> 

Sure you can unload a dlopen library, the API makes the program responsible
to synchronize the access (since dlsym/dlvsym returns an function pointer).

If I understood correctly what you are suggesting is making dlclose a noop,
so a newer dlopen will also be a noop if it is essentially the same shared
object (what happen if the shared library is updated and the inode keep the
same?).

This is design choice to actually unload the shared object on dlclose and
changing it because it might incurs in concurrent issues on programs that
do not synchronize its access is a really bad motivation.  There are multiple 
better ways to handle it, either by wrapping with a more user-friendly API or
using a high level language.

If the motivation is to avoid the potential synchronization issues libc
itself need to handle (such as TLS and other shared resources), it could
be a better motivation.  But even it is a trade off of keep allocated 
resources even when caller states it does not need them anymore.  As
fair I know this the design musl-libc has done.

We could do it, but we have been fixing an improving the dynamic loader
over time that makes this approach also complex and with not large benefits.
Also, we still need to do some filename caching to handle things as
RUNPATH/RPATH and SONAME; so the implementation to also take in consideration
inode might add even more complexity and have more corner cases.