ຕົວອະທິບາຍໄຟລ໌ໃນ Linux ດ້ວຍຕົວຢ່າງ

ຄັ້ງຫນຶ່ງ, ໃນລະຫວ່າງການສໍາພາດ, ຂ້ອຍຖືກຖາມວ່າ, ເຈົ້າຈະເຮັດແນວໃດຖ້າທ່ານຊອກຫາບໍລິການທີ່ບໍ່ເຮັດວຽກຍ້ອນຄວາມຈິງທີ່ວ່າແຜ່ນຫມົດພື້ນທີ່?

ແນ່ນອນ, ຂ້ອຍຕອບວ່າຂ້ອຍຈະເຫັນສິ່ງທີ່ຖືກຄອບຄອງໂດຍສະຖານທີ່ນີ້ແລະ, ຖ້າເປັນໄປໄດ້, ຂ້ອຍຈະເຮັດຄວາມສະອາດສະຖານທີ່.
ຫຼັງຈາກນັ້ນ, ຜູ້ສໍາພາດຖາມວ່າ, ຖ້າບໍ່ມີພື້ນທີ່ຫວ່າງໃນພາທິຊັນ, ແຕ່ເຈົ້າຍັງບໍ່ເຫັນໄຟລ໌ໃດໆທີ່ຈະໃຊ້ພື້ນທີ່ທັງຫມົດ?

ໃນເລື່ອງນີ້ຂ້ອຍເວົ້າວ່າເຈົ້າສາມາດເບິ່ງຕົວອະທິບາຍໄຟລ໌ທີ່ເປີດຢູ່ສະເຫມີ, ຕົວຢ່າງດ້ວຍຄໍາສັ່ງ lsof, ແລະເຂົ້າໃຈວ່າແອັບພລິເຄຊັນໃດໄດ້ເອົາພື້ນທີ່ທີ່ມີຢູ່ທັງຫມົດ, ແລະຫຼັງຈາກນັ້ນທ່ານສາມາດປະຕິບັດໄດ້ຕາມສະຖານະການ, ຂຶ້ນກັບວ່າຂໍ້ມູນຕ້ອງການ. .

ຜູ້ສໍາພາດໄດ້ຂັດຂວາງຂ້ອຍໃນຄໍາສຸດທ້າຍ, ເພີ່ມຄໍາຖາມຂອງລາວ: "ສົມມຸດວ່າພວກເຮົາບໍ່ຕ້ອງການຂໍ້ມູນ, ມັນເປັນພຽງແຕ່ບັນທຶກການດີບັກ, ແຕ່ແອັບພລິເຄຊັນບໍ່ເຮັດວຽກເພາະວ່າມັນບໍ່ສາມາດຂຽນ debug ໄດ້"?

"ຕົກລົງ," ຂ້ອຍຕອບວ່າ, "ພວກເຮົາສາມາດປິດການດີບັກໃນການຕັ້ງຄ່າແອັບພລິເຄຊັນແລະເປີດມັນໃຫມ່."
ຜູ້ສໍາພາດໄດ້ຄັດຄ້ານ: "ບໍ່, ພວກເຮົາບໍ່ສາມາດ restart ແອັບພລິເຄຊັນໄດ້, ພວກເຮົາຍັງມີຂໍ້ມູນທີ່ສໍາຄັນທີ່ເກັບໄວ້ໃນຫນ່ວຍຄວາມຈໍາ, ແລະລູກຄ້າທີ່ສໍາຄັນແມ່ນເຊື່ອມຕໍ່ກັບບໍລິການຂອງມັນເອງ, ເຊິ່ງພວກເຮົາບໍ່ສາມາດບັງຄັບໃຫ້ເຊື່ອມຕໍ່ອີກເທື່ອຫນຶ່ງ."

"ຕົກລົງ," ຂ້ອຍເວົ້າວ່າ, "ຖ້າພວກເຮົາບໍ່ສາມາດເປີດແອັບພລິເຄຊັນໃຫມ່ແລະຂໍ້ມູນບໍ່ສໍາຄັນສໍາລັບພວກເຮົາ, ຫຼັງຈາກນັ້ນພວກເຮົາສາມາດລຶບໄຟລ໌ທີ່ເປີດນີ້ຜ່ານຕົວອະທິບາຍໄຟລ໌, ເຖິງແມ່ນວ່າພວກເຮົາບໍ່ເຫັນມັນຢູ່ໃນຄໍາສັ່ງ ls. ໃນລະບົບໄຟລ໌."

ຜູ້ສໍາພາດມີຄວາມຍິນດີ, ແຕ່ຂ້ອຍບໍ່ໄດ້.

ຫຼັງຈາກນັ້ນ, ຂ້າພະເຈົ້າຄິດວ່າ, ເປັນຫຍັງຜູ້ທີ່ທົດສອບຄວາມຮູ້ຂອງຂ້ອຍບໍ່ເລິກກວ່າ? ແຕ່ຈະເປັນແນວໃດຖ້າຂໍ້ມູນມີຄວາມສໍາຄັນຫຼັງຈາກທັງຫມົດ? ຈະເປັນແນວໃດຖ້າພວກເຮົາບໍ່ສາມາດເລີ່ມຕົ້ນຂະບວນການໃຫມ່, ແລະຂະບວນການຂຽນໃສ່ລະບົບໄຟລ໌ໃນພາທິຊັນທີ່ບໍ່ມີພື້ນທີ່ຫວ່າງ? ຈະເປັນແນວໃດຖ້າພວກເຮົາບໍ່ສາມາດສູນເສຍບໍ່ພຽງແຕ່ຂໍ້ມູນທີ່ຂຽນແລ້ວ, ແຕ່ຍັງຂໍ້ມູນທີ່ຂະບວນການນີ້ຂຽນຫຼືພະຍາຍາມຂຽນ?

ຕູຊິກ

ໃນຕອນຕົ້ນຂອງການເຮັດວຽກຂອງຂ້ອຍ, ຂ້ອຍພະຍາຍາມສ້າງແອັບພລິເຄຊັນນ້ອຍໆທີ່ຕ້ອງການເກັບຮັກສາຂໍ້ມູນຜູ້ໃຊ້. ແລະຫຼັງຈາກນັ້ນຂ້າພະເຈົ້າຄິດວ່າ, ຂ້ອຍຈະຈັບຄູ່ຜູ້ໃຊ້ກັບຂໍ້ມູນຂອງລາວໄດ້ແນວໃດ. ຕົວຢ່າງ, ຂ້ອຍມີ Ivanov Ivan Ivanovich, ແລະລາວມີຂໍ້ມູນບາງຢ່າງ, ແຕ່ຂ້ອຍຈະສ້າງເພື່ອນກັບພວກເຂົາໄດ້ແນວໃດ? ຂ້າພະເຈົ້າສາມາດຊີ້ໃຫ້ເຫັນໂດຍກົງວ່າຫມາທີ່ມີຊື່ວ່າ "Tuzik" ເປັນຂອງ Ivan ນີ້. ແຕ່ຈະເປັນແນວໃດຖ້າລາວປ່ຽນຊື່ຂອງລາວແລະແທນທີ່ຈະ Ivan ກາຍເປັນ, ສໍາລັບຕົວຢ່າງ, Olya? ຫຼັງຈາກນັ້ນ, ມັນຈະປາກົດວ່າ Olya Ivanovna Ivanova ຂອງພວກເຮົາຈະບໍ່ມີຫມາອີກຕໍ່ໄປ, ແລະ Tuzik ຂອງພວກເຮົາຍັງຄົງເປັນຂອງ Ivan ທີ່ບໍ່ມີຢູ່. ຖານຂໍ້ມູນທີ່ໃຫ້ຜູ້ໃຊ້ແຕ່ລະຄົນມີຕົວລະບຸທີ່ເປັນເອກະລັກ (ID) ຊ່ວຍແກ້ໄຂບັນຫານີ້, ແລະ Tuzik ຂອງຂ້ອຍຖືກຜູກມັດກັບ ID ນີ້, ເຊິ່ງໃນຕົວຈິງແລ້ວ, ແມ່ນພຽງແຕ່ເລກລໍາດັບ. ດັ່ງນັ້ນ, ເຈົ້າຂອງຂອງ ace ມີ ID ເລກ 2, ແລະໃນບາງເວລາ Ivan ຢູ່ພາຍໃຕ້ ID ນີ້, ແລະຫຼັງຈາກນັ້ນ Olya ຢູ່ພາຍໃຕ້ ID ດຽວກັນ. ບັນຫາ​ມະນຸດ​ແລະ​ການ​ລ້ຽງສັດ​ໄດ້​ຮັບ​ການ​ແກ້​ໄຂ​ຢ່າງ​ຕັ້ງໜ້າ.

ຕົວອະທິບາຍໄຟລ໌

ບັນຫາຂອງໄຟລ໌ແລະໂຄງການທີ່ເຮັດວຽກກັບໄຟລ໌ນີ້ແມ່ນປະມານຄືກັນກັບຫມາແລະຜູ້ຊາຍຂອງພວກເຮົາ. ສົມມຸດວ່າຂ້ອຍໄດ້ເປີດໄຟລ໌ທີ່ເອີ້ນວ່າ ivan.txt ແລະເລີ່ມຂຽນຄໍາ tuzik ເຂົ້າໄປໃນມັນ, ແຕ່ສາມາດຂຽນຕົວອັກສອນທໍາອິດ "t" ໃນໄຟລ໌, ແລະໄຟລ໌ນີ້ຖືກປ່ຽນຊື່ໂດຍຜູ້ໃດຜູ້ຫນຶ່ງ, ຕົວຢ່າງ, ເປັນ olya.txt. ແຕ່ໄຟລ໌ຍັງຄົງຢູ່ຄືເກົ່າ, ແລະຂ້ອຍຍັງຕ້ອງການບັນທຶກ ace ຂອງຂ້ອຍຢູ່ໃນມັນ. ທຸກໆຄັ້ງເປີດໄຟລ໌ໂດຍການໂທຫາລະບົບ ເປີດ ໃນພາສາການຂຽນໂປລແກລມໃດກໍ່ຕາມຂ້ອຍໄດ້ຮັບ ID ທີ່ເປັນເອກະລັກທີ່ຊີ້ຂ້ອຍໄປຫາໄຟລ໌, ID ນີ້ແມ່ນຕົວອະທິບາຍໄຟລ໌. ແລະມັນບໍ່ສໍາຄັນວ່າແມ່ນຫຍັງແລະໃຜເຮັດກັບໄຟລ໌ນີ້ຕໍ່ໄປ, ມັນສາມາດຖືກລຶບ, ມັນສາມາດປ່ຽນຊື່, ເຈົ້າຂອງສາມາດປ່ຽນໄດ້, ຫຼືສິດໃນການອ່ານແລະຂຽນສາມາດຖືກເອົາໄປ, ຂ້ອຍຍັງສາມາດເຂົ້າເຖິງໄດ້. ກັບມັນ, ເພາະວ່າໃນເວລາທີ່ເປີດໄຟລ໌, ຂ້ອຍມີສິດທີ່ຈະອ່ານແລະ / ຫຼືຂຽນມັນແລະຂ້ອຍສາມາດເລີ່ມຕົ້ນເຮັດວຽກກັບມັນ, ຊຶ່ງຫມາຍຄວາມວ່າຂ້ອຍຕ້ອງສືບຕໍ່ເຮັດ.

ໃນ Linux, ຫ້ອງສະຫມຸດ libc ເປີດ 3 ໄຟລ໌ descriptor ສໍາລັບແຕ່ລະຄໍາຮ້ອງສະຫມັກທີ່ເຮັດວຽກ (ຂະບວນການ), ເລກ 0,1,2. ຂໍ້ມູນເພີ່ມເຕີມສາມາດພົບໄດ້ໃນການເຊື່ອມຕໍ່ ຜູ້ຊາຍ stdio и ຜູ້ຊາຍ stdout

• ຕົວອະທິບາຍໄຟລ໌ 0 ເອີ້ນວ່າ STDIN ແລະກ່ຽວຂ້ອງກັບການປ້ອນຂໍ້ມູນຂອງແອັບພລິເຄຊັນ
• ຕົວອະທິບາຍໄຟລ໌ 1 ຖືກເອີ້ນວ່າ STDOUT ແລະຖືກນໍາໃຊ້ໂດຍແອັບພລິເຄຊັນເພື່ອສົ່ງຂໍ້ມູນອອກ, ເຊັ່ນຄໍາສັ່ງພິມ
• ຕົວອະທິບາຍໄຟລ໌ 2 ເອີ້ນວ່າ STDERR ແລະຖືກໃຊ້ໂດຍແອັບພລິເຄຊັນເພື່ອສົ່ງຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດ.

ຖ້າຢູ່ໃນໂປຼແກຼມຂອງເຈົ້າເຈົ້າເປີດໄຟລ໌ໃດໆສໍາລັບການອ່ານຫຼືຂຽນ, ສ່ວນຫຼາຍອາດຈະໄດ້ຮັບ ID ຟຣີທໍາອິດແລະມັນຈະເປັນເລກ 3.

ບັນຊີລາຍຊື່ຂອງຕົວອະທິບາຍໄຟລ໌ສາມາດເບິ່ງໄດ້ສໍາລັບຂະບວນການໃດກໍ່ຕາມຖ້າທ່ານຮູ້ PID ຂອງມັນ.

ຕົວຢ່າງ, ໃຫ້ເປີດ bash console ແລະເບິ່ງ PID ຂອງຂະບວນການຂອງພວກເຮົາ

[user@localhost ]$ echo $$
15771

ໃນ console ທີສອງໃຫ້ພວກເຮົາດໍາເນີນການ

[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 ໄຟລ໌ descriptor ແມ່ນກ່ຽວຂ້ອງກັບອຸປະກອນ pseudo terminal /dev/pts, ແຕ່ພວກເຮົາຍັງສາມາດຫມູນໃຊ້ພວກມັນໄດ້, ຕົວຢ່າງ, ແລ່ນພວກມັນຢູ່ໃນຄອນໂຊທີສອງ

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

ແລະໃນ console ທໍາອິດພວກເຮົາຈະເຫັນ

[user@localhost ]$ hello world

ປ່ຽນເສັ້ນທາງແລະທໍ່

ທ່ານສາມາດ override ເຫຼົ່ານີ້ 3 ໄຟລ໌ descriptor ໄດ້ຢ່າງງ່າຍດາຍໃນຂະບວນການໃດຫນຶ່ງ, ລວມທັງໃນ bash, ສໍາລັບການຍົກຕົວຢ່າງໂດຍຜ່ານທໍ່ເຊື່ອມຕໍ່ສອງຂະບວນການ, ເບິ່ງ.

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

ທ່ານສາມາດດໍາເນີນການຄໍາສັ່ງນີ້ຕົວທ່ານເອງດ້ວຍ strace -f ແລະເບິ່ງສິ່ງທີ່ເກີດຂຶ້ນພາຍໃນ, ແຕ່ຂ້າພະເຈົ້າຈະບອກທ່ານໂດຍຫຍໍ້.

ຂະບວນການ bash ພໍ່ແມ່ຂອງພວກເຮົາກັບ PID 15771 parses ຄໍາສັ່ງຂອງພວກເຮົາແລະເຂົ້າໃຈຢ່າງແທ້ຈິງວ່າພວກເຮົາຕ້ອງການດໍາເນີນການຫຼາຍຄໍາສັ່ງ, ໃນກໍລະນີຂອງພວກເຮົາມີສອງຂອງເຂົາເຈົ້າ: cat ແລະນອນ. Bash ຮູ້ວ່າມັນຈໍາເປັນຕ້ອງສ້າງສອງຂະບວນການຂອງເດັກ, ແລະລວມພວກມັນເຂົ້າໄປໃນທໍ່ດຽວ. ໃນຈໍານວນທັງຫມົດ, bash ຈະຕ້ອງການ 2 ຂະບວນການເດັກແລະຫນຶ່ງທໍ່.

Bash ດໍາເນີນການໂທລະບົບກ່ອນທີ່ຈະສ້າງຂະບວນການເດັກນ້ອຍ ທໍ່ ແລະໄດ້ຮັບຕົວອະທິບາຍໄຟລ໌ໃຫມ່ໃນ buffer ທໍ່ຊົ່ວຄາວ, ແຕ່ buffer ນີ້ຍັງບໍ່ທັນເຊື່ອມຕໍ່ສອງຂະບວນການລູກຂອງພວກເຮົາ.

ສໍາລັບຂະບວນການຂອງພໍ່ແມ່, ເບິ່ງຄືວ່າມີທໍ່ແລ້ວ, ແຕ່ບໍ່ມີຂະບວນການຂອງເດັກນ້ອຍເທື່ອ:

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

ຫຼັງຈາກນັ້ນ, ການນໍາໃຊ້ລະບົບການໂທ clone 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 clones ຂະບວນການພ້ອມກັບ descriptors ໄຟລ໌ທັງຫມົດ, ດັ່ງນັ້ນເຂົາເຈົ້າຈະຄືກັນໃນຂະບວນການພໍ່ແມ່ແລະໃນເດັກນ້ອຍ. ວຽກງານຂອງຂະບວນການພໍ່ແມ່ທີ່ມີ PID 15771 ແມ່ນເພື່ອຕິດຕາມຂະບວນການຂອງເດັກ, ສະນັ້ນມັນພຽງແຕ່ລໍຖ້າການຕອບຮັບຈາກເດັກນ້ອຍ.

ດັ່ງນັ້ນ, ມັນບໍ່ຈໍາເປັນຕ້ອງທໍ່, ແລະມັນປິດຕົວອະທິບາຍໄຟລ໌ທີ່ມີເລກ 3 ແລະ 4.

ໃນຂະບວນການ bash ເດັກນ້ອຍຄັ້ງທໍາອິດກັບ PID 9004, ລະບົບໂທຫາ dup2, ປ່ຽນຕົວອະທິບາຍໄຟລ໌ STDOUT ຂອງພວກເຮົາເລກ 1 ເປັນຕົວອະທິບາຍໄຟລ໌ທີ່ຊີ້ໄປຫາທໍ່, ໃນກໍລະນີຂອງພວກເຮົາມັນເປັນເລກ 3. ດັ່ງນັ້ນ, ທຸກສິ່ງທຸກຢ່າງທີ່ຂະບວນການລູກທໍາອິດທີ່ມີ PID 9004 ຂຽນໃສ່ STDOUT ຈະສິ້ນສຸດລົງໂດຍອັດຕະໂນມັດໃນ buffer ທໍ່.

ໃນຂະບວນການລູກທີສອງກັບ PID 9005, bash ໃຊ້ dup2 ເພື່ອປ່ຽນໄຟລ໌ descriptor STDIN ເລກ 0. ໃນປັດຈຸບັນທຸກສິ່ງທຸກຢ່າງທີ່ bash ທີສອງຂອງພວກເຮົາກັບ PID 9005 ຈະອ່ານຈະຖືກອ່ານຈາກທໍ່.

ຫຼັງຈາກນີ້, ຕົວອະທິບາຍໄຟລ໌ເລກ 3 ແລະ 4 ຍັງຖືກປິດຢູ່ໃນຂະບວນການເດັກນ້ອຍ, ເພາະວ່າພວກມັນບໍ່ໄດ້ໃຊ້ອີກຕໍ່ໄປ.

ຂ້ອຍເຈດຕະນາລະເວັ້ນໄຟລ໌ descriptor 255; ມັນຖືກນໍາໃຊ້ເພື່ອຈຸດປະສົງພາຍໃນໂດຍ bash ຕົວມັນເອງແລະຍັງຈະຖືກປິດຢູ່ໃນຂະບວນການເດັກນ້ອຍ.

ຕໍ່ໄປ, ໃນຂະບວນການເດັກທໍາອິດທີ່ມີ PID 9004, bash ເລີ່ມໃຊ້ການໂທລະບົບ exec ໄຟລ໌ທີ່ສາມາດປະຕິບັດໄດ້ທີ່ພວກເຮົາລະບຸໄວ້ໃນເສັ້ນຄໍາສັ່ງ, ໃນກໍລະນີຂອງພວກເຮົາມັນແມ່ນ /usr/bin/cat.

ໃນຂະບວນການລູກທີສອງທີ່ມີ PID 9005, bash ດໍາເນີນການປະຕິບັດທີສອງທີ່ພວກເຮົາໄດ້ລະບຸໄວ້, ໃນກໍລະນີຂອງພວກເຮົາ /usr/bin/sleep.

ການໂທລະບົບ exec ບໍ່ປິດຕົວຈັດການໄຟລ໌ ເວັ້ນເສຍແຕ່ວ່າພວກມັນຖືກເປີດດ້ວຍທຸງ O_CLOEXEC ໃນເວລາໂທເປີດ. ໃນ​ກໍ​ລະ​ນີ​ຂອງ​ພວກ​ເຮົາ​, ຫຼັງ​ຈາກ​ການ​ເປີດ​ຕົວ​ໄຟລ​໌​ທີ່​ປະ​ຕິ​ບັດ​ໄດ້​, ການ​ອະ​ທິ​ບາຍ​ໄຟລ​໌​ທັງ​ຫມົດ​ໃນ​ປັດ​ຈຸ​ບັນ​ຈະ​ໄດ້​ຮັບ​ການ​ບັນ​ທຶກ​ໄວ້​.

ກວດເບິ່ງໃນ console:

[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 megabyte ຕໍ່ວິນາທີໃສ່ແຜ່ນ. ຍິ່ງໄປກວ່ານັ້ນ, ຖ້າເຫດຜົນບາງຢ່າງທີ່ພວກເຮົາບໍ່ສາມາດຂຽນຂໍ້ມູນໃສ່ແຜ່ນ, ພວກເຮົາຈະບໍ່ສົນໃຈເລື່ອງນີ້ແລະພະຍາຍາມຂຽນຂໍ້ມູນອີກເທື່ອຫນຶ່ງໃນວິນາທີ. ໃນຕົວຢ່າງທີ່ຂ້ອຍໃຊ້ 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 ຫຼັງຈາກລໍາຕົ້ນພຽງແຕ່ຖ້າພວກເຮົາເປີດໄຟລ໌ສໍາລັບການຂຽນເພີ່ມເຕີມ, ຊຶ່ງຫມາຍຄວາມວ່າໃນລະຫັດຂອງພວກເຮົາແທນ.

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

ການຂຽນໂປລແກລມຂະບວນການແລ່ນແລ້ວ

ປົກກະຕິແລ້ວນັກຂຽນໂປລແກລມ, ເມື່ອສ້າງແລະທົດສອບໂຄງການ, ໃຊ້ debuggers (ຕົວຢ່າງ GDB) ຫຼືລະດັບຕ່າງໆຂອງການເຂົ້າສູ່ລະບົບໃນແອັບພລິເຄຊັນ. Linux ສະຫນອງຄວາມສາມາດໃນການຂຽນແລະປ່ຽນແປງໂຄງການທີ່ເຮັດວຽກແລ້ວ, ຕົວຢ່າງ, ການປ່ຽນແປງຄ່າຂອງຕົວແປ, ກໍານົດຈຸດຢຸດ, ແລະອື່ນໆ.

ກັບຄືນໄປຫາຄໍາຖາມຕົ້ນສະບັບກ່ຽວກັບພື້ນທີ່ດິດບໍ່ພຽງພໍໃນການຂຽນໄຟລ໌, ໃຫ້ພະຍາຍາມຈໍາລອງບັນຫາ.

ໃຫ້ສ້າງໄຟລ໌ສໍາລັບພາທິຊັນຂອງພວກເຮົາ, ເຊິ່ງພວກເຮົາຈະ mount ເປັນແຜ່ນແຍກຕ່າງຫາກ:

[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% occupied.

ພວກເຮົາຈື່ໄວ້ວ່າອີງຕາມເງື່ອນໄຂຂອງວຽກງານ, ພວກເຮົາພະຍາຍາມບັນທຶກຂໍ້ມູນທີ່ສໍາຄັນຫຼາຍທີ່ບໍ່ສາມາດສູນເສຍໄດ້. ແລະໃນເວລາດຽວກັນ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ແກ້ໄຂການບໍລິການໂດຍບໍ່ມີການ restart ຂະບວນການ.

ໃຫ້ເວົ້າວ່າພວກເຮົາຍັງມີພື້ນທີ່ດິດ, ແຕ່ຢູ່ໃນພາທິຊັນທີ່ແຕກຕ່າງກັນ, ຕົວຢ່າງໃນ / home.

ໃຫ້ພະຍາຍາມ "reprogram on the fly" ລະຫັດຂອງພວກເຮົາ.

ໃຫ້ເບິ່ງ 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

ພວກເຮົາເບິ່ງຂໍ້ມູນກ່ຽວກັບໄຟລ໌ descriptor ເລກ 3, ເຊິ່ງພວກເຮົາສົນໃຈ

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

ຈື່ໄວ້ວ່າລະບົບເອີ້ນວ່າ Python ແມ່ນຫຍັງ (ເບິ່ງຂ້າງເທິງບ່ອນທີ່ພວກເຮົາແລ່ນ strace ແລະພົບເຫັນການໂທເປີດ), ເມື່ອປະມວນຜົນລະຫັດຂອງພວກເຮົາເພື່ອເປີດໄຟລ໌, ພວກເຮົາເຮັດເຊັ່ນດຽວກັນໃນນາມຂອງຂະບວນການຂອງພວກເຮົາ, ແຕ່ພວກເຮົາຕ້ອງການ O_WRONLY|O_CREAT| O_TRUNC bits ແທນທີ່ດ້ວຍຄ່າຕົວເລກ. ເພື່ອເຮັດສິ່ງນີ້, ເປີດແຫຼ່ງ 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

ພວກເຮົາຈື່ຈໍາຕົວຢ່າງທີ່ມີທໍ່ - how bash ປ່ຽນແປງໄຟລ໌ descriptors, ແລະພວກເຮົາໄດ້ຮຽນຮູ້ການໂທຫາລະບົບ 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

ບໍ່ມີຂໍ້ມູນສູນເສຍ, ແອັບພລິເຄຊັນເຮັດວຽກ, ບັນທຶກຖືກຂຽນໄວ້ໃນສະຖານທີ່ໃຫມ່.

ໃຫ້ complicate ວຽກງານເລັກນ້ອຍ

ລອງຈິນຕະນາການວ່າຂໍ້ມູນມີຄວາມສໍາຄັນກັບພວກເຮົາ, ແຕ່ພວກເຮົາບໍ່ມີພື້ນທີ່ດິສກ໌ຢູ່ໃນພາທິຊັນໃດໆ ​​ແລະພວກເຮົາບໍ່ສາມາດເຊື່ອມຕໍ່ແຜ່ນໄດ້.

ສິ່ງທີ່ພວກເຮົາສາມາດເຮັດໄດ້ແມ່ນການປ່ຽນເສັ້ນທາງຂໍ້ມູນຂອງພວກເຮົາຢູ່ບ່ອນໃດບ່ອນຫນຶ່ງ, ຕົວຢ່າງກັບທໍ່, ແລະເຮັດໃຫ້ການປ່ຽນເສັ້ນທາງຂໍ້ມູນຈາກທໍ່ໄປຫາເຄືອຂ່າຍໂດຍຜ່ານບາງໂຄງການ, ຕົວຢ່າງ 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 

ຢູ່ໃນເຊີບເວີທີ່ມີບັນຫາຂອງພວກເຮົາ, ພວກເຮົາເປີດຕົວໃນ terminal ແຍກຕ່າງຫາກ

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

ໃນປັດຈຸບັນຂໍ້ມູນທັງຫມົດທີ່ສິ້ນສຸດລົງໃນທໍ່ຈະໄປຫາ stdin ໃນ netcat ໂດຍອັດຕະໂນມັດ, ເຊິ່ງຈະສົ່ງມັນໄປຫາເຄືອຂ່າຍໃນ 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_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 podcasts.

ດີທຸກຢ່າງ.

ໃນຖານະເປັນການເຮັດວຽກບ້ານ, ຂ້າພະເຈົ້າແນະນໍາໃຫ້ທ່ານຄິດກ່ຽວກັບສິ່ງທີ່ຈະຢູ່ໃນຂະບວນການ descriptors cat ແລະນອນຖ້າຫາກວ່າທ່ານດໍາເນີນການຄໍາສັ່ງຕໍ່ໄປນີ້:

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

ແຫຼ່ງຂໍ້ມູນ: www.habr.com