मैं लिनक्स में लॉन्च होने वाली सभी प्रक्रिया को कैसे लॉग कर सकता हूं?

Question

मैं उन सभी प्रक्रियाओं का एक लॉग प्राप्त करना चाहूंगा जो उस समय के साथ लॉन्च किए गए हैं, जब वे लॉन्च किए गए थे और उनके साथ जो तर्क थे। क्या लिनक्स में यह संभव है?

Answer 1

आपका प्रारंभिक बिंदु लेखा परीक्षा होना चाहिए।

कुछ इस तरह की कोशिश करो:

apt-get install auditd
auditctl -a task,always
ausearch -i -sc execve

Comments

मुझे त्रुटि मिल रही है The audit system is disabledमैं इसे कहां सक्षम कर सकता हूं?

— टॉम्बर्ट

अच्छी तरह से एक समस्या को हल किया जा सकता है, chmod 0750 /sbin/audispdलेकिन यह अभी भी काम नहीं कर रहा है (डेबियन

— व्हीज़ी

कहते हैं, Unable to set audit pid, exitingलेकिन मुझे लगता है कि असली समस्या यह होगी कि सिस्टम LXC कंटेनर में चल रहा है

— टॉमबार्ट

ऑडिट सिस्टम जर्नल के साथ कैसे एकीकृत करता है? क्या उनके कार्य ओवरलैप होते हैं?

— CMCDragonkai

मैंने एक लाइव सर्वर पर यह कोशिश की और मैंने इसे प्रभावी ढंग से मार दिया, लगभग अनुत्तरदायी बन गया। मैंने मुश्किल से इस नियम को हटा दिया और सर्वर को फिर से उत्तरदायी बना दिया

— शॉकर

Answer 2

मुझे यह करने की आवश्यकता थी, (1) को छोड़कर मुझे समय की आवश्यकता नहीं थी और (2) मुझे केवल उन प्रक्रियाओं में दिलचस्पी थी जो किसी दिए गए प्रक्रिया द्वारा शुरू की जाती हैं, और इसके बच्चे और बाद के वंशज। इसके अलावा, पर्यावरण मैं उपयोग कर रहा था में, यह संभव नहीं मिल गया था auditdया acctonहै, लेकिन वहाँ था valgrind।

कमांड लाइन पर ब्याज की प्रक्रिया के लिए निम्नलिखित उपसर्ग करें:

valgrind --trace-children=yes

आपको आवश्यक जानकारी STDERR पर प्रदर्शित लॉग आउटपुट में होगी।

Comments

डिफ़ॉल्ट रूप से, वेलग्रिंड memcheckटूल से चलता है । उपकरण और इससे संबंधित लॉगिंग अक्षम करने के लिए, और केवल नए आदेश के निर्माण प्रिंट (अपने कार्यक्रम के सामान्य उत्पादन के अलावा), निम्न आदेश का उपयोग करें: valgrind --tool=none --trace-children=yes [command and args here]। जब भी कोई सबप्रोसेस किया जाता है, तो Valgrind तब पूरी कमांड को लॉग करेगा, जिसमें यह तर्क दिए गए थे।

— रॉब डब्ल्यू

Answer 3

आप इसके लिए स्नूपि का उपयोग कर सकते हैं ।

यह स्थापित करना बहुत सरल है, और 2.x के बाद से यह मनमाना डेटा (तर्क, पर्यावरण चर, cwd, आदि) लॉग कर सकता है।

प्रकटीकरण: यहाँ स्नूपी अनुरक्षक।

Answer 4

जब आप स्टार्ट-अप को चला सकते हैं और उसके मानक आउटपुट, Ctrl-C का अनुसरण कर सकते हैं। हाल ही में रेड हैट डिस्ट्रोस (आरएचईएल, फेडोरा, सेंटोस) पर स्टार्टर को संकलित करने और चलाने का तरीका बताया गया है:

sudo yum install git cmake gcc-c++
git clone https://github.com/pturmel/startmon
cd startmon
cmake .
make
sudo ./startmon -e

डेबियन (और उबंटू आदि) पर, उपरोक्त परिवर्तनों की पहली पंक्ति:

sudo apt-get install git cmake g++

वैकल्पिक रूप से आप execsnoopस्क्रिप्ट को perf-tools में आज़मा सकते हैं , इस उत्तर को देखें । डिफ़ॉल्ट रूप से केवल पहले 8 तर्क दिखाए गए हैं (9 प्रोग्राम नाम सहित); आप इसे बढ़ा सकते हैं

sudo ./execsnoop -a 16

यदि आपके पास सिस्टम तक रूट एक्सेस नहीं है, तो आप जो सबसे अच्छा कर सकते हैं, वह मतदान है /procऔर आशा है कि यह सब कुछ पकड़ता है (जो यह नहीं होगा), लेकिन पूर्णता के लिए यहाँ एक स्क्रिप्ट है जो मैंने किया है (मैंने डुप्लिकेट-निष्कासन डाल दिया है आउटपुट को सरल बनाने के लिए) -हालांकि यह उपरोक्त विधियों में से किसी एक के साथ ठीक से नज़र रखने के रूप में अच्छा नहीं है, यह कमांड लाइन तर्कों के बीच स्पष्ट रूप से प्रदर्शित विभाजकों का मामूली फायदा है, अगर आपको कभी भी बताने की आवश्यकता है रिक्त स्थान के बीच अंतर के अंदर एक तर्क और अंतरिक्ष के बीच बहस। यह स्क्रिप्ट अक्षम है क्योंकि यह CPU (अच्छी तरह से, इसके कोर में से एक) 100% समय का उपयोग करता है।

function pstail () { python -c 'import os
last=set(os.listdir("/proc")) ; o=x=""
while True:
 pids=set(os.listdir("/proc"))
 new=pids.difference(last);last=pids
 for n in new:
  try: o,x=x,[j for j in open("/proc/"+n+"/cmdline")
    .read().split(chr(0)) if j]
  except IOError: pass
  if x and not o==x: print n,x' ; }

pstail

आप execsnoopअधिक स्पष्ट रूप से बताने के लिए पैच कर सकते हैं कि कौन सा तर्क है:grep -v sub.*arg < execsnoop > n && chmod +x n && mv n execsnoop

Answer 5

CONFIG_FTRACEऔर के CONFIG_KPROBESमाध्यम सेbrendangregg/perf-tools

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

दूसरे शेल पर:

while true; do sleep 1; date; done

पहला शेल प्रारूप का डेटा दिखाता है:

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

CONFIG_PROC_EVENTS

नमूना सत्र:

$ su
# ./proc_events &
# /proc_events.out &
set mcast listen ok
# sleep 2 & sleep 1 &
fork: parent tid=48 pid=48 -> child tid=56 pid=56
fork: parent tid=48 pid=48 -> child tid=57 pid=57
exec: tid=57 pid=57
exec: tid=56 pid=56
exit: tid=57 pid=57 exit_code=0
exit: tid=56 pid=56 exit_code=0

CONFIG_PROC_EVENTSनेटलिंक सॉकेट के माध्यम से उपयोगकर्तालैंड में होने वाली घटनाओं को उजागर करता है ।

proc_events.c से अनुकूलित: https://bewareofgeek.livejournal.com/2945.html

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

static volatile bool need_exit = false;

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("socket");
        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 *)&sa_nl, sizeof(sa_nl));
    if (rc == -1) {
        perror("bind");
        close(nl_sock);
        return -1;
    }
    return nl_sock;
}

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(&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, &nlcn_msg, sizeof(nlcn_msg), 0);
    if (rc == -1) {
        perror("netlink send");
        return -1;
    }

    return 0;
}

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, &nlcn_msg, sizeof(nlcn_msg), 0);
        if (rc == 0) {
            /* shutdown? */
            return 0;
        } else if (rc == -1) {
            if (errno == EINTR) continue;
            perror("netlink recv");
            return -1;
        }
        switch (nlcn_msg.proc_ev.what) {
            case PROC_EVENT_NONE:
                printf("set mcast listen ok\n");
                break;
            case PROC_EVENT_FORK:
                printf("fork: parent tid=%d pid=%d -> child tid=%d pid=%d\n",
                        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("exec: tid=%d pid=%d\n",
                        nlcn_msg.proc_ev.event_data.exec.process_pid,
                        nlcn_msg.proc_ev.event_data.exec.process_tgid);
                break;
            case PROC_EVENT_UID:
                printf("uid change: tid=%d pid=%d from %d to %d\n",
                        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("gid change: tid=%d pid=%d from %d to %d\n",
                        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("exit: tid=%d pid=%d exit_code=%d\n",
                        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("unhandled proc event\n");
                break;
        }
    }

    return 0;
}

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

int main()
{
    int nl_sock;
    int rc = EXIT_SUCCESS;

    signal(SIGINT, &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);
}

गिटहब अपटस ।

हालाँकि मुझे नहीं लगता कि आप यूआईडी जैसे प्रक्रिया डेटा प्राप्त कर सकते हैं और तर्क वितर्क कर सकते हैं क्योंकि exec_proc_eventइसमें बहुत कम डेटा है: https://github.com/torvalds/linux/blob/v4.16/include/uapi/linux-cn_proc .h # L80 हम इसे तुरंत पढ़ने की कोशिश कर सकते हैं /proc, लेकिन एक जोखिम है कि प्रक्रिया समाप्त हो गई और एक अन्य ने अपना पीआईडी ​​ले लिया, इसलिए यह विश्वसनीय नहीं होगा।

उबुन्टु 17.10 में परीक्षण किया गया।

Answer 6

इसके अलावा, आप उपयोग कर सकते हैं के ऊपर प्रक्रियाओं द्वारा संसाधन उपयोग को देखने के लिए। यह समय के प्रत्येक भाग में संसाधन उपयोग लॉगिंग और विश्लेषण के लिए उपयोगी उपकरण है

Answer 7

आप कोशिश cat ~/.bash_history कर system log viewerसकते हैं, यह आपकी मदद कर सकता है।

Comments

~/.bash_historyकेवल ऐसे आदेश शामिल हैं जिन्हें मैंने एक टर्मिनल में निष्पादित किया है, जाहिरा तौर पर। मैं निष्पादित किए गए सभी कार्यक्रमों की एक लॉग की तलाश कर रहा हूं, उदाहरण के लिए जब मैं अपने ई-मेल क्लाइंट, गेडिट को खोलने के लिए एक आइकन पर क्लिक करता हूं, या मैं अपना ब्राउज़र खोलता हूं, और मेरा ब्राउज़र स्वयं द्वारा एक और प्रक्रिया निष्पादित करता है। new123456 के जवाब ने चाल चली।

— '19

आइए यह भी जोड़ते हैं कि कमांड historyइस जानकारी तक पहुंचने का सामान्य तरीका है।

— bryn