flock does not work under QNX on files created in /dev/shmem under QNX [10619]

[asobhy-qnx]

Fast-DDS/src/cpp/rtps/transport/shared_mem/RobustExclusiveLock.hpp

Line 192 in a5a7d16

if (0 != flock(fd, LOCK_EX | LOCK_NB))

flock returns "The filesystem doesn't support the operation" due to that the file descriptor represents a file created under /dev/shmem

Can the robust lock file be created under another path? what are the consequences of creating a file in /dev/shmem and not locking it?

[IkerLuengo]

The only purpose of the file we are locking is to act as an interprocess exclusion lock that is automatically freed when the creator process dies unexpectedly. These lock files always have a companion file where the data is actually shared among the processes, and both are created simultaneously by the same process. The lock file is used to detect when the creator process dies, so that we can garbage-collect and remove both.

The reason we are using flock is that it will be automatically freed when the process dies. You may have another suggestion that works for QNX.

[asobhy-qnx]

You mentioned above, "These lock files always have a companion file where the data is actually shared among the processes", which got me a bit confused. The companion file you mean by that the shared memory? or a regular file?

So here is my understanding:

a process creates a shared memory then it creates a file tagged with a segment number and locks it. The purpose of the file is to tell during clean up if there has been shared memory created or not and if yes then it cleans it up before terminating, correct?

Do we have to lock the file? isn't it enough to detect the existence of the file to know whether we created shared memory or not? In QNX we can create regular files under /dev/shmem but we cannot lock them because they are not regular files. We have two options here:

1- if the locking is necessary then we can create the file in any other path other than /dev/shmem then we can lock it just fine.
2- create the file under /dev/shmem but do not lock it.

Which one do you think would be the better option?

Thank you

[liutiegang]

Could someone please help on this issue? This issue can reproduce on QNX7.0 armV8 target.

[liutiegang]

I use a test demo to run, got the following log:

182885.178017408 Acquiring LOCK_EX on fd=3, fname='/tmp/fastrtps_d61cc318b6a158ff_el'
flock(fd=3, fname='/tmp/fastrtps_d61cc318b6a158ff_el', LOCK_EX): Function not implemented

it means QNX7 didn't implement the LOCK_EX of flock function?

Who can help on it?

Thanks.

[IkerLuengo]

We decided to use flock as a sync mechanism because it was very convenient to:

• avoid two participants using the same shared memory file name (flock-ing the companion will fail for one of them, an will try with another name)
• detecting dangling files whos participants have died unexpectedly and removing them (flock is automatically unlocked when the locking process ends)

These locked files do not need to be on shared memory, it was just convenient to put them together with their companion. We could move the location of the locked files to another directory (probably only for QNX). Is there any specific directory that couold be used for this in QNX? We are thinking of /var/lock, or even /usr/tmp. Are these directories mounted on QNX?

[asobhy-qnx]

/var/lock is good

Here is an implementation to replace https://github.com/eProsima/Fast-DDS/blobhttps://github.com/eProsima/Fast-DDS/blob/a5a7d162e483ddc30f8f45a73ed0ad4b0ad974f7/src/cpp/rtps/transport/shared_mem/RobustLock.hpp#L44-L69

#ifdef __QNXNTO__
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#endif

static std::string get_file_path(
            const std::string& filename)
    {
        
#ifdef __QNXNTO__
        static const char defaultdir[] = "/var/lock";
        struct stat buf;
        // check directory status
        if (stat(defaultdir, &buf) != 0){
            // directory not found, create it
            if(errno == ENOENT){
                mkdir(defaultdir, 0777);
            }
            // if another error then throw exception
            else{
                std::string err("get_file_path() ");
                err = err + strerror(errno);
                throw std::runtime_error(err);
            }
        }
        else{
            // directory exists do nothing
        }
#else
// Default value from: glibc-2.29/sysdeps/unix/sysv/linux/shm-directory.c
        static const char defaultdir[] = "/dev/shm/";
#endif
        std::string filepath;
        #if defined(BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
        const bool add_leading_slash = false;
        #elif defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
        const bool add_leading_slash = !boost::interprocess::shared_memory_object_detail::use_filesystem_based_posix();
        #else
        const bool add_leading_slash = true;
        #endif
        if (add_leading_slash)
        {
            boost::interprocess::ipcdetail::add_leading_slash(filename.c_str(), filepath);
        }
        else
        {
            boost::interprocess::ipcdetail::shared_filepath(filename.c_str(), filepath);
        }
        return defaultdir + filepath;
    }

[liutiegang]

Thanks a lot, this issue is fixed on my side.

[MiguelCompany]

This was fixed almost a year ago. Closing.