如何检测Linux上程序的启动？-IT科技

摘要：问题描述：我写了一个简单的守护进程。当我运行任何程序时，这个守护进程都应该响应。怎么做呢？在一个大的守护进程循环中：while(1) { /* function which catches new programm running */ } 当我运行一个新程序（创建新进程）时，在 Linux 中要调用哪...

问题描述：

我写了一个简单的守护进程。当我运行任何程序时，这个守护进程都应该响应。怎么做呢？在一个大的守护进程循环中：

while(1)
{
   /* function which catches new programm running */
}

当我运行一个新程序（创建新进程）时，在 Linux 中要调用哪些函数？

解决方案 1：

对于 Linux，内核中似乎有一个接口。在研究这个问题时，我发现有人使用 CONFIG_CONNECTOR 和 CONFIG_PROC_EVENTS 内核配置来获取进程死亡事件。

我再谷歌了一下，发现了这个：

http://netsplit.com/2011/02/09/the-proc-connector-and-socket-filters/

Proc 连接器和套接字过滤器发布于 2011 年 2 月 9 日，作者：scott
proc 连接器是那些有趣的内核功能之一，大多数人很少遇到，甚至很少找到相关文档。套接字过滤器也是如此。这很遗憾，因为它们都是非常有用的接口，如果对它们进行更好的文档记录，可能会有多种用途。
proc 连接器允许您接收进程事件的通知，例如 fork 和 exec 调用，以及进程的 uid、gid 或 sid（会话 ID）的更改。这些是通过基于套接字的接口提供的，通过读取内核头中定义的 struct proc_event 实例来实现的。...

感兴趣的标头是：

#include &lt;linux/cn_proc.h>

我在这里找到了示例代码：

http://bewareofgeek.livejournal.com/2945.html

/* This file is licensed under the GPL v2 (http://www.gnu.org/licenses/gpl2.txt) (some parts was originally borrowed from proc events example)

pmon.c

code highlighted with GNU source-highlight 3.1
*/

#define _XOPEN_SOURCE 700
#include &lt;sys/socket.h>
#include &lt;linux/netlink.h>
#include &lt;linux/connector.h>
#include &lt;linux/cn_proc.h>
#include &lt;signal.h>
#include &lt;errno.h>
#include &lt;stdbool.h>
#include &lt;unistd.h>
#include &lt;string.h>
#include &lt;stdlib.h>
#include &lt;stdio.h>

/*
* connect to netlink
* returns netlink socket, or -1 on error
*/
static int nl_connect()
{
int rc;
int nl_sock;
struct sockaddr_nl sa_nl;

nl_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
if (nl_sock == -1) {
    perror(&quot;socket&quot;);
    return -1;
}

sa_nl.nl_family = AF_NETLINK;
sa_nl.nl_groups = CN_IDX_PROC;
sa_nl.nl_pid = getpid();

rc = bind(nl_sock, (struct sockaddr *)&amp;sa_nl, sizeof(sa_nl));
if (rc == -1) {
    perror(&quot;bind&quot;);
    close(nl_sock);
    return -1;
}

return nl_sock;
}

/*
* subscribe on proc events (process notifications)
*/
static int set_proc_ev_listen(int nl_sock, bool enable)
{
int rc;
struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
    struct nlmsghdr nl_hdr;
    struct __attribute__ ((__packed__)) {
    struct cn_msg cn_msg;
    enum proc_cn_mcast_op cn_mcast;
    };
} nlcn_msg;

memset(&amp;nlcn_msg, 0, sizeof(nlcn_msg));
nlcn_msg.nl_hdr.nlmsg_len = sizeof(nlcn_msg);
nlcn_msg.nl_hdr.nlmsg_pid = getpid();
nlcn_msg.nl_hdr.nlmsg_type = NLMSG_DONE;

nlcn_msg.cn_msg.id.idx = CN_IDX_PROC;
nlcn_msg.cn_msg.id.val = CN_VAL_PROC;
nlcn_msg.cn_msg.len = sizeof(enum proc_cn_mcast_op);

nlcn_msg.cn_mcast = enable ? PROC_CN_MCAST_LISTEN : PROC_CN_MCAST_IGNORE;

rc = send(nl_sock, &amp;nlcn_msg, sizeof(nlcn_msg), 0);
if (rc == -1) {
    perror(&quot;netlink send&quot;);
    return -1;
}

return 0;
}

/*
* handle a single process event
*/
static volatile bool need_exit = false;
static int handle_proc_ev(int nl_sock)
{
int rc;
struct __attribute__ ((aligned(NLMSG_ALIGNTO))) {
    struct nlmsghdr nl_hdr;
    struct __attribute__ ((__packed__)) {
    struct cn_msg cn_msg;
    struct proc_event proc_ev;
    };
} nlcn_msg;

while (!need_exit) {
    rc = recv(nl_sock, &amp;nlcn_msg, sizeof(nlcn_msg), 0);
    if (rc == 0) {
    /* shutdown? */
    return 0;
    } else if (rc == -1) {
    if (errno == EINTR) continue;
    perror(&quot;netlink recv&quot;);
    return -1;
    }
    switch (nlcn_msg.proc_ev.what) {
    case PROC_EVENT_NONE:
        printf(&quot;set mcast listen ok
&quot;);
        break;
    case PROC_EVENT_FORK:
        printf(&quot;fork: parent tid=%d pid=%d -> child tid=%d pid=%d
&quot;,
            nlcn_msg.proc_ev.event_data.fork.parent_pid,
            nlcn_msg.proc_ev.event_data.fork.parent_tgid,
            nlcn_msg.proc_ev.event_data.fork.child_pid,
            nlcn_msg.proc_ev.event_data.fork.child_tgid);
        break;
    case PROC_EVENT_EXEC:
        printf(&quot;exec: tid=%d pid=%d
&quot;,
            nlcn_msg.proc_ev.event_data.exec.process_pid,
            nlcn_msg.proc_ev.event_data.exec.process_tgid);
        break;
    case PROC_EVENT_UID:
        printf(&quot;uid change: tid=%d pid=%d from %d to %d
&quot;,
            nlcn_msg.proc_ev.event_data.id.process_pid,
            nlcn_msg.proc_ev.event_data.id.process_tgid,
            nlcn_msg.proc_ev.event_data.id.r.ruid,
            nlcn_msg.proc_ev.event_data.id.e.euid);
        break;
    case PROC_EVENT_GID:
        printf(&quot;gid change: tid=%d pid=%d from %d to %d
&quot;,
            nlcn_msg.proc_ev.event_data.id.process_pid,
            nlcn_msg.proc_ev.event_data.id.process_tgid,
            nlcn_msg.proc_ev.event_data.id.r.rgid,
            nlcn_msg.proc_ev.event_data.id.e.egid);
        break;
    case PROC_EVENT_EXIT:
        printf(&quot;exit: tid=%d pid=%d exit_code=%d
&quot;,
            nlcn_msg.proc_ev.event_data.exit.process_pid,
            nlcn_msg.proc_ev.event_data.exit.process_tgid,
            nlcn_msg.proc_ev.event_data.exit.exit_code);
        break;
    default:
        printf(&quot;unhandled proc event
&quot;);
        break;
    }
}

return 0;
}

static void on_sigint(int unused)
{
need_exit = true;
}

int main(int argc, const char *argv[])
{
int nl_sock;
int rc = EXIT_SUCCESS;

signal(SIGINT, &amp;on_sigint);
siginterrupt(SIGINT, true);

nl_sock = nl_connect();
if (nl_sock == -1)
    exit(EXIT_FAILURE);

rc = set_proc_ev_listen(nl_sock, true);
if (rc == -1) {
    rc = EXIT_FAILURE;
    goto out;
}

rc = handle_proc_ev(nl_sock);
if (rc == -1) {
    rc = EXIT_FAILURE;
    goto out;
}

    set_proc_ev_listen(nl_sock, false);

out:
close(nl_sock);
exit(rc);
}

我发现此代码需要以 root 身份运行才能获取通知。

解决方案 2：

我感兴趣的是尝试弄清楚如何在没有轮询的情况下做到这一点。inotify() 似乎在 /proc 上不起作用，所以这个想法被否决了。

但是，任何动态链接的程序都会在启动时访问某些文件，例如动态链接器。这对于安全目的来说毫无用处，因为它不会在静态链接的程序上触发，但可能仍然很有趣：

#include &lt;stdio.h>
#include &lt;sys/inotify.h>
#include &lt;assert.h>
int main(int argc, char **argv) {
    char buf[256];
    struct inotify_event *event;
    int fd, wd;
    fd=inotify_init();
    assert(fd > -1);
    assert((wd=inotify_add_watch(fd, &quot;/lib/ld-linux.so.2&quot;, IN_OPEN)) > 0);
    printf(&quot;Watching for events, wd is %x
&quot;, wd);
    while (read(fd, buf, sizeof(buf))) {
      event = (void *) buf;
      printf(&quot;watch %d mask %x name(len %d)=\&quot;%s\&quot;
&quot;,
         event->wd, event->mask, event->len, event->name);
    }
    inotify_rm_watch(fd, wd);
    return 0;
}

打印出来的事件不包含任何有趣的信息 - 触发进程的 pid 似乎不是由 inotify 提供的。但是它可以用于唤醒并触发 /proc 的重新扫描

还要注意，在此程序唤醒并完成扫描 /proc 之前，短暂存在的程序可能会再次消失 - 大概您会知道它们曾经存在，但无法知道它们是什么。当然，任何人都可以继续打开和关闭动态链接器的 fd，让您淹没在噪音中。

解决方案 3：

使用forkstat，它是 proc 事件最完整的客户端：

sudo forkstat -e exec,comm,core

GitWeb：http://kernel.ubuntu.com/git? p=cking/forkstat.git
公告：http ://smackerelofopinion.blogspot.com/2014/03/forkstat-new-tool-to-trace-process.html

在 Ubuntu、Debian 和 AUR 中打包。

在此之前，有一个 cn_proc：

 bzr branch lp:~kees/+junk/cn_proc

Makefile 需要稍微修改一下（LDLIBS而不是LDFLAGS）。

cn_proc 和exec-notify.c (Arnaud 发布的) 有共同的祖先；cn_proc 处理更多的事件并具有更清晰的输出，但是在进程快速退出时缺乏弹性。

哦，找到了 exec-notify 的另一个分支，extrace。这个将子进程缩进到其父进程之下（使用 pid_depth 启发式方法）。

解决方案 4：

看看Sebastian Krahmer 编写的这个小程序，它以资源高效的方式和非常简单的代码完成了您要求的任务。

它确实要求你的内核启用 CONFIG_PROC_EVENTS，但最新的 Amazon Linux Image（2012.09）并非如此。

更新：根据向亚马逊提出的请求， Amazon Linux 映像内核现在支持 PROC_EVENTS

解决方案 5：

您选择的搜索引擎的关键词是“流程事件连接器”。

我发现了两个利用它们的工具，exec-notify和cn_proc。

我更喜欢后者，但两者都做得很好。

解决方案 6：

我不知道是否存在更好的方法，但您可以定期扫描/proc文件系统。

例如，/proc/<pid>/exe是指向进程可执行文件的符号链接。

在我的系统 (Ubuntu/RedHat) 上，/proc/loadavg包含正在运行的进程数（斜杠后面的数字）以及最近启动的进程的 pid。如果您的守护进程轮询该文件，则对这两个数字中的任何一个进行的任何更改都会告诉它何时需要重新扫描/proc以寻找新进程。

这绝不是万无一失的，但却是我能想到的最合适的机制。

解决方案 7：

您可以扫描操作系统以查找符合条件的程序，也可以等待程序向守护程序报告自身。选择哪种技术在很大程度上取决于您对非守护程序的控制程度。

扫描可以通过内核系统调用或读取用户空间公布的内核详细信息（与 /proc 文件系统一样）来完成。请注意，扫描并不能保证您能找到任何特定程序，因为如果程序在扫描周期之间设法启动和终止，则根本无法检测到它。

更复杂的进程检测技术是可行的，但它们也需要更复杂的实现。在开始寻求奇特的解决方案（插入内核驱动程序等）之前，了解真正需要什么非常重要，因为您所做的一切都与您正在监控的系统无关；您实际上是通过观察环境来改变环境，而观察环境的一些方法可能会不恰当地改变环境。

解决方案 8：

CONFIG_FTRACE并CONFIG_KPROBES通过brendangregg/perf-tools

git clone https://github.com/brendangregg/perf-tools.git
cd perf-tools
git checkout 98d42a2a1493d2d1c651a5c396e015d4f082eb20
sudo ./execsnoop

在另一个 shell 上：

while true; do sleep 1; date; done

第一个 shell 显示以下格式的数据：

Tracing exec()s. Ctrl-C to end.                                                        
Instrumenting sys_execve                                                               
   PID   PPID ARGS 
 20109   4336 date                                                                                       
 20110   4336 sleep 1                                                                                    
 20111   4336 date                                                                                                                                                                                                 
 20112   4336 sleep 1                                                                                    
 20113   4336 date                                                                                       
 20114   4336 sleep 1                                                                                    
 20115   4336 date                                                                                       
 20116   4336 sleep 1