ວິທີການທໍ່ຖືກປະຕິບັດໃນ Unix

ບົດຄວາມນີ້ອະທິບາຍການປະຕິບັດຂອງທໍ່ໃນ Unix kernel. ຂ້າ​ພະ​ເຈົ້າ​ຜິດ​ຫວັງ​ບາງ​ຢ່າງ​ທີ່​ບົດ​ຄວາມ​ທີ່​ຜ່ານ​ມາ​ທີ່​ມີ​ຫົວ​ຂໍ້​ວ່າ ".ທໍ່ເຮັດວຽກແນວໃດໃນ Unix?» ຫັນອອກ ບໍ່ ກ່ຽວກັບໂຄງສ້າງພາຍໃນ. ຂ້າ​ພະ​ເຈົ້າ​ຢາກ​ຮູ້​ສຶກ​ຢາກ​ເຫັນ​ແລະ​ໄດ້​ຂຸດ​ຄົ້ນ​ເຂົ້າ​ໄປ​ໃນ​ແຫຼ່ງ​ຂໍ້​ມູນ​ເກົ່າ​ເພື່ອ​ຊອກ​ຫາ​ຄໍາ​ຕອບ.

ພວກເຮົາເວົ້າກ່ຽວກັບຫຍັງ?

ທໍ່ແມ່ນ "ອາດຈະເປັນສິ່ງປະດິດທີ່ສໍາຄັນທີ່ສຸດໃນ Unix" - ລັກສະນະທີ່ກໍານົດຂອງປັດຊະຍາພື້ນຖານຂອງ Unix ໃນການວາງໂຄງການຂະຫນາດນ້ອຍຮ່ວມກັນ, ແລະຄໍາຂວັນຂອງເສັ້ນຄໍາສັ່ງທີ່ຄຸ້ນເຄີຍ:

$ echo hello | wc -c
6

ຟັງຊັນນີ້ຂຶ້ນກັບການເອີ້ນລະບົບທີ່ໃຫ້ kernel pipe, ເຊິ່ງໄດ້ອະທິບາຍຢູ່ໃນຫນ້າເອກະສານ ທໍ່ (7) и ທໍ່ (2):

ທໍ່ສົ່ງໃຫ້ຊ່ອງທາງດຽວສໍາລັບການສື່ສານລະຫວ່າງຂະບວນການ. ທໍ່ມີວັດສະດຸປ້ອນ (ຂຽນທ້າຍ) ແລະຜົນຜະລິດ (ອ່ານຈົບ). ຂໍ້​ມູນ​ທີ່​ຂຽນ​ໃສ່​ການ​ປ້ອນ​ຂໍ້​ມູນ​ຂອງ​ທໍ່​ສາ​ມາດ​ອ່ານ​ໄດ້​ຢູ່​ທີ່​ຜົນ​ຜະ​ລິດ​ໄດ້​.

ທໍ່ແມ່ນຖືກສ້າງຂຶ້ນໂດຍການໂທຫາ pipe(2), ເຊິ່ງສົ່ງຄືນສອງຕົວອະທິບາຍໄຟລ໌: ຫນຶ່ງຫມາຍເຖິງການປ້ອນຂໍ້ມູນຂອງທໍ່, ທີສອງໄປຫາຜົນໄດ້ຮັບ.

ຜົນຜະລິດການຕິດຕາມຈາກຄໍາສັ່ງຂ້າງເທິງສະແດງໃຫ້ເຫັນການສ້າງທໍ່ແລະການໄຫຼເຂົ້າຂອງຂໍ້ມູນຜ່ານມັນຈາກຂະບວນການຫນຶ່ງໄປຫາອີກອັນຫນຶ່ງ:

$ strace -qf -e execve,pipe,dup2,read,write 
    sh -c 'echo hello | wc -c'

execve("/bin/sh", ["sh", "-c", "echo hello | wc -c"], …)
pipe([3, 4])                            = 0
[pid 2604795] dup2(4, 1)                = 1
[pid 2604795] write(1, "hellon", 6)    = 6
[pid 2604796] dup2(3, 0)                = 0
[pid 2604796] execve("/usr/bin/wc", ["wc", "-c"], …)
[pid 2604796] read(0, "hellon", 16384) = 6
[pid 2604796] write(1, "6n", 2)        = 2

ຂະບວນການພໍ່ແມ່ໂທຫາ pipe()ເພື່ອເອົາຕົວອະທິບາຍໄຟລ໌ທີ່ຕິດຄັດມາ. ຂະບວນການລູກໜຶ່ງຂຽນໃສ່ຕົວອະທິບາຍໜຶ່ງ ແລະຂະບວນການອື່ນອ່ານຂໍ້ມູນດຽວກັນຈາກຕົວອະທິບາຍອື່ນ. ແກະ "ປ່ຽນຊື່" ຕົວອະທິບາຍ 2 ແລະ 3 ດ້ວຍ dup4 ເພື່ອໃຫ້ກົງກັບ stdin ແລະ stdout.

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

ຖ້າຂະບວນການພະຍາຍາມອ່ານຈາກທໍ່ເປົ່າ, ຫຼັງຈາກນັ້ນ read(2) ຈະບລັອກຈົນກວ່າຂໍ້ມູນຈະສາມາດໃຊ້ໄດ້. ຖ້າຂະບວນການພະຍາຍາມຂຽນໃສ່ທໍ່ເຕັມ, ຫຼັງຈາກນັ້ນ write(2) ຈະປິດກັ້ນຈົນກ່ວາຂໍ້ມູນພຽງພໍໄດ້ຖືກອ່ານຈາກທໍ່ເພື່ອເຮັດສໍາເລັດການຂຽນ.

ເຊັ່ນດຽວກັນກັບຂໍ້ກໍານົດ POSIX, ນີ້ແມ່ນຊັບສິນທີ່ສໍາຄັນ: ການຂຽນໄປຫາທໍ່ເຖິງ PIPE_BUF bytes (ຢ່າງຫນ້ອຍ 512) ຈະຕ້ອງເປັນປະລໍາມະນູເພື່ອໃຫ້ຂະບວນການສາມາດສື່ສານກັບກັນແລະກັນໂດຍຜ່ານທໍ່ໃນວິທີການທີ່ໄຟລ໌ປົກກະຕິ (ທີ່ບໍ່ໄດ້ສະຫນອງການຮັບປະກັນດັ່ງກ່າວ) ບໍ່ສາມາດ.

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

ພວກເຮົາກໍາລັງຊອກຫາຫຍັງ?

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

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

ພວກເຮົາຊອກຫາຢູ່ໃສ?

ຂ້ອຍບໍ່ຮູ້ວ່າສຳເນົາປຶ້ມທີ່ມີຊື່ສຽງຂອງຂ້ອຍຢູ່ໃສ.ປື້ມບັນທຶກຊ້າງ« ດ້ວຍລະຫັດແຫຼ່ງ Unix 6, ແຕ່ຂໍຂອບໃຈ ສະມາຄົມມໍລະດົກ Unix ສາມາດຄົ້ນຫາອອນໄລນ໌ ລະຫັດແຫຼ່ງ ແມ້ແຕ່ລຸ້ນເກົ່າຂອງ Unix.

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

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

ໂດຍວິທີທາງການ, pipe ແມ່ນລະບົບການໂທເລກ 42 ໃນຕາຕະລາງ sysent[]. ບັງເອີນ?

ແກ່ນ Unix ແບບດັ້ງເດີມ (1970-1974)

ຂ້ອຍບໍ່ພົບຮ່ອງຮອຍໃດໆ pipe(2) ບໍ່ຢູ່ໃນ PDP-7 Unix (ເດືອນມັງກອນ 1970), ຫຼືໃນ Unix ສະບັບທໍາອິດ (ເດືອນພະຈິກ 1971), ຫຼືຢູ່ໃນລະຫັດແຫຼ່ງທີ່ບໍ່ຄົບຖ້ວນ ສະບັບທີສອງ (ເດືອນມິຖຸນາ 1972).

TUHS ອ້າງວ່າ Unix ສະບັບທີສາມ (ເດືອນກຸມພາ 1973) ແມ່ນສະບັບທໍາອິດທີ່ມີທໍ່:

ສະບັບທີສາມຂອງ Unix ແມ່ນສະບັບສຸດທ້າຍທີ່ມີ kernel ຂຽນໃນຕົວປະກອບ, ແຕ່ຍັງເປັນສະບັບທໍາອິດທີ່ມີທໍ່. ໃນລະຫວ່າງປີ 1973, ວຽກງານກໍາລັງດໍາເນີນເພື່ອປັບປຸງສະບັບທີສາມ, kernel ໄດ້ຖືກຂຽນຄືນໃຫມ່ໃນ C, ແລະດັ່ງນັ້ນສະບັບທີສີ່ຂອງ Unix ໄດ້ເກີດມາ.

ຜູ້ອ່ານຄົນຫນຶ່ງໄດ້ພົບເຫັນການສະແກນເອກະສານທີ່ Doug McIlroy ສະເຫນີແນວຄວາມຄິດຂອງ "ໂຄງການເຊື່ອມຕໍ່ເຊັ່ນທໍ່ສວນ."

ໃນປື້ມຂອງ Brian KernighanUnix: ປະຫວັດສາດແລະບັນທຶກ”, ປະຫວັດການປະກົດຕົວຂອງເຄື່ອງລຳລຽງຍັງກ່າວເຖິງເອກະສານນີ້ວ່າ: “... ມັນແຂວນຢູ່ເທິງຝາໃນຫ້ອງການຂອງຂ້ອຍຢູ່ Bell Labs ເປັນເວລາ 30 ປີ.” ທີ່ນີ້ ການສໍາພາດກັບ McIlroyແລະເລື່ອງອື່ນຈາກ ວຽກງານຂອງ McIlroy, ຂຽນໃນປີ 2014:

ເມື່ອ Unix ປະກົດຕົວ, ຄວາມກະຕືລືລົ້ນຂອງຂ້ອຍສໍາລັບ coroutines ເຮັດໃຫ້ຂ້ອຍຮ້ອງຂໍໃຫ້ຜູ້ຂຽນ OS, Ken Thompson, ອະນຸຍາດໃຫ້ຂໍ້ມູນທີ່ຖືກຂຽນໄວ້ໃນບາງຂະບວນການບໍ່ພຽງແຕ່ໄປຫາອຸປະກອນ, ແຕ່ຍັງໄປຫາຂະບວນການອື່ນ. Ken ຕັດສິນໃຈວ່າມັນເປັນໄປໄດ້. ຢ່າງໃດກໍຕາມ, ໃນຖານະທີ່ເປັນຄົນຫນ້ອຍ, ລາວຕ້ອງການໃຫ້ທຸກໆລະບົບມີບົດບາດສໍາຄັນ. ການຂຽນໂດຍກົງລະຫວ່າງຂະບວນການແມ່ນເປັນປະໂຫຍດອັນໃຫຍ່ຫຼວງຕໍ່ກັບການຂຽນໄຟລ໌ລະດັບກາງບໍ? ແລະພຽງແຕ່ເມື່ອຂ້ອຍໄດ້ສະເຫນີຂໍ້ສະເຫນີສະເພາະທີ່ມີຊື່ທີ່ຫນ້າຈັບໃຈ "ທໍ່" ແລະຄໍາອະທິບາຍກ່ຽວກັບ syntax ຂອງການໂຕ້ຕອບຂອງຂະບວນການ, Ken ສຸດທ້າຍໄດ້ຮ້ອງອອກມາວ່າ: "ຂ້ອຍຈະເຮັດມັນ!".

ແລະໄດ້ເຮັດ. ຕອນແລງໂຊກຊະຕາມື້ຫນຶ່ງ, Ken ໄດ້ປ່ຽນແກ່ນແລະແກະ, ແກ້ໄຂບັນດາໂຄງການມາດຕະຖານຈໍານວນຫນຶ່ງເພື່ອມາດຕະຖານວິທີການຍອມຮັບການປ້ອນຂໍ້ມູນ (ເຊິ່ງອາດຈະມາຈາກທໍ່), ແລະປ່ຽນຊື່ໄຟລ໌. ໃນມື້ຕໍ່ມາ, ທໍ່ໄດ້ຖືກນໍາໃຊ້ຢ່າງກວ້າງຂວາງໃນຄໍາຮ້ອງສະຫມັກ. ໃນຕອນທ້າຍຂອງອາທິດ, ເລຂານຸການໄດ້ໃຊ້ພວກເຂົາເພື່ອສົ່ງເອກະສານຈາກຕົວປະມວນຜົນຄໍາໄປຫາເຄື່ອງພິມ. ຕໍ່ມາ, Ken ໄດ້ປ່ຽນແທນ API ແລະ syntax ຕົ້ນສະບັບສໍາລັບການຫໍ່ການນໍາໃຊ້ທໍ່ກັບສົນທິສັນຍາທີ່ສະອາດທີ່ຖືກນໍາໃຊ້ຕັ້ງແຕ່ນັ້ນມາ.

ແຕ່ຫນ້າເສຍດາຍ, ລະຫັດແຫຼ່ງຂອງ Unix kernel ສະບັບທີສາມໄດ້ສູນເສຍໄປ. ແລະເຖິງແມ່ນວ່າພວກເຮົາມີລະຫັດແຫຼ່ງ kernel ຂຽນໃນ C ສະບັບທີສີ່, ເຊິ່ງໄດ້ຖືກປ່ອຍອອກມາໃນເດືອນພະຈິກ 1973, ແຕ່ມັນອອກມາສອງສາມເດືອນກ່ອນທີ່ຈະເປີດຕົວຢ່າງເປັນທາງການແລະບໍ່ມີການປະຕິບັດຂອງທໍ່. ມັນເປັນການເສຍໃຈທີ່ລະຫັດແຫຼ່ງສໍາລັບຄຸນສົມບັດ Unix legendary ນີ້ສູນເສຍ, ບາງທີຕະຫຼອດໄປ.

ພວກເຮົາມີເອກະສານເອກະສານສໍາລັບ pipe(2) ຈາກທັງສອງສະບັບ, ດັ່ງນັ້ນທ່ານສາມາດເລີ່ມຕົ້ນໂດຍການຄົ້ນຫາເອກະສານ ສະບັບທີສາມ (ສຳລັບບາງຄຳ, ຂີດກ້ອງ "ດ້ວຍມື", ເປັນສະຕຣິງຂອງ ^H ຕົວອັກສອນຕາມດ້ວຍເຄື່ອງໝາຍຂີດກ້ອງ!). ນີ້ proto-pipe(2) ຖືກຂຽນໄວ້ໃນຕົວປະກອບແລະສົ່ງຄືນພຽງແຕ່ຫນຶ່ງຕົວອະທິບາຍໄຟລ໌, ແຕ່ສະຫນອງການເຮັດວຽກຫຼັກທີ່ຄາດໄວ້ແລ້ວ:

ໂທລະບົບ ທໍ່ ສ້າງກົນໄກ I/O ທີ່ເອີ້ນວ່າ pipeline. ຕົວອະທິບາຍໄຟລ໌ທີ່ສົ່ງຄືນສາມາດຖືກນໍາໃຊ້ສໍາລັບການອ່ານແລະຂຽນການດໍາເນີນງານ. ເມື່ອບາງສິ່ງບາງຢ່າງຖືກຂຽນໃສ່ທໍ່, ມັນ buffers ເຖິງ 504 bytes ຂອງຂໍ້ມູນ, ຫຼັງຈາກນັ້ນຂະບວນການຂຽນຖືກໂຈະ. ເມື່ອອ່ານຈາກທໍ່, ຂໍ້ມູນທີ່ຖືກ buffed ໄດ້ຖືກປະຕິບັດ.

ໃນປີຕໍ່ມາ, kernel ໄດ້ຖືກຂຽນຄືນໃຫມ່ໃນ C, ແລະ pipe(2) ສະບັບທີສີ່ ໄດ້​ຮັບ​ຮູບ​ແບບ​ທີ່​ທັນ​ສະ​ໄຫມ​ຂອງ​ຕົນ​ກັບ​ຕົ້ນ​ແບບ "pipe(fildes)"

ໂທລະບົບ ທໍ່ ສ້າງກົນໄກ I/O ທີ່ເອີ້ນວ່າທໍ່ສົ່ງ. ຕົວອະທິບາຍໄຟລ໌ທີ່ສົ່ງຄືນສາມາດຖືກນໍາໃຊ້ໃນການດໍາເນີນງານການອ່ານແລະຂຽນ. ເມື່ອບາງສິ່ງບາງຢ່າງຖືກຂຽນໃສ່ທໍ່, ຕົວອະທິບາຍກັບຄືນໃນ r1 (resp. fildes[1]) ຖືກນໍາໃຊ້, buffed ເຖິງ 4096 bytes ຂອງຂໍ້ມູນ, ຫຼັງຈາກນັ້ນຂະບວນການຂຽນຖືກໂຈະ. ເມື່ອອ່ານຈາກທໍ່, ຕົວອະທິບາຍກັບຄືນໄປຫາ r0 (resp. fildes[0]) ເອົາຂໍ້ມູນ.

ມັນສົມມຸດວ່າເມື່ອທໍ່ໄດ້ຖືກກໍານົດ, ສອງ (ຫຼືຫຼາຍກວ່າ) ຂະບວນການປະຕິສໍາພັນ (ສ້າງໂດຍການຮຽກຮ້ອງຕໍ່ໄປ. fork) ຈະຜ່ານຂໍ້ມູນຈາກທໍ່ໂດຍໃຊ້ການໂທ ອ່ານ и ຂຽນ.

Shell ມີ syntax ສໍາລັບກໍານົດ array linear ຂອງຂະບວນການທີ່ເຊື່ອມຕໍ່ຜ່ານທໍ່.

ໂທຫາເພື່ອອ່ານຈາກທໍ່ຫວ່າງເປົ່າ (ບໍ່ມີຂໍ້ມູນທີ່ມີ buffered) ທີ່ມີຈຸດຈົບພຽງແຕ່ຫນຶ່ງ (ຕົວອະທິບາຍໄຟລ໌ທັງຫມົດທີ່ປິດ) ກັບຄືນ "ສິ້ນສຸດຂອງໄຟລ໌". ຂຽນການໂທໃນສະຖານະການທີ່ຄ້າຍຄືກັນແມ່ນຖືກລະເລີຍ.

ໄວທີ່ສຸດ ການຈັດຕັ້ງປະຕິບັດທໍ່ທີ່ຖືກຮັກສາໄວ້ ໝາຍ ເຖິງ ຈົນເຖິງສະບັບທີ XNUMX ຂອງ Unix (ເດືອນມິຖຸນາ 1974), ແຕ່ມັນເກືອບຄືກັນກັບທີ່ປາກົດຢູ່ໃນການປ່ອຍຕໍ່ໄປ. ພຽງແຕ່ຄໍາເຫັນເພີ່ມ, ດັ່ງນັ້ນສະບັບທີຫ້າສາມາດຂ້າມໄດ້.

Unix ສະບັບທີຫົກ (1975)

ເລີ່ມອ່ານລະຫັດແຫຼ່ງ Unix ສະບັບທີຫົກ (ເດືອນພຶດສະພາ 1975). ຂອບໃຈເປັນສ່ວນໃຫຍ່ ຊ້າງ ມັນ​ເປັນ​ຫຼາຍ​ງ່າຍ​ທີ່​ຈະ​ຊອກ​ຫາ​ກ​່​ວາ​ແຫຼ່ງ​ຂໍ້​ມູນ​ຂອງ​ສະ​ບັບ​ກ່ອນ​ຫນ້າ​ນີ້​:

ສໍາລັບເວລາຫຼາຍປີຫນັງສື ຊ້າງ ເປັນເອກະສານດຽວໃນ kernel Unix ທີ່ມີຢູ່ໃນ Bell Labs. ເຖິງແມ່ນວ່າໃບອະນຸຍາດສະບັບທີ XNUMX ໄດ້ອະນຸຍາດໃຫ້ຄູສອນໃຊ້ລະຫັດແຫຼ່ງຂອງມັນ, ແຕ່ໃບອະນຸຍາດສະບັບທີ XNUMX ບໍ່ໄດ້ລວມເອົາຄວາມເປັນໄປໄດ້ນີ້, ດັ່ງນັ້ນປື້ມດັ່ງກ່າວໄດ້ຖືກແຈກຢາຍໃນສໍາເນົາທີ່ຂຽນຜິດກົດຫມາຍ.

ມື້​ນີ້​ເຈົ້າ​ສາມາດ​ຊື້​ປຶ້ມ​ທີ່​ພິມ​ຄືນ​ໃໝ່​ໄດ້, ໜ້າ​ປົກ​ທີ່​ສະ​ແດງ​ໃຫ້​ເຫັນ​ນັກ​ສຶກສາ​ຢູ່​ໃນ​ເຄື່ອງ​ສຳເນົາ. ແລະຂໍຂອບໃຈກັບ Warren Toomey (ຜູ້ທີ່ໄດ້ເລີ່ມຕົ້ນໂຄງການ TUHS), ທ່ານສາມາດດາວໂຫລດໄດ້ ສະບັບທີ VI ແຫຼ່ງ PDF. ຂ້ອຍຕ້ອງການໃຫ້ເຈົ້າຮູ້ວ່າຄວາມພະຍາຍາມຫຼາຍປານໃດເຂົ້າໄປໃນການສ້າງໄຟລ໌:

ຫຼາຍກວ່າ 15 ປີກ່ອນຫນ້ານີ້, ຂ້າພະເຈົ້າໄດ້ພິມສໍາເນົາຂອງລະຫັດແຫຼ່ງທີ່ສະຫນອງໃຫ້ຢູ່ໃນ ຊ້າງເພາະວ່າຂ້ອຍບໍ່ມັກຄຸນນະພາບຂອງສຳເນົາຂອງຂ້ອຍຈາກສຳເນົາອື່ນທີ່ບໍ່ຮູ້ຈັກ. TUHS ຍັງບໍ່ທັນມີເທື່ອ, ແລະຂ້ອຍບໍ່ສາມາດເຂົ້າເຖິງແຫຼ່ງເກົ່າ. ແຕ່​ໃນ​ປີ 1988 ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ພົບ​ເຫັນ tape ເກົ່າ​ທີ່​ມີ 9 ເພງ​ທີ່​ມີ​ສໍາ​ຮອງ​ຂໍ້​ມູນ​ຈາກ​ຄອມ​ພິວ​ເຕີ PDP11​. ມັນເປັນການຍາກທີ່ຈະຮູ້ວ່າມັນເຮັດວຽກ, ແຕ່ວ່າມີຕົ້ນໄມ້ /usr/src/ intact ທີ່ໄຟລ໌ສ່ວນໃຫຍ່ຖືກຫມາຍໃນປີ 1979, ເຊິ່ງເຖິງແມ່ນວ່າເບິ່ງຄືເກົ່າ. ມັນແມ່ນສະບັບທີເຈັດ, ຫຼືເປັນອະນຸພັນ PWB, ຂ້າພະເຈົ້າຄິດວ່າ.

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

ແລະມື້ນີ້ພວກເຮົາສາມາດອ່ານອອນໄລນ໌ຢູ່ TUHS ລະຫັດແຫຼ່ງຂອງສະບັບທີ VI ຂອງ ຮວບຮວມ, ເຊິ່ງ Dennis Ritchie ມີມື.

ໂດຍວິທີທາງການ, ຢູ່ glance ທໍາອິດ, ລັກສະນະຕົ້ນຕໍຂອງລະຫັດ C ກ່ອນໄລຍະເວລາຂອງ Kernighan ແລະ Ritchie ແມ່ນຂອງຕົນ. ຫຍໍ້. ມັນບໍ່ເລື້ອຍໆທີ່ຂ້ອຍສາມາດໃສ່ຕົວຢ່າງຂອງລະຫັດໂດຍບໍ່ມີການດັດແກ້ຢ່າງກວ້າງຂວາງເພື່ອໃຫ້ເຫມາະສົມກັບພື້ນທີ່ສະແດງທີ່ຂ້ອນຂ້າງແຄບຢູ່ໃນເວັບໄຊທ໌ຂອງຂ້ອຍ.

ໃນຕອນເລີ່ມຕົ້ນ /usr/sys/ken/pipe.c ມີຄໍາເຫັນອະທິບາຍ (ແລະແມ່ນແລ້ວ, ມີຫຼາຍກວ່ານັ້ນ /usr/sys/dmr):

/*
 * Max allowable buffering per pipe.
 * This is also the max size of the
 * file created to implement the pipe.
 * If this size is bigger than 4096,
 * pipes will be implemented in LARG
 * files, which is probably not good.
 */
#define    PIPSIZ    4096

ຂະຫນາດຂອງບັຟເຟີບໍ່ໄດ້ປ່ຽນແປງນັບຕັ້ງແຕ່ສະບັບທີສີ່. ແຕ່ໃນທີ່ນີ້ພວກເຮົາເຫັນ, ໂດຍບໍ່ມີເອກະສານສາທາລະນະໃດໆ, ທໍ່ນັ້ນເຄີຍໃຊ້ໄຟລ໌ເປັນບ່ອນເກັບຂໍ້ມູນສຳຮອງ!

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

ນີ້ແມ່ນການໂທລະບົບທີ່ແທ້ຈິງ pipe:

/*
 * The sys-pipe entry.
 * Allocate an inode on the root device.
 * Allocate 2 file structures.
 * Put it all together with flags.
 */
pipe()
{
    register *ip, *rf, *wf;
    int r;

    ip = ialloc(rootdev);
    if(ip == NULL)
        return;
    rf = falloc();
    if(rf == NULL) {
        iput(ip);
        return;
    }
    r = u.u_ar0[R0];
    wf = falloc();
    if(wf == NULL) {
        rf->f_count = 0;
        u.u_ofile[r] = NULL;
        iput(ip);
        return;
    }
    u.u_ar0[R1] = u.u_ar0[R0]; /* wf's fd */
    u.u_ar0[R0] = r;           /* rf's fd */
    wf->f_flag = FWRITE|FPIPE;
    wf->f_inode = ip;
    rf->f_flag = FREAD|FPIPE;
    rf->f_inode = ip;
    ip->i_count = 2;
    ip->i_flag = IACC|IUPD;
    ip->i_mode = IALLOC;
}

ຄໍາຄິດຄໍາເຫັນອະທິບາຍຢ່າງຊັດເຈນວ່າສິ່ງທີ່ເກີດຂຶ້ນຢູ່ທີ່ນີ້. ແຕ່ມັນບໍ່ງ່າຍທີ່ຈະເຂົ້າໃຈລະຫັດ, ສ່ວນຫນຶ່ງແມ່ນຍ້ອນວິທີການ "ໂຄງສ້າງຜູ້ໃຊ້ u»ແລະລົງທະບຽນ R0 и R1 ຕົວກໍານົດການໂທຫາລະບົບແລະຄ່າກັບຄືນແມ່ນຜ່ານ.

ລອງໃຊ້ກັບ ialloc() ວາງໃສ່ແຜ່ນ ໄອໂອດ (inode), ແລະດ້ວຍການຊ່ວຍເຫຼືອ falloc() - ເກັບຮັກສາສອງ ໄຟລ. ຖ້າທັງຫມົດດີ, ພວກເຮົາຈະຕັ້ງທຸງເພື່ອກໍານົດໄຟລ໌ເຫຼົ່ານີ້ເປັນສອງສົ້ນຂອງທໍ່, ຊີ້ພວກມັນໄປຫາ inode ດຽວກັນ (ເຊິ່ງຄໍາອ້າງອີງກາຍເປັນ 2), ແລະຫມາຍ inode ທີ່ຖືກດັດແກ້ແລະຖືກນໍາໃຊ້. ເອົາໃຈໃສ່ກັບຄໍາຮ້ອງຂໍ ຂ້ອຍ​ເອົາ​ໃສ່() ໃນເສັ້ນທາງຄວາມຜິດພາດທີ່ຈະຫຼຸດລົງການນັບອ້າງອີງໃນ inode ໃຫມ່.

pipe() ຜ່ານ​ການ R0 и R1 ກັບຄືນຕົວເລກຕົວອະທິບາຍໄຟລ໌ສໍາລັບການອ່ານແລະຂຽນ. falloc() ສົ່ງຄືນຕົວຊີ້ໄປຫາໂຄງສ້າງໄຟລ໌, ແຕ່ຍັງ "ກັບຄືນ" ຜ່ານ u.u_ar0[R0] ແລະຕົວອະທິບາຍໄຟລ໌. ນັ້ນແມ່ນ, ລະຫັດຖືກເກັບໄວ້ໃນ r file descriptor ສໍາລັບການອ່ານແລະມອບຫມາຍ descriptor ສໍາລັບການຂຽນໂດຍກົງຈາກ u.u_ar0[R0] ຫຼັງ​ຈາກ​ການ​ໂທ​ຄັ້ງ​ທີ​ສອງ​ falloc().

Flag FPIPE, ທີ່ພວກເຮົາກໍານົດໃນເວລາທີ່ສ້າງທໍ່, ຄວບຄຸມພຶດຕິກໍາຂອງຫນ້າທີ່ rdwr() ໃນ sys2.c, ເຊິ່ງເອີ້ນສະເພາະ I / O routines:

/*
 * common code for read and write calls:
 * check permissions, set base, count, and offset,
 * and switch out to readi, writei, or pipe code.
 */
rdwr(mode)
{
    register *fp, m;

    m = mode;
    fp = getf(u.u_ar0[R0]);
        /* … */

    if(fp->f_flag&FPIPE) {
        if(m==FREAD)
            readp(fp); else
            writep(fp);
    }
        /* … */
}

ຫຼັງຈາກນັ້ນ, ຫນ້າທີ່ readp() в pipe.c ອ່ານຂໍ້ມູນຈາກທໍ່. ແຕ່ມັນກໍ່ດີກວ່າທີ່ຈະຕິດຕາມການປະຕິບັດທີ່ເລີ່ມຕົ້ນຈາກ writep(). ອີກເທື່ອຫນຶ່ງ, ລະຫັດໄດ້ກາຍເປັນຄວາມສັບສົນຫຼາຍເນື່ອງຈາກລັກສະນະຂອງການໂຕ້ຖຽງທີ່ຜ່ານສົນທິສັນຍາ, ແຕ່ບາງລາຍລະອຽດສາມາດຖືກຍົກເລີກ.

writep(fp)
{
    register *rp, *ip, c;

    rp = fp;
    ip = rp->f_inode;
    c = u.u_count;

loop:
    /* If all done, return. */

    plock(ip);
    if(c == 0) {
        prele(ip);
        u.u_count = 0;
        return;
    }

    /*
     * If there are not both read and write sides of the
     * pipe active, return error and signal too.
     */

    if(ip->i_count < 2) {
        prele(ip);
        u.u_error = EPIPE;
        psignal(u.u_procp, SIGPIPE);
        return;
    }

    /*
     * If the pipe is full, wait for reads to deplete
     * and truncate it.
     */

    if(ip->i_size1 == PIPSIZ) {
        ip->i_mode =| IWRITE;
        prele(ip);
        sleep(ip+1, PPIPE);
        goto loop;
    }

    /* Write what is possible and loop back. */

    u.u_offset[0] = 0;
    u.u_offset[1] = ip->i_size1;
    u.u_count = min(c, PIPSIZ-u.u_offset[1]);
    c =- u.u_count;
    writei(ip);
    prele(ip);
    if(ip->i_mode&IREAD) {
        ip->i_mode =& ~IREAD;
        wakeup(ip+2);
    }
    goto loop;
}

ພວກເຮົາຕ້ອງການຂຽນ bytes ເຂົ້າໃນການປ້ອນຂໍ້ມູນທໍ່ u.u_count. ທໍາອິດພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ລັອກ inode (ເບິ່ງຂ້າງລຸ່ມນີ້ plock/prele).

ຫຼັງຈາກນັ້ນ, ພວກເຮົາກວດເບິ່ງການນັບອ້າງອີງ inode. ຕາບໃດທີ່ທັງສອງສົ້ນຂອງທໍ່ຍັງເປີດຢູ່, ເຄົາເຕີຄວນຈະເປັນ 2. ພວກເຮົາຍຶດຕິດກັບການເຊື່ອມຕໍ່ດຽວ (ຈາກ. rp->f_inode), ດັ່ງນັ້ນຖ້າ counter ຫນ້ອຍກວ່າ 2, ນີ້ຄວນຈະຫມາຍຄວາມວ່າຂະບວນການອ່ານໄດ້ປິດທ້າຍຂອງທໍ່ຂອງມັນ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ພວກເຮົາກໍາລັງພະຍາຍາມຂຽນເຖິງທໍ່ປິດ, ເຊິ່ງເປັນຄວາມຜິດພາດ. ລະຫັດຄວາມຜິດພາດຄັ້ງທໍາອິດ EPIPE ແລະສັນຍານ SIGPIPE ປະກົດຢູ່ໃນສະບັບທີ VI ຂອງ Unix.

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

ຖ້າມີພື້ນທີ່ຫວ່າງພຽງພໍໃນທໍ່, ພວກເຮົາຂຽນຂໍ້ມູນໃສ່ມັນໂດຍໃຊ້ ຂຽນ(). ພາລາມິເຕີ i_size1 inode'a (ມີທໍ່ເປົ່າສາມາດເທົ່າກັບ 0) ຊີ້ໃຫ້ເຫັນເຖິງຈຸດສິ້ນສຸດຂອງຂໍ້ມູນທີ່ມັນມີຢູ່ແລ້ວ. ຖ້າມີພື້ນທີ່ພຽງພໍທີ່ຈະຂຽນ, ພວກເຮົາສາມາດຕື່ມຂໍ້ມູນໃສ່ທໍ່ຈາກ i_size1 ການ PIPESIZ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາປ່ອຍຕົວລັອກແລະພະຍາຍາມປຸກຂະບວນການໃດໆທີ່ລໍຖ້າການອ່ານຈາກທໍ່. ພວກເຮົາກັບຄືນໄປຫາຈຸດເລີ່ມຕົ້ນເພື່ອເບິ່ງວ່າພວກເຮົາໄດ້ຈັດການການຂຽນຫຼາຍ bytes ເທົ່າທີ່ພວກເຮົາຕ້ອງການ. ຖ້າບໍ່, ພວກເຮົາເລີ່ມຕົ້ນຮອບບັນທຶກໃຫມ່.

ປົກກະຕິແລ້ວພາລາມິເຕີ i_mode inode ຖືກນໍາໃຊ້ເພື່ອເກັບຮັກສາການອະນຸຍາດ r, w и x. ແຕ່ໃນກໍລະນີຂອງທໍ່, ພວກເຮົາສັນຍານວ່າຂະບວນການບາງຢ່າງແມ່ນລໍຖ້າການຂຽນຫຼືອ່ານໂດຍໃຊ້ bits IREAD и IWRITE ຕາມລໍາດັບ. ຂະບວນການກໍານົດທຸງແລະໂທຫາ sleep(), ແລະຄາດວ່າໃນອະນາຄົດບາງຂະບວນການອື່ນໆຈະໂທຫາ wakeup().

magic ທີ່ແທ້ຈິງເກີດຂຶ້ນໃນ sleep() и wakeup(). ພວກເຂົາເຈົ້າໄດ້ຖືກປະຕິບັດໃນ slp.c, ແຫຼ່ງທີ່ມີຊື່ສຽງ "ທ່ານບໍ່ຄາດວ່າຈະເຂົ້າໃຈນີ້" ຄໍາເຫັນ. ໂຊກດີ, ພວກເຮົາບໍ່ຈໍາເປັນຕ້ອງເຂົ້າໃຈລະຫັດ, ພຽງແຕ່ເບິ່ງບາງຄໍາເຫັນ:

/*
 * Give up the processor till a wakeup occurs
 * on chan, at which time the process
 * enters the scheduling queue at priority pri.
 * The most important effect of pri is that when
 * pri<0 a signal cannot disturb the sleep;
 * if pri>=0 signals will be processed.
 * Callers of this routine must be prepared for
 * premature return, and check that the reason for
 * sleeping has gone away.
 */
sleep(chan, pri) /* … */

/*
 * Wake up all processes sleeping on chan.
 */
wakeup(chan) /* … */

ຂະບວນການທີ່ໂທຫາ sleep() ສໍາລັບຊ່ອງທາງສະເພາະໃດຫນຶ່ງ, ຕໍ່ມາອາດຈະຖືກປຸກໂດຍຂະບວນການອື່ນ, ເຊິ່ງຈະໂທຫາ wakeup() ສໍາລັບຊ່ອງດຽວກັນ. writep() и readp() ປະສານງານການປະຕິບັດຂອງເຂົາເຈົ້າໂດຍຜ່ານການໂທຫາຄູ່ດັ່ງກ່າວ. ສັງເກດວ່າ pipe.c ຈັດລໍາດັບຄວາມສໍາຄັນສະເຫມີ PPIPE ເມື່ອເອີ້ນ sleep(), ດັ່ງນັ້ນທັງຫມົດ sleep() ສາມາດຖືກລົບກວນໂດຍສັນຍານ.

ໃນປັດຈຸບັນພວກເຮົາມີທຸກສິ່ງທຸກຢ່າງທີ່ຈະເຂົ້າໃຈຫນ້າທີ່ readp():

readp(fp)
int *fp;
{
    register *rp, *ip;

    rp = fp;
    ip = rp->f_inode;

loop:
    /* Very conservative locking. */

    plock(ip);

    /*
     * If the head (read) has caught up with
     * the tail (write), reset both to 0.
     */

    if(rp->f_offset[1] == ip->i_size1) {
        if(rp->f_offset[1] != 0) {
            rp->f_offset[1] = 0;
            ip->i_size1 = 0;
            if(ip->i_mode&IWRITE) {
                ip->i_mode =& ~IWRITE;
                wakeup(ip+1);
            }
        }

        /*
         * If there are not both reader and
         * writer active, return without
         * satisfying read.
         */

        prele(ip);
        if(ip->i_count < 2)
            return;
        ip->i_mode =| IREAD;
        sleep(ip+2, PPIPE);
        goto loop;
    }

    /* Read and return */

    u.u_offset[0] = 0;
    u.u_offset[1] = rp->f_offset[1];
    readi(ip);
    rp->f_offset[1] = u.u_offset[1];
    prele(ip);
}

ເຈົ້າອາດຈະພົບວ່າມັນງ່າຍຂຶ້ນໃນການອ່ານຟັງຊັນນີ້ຈາກລຸ່ມຫາເທິງ. ສາຂາ "ອ່ານແລະກັບຄືນ" ມັກຈະຖືກນໍາໃຊ້ເມື່ອມີຂໍ້ມູນບາງຢ່າງຢູ່ໃນທໍ່. ໃນກໍລະນີນີ້, ພວກເຮົາໃຊ້ ອ່ານ() ອ່ານ​ຂໍ້​ມູນ​ຫຼາຍ​ເທົ່າ​ທີ່​ມີ​ຢູ່​ໂດຍ​ເລີ່ມ​ຕົ້ນ​ຈາກ​ປະ​ຈຸ​ບັນ​ f_offset ອ່ານ, ແລະຫຼັງຈາກນັ້ນປັບປຸງມູນຄ່າຂອງການຊົດເຊີຍທີ່ສອດຄ້ອງກັນ.

ໃນການອ່ານຕໍ່ມາ, ທໍ່ນັ້ນຈະຫວ່າງເປົ່າຖ້າການຊົດເຊີຍການອ່ານມາຮອດແລ້ວ i_size1 ຢູ່ inode ໄດ້. ພວກເຮົາຕັ້ງຕໍາແຫນ່ງໃຫມ່ເປັນ 0 ແລະພະຍາຍາມປຸກຂະບວນການໃດໆທີ່ຕ້ອງການຂຽນໃສ່ທໍ່. ພວກເຮົາຮູ້ວ່າໃນເວລາທີ່ conveyor ເຕັມ, writep() ນອນຫລັບຢູ່ ip+1. ແລະໃນປັດຈຸບັນທີ່ທໍ່ນັ້ນຫວ່າງເປົ່າ, ພວກເຮົາສາມາດປຸກມັນຂຶ້ນມາເພື່ອສືບຕໍ່ຮອບວຽນການຂຽນຂອງມັນ.

ຖ້າບໍ່ມີຫຍັງທີ່ຈະອ່ານ, ຫຼັງຈາກນັ້ນ readp() ສາມາດຕັ້ງທຸງ IREAD ແລະນອນຫລັບ ip+2. ພວກເຮົາຮູ້ວ່າສິ່ງທີ່ຈະປຸກລາວ writep()ເມື່ອມັນຂຽນຂໍ້ມູນບາງຢ່າງໃສ່ທໍ່ນັ້ນ.

ຄໍາເຫັນກ່ຽວກັບ ອ່ານ() ແລະ writei() ຈະຊ່ວຍໃຫ້ທ່ານເຂົ້າໃຈວ່າແທນທີ່ຈະຜ່ານຕົວກໍານົດການຜ່ານ "u» ພວກ​ເຮົາ​ສາ​ມາດ​ປະ​ຕິ​ບັດ​ໃຫ້​ເຂົາ​ເຈົ້າ​ຄື​ຫນ້າ​ທີ່ I/O ປົກ​ກະ​ຕິ​ທີ່​ໃຊ້​ໄຟລ​໌​, ຕໍາ​ແຫນ່ງ​, buffer ໃນ​ຫນ່ວຍ​ຄວາມ​ຈໍາ​, ແລະ​ນັບ​ຈໍາ​ນວນ​ຂອງ bytes ທີ່​ຈະ​ອ່ານ​ຫຼື​ຂຽນ​.

/*
 * Read the file corresponding to
 * the inode pointed at by the argument.
 * The actual read arguments are found
 * in the variables:
 *    u_base        core address for destination
 *    u_offset    byte offset in file
 *    u_count        number of bytes to read
 *    u_segflg    read to kernel/user
 */
readi(aip)
struct inode *aip;
/* … */

/*
 * Write the file corresponding to
 * the inode pointed at by the argument.
 * The actual write arguments are found
 * in the variables:
 *    u_base        core address for source
 *    u_offset    byte offset in file
 *    u_count        number of bytes to write
 *    u_segflg    write to kernel/user
 */
writei(aip)
struct inode *aip;
/* … */

ໃນຖານະເປັນສໍາລັບການສະກັດ "ອະນຸລັກ", ຫຼັງຈາກນັ້ນ readp() и writep() lock inodes ຈົນກ່ວາພວກເຂົາເຈົ້າສໍາເລັດຫຼືໄດ້ຮັບຜົນໄດ້ຮັບ (ເຊັ່ນ: ໂທ wakeup). plock() и prele() ເຮັດວຽກງ່າຍໆ: ໃຊ້ຊຸດການໂທທີ່ແຕກຕ່າງກັນ sleep и wakeup ອະນຸຍາດໃຫ້ພວກເຮົາປຸກຂະບວນການໃດໆທີ່ຕ້ອງການລັອກທີ່ພວກເຮົາຫາກໍປ່ອຍອອກມາ:

/*
 * Lock a pipe.
 * If its already locked, set the WANT bit and sleep.
 */
plock(ip)
int *ip;
{
    register *rp;

    rp = ip;
    while(rp->i_flag&ILOCK) {
        rp->i_flag =| IWANT;
        sleep(rp, PPIPE);
    }
    rp->i_flag =| ILOCK;
}

/*
 * Unlock a pipe.
 * If WANT bit is on, wakeup.
 * This routine is also used to unlock inodes in general.
 */
prele(ip)
int *ip;
{
    register *rp;

    rp = ip;
    rp->i_flag =& ~ILOCK;
    if(rp->i_flag&IWANT) {
        rp->i_flag =& ~IWANT;
        wakeup(rp);
    }
}

ທໍາອິດຂ້ອຍບໍ່ເຂົ້າໃຈວ່າເປັນຫຍັງ readp() ບໍ່ໄດ້ເຮັດໃຫ້ເກີດ prele(ip) ກ່ອນການໂທ wakeup(ip+1). ສິ່ງທໍາອິດ writep() ໂທຫາໃນ loop ຂອງຕົນ, ນີ້ plock(ip), ເຊິ່ງສົ່ງຜົນໃຫ້ມີການຢຸດເຊົາຖ້າ readp() ຍັງບໍ່ທັນໄດ້ເອົາບລັອກຂອງມັນອອກເທື່ອ, ດັ່ງນັ້ນລະຫັດຈະຕ້ອງເຮັດວຽກຢ່າງຖືກຕ້ອງ. ຖ້າທ່ານເບິ່ງ wakeup(), ມັນຈະກາຍເປັນທີ່ຊັດເຈນວ່າມັນພຽງແຕ່ marks ຂະບວນການນອນແມ່ນກຽມພ້ອມສໍາລັບການປະຕິບັດ, ດັ່ງນັ້ນໃນອະນາຄົດ sched() ເປີດຕົວແທ້ໆ. ດັ່ງນັ້ນ readp() ສາເຫດ wakeup(), unlocks, ຊຸດ IREAD ແລະການໂທ sleep(ip+2)- ທັງຫມົດນີ້ກ່ອນ writep() ຣີສະຕາດຮອບວຽນ.

ນີ້ເຮັດສໍາເລັດຄໍາອະທິບາຍກ່ຽວກັບທໍ່ໃນສະບັບທີຫົກ. ລະຫັດງ່າຍດາຍ, ຜົນສະທ້ອນໄກ.

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

Xv6, ເປັນແກ່ນທີ່ຄ້າຍຄື Unix ງ່າຍດາຍ

ເພື່ອສ້າງນິວເຄລຍ Xv6 ໄດ້ຮັບອິດທິພົນຈາກສະບັບທີ 86 ຂອງ Unix, ແຕ່ຂຽນໃນ C ທີ່ທັນສະໄຫມເພື່ອດໍາເນີນການກັບໂປເຊດເຊີ x11. ລະຫັດແມ່ນງ່າຍທີ່ຈະອ່ານແລະເຂົ້າໃຈໄດ້. ນອກຈາກນີ້, ບໍ່ເຫມືອນກັບແຫຼ່ງ Unix ກັບ TUHS, ທ່ານສາມາດລວບລວມມັນ, ດັດແປງມັນ, ແລະດໍາເນີນການກັບສິ່ງອື່ນທີ່ບໍ່ແມ່ນ PDP 70/XNUMX. ດັ່ງນັ້ນ, ຫຼັກນີ້ຖືກນໍາໃຊ້ຢ່າງກວ້າງຂວາງໃນວິທະຍາໄລເປັນອຸປະກອນການສອນກ່ຽວກັບລະບົບປະຕິບັດການ. ແຫຼ່ງຂໍ້ມູນ ຢູ່ໃນ Github.

ລະຫັດປະກອບມີການປະຕິບັດທີ່ຊັດເຈນແລະຄິດ pipe.c, ສະຫນັບສະຫນູນໂດຍ buffer ໃນຫນ່ວຍຄວາມຈໍາແທນທີ່ຈະເປັນ inode ໃນແຜ່ນ. ໃນທີ່ນີ້ຂ້າພະເຈົ້າໃຫ້ຄໍານິຍາມຂອງ "ທໍ່ໂຄງສ້າງ" ແລະຫນ້າທີ່ເທົ່ານັ້ນ pipealloc():

#define PIPESIZE 512

struct pipe {
  struct spinlock lock;
  char data[PIPESIZE];
  uint nread;     // number of bytes read
  uint nwrite;    // number of bytes written
  int readopen;   // read fd is still open
  int writeopen;  // write fd is still open
};

int
pipealloc(struct file **f0, struct file **f1)
{
  struct pipe *p;

  p = 0;
  *f0 = *f1 = 0;
  if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
    goto bad;
  if((p = (struct pipe*)kalloc()) == 0)
    goto bad;
  p->readopen = 1;
  p->writeopen = 1;
  p->nwrite = 0;
  p->nread = 0;
  initlock(&p->lock, "pipe");
  (*f0)->type = FD_PIPE;
  (*f0)->readable = 1;
  (*f0)->writable = 0;
  (*f0)->pipe = p;
  (*f1)->type = FD_PIPE;
  (*f1)->readable = 0;
  (*f1)->writable = 1;
  (*f1)->pipe = p;
  return 0;

 bad:
  if(p)
    kfree((char*)p);
  if(*f0)
    fileclose(*f0);
  if(*f1)
    fileclose(*f1);
  return -1;
}

pipealloc() ກໍານົດສະຖານະຂອງສ່ວນທີ່ເຫຼືອທັງຫມົດຂອງການປະຕິບັດ, ເຊິ່ງປະກອບມີຫນ້າທີ່ piperead(), pipewrite() и pipeclose(). ໂທລະບົບຕົວຈິງ sys_pipe ເປັນ wrapper ປະຕິບັດໃນ sysfile.c. ຂ້ອຍຂໍແນະນໍາໃຫ້ອ່ານລະຫັດຂອງລາວທັງຫມົດ. ຄວາມສັບສົນແມ່ນຢູ່ໃນລະດັບຂອງລະຫັດແຫຼ່ງຂອງສະບັບທີ XNUMX, ແຕ່ມັນງ່າຍຂຶ້ນຫຼາຍແລະມີຄວາມສຸກຫຼາຍທີ່ຈະອ່ານ.

Linux 0.01

ທ່ານສາມາດຊອກຫາລະຫັດແຫຼ່ງສໍາລັບ Linux 0.01. ມັນຈະເປັນຄໍາແນະນໍາທີ່ຈະສຶກສາການຈັດຕັ້ງປະຕິບັດທໍ່ຢູ່ໃນລາວ fs/pipe.c. ໃນທີ່ນີ້, inode ຖືກນໍາໃຊ້ເພື່ອເປັນຕົວແທນຂອງທໍ່, ແຕ່ທໍ່ນັ້ນເອງແມ່ນຂຽນໃນ C ທີ່ທັນສະໄຫມ. ຖ້າທ່ານໄດ້ hack ວິທີການຂອງທ່ານຜ່ານລະຫັດສະບັບທີ XNUMX, ທ່ານຈະບໍ່ມີບັນຫາໃດໆຢູ່ທີ່ນີ້. ນີ້ແມ່ນສິ່ງທີ່ຫນ້າທີ່ເບິ່ງຄືວ່າ write_pipe():

int write_pipe(struct m_inode * inode, char * buf, int count)
{
    char * b=buf;

    wake_up(&inode->i_wait);
    if (inode->i_count != 2) { /* no readers */
        current->signal |= (1<<(SIGPIPE-1));
        return -1;
    }
    while (count-->0) {
        while (PIPE_FULL(*inode)) {
            wake_up(&inode->i_wait);
            if (inode->i_count != 2) {
                current->signal |= (1<<(SIGPIPE-1));
                return b-buf;
            }
            sleep_on(&inode->i_wait);
        }
        ((char *)inode->i_size)[PIPE_HEAD(*inode)] =
            get_fs_byte(b++);
        INC_PIPE( PIPE_HEAD(*inode) );
        wake_up(&inode->i_wait);
    }
    wake_up(&inode->i_wait);
    return b-buf;
}

ເຖິງແມ່ນວ່າບໍ່ໄດ້ເບິ່ງຄໍານິຍາມຂອງໂຄງສ້າງ, ທ່ານສາມາດຄິດອອກວິທີການຈໍານວນການອ້າງອິງ inode ຖືກນໍາໃຊ້ເພື່ອກວດເບິ່ງວ່າການດໍາເນີນການຂຽນຜົນໄດ້ຮັບໃນ. SIGPIPE. ນອກເຫນືອຈາກການເຮັດວຽກ byte-by-byte, ຫນ້າທີ່ນີ້ແມ່ນງ່າຍທີ່ຈະປຽບທຽບກັບແນວຄວາມຄິດຂ້າງເທິງ. ເຖິງແມ່ນວ່າເຫດຜົນ sleep_on/wake_up ບໍ່ໄດ້ເບິ່ງຄືມະນຸດຕ່າງດາວ.

Linux Kernels ທີ່ທັນສະໄຫມ, FreeBSD, NetBSD, OpenBSD

ຂ້າພະເຈົ້າໄດ້ໄປຜ່ານແກ່ນທີ່ທັນສະໄຫມບາງອັນຢ່າງໄວວາ. ບໍ່ມີໃຜໃນພວກມັນມີການປະຕິບັດທີ່ອີງໃສ່ແຜ່ນ (ບໍ່ແປກໃຈ). Linux ມີການປະຕິບັດຂອງຕົນເອງ. ແລະເຖິງແມ່ນວ່າສາມເມັດ BSD ທີ່ທັນສະໄຫມປະກອບດ້ວຍການປະຕິບັດໂດຍອີງໃສ່ລະຫັດທີ່ຖືກຂຽນໂດຍ John Dyson, ໃນໄລຍະປີທີ່ຜ່ານມາພວກເຂົາໄດ້ກາຍເປັນທີ່ແຕກຕ່າງກັນເກີນໄປຈາກກັນແລະກັນ.

ອ່ານ fs/pipe.c (ໃນ Linux) ຫຼື sys/kern/sys_pipe.c (ໃນ *BSD), ມັນໃຊ້ເວລາການອຸທິດທີ່ແທ້ຈິງ. ປະສິດທິພາບ ແລະການສະຫນັບສະຫນູນຄຸນສົມບັດເຊັ່ນ vector ແລະ asynchronous I/O ແມ່ນມີຄວາມສໍາຄັນໃນລະຫັດໃນມື້ນີ້. ແລະລາຍລະອຽດຂອງການຈັດສັນຫນ່ວຍຄວາມຈໍາ, locks, ແລະການຕັ້ງຄ່າ kernel ທັງຫມົດແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍ. ນີ້ບໍ່ແມ່ນສິ່ງທີ່ມະຫາວິທະຍາໄລຕ້ອງການສໍາລັບຫຼັກສູດແນະນໍາກ່ຽວກັບລະບົບປະຕິບັດການ.

ໃນກໍລະນີໃດກໍ່ຕາມ, ມັນຫນ້າສົນໃຈສໍາລັບຂ້ອຍທີ່ຈະຄົ້ນພົບຮູບແບບເກົ່າຈໍານວນຫນ້ອຍ (ຕົວຢ່າງ, ການສ້າງ SIGPIPE ແລະກັບຄືນ EPIPE ເມື່ອຂຽນໃສ່ທໍ່ປິດ) ໃນທັງຫມົດເຫຼົ່ານີ້, ທີ່ແຕກຕ່າງກັນ, ແກ່ນທີ່ທັນສະໄຫມ. ຂ້ອຍອາດຈະບໍ່ເຄີຍເຫັນຄອມພິວເຕີ PDP-11 ມີຊີວິດຢູ່, ແຕ່ຍັງມີຫຼາຍຢ່າງທີ່ຈະຮຽນຮູ້ຈາກລະຫັດທີ່ຂຽນໄວ້ສອງສາມປີກ່ອນຂ້ອຍເກີດ.

ຂຽນໂດຍ Divi Kapoor ໃນປີ 2011, ບົດຄວາມ "ການປະຕິບັດ Linux Kernel ຂອງທໍ່ແລະ FIFOsແມ່ນພາບລວມຂອງວິທີການຂອງທໍ່ Linux (ມາຮອດປະຈຸບັນ) ເຮັດວຽກ. ກ ຄໍາຫມັ້ນສັນຍາທີ່ຜ່ານມາກ່ຽວກັບ linux ສະ​ແດງ​ໃຫ້​ເຫັນ​ຮູບ​ແບບ​ທໍ່​ຂອງ​ການ​ພົວ​ພັນ​, ທີ່​ມີ​ຄວາມ​ສາ​ມາດ​ເກີນ​ຂອງ​ໄຟລ​໌​ຊົ່ວ​ຄາວ​; ແລະຍັງສະແດງໃຫ້ເຫັນວ່າທໍ່ສົ່ງໄປໄກຈາກ "ການລັອກແບບອະນຸລັກ" ໃນ kernel Unix ສະບັບທີ XNUMX.

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