Question

背景

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

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

问题

（1）是否总是需要一个正在运行的进程来保留这个内存？

（2）由于我的库经常被加载和卸载，所有调用退出后会发生什么？那个人“拥有”记忆力还是泄漏了？

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

其他信息

对库的单独调用是原子的和独立的。
该库没有依赖关系，也没有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;
}

在Linux中保持共享库调用的数据

1 个答案: