កម្មវិធីពិពណ៌នាឯកសារនៅក្នុង Linux ជាមួយឧទាហរណ៍

មានពេលមួយ ក្នុងអំឡុងពេលសម្ភាសន៍ ខ្ញុំត្រូវបានគេសួរថា តើអ្នកនឹងធ្វើអ្វី ប្រសិនបើអ្នករកឃើញសេវាកម្មមិនដំណើរការ ដោយសារថាសអស់ទំហំផ្ទុក?

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

ចំពោះរឿងនេះខ្ញុំបាននិយាយថាអ្នកតែងតែអាចមើលការពិពណ៌នាឯកសារបើកចំហឧទាហរណ៍ដោយប្រើពាក្យបញ្ជា lsof ហើយយល់ថាកម្មវិធីណាមួយបានយកកន្លែងទំនេរទាំងអស់ហើយបន្ទាប់មកអ្នកអាចធ្វើសកម្មភាពតាមកាលៈទេសៈអាស្រ័យលើថាតើទិន្នន័យត្រូវការ .

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

"មិនអីទេ" ខ្ញុំឆ្លើយថា "យើងអាចបិទការបំបាត់កំហុសក្នុងការកំណត់កម្មវិធី ហើយចាប់ផ្តើមវាឡើងវិញ។"
អ្នកសម្ភាសន៍បានជំទាស់ថា "ទេ យើងមិនអាចចាប់ផ្តើមកម្មវិធីឡើងវិញបានទេ យើងនៅតែមានទិន្នន័យសំខាន់ៗត្រូវបានរក្សាទុកក្នុងអង្គចងចាំ ហើយអតិថិជនសំខាន់ៗត្រូវបានភ្ជាប់ទៅសេវាកម្មដោយខ្លួនឯង ដែលយើងមិនអាចបង្ខំឱ្យភ្ជាប់ម្តងទៀតបានទេ។"

"មិនអីទេ" ខ្ញុំបាននិយាយថា "ប្រសិនបើយើងមិនអាចចាប់ផ្តើមកម្មវិធីឡើងវិញបានទេ ហើយទិន្នន័យមិនសំខាន់សម្រាប់យើងទេ នោះយើងអាចសម្អាតឯកសារបើកចំហនេះតាមរយៈកម្មវិធីពិពណ៌នាឯកសារ ទោះបីជាយើងមិនឃើញវានៅក្នុងពាក្យបញ្ជា ls ក៏ដោយ។ នៅលើប្រព័ន្ធឯកសារ។"

អ្នកសម្ភាសពេញចិត្ត ប៉ុន្តែខ្ញុំអត់មានទេ។

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

ទូហ្ស៊ីក

នៅដើមអាជីពរបស់ខ្ញុំ ខ្ញុំបានព្យាយាមបង្កើតកម្មវិធីតូចមួយដែលត្រូវការរក្សាទុកព័ត៌មានអ្នកប្រើប្រាស់។ ហើយបន្ទាប់មកខ្ញុំគិតថាតើខ្ញុំអាចផ្គូផ្គងអ្នកប្រើប្រាស់ទៅនឹងទិន្នន័យរបស់គាត់ដោយរបៀបណា។ ឧទាហរណ៍ខ្ញុំមាន Ivanov Ivan Ivanovich ហើយគាត់មានព័ត៌មានខ្លះប៉ុន្តែតើខ្ញុំអាចបង្កើតមិត្តជាមួយពួកគេដោយរបៀបណា? ខ្ញុំអាចចង្អុលបង្ហាញដោយផ្ទាល់ថាសត្វឆ្កែដែលមានឈ្មោះថា "Tuzik" ជាកម្មសិទ្ធិរបស់ Ivan នេះ។ ប៉ុន្តែចុះយ៉ាងណាបើគាត់ប្តូរឈ្មោះរបស់គាត់ហើយជំនួសឱ្យ Ivan ក្លាយជាឧទាហរណ៍ Olya? បន្ទាប់មកវានឹងប្រែថា Olya Ivanovna Ivanova របស់យើងនឹងលែងមានឆ្កែទៀតហើយ Tuzik របស់យើងនឹងនៅតែជាកម្មសិទ្ធិរបស់ Ivan ដែលមិនមាន។ មូលដ្ឋានទិន្នន័យដែលបានផ្តល់ឱ្យអ្នកប្រើប្រាស់ម្នាក់ៗនូវឧបករណ៍កំណត់អត្តសញ្ញាណតែមួយគត់ (ID) បានជួយដោះស្រាយបញ្ហានេះ ហើយ Tuzik របស់ខ្ញុំត្រូវបានភ្ជាប់ជាមួយលេខសម្គាល់នេះ ដែលតាមពិតគ្រាន់តែជាលេខស៊េរីប៉ុណ្ណោះ។ ដូច្នេះម្ចាស់សន្លឹកអាត់មានលេខសម្គាល់លេខ 2 ហើយនៅពេលណាមួយ Ivan ស្ថិតនៅក្រោមលេខសម្គាល់នេះហើយបន្ទាប់មក Olya ស្ថិតនៅក្រោមលេខសម្គាល់ដូចគ្នា។ បញ្ហាមនុស្សជាតិ និងការចិញ្ចឹមសត្វត្រូវបានដោះស្រាយយ៉ាងជាក់ស្តែង។

អ្នកពិពណ៌នាឯកសារ

បញ្ហានៃឯកសារ និងកម្មវិធីដែលដំណើរការជាមួយឯកសារនេះគឺប្រហាក់ប្រហែលនឹងឆ្កែ និងមនុស្សរបស់យើង។ ឧបមាថាខ្ញុំបានបើកឯកសារមួយឈ្មោះថា ivan.txt ហើយចាប់ផ្តើមសរសេរពាក្យ tuzik ទៅក្នុងវា ប៉ុន្តែគ្រាន់តែអាចសរសេរអក្សរដំបូង "t" នៅក្នុងឯកសារ ហើយឯកសារនេះត្រូវបានប្តូរឈ្មោះដោយនរណាម្នាក់ឧទាហរណ៍ទៅ olya.txt ។ ប៉ុន្តែឯកសារនៅតែដដែល ហើយខ្ញុំនៅតែចង់កត់ត្រាសន្លឹកអាត់របស់ខ្ញុំនៅក្នុងនោះ។ រាល់ពេលដែលឯកសារត្រូវបានបើកដោយការហៅតាមប្រព័ន្ធ ការបើកចំហរ នៅក្នុងភាសាសរសេរកម្មវិធីណាមួយ ខ្ញុំទទួលបានលេខសម្គាល់តែមួយគត់ដែលចង្អុលខ្ញុំទៅឯកសារ លេខសម្គាល់នេះជាអ្នកពណ៌នាឯកសារ។ ហើយវាមិនមានបញ្ហាអ្វីទាំងអស់ ហើយអ្នកណាធ្វើជាមួយឯកសារនេះបន្ទាប់ វាអាចត្រូវបានលុប វាអាចត្រូវបានប្តូរឈ្មោះ ម្ចាស់អាចត្រូវបានផ្លាស់ប្តូរ ឬសិទ្ធិក្នុងការអាន និងសរសេរអាចត្រូវបានដកចេញ ខ្ញុំនឹងនៅតែមានសិទ្ធិចូលប្រើ។ ទៅវា ពីព្រោះនៅពេលបើកឯកសារ ខ្ញុំមានសិទ្ធិអាន និង/ឬសរសេរវា ហើយខ្ញុំបានគ្រប់គ្រងដើម្បីចាប់ផ្តើមធ្វើការជាមួយវា ដែលមានន័យថាខ្ញុំត្រូវតែបន្តធ្វើដូច្នេះ។

នៅក្នុងលីនុច បណ្ណាល័យ libc បើកឯកសារពិពណ៌នាចំនួន 3 សម្រាប់កម្មវិធីដែលកំពុងដំណើរការនីមួយៗ (ដំណើរការ) ដែលមានលេខ 0,1,2។ ព័ត៌មានបន្ថែមអាចរកបាននៅលើតំណភ្ជាប់ បុរស stdio и បុរស stdout

• កម្មវិធីពិពណ៌នាឯកសារ 0 ត្រូវបានគេហៅថា STDIN ហើយត្រូវបានភ្ជាប់ជាមួយនឹងការបញ្ចូលកម្មវិធី
• កម្មវិធីពិពណ៌នាឯកសារ 1 ត្រូវបានគេហៅថា STDOUT ហើយត្រូវបានប្រើប្រាស់ដោយកម្មវិធីដើម្បីបញ្ចេញទិន្នន័យ ដូចជាពាក្យបញ្ជាបោះពុម្ពជាដើម។
• កម្មវិធីពិពណ៌នាឯកសារ 2 ត្រូវបានគេហៅថា STDERR ហើយត្រូវបានប្រើប្រាស់ដោយកម្មវិធីដើម្បីបញ្ចេញសារកំហុស។

ប្រសិនបើនៅក្នុងកម្មវិធីរបស់អ្នក អ្នកបើកឯកសារណាមួយសម្រាប់អាន ឬសរសេរ នោះទំនងជាអ្នកនឹងទទួលបានលេខសម្គាល់ឥតគិតថ្លៃដំបូង ហើយវានឹងជាប់លេខ 3។

បញ្ជីអ្នកពិពណ៌នាឯកសារអាចត្រូវបានមើលសម្រាប់ដំណើរការណាមួយ ប្រសិនបើអ្នកស្គាល់ PID របស់វា។

ជាឧទាហរណ៍ សូមបើកកុងសូល bash ហើយមើល PID នៃដំណើរការរបស់យើង។

[user@localhost ]$ echo $$
15771

នៅក្នុងកុងសូលទីពីរសូមដំណើរការ

[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

អ្នកអាចមិនអើពើដោយសុវត្ថិភាពនូវឯកសារពិពណ៌នាលេខ 255 សម្រាប់គោលបំណងនៃអត្ថបទនេះ វាត្រូវបានបើកសម្រាប់តម្រូវការរបស់វាដោយ bash ខ្លួនវាផ្ទាល់ មិនមែនដោយបណ្ណាល័យដែលបានភ្ជាប់ទេ។

ឥឡូវនេះ ឯកសារពិពណ៌នាទាំង 3 ត្រូវបានភ្ជាប់ជាមួយឧបករណ៍ pseudo terminal /dev/ptsប៉ុន្តែយើងនៅតែអាចរៀបចំពួកវា ជាឧទាហរណ៍ ដំណើរការពួកវាក្នុងកុងសូលទីពីរ

[user@localhost ]$ echo "hello world" > /proc/15771/fd/0

ហើយនៅក្នុងកុងសូលដំបូងយើងនឹងឃើញ

[user@localhost ]$ hello world

បញ្ជូនបន្តនិងបំពង់

អ្នកអាចបដិសេធឯកសារពិពណ៌នាទាំង 3 នេះយ៉ាងងាយស្រួលនៅក្នុងដំណើរការណាមួយ រួមទាំងនៅក្នុង bash ឧទាហរណ៍តាមរយៈបំពង់តភ្ជាប់ដំណើរការពីរ សូមមើល

[user@localhost ]$ cat /dev/zero | sleep 10000

អ្នកអាចដំណើរការពាក្យបញ្ជានេះដោយខ្លួនឯងជាមួយ ផ្លូវ -f ហើយមើលអ្វីដែលកំពុងកើតឡើងនៅខាងក្នុង ប៉ុន្តែខ្ញុំនឹងប្រាប់អ្នកដោយសង្ខេប។

ដំណើរការ bash មេរបស់យើងជាមួយ PID 15771 ញែកពាក្យបញ្ជារបស់យើង ហើយយល់ច្បាស់អំពីចំនួនពាក្យបញ្ជាដែលយើងចង់ដំណើរការ ក្នុងករណីរបស់យើងមានពីរក្នុងចំណោមពួកគេ៖ ឆ្មា និងការគេង។ Bash ដឹងថាវាត្រូវការបង្កើតដំណើរការកូនពីរ ហើយបញ្ចូលវាទៅក្នុងបំពង់តែមួយ។ សរុបទៅ bash នឹងត្រូវការដំណើរការកូន 2 និងបំពង់មួយ។

Bash ដំណើរការការហៅជាប្រព័ន្ធ មុនពេលបង្កើតដំណើរការកុមារ បំពង់ និងទទួលការពិពណ៌នាឯកសារថ្មីនៅលើបណ្តុំបំពង់បណ្តោះអាសន្ន ប៉ុន្តែសតិបណ្ដោះអាសន្ននេះមិនទាន់ភ្ជាប់ដំណើរការកូនទាំងពីររបស់យើងនៅឡើយទេ។

សម្រាប់ដំណើរការមេ វាហាក់ដូចជាមានបំពង់រួចហើយ ប៉ុន្តែមិនទាន់មានដំណើរការកូននៅឡើយទេ៖

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

បន្ទាប់មកប្រើការហៅតាមប្រព័ន្ធ ក្លូន bash បង្កើតដំណើរការកូនពីរ ហើយដំណើរការទាំងបីរបស់យើងនឹងមើលទៅដូចនេះ៖

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
PID    command
9004  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21
PID    command
9005  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21

កុំភ្លេចថាក្លូនក្លូនដំណើរការរួមជាមួយនឹងឯកសារពណ៌នាទាំងអស់ ដូច្នេះពួកវានឹងដូចគ្នានៅក្នុងដំណើរការមេ និងនៅក្នុងកូន។ ការងារនៃដំណើរការមេជាមួយ PID 15771 គឺដើម្បីតាមដានដំណើរការរបស់កុមារ ដូច្នេះវាគ្រាន់តែរង់ចាំការឆ្លើយតបពីកុមារ។

ដូច្នេះវាមិនត្រូវការបំពង់ទេ ហើយវាបិទឯកសារពិពណ៌នាលេខ 3 និង 4 ។

នៅក្នុងដំណើរការ bash កូនដំបូងជាមួយ PID 9004 ការហៅប្រព័ន្ធ ឌុប ២ផ្លាស់ប្តូរលេខពិពណ៌នាឯកសារ STDOUT របស់យើង 1 ទៅឧបករណ៍ពិពណ៌នាឯកសារដែលចង្អុលទៅបំពង់ ក្នុងករណីរបស់យើងវាជាលេខ 3។ ដូច្នេះអ្វីៗដែលដំណើរការកូនដំបូងជាមួយ PID 9004 សរសេរទៅ STDOUT នឹងបញ្ចប់ដោយស្វ័យប្រវត្តិនៅក្នុងបណ្តុំបំពង់។

នៅក្នុងដំណើរការកូនទីពីរជាមួយ PID 9005 bash ប្រើ dup2 ដើម្បីផ្លាស់ប្តូរឯកសារ descriptor STDIN លេខ 0។ ឥឡូវនេះអ្វីគ្រប់យ៉ាងដែល bash ទីពីររបស់យើងជាមួយ PID 9005 នឹងអាននឹងត្រូវបានអានចេញពីបំពង់។

បន្ទាប់ពីនេះ អ្នកពណ៌នាឯកសារលេខ 3 និង 4 ក៏ត្រូវបានបិទនៅក្នុងដំណើរការកុមារផងដែរ ព្រោះវាលែងត្រូវបានប្រើទៀតហើយ។

ខ្ញុំព្រងើយកន្តើយចំពោះឯកសារ descriptor 255 ដោយចេតនា វាត្រូវបានប្រើសម្រាប់គោលបំណងផ្ទៃក្នុងដោយ bash ខ្លួនវា ហើយនឹងត្រូវបានបិទនៅក្នុងដំណើរការកុមារផងដែរ។

បន្ទាប់មក នៅក្នុងដំណើរការកូនដំបូងជាមួយ PID 9004 bash ចាប់ផ្តើមប្រើការហៅតាមប្រព័ន្ធ ប្រតិបត្តិ ឯកសារដែលអាចប្រតិបត្តិបានដែលយើងបានបញ្ជាក់នៅលើបន្ទាត់ពាក្យបញ្ជា ក្នុងករណីរបស់យើងវាគឺជា /usr/bin/cat ។

នៅក្នុងដំណើរការកូនទីពីរជាមួយ PID 9005 bash ដំណើរការការប្រតិបត្តិទីពីរដែលយើងបានបញ្ជាក់ ក្នុងករណីរបស់យើង /usr/bin/sleep ។

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

ពិនិត្យមើលកុងសូល៖

[user@localhost ]$ pgrep -P 15771
9004
9005
[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
[user@localhost ]$ ls -lah /proc/9004/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
l-wx------ 1 user user 64 Oct  7 15:57 1 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lr-x------ 1 user user 64 Oct  7 15:57 3 -> /dev/zero
[user@localhost ]$ ls -lah /proc/9005/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lr-x------ 1 user user 64 Oct  7 15:57 0 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
[user@localhost ]$ ps -up 9004
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9004  0.0  0.0 107972   620 pts/21   S+   15:57   0:00 cat /dev/zero
[user@localhost ]$ ps -up 9005
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9005  0.0  0.0 107952   360 pts/21   S+   15:57   0:00 sleep 10000

ដូចដែលអ្នកអាចមើលឃើញចំនួនតែមួយគត់នៃបំពង់របស់យើងគឺដូចគ្នានៅក្នុងដំណើរការទាំងពីរ។ ដូច្នេះ យើងមានការតភ្ជាប់រវាងដំណើរការពីរផ្សេងគ្នាជាមួយមេដូចគ្នា។

សម្រាប់អ្នកដែលមិនស៊ាំនឹងការហៅប្រព័ន្ធដែលប្រើ bash ខ្ញុំសូមផ្តល់អនុសាសន៍យ៉ាងខ្លាំងឱ្យដំណើរការពាក្យបញ្ជាតាមរយៈ strace និងមើលអ្វីដែលកំពុងកើតឡើងនៅខាងក្នុងឧទាហរណ៍ដូចនេះ៖

strace -s 1024 -f bash -c "ls | grep hello"

ចូរយើងត្រលប់ទៅបញ្ហារបស់យើងជាមួយនឹងទំហំថាសទាប ហើយព្យាយាមរក្សាទុកទិន្នន័យដោយមិនចាប់ផ្តើមដំណើរការឡើងវិញ។ ចូរយើងសរសេរកម្មវិធីតូចមួយដែលនឹងសរសេរប្រហែល 1 មេកាបៃក្នុងមួយវិនាទីទៅថាស។ ជាងនេះទៅទៀត ប្រសិនបើយើងមិនអាចសរសេរទិន្នន័យទៅឌីសដោយហេតុផលមួយចំនួន យើងនឹងមិនអើពើនឹងរឿងនេះ ហើយព្យាយាមសរសេរទិន្នន័យម្តងទៀតក្នុងមួយវិនាទី។ ក្នុងឧទាហរណ៍ដែលខ្ញុំកំពុងប្រើ Python អ្នកអាចប្រើភាសាសរសេរកម្មវិធីផ្សេងៗ។

[user@localhost ]$ cat openforwrite.py 
import datetime
import time

mystr="a"*1024*1024+"n"
with open("123.txt", "w") as f:
    while True:
        try:
            f.write(str(datetime.datetime.now()))
            f.write(mystr)
            f.flush()
            time.sleep(1)
        except:
            pass

តោះដំណើរការកម្មវិធី ហើយមើលឯកសារពិពណ៌នា

[user@localhost ]$ python openforwrite.py &
[1] 3762
[user@localhost ]$ ps axuf | grep [o]penforwrite
user  3762  0.0  0.0 128600  5744 pts/22   S+   16:28   0:00  |   _ python openforwrite.py
[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt

ដូចដែលអ្នកអាចឃើញ យើងមានឧបករណ៍ពណ៌នាឯកសារស្តង់ដារចំនួន 3 របស់យើង និងមួយទៀតដែលយើងបានបើក។ តោះពិនិត្យមើលទំហំឯកសារ៖

[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 117M Oct  7 16:30 123.txt

ទិន្នន័យកំពុងត្រូវបានសរសេរ យើងព្យាយាមផ្លាស់ប្តូរការអនុញ្ញាតនៅលើឯកសារ៖

[user@localhost ]$ sudo chown root: 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 168M Oct  7 16:31 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 172M Oct  7 16:31 123.txt

យើងឃើញថាទិន្នន័យនៅតែកំពុងត្រូវបានសរសេរ ទោះបីជាអ្នកប្រើប្រាស់របស់យើងមិនមានការអនុញ្ញាតក្នុងការសរសេរទៅកាន់ឯកសារក៏ដោយ។ តោះព្យាយាមលុបវាចេញ៖

[user@localhost ]$ sudo rm 123.txt 
[user@localhost ]$ ls 123.txt
ls: cannot access 123.txt: No such file or directory

តើទិន្នន័យត្រូវបានសរសេរនៅឯណា? ហើយ​គេ​សរសេរ​ទាំង​អស់​គ្នា​ឬ? យើងពិនិត្យ៖

[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt (deleted)

បាទ អ្នកពណ៌នាឯកសាររបស់យើងនៅតែមាន ហើយយើងអាចចាត់ទុកឯកសារពិពណ៌នានេះដូចជាឯកសារចាស់របស់យើង យើងអាចអាន ជម្រះ និងចម្លងវាបាន។

តោះមើលទំហំឯកសារ៖

[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5   19923457   2621522 /home/user/123.txt

ទំហំឯកសារគឺ 19923457។ តោះព្យាយាមលុបឯកសារ៖

[user@localhost ]$ truncate -s 0 /proc/31083/fd/3
[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5  136318390   2621522 /home/user/123.txt

ដូចដែលអ្នកអាចឃើញ ទំហំឯកសារកំពុងកើនឡើង ហើយប្រអប់របស់យើងមិនដំណើរការទេ។ តោះមើលឯកសារហៅប្រព័ន្ធ ការបើកចំហរ. ប្រសិនបើយើងប្រើទង់ O_APPEND នៅពេលបើកឯកសារ នោះជាមួយនឹងការសរសេរនីមួយៗ ប្រព័ន្ធប្រតិបត្តិការពិនិត្យមើលទំហំឯកសារ ហើយសរសេរទិន្នន័យទៅចុងបំផុតនៃឯកសារ ហើយធ្វើវាដោយអាតូម។ វាអនុញ្ញាតឱ្យខ្សែស្រឡាយ ឬដំណើរការជាច្រើនសរសេរទៅឯកសារដូចគ្នា។ ប៉ុន្តែនៅក្នុងកូដរបស់យើង យើងមិនប្រើទង់នេះទេ។ យើងអាចមើលឃើញទំហំឯកសារផ្សេងគ្នានៅក្នុង lsof បន្ទាប់ពី trunk លុះត្រាតែយើងបើកឯកសារសម្រាប់ការសរសេរបន្ថែម ដែលមានន័យថានៅក្នុងកូដរបស់យើងជំនួសវិញ។

with open("123.txt", "w") as f:

យើងត្រូវតែដាក់

with open("123.txt", "a") as f:

ពិនិត្យជាមួយទង់ "w"

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3

និងជាមួយទង់ "a"

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_APPEND, 0666) = 3

ដំណើរការកម្មវិធីដែលកំពុងដំណើរការ

ជាញឹកញាប់ អ្នកសរសេរកម្មវិធី នៅពេលបង្កើត និងសាកល្បងកម្មវិធី ប្រើកម្មវិធីបំបាត់កំហុស (ឧទាហរណ៍ GDB) ឬកម្រិតផ្សេងៗនៃការចូលនៅក្នុងកម្មវិធី។ លីនុចផ្តល់នូវសមត្ថភាពក្នុងការសរសេរ និងផ្លាស់ប្តូរកម្មវិធីដែលកំពុងដំណើរការរួចហើយ ឧទាហរណ៍ ផ្លាស់ប្តូរតម្លៃនៃអថេរ កំណត់ចំណុចឈប់។ល។

ត្រលប់ទៅសំណួរដើមអំពីទំហំថាសមិនគ្រប់គ្រាន់ដើម្បីសរសេរឯកសារ សូមព្យាយាមក្លែងធ្វើបញ្ហា។

តោះបង្កើតឯកសារសម្រាប់ភាគថាសរបស់យើង ដែលយើងនឹងម៉ោនជាថាសដាច់ដោយឡែក៖

[user@localhost ~]$ dd if=/dev/zero of=~/tempfile_for_article.dd bs=1M count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00525929 s, 2.0 GB/s
[user@localhost ~]$

តោះបង្កើតប្រព័ន្ធឯកសារ៖

[user@localhost ~]$ mkfs.ext4 ~/tempfile_for_article.dd
mke2fs 1.42.9 (28-Dec-2013)
/home/user/tempfile_for_article.dd is not a block special device.
Proceed anyway? (y,n) y
...
Writing superblocks and filesystem accounting information: done
[user@localhost ~]$

ដំឡើងប្រព័ន្ធឯកសារ៖

[user@localhost ~]$ sudo mount ~/tempfile_for_article.dd /mnt/
[sudo] password for user: 
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  172K  7.9M   3% /mnt

យើងបង្កើតថតជាមួយម្ចាស់របស់យើង៖

[user@localhost ~]$ sudo mkdir /mnt/logs
[user@localhost ~]$ sudo chown user: /mnt/logs

តោះបើកឯកសារសម្រាប់សរសេរតែក្នុងកម្មវិធីរបស់យើង៖

with open("/mnt/logs/123.txt", "w") as f:

បើកដំណើរការ

[user@localhost ]$ python openforwrite.py 

យើងរង់ចាំពីរបីវិនាទី

[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

ដូច្នេះ, យើងមានបញ្ហាដែលបានពិពណ៌នានៅដើមអត្ថបទនេះ។ ទំហំទំនេរ 0, 100% កាន់កាប់។

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

ចូរនិយាយថាយើងនៅតែមានទំហំថាស ប៉ុន្តែនៅក្នុងភាគថាសផ្សេងគ្នា ឧទាហរណ៍នៅក្នុង /home ។

តោះព្យាយាម "រៀបចំឡើងវិញភ្លាមៗ" កូដរបស់យើង។

សូមក្រឡេកមើល PID នៃដំណើរការរបស់យើង ដែលស៊ីទំហំថាសទាំងអស់៖

[user@localhost ~]$ ps axuf | grep [o]penfor
user 10078 27.2  0.0 128600  5744 pts/22   R+   11:06   0:02  |   _ python openforwrite.py

ភ្ជាប់ទៅដំណើរការតាមរយៈ gdb

[user@localhost ~]$ gdb -p 10078
...
(gdb) 

សូមក្រឡេកមើលការពិពណ៌នាឯកសារបើក៖

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt

យើងមើលព័ត៌មានអំពីឯកសារពិពណ៌នាលេខ 3 ដែលចាប់អារម្មណ៍

(gdb) shell cat /proc/10078/fdinfo/3
pos:    8189952
flags:  0100001
mnt_id: 482

ដោយចងចាំថាតើប្រព័ន្ធហៅ Python បង្កើតអ្វី (សូមមើលខាងលើកន្លែងដែលយើងរត់ strace ហើយបានរកឃើញការហៅបើកចំហ) នៅពេលដំណើរការកូដរបស់យើងដើម្បីបើកឯកសារ យើងធ្វើដូចគ្នាដោយខ្លួនឯងក្នុងនាមដំណើរការរបស់យើង ប៉ុន្តែយើងត្រូវការ O_WRONLY|O_CREAT| ប៊ីត O_TRUNC ជំនួសដោយតម្លៃលេខ។ ដើម្បីធ្វើដូចនេះបើកប្រភពខឺណែលឧទាហរណ៍ នៅទីនេះ ហើយមើលថាតើទង់ណាទទួលខុសត្រូវចំពោះអ្វី

#កំណត់ O_WROONLY 00000001
#កំណត់ O_CREAT 00000100
#កំណត់ O_TRUNC 00001000

យើង​រួម​បញ្ចូល​តម្លៃ​ទាំង​អស់​ជា​មួយ យើង​ទទួល​បាន 00001101

យើងដំណើរការការហៅរបស់យើងពី gdb

(gdb) call open("/home/user/123.txt", 00001101,0666)
$1 = 4

ដូច្នេះ​យើង​ទទួល​បាន​ឯកសារ​ពណ៌នា​ថ្មី​ដែល​មាន​លេខ 4 និង​ឯកសារ​បើក​ថ្មី​នៅ​លើ​ភាគ​ថាស​ផ្សេង​ទៀត យើង​ពិនិត្យ​មើល៖

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

យើងចងចាំឧទាហរណ៍ជាមួយបំពង់ - របៀប bash ផ្លាស់ប្តូរអ្នកពិពណ៌នាឯកសារហើយយើងបានរៀនការហៅប្រព័ន្ធ dup2 រួចហើយ។

យើងព្យាយាមជំនួសអ្នកពណ៌នាឯកសារមួយជាមួយឯកសារផ្សេងទៀត។

(gdb) call dup2(4,3)
$2 = 3

កំពុងពិនិត្យ:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /home/user/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

យើងបិទកម្មវិធីពិពណ៌នាឯកសារ 4 ដោយសារយើងមិនត្រូវការវា៖

(gdb) call close (4)
$1 = 0

ហើយចេញពី gdb

(gdb) quit
A debugging session is active.

    Inferior 1 [process 10078] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 10078

ពិនិត្យឯកសារថ្មី៖

[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 5.1M Oct  8 11:18 /home/user/123.txt
[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 7.1M Oct  8 11:18 /home/user/123.txt

ដូចដែលអ្នកអាចឃើញទិន្នន័យត្រូវបានសរសេរទៅឯកសារថ្មី សូមពិនិត្យមើលឯកសារចាស់៖

[user@localhost ~]$ ls -lah /mnt/logs/123.txt 
-rw-rw-r-- 1 user user 7.9M Oct  8 11:08 /mnt/logs/123.txt

គ្មានទិន្នន័យត្រូវបានបាត់បង់ កម្មវិធីដំណើរការ កំណត់ហេតុត្រូវបានសរសេរទៅកាន់ទីតាំងថ្មី។

ចូរធ្វើឱ្យកិច្ចការស្មុគស្មាញបន្តិច

សូមស្រមៃថាទិន្នន័យមានសារៈសំខាន់សម្រាប់យើង ប៉ុន្តែយើងមិនមានទំហំថាសនៅក្នុងភាគថាសណាមួយទេ ហើយយើងមិនអាចភ្ជាប់ថាសបានទេ។

អ្វី​ដែល​យើង​អាច​ធ្វើ​បាន​គឺ​ប្តូរ​ទិស​ទិន្នន័យ​របស់​យើង​ទៅ​កន្លែង​ណា​មួយ ឧទាហរណ៍​ទៅ​បំពង់ ហើយ​ប្តូរ​ទិស​ទិន្នន័យ​ពី​បំពង់​ទៅ​បណ្តាញ​តាម​រយៈ​កម្មវិធី​មួយ​ចំនួន​ឧទាហរណ៍ netcat។
យើងអាចបង្កើតបំពង់ដែលមានឈ្មោះដោយប្រើពាក្យបញ្ជា mkfifo ។ វានឹងបង្កើតឯកសារ pseudo នៅលើប្រព័ន្ធឯកសារ ទោះបីជាមិនមានកន្លែងទំនេរនៅលើវាក៏ដោយ។

ចាប់ផ្តើមកម្មវិធីឡើងវិញ ហើយពិនិត្យ៖

[user@localhost ]$ python openforwrite.py 
[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 72.9  0.0 128600  5744 pts/22   R+   11:27   0:20  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

មិនមានទំហំថាសទេ ប៉ុន្តែយើងបង្កើតបំពង់ដែលមានឈ្មោះនៅទីនោះដោយជោគជ័យ៖

[user@localhost ~]$ mkfifo /mnt/logs/megapipe
[user@localhost ~]$ ls -lah /mnt/logs/megapipe 
prw-rw-r-- 1 user user 0 Oct  8 11:28 /mnt/logs/megapipe

ឥឡូវនេះ យើងចាំបាច់ត្រូវរុំទិន្នន័យទាំងអស់ដែលចូលទៅក្នុងបំពង់នេះទៅកាន់ម៉ាស៊ីនមេផ្សេងទៀតតាមរយៈបណ្តាញ។ netcat ដូចគ្នាគឺសមរម្យសម្រាប់វា។

នៅលើម៉ាស៊ីនមេ remote-server.example.com យើងដំណើរការ

[user@localhost ~]$ nc -l 7777 > 123.txt 

នៅលើម៉ាស៊ីនមេដែលមានបញ្ហារបស់យើង យើងបើកដំណើរការនៅក្នុងស្ថានីយដាច់ដោយឡែកមួយ។

[user@localhost ~]$ nc remote-server.example.com 7777 < /mnt/logs/megapipe 

ឥឡូវនេះទិន្នន័យទាំងអស់ដែលបញ្ចប់នៅក្នុងបំពង់នឹងទៅ stdin ដោយស្វ័យប្រវត្តិនៅក្នុង netcat ដែលនឹងបញ្ជូនវាទៅបណ្តាញនៅលើច្រក 7777 ។

អ្វីដែលយើងត្រូវធ្វើគឺចាប់ផ្តើមសរសេរទិន្នន័យរបស់យើងទៅក្នុងបំពង់ដែលមានឈ្មោះនេះ។

យើងមានកម្មវិធីដំណើរការរួចហើយ៖

[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 99.8  0.0 128600  5744 pts/22   R+   11:27 169:27  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt

ក្នុងចំណោមទង់ទាំងអស់ យើងគ្រាន់តែត្រូវការ O_WRONLY ចាប់តាំងពីឯកសារមានរួចហើយ ហើយយើងមិនចាំបាច់សម្អាតវាទេ

[user@localhost ~]$ gdb -p 5946
...
(gdb) call open("/mnt/logs/megapipe", 00000001,0666)
$1 = 4
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call dup2(4,3)
$2 = 3
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call close(4)
$3 = 0
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
(gdb) quit
A debugging session is active.

    Inferior 1 [process 5946] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 5946

កំពុងពិនិត្យមើលម៉ាស៊ីនមេពីចម្ងាយ remote-server.example.com

[user@localhost ~]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 38M Oct  8 14:21 123.txt

ទិន្នន័យមកដល់ យើងពិនិត្យមើលម៉ាស៊ីនមេដែលមានបញ្ហា

[user@localhost ~]$ ls -lah /mnt/logs/
total 7.9M
drwxr-xr-x 2 user user 1.0K Oct  8 11:28 .
drwxr-xr-x 4 root     root     1.0K Oct  8 10:55 ..
-rw-rw-r-- 1 user user 7.9M Oct  8 14:17 123.txt
prw-rw-r-- 1 user user    0 Oct  8 14:22 megapipe

ទិន្នន័យត្រូវបានរក្សាទុក បញ្ហាត្រូវបានដោះស្រាយ។

ខ្ញុំឆ្លៀតឱកាសនេះដើម្បីជំរាបសួរមិត្តរួមការងាររបស់ខ្ញុំពី Degiro ។
ស្តាប់ផតខាស់ Radio-T ។

ល្អសម្រាប់ទាំងអស់គ្នា។

ក្នុងនាមជាកិច្ចការផ្ទះ ខ្ញុំស្នើឱ្យអ្នកគិតអំពីអ្វីដែលនឹងមាននៅក្នុងដំណើរការឯកសារ descriptors cat and sleep ប្រសិនបើអ្នកដំណើរការពាក្យបញ្ជាខាងក្រោម៖

[user@localhost ~]$ cat /dev/zero 2>/dev/null| sleep 10000

ប្រភព: www.habr.com