Question

我目前正在实现一个使用posix共享内存的小型C函数（shm_open()，ftruncate()，mmap()和shm_unlink()。

我面临的问题是，我的应用程序通常会优雅地存在，而我的清理例程会调用shm_unlink()。

但是如果我的进程得到kill -9我面临的问题是shm段仍然存在。我的应用程序使用fork()，甚至可以在多个实例中启动。因此，如果在启动期间我检测到存在共享内存段，我如何判断它是否是崩溃的剩余部分，因此我可以重置它或其他一些进程可能仍在使用它？

在SystemV IPC共享内存集函数中，一旦我执行了shmget()，后续shmat()我就有shm_nattch。

与posix共享内存有类似之处吗？

Answer 1

POSIX共享内存实际上是映射内存的变体。主要的区别是使用shm_open（）来打开共享内存对象（而不是调用open（））并使用shm_unlink（）来关闭和删除对象（而不是调用不移除对象的close（））。 shm_open（）中的选项远远少于open（）中提供的选项数。

IPC共享内存是一种在程序之间传递数据的有效手段。一个程序将创建一个内存部分，其他进程（如果允许）可以访问。

恕我直言，它们之间的区别并不大，甚至很大，因为POSIX共享内存只是后者和更标准的共享内存概念实现。 kill -9问题确实存在问题。你不能设置任何处理程序，甚至没有调用atexit。但您可以为SIGTERM设置处理程序并使用以下命令终止您的进程：

kill -SIGTERM <pid>

atexit和信号处理程序的示例代码：

#include <signal.h>
#include <unistd.h>
#include <cerrno>
#include <system_error>
#include <iostream>

static sigset_t theMask;

static void
signalWrapper(
    int         theSignalNumber,
    siginfo_t*  theSignalDescription,
    void*       theUserContext)
{
  if (theSignalNumber == SIGTERM)
  {
    std::cerr << "Clear shared memory and exit" << std::endl;
    exit(1);
  }

  // Reinstall handler (usefull for other signals)
  struct ::sigaction sa;
  sa.sa_sigaction = &signalWrapper;
  sa.sa_mask = theMask;
  sa.sa_flags = SA_SIGINFO;

  try
  {
    if (::sigaction(theSignalNumber, &sa, NULL) == -1)
      throw std::error_code(errno, std::system_category());
  }
  catch (const std::error_code& ec)
  {
    std::cerr << ec << std::endl;
  }
}

void
setupSignalHandlers()
{
  struct ::sigaction sa;

  // Prepare mask
  sigemptyset(&theMask);
  sigaddset(&theMask, SIGTERM);
  // Add some more if you need it to process

  sa.sa_mask      = theMask;
  sa.sa_flags     = SA_SIGINFO;
  sa.sa_sigaction = &signalWrapper;

  // Perform setup
  try
  {
    if (::sigaction(SIGTERM, &sa, NULL) == -1)
      throw std::error_code(errno, std::system_category());
  }
  catch (const std::error_code& ec)
  {
    std::cerr << ec << std::endl;
  }
}

void
bye()
{
  std::cout << "Bye!" << std::endl;
}

int
main()
{
  std::cout << "Set handler!" << std::endl;
  setupSignalHandlers();
  if (std::atexit(bye))
  {
    std::cerr << "Failed to register atexit" << std::endl;
    return 2;
  }

  std::cout << "Emit SIGTERM signals" << std::endl;
  kill(getpid(), SIGTERM);
  sleep(100);

  return 0;
}

另一个有趣的方法是在 shm_open（）之后 shm_unlink（）并使用 O_CLOEXEC 。我写了一些小代码示例来说明使用unlink和POSIX共享内存重新打开：

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <cerrno>
#include <cstring>

#include <system_error>
#include <iostream>

// Simple ShMem with RAII
struct ShMem
{
  ShMem(
    const std::string& theName)
  : _handle(-1),
    _mode(S_IRUSR | S_IWUSR),
    _name(theName)
  {
    // Here we try to create the object with exclusive right to it
    // If the object exists - it must fail.
    // File opened as 0600. The open mode might be set with
    // class enum and additional paramter to constructor
    if ((_handle = shm_open(_name.c_str(), O_CREAT | O_RDWR | O_EXCL, _mode)) < 0)
    {
      std::cerr << strerror(errno) << std::endl;

      std::cout << "File " << _name << "exists. Try to reopen it!" << std::endl;
      if ((_handle = shm_open(_name.c_str(), O_RDWR | O_TRUNC, _mode)) < 0)
      {
        std::cerr << strerror(errno) << std::endl;
        throw std::error_code(errno, std::system_category());
      }
      else
        std::cout << _name << " reopened OK";
    }
    else
      std::cout << _name << " created OK";

    // Unlink but keep descriptor
    shm_unlink(_name.c_str());
  }

 ~ShMem()
  {
  }

  const int
  handle()
  {
    return _handle;
  }

private:

  int         _handle;
  mode_t      _mode;
  std::string _name;
};

使用 O_CLOEXEC ，你可以删除 shm_unlink（），看看 kill -9 会发生什么。

IPC共享内存与posix共享内存

1 个答案: