ဥပမာများဖြင့် Linux ရှိ ဖိုင်ဖော်ပြချက်

တစ်ခါက အင်တာဗျူးတစ်ခုမှာ၊ disk နေရာလွတ်ကုန်သွားလို့ အလုပ်မလုပ်တဲ့ ဝန်ဆောင်မှုတစ်ခုကို တွေ့ရင် ဘာလုပ်မလဲလို့ မေးပါတယ်။

ဟုတ်ပါတယ်၊ ဒီနေရာကို သိမ်းပိုက်ထားတာတွေကို ကြည့်မယ်၊ ဖြစ်နိုင်ရင် နေရာကို သန့်ရှင်းရေးလုပ်မယ် ဆိုပြီး ပြန်ပြောခဲ့တယ်။
ထို့နောက် အင်တာဗျူးသူမေးသည်၊ အခန်းကန့်တွင် နေရာလွတ်မရှိပါက၊ သို့သော် နေရာအားလုံးယူမည့် ဖိုင်များကို သင်မတွေ့ပါက၊

ဤအတွက်ကြောင့် သင်သည် open file descriptors များကို ဥပမာ lsof command ဖြင့် အမြဲတမ်းကြည့်ရှုနိုင်ပြီး မည်သည့် application မှ ရရှိနိုင်သော space အားလုံးကို ရယူထားကြောင်း နားလည်ပြီးနောက် data လိုအပ်မှုပေါ်မူတည်၍ အခြေအနေများအလိုက် လုပ်ဆောင်နိုင်သည်ဟု ငါပြောခဲ့သည်။ .

အင်တာဗျူးသူသည် ကျွန်ုပ်အား နောက်ဆုံးစကားလုံးဖြင့် နှောင့်ယှက်ခဲ့ပြီး ၎င်း၏မေးခွန်းကို “ကျွန်ုပ်တို့ ဒေတာမလိုအပ်ဘူးဆိုပါစို့၊ ၎င်းသည် အမှားအယွင်းမှတ်တမ်းတစ်ခုမျှသာဖြစ်သော်လည်း၊ အက်ပ်လီကေးရှင်းသည် အမှားအယွင်းကို မရေးနိုင်သောကြောင့် အလုပ်မလုပ်ပါ”။

"ကောင်းပြီ၊" "ကျွန်ုပ်တို့သည် အပလီကေးရှင်း config တွင် အမှားအယွင်းများကို ပိတ်ပြီး ၎င်းကို ပြန်လည်စတင်နိုင်ပါသည်။"
အင်တာဗျူးသူမှကန့်ကွက်သည်- "မဟုတ်ပါ၊ ကျွန်ုပ်တို့သည် လျှောက်လွှာကို ပြန်လည်စတင်၍မရပါ၊ ကျွန်ုပ်တို့တွင် အရေးကြီးသောဒေတာများကို မှတ်ဉာဏ်တွင် သိမ်းဆည်းထားဆဲဖြစ်ပြီး အရေးကြီးသောဖောက်သည်များသည် ဝန်ဆောင်မှုကိုယ်တိုင်နှင့် ချိတ်ဆက်ထားသောကြောင့် ထပ်မံချိတ်ဆက်ရန်အတင်းအကြပ်မဖြစ်နိုင်ပါ။"

"ကောင်းပြီ၊" ကျွန်ုပ်က "ကျွန်ုပ်တို့သည် application ကိုပြန်လည်စတင်၍မရပါက၊ ဒေတာသည်ကျွန်ုပ်တို့အတွက်အရေးကြီးသည်မဟုတ်ပါက၊ ls command တွင်ကျွန်ုပ်တို့မတွေ့ပါက၎င်းကိုဖိုင်ဖော်ပြချက်မှတဆင့်ဤဖွင့်ဖိုင်ကိုရိုးရှင်းစွာရှင်းလင်းနိုင်သည်။ ဖိုင်စနစ်ပေါ်မှာ။"

အင်တာဗျူးသူ ကျေနပ်သော်လည်း ကျွန်တော် မကျေနပ်ပါ။

ထိုအခါ ကျွန်ုပ်သည် ကျွန်ုပ်၏ အသိပညာကို စမ်းသပ်နေသူသည် အဘယ်ကြောင့် နက်နဲသည်ထက် နက်နဲသနည်းဟု တွေးလိုက်မိသည်။ ဒါပေမယ့် အချက်အလက်က အရေးကြီးရင် ဘယ်လိုလုပ်မလဲ။ ကျွန်ုပ်တို့သည် လုပ်ငန်းစဉ်ကို ပြန်လည်စတင်၍မရပါက၊ လုပ်ငန်းစဉ်သည် နေရာလွတ်မရှိသော အခန်းကန့်တစ်ခုရှိ ဖိုင်စနစ်သို့ စာရေးမည်ဆိုပါက အဘယ်နည်း။ ရေးပြီးသား data တွေသာမက ဒီ process ကရေးတာ ဒါမှမဟုတ် ရေးဖို့ကြိုးစားတဲ့ data တွေ မဆုံးရှုံးနိုင်ရင် ဘာဖြစ်မလဲ။

Tuzik

အသက်မွေးဝမ်းကြောင်း အစောပိုင်းတွင်၊ အသုံးပြုသူ အချက်အလက် သိမ်းဆည်းရန် လိုအပ်သော အပလီကေးရှင်းငယ်လေး တစ်ခုကို ဖန်တီးရန် ကြိုးစားခဲ့သည်။ ပြီးတော့ အသုံးပြုသူကို သူ့ဒေတာနဲ့ ဘယ်လို ယှဉ်နိုင်မလဲလို့ စဉ်းစားမိပါတယ်။ ဥပမာအားဖြင့်၊ ငါ့မှာ Ivanov Ivan Ivanovich ရှိတယ်၊ သူ့မှာ အချက်အလက်တချို့ရှိတယ်၊ ဒါပေမယ့် ငါသူတို့နဲ့ ဘယ်လိုမိတ်ဖွဲ့ရမလဲ။ "Tuzik" ဟူသောခွေးသည် ဤအိုင်ဗင်၏ပိုင်ကြောင်း ကျွန်ုပ် တိုက်ရိုက် ထောက်ပြနိုင်သည်။ ဒါပေမယ့် သူနာမည်ပြောင်းပြီး Ivan အစား Olya ဖြစ်သွားရင်ကော။ ထိုအခါကျွန်ုပ်တို့၏ Olya Ivanovna Ivanova သည်ခွေးရှိတော့မည်မဟုတ်ကြောင်းနှင့်ကျွန်ုပ်တို့၏ Tuzik သည်တည်ရှိခြင်းမရှိသော Ivan နှင့်ဆက်လက်ပိုင်ဆိုင်လိမ့်မည်။ သုံးစွဲသူတစ်ဦးစီအား သီးသန့်အမှတ်အသား (ID) ပေးထားသည့် ဒေတာဘေ့စ်တစ်ခုသည် ဤပြဿနာကို ဖြေရှင်းရာတွင် အထောက်အကူဖြစ်စေပြီး ကျွန်ုပ်၏ Tuzik သည် တကယ်တော့ နံပါတ်စဉ်တစ်ခုမျှသာဖြစ်ပြီး ဤ ID နှင့် ချိတ်ဆက်ထားသည်။ ထို့ကြောင့်၊ အေ့စ်၏ပိုင်ရှင်တွင် ID နံပါတ် 2 ရှိပြီး တစ်ချိန်ချိန်တွင် အိုင်ဗန်သည် ဤ ID အောက်တွင်ရှိနေကာ၊ ထို့နောက် Olya သည် တူညီသော ID အောက်တွင် ဖြစ်လာခဲ့သည်။ လူသားမျိုးနွယ်နှင့် တိရစ္ဆာန်မွေးမြူရေးပြဿနာကို လက်တွေ့ကျကျ ဖြေရှင်းနိုင်ခဲ့သည်။

ဖိုင်ဖော်ပြချက်

ဖိုင်၏ပြဿနာနှင့် ဤဖိုင်နှင့်အလုပ်လုပ်သောပရိုဂရမ်သည် ကျွန်ုပ်တို့၏ခွေးနှင့်လူနှင့်အနီးစပ်ဆုံးတူညီပါသည်။ ivan.txt ဟုခေါ်သော ဖိုင်ကိုဖွင့်ပြီး ၎င်းတွင် tuzik ဟူသော စကားလုံးကို စတင်ရေးသားခဲ့သည်ဆိုပါစို့၊ သို့သော် ဖိုင်ထဲတွင် ပထမစာလုံး “t” ကိုသာ ရေးသားနိုင်ခဲ့ပြီး ဤဖိုင်ကို တစ်စုံတစ်ဦးမှ ဥပမာအားဖြင့် olya.txt ဟု အမည်ပြောင်းခဲ့သည်ဆိုပါစို့။ ဒါပေမယ့် ဖိုင်က ဒီအတိုင်းပဲ ကျန်နေသေးပြီး ကျွန်တော့်ရဲ့ ace ကို မှတ်တမ်းတင်ချင်ပါတယ်။ စနစ်ခေါ်ဆိုမှုဖြင့် ဖိုင်တစ်ခုကို ဖွင့်လိုက်တိုင်း ဖွင့်လှစ် မည်သည့်ပရိုဂရမ်းမင်းဘာသာစကားဖြင့်မဆို ကျွန်ုပ်အား ဖိုင်တစ်ခုသို့ ညွှန်ပြသည့် သီးသန့် ID တစ်ခုကို လက်ခံရရှိသည်၊ ဤ ID သည် ဖိုင်ဖော်ပြချက်ဖြစ်သည်။ နောက်တစ်ခုက ဒီဖိုင်ကို ဘယ်သူလုပ်သလဲ၊ ဖျက်ပစ်နိုင်တယ်၊ အမည်ပြောင်းနိုင်တယ်၊ ပိုင်ရှင်ကို ပြောင်းနိုင်တယ်၊ ဒါမှမဟုတ် ရေးနိုင်ဖတ်နိုင်ခွင့်တွေကို ဖယ်ထုတ်နိုင်တယ်၊ ငါ ဝင်သုံးခွင့်ရှိသေးတယ်၊ အကြောင်းမှာ၊ ဖိုင်ကိုဖွင့်ချိန်တွင် ကျွန်ုပ်တွင် ၎င်းကိုဖတ်ရန်/သို့မဟုတ် ရေးရန်အခွင့်အရေးရှိသောကြောင့် ၎င်းနှင့်စတင်လုပ်ဆောင်နိုင်ပြီဖြစ်သောကြောင့် ဆက်လက်လုပ်ဆောင်ရမည်ဟု ဆိုလိုပါသည်။

Linux တွင်၊ libc စာကြည့်တိုက်သည် 3 နံပါတ်ဖြင့် လုပ်ဆောင်နေသည့် အပလီကေးရှင်းတစ်ခုစီအတွက် ဖော်ပြချက်ဖိုင် 0,1,2 ခုကို ဖွင့်ပေးပါသည်။ အသေးစိတ်အချက်အလက်များကို လင့်ခ်များတွင် ကြည့်ရှုနိုင်ပါသည်။ man stdio и ယောက်ျား stdout

• ဖိုင်ဖော်ပြချက် 0 ကို STDIN ဟုခေါ်ပြီး အပလီကေးရှင်းထည့်သွင်းခြင်းနှင့် ဆက်စပ်နေသည်။
• ဖိုင်ဖော်ပြချက် 1 ကို STDOUT ဟုခေါ်ပြီး ပရင့်ထုတ်သည့်အမိန့်များကဲ့သို့သော အချက်အလက်ထုတ်ပေးရန်အတွက် အပလီကေးရှင်းများက အသုံးပြုသည်။
• ဖိုင်ဖော်ပြချက် 2 ကို STDERR ဟုခေါ်ပြီး အမှားအယွင်းစာတိုများထုတ်ရန်အတွက် အပလီကေးရှင်းများက အသုံးပြုသည်။

သင့်ပရိုဂရမ်တွင် သင်ဖတ်ရန် သို့မဟုတ် စာရေးရန်အတွက် မည်သည့်ဖိုင်ကိုဖွင့်ထားပါက သင်သည် ပထမဆုံးအခမဲ့ ID ကိုရရှိမည်ဖြစ်ပြီး ၎င်းသည် နံပါတ် 3 ဖြစ်လိမ့်မည်။

၎င်း၏ PID ကို သင်သိပါက မည်သည့်လုပ်ငန်းစဉ်အတွက်မဆို ဖိုင်ဖော်ပြသူစာရင်းကို ကြည့်ရှုနိုင်ပါသည်။

ဥပမာအားဖြင့်၊ bash ကွန်ဆိုးလ်ကိုဖွင့်ပြီး ကျွန်ုပ်တို့၏လုပ်ငန်းစဉ်၏ PID ကို ကြည့်ကြပါစို့

[user@localhost ]$ echo $$
15771

ဒုတိယ console တွင် run ကြပါစို့

[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

ပထမ console တွင်ကျွန်ုပ်တို့တွေ့လိမ့်မည်။

[user@localhost ]$ hello world

Redirect နှင့် Pipe

bash အပါအဝင် မည်သည့်လုပ်ငန်းစဉ်တွင်မဆို ဤဖော်ပြချက်ဖိုင် 3 ခုကို လွယ်ကူစွာ ကျော်လွှားနိုင်သည်၊ ဥပမာ လုပ်ငန်းစဉ်နှစ်ခုကို ချိတ်ဆက်ထားသော ပိုက်တစ်ခုမှတဆင့် ကြည့်ပါ၊

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

ဤအမိန့်ကို သင်ကိုယ်တိုင် လုပ်ဆောင်နိုင်သည်။ ခြေရာ-f အထဲမှာဘာတွေဖြစ်နေလဲကြည့်၊ ဒါပေမယ့် အတိုချုံးပြောပြမယ်။

PID 15771 ဖြင့် ကျွန်ုပ်တို့၏ parent bash လုပ်ငန်းစဉ်သည် ကျွန်ုပ်တို့၏အမိန့်ကို ခွဲခြမ်းစိပ်ဖြာပြီး ကျွန်ုပ်တို့လုပ်ဆောင်လိုသော command မည်မျှကို အတိအကျနားလည်နိုင်သည်၊ ကျွန်ုပ်တို့၏အခြေအနေတွင် ၎င်းတို့ထဲမှ နှစ်ခုရှိသည်- cat နှင့် sleep။ Bash သည် ကလေးလုပ်ငန်းစဉ်နှစ်ခုကို ဖန်တီးပြီး ၎င်းတို့ကို ပိုက်တစ်ခုထဲသို့ ပေါင်းစည်းရန် လိုအပ်ကြောင်း Bash သိသည်။ စုစုပေါင်း၊ bash သည် ကလေးလုပ်ငန်းစဉ် ၂ ခုနှင့် ပိုက်တစ်ခု လိုအပ်မည်ဖြစ်သည်။

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

ထို့နောက် system call ကိုအသုံးပြုပါ။ ကိုယ်ပွား 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

clone သည် ဖိုင်ဖော်ပြချက်အားလုံးနှင့်အတူ လုပ်ငန်းစဉ်ကို clone ပြုလုပ်ထားသည်ကို မမေ့ပါနှင့်၊ ထို့ကြောင့် ၎င်းတို့သည် မိဘလုပ်ငန်းစဉ်နှင့် ကလေးများတွင် အတူတူပင်ဖြစ်သည်။ PID 15771 ပါရှိသည့် မိဘလုပ်ငန်းစဉ်၏ အလုပ်မှာ ကလေးဖြစ်စဉ်များကို စောင့်ကြည့်ရန်ဖြစ်ပြီး၊ ထို့ကြောင့် ကလေးထံမှ တုံ့ပြန်မှုကို စောင့်ဆိုင်းနေပါသည်။

ထို့ကြောင့်၊ ၎င်းသည် ပိုက်မလိုအပ်ဘဲ နံပါတ် 3 နှင့် 4 ပါသော ဖိုင်ဖော်ပြချက်များကို ပိတ်သည်။

PID 9004 ဖြင့် ပထမဆုံး ကလေး bash လုပ်ငန်းစဉ်တွင်၊ စနစ်ခေါ်ဆိုမှု dup2၊ ကျွန်ုပ်တို့၏ STDOUT ဖိုင်ဖော်ပြချက်နံပါတ် 1 ကို ပိုက်သို့ညွှန်ပြသော ဖိုင်ဖော်ပြသူအဖြစ်သို့ ပြောင်းလိုက်သည်၊ ကျွန်ုပ်တို့၏အခြေအနေတွင် ၎င်းသည် နံပါတ် 3 ဖြစ်သည်။ ထို့ကြောင့် PID 9004 ဖြင့် ပထမကလေးလုပ်ငန်းစဉ်သည် STDOUT သို့ရေးလိုက်သမျှသည် ပိုက်ကြားခံတွင် အလိုအလျောက်အဆုံးသတ်သွားမည်ဖြစ်သည်။

PID 9005 နှင့် ဒုတိယကလေးလုပ်ငန်းစဉ်တွင်၊ bash သည် ဖိုင်ဖော်ပြချက် STDIN နံပါတ် 2 ကိုပြောင်းလဲရန် dup0 ကိုအသုံးပြုသည်။ ယခုကျွန်ုပ်တို့၏ဒုတိယ bash နှင့်အတူ PID 9005 ဖတ်မည့်အရာအားလုံးကို ပိုက်မှဖတ်ပါမည်။

၎င်းနောက်တွင်၊ နံပါတ် 3 နှင့် 4 ရှိသော ဖိုင်ဖော်ပြချက်များအား ၎င်းတို့အသုံးမပြုတော့သောကြောင့် ကလေးလုပ်ငန်းစဉ်များတွင်လည်း ပိတ်ထားပါသည်။

ကျွန်ုပ်သည် ဖိုင်ဖော်ပြချက် 255 ကို တမင်တကာ လျစ်လျူရှုပါသည်၊ ၎င်းကို bash ကိုယ်တိုင်က အတွင်းရည်ရွယ်ချက်အတွက် အသုံးပြုပြီး ကလေးလုပ်ငန်းစဉ်များတွင်လည်း ပိတ်ပါမည်။

ထို့နောက်၊ PID 9004 ဖြင့် ပထမကလေးလုပ်ငန်းစဉ်တွင် bash သည် စနစ်ခေါ်ဆိုမှုကို စတင်အသုံးပြုသည်။ အမှုဆောင်အရာရှိ command line တွင်ကျွန်ုပ်တို့သတ်မှတ်ထားသော executable file သည် /usr/bin/cat ဖြစ်သည်။

PID 9005 ဖြင့် ဒုတိယကလေး လုပ်ငန်းစဉ်တွင်၊ bash သည် ကျွန်ုပ်တို့၏ ကိစ္စတွင်၊ /usr/bin/sleep တွင် ကျွန်ုပ်တို့သတ်မှတ်ထားသော ဒုတိယမြောက် လုပ်ဆောင်ချက်ကို လုပ်ဆောင်ပါသည်။

အဖွင့်ခေါ်ဆိုမှုပြုလုပ်ချိန်တွင် O_CLOEXEC အလံဖြင့် ဖွင့်ထားခြင်းမရှိပါက exec စနစ်ခေါ်ဆိုမှုသည် ဖိုင်လက်ကိုင်များကို ပိတ်မည်မဟုတ်ပါ။ ကျွန်ုပ်တို့၏အခြေအနေတွင်၊ လည်ပတ်နိုင်သောဖိုင်များကိုဖွင့်ပြီးနောက်၊ လက်ရှိဖိုင်ဖော်ပြချက်အားလုံးကို သိမ်းဆည်းသွားပါမည်။

ကွန်ဆိုးလ်တွင် စစ်ဆေးပါ-

[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 အသုံးပြုသော system calls နှင့် မရင်းနှီးသောသူများအတွက်၊ strace မှတဆင့် command များကို run ပြီး internal တွင်ဖြစ်ပျက်နေသည်များကိုကြည့်ပါ၊ ဥပမာအားဖြင့် ဤကဲ့သို့ဖြစ်သည်-

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

လုပ်ငန်းစဉ်ကို ပြန်လည်စတင်ခြင်းမပြုဘဲ ဒစ်ခ်နေရာလွတ်ကုန်သွားပြီး ဒေတာသိမ်းဆည်းရန် ကျွန်ုပ်တို့၏ပြဿနာကို ပြန်သွားကြပါစို့။ တစ်စက္ကန့်လျှင် 1 megabyte ခန့်ကို disk သို့ ရေးပေးမည့် ပရိုဂရမ်လေးတစ်ခု ရေးကြည့်ရအောင်။ ထို့အပြင်၊ အကြောင်းတစ်ခုခုကြောင့် ကျွန်ုပ်တို့သည် disk သို့ data မရေးနိုင်ပါက၊ ၎င်းကို ရိုးရှင်းစွာ လျစ်လျူရှုပြီး ဒေတာကို တစ်စက္ကန့်အတွင်း ထပ်ရေးရန် ကြိုးစားပါမည်။ ကျွန်တော် 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

ပရိုဂရမ်ကို run ပြီး ဖိုင်ဖော်ပြချက်တွေကို ကြည့်ရအောင်

[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 တွင် မတူညီသောဖိုင်အရွယ်အစားကို ကျွန်ုပ်တို့မြင်နိုင်သည်၊ ဆိုလိုသည်မှာ ကျွန်ုပ်တို့၏ကုဒ်အစား၊

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) သို့မဟုတ် အပလီကေးရှင်းတွင် လော့ဂ်အင်အဆင့် အမျိုးမျိုးကို အသုံးပြုကြသည်။ Linux သည် လက်ရှိလည်ပတ်နေသော ပရိုဂရမ်တစ်ခုအား အမှန်တကယ်ရေးသားခြင်းနှင့် ပြောင်းလဲနိုင်စွမ်းကို ပံ့ပိုးပေးသည်၊ ဥပမာ၊ ကိန်းရှင်များ၏ တန်ဖိုးများကို ပြောင်းလဲခြင်း၊ breakpoint သတ်မှတ်ခြင်း စသည်ဖြင့်၊

ဖိုင်တစ်ခုရေးရန် disk နေရာအလုံအလောက်မရှိခြင်းနှင့်ပတ်သက်၍ မူရင်းမေးခွန်းသို့ ပြန်သွားကာ ပြဿနာကို ပုံဖော်ကြည့်ရအောင်။

သီးခြားဒစ်တစ်ခုအဖြစ် တပ်ဆင်မည့် ကျွန်ုပ်တို့၏ partition အတွက် ဖိုင်တစ်ခုကို ဖန်တီးကြပါစို့။

[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% သိမ်းပိုက်ထားသည်။

အလုပ်၏အခြေအနေများအရ၊ ကျွန်ုပ်တို့သည် မဆုံးရှုံးနိုင်သော အလွန်အရေးကြီးသော အချက်အလက်များကို မှတ်တမ်းတင်ရန် ကြိုးစားနေကြောင်း သတိရပါ။ တစ်ချိန်တည်းမှာပင်၊ လုပ်ငန်းစဉ်ကို ပြန်လည်စတင်ခြင်းမပြုဘဲ ဝန်ဆောင်မှုကို ကျွန်ုပ်တို့ ပြင်ဆင်ရန် လိုအပ်ပါသည်။

ကျွန်ုပ်တို့တွင် disk space ရှိနေသေးသည်ဆိုပါစို့၊ သို့သော် ဥပမာအားဖြင့် /home တွင် မတူညီသော partition တစ်ခုတွင်ရှိသည်။

ကျွန်ုပ်တို့၏ကုဒ်ကို “အလျင်အမြန် ပြန်လည်ပရိုဂရမ်” လုပ်ကြည့်ရအောင်။

disk space အားလုံးကို စားသုံးပေးသော ကျွန်ုပ်တို့၏ လုပ်ငန်းစဉ်၏ 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 ဟုခေါ်သောစနစ်သည် မည်သည့်စနစ်က လုပ်ဆောင်သည်ကို သတိရပါ (ကျွန်ုပ်တို့ ပြေးလမ်းနှင့် ဖွင့်ထားသောခေါ်ဆိုမှုအား တွေ့ရှိသည့်အပေါ်တွင်ကြည့်ပါ)၊ ဖိုင်တစ်ခုဖွင့်ရန် ကျွန်ုပ်တို့၏ကုဒ်ကို စီမံဆောင်ရွက်သည့်အခါ ကျွန်ုပ်တို့၏လုပ်ငန်းစဉ်ကိုယ်စား ကျွန်ုပ်တို့ကိုယ်တိုင်လုပ်ဆောင်သည်၊ သို့သော် ကျွန်ုပ်တို့သည် O_WRONLY|O_CREAT| လိုအပ်ပါသည်။ O_TRUNC ဘစ်များကို ဂဏန်းတန်ဖိုးဖြင့် အစားထိုးသည်။ ဒါကိုလုပ်ဖို့၊ ဥပမာ၊ kernel ရင်းမြစ်တွေကို ဖွင့်ပါ။ ဒီမှာ ဘယ်အလံတွေက ဘာအတွက်တာဝန်ရှိလဲ ဆိုတာ ကြည့်ပါ။

#Define O_WRONLY 00000001
#Define O_CREAT 00000100
#define 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

ဒေတာမဆုံးရှုံးပါ၊ အပလီကေးရှင်းအလုပ်လုပ်သည်၊ မှတ်တမ်းများကိုတည်နေရာအသစ်သို့ရေးပါ။

အလုပ်နည်းနည်းရှုပ်ရအောင်

ဒေတာသည် ကျွန်ုပ်တို့အတွက် အရေးကြီးသည်ဟု စိတ်ကူးကြည့်ကြပါစို့၊ သို့သော် ကျွန်ုပ်တို့တွင် မည်သည့်အပိုင်းတွင်မဆို disk space ရှိပြီး disk ကို ချိတ်ဆက်၍မရပါ။

ကျွန်ုပ်တို့လုပ်ဆောင်နိုင်သည့်အရာမှာ ကျွန်ုပ်တို့၏ဒေတာကို တစ်နေရာရာသို့ လမ်းကြောင်းလွှဲရန် ဥပမာအားဖြင့် ပိုက်သို့ လမ်းကြောင်းပြောင်းပေးပြီး၊ ဥပမာအားဖြင့် အချို့သောပရိုဂရမ်မှတဆင့် ပိုက်မှဒေတာကို ကွန်ရက်သို့ ပြန်ညွှန်းခြင်းဖြစ်သည်။
mkfifo command ဖြင့် အမည်ပေးထားသော ပိုက်တစ်ခုကို ဖန်တီးနိုင်သည်။ ၎င်းတွင် နေရာလွတ်မရှိသော်လည်း ၎င်းသည် ဖိုင်စနစ်ပေါ်တွင် 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

disk နေရာမရှိသော်လည်း၊ ကျွန်ုပ်တို့သည် ထိုနေရာတွင် အမည်ရှိသော ပိုက်တစ်ခုကို အောင်မြင်စွာ ဖန်တီးနိုင်သည်-

[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 

ကျွန်ုပ်တို့၏ ပြဿနာရှိသော ဆာဗာတွင် သီးခြား terminal တစ်ခုတွင် ကျွန်ုပ်တို့ စတင်လုပ်ဆောင်ပါသည်။

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

ယခုအခါတွင် ပိုက်တွင် အကျုံးဝင်သည့် ဒေတာအားလုံးသည် netcat တွင် stdin သို့ အလိုအလျောက် ရောက်သွားမည်ဖြစ်ပြီး ၎င်းသည် port 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_WROONLY သာလိုအပ်ပြီး ၎င်းကိုရှင်းလင်းရန်မလိုအပ်ပါ။

[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 ပေါ့တ်ကာစ်များကို နားထောင်ပါ။

အားလုံးအကောင်း။

အိမ်စာအနေဖြင့်၊ သင်သည် အောက်ပါ command ကို run ပါက process file descriptors cat and sleep တွင် မည်သည်ကို စဉ်းစားရန် အကြံပြုအပ်ပါသည်။

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

source: www.habr.com