在 Linux 中跨共享库调用保留数据

Question

背景

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

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

问题

(1)是否总是需要运行进程来保留这个内存？

(2) 由于我的库一直在加载和卸载，所以当所有调用退出时会发生什么？谁 "owns" 那个时候的内存还是泄漏了？

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

附加信息

对库的单独调用是原子的和独立的。
库没有依赖项，也没有 fork 任何子项。
被跟踪的数据需要在设备的整个启动时间内保持。
该平台是 3.x Linux 内核的自定义版本。
所有代码都是用 C 编写的，重点是可重用性和可移植性。

Answer 1

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

概览

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

问题的答案

(1) 不，并不总是需要运行进程来保留内存，因为它与系统一起存储。

(2) 随着各种调用的进入/退出，共享内存段反复attached/detached。 None 这些行为导致记忆被破坏；它保留在系统中，直到明确删除。如果内存永远不删除，它就会泄漏。

(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;
}

在 Linux 中跨共享库调用保留数据

Persisting Data Across Shared Library Calls in Linux

c

linux

shared-libraries

shared-memory