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

Question

背景

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

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

问题

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

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

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

其他信息

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

• 该库没有依赖项，并且不会fork任何子项。

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

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

• 所有代码均采用 C 语言编写，重点关注可重用性和可移植性。

Answer 1

因此，通过多次尝试和错误，我设法提出了一个可行的解决方案。对于任何将来偶然发现这一点的人，以下是对我有用的方法。

概述

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

问题解答

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