1

情况如下：

我正在尝试做一个在 github 中破解内核的项目。内核版本为 linux-3.18.6。

QEMU 用于模拟环境。

在我的应用程序中，我尝试通过跟随它们来理解系统调用过程。完成我的目标的方法就像shell程序一样。我只是创建一些命令来运行相对系统调用。也许通过图片很简单。 一些命令

代码很简单如下：

1 使用 API getpid。

int Getpid(int argc, char **argv)
{
    pid_t pid;
    pid = getpid();
    printf("current process's pid:%d\n",pid);
    return 0;
}

2 直接使用 int $0x80。

int GetpidAsm(int argc, char **argv)
{
    pid_t pid;
    asm volatile(
    "mov $20, %%eax\n\t"
    "int $0x80\n\t"
    "mov %%eax, %0\n\t"
    :"=m"(pid)
    );
    printf("current process's pid(ASM):%d\n",pid);
    return 0;
}

因为我的应用程序只是在 pid 1 的进程中运行，所以每次我输入命令 getpid 时，它都会返回 1。当然这是真的。

奇怪的是，当我使用 gdb 调试 syscall 进程时，它只会在我键入 getpid 执行时在 berakpoint sys_getpid 处停止一次。当我一次又一次地这样做时，它只是不停地输出。

显然，据我所知，使用 int $0x80 是绝对正确的。

为了解决这个问题，我做了一些研究。我下载了 glibc 源代码（glibc-2.25）代码来查看 api getpid 如何包装 int $0x80。不幸的是，它不在那里，或者我只是没有找到正确的位置。

glibc 中的一些代码。

pid_t getpid(void)
{
  pid_t (*f)(void);
  f = (pid_t (*)(void)) dlsym (RTLD_NEXT, "getpid");
  if (f == NULL)
    error (EXIT_FAILURE, 0, "dlsym (RTLD_NEXT, \"getpid\"): %s", dlerror ());
  return (pid2 = f()) + 26;
}

如果我得到了错误的代码，请告诉我，tks。

如代码所示，glibc 中不包含 getpid 的定义。看了一些资料后，有人说VDSO ....

请注意，AFAIK，简单系统调用成本的很大一部分是从用户空间到内核并返回。因此，对于某些系统调用（可能是 gettimeofday、getpid ...），VDSO 甚至可以避免这种情况（并且在技术上可能会避免进行真正的系统调用）。

在 man getpid pgae 中：

C 库/内核差异 从 glibc 2.3.4 版本开始，glibc 的 getpid() 包装函数会缓存 PID，以避免在进程重复调用 getpid() 时产生额外的系统调用。通常这种缓存是不可见的，但它的正确操作依赖于对 fork(2)、vfork(2) 和 clone(2) 的包装器函数的支持：如果应用程序通过使用 syscall(2) 绕过这些系统调用的 glibc 包装器)，然后在子进程中调用 getpid() 将返回错误的值（准确地说：它将返回父进程的 PID）。另请参阅 clone(2) 以讨论 getpid() 可能返回错误值的情况，即使通过 glibc 包装函数调用 clone(2) 也是如此。

虽然有这么多的解释，但我无法弄清楚API getpid的工作过程。

相比之下，API 时间很容易理解。时间的定义：

time_t
time (time_t *t)
{
  INTERNAL_SYSCALL_DECL (err);
  time_t res = INTERNAL_SYSCALL (time, err, 1, NULL);
  /* There cannot be any error.  */
  if (t != NULL)
    *t = res;
  return res;
}

然后，

#define INTERNAL_SYSCALL(name, err, nr, args...)            \
    internal_syscall##nr ("li\t%0, %2\t\t\t# " #name "\n\t",    \
                  "IK" (SYS_ify (name)),            \
                  0, err, args)

最后，它是嵌入式 asm，这是使用内核源代码的正常方式。

#define internal_syscall1(v0_init, input, number, err, arg1)        \
({                                  \
    long _sys_result;                       \
                                    \
    {                               \
    register long __s0 asm ("$16") __attribute__ ((unused))     \
      = (number);                           \
    register long __v0 asm ("$2");                  \
    register long __a0 asm ("$4") = (long) (arg1);          \
    register long __a3 asm ("$7");                  \
    __asm__ volatile (                      \
    ".set\tnoreorder\n\t"                       \
    v0_init                             \
    "syscall\n\t"                           \
    ".set reorder"                          \
    : "=r" (__v0), "=r" (__a3)                  \
    : input, "r" (__a0)                     \
    : __SYSCALL_CLOBBERS);                      \
    err = __a3;                         \
    _sys_result = __v0;                     \
    }                               \
    _sys_result;                            \
})

有人可以清楚地解释 API getpid 是如何工作的吗？为什么 getpid 只陷入系统调用 sys_getpid 一次？如果可能的话，一些参考是值得赞赏的。

谢谢你的帮助。

4

1 回答 1

4

首先请注意，glibc 源代码几乎无法导航。

正如您所注意到的，文档指出 getpid() 缓存其结果。您发现的代码看起来像

pid_t getpid(void)
{
  pid_t (*f)(void);
  f = (pid_t (*)(void)) dlsym (RTLD_NEXT, "getpid");
  if (f == NULL)
    error (EXIT_FAILURE, 0, "dlsym (RTLD_NEXT, \"getpid\"): %s", dlerror ());
  return (pid2 = f()) + 26;
}

只是一个包装器。它查找一个getpid符号，并调用该函数。该功能是您需要找到的。它是您可以在sysdeps/unix/sysv/linux/getpid.c文件中找到的 __getpid() 函数的别名，也显示在本文的底部。

现在 - 您可能正在查看与当前 glibc 不匹配的 glibc 源代码 - 在此提交中，关于 2016 年 11 月的 getpid() 缓存有一个很大的变化，据我所知，该变化将是 glibc 的一部分-2.25 于 2017 年 2 月发布

较旧的 getpid() 实现缓存其值以避免多次调用 getpid() 系统调用，可以在这里看到： http ://repo.or.cz/glibc.git/blob/93eb85ceb25ee7aff432ddea0abf559f53d7a5fc:/sysdeps/unix/ sysv/linux/getpid.c看起来像

static inline __attribute__((always_inline)) pid_t
really_getpid (pid_t oldval)
{
  if (__glibc_likely (oldval == 0))
    {
      pid_t selftid = THREAD_GETMEM (THREAD_SELF, tid);
      if (__glibc_likely (selftid != 0))
    return selftid;
    }

  INTERNAL_SYSCALL_DECL (err);
  pid_t result = INTERNAL_SYSCALL (getpid, err, 0);

  /* We do not set the PID field in the TID here since we might be
     called from a signal handler while the thread executes fork.  */
  if (oldval == 0)
    THREAD_SETMEM (THREAD_SELF, tid, result);
  return result;
}
#endif

pid_t
__getpid (void)
{
#if !IS_IN (libc)
  INTERNAL_SYSCALL_DECL (err);
  pid_t result = INTERNAL_SYSCALL (getpid, err, 0);
#else
  pid_t result = THREAD_GETMEM (THREAD_SELF, pid);
  if (__glibc_unlikely (result <= 0))
    result = really_getpid (result);
#endif
  return result;
}

libc_hidden_def (__getpid)
weak_alias (__getpid, getpid)
libc_hidden_def (getpid)
于 2017-04-06T09:19:30.853 回答