ਯੂਨਿਕਸ-ਵਰਗੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ, ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦਾ ਬਾਹਰੀ ਸੰਸਾਰ ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨਾਲ ਸੰਚਾਰ ਫੰਕਸ਼ਨਾਂ ਦੇ ਇੱਕ ਛੋਟੇ ਸਮੂਹ ਦੁਆਰਾ ਹੁੰਦਾ ਹੈ - ਸਿਸਟਮ ਕਾਲਾਂ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਡੀਬੱਗਿੰਗ ਉਦੇਸ਼ਾਂ ਲਈ ਇਹ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੁਆਰਾ ਚਲਾਈਆਂ ਜਾ ਰਹੀਆਂ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਜਾਸੂਸੀ ਕਰਨਾ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ।

ਇੱਕ ਉਪਯੋਗਤਾ ਤੁਹਾਨੂੰ ਲੀਨਕਸ 'ਤੇ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ "ਅੰਤਰਜਨ ਜੀਵਨ" ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ strace, ਜੋ ਕਿ ਇਸ ਲੇਖ ਦਾ ਵਿਸ਼ਾ ਹੈ। ਜਾਸੂਸੀ ਉਪਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਇੱਕ ਸੰਖੇਪ ਇਤਿਹਾਸ ਦੇ ਨਾਲ ਹਨ strace ਅਤੇ ਅਜਿਹੇ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਡਿਜ਼ਾਈਨ ਦਾ ਵੇਰਵਾ।

ਸਮੱਗਰੀ

• ਸਪੀਸੀਜ਼ ਦਾ ਮੂਲ
• ਸੰਖੇਪ ਵਿੱਚ ਸਟ੍ਰੈਸ ਡਿਵਾਈਸ: ਪਿਗਲੇਟ ਟਰੇਸ
• ਬੁਨਿਆਦ: ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਚੱਲ ਰਿਹਾ strace ਨੂੰ ਚਲਾਉਣਾ
• ਬੁਨਿਆਦ: ਉੱਡਦੇ ਹੋਏ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ
• ਉਦਾਹਰਨ: ਬਾਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨਾ
• ਉਦਾਹਰਨ: ਹੈਂਡਲ ਦੀ ਬਜਾਏ ਫਾਈਲ ਪਾਥ
• ਉਦਾਹਰਨ: ਫਾਈਲ ਐਕਸੈਸ ਟ੍ਰੈਕਿੰਗ
• ਉਦਾਹਰਨ: ਮਲਟੀਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮ
• ਮਾਸਟਰ ਕਲਾਸ: ਸਿਸਟਮ ਕਾਲ ਦੇ ਸਮੇਂ ਪ੍ਰਕਿਰਿਆ ਸਟੈਕ
• ਮਾਸਟਰ ਕਲਾਸ: ਗਲਤੀ ਟੀਕਾ
• ਬਾਅਦ

ਸਪੀਸੀਜ਼ ਦਾ ਮੂਲ

ਯੂਨਿਕਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ OS ਕਰਨਲ ਵਿਚਕਾਰ ਮੁੱਖ ਇੰਟਰਫੇਸ ਸਿਸਟਮ ਕਾਲਾਂ ਹਨ। ਸਿਸਟਮ ਕਾਲ, ਸਾਈਕਲ), ਬਾਹਰੀ ਸੰਸਾਰ ਨਾਲ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਆਪਸੀ ਤਾਲਮੇਲ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਦੁਆਰਾ ਹੁੰਦੀ ਹੈ।

ਪਰ ਯੂਨਿਕਸ ਦੇ ਪਹਿਲੇ ਜਨਤਕ ਸੰਸਕਰਣ ਵਿੱਚ (ਸੰਸਕਰਣ 6 ਯੂਨਿਕਸ, 1975) ਉਪਭੋਗਤਾ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਕੋਈ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕੇ ਨਹੀਂ ਸਨ। ਇਸ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਬੈੱਲ ਲੈਬ ਅਗਲੇ ਸੰਸਕਰਣ (ਸੰਸਕਰਣ 7 ਯੂਨਿਕਸ, 1979) ਨੇ ਇੱਕ ਨਵੀਂ ਸਿਸਟਮ ਕਾਲ ਦਾ ਪ੍ਰਸਤਾਵ ਕੀਤਾ - ptrace.

ptrace ਮੁੱਖ ਤੌਰ 'ਤੇ ਇੰਟਰਐਕਟਿਵ ਡੀਬੱਗਰਾਂ ਲਈ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ 80 ਦੇ ਦਹਾਕੇ ਦੇ ਅੰਤ ਤੱਕ (ਵਪਾਰਕ ਦੇ ਯੁੱਗ ਵਿੱਚ ਸਿਸਟਮ V ਰੀਲੀਜ਼ 4) ਇਸ ਆਧਾਰ 'ਤੇ, ਘੱਟ ਕੇਂਦ੍ਰਿਤ ਡੀਬੱਗਰ—ਸਿਸਟਮ ਕਾਲ ਟਰੇਸਰ—ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਏ ਅਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੇ ਗਏ।

ਪਹਿਲਾ ਸਟਰੇਸ ਦਾ ਉਹੀ ਸੰਸਕਰਣ ਪਾਲ ਕ੍ਰੋਨੇਨਬਰਗ ਦੁਆਰਾ 1992 ਵਿੱਚ ਬੰਦ ਉਪਯੋਗਤਾ ਦੇ ਵਿਕਲਪ ਵਜੋਂ comp.sources.sun ਮੇਲਿੰਗ ਲਿਸਟ ਉੱਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। trace ਸੂਰਜ ਤੋਂ. ਕਲੋਨ ਅਤੇ ਅਸਲੀ ਦੋਵੇਂ ਸਨੋਸ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਸਨ, ਪਰ 1994 ਤੱਕ strace ਸਿਸਟਮ V, ਸੋਲਾਰਿਸ ਅਤੇ ਵਧਦੇ ਪ੍ਰਸਿੱਧ ਲੀਨਕਸ ਲਈ ਪੋਰਟ ਕੀਤਾ ਗਿਆ ਸੀ।

ਅੱਜ ਸਟ੍ਰੈਸ ਸਿਰਫ਼ ਲੀਨਕਸ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਅਤੇ ਉਸੇ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ptrace, ਬਹੁਤ ਸਾਰੇ ਐਕਸਟੈਂਸ਼ਨਾਂ ਨਾਲ ਵਧਿਆ ਹੋਇਆ ਹੈ।

ਆਧੁਨਿਕ (ਅਤੇ ਬਹੁਤ ਸਰਗਰਮ) ਰੱਖ-ਰਖਾਅ ਕਰਨ ਵਾਲਾ strace - ਦਮਿਤਰੀ ਲੇਵਿਨ. ਉਸਦੇ ਲਈ ਧੰਨਵਾਦ, ਉਪਯੋਗਤਾ ਨੇ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ ਜਿਵੇਂ ਕਿ ਸਿਸਟਮ ਕਾਲਾਂ ਵਿੱਚ ਗਲਤੀ ਇੰਜੈਕਸ਼ਨ, ਆਰਕੀਟੈਕਚਰ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਲਈ ਸਮਰਥਨ ਅਤੇ, ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ, ਮਾਸਕੌਟ. ਅਣਅਧਿਕਾਰਤ ਸਰੋਤਾਂ ਦਾ ਦਾਅਵਾ ਹੈ ਕਿ ਰੂਸੀ ਸ਼ਬਦ "ਸ਼ੁਤਰਮੁਰਗ" ਅਤੇ ਅੰਗਰੇਜ਼ੀ ਸ਼ਬਦ "ਸਟਰੇਸ" ਦੇ ਵਿਚਕਾਰ ਵਿਅੰਜਨ ਦੇ ਕਾਰਨ ਚੋਣ ਸ਼ੁਤਰਮੁਰਗ 'ਤੇ ਡਿੱਗ ਗਈ।

ਇਹ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਲੀਨਕਸ, ਫ੍ਰੀਬੀਐਸਡੀ, ਓਪਨਬੀਐਸਡੀ ਅਤੇ ਰਵਾਇਤੀ ਯੂਨਿਕਸ ਵਿੱਚ ਲੰਬੇ ਇਤਿਹਾਸ ਅਤੇ ਲਾਗੂ ਹੋਣ ਦੇ ਬਾਵਜੂਦ, ptrace ਸਿਸਟਮ ਕਾਲ ਅਤੇ ਟਰੇਸਰ ਕਦੇ ਵੀ POSIX ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤੇ ਗਏ ਸਨ।

ਸੰਖੇਪ ਵਿੱਚ ਸਟ੍ਰੈਸ ਡਿਵਾਈਸ: ਪਿਗਲੇਟ ਟਰੇਸ

"ਤੁਹਾਡੇ ਤੋਂ ਇਹ ਸਮਝਣ ਦੀ ਉਮੀਦ ਨਹੀਂ ਹੈ" (ਡੈਨਿਸ ਰਿਚੀ, ਸੰਸਕਰਣ 6 ਯੂਨਿਕਸ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਟਿੱਪਣੀ)

ਬਚਪਨ ਤੋਂ ਹੀ, ਮੈਂ ਬਲੈਕ ਬਾਕਸ ਨੂੰ ਖੜਾ ਨਹੀਂ ਕਰ ਸਕਦਾ: ਮੈਂ ਖਿਡੌਣਿਆਂ ਨਾਲ ਨਹੀਂ ਖੇਡਿਆ, ਪਰ ਉਹਨਾਂ ਦੀ ਬਣਤਰ ਨੂੰ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ (ਬਾਲਗਾਂ ਨੇ "ਟੁੱਟਿਆ" ਸ਼ਬਦ ਵਰਤਿਆ, ਪਰ ਬੁਰਾਈਆਂ 'ਤੇ ਵਿਸ਼ਵਾਸ ਨਾ ਕਰੋ)। ਸ਼ਾਇਦ ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਪਹਿਲੇ ਯੂਨਿਕਸ ਅਤੇ ਆਧੁਨਿਕ ਓਪਨ-ਸੋਰਸ ਅੰਦੋਲਨ ਦਾ ਗੈਰ ਰਸਮੀ ਸੱਭਿਆਚਾਰ ਮੇਰੇ ਬਹੁਤ ਨੇੜੇ ਹੈ।

ਇਸ ਲੇਖ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ, ਸਟ੍ਰੈਸ ਦੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਵੱਖ ਕਰਨਾ ਗੈਰ-ਵਾਜਬ ਹੈ, ਜੋ ਦਹਾਕਿਆਂ ਤੋਂ ਵਧਿਆ ਹੈ। ਪਰ ਪਾਠਕਾਂ ਲਈ ਕੋਈ ਭੇਤ ਨਹੀਂ ਛੱਡਣਾ ਚਾਹੀਦਾ। ਇਸ ਲਈ, ਅਜਿਹੇ ਸਟਰੇਸ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਸੰਚਾਲਨ ਦੇ ਸਿਧਾਂਤ ਨੂੰ ਦਰਸਾਉਣ ਲਈ, ਮੈਂ ਇੱਕ ਛੋਟੇ ਟਰੇਸਰ ਲਈ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ - ਪਿਗਲੇਟ ਟਰੇਸ (ptr)। ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਕੁਝ ਖਾਸ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਪਰ ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਿਸਟਮ ਕਾਲਾਂ - ਇਹ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ:

$ gcc examples/piglet-trace.c -o ptr
$ ptr echo test > /dev/null
BRK(12) -> 94744690540544
ACCESS(21) -> 18446744073709551614
ACCESS(21) -> 18446744073709551614
unknown(257) -> 3
FSTAT(5) -> 0
MMAP(9) -> 140694657216512
CLOSE(3) -> 0
ACCESS(21) -> 18446744073709551614
unknown(257) -> 3
READ(0) -> 832
FSTAT(5) -> 0
MMAP(9) -> 140694657208320
MMAP(9) -> 140694650953728
MPROTECT(10) -> 0
MMAP(9) -> 140694655045632
MMAP(9) -> 140694655070208
CLOSE(3) -> 0
unknown(158) -> 0
MPROTECT(10) -> 0
MPROTECT(10) -> 0
MPROTECT(10) -> 0
MUNMAP(11) -> 0
BRK(12) -> 94744690540544
BRK(12) -> 94744690675712
unknown(257) -> 3
FSTAT(5) -> 0
MMAP(9) -> 140694646390784
CLOSE(3) -> 0
FSTAT(5) -> 0
IOCTL(16) -> 18446744073709551591
WRITE(1) -> 5
CLOSE(3) -> 0
CLOSE(3) -> 0
unknown(231)
Tracee terminated

ਪਿਗਲੇਟ ਟਰੇਸ ਲਗਭਗ ਸੈਂਕੜੇ ਲੀਨਕਸ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਪਛਾਣਦਾ ਹੈ (ਵੇਖੋ. ਮੇਜ਼) ਅਤੇ ਸਿਰਫ਼ x86-64 ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਵਿਦਿਅਕ ਉਦੇਸ਼ਾਂ ਲਈ ਕਾਫੀ ਹੈ।

ਆਓ ਆਪਣੇ ਕਲੋਨ ਦੇ ਕੰਮ ਨੂੰ ਵੇਖੀਏ. ਲੀਨਕਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਡੀਬੱਗਰ ਅਤੇ ਟਰੇਸਰ, ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ptrace ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਹ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਕਮਾਂਡ ਪਛਾਣਕਰਤਾ ਨੂੰ ਪਾਸ ਕਰਕੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਜਿਸਦੀ ਸਾਨੂੰ ਸਿਰਫ਼ ਲੋੜ ਹੈ PTRACE_TRACEME, PTRACE_SYSCALL и PTRACE_GETREGS.

ਟਰੇਸਰ ਆਮ ਯੂਨਿਕਸ ਸ਼ੈਲੀ ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ: fork(2) ਇੱਕ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਜੋ ਬਦਲੇ ਵਿੱਚ ਵਰਤਦਾ ਹੈ exec(3) ਅਧਿਐਨ ਅਧੀਨ ਪ੍ਰੋਗਰਾਮ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਸਿਰਫ ਸੂਖਮਤਾ ਚੁਣੌਤੀ ਹੈ ptrace(PTRACE_TRACEME) перед exec: ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਮਾਤਾ-ਪਿਤਾ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਇਸਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਦੀ ਹੈ:

pid_t child_pid = fork();
switch (child_pid) {
case -1:
    err(EXIT_FAILURE, "fork");
case 0:
    /* Child here */
    /* A traced mode has to be enabled. A parent will have to wait(2) for it
     * to happen. */
    ptrace(PTRACE_TRACEME, 0, NULL, NULL);
    /* Replace itself with a program to be run. */
    execvp(argv[1], argv + 1);
    err(EXIT_FAILURE, "exec");
}

ਮਾਤਾ-ਪਿਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹੁਣ ਕਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ wait(2) ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, ਯਾਨੀ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਟਰੇਸ ਮੋਡ ਵਿੱਚ ਸਵਿਚ ਕਰਨਾ ਹੋਇਆ ਹੈ:

/* Parent */

/* First we wait for the child to set the traced mode (see
 * ptrace(PTRACE_TRACEME) above) */
if (waitpid(child_pid, NULL, 0) == -1)
    err(EXIT_FAILURE, "traceme -> waitpid");

ਇਸ ਸਮੇਂ, ਤਿਆਰੀਆਂ ਪੂਰੀਆਂ ਹੋ ਗਈਆਂ ਹਨ ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਬੇਅੰਤ ਲੂਪ ਵਿੱਚ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਸਿੱਧੇ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹੋ।

ਚੁਣੌਤੀ ptrace(PTRACE_SYSCALL) ਇਸ ਤੋਂ ਬਾਅਦ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ wait ਮਾਤਾ ਜਾਂ ਤਾਂ ਸਿਸਟਮ ਕਾਲ ਦੇ ਐਗਜ਼ੀਕਿਊਟ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂ ਇਸ ਦੇ ਪੂਰਾ ਹੋਣ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਪੂਰਾ ਹੋ ਜਾਵੇਗਾ। ਦੋ ਕਾਲਾਂ ਦੇ ਵਿਚਕਾਰ ਤੁਸੀਂ ਕੋਈ ਵੀ ਕਾਰਵਾਈਆਂ ਕਰ ਸਕਦੇ ਹੋ: ਕਾਲ ਨੂੰ ਕਿਸੇ ਵਿਕਲਪਕ ਨਾਲ ਬਦਲੋ, ਆਰਗੂਮੈਂਟਸ ਜਾਂ ਵਾਪਸੀ ਮੁੱਲ ਬਦਲੋ।

ਸਾਨੂੰ ਸਿਰਫ਼ ਦੋ ਵਾਰ ਕਮਾਂਡ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ptrace(PTRACE_GETREGS)ਰਜਿਸਟਰ ਰਾਜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ rax ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ (ਸਿਸਟਮ ਕਾਲ ਨੰਬਰ) ਅਤੇ ਤੁਰੰਤ ਬਾਅਦ (ਵਾਪਸੀ ਮੁੱਲ)।

ਅਸਲ ਵਿੱਚ, ਚੱਕਰ:

/* A system call tracing loop, one interation per call. */
for (;;) {
    /* A non-portable structure defined for ptrace/GDB/strace usage mostly.
     * It allows to conveniently dump and access register state using
     * ptrace. */
    struct user_regs_struct registers;

    /* Enter syscall: continue execution until the next system call
     * beginning. Stop right before syscall.
     *
     * It's possible to change the system call number, system call
     * arguments, return value or even avoid executing the system call
     * completely. */
  if (ptrace(PTRACE_SYSCALL, child_pid, NULL, NULL) == -1)
      err(EXIT_FAILURE, "enter_syscall");
  if (waitpid(child_pid, NULL, 0) == -1)
      err(EXIT_FAILURE, "enter_syscall -> waitpid");

  /* According to the x86-64 system call convention on Linux (see man 2
   * syscall) the number identifying a syscall should be put into the rax
   * general purpose register, with the rest of the arguments residing in
   * other general purpose registers (rdi,rsi, rdx, r10, r8, r9). */
  if (ptrace(PTRACE_GETREGS, child_pid, NULL, &registers) == -1)
      err(EXIT_FAILURE, "enter_syscall -> getregs");

  /* Note how orig_rax is used here. That's because on x86-64 rax is used
   * both for executing a syscall, and returning a value from it. To
   * differentiate between the cases both rax and orig_rax are updated on
   * syscall entry/exit, and only rax is updated on exit. */
  print_syscall_enter(registers.orig_rax);

  /* Exit syscall: execute of the syscall, and stop on system
   * call exit.
   *
   * More system call tinkering possible: change the return value, record
   * time it took to finish the system call, etc. */
  if (ptrace(PTRACE_SYSCALL, child_pid, NULL, NULL) == -1)
      err(EXIT_FAILURE, "exit_syscall");
  if (waitpid(child_pid, NULL, 0) == -1)
      err(EXIT_FAILURE, "exit_syscall -> waitpid");

  /* Retrieve register state again as we want to inspect system call
   * return value. */
  if (ptrace(PTRACE_GETREGS, child_pid, NULL, &registers) == -1) {
      /* ESRCH is returned when a child terminates using a syscall and no
       * return value is possible, e.g. as a result of exit(2). */
      if (errno == ESRCH) {
          fprintf(stderr, "nTracee terminatedn");
          break;
      }
      err(EXIT_FAILURE, "exit_syscall -> getregs");
  }

  /* Done with this system call, let the next iteration handle the next
   * one */
  print_syscall_exit(registers.rax);
}

ਇਹ ਸਾਰਾ ਟਰੇਸਰ ਹੈ। ਹੁਣ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਅਗਲੀ ਪੋਰਟਿੰਗ ਕਿੱਥੋਂ ਸ਼ੁਰੂ ਕਰਨੀ ਹੈ ਡੀਟਰੇਸ ਲੀਨਕਸ 'ਤੇ.

ਬੁਨਿਆਦ: ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਚੱਲ ਰਿਹਾ strace ਨੂੰ ਚਲਾਉਣਾ

ਪਹਿਲੀ ਵਰਤੋਂ ਦੇ ਕੇਸ ਵਜੋਂ strace, ਸ਼ਾਇਦ ਇਹ ਸਭ ਤੋਂ ਸਰਲ ਵਿਧੀ ਦਾ ਹਵਾਲਾ ਦੇਣ ਦੇ ਯੋਗ ਹੈ - ਚੱਲ ਰਹੀ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਂਚ ਕਰਨਾ strace.

ਇੱਕ ਆਮ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਕਾਲਾਂ ਦੀ ਬੇਅੰਤ ਸੂਚੀ ਵਿੱਚ ਨਾ ਜਾਣ ਲਈ, ਅਸੀਂ ਲਿਖਦੇ ਹਾਂ ਘੱਟੋ-ਘੱਟ ਪ੍ਰੋਗਰਾਮ ਆਲੇ ਦੁਆਲੇ write:

int main(int argc, char *argv[])
{
    char str[] = "write me to stdoutn";
    /* write(2) is a simple wrapper around a syscall so it should be easy to
     * find in the syscall trace. */
    if (sizeof(str) != write(STDOUT_FILENO, str, sizeof(str))){
        perror("write");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

ਆਉ ਪ੍ਰੋਗਰਾਮ ਬਣਾਉ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ:

$ gcc examples/write-simple.c -o write-simple
$ ./write-simple
write me to stdout

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਆਓ ਇਸਨੂੰ ਸਟ੍ਰੈਸ ਨਿਯੰਤਰਣ ਵਿੱਚ ਚਲਾਈਏ:

$ strace ./write-simple
pexecve("./write", ["./write"], 0x7ffebd6145b0 /* 71 vars */) = 0
brk(NULL)                               = 0x55ff5489e000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=197410, ...}) = 0
mmap(NULL, 197410, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f7a2a633000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "177ELF21133>1260342"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7a2a631000
mmap(NULL, 4131552, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f7a2a04c000
mprotect(0x7f7a2a233000, 2097152, PROT_NONE) = 0
mmap(0x7f7a2a433000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1e7000) = 0x7f7a2a433000
mmap(0x7f7a2a439000, 15072, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f7a2a439000
close(3)                                = 0
arch_prctl(ARCH_SET_FS, 0x7f7a2a6324c0) = 0
mprotect(0x7f7a2a433000, 16384, PROT_READ) = 0
mprotect(0x55ff52b52000, 4096, PROT_READ) = 0
mprotect(0x7f7a2a664000, 4096, PROT_READ) = 0
munmap(0x7f7a2a633000, 197410)          = 0
write(1, "write me to stdoutn", 20write me to stdout
)  = 20
exit_group(0)                           = ?

ਬਹੁਤ "ਸ਼ਬਦ" ਅਤੇ ਬਹੁਤ ਵਿਦਿਅਕ ਨਹੀਂ। ਇੱਥੇ ਦੋ ਸਮੱਸਿਆਵਾਂ ਹਨ: ਪ੍ਰੋਗਰਾਮ ਆਉਟਪੁੱਟ ਨੂੰ ਆਉਟਪੁੱਟ ਨਾਲ ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ strace ਅਤੇ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਬਹੁਤਾਤ ਜੋ ਸਾਡੀ ਦਿਲਚਸਪੀ ਨਹੀਂ ਰੱਖਦੇ।

ਤੁਸੀਂ -o ਸਵਿੱਚ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਅਤੇ ਸਟ੍ਰੈਸ ਐਰਰ ਆਉਟਪੁੱਟ ਨੂੰ ਵੱਖ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਫਾਈਲ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕਰਦਾ ਹੈ।

ਇਹ "ਵਾਧੂ" ਕਾਲਾਂ ਦੀ ਸਮੱਸਿਆ ਨਾਲ ਨਜਿੱਠਣਾ ਬਾਕੀ ਹੈ। ਚਲੋ ਇਹ ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਸਿਰਫ ਕਾਲਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ write. ਕੁੰਜੀ -e ਤੁਹਾਨੂੰ ਸਮੀਕਰਨ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਿਸ ਦੁਆਰਾ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਫਿਲਟਰ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਸਥਿਤੀ ਵਿਕਲਪ ਹੈ, ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, trace=*, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਕਾਲਾਂ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ ਜੋ ਸਾਡੀ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਨ।

ਜਦੋਂ ਇੱਕੋ ਸਮੇਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ -o и -e ਸਾਨੂੰ ਮਿਲੇਗਾ:

$ strace -e trace=write -owrite-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
write(1, "write me to stdoutn", 20
)  = 20
+++ exited with 0 +++

ਇਸ ਲਈ, ਤੁਸੀਂ ਦੇਖੋ, ਇਹ ਪੜ੍ਹਨਾ ਬਹੁਤ ਸੌਖਾ ਹੈ.

ਤੁਸੀਂ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਵੀ ਹਟਾ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ ਜੋ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਖਾਲੀ ਕਰਨ ਨਾਲ ਸਬੰਧਤ ਹਨ:

$ strace -e trace=!brk,mmap,mprotect,munmap -owrite-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
execve("./write-simple", ["./write-simple"], 0x7ffe9972a498 /* 69 vars */) = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=124066, ...}) = 0
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "177ELF21133>1260342"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, ...}) = 0
close(3)                                = 0
arch_prctl(ARCH_SET_FS, 0x7f00f0be74c0) = 0
write(1, "write me to stdoutn", 20)  = 20
exit_group(0)                           = ?
+++ exited with 0 +++

ਕੱਢੀਆਂ ਗਈਆਂ ਕਾਲਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਬਚੇ ਵਿਸਮਿਕ ਚਿੰਨ੍ਹ ਨੂੰ ਨੋਟ ਕਰੋ: ਇਹ ਕਮਾਂਡ ਸ਼ੈੱਲ ਦੁਆਰਾ ਲੋੜੀਂਦਾ ਹੈ। ਸ਼ੈੱਲ).

glibc ਦੇ ਮੇਰੇ ਸੰਸਕਰਣ ਵਿੱਚ, ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰ ਦਿੰਦੀ ਹੈ exit_group, ਰਵਾਇਤੀ ਨਹੀਂ _exit. ਇਹ ਸਿਸਟਮ ਕਾਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਮੁਸ਼ਕਲ ਹੈ: ਇੰਟਰਫੇਸ ਜਿਸ ਨਾਲ ਪ੍ਰੋਗਰਾਮਰ ਕੰਮ ਕਰਦਾ ਹੈ, ਸਿਸਟਮ ਕਾਲਾਂ ਨਾਲ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਲਾਗੂ ਕਰਨ ਅਤੇ ਪਲੇਟਫਾਰਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਬਦਲਦਾ ਹੈ।

ਬੁਨਿਆਦ: ਉੱਡਦੇ ਹੋਏ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ

ਸ਼ੁਰੂ ਵਿੱਚ, ptrace ਸਿਸਟਮ ਕਾਲ ਜਿਸ 'ਤੇ ਇਸ ਨੂੰ ਬਣਾਇਆ ਗਿਆ ਸੀ strace, ਸਿਰਫ ਉਦੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੋਡ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਰਿਹਾ ਹੋਵੇ। ਸੰਸਕਰਣ 6 ਯੂਨਿਕਸ ਦੇ ਦਿਨਾਂ ਵਿੱਚ ਇਹ ਸੀਮਾ ਵਾਜਬ ਲੱਗ ਸਕਦੀ ਹੈ। ਅੱਜਕੱਲ੍ਹ, ਇਹ ਹੁਣ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ: ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਕਾਰਜਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇੱਕ ਖਾਸ ਉਦਾਹਰਨ ਹੈਂਡਲ ਜਾਂ ਸਲੀਪਿੰਗ 'ਤੇ ਬਲੌਕ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਹੈ। ਇਸ ਲਈ ਆਧੁਨਿਕ strace ਫਲਾਈ 'ਤੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ।

ਠੰਢਕ ਦੀ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ:

int main(int argc, char *argv[])
{
    (void) argc; (void) argv;

    char str[] = "write men";

    write(STDOUT_FILENO, str, sizeof(str));

    /* Sleep indefinitely or until a signal arrives */
    pause();

    write(STDOUT_FILENO, str, sizeof(str));

    return EXIT_SUCCESS;
}

ਆਉ ਪ੍ਰੋਗਰਾਮ ਬਣਾਉ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਇਹ ਜੰਮਿਆ ਹੋਇਆ ਹੈ:

$ gcc examples/write-sleep.c -o write-sleep
$ ./write-sleep
./write-sleep
write me
^C
$

ਆਓ ਹੁਣ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

$ ./write-sleep &
[1] 15329
write me
$ strace -p 15329
strace: Process 15329 attached
pause(
^Cstrace: Process 15329 detached
 <detached ...>

ਪ੍ਰੋਗਰਾਮ ਕਾਲ ਦੁਆਰਾ ਬਲੌਕ ਕੀਤਾ ਗਿਆ pause. ਆਓ ਦੇਖੀਏ ਕਿ ਉਹ ਸਿਗਨਲਾਂ 'ਤੇ ਕਿਵੇਂ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦੀ ਹੈ:

$ strace -o write-sleep.log -p 15329 &
strace: Process 15329 attached
$
$ kill -CONT 15329
$ cat write-sleep.log
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGCONT {si_signo=SIGCONT, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
pause(
$
$ kill -TERM 15329
$ cat write-sleep.log
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGCONT {si_signo=SIGCONT, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGTERM {si_signo=SIGTERM, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
+++ killed by SIGTERM +++

ਅਸੀਂ ਫ੍ਰੀਜ਼ ਕੀਤੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲਾਂਚ ਕੀਤਾ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸ਼ਾਮਲ ਹੋਏ strace. ਦੋ ਗੱਲਾਂ ਸਪੱਸ਼ਟ ਹੋ ਗਈਆਂ: ਵਿਰਾਮ ਸਿਸਟਮ ਕਾਲ ਹੈਂਡਲਰ ਤੋਂ ਬਿਨਾਂ ਸਿਗਨਲਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦੀ ਹੈ ਅਤੇ, ਵਧੇਰੇ ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ, ਸਟ੍ਰੈਸ ਮਾਨੀਟਰ ਨਾ ਸਿਰਫ ਸਿਸਟਮ ਕਾਲਾਂ, ਬਲਕਿ ਆਉਣ ਵਾਲੇ ਸਿਗਨਲਾਂ ਨੂੰ ਵੀ।

ਉਦਾਹਰਨ: ਬਾਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨਾ

ਇੱਕ ਕਾਲ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ fork - ਸਾਰੇ ਯੂਨਿਕਸ ਦਾ ਆਧਾਰ. ਆਉ ਵੇਖੀਏ ਕਿ ਸਟ੍ਰੈਸ ਇੱਕ ਸਧਾਰਨ "ਬ੍ਰੀਡਿੰਗ" ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਰੁੱਖ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਪ੍ਰੋਗਰਾਮ:

int main(int argc, char *argv[])
{
    pid_t parent_pid = getpid();
    pid_t child_pid = fork();
    if (child_pid == 0) {
        /* A child is born! */
        child_pid = getpid();

        /* In the end of the day printf is just a call to write(2). */
        printf("child (self=%d)n", child_pid);
        exit(EXIT_SUCCESS);
    }

    printf("parent (self=%d, child=%d)n", parent_pid, child_pid);

    wait(NULL);

    exit(EXIT_SUCCESS);
}

ਇੱਥੇ ਮੂਲ ਪ੍ਰਕਿਰਿਆ ਇੱਕ ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਂਦੀ ਹੈ, ਦੋਵੇਂ ਸਟੈਂਡਰਡ ਆਉਟਪੁੱਟ ਨੂੰ ਲਿਖਦੇ ਹਨ:

$ gcc examples/fork-write.c -o fork-write
$ ./fork-write
parent (self=11274, child=11275)
child (self=11275)

ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ ਪੇਰੈਂਟ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਦੇਖਾਂਗੇ:

$ strace -e trace=write -ofork-write.log ./fork-write
child (self=22049)
parent (self=22048, child=22049)
$ cat fork-write.log
write(1, "parent (self=22048, child=22049)"..., 33) = 33
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=22049, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
+++ exited with 0 +++

ਫਲੈਗ ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਰੁੱਖ ਨੂੰ ਟਰੈਕ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਦਾ ਹੈ -f, ਜੋ strace ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ। ਇਹ ਆਉਟਪੁੱਟ ਦੀ ਹਰੇਕ ਲਾਈਨ ਨੂੰ ਜੋੜਦਾ ਹੈ pid ਪ੍ਰਕਿਰਿਆ ਜੋ ਸਿਸਟਮ ਆਉਟਪੁੱਟ ਬਣਾਉਂਦੀ ਹੈ:

$ strace -f -e trace=write -ofork-write.log ./fork-write
parent (self=22710, child=22711)
child (self=22711)
$ cat fork-write.log
22710 write(1, "parent (self=22710, child=22711)"..., 33) = 33
22711 write(1, "child (self=22711)n", 19) = 19
22711 +++ exited with 0 +++
22710 --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=22711, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
22710 +++ exited with 0 +++

ਇਸ ਸੰਦਰਭ ਵਿੱਚ, ਸਿਸਟਮ ਕਾਲਾਂ ਦੇ ਸਮੂਹ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰਨਾ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ:

$ strace -f -e trace=%process -ofork-write.log ./fork-write
parent (self=23610, child=23611)
child (self=23611)
$ cat fork-write.log
23610 execve("./fork-write", ["./fork-write"], 0x7fff696ff720 /* 63 vars */) = 0
23610 arch_prctl(ARCH_SET_FS, 0x7f3d03ba44c0) = 0
23610 clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f3d03ba4790) = 23611
23610 wait4(-1,  <unfinished ...>
23611 exit_group(0)                     = ?
23611 +++ exited with 0 +++
23610 <... wait4 resumed> NULL, 0, NULL) = 23611
23610 --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=23611, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
23610 exit_group(0)                     = ?
23610 +++ exited with 0 +++

ਤਰੀਕੇ ਨਾਲ, ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਲਈ ਕਿਹੜੀ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ?

ਉਦਾਹਰਨ: ਹੈਂਡਲ ਦੀ ਬਜਾਏ ਫਾਈਲ ਪਾਥ

ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰਾਂ ਨੂੰ ਜਾਣਨਾ ਨਿਸ਼ਚਤ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਖਾਸ ਫਾਈਲਾਂ ਦੇ ਨਾਮ ਜਿਨ੍ਹਾਂ ਨੂੰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਐਕਸੈਸ ਕਰਦਾ ਹੈ ਉਹ ਵੀ ਕੰਮ ਵਿੱਚ ਆ ਸਕਦੇ ਹਨ।

ਅਗਲਾ ਪ੍ਰੋਗਰਾਮ ਆਰਜ਼ੀ ਫਾਈਲ ਵਿੱਚ ਲਾਈਨ ਲਿਖਦਾ ਹੈ:

void do_write(int out_fd)
{
    char str[] = "write me to a filen";

    if (sizeof(str) != write(out_fd, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    char tmp_filename_template[] = "/tmp/output_fileXXXXXX";

    int out_fd = mkstemp(tmp_filename_template);
    if (out_fd == -1) {
        perror("mkstemp");
        exit(EXIT_FAILURE);
    }

    do_write(out_fd);

    return EXIT_SUCCESS;
}

ਇੱਕ ਆਮ ਕਾਲ ਦੌਰਾਨ strace ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਪਾਸ ਕੀਤੇ ਡਿਸਕ੍ਰਿਪਟਰ ਨੰਬਰ ਦਾ ਮੁੱਲ ਦਿਖਾਏਗਾ:

$ strace -e trace=write -o write-tmp-file.log ./write-tmp-file
$ cat write-tmp-file.log
write(3, "write me to a filen", 20)  = 20
+++ exited with 0 +++

ਝੰਡੇ ਨਾਲ -y ਉਪਯੋਗਤਾ ਫਾਈਲ ਦਾ ਮਾਰਗ ਦਰਸਾਉਂਦੀ ਹੈ ਜਿਸ ਨਾਲ ਵਰਣਨਕਰਤਾ ਅਨੁਸਾਰੀ ਹੈ:

$ strace -y -e trace=write -o write-tmp-file.log ./write-tmp-file
$ cat write-tmp-file.log
write(3</tmp/output_fileCf5MyW>, "write me to a filen", 20) = 20
+++ exited with 0 +++

ਉਦਾਹਰਨ: ਫਾਈਲ ਐਕਸੈਸ ਟ੍ਰੈਕਿੰਗ

ਇੱਕ ਹੋਰ ਉਪਯੋਗੀ ਵਿਸ਼ੇਸ਼ਤਾ: ਇੱਕ ਖਾਸ ਫਾਈਲ ਨਾਲ ਸੰਬੰਧਿਤ ਸਿਰਫ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ। ਅਗਲਾ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਪਾਸ ਕੀਤੀ ਇੱਕ ਆਰਬਿਟਰਰੀ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਲਾਈਨ ਜੋੜਦਾ ਹੈ:

void do_write(int out_fd)
{
    char str[] = "write me to a filen";

    if (sizeof(str) != write(out_fd, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    /*
     * Path will be provided by the first program argument.
     *  */
    const char *path = argv[1];

    /*
     * Open an existing file for writing in append mode.
     *  */
    int out_fd = open(path, O_APPEND | O_WRONLY);
    if (out_fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    do_write(out_fd);

    return EXIT_SUCCESS;
}

ਮੂਲ ਰੂਪ ਵਿੱਚ strace ਬਹੁਤ ਸਾਰੀ ਬੇਲੋੜੀ ਜਾਣਕਾਰੀ ਦਿਖਾਉਂਦਾ ਹੈ। ਝੰਡਾ -P ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਨਾਲ ਸਟਰੇਸ ਸਿਰਫ ਨਿਰਧਾਰਤ ਫਾਈਲ ਲਈ ਕਾਲਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ:

$ strace -y -P/tmp/test_file.log -o write-file.log ./write-file /tmp/test_file.log
$ cat write-file.log
openat(AT_FDCWD, "/tmp/test_file.log", O_WRONLY|O_APPEND) = 3</tmp/test_file.log>
write(3</tmp/test_file.log>, "write me to a filen", 20) = 20
+++ exited with 0 +++

ਉਦਾਹਰਨ: ਮਲਟੀਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮ

ਉਪਯੋਗਤਾ strace ਮਲਟੀ-ਥ੍ਰੈਡਡ ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਵੀ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ਪ੍ਰੋਗਰਾਮ. ਨਿਮਨਲਿਖਤ ਪ੍ਰੋਗਰਾਮ ਦੋ ਧਾਰਾਵਾਂ ਤੋਂ ਮਿਆਰੀ ਆਉਟਪੁੱਟ ਨੂੰ ਲਿਖਦਾ ਹੈ:

void *thread(void *arg)
{
    (void) arg;

    printf("Secondary thread: workingn");
    sleep(1);
    printf("Secondary thread: donen");

    return NULL;
}

int main(int argc, char *argv[])
{
    printf("Initial thread: launching a threadn");

    pthread_t thr;
    if (0 != pthread_create(&thr, NULL, thread, NULL)) {
        fprintf(stderr, "Initial thread: failed to create a thread");
        exit(EXIT_FAILURE);
    }

    printf("Initial thread: joining a threadn");
    if (0 != pthread_join(thr, NULL)) {
        fprintf(stderr, "Initial thread: failed to join a thread");
        exit(EXIT_FAILURE);
    };

    printf("Initial thread: done");

    exit(EXIT_SUCCESS);
}

ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਇਸ ਨੂੰ ਲਿੰਕਰ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਨਮਸਕਾਰ ਦੇ ਨਾਲ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ - the -pthread ਫਲੈਗ:

$ gcc examples/thread-write.c -pthread -o thread-write
$ ./thread-write
/thread-write
Initial thread: launching a thread
Initial thread: joining a thread
Secondary thread: working
Secondary thread: done
Initial thread: done
$

ਫਲੈਗ -f, ਜਿਵੇਂ ਕਿ ਨਿਯਮਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਹਰੇਕ ਲਾਈਨ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਦੇ pid ਨੂੰ ਜੋੜ ਦੇਵੇਗਾ।

ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਪੋਸਿਕਸ ਥ੍ਰੈਡਸ ਸਟੈਂਡਰਡ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਅਰਥਾਂ ਵਿੱਚ ਇੱਕ ਥ੍ਰੈਡ ਪਛਾਣਕਰਤਾ ਬਾਰੇ ਗੱਲ ਨਹੀਂ ਕਰ ਰਹੇ ਹਾਂ, ਪਰ ਲੀਨਕਸ ਵਿੱਚ ਟਾਸਕ ਸ਼ਡਿਊਲਰ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਸੰਖਿਆ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ। ਬਾਅਦ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇੱਥੇ ਕੋਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਥਰਿੱਡ ਨਹੀਂ ਹਨ - ਅਜਿਹੇ ਕਾਰਜ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮਸ਼ੀਨ ਦੇ ਉਪਲਬਧ ਕੋਰਾਂ ਵਿੱਚ ਵੰਡਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਮਲਟੀਪਲ ਥਰਿੱਡਾਂ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਸਿਸਟਮ ਕਾਲਾਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੋ ਜਾਂਦੀਆਂ ਹਨ:

$ strace -f -othread-write.log ./thread-write
$ wc -l thread-write.log
60 thread-write.log

ਆਪਣੇ ਆਪ ਨੂੰ ਪ੍ਰੋਸੈਸ ਮੈਨੇਜਮੈਂਟ ਅਤੇ ਸਿਸਟਮ ਕਾਲਾਂ ਤੱਕ ਹੀ ਸੀਮਤ ਕਰਨਾ ਸਮਝਦਾਰ ਹੈ write:

$ strace -f -e trace="%process,write" -othread-write.log ./thread-write
$ cat thread-write.log
18211 execve("./thread-write", ["./thread-write"], 0x7ffc6b8d58f0 /* 64 vars */) = 0
18211 arch_prctl(ARCH_SET_FS, 0x7f38ea3b7740) = 0
18211 write(1, "Initial thread: launching a thre"..., 35) = 35
18211 clone(child_stack=0x7f38e9ba2fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f38e9ba39d0, tls=0x7f38e9ba3700, child_tidptr=0x7f38e9ba39d0) = 18212
18211 write(1, "Initial thread: joining a thread"..., 33) = 33
18212 write(1, "Secondary thread: workingn", 26) = 26
18212 write(1, "Secondary thread: donen", 23) = 23
18212 exit(0)                           = ?
18212 +++ exited with 0 +++
18211 write(1, "Initial thread: done", 20) = 20
18211 exit_group(0)                     = ?
18211 +++ exited with 0 +++

ਤਰੀਕੇ ਨਾਲ, ਸਵਾਲ. ਨਵਾਂ ਥਰਿੱਡ ਬਣਾਉਣ ਲਈ ਕਿਹੜੀ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ? ਥ੍ਰੈਡਸ ਲਈ ਇਹ ਕਾਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਕਾਲ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰੀ ਹੈ?

ਮਾਸਟਰ ਕਲਾਸ: ਸਿਸਟਮ ਕਾਲ ਦੇ ਸਮੇਂ ਪ੍ਰਕਿਰਿਆ ਸਟੈਕ

ਹਾਲ ਹੀ ਵਿੱਚ ਪ੍ਰਗਟ ਹੋਏ ਵਿੱਚੋਂ ਇੱਕ strace ਸਮਰੱਥਾਵਾਂ - ਸਿਸਟਮ ਕਾਲ ਦੇ ਸਮੇਂ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਦੇ ਸਟੈਕ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ। ਆਸਾਨ ਉਦਾਹਰਨ:

void do_write(void)
{
    char str[] = "write me to stdoutn";
    if (sizeof(str) != write(STDOUT_FILENO, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    do_write();
    return EXIT_SUCCESS;
}

ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਪ੍ਰੋਗਰਾਮ ਦੀ ਆਉਟਪੁੱਟ ਬਹੁਤ ਵੱਡੀ ਹੋ ਜਾਂਦੀ ਹੈ, ਅਤੇ, ਫਲੈਗ ਤੋਂ ਇਲਾਵਾ -k (ਕਾਲ ਸਟੈਕ ਡਿਸਪਲੇਅ), ਇਹ ਨਾਮ ਦੁਆਰਾ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦਾ ਅਰਥ ਰੱਖਦਾ ਹੈ:

$ gcc examples/write-simple.c -o write-simple
$ strace -k -e trace=write -o write-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
write(1, "write me to stdoutn", 20)  = 20
 > /lib/x86_64-linux-gnu/libc-2.27.so(__write+0x14) [0x110154]
 > /home/vkazanov/projects-my/strace-post/write-simple(do_write+0x50) [0x78a]
 > /home/vkazanov/projects-my/strace-post/write-simple(main+0x14) [0x7d1]
 > /lib/x86_64-linux-gnu/libc-2.27.so(__libc_start_main+0xe7) [0x21b97]
 > /home/vkazanov/projects-my/strace-post/write-simple(_start+0x2a) [0x65a]
+++ exited with 0 +++

ਮਾਸਟਰ ਕਲਾਸ: ਗਲਤੀ ਟੀਕਾ

ਅਤੇ ਇੱਕ ਹੋਰ ਨਵੀਂ ਅਤੇ ਬਹੁਤ ਉਪਯੋਗੀ ਵਿਸ਼ੇਸ਼ਤਾ: ਗਲਤੀ ਟੀਕਾ. ਇਥੇ ਪ੍ਰੋਗਰਾਮ, ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਲਈ ਦੋ ਲਾਈਨਾਂ ਲਿਖਣਾ:

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

void do_write(const char *str, ssize_t len)
{
    if (len != write(STDOUT_FILENO, str, (size_t)len)){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    (void) argc; (void) argv;

    char str1[] = "write me 1n";
    do_write(str1, sizeof(str1));

    char str2[] = "write me 2n";
    do_write(str2, sizeof(str2));

    return EXIT_SUCCESS;
}

ਆਉ ਦੋਨੋਂ ਲਿਖਤੀ ਕਾਲਾਂ ਨੂੰ ਟਰੇਸ ਕਰੀਏ:

$ gcc examples/write-twice.c -o write-twice
$ ./write-twice
write me 1
write me 2
$ strace -e trace=write -owrite-twice.log ./write-twice
write me 1
write me 2
$ cat write-twice.log
write(1, "write me 1n", 12)          = 12
write(1, "write me 2n", 12)          = 12
+++ exited with 0 +++

ਹੁਣ ਅਸੀਂ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ injectਇੱਕ ਗਲਤੀ ਪਾਉਣ ਲਈ EBADF ਸਾਰੀਆਂ ਲਿਖਤੀ ਕਾਲਾਂ ਵਿੱਚ:

$ strace -e trace=write -e inject=write:error=EBADF -owrite-twice.log ./write-twice
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = -1 EBADF (Bad file descriptor) (INJECTED)
+++ exited with 1 +++

ਇਹ ਦਿਲਚਸਪ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਗਲਤੀਆਂ ਵਾਪਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਸਾਰੇ ਚੁਣੌਤੀਆਂ write, ਪੀਰ ਦੇ ਪਿੱਛੇ ਛੁਪੀ ਹੋਈ ਕਾਲ ਸਮੇਤ। ਇਹ ਸਿਰਫ ਪਹਿਲੀ ਕਾਲ ਲਈ ਇੱਕ ਗਲਤੀ ਵਾਪਸ ਕਰਨ ਲਈ ਸਮਝਦਾ ਹੈ:

$ strace -e trace=write -e inject=write:error=EBADF:when=1 -owrite-twice.log ./write-twice
write: Bad file descriptor
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = 27
+++ exited with 1 +++

ਜਾਂ ਦੂਜਾ:

$ strace -e trace=write -e inject=write:error=EBADF:when=2 -owrite-twice.log ./write-twice
write me 1
write: Bad file descriptor
$ cat write-twice.log
write(1, "write me 1n", 12)          = 12
write(1, "write me 2n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = 27
+++ exited with 1 +++

ਗਲਤੀ ਦੀ ਕਿਸਮ ਨਿਰਧਾਰਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ:

$ strace -e trace=write -e fault=write:when=1 -owrite-twice.log ./write-twice
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 ENOSYS (Function not implemented) (INJECTED)
write(3, "write: Function not implementedn", 32) = 32
+++ exited with 1 +++

ਹੋਰ ਫਲੈਗਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਫਾਈਲ ਤੱਕ ਪਹੁੰਚ ਨੂੰ "ਬ੍ਰੇਕ" ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ:

$ strace -y -P/tmp/test_file.log -e inject=file:error=ENOENT -o write-file.log ./write-file /tmp/test_file.log
open: No such file or directory
$ cat write-file.log
openat(AT_FDCWD, "/tmp/test_file.log", O_WRONLY|O_APPEND) = -1 ENOENT (No such file or directory) (INJECTED)
+++ exited with 1 +++

ਗਲਤੀ ਇੰਜੈਕਸ਼ਨ ਤੋਂ ਇਲਾਵਾ, ਹੋ ਸਕਦਾ ਹੈ ਕਾਲਾਂ ਕਰਨ ਜਾਂ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰਨ ਵੇਲੇ ਦੇਰੀ ਸ਼ੁਰੂ ਕਰੋ।

ਬਾਅਦ

ਉਪਯੋਗਤਾ strace - ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਭਰੋਸੇਮੰਦ ਸਾਧਨ. ਪਰ ਸਿਸਟਮ ਕਾਲਾਂ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸੰਚਾਲਨ ਦੇ ਹੋਰ ਪਹਿਲੂਆਂ ਨੂੰ ਡੀਬੱਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਲਿੰਕਡ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਕਾਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰ ਸਕਦਾ ਹੈ। ltrace, ਉਹ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸੰਚਾਲਨ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹਨ ਸਿਸਟਮਟੈਪ и ftrace, ਅਤੇ ਤੁਹਾਨੂੰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਡੂੰਘਾਈ ਨਾਲ ਜਾਂਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਸੰਪੂਰਣ. ਫਿਰ ਵੀ, ਇਹ ਹੈ strace - ਮੇਰੇ ਆਪਣੇ ਅਤੇ ਹੋਰ ਲੋਕਾਂ ਦੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਬਚਾਅ ਦੀ ਪਹਿਲੀ ਲਾਈਨ, ਅਤੇ ਮੈਂ ਇਸਨੂੰ ਹਫ਼ਤੇ ਵਿੱਚ ਘੱਟੋ ਘੱਟ ਦੋ ਵਾਰ ਵਰਤਦਾ ਹਾਂ.

ਸੰਖੇਪ ਵਿੱਚ, ਜੇ ਤੁਸੀਂ ਯੂਨਿਕਸ ਨੂੰ ਪਿਆਰ ਕਰਦੇ ਹੋ, ਪੜ੍ਹੋ man 1 strace ਅਤੇ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮਾਂ 'ਤੇ ਝਾਤ ਮਾਰਨ ਲਈ ਸੁਤੰਤਰ ਮਹਿਸੂਸ ਕਰੋ!

ਸਰੋਤ: www.habr.com