在 Linux 中跨共享库调用持久化数据

Question

背景

我正在开发一个管理嵌入式以太网交换机的共享库。该库由各种开关感知管理应用程序调用，旨在成为设备的唯一接口。所讨论的特定开关是为企业应用程序设计的，并期望控制 CPU 来管理大部分内部状态。为此，我需要存储一个数据表，该表将在不同应用程序对库的多次调用中保持不变。

为此，我一直在考虑使用适当的并发保护来共享内存。然而，由于共享库的动态特性，这引发了许多问题。

问题

(1) 是否总是需要有一个正在运行的进程来保留这块内存？

(2) 由于我的库不断被加载和卸载，当所有调用退出时会发生什么？谁在那个时候“拥有”了内存或者它是否泄漏了？

(3) 是否有更好的系统可以在我的库的多次调用中持久保存 structs 数组（我曾考虑过平面文件，但文件系统访问非常有限）。

其他信息

• 对库的单独调用是原子的且独立的。

• 该库没有依赖关系，也没有fork 任何子级。

• 需要在设备的整个启动时间内维护被跟踪的数据。

• 该平台是 3.x Linux 内核的自定义版本。

• 所有代码都是用 C 语言编写的，重点是可重用性和可移植性。

Answer 1

所以，经过反复试验，我设法提出了一个可行的解决方案。对于将来偶然发现这一点的任何人，以下是对我有用的方法。

概述

我最终使用了 System-V “SHM 风格”的共享内存。事实证明，此内存与正在运行的系统一起存储，直到它被明确删除（或系统重新启动）。我附加到它的任何进程，只要它在附加时提供适当的密钥。

问题解答

(1) 不，并不总是需要一个正在运行的进程来保留与系统一起存储的内存。

(2)随着各种调用的进入/退出，共享内存段被反复附加/分离。这些动作都不会导致内存被破坏；它会保留在系统中，直到明确删除。如果内存永远不被删除，它就会泄漏。

(3) 我无法回答是否有更好的 解决方案，但是 System-V 共享内存很容易设置并满足我的所有要求。

示例代码

注意：这是为了说明目的，可能需要进行优化。它应该可以正常工作，但是您需要根据您的确切要求填写一些空白。

/* Attaches to a shared memory segment.  If the segment doesn't exist, it is
 * created.  If it does exist, it is attached and returned.  Semaphores are
 * expected to be handled by the caller.  Returns 0 on success and -errno
 * on failure.
 *
 * Params:
 *   size  - Size of memory segment to create
 *   local - Pointer to attached memory region; populated by this function
 */
int16_t shm_attach(u_int32_t size, void **local)
{
    key_t key;
    int shmid;

    // Create unique-ish key
    key = ftok("/path/to/any/file", 'Z');

    // Determine if shared segment already exists
    shmid = shmget(key, size, 0666 | IPC_CREAT | IPC_EXCL);
    if (shmid == -1)
    {
        if (errno == EEXIST)
        {
            // Segment exists; attach to it and return
            printf("%s: SHM exists\n", __func__);
            shmid = shmget(key, size, 0666 | IPC_CREAT);
            printf("%s: SHM ID = %d\n", __func__, shmid);
            *local = shmat(shmid, NULL, 0);
            return 0;

        } else
        {
            // Unexpected error
            fprintf(stderr, "%s: Error while initializing shared memory: %d\n", __func__, -errno);
            return -errno;
        }
    } else
    {
        // Segment didn't exist and was created; initialize and return it
        printf("%s: SHM created\n", __func__);
        printf("%s: SHM ID = %d\n", __func__, shmid);
        *local = shmat(shmid, NULL, 0);

        // Initialize shared memory with whatever contents you need here
        memset(*local, 0x00, size);
        // ...

        return 0;
    }
}

/* Detaches from a shared memory segment.  Semaphores are expected to be
 * handled by caller.  Returns 0 on success and -errno on failure.
 *
 * Params:
 *   addr  - Local address of shared memory segment
 */
int16_t shm_detach(void *addr)
{
    if (shmdt(addr) == -1)
    {
        fprintf(stderr, "%s: Error detaching shared memory: %d\n", __func__, -errno);
        return -errno;
    }

    return 0;
}

// Fill this in with your actual data types
typedef struct {
    int foo;
} your_shm_storage_t;

// Sample main with basic usage.  Not that this will never delete the SHM
// block so the memory will technically leak until the next reboot.  This
// is a sample, not the entire application.  =P
int main()
{
     sem_t *sem;
     your_shm_storage_t *shared;

    // Open shared memory
    sem = sem_open("/your_sem_name", O_CREAT, 0666, 1);
    sem_wait(sem);
    shm_attach(sizeof(your_shm_storage_t), (void **)&shared);

    // Do stuff with shared memory
    shared->foo++;
    printf("foo = %d\n", shared->foo);

    shm_detach(shared);
    sem_post(sem);

    return EXIT_SUCCESS;
}