បំបាត់កំហុស ការដាក់ពង្រាយកម្មវិធីជាមួយ strace

ការងារប្រចាំថ្ងៃរបស់ខ្ញុំភាគច្រើនគឺការដាក់ឱ្យប្រើប្រាស់កម្មវិធី ដែលមានន័យថាខ្ញុំចំណាយពេលច្រើនក្នុងការព្យាយាមឆ្លើយសំណួរដូចជា៖

• កម្មវិធីនេះដំណើរការសម្រាប់អ្នកអភិវឌ្ឍន៍ ប៉ុន្តែមិនមែនសម្រាប់ខ្ញុំទេ។ ហេតុអ្វី?
• ម្សិលមិញ កម្មវិធីនេះដំណើរការសម្រាប់ខ្ញុំ ប៉ុន្តែថ្ងៃនេះវាមិនដំណើរការទេ។ ហេតុអ្វី?

នេះគឺជាប្រភេទនៃការបំបាត់កំហុសដែលខុសពីការកែកំហុសកម្មវិធីធម្មតា។ ការបំបាត់កំហុសជាទៀងទាត់គឺនិយាយអំពីតក្កវិជ្ជានៃកូដ ប៉ុន្តែការបំបាត់កំហុសនៃការដាក់ពង្រាយគឺនិយាយអំពីអន្តរកម្មរវាងកូដ និងបរិស្ថាន។ ទោះបីជាឫសគល់នៃបញ្ហាគឺជាកំហុសឡូជីខលក៏ដោយ ការពិតដែលថាអ្វីៗដំណើរការលើម៉ាស៊ីនមួយ និងមិនមែននៅលើម៉ាស៊ីនមួយផ្សេងទៀតមានន័យថាបញ្ហាគឺនៅក្នុងបរិស្ថាន។

ដូច្នេះជំនួសឱ្យឧបករណ៍បំបាត់កំហុសធម្មតាដូចជា gdb ខ្ញុំ​មាន​ឧបករណ៍​ផ្សេង​គ្នា​សម្រាប់​ការ​បំបាត់​កំហុស​ការ​ដាក់​ពង្រាយ។ ហើយឧបករណ៍ដែលខ្ញុំចូលចិត្តសម្រាប់ដោះស្រាយបញ្ហាដូចជា "ហេតុអ្វីកម្មវិធីនេះមិនដំណើរការសម្រាប់ខ្ញុំ?" ហៅ ខ្សែ.

តើ​អ្វី​ទៅ​ជា​ខ្សែ?

ខ្សែ គឺជាឧបករណ៍សម្រាប់ "តាមដានការហៅតាមប្រព័ន្ធ"។ វាត្រូវបានបង្កើតឡើងដំបូងសម្រាប់លីនុច ប៉ុន្តែល្បិចបំបាត់កំហុសដូចគ្នាអាចត្រូវបានធ្វើជាមួយឧបករណ៍សម្រាប់ប្រព័ន្ធផ្សេងទៀត (ឌីធីដ ឬ ktrace).

កម្មវិធីមូលដ្ឋានគឺសាមញ្ញណាស់។ អ្នកគ្រាន់តែត្រូវការរត់ strace ជាមួយនឹងពាក្យបញ្ជាណាមួយ ហើយវានឹងលុបការហៅតាមប្រព័ន្ធទាំងអស់ (ទោះបីជាដំបូងអ្នកប្រហែលជាត្រូវដំឡើងវាដោយខ្លួនឯងក៏ដោយ។ ខ្សែ):

$ strace echo Hello
...Snip lots of stuff...
write(1, "Hellon", 6)                  = 6
close(1)                                = 0
close(2)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++

តើការហៅប្រព័ន្ធទាំងនេះជាអ្វី? នេះគឺជាអ្វីមួយដូចជា API សម្រាប់ខឺណែលប្រព័ន្ធប្រតិបត្តិការ។ មានពេលមួយ កម្មវិធីបានចូលប្រើដោយផ្ទាល់ទៅកាន់ផ្នែករឹងដែលវាដំណើរការ។ ឧទាហរណ៍ ប្រសិនបើ​វា​ត្រូវ​ការ​ដើម្បី​បង្ហាញ​អ្វី​មួយ​នៅ​លើ​អេក្រង់ វា​បាន​លេង​ជាមួយ​ច្រក​ឬ​ការ​ចុះឈ្មោះ​ដែល​បាន​គូស​ផែនទី​អង្គចងចាំ​សម្រាប់​ឧបករណ៍​វីដេអូ។ នៅពេលដែលប្រព័ន្ធកុំព្យូទ័រពហុមុខងារបានក្លាយជាការពេញនិយម ភាពវឹកវរបានគ្រប់គ្រងនៅពេលដែលកម្មវិធីផ្សេងៗបានវាយលុកលើផ្នែករឹង។ កំហុស​ក្នុង​កម្មវិធី​មួយ​អាច​ធ្វើ​ឱ្យ​អ្នក​ផ្សេង​ធ្លាក់​ចុះ បើ​មិនមែន​ប្រព័ន្ធ​ទាំងមូល។ បន្ទាប់មក របៀបឯកសិទ្ធិ (ឬ "ការការពារសំឡេងរោទ៍") បានបង្ហាញខ្លួននៅក្នុងស៊ីភីយូ។ ខឺណែលបានក្លាយជាឯកសិទ្ធិបំផុត៖ វាទទួលបានការចូលដំណើរការពេញលេញទៅកាន់ផ្នែករឹង បង្កើតកម្មវិធីដែលមានសិទ្ធិតិចជាងមុន ដែលត្រូវតែស្នើសុំការចូលប្រើពីខឺណែលរួចហើយដើម្បីធ្វើអន្តរកម្មជាមួយផ្នែករឹងតាមរយៈការហៅតាមប្រព័ន្ធ។

នៅកម្រិតគោលពីរ ការហៅប្រព័ន្ធគឺខុសគ្នាបន្តិចបន្តួចពីការហៅមុខងារសាមញ្ញ ប៉ុន្តែកម្មវិធីភាគច្រើនប្រើ wrapper នៅក្នុងបណ្ណាល័យស្តង់ដារ។ ទាំងនោះ។ បណ្ណាល័យស្តង់ដារ POSIX C មានការហៅមុខងារ សរសេរ ()ដែលមានកូដស្ថាបត្យកម្មជាក់លាក់ទាំងអស់សម្រាប់ការហៅប្រព័ន្ធ សរសេរ.

សរុបមក អន្តរកម្មណាមួយរវាងកម្មវិធី និងបរិស្ថានរបស់វា (ប្រព័ន្ធកុំព្យូទ័រ) ត្រូវបានអនុវត្តតាមរយៈការហៅតាមប្រព័ន្ធ។ ដូច្នេះហើយ នៅពេលដែលកម្មវិធីដំណើរការលើម៉ាស៊ីនមួយ ប៉ុន្តែមិនមែននៅលើម៉ាស៊ីនមួយផ្សេងទៀត វាជាការល្អក្នុងការមើលលទ្ធផលតាមដានការហៅតាមប្រព័ន្ធ។ ពិសេសជាងនេះទៅទៀត នេះគឺជាបញ្ជីនៃចំណុចធម្មតាដែលអាចត្រូវបានវិភាគដោយប្រើដានការហៅតាមប្រព័ន្ធ៖

• កុងសូល I/O
• បណ្តាញ I/O
• ការចូលប្រើប្រព័ន្ធឯកសារ និងឯកសារ I/O
• គ្រប់គ្រងអាយុកាលនៃដំណើរការ
• ការគ្រប់គ្រងអង្គចងចាំកម្រិតទាប
• ចូលប្រើកម្មវិធីបញ្ជាឧបករណ៍ជាក់លាក់

ពេលណាត្រូវប្រើខ្សែ?

ក្នុង​ទ្រឹ​ស្តី, ខ្សែ ប្រើជាមួយកម្មវិធីណាមួយក្នុងចន្លោះអ្នកប្រើប្រាស់ ពីព្រោះកម្មវិធីណាមួយក្នុងចន្លោះអ្នកប្រើប្រាស់ត្រូវតែធ្វើការហៅជាប្រព័ន្ធ។ វាដំណើរការកាន់តែមានប្រសិទ្ធភាពជាមួយកម្មវិធីកម្រិតទាប ប៉ុន្តែវាក៏ដំណើរការជាមួយភាសាកម្រិតខ្ពស់ដូចជា Python ប្រសិនបើអ្នកអាចកាត់បន្ថយសំឡេងរំខានបន្ថែមពីពេលរត់ និងអ្នកបកប្រែ។

នៅក្នុងសិរីរុងរឿងរបស់វា។ ខ្សែ បង្ហាញ​ខ្លួន​វា​ក្នុង​កំឡុង​ពេល​បំបាត់​កំហុស​កម្មវិធី​ដែល​ដំណើរ​ការ​បាន​ល្អ​នៅ​លើ​ម៉ាស៊ីន​មួយ ប៉ុន្តែ​ភ្លាមៗ​នោះ​ឈប់​ធ្វើ​ការ​លើ​ម៉ាស៊ីន​មួយ​ទៀត ដោយ​បង្កើត​សារ​មិន​ច្បាស់លាស់​អំពី​ឯកសារ ការ​អនុញ្ញាត ឬ​ការ​ព្យាយាម​មិន​បាន​ជោគជ័យ​ក្នុង​ការ​ប្រតិបត្តិ​ពាក្យ​បញ្ជា​មួយ​ចំនួន ឬ​អ្វី​ផ្សេង​ទៀត... វា​ជា​ការ​សោកស្ដាយ ប៉ុន្តែ​វា​មិន​បាន​ជោគជ័យ​ទេ។ រួមបញ្ចូលគ្នាយ៉ាងល្អជាមួយនឹងបញ្ហាកម្រិតខ្ពស់ដូចជាកំហុសក្នុងការផ្ទៀងផ្ទាត់វិញ្ញាបនបត្រ។ ជាធម្មតាវាទាមទារការរួមបញ្ចូលគ្នា ខ្សែពេលខ្លះ ដាន និងឧបករណ៍កម្រិតខ្ពស់ (ដូចជាឧបករណ៍បន្ទាត់ពាក្យបញ្ជា openssl ដើម្បីបំបាត់កំហុសវិញ្ញាបនបត្រ) ។

យើង​នឹង​ប្រើ​ម៉ាស៊ីនមេ​ឯករាជ្យ​ជា​ឧទាហរណ៍ ប៉ុន្តែ​ការ​តាមដាន​ការ​ហៅ​ទូរសព្ទ​តាម​ប្រព័ន្ធ​អាច​ត្រូវ​បាន​ធ្វើ​ជា​ញឹក​ញាប់​នៅ​លើ​វេទិកា​ដាក់​ពង្រាយ​ដែល​ស្មុគស្មាញ​ជាង​នេះ។ អ្នកគ្រាន់តែត្រូវជ្រើសរើសឧបករណ៍ត្រឹមត្រូវ។

ឧទាហរណ៍នៃការបំបាត់កំហុសសាមញ្ញ

ចូរនិយាយថាអ្នកចង់ដំណើរការកម្មវិធីម៉ាស៊ីនមេដ៏អស្ចារ្យ foo ហើយនេះគឺជាអ្វីដែលអ្នកបញ្ចប់ដោយ៖

$ foo
Error opening configuration file: No such file or directory

តាមមើលទៅ វាមិនអាចរកបានឯកសារកំណត់រចនាសម្ព័ន្ធដែលអ្នកបានសរសេរទេ។ វាកើតឡើងដោយសារតែពេលខ្លះនៅពេលដែលអ្នកគ្រប់គ្រងកញ្ចប់ចងក្រងកម្មវិធីមួយ ពួកគេបដិសេធទីតាំងឯកសារដែលរំពឹងទុក។ ហើយប្រសិនបើអ្នកធ្វើតាមការណែនាំអំពីការដំឡើងសម្រាប់ការចែកចាយមួយ អ្នករកឃើញឯកសារខុសគ្នាទាំងស្រុងពីកន្លែងដែលអ្នករំពឹងទុក។ បញ្ហាអាចត្រូវបានដោះស្រាយក្នុងរយៈពេលពីរបីវិនាទី ប្រសិនបើសារកំហុសប្រាប់កន្លែងដែលត្រូវរកមើលឯកសារកំណត់រចនាសម្ព័ន្ធ ប៉ុន្តែវាមិនដំណើរការទេ។ ដូច្នេះកន្លែងដែលត្រូវរកមើល?

ប្រសិនបើអ្នកមានសិទ្ធិចូលប្រើកូដប្រភព អ្នកអាចអានវា និងស្វែងរកអ្វីៗគ្រប់យ៉ាង។ ផែនការបម្រុងទុកដ៏ល្អ ប៉ុន្តែមិនមែនជាដំណោះស្រាយលឿនបំផុតនោះទេ។ អ្នកអាចងាកទៅរកកម្មវិធីបំបាត់កំហុសមួយជំហានម្តងៗដូចជា gdb ហើយមើលថាកម្មវិធីធ្វើអ្វី ប៉ុន្តែវាមានប្រសិទ្ធភាពជាងក្នុងការប្រើឧបករណ៍ដែលត្រូវបានរចនាឡើងជាពិសេសដើម្បីបង្ហាញអន្តរកម្មជាមួយបរិស្ថាន៖ ខ្សែ.

សេចក្តីសន្និដ្ឋាន ខ្សែ ប្រហែល​ជា​មើល​ទៅ​មិន​អស់​ប្រាក់ ប៉ុន្តែ​ដំណឹង​ល្អ​គឺ​ថា​វា​ភាគ​ច្រើន​អាច​ត្រូវ​បាន​គេ​មិន​អើពើ​ដោយ​សុវត្ថិភាព។ ជាញឹកញាប់វាមានប្រយោជន៍ក្នុងការប្រើ -o operator ដើម្បីរក្សាទុកលទ្ធផលតាមដានទៅឯកសារដាច់ដោយឡែកមួយ៖

$ strace -o /tmp/trace foo
Error opening configuration file: No such file or directory
$ cat /tmp/trace
execve("foo", ["foo"], 0x7ffce98dc010 /* 16 vars */) = 0
brk(NULL)                               = 0x56363b3fb000
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=25186, ...}) = 0
mmap(NULL, 25186, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f2f12cf1000
close(3)                                = 0
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "177ELF2113 3 > 1 260A2 "..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1824496, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2f12cef000
mmap(NULL, 1837056, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f2f12b2e000
mprotect(0x7f2f12b50000, 1658880, PROT_NONE) = 0
mmap(0x7f2f12b50000, 1343488, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x22000) = 0x7f2f12b50000
mmap(0x7f2f12c98000, 311296, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x16a000) = 0x7f2f12c98000
mmap(0x7f2f12ce5000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1b6000) = 0x7f2f12ce5000
mmap(0x7f2f12ceb000, 14336, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f2f12ceb000
close(3)                                = 0
arch_prctl(ARCH_SET_FS, 0x7f2f12cf0500) = 0
mprotect(0x7f2f12ce5000, 16384, PROT_READ) = 0
mprotect(0x56363b08b000, 4096, PROT_READ) = 0
mprotect(0x7f2f12d1f000, 4096, PROT_READ) = 0
munmap(0x7f2f12cf1000, 25186)           = 0
openat(AT_FDCWD, "/etc/foo/config.json", O_RDONLY) = -1 ENOENT (No such file or directory)
dup(2)                                  = 3
fcntl(3, F_GETFL)                       = 0x2 (flags O_RDWR)
brk(NULL)                               = 0x56363b3fb000
brk(0x56363b41c000)                     = 0x56363b41c000
fstat(3, {st_mode=S_IFCHR|0620, st_rdev=makedev(0x88, 0x8), ...}) = 0
write(3, "Error opening configuration file"..., 60) = 60
close(3)                                = 0
exit_group(1)                           = ?
+++ exited with 1 +++

ប្រហែលទំព័រទីមួយទាំងមូលនៃលទ្ធផល ខ្សែ - ជាធម្មតានេះគឺជាការរៀបចំកម្រិតទាបសម្រាប់ការបាញ់បង្ហោះ។ (ការហៅទូរស័ព្ទច្រើន។ ម៉ាប់, មិនការពារ, ភួយ សម្រាប់អ្វីៗដូចជាការរកឃើញអង្គចងចាំកម្រិតទាប និងបង្ហាញបណ្ណាល័យថាមវន្ត។) តាមពិត កំឡុងពេលបំបាត់កំហុសលទ្ធផល ខ្សែ វាជាការប្រសើរក្នុងការអានពីទីបញ្ចប់។ វានឹងមានការប្រកួតប្រជែងខាងក្រោម សរសេរដែលបង្ហាញសារកំហុស។ យើងមើលទៅខាងលើហើយឃើញការហៅប្រព័ន្ធដែលមានកំហុសដំបូង - ការហៅ បើកដែលបោះចោលកំហុស ENOENT ("រកមិនឃើញឯកសារ ឬថតឯកសារ") កំពុងព្យាយាមបើក /etc/foo/config.json. នេះជាកន្លែងដែលឯកសារកំណត់រចនាសម្ព័ន្ធគួរតែស្ថិតនៅ។

នេះគ្រាន់តែជាឧទាហរណ៍មួយប៉ុណ្ណោះ ប៉ុន្តែខ្ញុំនឹងនិយាយថា 90% នៃពេលវេលាដែលខ្ញុំប្រើ ខ្សែគ្មានអ្វីពិបាកធ្វើជាងនេះទេ។ ខាង​ក្រោម​នេះ​គឺ​ជា​មគ្គុទ្ទេសក៍​បំបាត់​កំហុស​ជា​ជំហាន​ដោយ​ជំហាន​ពេញលេញ៖

• មានការខកចិត្តដោយសារតែសារមិនច្បាស់លាស់អំពីបញ្ហាប្រព័ន្ធ-y ពីកម្មវិធីមួយ។
• ចាប់ផ្តើមកម្មវិធីឡើងវិញជាមួយ ខ្សែ
• ស្វែងរកសារកំហុសក្នុងលទ្ធផលតាមដាន
• ឡើង​ខ្ពស់​រហូត​ទាល់​តែ​អ្នក​ចុច​ការ​ហៅ​ទូរសព្ទ​ដែល​បរាជ័យ​លើក​ដំបូង

វាទំនងណាស់ដែលការហៅប្រព័ន្ធក្នុងជំហានទី 4 នឹងបង្ហាញពីអ្វីដែលខុស។

ព័ត៌មានជំនួយ

មុនពេលបង្ហាញអ្នកនូវឧទាហរណ៍នៃការបំបាត់កំហុសដែលស្មុគស្មាញជាងនេះ ខ្ញុំនឹងបង្ហាញអ្នកនូវល្បិចមួយចំនួនសម្រាប់ការប្រើប្រាស់ប្រកបដោយប្រសិទ្ធភាព ខ្សែ:

បុរសគឺជាមិត្តរបស់អ្នក។

នៅលើប្រព័ន្ធ *nix ជាច្រើន បញ្ជីពេញលេញនៃការហៅប្រព័ន្ធទៅកាន់ខឺណែលអាចទទួលបានដោយការដំណើរការ បុរស syscalls. អ្នកនឹងឃើញអ្វីៗដូចជា brk(2)ដែលមានន័យថាព័ត៌មានបន្ថែមអាចទទួលបានដោយការដំណើរការ បុរស 2 brk.

តុងរួចតូច៖ បុរស 2 fork បង្ហាញខ្ញុំនូវទំព័រសម្រាប់សែល សម () в GNU libc, ដែល, វាប្រែចេញ, ត្រូវបានអនុវត្តដោយការហៅទូរស័ព្ទ ក្លូន(). ហៅតាមន័យវិទ្យា សម នៅតែដដែលប្រសិនបើអ្នកសរសេរកម្មវិធីដោយប្រើ សម ()និងដំណើរការដាន - ខ្ញុំនឹងមិនស្វែងរកការហៅទូរស័ព្ទណាមួយទេ។ សមជំនួសឱ្យពួកគេនឹងមាន ក្លូន(). តុងរួចបែបនេះធ្វើឱ្យអ្នកយល់ច្រឡំតែប៉ុណ្ណោះ ប្រសិនបើអ្នកចាប់ផ្តើមប្រៀបធៀបប្រភពជាមួយទិន្នផល ខ្សែ.

ប្រើ -o ដើម្បីរក្សាទុកលទ្ធផលទៅឯកសារ

ខ្សែ អាចបង្កើតទិន្នផលយ៉ាងទូលំទូលាយ ដូច្នេះជាញឹកញាប់វាមានប្រយោជន៍ក្នុងការរក្សាទុកលទ្ធផលដាននៅក្នុងឯកសារដាច់ដោយឡែក (ដូចក្នុងឧទាហរណ៍ខាងលើ)។ នេះក៏ជួយជៀសវាងការភាន់ច្រលំនូវលទ្ធផលកម្មវិធីជាមួយនឹងលទ្ធផលផងដែរ។ ខ្សែ នៅក្នុងកុងសូល។

ប្រើ -s ដើម្បីមើលទិន្នន័យអាគុយម៉ង់បន្ថែមទៀត

អ្នកប្រហែលជាបានកត់សម្គាល់ឃើញថា ពាក់កណ្តាលទីពីរនៃសារកំហុសមិនត្រូវបានបង្ហាញក្នុងឧទាហរណ៍ខាងលើទេ។ វាដោយសារតែ ខ្សែ លំនាំដើមបង្ហាញតែ 32 បៃដំបូងនៃអាគុយម៉ង់ខ្សែអក្សរប៉ុណ្ណោះ។ ប្រសិនបើអ្នកចង់មើលបន្ថែមទៀតសូមបន្ថែមអ្វីមួយដូចជា -s ១៩២.១៦៨.១២២.៨៨ ទៅការហៅ ខ្សែ.

-y ធ្វើឱ្យវាកាន់តែងាយស្រួលក្នុងការតាមដានឯកសារ រន្ធ ជាដើម។

"ទាំងអស់គឺជាឯកសារ" មានន័យថាប្រព័ន្ធ *nix ធ្វើ I/O ទាំងអស់ដោយប្រើកម្មវិធីពណ៌នាឯកសារ ថាតើវាអនុវត្តចំពោះឯកសារ ឬបណ្តាញ ឬបំពង់អន្តរដំណើរការក៏ដោយ។ វាងាយស្រួលសម្រាប់ការសរសេរកម្មវិធី ប៉ុន្តែធ្វើឱ្យវាពិបាកក្នុងការតាមដាននូវអ្វីដែលកំពុងកើតឡើងនៅពេលដែលអ្នកឃើញជារឿងធម្មតា អាន и សរសេរ នៅក្នុងប្រព័ន្ធហៅលទ្ធផលតាមដាន។

ដោយបន្ថែមប្រតិបត្តិករ -yអ្នកនឹងបង្ខំ ខ្សែ កំណត់ចំណាំអ្នកពណ៌នាឯកសារនីមួយៗនៅក្នុងលទ្ធផលដោយចំណាំអំពីអ្វីដែលវាចង្អុលបង្ហាញ។

ភ្ជាប់ទៅដំណើរការដែលកំពុងដំណើរការរួចហើយជាមួយ -p**

ដូចដែលអ្នកនឹងឃើញពីឧទាហរណ៍ខាងក្រោម ពេលខ្លះអ្នកត្រូវតាមដានកម្មវិធីដែលកំពុងដំណើរការរួចហើយ។ ប្រសិនបើគេដឹងថាវាកំពុងដំណើរការជាដំណើរការ 1337 (និយាយចេញពីលទ្ធផល ps) បន្ទាប់មកអ្នកអាចតាមដានវាដូចនេះ៖

$ strace -p 1337
...system call trace output...

អ្នកអាចត្រូវការសិទ្ធិជា root ។

ប្រើ -f ដើម្បីតាមដានដំណើរការរបស់កុមារ

ខ្សែ តាមលំនាំដើម វាតាមដានដំណើរការតែមួយប៉ុណ្ណោះ។ ប្រសិនបើដំណើរការនេះបង្កើតដំណើរការកុមារ នោះការហៅប្រព័ន្ធដើម្បីបង្កាត់ដំណើរការកុមារអាចមើលឃើញ ប៉ុន្តែការហៅប្រព័ន្ធដំណើរការកុមារនឹងមិនត្រូវបានបង្ហាញទេ។

ប្រសិនបើអ្នកគិតថាកំហុសស្ថិតនៅក្នុងដំណើរការកុមារ សូមប្រើសេចក្តីថ្លែងការណ៍ -fវានឹងបើកការតាមដានរបស់វា។ គុណវិបត្តិនេះគឺថាទិន្នផលនឹងធ្វើឱ្យអ្នកយល់ច្រឡំថែមទៀត។ ពេលណា​ ខ្សែ តាមដានដំណើរការមួយ ឬខ្សែស្រឡាយមួយ វាបង្ហាញព្រឹត្តិការណ៍ហៅទូរសព្ទតែមួយ។ នៅពេលដែលវាតាមដានដំណើរការជាច្រើនក្នុងពេលតែមួយ អ្នកអាចនឹងឃើញការចាប់ផ្តើមនៃការហៅទូរសព្ទដែលរំខានដោយសារមួយ។ បន្ទាប់មក - បាច់នៃការអំពាវនាវសម្រាប់សាខាប្រតិបត្តិផ្សេងទៀតហើយមានតែពេលនោះទេ - ចុងបញ្ចប់នៃទីមួយ <…foocall បន្ត>. ឬបំបែកលទ្ធផលដានទាំងអស់ទៅជាឯកសារផ្សេងគ្នា ដោយប្រើប្រតិបត្តិករផងដែរ។ -ff (ព័ត៌មានលម្អិតនៅក្នុង ភាពជាអ្នកដឹកនាំ នៅលើ ខ្សែ).

ត្រងដានដោយប្រើ -e

ដូចដែលអ្នកអាចឃើញលទ្ធផលនៃដានគឺជាគំនរពិតប្រាកដនៃការហៅតាមប្រព័ន្ធដែលអាចធ្វើបានទាំងអស់។ ទង់ជាតិ -e អ្នកអាចត្រងដាន (សូមមើល ភាពជាអ្នកដឹកនាំ នៅលើ ខ្សែ) អត្ថប្រយោជន៍ចម្បងគឺថាវាលឿនជាងមុនក្នុងការដំណើរការដានដែលបានត្រងជាជាងការតាមដានពេញលេញហើយបន្ទាប់មក grep`នៅ។ និយាយឱ្យត្រង់ទៅ ខ្ញុំស្ទើរតែមិនខ្វល់។

មិនមែនកំហុសទាំងអស់សុទ្ធតែអាក្រក់នោះទេ។

ឧទាហរណ៍សាមញ្ញ និងសាមញ្ញគឺជាកម្មវិធីដែលស្វែងរកឯកសារនៅកន្លែងជាច្រើនក្នុងពេលតែមួយ ដូចជាសែលកំពុងស្វែងរកថតដែលមានឯកសារដែលអាចប្រតិបត្តិបាន៖

$ strace sh -c uname
...
stat("/home/user/bin/uname", 0x7ffceb817820) = -1 ENOENT (No such file or directory)
stat("/usr/local/bin/uname", 0x7ffceb817820) = -1 ENOENT (No such file or directory)
stat("/usr/bin/uname", {st_mode=S_IFREG|0755, st_size=39584, ...}) = 0
...

Heuristics ដូចជា "សំណើដែលបរាជ័យចុងក្រោយ មុនពេលរាយការណ៍អំពីកំហុស" គឺល្អក្នុងការស្វែងរកកំហុសដែលពាក់ព័ន្ធ។ ត្រូវថាតាមដែលអាចធ្វើបាន វាជាឡូជីខលក្នុងការចាប់ផ្តើមពីទីបញ្ចប់។

ការបង្រៀនសរសេរកម្មវិធី C អាចជួយអ្នកឱ្យយល់ពីការហៅតាមប្រព័ន្ធ។

ការហៅតាមស្តង់ដារទៅកាន់បណ្ណាល័យ C មិនមែនជាការហៅតាមប្រព័ន្ធទេ ប៉ុន្តែមានតែស្រទាប់ផ្ទៃស្តើងប៉ុណ្ណោះ។ ដូច្នេះប្រសិនបើអ្នកយល់យ៉ាងហោចណាស់បន្តិចអំពីរបៀប និងអ្វីដែលត្រូវធ្វើនៅក្នុង C វានឹងកាន់តែងាយស្រួលសម្រាប់អ្នកក្នុងការយល់អំពីលទ្ធផលនៃការហៅតាមប្រព័ន្ធ។ ឧទាហរណ៍ អ្នក​មាន​បញ្ហា​ក្នុង​ការ​បំបាត់​កំហុស​ការ​ហៅ​ទូរសព្ទ​ទៅ​ប្រព័ន្ធ​បណ្ដាញ សូម​មើល​លក្ខណៈ​បុរាណ​ដូច​គ្នា។ មគ្គុទ្ទេសក៍របស់ Bija ចំពោះការសរសេរកម្មវិធីបណ្តាញ.

ឧទាហរណ៍នៃការបំបាត់កំហុសដែលស្មុគស្មាញជាងនេះ។

ខ្ញុំបាននិយាយរួចហើយថាឧទាហរណ៍នៃការបំបាត់កំហុសសាមញ្ញគឺជាឧទាហរណ៍នៃអ្វីដែលខ្ញុំភាគច្រើនត្រូវដោះស្រាយនៅពេលធ្វើការជាមួយ ខ្សែ. ទោះយ៉ាងណាក៏ដោយ ពេលខ្លះការស៊ើបអង្កេតពិតប្រាកដគឺត្រូវបានទាមទារ ដូច្នេះនេះគឺជាឧទាហរណ៍ជាក់ស្តែងនៃការបំបាត់កំហុសកម្រិតខ្ពស់ជាងនេះ។

bcron - កម្មវិធីកំណត់ពេលដំណើរការភារកិច្ច ការអនុវត្តមួយផ្សេងទៀតនៃ * ដេមិន nix cron. វា​ត្រូវ​បាន​ដំឡើង​នៅ​លើ​ម៉ាស៊ីន​មេ ប៉ុន្តែ​នៅ​ពេល​នរណា​ម្នាក់​ព្យាយាម​កែ​សម្រួល​កាលវិភាគ នេះ​ជា​អ្វី​ដែល​កើត​ឡើង៖

# crontab -e -u logs
bcrontab: Fatal: Could not create temporary file

យល់ព្រម មានន័យថា bcron ព្យាយាមសរសេរឯកសារជាក់លាក់មួយ ប៉ុន្តែវាមិនដំណើរការ ហើយគាត់នឹងមិនទទួលស្គាល់ថាហេតុអ្វីនោះទេ។ ការលាតត្រដាង ខ្សែ:

# strace -o /tmp/trace crontab -e -u logs
bcrontab: Fatal: Could not create temporary file
# cat /tmp/trace
...
openat(AT_FDCWD, "bcrontab.14779.1573691864.847933", O_RDONLY) = 3
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f82049b4000
read(3, "#Ansible: logsaggn20 14 * * * lo"..., 8192) = 150
read(3, "", 8192)                       = 0
munmap(0x7f82049b4000, 8192)            = 0
close(3)                                = 0
socket(AF_UNIX, SOCK_STREAM, 0)         = 3
connect(3, {sa_family=AF_UNIX, sun_path="/var/run/bcron-spool"}, 110) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f82049b4000
write(3, "156:Slogs #Ansible: logsaggn20 1"..., 161) = 161
read(3, "32:ZCould not create temporary f"..., 8192) = 36
munmap(0x7f82049b4000, 8192)            = 0
close(3)                                = 0
write(2, "bcrontab: Fatal: Could not creat"..., 49) = 49
unlink("bcrontab.14779.1573691864.847933") = 0
exit_group(111)                         = ?
+++ exited with 111 +++

មានសារកំហុសនៅជិតចុងបញ្ចប់ សរសេរប៉ុន្តែលើកនេះមានអ្វីប្លែក។ ទីមួយ មិនមានកំហុសក្នុងការហៅប្រព័ន្ធដែលពាក់ព័ន្ធ ដែលជាធម្មតាកើតឡើងមុននេះទេ។ ទីពីរ វាច្បាស់ណាស់ថាកន្លែងណាមួយមាននរណាម្នាក់បានអានសារកំហុសរួចហើយ។ វាហាក់ដូចជាបញ្ហាពិតនៅកន្លែងផ្សេង bcrontab គ្រាន់តែចាក់សារឡើងវិញ។

ប្រសិនបើអ្នកក្រឡេកមើល បុរស 2 អានអ្នកអាចមើលឃើញថាអាគុយម៉ង់ទីមួយ (3) គឺជាកម្មវិធីពិពណ៌នាឯកសារ ដែល *nix ប្រើសម្រាប់ដំណើរការ I/O ទាំងអស់។ តើខ្ញុំអាចដឹងថាឯកសារពិពណ៌នា 3 តំណាងឱ្យដោយរបៀបណា? ក្នុងករណីពិសេសនេះអ្នកអាចរត់បាន។ ខ្សែ ជាមួយប្រតិបត្តិករ -y (សូមមើលខាងលើ) ហើយវានឹងប្រាប់អ្នកដោយស្វ័យប្រវត្តិ ប៉ុន្តែដើម្បីស្វែងរកវត្ថុដូចនេះ វាពិតជាមានប្រយោជន៍ក្នុងការដឹងពីរបៀបអាន និងញែកលទ្ធផលដាន។

ប្រភពនៃកម្មវិធីពណ៌នាឯកសារអាចជាការហៅទូរស័ព្ទមួយក្នុងចំណោមប្រព័ន្ធជាច្រើន (វាទាំងអស់គឺអាស្រ័យលើអ្វីដែលអ្នកពណ៌នាគឺសម្រាប់ - កុងសូល រន្ធបណ្តាញ ឯកសារខ្លួនវា ឬអ្វីផ្សេងទៀត) ប៉ុន្តែត្រូវស្វែងរកវាតាមដែលអាចធ្វើបាន។ ការហៅទូរសព្ទដោយត្រឡប់លេខ 3 (ឧ. យើងស្វែងរក “= 3” នៅក្នុងលទ្ធផលតាមដាន)។ នៅក្នុងលទ្ធផលនេះមាន 2 ក្នុងចំណោមពួកគេ: បើក នៅកំពូលនិង រន្ធ នៅ​ពាក់​ក​ណ្តា​ល។ បើក បើកឯកសារប៉ុន្តែ ការជិតស្និទ្ធ(3) បន្ទាប់មកនឹងបង្ហាញថាវាបិទម្តងទៀត។ (តុងរួច៖ ឯកសារពិពណ៌នាអាចប្រើឡើងវិញបាននៅពេលបើក និងបិទ)។ ហៅ រន្ធ () ស័ក្តិសមព្រោះវាជាចុងក្រោយពីមុន អាន ()ហើយវាប្រែថា bcrontab ធ្វើការជាមួយអ្វីមួយតាមរយៈរន្ធ។ បន្ទាត់បន្ទាប់បង្ហាញថាឯកសារពិពណ៌នាត្រូវបានភ្ជាប់ជាមួយ រន្ធដែនយូនីក នៅ​តាមផ្លូវ /var/run/bcron-spool.

ដូច្នេះ យើងត្រូវស្វែងរកដំណើរការដែលពាក់ព័ន្ធ រន្ធយូនីក នៅ​ម្ខាងទៀត។ មានល្បិចពីរយ៉ាងសម្រាប់គោលបំណងនេះ ដែលទាំងពីរនេះមានប្រយោជន៍សម្រាប់ការបំបាត់កំហុសលើការដាក់ពង្រាយម៉ាស៊ីនមេ។ ទីមួយគឺត្រូវប្រើ netstat ឬថ្មីជាងនេះ។ ss (ស្ថានភាពរន្ធ) ។ ពាក្យបញ្ជាទាំងពីរបង្ហាញពីការភ្ជាប់បណ្តាញសកម្មរបស់ប្រព័ន្ធ និងយកសេចក្តីថ្លែងការណ៍ -l ដើម្បីពិពណ៌នាអំពីរន្ធស្តាប់ ក៏ដូចជាប្រតិបត្តិករ -p ដើម្បីបង្ហាញកម្មវិធីដែលភ្ជាប់ទៅរន្ធជាម៉ាស៊ីនភ្ញៀវ។ (មានជម្រើសមានប្រយោជន៍ជាច្រើនទៀត ប៉ុន្តែទាំងពីរនេះគឺគ្រប់គ្រាន់សម្រាប់កិច្ចការនេះ។ )

# ss -pl | grep /var/run/bcron-spool
u_str LISTEN 0   128   /var/run/bcron-spool 1466637   * 0   users:(("unixserver",pid=20629,fd=3))

នេះបង្ហាញថាអ្នកស្តាប់គឺជាពាក្យបញ្ជា inixserverដំណើរការជាមួយលេខសម្គាល់ដំណើរការ 20629។ (ហើយចៃដន្យ វាប្រើកម្មវិធីពិពណ៌នាឯកសារ 3 ជារន្ធ។)

ឧបករណ៍ដ៏មានប្រយោជន៍ទីពីរសម្រាប់ការស្វែងរកព័ត៌មានដូចគ្នាត្រូវបានគេហៅថា សូហ្វ. វារាយបញ្ជីឯកសារបើកទាំងអស់ (ឬឯកសារពិពណ៌នា) នៅលើប្រព័ន្ធ។ ឬអ្នកអាចទទួលបានព័ត៌មានអំពីឯកសារជាក់លាក់មួយ៖

# lsof /var/run/bcron-spool
COMMAND   PID   USER  FD  TYPE  DEVICE              SIZE/OFF  NODE    NAME
unixserve 20629 cron  3u  unix  0x000000005ac4bd83  0t0       1466637 /var/run/bcron-spool type=STREAM

ដំណើរការ 20629 គឺជាម៉ាស៊ីនមេដែលមានអាយុកាលយូរ ដូច្នេះអ្នកអាចភ្ជាប់វាបាន ខ្សែ ដោយប្រើអ្វីមួយដូចជា strace -o /tmp/trace -p 20629. ប្រសិនបើអ្នកកែសម្រួលការងារ cron នៅក្នុងស្ថានីយផ្សេងទៀត អ្នកនឹងទទួលបានលទ្ធផលដានដែលមានកំហុស។ ហើយនេះគឺជាលទ្ធផល៖

accept(3, NULL, NULL)                   = 4
clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7faa47c44810) = 21181
close(4)                                = 0
accept(3, NULL, NULL)                   = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=21181, si_uid=998, si_status=0, si_utime=0, si_stime=0} ---
wait4(0, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG|WSTOPPED, NULL) = 21181
wait4(0, 0x7ffe6bc36764, WNOHANG|WSTOPPED, NULL) = -1 ECHILD (No child processes)
rt_sigaction(SIGCHLD, {sa_handler=0x55d244bdb690, sa_mask=[CHLD], sa_flags=SA_RESTORER|SA_RESTART, sa_restorer=0x7faa47ab9840}, {sa_handler=0x55d244bdb690, sa_mask=[CHLD], sa_flags=SA_RESTORER|SA_RESTART, sa_restorer=0x7faa47ab9840}, 8) = 0
rt_sigreturn({mask=[]})                 = 43
accept(3, NULL, NULL)                   = 4
clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7faa47c44810) = 21200
close(4)                                = 0
accept(3, NULL, NULL)                   = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=21200, si_uid=998, si_status=111, si_utime=0, si_stime=0} ---
wait4(0, [{WIFEXITED(s) && WEXITSTATUS(s) == 111}], WNOHANG|WSTOPPED, NULL) = 21200
wait4(0, 0x7ffe6bc36764, WNOHANG|WSTOPPED, NULL) = -1 ECHILD (No child processes)
rt_sigaction(SIGCHLD, {sa_handler=0x55d244bdb690, sa_mask=[CHLD], sa_flags=SA_RESTORER|SA_RESTART, sa_restorer=0x7faa47ab9840}, {sa_handler=0x55d244bdb690, sa_mask=[CHLD], sa_flags=SA_RESTORER|SA_RESTART, sa_restorer=0x7faa47ab9840}, 8) = 0
rt_sigreturn({mask=[]})                 = 43
accept(3, NULL, NULL

(ចុងក្រោយ ទទួលយក () នឹងមិនត្រូវបានបញ្ចប់នៅពេលតាមដាន។) ជាថ្មីម្តងទៀត ជាអកុសល លទ្ធផលនេះមិនមានកំហុសដែលយើងកំពុងស្វែងរកទេ។ យើងមិនឃើញសារណាមួយដែល bcrontag ផ្ញើទៅ ឬទទួលពីរន្ធនោះទេ។ ជំនួសមកវិញ ការគ្រប់គ្រងដំណើរការពេញលេញ (ក្លូន, រង់ចាំ ៤, SIGCHLD ល) ដំណើរការនេះបង្កើតដំណើរការកុមារ ដែលតាមដែលអ្នកប្រហែលជាស្មាន ដំណើរការពិតប្រាកដ។ ហើយប្រសិនបើអ្នកត្រូវការចាប់ផ្លូវរបស់នាង សូមបន្ថែមទៅការហៅទូរសព្ទ ផ្លូវ -f. នេះ​ជា​អ្វី​ដែល​យើង​នឹង​រក​ឃើញ​នៅ​ពេល​ដែល​យើង​ស្វែង​រក​សារ​កំហុស​ក្នុង​លទ្ធផល​ថ្មី​ជាមួយ​នឹង​ខ្សែ​ -f -o /tmp/trace -p 20629:

21470 openat(AT_FDCWD, "tmp/spool.21470.1573692319.854640", O_RDWR|O_CREAT|O_EXCL, 0600) = -1 EACCES (Permission denied) 
21470 write(1, "32:ZCould not create temporary f"..., 36) = 36
21470 write(2, "bcron-spool[21470]: Fatal: logs:"..., 84) = 84
21470 unlink("tmp/spool.21470.1573692319.854640") = -1 ENOENT (No such file or directory)
21470 exit_group(111)                   = ?
21470 +++ exited with 111 +++

ឥឡូវនេះ នោះជាអ្វីមួយ។ ដំណើរការ 21470 ទទួលបានកំហុស "ការចូលដំណើរការត្រូវបានបដិសេធ" នៅពេលព្យាយាមបង្កើតឯកសារនៅផ្លូវ tmp/spool.21470.1573692319.854640 (ទាក់ទងនឹងបញ្ជីការងារបច្ចុប្បន្ន) ។ ប្រសិនបើយើងទើបតែស្គាល់បញ្ជីការងារបច្ចុប្បន្ន យើងក៏នឹងស្គាល់ផ្លូវពេញលេញ និងអាចស្វែងយល់ពីមូលហេតុដែលដំណើរការមិនអាចបង្កើតឯកសារបណ្តោះអាសន្នរបស់វានៅក្នុងនោះ។ ជាអកុសល ដំណើរការបានចេញរួចហើយ ដូច្នេះអ្នកមិនអាចគ្រាន់តែប្រើបានទេ។ lsof -p 21470 ដើម្បីស្វែងរកថតបច្ចុប្បន្ន ប៉ុន្តែអ្នកអាចធ្វើការក្នុងទិសដៅផ្ទុយ - រកមើលការហៅតាមប្រព័ន្ធ PID 21470 ដែលផ្លាស់ប្តូរថត។ (ប្រសិនបើមិនមានទេ PID 21470 ត្រូវតែបានទទួលមរតកពីឪពុកម្តាយរបស់វា ហើយនេះគឺតាមរយៈ lsof - ទំ មិនអាចត្រូវបានរកឃើញទេ។) ការហៅតាមប្រព័ន្ធនេះគឺ ស៊ីឌី (ដែលងាយស្រួលស្វែងរកដោយជំនួយពីម៉ាស៊ីនស្វែងរកតាមអ៊ីនធឺណិតទំនើប)។ ហើយនេះគឺជាលទ្ធផលនៃការស្វែងរកបញ្ច្រាសដោយផ្អែកលើលទ្ធផលតាមដាន គ្រប់មធ្យោបាយទៅកាន់ម៉ាស៊ីនមេ PID 20629៖

20629 clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7faa47c44810) = 21470
...
21470 execve("/usr/sbin/bcron-spool", ["bcron-spool"], 0x55d2460807e0 /* 27 vars */) = 0
...
21470 chdir("/var/spool/cron")          = 0
...
21470 openat(AT_FDCWD, "tmp/spool.21470.1573692319.854640", O_RDWR|O_CREAT|O_EXCL, 0600) = -1 EACCES (Permission denied) 
21470 write(1, "32:ZCould not create temporary f"..., 36) = 36
21470 write(2, "bcron-spool[21470]: Fatal: logs:"..., 84) = 84
21470 unlink("tmp/spool.21470.1573692319.854640") = -1 ENOENT (No such file or directory)
21470 exit_group(111)                   = ?
21470 +++ exited with 111 +++

(ប្រសិនបើអ្នកវង្វេង អ្នកប្រហែលជាចង់អានអត្ថបទមុនរបស់ខ្ញុំ អំពី * ការគ្រប់គ្រងដំណើរការ nix និងសែល.) ដូច្នេះ ម៉ាស៊ីនមេ PID 20629 មិនបានទទួលការអនុញ្ញាតដើម្បីបង្កើតឯកសារនៅលើផ្លូវនោះទេ។ /var/spool/cron/tmp/spool.21470.1573692319.854640. ភាគច្រើនទំនងជាហេតុផលសម្រាប់នេះគឺការកំណត់ការអនុញ្ញាតប្រព័ន្ធឯកសារបុរាណ។ តោះពិនិត្យ៖

# ls -ld /var/spool/cron/tmp/
drwxr-xr-x 2 root root 4096 Nov  6 05:33 /var/spool/cron/tmp/
# ps u -p 20629
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
cron     20629  0.0  0.0   2276   752 ?        Ss   Nov14   0:00 unixserver -U /var/run/bcron-spool -- bcron-spool

នោះ​ហើយ​ជា​កន្លែង​ដែល​ឆ្កែ​ត្រូវ​បាន​គេ​កប់​! ម៉ាស៊ីនមេដំណើរការជាអ្នកប្រើប្រាស់ cron ប៉ុន្តែមានតែ root ប៉ុណ្ណោះដែលមានសិទ្ធិសរសេរទៅថត /var/spool/cron/tmp/. ពាក្យបញ្ជាសាមញ្ញ chown cron /var/spool/cron/tmp/ នឹង​បង្ខំ bcron ធ្វើការបានត្រឹមត្រូវ។ (ប្រសិនបើនោះមិនមែនជាបញ្ហាទេ នោះការសង្ស័យដែលទំនងបំផុតគឺម៉ូឌុលសុវត្ថិភាពខឺណែលដូចជា SELinux ឬ AppArmor ដូច្នេះខ្ញុំនឹងពិនិត្យមើលកំណត់ហេតុសារខឺណែលជាមួយ dmesg.)

សរុប

ដានការហៅតាមប្រព័ន្ធអាចមានច្រើនលើសលប់សម្រាប់អ្នកចាប់ផ្តើមដំបូង ប៉ុន្តែខ្ញុំសង្ឃឹមថាខ្ញុំបានបង្ហាញថាពួកគេគឺជាវិធីរហ័សក្នុងការបំបាត់បញ្ហាទូទៅនៃការប្រើប្រាស់ទូទៅ។ ស្រមៃថាព្យាយាមបំបាត់ដំណើរការពហុដំណើរការ bcronដោយប្រើឧបករណ៍បំបាត់កំហុសជាជំហាន ៗ ។

ការញែកលទ្ធផលលទ្ធផលថយក្រោយតាមខ្សែសង្វាក់នៃការហៅតាមប្រព័ន្ធទាមទារជំនាញ ប៉ុន្តែដូចដែលខ្ញុំបាននិយាយ ស្ទើរតែគ្រប់ពេល ការប្រើ ខ្សែខ្ញុំ​គ្រាន់​តែ​ទទួល​បាន​លទ្ធផល​ដាន​ហើយ​ស្វែង​រក​កំហុស​ចាប់​ផ្តើម​ពី​ចុង​បញ្ចប់។ យ៉ាង​ណា​ក៏​ដោយ ខ្សែ ជួយខ្ញុំសន្សំពេលវេលាច្រើនលើការកែកំហុស។ ខ្ញុំសង្ឃឹមថាវានឹងមានប្រយោជន៍សម្រាប់អ្នកផងដែរ។

ប្រភព: www.habr.com