‫ﺗﻢ ﺗﺤﻤﻴﻞ اﻟﻤﻠﻒ ﻣﻦ ﻣﻮﻗﻊ‬

‫اﻟﺒﻮﺻﻠﺔ اﻟﺘﻘﻨﻴﺔ‬
‫‪www.boosla.com‬‬
 ‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﲪﻦ ﺍﻟﺮﺣﻴﻢ‬

‫ﺟﺎﻣﻌﺔ ﺍﳋﺮﻃﻮﻡ ‪ -‬ﻛﻠﻴﺔ ﺍﻟﻌﻠﻮﻡ ﺍﻟﺮﻳﺎﺿﻴﺔ‬

‫ﻗﺴﻢ ﺍﳊﺎﺳﻮﺏ‬

‫ﲝﺚ ﻣﻘﺪﻡ ﻟﻨﻴﻞ ﺩﺭﺟﺔ ﺍﻟﺒﻜﺎﻟﻮﺭﻳﻮﺱ ﰲ ﻋﻠﻮﻡ ﺍﳊﺎﺳﻮﺏ ﺑﻌﻨﻮﺍﻥ‪:‬‬

‫ﺼﻤ‪‬ﻴﻢْ ﻧﻈَﺎﻡ ﺗ‪‬ﺸ‪‬ﻐ‪‬ﻴﻞْ‬

‫ﺑ‪‬ﺮ‪‬ﻣ‪‬ﺠ‪‬ﺔ ﻭ‪ ‬ﺗ‪ ‬‬
‫"ﻧﻈﺎﻡ ﺇﻗﺮﺃ"‬

‫ﺇﻋﺪﺍﺩ ﺍﻟﺒﺎﺣﺚ ‪ :‬ﺃﲪﺪ ﻋﺼﺎﻡ ﻋﺒﺪ ﺍﻟﺮﺣﻴﻢ ﺃﲪﺪ‬

‫ﺑﺈﺷﺮﺍﻑ ‪ :‬ﺩ‪.‬ﻣﺼﻄﻔﻰ ﺑﺎﺑﻜﺮ ﺻﺪﻳﻖ‬

‫‪ ٣‬ﻳﻮﻟﻴﻮ ‪٢٠١٠‬‬
 ‫ﺟﺎﻣﻌﺔ ﺍﳋﺮﻃﻮﻡ‪.‬‬
‫ﻛﻠﻴﺔ ﺍﻟﻌﻠﻮﻡ ﺍﻟﺮﻳﺎﺿﻴﺔ ‪ -‬ﻗﺴﻢ ﺍﳊﺎﺳﻮﺏ‪.‬‬
‫ﰎ ﻛﺘﺎﺑﺔ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻧﻈﺎﻡ ‪.LATEX‬‬
‫⃝ ‪ ٢٠١٠‬ﺃﲪﺪ ﻋﺼﺎﻡ ﻋﺒﺪ ﺍﻟﺮﺣﻴﻢ ﺃﲪﺪ‪.‬‬ ‫ﲨﻴﻊ ﺍﳊﻘﻮﻕ ﳏﻔﻮﻇﺔ ‪c‬‬
‫ﻳﺴﻤﺢ ﺑﻨﺴﺦ‪ ،‬ﺗﻮﺯﻳﻊ ﻭ‪/‬ﺃﻭ ﺗﻌﺪﻳﻞ ﻫﺬﺍ ﺍﳌﺴﺘﻨﺪ ﺿﻤﻦ ﺷﺮﻭﻁ ﺇﺗﻔﺎﻗﻴﺔ ﺗﺮﺧﻴﺺ ﺍﳌﺴﺘﻨﺪﺍﺕ ﺍﳊﺮﺓ ﺟﻨﻮ ﺍﻹﺻﺪﺍﺭ ‪ ١.٢‬ﺃﻭ ﺃﻱ ﺇﺻﺪﺍﺭﹴ ﻻﺣ ﹴﻖ‬
‫ﰎ ﻧﺸﺮﻩ ﻣﻦ ﻗﺒﻞ ﻣﺆﺳﺴﺔ ﺍﻟﱪﳎﻴﺎﺕ ﺍﳊﺮﺓ‪ ،‬ﺩﻭﻥ ﺃﻳﺔ ﺃﻗﺴﺎﻡ ﺛﺎﺑﺘﺔ‪ ،‬ﻧﺼﻮﺹ ﻏﻼﻑ ﺃﻣﺎﻣﻲ ﻭﻧﺼﻮﺹ ﻏﻼﻑ ﺧﻠﻔﻲ‪ .‬ﻟﻘﺪ ﲤﺖ ﺇﺿﺎﻓﺔ‬
‫ﻧﺴﺨﺔ ﻣﻦ ﺇﺗﻔﺎﻗﻴﺔ ﺍﻟﺘﺮﺧﻴﺺ ﰲ ﺍﻟﻘﺴﻢ ﺍﳌﻌﻨﻮﻥ )ﺇﺗﻔﺎﻗﻴﺔ ﺗﺮﺧﻴﺺ ﺍﳌﺴﺘﻨﺪﺍﺕ ﺍﳊﺮﺓ ‪.(GNU‬‬
 ‫ﺍﳌﺤﺘﻮﻳﺎﺕ‬

‫‪١‬‬ ‫‪Basics‬‬ ‫ﺍﻷﺳﺎﺳﻴﺎﺕ‬ ‫‪.I‬‬

‫‪٣‬‬ ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬
‫‪٦‬‬ ‫‪ .١.١‬ﻣﺎ ﻫﻮ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ‪. . . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫‪٦‬‬ ‫‪ .١.١.١‬ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻛﺠﻬﺎﺯ ﲣﻴﻠﻲ ‪. . . . . . . . . . . . . . . . .‬‬
‫‪٦‬‬ ‫‪ .٢.١.١‬ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻛﻤﺪﻳﺮ ﻟﻠﻤﻮﺍﺭﺩ ﻭﺍﻟﻌﺘﺎﺩ ‪. . . . . . . . . . . . . .‬‬
‫‪٦‬‬ ‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ‪. . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫‪٧‬‬ ‫‪ .١.٢.١‬ﺍﳉﻴﻞ ﺍﻟﺼﻔﺮﻱ )‪ :(١٩٤٥-١٦٢٤‬ﺍﳊﻮﺍﺳﻴﺐ ﺍﳌﻴﻜﺎﻧﻴﻜﻴﺔ ‪. . . . . .‬‬
‫‪١٠‬‬ ‫‪ .٢.٢.١‬ﺍﳉﻴﻞ ﺍﻷﻭﻝ )‪ :(١٩٥٥-١٩٤٥‬ﺍﻟﺼﻤﺎﻣﺎﺕ ﺍﳌﻔﺮﻏﺔ ﻭ ﻟﻮﺣﺎﺕ ﺍﻟﺘﻮﺻﻴﻞ‬
‫‪١٥‬‬ ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬
‫‪١٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺍﻟﻨﻈﺎﻡ ‪. . . . . . . . . . . . .‬‬
‫‪١٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.١.٢‬ﻣﺴﺎﺭ ﺍﻟﻨﻈﺎﻡ ‪. . . System Bus‬‬
‫‪١٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.١.٢‬ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ‪. . . . . . .‬‬
‫‪١٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.١.٢‬ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ‪. . .‬‬
‫‪١٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ ‪. . . . . . . . . . . . . . . .‬‬
‫‪٢٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٢.٢‬ﺩﻭﺭﺓ ﺗﻨﻔﻴﺬ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ‪. . . . .‬‬
‫‪٢٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٢.٢‬ﺃﳕﺎﻁ ﻋﻤﻞ ﺍﳌﻌﺎﰿ ‪. CPU Modes‬‬
‫‪٢٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٢.٢‬ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ‪. . Real Mode‬‬
‫‪٢٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٢.٢‬ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪Protected Mode‬‬
‫‪٢٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٥.٢.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﻣﻌﺎﳉﺎﺕ ‪. . . . . x86‬‬

‫‪٣١‬‬ ‫‪Boo ng‬‬ ‫‪ .II‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ‬

‫‪٣٣‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪Bootloader‬‬
‫‪٣٣‬‬ ‫‪ .١.٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ‪. . . . . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫‪٣٤‬‬ ‫‪ .٢.٣‬ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪. . . . . . . . . . . . . . . . . . . . . . . Bootloader‬‬

‫ﺝ‬
 ‫ﺍﳌﺤﺘﻮﻳﺎﺕ‬

‫‪٣٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٣‬ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ ‪. . . . . . . . . . . . . . . . . . . . . . .‬‬

‫‪٣٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٣‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪. . . . . . . . . . . . . . . . . . . . .‬‬
‫‪٣٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٤.٣‬ﻋﺮﺽ ﺭﺳﺎﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ ‪. . . . . . . . . . . . . . .‬‬
‫‪٤٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٤.٣‬ﻣﻌﻠﻮﻣﺎﺕ ﻗﻄﺎﻉ ﺍﻻﻗﻼﻉ ‪. . . . . . . . . . . . . .‬‬
‫‪٤٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٤.٣‬ﲢﻤﻴﻞ ﻗﻄﺎﻉ ﻣﻦ ﺍﻟﻘﺮﺹ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﻘﺎﻃﻌﺔ ‪. int 0x13‬‬
‫‪٥٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ ‪. . . . . . . . . . . . . . . . . . . FAT12‬‬
‫‪٥١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٥.٣‬ﻗﻴﻮﺩ ﻧﻈﺎﻡ ‪. . . . . . . . . . . . . . . . . FAT12‬‬
‫‪٥١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٥.٣‬ﻫﻴﻜﻠﺔ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﺍﻟﻘﺮﺹ ‪. . . . . . . . . . .‬‬
‫‪٥٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٥.٣‬ﻫﻴﻜﻠﺔ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ‪. . . . . . . . . . . . . . . .‬‬
‫‪٥٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٥.٣‬ﺍﻟﻘﺮﺍءﺓ ﻭ ﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻧﻈﺎﻡ ‪. . . . . . . . . . FAT12‬‬

‫‪٦٧‬‬ ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪٦٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٤‬ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪. . . . . . . . . . . . . . . . . .‬‬
‫‪٦٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.١.٤‬ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ‪. . . Global Descriptor Table‬‬
‫‪٧٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.١.٤‬ﺍﻟﻌﻨﻮﻧﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪. PMode Memory Addressing‬‬
‫‪٧٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.١.٤‬ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪. . . . . . . . . . . . .‬‬
‫‪٧٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٤‬ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪. . . . . . . . . . . . . . . . . . . . . A20‬‬
‫‪٧٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٢.٤‬ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ‪ 8042‬ﻭﺍﻟﺒﻮﺍﺑﺔ ‪. . . . . . . A20‬‬
‫‪٧٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٢.٤‬ﻃﺮﻕ ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪. . . . . . . . . . . . . . A20‬‬
‫‪٨١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ ‪. . . . . . . . . . . . . . . . . . . . . VGA‬‬
‫‪٨٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٣.٤‬ﻋﻨﻮﻧﺔ ﺍﻟﺬﺍﻛﺮﺓ ﰲ ﻣﺘﺤﻜﻤﺎﺕ ‪. . . . . . . . . . VGA‬‬
‫‪٨٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٣.٤‬ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ‪. . . . . . . . . . . . .‬‬
‫‪٨٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٣.٤‬ﻃﺒﺎﻋﺔ ﺍﻟﺴﻼﺳﻞ ﺍﻟﻨﺼﻴﺔ ‪. . . . . . . . . . . strings‬‬
‫‪٨٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٣.٤‬ﲢﺪﻳﺚ ﺍﳌﺆﺷﺮ ‪. . . . . . . . . . Hardware Cursor‬‬
‫‪٩٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٥.٣.٤‬ﺗﻨﻈﻴﻒ ﺍﻟﺸﺎﺷﺔ ‪. . . . . . . . . . . Clear Screen‬‬
‫‪٩٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٤‬ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ‪. . . . . . . . . . . . . . . . . . . . . . . .‬‬

‫‪١٠١‬‬ ‫‪Kernel‬‬ ‫‪ .III‬ﺍﻟﻨﻮﺍﺓ‬

‫‪١٠٣‬‬ ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬
‫‪١٠٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .١.٥‬ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ‪. . . . .‬‬
‫‪١٠٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .١.١.٥‬ﻣﺴﺘﻮﻳﺎﺕ ﺍﻟﺘﺠﺮﻳﺪ‬
‫‪١٠٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .٢.٥‬ﻭﻇﺎﺋﻒ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ‪. . . . .‬‬
‫‪١٠٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .١.٢.٥‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ‪. .‬‬
‫‪١٠٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .٣.٥‬ﻫﻴﻜﻠﺔ ﻭﺗﺼﻤﻴﻢ ﺍﻟﻨﻮﺍﺓ ‪. . . .‬‬
‫‪١٠٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﻟﻀﺨﻤﺔ ‪Monolithic Kernel‬‬
‫‪١٠٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﳌﺼﻐﺮﺓ ‪. . . MicroKernel‬‬

‫ﺩ‬
‫ﺍﳌﺤﺘﻮﻳﺎﺕ‬

‫‪١٠٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﳍﺠﻴﻨﺔ ‪. Hybrid Kernel‬‬
‫‪١٠٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٥‬ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ‪. . . . . . . . . . .‬‬
‫‪١٠٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٤.٥‬ﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﻧﻮﺍﺓ ‪. . . . PE‬‬
‫‪١١١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٤.٥‬ﺗﻄﻮﻳﺮ ﺑﻴﺌﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻟﻠﻐﺔ ﺳﻲ‪++‬‬
‫‪١١٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٤.٥‬ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﻨﻮﺍﺓ ‪. . . .‬‬
‫‪١١٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٥.٥‬ﻧﻈﺮﺓ ﻋﻠﻰ ﺷﻔﺮﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ ‪. . . . . . .‬‬
‫‪١١٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٦.٥‬ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﺍﻟﻘﻴﺎﺳﻴﺔ ‪. . . . . . . . .‬‬

‫‪١٢٣‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ‪Interrupts‬‬

‫‪١٢٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ ‪. So ware Interrupts‬‬
‫‪١٢٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .١.١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ‪.‬‬
‫‪١٢٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .٢.١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪.‬‬
‫‪١٢٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .٣.١.٦‬ﺃﺧﻄﺎء ﺍﳌﻌﺎﰿ ‪. . . . . . .‬‬
‫‪١٢٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫‪ .٤.١.٦‬ﺇﻧﺸﺎء ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ‪GDT‬‬
‫‪١٣٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ ‪Programmable Interrupt Controller‬‬
‫‪١٣٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٢.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ‪. . . . . . . . Hardware Interrupts‬‬
‫‪١٣٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٢.٦‬ﺑﺮﳎﺔ ﻣﺘﺤﻜﻢ ‪. . . . . . . . . . . . . . . . . PIC‬‬
‫‪١٤١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٦‬ﺍﳌﺆﻗﺘﺔ ‪. . . . . . . . . . . . . Programmable Interval Timer‬‬
‫‪١٤٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٣.٦‬ﺑﺮﳎﺔ ﺍﳌﺆﻗﺘﺔ ‪. . . . . . . . . . . . . . . . . . PIT‬‬
‫‪١٤٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.٦‬ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ ‪. . . . . . . . . . . . . . . . . . . . . . . HAL‬‬
‫‪١٤٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.٤.٦‬ﺩﻋﻢ ‪. . . . . . . . . . . . . . . . . . . . . PIC‬‬
‫‪١٤٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٤.٦‬ﺩﻋﻢ ‪. . . . . . . . . . . . . . . . . . . . . PIT‬‬
‫‪١٥٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.٤.٦‬ﻭﺍﺟﻬﺔ ‪ HAL‬ﺍﳉﺪﻳﺪﺓ ‪. . . . . . . . . . . . . . . .‬‬
‫‪١٦١‬‬ ‫‪ .٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬
‫‪١٦١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪Physical Memory Management‬‬ ‫‪ .١.٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬
‫‪١٦٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .١.١.٧‬ﺣﺴﺎﺏ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ‪. . . . . . . . .‬‬
‫‪١٦٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.١.٧‬ﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ ‪. . . . . Memory Map‬‬
‫‪١٦٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٣.١.٧‬ﻣﻮﺍﺻﻔﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ ‪. . . . . . .‬‬
‫‪١٧١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٤.١.٧‬ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ ‪. . . . . . . . .‬‬
‫‪١٧٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪ .٢.٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ ‪Virtual Memory Management‬‬

‫‪١٨٣‬‬ ‫‪Device Driver‬‬ ‫‪ .٨‬ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬

‫‪١٨٣ . . . . . . . . . . . . . . .‬‬ ‫‪Keyboard Driver‬‬ ‫‪ .١.٨‬ﺑﺮﳎﺔ ﻣﺸﻐﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬

‫‪١٩٥‬‬ ‫ﺗﺮﲨﺔ ﻭﺗﺸﻐﻴﻞ ﺍﻟﱪﺍﻣﺞ‬ ‫ﺍ‪.‬‬

‫ﺍ‪ .١.‬ﻧﻈﺎﻡ ﻭﻳﻨﺪﻭﺯ ‪١٩٥ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫ﺍ‪ .٢.‬ﻧﻈﺎﻡ ﻟﻴﻨﻮﻛﺲ ‪١٩٥ . . . . . . . . . . . . . . . . . . . . . . . . . . . .‬‬

‫ﻫ‬
 ‫ﺍﳌﺤﺘﻮﻳﺎﺕ‬

‫‪١٩٧‬‬ ‫ﺏ‪ .‬ﺷﻔﺮﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‬

‫ﻭ‬
 ‫ﺍﻷﻣﺜﻠﺔ ﺍﻟﺘﻮﺿﻴﺤﻴﺔ‬
٤ . . . . . . . . . . . . . . . . . . . . . . . . . Assembly Language .١.١
٣٧ . . . . . . . . . . . . . . . . . . . . . . . . Smallest Bootloader .٣.١
٣٧ . . . . . . . . . . . . . . . . . . . . . . . . Welcom to OS World .٣.٢
٤٠ . . . . . . . . . . . . . . . . . . . . . . . . Bios Parameter Block .٣.٣
٤١ . . . . . . . . . . . . . . . . . . . . . . . . . . . . BPB example .٣.٤
٤٤ . . . . . . . . . . . . . . . . . . . . . . . Hex value of bootloader .٣.٥
٤٥ . . . . . . . . . . . . . . . . . . . . . . . . . Complete Example .٣.٦
٤٨ . . . . . . . . . . . . . . . . . . . . . . . . . Reset Floppy Drive .٣.٧
٤٩ . . . . . . . . . . . . . . . . . . . . . . Read Floppy Disk Sectors .٣.٨
٥٥ . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hello Stage2 .٣.٩
٥٧ . . . . . . . . . . . . . . . . . . . . . . . . . Load Root directory .٣.١٠
٥٨ . . . . . . . . . . . . . . . . . . . . . . . Find Stage2 Bootloader .٣.١١
٥٩ . . . . . . . . . . . . . . . . . . . . . . . . . . . Load FAT Table .٣.١٢
٦٠ . . . . . . . . . . . . . . . . . . . Convert Cluster number to LBA .٣.١٣
٦٠ . . . . . . . . . . . . . . . . . . . . . . . . . Convert LBA to CHS .٣.١٤
٦١ . . . . . . . . . . . . . . . . . . . . . . . . . . . . Load Cluster .٣.١٥
٦٢ . . . . . . . . . . . . . . . . . . . . . . . . Read Sectors Rou ne .٣.١٦
٦٤ . . . . . . . . . . . . . . . . . . . . . . . . . . . Read FAT entry .٣.١٧
٦٩ . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . GDT .٤.١
٧١ . . . . . . . . . . . . . . .
. . . . . . . . . Load GDT into GDTR .٤.٢
٧٣ . . . . . . . . . . . . . . .
. . . . . Switching to Protected Mode .٤.٣
٧٥ . . . . . . . . . . . . . . .
Enable A20 by System Control Port 0x92 .٤.٤
٧٦ . . . . . . . . . . . . . . .
. . . . . . Enable A20 by BIOS int 0x15 .٤.٥
٧٧ . . . . . . . . . . . . . . .
. . . . . . . . . . Wait Input/Output .٤.٦
٧٨ . . . . . . . . . . . . . . .
. . . . . . . Enable A20 by Send 0xdd .٤.٧
٨٠ . . . . . . . Enable A20 by write to output port of Keyboard Controller .٤.٨
٨٣ . . . . . . . . . . . . . . . . . . . . . Print 'A' character on screen .٤.٩
٨٥ . . . . . . . . . . . . . . . . . . . . . . . . . . putch32 rou ne .٤.١٠
٨٧ . . . . . . . . . . . . . . . . . . . . . . . . . . . puts32 rou ne .٤.١١
٩٠ . . . . . . . . . . . . . . . . . . . . . . . Move Hardware Cursor .٤.١٢
٩٢ . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clear Screen .٤.١٣
٩٣ . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hello Kernel .٤.١٤

‫ﺯ‬
 ‫ﺍﻷﻣﺜﻠﺔ ﺍﻟﺘﻮﺿﻴﺤﻴﺔ‬

٩٥ .............. Loading and Execu ng Kernel: Full Example .٤.١٥

١٠٨ . . . . . . . . . . . . . . . . . . . . . Portable Executable Header .٥.١
١١٠ . . . . . . . . . . . . . . . . . . . . . . . . Ge ng Kernel entry .٥.٢
١١١ . . . . . . . . . . . . . . . . . . . . . Global new/delete operator .٥.٣
١١٢ . . . . . . . . . . . . . . . . . . . Pure virtual func on call handler .٥.٤
١١٢ . . . . . . . . . . . . . . . . . . . . . . . Floa ng Point Support .٥.٥
١١٣ . . . . . . . . . . . . . . . . . . . . . . . . . . Object Ini alizer .٥.٦
١١٤ . . . . . . . . . . . . . . . . . . . . . . . . . . . Delete Object .٥.٧
١١٦ . . . . . . . . . . . . . . . . . . . . . . . . Kernel Entry rou ne .٥.٨
١١٨ . . . . . . . . . . . . . . . . null.h:Defini on of NULL in C and C++ .٥.٩
١١٩ . . . . . . . . . . . . . . . . . size t.h:Defini on of size t in C/C++ .٥.١٠
١٢٠ . . . . . . . . . . . . . . . . . . . . . . stdint.h:typedef data type .٥.١١
١٢٠ . . . . . . . . . . . . . . . . . . . . cstdint:C++ typedef data type .٥.١٢
١٢١ . . . . . . . . . . . . . . . . . . ctype.h:determine character type .٥.١٣
١٢٦ . . . . . . . . . . . . . . . . . . . Example of interrupt descriptor .٦.١
١٢٦ . . . . . . . . . . . . . . . . . . . . . . . . Value to put in IDTR .٦.٢
١٢٩ . . . . . . . . . . include/hal.h:Hardware Abstrac on Layer Interface .٦.٣
١٣٠ . . . . . . . . . . . . . . . . . . . . . . . hal/gdt.cpp:Install GDT .٦.٤
١٣٧ . . . . . . . . . . . . . . . . . . . . Ini aliza on Control Words 1 .٦.٥
١٣٨ . . . . . . . . . . . . . . . . . . . . Ini aliza on Control Words 2 .٦.٦
١٣٨ . . . . . . . . . . . . . . . . . . . . Ini aliza on Control Words 3 .٦.٧
١٣٩ . . . . . . . . . . . . . . . . . . . . Ini aliza on Control Words 4 .٦.٨
١٤٠ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Send EOI .٦.٩
١٤٤ . . . . . . . . . . . . . . . . . . . . . . . . . . PIT programming .٦.١٠
١٤٥ . . . . . . . . . . . . . . . . . . . . . . . hal/pic.h: PIC Interface .٦.١١
١٤٧ . . . . . . . . . . . . . . . . . . . hal/pic.cpp: PIC Implementa on .٦.١٢
١٤٩ . . . . . . . . . . . . . . . . . . . . . . . hal/pit.h: PIt Interface .٦.١٣
١٥٠ . . . . . . . . . . . . . . . . . . . hal/pit.cpp: PIT Implementa on .٦.١٤
١٥٢ . . . . . . . . . . . . . . . . . . . . . . . . . New HAL Interface .٦.١٥
١٥٣ . . . . . . . . . . . . . . . . . . . . . . New HAL Impelmenta on .٦.١٦
١٥٦ . . . . . . . . . . . . . . . . . . . . . . . . . . kernel/main.cpp .٦.١٧
١٥٦ . . . . . . . . . . . . . . . . . . . . . . . . . kernel/excep on.h .٦.١٨
١٥٨ . . . . . . . . . . . . . . . . . . . . . . . . kernel/excep on.cpp .٦.١٩
١٥٨ . . . . . . . . . . . . . . . . . . . . . . . . . . kernel/panic.cpp .٦.٢٠
١٦٢ . . . . . . . . . . . . . . . . . Using int 0x12 to get size of memory .٧.١
١٦٣ . . . . . . . . . Using int 0x15 Func on 0xe801 to get size of memory .٧.٢
١٦٥ . . . . . . . . . . . . . . . . . . . . Memory Map Entry Structure .٧.٣
١٦٥ . . . . . . . . . . . . . . . . . . . . . . . . . Get Memory Map .٧.٤

‫ﺡ‬
‫ﺍﻷﻣﺜﻠﺔ ﺍﻟﺘﻮﺿﻴﺤﻴﺔ‬

١٦٨ . . . . . . . . . . . . . . . . . . . Mul boot Inforam on Structure .٧.٥

١٦٩ . . . . . . . . . . . . . . . . . . . snippet from stage2 bootloader .٧.٦
١٧٠ . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kernel Entry .٧.٧
١٧١ . . . . . . . . . . . . . . . . . Physical Memory Manager Interface .٧.٨
١٧١ . . . . . . . . . . . . . . Physical Memory Manager Implemeta on .٧.٩
١٧٧ . . . . . . . . . . . . . . . . . . Virtual Memory Manager Interface .٧.١٠
١٧٨ . . . . . . . . . . . . . . . Virtual Memory Manager Implemeta on .٧.١١
١٨٣ . . . . . . . . . . . . . . . . . . . . . . Keybaord Driver Interface .٨.١
١٨٧ . . . . . . . . . . . . . . . . . . . Keybaord Driver Implemeta on .٨.٢

‫ﻁ‬
 ‫ﻗﺎﺋﻤﺔ ﺍﻷﺷﻜﺎﻝ‬
‫‪٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻷﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ ‪. . . . . . x86‬‬ ‫‪.١.١‬‬
‫‪٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﻃﺒﻘﺎﺕ ﺍﳊﺎﺳﺐ ‪. . . . . . . . . . . .‬‬ ‫‪.٢.١‬‬
‫‪٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﺁﻟﺔ ﺑﺎﺳﻜﺎﻝ ‪. . . . . . . . . . . . . .‬‬ ‫‪.٣.١‬‬
‫‪٧‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﺁﻟﺔ ‪ Step Reckoner‬ﰲ ﻣﺘﺤﻒ ﺑﺄﳌﺎﻧﻴﺎ ‪. . .‬‬ ‫‪.٤.١‬‬
‫‪٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﳏﺮﻙ ﺍﻟﻔﺮﻭﻕ ﺑﻌﺪ ﺃﻥ ﻗﺎﻡ ﺍﺑﻦ ﺑﺎﺑﺒﺎﺝ ﺑﺘﺠﻤﻴﻌﻪ ‪.‬‬ ‫‪.٥.١‬‬
‫‪٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﺍﳌﺤﺮﻙ ﺍﻟﺘﺤﻠﻴﻠﻲ ﲟﺘﺤﻒ ﰲ ﻟﻨﺪﻥ ‪. . . . .‬‬ ‫‪.٦.١‬‬
‫‪٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫ﺣﺎﺳﺒﺔ ‪ Z1‬ﺑﻌﺪ ﺇﻋﺎﺩﺓ ﺍﻧﺸﺎﺋﻬﺎ ﰲ ﻣﺘﺤﻒ ﺑﺄﳌﺎﻧﻴﺎ‬ ‫‪.٧.١‬‬
‫‪١٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺣﺎﺳﺒﺔ ‪ Atanasoff‬ﺑﻌﺪ ﺇﻋﺎﺩﺓ ﺍﻧﺸﺎﺋﻬﺎ ﰲ ﺟﺎﻣﻌﺔ ‪Iowa State‬‬ ‫‪.٨.١‬‬
‫‪١٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺣﺎﺳﺒﺔ ‪. . . . . . . . . . . . . . . Harvard Mark I‬‬ ‫‪.٩.١‬‬
‫‪١١‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺁﻟﺔ ﺇﳒﻤﺎ ﺍﻷﳌﺎﻧﻴﺔ ﻟﺘﺸﻔﲑ ﺍﻟﺮﺳﺎﺋﻞ ﻭﻓﻜﻬﺎ ‪. . . . . . . . .‬‬ ‫‪.١٠.١‬‬
‫‪١٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳊﺎﺳﺒﺔ ‪ colossus‬ﺍﻟﱵ ﻛﺴﺮﺕ ﺷﻔﺮﺓ ﺇﳒﻤﺎ ‪. . . . . . .‬‬ ‫‪.١١.١‬‬
‫‪١٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳊﺎﺳﺒﺔ ‪. . . . . . . . . . . . . . . . . . ENIAC‬‬ ‫‪.١٢.١‬‬
‫‪١٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳊﺎﺳﺒﺔ ‪. . . . . . . . . . . . . . . . . . EDVAC‬‬ ‫‪.١٣.١‬‬
‫‪١٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ ‪. . . . . . x86‬‬ ‫‪.١.٢‬‬
‫‪١٦‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳌﺴﺎﺭﺍﺕ ﰲ ﺍﳊﻮﺍﺳﻴﺐ ﺍﻟﺸﺨﺼﻴﺔ ‪x86‬‬ ‫‪.٢.٢‬‬
‫‪١٨‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ ‪. . . . . . . . . .‬‬ ‫‪.٣.٢‬‬
‫‪٢٤‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺗﺪﺍﺧﻞ ﺍﳌﻘﺎﻃﻊ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ‪. .‬‬ ‫‪.٤.٢‬‬
‫‪٢٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺣﻠﻘﺎﺕ ﺍﳌﻌﺎﰿ ‪. . . . . . . . . .‬‬ ‫‪.٥.٢‬‬
‫‪٣٦‬‬ ‫‪ .١.٣‬ﳐﻄﻂ ﳏﺘﻮﻳﺎﺕ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ‪. . . . . . . . . . . . . . . . . . . . .‬‬
‫‪٥١‬‬ ‫‪ .٢.٣‬ﻫﻴﻜﻠﺔ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﺍﻟﻘﺮﺹ ‪. . . . . . . . . . . . . . . . . . . . .‬‬
‫‪ .١.٤‬ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺃﺛﻨﺎء ﺍﻟﻌﻤﻞ ‪١٠٠ . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫‪ .٢.٤‬ﺑﺪء ﺗﻨﻔﻴﺬ ﺍﻟﻨﻮﺍﺓ ‪١٠٠ . . . . . . . . . . . . . . . . . . . . . . . . . . .‬‬
‫‪١٣٣‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪8259A‬‬ ‫ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬ ‫‪.١.٦‬‬
‫‪١٣٥‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﻣﺸﺎﺑﻚ ﻣﺘﺤﻜﻢ ‪. . . . . . PIC‬‬ ‫‪.٢.٦‬‬
‫‪١٤٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﳌﺆﻗﺘﺔ ﺍﻟﻘﺎﺑﻠﺔ ﻟﻠﱪﳎﺔ ‪. . . . 8253‬‬ ‫‪.٣.٦‬‬
‫‪١٤٢‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﻣﺸﺎﺑﻚ ﺍﳌﺆﻗﺘﺔ ‪. . . . . . . PIT‬‬ ‫‪.٤.٦‬‬
‫‪١٥٩‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﻭﺍﺟﻬﺔ ﺍﻟﻨﻈﺎﻡ ﺑﻌﺪ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ ‪HAL‬‬ ‫‪.٥.٦‬‬
‫‪١٦٠‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ ‪. .‬‬ ‫‪.٦.٦‬‬

‫ﻳﺎ‬
 ‫ﻗﺎﺋﻤﺔ ﺍﳉﺪﺍﻭﻝ‬
‫‪٢٠‬‬ ‫‪..‬‬ ‫‪...........‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ ﳊﻮﺍﺳﻴﺐ ‪. . . . . . x86‬‬ ‫‪.١.٢‬‬
‫‪٢١‬‬ ‫‪..‬‬ ‫‪...........‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﻣﻨﺎﻓﺬ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﳊﻮﺍﺳﻴﺐ ‪. x86‬‬ ‫‪.٢.٢‬‬
‫‪٢٦‬‬ ‫‪..‬‬ ‫‪...........‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﺗﺘﻄﻠﺐ ﺻﻼﺣﻴﺔ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ‪.‬‬ ‫‪.٣.٢‬‬
‫‪٢..٤‬‬ ‫‪ EFLAGS‬ﺍﻷﻋﻼﻡ ﻣﺴﺠﻞ‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪...................‬‬ ‫‪. . ٢٩‬‬
‫‪٦..١‬‬ ‫‪Interrupt Vector Table .‬‬‫‪. . . . . . . . . . . . . . . . . . . . . . . ١٢٤‬‬
‫‪١٢٨ . .‬‬ ‫‪. . . . . . . . . . . . . . . . . x86 Processor Excep ons Table .٢.٦‬‬
‫‪١٣٤ . .‬‬ ‫‪ .٣.٦‬ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩ ﳊﻮﺍﺳﻴﺐ ‪. . . . . . . . . . . . . . . . . . . x86‬‬
‫‪١٣٦ . .‬‬ ‫‪ .٤.٦‬ﻣﺴﺠﻞ ‪. . . . . . . . . . . . . . . . . . . . . . . IRR/ISR/IMR‬‬
‫‪١٣٦ . .‬‬ ‫‪ .٥.٦‬ﻋﻨﺎﻭﻳﻦ ﺍﳌﻨﺎﻓﺬ ﳌﺘﺤﻜﻢ ‪. . . . . . . . . . . . . . . . . . . . . PIC‬‬
‫‪١٣٧ . .‬‬ ‫‪ .٦.٦‬ﺍﻷﻣﺮ ﺍﻷﻭﻝ ‪. . . . . . . . . . . . . . . . . . . . . . . . ICW1‬‬
‫‪٦..٧‬‬ ‫‪ ICW3 for Primary PIC . . . . . . . . . . . ١٣٨‬ﺍﻟﺮﺋﻴﺴﻲ ﻟﻠﻤﺘﺤﻜﻢ ﺍﻟﺜﺎﻟﺚ ﺍﻷﻣﺮ‬
‫‪٦..٨‬‬ ‫‪ ICW3 for Slave PIC . . . . . . . . . . . . . ١٣٨‬ﺍﻟﺜﺎﻧﻮﻱ ﻟﻠﻤﺘﺤﻜﻢ ﺍﻟﺜﺎﻟﺚ ﺍﻷﻣﺮ‬
‫‪٦..٩‬‬ ‫‪ ICW4 . . . . . . . . . . . . . . . . . . . . . . . . . . ١٣٩‬ﺍﻟﺮﺍﺑﻊ ﺍﻷﻣﺮ‬
‫‪١٤٠ . .‬‬ ‫‪ .١٠.٦‬ﺃﻣﺮ ﺍﻟﺘﺤﻜﻢ ﺍﻟﺜﺎﱐ ‪. . . . . . . . . . . . . . . . . . . . . OCW2‬‬
‫‪١٤٠ . .‬‬ ‫‪ .١١.٦‬ﺃﻣﺮ ‪. . . . . . . . . . . . . . . . . . . . . . . . . . . OCW2‬‬
‫‪١٤٣ . .‬‬ ‫‪ .١٢.٦‬ﻣﺴﺠﻼﺕ ﺍﳌﺆﻗﺘﺔ ‪. . . . . . . . . . . . . . . . . . . . 8253 PIT‬‬

‫ﻳﺞ‬
 ‫ﻣﻠﺨﺺ ﺍﻟﺒﺤﺚ‬
‫ﻫﺪﻑ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﻫﻮ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ )ﻧﻈﺎﻡ ﺇﻗﺮﺃ( ﻟﻺﺳﺘﺨﺪﺍﻣﺎﺕ ﺍﻟﺘﻌﻠﻴﻤﻴﺔ ﻭﺍﻷﻛﺎﺩﳝﻴﺔ ﲝﻴﺚ ﻳ‪‬ﻤﻜﱢﻦ ﺍﻟﻄﺎﻟﺐ‬
‫ﻣﻦ ﺗﻄﺒﻴﻖ ﻣﺎ ﺗﻌﻠﻤﻪ ﻣﻦ ﻧﻈﺮﻳﺎﺕ ﺧﻼﻝ ﻓﺘﺮﺓ ﺍﻟﺪﺭﺍﺳﺔ ﻋﻠﻰ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﺣﻘﻴﻘﻲ ﳑﺎ ﻳﻜﺴﺒﻪ ﺧﱪﺓ ﻭﻳﺆﻫﻠﻪ ﻟﻠﻤﺸﺎﺭﻛﺔ‬
‫ﰲ ﺑﺮﳎﺔ ﺃﻧﻈﻤﺔ ﺗﺸﻐﻴﻞ ﺿﺨﻤﺔ ﻣﺜﻞ ﺟﻨﻮ‪/‬ﻟﻴﻨﻮﻛﺲ‪ .‬ﻛﺬﻟﻚ ﻳﻬﺪﻑ ﺍﱃ ﺗﻮﻓﲑ ﲝﺜﺎ ﺑﺎﻟﻠﻐﺔ ﺍﻟﻌﺮﺑﻴﺔ ﻳﺸﺮﺡ ﺍﻷﺳﺲ‬
‫ﺍﻟﻌﻠﻤﻴﺔ ﻟﻜﻴﻔﻴﺔ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﻣﻦ ﺍﻟﺼﻔﺮ ﺩﻭﻥ ﺍﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺃﻱ ﻣﻜﻮﻧﺎﺕ ﺧﺎﺭﺟﻴﺔ ﰲ ﺍﻟﻮﻗﺖ ﺍﻟﺬﻱ ﺗﻨﺪﺭ‬
‫ﺗﻮﻓﺮ ﻣﺜﻞ ﻫﺬﻩ ﺍﻟﺒﺤﻮﺙ ﺍﳌﻔﻴﺪﺓ ﻟﻠﻄﺎﻟﺐ ﻭﺧﺎﺻﺔ ﰲ ﻫﺬﺍ ﺍﳌﺠﺎﻝ ﺍﻟﺬﻱ ﻳﻌﺘﱪ ﻣﻦ ﺃﻫﻢ ﺍﳌﺠﺎﻻﺕ ﰲ ﻋﻠﻮﻡ ﺍﳊﺎﺳﻮﺏ‪.‬‬
‫ﻭﺗﻨﺎﻭﻟﺖ ﻫﺬﻩ ﺍﻟﺪﺭﺍﺳﺔ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺃﺳﺎﺳﻴﺎﺕ ﻭﻣﻔﺎﻫﻴﻢ ﻧﻈﻢ ﺍﻟﺘﺸﻐﻴﻞ ﺑﺪءﺍ ﻣﻦ ﻣﺮﺣﻠﺔ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﺍﻹﻧﺘﻘﺎﻝ‬
‫ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻭﺍﻧﺘﻬﺎءﺍ ﺑﱪﳎﺔ ﻣﺪﻳﺮﺍ ﻟﻠﺬﺍﻛﺮﺓ ﻭﺗﻌﺮﻳﻔﺎﺕ ﻟﺒﻌﺾ ﺍﻟﻌﺘﺎﺩ‪.‬‬
‫ﻭ ﺭﺅﻳﺔ ﺍﻟﺒﺎﺣﺚ ﰲ ﻫﺬﻩ ﺍﻟﺪﺭﺍﺳﺔ ﻫﻲ ﺃﻥ ﺗﺴﺘﺨﺪﻡ ﻛﻤﻨﻬﺞ ﻟﺘﺪﺭﻳﺲ ﺍﻟﻄﻼﺏ ﰲ ﻣﺎﺩﺓ ﻧﻈﻢ ﺍﻟﺘﺸﻐﻴﻞ ﻭﺃﻥ ﺗ‪‬ﺪﺭﱠﺱ‬
‫ﺍﻟﺸﻔﺮﺓ ﺍﳌﺼﺪﺭﻳﺔ ﻟﻠﻨﻈﺎﻡ ‪ .‬ﻭﻻ ﻳ‪‬ﻘﺘﺼﺮ ﻋﻠﻰ ﺫﻟﻚ ﺑﻞ ﻳ‪‬ﺴﺘﻤﺮ ﺍﻟﺘﻄﻮﻳﺮ ﰲ ﺍﻟﻨﻈﺎﻡ ﻟﻴﻜﻮﻥ ﺃﺩﺍﺓ ﺗﻌﻠﻴﻤﻴﺔ )ﻣﻔﺘﻮﺣﺔ‬
‫ﺍﳌﺼﺪﺭ( ﻟﻠﻄﻼﺏ ﻭﺍﻟﺒﺎﺣﺜﲔ‪.‬‬

‫ﻳﻪ‬
 ‫ﻣﻘﺪﻣﺔ ﺍﻟﺒﺤﺚ‬
‫ﺗﻠﻌﺐ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺩﻭﺭﴽ ﻣﻬﻤﺎ ﰲ ﺷﱴ ﳎﺎﻻﺕ ﺍﳊﻴﺎﺓ ﺣﻴﺚ ﺃﺻﺒﺤﺖ ﺃﺣﺪ ﺃﻫﻢ ﺍﻟﺮﻛﺎﺋﺰ ﺍﻷﺳﺎﺳﻴﺔ ﻟﺘﺸﻐﻴﻞ‬
‫ﻭﺍﺩﺍﺭﺓ ﺃﻱ ﺟﻬﺎﺯ ﺃﻭ ﻋﺘﺎﺩ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺍﻟﺸﺮﺍﺋﺢ ﺍﻻﻟﺘﻜﺮﻭﻧﻴﺔ ﺍﳌﺘﻜﺎﻣﻠﺔ ‪ ،‬ﻓﺒﺪءﺍ ﻣﻦ ﺟﻬﺎﺯ ﺍﳊﺎﺳﺐ ﺍﻟﺸﺨﺼﻲ‬
‫ﻭ ﺍﳉﻮﺍﻻﺕ ﻭ ﺍﻷﺟﻬﺰﺓ ﺍﻟﻜﻔﻴﺔ ﻭﺍﳌﻀﻤﻨﺔ )‪ (Embedded Device‬ﻭ ﺃﺟﻬﺰﺓ ﺍﻷﻟﻌﺎﺏ ﻭﺍﻟﺼﺮﺍﻓﺎﺕ ﺍﻵﻟﻴﺔ ﻭﺣﱴ‬
‫ﺃﺟﻬﺰﺓ ﺍﻟﻔﻀﺎء ﻭﺍﻟﺪﻭﺭﺍﺕ )‪ (Orbiter‬ﻛﻠﻬﺎ ﺗﻌﻤﻞ ﺑﺄﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﻭﻧﻈﺮﴽ ﻟﺬﻟﻚ ﻓﺎﻥ ﳎﺎﻝ ﺑﺮﳎﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﻳﻌﺘﱪ ﻣﻦ ﺃﻫﻢ ﺍﳌﺠﺎﻻﺕ ﰲ ﻋﻠﻮﻡ ﺍﳊﺎﺳﺐ ﺍﻟﱵ ﳚﺐ ﺃﻥ ﺗﺄﺧﺬ ﻧﺼﻴﺒﻬﺎ ﻣﻦ ﺍﻟﺒﺤﺚ ﺍﻟﻌﻠﻤﻲ ﻭﺍﻟﺘﻄﺒﻴﻖ ﺍﻟﱪﳎﻲ‪.‬‬
‫ﻭﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﳘﻴﺔ ﻫﺬﺍ ﺍﳌﺠﺎﻝ ﺍﻻ ﺍﻧﻪ ﻳﻨﺪﺭ ﻭﺟﻮﺩ ﲝﻮﺛﺎ ﻓﻴﻪ ﻭﻳﻌﻮﺩ ﺫﻟﻚ ﻟﻌﺪﺓ ﺃﺳﺒﺎﺏ‪ :‬ﺍﻷﻭﻝ ﻫﻮ ﺗﻨﻮﻉ‬
‫ﺍﳌﺠﺎﻻﺕ ﺍﻟﱵ ﳚﺐ ﺩﺭﺍﺳﺘﻬﺎ ﻗﺒﻞ ﺍﳋﻮﺽ ﰲ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﺣﻴﺚ ﻻ ﺑﺪ ﻟﻠﻄﺎﻟﺐ ﺃﻭ ﺍﻟﺒﺎﺣﺚ ﺍﻹﳌﺎﻡ ﺑﻠﻐﺔ‬
‫ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‪ ++‬ﻭﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ )‪ (Assembly‬ﺑﺎﻹﺿﺎﻓﺔ ﺍﱃ ﺍﳌﻌﺮﻓﺔ ﺍﻟﺘﺎﻣﺔ ﲟﻌﻤﺎﺭﻳﺔ ﺍﳊﺎﺳﺐ ﻣﻦ ﻣﻌﺎﰿ ﻭﺫﺍﻛﺮﺓ‬
‫ﻭﻭﺣﺪﺍﺕ ﺇﺩﺧﺎﻝ ﻭﺇﺧﺮﺍﺝ‪ .‬ﺃﻣﺎ ﺍﻟﺴﺒﺐ ﺍﻟﺜﺎﱐ ﻓﻬﻮ ﻋﺪﻡ ﺗﻮﻓﺮ ﻣﺮﺍﺟﻊ ﻭﻛﺘﺒﺎ ﺑﺎﻟﻠﻐﺔ ﺍﻟﻌﺮﺑﻴﺔ ﺗﺸﺮﺡ ﺍﻷﺳﺲ ﺍﻟﻌﻠﻤﻴﺔ‬
‫ﻟﱪﳎﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﻭﺍﻟﺴﺒﺐ ﺍﻟﺜﺎﻟﺚ ﻫﻮ ﺗﻮﻓﺮ ﻛﻤﻴﺔ ﻛﺒﲑﺓ ﻣﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﰲ ﺍﻟﻮﻗﺖ ﺍﳊﺎﱄ ﲡﻌﻞ ﺍﻟﻄﺎﻟﺐ‬
‫ﻳﻌﺘﻘﺪ ﺑﻌﺪﻡ ﺍﳊﻮﺟﺔ ﻟﻠﺒﺤﺚ ﰲ ﻫﺬﺍ ﺍﳌﺠﺎﻝ ﻭﻫﺬﺍ ﻣﻔﻬﻮﻡ ﺧﺎﻃﺊ ﺣﻴﺚ ﺃﻥ ﻣﱪﻣﺞ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻟﻴﺲ ﺑﺎﻟﻀﺮﻭﺭﺓ‬
‫ﺃﻥ ﻳﱪﻣﺞ ﻧﻈﺎﻣﺎ ﻣﻦ ﺍﻟﺼﻔﺮ ﻭﺍﳕﺎ ﳝﻜﻦ ﺃﻥ ﻳﻘﻮﻡ ﺑﺎﻟﺘﻌﺪﻳﻞ ﻭﺍﻟﺘﻄﻮﻳﺮ ﰲ ﺃﺣﺪ ﺍﻷﻧﻈﻤﺔ ﺍﳌﻔﺘﻮﺣﺔ ﺍﳌﺼﺪﺭ ﻛﺬﻟﻚ ﺭﲟﺎ‬
‫ﻳﻌﻤﻞ ﰲ ﺑﺮﳎﺔ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﺍﻟﱵ ﺗﺘﻄﻠﺐ ﺍﳌﺎﻣﺎ ﺗﺎﻣﺎ ﺑﻔﺎﻫﻴﻢ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻣﺜﻞ ﺑﺮﳎﺔ ﺑﺮﺍﻣﺞ ﺍﺻﻼﺡ ﺍﻟﻘﺎﻃﺎﻋﺎﺕ‬
‫ﺍﻟﺘﺎﻟﻔﺔ )‪ (Bad Sectors‬ﻭﺍﺳﺘﺮﺟﺎﻉ ﺍﳌﻠﻔﺎﺕ ﺍﳌﻔﻘﻮﺩﺓ ﻭﻏﲑﻫﺎ ﻣﻦ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ‪.‬‬
‫ﻭﻗﺪ ﻭﺿﻊ ﺍﻟﻜﺎﺗﺐ ﻧﺼﺐ ﻋﻴﻨﻴﻪ ﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﺍﻟﺘﻄﺮﻕ ﻟﻸﻣﻮﺭ ﺍﻟﱪﳎﻴﺔ ﺑﺘﻔﺎﺻﻴﻠﻬﺎ ﻭﺍﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ‬
‫ﺍﻟﺸﻔﺮﺓ ﻟﻜﻞ ﺟﺰﺋﻴﺔ ﰲ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ‪ .‬ﻭ ﱂ ﻳﺘﻢ ﺫﻛﺮ ﻛﻞ ﺍﳉﻮﺍﻧﺐ ﺍﻟﻨﻈﺮﻳﺔ ﰲ ﺍﳌﻮﺿﻮﻉ ﻭﻫﺬﺍ ﺑﺴﺒﺐ ﺃﻥ ﺍﻷﻣﻮﺭ‬
‫ﺍﻟﻨﻈﺮﻳﺔ ﰲ ﺍﻟﻐﺎﻟﺐ ﺗﺄﺧﺬ ﺑﺎﻟﻄﺎﻟﺐ ﺑﻌﻴﺪﺍ ﻭﲢﺠﺐ ﺭﺅﻳﺘﻪ ﻋﻦ ﺣﻘﻴﻘﺔ ﻋﻤﻞ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ‪ .‬ﻭﻗﺪ ﰎ ﺑﺮﳎﺔ ﺍﻟﻨﻈﺎﻡ‬
‫ﻣﻦ ﺍﻟﺼﻔﺮ ﺩﻭﻥ ﺍﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺃﻱ ﻣﻜﻮﻧﺎﺕ ﺃﻭ ﺷﻔﺮﺍﺕ ﺟﺎﻫﺰﺓ )ﻣﻔﺘﻮﺣﺔ ﺍﳌﺼﺪﺭ( ﻭﻻ ﳝﻜﻦ ﺍﻋﺘﺒﺎﺭ ﻫﺬﺍ ﺇﻋﺎﺩﺓ‬
‫ﺍﺧﺘﺮﺍﻉ ﻟﻠﻌﺠﻠﺔ ! ﺑﻞ ﻫﻮ ﺃﺳﺎﺱ ﳝﻜﻦ ﺍﻻﻋﺘﻤﺎﺩ ﻋﻠﻴﻪ ﻭﺗﻌﻠﻴﻢ ﺍﻟﻄﻼﺏ ﻋﻠﻴﻪ ﻭﻫﻜﺬﺍ ﻳﺘﻄﻮﺭ ﺍﳌﺸﺮﻭﻉ ﻭﻳﺘﻘﺪﻡ ﺍﱃ‬
‫ﺍﻷﻣﺎﻡ ﻭﰲ ﻧﻔﺲ ﺍﻟﻮﻗﺖ ﺗﺰﺩﺍﺩ ﺧﱪﺓ ﺍﻟﻄﺎﻟﺐ ﺍﻟﻌﻤﻠﻴﺔ ﰲ ﺍﳌﺠﺎﻝ‪.‬‬
‫ﻭ ﳚﺪﺭ ﺑﻨﺎ ﺍﻳﻀﺎﺡ ﺃﻥ ﻫﺪﻑ ﺍﻟﻨﻈﺎﻡ )ﻧﻈﺎﻡ ﺇﻗﺮﺃ( ﻫﻮ ﻟﻼﺳﺘﺨﺪﺍﻣﺎﺕ ﺍﻷﻛﺎﺩﳝﻴﺔ ﻭﺍﻟﺘﻌﻠﻴﻤﻴﺔ ﻭﻟﻴﺲ ﻟﻠﻤﺴﺘﺨﺪﻡ ﺍﻷﺧﲑ‬
‫‪ ،‬ﺣﻴﺚ ﺃﻥ ﺍﳍﺪﻑ ﻫﻮ ﺗﻌﻠﻴﻢ ﺍﻟﻄﺎﻟﺐ ﻋﻠﻰ ﻫﺬﻩ ﺍﻷﺩﺍﺓ ﻭﺍﻋﺪﺍﺩﻩ ﻟﻠﻌﻤﻞ ﻋﻠﻰ ﺃﻧﻈﻤﺔ ﺿﺨﻤﺔ ﻣﺜﻞ ﺟﻨﻮ‪/‬ﻟﻴﻨﻮﻛﺲ‪.‬‬

‫ﺃﲪﺪ ﻋﺼﺎﻡ ﻋﺒﺪ ﺍﻟﺮﺣﻴﻢ‪.‬‬

‫‪٢٩/٦/٢٠١٠‬‬

‫ﻳﺰ‬
 ‫ﺍﻟﻘﺴﻢ ‪.I‬‬
‫‪Basics‬‬ ‫ﺍﻷﺳﺎﺳﻴﺎﺕ‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﺟﻬﺎﺯ ﺍﳊﺎﺳﺐ ﻫﻮ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺸﺮﺍﺋﺢ ﺍﻹﻟﻜﺘﺮﻭﻧﻴﺔ ﻭﺍﻟﻌﺘﺎﺩﻳﺎﺕ ﻭﺍﳌﺘﺤﻜﻤﺎﺕ ﺍﳌﺮﺗﺒﻄﺔ ﻣﻊ ﺑﻌﻀﻬﺎ ﻟﺘﻮﻓﲑ ﻣﻨﺼﺔ‬
‫ﺗﺸﻐﻴﻠﻴﺔ ﻟﻠﱪﺍﻣﺞ ﻭ ﺍﻟﱵ ﺑﺪﻭ‪‬ﺎ ﻟﻦ ﻳﻌﻤﻞ ﻫﺬﺍ ﺍﳉﻬﺎﺯ‪ .‬ﻭﳝﻜﻦ ﺗﻘﺴﻴﻢ ﺍﻟﱪﺍﻣﺞ ﲝﺴﺐ ﻃﺒﻴﻌﺔ ﻋﻤﻠﻬﺎ ﻭﻭﻇﻴﻔﺘﻬﺎ ﺍﱃ‬
‫ﻗﺴﻤﲔ ﳘﺎ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﻭﺍﻟﱵ ﺻﻤﻤﺖ ﺧﺼﻴﺼﴼ ﳊﻞ ﻣﺸﺎﻛﻞ ﺍﳌﺴﺘﺨﺪﻡ ﻭ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﻭﺍﻟﱵ ﺗﺘﺤﻜﻢ ﰲ‬
‫ﻋﺘﺎﺩ ﻭﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ‪ ،‬ﻭﻳﻌﺘﱪ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻣﺜﺎﻻ ﻟﱪﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﺣﻴﺚ ﻳﺪﻳﺮ ﻋﺘﺎﺩ ﻭﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ﺑﺎﻹﺿﺎﻓﺔ‬
‫ﺍﱃ ﻣﻴﺰﺓ ﻣﻬﻤﺔ ﻭﻫﻲ ﺗﻮﻓﺮ ﺑﻴﺌﺔ ﺗﺸﻐﻴﻞ ﻭﳘﻴﺔ )‪ (Virtual Machine‬ﻟﱪﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ‪.‬‬
‫ﻭﻳﻮﺿﺢ ﺍﻟﺘﻌﺮﻳﻒ ﺍﻟﺴﺎﺑﻖ ﻋﺪﺩﴽ ﻣﻦ ﺍﳌﻔﺎﻫﻴﻢ ﺍﻟﱵ ﳚﺐ ﺍﻟﻮﻗﻮﻑ ﻋﻠﻴﻬﺎ ﻭﺗﻮﺿﺤﻴﻬﺎ ﺑﺸﻜﻞ ﻣﻔﺼﻞ‪ .‬ﻓﺠﻬﺎﺯ‬
‫ﺍﳊﺎﺳﺐ ﻫﻮ ﻣﻨﺼﺔ ﺗﺸﻐﻴﻠﻴﺔ ﺣﻘﻴﻘﻴﺔ ﻟﻸﻭﺍﻣﺮ ﻭﻳﺄﰐ ﺫﻟﻚ ﺑﺴﺒﺐ ﻭﺟﻮﺩ ﻣﺘﺤﻜﻢ ﺧﺎﺹ ﳌﻌﺎﳉﺔ ﺍﻷﻭﺍﻣﺮ ﻭﺗﻨﻔﻴﺬﻫﺎ‬
‫‪ ،‬ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﻫﻮ ﺍﳌﻌﺎﰿ )‪ (Processor‬ﺣﻴﺚ ﻳﻌﻤﻞ ﻋﻠﻰ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ )ﻣﻦ ﻋﻤﻠﻴﺎﺕ ﺣﺴﺎﺑﻴﺔ ﻭﻣﻨﻄﻘﻴﺔ( ﻭﺇﺭﺳﺎﻝ‬
‫ﺍﻟﻨﺘﺎﺋﺞ ﺍﱃ ﺍﻷﻣﺎﻛﻦ ﺍﳌﻄﻠﻮﺑﺔ‪ .‬ﻭﺗﺴﻤﻰ ﳎﻤﻮﻋﺔ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﻳﻨﻔﺬﻫﺎ ﺍﳌﻌﺎﰿ ﺑﺎﺳﻢ ﺍﻟﱪﺍﻣﺞ‪ ،‬ﻭﺑﺴﺒﺐ ﺗﻜﻠﻔﺔ ﺑﻨﺎء‬
‫ﺍﳌﻌﺎﰿ ﻓﺎﻧﻪ ﻏﺎﻟﺒﴼ ﻣﺎ ﻳﺘﻌﺮﻑ ﻋﻠﻰ ﻋﺪﺩﴽ ﻣﻌﻴﻨﺎ ﻣﻦ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﱵ ﺗﻌﺮﻑ ﲟﺠﻤﻮﻋﺔ ﺍﻷﻭﺍﻣﺮ )‪.(Instruc on Set‬‬
‫ﻟﺬﻟﻚ ﺣﱴ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﺃﻭﺍﻣﺮ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﻓﺎ‪‬ﺎ ﳚﺐ ﺃﻥ ﺗ‪‬ﻜﺘﺐ ﻭﻓﻘﺎ ﳌﺠﻤﻮﻋﺔ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﻳﺪﻋﻤﻬﺎ ﺍﳌﻌﺎﰿ ‪.١‬ﻭﺍﻟﺸﻜﻞ‬
‫‪ ١.١‬ﻳﻮﺿﺢ ﳕﻮﺫﺟﴼ ﻋﺎﻣﺎ ﻟﺘﻌﻠﻴﻤﺎﺕ ﻭﺃﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ ﺍﻟﱵ ﺗﺘﻜﻮﻥ ﻣﻨﻬﺎ ﺍﻟﱪﺍﻣﺞ‪ .‬ﻭﺟﺰءﺍ ﻣﻨﻬﺎ ﻫﻲ ﺍﺧﺘﻴﺎﺭﻳﺔ ﻭﺳﻨﺮﻛﺰ‬
‫ﻫﻨﺎ ﻋﻠﻰ ﺍﻝ ‪ OPCODE‬ﻭﺍﻟﱵ ﲤﺜﻞ ﺃﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ‪.‬‬

‫‪x86‬‬ ‫ﺷﻜﻞ ‪ :.١.١‬ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻷﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ‬

‫ﻭﺗﺸﻜﻞ ﺃﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ ﻟﻐﺔ ﺑﺮﳎﻴﺔ ﻣﻦ ﺧﻼﳍﺎ ﳝﻜﻦ ﺑﺮﳎﺔ ﺍﳊﺎﺳﺐ ﻭﻛﺘﺎﺑﺔ ﺍﻟﱪﺍﻣﺞ ﳊﻞ ﻣﺸﺎﻛﻞ ﺍﳌﺴﺘﺨﺪﻡ ‪ ،‬ﻫﺬﻩ‬
‫ﺍﻟﻠﻐﺔ ﺗﺴﻤﻰ ﺑﻠﻐﺔ ﺍﻵﻟﺔ )‪ . (Machine Language‬ﻭﺗﺘﻜﻮﻥ ﻫﺬﻩ ﺍﻟﻠﻐﺔ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ‪ 0‬ﻭ ‪ 1‬ﺣﻴﺚ ﺃﻥ ﺃﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ‬
‫ﻣﺎ ﻫﻲ ﺍﻻ ﺳﻠﺴﻠﺔ ﻣﻌﻴﻨﺔ ﻣﻦ ﻫﺬﻩ ﺍﻟﺮﻣﻮﺯ‪ .‬ﻓﻤﺜﻼ ﻟﺘﻌﻴﲔ ﺍﻟﻘﻴﻤﺔ ‪ 31744‬ﻟﻠﻤﺴﺠﻞ ‪ ٢ AX‬ﳚﺐ ﺃﻥ ﳛﻮﻱ ﺍﻟﱪﻧﺎﻣﺞ‬
‫ﻋﻠﻰ ﺍﻷﻣﺮ ‪ .101110001100000000000111‬ﻭﺑﺎﻟﺘﺎﱄ ﺗﻜﻮﻥ ﻋﻤﻠﻴﺔ ﻛﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻣﺘﻜﺎﻣﻞ ‪‬ﺬﻩ ﺍﻟﻠﻐﺔ ﺃﻣﺮﴽ‬
‫‪١‬ﺳﻨﺘﺤﺪﺙ ﻋﻦ ﻣﻌﺎﳉﺎﺕ ﺍﻧﺘﻞ ‪ ٣٢‬ﺑﺖ ﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﻧﻈﺮﴽ ﻷ‪‬ﺎ ﺍﻷﻛﺜﺮ ﺍﻧﺘﺸﺎﺭﴽ‪.‬‬
‫‪٢‬ﺍﳌﺴﺠﻼﺕ ﻫﻲ ﺫﻭﺍﻛﺮ ﺑﺪﺍﺧﻞ ﺍﳌﻌﺎﰿ‪.‬‬

‫‪٣‬‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﰲ ﻏﺎﻳﺔ ﺍﻟﺼﻌﻮﺑﺔ ﻭﻛﺬﻟﻚ ﻣﻬﻤﺔ ﺗﻨﻘﻴﺢ ﺍﻟﱪﻧﺎﻣﺞ ﻭﺗﻄﻮﻳﺮﻩ ﰲ ﺍﳌﺴﺘﻘﺒﻞ ﻫﻲ ﻣﻌﻘﺪﺓ ﺃﻳﻀﺎ‪ .‬ﻟﺬﻟﻚ ﻇﻬﺮﺕ ﻟﻐﺔ‬
‫ﺍﻟﺘﺠﻤﻴﻊ ﳊﻞ ﻫﺬﻩ ﺍﳌﺸﻜﻠﺔ ﺣﻴﺚ ﺃﻥ ﺍﻟﻠﻐﺔ ﺗﺪﻋﻢ ﻣﺴﻤﻴﺎﺕ ﻭﳐﺘﺼﺮﺍﺕ ﻟﻠﻤﺴﺠﻼﺕ ﻭﻷﻭﺍﻣﺮ ﺍﳌﻌﺎﰿ ‪ ،‬ﻓﻤﺜﻼ‬
‫ﺍﻷﻣﺮ ﺍﻟﺴﺎﺑﻖ ﰲ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻳﻜﻮﻥ ﺑﺎﻟﺼﻮﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ‪.‬‬
‫‪Example‬‬ ‫‪١.١: Assembly Language‬‬
‫‪١‬‬ ‫‪MOV AX,0x7C00 ; Instead of 101110001100000000000111‬‬

‫ﻭﺍﻟﺬﻱ ﳚﺐ ﲢﻮﻳﻠﻪ ﺍﱃ ﻟﻐﺔ ﺍﻵﻟﺔ ﺣﱴ ﻳﺘﻤﻜﻦ ﺍﳌﻌﺎﰿ ﻣﻦ ﺗﻨﻔﻴﺬﻩ ‪ ،‬ﻫﺬﺍ ﺍﳌﺤﻮﻝ ﻳﺴﻤﻰ ﺑﺎﳌﺠﻤﻊ ﻭﺍﻟﺬﻱ ﻳﻘﻮﻡ‬
‫ﺑﺘﺤﻮﻳﻞ ﺃﻣﺮ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﺍﱃ ﻣﺎ ﻳﻘﺎﺑﻠﻪ ﺑﻠﻐﺔ ﺍﻵﻟﺔ ‪ .٣‬ﻭﱂ ﺗﻨﺠﺢ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﰲ ﺗﻮﻓﲑ ﻟﻐﺔ ﻋﺎﻟﻴﺔ ﺍﳌﺴﺘﻮﻯ ﺗﺒﺴﻂ‬
‫ﻋﻤﻠﻴﺔ ﺑﺮﳎﺔ ﺍﻟﱪﺍﻣﺞ ﺑﺸﻜﻞ ﺃﻛﱪ ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃ‪‬ﺎ ﳐﺘﺼﺮﺍﺕ ﻟﻠﻐﺔ ﺍﻵﻟﺔ ﻟﺬﻟﻚ ﺳﺮﻋﺎﻥ ﻣﺎ ﰎ ﺗﻄﻮﻳﺮ ﻟﻐﺎﺕ ﻋﺎﻟﻴﺔ‬
‫ﺍﳌﺴﺘﻮﻯ ﻣﺜﻞ ﻟﻐﺔ ﺍﻟﺴﻲ ‪ ٤‬ﻭﺍﻟﺴﻲ‪ ++‬ﲝﻴﺚ ﺗﻜﺘﺐ ﺍﻟﱪﺍﻣﺞ ﻓﻴﻬﺎ ﺑﺸﻜﻞ ﻣﺒﺴﻂ ﺑﻌﻴﺪﴽ ﻋﻦ ﺗﻌﻘﻴﺪﺍﺕ ﺍﻵﻟﺔ ﻭﺃﻭﺍﻣﺮﻫﺎ‬
‫ﻭﻣﺴﺠﻼ‪‬ﺎ ﻭﺗﺪﻋﻢ ﻫﺬﻩ ﺍﻟﻠﻐﺎﺕ ﻋﺪﺩﺍ ﻣﻦ ﺍﻟﺘﺮﺍﻛﻴﺐ ﻭﲨﻞ ﺍﻟﺘﺤﻜﻢ ﺍﻟﻌﺎﻟﻴﺔ ﺍﳌﺴﺘﻮﻯ‪ .‬ﻭﻟﻜﻲ ﻳﻨﻔﺬ ﺍﳌﻌﺎﰿ ﺑﺮﺍﻣﺞ‬
‫ﻫﺬﻩ ﺍﻟﻠﻐﺎﺕ ﻓﺎﻧﻪ ﳚﺐ ﺃﻭﻻ ﺗﺮﲨﺔ ﺍﻟﺸﻔﺮﺓ ﺍﳌﺼﺪﺭﻳﺔ ﺍﱃ ﻣﺎ ﻳﻘﺎﺑﻠﻬﺎ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺑﺮﻧﺎﻣﺞ‬
‫ﻳﺴﻤﻰ ﺍﳌﺘﺮﺟﻢ )‪ (Compiler‬ﻭﺑﻌﺪﻫﺎ ﻳﻘﻮﻡ ﺍﳌﺠﻤﻊ ﺑﺘﺤﻮﻳﻞ ﺷﻔﺮﺓ ﺍﻟﺘﺠﻤﻴﻊ ﺍﱃ ﺑﺮﻧﺎﳎﴼ ﺑﻠﻐﺔ ﺍﻵﻟﺔ ﻭﺍﻟﺬﻱ ﻳﺴﺘﻄﻴﻊ‬
‫ﺍﳌﻌﺎﰿ ﺗﻨﻔﻴﺬﻩ‪.‬‬
‫‪2‬ﲞﺼﻮﺹ ﲤﺜﻴﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﻟﱪﺍﻣﺞ ﰲ ﺍﳊﺎﺳﺐ ﻓﺈ‪‬ﺎ ﲤﺜﻞ ﺑﻄﺮﻕ ﳐﺘﻠﻔﺔ ﲣﺘﻠﻒ ﻋﻠﻰ ﺣﺴﺐ ﻭﺣﺪﺓ‬
‫ﺍﻟﺘﺨﺰﻳﻦ ﻭ ﻟﻜﻨﻬﺎ ﰲ ﺍﻵﺧﺮ ﺗﺴﺘﺨﺪﻡ ﺍﳌﻨﻄﻖ ﺍﻟﺜﻨﺎﺋﻲ ﻭﻫﻮ ﻭﺟﻮﺩ ﻃﺎﻗﺔ ﻛﻬﺮﺑﺎﺋﻴﺔ ﺃﻡ ﻻ ‪ ،‬ﻓﻤﺜﻼ ﺗﺘﻜﻮﻥ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ‪ DRAM‬ﻣﻦ ﻣﻼﻳﲔ ﺍﳌﻜﺜﻔﺎﺕ )‪ (Capacitors‬ﻭﺍﻟﺘﺮﺍﻧﺰﺳﺘﻮﺭﺍﺕ )‪(Transistors‬‬
‫ﻟﺘﻜﻮﻳﻦ ﺧﻼﻳﺎ ﺍﻟﺬﺍﻛﺮﺓ )‪ ، (Memory Cells‬ﻭ ﺗﺘﻜﻮﻥ ﻛﻞ ﺧﻠﻴﺔ )ﻭﺍﻟﱵ ﺗﺸﻜﻞ ﺑﺖ ﻭﺍﺣﺪ ﻣﻦ‬
‫ﺍﻟﺬﺍﻛﺮﺓ( ﻣﻦ ﻣﻜﺜﻒ ﻭﺗﺮﺍﻧﺰﺳﺘﻮﺭ ﲝﻴﺚ ﳛﻔﻆ ﺍﳌﻜﺜﻒ ﻗﻴﻤﺔ ﺍﳋﻠﻴﺔ )ﺍﻟﺒﺖ( ﻭﺍﻟﱵ ﻫﻲ ﺇﻣﺎ ﻭﺟﻮﺩ‬
‫ﺇﻟﻜﺘﺮﻭﻥ )ﻣﻨﻄﻘﻴﺎ ﺗﺴﺎﻭﻱ ‪ (1‬ﻭﺇﻣﺎ ﻋﺪﻣﻬﺎ )ﻣﻨﻄﻘﻴﺎ ﺗﺴﺎﻭﻱ ‪ (0‬ﻭﻳﻌﻤﻞ ﺍﻟﺘﺮﺍﻧﺰﺳﺘﻮﺭ ﻋﻠﻰ ﺗﻐﻴﲑ ﻗﻴﻤﺔ‬
‫ﺍﳌﻜﺜﻒ ‪ .‬ﻭﻋﻠﻰ ﻫﺬﺍ ﺍﻟﺸﻜﻞ ﲢﻔﻆ ﲨﻴﻊ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﱪﺍﻣﺞ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﻳﺄﰐ ﺩﻭﺭ ﺍﳌﻌﺎﰿ‬
‫ﻟﺘﻨﻔﻴﺬ ﻫﺬﻩ ﺍﻷﻭﺍﻣﺮ ﺣﻴﺚ ﻳﻘﻮﻡ ﺑﻘﺮﺍﺋﺘﻬﺎ ﻭﻓﻬﻢ ﻭﻇﻴﻔﺘﻬﺎ )‪ (Decode‬ﻭﺗﻨﻔﻴﺬﻫﺎ ﻭﻣﻦ ﰒ ﻳﻘﻮﻡ ﲝﻔﻆ‬
‫ﺍﻟﻨﺘﺎﺋﺞ‪ .‬ﻭﻟﻜﻲ ﻳﻨﻔﺬ ﺍﳌﻌﺎﰿ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﻓﺎﻥ ﺍﻟﱪﻧﺎﻣﺞ ﳚﺐ ﺃﻥ ﻳﺘﻮﺍﺟﺪ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﻟﻴﺲ‬
‫ﻋﻠﻰ ﺃﺣﺪ ﺍﻟﺬﻭﺍﻛﺮ ﺍﻟﺜﺎﻧﻮﻳﺔ )ﻣﺜﻞ ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ(‪.‬‬
‫ﺣﱴ ﺍﻻﻥ ﱂ ﻧﺬﻛﺮ ﻭﻇﻴﻔﺔ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻷﻥ ﺑﻴﺌﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺍﳊﻘﻴﻘﻴﺔ ﻫﻲ ﺍﳌﻌﺎﰿ ﻭﻟﻴﺴﺖ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺃﻭ ﻏﲑﻩ ﻣﻦ‬
‫ﺍﻟﱪﺍﻣﺞ ﻭﻋﻠﻰ ﺍﳌﱪﻣﺞ ﺍﻹﳌﺎﻡ ﺑﻜﻴﻔﻴﺔ ﺑﺮﳎﺔ ﻋﺘﺎﺩ ﻭﻣﺘﺤﻜﻤﺎﺕ ﺍﳊﺎﺳﺐ ﻭﻛﻴﻔﻴﺔ ﻃﺒﺎﻋﺔ ﺍﳌﺨﺮﺟﺎﺕ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‬
‫ﻭﻗﺮﺍءﺓ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻣﻦ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻭﻻ ﻳﻘﺘﺼﺮ ﻋﻠﻰ ﺫﻟﻚ ﺑﻞ ﻋﻠﻰ ﺍﳌﱪﻣﺞ ﺗﻮﻓﲑ ﻃﺮﻗﺎ ﻭﺩﻭﺍﻻﹰ ﻹﺩﺍﺭﺓ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻣﻦ ﺣﺠﺰ ﺍﳌﻘﺎﻃﻊ ﻭﲢﺮﻳﺮﻫﺎ ﻭﻛﺬﻟﻚ ﺇﺩﺍﺭﺓ ﲨﻴﻊ ﻋﺘﺎﺩ ﺍﳊﺎﺳﺐ‪ .‬ﻛﻞ ﺫﻟﻚ ﳚﻌﻞ ﻋﻤﻠﻴﺔ ﻛﺘﺎﺑﺔ ﺍﻟﱪﺍﻣﺞ‬
‫ﻣﺴﺘﺤﻴﻠﺔ ﻭﻫﺬﺍ ﻣﺎ ﺃﺩﻯ ﺍﱃ ﻇﻬﻮﺭ ﻃﺒﻘﺔ ﺑﺮﳎﻴﺔ )‪ (Layer‬ﺗﺪﻳﺮ ﻋﺘﺎﺩ ﻭﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ﻭﺗﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺑﺮﳎﻴﺔ ﻟﻠﻤﱪﻣﺞ‬
‫‪٣‬ﻛﻞ ﺃﻣﺮ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻳﻘﺎﺑﻠﻪ ﺃﻣﺮﴽ ﻭﺍﺣﺪﴽ ﺑﻠﻐﺔ ﺍﻵﻟﺔ ﻟﺬﻟﻚ ﺣﻘﻴﻘﺔ ﻻ ﻳﻮﺟﺪ ﻓﺮﻗﴼ ﰲ ﺃﺩﺍء ﺍﻟﱪﺍﻣﺞ ﺍﳌﻜﺘﻮﺑﺔ ﺑﺄﻱ ﻣﻨﻬﻢ ﻭﻻ ﰲ ﺣﺠﻢ‬
‫ﺍﳌﻠﻒ ﺍﻟﻨﺎﺗﺞ ‪ ،‬ﻭﺇﳕﺎ ﻳﻈﻬﺮ ﺍﻟﻔﺮﻕ ﰲ ﺳﻬﻮﻟﺔ ﺗﻄﻮﻳﺮ ﺍﻟﱪﺍﻣﺞ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻭﻟﻜﻦ ﻋﻠﻰ ﺣﺴﺎﺏ ﺃﻧﻪ ﳚﺐ ﲢﻮﻳﻠﻬﺎ ﻋﻦ ﻃﺮﻳﻖ ﺍﳌﺠﻤﻊ‪.‬‬
‫‪٤‬ﰎ ﺗﻄﻮﻳﺮ ﻟﻐﺔ ﺍﻟﺴﻲ ‪‬ﺪﻑ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ﻳﻮﻧﻴﻜﺲ ‪ Unix‬ﰲ ﻣﻌﺎﻣﻞ ﺑﻴﻞ‪.‬‬

‫‪٤‬‬
‫ﻟﻜﻲ ﻳﺘﻌﺎﻣﻞ ﻣﻊ ﻫﺬﻩ ﺍﳌﻮﺍﺭﺩ‪.‬ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﲰﻴﺖ ﺑﻨﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ )‪ .(Opera ng System‬ﺍﳍﺪﻑ ﺍﻟﺮﺋﻴﺴﻲ ﳍﺬﻩ‬
‫ﺍﻟﻄﺒﻘﺔ ﻫﻲ ﻋﺰﻝ ﺍﳌﱪﻣﺞ ﻋﻦ ﺗﻌﻘﻴﺪﺍﺕ ﺍﻟﻌﺘﺎﺩ ﲝﻴﺚ ﺃﻥ ﺇﺩﺍﺭﺓ ﻫﺬﻩ ﺍﻟﻌﺘﺎﺩﻳﺎﺕ ﺃﺻﺒﺤﺖ ﻣﻦ ﻣﻬﻤﺔ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ‬
‫ﻭﰲ ﻧﻔﺲ ﺍﻟﻮﻗﺖ ﺗﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺑﺮﳎﻴﺔ )ﺃﻭ ﺟﻬﺎﺯ ﲣﻴﻠﻲ( ﻟﻺﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻫﺬﻩ ﺍﻟﻌﺘﺎﺩﻳﺎﺕ‪ .‬ﻭﺍﻟﺸﻜﻞ ‪ ٢.١‬ﻳﻮﺿﺢ‬
‫ﻣﻮﺿﻊ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ )ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ( ﰲ ﺣﺎﻟﺔ ﻗﺴﻤﻨﺎ ﺟﻬﺎﺯ ﺍﳊﺎﺳﺐ ﺍﱃ ﻋﺪﺓ ﻃﺒﻘﺎﺕ ]?[‪ .‬ﻭﺃﺩﱏ ﻃﺒﻘﺔ ﻫﻲ‬

‫ﺷﻜﻞ ‪ :.٢.١‬ﻃﺒﻘﺎﺕ ﺍﳊﺎﺳﺐ‬

‫ﻃﺒﻘﺔ ﺍﻟﻌﺘﺎﺩﻳﺎﺕ )‪ (Device Level‬ﺣﻴﺚ ﺗﺘﻜﻮﻥ ﻣﻦ ﺍﳌﺘﺤﻜﻤﺎﺕ ﻭﻣﻦ ﺍﻟﺸﺮﺍﺋﺢ ﺍﳌﺘﻜﺎﻣﻠﺔ )‪(Integrated Circuit‬‬
‫ﻭﺍﻷﺳﻼﻙ ﻭﻛﻞ ﻣﺎ ﻳﺘﻌﻠﻖ ﺑﺎﻷﺟﻬﺰﺓ ﺍﳌﺎﺩﻳﺔ‪.‬ﻳﻠﻲ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﻃﺒﻘﺔ ‪ Microarchitecure‬ﻭﻓﻴﻬﺎ ﺗﻈﻬﺮ ﺑﺮﳝﺠﺎﺕ‬
‫)‪ (Mircoprogram‬ﺗﺘﺤﻜﻢ ﰲ ﻋﻤﻞ ﺍﳌﺘﺤﻜﻤﺎﺕ ﻟﻜﻲ ﺗﺆﺩﻱ ﻭﻇﻴﻔﺘﻬﺎ ﻓﻤﺜﻼً ﺑﺮﳝﺞ ﺍﻝ ‪ data path‬ﺑﺪﺍﺧﻞ‬
‫ﺍﳌﻌﺎﰿ ﻭﺍﻟﺬﻱ ﻳﻘﻮﻡ ﰲ ﻛﻞ ﺩﻭﺭﺓ ﻟﻠﺴﺎﻋﺔ )‪ (Clock Cycle‬ﲜﻠﺐ ﻗﻴﻤﺘﲔ ﻣﻦ ﺍﳌﺴﺠﻼﺕ ﺍﱃ ﻭﺣﺪﺓ ﺍﳊﺴﺎﺏ‬
‫ﻭﺍﳌﻨﻄﻖ )‪ (Arithme c Logic Unit‬ﺍﻟﱵ ﲡﺮﻱ ﻋﻠﻴﻬﻢ ﻋﻤﻠﻴﺔ ﻣﺎ ﻭﻣﻦ ﰒ ﺗﻘﻮﻡ ﲝﻔﻆ ﺍﻟﻨﺘﻴﺠﺔ ﰲ ﺃﺣﺪ ﺍﳌﺴﺠﻼﺕ‪.‬‬
‫ﻭﻇﻴﻔﺔ ‪ data path‬ﻫﻲ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻭﺫﻟﻚ ﺑﺎﺭﺳﺎﳍﺎ ﺍﱃ ﻭﺣﺪﺓ ﺍﳊﺴﺎﺏ ﻭﺍﳌﻨﻄﻖ ‪ ،‬ﻭﺗﺸﻜﻞ‬
‫ﳎﻤﻮﻋﺔ ﺍﻷﻭﺍﻣﺮ ﺍﳌﺪﻋﻮﻣﺔ ﻭﻛﺬﻟﻚ ﺍﳌﺴﺠﻼﺕ ﺍﳌﺮﺋﻴﺔ ﳌﱪﻣﺞ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻃﺒﻘﺔ ﳎﻤﻮﻋﺔ ﺍﻷﻭﺍﻣﺮ )‪Instruc on‬‬
‫‪ (Set Architecture‬ﻭﺗﺴﻤﻰ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﻃﺒﻘﺔ ﺍﻵﻟﺔ )‪ (Machine Language‬ﺣﻴﺚ ﲢﻮﻱ ﻋﻠﻰ ﻛﻞ ﺍﻷﻭﺍﻣﺮ‬
‫ﺍﻟﱵ ﻳﺪﻋﻤﻬﺎ ﺍﳌﻌﺎﰿ ﲟﺎ ﻓﻴﻬﺎ ﺃﻭﺍﻣﺮ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻣﺴﺠﻼﺕ ﻣﺘﺤﻜﻤﺎﺕ ﺍﻟﻌﺘﺎﺩ )‪. (Device Controller‬‬
‫ﻭﻳﻠﻲ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﻃﺒﻘﺔ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻭﺍﻟﱵ ﺗﻔﺼﻞ ﻭﺗﻌﺰﻝ ﺍﻟﻌﺘﺎﺩ ﻋﻦ ﺍﳌﺴﺘﺨﺪﻡ ﻓﺒﺪﻻً ﻣﻦ ﺃﻥ ﻳﻘﻮﻡ ﺍﳌﱪﻣﺞ ﺑﱪﳎﺔ‬
‫ﻣﺘﺤﻜﻢ ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ ﻭﻧﻈﺎﻡ ﻟﻠﻤﻠﻔﺎﺕ ﺣﱴ ﻳﺘﻤﻜﻦ ﻣﻦ ﻗﺮﺍءﺓ ﻣﻠﻒ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﻓﺎﻥ ﺍﻟﻨﻈﺎﻡ ﻳﻮﻓﺮ ﻭﺍﺟﻬﺔ‬
‫ﻣﺒﺴﻄﺔ ﺑﺎﻟﺼﻮﺭﺓ )‪ .read(fd,buffer,size‬ﻭﺃﺧﲑﴽ ﺗﻮﺟﺪ ﻃﺒﻘﺔ ﺍﻟﱪﺍﻣﺞ )ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﻭﺍﳌﺴﺘﺨﺪﻡ(‬
‫ﻭﻻ ﺗﺼﻨﻒ ﺍﻟﻜﺜﲑ ﻣﻦ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﺿﻤﻦ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺣﻴﺚ ﺃﻥ ﺍﻟﱪﺍﻣﺞ ﺍﻟﱵ ﺗﺘﺒﻊ ﻟﻨﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﳚﺐ ﺃﻥ‬
‫ﺗﻌﻤﻞ ﰲ ﻣﺴﺘﻮﻯ ﺍﻟﻨﻮﺍﺓ )‪ (Kernel Mode‬ﻭﻟﻴﺲ ﰲ ﺍﳌﺴﺘﻮﻳﺎﺕ ﺍﻷﺧﺮﻯ ‪.٥‬‬
‫‪٥‬ﰲ ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﱐ ﺑﺈﺫﻥ ﺍﷲ ﺳﻴﺘﻢ ﺍﳊﺪﻳﺚ ﻋﻦ ﻣﺴﺘﻮﻳﺎﺕ ﺍﳊﻤﺎﻳﺔ ﰲ ﺍﳌﻌﺎﳉﺎﺕ‪.‬‬

‫‪٥‬‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪ .١.١‬ﻣﺎ ﻫﻮ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﻣﻦ ﺍﻟﺼﻌﺐ ﺇﳚﺎﺩ ﺗﻌﺮﻳﻔﴼ ﻭﺍﺿﺤﴼ ﻷﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻓﻤﺎ ﻳﻌﺘﱪﻩ ﺍﻟﺒﻌﺾ ﺗﺎﺑﻌﴼ ﻟﻨﻈﺎﻡ ﻣﺎ ﻻ ﻳﻌﺘﱪﻩ ﺍﻵﺧﺮﻭﻥ ﻛﺬﻟﻚ‪.‬‬
‫ﻟﻜﻦ ﻣﺎ ﰎ ﺍﻹﺗﻔﺎﻕ ﻋﻠﻴﻪ ﻫﻮ ﺃﻥ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻳﺪﻳﺮ ﻋﺘﺎﺩ ﻭﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ﻭﻳﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺑﺮﳎﻴﺔ )ﺟﻬﺎﺯ ﲣﻴﻠﻲ(‬
‫ﻣﻦ ﺧﻼﳍﺎ ﳝﻜﻦ ﺍﻹﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻫﺬﻩ ﺍﳌﻮﺍﺭﺩ‪.‬‬

‫‪ .١.١.١‬ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻛﺠﻬﺎﺯ ﲣﻴﻠﻲ‬

‫ﳑﺎ ﺳﺒﻖ ﳒﺪ ﺃﻥ ﺍﻟﻮﺍﺟﻬﺔ ﺍﻟﱵ ﺗﻘﺪﻣﻬﺎ ﻃﺒﻘﺔ ﺍﻵﻟﺔ )‪ (Machine Language Level‬ﻫﻲ ﺑﺪﺍﺋﻴﺔ ﻭﻳﺼﻌﺐ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ‬
‫ﰲ ﻛﺘﺎﺑﺔ ﺍﻟﱪﺍﻣﺞ ‪ ،‬ﻓﻜﻤﺎ ﺫﻛﺮﻧﺎ ﻛﻤﺜﺎﻝ ﻟﻠﻘﺮﺍءﺓ ﻣﻦ ﻣﻠﻒ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﳚﺐ ﺃﻥ ﳛﻮﻱ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻠﻰ ﺷﻔﺮﺓ ﻟﻨﻈﺎﻡ‬
‫ﺍﳌﻠﻔﺎﺕ ﺣﱴ ﻧﻌﺮﻑ ﻋﻨﻮﺍﻥ ﺍﳌﻠﻒ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ﻋﻠﻰ ﺍﻟﻘﺮﺹ‪ ،‬ﻭﻛﺬﻟﻚ ﳚﺐ ﺃﻥ ﳛﻮﻱ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻠﻰ ﺷﻔﺮﺓ ﻟﻠﺘﻌﺎﻣﻞ‬
‫ﻣﻊ ﻣﺘﺤﻜﻢ ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ ﻭﻫﻲ ﺷﻔﺮﺓ ﻟﻴﺴﺖ ﺑﺎﻟﻴﺴﲑﺓ ﺣﻴﺚ ﻟﻠﻘﺮﺍءﺓ ﻣﻦ ﺍﻟﻘﺮﺹ ﳚﺐ ﲢﺪﻳﺪ ﺭﻗﻢ ﺍﳌﻘﻄﻊ‬
‫ﻭﺭﻗﻢ ﺍﻟﺮﺃﺱ ﻭﺭﻗﻢ ﺍﳌﺴﺎﺭ ﻭﲢﺪﻳﺪ ﺍﻟﺬﺍﻛﺮﺓ ﺍﳌﺆﻗﺘﺔ )‪ (Buffer‬ﺣﱴ ﻳﺘﻢ ﲢﻤﻴﻞ ﺍﳌﻘﺎﻃﻊ ﺍﻟﻴﻬﺎ‪.‬ﻛﻞ ﻫﺬﻩ ﺍﻷﻣﻮﺭ ﻟﻮ‬
‫ﺍﺳﺘﻤﺮﺕ ‪‬ﺬﺍ ﺍﻟﺸﻜﻞ ﳌﺎ ﻭﺻﻠﺖ ﺍﻟﺘﻄﺒﻴﻘﺎﺕ ﳌﺎ ﻫﻲ ﻋﻠﻴﻬﺎ ﺍﻻﻥ‪ ،‬ﻟﺬﻟﻚ ﻛﺎﻥ ﺍﳊﻞ ﻫﻮ ﺑﺈﳚﺎﺩ ﻃﺒﻘﺔ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﻭﺍﻟﱵ ﺗﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺃﻭ ﺃﻭﺍﻣﺮ ﻣﺒﺴﻄﺔ ﻭﳎﺮﺩﺓ ﻣﻦ ﺗﻔﺎﺻﻴﻞ ﻭﺗﻌﻘﻴﺪﺍﺕ ﺍﻟﻌﺘﺎﺩ ﻟﻜﻲ ﺗﺴﺘﺨﺪﻣﻬﺎ ﺍﻟﱪﺍﻣﺞ ﺑﺪﻻ ﻣﻦ‬
‫ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﺗﻮﻓﺮﻫﺎ ﻃﺒﻘﺔ ﺍﻵﻟﺔ ‪.‬‬

‫‪ .٢.١.١‬ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻛﻤﺪﻳﺮ ﻟﻠﻤﻮﺍﺭﺩ ﻭﺍﻟﻌﺘﺎﺩ‬

‫ﺑﻌﺪ ﺃﻥ ﰎ ﻋﺰﻝ ﺍﳌﱪﻣﺞ ﺑﻮﺍﺳﻄﺔ ﻃﺒﻘﺔ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻓﺎﻥ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﺗﻘﺪﻡ ﲜﺎﻧﺐ ﺍﻟﻮﺍﺟﻬﺔ ﺍﻟﱪﳎﻴﺔ ﺇﺩﺍﺭﺓ ﻟﻌﺘﺎﺩ‬
‫ﺍﳊﺎﺳﺐ )ﺍﳌﻌﺎﰿ‪،‬ﺍﻟﺬﺍﻛﺮﺓ‪،‬ﺍﻷﻗﺮﺍﺹ ﺍﻟﺼﻠﺒﺔ ﻭﺍﳌﺮﻧﺔ‪،‬ﻛﺮﺕ ﺍﻟﺸﺒﻜﺔ‪،‬ﻭﻏﲑﻫﺎ ﻣﻦ ﺍﳌﺘﺤﻜﻤﺎﺕ( ‪ ،‬ﻭﻣﻬﻤﺔ ﺇﺩﺍﺭﺓ ﺍﻟﻌﺘﺎﺩ‬
‫ﺗﺘﺮﻛﺰ ﰲ ﺣﺠﺰ ﺍﻟﻌﺘﺎﺩ ﻭﲢﺮﻳﺮﻩ ‪ ،‬ﻓﻤﺜﻼً ﻳﻘﻮﻡ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺑﺈﺩﺍﺭﺓ ﺍﳌﻌﺎﰿ ﻧﻔﺴﻪ ﻭﺫﻟﻚ ﺑﺄﻥ ﳛﺠﺰ ﺍﳌﻌﺎﰿ ﻟﱪﻧﺎﻣﺞ‬
‫ﻣﺎ ﻭﻣﻦ ﰒ ﳛﺮﺭ ﺍﳌﻌﺎﰿ ﻭﳛﺠﺰﻩ ﻟﱪﻧﺎﻣﺞ ﺁﺧﺮ )ﺗﻌﺪﺩ ﺍﳌﻬﺎﻡ ‪ (Mul tasking‬ﻭﻛﺬﻟﻚ ﻳﺪﻳﺮ ﺍﻟﻨﻈﺎﻡ ﺃﻫﻢ ﻣﻮﺍﺭﺩ‬
‫ﺍﳊﺎﺳﺐ ﻭﻫﻲ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺫﻟﻚ ﲝﺠﺰ ﻣﻘﺎﻃﻊ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ )‪ (Memory Blocks‬ﺑﻨﺎءﴽ ﻋﻠﻰ ﻃﻠﺐ ﺑﺮﺍﻣﺞ‬
‫ﺍﳌﺴﺘﺨﺪﻡ ﻭﻛﺬﻟﻚ ﻋﻤﻠﻴﺔ ﲢﺮﻳﺮ ﺍﻟﺬﻭﺍﻛﺮ ﻭﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ ﻭﻣﻔﻬﻮﻡ ﺍﻟﺼﻔﺤﺎﺕ‪.‬‬

‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺧﻼﻝ ﺳﻨﻮﺍﺕ ﻣﻀﺖ ﺗﻄﻮﺭﺕ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺗﻄﻮﺭﴽ ﻣﻠﺤﻮﻇﴼ ﻣﻦ ﺃﻧﻈﻤﺔ ﺗﺸﻐﻴﻞ ﻟﱪﻧﺎﳎﴼ ﻭﺍﺣﺪﺍ ﺍﱃ ﺃﻧﻈﻤﺔ‬
‫ﻣﻮﺯﻋﺔ ﺗﺴﻤﺢ ﺑﺘﺸﻐﻴﻞ ﺃﻛﺜﺮ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﻋﻠﻰ ﻋﺪﺓ ﺣﻮﺍﺳﻴﺐ ﳐﺘﻠﻔﺔ‪ .‬ﻫﺬﺍ ﺍﻟﺘﻄﻮﺭ ﺳﺒﺒﻪ ﺍﻟﺮﺋﻴﺴﻲ ﺗﻄﻮﺭ ﺍﳊﺎﺳﺒﺎﺕ‬
‫ﻭﺍﳌﻌﺎﳉﺎﺕ ﻭﺍﺯﺩﻳﺎﺩ ﺣﺠﻢ ﺍﻟﺬﻭﺍﻛﺮ ﺑﺸﻜﻞ ﺭﻫﻴﺐ‪ .‬ﻭﰲ ﻫﺬﺍ ﺍﳉﺰء ﺳﻨﻠﻘﻲ ﻧﻈﺮﺓ ﻋﻠﻰ ﺗﻄﻮﺭ ﺃﺟﻴﺎﻝ ﺍﳊﻮﺍﺳﻴﺐ‬
‫ﻭﺑﻌﺾ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺍﻟﱵ ﺍﺳﺘﺨﺪﻣﺖ ﰲ ﺗﻠﻚ ﺍﻟﻔﺘﺮﺍﺕ‪.‬‬

‫‪٦‬‬
‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪ .١.٢.١‬ﺍﳉﻴﻞ ﺍﻟﺼﻔﺮﻱ )‪ :(١٩٤٥-١٦٢٤‬ﺍﳊﻮﺍﺳﻴﺐ ﺍﳌﻴﻜﺎﻧﻴﻜﻴﺔ‬

‫ﺃﻭﻝ ﳏﺎﻭﻟﺔ ﻟﺒﻨﺎء ﺁﻟﺔ ﺣﺴﺎﺑﻴﺔ ﻛﺎﻧﺖ ﻣﻦ ﻗﺒﻞ ﺍﻟﻌﺎﱂ ﺍﻟﻔﺮﻧﺴﻲ ﺑﻠﻴﺰ ﺑﺎﺳﻜﺎﻝ ‪ ٦‬ﰲ ﻋﺎﻡ ‪ ١٦٤٢‬ﻋﻨﺪﻣﺎ ﻛﺎﻥ ﻋﻤﺮﻩ ‪١٩‬‬
‫ﻋﺎﻣﴼ ﻭﺫﻟﻚ ﳌﺴﺎﻋﺪﺓ ﻭﺍﻟﺪﻩ ﺍﻟﺬﻱ ﻛﺎﻥ ﻳﻌﻤﻞ ﳏﺼﻼﹸ ﻟﻠﻀﺮﺍﺋﺐ ﳌﺼﻠﺤﺔ ﺍﳊﻜﻮﻣﺔ ﺍﻟﻔﺮﻧﺴﻴﺔ‪.‬ﻫﺬﻩ ﺍﻵﻟﺔ )ﻭﺗﻌﺮﻑ‬
‫ﺑﺎﻻﺳﻢ ‪ (Pascaline‬ﻫﻲ ﻣﻴﻜﺎﻧﻴﻜﻴﺔ ﺑﺎﻟﻜﺎﻣﻞ ﻭﺗﻮﻓﺮ ﻓﻘﻂ ﻋﻤﻠﻴﺔ ﺍﳉﻤﻊ ﻭﺍﻟﻄﺮﺡ )ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪.(٣.١‬‬

‫ﺷﻜﻞ ‪ :.٣.١‬ﺁﻟﺔ ﺑﺎﺳﻜﺎﻝ‬

‫ﻭﺑﻌﺪ ﺣﻮﺍﱄ ‪ ٣٠‬ﻋﺎﻣﴼ ﻗﺎﻡ ﺍﻟﻌﺎﱂ ﺍﻟﺮﻳﺎﺿﻲ ﺟﻮﺗﻔﺮﻳﺪ ﻟﻴﺒﱰ ‪ Go ried Wilhelm Leibniz‬ﺑﺒﻨﺎء ﺁﻟﺔ ﺣﺴﺎﺑﻴﺔ‬
‫ﻣﻴﻜﺎﻧﻴﻜﻴﺔ ﺃﺧﺮﻯ )ﰎ ﺍﻹﻧﺘﻬﺎء ﻣﻨﻬﺎ ﰲ ﻋﺎﻡ ‪ ١٦٩٤‬ﻭﲰﻴﺖ ﺑﺎﻻﺳﻢ ‪ (Step Reckoner‬ﻭﻟﻜﻦ ﻫﺬﻩ ﺍﳌﺮﺓ ﺃﺻﺒﺢ‬
‫ﻣﻦ ﺍﳌﻤﻜﻦ ﺇﺟﺮﺍء ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﳊﺴﺎﺑﻴﺔ ﺍﻷﺭﺑﻌﺔ‪ :‬ﺍﳉﻤﻊ ﻭﺍﻟﻄﺮﺡ ﻭ ﺍﻟﻀﺮﺏ ﻭﺍﻟﻘﺴﻤﺔ )ﺍﻟﺸﻜﻞ ‪ .(٤.١‬ﻭﻣﻀﺖ‬

‫ﺷﻜﻞ ‪ :.٤.١‬ﺁﻟﺔ ‪ Step Reckoner‬ﰲ ﻣﺘﺤﻒ ﺑﺄﳌﺎﻧﻴﺎ‬

‫ﺣﻮﺍﱄ ‪ ١٥٠‬ﻋﺎﻣﴼ ﺑﺪﻭﻥ ﺃﻱ ﺷﻲء ﻳﺬﻛﺮ ﺣﱴ ﻗﺎﻡ ﺍﻟﱪﻭﻓﻴﺴﻮﺭ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺒﺎﺝ ‪ Charles Babbage‬ﺑﺘﺼﻤﻴﻢ ﺁﻟﺔ‬
‫ﳏﺮﻙ ﺍﻟﻔﺮﻭﻕ ‪) Difference engine‬ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ ، (٥.١‬ﻭﻫﻲ ﺁﻟﺔ ﻣﻴﻜﺎﻧﻴﻜﻴﺔ ﺃﻳﻀﺎ ﺗﺸﺎﺑﻪ ﺁﻟﺔ ﺑﺎﺳﻜﺎﻝ ﰲ ﺃ‪‬ﺎ‬
‫‪٦‬ﻭﺍﻟﺬﻱ ﰎ ﺗﺴﻤﻴﺔ ﻟﻐﺔ ﺍﻟﱪﳎﺔ ﺑﺎﺳﻜﺎﻝ ﺑﺎﲰﻪ ﺗﺸﺮﻳﻔﴼ ﻟﻪ‪.‬‬

‫‪٧‬‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﻻ ﺗﻮﻓﺮ ﺳﻮﻯ ﻋﻤﻠﻴﱵ ﺍﳉﻤﻊ ﻭﺍﻟﻄﺮﺡ ﻟﻜﻦ ﻫﺬﻩ ﺍﻵﻟﺔ ﰎ ﺗﺼﻤﻴﻤﻬﺎ ﻟﻐﺮﺽ ﺣﺴﺎﺏ ﻗﻴﻢ ﺩﻭﺍﻝ ﻛﺜﲑﺍﺕ ﺍﳊﺪﻭﺩ‬
‫ﺑﺎﺳﺘﺨﺪﺍﻡ ﻃﺮﻕ ﺍﻟﺘﻘﺮﻳﺐ ﺍﳌﻨﺘﻬﻴﺔ )‪ . (Method of Finite Differences‬ﻭﻣﺎ ﻣﻴﺰ ﻫﺬﻩ ﺍﻵﻟﺔ ﻫﻲ ﻃﺮﻳﻘﺔ ﺇﺧﺮﺍﺝ‬

‫ﺷﻜﻞ ‪ :.٥.١‬ﳏﺮﻙ ﺍﻟﻔﺮﻭﻕ ﺑﻌﺪ ﺃﻥ ﻗﺎﻡ ﺍﺑﻦ ﺑﺎﺑﺒﺎﺝ ﺑﺘﺠﻤﻴﻌﻪ‬

‫ﺍﻟﻨﺘﺎﺋﺞ ﺣﻴﺚ ﺗﻨﻘﺶ ﺍﻟﻨﺘﺎﺋﺞ ﻋﻠﻰ ﺃﻟﻮﺍﺡ ﳓﺎﺳﻴﺔ‪ .‬ﻭﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﻥ ﺁﻟﺔ ﺍﻟﻔﺮﻭﻕ ﻋﻤﻠﺖ ﺟﻴﺪﴽ ﺇﻻ ﺃﻥ ﺗﺼﻤﻴﻤﻬﺎ‬
‫ﻛﺎﻥ ﻳﺴﻤﺢ ﲝﺴﺎﺏ ﺧﻮﺍﺭﺯﻣﻴﺔ ﻭﺍﺣﺪﺓ ﻓﻘﻂ ‪ ٧‬ﻭﻫﺬﺍ ﻣﺎ ﺟﻌﻞ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺒﺎﺝ ﻳﻌﻴﺪ ﳏﺎﻭﻟﺘﻪ ﳎﺪﺩﴽ ﻭﻳﺴﺘﻬﻠﻚ‬
‫ﺟﺰءﴽ ﺿﺨﻤﺎ ﻣﻦ ﻭﻗﺘﻪ ﻭﻣﻦ ﺛﺮﻭﺓ ﺣﻜﻮﻣﺘﻪ ﰲ ﺑﻨﺎء ﺁﻟﺔ ﺃﺧﺮﻯ ﻋ‪‬ﺮﻓﺖ ﺑﺎﳌﺤﺮﻙ ﺍﻟﺘﺤﻠﻴﻠﻲ ‪Analy cal Engine‬‬
‫)ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ .(٦.١‬ﻫﺬﺍ ﺍﳌﺤﺮﻙ )ﻭﻫﻮ ﺃﻳﻀﺎ ﺁﻟﺔ ﻣﻴﻜﺎﻧﻴﻜﻴﺔ ﺑﺎﻟﻜﺎﻣﻞ( ﺍﺣﺘﻮﻯ ﻋﻠﻰ ﺃﺭﺑﻊ ﻣﻜﻮﻧﺎﺕ‪ :‬ﺍﳌﺨﺰﻥ‬
‫)ﺍﻟﺬﺍﻛﺮﺓ ‪ ،(Memory‬ﺍﻟﻄﺎﺣﻨﺔ )ﻭﺣﺪﺓ ﺍﳊﺴﺎﺏ ‪ ، (Computa on Unit‬ﻭﺣﺪﺓ ﺍﻹﺩﺧﺎﻝ )ﻗﺎﺭﺉ ﺍﻟﺒﻄﺎﻗﺎﺕ‬
‫ﺍﳌﺜﻘﺒﺔ ‪ (Punched Card Reader‬ﻭﻭﺣﺪﺓ ﺍﻹﺧﺮﺍﺝ )ﺍﻟﺒﻄﺎﻗﺎﺕ ﺍﳌﺜﻘﺒﺔ ﻭﺍﻟﻠﻮﺣﺎﺕ ﺍﳌﻄﺒﻮﻋﺔ(‪ .‬ﻭﻳﺘﻜﻮﻥ ﺍﳌﺨﺰﻥ‬
‫ﻣﻦ ‪ ١٠٠٠‬ﻛﻠﻤﺔ )‪ (Word‬ﺑﻄﻮﻝ ‪ ٥٠‬ﺭﻗﻢ ﺻﺤﻴﺢ ﻭﺗﺴﺘﺨﺪﻡ ﳊﻔﻆ ﺍﳌﺘﻐﲑﺍﺕ ﻭﺍﻟﻨﺘﺎﺋﺞ ‪ ،‬ﺃﻣﺎ ﺍﻟﻄﺎﺣﻨﺔ ﻓﺘﺴﺘﻘﺒﻞ‬
‫ﺍﻟﻮﺳﺎﺋﻂ ﻣﻦ ﺍﳌﺨﺰﻥ ﻭﲡﺮﻱ ﻋﻠﻴﻬﻢ ﺃﻱ ﻣﻦ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺮﻳﺎﺿﻴﺔ ﺍﻷﺭﺑﻌﺔ ﻭﻣﻦ ﰒ ﲢﻔﻆ ﺍﻟﻨﺘﺎﺋﺞ ﰲ ﺍﳌﺨﺰﻥ‪ .‬ﺍﳌﻴﺰﺓ‬
‫ﺍﻷﺳﺎﺳﻴﺔ ﻟﻠﻤﺤﺮﻙ ﺍﻟﺘﺤﻠﻴﻠﻲ ﻫﻮ ﻗﺪﺭﺗﻪ ﻋﻠﻰ ﺣﻞ ﻋﺪﺩ ﻛﺒﲑ ﻣﻦ ﺍﳌﺸﺎﻛﻞ )ﻋﻠﻰ ﻋﻜﺲ ﳏﺮﻙ ﺍﻟﻔﺮﻭﻕ( ﺣﻴﺚ‬
‫ﺗﻜﺘﺐ ﺍﻟﱪﺍﻣﺞ ﰲ ﺑﻄﺎﻗﺎﺕ ﻣﺜﻘﺒﺔ ﻭﻳﺘﻢ ﻗﺮﺍﺋﺘﻬﺎ ﺍﱃ ﺍﳌﺤﺮﻙ ﺑﻮﺍﺳﻄﺔ ﻗﺎﺭﺋﴼ ﳍﺬﻩ ﺍﻟﺒﻄﺎﻗﺎﺕ‪ .‬ﻭﲢﻮﻱ ﻫﺬﻩ ﺍﻟﺒﻄﺎﻗﺎﺕ‬
‫ﻋﻠﻰ ﺃﻭﺍﻣﺮ ﻣﻮﺟﻪ ﺍﱃ ﺍﳌﺤﺮﻙ ﻟﻜﻲ ﻳﻘﻮﻡ ﺑﻘﺮﺍﺋﺔ ﻋﺪﺩﻳﻦ ﻣﻦ ﺍﳌﺨﺰﻥ ﻭﳚﺮﻱ ﻋﻤﻠﻴﺔ ﻣﺎ )ﲨﻊ ﻣﺜﻼ( ﻭﻣﻦ ﰒ ﳛﻔﻆ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﰲ ﺍﳌﺨﺰﻥ ﺃﻳﻀﺎ ‪ ،‬ﻭﻛﺬﻟﻚ ﲢﻮﻱ ﺃﻭﺍﻣﺮ ﺃﺧﺮﻯ ﻣﺜﻞ ﺍﳌﻘﺎﺭﻧﺔ ﺑﲔ ﻋﺪﺩﻳﻦ ﻭﺍﻟﺘﻔﺮﻉ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ‪ .‬ﻭﻷﻥ‬
‫ﺍﳌﺤﺮﻙ ﻗﺎﺑﻞ ﻟﻠﱪﳎﺔ )ﺑﻠﻐﺔ ﺷﺒﻴﻬﺔ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ( ﻓﻘﺪ ﺍﺳﺘﻌﺎﻥ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺒﺎﺝ ﺑﺎﳌﱪﳎﺔ ﺁﺩﺍ ﻟﻮﻓﻼﺱ ‪Ada Lovelace‬‬
‫ﻭﺍﻟﱵ ﺻﻨﻔﺖ ﻛﺄﻭﻝ ﻣﱪﻣﺞ ﰲ ﺍﻟﺘﺎﺭﻳﺦ‪ .‬ﻭﻟﺴﻮء ﺍﳊﻆ ﱂ ﻳﻨﺠﺢ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺒﺎﺝ ﰲ ﺃﻥ ﻳﺰﻳﺪ ﻣﻦ ﺩﻗﺔ ﺍﳌﺤﺮﻙ ﺭﲟﺎ‬
‫ﻷﻧﻪ ﳛﺘﺎﺝ ﺍﱃ ﺁﻻﻓﴼ ﻣﻦ ﺍﻟﺘﺮﻭﺱ ﻭﺍﻟﻌﺠﻼﺕ‪ .‬ﻭﺑﺸﻜﻞ ﺃﻭ ﺑﺂﺧﺮ ﻳﻌﺘﱪ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺎﺝ ﺍﳉﺪ ﺍﻷﻭﻝ ﻟﻠﺤﻮﺍﺳﻴﺐ‬
‫ﺍﳊﺎﻟﻴﺔ ﺣﻴﺚ ﺃﻥ ﻓﻜﺮﺓ ﻋﻤﻞ ﺍﳌﺤﺮﻙ ﺍﻟﺘﺤﻠﻴﻠﻲ ﻣﺸﺎ‪‬ﺔ ﻟﻠﺤﻮﺍﺳﻴﺐ ﺍﳊﺎﻟﻴﺔ‪.‬‬
‫ﻭﰲ ﺃﻭﺍﺧﺮ ‪ ١٩٣٠‬ﻗﺎﻡ ﺍﻟﻄﺎﻟﺐ ﺍﻷﳌﺎﱐ ﻛﻮﻧﺎﺭﺕ ﺗﺴﻮﺯﺍ ‪ Konrad Zuse‬ﺑﺒﻨﺎء ﺁﻟﺔ ﺣﺴﺎﺑﻴﺔ ﻭﻟﻜﻨﻬﺎ ﺗﻌﺘﻤﺪ ﻋﻠﻰ‬
‫ﺍﻟﺮﻳﻼﻱ )‪ (Relay‬ﻭﲰﻴﺖ ﲜﻬﺎﺯ ‪) Z1‬ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ (٧.١‬ﻭﺗﻌﺘﱪ ﺃﻭﻝ ﺣﺎﺳﺒﺔ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﺍﻟﺮﻳﻼﻱ ﻭﻋﻠﻰ ﺍﳌﻨﻄﻖ‬
‫‪٧‬ﰲ ﻋﺎﻡ ‪ ١٩٩١‬ﻗﺎﻡ ﻣﺘﺤﻒ ﺍﻟﻌﻠﻮﻡ ﺑﻠﻨﺪﻥ ﺑﺒﻨﺎء ﳕﻮﺫﺝ ﻣﻜﺘﻤﻞ ﳌﺤﺮﻙ ﺍﻟﻔﺮﻭﻕ‪.‬‬

‫‪٨‬‬
‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺷﻜﻞ ‪ :.٦.١‬ﺍﳌﺤﺮﻙ ﺍﻟﺘﺤﻠﻴﻠﻲ ﲟﺘﺤﻒ ﰲ ﻟﻨﺪﻥ‬

‫ﺍﻟﺜﻨﺎﺋﻲ ﰲ ﻋﻤﻠﻬﺎ‪ .‬ﻭﻟﺴﻮء ﺍﳊﻆ ﰎ ﺗﺪﻣﲑ ﺍﳊﺎﺳﺒﺔ ‪ Z1‬ﰲ ﺍﻧﻔﺠﺎﺭ ﰲ ﺑﺮﻟﲔ ﺃﺛﻨﺎء ﺍﳊﺮﺏ ﺍﻟﻌﺎﳌﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻋﺎﻡ ‪.١٩٤٣‬‬
‫ﻭﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﻥ ﺗﺼﻤﻴﻢ ‪ Z1‬ﱂ ﻳﺆﺛﺮ ﰲ ﺗﺼﺎﻣﻴﻢ ﺍﳊﻮﺍﺳﻴﺐ ﺍﻟﱵ ﺗﻠﻴﻪ ﺑﺴﺒﺐ ﺗﺪﻣﲑﻩ ﻫﻮ ﻭﲨﻴﻊ ﺧﻄﻂ ﺑﻨﺎﺋﻪ‬
‫ﺇﻻ ﺃﻧﻪ ﻳﻌﺘﱪ ﺃﺣﺪ ﺍﻟﺘﺼﺎﻣﻴﻢ ﺍﻟﱵ ﻛﺎﻥ ﳍﺎ ﺃﺛﺮﻫﺎ ﺫﺍﻙ ﺍﻟﻮﻗﺖ‪ .‬ﻭﺑﻌﺪ ﺑﺮﻫﺔ ﻣﻦ ﺍﻟﺰﻣﻦ ﻗﺎﻡ ﺟﻮﻥ ﺃﺗﺎﻧﺎﺳﻮﻑ ‪John‬‬

‫ﺷﻜﻞ ‪ :.٧.١‬ﺣﺎﺳﺒﺔ ‪ Z1‬ﺑﻌﺪ ﺇﻋﺎﺩﺓ ﺍﻧﺸﺎﺋﻬﺎ ﰲ ﻣﺘﺤﻒ ﺑﺄﳌﺎﻧﻴﺎ‬

‫‪ Vincent Atanasoff‬ﺑﺘﺼﻤﻴﻢ ﺟﻬﺎﺯ ‪)Atanasoff‬ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ??( ﻭﺍﻟﺬﻱ ﻛﺎﻥ ﻣﺪﻫﺸﺎ ﰲ ﻭﻗﺘﻪ ﺣﻴﺚ ﻳﺴﺘﺨﺪﻡ‬
‫ﺍﻟﺘﺤﺴﻴﺐ ﺍﻟﺜﻨﺎﺋﻲ )‪ (Binray Arithme c‬ﻭﳛﻮﻱ ﻣﻜﺜﻔﺎﺕ ﻟﻠﺬﺍﻛﺮﺓ ﻭﻟﻜﻦ ﺍﳉﻬﺎﺯ ﱂ ﻳﻜﻦ ﻋﻤﻠﻴﺎ‪ .‬ﻭﰲ ﺑﺪﺍﻳﺎﺕ‬
‫‪ ١٩٤٠‬ﻗﺎﻡ ﻫﻮﺍﺭﺩ ﺍﻳﻜﲔ ‪ Howard Aiken‬ﺑﺘﺼﻤﻴﻢ ﺍﳊﺎﺳﺒﺔ ‪ - ASCC‬ﻭﺍﻟﱵ ﺃﻋﻴﺪ ﺗﺴﻤﻴﺘﻬﺎ ﺍﱃ ‪Harvard Mark‬‬
‫‪ - I‬ﰲ ﺟﺎﻣﻌﺔ ﻫﺎﻓﺎﺭﺩ )ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪.(٩.١‬ﻭﻗﺪ ﺃﺗﺒﻊ ﻫﻮﺍﺭﺩ ﻧﻔﺲ ﻣﻨﻬﺞ ﺑﺎﺑﺒﺎﺝ ﻭﻗﺮﺭ ﺃﻥ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺍﻟﺮﻳﻼﻱ‬
‫ﻭﺃﻥ ﻳﺼﻤﻢ ﺣﺎﺳﺒﺔ ﻟﻸﻏﺮﺍﺽ ﺍﻟﻌﺎﻣﺔ ﻭﺍﻟﱵ ﻓﺸﻞ ‪‬ﺎ ﺷﺎﺭﻟﺰ ﺑﺎﺑﺒﺎﺝ‪.‬ﻭﰲ ﻋﺎﻡ ‪ ١٩٤٤‬ﰎ ﺍﻹﻧﺘﻬﺎء ﻣﻦ ﺗﺼﻤﻴﻤﻬﺎ ﻭﰎ‬
‫ﺗﺼﻤﻴﻢ ﻧﺴﺨﺔ ﳏﺴﻨﺔ ﺃﻳﻀﺎ ﲰﻴﺖ ﺏ ‪.Harvard Mark II‬ﻭﻣﻊ ﻫﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﺍﻧﺘﻬﻰ ﻋﺼﺮ ﺍﳊﺎﺳﺒﺎﺕ ﺍﳌﻴﻜﺎﻧﻴﻜﻴﺔ‬

‫‪٩‬‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪Iowa State‬‬ ‫ﺷﻜﻞ ‪ :.٨.١‬ﺣﺎﺳﺒﺔ ‪ Atanasoff‬ﺑﻌﺪ ﺇﻋﺎﺩﺓ ﺍﻧﺸﺎﺋﻬﺎ ﰲ ﺟﺎﻣﻌﺔ‬

‫)ﺏ( ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﻭﺍﻟﺘﺤﻜﻢ‬ ‫‪Mark I‬‬ ‫)ﺍ( ﺍﳉﺰء ﺍﻷﻳﺴﺮ ﻣﻦ ﺣﺎﺳﺒﺔ‬
‫‪Harvard Mark I‬‬ ‫ﺷﻜﻞ ‪ :.٩.١‬ﺣﺎﺳﺒﺔ‬

‫ﻭﺍﻟﺮﻳﻼﻱ ﻭﺑﺪﺃ ﻋﺼﺮ ﺟﺪﻳﺪ‪.‬‬

‫‪ .٢.٢.١‬ﺍﳉﻴﻞ ﺍﻷﻭﻝ )‪ :(١٩٥٥-١٩٤٥‬ﺍﻟﺼﻤﺎﻣﺎﺕ ﺍﳌﻔﺮﻏﺔ ﻭ ﻟﻮﺣﺎﺕ ﺍﻟﺘﻮﺻﻴﻞ‬

‫ﰲ ﺑﺪﺍﻳﺎﺕ ﺍﳊﺮﺏ ﺍﻟﻌﺎﳌﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ‪ ،‬ﻛﺎﻥ ﺃﻣﲑ ﺍﻟﺒﺤﺮﻳﺔ ﰲ ﺑﺮﻟﲔ ﻳﺮﺳﻞ ﺭﺳﺎﺋﻞ ﺍﱃ ﺍﻟﻐﻮﺍﺻﺎﺕ ﺍﻷﳌﺎﻧﻴﺔ ﻋﱪ ﻣﻮﺟﺎﺕ‬
‫ﺍﻟﺮﺍﺩﻳﻮ ﻭﺍﻟﱵ ﺍﺳﺘﻄﺎﻉ ﺣﻠﻔﺎﺅﻫﺎ ﺍﻟﱪﻳﻄﺎﻧﻴﲔ ﺍﻟﺘﻘﺎﻃﻬﺎ ‪ ،‬ﻭﻟﺴﻮء ﺣﻈﻬﻢ ﻛﺎﻧﺖ ﺍﻟﺮﺳﺎﺋﻞ ﺗﺮﺳﻞ ﻣﺸﻔﺮﺓ ﻭﺫﻟﻚ ﻋﻦ‬
‫ﻃﺮﻳﻖ ﺷﻔﺮﺓ ﺧﺎﺻﺔ ﺗﻨﺘﺞ ﻣﻦ ﻗﺒﻞ ﺟﻬﺎﺯ ﻳﺴﻤﻰ ﲜﻬﺎﺯ ﺇﳒﻤﺎ )‪ Enigma Machine‬ﻭﺍﻟﺬﻱ ﰎ ﺗﺼﻨﻴﻌﻪ ﻟﺘﺸﻔﲑ‬
‫ﺍﻟﺮﺳﺎﺋﻞ ﻭﻓﻚ ﺗﺸﻔﲑﻫﺎ ‪ .‬ﻭﻗﺪ ﲤﻜﻨﺖ ﺍﻹﺳﺘﺨﺒﺎﺭﺍﺕ ﺍﻟﱪﻳﻄﺎﻧﻴﺔ ﻣﻦ ﺍﳊﺼﻮﻝ ﻋﻠﻰ ﺃﺣﺪ ﻫﺬﻩ ﺍﻷﺟﻬﺰﺓ ﻭﺫﻟﻚ‬
‫ﺑﻌﺪ ﺍﻹﺗﻔﺎﻕ ﻣﻊ ﺍﻹﺳﺘﺨﺒﺎﺭﺍﺕ ﺍﻟﺒﻮﻟﻨﺪﻳﺔ ﻭﺍﻟﱵ ﻛﺎﻧﺖ ﻗﺪ ﺳﺮﻗﺖ ﺟﻬﺎﺯﴽ ﻣﻦ ﺍﻷﳌﺎﻥ‪ .‬ﻭﺣﱴ ﻳﺘﻤﻜﻦ ﺍﻟﱪﻳﻄﺎﻧﻴﲔ‬
‫ﻣﻦ ﻓﻚ ﺷﻔﺮﺓ ﺍﻟﺮﺳﺎﺋﻞ ﻓﺎﻥ ﻫﺬﺍ ﻳﺘﻄﻠﺐ ﻭﻗﺘﴼ ﻭﻋﻤﻠﻴﺎﺕ ﺣﺴﺎﺑﻴﺔ ﻃﻮﻳﻠﺔ ‪ ،‬ﻟﺬﻟﻚ ﺳﺮﻋﺎﻥ ﻣﺎ ﺃﺳﺴﺖ ﻣﻌﻤﻼ‬

‫‪١٠‬‬
‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺷﻜﻞ ‪ :.١٠.١‬ﺁﻟﺔ ﺇﳒﻤﺎ ﺍﻷﳌﺎﻧﻴﺔ ﻟﺘﺸﻔﲑ ﺍﻟﺮﺳﺎﺋﻞ ﻭﻓﻜﻬﺎ‬

‫ﺳﺮﻳﺎ ﳛﻮﻱ ﻋﻠﻰ ﺣﺎﺳﺒﺔ ﺍﻟﻜﺘﺮﻭﻧﻴﺔ ﻋﺮﻓﺖ ﺑﺎﻻﺳﻢ ‪ .Colossus‬ﻫﺬﻩ ﺍﳊﺎﺳﺒﺔ ﰎ ﺗﺼﻤﻴﻤﻬﺎ ﻣﻦ ﻗﺒﻞ ﻋﺪﺓ ﺃﺷﺨﺎﺹ‬
‫ﻭﺷﺎﺭﻙ ﻓﻴﻬﺎ ﺍﻟﻌﺎﱂ ﺁﻻﻥ ﺗﻮﺭﻧﺞ ﻭﺃﺻﺒﺤﺖ ﺟﺎﻫﺰﺓ ﻟﻠﻌﻤﻞ ﰲ ﻋﺎﻡ ‪ .١٩٤٣‬ﻭﺑﺴﺒﺐ ﻛﻮﻥ ﺍﳌﺸﺮﻭﻉ ﺳﺮﻳﺎ ﻭﰎ‬
‫ﺍﻟﺘﻜﺘﻢ ﻋﻠﻴﻪ ﳌﺎ ﻳﻘﺎﺭﺏ ‪ ٣٠‬ﻋﺎﻣﺎ ﻓﺎﻥ ﻫﺬﺍ ﺍﻟﻨﻮﻉ ﻣﻦ ﺍﳊﻮﺍﺳﻴﺐ ﱂ ﻳﺆﺛﺮ ﻋﻠﻰ ﺗﺼﺎﻣﻴﻢ ﺍﳊﻮﺍﺳﻴﺐ ﺍﳊﺪﻳﺜﺔ ﻭﻟﻜﻦ‬
‫ﳚﺪﺭ ﺑﺎﻟﺬﻛﺮ ﺃﻥ ﻫﺬﻩ ﺍﳊﺎﺳﺒﺔ ﺗﻌﺘﱪ ﺃﻭﻝ ﺣﺎﺳﺒﺔ ﺇﻟﻜﺘﺮﻭﻧﻴﺔ ﻗﺎﺑﻠﺔ ﻟﻠﱪﳎﺔ ﺗﺴﺘﺨﺪﻡ ﺍﻟﺼﻤﺎﻣﺎﺕ ﺍﳍﻮﺍﺋﻴﺔ ﰲ ﺣﺴﺎﺑﺎ‪‬ﺎ‪.‬‬
‫ﻭﰲ ﻋﺎﻡ ‪ ١٩٤٣‬ﻗﺪﻡ ﺟﻮﻥ ﻣﻮﻛﻠﻲ ‪ John Mauchley‬ﻣﻘﺘﺮﺣﴼ ﺍﱃ ﺍﳉﻴﺶ ﺍﻷﻣﺮﻳﻜﻲ ﻃﺎﻟﺒﴼ ﲤﻮﻳﻠﻪ ﺑﺎﳌﺎﻝ ﻟﻠﺒﺪء‬
‫ﺑﺘﺼﻤﻴﻢ ﺣﺎﺳﺒﺔ ﺇﻟﻜﺘﺮﻭﻧﻴﺔ ﳊﺴﺎﺏ ﺟﺪﺍﻭﻝ ﺇﻃﻼﻕ ﺍﳌﺪﻓﻌﻴﺎﺕ ﺑﺪﻻﹰ ﻣﻦ ﺣﺴﺎ‪‬ﺎ ﻳﺪﻭﻳﺎ ﻭﺫﻟﻚ ﻟﺘﻘﻠﻴﻞ ﺍﻷﺧﻄﺎء‬
‫ﻭﻛﺴﺐ ﺍﻟﻮﻗﺖ‪ ،‬ﻭﻗﺪ ﲤﺖ ﺍﳌﻮﺍﻓﻘﺔ ﻋﻠﻰ ﺍﳌﺸﺮﻭﻉ ﻭﺑﺪﺃ ﺟﻮﻥ ﻣﻮﻛﻠﻲ ﻭﻃﺎﻟﺒﻪ ﺍﳋﺮﻳﺞ ﺇﻳﻜﺮﻳﺖ ﺑﺒﻨﺎء ﺣﺎﺳﺒﺔ‬
‫ﰎ ﺗﺴﻤﻴﺘﻬﺎ ﺑﺎﻻﺳﻢ ﺇﻳﻨﺎﻙ ‪ ENIAC‬ﺍﺧﺘﺼﺎﺭﺍ ﻟﻠﺠﻤﻠﺔ ‪.Electronic Numerical Integrator And Computer‬‬
‫ﻭﺗﺘﻜﻮﻥ ﻣﻦ ‪ ١٨٠٠٠‬ﺻﻤﺎﻣﺎ ﻣﻔﺮﻏﺎ )‪ (Vacuum Tubes‬ﻭ ‪ ١٥٠٠‬ﺣﺎﻛﻤﺔ )‪ ، (Relays‬ﻭﺗﺰﻥ ﺍﳊﺎﺳﺒﺔ ‪٣٠‬‬
‫ﻃﻦ ﻭﺗﺴﺘﻬﻠﻚ ‪ ١٤٠‬ﻛﻴﻠﻮ ﻭﺍﻁ ﻣﻦ ﺍﻟﻄﺎﻗﺔ‪ .‬ﻭﺩﺍﺧﻠﻴﺎ ﲢﺘﻮﻱ ﺍﳊﺎﺳﺒﺔ ﻋﻠﻰ ‪ ٢٠‬ﻣﺴﺠﻞ ﻛﻞ ﻣﻨﻬﻢ ﻳﺴﻊ ﻋﺪﺩﺍ‬
‫ﺻﺤﻴﺤﺎ ﺑﻄﻮﻝ ‪ ١٠‬ﺧﺎﻧﺎﺕ‪ .‬ﻭﺗﺘﻢ ﺑﺮﳎﺔ ﺇﻳﻨﺎﻙ ﻋﻦ ﻃﺮﻳﻖ ‪ ٦٠٠٠‬ﻣﻔﺘﺎﺡ ‪.Switch‬‬
‫ﻭﻗﺪ ﰎ ﺍﻹﻧﺘﻬﺎء ﻣﻦ ﺗﺼﻤﻴﻢ ﺇﻳﻨﺎﻙ ﻋﺎﻡ ‪ ، ١٩٤٦‬ﺍﻟﻮﻗﺖ ﺍﻟﺬﻱ ﻛﺎﻧﺖ ﺍﳊﺮﺏ ﻗﺪ ﺍﻧﺘﻬﺖ ﻭﱂ ﺗﺴﺘﺨﺪﻡ ﺍﳊﺎﺳﺒﺔ‬
‫ﳍﺪﻓﻬﺎ ﺍﻟﺮﺋﻴﺴﻲ‪ .‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻧﻈﻢ ﺟﻮﻥ ﻣﻮﻛﻠﻲ ﻭﻃﺎﻟﺒﻪ ﺇﻳﻜﺮﻳﺖ ﻣﺪﺭﺳﺔ ﺻﻴﻔﻴﺔ ﻟﻮﺻﻒ ﻣﺸﺮﻭﻋﻬﻢ ﻟﻠﺒﺎﺣﺜﲔ‬
‫ﻭﺍﳌﻬﺘﻤﲔ‪ .‬ﺍﻷﻣﺮ ﺍﻟﺬﻱ ﺃﺳﻔﺮ ﻋﻦ ﻇﻬﻮﺭ ﻋﺪﺩ ﻛﺒﲑ ﻣﻦ ﺍﳊﺎﺳﺒﺎﺕ ﺍﻟﻀﺨﻤﺔ ‪ .‬ﻭﺃﻭﻝ ﺣﺎﺳﺒﺔ ﺑﻌﺪﻫﺎ ﻛﺎﻧﺖ‬

‫‪١١‬‬
 ‫‪ .١‬ﻣﻘﺪﻣﺔ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺷﻜﻞ ‪ :.١١.١‬ﺍﳊﺎﺳﺒﺔ ‪ colossus‬ﺍﻟﱵ ﻛﺴﺮﺕ ﺷﻔﺮﺓ ﺇﳒﻤﺎ‬

‫‪ENIAC‬‬ ‫ﺷﻜﻞ ‪ :.١٢.١‬ﺍﳊﺎﺳﺒﺔ‬

‫‪ILLIAC‬‬‫‪ EDSAC‬ﰲ ﻋﺎﻡ ‪ ١٩٤٩‬ﺑﻮﺍﺳﻄﺔ ﻭﻳﻠﻜﺲ ﰲ ﺟﺎﻣﻌﺔ ﻛﺎﻣﱪﺩﺝ‪ .‬ﻛﺬﻟﻚ ﺗﻠﺘﻪ ﺍﳊﺎﺳﺒﺎﺕ ‪ JOHNIAC‬ﻭ‬
‫ﻭﻏﲑﻫﻢ‪.‬ﺑﻌﺪ ﺫﻟﻚ ﺑﺪﺃ ﺟﻮﻥ ﻣﻮﻛﻠﻲ ﻭﺇﻳﻜﺮﻳﺖ ﺑﺎﻟﻌﻤﻞ ﻋﻠﻰ ﺣﺎﺳﺒﺔ ﺃﺧﺮﻯ ﲰﻴﺖ ﺑﺎﻻﺳﻢ ‪ EDVAC‬ﺍﺧﺘﺼﺎﺭﺍ‬
‫ﻟﻠﺠﻤﻠﺔ ‪ Electronic Discrete Variable Automa c Computer‬ﻭﺍﻟﱵ ﻛﺎﻧﺖ ﺗﻌﻤﻞ ﺑﺎﻷﺭﻗﺎﻡ ﺍﻟﺜﻨﺎﺋﻴﺔ ﺑﺪﻻ ﻣﻦ‬
‫ﺍﻟﻌﺸﺮﻳﺔ )ﻛﻤﺎ ﰲ ﺇﻳﻨﺎﻙ(‪.‬ﺑﻌﺪ ﺫﻟﻚ ﺗﻮﻗﻒ ﺍﳌﺸﺮﻭﻉ ﺑﺴﺒﺐ ﺃﻥ ﺟﻮﻥ ﻭﺇﻳﻜﺮﻳﺖ ﻗﺪ ﺃﻧﺸﺌﺎ ﺷﺮﻛﺘﻬﻢ ﺍﳋﺎﺻﺔ‪.‬‬

‫‪١٢‬‬
‫‪ .٢.١‬ﺗﺎﺭﻳﺦ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪EDVAC‬‬ ‫ﺷﻜﻞ ‪ :.١٣.١‬ﺍﳊﺎﺳﺒﺔ‬

‫‪١٣‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬
‫ﺣﻮﺍﺳﻴﺐ ﻋﺎﺋﻠﺔ ‪ x86‬ﺗﺘﺒﻊ ﳌﻌﻤﺎﺭﻳﺔ ﺍﻟﻌﺎﱂ ﺟﻮﻥ ﻓﻮﻥ ﻧﻴﻮﻣﺎﻥ )‪ (John von Neumann architecture‬ﻭﺍﻟﱵ ﺗﻨﺺ‬
‫ﻋﻠﻰ ﺃﻥ ﺃﻱ ﺗﺼﻤﻴﻢ ﳉﻬﺎﺯ ﺣﺎﺳﺐ ﳚﺐ ﺃﻥ ﻳﺘﻜﻮﻥ ﻣﻦ ﺍﻟﺜﻼﺙ ﻭﺣﺪﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ .١‬ﻣﻌﺎﰿ ﺃﻭ ﻭﺣﺪﺓ ﻣﻌﺎﳉﺔ ﻣﺮﻛﺰﻳﺔ )‪.(Central Processing Unit‬‬
‫‪ .٢‬ﺫﺍﻛﺮﺓ )‪.(Memory‬‬
‫‪ .٣‬ﺃﺟﻬﺰﺓ ﺇﺩﺧﺎﻝ ﻭﺇﺧﺮﺍﺝ )‪.(I/O Devices‬‬
‫ﺍﻟﻮﺣﺪﺓ ﺍﻻﻭﱃ ﻫﻲ ﻭﺣﺪﺓ ﺍﳌﻌﺎﳉﺔ ﻭﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﳊﺴﺎﺑﻴﺔ ‪ ،‬ﺃﻣﺎ ﺍﻟﻮﺣﺪﺓ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻬﻲ‬
‫ﲢﻮﻱ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻭﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﳚﺐ ﻋﻠﻰ ﻭﺣﺪﺓ ﺍﳌﻌﺎﳉﺔ ﺃﻥ ﺗﻨﻔﺬﻫﺎ ‪ ،‬ﻭﺃﺧﲑﴽ ﻭﺣﺪﺍﺕ ﺍﻹﺩﺧﺎﻝ‬
‫ﻭﺍﻹﺧﺮﺍﺝ ﻭﻫﻲ ﺍﻻﺟﻬﺰﺓ ﺍﻟﱵ ﺗﺴﺘﺨﺪﻡ ﰲ ﺍﺩﺧﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﺧﺮﺍﺟﻬﺎ‪).‬ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ ١.٢‬ﺣﻴﺚ ﻳﻮﺿﺢ ﻣﺜﺎﻻً‬
‫ﳍﺬﻩ ﺍﳌﻌﻤﺎﺭﻳﺔ( ﻭﻳﺮﺑﻂ ﺑﲔ ﻛﻞ ﻫﺬﻩ ﺍﻷﺟﺰﺍء ﻫﻮ ﻣﺴﺎﺭ ﺍﻟﻨﻈﺎﻡ )‪ (System Bus‬ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺳﻨﺴﺘﻌﺮﺽ ﻭﻇﻴﻔﺔ‬
‫ﻛﻞ ﺟﺰء ﻋﻠﻰ ﺣﺪﺓ‪.‬‬

‫‪x86‬‬ ‫ﺷﻜﻞ ‪ :.١.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫‪١٥‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫‪ .١.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺍﻟﻨﻈﺎﻡ‬

‫‪System Bus‬‬ ‫‪ .١.١.٢‬ﻣﺴﺎﺭ ﺍﻟﻨﻈﺎﻡ‬

‫ﻳﺮﺑﻂ ﻣﺴﺎﺭ ﺍﻟﻨﻈﺎﻡ ‪ (System Bus) ١‬ﻭﺣﺪﺓ ﺍﳌﻌﺎﳉﺔ ﺍﳌﺮﻛﺰﻳﺔ )‪ (CPU‬ﻣﻊ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ‪ .‬ﻭ ﻭﻇﻴﻔﺔ‬
‫ﻫﺬﻩ ﺍﳌﺴﺎﺭﺍﺕ ﻫﻲ ﻧﻘﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﲔ ﺃﺟﺰﺍء ﺍﳊﺎﺳﺐ ﺍﳌﺨﺘﻠﻔﺔ‪ .‬ﻭﺍﻟﺸﻜﻞ ‪ ٢.٢‬ﻳﻮﺿﺢ ﺍﻟﺼﻮﺭﺓ ﺍﻟﻌﺎﻣﺔ ﻟﻠﻤﺴﺎﺭﺍﺕ‬
‫ﰲ ﺃﺟﻬﺰﺓ ﺍﳊﻮﺍﺳﻴﺐ ﺍﻟﺸﺨﺼﻴﺔ )‪ .(Personal Computers‬ﻭﻳﺘﺄﻟﻒ ﻣﺴﺎﺭ ﺍﻟﻨﻈﺎﻡ ﻣﻦ ﺛﻼﺙ ﻣﺴﺎﺭﺍﺕ‪ :‬ﻣﺴﺎﺭ‬
‫ﺍﻟﺒﻴﺎﻧﺎﺕ )‪ (Data Bus‬ﻭﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ )‪ (Address Bus‬ﻭﻣﺴﺎﺭ ﺍﻟﺘﺤﻜﻢ )‪.(Control Bus‬‬

‫‪x86‬‬ ‫ﺷﻜﻞ ‪ :.٢.٢‬ﺍﳌﺴﺎﺭﺍﺕ ﰲ ﺍﳊﻮﺍﺳﻴﺐ ﺍﻟﺸﺨﺼﻴﺔ‬

‫‪١‬ﻭﻳﺴﻤﻰ ﺃﻳﻀﺎ ‪.Front-side Bus‬‬

‫‪١٦‬‬
‫‪ .١.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺍﻟﻨﻈﺎﻡ‬

‫‪Data Bus‬‬ ‫ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ‬

‫ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻫﻮ ﻋﺒﺎﺭﺓ ﻋﻦ ﺧﻄﻮﻁ )‪ (Lines‬ﻛﻞ ﺧﻂ ﳝﺜﻞ ﺑﺖ ﻭﺍﺣﺪ‪ .‬ﻭﻏﺎﻟﺒﺎ ﻣﺎ ﻳﻜﻮﻥ ﻫﻨﺎﻙ ‪ ٣٢‬ﺧﻂ‬
‫)ﺃﻱ ﺃﻥ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﻄﻮﻝ ‪ ٣٢‬ﺑﺖ( ﻭﻳﺴﺘﺨﺪﻡ ﻫﺬﺍ ﺍﳌﺴﺎﺭ ﰲ ﻧﻘﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ )‪ (Data‬ﻣﻦ ﺍﳌﻌﺎﰿ )ﻭﲢﺪﻳﺪﴽ‬
‫ﻣﻦ ﻭﺣﺪﺓ ﺍﻟﺘﺤﻜﻢ ‪ (Control Unit‬ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺍﻟﺬﻱ ﻳﺘﻮﺍﺟﺪ ﺑﺪﺍﺧﻞ ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ ‪.NorthBridge‬‬
‫ﻭﺑﺴﺒﺐ ﺃﻥ ﺣﺠﻢ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻫﻮ ﺣﺠﻢ ﺛﺎﺑﺖ ﻓﺎﻥ ﻫﺬﺍ ﻳﺘﻄﻠﺐ ﻣﻌﺎﳉﺔ ﺧﺎﺻﺔ ﻋﻨﺪ ﺍﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ ﺑﻄﻮﻝ‬
‫ﺃﻗﻞ ﻣﻦ ﻃﻮﻝ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ ،‬ﻓﻐﺎﻟﺒﺎ ﻣﺎ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﺎﺿﺎﻓﺔ ﺃﺻﻔﺎﺭ ﰲ ﺍﳋﻄﻮﻁ ﺍﻟﻐﲑ ﻣﺴﺘﺨﺪﻣﺔ )‪.(Padding‬‬
‫ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺇﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ ﺑﻄﻮﻝ ﺃﻛﱪ ﻓﺎﻥ ﻋﻤﻠﻴﺔ ﻧﻘﻠﻬﺎ ﺗﺘﻢ ﻋﻠﻰ ﻋﺪﺓ ﻣﺮﺍﺣﻞ ﻭﰲ ﻛﻞ ﻣﺮﺣﻠﺔ ﺗﺮﺳﻞ ‪ ٣٢‬ﺑﺖ‬
‫ﻣﻦ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪.‬‬

‫‪Address Bus‬‬ ‫ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ‬

‫ﻳﺴﺘﺨﺪﻡ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﻧﻘﻞ ﻋﻨﻮﺍﻥ ﺍﻟﺬﺍﻛﺮﺓ ﺍﳌﺮﺍﺩ ﺍﺳﺘﺨﺪﺍﻣﻪ ﺳﻮﺍءﴽ ﻟﻠﻘﺮﺍءﺓ ﻣﻨﻪ ﺃﻭ ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻴﻪ ‪ ،‬ﻭﳛﺪﺩ‬
‫ﺣﺠﻢ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺃﻛﱪ ﻋﻨﻮﺍﻥ ﳝﻜﻦ ﺍﻟﻮﺻﻞ ﺍﻟﻴﻪ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺑﺎﻟﺘﺎﱄ ﳛﺪﺩ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﱵ ﻳﺴﺘﻄﻴﻊ‬
‫ﺍﳊﺎﺳﺐ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ‪ .‬ﻭﰲ ﺍﻷﺟﻬﺰﺓ ﺍﻟﱵ ﺗﺴﺘﺨﺪﻡ ﻣﻌﺎﳉﺎﺕ ﺍﻧﺘﻞ ‪ 8086‬ﻛﺎﻥ ﺣﺠﻢ ﻫﺬﺍ ﺍﳌﺴﺎﺭ ﻫﻮ ‪ ٢٠‬ﺑﺖ‬
‫ﻭﺑﺎﻟﺘﺎﱄ ﻓﺎﻥ ﺃﻗﺼﻰ ﺫﺍﻛﺮﺓ ﻳﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻫﺬﺍ ﺍﳌﻌﺎﰿ ﻫﻲ ‪ ١‬ﻣﻴﺠﺎ ‪ ٢‬ﺃﻣﺎ ﰲ ﻣﻌﺎﳉﺎﺕ ‪ 80286/80386‬ﻓﺎﻥ ﺣﺠﻢ‬
‫ﻫﺬﺍ ﻣﺴﺎﺭ ﻫﻮ ‪ ٢٤‬ﺑﺖ ﻭﰲ ﺍﳌﻌﺎﳉﺎﺕ ﺍﻟﱵ ﺗﻠﻴﻬﺎ ﰎ ﺯﻳﺎﺩﺓ ﻫﺬﺍ ﺍﳊﺠﻢ ﺍﱃ ‪ ٣٢‬ﺑﺖ ﻭﺑﺎﻟﺘﺎﱄ ﳝﻜﻦ ﺗﻨﺼﻴﺐ ﺫﺍﻛﺮﺓ‬
‫ﲝﺠﻢ ‪ ٤‬ﺟﻴﺠﺎ ‪ ،‬ﻭﰲ ﺍﳌﻌﺎﳉﺎﺕ ﺍﳊﺪﻳﺜﺔ ﰎ ﺯﻳﺎﺩﺓ ﻫﺬﺍ ﺍﳊﺠﻢ ‪ ،‬ﻭﻟﻜﻨﻨﺎ ﺳﻨﻘﺘﺼﺮ ﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﻋﻠﻰ ﺍﳌﻌﺎﳉﺎﺕ‬
‫ﺍﻟﱵ ﺗﺪﻋﻢ ﻣﺴﺎﺭ ﻋﻨﺎﻭﻳﻦ ﺑﻄﻮﻝ ‪ ٣٢‬ﺑﺖ ﺑﺴﺒﺐ ﺍﻧﺘﺸﺎﺭﻫﺎ ﻭﺳﻴﻄﺮ‪‬ﺎ ﳌﺪﺓ ﻣﻦ ﺍﻟﺰﻣﻦ ﻋﻠﻰ ﺃﺟﻬﺰﺓ ﺍﳊﻮﺍﺳﻴﺐ‬
‫ﺍﻟﺸﺨﺼﻴﺔ‪.‬‬

‫‪Control Bus‬‬ ‫ﻣﺴﺎﺭ ﺍﻟﺘﺤﻜﻢ‬

‫ﻳﺴﺘﺨﺪﻡ ﻣﺴﺎﺭ ﺍﻟﺘﺤﻜﻢ ﰲ ﺍﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ﻣﺜﻞ ﺃﻣﺮ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻮﺟﻮﺩ ﻋﻠﻰ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺃﻭ ﺃﻣﺮ‬
‫ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻰ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻄﻠﻮﺏ ‪ .‬ﻭﻳﺘﺄﻟﻒ ﻫﺬﺍ ﺍﳌﺴﺎﺭ ﻣﻦ ﻋﺪﺩ ﻣﻦ ﺍﳋﻄﻮﻁ ﻭﻛﻞ ﺧﻂ )ﺑﺖ( ﻳﺆﺩﻱ ﻭﻇﻴﻔﺔ‬
‫ﳏﺪﺩﺓ‪ .‬ﺃﺣﺪ ﻫﺬﻩ ﺍﳋﻄﻮﻁ ﻫﻮ ﺧﻂ ﺍﻟﻜﺘﺎﺑﺔ ‪ WRITE‬ﻭﺍﻟﺬﻱ ﻳﻌﲏ ﺃﻥ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻮﺟﻮﺩ ﻋﻠﻰ ﺧﻂ ﺍﻟﻌﻨﺎﻭﻳﻦ ﳚﺐ‬
‫ﺃﻥ ﺗ‪‬ﻌﻴﱠﻦ ﻟﻪ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ .‬ﺍﳋﻂ ﺍﻵﺧﺮ ﻫﻮ ﺧﻂ ﺍﻟﻘﺮﺍءﺓ ‪ READ‬ﻭﺍﻟﺬﻱ ﻳﺪﻝ ﻋﻠﻰ ﺃﻥ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻮﺟﻮﺩ ﰲ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﳚﺐ ﺃﻥ ﺗ‪‬ﻘﺮﺃ ﻗﻴﻤﺘﻪ ﺍﱃ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ .‬ﺁﺧﺮ ﺧﻂ ﻳﻬﻤﻨﺎ ﻫﻮ ﺧﻂ ﺍﻟﻮﻟﻮﺝ‬
‫‪ ACCESS‬ﻭﺍﻟﺬﻱ ﳛﺪﺩ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻮﺟﻪٌ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺃﻡ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ‬
‫ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﻫﺬﺍ ﺍﳋﻂ ﻫﻲ ﺍﻟﻘﻴﻤﺔ ‪ ١‬ﻓﺎﻥ ﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻮﺟﻪُ ﺍﱃ ﻣﺘﺤﻜﻢ ﺃﺟﻬﺰﺓ ﺍﻹﺩﺧﺎﻝ‬
‫ﻭﺍﻹﺧﺮﺍﺝ ﻭﺑﺎﻟﺘﺎﱄ ﺳﻴﺘﻢ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﺃﻭ ﺍﻟﻜﺘﺎﺑﺔ ﺍﻟﻴﻪ ﻭﺫﻟﻚ ﲝﺴﺐ ﻗﻴﻤﺔ ﺍﳋﻄﲔ ‪READ and‬‬
‫‪.WRITE‬‬
‫‪٢‬ﻧﺎﲡﺔ ﻣﻦ ﺣﺴﺎﺏ ‪ ٢‬ﻣﺮﻓﻮﻉ ﻟﻠﻘﻮﺓ ‪.٢٠‬‬

‫‪١٧‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫‪ .٢.١.٢‬ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﻗﺒﻞ ﺫﻛﺮ ﻭﻇﻴﻔﺔ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﳚﺐ ﺇﻋﻄﺎء ﻧﺒﺬﺓ ﻋﻦ ﻣﺎﻫﻴﺔ ﺍﳌﺘﺤﻜﻤﺎﺕ )‪ (Controllers‬ﰲ ﺟﻬﺎﺯ ﺍﳊﺎﺳﺐ‪.‬‬
‫ﻭﻳُﻌﺮﱠﻑ ﺍﳌﺘﺤﻜﻢ ﺑﺄﻧﻪ ﺷﺮﳛﺔ ﺗﺘﺤﻜﻢ ﺑﻌﺘﺎﺩ ﻣﺎ ﲢﻮﻱ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺴﺠﻼﺕ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻭﻇﻴﻔﺘﻬﺎ ﻫﻲ ﺍﺳﺘﻘﺒﺎﻝ‬
‫ﺍﻷﻭﺍﻣﺮ ﻭﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ ﺍﻟﻌﺘﺎﺩ‪ .‬ﻭﳝﻜﻦ ﺗﻌﺮﻳﻔﻬﺎ ﻛﺬﻟﻚ ﺑﺄ‪‬ﺎ ﺷﺮﳛﺔ ﻟﻠﺮﺑﻂ ﻣﺎ ﺑﲔ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱪﳎﻴﺔ ﺍﱃ ﺃﻭﺍﻣﺮ ﺗﻨﻔﺬ‬
‫ﻋﻠﻰ ﻋﺘﺎﺩ ﻣﺎ‪ .‬ﻭﺃﻱ ﻣﺘﺤﻜﻢ ﳛﻮﻱ ﻏﺎﻟﺒﺎ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺴﺠﻼﺕ ﺳﻮﺍءﺍ ﻛﺎﻧﺖ ﻹﺭﺳﺎﻝ ﻭﺍﺳﺘﻘﺒﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺃﻭ‬
‫ﻟﻸﻭﺍﻣﺮ ‪ ،‬ﻭﺃﻱ ﻣﺴﺠﻞ ﳚﺐ ﺃﻥ ﻳﺄﺧﺬ ﺭﻗﻢ ﻓﺮﻳﺪ ﳝﻴﺰﻩ ﻋﻦ ﺑﻘﻴﺔ ﺍﳌﺴﺠﻼﺕ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﺃﻭ ﰲ‬
‫ﺃﻱ ﻣﺘﺤﻜﻢ ﺁﺧﺮ ﻭﺫﻟﻚ ﺣﱴ ﳝﻜﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﺑﺮﳎﻴﴼ ‪ ،‬ﻫﺬﺍ ﺍﻟﺮﻗﻢ ﻳﻌﺮﻑ ﺑﺎﺳﻢ ﺍﳌﻨﻔﺬ )‪ (Port‬ﻭﺳﻴﺘﻢ ﺍﳊﺪﻳﺚ‬
‫ﻋﻨﻪ ﻻﺣﻘﴼ‪ .‬ﻭﻋﻤﻞ ﺍﳌﺘﺤﻜﻢ ﻳﺒﺪﺃ ﻋﻨﺪﻣﺎ ﻳ‪‬ﺮﺳﻞ ﺃﻣﺮ ﺍﻟﻴﻪ ﺣﻴﺚ ﻳﺒﺪﺃ ﺍﳌﺘﺤﻜﻢ ﰲ ﺗﻨﻔﻴﺬ ﻫﺬﺍ ﺍﻷﻣﺮ ﻭﻣﻦ ﰒ ﻳﻀﻊ‬
‫ﺍﻟﻨﺘﻴﺠﺔ ﰲ ﺃﺣﺪ ﻣﺴﺠﻼﺗﻪ ﻭﻳﺮﺳﻞ ﺇﺷﺎﺭﺓ )‪ (Interrupt‬ﺍﱃ ﺍﳌﻌﺎﰿ ﻟﻜﻲ ﻳﻘﻮﻡ ﺑﻘﺮﺍﺋﺔ ﺍﻟﻘﻴﻤﺔ‪.‬‬
‫ﻭﻋﻮﺩﺓ ﺑﺎﳊﺪﻳﺚ ﻋﻦ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺍﻟﺬﻱ ﻳﺘﻮﺍﺟﺪ ﻏﺎﻟﺒﺎ ﻋﻠﻰ ﻣﺘﺤﻜﻢ ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ )‪(NorthBridge‬‬
‫ﺇﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪. ٣.٢‬ﺣﻴﺚ ﺗﻜﻤﻦ ﻭﻇﻴﻔﺘﻪ ﺍﻷﺳﺎﺳﻴﺔ ﰲ ﺍﺳﺘﻘﺒﺎﻝ ﺍﻷﻭﺍﻣﺮ ﺍﳌﺮﺳﻠﺔ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺗﻨﻔﻴﺬﻫﺎ ‪ ،‬ﻭﻳﻘﻮﻡ‬
‫ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﺑﺘﻮﺟﻴﻪ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﳌﺮﺳﻠﺔ ﺍﱃ ﺃﻱ ﻣﻦ ﺷﺮﺍﺋﺢ ﺍﻟﺬﺍﻛﺮﺓ ﻛﺬﻟﻚ ﻳﻘﻮﻡ ﺑﺈﻋﺎﺩﺓ ﺗﻨﻌﻴﺶ )‪ (Refresh‬ﻫﺬﻩ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻃﻴﻠﺔ ﻋﻤﻞ ﺍﳊﺎﺳﺐ ﺣﱴ ﻻ ﺗﻔﻘﺪ ﺍﻟﺬﺍﻛﺮﺓ ﳏﺘﻮﻳﺎ‪‬ﺎ‪.‬‬

‫ﺷﻜﻞ ‪ :.٣.٢‬ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ‬

‫ﻳﻌﺘﱪ ﻫﺬﺍ ﺍﳉﺴﺮ ﺣﻠﻘﺔ ﺍﻟﻮﺻﻞ ﻣﺎ ﺑﲔ ﺍﳌﻌﺎﰿ ﻭﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺍﻟﺒﺎﻳﻮﺱ ﻭﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ﻭﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ‬
‫ﻭﺍﻹﺧﺮﺍﺝ ﺣﻴﺚ ﻳﺴﺘﻘﺒﻞ ﺍﻷﻭﺍﻣﺮ ﻭﻳﻘﻮﻡ ﺑﺘﻮﺟﻴﻬﻬﺎ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﺍﳌﻄﻠﻮﺏ‪.‬‬

‫‪ .٣.١.٢‬ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ‬

‫ﻳﺴﺘﺨﺪﻡ ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ )ﻭﻳﺴﻤﻰ ﺃﻳﻀﺎ ﺍﳉﺴﺮ ﺍﳉﻨﻮﰊ ‪ (SouthBridge‬ﰲ ﺭﺑﻂ ﻣﺘﺤﻜﻤﺎﺕ ﺃﺟﻬﺰﺓ‬
‫ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﻣﻊ ﺍﳌﻌﺎﰿ ﻭﻫﺬﺍ ﻳﺘﻀﺢ ﻣﻦ ﺍﻟﺸﻜﻞ ‪ .٢.٢‬ﺣﻴﺚ ﻳﻈﻬﺮ ﺃﻥ ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ ﻳﺮﺗﺒﻂ ﻣﺒﺎﺷﺮﺓ ﻣﻊ‬
‫ﺍﳌﻌﺎﰿ ﺑﻴﻨﻤﺎ ﺍﳉﺴﺮ ﺍﳉﻨﻮﰊ ﻳﺮﺗﺒﻂ ﻣﻊ ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ ﻭﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻳﺮﺑﻂ ﻣﺘﺤﻜﻤﺎﺕ ﻋﺘﺎﺩ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ‬
‫ﰲ ﺍﳊﺎﺳﺐ‪ .‬ﻭﻛﻞ ﺟﻬﺎﺯ ﻳﺮﺗﺒﻂ ﺑﺎﳊﺎﺳﺐ )ﻣﺜﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﺃﻭ ﺍﻟﻔﺄﺭﺓ ﺃﻭ ﺍﻟﻄﺎﺑﻌﺔ ‪...‬ﺍﱁ( ﻟﺪﻳﻪ ﻣﺘﺤﻜﻢ ﺑﺪﺍﺧﻠﻪ‬
‫ﻭﻣﺘﺤﻜﻢ ﺁﺧﺮ ﺑﺪﺍﺧﻞ ﺍﳊﺎﺳﺐ ‪ ،‬ﺣﻴﺚ ﻳﺮﺳﻞ ﺍﳌﺘﺤﻜﻢ ﺍﳌﻮﺟﻮﺩ ﺑﺪﺍﺧﻞ ﺍﳊﺎﺳﺐ ﺍﻷﻭﺍﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﺍﳌﻮﺟﻮﺩ‬
‫ﺑﺪﺍﺧﻞ ﺍﻟﻌﺘﺎﺩ ‪ .‬ﻭﻟﱪﳎﺔ ﺃﻱ ﺟﻬﺎﺯ ﻓﺎﻧﻪ ﳚﺐ ﺑﺮﳎﺔ ﺍﳌﺘﺤﻜﻢ ﺍﳌﻮﺟﻮﺩ ﰲ ﺍﳊﺎﺳﺐ ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﻣﻌﺮﻓﺔ‬
‫ﺍﳌﺴﺠﻼﺕ )‪ (Registers‬ﺍﳌﻮﺟﻮﺩﺓ ﺑﻪ ﻭﻭﻇﻴﻔﺔ ﻛﻞ ﻣﺴﺠﻞ ﻓﻴﻪ ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺇﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ﺍﻟﺼﺤﻴﺤﺔ ﺍﻟﻴﻪ‪.‬‬

‫‪١٨‬‬
‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ‬

‫‪ (So‬ﲝﻴﺚ ﲤﻴﺰ ﻫﺬﻩ ﺍﻷﺭﻗﺎﻡ ﺍﳌﺴﺠﻼﺕ‬ ‫)‪ware Ports‬‬ ‫ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﺗﺄﺧﺬ ﺃﺭﻗﺎﻣﺎ ﻣﻌﻴﻨﺔ ﺗﺴﻤﻰ ﻣﻨﺎﻓﺬ ﺑﺮﳎﻴﺔ‬
‫ﻣﻦ ﺑﻌﻀﻬﺎ ﺍﻟﺒﻌﺾ ‪.٣‬‬

‫‪Ports‬‬ ‫ﺍﳌﻨﺎﻓﺬ‬
‫ﻳﺴﺘﺨﺪﻡ ﻣﻔﻬﻮﻡ ﺍﳌﻨﺎﻓﺬ ﰲ ﻋﻠﻮﻡ ﺍﳊﺎﺳﺐ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﻋﺪﺓ ﺃﺷﻴﺎء ﻓﻤﺜﻼ ﰲ ﳎﺎﻝ ﺑﺮﳎﺔ ﺍﻟﺸﺒﻜﺎﺕ ﺗﻜﻮﻥ ﺑﺮﺍﻣﺞ‬
‫ﺍﳋﺎﺩﻡ ﳍﺎ ﺭﻗﻢ ﻣﻨﻔﺬ ﻣﻌﲔ ﺣﱴ ﺗﺴﻤﺢ ﻟﱪﺍﻣﺞ ﺍﻟﻌﻤﻴﻞ ﺑﺎﻻﺗﺼﺎﻝ ﻣﻌﻬﺎ‪ ،‬ﻛﺬﻟﻚ ﺭﲟﺎ ﻳﻘﺼﺪ ﺑﺎﳌﻔﻬﻮﻡ ﺍﳌﻨﺎﻓﺬ ﺍﳌﻮﺟﻮﺩﺓ‬
‫ﰲ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ ﻟﻮﺻﻞ ﻋﺘﺎﺩ ﺍﳊﺎﺳﺐ ‪‬ﺎ ‪ ،‬ﺃﻳﻀﺎ ﻗﺪ ﻳﺪﻝ ﺍﳌﻔﻬﻮﻡ ﻋﻠﻰ ﺍﳌﺴﺠﻼﺕ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﺍﳌﺘﺤﻜﻤﺎﺕ ﻋﻠﻰ‬
‫ﺍﳉﻬﺎﺯ ﻭﻫﺬﺍ ﻣﺎ ﺳﻨﻘﺼﺪﻩ ﰲ ﺣﺪﻳﺜﻨﺎ ﻋﻦ ﺍﳌﻨﺎﻓﺬ ﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ‪ .‬ﻭ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﳌﻨﺎﻓﺬ ﺍﳌﺘﺤﻜﻤﺎﺕ ﻭﺍﻟﱵ‬
‫ﺗﻌﺮﻑ ﺏ ‪ I/O ports‬ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﻌﻠﻴﻤﺔ ﺍﳌﻌﺎﰿ ‪ in port address‬ﻭﺍﻟﺘﻌﻠﻴﻤﺔ ‪out port address‬‬
‫ﺣﻴﺚ ﺗﺴﺘﺨﺪﻡ ﺍﻷﻭﱃ ﻟﻘﺮﺍءﺓ ﻗﻴﻤﺔ ﻣﻦ ﻣﺴﺠﻞ ﰲ ﻣﺘﺤﻜﻢ ﻭﻭﺿﻌﻬﺎ ﰲ ﺃﺣﺪ ﻣﺴﺠﻼﺕ ﺍﳌﻌﺎﰿ ﺃﻣﺎ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫ﺍﻟﺜﺎﻧﻴﺔ ﺗﺴﺘﺨﺪﻡ ﻟﻜﺘﺎﺑﺔ ﻗﻴﻤﺔ ﰲ ﻣﺴﺠﻞ ﻟﻠﻤﻌﺎﰿ ﺍﱃ ﻣﺴﺠﻞ ﰲ ﺍﳌﺘﺤﻜﻢ ‪ .‬ﻭﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻡ ﺃﺣﺪ ﻫﺬﻳﻦ ﺍﻷﻣﺮﻳﻦ‬
‫ﻓﺎﻥ ﺫﻟﻚ ﻳﻌﲏ ﺃﻥ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻮﺟﻪ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﻭﻟﻴﺲ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺣﻴﺚ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ‬
‫ﺑﺘﻌﲔ ﻗﻴﻤﺔ ﺍﳋﻂ ‪ ACCESS‬ﺍﳌﻮﺟﻮﺩ ﰲ ﻣﺴﺎﺭ ﺍﻟﺘﺤﻜﻢ )‪ (Control Bus‬ﻭﺑﺎﻟﺘﺎﱄ ﻳﺴﺘﺠﻴﺐ ﻣﺘﺤﻜﻢ ﺍﻹﺩﺧﺎﻝ‬
‫ﻭﺍﻹﺧﺮﺍﺝ ﻭﻳﻘﺮﺃ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻭﻳﻘﻮﻡ ﺑﺘﻮﺟﻴﻬﻪ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﺍﳌﻄﻠﻮﺏ ‪ .‬ﻭﻫﻨﺎﻙ ﺑﻌﺾ ﺍﻷﺟﻬﺰﺓ ﺗﺴﺘﺨﺪﻡ ﻋﻨﻮﺍﻳﻦ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻟﻠﻮﺻﻮﻝ ﻟﻠﻤﺘﺤﻜﻢ ﺍﳋﺎﺹ ‪‬ﺎ ﻭﻫﻮ ﻣﺎ ﻳﻌﺮﻑ ﺏ ‪ Memory Mapped I/O‬ﺣﻴﺚ ﻋﻨﺪ ﻛﺘﺎﺑﺔ ﺃﻱ ﺑﻴﺎﻧﺎﺕ‬
‫ﻋﻠﻰ ﻫﺬﻩ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻓﺎﻥ ﺫﻟﻚ ﻳﻌﲏ ﻛﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻋﻠﻰ ﻣﺘﺤﻜﻤﺎﺕ ﻟﻸﺟﻬﺰﺓ ﻭﻟﻴﺲ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ‪.‬‬
‫ﻓﻤﺜﻼً ﻋﻨﺪ ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻰ ﻋﻨﻮﺍﻥ ﺍﻟﺬﺍﻛﺮﺓ ‪ 0xa000:0x0‬ﻓﺎﻥ ﻫﺬﺍ ﻳﺆﺩﻱ ﺍﱃ ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻰ ﺷﺎﺷﺔ ﺍﳊﺎﺳﺐ ﻧﻈﺮﴽ‬
‫ﻻﻥ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻫﻮ ﻣﻮﺟﻪ )‪ (Memory Mapped‬ﻣﻊ ﻣﺘﺤﻜﻢ ﺷﺎﺷﺔ ﺍﳊﺎﺳﺐ ﻭﺍﳉﺪﻭﻝ ‪ ١.٢‬ﻳﻮﺿﺢ ﺧﺮﻳﻄﺔ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﰲ ﺣﻮﺍﺳﻴﺐ ‪ ،x86‬ﻭﻻ ﲢﺘﺎﺝ ﺍﻟﻜﺘﺎﺑﺔ ﳌﺜﻞ ﻫﺬﻩ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻷﻭﺍﻣﺮ ‪ in/out‬ﺑﻌﻜﺲ ﺍﻟﻜﺘﺎﺑﺔ‬
‫ﰲ ﻋﻨﻮﺍﻳﻦ ﺍﳌﻨﺎﻓﺬ ‪. port I/O‬‬
‫ﻋﻨﺎﻭﻳﻦ ﻣﻨﺎﻓﺬ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ )‪ (Port I/O‬ﻫﻲ ﻋﻨﺎﻭﻳﻦ ﺗﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﺴﺠﻼﺕ ﺍﳌﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﳌﺘﺤﻜﻤﺎﺕ‬
‫ﻭﻳﻘﻮﻡ ﺍﻟﺒﺎﻳﻮﺱ ﲟﻬﻤﺔ ﺗﺮﻗﻴﻢ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ‪ ،‬ﻭﺍﳉﺪﻭﻝ ‪ ٢.٢‬ﻳﻌﺮﺽ ﻗﺎﺋﻤﺔ ﺑﻌﻨﺎﻭﻳﻦ ﺍﳌﻨﺎﻓﺬ ﻭﻭﻇﻴﻔﺔ ﻛﻞ ﻣﻨﻬﻢ‪.‬‬

‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ‬

‫ﻳﻌﺘﱪ ﺍﳌﻌﺎﰿ ﻫﻮ ﺍﳌﺤﺮﻙ ﺍﻟﺮﺋﻴﺴﻲ ﳉﻬﺎﺯ ﺍﳊﺎﺳﺐ ﺣﻴﺚ ﻳﺴﺘﻘﺒﻞ ﺍﻷﻭﺍﻣﺮ ﻭﻳﻘﻮﻡ ﺑﺘﻔﻴﺬﻫﺎ ‪.‬‬

‫‪٣‬ﻫﻨﺎﻙ ﺑﻌﺾ ﺍﳌﺴﺠﻼﺕ ﻟﺒﻌﺾ ﺍﳌﺘﺤﻜﻤﺎﺕ ﺗﺄﺧﺬ ﻧﻔﺲ ﺍﻟﺮﻗﻢ ‪ ،‬ﻟﻜﻦ ﻃﺒﻴﻌﺔ ﺍﻷﻣﺮ ﺍﳌُﺮﺳﻞ )ﻗﺮﺍءﺓ ﺃﻭ ﻛﺘﺎﺑﺔ( ﻫﻮ ﺍﻟﺬﻱ ﳛﺪﺩ ﺍﳌﺴﺠﻞ‬
‫ﺍﻟﺬﻱ ﳚﺐ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‪.‬‬

‫‪١٩‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫ﺟﺪﻭﻝ ‪ :.١.٢‬ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ ﳊﻮﺍﺳﻴﺐ‬

‫‪x86‬‬
‫ﻋﻨﻮﺍﻥ ﺍﻟﺒﺪﺍﻳﺔ ﻋﻨﻮﺍﻥ ﺍﻟﻨﻬﺎﻳﺔ ﺍﻟﻮﺻﻒ‬
‫ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪IVT‬‬ ‫‪0x003ff‬‬ ‫‪0x00000‬‬
‫ﻣﻨﻄﻘﺔ ﺑﻴﺎﻧﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ‬ ‫‪0x004ff‬‬ ‫‪0x00400‬‬
‫ﻏﲑ ﻣﺴﺘﺨﺪﻣﺔ‬ ‫‪0x07bff‬‬ ‫‪0x00500‬‬
‫ﺑﺮﻧﺎﻣﺞ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬ ‫‪0x07dff‬‬ ‫‪0x07c00‬‬
‫ﻏﲑ ﻣﺴﺘﺨﺪﻣﺔ‬ ‫‪0x9ffff‬‬ ‫‪0x07e00‬‬
‫ﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ‪Video RAM‬‬ ‫‪0xaffff‬‬ ‫‪0xa0000‬‬
‫ﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ﺃﺣﺎﺩﻳﺔ ﺍﻟﻠﻮﻥ ‪Monochrome VRAM‬‬ ‫‪0xb7777‬‬ ‫‪0xb0000‬‬
‫ﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ﺍﳌﻠﻮﻧﺔ ‪Color VRAM‬‬ ‫‪0xbffff‬‬ ‫‪0xb8000‬‬
‫ﺫﺍﻛﺮﺓ ‪Video ROM BIOS‬‬ ‫‪0xc7fff‬‬ ‫‪0xc0000‬‬
‫ﻣﻨﻄﻘﺔ ‪BIOS Shadow Area‬‬ ‫‪0xeffff‬‬ ‫‪0xc8000‬‬
‫ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ‬ ‫‪0xfffff‬‬ ‫‪0xf0000‬‬

‫‪ .١.٢.٢‬ﺩﻭﺭﺓ ﺗﻨﻔﻴﺬ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‬

‫ﻟﻜﻲ ﻳ‪‬ﻨﻔﺬ ﺍﳌﻌﺎﰿ ﺍﻟﱪﺍﻣﺞ ﺍﳌﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺎﻥ ﻫﺬﺍ ﻳﺘﻄﻠﺐ ﺑﻌﻀﺎ ﻣﻦ ﺍﳋﻄﻮﺍﺕ ﺍﻟﱵ ﳚﺐ ﺃﻥ ﻳﻘﻮﻡ ‪‬ﺎ ‪،‬‬
‫ﻭﰲ ﻛﻞ ﺩﻗﺔ ﻟﻠﺴﺎﻋﺔ )‪ (Clock ck‬ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﺎﻟﺒﺪء ﲞﻄﻮﺓ ﻣﻦ ﻫﺬﻩ ﺍﳋﻄﻮﺍﺕ ‪ ،‬ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺳﺮﺩﺍ ﳍﺎ‪.‬‬

‫ﺃﻭﻻﹰ ﻣﺮﺣﻠﺔ ﺟﻠﺐ ﺍﻟﺒﻴﺎﻧﺎﺕ )‪ (Fetch‬ﻭﻓﻴﻬﺎ ﻳﺘﻢ ﺟﻠﺐ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﺍﱃ ﺍﳌﺴﺠﻼﺕ ﺑﺪﺍﺧﻞ‬
‫ﺍﳌﻌﺎﰿ‪.‬‬
‫ﺛﺎﻧﻴﴼ ﻣﺮﺣﻠﺔ ﺗﻔﺴﲑ ﺍﻟﺒﻴﺎﻧﺎﺕ )‪.(Decode‬‬
‫ﺛﺎﻟﺜﴼ ﻣﺮﺣﻠﺔ ﺗﻨﻔﻴﺬ ﺍﻟﺒﻴﺎﻧﺎﺕ )‪.(Execute‬‬
‫ﺭﺍﺑﻌﴼ ﻣﺮﺣﻠﺔ ﺣﻔﻆ ﺍﻟﻨﺘﺎﺋﺞ )‪.(Write back‬‬

‫‪CPU Modes‬‬ ‫‪ .٢.٢.٢‬ﺃﳕﺎﻁ ﻋﻤﻞ ﺍﳌﻌﺎﰿ‬

‫ﻋﻨﺪﻣﺎ ﻃﺮﺣﺖ ﺷﺮﻛﺔ ﺃﻧﺘﻞ ﺃﻭﻝ ﺍﺻﺪﺍﺭﺓ ﻣﻦ ﻣﻌﺎﳉﺎﺕ ‪ ١٦‬ﺑﺖ ﱂ ﻳﻜﻦ ﻫﻨﺎﻙ ﻣﺎ ﻳﻌﺮﻑ ﺑﺄﳕﺎﻁ ﺍﳌﻌﺎﰿ ﺣﻴﺚ‬
‫ﻛﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻌﻤﻞ ﺑﻨﻤﻂ ﻭﺍﺣﺪ ﻭﻫﻮ ﻣﺎ ﻳﻌﺮﻑ ﺍﻻﻥ ﺑﺎﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ )‪ ، (Real Mode‬ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻳﻘﻮﻡ‬
‫ﺍﳌﻌﺎﰿ ﺑﺘﻨﻔﻴﺬ ﺃﻱ ﺃﻣﺮ ﻣﻮﺟﻪ ﺍﻟﻴﻪ ﻭﻻ ﻳﻮﺟﺪ ﻣﺎ ﻳ‪‬ﻌﺮﻑ ﺑﺼﻼﺣﻴﺎﺕ ﺍﻟﺘﻨﻔﻴﺬ ﺣﻴﺚ ﳝﻜﻦ ﻟﱪﻧﺎﻣﺞ ﻟﻠﻤﺴﺘﺨﺪﻡ ﺃﻱ‬
‫ﻳﻘﻮﻡ ﺑﺘﻨﻔﻴﺬ ﺃﻣﺮ ﻳﺘﺴﺒﺐ ﰲ ﺍﻳﻘﺎﻑ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ )ﻣﺜﻞ ﺍﻷﻣﺮ ‪ ، (hlt‬ﻛﺬﻟﻚ ﺗﻮﺟﺪ ﻋﺪﺩ‪ ‬ﻣﻦ ﺍﳌﺸﺎﻛﻞ‬
‫ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻓﻤﺜﻼ ﻻ ﺗﻮﺟﺪ ﲪﺎﻳﺔ ﻟﻠﺬﺍﻛﺮﺓ ﻣﻦ ﺑﺮﳎﻴﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ ﻭﻻ ﻳﻮﺟﺪ ﺃﻱ ﺩﻋﻢ ﳌﻔﻬﻮﻡ ﺗﻌﺪﺩ ﺍﳌﻬﺎﻡ‬
‫)‪ .(Mul tasking‬ﻟﺬﻟﻚ ﺳﺎﺭﻋﺖ ﺃﻧﺘﻞ ﺑﺎﺩﺧﺎﻝ ﻋﺪﺓ ﺃﳕﺎﻁ ﻋﻠﻰ ﺑﻨﻴﺔ ﺍﳌﻌﺎﰿ ﻟﺘﺤﻞ ﻫﺬﻩ ﺍﳌﺸﺎﻛﻞ ‪ ،‬ﲝﻴﺚ ﻳ‪‬ﻤﻜﻦ‬
‫ﻟﻠﻤﻌﺎﰿ ﺃﻱ ﻳﻌﻤﻞ ﰲ ﺃﻱ ﳕﻂ ﻭﺃﻥ ﻳﻘﻮﻡ ﺑﺎﻟﺘﺤﻮﻳﻞ ﻭﻗﺘﻤﺎ ﺷﺎء‪ .‬ﻭﻳُﻌﺮﱠﻑ ﳕﻂ ﺍﳌﻌﺎﰿ ﺑﺄﻧﻪ ﻃﺮﻳﻘﺔ ﻣﻌﻴﻨﺔ ﻳﺘﺒﻌﻬﺎ‬

‫‪٢٠‬‬
‫ ﺍﳌﻌﺎﰿ‬.٢.٢

x86 ‫ ﻣﻨﺎﻓﺬ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﳊﻮﺍﺳﻴﺐ‬:.٢.٢ ‫ﺟﺪﻭﻝ‬

‫ﺍﻹﺳﺘﺨﺪﺍﻡ‬ ‫ﺭﻗﻢ ﺍﳌﻨﻔﺬ‬
Slave DMA controller 0000-000f
System 0010-001F
First Interrupt controller (8259 chip) 0020-0021
Second interrupt controller 0030-0031
Programable Interval Timer 1 (8254 chip) 0040-0043
Programable Interval Timer 2 0048-004B
System devices 0050-006F
NMI Enable / Real Time Clock 0070-0071
DMA Page registers 0080-008B
System devices 0090-009F
Slave interrupt controller 00A0-00A1
Master DMA controller 00C0-00DE
System devices 00F0-00FF
System devices 0100-0167
IDE Interface - Quaternary channel 0168-016F
IDE interface - Secondary channel 0170-0177
IDE Interface - Ter ary channel 01E8-01EF
IDE interface - Primary channel 01F0-01F7
Games Port (joys ck port) 0200-0207
Usually used by sound cards, also used by NOVEL NETWARE KEY CARD 0220-022F
Plug and Play hardware 0270-0273
Parallel Port * 0278-027A
Some mes used for LCD Display I/O 0280-028F
Alternate VGA Video Display Adaptor assignment (secondary address) 02B0-02DF
GPIB 0, data aquisi on card 0 (02E1 to 02E3 only) 02E0-02E7
Serial Port - COM 4 02E8-02EF
Serial Port - COM 2 02F8-02FF
O en used as a default for Network Interface cards (was prototype card) 0300-031F
ST506 and ESDI Hard Disk Drive Interface (mostly used in PX/XT and early PC/AT) 0320-023F
MPU-401 (midi) interface, on Sound Cards 0330-0331
Some mes used for Network Interface cards 0360-036F
Another address used by the Secondary IDE Controller (see 0170-0177) 0376-0377
Parallel Port * 0378-037A
FM (sound) synthesis port on sound cards 0388-038B
MDA, EGA and VGA Video Display Adaptor (only 03B0 to 03BB used) 03B0-03BB
Parallel Port (originally only fi ed to IBM mono display adaptors) * 03BC-03BF
EGA / VGA Video Display Adaptor, (Primary address) 03C0-03DF
PCIC PCMCIA Port Controller 03E0-03E7
Serial Port - COM 3 03E8-03EF
Floppy Disk Drive Interface 03F0-03F6
٢١
Another address used by the Primary IDE Controller (see 01F0-01F7)
Serial Port - COM 1
03F7-03f7
03F8-03FF
Windows sound system (used by many sound cards) 0533-0537
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫ﺍﳌﻌﺎﰿ ﺃﺛﻨﺎء ﻋﻤﻠﻪ ﻟﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﻓﻤﺜﻼ ﳛﺪﺩ ﺍﻟﻨﻤﻂ ﺍﳌﺴﺘﺨﺪﻡ ﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﻫﻨﺎﻙ ﲪﺎﻳﺔ ﻟﻌﻨﻮﺍﻳﻦ ﺍﻟﺬﺍﻛﺮﺓ ﲝﻴﺚ ﻻ‬
‫ﳝﻜﻦ ﻟﱪﻧﺎﻣﺞ ﻻ ﳝﺘﻠﻚ ﺻﻼﺣﻴﺎﺕ ﻣﻌﻴﻨﺔ ﺍﻟﻮﺻﻮﻝ ﻷﻱ ﻣﻨﻄﻘﺔ ﰲ ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬

‫‪Real Mode‬‬ ‫‪ .٣.٢.٢‬ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‬

‫ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻫﻮ ﺍﻟﺬﻱ ﻳﺒﺪﺃ ﺍﳉﻬﺎﺯ ﺍﳊﺎﺳﺐ ﺑﺎﻟﻌﻤﻞ ﻋﻨﺪﻣﺎ ﻳﻘﻠﻊ ﻭﻫﺬﺍ ﺑﺴﺒﺐ ﺃﻥ ﺣﻮﺍﺳﻴﺐ ‪ x86‬ﰎ ﺗﺼﻤﻴﻤﻬﺎ‬
‫ﲝﻴﺚ ﺗﺪﻋﻢ ﺍﻷﺟﻬﺰﺓ ﺍﻟﻘﺪﳝﺔ ﻭﺣﱴ ﲢﺎﻓﻆ ﺍﻧﺘﻞ ﻋﻠﻰ ﺫﻟﻚ ﻓﺎﻥ ﻫﺬﺍ ﻣﺎ ﺟﻌﻠﻬﺎ ﺗﺪﻉ ﺍﳌﻌﺎﰿ ﻳﺒﺪﺃ ﺑﺎﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‬
‫ﻋﻨﺪ ﺍﻹﻗﻼﻉ ﺗﻮﺍﻓﻘﴼ ﻣﻊ ﺍﳊﻮﺍﺳﻴﺐ ﺍﻟﻘﺪﳝﺔ ‪ ،‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻋﻨﺪﻣﺎ ﻳﺴﺘﻠﻢ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺯﻣﺎﻡ ﺍﻟﺘﺤﻜﻢ ﺑﺎﳊﺎﺳﺐ‬
‫ﻓﺎﻧﻪ ﳐﲑٌ ﻣﺎ ﺑﲔ ﺍﻹﺳﺘﻤﺮﺍﺭ ﺑﺎﻟﻌﻤﻞ ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻭﺑﺎﻟﺘﺎﱄ ﻳﺴﻤﻰ ﻫﺬﺍ ﺍﻟﻨﻈﺎﻡ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ‪ ١٦‬ﺑﺖ ﻭﺑﲔ ﲢﻮﻳﻞ‬
‫ﳕﻂ ﺍﳌﻌﺎﰿ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﻻﺧﺮ ﻭﻫﻮ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (Protected Mode‬ﻭﺑﺎﻟﺘﺎﱄ ﻳﺴﻤﻰ ﺍﻟﻨﻈﺎﻡ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ‪٣٢‬‬
‫ﺑﺖ‪ .‬ﻭ ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻳﺴﺘﺨﺪﻡ ﺍﳌﻌﺎﰿ ﻣﺴﺠﻼﺕ ﻣﻦ ﻃﻮﻝ ‪ ١٦‬ﺑﺖ )ﻣﺜﻼﹰ ﺍﳌﺴﺠﻼﺕ ‪(ax,bx,cx,dx,...etc‬‬
‫ﻭﻳﺴﺘﺨﺪﻡ ﻋﻨﻮﻧﺔ ﺍﳌﻘﻄﻊ‪:‬ﺍﻹﺯﺍﺣﺔ )‪ (Segment:Offset‬ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ‪ -‬ﺳﻴﺘﻢ ﺷﺮﺣﻬﺎ ﰲ ﺍﻟﻔﻘﺮﺓ‬
‫ﺍﻟﺘﺎﻟﻴﺔ‪ -‬ﻭﺃﻳﻀﺎ ﻳﺪﻋﻢ ﺫﺍﻛﺮﺓ ﲝﺠﻢ ‪ 1‬ﻣﻴﺠﺎﺑﺎﻳﺖ ﻭﻻ ﻳﻘﺪﻡ ﺃﻱ ﺩﻋﻢ ﳊﻤﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ )‪Virtual‬‬
‫‪ (Memory‬ﻭﻻ ﻳﻮﻓﺮ ﲪﺎﻳﺔ ﻟﻠﺬﺍﻛﺮﺓ ﻣﻦ ﺑﺮﳎﻴﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ‪.‬‬

‫ﻋﻨﻮﻧﺔ ﺍﳌﻘﻄﻊ‪:‬ﺍﻹﺯﺍﺣﺔ )‪(Segment:Offset Addressing‬‬

‫ﺑﻌﺪ ﻃﺮﺡ ﺃﻧﺘﻞ ﳌﻌﺎﰿ ‪ 8086‬ﻭﻫﻮ ﺃﻭﻝ ﻣﻌﺎﰿ ‪ ١٦‬ﺑﺖ ‪ ،‬ﻇﻬﺮﺕ ﻣﺸﻜﻠﺔ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺣﻴﺚ ﺃﻥ ﻃﻮﻝ ﺍﳌﺴﺠﻼﺕ‬
‫ﺍﳌﺴﺘﺨﺪﻣﺔ ﰲ ﻫﺬﺍ ﺍﳌﻌﺎﰿ )ﻣﺴﺠﻼﺕ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﻟﻌﻨﺎﻭﻳﻦ( ﻫﻮ ‪ ١٦‬ﺑﺖ ﻭﻫﺬﺍ ﻣﺎ ﲰﺢ ﻟﻠﻤﺴﺠﻞ ﺑﺄﻥ ﻳﺘﻌﺎﻣﻞ‬
‫ﻣﻊ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ ﻓﻘﻂ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﻥ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ )‪ (Address Bus‬ﰲ ﻫﺬﻩ ﺍﻷﺟﻬﺰﺓ‬
‫ﻛﺎﻥ ﲝﺠﻢ ‪ ٢٠‬ﺑﺖ ﻭﻫﻮ ﻣﺎ ﻳﺴﻤﺢ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺫﺍﻛﺮﺓ ﲝﺠﻢ ‪ ١‬ﻣﻴﺠﺎ‪ .‬ﺍﱃ ﻫﻨﺎ ﻛﺎﻥ ﺍﳋﻴﺎﺭ ﺃﻣﺎﻡ ﺷﺮﻛﺔ ﺃﻧﺘﻞ‬
‫ﻫﻮ ﺑﺰﻳﺎﺩﺓ ﺣﺠﻢ ﺍﳌﺴﺠﻼﺕ ﺍﳌﻮﺟﻮﺩﺓ ﺑﺪﺍﺧﻞ ﺍﳌﻌﺎﰿ ﻭﻟﻜﻦ ﻫﺬﺍ ﺍﳊﻞ ﻛﺎﻥ ﻣﻜﻠﻔﴼ ﺟﺪﺍ ﺁﻧﺬﺍﻙ ﻧﻈﺮﴽ ﻹﻥ ﻫﺬﻩ‬
‫ﺍﳌﺴﺠﻼﺕ ﻫﻲ ﺫﻭﺍﻛﺮ ﻣﻦ ﺍﻟﻨﻮﻉ ‪ SRAM‬ﻭﻫﻮ ﻧﻮﻉ ﻣﻜﻠﻔﺎﹼ ﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺇﻣﻜﺎﻧﻴﺎﺗﻪ ﺍﻟﻌﺎﻟﻴﺔ‪ .‬ﻣﺎ ﻓﻌﻠﺘﻪ ﺍﻧﺘﻞ ﻫﻮ‬
‫ﺇﳚﺎﺩ ﻃﺮﻳﻘﺔ ﳐﺘﻠﻔﺔ ﻟﻌﻨﻮﻧﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺒﺪﻻً ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺴﺠﻞ ﻭﺍﺣﺪ ﻟﻠﻮﺻﻞ ﺍﱃ ﻋﻨﺎﻭﻳﻦ ﺍﻟﺬﺍﻛﺮﺓ ﰎ ﺍﺳﺘﺨﺪﺍﻡ‬
‫ﻣﺴﺠﻠﲔ ﻛﻞ ﻣﻨﻬﻤﺎ ﺑﻄﻮﻝ ‪ ١٦‬ﺑﺖ ‪ ،‬ﺍﻟﻔﻜﺮﺓ ﻛﺎﻧﺖ ﰲ ﺗﻘﺴﻴﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﱃ ﻣﻘﺎﻃﻊ )‪ (Segments‬ﻭﻳُﺴﺘﺨﺪﻡ‬
‫ﺃﺣﺪ ﺍﳌﺴﺠﻼﺕ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﺭﻗﻢ ﺃﻭ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ )‪ (Segment Number or Address‬ﻭﺑﺎﻟﺘﺎﱄ ﻫﻨﺎﻙ ‪٦٥٥٣٦‬‬
‫ﻣﻘﻄﻊ ﳐﺘﻠﻒ ‪ ٤‬ﻭﻳُﺴﺘﺨﺪﻡ ﺍﳌﺴﺠﻞ ﺍﻵﺧﺮ ﻟﻠﻮﺻﻞ ﺍﱃ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺑﺪﺍﺧﻞ ﺍﳌﻘﻄﻊ ﻭﻫﻲ ﻣﺎ ﺗﻌﺮﻑ ﺑﺎﻟﻘﻴﻢ )‪(Offsets‬‬
‫ﺑﺪﺍﺧﻞ ﺍﳌﻘﻄﻊ ﻭﺑﺎﻟﺘﺎﱄ ﻛﻞ ﻣﻘﻄﻊ ﳛﻮﻱ ‪ ٦٥٥٣٦‬ﺑﺎﻳﺖ )ﺃﻱ ﺃﻥ ﺣﺠﻢ ﺍﳌﻘﻄﻊ ﻫﻮ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ(‪ .‬ﺇﺫﴽ‬
‫ﻳ‪‬ﻌﺮﱠﻑ ﺍﳌﻘﻄﻊ ‪ Segments‬ﺑﺄ‪‬ﺎ ﻣﻨﻄﻘﺔ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﲝﺠﻢ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ ﻭﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﻣﻘﻄﻊ ﻭﺫﻟﻚ‬
‫ﺑﺘﺤﻤﻴﻞ ﺭﻗﻢ ﺍﳌﻘﻄﻊ ﺃﻭ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ ﺍﱃ ﺃﻱ ﻣﻦ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﺍﳌﻮﺟﻮﺩﺓ ﺑﺪﺍﺧﻞ ﺍﳌﻌﺎﰿ )ﻣﺜﻞ ﺍﳌﺴﺠﻼﺕ‬
‫‪ - (CS,SS,DS,ES‬ﺳﻴﺘﻢ ﺷﺮﺣﻬﺎ ﻻﺣﻘﺎ ‪ ، -‬ﻭﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﳏﺘﻮﻳﺎﺕ ﺍﳌﻘﻄﻊ ﺍﻹﺯﺍﺣﺔ ‪ Offset‬ﻭﺫﻟﻚ‬
‫‪٤‬ﻫﺬﺍ ﻧﺎﺗﺞ ﻣﻦ ﺣﺴﺎﺏ ‪.216‬‬

‫‪٢٢‬‬
‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ‬

‫‪0x0‬‬ ‫ﺑﺘﺤﻤﻴﻞ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻄﻠﻮﺏ ﺍﻟﻮﺻﻞ ﺍﻟﻴﻪ ﺍﱃ ﺃﻱ ﻣﻦ ﻣﺴﺠﻼﺕ ﺍﻟﻘﻴﻢ )ﺗﺒﺪﺃ ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﺃﻱ ﻣﻘﻄﻊ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ‬
‫ﺍﱃ ‪ .(0xffff‬ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﱵ ﺍﻗﺘﺮﺣﺘﻬﺎ ﺍﻧﺘﻞ ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﻋﻨﺎﻭﻳﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺧﻠﻘﺖ ﻟﻨﺎ ﻣﻔﻬﻮﻡ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ‬
‫)‪ (Logical Address‬ﺣﻴﺚ ﻟﻜﻲ ﻧﺼﻞ ﺍﱃ ﺃﻱ ﻣﻜﺎﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺎﻧﻪ ﳚﺐ ﲢﺪﻳﺪ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ ﻭﺍﻟﻌﻨﻮﺍﻥ ﺑﺪﺍﺧﻞ‬
‫ﻫﺬﺍ ﺍﳌﻘﻄﻊ ﻭﺫﻟﻚ ﻋﻠﻰ ﺍﻟﺸﻜﻞ ‪ Segment:Offset‬ﺣﻴﺚ ﺍﳉﺰء ﺍﻷﻭﻝ ﳛﺪﺩ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ ﻭﺍﳉﺰء ﺍﻟﺜﺎﱐ ﳛﺪﺩ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ﺑﺪﺍﺧﻞ ﺍﳌﻘﻄﻊ‪ .‬ﻣﻬﻤﺔ ﺍﳌﻌﺎﰿ ﺣﺎﻟﻴﺎ ﻫﻲ ﲢﻮﻳﻞ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ ﺍﱃ ﻋﻨﻮﺍﻥ ﻓﻴﺰﻳﺎﺋﻲ ﺃﻭ ﺣﻘﻴﻘﻲ ﻟﻜﻲ ﻳﻘﻮﻡ‬
‫ﺑﺎﺭﺳﺎﻟﻪ ﻋﱪ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻭ ﻃﺮﻳﻘﺔ ﺍﻟﺘﺤﻮﻳﻞ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﺃﻥ ﺍﻹﺯﺍﺣﺔ )‪ (Offset‬ﻳﺘﻢ‬
‫ﲨﻌﻬﺎ ﺍﱃ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ )‪ ٥ (Segment‬ﻭﻟﻜﻦ ﺑﻌﺪ ﺃﻥ ﻳﺘﻢ ﺿﺮ‪‬ﺎ ﰲ ﺍﻟﻌﺪﺩ ‪ ١٦‬ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃﻥ ﺃﻱ ﻣﻘﻄﻊ‬
‫ﻳﺒﺪﺃ ﺑﻌﺪ ‪ ١٦‬ﺑﺎﻳﺖ ﻣﻦ ﺍﳌﻘﻄﻊ ﺍﻟﺴﺎﺑﻖ ﻟﻪ ‪ .‬ﻭﺍﻟﺘﺤﻮﻳﻞ ﻳﺘﻢ ﻛﺎﻷﰐ ‪:‬‬
‫‪physical address = segment ∗ 0x10 + of f set‬‬

‫ﻓﻤﺜﻼ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ ‪ 0x07c0:0x0000‬ﻳﺘﻢ ﲢﻮﻳﻠﻪ ﻭﺫﻟﻚ ﺑﻀﺮﺏ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x07c0‬ﺑﺎﻟﻌﺪﺩ ‪) ١٦‬ﺃﻭ ﺍﻟﻌﺪﺩ ‪0x10‬‬
‫ﺑﺎﻟﻨﻈﺎﻡ ﺍﻟﺴﺎﺩﺱ ﻋﺸﺮ( ﻟﻴﺼﺒﺢ ﻫﻜﺬﺍ ‪ ،0x07c00‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺘﻢ ﲨﻌﻪ ﺍﱃ ﺍﻝ ‪ Offset‬ﻟﻴﺨﺮﺝ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ‬
‫‪.0x07c00‬‬

‫ﻣﺸﻜﻠﺔ ﺗﺪﺍﺧﻞ ﺍﳌﻘﺎﻃﻊ‬

‫ﺫﻛﺮﻧﺎ ﰲ ﺍﻟﻔﻘﺮﺓ ﺍﻟﺴﺎﺑﻘﺔ ﺃﻥ ﺃﻱ ﻣﻘﻄﻊ ﻳﺒﺪﺃ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪ ‪ ١٦‬ﺑﺎﻳﺖ ﻣﻦ ﺍﳌﻘﻄﻊ ﺍﻟﺴﺎﺑﻖ ﻟﻪ ‪ ،‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ﺍﳌﻘﺎﻃﻊ‬
‫ﻣﺘﺪﺍﺧﻠﺔ ﺣﻴﺚ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﻟﻌﻨﻮﺍﻥ ﻓﻴﺰﻳﺎﺋﻲ ﻣﻌﲔ ﺑﺄﻛﺜﺮ ﻣﻦ ﻃﺮﻳﻘﺔ ﳐﺘﻠﻔﺔ‪ .‬ﻣﺜﻼﹰ ﰲ ﻣﺜﺎﻟﻨﺎ ﺍﻟﺴﺎﺑﻖ ﺍﺳﺘﺨﺪﻣﻨﺎ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ ‪ 0x07c0:0x0000‬ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﺍﳌﻨﻄﻘﺔ ﺍﻟﺬﺍﻛﺮﻳﺔ ‪ ، 0x07c00‬ﻭﳝﻜﻦ ﺃﻥ ﻧﺴﺘﺒﺪﻝ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ‬
‫ﺍﻟﺴﺎﺑﻖ ﺑﺎﻟﻌﻨﻮﺍﻥ ‪ 0x0000:0x7c00‬ﻭﺑﻌﺪ ﺍﺟﺮﺍء ﺍﻟﺘﺤﻮﻳﻞ ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻧﻔﺲ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ‪ .0x07c00‬ﻭﰲ‬
‫ﺍﳊﻘﻴﻘﺔ ﻫﻨﺎﻙ ‪ ٤٠٩٦‬ﻃﺮﻳﻘﺔ ﳐﺘﻠﻔﺔ ﻟﻠﻮﺻﻞ ﻟﻌﻨﻮﺍﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ‪ ٦‬ﻭﺍﻟﺸﻜﻞ ‪ ٤.٢‬ﻳﻮﺿﺢ ﻟﻨﺎ ﺗﺪﺍﺧﻞ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻊ‪.‬‬
‫ﻫﺬﺍ ﺍﻟﺘﺪﺍﺧﻞ ‪ Overlapping‬ﲰﺢ ﻷﻱ ﺑﺮﻧﺎﻣﺞ ﻣﺎ ﺇﻣﻜﺎﻧﻴﺔ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺑﻴﺎﻧﺎﺕ ﺑﺮﻧﺎﻣﺞ ﺁﺧﺮ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻴﻬﺎ‬
‫ﻭﻫﺬﺍ ﻣﺎ ﺟﻌﻞ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﺿﻌﻴﻒ ﻣﻦ ﻧﺎﺣﻴﺔ ﲪﺎﻳﺔ ﺃﺟﺰﺍء ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬

‫‪Protected Mode‬‬ ‫‪ .٤.٢.٢‬ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬

‫ﺑﻌﺪ ﺃﻥ ﰎ ﺍﻟﺘﻌﺮﻑ ﻋﻠﻰ ﻫﺬﻩ ﺍﳌﺸﺎﻛﻞ ﺳﺎﺭﻋﺖ ﺃﻧﺘﻞ ﺑﺎﺻﺪﺍﺭ ﺍﳌﻌﺎﰿ ‪ 80286‬ﻭﺍﻟﺬﻱ ﻛﺎﻥ ﺃﻭﻝ ﻣﻌﺎﰿ ﻳﻌﻤﻞ ﰲ‬
‫ﳕﻄﲔ )ﺍﳊﻘﻴﻘﻲ ﻭﺍﳌﺤﻤﻲ( ‪ .‬ﻫﺬﺍ ﺍﳌﻌﺎﰿ )ﻭﺍﳌﻌﺎﳉﺎﺕ ﺍﻟﱵ ﺗﻠﻴﻬﺎ( ﺣﻞ ﺃﻫﻢ ﻣﺸﻜﻠﺔ ﻭﻫﻲ ﲪﺎﻳﺔ ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﻣﻦ ﺍﻟﻮﺻﻮﻝ ﺍﻟﻌﺸﻮﺍﺋﻲ ﻣﻦ ﻗﺒﻞ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﻭﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﻭﺻﻒ ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺻﻼﺣﻴﺎﺕ ﺍﻟﻮﺻﻮﻝ‬
‫ﺍﻟﻴﻬﺎ ﰲ ﺟﺪﺍﻭﻝ ﺗﺴﻤﻰ ﺟﺪﺍﻭﻝ ﺍﻟﻮﺻﻔﺎﺕ )‪ .(Descriptor Table‬ﺍﳌﻌﺎﰿ ‪ 80386‬ﻫﻮ ﺃﻭﻝ ﻣﻌﺎﰿ ‪ ٣٢‬ﺑﺖ‬
‫ﻭﻳﺴﺘﺨﺪﻡ ﻣﺴﺠﻼﺕ ﲝﺠﻢ ‪ ٣٢‬ﻳﺖ ﻭﺣﺠﻢ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺃﻳﻀﺎ ﺑﻨﻔﺲ ﺍﳊﺠﻢ ﳑﺎ ﲰﺢ ﺑﺈﻣﻜﺎﻧﻴﺔ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ‬
‫ﺫﺍﻛﺮﺓ ﲝﺠﻢ ‪ ٤‬ﺟﻴﺠﺎﺑﺎﻳﺖ ‪.‬ﻛﺬﻟﻚ ﰎ ﺍﺿﺎﻓﺔ ﺩﻋﻢ ﻟﻠﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ ﻭﻣﻔﻬﻮﻡ ﺍﻟﺼﻔﺤﺎﺕ )‪ (Paging‬ﻭﺩﻋﻢ ﺗﻌﺪﺩ‬
‫‪٥‬ﲝﻴﺚ ﻧﻌﺘﱪ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ ﻫﻮ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ )‪ (Base Address‬ﻟﻌﻨﺎﻭﻳﻦ ﺍﻟﻘﻴﻢ )‪.(Offset‬‬
‫‪٦‬ﺍﻧﻈﺮ ﺍﱃ ﻣﻘﺎﻟﺔ ﺍﻟﻜﺎﺗﺐ ‪ Daniel B. Sedory‬ﻋﻠﻰ ﺍﻟﺮﺍﺑﻂ ‪http://mirror.href.com/thestarman/asm/debug/‬‬
‫‪.Segments.html‬‬

‫‪٢٣‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫ﺷﻜﻞ ‪ :.٤.٢‬ﺗﺪﺍﺧﻞ ﺍﳌﻘﺎﻃﻊ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‬

‫ﺍﳌﻬﺎﻡ‪ .‬ﻭﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﺳﻴﺘﻢ ﺍﳊﺪﻳﺚ ﻋﻦ ﻣﻌﺎﳉﺎﺕ ‪ ٣٢‬ﺑﺖ ﺑﺎﻋﺘﺒﺎﺭﻫﺎ ﺃﺣﺪ ﺍﻷﻛﺜﺮ ﺍﻧﺘﺸﺎﺭﴽ ﺣﱴ ﻭﻗﺘﻨﺎ ﻫﺬﺍ‬
‫‪،‬ﻭ ﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﻇﻬﻮﺭ ﻣﻌﺎﳉﺎﺕ ‪ ٦٤‬ﺑﺖ ﺇﻻ ﺍﻥ ﺍﻟﺪﺭﺍﺳﺔ ﺣﻮﻝ ﻣﻌﺎﳉﺎﺕ ‪ ٣٢‬ﺑﺖ ﺗﻌﺘﱪ ﻫﻲ ﺍﻷﺳﺎﺱ ﻧﻈﺮﴽ‬
‫ﻻﻥ ﺍﳌﻌﺎﳉﺎﺕ ﺍﳊﺪﻳﺜﺔ ﻣﺎ ﻫﻲ ﺍﻻ ﺗﻄﻮﻳﺮ ﻭﺍﺿﺎﻓﺎﺕ ﻟﻠﻤﻔﺎﻫﻴﻢ ﺍﳌﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﳌﻌﺎﳉﺎﺕ ﺍﻟﺴﺎﺑﻘﺔ‪.‬‬

‫‪CPU Rings‬‬ ‫ﺣﻠﻘﺎﺕ ﺍﳌﻌﺎﰿ‬

‫ﻋﻨﺪﻣﺎ ﻳﻌﻤﻞ ﺍﳌﻌﺎﰿ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻓﺎﻥ ﻫﺬﺍ ﻳﻀﻤﻦ ﲪﺎﻳﺔ ﻟﻠﺬﺍﻛﺮﺓ ﻣﻦ ﺑﺮﳎﻴﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ ‪ ،‬ﻭﻫﺬﺍ ﺑﺴﺒﺐ‬
‫ﺗﻮﺻﻴﻒ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺻﻼﺣﻴﺎﺕ ﺍﻟﻮﺻﻮﻝ ﳍﺎ ﰲ ﺟﺪﻭﻝ ﻳﺴﺘﺨﺪﻣﻪ ﺍﳌﻌﺎﰿ ﻟﻌﻨﻮﻧﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻫﻮ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ‪.‬‬
‫ﻧﻈﺎﻡ ﺍﻟﺼﻼﺣﻴﺎﺕ ﺍﻟﺬﻱ ﰎ ﺍﺩﺧﺎﻟﻪ ﺍﱃ ﺍﳌﻌﺎﰿ ﻋﻨﺪ ﻋﻤﻠﻪ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻳﺴﻤﻰ ﲝﻠﻘﺎﺕ ﺍﳌﻌﺎﰿ )‪،(CPU Rings‬‬
‫ﻫﺬﻩ ﺍﳊﻠﻘﺎﺕ ﲢﺪﺩ ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ﺍﳌﻄﻠﻮﺏ ﻟﻜﻲ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﻌﺎﰿ ﰲ ﺗﻘﺮﻳﺮ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺗﻨﻔﻴﺬ ﺃﻣﺮ ﻣﺎ ﳛﺘﺎﺝ ﺍﱃ‬
‫ﺻﻼﺣﻴﺔ ﺃﻋﻠﻰ ﺃﻡ ﻻ‪ ،‬ﻭﻛﺬﻟﻚ ﻟﻜﻲ ﻳﻘﺮﺭ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﻋﻨﻮﺍﻥ ﻣﻌﲔ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻣﺴﻤﻮﺡ‪ ‬ﺑﺎﺳﺘﺨﺪﺍﻡ‬
‫ﺻﻼﺣﻴﺔ ﻣﻌﻴﻨﺔ ﺃﻡ ﻻ‪.‬ﻭﺗﻮﺟﺪ ﺃﺭﺑﻊ ﺣﻠﻘﺎﺕ ﻟﻠﻤﻌﺎﰿ ﺗﺒﺪﺃ ﻣﻦ ﺍﳊﻠﻘﺔ ﺻﻔﺮ )‪ (Ring0‬ﻭﺗﻨﺘﻬﻲ ﺑﺎﳊﻠﻘﺔ ‪.(Ring3) ٣‬‬
‫ﺍﳊﻠﻘﺔ ﺻﻔﺮ ﺗﺴﻤﻰ ﳕﻂ ﺍﻟﻨﻮﺍﺓ )‪ (Kernel Mode‬ﺑﺴﺒﺐ ﺃﻥ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﻳﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ﻟﺪﻳﻪ ﺍﻟﺼﻼﺣﻴﺎﺕ‬
‫ﺍﻟﻜﺎﻣﻠﺔ ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ ﺑﺎﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﻋﻨﻮﺍﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺗﻨﻔﻴﺬ ﺃﻱ ﺗﻌﻠﻴﻤﻴﺔ ﺣﱴ ﻟﻮ ﺗﺴﺒﺒﺖ ﰲ ﺍﻳﻘﺎﻑ ﺍﻟﻨﻈﺎﻡ‬
‫ﻋﻦ ﺍﻟﻌﻤﻞ )ﺍﳌﺴﺆﻭﻟﻴﺔ ﺗﻘﻊ ﻋﻠﻰ ﺍﻟﱪﻧﺎﻣﺞ( ﻟﺬﻟﻚ ﻏﺎﻟﺒﺎ ﺍﻟﱪﺍﻣﺞ ﺍﻟﱵ ﺗﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ﻫﻲ ﺍﻟﱪﺍﻣﺞ ﺍﻟﱵ ﺗﺘﺒﻊ‬
‫ﻟﻨﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﺃﻣﺎ ﺍﳊﻠﻘﺔ ‪ ٣‬ﺗﺴﻤﻰ ﺑﻨﻤﻂ ﺍﳌﺴﺘﺨﺪﻡ )‪ (User Mode‬ﺣﻴﺚ ﺃﻥ ﺍﻟﱪﺍﻣﺞ ﺍﻟﱵ ﺗﻌﻤﻞ ﻋﻠﻴﻬﺎ ﻻ‬
‫ﲤﻠﻚ ﺻﻼﺣﻴﺎﺕ ﻟﺘﻨﻔﻴﺬ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﻭﺍﻣﺮ )ﻣﺜﻞ ﺍﻻﻣﺮ ‪ cli‬ﻭﺍﻷﻣﺮ ‪ (hlt‬ﻭﻻ ﲤﻠﻚ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﻋﻨﻮﺍﻥ‬
‫ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﲞﻼﻑ ﻣﺴﺎﺣﺔ ﺍﻟﻌﻨﻮﻧﺔ ﺍﻟﺘﺨﻴﻠﻴﺔ )‪ (Virtual Address Space‬ﺍﳋﺎﺻﺔ ﺑﺎﻟﱪﻧﺎﻣﺞ ﻧﻔﺴﻪ ﻭﻫﺬﺍ ﻣﺎ ﺭﻓﻊ‬
‫ﺩﺭﺟﺔ ﲪﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ﺍﱃ ﺃﻗﺼﻰ ﺣﺪ ﳑﻜﻦ ‪ ،‬ﻭﺍﻟﺸﻜﻞ ‪ ٥.٢‬ﻳﻮﺿﺢ ﻫﺬﻩ ﺍﳊﻠﻘﺎﺕ ﻭﺻﻼﺣﻴﺎ‪‬ﺎ‪ .‬ﻭﻋﻨﺪﻣﺎ ﻳﺒﺪﺃ‬
‫ﺍﻟﻨﻈﺎﻡ ﺑﺎﻹﻗﻼﻉ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻜﻮﻥ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻭﻫﻮ ﳕﻂ ﻻ ﳛﻮﻱ ﻋﻠﻰ ﺣﻠﻘﺎﺕ ﺣﻴﺚ ﺃﻧﻪ ﳝﻜﻦ ﺗﻨﻔﻴﺬ ﻛﻞ‬
‫ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﻋﻨﻮﺍﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻭﻋﻨﺪ ﺍﻟﺘﺤﻮﻳﻞ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (PMode‬ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻜﻮﻥ‬

‫‪٢٤‬‬
‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ‬

‫ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ )‪ ، (Kernel Mode‬ﻭﻳﺘﻢ ﲢﻮﻳﻞ ﺍﳊﻠﻘﺔ ﺍﱃ ﺣﻠﻘﺔ ﻣﻌﻴﻨﺔ ﺗﻠﻘﺎﺋﻴﺎ ﻋﻨﺪ ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﻋﻨﻮﺍﻥ ﰲ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻣﻮﺻﻮﻑ ﰲ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺑﺄﻧﻪ ﻳﻌﻤﻞ ﺑﺘﻠﻚ ﺍﳊﻠﻘﺔ‪.‬‬

‫ﺷﻜﻞ ‪ :.٥.٢‬ﺣﻠﻘﺎﺕ ﺍﳌﻌﺎﰿ‬

‫‪x86‬‬ ‫‪ .٥.٢.٢‬ﻣﻌﻤﺎﺭﻳﺔ ﻣﻌﺎﳉﺎﺕ‬

‫ﺃﻱ ﻣﻌﺎﰿ ﻳﺘﻌﺮﻑ ﻋﻠﻰ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻷﻭﺍﻣﺮ ﺗﺴﻤﻰ ‪ Instruc on Set‬ﺑﻌﻀﴼ ﻣﻨﻬﺎ ﺗﺘﻄﻠﺐ ﺻﻼﺣﻴﺔ ﻣﻌﻴﻨﺔ‬
‫)ﺍﳊﻠﻘﺔ ﺻﻔﺮ( ﻟﻜﻲ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﺘﻨﻔﻴﺬﻫﺎ )ﺍﻧﻈﺮ ﺍﳉﺪﻭﻝ ‪ ٣.٢‬ﳌﻌﺮﻓﺔ ﻫﺬﻩ ﺍﻷﻭﺍﻣﺮ( ﻭﺇﻻ ﻓﺎﻥ ﻫﺬﺍ ﺳﻴﺘﺴﺒﺐ‬
‫ﰲ ﺣﺪﻭﺙ ﺧﻄﺄ ﻣﻦ ﺍﳌﻌﺎﰿ ﻳﺴﻤﻰ ﺍﳋﻄﺄ ﺍﻟﻌﺎﻡ )‪ (General Protec on Fault‬ﻭﺍﻟﺬﻱ ﺍﻥ ﱂ ﺗﺘﻮﻓﺮ ﺩﺍﻟﺔ ﺗﺘﻌﺎﻣﻞ‬
‫ﻣﻌﻪ )‪ (Excep on Handler‬ﻓﺎﻥ ﻫﺬﺍ ﻳﺆﺩﻱ ﺍﱃ ﺗﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ‪.‬‬
‫ﻭﲢﻮﻱ ﻣﻌﺎﳉﺎﺕ ‪ x86‬ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺴﺠﻼﺕ ﻣﻨﻬﺎ ﻣﺎ ﻳﺴﺘﺨﺪﻡ ﻟﻸﻏﺮﺍﺽ ﺍﻟﻌﺎﻣﺔ )‪ (General Registers‬ﻭﻣﻨﻬﺎ ﻣﺎ‬
‫ﻳﺴﺘﺨﺪﻡ ﳊﻔﻆ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻭﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻊ )‪ (Segments Registers‬ﻭﺗﻮﺟﺪ ﺃﻳﻀﺎ ﻣﺴﺠﻼﺕ ﻻ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ‬
‫ﺇﻻ ﰲ ﺑﺮﺍﻣﺞ ﺍﳊﻠﻘﺔ ﺻﻔﺮ )ﺃﻱ ﺍﻟﻨﻮﺍﺓ( ﺣﻴﺚ ﺃﻥ ﺍﻟﺘﻐﻴﲑ ﻓﻴﻬﺎ ﻳﺆﺛﺮ ﻋﻠﻰ ﻋﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﺃﺧﲑﺍ ﻫﻨﺎﻙ ﳎﻤﻮﻋﺔ ﻣﻦ‬
‫ﺍﳌﺴﺠﻼﺕ ﺍﻟﺪﺍﺧﻠﻴﺔ ﻟﻠﻤﻌﺎﰿ ﻭﺍﻟﱵ ﻻ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﳍﺎ ﺑﺮﳎﻴﴼ‪ .‬ﻭﺍﻟﻘﺎﺋﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ‪:‬‬
‫• ﻣﺴﺠﻼﺕ ﻋﺎﻣﺔ ‪RAX (EAX(AX/AH/AL)), RBX (EBX(BX/BH/BL)), RCX (ECX(CX/CH/CL)), RDX :‬‬
‫))‪.(EDX(DX/DH/DL‬‬
‫ﻣﺴﺠﻼﺕ ﻋﻨﺎﻭﻳﻦ‪:‬‬ ‫•‬
‫– ﻣﺴﺠﻼﺕ ﻣﻘﺎﻃﻊ‪. CS,SS,ES,DS,FS,GS:‬‬
‫– ﻣﺴﺠﻼﺕ ﺇﺯﺍﺣﺔ‪RSI (ESI (SI)), RDI (EDI (DI)), RBP (EBP (BP)). RSP (ESP (SP)), RIP (EIP :‬‬
‫))‪.(IP‬‬
‫ﻣﺴﺠﻞ ﺍﻷﻋﻼﻡ‪.RFLAGS (EFLAGS (FLAGS)) :‬‬ ‫•‬

‫ﻣﺴﺠﻼﺕ ﺍﻟﺘﻨﻘﻴﺢ‪.DR0, DR1, DR2, DR3, DR4, DR5, DR6, DR7 :‬‬ ‫•‬

‫‪٢٥‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫ﺟﺪﻭﻝ ‪ :.٣.٢‬ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﺗﺘﻄﻠﺐ ﺻﻼﺣﻴﺔ ﺍﳊﻠﻘﺔ ﺻﻔﺮ‬

‫ﺍﻷﻣﺮ ﺍﻟﻮﺻﻒ‬
‫‪ LGDT‬ﲢﻤﻴﻞ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ﺍﱃ ﺍﳌﺴﺠﻞ ‪GDTR‬‬
‫‪ LLDT‬ﲢﻤﻴﻞ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﳋﺎﺹ ﺍﱃ ﺍﳌﺴﺠﻞ ‪LDTR‬‬
‫‪ LTR‬ﲢﻤﻴﻞ ﻣﺴﺠﻞ ﺍﳌﻬﺎﻡ‬
‫‪ MOV cr x‬ﻧﻘﻞ ﺑﻴﺎﻧﺎﺕ ﺍﱃ ﻣﺴﺠﻞ ﲢﻜﻢ‬
‫‪ LMSW‬ﲢﻤﻴﻞ ‪new Machine Status WORD‬‬
‫‪ MOV dr x‬ﻧﻘﻞ ﺑﻴﺎﻧﺎﺕ ﺍﱃ ﻣﺴﺠﻞ ﺗﻨﻘﻴﺢ‬
‫‪ CLTS‬ﺗﺼﻔﲑ ‪ Task Switch Flag‬ﰲ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ ﺍﻷﻭﻝ‬
‫‪Invalidate Cache without writeback‬‬ ‫‪INVD‬‬
‫‪Invalidate TLB Entry‬‬ ‫‪INVLPG‬‬
‫‪Invalidate Cache with writeback‬‬ ‫‪WBINVD‬‬
‫ﺇﻳﻘﺎﻑ ﻋﻤﻞ ﺍﳌﻌﺎﰿ‬ ‫‪HLT‬‬
‫‪MSR‬‬ ‫ﻗﺮﺍءﺓ ﻣﺴﺠﻞ‬ ‫‪RDMSR‬‬
‫ﺍﻟﻜﺘﺎﺑﺔ ﺍﱃ ﻣﺴﺠﻞ ‪MSR‬‬ ‫‪WRMSR‬‬
‫ﻗﺮﺍءﺓ ‪Performance Monitoring Counter‬‬ ‫‪RDPMC‬‬
‫ﻗﺮﺍءﺓ ‪me Stamp Counter‬‬ ‫‪RDTSC‬‬

‫ﻣﺴﺠﻼﺕ ﺍﻟﺘﺤﻜﻢ‪.CR0, CR1, CR2, CR3, CR4, CR8 :‬‬ ‫•‬

‫ﻣﺴﺠﻼﺕ ﺍﻹﺧﺘﺒﺎﺭ‪.TR1, TR2, TR3, TR4, TR5, TR6, TR7 :‬‬ ‫•‬

‫• ﻣﺴﺠﻼﺕ ﺃﺧﺮﻯ‪mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, xmm0, xmm1, xmm2, :‬‬
‫‪.xmm3, xmm4, xmm5, xmm6, xmm7, GDTR, LDTR, IDTR, MSR, and TR‬‬

‫‪General Purpose Registers‬‬ ‫ﺍﳌﺴﺠﻼﺕ ﺍﻟﻌﺎﻣﺔ‬

‫ﰲ ﺍﳌﻌﺎﳉﺎﺕ ‪ ٣٢‬ﺑﺖ ﻳﻮﺟﺪ ‪ ٤‬ﺃﺭﺑﻊ ﻣﺴﺠﻼﺕ ﻋﺎﻣﺔ ﻃﻮﻝ ﻛﻞ ﻣﻨﻬﺎ ﻫﻮ ‪ ٣٢‬ﺑﺖ )‪ ٤‬ﺑﺎﻳﺖ( ﻭﺗﻘﺴﻢ ﺃﻱ ﻣﻦ‬
‫ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﺍﱃ ﺟﺰﺋﲔ‪ :‬ﺍﳉﺰء ﺍﻷﻋﻠﻰ )‪ (High Order Word‬ﻭﻫﻮ ﺑﻄﻮﻝ ‪ ١٦‬ﺑﺖ ﻭﺍﳉﺰء ﺍﻷﺩﱏ )‪Low‬‬
‫‪ (Order Word‬ﻭﻫﻮ ﺃﻳﻀﺎ ﺑﻄﻮﻝ ‪ ١٦‬ﺑﺖ ‪ ،‬ﻛﺬﻟﻚ ﻳ‪‬ﻘﺴﻢ ﺍﳉﺰء ﺍﻷﺩﱏ ﺍﱃ ﺟﺰﺋﲔ‪ :‬ﺍﳉﺰء ﺍﻷﻋﻠﻰ )‪High‬‬
‫‪ (Order Byte‬ﻭﻫﻮ ﺑﻄﻮﻝ ‪ ٨‬ﺑﺖ ﻭﺍﳉﺰء ﺍﻷﺩﱏ )‪ (Low Order Byte‬ﻭﻫﻮ ﺃﻳﻀﺎ ﺑﻄﻮﻝ ‪ ٨‬ﺑﺖ‪ .‬ﻋﻠﻰ ﺳﺒﻴﻞ‬
‫ﺍﳌﺜﺎﻝ ﻣﺴﺠﻞ ‪ EAX‬ﺣﻴﺚ ﻳﻘﺴﻢ ﺍﱃ ﺟﺰء ﺃﻋﻠﻰ )ﻻ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﺍﻟﻴﻪ ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ( ﻭﺟﺰء ﺃﺳﻔﻞ ﻭﻫﻮ ‪AX‬‬
‫ﺍﻟﺬﻱ ﻳ‪‬ﻘﺴﻢ ﺃﻳﻀﺎ ﺍﱃ ﻗﺴﻤﲔ ‪ AH‬ﻭ ‪ .AL‬ﻛﻞ ﻣﺴﺠﻞ ﻣﻦ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﺍﻟﻌﺎﻣﺔ ﻳﺴﺘﺨﺪﻡ ﻷﻱ ﺷﻲء ﻟﻜﻦ‬
‫ﻫﻨﺎﻙ ﺑﻌﺾ ﺍﻹﺳﺘﺨﺪﺍﻣﺎﺕ ﺍﻟﻐﺎﻟﺒﺔ ﻟﻜﻞﹲ ﻣﻨﻬﻢ ﺗﻮﺿﺤﻬﺎ ﺍﻟﻘﺎﺋﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‪.‬‬

‫ﺍﳌﺴﺠﻞ ‪ :EAX‬ﻳﺴﺘﺨﺪﻡ ﻟﻨﻘﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﳊﺴﺎﺑﻴﺔ‪.‬‬ ‫•‬

‫‪٢٦‬‬
‫‪ .٢.٢‬ﺍﳌﻌﺎﰿ‬

‫ﺍﳌﺴﺠﻞ ‪ :EBX‬ﻳﺴﺘﺨﺪﻡ ﰲ ﺍﻟﻮﺻﻮﻝ ﻟﻠﺬﺍﻛﺮﺓ ﺑﺸﻜﻞ ﻏﲑ ﻣﺒﺎﺷﺮ ﻭﺫﻟﻚ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﺴﺠﻞ ﺁﺧﺮ ﻳﻌﻤﻞ‬ ‫•‬
‫ﻛﻌﻨﻮﺍﻥ ﺭﺋﻴﺴﻲ ‪.Base Address‬‬
‫ﺍﳌﺴﺠﻞ ‪ :ECX‬ﻳﺴﺘﺨﺪﻡ ﰲ ﻋﻤﻠﻴﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ ﻭﺍﻟﻌﺪ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :EDX‬ﻳﺴﺘﺨﺪﻡ ﰲ ﲣﺰﻳﻦ ﺍﻟﺒﻴﺎﻧﺎﺕ‪.‬‬ ‫•‬

‫‪Segment Registers‬‬ ‫ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ‬

‫ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﺗﺴﺘﺨﺪﻡ ﻟﺘﺨﺰﻳﻦ ﺃﺭﻗﺎﻡ ﻭﻋﻨﺎﻭﻳﻦ ﺍﳌﻘﺎﻃﻊ )‪ (Segments‬ﻭﺗﻮﺟﺪ ‪ ٦‬ﻣﺴﺠﻼﺕ ﻣﻘﺎﻃﻊ ﺗﺴﺘﺨﺪﻡ‬
‫ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪ :CS‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﺸﻔﺮﺓ ﻟﻠﱪﻧﺎﻣﺞ ﺍﳌﺮﺍﺩ ﺗﻨﻔﻴﺬﻩ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :DS‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻟﻠﱪﻧﺎﻣﺞ ﺍﳌﺮﺍﺩ ﺗﻨﻔﻴﺬﻩ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :SS‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﳌﻜﺪﺱ ﻟﻠﱪﻧﺎﻣﺞ ﺍﳌﺮﺍﺩ ﺗﻨﻔﻴﺬﻩ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :ES‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻟﻠﱪﻧﺎﻣﺞ ﺍﳌﺮﺍﺩ ﺗﻨﻔﻴﺬﻩ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :FS‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﻣﻘﻄﻊ ﺑﻌﻴﺪ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :GS‬ﻳﺴﺘﺨﺪﻡ ﻟﻸﻏﺮﺍﺽ ﺍﻟﻌﺎﻣﺔ‪.‬‬ ‫•‬

‫ﺃﻣﺎ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (PMode‬ﻓﺈﻥ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﻻ ﺗﺸﲑ ﺍﱃ ﻣﻘﺎﻃﻊ ﺍﻟﱪﺍﻣﺞ ﻭﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺇﳕﺎ ﺗﺸﲑ ﺍﱃ‬
‫ﻭﺍﺻﻔﺎﺕ ﻣﻌﻴﻨﺔ ﰲ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ‪ ،‬ﻫﺬﻩ ﺍﻟﻮﺍﺻﻔﺎﺕ ﲢﺪﺩ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ﻭﻧﻮﻉ ﺍﳌﻘﻄﻊ )ﳛﻮﻱ‬
‫ﺷﻔﺮﺍﺕ ﺃﻡ ﺑﻴﺎﻧﺎﺕ ( ﻭﲢﺪﺩ ﺻﻼﺣﻴﺔ ﺍﻟﺘﻨﻔﻴﺬ ﻭﺻﻼﺣﻴﺔ ﻭﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻓﻴﻬﺎ ‪ -‬ﻛﻤﺎ ﺳﻨﺮﻯ ﺫﻟﻚ ﰲ ﺍﻟﻔﺼﻞ‬
‫ﺍﻟﺮﺍﺑﻊ ﺑﺈﺫﻥ ﺍﷲ‪.-‬‬

‫‪Offset Registers‬‬ ‫ﻣﺴﺠﻼﺕ ﺍﻹﺯﺍﺣﺔ‬

‫ﲜﺎﻧﺐ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﻓﺈﻥ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻳﺘﻄﻠﺐ ﻋﻨﻮﺍﻥ ﺍﻹﺯﺍﺣﺔ ﺑﺪﺍﺧﻞ ﺍﳌﻘﻄﻊ ‪،‬‬
‫ﻭﺗﻮﺟﺪ ‪ ٤‬ﻣﺴﺠﻼﺕ ﺇﺯﺍﺣﺔ ﰲ ﻣﻌﺎﳉﺎﺕ ‪ x86‬ﺣﺠﻢ ﻛﻞ ﻣﻨﻬﺎ ﻫﻮ ‪ ٣٢‬ﺑﺖ ﰲ ﺍﻷﻧﻈﻤﺔ ‪ ٣٢‬ﺑﺖ ﻭ ‪ ١٦‬ﺑﺖ‬
‫ﰲ ﺃﻧﻈﻤﺔ ‪ ١٦‬ﺑﺖ‪ .‬ﻭﺍﻟﻘﺎﺋﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪ :SI‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻹﺯﺍﺣﺔ ﰲ ﻣﻘﻄﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :DI‬ﻧﻔﺲ ﺍﻟﻮﻇﻴﻔﺔ ﺍﻟﺴﺎﺑﻘﺔ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :BP‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻹﺯﺍﺣﺔ ﺑﺪﺍﺧﻞ ﻣﻘﻄﻊ ﺍﳌﻜﺪﺱ ﻭﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻸﺷﺎﺭﺓ ﻋﻠﻰ ﺃﻱ ﻋﻨﻮﺍﻥ ﰲ‬ ‫•‬
‫ﺃﻱ ﻣﻘﻄﻊ ﺁﺧﺮ‪.‬‬

‫‪٢٧‬‬
 ‫‪x86‬‬ ‫‪ .٢‬ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬

‫ﺍﳌﺴﺠﻞ ‪ :SP‬ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻹﺯﺍﺣﺔ ﺑﺪﺍﺧﻞ ﻣﻘﻄﻊ ﺍﳌﻜﺪﺱ‪.‬‬ ‫•‬

‫‪Instruc on Pointer‬‬ ‫ﻣﺆﺷﺮ ﺍﻟﺘﻌﻠﻴﻤﺔ‬

‫ﻫﺬﺍ ﺍﳌﺴﺠﻞ )‪ (IP‬ﳝﺜﻞ ﺇﺯﺍﺣﺔ ﺑﺪﺍﺧﻞ ﻣﻘﻄﻊ ﺍﻟﺸﻔﺮﺓ )‪ (CS‬ﻭﻫﻮ ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺍﻟﱵ ﺳﻴﻘﻮﻡ ﺍﳌﻌﺎﰿ‬
‫ﺑﺘﻨﻔﻴﺬﻫﺎ ‪ ،‬ﻭﺍﻟﻌﻨﻮﺍﻥ ‪ CS:IP‬ﳝﺜﻞ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ‪ .‬ﻫﺬﺍ ﺍﳌﺴﺠﻞ ﻫﻮ ﺑﻄﻮﻝ ‪ ٣٢‬ﺑﺖ )‪ (EIP‬ﰲ‬
‫ﺃﻧﻈﻤﺔ ‪ ٣٢‬ﺑﺖ ﻭ ‪ ١٦‬ﺑﺖ )‪ (IP‬ﰲ ﺃﻧﻈﻤﺔ ‪ ١٦‬ﺑﺖ‪ ،‬ﻭﻫﻮ ﻣﺴﺠﻞ ﻻ ﳝﻜﻦ ﺗﻐﻴﲑ ﳏﺘﻮﺍﻩ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﻌﻠﻴﻤﺔ ﺍﳌﻌﺎﰿ‬
‫‪ MOV‬ﻭﺇﳕﺎ ﻳﺘﻢ ﺗﻐﻴﲑ ﳏﺘﻮﺍﻩ ﻋﻦ ﺍﻟﻘﻔﺰ ﺍﱃ ﻣﻜﺎﻥ ﺁﺧﺮ ﻟﻠﺘﻨﻔﻴﺬ‪.‬‬

‫‪FLAGS Register‬‬ ‫ﻣﺴﺠﻞ ﺍﻷﻋﻼﻡ‬

‫ﻣﺴﺠﻞ ﺍﻷﻋﻼﻡ ﻫﻮ ﻣﺴﺠﻞ ﲝﺠﻢ ‪ ٣٢‬ﺑﺖ )‪ (EFLAGS‬ﰲ ﺃﻧﻈﻤﺔ ‪ ٣٢‬ﺑﺖ ﻭ ﲝﺠﻢ ‪ ١٦‬ﺑﺖ )‪ (FLAGS‬ﰲ‬
‫ﺃﻧﻈﻤﺔ ‪ ١٦‬ﺑﺖ ‪ ،‬ﻭﻫﺬﺍ ﺍﳌﺴﺠﻞ ﻫﻮ ﻋﺒﺎﺭﺓ ﻋﻦ ﺑﺘﺎﺕ )ﺑﺎﳊﺠﻢ ﺍﻟﺴﺎﺑﻖ ﺫﻛﺮﻩ( ﻛﻞ ﺑﺖ ﻟﺪﻳﻪ ﻭﻇﻴﻔﻪ ﳏﺪﺩﻩ ‪،‬‬
‫ﻭﻳﻨﻘﺴﻢ ﺑﺸﻜﻞ ﻋﺎﻡ ﺍﱃ ﺑﺘﺎﺕ ﺣﺎﻟﺔ )‪ (Status‬ﲝﻴﺚ ﺗﻌﻜﺲ ﺣﺎﻟﺔ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﺘﻨﻔﻴﺬﻫﺎ ﻭ ﺑﺘﺎﺕ‬
‫ﲢﻜﻢ )‪ (Control‬ﲝﻴﺚ ﺗﺘﺤﻜﻢ ﰲ ﺑﻌﺾ ﺍﳋﺼﺎﺋﺺ ﻭ ﺑﺘﺎﺕ ﻟﻠﻨﻈﺎﻡ )‪ .(System‬ﻭﺍﳉﺪﻭﻝ ‪ ٤.٢‬ﻳﻮﺿﺢ ﻭﻇﻴﻔﺔ‬
‫ﻛﻞ ﺑﺖ ﰲ ﻫﺬﺍ ﺍﳌﺴﺠﻞ‪.‬‬
‫ﻭﳛﺪﺩ ﺍﻟﺒﺘﲔ ‪ IOPL‬ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ﺍﳌﻄﻠﻮﺏ ﻟﺘﻨﻔﻴﺬ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻷﻭﺍﻣﺮ )ﻣﺜﻞ ﺍﻷﻭﺍﻣﺮ ‪ (CLI,STI,IN,OUT‬ﺣﻴﺚ‬
‫ﻟﻦ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﻣﺜﻞ ﻫﺬﻩ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺇﻻ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ﺍﳊﺎﱄ ‪ Current Priviledge Level‬ﺃﻋﻠﻰ‬
‫ﻣﻦ ﺃﻭ ﻣﺴﺎﻭﻳﴼ ﻟﻠﻘﻴﻤﺔ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﺍﻟﺒﺘﲔ ‪ ، ٧ IOPL‬ﻭﻏﺎﻟﺒﴼ ﻣﺎ ﺗﻜﻮﻥ ﺍﻟﻘﻴﻤﺔ ﻫﻲ ﺻﻔﺮ ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‬
‫ﺍﻟﺴﺎﺑﻘﺔ ﻻ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﺍﻻ ﻟﱪﺍﻣﺞ ﺍﻟﻨﻮﺍﺓ )‪.(Ring0‬‬

‫‪Control Registers‬‬ ‫ﻣﺴﺠﻼﺕ ﺍﻟﺘﺤﻜﻢ‬

‫ﺗﻮﺟﺪ ﰲ ﻣﻌﺎﳉﺎﺕ ‪ ٣٢‬ﺑﺖ ﺳﺘﺔ ﻣﺴﺠﻼﺕ ﻟﻠﺘﺤﻜﻢ ﰲ ﺳﻠﻮﻙ ﻭﻋﻤﻞ ﺍﳌﻌﺎﰿ ﻭﻫﻲ ‪CR0, CR1, CR2,CR3, CR4,‬‬
‫‪ ، CR8‬ﻭﻧﻈﺮﴽ ﳋﻄﻮﺭﺓ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻓﺎﻥ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﻻ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﳍﺎ ﺇﻻ ﻋﻨﺪ ﺍﻟﻌﻤﻞ ﰲ ﳕﻂ ﺍﻟﻨﻮﺍﺓ‬
‫)‪ (Kernel Moder/Ring0‬ﻭﻻ ﻳ‪‬ﻤﻜﻦ ﻟﱪﳎﻴﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﻫﺬﻩ ﺍﳌﺴﺠﻼﺕ ﻭﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‪ .‬ﻭﰲ‬
‫ﺍﻟﻮﻗﺖ ﺍﳊﺎﱄ ﻳﻬﻤﻨﺎ ﻓﻘﻂ ﺃﻭﻝ ﻣﺴﺠﻞ ﲢﻜﻢ ﻭﻫﻮ ‪ CR0‬ﺣﻴﺚ ﻣﻦ ﺧﻼﻟﻪ ﳝﻜﻦ ﺃﻭ ﻧﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ ﲢﻮﻳﻞ ﳕﻂ ﺍﳌﻌﺎﰿ‬
‫ﻣﻦ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (PMode‬ﻭﻛﺬﻟﻚ ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻡ ﺑﺘﻔﻌﻴﻞ ﺧﺎﺻﻴﺔ ﺍﻟﺼﻔﺤﺎﺕ )‪(Paging‬‬
‫‪ ،‬ﻭﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﳏﺘﻮﻳﺎﺕ ﻛﻞ ﺑﺖ ﰲ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ ‪ CR0‬ﻭﻫﻮ ﻣﺴﺠﻞ ﲝﺠﻢ ‪ ٣٢‬ﺑﺖ‪.‬‬
‫‪• Bit 0 (PE) : Puts the system into protected mode.‬‬

‫‪• Bit 1 (MP) : Monitor Coprocessor Flag This controls the opera on of the WAIT instruc on.‬‬

‫‪• Bit 2 (EM) : Emulate Flag. When set, coprocessor instruc ons will generate an excep on‬‬
‫‪٧‬ﺃﻋﻠﻰ ﻣﺴﺘﻮﻯ ﲪﺎﻳﺔ ﻫﻮ ﺍﳊﻠﻘﺔ ﺻﻔﺮ )‪ (Ring0‬ﻭﻳﻠﻴﻬﺎ ﺍﳊﻠﻘﺔ ‪ ١‬ﰒ ‪ ٢‬ﻭ‪.٣‬‬

‫‪٢٨‬‬
‫ ﺍﳌﻌﺎﰿ‬.٢.٢

EFLAGS ‫ ﻣﺴﺠﻞ ﺍﻷﻋﻼﻡ‬:.٤.٢ ‫ﺟﺪﻭﻝ‬

‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﺳﻢ ﺍﻟﺒﺖ ﺍﻹﺳﺘﺨﺪﺍﻡ‬
Carry Flag - Status bit CF 0
‫ﳏﺠﻮﺯﺓ‬ - 1
Parity Flag PF 2
‫ﳏﺠﻮﺯﺓ‬ - 3
Adjust Flag - Status bit AF 4
‫ﳏﺠﻮﺯﺓ‬ - 5
Zero Flag - Status bit ZF 6
Sign Flag - Status bit SF 7
Trap Flag - System Flag TF 9
Interrupt Enabled Flag - System Flag IF 9
Direc on Flag - Control Flag DF 10
Overflow Flag - Status bit OF 11
I/O Priviledge Level - Control Flag IOPL 12-13
Nested Task Flag - Control Flag NT 14
‫ﳏﺠﻮﺯﺓ‬ - 15
Resume Flag (386+ Only) - Control Flag RF 16
v8086 Mode Flag (386+ Only) - Control Flag VM 17
Alignment Check (486SX+ Only) - Control Flag AC 18
Virtual Interrupt Flag (Pen um+ Only) - Control Flag VIF 19
Virtual Interrupt Pending (Pen um+ Only) - Control Flag VIP 20
Iden fica on (Pen um+ Only) - Control Flag ID 21
‫ﳏﺠﻮﺯﺓ‬ - 22-31

٢٩
 x86 ‫ ﻣﻌﻤﺎﺭﻳﺔ ﺣﻮﺍﺳﻴﺐ‬.٢

• Bit 3 (TS) : Task Switched Flag This will be set when the processor switches to another task.

• Bit 4 (ET) : ExtensionType Flag. This tells us what type of coprocesor is installed.
– 0 - 80287 is installed
– 1 - 80387 is installed.

• Bit 5 (NE): Numeric Error

– 0 - Enable standard error repor ng
– 1 - Enable internal x87 FPU error repor ng

• Bits 6-15 : Unused

• Bit 16 (WP): Write Protect

• Bit 17: Unused

• Bit 18 (AM): Alignment Mask

– 0 - Alignment Check Disable
– 1 - Alignment Check Enabled (Also requires AC flag set in EFLAGS and ring 3)

• Bits 19-28: Unused

• Bit 29 (NW): Not Write-Through

• Bit 30 (CD): Cache Disable

• Bit 31 (PG) : Enables Memory Paging.

– 0 - Disable
– 1 - Enabled and use CR3 register

٣٠
 ‫ﺍﻟﻘﺴﻢ ‪.II‬‬
‫‪Boo ng‬‬ ‫ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬
‫ﺃﺣﺪ ﺃﻫﻢ ﺍﻷﺳﺎﺳﻴﺎﺕ ﰲ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﻫﻲ ﻛﺘﺎﺑﺔ ﳏﻤﻞﹲ ﻟﻪ ‪ ،‬ﻫﺬﺍ ﺍﳌﺤﻤﻞ ﻳﻌﻤﻞ ﻋﻠﻰ ﻧﺴﺦ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻣﻦ‬
‫ﺃﺣﺪ ﺍﻷﻗﺮﺍﺹ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﰒ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﻨﻮﺍﺓ ‪ ،‬ﻭﻫﻜﺬﺍ ﺗﻨﺘﻬﻲ ﺩﻭﺭﺓ ﻋﻤﻞ ﺍﳌﺤﻤﻞ ﻭﻳﺒﺪﺃ ﻧﻈﺎﻡ‬
‫ﺍﻟﺘﺸﻐﻴﻞ ﻣﺘﻤﺜﻼ ﰲ ﺍﻟﻨﻮﺍﺓ ﺑﺎﻟﺒﺪء ﺑﺘﻨﻔﻴﺬ ﺍﻻﻭﺍﻣﺮ ﻭﺍﳌﻬﻤﺎﺕ ﻭﺗﻠﺒﻴﺔ ﺇﺣﺘﻴﺎﺟﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ‪ .‬ﰲ ﻫﺬﺍ ﺍﻟﻔﺼﻞ ﺳﻨﺪﺭﺱ‬
‫ﻛﻴﻔﻴﺔ ﺑﺮﳎﺔ ﺍﳌﺤﻤﻞ ﻭﻣﺎﻫﻴﺘﻪ ﻭﺳﻴﺘﻢ ﺍﻻﻗﻼﻉ ﻣﻦ ﻗﺮﺹ ﻣﺮﻥ ﺑﻨﻈﺎﻡ ‪ ، FAT12‬ﻓﺎﻟﻐﺮﺽ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ ﻫﻮ ﺩﺭﺍﺳﺔ‬
‫ﺃﺳﺎﺳﻴﺎﺕ ﺍﳌﺤﻤﻞ ﻭﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﻧﻮﺍﺓ ﻣﺒﺴﻄﺔ ‪.‬‬

‫‪ .١.٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ‬
‫ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ )‪ (Boot-Strapping‬ﻫﻲ ﺃﻭﻝ ﺧﻄﻮﺓ ﻳﻘﻮﻡ ‪‬ﺎ ﺍﳉﻬﺎﺯ ﻋﻨﺪ ﻭﺻﻠﻪ ﺑﺎﻟﻜﻬﺮﺑﺎء ﻟﺘﺤﻤﻴﻞ ﻧﻈﺎﻡ‬
‫ﺍﻟﺘﺸﻐﻴﻞ‪ ،‬ﻭﺗﺒﺪﺃ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﻣﺒﺎﺷﺮﺓ ﻋﻨﺪ ﺍﻟﻀﻐﻂ ﻋﻠﻰ ﻣﻔﺘﺎﺡ ﺍﻟﺘﺸﻐﻴﻞ ﰲ ﺍﳊﺎﺳﺐ ‪ ،‬ﺣﻴﺚ ﺗﺮﺳﻞ ﺇﺷﺎﺭﺓ‬
‫ﻛﻬﺮﺑﺎﺋﻴﺔ ‪ ١‬ﺍﱃ ﺍﻟﻠﻮﺣﺔ ﺍﻻﻡ ) ‪ ( MotherBoard‬ﻭﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺘﻮﺟﻴﻬﻬﺎ ﺍﱃ ﻭﺣﺪﺓ ﻣﻮﺯﺩ ﺍﻟﻄﺎﻗﺔ )‪Power Supply‬‬
‫‪ .(Unit‬ﺑﻌﺪ ﺫﻟﻚ ﻳﺄﰐ ﺩﻭﺭ ﻭﺣﺪﺓ ‪ PSU‬ﻟﻜﻲ ﺗﻘﻮﻡ ﲟﻬﻤﺔ ﺗﺰﻭﻳﺪ ﺍﳊﺎﺳﺐ ﻭﻣﻠﺤﻘﺎﺗﻪ ﺑﺎﻟﻜﻤﻴﺔ ﺍﳌﻄﻠﻮﺑﺔ ﻣﻦ ﺍﻟﻄﺎﻗﺔ‪،‬‬
‫ﻭﺇﺭﺳﺎﻝ ﺍﺷﺎﺭﺓ ‪ Power Good‬ﺇﱃ ﺍﻟﻠﻮﺣﺔ ﺍﻻﻡ ﻭﺑﺎﻟﺘﺤﺪﻳﺪ ﺍﱃ ﻧﻈﺎﻡ ﺍﻝ ‪ . BIOS‬ﺗﺪﻝ ﻫﺬﻩ ﺍﻻﺷﺎﺭﺓ ﻋﻠﻰ ﺃﻧﻪ ﰎ‬
‫ﺗﺰﻭﻳﺪ ﺍﻟﻄﺎﻗﺔ ﺍﻟﻜﺎﻓﻴﺔ ‪ ،‬ﻭﻓﻮﺭﺍ ﺳﻴﺒﺪﺃ ﺑﺮﻧﺎﻣﺞ ﺍﻟﻔﺤﺺ ﺍﻟﺬﺍﰐ ) ‪ ( Power on Self Test‬ﺍﻟﺬﻱ ﻳﻌﺮﻑ ﺍﺧﺘﺼﺎﺭﴽ‬
‫ﺏ ‪ POST‬ﺑﻔﺤﺺ ﺃﺟﻬﺰﺓ ﻭﳏﻠﻘﺎﺕ ﺍﳊﺎﺳﺐ )ﻣﺜﻞ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻭﺍﳌﺎﻭﺱ ﻭﺍﻟﻨﺎﻗﻞ ﺍﻟﺘﺴﻠﺴﻠﻲ ‪...‬ﺍﱁ(‬
‫ﻭﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃ‪‬ﺎ ﺳﻠﻴﻤﺔ‪ .‬ﺑﻌﺪﻫﺎ ﻳﻘﻮﻡ ﺍﻝ ‪ POST‬ﺑﻨﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﱃ ﻧﻈﺎﻡ ﺍﻝ ‪ BIOS‬ﺣﻴﺚ ﺳﻴﻘﻮﻡ ﺍﻝ ‪POST‬‬
‫ﺑﺘﺤﻤﻴﻞ ﺍﻝ ‪ BIOS‬ﺍﱃ ‪‬ﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ‪ 0xFFFF0‬ﻭ ﺳﻴﻘﻮﻡ ﺃﻳﻀﺎ ﺑﻮﺿﻊ ﺗﻌﻠﻴﻤﺔ ﻗﻔﺰ ) ‪ ( jump‬ﰲ ﺃﻭﻝ ﻋﻨﻮﺍﻥ‬
‫ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﺍﱃ ‪‬ﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻛﺬﻟﻚ ﻣﻦ ﻣﻬﺎﻡ ﺍﻝ ‪ POST‬ﻫﻲ ﺗﺼﻔﲑ ﺍﳌﺴﺠﻠﲔ ‪ CS:IP‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ﺃﻭﻝ‬
‫ﺗﻌﻠﻴﻤﻴﺔ ﺳﻴﻨﻔﺬﻫﺎ ﺍﳌﻌﺎﰿ ﻫﻲ ﺗﻌﻠﻴﻤﺔ ﺍﻟﻘﻔﺰ ﺍﱃ ‪‬ﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺑﺎﻟﺘﺤﺪﻳﺪ ﺍﱃ ﺍﻝ ‪ . BIOS‬ﻳﺴﺘﻠﻢ ﺍﻝ ‪ BIOS‬ﺍﻟﺘﺤﻜﻢ‬
‫ﻭﻳﺒﺪﺃ ﰲ ﺍﻧﺸﺎء ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ) ‪ ( Interrupt Vector Table‬ﻭﺗﻮﻓﲑ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪،‬ﻭﻳﻘﻮﻡ ﺑﺎﳌﺰﻳﺪ‬
‫ﻣﻦ ﻋﻤﻠﻴﺎﺕ ﺍﻟﻔﺤﺺ ﻭﺍﻻﺧﺘﺒﺎﺭ ﻟﻠﺤﺎﺳﺐ ‪ ،‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺒﺪﺃ ﰲ ﻣﻬﻤﺔ ﺍﻟﺒﺤﺚ ﻋﻦ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﰲ ﺍﻻﺟﻬﺰﺓ‬
‫ﺍﳌﻮﺟﻮﺩﺓ ﺑﻨﺎءﺍ ﻋﻠﻰ ﺗﺮﺗﻴﺒﻬﺎ ﰲ ﺍﻋﺪﺍﺩﺍﺕ ﺍﻝ ‪ BIOS‬ﰲ ﺑﺮﻧﺎﻣﺞ ‪، Setup‬ﻭﰲ ﺣﺎﻟﺔ ﱂ ﳚﺪ ﺍﻝ ‪ BIOS‬ﺟﻬﺎﺯﺍ ﻗﺎﺑﻼ‬
‫ﻟﻼﻗﻼﻉ ﰲ ﻛﻞ ﺍﻟﻘﺎﺋﻤﺔ ﻓﺎﻧﻪ ﻳﺼﺪﺭ ﺭﺳﺎﻟﺔ ﺧﻄﺄ ﺑﻌﺪﻡ ﺗﻮﻓﺮ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﻭﻳﻮﻗﻒ ﺍﳊﺎﺳﺐ ﻋﻦ ﺍﻟﻌﻤﻞ ) ‪( Halt‬‬
‫‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﺗﻮﻓﺮ ﺟﻬﺎﺯﴽ ﻗﺎﺑﻼً ﻟﻺﻗﻼﻉ ﺳﻴﻘﻮﻡ ﺍﻝ ‪ BIOS‬ﺑﺘﺤﻤﻴﻞ ﺍﻟﻘﻄﺎﻉ ﺍﻷﻭﻝ ﻣﻨﻪ ) ﳛﻮﻱ ﻫﺬﺍ ﺍﻟﻘﻄﺎﻉ ﻋﻠﻰ‬
‫ﺑﺮﻧﺎﻣﺞ ﺍﳌﺤﻤﻞ( ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺑﺎﻟﺘﺤﺪﻳﺪ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ‪ 0x07c00‬ﻭﺳﻴ‪‬ﻨﻘَﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﳌﺤﻤﻞ‪.‬‬

‫‪١‬ﻫﺬﻩ ﺍﻹﺷﺎﺭﺓ ﲢﻮﻱ ﻋﻠﻰ ﺑﺖ ) ‪ ( bit‬ﺗﺪﻝ ﻗﻴﻤﺘﻪ ﺍﺫﺍ ﻛﺎﻧﺖ ‪ 1‬ﻋﻠﻰ ﺃﻧﻪ ﰎ ﺗﺸﻐﻴﻞ ﺍﳊﺎﺳﺐ‪.‬‬

‫‪٣٣‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺧﻼﻝ ﻫﺬﻩ ﺍﳌﻬﻤﺔ )ﺍﻗﻼﻉ ﺍﻟﻨﻈﺎﻡ( ﻳﻮﻓﺮ ﻟﻨﺎ ﻧﻈﺎﻡ ﺍﻝ ‪ BIOS‬ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻋﻠﻰ ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻭﺍﻟﺬﻱ‬
‫ﻳﺘﻢ ﺍﻧﺸﺎﺋﻪ ﺑﺪءﴽ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ ، 0x0‬ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻫﻲ ﺧﺪﻣﺎﺕ ﻳﻮﻓﺮﻫﺎ ﻟﻨﺎ ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ ﻻﺩﺍء ﻭﻇﻴﻔﺔ ﻣﻌﻴﻨﺔ‬
‫ﻣﺜﻞ ﻣﻘﺎﻃﻌﺔ ﻟﻄﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‪ .‬ﻭﺍﺣﺪﺓ ﻣﻦ ﺃﻫﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﻳﺴﺘﺨﺪﻣﻬﺎ ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ ﻟﻠﺒﺤﺚ ﻋﻦ‬
‫ﺟﻬﺎﺯ ﺍﻻﻗﻼﻉ ﻫﻲ ﺍﳌﻘﺎﻃﻌﺔ ‪ int 0x19‬ﺣﻴﺚ ﺗﻜﻤﻦ ﻭﻇﻴﻔﺘﻬﺎ ﰲ ﺍﻟﺒﺤﺚ ﻋﻦ ﻫﺬﺍ ﺍﳉﻬﺎﺯ ﻭﻣﻦ ﰒ ﲢﻤﻴﻞ ﺍﻟﻘﻄﺎﻉ‬
‫ﺍﻷﻭﻝ ﻣﻨﻪ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ‪ 0x07c00‬ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻪ ‪ .‬ﻃﺮﻳﻘﺔ ﺍﻟﺒﺤﺚ ﻭﺍﻟﺘﺤﻤﻴﻞ ﻟﻴﺴﺖ ﺑﺎﻻﻣﺮ ﺍﳌﻌﻘﺪ‬
‫ﺣﻴﺚ ﻋﻠﻰ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ ﺍﻟﺒﺤﺚ ﰲ ﺃﻭﻝ ﻗﻄﺎﻉ )ﻣﻦ ﺃﻱ ﺟﻬﺎﺯ ﻣﻮﺟﻮﺩ ﻋﻠﻰ ﻗﺎﺋﻤﺔ ﺍﻻﺟﻬﺰﺓ ﺍﻟﻘﺎﺑﻠﺔ ﻟﻼﻗﻼﻉ(‬
‫ﻋﻦ ﺍﻟﺘﻮﻗﻴﻊ ‪ 0xAA55‬ﻭﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﺑﺎﻳﺘﲔ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﻋﻠﻰ ﺁﺧﺮ ﺍﻟﻘﻄﺎﻉ ﺍﻻﻭﻝ ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﻫﺬﺍ ﺍﳉﻬﺎﺯ‬
‫ﻗﺎﺑﻞ ﻟﻼﻗﻼﻉ‪ .‬ﻭﻣﻦ ﺍﳉﺪﻳﺮ ﺑﺎﻟﺬﻛﺮ ﺃﻥ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﻳﻮﻓﺮﻫﺎ ﻟﻨﺎ ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻓﻘﻂ ﺍﺫﺍ ﻛﺎﻥ‬
‫ﺍﳌﻌﺎﰿ ﻳﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ‪ Real Mode‬ﺃﻣﺎ ﺇﺫﺍ ﰎ ﺗﻐﻴﲑ ﳕﻂ ﺍﳌﻌﺎﰿ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪Protected Mode‬‬
‫‪ -‬ﻛﻤﺎ ﺳﻨﺮﻯ ﺫﻟﻚ ﻻﺣﻘﺎ‪ -‬ﻓﺎﻧﻪ ﻟﻦ ﳝﻜﻦ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺑﻞ ﺳﻴﺘﺴﺒﺐ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﰲ ﺣﺪﻭﺙ‬
‫ﺍﺳﺘﺜﻨﺎءﺍﺕ ) ‪ ( Excep on‬ﺗﻮﻗﻒ ﻋﻤﻞ ﺍﳊﺎﺳﺐ‪.‬‬

‫‪Bootloader‬‬ ‫‪ .٢.٣‬ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻫﻮ ﺑﺮﻧﺎﻣﺞ ﻭﻇﻴﻔﺘﻪ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻫﻲ ﲢﻤﻴﻞ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ‪.‬ﻫﺬﺍ ﺍﳌﺤﻤﻞ ﳚﺐ‬
‫ﺍﻥ ﺗﺘﻮﻓﺮ ﻓﻴﻪ ﺍﻟﺸﺮﻭﻁ ﺍﻻﺗﻴﺔ ‪:‬‬
‫‪ .١‬ﺣﺠﻢ ﺍﻟﱪﻧﺎﻣﺞ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ‪ 512‬ﺑﺎﻳﺖ ﺑﺎﻟﻀﺒﻂ‪.‬‬
‫‪ .٢‬ﺃﻥ ﻳﺘﻮﺍﺟﺪ ﻋﻠﻰ ﺍﻟﻘﻄﺎﻉ ﺍﻷﻭﻝ ﰲ ﺍﻟﻘﺮﺹ ‪ :‬ﺍﻟﻘﻄﺎﻉ ﺭﻗﻢ ‪ ، 1‬ﺍﻟﺮﺃﺱ ‪ ، 0‬ﺍﳌﺴﺎﺭ ‪ ، 0‬ﻭﺃﻥ ﳛﻤﻞ ﺍﻟﺘﻮﻗﻴﻊ‬
‫ﺍﳌﻌﺮﻭﻑ‪.‬‬
‫‪ .٣‬ﺃﻥ ﳛﻮﻱ ﺷﻔﺮﺓ ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ‪.‬‬
‫( ﻭﻫﻮ ﻣﺎ‬ ‫‪header,symbol table,...etc‬‬ ‫ﺧﺎﱄ ﻣﻦ ﺃﻱ ﺃﺿﺎﻓﺎﺕ )‬ ‫‪object code‬‬ ‫‪ .٤‬ﺃﻥ ﻳﻜﻮﻥ ﺍﻟﱪﻧﺎﻣﺞ‬
‫ﻳﻌﺮﻑ ﺃﻳﻀﺎ ﺑـ ‪. Flat Binary‬‬
‫ﺍﻟﺸﺮﻁ ﺍﻷﻭﻝ ﻳ‪‬ﻘﻴﺪ ﻭﻇﻴﻔﺔ ﺍﳌﺤﻤﻞ ﻭﻗﺪﺭﺗﻪ ﻋﻠﻰ ﺗﻮﻓﲑ ﺧﺼﺎﺋﺺ ﻣﺘﻘﺪﻣﺔ ‪ ،٢‬ﺣﻴﺚ ﺃﻥ ﻫﺬﺍ ﺍﳊﺠﻢ ﻻ ﻳﻜﻔﻲ‬
‫ﻟﻜﻲ ﻳﺒﺤﺚ ﺍﳌﺤﻤﻞ ﻋﻦ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻭﲤﻬﻴﺪ ﺍﻟﻄﺮﻳﻖ ﳍﺎ ﻟﻠﺒﺪء ﺑﺘﻨﻔﻴﺬﻫﺎ ‪ ،‬ﻭﺑﺴﺒﺐ ﺃﻥ ﺍﻟﻨﻮﺍﺓ ﺳﺘﻜﻮﻥ ‪ 32-bit‬ﻓﺎﻧﻪ‬
‫ﳚﺐ ﲡﻬﻴﺰ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﺷﻴﺎء ﺑﺪءﴽ ﻣﻦ ﺟﺪﺍﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ )ﺍﻟﻌﺎﻣﺔ ﻭﺍﳋﺎﺻﺔ( ﻭﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪ A20‬ﻭﺍﻧﺘﻬﺎءﴽ‬
‫ﺑﺘﻐﻴﲑ ﳕﻂ ﺍﳌﻌﺎﰿ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻭﺍﻟﻘﻔﺰ ﺍﱃ ﺍﻟﻨﻮﺍﺓ ﻟﻠﻤﺒﺎﺷﺮﺓ ﰲ ﺗﻨﻔﻴﺬﻫﺎ ‪ .‬ﻛﻞ ﺫﻟﻚ ﳛﺘﺎﺝ ﺍﱃ ﺣﺠﻢ ﺃﻛﱪ‬
‫ﻣﻦ ﺍﳊﺠﻢ ﺍﳌﺸﺮﻭﻁ ﻟﺬﻟﻚ ﻋﺎﺩﺓ ﻣﺎ ﻳﻠﺠﺄ ﻣﱪﳎﻮﺍ ﺍﳌﺤﻤﻼﺕ ﺍﱃ ﲡﺰﺋﻴﻬﺎ ﻋﻠﻰ ﻣﺮﺣﻠﺘﲔ ﻭﻫﻮ ﻣﺎ ﻳﺴﻤﻰ ﺏ‬
‫‪ . Mul -Stage Boot Loader‬ﺍﻟﺸﺮﻁ ﺍﻟﺜﺎﱐ ﻟﻠﻤﺤﻤﻞ ﻭﻫﻮ ﺃﻥ ﻳﺘﻮﺍﺟﺪ ﻋﻠﻰ ﺃﻭﻝ ﻗﻄﺎﻉ ﰲ ﺍﻟﻘﺮﺹ ﻭﻫﻮ ﳛﻤﻞ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ﺍﻟﺘﺎﱄ‪:‬‬
‫• ﺍﻟﻘﻄﺎﻉ ﺭﻗﻢ ‪1‬‬

‫‪Safe Mode‬‬ ‫‪٢‬ﻣﺜﻞ ﺧﺎﺻﻴﺔ ﺍﻝ‬

‫‪٣٤‬‬
‫‪ .٣.٣‬ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ‬

‫‪0‬‬ ‫ﺍﳌﺴﺎﺭ ﺭﻗﻢ‬ ‫•‬

‫‪0‬‬ ‫ﺍﻟﺮﺃﺱ ﺭﻗﻢ‬ ‫•‬

‫ﻭﲢﻘﻴﻖ‪ ‬ﻫﺬﺍ ﺍﻟﺸﺮﻁ ﻟﻴﺲ ﺑﺎﻷﻣﺮ ﺍﳌﻌﻘﺪ ﺧﺼﻮﺻﺎ ﻣﻊ ﺗﻮﻓﺮ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻻﺩﻭﺍﺕ ﺍﻟﱵ ﺗﺴﺎﻋﺪ ﻋﻠﻰ ﻧﺴﺦ ﻣﻘﻄﻊ‬
‫ﻣﻦ ﻗﺮﺹ ﻣﺎ ﺍﱃ ﻣﻘﻄﻊ ﰲ ﻗﺮﺹ ﺁﺧﺮ ‪ ،‬ﺃﻣﺎ ﺍﻟﺸﻖ ﺍﻟﺜﺎﱐ ﻣﻦ ﺍﻟﺸﺮﻁ ﻓﻬﻮ ﻣﺘﻌﻠﻖ ﺑﺘﻤﻴﻴﺰ ﺍﻟﻘﻄﺎﻉ ﺍﻻﻭﻝ ﻛﻘﻄﺎﻉ‬
‫ﻗﺎﺑﻞ ﻟﻼﻗﻼﻉ ﻣﻦ ﻏﲑﻩ ‪ ،‬ﺣﻴﺚ ﺣﱴ ﻳﻜﻮﻥ ﺍﻟﻘﻄﺎﻉ ﻗﺎﺑﻼ ﻟﻼﻗﻼﻉ ﻓﺎﻧﻪ ﳚﺐ ﺃﻥ ﳛﻤﻞ ﺍﻟﺘﻮﻗﻴﻊ ‪ 0xAA55‬ﰲ‬
‫ﺍﻟﺒﺎﻳﺖ ﺭﻗﻢ ‪ 510‬ﻭ ‪ . 511‬ﻭﺑﺪﻭﻥ ﻫﺬﺍ ﺍﻟﺘﻮﻗﻴﻊ ﻓﺎﻥ ﺍﻟﺒﺎﻳﻮﺱ )ﻭﲢﺪﻳﺪﺍ ﻣﻘﺎﻃﻌﺔ ﺭﻗﻢ ‪ (0x19‬ﻟﻦ ﺗﺘﻌﺮﻑ ﻋﻠﻰ‬
‫ﻫﺬﺍ ﺍﻟﻘﻄﺎﻉ ﻛﻘﻄﺎﻉ ﻗﺎﺑﻞٌ ﻟﻺﻗﻼﻉ‪ .‬ﺃﻣﺎ ﺍﻟﺸﺮﻁ ﺍﻟﺜﺎﻟﺚ ﻓﻬﻮ ﺷﺮﻁ ﺍﺧﺘﻴﺎﺭﻱ ﻭﻟﻴﺲ ﺍﺟﺒﺎﺭﻱ ‪ ،‬ﻓﻤﻦ ﺍﳌﻤﻜﻦ ﺃﻥ‬
‫ﺗﻜﻮﻥ ﻭﻇﻴﻔﺔ ﺍﳌﺤﻤﻞ ﻫﻲ ﻋﺮﺽ ﺭﺳﺎﻟﺔ ﺗﺮﺣﻴﺐ ﻓﻘﻂ ! ﻭﻟﻜﻦ ﰲ ﺃﻏﻠﺐ ﺍﳊﺎﻻﺕ ﺍﻟﻮﺍﻗﻌﻴﺔ ﳚﺐ ﺃﻥ ﺗ‪‬ﺤﻤﱠﻞ‬
‫ﺍﻟﻨﻮﺍﺓ ﻭﺗُﻨﻔﱠﺬ ﻋﻦ ﻃﺮﻳﻖ ﻫﺬﺍ ﺍﳌﺤﻤﻞ‪ .‬ﻭﻗﺪ ﺃﺳﻠﻔﻨﺎ ﻭﺫﻛﺮﻧﺎ ﺃﻥ ﲢﻤﻴﻞ ﻧﻮﺍﺓ ‪ 32-bit‬ﳜﺘﻠﻒ ﻋﻦ ﲢﻤﻴﻞ ﻧﻮﺍﺓ ‪16-bit‬‬
‫‪ ،‬ﺣﻴﺚ ﰲ ﺍﻻﻭﱃ ﳚﺐ ﲡﻬﻴﺰ ﺍﻟﻄﺮﻳﻖ ﺃﻣﺎﻡ ﺍﻟﻨﻮﺍﺓ ﻭﺗﻔﻌﻴﻞ ﺑﻌﺾ ﺍﳋﺼﺎﺋﺺ ﻟﺬﻟﻚ ﻭ‪‬ﺟﺐ ﺗﻘﺴﻴﻢ ﻣﻬﻤﺔ ﳏﻤﻞ‬
‫ﺍﻟﻨﻈﺎﻡ ﺍﱃ ﻣﺮﺣﻠﻴﱳ ‪ -‬ﻛﻤﺎﺳﻨﺮﻯ ﺫﻟﻚ ‪ ، -‬ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ ﺍﻟﻨﻮﺍﺓ ‪ 16-bit‬ﻓﺎﻧﻪ ﳝﻜﻦ ﲢﻤﻴﻠﻬﺎ ﲟﺮﺣﻠﺔ ﻭﺍﺣﺪﺓ‬
‫ﻓﻘﻂ ‪ .‬ﻭﺍﻟﺸﺮﻁ ﺍﻻﺧﲑ ﻳﺘﻌﻠﻖ ﺑﺼﻴﻐﺔ ﺍﳌﻠﻒ ﺍﻟﺘﻨﻔﻴﺬﻱ ﻟﻠﻤﺤﻤﻞ‪ ،‬ﺣﻴﺚ ﺃﻏﻠﺐ ﺍﳌﺘﺮﲨﺎﺕ ﲣﺮﺝ ﺻﻴﻎ ﺗﻨﻔﻴﺬﻳﺔ‬
‫ﲢﻮﻱ ﻋﻠﻰ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﳌﻌﻠﻮﻣﺎﺕ ﺍﳌﻀﺎﻓﺔ ﻣﻦ ﻗﺒﻠﻪ ) ﻛﺼﻴﻎ ‪ ( ELF,PE,COFF,...etc‬ﻭﻫﺬﺍ ﻣﺎ ﳚﻌﻞ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ‬
‫ﺍﳌﺤﻤﻞ ﻭﺗﺸﻐﻴﻠﻪ ﻣﻦ ﻗﺒﻞ ﺍﻟﺒﺎﻳﻮﺱ ﻣﺴﺘﺤﻴﻠﺔ ‪ ،‬ﻓﺎﻟﺒﺎﻳﻮﺱ ﻋﻨﺪﻣﺎ ﻳﻘﺮﺃ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺎﻧﻪ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ‬
‫ﺍﱃ ﺃﻭﻝ ﺑﺎﻳﺖ ﻓﻴﻪ ﻭﺍﻟﺬﻱ ﳚﺐ ﺍﻥ ﻳﻜﻮﻥ ﻗﺎﺑﻞ ﻟﻠﺘﻨﻔﻴﺬ ﻭﻟﻴﺲ ﻣﻌﻠﻮﻣﺎﺕ ﺃﻭ ﻫﻴﺪﺭ ﻋﻦ ﺍﳌﻠﻒ ‪ -‬ﻛﻤﺎ ﰲ ﺣﺎﻟﺔ‬
‫ﺍﻟﺼﻴﻎ ﺍﻟﺴﺎﺑﻖ ﺫﻛﺮﻫﺎ‪ . -‬ﻟﺬﻟﻚ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﺻﻴﻐﺔ ﺍﳌﺤﻤﻞ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺜﻨﺎﺋﻴﺔ ﺍﳌﻘﺎﺑﻠﺔ ﻟﻸﻭﺍﻣﺮ‬
‫ﺍﳌﻮﺟﻮﺩﺓ ﻓﻴﻪ ﺑﺪﻭﻥ ﺃﻱ ﺍﺿﺎﻓﺎﺕ ﺃﻱ ‪ Object Code‬ﺍﻭ ‪.Flat Binary‬‬
‫ﻭﳚﺪﺭ ﺑﻨﺎ ﺍﳊﺪﻳﺚ ﻋﻦ ﻟﻐﺔ ﺑﺮﳎﺔ ﳏﻤﱢﻞ ﺍﻟﻨﻈﺎﻡ‪ ،‬ﻓﻐﺎﻟﺒﺎ ﺗﺴﺘﺨﺪﻡ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ )‪ (Assembly 16-bit‬ﻷﺳﺒﺎﺏ‬
‫ﻛﺜﲑﺓ ‪ ،‬ﻣﻨﻬﺎ ﺃﻥ ﺍﳊﺎﺳﺐ ﻋﻨﺪﻣﺎ ﻳﺒﺪﺃ ﺍﻟﻌﻤﻞ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻜﻮﻥ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﲢﻘﻴﻘﺎ ﻷﻏﺮﺍﺽ ﺍﻟﺘﻮﻓﻘﻴﺔ )‬
‫‪ ( Backward Compa bility‬ﻣﻊ ﺍﻷﺟﻬﺰﺓ ﺍﻟﺴﺎﺑﻘﺔ ‪ ،‬ﺃﻳﻀﺎ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ‪ 16-bit‬ﳚﻌﻞ ﻣﻦ ﺍﳌﻤﻜﻦ‬
‫ﺍﺳﺘﺪﻋﺎء ﻣﻘﺎﻃﻌﺎﺕ ﻭﺧﺪﻣﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ‪ -‬ﻗﺒﻞ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺑﻴﺌﺔ ‪ ، - 32-bit‬ﺃﺧﲑﴽ ﻻ ﺣﺎﺟﺔ ﳌﻠﻔﺎﺕ ﻭﻗﺖ‬
‫ﺍﻟﺘﺸﻐﻴﻞ ‪ ، run- me library‬ﺣﻴﺚ ﺃﻥ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻣﺎﻫﻲ ﺍﻻ ﳐﺘﺼﺮﺍﺕ ﻟﻠﻐﺔ ﺍﻵﻟﺔ ‪ .Machine Language‬ﻛﻞ‬
‫ﻫﺬﺍ ﻻ ﳚﻌﻞ ﻋﻤﻠﻴﺔ ﻛﺘﺎﺑﺔ ﳏﻤﱢﻞ ﺍﻟﻨﻈﺎﻡ ﺑﻠﻐﺔ ﺍﻟﺴﻲ ﻣﺴﺘﺤﻴﻼ ! ﻓﻬﻨﺎﻙ ﻛﻢﱞ ﻛﺒﲑ ﻣﻦ ﺍﳌﺤﻤﻼﺕ ﺗﺴﺘﺨﺪﻡ ﻟﻐﺔ‬
‫ﺍﻟﺴﻲ ﻭﺍﻟﺘﺠﻤﻴﻊ ﰲ ﺁﻥ ﻭﺍﺣﺪ ) ﻣﺜﻞ ‪ ، ( GRUB,NTLDR,LILO...etc‬ﻟﻜﻦ ﻗﺒﻞ ﺑﺮﳎﺔ ﻣﺜﻞ ﻫﺬﻩ ﺍﳌﺤﻤﻼﺕ ﳚﺐ‬
‫ﺑﺮﳎﺔ ﺑﻌﺾ ﻣﻠﻔﺎﺕ ﺍﻝ ‪ run- me‬ﻟﺘﻮﻓﲑ ﺑﻴﺌﺔ ﻟﻜﻲ ﺗﻌﻤﻞ ﺑﺮﺍﻣﺞ ﺍﻟﺴﻲ ﻋﻠﻴﻬﺎ ‪ ،‬ﺃﻳﻀﺎ ﳚﺐ ﻛﺘﺎﺑﺔ ‪ loader‬ﻟﻜﻲ‬
‫ﻳﻘﺮﺃ ﺍﻟﺼﻴﻐﺔ ﺍﻟﻨﺎﲡﺔ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﺍﻟﺴﻲ ﻭﻳﺒﺪﺃ ﺍﻟﺘﻨﻔﻴﺬ ﻣﻦ ﺩﺍﻟﺔ ﺍﻝ ‪. main‬‬

‫‪ .٣.٣‬ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺃﺛﻨﺎء ﻣﺮﺣﻠﺔ ﺍﻹﻗﻼﻉ ﻭﻋﻨﺪﻣﺎ ﻳ‪‬ﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻓﺎﻥ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﺗﺄﺧﺬ ﺍﻟﺸﻜﻞ ‪. ١.٣‬ﻭﺃﻭﻝ‬
‫‪ ١٠٢٤‬ﺑﺎﻳﺖ ﺗﺴﺘﺨﺪﻡ ﻣﻦ ﻗﺒﻞ ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﺬﻱ ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺩﺍﻟﺔ ﺍﻟﺘﻨﻔﻴﺬ ﻟﻜﻞ ﻣﻘﺎﻃﻌﺔ ﻟﻠﺒﺎﻳﻮﺱ ‪،‬‬

‫‪٣٥‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺷﻜﻞ ‪ :.١.٣‬ﳐﻄﻂ ﳏﺘﻮﻳﺎﺕ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ‬

‫ﻳﻠﻴﻬﺎ ﻣﻨﻄﻘﺔ ﺑﻴﺎﻧﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﰒ ﻣﺴﺎﺣﺔ ﺫﺍﻛﺮﺓ ﺧﺎﻟﻴﺔ ﲢﻮﻱ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x07c00‬ﻭﻫﻮ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﺬﻱ ﻳﻨﻘﻞ ﺍﻟﺒﺎﺑﻮﺱ‬
‫ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻪ )ﻋﻨﻮﺍﻥ ﺑﺮﻧﺎﻣﺞ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ( ‪ ،‬ﻭﻳﻠﻴﻬﺎ ﻣﻨﻄﻘﺔ ﺑﻴﺎﻧﺎﺕ ﺑﺎﻳﻮﺱ ﺍﳌﻮﺳﻌﺔ ﻭﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ﻭﺍﻟﱵ ﲟﺠﺮﺩ‬
‫ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻴﻬﺎ ﺗﻈﻬﺮ ﺍﻷﺣﺮﻑ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ )‪ (Memory Mapped‬ﻭﻳﻠﻴﻬﺎ ﺍﻟﺒﺎﻳﻮﺱ ﻋﻠﻰ ﺫﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ ﻭﻣﻨﺎﻃﻖ‬
‫ﳏﺠﻮﺯﺓ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﻟﺒﻌﺾ ﺃﺟﻬﺰﺓ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﻭﻣﻦ ﰒ ﺍﻟﺒﺎﻳﻮﺱ ﻭﺍﻟﺬﻱ ﻳﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0xf0000‬ﻭﻫﻮ‬
‫ﻣﻮﺟﻮﺩ ﻋﻠﻰ ﺫﺍﻛﺮﺓ ﺍﻟﺮﻭﻡ )‪. (Memory Mapped‬‬

‫‪ .٤.٣‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺍﳌﺜﺎﻝ ‪ ٣.١‬ﻳﻮﺿﺢ ﺃﺻﻐﺮ ﳏﻤﻞ ﻟﻠﻨﻈﺎﻡ ﳝﻜﻦ ﻛﺘﺎﺑﺘﻪ ﻭﺗﻨﻔﻴﺬﻩ ‪ ،‬ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﺠﻤﻊ ‪ ٣ NASM‬ﻭﻫﻮ ﳎﻤﻊ ﻣﺘﻌﺪﺩ‬
‫ﺍﳌﻨﺼﺎﺕ ﻭﻳﻮﻓﺮ ﻣﻴﺰﺓ ﺍﻧﺘﺎﺝ ﻣﻠﻔﺎﺕ ﺛﻨﺎﺋﻴﺔ ‪. object code‬‬

‫‪٣‬ﺭﺍﺟﻊ ﺍﳌﻠﺤﻖ ﺍ ﳌﻌﺮﻓﺔ ﻛﻴﻔﻴﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﺠﻤﻊ ﻟﺘﺮﲨﺔ ﺍﳌﺤﻤﻞ ﻭﻛﻴﻔﻴﺔ ﻧﺴﺨﻪ ﺍﱃ ‪ floppy disk or CD‬ﻟﻴﺘﻢ ﺍﻟﻘﻼﻉ ﻣﻨﻪ ﺳﻮﺍءﴽ ﻛﺎﻥ‬
‫ﻋﻠﻰ ﺟﻬﺎﺯ ﻓﻌﻠﻲ ﺃﻭ ﻋﻠﻰ ﺟﻬﺎﺯ ﲣﻴﻠﻲ )‪. (Virtual Machine‬‬

‫‪٣٦‬‬
‫‪ .٤.٣‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫‪Example‬‬ ‫‪٣.١: Smallest Bootloader‬‬

‫‪١‬‬
‫‪٢ ;Simple Bootloader do nothing.‬‬
‫‪٣‬‬
‫‪٤ bits 16‬‬ ‫‪; 16−bit real mode.‬‬
‫‪٥‬‬
‫‪٦ start:‬‬ ‫‪; label are pointer.‬‬
‫‪٧‬‬ ‫‪cli‬‬ ‫‪; clear interrupt.‬‬
‫‪٨‬‬ ‫‪hlt‬‬ ‫‪; halt the system.‬‬
‫‪٩‬‬
‫‪١٠‬‬ ‫) ‪times 510−($−$$‬‬ ‫‪db‬‬ ‫‪0‬‬ ‫‪; append zeros.‬‬
‫‪١١‬‬
‫‪١٢‬‬ ‫‪; $ is the address of first instruction (should be 0x07c00).‬‬
‫‪١٣‬‬ ‫‪; $$ is the address of current line.‬‬
‫‪١٤‬‬ ‫‪; $−$$ means how many byte between start and current.‬‬
‫‪١٥‬‬
‫‪١٦‬‬ ‫‪; if cli and hlt take 4 byte then time directive will fill‬‬
‫‪١٧‬‬ ‫‪; 510−4 = 506 zero's.‬‬
‫‪١٨‬‬
‫‪١٩‬‬ ‫‪; finally the boot signature 0xaa55‬‬
‫‪٢٠‬‬ ‫‪db‬‬ ‫‪0x55 ; first byte of a boot signature.‬‬
‫‪٢١‬‬ ‫‪db‬‬ ‫‪0xaa ; second byte of a boot signature.‬‬

‫ﻭﻋﻨﺪﻣﺎ ﻳﺒﺪﺃ ﺍﳉﻬﺎﺯ ﺑﺎﻟﻌﻤﻞ ﻓﺎﻥ ﺍﻟﺒﺎﻳﻮﺱ ﻳﻘﻮﻡ ﺑﻨﺴﺦ ﻫﺬﺍ ﺍﳌﺤﻤﻞ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x0000:0x7c00‬ﻭﻳﺒﺪﺃ‬
‫ﺑﺘﻨﻔﻴﺬﻩ ‪ ،‬ﻭﰲ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﻓﺎﻥ ﺍﳌﺤﻤﻞ ﻫﺬﺍ ﺍﻟﺬﻱ ﻳﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ )‪ (real mode‬ﻻ ﻳﻘﻮﻡ ﺑﺸﻲء ﺫﻭ‬
‫ﻓﺎﺋﺪﺓ ﺣﻴﺚ ﻳﺒﺪﺃ ﺑﺘﻨﻔﻴﺬ ﺍﻻﻣﺮ ‪ cli‬ﺍﻟﺬﻱ ﻳﻮﻗﻒ ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪ ،‬ﻳﻠﻴﻬﺎ ﺍﻻﻣﺮ ‪ hlt‬ﺍﻟﺬﻱ ﻳﻮﻗﻒ ﻋﻤﻞ ﺍﳌﻌﺎﰿ‬
‫ﻭﺑﺎﻟﺘﺎﱄ ﻳﺘﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ ‪ ،‬ﻭﺑﺪﻭﻥ ﻫﺬﺍ ﺍﻷﻣﺮ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﺳﻴﺴﺘﻤﺮ ﰲ ﺗﻨﻔﻴﺬ ﺃﻭﺍﻣﺮ ﻻ ﻣﻌﲎ ﳍﺎ )‪(garbage‬‬
‫ﻭﺍﻟﱵ ﺳﺘﺆﺩﻱ ﺍﱃ ﺳﻘﻮﻁ )‪ (Crash‬ﺍﻟﻨﻈﺎﻡ ‪ .‬ﻭﺑﺴﺒﺐ ﺃﻥ ﺣﺠﻢ ﺍﳌﺤﻤﻞ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ‪ 512‬ﺑﺎﻳﺖ ﻭﺃﻥ ﺁﺧﺮ‬
‫ﺑﺎﻳﺘﲔ ﻓﻴﻪ ﳚﺐ ﺃﻥ ﺗﻜﻮﻧﺎ ﺍﻟﺘﻮﻗﻴﻊ ﺍﳋﺎﺹ ﺑﺎﳌﺤﻤﻞ ﻓﺎﻧﻪ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﺃﻭﻝ ‪ 510‬ﺑﺎﻳﺖ ﺫﺍﺕ ﻗﻴﻤﺔ ﻭﺍﺧﺮ ﺑﺎﻳﺘﲔ‬
‫ﳘﺎ ‪ ، 0xaa55‬ﻟﺬﻟﻚ ﰎ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﻮﺟﻪ ‪ times‬ﻟﻜﻲ ﻳﺘﻢ ﻣﻠﺊ ﺍﳌﺘﺒﻘﻲ ﻣﻦ ﺃﻭﻝ ‪ 510‬ﺑﺎﻳﺖ ﺑﺎﻟﻘﻴﻤﺔ ﺻﻔﺮ‬
‫)ﻭﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺃﻱ ﻗﻴﻤﺔ ﺍﺧﺮﻯ( ﻭﺑﻌﺪ ﺫﻟﻚ ﰎ ﻛﺘﺎﺑﺔ ﺍﻟﺘﻮﻗﻴﻊ ﺍﳋﺎﺹ ﺑﺎﳌﺤﻤﻞ ﻭﺫﻟﻚ ﺣﱴ ﻳﺘﻢ ﺍﻟﺘﻌﺮﻑ ﻋﻠﻴﻪ‬
‫ﻣﻦ ﻗ‪‬ﺒﻞ ﺍﻟﺒﺎﻳﻮﺱ‪.‬‬

‫‪ .١.٤.٣‬ﻋﺮﺽ ﺭﺳﺎﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ‬

‫ﻃﺎﳌﺎ ﻣﺎ ﺯﻟﻨﺎ ﻧﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻓﺎﻥ ﺫﻟﻚ ﳝﻜﻨﻨﺎ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ‪ ،‬ﻭﰲ ﺍﳌﺜﺎﻝ ‪ ٣.٢‬ﰎ‬
‫ﻋﺮﺽ ﺭﺳﺎﻟﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪ int 0x10‬ﺍﻟﺪﺍﻟﺔ ‪. 0xe‬‬

‫‪٣٧‬‬
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

Example ٣.٢: Welcom to OS World

١
٢ ;Hello Bootloader
٣
٤ bits 16 ; 16−bit real mode.
٥ org 0x0 ; this number will added to all addresses (relocating).
٦
٧ start:
٨ jmp main ; jump over data and function to entry point.
٩
١٠
١١
١٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٣ ; data
١٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٥
١٦ hello msg db "Welcome to eqraOS, Coded by Ahmad Essam",0xa,0xd,0
١٧
١٨ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٩ ; puts16: prints string using BIOS interrupt
٢٠ ; input:
٢١ ; es: pointer to data segment.
٢٢ ; si: point to the string
٢٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٤
٢٥ puts16:
٢٦
٢٧ lodsb ; read character from ds:si to al ,and increment si if
df=0.
٢٨
٢٩ cmp al,0 ; check end of string ?
٣٠ je end puts16 ; yes jump to end.
٣١
٣٢ mov ah,0xe ; print character routine number.
٣٣ int 0x10 ; call BIOS.
٣٤
٣٥ jmp puts16 ; continue prints until 0 is found.
٣٦
٣٧ end puts16:
٣٨

٣٨
‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤.٣

٣٩ ret
٤٠
٤١
٤٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٣ ; entry point of bootloader.
٤٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٥
٤٦ main:
٤٧
٤٨ ;−−−−−−−−−−−−−−−−−−−−−
٤٩ ; intit registers
٥٠ ;−−−−−−−−−−−−−−−−−−−−−
٥١
٥٢ ; because bootloader are loaded at 0x07c00 we can refrence this
location with many different combination of segment:offset
addressing.
٥٣
٥٤ ; So we will use either 0x0000:0x7c000 or 0x:07c0:0x0000 , and in
this example we use 0x07c0 for segment and 0x0 for offset.
٥٥
٥٦ mov ax,0x07c0
٥٧ mov ds,ax
٥٨ mov es,ax
٥٩
٦٠ mov si,hello msg
٦١ call puts16
٦٢
٦٣ cli ; clear interrupt.
٦٤ hlt ; halt the system.
٦٥
٦٦ times 510−($−$$ ) db 0 ; append zeros.
٦٧
٦٨ ; finally the boot signature 0xaa55
٦٩ db 0x55
٧٠ db 0xaa

data segment ‫ ﻭﻣﻘﻄﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ‬code segment ‫ﺍﻟﺸﻲء ﺍﳌﻼﺣﻆ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻫﻮ ﺃﻥ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ‬
‫ ﺑﺎﻳﺖ( ﻟﺬﻟﻚ ﳚﺐ ﺗﻌﺪﻳﻞ ﻗﻴﻢ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ‬512 ‫ﻣﺘﻮﺍﺟﺪﺍﻥ ﰲ ﻧﻔﺲ ﺍﳌﻜﺎﻥ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ )ﺩﺍﺧﻞ ﺍﻝ‬
‫ ﻭ ﺑﺪﺍﻳﺔ ﻧﺬﻛﺮ ﺃﻥ ﺍﻟﺒﺎﻳﻮﺱ ﻋﻨﺪﻣﺎ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺑﺮﻧﺎﻣﺞ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺬﻱ ﻗﻤﻨﺎ‬.‫ﻟﻼﺷﺎﺭﺓ ﺍﱃ ﺍﳌﻜﺎﻥ ﺍﻟﺼﺤﻴﺢ‬
‫ ﻟﺬﻟﻚ ﻻ ﺩﺍﻋﻲ‬cs:ip ‫ ﻭﺍﻟﱵ ﻳﻨﺘﺞ ﻣﻨﻬﺎ ﺗﺼﺤﻴﺢ ﻗﻴﻢ ﺍﻝ‬far jump ‫ﺑﻜﺘﺎﺑﺘﻪ ﻓﺎﻧﻪ ﰲ ﺣﻘﻴﻘﺔ ﺍﻷﻣﺮ ﻳﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ‬

٣٩
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﻟﻠﻘﻠﻖ ﺣﻮﻝ ﻫﺬﻳﻦ ﺍﳌﺴﺠﻠﲔ‪ ،‬ﻟﻜﻦ ﳚﺐ ﺗﻌﺪﻳﻞ ﻗﻴﻢ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﺍﻻﺧﺮﻯ ﻣﺜﻞ ‪.ds,es,ss,fs,gs‬‬
‫ﻭﻛﻤﺎ ﻧﻌﻠﻢ ﺃﻥ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ﳌﺤﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻫﻮ ‪ 0x07c00‬ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﺍﻟﻴﻪ ﺑﺄﻛﺜﺮ ﻣﻦ ‪ 4000‬ﻃﺮﻳﻘﺔ‬
‫ﳐﺘﻠﻔﺔ ‪ ،‬ﻟﻜﻦ ﺳﻮﻑ ﻧﻘﺘﺼﺮ ﻋﻠﻰ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x07c0:0x0‬ﺃﻭ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x0:0x7c00‬ﻧﻈﺮﴽ ﻻﻥ‬
‫ﻫﺬﻩ ﻫﻲ ﺍﻟﻘﻴﻢ ﺍﻟﻔﻌﻠﻴﺔ ﺍﻟﱵ ﺗﺴﺘﺨﺪﻣﻬﺎ ﺍﻟﺒﺎﻳﻮﺱ‪.‬‬
‫ﻭﰲ ﺣﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻌﻨﻮﻧﺔ ﺍﻻﻭﱃ ﻓﺎﻥ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﳚﺐ ﺃﻥ ﲢﻮﻱ ﺍﻟﻘﻴﻤﺔ ‪) 0x07c0‬ﻛﻤﺎ ﰲ ﺍﳌﺜﺎﻝ‬
‫ﺍﻋﻼﻩ( ﺃﻣﺎ ﺑﻘﻴﺔ ﺍﻟﻌﻨﻮﺍﻧﲔ )ﺳﻮﺍءﺍ ﻟﻠﻤﺘﻐﲑﺍﺕ ﻭﺍﻝ ‪ (label‬ﻓﺎ‪‬ﺎ ﳚﺐ ﺃﻥ ﺗﺒﺪﺃ ﻣﻦ ﺍﻟﻘﻴﻤﺔ ‪ ،0x0‬ﻭﻛﻤﺎ ﻫﻮ ﻣﻌﺮﻭﻑ‬
‫ﺍﻥ ﺍﳌﺠﻤﻌﺎﺕ ﻋﻨﺪﻣﺎ ﺗﺒﺪﺃ ﰲ ﻋﻤﻠﻴﺔ ﺗﺮﲨﺔ ﺍﳌﻠﻒ ﺍﱃ ﻣﻠﻒ ﺛﻨﺎﺋﻲ ﻓﺎ‪‬ﺎ ﺗﺒﺪﺃ ﺑﺘﺮﻗﻴﻢ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺑﺪءﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪0x0‬‬
‫ﻟﺬﻟﻚ ﻛﺎﻧﺖ ﻭﻇﻴﻔﺔ ﺍﳌﻮﺟﻪ ‪ org‬ﻫﻲ ﻋﻤﻞ ﺍﻋﺎﺩﺓ ﺗﻌﻴﲔ )‪ (reloca ng‬ﻟﻠﻌﻨﺎﻭﻳﻦ ﺑﺎﻟﻘﻴﻤﺔ ﺍﻟﱵ ﰎ ﻛﺘﺎﺑﺘﻬﺎ ‪ ،‬ﻭﰲ‬
‫ﺍﳌﺜﺎﻝ ﺃﻋﻼﻩ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﻫﻲ ‪ ، 0x0‬ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﻣﻜﺎﻥ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬
‫ﻓﺎﻥ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﳚﺐ ﺃﻥ ﲢﻮﻱ ﺍﻟﻘﻴﻤﺔ ‪ 0x0‬ﺑﻴﻨﻤﺎ ﺍﳌﺴﺠﻼﺕ ﺍﻻﺧﺮﻯ ﳚﺐ ﺃﻥ ﺗﺒﺪﺃ ﻗﻴﻤﻬﺎ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ‬
‫‪ ، 0x7c00‬ﻭﻫﺬﺍ ﻻ ﳝﻜﻦ ﺑﺎﻟﻮﺿﻊ ﺍﻟﻄﺒﻴﻌﻲ ﻻﻥ ﺍﳌﺠﻤﻌﺎﺕ ﺳﺘﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x0‬ﻟﺬﻟﻚ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ‬
‫ﺍﳌﻮﺟﻪ ‪ org‬ﻭﲢﺪﻳﺪ ﻗﻴﻤﺔ ﺍﻝ ‪ relocate‬ﺑﺎﻟﻘﻴﻤﺔ ‪. 0x7c00‬‬

‫‪ .٢.٤.٣‬ﻣﻌﻠﻮﻣﺎﺕ ﻗﻄﺎﻉ ﺍﻻﻗﻼﻉ‬

‫ﺇﺿﺎﻓﺔ ﺍﱃ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻓﺎﻥ ﻗﻄﺎﻉ ﺍﻹﻗﻼﻉ ‪ boot sector‬ﳚﺐ ﺃﻥ ﳛﻮﻱ ﻛﺬﻟﻚ ﻋﻠﻰ ﻣﻌﻠﻮﻣﺎﺕ ﺗﺴﺎﻋﺪ ﰲ‬
‫ﻭﺻﻒ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ ﻭﻭﺻﻒ ﺍﻟﻘﺮﺹ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﺍﻻﻗﻼﻉ ﻣﻨﻪ ‪ ،‬ﻫﺬﻩ ﺍﳌﻌﻠﻮﻣﺎﺕ ﲢﻮﻱ ﻣﻌﺮﻑ ‪OEM‬‬
‫ﻭﲢﻮﻱ ﺑﻴﺎﻧﺎﺕ ‪) BIOS Parameter Block‬ﲣﺘﺼﺮ ﺏ ‪ (BPB‬ﻭﳚﺐ ﺃﻥ ﺗﺒﺪﺃ ﻛﻞ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻣﻦ ﺍﻟﺒﺎﻳﺖ ﺭﻗﻢ‬
‫‪ .٤ 3‬ﻭﺳﻮﻑ ﻳﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﻜﺜﺮﺓ ﺃﺛﻨﺎء ﺗﻄﻮﻳﺮ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻛﺬﻟﻚ ﺃﺣﺪ ﻓﻮﺍﺋﺪ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻫﻮ‬
‫ﺗﻌﺮﻑ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻋﻠﻰ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﺍﻟﻘﺮﺹ‪.‬‬
‫‪Example‬‬ ‫‪٣.٣: Bios Parameter Block‬‬
‫‪١‬‬
‫‪٢ OEM ID‬‬ ‫‪db‬‬ ‫‪"eqraOS‬‬ ‫"‬ ‫‪; Name of your OS, Must‬‬
‫‪be 8 byte! no more no less.‬‬
‫‪٣‬‬
‫‪٤ bytes per sector‬‬ ‫‪dw‬‬ ‫‪0x200‬‬ ‫‪; 512 byte per sector.‬‬
‫‪٥ sectors per cluster‬‬ ‫‪db‬‬ ‫‪0x1‬‬ ‫‪; 1 sector per cluster.‬‬
‫‪٦ reserved sectors‬‬ ‫‪dw‬‬ ‫‪0x1‬‬ ‫‪; boot sector is‬‬
‫‪reserved.‬‬
‫‪٧ total fats‬‬ ‫‪db‬‬ ‫‪0x2‬‬ ‫‪; two fats.‬‬
‫‪٨ root directory‬‬ ‫‪dw‬‬ ‫‪0xe0‬‬ ‫‪; root dir has 224‬‬
‫‪entries.‬‬
‫‪٩ total sectors‬‬ ‫‪dw‬‬ ‫‪0xb40‬‬ ‫‪; 2880 sectors in the‬‬
‫‪volume.‬‬

‫‪٤‬ﳍﺬﺍ ﺍﻟﺴﺒﺐ ﻓﺎﻥ ﺃﻭﻝ ﺗﻌﻠﻴﻤﺔ ﰲ ﺍﳌﺤﻤﻞ ﺳﺘﻜﻮﻥ ﺗﻌﻠﻴﻤﺔ ﺍﻟﻘﻔﺰ ﺍﱃ ﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﻨﻔﻴﺬﻳﺔ‪ ،‬ﻭﺑﺪﻭﻥ ﺍﻟﻘﻔﺰ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﺳﻴﺒﺪﺃ ﺑﺘﻨﻔﻴﺬ ﻫﺬﻩ‬
‫ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﺎﻋﺘﺒﺎﺭ ﺍ‪‬ﺎ ﺗﻌﻠﻴﻤﺎﺕ ﻭﻫﺬﺍ ﻣﺎ ﻳﺆﺩﻱ ﰲ ﺍﻻﺧﺮ ﺍﱃ ﺳﻘﻮﻁ ﺍﻟﻨﻈﺎﻡ‪.‬‬

‫‪٤٠‬‬
‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤.٣

١٠ media descriptor db 0xf0 ; 1.44 floppy disk.

١١ sectors per fat dw 0x9 ; 9 sector per fat.
١٢ sectors per track dw 0x12 ; 18 sector per track.
١٣ number of heads dw 0x2 ; 2 heads per platter.
١٤ hidden sectors dd 0x0 ; no hidden sector.
١٥ total sectors large dd 0x0
١٦
١٧ ; Extended BPB.
١٨
١٩ drive number db 0x0
٢٠ flags db 0x0
٢١ signature db 0x29 ; must be 0x28 or 0x29.
٢٢ volume id dd 0x0 ; serial number written
when foramt the disk.
٢٣ volume label db "MOS FLOPPY " ; 11 byte.
٢٤ system id db "fat12 " ; 8 byte.

.OEM and BPB ‫ ﻳﻮﺿﺢ ﺷﻔﺮﺓ ﺍﳌﺤﻤﻞ ﺑﻌﺪ ﺍﺿﺎﻓﺔ ﺑﻴﺎﻧﺎﺕ‬٣.٤ ‫ﺍﳌﺜﺎﻝ‬
Example ٣.٤: BPB example
١
٢ ;Hello Bootloader
٣
٤ bits 16 ; 16−bit real mode.
٥ org 0x0 ; this number will added to all addresses (relocating).
٦
٧ start:
٨ jmp main ; jump over data and function to entry point.
٩
١٠
١١ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٢ ; OEM Id and BIOS Parameter Block (BPB)
١٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٤
١٥ ; must begin at byte 3(4th byte), if not we should add nop
instruction.
١٦
١٧ OEM ID db "eqraOS " ; Name of your OS, Must
be 8 byte! no more no less.
١٨

٤١
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

١٩ bytes per sector dw 0x200 ; 512 byte per sector.

٢٠ sectors per cluster db 0x1 ; 1 sector per cluster.
٢١ reserved sectors dw 0x1 ; boot sector is
reserved.
٢٢ total fats db 0x2 ; two fats.
٢٣ root directory dw 0xe0 ; root dir has 224
entries.
٢٤ total sectors dw 0xb40 ; 2880 sectors in the
volume.
٢٥ media descriptor db 0xf0 ; 1.44 floppy disk.
٢٦ sectors per fat dw 0x9 ; 9 sector per fat.
٢٧ sectors per track dw 0x12 ; 18 sector per track.
٢٨ number of heads dw 0x2 ; 2 heads per platter.
٢٩ hidden sectors dd 0x0 ; no hidden sector.
٣٠ total sectors large dd 0x0
٣١
٣٢ ; Extended BPB.
٣٣
٣٤ drive number db 0x0
٣٥ flags db 0x0
٣٦ signature db 0x29 ; must be 0x28 or 0x29.
٣٧ volume id dd 0x0 ; serial number written
when foramt the disk.
٣٨ volume label db "MOS FLOPPY " ; 11 byte.
٣٩ system id db "fat12 " ; 8 byte.
٤٠
٤١
٤٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٣ ; data
٤٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٥
٤٦ hello msg db "Welcome to eqraOS, Coded by Ahmad Essam",0xa,0xd,0
٤٧
٤٨ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٩ ; puts16: prints string using BIOS interrupt
٥٠ ; input:
٥١ ; es: pointer to data segment.
٥٢ ; si: point to the string
٥٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٥٤
٥٥ puts16:

٤٢
‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤.٣

٥٦
٥٧ lodsb ; read character from ds:si to al ,and increment si if
df=0.
٥٨
٥٩ cmp al,0 ; check end of string ?
٦٠ je end puts16 ; yes jump to end.
٦١
٦٢ mov ah,0xe ; print character routine number.
٦٣ int 0x10 ; call BIOS.
٦٤
٦٥ jmp puts16 ; continue prints until 0 is found.
٦٦
٦٧ end puts16:
٦٨
٦٩ ret
٧٠
٧١
٧٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٧٣ ; entry point of bootloader.
٧٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٧٥
٧٦ main:
٧٧
٧٨ ;−−−−−−−−−−−−−−−−−−−−−
٧٩ ; intit registers
٨٠ ;−−−−−−−−−−−−−−−−−−−−−
٨١
٨٢ ; because bootloader are loaded at 0x07c00 we can refrence this
location with many different combination
٨٣ ; of segment:offset addressing.
٨٤
٨٥ ; So we will use either 0x0000:0x7c000 or 0x07c0:0x0000
٨٦ ; and in this example we use 0x07c0 for segment and 0x0 for
offset.
٨٧
٨٨ mov ax,0x07c0
٨٩ mov ds,ax
٩٠ mov es,ax
٩١
٩٢ mov si,hello msg
٩٣ call puts16

٤٣
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

٩٤
٩٥ cli ; clear interrupt.
٩٦ hlt ; halt the system.
٩٧
٩٨ times 510−($−$$ ) db 0 ; append zeros.
٩٩
١٠٠ ; finally the boot signature 0xaa55
١٠١ db 0x55
١٠٢ db 0xaa

‫ ﺣﻴﺚ ﻛﻤﺎ ﻧﻼﺣﻆ‬Hex Editor ‫ ﻳﻮﺿﺢ ﺍﻟﺸﻔﺮﺓ ﺍﻟﺴﺎﺑﻘﺔ ﰲ ﺣﺎﻟﺔ ﻋﺮﺿﻬﺎ ﺑﺄﻱ ﳏﺮﺭ ﺳﺎﺩﺱ ﻋﺸﺮ‬٣.٥ ‫ﻭ ﺍﳌﺨﺮﺝ‬
‫ﺃﻥ ﺑﻴﺎﻧﺎﺕ ﺍﳌﺤﻤﻞ ﻣﺘﺪﺍﺧﻠﺔ ﻣﻊ ﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﻨﻔﻴﺬﻳﺔ )ﺗﻌﻠﻴﻤﺎﺕ ﺍﳌﻌﺎﰿ( ﻟﺬﻟﻚ ﳚﺐ ﺃﻥ ﻳﺘﻢ ﺍﻟﻘﻔﺰ ﻓﻮﻕ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
.‫ﺎ ﲢﻤﻞ ﺍﻟﺘﻮﻗﻴﻊ ﺍﻟﺼﺤﻴﺢ‬‫ ﻛﺬﻟﻚ ﳚﺐ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺁﺧﺮ ﺑﺎﻳﺘﲔ ﻭﺃ‬، ‫ﻔﺬ ﻛﺘﻌﻠﻴﻤﺎﺕ ﺧﺎﻃﺌﺔ‬‫ﻨ‬‫ﺣﱴ ﻻ ﺗ‬
Example ٣.٥: Hex value of bootloader

O f f s e t ( h ) 00 01 02 03 04 05 06 07

00000000 E9 72 00
65 71 72 61 4F é r . eqraO
00000008 53 20 20
00 02 01 01 00 S .....
00000010 02 E0 00
40 0B F0 09 00 . à .@đ . . .
00000018 12 00 02
00 00 00 00 00 ........
00000020 00 00 00
00 00 00 29 00 ......).
00000028 00 00 00
4D 4F 53 20 46 . . . MOS F
00000030 4C 4F 50
50 59 20 66 61 LOPPY f a
00000038 74 31 32
20 20 20 57 65 t12 We
00000040 6C 63 6F
6D 65 20 74 6F lcome t o
00000048 20 65 71
72 61 4F 53 2C eqraOS ,
00000050 20 43 6F
64 65 64 20 62 Coded b
00000058 79 20 41
68 6D 61 64 20 y Ahmad
00000060 45 73 73
61 6D 0A 0D 00 Essam . . .
00000068 AC 3C 00
74 07 B4 0E CD ¬ <. t . ´ . Í
00000070 10 E9 F4
FF C3 B8 C0 07 . Ăéôÿ¸À .
00000078 8E D8 8E
C0 BE 3E 00 E8 .Ø.À¾>.è
00000080 E6 FF FA
F4 00 00 00 00 æÿúô . . . .
00000088 00 00 00
00 00 00 00 00 ........
...
...
000001F0 00 00 00 00 00 00 00 00 ........

٤٤
‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤.٣

000001F8 00 00 00 00 00 00 55 AA . . . . . . Uª

‫ ﻓﻤﺜﻼ ﳝﻜﻦ ﺣﺬﻑ‬،٥ ‫ﻭﳝﻜﻦ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻫﺬﻩ ﺍﳌﺤﺮﺭﺍﺕ ﻭﺍﻟﺘﻌﺪﻳﻞ ﺍﳌﺒﺎﺷﺮ ﰲ ﻗﻴﻢ ﺍﳍﻴﻜﺲ ﻟﻠﻤﻠﻒ ﺍﻟﺜﻨﺎﺋﻲ‬
‫ﺍﻟﺘﻮﻗﻴﻊ ﻭﺍﺳﺘﺒﺪﺍﻟﻪ ﺑﺄﻱ ﺭﻗﻢ ﻭﳏﺎﻭﻟﺔ ﺍﻹﻗﻼﻉ ﻣﻦ ﺍﻟﻘﺮﺹ ! ﺑﺎﻟﺘﺄﻛﻴﺪ ﻻ ﳝﻜﻦ ﺍﻻﻗﻼﻉ ﺑﺴﺒﺐ ﺃﻥ ﺍﻟﺒﺎﻳﻮﺱ ﻟﻦ‬
‫ﺎﺋﻴﺔ ﻭﻃﺒﺎﻋﺔ ﺍﳉﻤﻠﺔ ﺍﻟﺘﺮﺣﻴﺒﺔ‬ ‫ ﻛﺬﻟﻚ ﻛﻤﺜﺎﻝ ﳝﻜﻦ ﻋﻤﻞ ﺣﻠﻘﺔ ﻻ‬، ‫ﻳﺘﻌﺮﻑ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﺑﺄﻧﻪ ﻗﺎﺑﻞ ﻟﻺﻗﻼﻉ‬
‫ ﻭﺇﺩﺧﺎﻝ‬Disassembler ‫ ﻭﳚﺐ ﺃﻭﻻ ﺍﻋﺎﺩﺓ ﲡﻤﻴﻊ ﺍﳌﻠﻒ ﺍﻟﺜﻨﺎﺋﻲ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺃﻱ ﻣﻦ ﺑﺮﺍﻣﺞ ﺍﻝ‬، ‫ﰲ ﻛﻞ ﺗﻜﺮﺍﺭ‬
.‫ﺗﻌﻠﻴﻤﺔ ﻗﻔﺰ ﺑﻌﺪ ﺍﺳﺘﺪﻋﺎء ﺩﺍﻟﺔ ﻃﺒﺎﻋﺔ ﺍﻟﺴﻠﺴﻠﺔ ﺍﱃ ﻣﺎ ﻗﺒﻠﻬﺎ‬

Example ٣.٦: Complete Example

١ ;Hello Bootloader
٢
٣ bits 16 ; 16−bit real mode.
٤ org 0x0 ; this number will added to all addresses (relocating).
٥
٦ start:
٧ jmp main ; jump over data and function to entry point.
٨
٩
١٠ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١١ ; OEM Id and BIOS Parameter Block (BPB)
١٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٣
١٤ ; must begin at byte 3(4th byte), if not we should add nop
instruction.
١٥
١٦ OEM ID db "eqraOS " ; Name of your OS, Must
be 8 byte! no more no less.
١٧
١٨ bytes per sector dw 0x200 ; 512 byte per sector.
١٩ sectors per cluster db 0x1 ; 1 sector per cluster.
٢٠ reserved sectors dw 0x1 ; boot sector is
reserved.
٢١ total fats db 0x2 ; two fats.
٢٢ root directory dw 0xe0 ; root dir has 224
entries.
٢٣ total sectors dw 0xb40 ; 2880 sectors in the
volume.
٢٤ media descriptor db 0xf0 ; 1.44 floppy disk.

.source code ‫ﰲ ﺣﺎﻟﺔ ﱂ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﻣﻠﻒ ﺍﳌﺼﺪﺭ‬٥

٤٥
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

٢٥ sectors per fat dw 0x9 ; 9 sector per fat.

٢٦ sectors per track dw 0x12 ; 18 sector per track.
٢٧ number of heads dw 0x2 ; 2 heads per platter.
٢٨ hidden sectors dd 0x0 ; no hidden sector.
٢٩ total sectors large dd 0x0
٣٠
٣١ ; Extended BPB.
٣٢
٣٣ drive number db 0x0
٣٤ flags db 0x0
٣٥ signature db 0x29 ; must be 0x28 or 0x29.
٣٦ volume id dd 0x0 ; serial number written
when foramt the disk.
٣٧ volume label db "MOS FLOPPY " ; 11 byte.
٣٨ system id db "fat12 " ; 8 byte.
٣٩
٤٠
٤١ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٢ ; data
٤٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٤
٤٥ hello msg db "Welcome to eqraOS, Coded by Ahmad Essam",0xa,0xd,0
٤٦
٤٧ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤٨ ; puts16: prints string using BIOS interrupt
٤٩ ; input:
٥٠ ; es: pointer to data segment.
٥١ ; si: point to the string
٥٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٥٣
٥٤ puts16:
٥٥
٥٦ lodsb ; read character from ds:si to al ,and increment si if
df=0.
٥٧
٥٨ cmp al,0 ; check end of string ?
٥٩ je end puts16 ; yes jump to end.
٦٠
٦١ mov ah,0xe ; print character routine number.
٦٢ int 0x10 ; call BIOS.
٦٣

٤٦
 ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤.٣

٦٤ jmp puts16 ; continue prints until 0 is found.

٦٥
٦٦ end puts16:
٦٧
٦٨ ret
٦٩
٧٠
٧١ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٧٢ ; entry point of bootloader.
٧٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٧٤
٧٥ main:
٧٦
٧٧ ;−−−−−−−−−−−−−−−−−−−−−
٧٨ ; intit registers
٧٩ ;−−−−−−−−−−−−−−−−−−−−−
٨٠
٨١ ; because bootloader are loaded at 0x07c00 we can refrence this
location with many different combination
٨٢ ; of segment:offset addressing.
٨٣
٨٤ ; So we will use either 0x0000:0x7c000 or 0x07c0:0x0000
٨٥ ; and in this example we use 0x07c0 for segment and 0x0 for
offset.
٨٦
٨٧ mov ax,0x07c0
٨٨ mov ds,ax
٨٩ mov es,ax
٩٠
٩١ mov si,hello msg
٩٢ call puts16
٩٣
٩٤ cli ; clear interrupt.
٩٥ hlt ; halt the system.
٩٦
٩٧ times 510−($−$$ ) db 0 ; append zeros.
٩٨
٩٩ ; finally the boot signature 0xaa55
١٠٠ db 0x55
١٠١ db 0xaa

٤٧
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫‪int 0x13‬‬ ‫‪ .٣.٤.٣‬ﲢﻤﻴﻞ ﻗﻄﺎﻉ ﻣﻦ ﺍﻟﻘﺮﺹ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﻘﺎﻃﻌﺔ‬

‫ﺑﻌﺪ ﺃﻥ ﰎ ﺗﺸﻐﻴﻞ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻟﻌﺮﺽ ﺭﺳﺎﻟﺔ ﺗﺮﺣﻴﺒﺔ ‪ ،‬ﻓﺎﻥ ﻣﻬﻤﺔ ﺍﳌﺤﻤﻞ ﺍﻟﻔﻌﻠﻴﺔ ﻫﻲ ﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﺍﳌﺮﺣﻠﺔ‬
‫ﺍﻟﺜﺎﻧﻴﺔ ﻟﻪ ﺣﻴﺚ ﻛﻤﺎ ﺫﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ ﺃﻥ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺳﺘﻜﻮﻥ ﻋﻠﻰ ﻣﺮﺣﻠﺘﲔ ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺍﻟﻘﻴﻮﺩ ﻋﻠﻰ ﺣﺠﻢ‬
‫ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ ‪ ،‬ﻭﺗﻜﻤﻦ ﻭﻇﻴﻔﺔ ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ ﰲ ﺍﻟﺒﺤﺚ ﻋﻦ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ‬
‫‪ ،‬ﻭﺑﻌﺪﻫﺎ ﻳﺄﰐ ﺩﻭﺭ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﰲ ﺍﻟﺒﺤﺚ ﻋﻦ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻭﻧﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﻟﻴﻬﺎ‪ .‬ﻭﺳﻨﺘﻨﺎﻭﻝ ﺍﻻﻥ ﻛﻴﻔﻴﺔ ﲢﻤﻴﻞ‬
‫ﻣﻘﻄﻊ ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﻧﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﻟﻴﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪. int 0x13‬‬

‫ﺇﻋﺎﺩﺓ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‬

‫ﻋﻨﺪ ﺗﻜﺮﺍﺭ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻓﺎﻧﻪ ﳚﺐ ﰲ ﻛﻞ ﻣﺮﺓ ﺃﻥ ﻧﻌﻴﺪ ﻣﻜﺎﻥ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﺍﱃ ﺃﻭﻝ ﻣﻘﻄﻊ ‪sector‬‬
‫ﰲ ﺍﻟﻘﺮﺹ ﻭﺫﻟﻚ ﻟﻜﻲ ﻧﻀﻤﻦ ﻋﺪﻡ ﺣﺪﻭﺙ ﻣﺸﺎﻛﻞ‪ ،‬ﻭﺗﺴﺘﺨﺪﻡ ﺍﻟﺪﺍﻟﺔ ‪ 0x0‬ﻣﻦ ﺍﳌﻘﺎﻃﻌﺔ ‪ int 0x13‬ﳍﺬﺍ‬
‫ﺍﻟﻐﺮﺽ‪.‬‬
‫ﺍﳌﺪﺧﻼﺕ ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪.0x0 : ah‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ : dl‬ﺭﻗﻢ ﳏﺮﻙ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻭﻫﻮ ‪.0x0‬‬ ‫•‬

‫ﺍﻟﻨﺘﻴﺠﺔ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪ : ah‬ﺍﳊﺎﻟﺔ‪.‬‬ ‫•‬

‫‪ 0x1 : CF‬ﺍﺫﺍ ﺣﺪﺙ ﺧﻄﺄ ‪ 0x0 ،‬ﺍﺫﺍ ﲤﺖ ﺍﻟﻌﻤﻠﻴﺔ ﺑﻨﺠﺎﺡ‪.‬‬ ‫•‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪Example‬‬ ‫‪٣.٧: Reset Floppy Drive‬‬
‫‪١ reset floppy:‬‬
‫‪٢‬‬
‫‪٣‬‬ ‫‪mov ah,0x0‬‬ ‫‪; reset floppy routine number.‬‬
‫‪٤‬‬ ‫‪mov dl,0x0‬‬ ‫‪; drive number‬‬
‫‪٥‬‬
‫‪٦‬‬ ‫‪int 0x13‬‬ ‫‪; call BIOS‬‬
‫‪٧‬‬
‫‪٨‬‬ ‫‪jc reset floppy‬‬ ‫‪; try again if error occur.‬‬

‫‪٤٨‬‬
‫‪ .٤.٣‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫‪sectors‬‬ ‫ﻗﺮﺍءﺓ ﺍﳌﻘﺎﻃﻊ‬

‫ﻟﻘﺮﺍءﺓ ﺍﳌﻘﺎﻃﻊ‬ ‫‪0x2‬‬ ‫ﺍﻟﺪﺍﻟﺔ‬ ‫‪int 0x13‬‬ ‫ﺃﺛﻨﺎء ﺍﻟﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻓﺎﻧﻨﺎ ﺳﻨﺴﺘﺨﺪﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ‬
‫)‪ (sectors‬ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ‪. RAM‬‬
‫ﺍﳌﺪﺧﻼﺕ ‪:‬‬
‫• ﺍﳌﺴﺠﻞ ‪ :ah‬ﺍﻟﺪﺍﻟﺔ ‪0x2‬‬

‫• ﺍﳌﺴﺠﻞ ‪ :al‬ﻋﺪﺩ ﺍﳌﻘﺎﻃﻊ ﺍﻟﱵ ﳚﺐ ﻗﺮﺍﺋﺘﻬﺎ‪.‬‬

‫ﺍﳌﺴﺠﻞ ‪ :ch‬ﺭﻗﻢ ﺍﻻﺳﻄﻮﺍﻧﺔ )‪ ، (Cylinder‬ﺑﺎﻳﺖ ﻭﺍﺣﺪ‪.‬‬ ‫•‬

‫‪hard‬‬ ‫ﺍﳌﺴﺠﻞ ‪ :cl‬ﺭﻗﻢ ﺍﳌﻘﻄﻊ ‪ ،‬ﻣﻦ ﺍﻟﺒﺖ ‪ ، 5 - 0‬ﺃﻣﺎ ﺍﺧﺮ ﺑﺘﲔ ﻳﺴﺘﺨﺪﻣﺎﻥ ﻣﻊ ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ‬ ‫•‬
‫‪.disk‬‬
‫ﺍﳌﺴﺠﻞ ‪ :dh‬ﺭﻗﻢ ﺍﻟﺮﺃﺱ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ : dl‬ﺭﻗﻢ ﳏﺮﻙ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻭﻫﻮ ‪.0x0‬‬ ‫•‬

‫ﺍﻟﻌﻨﻮﺍﻥ ‪ : es:bx‬ﻣﺆﺷﺮ ﺍﱃ ﺍﳌﺴﺎﺣﺔ ﺍﻟﱵ ﺳﻴﺘﻢ ﻗﺮﺍءﺓ ﺍﳌﻘﺎﻃﻊ ﺍﻟﻴﻬﺎ‪.‬‬ ‫•‬

‫ﺍﻟﻨﺘﻴﺠﺔ‪:‬‬
‫• ﺍﳌﺴﺠﻞ ‪ : ah‬ﺍﳊﺎﻟﺔ‪.‬‬
‫• ﺍﳌﺴﺠﻞ ‪ :al‬ﻋﺪﺩ ﺍﳌﻘﺎﻃﻊ ﺍﻟﱵ ﰎ ﻗﺮﺍﺋﺘﻬﺎ‪.‬‬
‫‪ 0x1 : CF‬ﺍﺫﺍ ﺣﺪﺙ ﺧﻄﺄ ‪ 0x0 ،‬ﺍﺫﺍ ﲤﺖ ﺍﻟﻌﻤﻠﻴﺔ ﺑﻨﺠﺎﺡ‪.‬‬ ‫•‬

‫ﻣﺜﺎﻝ‪:‬‬

‫‪Example‬‬ ‫‪٣.٨: Read Floppy Disk Sectors‬‬

‫‪١‬‬
‫‪٢ read sectors:‬‬
‫‪٣‬‬
‫‪٤‬‬ ‫‪reset floppy:‬‬
‫‪٥‬‬
‫‪٦‬‬ ‫‪mov ah,0x0‬‬ ‫‪; reset floppy routine number.‬‬
‫‪٧‬‬ ‫‪mov dl,0x0‬‬ ‫‪; drive number‬‬
‫‪٨‬‬
‫‪٩‬‬ ‫‪int 0x13‬‬ ‫‪; call BIOS‬‬
‫‪١٠‬‬
‫‪١١‬‬ ‫‪jc reset floppy‬‬ ‫‪; try again if error occur.‬‬

‫‪٤٩‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫‪١٢‬‬
‫‪١٣‬‬ ‫‪; init buffer.‬‬
‫‪١٤‬‬ ‫‪mov ax,0x1000‬‬
‫‪١٥‬‬ ‫‪mov es,ax‬‬
‫‪١٦‬‬ ‫‪xor bx,bx‬‬
‫‪١٧‬‬
‫‪١٨‬‬ ‫‪read:‬‬
‫‪١٩‬‬
‫‪٢٠‬‬ ‫‪mov‬‬ ‫‪ah,0x2‬‬ ‫‪; routine number.‬‬
‫‪٢١‬‬ ‫‪mov‬‬ ‫‪al,1‬‬ ‫?‪; how many sectors‬‬
‫‪٢٢‬‬ ‫‪mov‬‬ ‫‪ch,1‬‬ ‫‪; cylinder or track number.‬‬
‫‪٢٣‬‬ ‫‪mov‬‬ ‫‪cl,2‬‬ ‫‪; sector number "fisrt sector is 1 not 0",now we read‬‬
‫‪the second sector.‬‬
‫‪٢٤‬‬ ‫‪mov dh,0‬‬ ‫‪; head number "starting with 0".‬‬
‫‪٢٥‬‬ ‫‪mov dl,0‬‬ ‫‪; drive number ,floppy drive always zero.‬‬
‫‪٢٦‬‬
‫‪٢٧‬‬ ‫‪int 0x13‬‬ ‫‪; call BIOS.‬‬
‫‪٢٨‬‬ ‫‪jc read‬‬ ‫‪; if error, try again.‬‬
‫‪٢٩‬‬
‫‪٣٠‬‬ ‫‪jmp 0x1000:0x0‬‬ ‫‪; jump to execute the second sector.‬‬

‫‪FAT12‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬

‫ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻫﻮ ﺑﺮﻧﺎﻣﺞ ﻳﺴﺎﻋﺪ ﰲ ﺣﻔﻆ ﺍﳌﻠﻔﺎﺕ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﲝﻴﺚ ﻳﻨﺸﺊ ﻟﻨﺎ ﻣﻔﻬﻮﻡ ﺍﳌﻠﻒ ﻭﺧﺼﺎﺋﺼﻪ ﻭﺍﻟﻌﺪﻳﺪ‬
‫ﻣﻦ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﺘﻌﻠﻘﺔ ﺑﻪ ﻣﻦ ﺗﺎﺭﻳﺦ ﺍﻻﻧﺸﺎء ﻭﺍﻟﻮﻗﺖ ‪ ،‬ﻛﺬﻟﻚ ﳛﺘﻔﻆ ﺑﻘﺎﺋﻤﺔ ﲜﻤﻴﻊ ﺍﳌﻠﻔﺎﺕ ﻭﺃﻣﺎﻛﻦ ﺗﻮﺍﺟﺪﻫﺎ‬
‫ﰲ ﺍﻟﻘﺮﺹ ‪ ،‬ﺃﻳﻀﴼ ﺃﺣﺪ ﺃﻫﻢ ﻓﻮﺍﺋﺪ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﻫﻲ ﻣﺘﺎﺑﻌﺔ ﺍﻷﻣﺎﻛﻦ ﺍﻟﻐﲑ ﺍﳌﺴﺘﺨﺪﻣﺔ ﰲ ﺍﻟﻘﺮﺹ ﻭﺍﻷﻣﺎﻛﻦ‬
‫ﺍﻟﱵ ﺗﻀﺮﺭﺕ ﺑﺴﺒﺐ ﺃﻭ ﻵﺧﺮ ‪ ، bad sectors‬ﻛﺬﻟﻚ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﺍﳉﻴﺪﺓ ﺗﻘﻮﻡ ﺑﻌﻤﻞ ﲡﻤﻴﻊ ﺍﳌﻠﻔﺎﺕ ﺍﳌﺒﻌﺜﺮﺓ‬
‫ﻋﻠﻰ ﺍﻟﻘﺮﺹ ‪ Defragmenta on‬ﺣﱴ ﺗﺴﺘﻔﻴﺪ ﻣﻦ ﺍﳌﺴﺎﺣﺎﺕ ﺍﻟﺼﻐﲑﺓ ﺍﻟﱵ ﻇﻬﺮﺕ ﺑﺴﺒﺐ ﺣﺬﻑ ﻣﻠﻒ ﻣﻮﺟﻮﺩ‬
‫ﺃﻭ ﲣﺮﻳﻦ ﻣﻠﻒ ﺫﻭ ﺣﺠﻢ ﺃﻗﻞ ﻣﻦ ﺍﳌﺴﺎﺣﺔ ﺍﳋﺎﻟﻴﺔ‪ .‬ﻭﺑﺪﻭﻥ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﻓﺎﻥ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻘﺮﺹ ﺳﻴﻜﻮﻥ‬
‫ﻣﺴﺘﺤﻴﻼ ! ﺣﻴﺚ ﻟﻦ ﻧﻌﺮﻑ ﻣﺎﻫﻲ ﺍﳌﺴﺎﺣﺎﺕ ﺍﻟﻐﲑ ﻣﺴﺘﺨﺪﻣﺔ ﻣﻦ ﺍﻻﺧﺮﻯ ﻭﻟﻦ ﻧﺴﺘﻄﻴﻊ ﺍﻥ ﻧﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﻣﻠﻒ‬
‫ﻃﻠﺒﻪ ﺍﳌﺴﺘﺨﺪﻡ ﻟﻌﺮﺿﻪ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ !‬
‫ﻭﺑﺸﻜﻞ ﻋﺎﻡ ﻓﺎﻥ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻳﺘﻜﻮﻥ ﻣﻦ‪:‬‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﺍﻟﻘﺮﺹ ﻭﺳﻨﻄﻠﻖ ﻋﻠﻴﻪ ﺍﺳﻢ ﺍﳌﺤﺮﻙ )‪.(Driver‬‬ ‫•‬

‫ﻭﺟﻮﺩ ﻫﻴﻜﻠﺔ ﺑﻴﺎﻧﺎﺕ ‪ Data Structure‬ﻣﻌﻴﻨﺔ ﻋﻠﻰ ﺍﻟﻘﺮﺹ‪،‬ﻳﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺩﺭﺍﻳﻔﺮ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ‪.‬‬ ‫•‬

‫‪٥٠‬‬
‫‪FAT12‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬

‫ﻭﺣﻴﺚ ﺃﻥ ﺑﺮﳎﺔ ﺑﺮﻧﺎﻣﺞ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﺗﻌﺘﻤﺪ ﻛﻠﻴﺎُ ﻋﻠﻰ ﻫﻴﻜﻠﺔ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ‪ ،‬ﻓﺎﻧﻨﺎ ﺳﻨﺒﺪﺃ‬
‫ﺑﺎﳊﺪﻳﺚ ﻋﻨﻬﺎ ﺃﻭﻻ ﻭﺳﻮﻑ ﻧﺄﺧﺬ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﻗﺮﺹ ﻣﺮﻥ ﻛﻤﺜﺎﻝ ‪ ،‬ﻧﻈﺮﴽ ﻟﺒﺴﺎﻃﺔ ﻫﺬﺍ ﺍﻟﻨﻈﺎﻡ ﻭﺧﻠﻮﻩ ﻣﻦ‬
‫ﺍﻟﺘﻌﻘﻴﺪﺍﺕ‪.‬‬

‫‪FAT12‬‬ ‫‪ .١.٥.٣‬ﻗﻴﻮﺩ ﻧﻈﺎﻡ‬

‫ﻳﻌﺘﱪ ﻧﻈﺎﻡ ‪ FAT12‬ﻣﻦ ﺃﻗﺪﻡ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﻇﻬﻮﺭﴽ ﻭﻗﺪ ﺍﻧﺘﺸﺮ ﺍﺳﺘﺨﺪﺍﻣﻪ ﰲ ﺍﻻﻗﺮﺍﺹ ﺍﳌﺮﻧﺔ ﻣﻨﺬ ﺃﻭﺍﺧﺮ ﺍﻟﺴﺒﻌﻴﻨﺎﺕ‬
‫‪ ،‬ﻭﻳﻌﻴﺐ ﻧﻈﺎﻡ ‪: FAT12‬‬
‫ﻋﺪﻡ ﺩﻋﻤﻪ ﻟﻠﻤﺠﻠﺪﺍﺕ ﺍﳍﺮﻣﻴﺔ ﻭﻳﺪﻋﻢ ﻓﻘﻂ ﳎﻠﺪ ﻭﺍﺣﺪ ﻳﺴﻤﻰ ﺍﳉﺬﺭ ‪.Root Directory‬‬ ‫•‬

‫ﻃﻮﻝ ﺍﻟﻌﻨﻘﻮﺩ )‪ (Cluster‬ﻫﻮ ‪ 12‬ﺑﺖ ‪ ،‬ﲟﻌﲎ ﺃﻥ ﻋﺪﺩ ﺍﻟﻜﻠﺴﺘﺮﺍﺕ ﻫﻲ ‪.212‬‬ ‫•‬

‫ﺃﲰﺎء ﺍﳌﻠﻔﺎﺕ ﻻ ﺗﺰﻳﺪ ﻋﻦ ‪ 12‬ﺑﺖ‪.‬‬ ‫•‬

‫ﻳﺴﺘﻮﻋﺐ ﻛﺤﺪ ﺃﻗﺼﻰ ‪ 4077‬ﻣﻠﻒ ﻓﻘﻂ‪.‬‬ ‫•‬

‫‪.32‬‬ ‫‪MB‬‬ ‫ﺣﺠﻢ ﺍﻟﻘﺮﺹ ﳛﻔﻆ ﰲ ‪ 16‬ﺑﺖ ‪ ،‬ﻭﻟﺬﺍ ﻓﺎﻧﻪ ﻻ ﻳﺪﻋﻢ ﺍﻻﻗﺮﺍﺹ ﺍﻟﱵ ﺣﺠﻤﻬﺎ ﻳﺰﻳﺪ ﻋﻦ‬ ‫•‬

‫‪.(Par‬‬ ‫)‪ons‬‬ ‫ﻳﺴﺘﺨﺪﻡ ﺍﻟﻌﻼﻣﺔ ‪ 0x01‬ﻟﺘﻤﻴﻴﺰ ﺍﻟﺘﻘﺴﻴﻤﺎﺕ ﻋﻠﻰ ﺍﻟﻘﺮﺹ‬ ‫•‬

‫ﻭﻛﻤﺎ ﺫﻛﺮﻧﺎ ﺃﻧﻨﺎ ﺳﻨﺴﺘﺨﺪﻡ ﻫﺬﺍ ﺍﻟﻨﻈﺎﻡ ﰲ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ ﻧﻈﺮﴽ ﻟﺒﺴﺎﻃﺘﻪ ‪ ،‬ﻭﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﻧﻪ ﻗﺪ ﺗﻼﺷﻰ‬
‫ﺍﺳﺘﺨﺪﺍﻣﻪ ﰲ ﻫﺬﺍ ﺍﻟﺰﻣﻦ ﺍﻻ ﺍﻧﻪ ﻳﻌﺘﱪ ﺃﺳﺎﺱ ﺟﻴﺪ ﻟﻸﻧﻈﻤﺔ ﺍﳌﺘﻘﺪﻣﺔ ﻟﺬﺍ ﻭﺟﺐ ﺩﺭﺍﺳﺘﻪ‪.‬‬

‫‪ .٢.٥.٣‬ﻫﻴﻜﻠﺔ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﺍﻟﻘﺮﺹ‬

‫ﻋﻨﺪ ‪‬ﺌﻴﺔ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ‪ (Format) ٦‬ﺑﻨﻈﺎﻡ ‪ FAT12‬ﻓﺎﻥ ﺗﺮﻛﻴﺒﺔ ﺍﻟﻘﺮﺹ ﺗﻜﻮﻥ ﻋﻠﻰ ﺍﻟﺸﻜﻞ ‪: ٢.٣‬‬

‫ﺷﻜﻞ ‪ :.٢.٣‬ﻫﻴﻜﻠﺔ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﺍﻟﻘﺮﺹ‬

‫‪٦‬ﺳﻮﺍءﴽ ﻛﺎﻧﺖ ﺍﻟﺘﻬﺌﻴﺔ ﻣﻦ ﻗﺒﻞ ﺩﺭﺍﻳﻔﺮ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺬﻱ ﺳﻨﻘﻮﻡ ﺑﱪﳎﺘﻪ ﺃﻭ ﻛﺎﻧﺖ ﻣﻦ ﻗﺒﻞ ﻧﻈﺎﻡ ﺍﻟﺸﺘﻐﻴﻞ ﺍﳌﺴﺘﺨﺪﻡ ﺃﺛﻨﺎء ﻋﻤﻠﻴﺔ‬
‫ﺍﻟﺘﻄﻮﻳﺮ ‪ ،‬ﻓﻤﺜﻼ ﰲ ﻭﻳﻨﺪﻭﺯ ﳝﻜﻦ ﺇﻋﺎﺩﺓ ‪‬ﺌﻴﺔ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺑﻨﻈﺎﻡ ‪. FAT12‬‬

‫‪٥١‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﻭﺃﻭﻝ ﻣﻘﻄﻊ ﻫﻮ ﻣﻘﻄﻊ ﺍﻻﻗﻼﻉ )‪ (Boot Sector‬ﻭﳛﻮﻱ ﺷﻔﺮﺓ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ )ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ( ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ‬
‫ﺑﻴﺎﻧﺎﺕ ﻭﻣﻌﻠﻮﻣﺎﺕ ‪ ، BPB and OEM id‬ﻫﺬﺍ ﺍﳌﻘﻄﻊ ﻋﻨﻮﺍﻧﻪ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﻫﻮ ‪ :‬ﺍﳌﻘﻄﻊ ‪ 1‬ﺍﳌﺴﺎﺭ ‪0‬‬
‫ﺍﻟﺮﺃﺱ ‪ 0‬ﻭﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻫﻮ ﺍﻟﺬﻱ ﳚﺐ ﲤﺮﻳﺮ ﺍﱃ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪ int 0x13‬ﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺎﻟﻘﺮﺍءﺓ ﻣﻦ ﺍﻟﻘﺮﺹ‬
‫ﻛﺬﻟﻚ ﰲ ﺣﺎﻟﺔ ﻣﺎ ﺃﺭﺩﻧﺎ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﻣﺘﺤﻜﻢ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‪ .‬ﻭﻧﻈ ًﺮ ﻟﺼﻌﻮﺑﺔ ﻫﺬﻩ ﺍﻟﻌﻨﻮﻧﺔ ﻭﺍﻟﱵ ﺗﻌﺮﻑ‬
‫ﺏ ‪ Absolute Sector‬ﻓﺎﻥ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻧﻈﺎﻡ ﻋﻨﻮﻧﺔ ﳐﺘﻠﻒ ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﳏﺘﻮﻳﺎﺕ ﺍﻟﻘﺮﺹ ‪ ،‬ﻓﺒﺪﻻً‬
‫ﻣﻦ ﺫﻛﺮ ﻛﻞ ﻣﻦ ﺍﳌﻘﻄﻊ ﻭﺍﳌﺴﺎﺭ ﻭﺍﻟﺮﺃﺱ ﻟﻠﻮﺻﻮﻝ ﺍﱃ ﻣﻘﻄﻊ ﻣﺎ ﻓﺎﻥ ﻫﺬﻩ ﺍﻟﻌﻨﻮﻧﺔ ﺗﺴﺘﺨﺪﻡ ﻓﻘﻂ ﺭﻗﻢ ﻟﻠﻤﻘﻄﻊ ‪.‬‬
‫ﻧﻈﺎﻡ ﺍﻟﻌﻨﻮﻧﺔ ﺍﻟﺬﻱ ﺗﺴﺘﺨﺪﻣﻪ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ﻳﺴﻤﻰ ﺑﺎﻟﻌﻨﻮﻧﺔ ﺍﳌﻨﻄﻘﻴﺔ )‪ (Logical Sector Addressing‬ﻭﳜﺘﺼﺮ‬
‫ﺏ ‪ LBA‬ﻫﻮ ﻧﻈﺎﻡ ﺑﺴﻴﻂ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺗﺮﻗﻴﻢ ﺍﳌﻘﺎﻃﻊ ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ ﺑﺪﺋﴼ ﻣﻦ ﻣﻘﻄﻊ ﺍﻻﻗﻼﻉ )‪(Boot Sector‬‬
‫ﻭﺍﻟﺬﻱ ﻳﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ ‪ ، 0‬ﻭﺍﳌﻘﻄﻊ ﺍﻟﺜﺎﱐ ‪ 1‬ﻭﻫﻜﺬﺍ ﻫﻠﻢ ﺟﺮﺍ ﺣﱴ ﻧﺼﻞ ﺍﱃ ﺁﺧﺮ ﻣﻘﻄﻊ ﰲ ﺍﻟﻘﺮﺹ‪ .‬ﻭﲟﺎ ﺃﻧﻪ‬
‫ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻌﻨﻮﻧﺔ ﺍﳊﻘﻴﻘﺔ ﺑﺪﻻ ﻣﻦ ﺍﳌﻨﻄﻘﻴﺔ ﳊﻈﺔ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ﺍﻟﻘﺮﺹ )ﺗﺬﻛﺮ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪int 0x13‬‬
‫ﻭﺍﳌﺴﺠﻼﺕ ﺍﻟﱵ ﳚﺐ ﺍﺩﺧﺎﻝ ﻗﻴﻤﻬﺎ( ﻓﺎﻧﻪ ﳚﺐ ﺍﳚﺎﺩ ﻃﺮﻳﻘﺔ ﻟﻠﺘﺤﻮﻳﻞ ﻣﻦ ﺍﻟﻌﻨﻮﻧﺔ ﺍﳊﻘﻴﻘﺔ ﺍﱃ ﺍﳌﻨﻄﻘﻴﺔ ‪-‬ﺳﻨﻨﺎﻗﺶ‬
‫ﺍﳌﻮﺿﻮﻉ ﻻﺣﻘﺎ‪ .-‬ﻧﻨﺘﻘﻞ ﺍﱃ ﺍﳌﻘﻄﻊ ﺍﻟﺘﺎﱄ ﳌﻘﻄﻊ ﺍﻹﻗﻼﻉ ﻭﻫﻮ ﻣﻘﻄﻊ )ﺃﻭ ﻋﺪﺓ ﻣﻘﺎﻃﻊ( ﳝﻜﻦ ﺃﻥ ﳛﺠﺰﻫﺎ ﺍﳌﱪﻣﺞ‬
‫ﻻﺩﺍء ﺃﻱ ﻭﻇﻴﻔﺔ ﻳﺮﻳﺪﻫﺎ ﻭﺗﺴﻤﻰ ﺍﳌﻘﺎﻃﻊ ﺍﳌﺤﺠﻮﺯﺓ ﺍﻻﺿﺎﻓﻴﺔ ‪ ، Extra Reserved Sectors‬ﻭﺍﳌﻘﺼﻮﺩ ﲟﺤﺠﻮﺯﺓ‬
‫ﺃﻱ ﺍﻧﻪ ﻻ ﻳﻮﺟﺪ ﳍﺎ ﻭﺟﻮﺩ ﰲ ﺩﻟﻴﻞ ‪ ، FAT‬ﻭﻣﻘﻄﻊ ﺍﻹﻗﻼﻉ ﻫﻮ ﻣﻘﻄﻊ ﳏﺠﻮﺯ ﺩﺍﺋﻤﺎ ﻟﺬﻟﻚ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ‬
‫‪ reserved sectors‬ﰲ ﻣﻌﻠﻮﻣﺎﺕ ‪ BPB‬ﻫﻲ ﻭﺍﺣﺪ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﻣﺎ ﺃﺭﺩﺕ ﺣﺠﺰ ﻣﻘﺎﻃﻊ ﺃﺧﺮﻯ ﻛﻞ ﻣﺎ ﻋﻠﻴﻚ‬
‫ﻫﻮ ﺯﻳﺎﺩﺓ ﻫﺬﻩ ﺍﻟﻘﻴﻤﺔ ﺑﻌﺪﺩ ﺍﳌﻘﺎﻃﻊ ﺍﳌﺮﻏﻮﺑﺔ ‪ ،‬ﻭﻟﻠﻮﺻﻮﻝ ﺍﱃ ﳏﺘﻮﻳﺎﺕ ﻫﺬﺍ ﺍﳌﻘﻄﻊ ﺍﻻﺿﺎﰲ)ﺍﻥ ﻛﺎﻥ ﻟﻪ ﻭﺟﻮﺩ(‬
‫ﻓﺎﻥ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳊﻘﻴﻘﻲ ﻟﻪ ﻫﻮ ﺍﳌﻘﻄﻊ ‪ 2‬ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﻟﺮﺃﺱ ‪ ، 0‬ﺃﻣﺎ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻨﻄﻘﻲ ﻟﻪ ﻫﻮ ﺍﳌﻘﻄﻊ ‪ .1‬ﻭﺑﺸﻜﻞ ﻋﺎﻡ‬
‫ﻓﺎﻧﻪ ﰲ ﺍﻟﻐﺎﻟﺐ ﻻ ﻳﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻊ ﺍﺿﺎﻓﻴﺔ ﺳﻮﻯ ﻣﻘﻄﻊ ﺍﻻﻗﻼﻉ ‪ .‬ﺍﳌﻘﻄﻊ ﺍﻟﺜﺎﻟﺚ ﻫﻮ ﺟﺪﻭﻝ ‪ ، FAT‬ﻭﻫﻮ‬
‫ﺟﺪﻭﻝ ﳛﻮﻱ ﺳﺠﻼﺕ ﺑﻄﻮﻝ ‪ 12‬ﺑﺖ ﻋﻦ ﻛﻞ ﻛﻠﺴﺘﺮ )‪ (Cluster‬ﰲ ﺍﻟﻘﺮﺹ ‪ ،‬ﺑﻴﺎﻧﺎﺕ ﻫﺬﺍ ﺍﻟﺴﺠﻞ ﺗﻮﺿﺢ ﻣﺎ‬
‫ﺍﺫﺍ ﻛﺎﻥ ﺍﻟﻜﻠﺴﺘﺮ ﻗﻴﺪ ﺍﻻﺳﺘﺨﺪﺍﻡ ﺃﻡ ﻻ ‪ ،‬ﻭﻫﻞ ﻫﻮ ﺁﺧﺮ ﻛﻠﺴﺘﺮ ﻟﻠﻤﻠﻒ ﺃﻡ ﻻ ﻭﺇﺫﺍ ﻛﺎﻥ ﻟﻴﺲ ﺑﺎﺧﺮ ﻓﺎﻧﻪ ﻳﻮﺿﺢ‬
‫ﻟﻨﺎ ﺍﻟﻜﻠﺴﺘﺮ ﺍﻟﺘﺎﱄ ﻟﻠﻤﻠﻒ ‪ ،‬ﻭﻳﻮﺿﺢ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﱄ ﺗﺮﻛﻴﺒﺔ ﻫﺬﺍ ﺍﳉﺪﻭﻝ‬
‫ﺍﺫﴽ ﻫﺬﺍ ﻭﻇﻴﻔﺔ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻫﻲ ﻣﻌﺮﻓﺔ ﺍﻟﻜﻠﺴﺘﺮﺍﺕ ﺍﳋﺎﻟﻴﺔ ﻣﻦ ﻏﲑﻫﺎ ﻛﺬﻟﻚ ﺍﻟﻮﻇﻴﻔﺔ ﺍﻻﺧﺮﻯ ﻫﻲ ﻣﻌﺮﻓﺔ ﲨﻴﻊ‬
‫ﺍﻟﻜﻠﺴﺘﺮﺍﺕ ﳌﻠﻒ ﻣﺎ ﻭﻳﺘﻢ ﺫﻟﻚ ﺑﺎﻟﻨﻈﺮ ﺍﱃ ﻗﻴﻤﺔ ﺍﻟﺴﺠﻞ )ﻗﻴﻤﺔ ﺍﻝ ‪ 12‬ﺑﺖ( ‪ ،‬ﻭﺍﻟﻘﻴﻢ ﻫﻲ ‪:‬‬
‫ﺍﻟﻘﻴﻤﺔ ‪ :0x00‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﻟﻜﻠﺴﺘﺮ ﺧﺎﱄ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻤﺔ ‪ : 0x01‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﻟﻜﻠﺴﺘﺮ ﳏﺠﻮﺯ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻢ ﻣﻦ ‪ 0x02‬ﺍﱃ ‪ : 0xfef‬ﺗﺪﻝ ﻋﻠﻰ ﻋﻨﻮﺍﻥ ﺍﻟﻜﻠﺴﺘﺮ ﺍﻟﺘﺎﱄ )ﲟﻌﲎ ﺁﺧﺮ ﺃﻥ ﺍﻟﻜﻠﺴﺘﺮ ﳏﺠﻮﺯ ﻭﺗﻮﺟﺪ‬ ‫•‬
‫ﻛﻠﺴﺘﺮﺍﺕ ﻣﺘﺒﻘﻴﺔ ﻟﻠﻤﻠﻒ(‪.‬‬
‫ﺍﻟﻘﻴﻢ ﻣﻦ ‪ 0xff0‬ﺍﱃ ‪ :0xff6‬ﻗﻴﻢ ﳏﺠﻮﺯﺓ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻤﺔ ‪ : 0xff6‬ﺗﺪﻝ ﻋﻠﻰ ‪.Bad Cluster‬‬ ‫•‬

‫ﺍﻟﻘﻴﻢ ﻣﻦ ‪ 0xff8‬ﺍﱃ ‪ :0xfff‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﻫﺬﺍ ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ﺍﻻﺧﲑ ﻟﻠﻤﻠﻒ‪.‬‬ ‫•‬

‫‪٥٢‬‬
‫‪FAT12‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬

‫ﻭﳝﻜﻦ ﺍﻟﻨﻈﺮ ﺍﱃ ﺟﺪﻭﻝ ‪ FAT‬ﺑﺄﻧﻪ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﺍﻟﻘﻴﻢ ﺃﻋﻼﻩ ‪ ،‬ﻭﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﲢﻤﻴﻞ ﻣﻠﻒ ﻓﺎﻧﻨﺎ ﺳﻨﺄﰐ ﺑﻌﻨﻮﺍﻥ ﺃﻭﻝ‬
‫ﻛﻠﺴﺘﺮ ﻟﻪ ﻣﻦ ﺟﺪﻭﻝ ‪) Root Directory‬ﺳﻨﺄﰐ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ( ﻭﺑﻌﺪﻫﺎ ﻧﺴﺘﺨﺪﻡ ﻋﻨﻮﺍﻥ ﺍﻟﻜﻠﺴﺘﺮ ﻙ ‪ index‬ﺍﱃ‬
‫ﺟﺪﻭﻝ ‪ FAT‬ﻭﻧﻘﺮﺃ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻘﺎﺑﻠﻪ ﻟﻠﻜﻠﺴﺘﺮ ‪ ،‬ﻓﺎﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﺑﲔ ‪ 0x02‬ﺍﱃ ‪ 0xfef‬ﻓﺎ‪‬ﺎ ﺗﺪﻝ ﻋﻠﻰ ﺍﻟﻜﻠﺴﺘﺮ‬
‫ﺍﻟﺘﺎﱄ ﻟﻠﻤﻠﻒ ‪ ،‬ﻭﻣﻦ ﰒ ﺳﻨﺴﺘﺨﺪﻡ ﻫﺬﻩ ﺍﻟﻘﻴﻤﺔ ﺃﻳﻀﺎ ﻙ ‪ index‬ﻭﻧﻘﺮﺃ ﺍﻟﻘﻴﻤﺔ ﺍﳉﺪﻳﺪﺓ ‪ ،‬ﻭﻧﺴﺘﻤﺮ ﻋﻠﻰ ﻫﺬﺍ ﺍﳊﺎﻝ‬
‫ﺍﱃ ﺃﻥ ﻧﻘﺮﺃ ﻗﻴﻤﺔ ﺗﺪﻝ ﻋﻠﻰ ‪‬ﺎﻳﺔ ﺍﳌﻠﻒ‪ .‬ﻫﺬﺍ ﺍﳉﺪﻭﻝ ‪ FAT‬ﻳﺒﺪﺃ ﻣﻦ ﺍﳌﻘﻄﻊ ﺍﳌﻨﻄﻘﻲ ‪ ٧ 1‬ﻭﻃﻮﻟﻪ ‪ 9‬ﻣﻘﺎﻃﻊ ﺃﻱ‬
‫ﺃﻥ ‪‬ﺎﻳﺔ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﺗﻜﻮﻥ ﰲ ﺍﳌﻘﻄﻊ ﺗﻜﻮﻥ ﰲ ﺁﺧﺮ ﺍﳌﻘﻄﻊ ‪ ،10‬ﻭﳌﻌﺮﻓﺔ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳊﻘﻴﻘﻲ ﻟﻠﻤﻘﻄﻊ ﻓﺎﻧﻪ ﳝﻜﻦ‬
‫ﺍﺳﺘﺨﺪﺍﻡ ﺑﻌﺾ ﺍﳌﻌﺎﺩﻻﺕ ﻟﻠﺘﺤﻮﻳﻞ ‪ ،‬ﻭﺍﻟﻘﺴﻢ ﺍﻟﺘﺎﱄ ﺳﻴﻮﺿﺢ ﺫﻟﻚ ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﺷﺮﺡ ﻣﺒﺴﻂ ﻋﻦ ﻫﻴﻜﻠﺔ ﺍﻟﻘﺮﺹ‬
‫ﺍﳌﺮﻥ ﻭﻛﻴﻔﻴﺔ ﺣﻔﻈﻪ ﻟﻠﺒﻴﺎﻧﺎﺕ ‪ .‬ﻭﺑﻌﺪ ﺟﺪﻭﻝ ‪ FAT‬ﺗﻮﺟﺪ ﻧﺴﺨﺔ ﺃﺧﺮﻯ ﻣﻦ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻭﺗﺴﺘﺨﺪﻡ ﻛﻨﺴﺨﺔ‬
‫ﺍﺣﺘﻴﺎﻃﻴﺔ ‪ backup‬ﻭﻫﻲ ﺑﻨﻔﺲ ﺣﺠﻢ ﻭﺧﺼﺎﺋﺺ ﺍﻟﻨﺴﺨﺔ ﺍﻻﻭﱃ ‪ ،‬ﻭﺑﻌﺪﻫﺎ ﻳﺄﰐ ﺩﻟﻴﻞ ﺍﳉﺬﺭ ‪Root Directory‬‬
‫ﻭﻫﻮ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ‪ 224‬ﺳﺠﻞ ﻛﻞ ﺳﺠﻞ ﺑﻄﻮﻝ ‪ 32‬ﺑﺎﻳﺖ ‪ ،‬ﻭﻇﻴﻔﻴﺔ ﻫﺬﺍ ﺍﻟﺪﻟﻴﻞ ﻫﻲ ﺣﻔﻆ ﺃﲰﺎء ﺍﳌﻠﻔﺎﺕ‬
‫ﺍﳌﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﻌﻠﻮﻣﺎﺕ ﺍﻟﱵ ﲣﺺ ﻭﻗﺖ ﺍﻻﻧﺸﺎء ﻭﺍﻟﺘﻌﺪﻳﻞ ﻭﺣﺠﻢ ﺍﳌﻠﻒ‬
‫ﻭﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻠﻤﻠﻒ ‪ ،‬ﻋﻨﻮﺍﻥ ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ﺃﻫﻢ ﻣﻌﻠﻮﻣﺔ ﻟﻜﻲ ﻧﺴﺘﻄﻴﻊ ﲢﻤﻴﻞ ﺍﳌﻠﻒ ﻛﺎﻣﻼ ‪ ،‬ﺣﻴﺚ ﻛﻤﺎ‬
‫ﺫﻛﺮﻧﺎ ﺃﻥ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﺳﻴﻌﻤﻞ ﻙ ‪ index‬ﰲ ﺟﺪﻭﻝ ‪ FAT‬ﻭﺑﻌﺪﻫﺎ ﺳﻨﺤﺪﺩ ﻣﺎ ﺍﺫﺍ ﻛﺎﻧﺖ ﺗﻮﺟﺪ ﻛﻠﺴﺘﺮﺍﺕ ﺃﺧﺮﻯ‬
‫ﳚﺐ ﲢﻤﻴﻠﻬﺎ ﺃﻡ ﺃﻥ ﺍﳌﻠﻒ ﻳﺘﻜﻮﻥ ﻣﻦ ﻛﻠﺴﺘﺮ ﻭﺍﺣﺪ‪ .‬ﻭﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﳏﺘﻮﻳﺎﺕ ﺍﻟﺴﺠﻞ ﺍﻟﻮﺍﺣﺪ ﰲ ﺩﻟﻴﻞ‬
‫ﺍﻝ ‪ root directory‬ﺑﺪﺍءﴽ ﻣﻦ ﺍﻟﺒﺎﻳﺖ ﺍﻻﻭﻝ ﺍﱃ ﺍﻻﺧﲑ‪:‬‬
‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :7-0‬ﺍﺳﻢ ﺍﳌﻠﻒ) ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺍﳊﺠﻢ ﺃﻗﻞ ﻣﻦ ‪ 8‬ﺑﺎﻳﺖ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﺣﺮﻑ ﺍﳌﺴﺎﻓﺔ ﻟﺘﻌﺒﺌﺔ‬ ‫•‬
‫ﺍﳌﺘﺒﻘﻲ(‪.‬‬
‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :10-8‬ﺍﻣﺘﺪﺍﺩ ﺍﳌﻠﻒ)ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﺴﺎﻓﺔ ﺃﻳﻀﺎ ﻟﺘﻌﺒﺌﺔ ﺍﳌﺘﺒﻘﻲ(‪.‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺖ ‪ :11‬ﺧﺼﺎﺋﺺ ﺍﳌﻠﻒ ﻭﻫﻲ ‪:‬‬ ‫•‬

‫– ﺍﻟﺒﺖ ‪ :0‬ﺍﻟﻘﺮﺍءﺓ ﻓﻘﻂ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :1‬ﳐﻔﻲ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :2‬ﻣﻠﻒ ﻧﻈﺎﻡ‪.‬‬
‫– ﺍﻟﺒﺖ‪ :3‬ﺍﺳﻢ ﺍﻟﻘﺮﺹ ‪.Volume Label‬‬
‫– ﺍﻟﺒﺖ ‪ :4‬ﺍﳌﻠﻒ ﻫﻮ ﳎﻠﺪ ﻓﺮﻋﻲ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :5‬ﺃﺭﺷﻴﻒ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :6‬ﺟﻬﺎﺯ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :7‬ﻏﲑ ﻣﺴﺘﺨﺪﻡ‪.‬‬
‫ﺍﻟﺒﺎﻳﺖ ‪ :12‬ﻏﲑ ﻣﺴﺘﺨﺪﻡ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺖ ‪ :13‬ﻭﻗﺖ ﺍﻻﻧﺸﺎء ﺑﻮﺣﺪﺓ ‪.MS‬‬ ‫•‬

‫‪٧‬ﺑﺎﻓﺘﺮﺍﺽ ﺍﻟﻮﺿﻊ ﺍﻟﻐﺎﻟﺐ ﻭﻫﻮ ﻋﺪﻡ ﻭﺟﻮﺩ ﻣﻘﺎﻃﻊ ﺇﺿﺎﻓﻴﺔ ﺑﺎﺳﺘﺜﻨﺎء ﻣﻘﻄﻊ ﺍﻹﻗﻼﻉ‬

‫‪٥٣‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :15-14‬ﻭﻗﺖ ﺍﻻﻧﺸﺎء ﺑﺎﻟﺘﺮﺗﻴﺐ ﺍﻟﺘﺎﱄ‪:‬‬ ‫•‬

‫– ﺍﻟﺒﺘﺎﺕ ‪ :4-0‬ﺍﻟﺜﻮﺍﱐ )‪.(29-0‬‬
‫– ﺍﻟﺒﺘﺎﺕ ‪ :10-5‬ﺍﻟﺪﻗﺎﺋﻖ )‪.(59-0‬‬
‫– ﺍﻟﺒﺘﺎﺕ ‪ :15-11‬ﺍﻟﺴﺎﻋﺎﺕ )‪.(23-0‬‬
‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :17-16‬ﺳﻨﺔ ﺍﻻﻧﺸﺎء ﺑﺎﻟﺘﺮﺗﻴﺐ ﺍﻟﺘﺎﱄ‪:‬‬ ‫•‬
‫– ﺍﻟﺒﺘﺎﺕ ‪ :4-0‬ﺍﻟﺴﻨﺔ )‪.(2107=127 ;1980=0‬‬
‫– ﺍﻟﺒﺘﺎﺕ ‪ :8-5‬ﺍﻟﺸﻬﺮ )‪=1‬ﻳﻨﺎﻳﺮ; ‪=12‬ﺩﻳﺴﻤﱪ(‪.‬‬
‫– ﺍﻟﺒﺘﺎﺕ ‪ :15-9‬ﺍﻟﺴﺎﻋﺔ )‪.(23-0‬‬
‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :19-18‬ﺗﺎﺭﻳﺦ ﺁﺧﺮ ﺍﺳﺘﺨﺪﺍﻡ )ﺗﺘﺒﻊ ﻧﻔﺲ ﺍﻟﺘﺮﺗﻴﺐ ﺍﻟﺴﺎﺑﻖ(‪.‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪.EA index :21-20‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :23-22‬ﻭﻗﺖ ﺁﺧﺮ ﺗﻌﺪﻳﻞ )ﺗﺘﺒﻊ ﻧﻔﺲ ﺗﺮﺗﻴﺐ ﺍﻟﺒﺎﻳﺘﺎﺕ ‪.(15-14‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :25-24‬ﺗﺎﺭﻳﺦ ﺁﺧﺮ ﺗﻌﺪﻳﻞ )ﺗﺘﺒﻊ ﻧﻔﺲ ﺗﺮﺗﻴﺐ ﺍﻟﺒﺎﻳﺘﺎﺕ ‪.(17-16‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :27-26‬ﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻠﻤﻠﻒ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺘﺎﺕ ‪ :29-28‬ﺣﺠﻢ ﺍﳌﻠﻒ‪.‬‬ ‫•‬

‫ﻭﳚﺐ ﻣﻼﺣﻈﺔ ﺃﻥ ﺣﺠﻢ ﺍﻟﺴﺠﻼﺕ ﻫﻮ ﺛﺎﺑﺖ ‪ Fixed Lenght Record‬ﻓﻤﺜﻼ ﺍﺳﻢ ﺍﳌﻠﻒ ﳚﺐ ﺍﻥ ﻳﻜﻮﻥ ﺑﻄﻮﻝ‬
‫‪ 8‬ﺑﺎﻳﺖ ﻭﰲ ﺣﺎﻟﺔ ﺯﺍﺩ ﻋﻠﻰ ﺫﻟﻚ ﻓﺎﻥ ﻫﺬﺍ ﺳﻮﻑ ﳛﺪﺙ ﺿﺮﺭﴽ ﻋﻠﻰ ﻫﺬﺍ ﺍﻟﺪﻟﻴﻞ ‪ ،‬ﺃﻳﻀﺎ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺍﻻﺳﻢ‬
‫ﲝﺠﻢ ﺃﻗﻞ ﻣﻦ ﺍﳌﻄﻠﻮﺏ ﻓﺎﻧﻪ ﳚﺐ ﺗﻜﻠﻤﺔ ﺍﻟﻌﺪﺩ ﺍﻟﻨﺎﻗﺺ ﻣﻦ ﺍﳊﺮﻭﻑ ﲝﺮﻑ ﺍﳌﺴﺎﻓﺔ ‪.Space‬‬

‫‪ .٣.٥.٣‬ﻫﻴﻜﻠﺔ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‬

‫ﻳﺘﻜﻮﻥ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻣﻦ ﻗﺮﺹ ‪) Pla er‬ﺃﻭ ﻋﺪﺓ ﺃﻗﺮﺍﺹ( ﻣﻘﺴﻤﺔ ﺍﱃ ﻣﺴﺎﺭﺍﺕ )‪ (Tracks‬ﻭﻛﻞ ﻣﻦ ﻫﺬﻩ ﺍﳌﺴﺎﺭﺍﺕ‬
‫ﻳﺘﻜﻮﻥ ﻣﻦ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻘﻄﺎﻋﺎﺕ ﻭﻳﻮﺟﺪ ﻋﺎﺩﺓ ﺭﺃﺳﲔ ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻰ ﻛﻞ ﻗﺮﺹ‪ .‬ﻭﰲ ﺍﻻﻗﺮﺍﺹ ﺍﳌﺮﻧﺔ‬
‫ﺫﺍﺕ ﺍﳊﺠﻢ ‪ 1.44 MB‬ﻳﻮﺟﺪ ‪ 80‬ﻣﺴﺎﺭﴽ )ﻣﻦ ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﱃ ﺍﳌﺴﺎﺭ ‪ (79‬ﻭﻛﻞ ﻣﺴﺎﺭ ﻳﺘﻜﻮﻥ ﻣﻦ ‪ 18‬ﻗﻄﺎﻉ‬
‫‪ ،‬ﻭﺑﺎﻟﺘﺎﱄ ﻓﺎﻥ ﻋﺪﺩ ﺍﻟﻘﻄﺎﻋﺎﺕ ﺍﻟﻜﻠﻴﺔ ﻫﻲ ‪ 80 ∗ 18 ∗ 2‬ﻭﺗﺴﺎﻭﻱ ‪ 2880‬ﻗﻄﺎﻋﴼ‪.‬‬
‫ﻭﻟﺘﺨﺰﻳﻦ ﺑﻴﺎﻧﺎﺕ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﻓﺎﻧﻪ ﳚﺐ ﲢﺪﻳﺪ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳊﻘﻴﻘﻲ ﻭﺍﻟﺬﻱ ﻳﺘﻜﻮﻥ ﻣﻦ ﻋﻨﻮﺍﻥ ﺍﻟﻘﻄﺎﻉ ﻭﺍﳌﺴﺎﺭ‬
‫ﻭﺍﻟﺮﺃﺱ ‪ ،‬ﻭﺃﻭﻝ ﻗﻄﺎﻉ ﰲ ﺍﻟﻘﺮﺹ )ﻗﻄﺎﻉ ﺍﻻﻗﻼﻉ( ﻳﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ‪ :‬ﺍﻟﻘﻄﺎﻉ ‪ 1‬ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﻟﺮﺃﺱ ‪ ، 0‬ﻭﺍﻟﻘﻄﺎﻉ‬
‫ﺍﻟﺜﺎﱐ ﻳﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ‪ :‬ﺍﻟﻘﻄﺎﻉ ‪ 2‬ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﻟﺮﺃﺱ ‪ ، 0‬ﻭﻫﻜﺬﺍ ﻳﺴﺘﻤﺮ ﻧﻈﺎﻡ ﺍﻟﺘﺨﺰﻳﻦ ﰲ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺍﱃ ﺃﻥ‬
‫ﻳﺼﻞ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ 18‬ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﻟﺮﺃﺱ ‪ 0‬ﻭﻫﻮ ﻋﻨﻮﺍﻥ ﺁﺧﺮ ﻗﻄﺎﻉ ﻋﻠﻰ ﺍﳌﺴﺎﺭ ﺍﻻﻭﻝ ﻭﺍﻟﺮﺃﺱ ﺍﻻﻭﻝ ‪ ،‬ﻭﺳﻴﺘﻢ‬
‫ﺣﻔﻆ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﰲ ﺍﻟﺮﺃﺱ ﺍﻟﺜﺎﱐ ﻋﻠﻰ ﺍﻟﻌﻨﻮﺍﻥ‪ :‬ﺍﻟﻘﻄﺎﻉ ‪ 1‬ﺍﳌﺴﺎﺭ ‪ 0‬ﺍﻟﺮﺃﺱ ‪ 1‬ﻭﻳﺴﺘﻤﺮ ﺍﱃ ﺃﻥ ﻳﺼﻞ ﺍﱃ ﺁﺧﺮ‬
‫ﻗﻄﺎﻉ ﰲ ﻫﺬﺍ ﺍﳌﺴﺎﺭ ﻋﻠﻰ ﺍﻟﺮﺃﺱ ﺍﻟﺜﺎﱐ‪ ،‬ﻭﺑﻌﺪﻫﺎ ﺳﻴﺘﻢ ﺣﻔﻆ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﰲ ﺍﻟﺮﺃﺱ ﺍﻻﻭﻝ ﺍﳌﺴﺎﺭ ﺍﻟﺜﺎﱐ ‪...‬‬
‫‪،‬ﻭﻫﻜﺬﺍ‪.‬‬

‫‪٥٤‬‬
‫‪FAT12‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬

‫‪FAT12‬‬ ‫‪ .٤.٥.٣‬ﺍﻟﻘﺮﺍءﺓ ﻭ ﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻧﻈﺎﻡ‬

‫‪FAT12‬‬ ‫ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ )ﻗﺮﺍءﺓ ﻭﻛﺘﺎﺑﺔ ﺍﻟﻘﻄﺎﻋﺎﺕ( ﻓﺎﻧﻪ ﻳﻠﺰﻣﻨﺎ ﺑﺮﳎﺔ ﺩﺭﺍﻳﻔﺮ ﻟﻨﻈﺎﻡ‬
‫ﻭﺍﻟﺬﻱ ﺳﻴﻌﻤﻞ ﻛﻮﺳﻴﻂ ﺑﲔ ﺍﳌﺴﺘﺨﺪﻡ ﻭﺑﲔ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‪ ،‬ﲟﻌﲎ ﺃﻥ ﺃﻱ ﻃﻠﺐ ﻟﻘﺮﺍءﺓ ﻣﻠﻒ ﻣﺎ ﳚﺐ ﺃﻥ ﺗﺬﻫﺐ‬
‫ﺃﻭﻻ ﺍﱃ ﻧﻈﺎﻡ ‪ FAT12‬ﺣﻴﺚ ﺳﻴﻘﺮﺭ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻠﻒ ﻣﻮﺟﻮﺩﴽ ﺃﻡ ﻻ )ﻋﻦ ﻃﺮﻳﻖ ﺍﻟﺒﺤﺚ ﰲ ﺩﻟﻴﻞ ‪Root‬‬
‫‪ (directory‬ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﻣﻮﺟﻮﺩﴽ ﺳﻴﻌﻮﺩ ﻟﻨﺎ ﲜﻤﻴﻊ ﺧﺼﺎﺋﺺ ﺍﳌﻠﻒ ﻭﺭﻗﻢ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻪ ﻟﻜﻲ ﻧﺘﻤﻜﻦ ﻣﻦ‬
‫ﲢﻤﻴﻞ ﺍﳌﻠﻒ ﻛﺎﻣﻼً ‪ ،‬ﻭﻧﻔﺲ ﺍﳌﺒﺪﺃ ﰲ ﺣﺎﻟﺔ ﻃﻠﺐ ﺍﳌﺴﺘﺨﺪﻡ ﻛﺘﺎﺑﺔ ﻣﻠﻒ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﻓﺎﻥ ﺩﺭﺍﻳﻔﺮ ﻧﻈﺎﻡ ‪FAT12‬‬
‫ﺳﻴﺒﺤﺚ ﰲ ﺟﺪﻭﻝ ‪ FAT‬ﻋﻦ ﻣﺴﺎﺣﺔ ﺧﺎﻟﻴﺔ ﻣﻨﺎﺳﺒﺔ ﻟﻠﻤﻠﻒ ﻭﺫﻟﻚ ﺑﺎﺗﺒﺎﻉ ﺃﺣﺪ ﺍﳋﻮﺭﺍﺯﻣﻴﺎﺕ ﺍﳌﻌﺮﻭﻓﺔ ﻭﺑﻌﺪﻫﺎ‬
‫ﺳﻴﺘﻢ ﺣﻔﻆ ﺍﳌﻠﻒ ﻭﻛﺘﺎﺑﺔ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﺘﻌﻠﻘﺔ ﺑﻪ ﰲ ﺩﻟﻴﻞ ‪. Root directory‬‬
‫ﻭﺳﻨﺄﺧﺬ ﻣﺜﺎﻝ ﻋﻠﻰ ﺍﳌﻮﺿﻮﻉ ﻭﺫﻟﻚ ﺑﱪﳎﺔ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪Second Stage Bootloader‬‬
‫ﻭﺳﺘﻘﺘﺼﺮ ﻭﻇﻴﻔﺘﻪ ﺣﺎﻟﻴﴼ ﰲ ﻃﺒﺎﻋﺔ ﺭﺳﺎﻟﺔ ﺗﺮﺣﻴﺒﺔ ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻧﻪ ﰎ ﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﺑﻨﺠﺎﺡ ‪ ،‬ﻭﰲ‬
‫ﺍﻷﻗﺴﺎﻡ ﺍﻟﺘﺎﻟﻴﺔ ﺳﻨﺒﺪﺃ ﰲ ﺗﻄﻮﻳﺮ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻭﲡﻬﻴﺰ ﻣﺮﺣﻠﺔ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺑﻴﺌﺔ ‪ 32‬ﺑﺖ‪.‬‬
‫ﻣﻬﻤﺔ ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ ﺳﺘﺘﻐﲑ ﻋﻦ ﻣﺎ ﺳﺒﻖ ‪ ،‬ﺣﻴﺚ ﺍﻻﻥ ﳚﺐ ﻋﻠﻰ ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ ﺃﻥ ﺗﻘﻮﻡ ﺑﺎﻟﺒﺤﺚ ﻋﻦ ﺍﳌﺮﺣﻠﺔ‬
‫ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ ‪ ،‬ﻭﻳﺘﻢ ﻫﺬﺍ ﻭﻓﻖ ﺍﳋﻄﻮﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫‪ .١‬ﲢﻤﻴﻞ ﺟﺪﻭﻝ ‪ Root Directory‬ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻣﻦ ﰒ ﺍﻟﺒﺤﺚ ﻋﻦ ﻣﻠﻒ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻭﺃﺧﺬ‬
‫ﺭﻗﻢ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻪ‪.‬‬
‫‪ .٢‬ﲢﻤﻴﻞ ﺟﺪﻭﻝ ‪ FAT‬ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻣﻦ ﰒ ﲢﻤﻴﻞ ﲨﻴﻊ ﺍﻟﻜﻠﺴﺘﺮﺍﺕ ﻟﻠﻤﻠﻒ‪.‬‬
‫‪ .٣‬ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺃﻭﻝ ﺑﺎﻳﺖ ﰲ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‪.‬‬

‫ﺇﻧﺸﺎء ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺑﺪﺍﻳﺔ ﺳﻨﻘﻮﻡ ﺑﺈﻧﺸﺎء ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﻧﺴﺨﻬﺎ ﺍﱃ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ‪ ،‬ﻭﻧﻈﺮﴽ ﻻﻥ ﺗﻄﻮﻳﺮ ﻧﻈﺎﻣﻨﺎ ﺍﳋﺎﺹ‬
‫ﳚﺐ ﺍﻥ ﻳﺘﻢ ﲢﺖ ﻧﻈﺎﻡ ﺁﺧﺮ ﻓﺎﻥ ﻫﺬﺍ ﺍﻟﻨﻈﺎﻡ ﺍﻵﺧﺮ ﻏﺎﻟﺒﺎ ﻣﺎ ﳛﻮﻱ ﺩﺭﺍﻳﻔﺮ ﻟﻨﻈﺎﻡ ﻣﻠﻔﺎﺕ ‪ FAT12‬ﺣﻴﺚ ﻳﺘﻜﻔﻞ‬
‫ﺑﻌﻤﻠﻴﺔ ﻛﺘﺎﺑﺔ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﱃ ﺟﺪﻭﻝ ‪ Root Directory‬ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﺍﻟﺒﺤﺚ ﻋﻦ ﻛﻠﺴﺘﺮﺍﺕ ﺧﺎﻟﻴﺔ ﰲ ﺟﺪﻭﻝ ‪FAT‬‬
‫ﺩﻭﻥ ﺃﻱ ﺗﺪﺧﻞ ﻣﻦ ﻗﺒﻞ ﻣﻄﻮﺭ ﺍﻟﻨﻈﺎﻡ ﺍﳉﺪﻳﺪ‪ ،‬ﻟﺬﻟﻚ ﰲ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ ﻣﻦ ﺍﻟﺘﻄﻮﻳﺮ ﺳﻨﺘﺠﺎﻫﻞ ﺟﺰﺋﻴﺔ ﺍﻟﻜﺘﺎﺑﺔ ﰲ‬
‫ﻧﻈﺎﻡ ‪ FAT12‬ﻭﻧﺘﺮﻙ ﺍﳌﻬﻤﺔ ﻟﻨﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺍﻟﺬﻱ ﻧﻌﺘﻤﺪ ﻋﻠﻴﻪ ﰲ ﻋﻤﻠﻴﺔ ﺗﻄﻮﻳﺮ ﺍﻟﻨﻈﺎﻡ ﺍﳉﺪﻳﺪ ‪ ،‬ﻭ‪‬ﺬﺍ ﺳﻴﻜﻮﻥ‬
‫ﺍﻟﺪﺭﺍﻳﻔﺮ ﺍﻟﺬﻱ ﺳﻨﻨﺸﺌﻪ ﰲ ﻫﺬﺍ ﺍﻟﻔﺼﻞ ﻣﺎ ﻫﻮ ﺍﻻ ﺟﺰء ﻣﻦ ﺍﻟﺪﺭﺍﻳﻔﺮ ﺍﻟﻜﺎﻣﻞ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﺗﻜﻠﻤﺘﻪ ﻻﺣﻘﺎ ﲟﺸﻴﺌﺔ‬
‫ﺍﷲ‪.‬ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻣﺜﺎﻝ ﻟﻠﻤﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﺍﳌﺤﻤﻞ ﻟﻌﺮﺽ ﺭﺳﺎﻟﺔ ﺑﺴﻴﻄﺔ‪.‬‬
‫‪Example‬‬ ‫‪٣.٩: Hello Stage2‬‬
‫‪١‬‬ ‫‪; Second Stage Bootloader.‬‬
‫‪٢‬‬ ‫‪; loaded by stage1.bin at address 0x050:0x0 (0x00500).‬‬
‫‪٣‬‬

‫‪٥٥‬‬
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

٤
٥ bits 16 ; 16−bit real mode.
٦ org 0x0 ; offset to zero.
٧
٨ start: jmp stage2
٩
١٠
١١ ; data and variable
١٢ hello msg db "Welcome to eqraOS Stage2",0xa,0xd,0
١٣
١٤ ; include files:
١٥ %include "stdio.inc" ; standard i/o routines.
١٦
١٧
١٨
١٩
٢٠ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢١ ; entry point of stage2 bootloader.
٢٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٣
٢٤ stage2:
٢٥
٢٦ push cs
٢٧ pop ds ; ds = cs.
٢٨
٢٩ mov si,hello msg
٣٠ call puts16
٣١
٣٢ cli ; clear interrupt.
٣٣ hlt ; halt the system.

stage2.sys ‫ ﺃﻣﺎ ﺍﳌﻠﻒ ﺍﻟﻨﺎﺗﺞ ﻣﻦ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺠﻤﻴﻊ ﺳﻴﻜﻮﻥ ﺑﺎﻻﺳﻢ‬stage2.asm ‫ﻭﺳﻴﺘﻢ ﺗﺴﻤﻴﺔ ﺍﳌﻠﻒ ﺑﺎﻻﺳﻢ‬
‫ ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻥ‬، ‫ ﺣﺮﻭﻑ‬3 ‫ ﺣﺮﻭﻑ ﻭﺍﻻﻣﺘﺪﺍﺩ ﻋﻦ‬8 ‫ﻭﳝﻜﻦ ﺗﺴﻤﻴﺘﻪ ﺑﺄﻱ ﺍﺳﻢ ﺍﺧﺮ ﺑﺸﺮﻁ ﺃﻥ ﻻ ﻳﺰﻳﺪ ﺍﻻﺳﻢ ﻋﻦ‬
.Root Directory ‫ ﺣﱴ ﻻ ﻳﺘﻀﺮﺭ ﺟﺪﻭﻝ‬Spaces ‫ ﺳﻴﻘﻮﻡ ﺑﺎﺿﺎﻓﺔ ﻣﺴﺎﻓﺎﺕ‬FAT12 ‫ﻃﻮﻝ ﺍﻻﺳﻢ ﺃﻗﻞ ﻓﺎﻥ ﺩﺭﺍﻳﻔﺮ‬
(FAT12 ‫ﻭﳝﻜﻨﻨﺎ ﺃﻥ ﻧﻔﺮﻕ ﺑﲔ ﺍﲰﺎء ﺍﳌﻠﻔﺎﺕ ﺍﻟﺪﺍﺧﻠﻴﺔ )ﻭﻫﻲ ﺍﻟﱵ ﻳﺘﻢ ﺍﺿﺎﻓﺔ ﻣﺴﺎﻓﺎﺕ ﻋﻠﻴﻬﺎ ﻭﻳﺴﺘﺨﺪﻣﻬﺎ ﻧﻈﺎﻡ‬
.(‫ﻭﺍﻷﲰﺎء ﺍﳋﺎﺭﺟﻴﺔ )ﻭﻫﻲ ﺍﻟﱵ ﻳﻨﺸﺌﻬﺎ ﺍﳌﺴﺘﺨﺪﻡ‬

٥٦
FAT12 ‫ ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬.٥.٣

‫ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ‬Root Directory ‫ﲢﻤﻴﻞ ﺍﻝ‬

‫ ﳛﻮﻱ ﺃﲰﺎء ﻛﻞ ﺍﳌﻠﻔﺎﺕ ﻭ ﺃﻣﺎﻛﻦ ﺗﻮﺍﺟﺪﻫﺎ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﻟﺬﺍ ﳚﺐ ﲢﻤﻴﻠﻪ ﺃﻭﻻ ﻭﺍﻟﺒﺤﺚ‬Root Directory ‫ﺟﺪﻭﻝ‬
‫( ﻭﻋﻨﺪ ﺍﻟﺒﺤﺚ ﳚﺐ ﺍﻟﺒﺤﺚ ﺑﺎﻻﺳﻢ ﺍﻟﺪﺍﺧﻠﻲ ﺍﻟﺬﻱ‬stage2.sys ‫ﻋﻦ ﻣﻠﻒ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ )ﺫﻭ ﺍﻻﺳﻢ ﺍﳋﺎﺭﺟﻲ‬
.‫ ﻭﻧﺄﰐ ﺑﺮﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﺍﻷﻭﻝ ﻟﻠﻤﻠﻒ‬، "stage2 sys" ‫ﻳﺴﺘﺨﺪﻣﻪ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻟﺬﻟﻚ ﳚﺐ ﺃﻥ ﻧﺒﺤﺚ ﻋﻦ ﺍﳌﻠﻒ‬
‫ﻭﻗﺒﻞ ﲢﻤﻴﻞ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻓﺎﻧﻪ ﳚﺐ ﻋﻠﻴﻨﺎ ﺃﻭﻻﹰ ﻣﻌﺮﻓﺔ ﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻗﻄﺎﻉ ﻓﻴﻪ ﻭﺣﺴﺎﺏ ﻋﺪﺩ ﺍﻟﻘﻄﺎﻋﺎﺕ ﺍﻟﱵ ﻳﺸﻐﻠﻬﺎ‬
‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ‬.‫( ﻟﻜﻲ ﻳﺘﻢ ﻧﻘﻞ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﺍﻟﻴﻬﺎ‬Buffer) ‫ ﻛﺬﻟﻚ ﳚﺐ ﲢﺪﻳﺪ ﺍﳌﺴﺎﺣﺔ ﺍﳋﺎﻟﻴﺔ‬، ‫ﻫﺬﺍ ﺍﳉﺪﻭﻝ‬
.‫ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﻋﻤﻞ ﺫﻟﻚ‬
Example ٣.١٠: Load Root directory
١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢ ; Compute Root Directory Size
٣ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٤
٥ xor cx,cx
٦ mov ax,32 ; every root entry size are 32 byte.
٧ mul word[root directory] ; dx:ax = 32∗224 bytes
٨ div word[bytes per sector]
٩ xchg ax,cx ; cx = number of sectors to load.
١٠
١١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
١٢ ; Get start sector of root directory
١٣ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
١٤
١٥ mov al,byte[total fats] ; there are 2 fats.
١٦ mul word[sectors per fat] ; 9∗2 sectors
١٧ add ax,word[reserved sectors] ; ax = start sector of root
directory.
١٨
١٩ mov word[data region],ax
٢٠ add word[data region],cx ; data region = start sector of data.
٢١
٢٢
٢٣ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٤ ; Load Root Dir at 0x07c0:0x0200 above bootloader.
٢٥ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٦
٢٧ mov bx,0x0200 ; es:bs = 0x07c0:0x0200.
٢٨ call read sectors

٥٧
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

‫ﺑﻌﺪ ﲢﻤﻴﻞ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﳚﺐ ﺍﻟﺒﺤﺚ ﻓﻴﻪ ﻋﻦ ﺍﺳﻢ ﻣﻠﻒ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﻣﻦ ﰒ ﺣﻔﻆ ﺭﻗﻢ ﺃﻭﻝ‬
‫ ﺃﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻠﻒ ﻏﲑ ﻣﻮﺟﻮﺩ ﻓﻨﺼﺪﺭ ﺭﺳﺎﻟﺔ ﺧﻄﺄ ﻭﻧﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ‬، ‫ﻛﻠﺴﺘﺮ ﻟﻪ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺍﳌﻠﻒ ﻣﻮﺟﻮﺩﴽ‬
.‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﺫﻟﻚ‬.‫ﻋﻦ ﺍﻟﻌﻤﻞ‬
Example ٣.١١: Find Stage2 Bootloader
١ ;−−−−−−−−−−−−−−−−−−−
٢ ; Find stage2.sys
٣ ;−−−−−−−−−−−−−−−−−−−
٤
٥ mov di,0x0200 ; di point to first entry in root dir.
٦ mov cx,word[root directory] ; loop 224 time.
٧
٨ find stage2:
٩
١٠ mov si,kernel loader name
١١ push cx
١٢ push di
١٣ mov cx,11 ; file name are 11 char long.
١٤
١٥ rep cmpsb
١٦ pop di
١٧ je find successfully
١٨
١٩ mov di,32 ; point to next entry.
٢٠ pop cx
٢١
٢٢ loop find stage2
٢٣
٢٤ ; no found ?
٢٥ jmp find fail
٢٦
٢٧ find successfully:
٢٨ ;−−−−−−−−−−−−−−−−−−−−−
٢٩ ; Get first Cluster.
٣٠ ;−−−−−−−−−−−−−−−−−−−−−
٣١
٣٢ mov ax,word[di+26] ; 27 byte in the di entry are cluster
number.
٣٣ mov word[cluster number],ax

٥٨
‫‪FAT12‬‬ ‫‪ .٥.٣‬ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬

‫ﲢﻤﻴﻞ ﺟﺪﻭﻝ ‪ FAT‬ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ‬

‫ﺟﺪﻭﻝ ‪ FAT‬ﻳﻮﺿﺢ ﺣﺎﻟﺔ ﻛﻞ ﺍﻟﻜﻠﺴﺘﺮﺍﺕ ﺍﳌﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﻟﻘﺮﺹ ﺳﻮﺍءﺍ ﻛﺎﻧﺖ ﺧﺎﻟﻴﺔ ﺃﻡ ﻣﻌﻄﻮﺑﺔ ﺃﻡ ﺍ‪‬ﺎ‬
‫ﻣﺴﺘﺨﺪﻣﺔ ‪ ،‬ﻭﳚﺐ ﲢﻤﻴﻞ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻲ ﻧﺴﺘﻄﻴﻊ ﻋﻦ ﻃﺮﻳﻖ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﺍﻟﺬﻱ ﲢﺼﻠﻨﺎ ﻋﻠﻴﻪ‬
‫ﻣﻦ ﺟﺪﻭﻝ ‪ Root Directory‬ﺃﻥ ﳓﻤﻞ ﲨﻴﻊ ﻛﻠﺴﺘﺮﺍﺕ ﺍﳌﻠﻒ‪ .‬ﻭﺑﻨﻔﺲ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﱵ ﻗﻤﻨﺎ ‪‬ﺎ ﻟﺘﺤﻤﻴﻞ ﺟﺪﻭﻝ‬
‫‪ Root Directory‬ﺳﻴﺘﻢ ‪‬ﺎ ﲢﻤﻴﻞ ﺟﺪﻭﻝ ‪ FAT‬ﺣﻴﺚ ﳚﺐ ﲢﺪﺩ ﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻗﻄﺎﻉ ﻟﻠﺠﺪﻭﻝ ﻭ ﻋﺪﺩ ﺍﻟﻘﻄﺎﻋﺎﺕ‬
‫ﺍﻟﱵ ﻳﺸﻐﻠﻬﺎ ﺍﳉﺪﻭﻝ ‪ ،‬ﻭﻛﺬﻟﻚ ﺍﳌﺴﺎﺣﺔ ﺍﳋﺎﻟﻴﺔ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻲ ﻳﺘﻢ ﺣﻔﻆ ﺍﳊﺪﻭﻝ ‪‬ﺎ ‪ .‬ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ‬
‫ﺫﻟﻚ‪.‬‬

‫‪Example‬‬ ‫‪٣.١٢: Load FAT Table‬‬

‫‪١‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٢‬‬ ‫‪; Compute FAT size‬‬
‫‪٣‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٤‬‬
‫‪٥‬‬ ‫‪xor cx,cx‬‬
‫‪٦‬‬ ‫‪xor ax,ax‬‬
‫‪٧‬‬ ‫‪xor dx,dx‬‬
‫‪٨‬‬
‫‪٩‬‬ ‫]‪mov al,byte[total fats‬‬ ‫‪; there are 2 fats.‬‬
‫‪١٠‬‬ ‫]‪mul word[sectors per fat‬‬ ‫‪; 9∗2 sectors‬‬
‫‪١١‬‬ ‫‪xchg ax,cx‬‬
‫‪١٢‬‬
‫‪١٣‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪١٤‬‬ ‫‪; Get start sector of FAT‬‬
‫‪١٥‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪١٦‬‬
‫‪١٧‬‬ ‫]‪add ax,word[reserved sectors‬‬
‫‪١٨‬‬
‫‪١٩‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٢٠‬‬ ‫‪; Load FAT at 0x07c0:0x0200‬‬
‫‪٢١‬‬ ‫‪; Overwrite Root dir with FAT, no need to Root Dir now.‬‬
‫‪٢٢‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٢٣‬‬
‫‪٢٤‬‬ ‫‪mov bx,0x0200‬‬
‫‪٢٥‬‬ ‫‪call read sectors‬‬

‫‪٥٩‬‬
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﲢﻤﻴﻞ ﻛﻠﺴﺘﺮﺍﺕ ﺍﳌﻠﻒ‬

‫ﻭﺣﺪﺓ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻟﻠﻘﺮﺹ ﺍﳌﺮﻥ ﻫﻲ ﺑﺎﻟﻘﻄﺎﻉ ‪ Sector‬ﻟﻜﻦ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ‪ FAT12‬ﻳﺘﻌﺎﻣﻞ ﻣﻊ ﳎﻤﻮﻋﺔ ﻣﻦ‬
‫ﺍﻟﻘﻄﺎﻋﺎﺕ ﻛﻜﺘﻠﺔ ﻭﺍﺣﺪﺓ ‪ ،Cluster‬ﻭﻛﻠﻤﺎ ﻛﱪ ﺣﺠﻢ ﺍﻟﻜﻠﺴﺘﺮ ﺯﺍﺩﺕ ﺍﳌﺴﺎﺣﺎﺕ ﺍﳋﺎﻟﻴﺔ ﺑﺪﺍﺧﻠﻪ ‪Internel‬‬
‫‪ Fragmenta on‬ﻟﺬﻟﻚ ﳚﺐ ﺍﺧﺘﻴﺎﺭ ﺣﺠﻢ ﻣﻼﺋﻢ ‪ ،‬ﻭﰲ ﺗﻨﻔﻴﺬ ﻧﻈﺎﻡ ‪ FAT12‬ﻋﻠﻰ ﻗﺮﺹ ﻣﺮﻥ ﺃﺧﺘﺮﻧﺎ ﺃﻥ ﻛﻞ‬
‫ﻛﻠﺴﺘﺮ ﻳﻘﺎﺑﻞ ﻗﻄﺎﻉ ﻭﺍﺣﺪ ﻓﻘﻂ ﻣﻦ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‪ .‬ﺍﳌﺸﻜﻠﺔ ﺍﻟﱵ ﺳﺘﻮﺍﺟﻬﻨﺎ ﻫﻲ ﻛﻴﻔﻴﺔ ﻗﺮﺍءﺓ ﻛﻠﺴﺘﺮ ﻣﻦ ﺍﻟﻘﺮﺹ‬
‫‪ ،‬ﻓﺎﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻻ ﻳﻘﺮﺃ ﺍﻱ ﻗﻄﺎﻉ ﺍﻻ ﺑﺘﺤﺪﻳﺪ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻄﻠﻖ ﻟﻪ ‪ Absolute Address‬ﻭﻟﺬﻟﻚ ﳚﺐ ﲢﻮﻳﻞ ﺭﻗﻢ‬
‫ﺍﻟﻜﻠﺴﺘﺮ ﺍﱃ ﻋﻨﻮﺍﻥ ﻣﻄﻠﻖ ﻭﲢﻮﻳﻞ ﻋﻨﻮﺍﻥ ‪ LBA‬ﺃﻳﻀﺎ ﺍﱃ ﻋﻨﻮﺍﻥ ﻣﻄﻠﻖ‪.‬‬
‫ﺍﻟﺘﺤﻮﻳﻞ ﻣﻦ ﺭﻗﻢ ‪ Cluster‬ﺍﱃ ﻋﻨﻮﺍﻥ ‪ LBA‬ﻳﺘﻢ ﻛﺎﻻﰐ‪:‬‬
‫‪Example‬‬ ‫‪٣.١٣: Convert Cluster number to LBA‬‬
‫; ‪١‬‬ ‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗‬
‫‪٢ ; cluster to lba: convert cluster number to LBA‬‬
‫; ‪٣‬‬ ‫‪input:‬‬
‫; ‪٤‬‬ ‫‪ax: Cluster number.‬‬
‫‪٥ ; output:‬‬
‫; ‪٦‬‬ ‫‪ax: lba number.‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٧‬‬
‫‪٨ cluster to lba:‬‬
‫‪٩‬‬
‫‪١٠‬‬ ‫‪; lba = (cluster − 2)∗ sectors per cluster‬‬
‫‪١١‬‬ ‫‪; the first cluster is always 2.‬‬
‫‪١٢‬‬
‫‪١٣‬‬ ‫‪sub ax,2‬‬
‫‪١٤‬‬
‫‪١٥‬‬ ‫‪xor cx,cx‬‬
‫‪١٦‬‬ ‫]‪mov cl, byte[sectors per cluster‬‬
‫‪١٧‬‬ ‫‪mul cx‬‬
‫‪١٨‬‬
‫‪١٩‬‬ ‫]‪add ax,word[data region‬‬ ‫‪; cluster start from data area.‬‬
‫‪٢٠‬‬ ‫‪ret‬‬

‫ﺣﻴﺚ ﻳﺘﻢ ﻃﺮﺡ ﺍﻟﻌﺪﺩ ‪ 2‬ﻣﻦ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﻭﻫﺬﺍ ﺑﺴﺒﺐ ﺃﻥ ﺃﻭﻝ ﺭﻗﻢ ﻛﻠﺴﺘﺮ ﰲ ﻧﻈﺎﻡ ‪ FAT12‬ﻫﻮ ‪ - 2‬ﻛﻤﺎ‬
‫ﺳﻨﺮﻯ ﺫﻟﻚ ﻻﺣﻘﺎ‪.-‬‬
‫ﻭﻟﻠﺘﺤﻮﻳﻞ ﻣﻦ ﻋﻨﻮﺍﻥ ‪ LBA‬ﺍﱃ ﻋﻨﻮﺍﻥ ‪: Absolute Address‬‬
‫‪Example‬‬ ‫‪٣.١٤: Convert LBA to CHS‬‬
‫; ‪١‬‬ ‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗‬
‫‪٢ ; lba to chs: Convert LBA to CHS.‬‬

‫‪٦٠‬‬
FAT12 ‫ ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬.٥.٣

٣ ; input:
٤ ; ax: LBA.
٥ ; output:
٦ ; absolute sector
٧ ; absolute track
٨ ; absolute head
٩ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١٠ lba to chs:
١١
١٢ ; absolute sector = (lba % sectors per track) + 1
١٣ ; absolute track = (lba / sectors per track) / number of heads
١٤ ; absolute head = (lba / sectors per track) % number of heads
١٥
١٦ xor dx,dx
١٧ div word[sectors per track]
١٨ inc dl
١٩ mov byte[absolute sector],dl
٢٠
٢١ xor dx,dx
٢٢ div word[number of heads]
٢٣ mov byte[absolute track],al
٢٤ mov byte[absolute head],dl
٢٥
٢٦ ret

‫ﻭﺑﻌﺪ ﺫﻟﻚ ﻧﻘﻮﻡ‬ Root Directory ‫ﻭﻟﺘﺤﻤﻴﻞ ﻛﻠﺴﺘﺮ ﻣﻦ ﺍﻟﻘﺮﺹ ﳚﺐ ﺃﻭﻻ ﺍﳊﺼﻮﻝ ﻋﻠﻰ ﺭﻗﻤﻪ ﻣﻦ ﺟﺪﻭﻝ‬
Abolsute Address ‫ ﺍﱃ ﻋﻨﻮﺍﻥ ﻣﻄﻠﻖ‬LBA ‫ ﻭﺑﻌﺪﻫﺎ ﻧﻘﻮﻡ ﺑﺘﺤﻮﻳﻞ ﻋﻨﻮﺍﻥ‬LBA ‫ﺑﺘﺤﻮﻳﻞ ﻫﺬﺍ ﺍﻟﺮﻗﻢ ﺍﱃ ﻋﻨﻮﺍﻥ‬
.‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﺫﻟﻚ‬،‫ ﻟﻘﺮﺍءﺓ ﺍﻟﻘﻄﺎﻋﺎﺕ ﻣﻦ ﺍﻟﻘﺮﺹ‬int 0x13 ‫ﻭﻣﻦ ﰒ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ‬
Example ٣.١٥: Load Cluster
١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢ ; Load all clusters(stage2.sys)
٣ ; At address 0x050:0x0
٤ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٥
٦ xor bx,bx
٧ mov ax,0x0050
٨ mov es,ax
٩
١٠ load cluster:

٦١
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

١١
١٢ mov ax,word[cluster number] ; ax = cluster number
١٣ call cluster to lba ; convert cluster number to LBA
addressing.
١٤
١٥ xor cx,cx
١٦ mov cl,byte[sectors per cluster] ; cx = 1 sector
١٧
١٨ call read sectors bios ; load cluster.

‫ ﻭﻫﻲ ﺗﻌﻤﻞ ﻓﻘﻂ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‬int 0x13 ‫ﻭﺩﺍﻟﺔ ﻗﺮﺍءﺓ ﺍﻟﻘﻄﺎﻋﺎﺕ ﻣﻦ ﺍﻟﻘﺮﺹ ﺗﺴﺘﺨﺪﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ‬
.32-bit ‫ﻭﳚﺐ ﺍﺳﺘﺒﺪﺍﳍﺎ ﻻﺣﻘﺎ ﻋﻨﺪ ﺍﻟﺘﺤﻮﻳﻞ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﺑﺪﺍﻟﺔ ﺍﺧﺮﻯ‬
Example ٣.١٦: Read Sectors Rou ne
١ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢ ; read sectors bios: load sector from floppy disk
٣ ; input:
٤ ; es:bx : Buffer to load sector.
٥ ; ax: first sector number ,LBA.
٦ ; cx: number of sectors.
٧ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٨ read sectors bios:
٩
١٠ begin:
١١ mov di,5 ; try 5 times to load any sector.
١٢
١٣ load sector:
١٤
١٥ push ax
١٦ push bx
١٧ push cx
١٨
١٩ call lba to chs
٢٠
٢١ mov ah,0x2 ; load sector routine number.
٢٢ mov al,0x1 ; 1 sector to read.
٢٣ mov ch,byte[absolute track] ; absolute track number.
٢٤ mov cl,byte[absolute sector] ; absolute sector number.
٢٥ mov dh,byte[absolute head] ; absolute head number.
٢٦ mov dl,byte[drive number] ; floppy drive number.

٦٢
FAT12 ‫ ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬.٥.٣

٢٧
٢٨ int 0x13 ; call BIOS.
٢٩
٣٠ jnc continue ; if no error jmp.
٣١
٣٢ ; reset the floppy and try read again.
٣٣
٣٤ mov ah,0x0 ; reset routine number.
٣٥ mov dl,0x0 ; floppy drive number.
٣٦ int 0x13 ; call BIOS.
٣٧
٣٨ pop cx
٣٩ pop bx
٤٠ pop ax
٤١
٤٢ dec di
٤٣ jne load sector
٤٤
٤٥ ; error.
٤٦ int 0x18
٤٧
٤٨ continue:
٤٩
٥٠ mov si,progress msg
٥١ call puts16
٥٢
٥٣ pop cx
٥٤ pop bx
٥٥ pop ax
٥٦
٥٧ add ax,1 ; next sector
٥٨ add bx,word[bytes per sector] ; point to next empty block in
buffer.
٥٩
٦٠
٦١ loop begin ; cx time
٦٢
٦٣ ret

‫ ﻭﻗﺮﺍءﺓ ﺍﻟﻘﻴﻤﺔ‬FAT ‫ﻭﻟﺘﺤﻤﻴﻞ ﺑﻘﻴﺔ ﻛﻠﺴﺘﺮﺍﺕ ﺍﳌﻠﻒ ﳚﺐ ﺃﺧﺬ ﺭﻗﻢ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻠﻤﻠﻒ ﻭﺍﻟﺬﻫﺎﺏ ﺑﻪ ﺍﱃ ﺟﺪﻭﻝ‬

٦٣
 ‫‪Bootloader‬‬ ‫‪ .٣‬ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬

‫ﺍﳌﻘﺎﺑﻠﺔ ﻟﻪ ﻭﺍﻟﱵ ﺳﺘﺪﻝ ﻋﻠﻰ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﻫﺬﺍ ﺁﺧﺮ ﻛﻠﺴﺘﺮ ﺃﻡ ﺃﻥ ﻫﻨﺎﻟﻚ ﻛﻠﺴﺘﺮﺍﺕ ﺍﺧﺮﻯ ﳚﺐ ﲢﻤﻴﻠﻬﺎ‪.‬ﻭﻳﻠﺰﻡ‬
‫ﺍﻷﺧﺬ ﺑﺎﻻﻋﺘﺒﺎﺭ ﺑﻨﻴﺔ ﺟﺪﻭﻝ ‪ FAT‬ﻭﺍﻧﻪ ﻳﺘﻜﻮﻥ ﻣﻦ ﺳﺠﻼﺕ ﺑﻄﻮﻝ ‪ 12‬ﺑﺖ ﻭﺗﻌﺎﺩﻝ ﺑﺎﻳﺖ ﻭﻧﺼﻒ ‪ ،‬ﺃﻱ ﺃﻧﻪ ﺍﺫﺍ‬
‫ﻛﺎﻥ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ‪ 0‬ﻓﺎﻧﻨﺎ ﳚﺐ ﺃﻥ ﻧﻘﺮﺃ ﺍﻟﺴﺠﻞ ﺍﻻﻭﻝ ﻣﻦ ﺟﺪﻭﻝ ‪ FAT‬ﻭﺑﺴﺒﺐ ﺍﻧﻪ ﻻ ﳝﻜﻦ ﻗﺮﺍءﺓ ‪12‬‬
‫ﺑﺖ ﻓﺴﻮﻑ ﺗﺘﻢ ﻗﺮﺍءﺓ ‪ 16‬ﺑﺖ )ﺍﻟﺴﺠﻞ ﺍﻻﻭﻝ ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﻧﺼﻒ ﺍﻟﺴﺠﻞ ﺍﻟﺜﺎﱐ( ﻭﻋﻤﻞ ‪ mask‬ﻻﺧﺮ ‪ 4‬ﺑﺖ‬
‫)ﻻﺯﺍﻟﺔ ﻣﺎ ﰎ ﻗﺮﺍﺋﺘﻪ ﻣﻦ ﺍﻟﺴﺠﻞ ﺍﻟﺜﺎﱐ(‪ .‬ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ‪ 1‬ﻓﻴﺠﺐ ﻗﺮﺍءﺓ ﺍﻟﺴﺠﻞ ﺍﻟﺜﺎﱐ ﻣﻦ‬
‫ﺟﺪﻭﻝ ‪ FAT‬ﻭﺍﻟﺬﻱ ﻳﺒﺪﺃ ﻣﻦ ﺍﻟﺒﺖ ‪ 23-12‬ﻭﺑﺴﺒﺐ ﺃﻧﻪ ﻻ ﳝﻜﻦ ﻗﺮﺍءﺓ ‪ 12‬ﺑﺖ ﺳﻨﻘﻮﻡ ﺑﻘﺮﺍءﺓ ‪ 16‬ﺑﺖ ﺃﻱ ﻣﻦ‬
‫ﺍﻟﺒﺖ ‪ 23-8‬ﻭﺍﺯﺍﻟﺔ ﺃﻭﻝ ‪ 4‬ﺑﺖ‪.‬‬
‫ﻭﺑﺎﺧﺘﺼﺎﺭ‪ ،‬ﻟﻘﺮﺍءﺓ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻘﺎﺑﻠﺔ ﻟﺮﻗﻢ ﻛﻠﺴﺘﺮ ﻣﺎ ﻓﻴﺠﺐ ﺃﻭﻻ ﺗﻄﺒﻴﻖ ﺍﻟﻘﺎﻧﻮﻥ ‪:‬‬
‫)‪cluster = cluster + (cluster/2‬‬

‫ﻭﻗﺮﺍءﺓ ‪ 16‬ﺑﺖ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ﺭﻗﻢ ﺯﻭﺟﻲ ﻓﻴﺠﺐ ﻋﻤﻞ ‪ Mask‬ﻻﺧﺮ ‪ 4‬ﺑﺖ ‪ ،‬ﺃﻣﺎ‬
‫ﺍﺫﺍ ﻛﺎﻥ ﺭﻗﻢ ﺍﻟﻜﻠﺴﺘﺮ ﻓﺮﺩﻱ ﻓﻴﺠﺐ ﺍﺯﺍﻟﺔ ﺃﻭﻝ ‪ 4‬ﺑﺖ ‪ .‬ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﲢﻤﻴﻞ ﲨﻴﻊ ﻛﻠﺴﺘﺮﺍﺕ‬
‫ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ ‪.‬‬
‫‪Example‬‬ ‫‪٣.١٧: Read FAT entry‬‬
‫‪١‬‬ ‫‪read cluster fat entry:‬‬
‫‪٢‬‬
‫‪٣‬‬ ‫]‪mov ax,word[cluster number‬‬
‫‪٤‬‬
‫‪٥‬‬ ‫;‬ ‫‪Every FAT entry are 12−bit long( byte and half one).‬‬
‫‪٦‬‬ ‫;‬ ‫‪so we must map the cluster number to this entry.‬‬
‫‪٧‬‬ ‫;‬ ‫‪to read cluster 0 we need to read fat[0].‬‬
‫‪٨‬‬ ‫;‬ ‫‪cluster 1 −> fat[1].‬‬
‫‪٩‬‬ ‫;‬ ‫‪cluster 2 −> fat[3],...etc.‬‬
‫‪١٠‬‬
‫‪١١‬‬ ‫‪mov‬‬ ‫‪cx,ax‬‬ ‫‪; cx = cluster number.‬‬
‫‪١٢‬‬ ‫‪shr‬‬ ‫‪cx,1‬‬ ‫‪; divide cx by 2.‬‬
‫‪١٣‬‬ ‫‪add‬‬ ‫‪cx,ax‬‬ ‫‪; cx = ax + (ax/2).‬‬
‫‪١٤‬‬ ‫‪mov‬‬ ‫‪di,cx‬‬
‫‪١٥‬‬ ‫‪add‬‬ ‫‪di,0x0200‬‬
‫‪١٦‬‬ ‫‪mov‬‬ ‫‪dx,word[di] ; read 16−bit form FAT.‬‬
‫‪١٧‬‬
‫‪١٨‬‬
‫‪١٩‬‬ ‫‪; Now, because FAT entry are 12−bit long, we should remove 4‬‬
‫‪bits.‬‬
‫‪٢٠‬‬ ‫‪; if the cluster number are even, we must mask the last four‬‬
‫‪bits.‬‬
‫‪٢١‬‬ ‫‪; if it odd, we must do four right shift.‬‬

‫‪٦٤‬‬
FAT12 ‫ ﻣﻘﺪﻣﺔ ﺍﱃ ﻧﻈﺎﻡ‬.٥.٣

٢٢
٢٣ test ax,1
٢٤ jne odd cluster
٢٥
٢٦ even cluster:
٢٧
٢٨ and dx,0x0fff
٢٩ jmp next cluster
٣٠
٣١ odd cluster:
٣٢
٣٣ shr dx,4
٣٤
٣٥
٣٦ next cluster:
٣٧ mov word[cluster number],dx ; next cluster to load.
٣٨
٣٩ cmp dx,0x0ff0 ; check end of file, last cluster?
٤٠ jb load cluster ; no, load the next cluster.
٤١
٤٢
٤٣ ; yes jmp to end
٤٤ jmp end of first stage
٤٥
٤٦ find fail:
٤٧
٤٨ mov si,fail msg
٤٩ call puts16
٥٠
٥١ mov ah,0x0
٥٢ int 0x16 ; wait keypress.
٥٣ int 0x19 ; warm boot.
٥٤
٥٥
٥٦ end of first stage:
٥٧
٥٨ ; jump to stage2 and begin execute.
٥٩ push 0x050 ; segment number.
٦٠ push 0x0 ; offset number.
٦١
٦٢ retf ; cs:ip = 0x050:0x0

٦٥
 Bootloader ‫ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻭﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٣

٦٣
٦٤ times 510−($−$$ ) db 0 ; append zeros.
٦٥
٦٦ ; finally the boot signature 0xaa55
٦٧ db 0x55
٦٨ db 0xaa

٦٦
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬
‫ﺑﺴﺒﺐ ﺍﻟﻘﻴﻮﺩ ﻋﻠﻰ ﺣﺠﻢ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻓﺎﻥ ﻫﺬﺍ ﻗﺪ ﺃﺩﻯ ﺍﱃ ﺗﻘﺴﻴﻢ ﺍﳌﻬﻤﺔ ﺍﱃ ﻣﺮﺣﻠﺘﲔ ﺣﻴﺚ ﺍﻗﺘﺼﺮﺕ ﻣﻬﻤﺔ‬
‫ﺍﳌﺮﺣﻠﺔ ﺍﻻﻭﱃ ﻋﻠﻰ ﲢﻤﻴﻞ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﺍﳌﺤﻤﻞ ‪ ،‬ﺃﻣﺎ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ‪ stage 2‬ﻓﻼ ﻗﻴﻮﺩ ﻋﻠﻴﻬﺎ ﻭﻏﺎﻟﺒﺎ ﻣﺎ ﻳﺘﻢ‬
‫ﺗﻨﻔﻴﺬ ﺍﳌﻬﻤﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﰲ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ‪:‬‬
‫ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‪.PMode‬‬ ‫•‬

‫ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪ A20‬ﻟﺪﻋﻢ ﺫﺍﻛﺮﺓ ﺣﱴ ‪ 4‬ﺟﻴﺠﺎ ﺑﺎﻳﺖ‪.‬‬ ‫•‬

‫ﺗﻮﻓﲑ ﺩﻭﺍﻝ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪.Interrupt Handler‬‬ ‫•‬

‫ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﻭﺍﻟﺘﺤﻜﻢ ﺍﻟﻴﻬﺎ‪.‬‬ ‫•‬

‫ﺗﻮﻓﲑ ﺧﺼﺎﺋﺺ ﺃﺛﻨﺎء ﺍﻹﻗﻼﻉ ﻣﺜﻞ ‪.Safe Mode‬‬ ‫•‬

‫‪ Mul‬ﻭﺫﻟﻚ ﻋﱪ ﻣﻠﻔﺎﺕ ﺍﻟﺘﻬﻴﺌﺔ‪.‬‬ ‫‪Boot‬‬ ‫ﺩﻋﻢ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‬ ‫•‬

‫‪ .١.٤‬ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬

‫ﺍﳌﺸﻜﻠﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ‪ Real Mode‬ﻫﻲ ﻋﺪﻡ ﺗﻮﻓﺮ ﲪﺎﻳﺔ ﻟﻠﺬﺍﻛﺮﺓ ﺣﻴﺚ ﳝﻜﻦ ﻷﻱ ﺑﺮﻧﺎﻣﺞ ﻳﻌﻤﻞ‬
‫ﺃﻥ ﻳﺼﻞ ﻷﻱ ﺟﺰء ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻛﺬﻟﻚ ﺃﻗﺼﻰ ﺣﺠﻢ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﻟﻪ ﻫﻮ ‪ 1‬ﻣﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻭﻻ ﻳﻮﺟﺪ‬
‫ﺩﻋﻢ ﻟﺘﻘﻨﻴﺔ ‪ Paging‬ﻭﻻ ﻟﻠﺬﺍﻛﺮﺓ ﺍﻟﻈﺎﻫﺮﻳﺔ ‪ Virtual Memory‬ﺣﱴ ﺗﻌﺪﺩ ﺍﻟﱪﺍﻣﺞ ﻻ ﻳﻮﺟﺪ ﺩﻋﻢ ﻟﻪ‪.‬‬
‫ﻛﻞ ﻫﺬﻩ ﺍﳌﺸﺎﻛﻞ ﰎ ﺣﻠﻬﺎ ﺑﺎﺿﺎﻓﺔ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﺍﱃ ﺍﳌﻌﺎﰿ ﻭﳝﻜﻦ ﺍﻻﻧﺘﻘﺎﻝ ﺑﺴﻬﻮﻟﺔ ﺍﱃ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻋﻦ‬
‫ﻃﺮﻳﻖ ﺗﻔﻌﻴﻞ ﺍﻟﺒﺖ ﺍﻻﻭﻝ ﰲ ﺍﳌﺴﺠﻞ ‪ ، cr0‬ﻭﻟﻜﻦ ﺑﺴﺒﺐ ﺃﻥ ﺍﳌﻌﺎﰿ ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻳﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﻋﻨﻮﻧﺔ‬
‫ﻟﻠﺬﺍﻛﺮﺓ ﲣﺘﻠﻒ ﻋﻦ ﺍﻟﻄﺮﻳﻘﺔ ﺍﳌﺴﺘﺨﺪﻣﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻓﺎﻧﻪ ﳚﺐ ﲡﻬﻴﺰ ﺑﻌﺾ ﺍﳉﺪﺍﻭﻝ ﺗﺴﻤﻰ ﺟﺪﺍﻭﻝ‬
‫ﺍﻟﻮﺍﺻﻔﺎﺕ ‪ Descriptor Table‬ﻭﺑﺪﻭﻥ ﲡﻬﻴﺰ ﻫﺬﻩ ﺍﳉﺪﺍﻭﻝ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﺳﻴﺼﺪﺭ ﺍﺳﺘﺜﻨﺎء ‪General Protec on‬‬
‫‪ Fault‬ﻭﺍﺧﺘﺼﺎﺭﴽ ‪ GPF‬ﻭﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻳﺆﺩﻱ ﺍﱃ ﺣﺪﻭﺙ ‪ triple fault‬ﻭﺗﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ‪.‬‬
‫ﺃﺣﺪ ﻫﺬﻩ ﺍﳉﺪﺍﻭﻝ ﻭﻳﺴﻤﻰ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ )‪ (Global Descriptor Table‬ﻭﺍﺧﺘﺼﺎﺭﴽ ‪ GDT‬ﻭﻇﻴﻔﺘﻪ‬
‫ﺍﻻﺳﺎﺳﻴﺔ ﻫﻲ ﺗﻌﺮﻳﻒ ﻛﻴﻔﻴﺔ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﺣﻴﺚ ﳛﺪﺩ ﻣﺎ ﻫﻮ ﺍﻟﻘﺴﻢ ﺍﻟﺬﻱ ﺳﻴﻨﻔﺬ ﻛﺸﻔﺮﺓ ؟ ﻭﻣﺎ ﻫﻮ‬
‫ﺍﻟﻘﺴﻢ ﺍﻟﺬﻱ ﳚﺐ ﺃﻥ ﳛﻮﻱ ﺑﻴﺎﻧﺎﺕ ؟ ﻭﳛﺪﺩ ﺃﻳﻀﺎ ﺑﺪﺍﻳﺔ ﻭ‪‬ﺎﻳﺔ ﻛﻞ ﻗﺴﻢ ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﺻﻼﺣﻴﺔ ﺍﻟﻮﺻﻮﻝ ﺍﱃ‬
‫ﺫﻟﻚ ﺍﻟﻘﺴﻢ‪.‬‬

‫‪٦٧‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪Global Descriptor Table‬‬ ‫‪ .١.١.٤‬ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ‬

‫‪GDT‬‬ ‫ﻋﻨﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪ PMode‬ﻓﺎﻥ ﺃﻱ ﻋﻤﻠﻴﺔ ﻭﺻﻮﻝ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺗﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﻫﺬﺍ ﺍﳉﺪﻭﻝ‬
‫‪ ،‬ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﻌﻤﻞ ﻋﻠﻰ ﲪﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺫﻟﻚ ﺑﻔﺤﺺ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﺮﺍﺩ ﺍﻟﻮﺻﻮﻝ ﺍﻟﻴﻪ ﻭﺍﻟﺘﺄﻛﺪ ﻣﻦ ﻋﺪﻡ ﳐﺎﻟﻔﺘﻪ‬
‫ﻟﺒﻴﺎﻧﺎﺕ ﻫﺬﺍ ﺍﳉﺪﻭﻝ‪.‬ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﲢﺪﺩ ﺍﻟﻘﺴﻢ ﺍﻟﺬﻱ ﳝﻜﻦ ﺃﻥ ﻳﻨﻔﺬ ﻛﺸﻔﺮﺓ )‪ (Code‬ﻭﺍﻟﻘﺴﻢ ﺍﻟﺬﻱ ﻻ ﻳﻨﻔﺬ‬
‫)‪ (Data‬ﻛﺬﻟﻚ ﲢﺪﺩ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﻛﻤﺎ ﺳﻨﺮﺍﻫﺎ ﺍﻻﻥ‪.‬‬
‫ﻭﻋﺎﺩﺓ ﻳﺘﻜﻮﻥ ﺟﺪﻭﻝ ‪ GDT‬ﻣﻦ ﺛﻼﺙ ﻭﺍﺻﻔﺎﺕ ‪) Descriptors‬ﺣﺠﻢ ﻛﻞٌ ﻣﻨﻬﺎ ﻫﻮ ‪ 64‬ﺑﺖ( ﻭﻫﻢ‪:‬‬
‫‪ :Null Descriptor‬ﺗﻜﻮﻥ ﻓﺎﺭﻏﺔ ﰲ ﺍﻟﻌﺎﺩﺓ‪.‬‬ ‫•‬

‫‪ :Code Descriptor‬ﺗﺼﻒ ﺧﺼﺎﺋﺺ ﺍﳌﻘﻄﻊ ﺃﻭ ﺍﻟﻘﺴﻢ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺬﻱ ﻳﻨﻔﺬ ﻛﺸﻔﺮﺓ ‪.Code‬‬ ‫•‬

‫‪ :Data Descriptor‬ﺗﺼﻒ ﺧﺼﺎﺋﺺ ﺍﳌﻘﻄﻊ ﺃﻭ ﺍﻟﻘﺴﻢ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺬﻱ ﻻ ﻳﻨﻔﺬ ﻭﳛﻮﻱ ﺑﻴﺎﻧﺎﺕ ‪.Data‬‬ ‫•‬

‫ﺑﻴﺎﻧﺎﺕ ﺃﻱ ﻭﺍﺻﻔﺔ ‪ Descriptor‬ﺗﺄﺧﺬ ﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ‪:‬‬

‫ﺍﻟﺒﺘﺎﺕ ‪ :15-0‬ﲢﻮﻱ ﺃﻭﻝ ﺑﺎﻳﺘﲔ )ﻣﻦ ﺑﺖ ‪ (15- 0‬ﻣﻦ ﺣﺠﻢ ﺍﳌﻘﻄﻊ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺘﺎﺕ ‪ :39-16‬ﲢﻮﻱ ﺃﻭﻝ ﺛﻼﺙ ﺑﺎﻳﺘﺎﺕ ﻣﻦ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ‪.Base Address‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :40‬ﺑﺖ ﺍﻟﻮﺻﻮﻝ ‪) Access Bit‬ﻳﺴﺘﺨﺪﻡ ﻣﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻈﺎﻫﺮﻳﺔ ‪.(Virtual Memory‬‬ ‫•‬

‫ﺍﻟﺒﺘﺎﺕ ‪ :41-43‬ﻧﻮﻉ ﺍﻟﻮﺍﺻﻔﺔ ‪:Descriptor Type‬‬ ‫•‬

‫– ﺍﻟﺒﺖ ‪ :41‬ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ‪:‬‬
‫∗ ‪ :Data Descriptor‬ﺍﻟﻘﻴﻤﺔ ‪ 0‬ﻟﻠﻘﺮﺍءﺓ ﻓﻘﻂ ﻭﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ‪.‬‬
‫∗ ‪ :Code Descriptor‬ﺍﻟﻘﻴﻤﺔ ‪ 0‬ﻟﻠﺘﻨﻔﻴﺬ ﻓﻘﻂ ‪ execute‬ﻭﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﺘﻨﻔﻴﺬ‪.‬‬
‫– ﺍﻟﺒﺖ ‪.Expansion direc on (Data segments), conforming (Code Segments) :42‬‬
‫– ﺍﻟﺒﺖ ‪ :43‬ﻗﺎﺑﻠﻴﺔ ﺍﻟﺘﻨﻔﻴﺬ‪:‬‬
‫∗ ‪ :0‬ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ ﻋﺒﺎﺭﺓ ﻋﻦ ﺑﻴﺎﻧﺎﺕ‪.‬‬
‫∗ ‪ :1‬ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ ﻋﺒﺎﺭﺓ ﻋﻦ ﺷﻔﺮﺓ‪.‬‬
‫ﺍﻟﺒﺖ ‪:Descriptor Bit :44‬‬ ‫•‬
‫– ‪.System descriptor:0‬‬
‫– ‪.Code or Data Descriptor :1‬‬
‫ﺍﻟﺒﺘﺎﺕ ‪ :46-45‬ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ‪Privilege Level‬‬ ‫•‬
‫– ‪.(Ring 0) Highest :0‬‬
‫– ‪.(Ring 3) Lowest :3‬‬

‫‪٦٨‬‬
‫ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬.١.٤

.Segment is in memory (Used with Virtual Memory) :47 ‫ﺍﻟﺒﺖ‬ •

.‫ ﻣﻦ ﺣﺠﻢ ﺍﳌﻘﻄﻊ‬19- 16 ‫ ﲢﻮﻱ ﺍﻟﺒﺖ‬:51-48 ‫ﺍﻟﺒﺘﺎﺕ‬ •

.‫ ﳏﺠﻮﺯﺓ‬:52 ‫ﺍﻟﺒﺖ‬ •

.‫ ﳏﺠﻮﺯﺓ‬:53 ‫ﺍﻟﺒﺖ‬ •

:Segment type ‫ ﻧﻮﻉ ﺍﳌﻘﻄﻊ‬:54 ‫ﺍﻟﺒﺖ‬ •

.‫ ﺑﺖ‬16 ‫ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ‬:0 –
.‫ ﺑﺖ‬32 ‫ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ‬:1 –
:Granularity :55 ‫ﺍﻟﺒﺖ‬ •
.None :0 –
.Limit gets mul plied by 4K :1 –
.Base Address ‫ ﻣﻦ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ‬32- 23 ‫ ﲢﻮﻱ ﺍﻟﺒﺖ‬:63-56 ‫ﺍﻟﺒﺘﺎﺕ‬ •

،Code and Data Descriptor ‫ﻭﰲ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ ﺳﻨﻘﻮﻡ ﺑﺒﻨﺎء ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻭﻳﺘﻜﻮﻥ ﻣﻦ ﻭﺍﺻﻔﺔ ﻟﻠﻜﻮﺩ ﻭﻟﻠﺒﻴﺎﻧﺎﺕ‬
.0xffffffff ‫ﲝﻴﺚ ﳝﻜﻦ ﺍﻟﻘﺮﺍءﺓ ﻭ ﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﺃﻭﻝ ﺑﺎﻳﺖ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﺍﱃ ﺁﺧﺮ ﺍﻟﺬﺍﻛﺮﺓ‬
Example ٤.١: GDT
١ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢ ; Global Descriptor Table
٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤
٥ begin of gdt:
٦
٧ ; Null Descriptor: start at 0x0.
٨
٩ dd 0x0 ; fill 8 byte with zero.
١٠ dd 0x0
١١
١٢ ; Code Descriptor: start at 0x8.
١٣
١٤ dw 0xffff ; limit low.
١٥ dw 0x0 ; base low.
١٦ db 0x0 ; base middle.
١٧ db 10011010b ; access byte.
١٨ db 11001111b ; granularity byte.
١٩ db 0x0 ; base high.

٦٩
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪٢٠‬‬
‫‪٢١ ; Data Descriptor: start at 0x10.‬‬
‫‪٢٢‬‬
‫‪٢٣‬‬ ‫‪dw‬‬ ‫‪0xffff‬‬ ‫‪; limit low.‬‬
‫‪٢٤‬‬ ‫‪dw‬‬ ‫‪0x0‬‬ ‫;‬ ‫‪base low.‬‬
‫‪٢٥‬‬ ‫‪db‬‬ ‫‪0x0‬‬ ‫;‬ ‫‪base middle.‬‬
‫‪٢٦‬‬ ‫‪db‬‬ ‫‪10010010b‬‬ ‫‪; access byte.‬‬
‫‪٢٧‬‬ ‫‪db‬‬ ‫‪11001111b‬‬ ‫‪; granularity byte.‬‬
‫‪٢٨‬‬ ‫‪db‬‬ ‫‪0x0‬‬ ‫;‬ ‫‪base high.‬‬
‫‪٢٩‬‬
‫‪٣٠ end of gdt:‬‬

‫ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﺒﺪﺃ ﺑﺎﻟﻮﺍﺻﻔﺔ ﺍﳋﺎﻟﻴﺔ ‪ Null Descriptor‬ﻭﺣﺠﻤﻬﺎ ‪ 8‬ﺑﺎﻳﺖ ﻭﻣﺘﺤﻮﻳﺎ‪‬ﺎ ﺗﻜﻮﻥ ﺻﻔﺮﴽ ﰲ ﺍﻟﻌﺎﺩﺓ ‪ ،‬ﺃﻣﺎ‬
‫ﺍﻟﻮﺍﺻﻔﺔ ﺍﻟﺘﺎﻟﻴﺔ ﳍﺎ ﻓﻬﻲ ﻭﺍﺻﻔﺔ ﻣﻘﻄﻊ ﺍﻟﺸﻔﺮﺓ ‪ Code Descriptor‬ﻭﺗﻮﺿﺢ ﺍﳌﻘﻄﻊ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺬﻱ ﺳﻴﺘﺴﺨﺪﻡ‬
‫ﻛﺸﻔﺮﺓ ﻭﻣﺎ ﻫﻲ ﺑﺪﺍﻳﺘﻪ ﻭﺣﺠﻤﻪ ﻭﺻﻼﺣﻴﺎﺕ ﺍﺳﺘﺨﺪﺍﻣﻪ ﺣﻴﺚ ﳝﻜﻦ ﺃﻥ ﻧﺴﻤﺢ ﻓﻘﻂ ﻟﻠﱪﺍﻣﺞ ﺍﻟﱵ ﺗﻌﻤﻞ ﻋﻠﻰ‬
‫ﻣﺴﺘﻮﻯ ﺍﻟﻨﻮﺍﺓ ‪ Kernel Mode‬ﺑﺎﻟﺪﺧﻮﻝ ﺍﱃ ﻫﺬﺍ ﺍﳌﻘﻄﻊ‪.‬ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺷﺮﺡ ﳌﺤﺘﻮﻳﺎﺕ ﻫﺬﻩ ﺍﻟﻮﺍﺻﻔﺔ ﻭﳝﻜﻨﻚ‬
‫ﺍﳌﻄﺎﺑﻘﺔ ﻣﻊ ﺍﳉﺪﻭﻝ ﺍﻟﺬﻱ ﻳﻮﺿﺢ ﺍﻟﺸﻜﻞ ﺍﻟﻌﺎﻡ ﻟﻜﻞ ﻭﺍﺻﻔﺔ‪.‬‬
‫ﺗﺒﺪﺃ ﻭﺍﺻﻔﺔ ﺍﻟﻜﻮﺩ ‪ Code Descriptor‬ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x8‬ﻭﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻬﻢ ﺟﺪﺍ ﺣﻴﺚ ﺳﻴﻜﻮﻥ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ‬
‫ﻫﻮ ﻗﻴﻤﺔ ﺍﳌﺴﺠﻞ ‪ ، CS‬ﻭﺍﻟﺒﺘﺎﺕ ﻣﻦ ‪ 15-0‬ﲢﺪﺩ ﺣﺠﻢ ﺍﳌﻘﻄﻊ ‪ Segment Limit‬ﻭﺍﻟﻘﻴﻤﺔ ﻫﻲ ‪ 0xffff‬ﺗﺪﻝ‬
‫ﻋﻠﻰ ﺃﻥ ﺃﻛﱪ ﺣﺠﻢ ﳝﻜﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻫﻮ ‪.0xffff‬‬
‫ﺍﻟﺒﺘﺎﺕ ﻣﻦ ‪ 39-16‬ﲤﺜﻞ ﺍﻟﺒﺘﺎﺕ ‪ 23-0‬ﻣﻦ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ‪ Base Address‬ﻭﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﰎ ﺍﺧﺘﻴﺎﺭﻫﺎ ﻫﻲ‬
‫‪ 0x0‬ﻭﺑﺎﻟﺘﺎﱄ ﻧﻌﺮﻑ ﺃﻥ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ ﻫﻮ ‪ 0x0‬ﻭﻋﻨﻮﺍﻥ ﺍﻟﻨﻬﺎﻳﺔ ‪. 0xffff‬‬
‫ﺍﻟﺒﺎﻳﺖ ﺭﻗﻢ ‪ 6‬ﻭﻳﺴﻤﻰ ‪ Access Byte‬ﳛﺪﺩ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺗﻮﺿﻴﺢ ﳌﻌﲎ ﻛﻞ ﺑﺖ ﻣﻮﺟﻮﺩﺓ‬
‫ﻓﻴﻪ‪:‬‬
‫• ﺍﻟﺒﺖ ‪ Access Bit :0‬ﻭﻳﺴﺘﺨﺪﻡ ﻣﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻈﺎﻫﺮﻳﺔ ﻟﺬﻟﻚ ﺍﺧﺘﺮﻧﺎ ﺍﻟﻘﻴﻤﺔ ‪.0‬‬
‫ﺍﻟﺒﺖ ‪ :1‬ﺑﺖ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ‪ ،‬ﻭﰎ ﺍﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﺬﺍ ﳝﻜﻦ ﻗﺮﺍءﺓ ﻭﺗﻨﻔﻴﺬ ﺃﻱ ﺑﺎﻳﺖ ﻣﻮﺟﻮﺩﺓ ﰲ‬ ‫•‬
‫ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ ﻣﻦ ‪.0xffff-0x0‬‬
‫‪ expansion direc‬ﻻ ﻳﻬﻢ ﺣﺎﻟﻴﺎ ﻟﺬﺍ ﺍﻟﻘﻴﻤﺔ ﻫﻲ ‪.0‬‬ ‫‪on :2‬‬ ‫ﺍﻟﺒﺖ‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :3‬ﰎ ﺍﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﺬﺍ ﻣﻘﻄﻊ ﺷﻔﺮﺓ ‪.Code Segment‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :4‬ﰎ ﺍﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﺬﺍ ﻣﻘﻄﻊ ﻟﻠﺸﻔﺮﺓ ﺍﻭ ﻟﻠﺒﻴﺎﻧﺎﺕ ﻭﻟﻴﺲ ﻟﻠﻨﻈﺎﻡ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺘﺎﺕ ‪ :6-5‬ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ﻭﰎ ﺍﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 0‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﺬﺍ ﺍﳌﻘﻄﻊ ﻳﺴﺘﺨﺪﻡ ﻓﻘﻂ ﰲ ﺍﳊﻠﻘﺔ‬ ‫•‬
‫ﺻﻔﺮ ‪ Ring0‬ﺃﻭ ﻣﺎ ﻳﺴﻤﻰ ‪.Kernel Mode‬‬
‫ﺍﻟﺒﺖ ‪ :7‬ﺗﺴﺘﺨﺪﻡ ﻣﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻈﺎﻫﺮﻳﺔ ﻟﺬﺍ ﰎ ﺍﳘﺎﳍﺎ‪.‬‬ ‫•‬

‫‪٧٠‬‬
‫‪ .١.٤‬ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬

‫ﺍﻟﺒﺎﻳﺖ ﺭﻗﻢ ‪ 7‬ﻭﻳﺴﻤﻰ ‪ granularity‬ﳛﺪﺩ ﺃﻳﻀﺎ ﺑﻌﺾ ﺍﳋﺼﺎﺋﺺ‪ ،‬ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺗﻮﺿﻴﺢ ﳌﻌﲎ ﻛﻞ ﺑﺖ ﻣﻮﺟﻮﺩﺓ‬
‫ﻓﻴﻪ‪:‬‬
‫ﺍﻟﺒﺘﺎﺕ ‪ :3-0‬ﲤﺜﻞ ﺍﻟﺒﺘﺎﺕ ﻣﻦ ‪ 19-16‬ﻣﻦ ‪‬ﺎﻳﺔ ﺣﺠﻢ ﺍﳌﻘﻄﻊ ‪ Segment Limit‬ﻭﺍﻟﻘﻴﻤﺔ ﻫﻲ ‪، 0xf‬‬ ‫•‬
‫ﻭ‪‬ﺬﺍ ﻳﻜﻮﻥ ﺃﻗﺼﻰ ﻋﻨﻮﺍﻥ ﻟﻠﻤﻘﻄﻊ ﻫﻮ ‪ 0xfffff‬ﺃﻱ ‪ 1‬ﻣﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻭﻻﺣﻘﴼ ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﺗﻔﻌﻴﻞ‬
‫ﺑﻮﺍﺑﺔ ‪ A20‬ﺳﻨﺘﻤﻜﻦ ﻣﻦ ﺍﻟﻮﺻﻮﻝ ﺣﱴ ‪ 4‬ﺟﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬
‫ﺍﻟﺒﺘﺎﺕ ‪ :5-4‬ﳏﺠﻮﺯﺓ ﻟﻠﻨﻈﺎﻡ ﻟﺬﺍ ﰎ ﺍﳘﺎﳍﺎ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :6‬ﰎ ﺍﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺩﻻﻟﺔ ﻋﻠﻰ ﻫﺬﺍ ﺍﳌﻘﻄﻊ ﻫﻮ ‪ 32‬ﺑﺖ‪.‬‬ ‫•‬

‫‪.4‬‬ ‫‪KB‬‬ ‫ﺍﻟﺒﺖ ‪ :7‬ﺑﺎﺧﺘﻴﺎﺭ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﺳﻴﺘﻢ ﺇﺣﺎﻃﺔ ﺍﳌﻘﻄﻊ ﺏ‬ ‫•‬

‫ﺍﻟﺒﺎﻳﺖ ﺍﻻﺧﲑ ﰲ ﻭﺍﺻﻔﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ )ﺍﻟﺒﺎﻳﺖ ﺭﻗﻢ ‪ (8‬ﳝﺜﻞ ﺍﻟﺒﺘﺎﺕ ﻣﻦ ‪ 32-24‬ﻣﻦ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ‬
‫ﻭﺍﻟﻘﻴﻤﺔ ﻫﻲ ‪ 0x0‬ﻭﺑﺎﻟﺘﺎﱄ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ ﺍﻟﻜﻠﻲ ﻫﻮ ‪ 0x0‬ﺃﻱ ﻣﻦ ﺃﻭﻝ ﺑﺎﻳﺖ ﰲ ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬
‫ﺇﺫﴽ ﻭﺍﺻﻔﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ ‪ Code Descriptor‬ﺣﺪﺩﺕ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻣﻘﻄﻊ ﺍﻟﻜﻮﺩ ﻭ‪‬ﺎﻳﺘﻪ ﻭﻛﺬﻟﻚ ﺻﻼﺣﻴﺔ ﺍﻟﺘﻨﻔﻴﺬ‬
‫ﻭﺣﺪﺩﺕ ﺑﺄﻥ ﺍﳌﻘﻄﻊ ﻫﻮ ﻣﻘﻄﻊ ﻛﻮﺩ ‪.Code Segment‬‬
‫ﺍﻟﻮﺍﺻﻔﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻫﻲ ﻭﺍﺻﻔﺔ ﻣﻘﻄﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ Data Descriptor‬ﻭﺗﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ﺭﻗﻢ ‪ 0x10‬ﻭﻫﻲ ﻣﺸﺎ‪‬ﺔ ﲤﺎﻣﺎ‬
‫ﻟﻮﺍﺻﻔﺔ ﺍﻟﻜﻮﺩ ﺑﺎﺳﺘﺜﻨﺎء ﺍﻟﺒﺖ ﺭﻗﻢ ‪ 43‬ﺣﻴﺚ ﳛﺪﺩ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ ﻛﻮﺩ ﺃﻡ ﺑﻴﺎﻧﺎﺕ‪.‬‬
‫ﻭﺑﻌﺪ ﺇﻧﺸﺎء ﻫﺬﺍ ﺍﳉﺪﻭﻝ )‪ (GDT‬ﰲ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﳚﺐ ﺃﻥ ﻳ‪‬ﺤﻤِﻞ ﺍﳌﺴﺠﻞ ‪ gdtr‬ﻋﻠﻰ ﺣﺠﻢ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻧﺎﻗﺼﺎ‬
‫ﻭﺍﺣﺪ ﻭﻋﻠﻰ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳉﺪﻭﻝ‪ ،‬ﻭﻳﺘﻢ ﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺇﻧﺸﺎء ﻣﺆﺷﺮﺍ ﺍﱃ ﺟﺪﻭﻝ ‪ GDT‬ﻭﻣﻦ ﰒ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻻﻣﺮ‬
‫‪) lgdt‬ﻭﻫﻮ ﺃﻣﺮ ﻳﻌﻤﻞ ﻓﻘﻂ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ‪ ، (Ring0‬ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﺫﻟﻚ‪.‬‬
‫‪Example‬‬ ‫‪٤.٢: Load GDT into GDTR‬‬
‫‪١‬‬
‫‪٢ bits‬‬ ‫‪16‬‬ ‫‪; real mode.‬‬
‫‪٣‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٤‬‬
‫‪٥ ; load gdt: Load GDT into GDTR.‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٦‬‬
‫‪٧‬‬
‫‪٨ load gdt:‬‬
‫‪٩‬‬
‫‪١٠‬‬ ‫‪cli‬‬ ‫‪; clear interrupt.‬‬
‫‪١١‬‬ ‫‪pusha‬‬ ‫‪; save registers‬‬
‫‪١٢‬‬ ‫]‪lgdt [gdt ptr‬‬ ‫‪; load gdt into gdtr‬‬
‫‪١٣‬‬ ‫‪sti‬‬ ‫‪; enable interrupt‬‬
‫‪١٤‬‬ ‫‪popa‬‬ ‫‪; restore registers.‬‬
‫‪١٥‬‬

‫‪٧١‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪١٦‬‬ ‫‪ret‬‬
‫‪١٧‬‬
‫‪١٨‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٩‬‬
‫‪٢٠ ; gdt ptr: data structure used by gdtr‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٢١‬‬
‫‪٢٢‬‬
‫‪٢٣ gdt ptr:‬‬
‫‪٢٤‬‬
‫‪٢٥‬‬ ‫‪dw end of gdt − begin of gdt − 1‬‬ ‫‪; size −1‬‬
‫‪٢٦‬‬ ‫‪dd begin of gdt‬‬ ‫‪; base of gdt‬‬

‫‪PMode Memory Addressing‬‬ ‫‪ .٢.١.٤‬ﺍﻟﻌﻨﻮﻧﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬

‫ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻳﺴﺘﺨﺪﻡ ﺍﳌﻌﺎﰿ ﻋﻨﻮﻧﺔ ‪ Segment:Offset‬ﻭﺫﻟﻚ ﺑﺄﻥ ﺗﻜﻮﻥ ﺃﻱ ﻣﻦ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ‬
‫)‪ (Segments Registers‬ﲢﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ‪ ،‬ﻭﻣﺴﺠﻼﺕ ﺍﻟﻌﻨﺎﻭﻳﻦ ﲢﻮﻱ ﺍﻟﻌﻨﻮﺍﻥ ﺩﺍﺧﻞ ﻣﻘﻄﻊ ﻣﺎ ‪،‬‬
‫ﻭﻳﺘﻢ ﺿﺮﺏ ﻋﻨﻮﺍﻥ ﺍﳌﻘﻄﻊ ﺑﺎﻟﻌﺪﺩ ‪ 0x10‬ﻭﲨﻊ ﺍﻝ ‪ offset‬ﺍﻟﻴﻪ ﻟﻠﺤﺼﻮﻝ ﻋﻠﻰ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻨﻬﺎﺋﻲ ﻭﺍﻟﺬﻱ ﺳﻴﻤﺮ‬
‫ﺑﺪﺍﺧﻞ ﻣﺴﺎﺭ ﺍﻟﻌﻨﻮﺍﻥ ‪.Address Bus‬‬
‫ﺃﻣﺎ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪ PMode‬ﻓﺎﻧﻪ ﻳﺴﺘﺨﺪﻡ ﻋﻨﻮﻧﺔ ‪ Descriptor:Offset‬ﻭﺫﻟﻚ ﺑﺄﻥ ﺗﻜﻮﻥ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﲢﻮﻱ‬
‫ﻋﻨﻮﺍﻥ ﺃﺣﺪ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﱵ ﻗﻤﻨﺎ ﺑﺒﻨﺎﺋﻬﺎ )ﻣﺜﻼ ﻣﺴﺠﻞ ‪ CS‬ﳛﻮﻱ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x8‬ﻭﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ DS‬ﳛﻮﻱ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ‪ ، (0x10‬ﻭﺍﻝ ‪ offset‬ﺳﻴﺘﻢ ﲨﻌﻬﺎ ﺍﱃ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ‪ Base Address‬ﻭﺍﻟﺬﻱ ﻗﻤﻨﺎ ﺑﺘﺤﺪﻳﺪﻩ ﰲ‬
‫ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﻛﺬﻟﻚ ﺳﻴﺘﻢ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃﻥ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻻ ﻳﺘﺠﺎﻭﺯ ﺣﺠﻢ ﺍﳌﻘﻄﻊ ‪ Segment Limit‬ﺃﻳﻀﺎ‬
‫ﺳﻴﺘﻢ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﻣﺴﺘﻮﻯ ﺍﻟﺼﻼﺣﻴﺔ ﻭﺃﻧﻪ ﳝﻜﻦ ﺍﻟﻮﺻﻮﻝ ﻟﻠﻌﻨﻮﺍﻥ ﺍﳌﻄﻠﻮﺏ‪ .‬ﻭﻧﻈﺮﴽ ﻻﻥ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﳝﻜﻦ‬
‫ﺍﺳﺘﺨﺪﺍﻡ ﻣﺴﺠﻼﺕ ‪ 32-bit‬ﻓﺎﻧﻪ ﳝﻜﻦ ﻋﻨﻮﻧﺔ ‪ 4‬ﺟﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪.١‬‬

‫‪ .٣.١.٤‬ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬

‫ﺑﻌﺪ ﺇﻧﺸﺎء ﺟﺪﻭﻝ ‪ GDT‬ﻭﲢﻤﻴﻞ ﻣﺴﺠﻞ ‪ GDTR‬ﳝﻜﻦ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻋﻦ ﻃﺮﻳﻖ ﺗﻔﻌﻴﻞ ﺍﻟﺒﺖ ﺍﻻﻭﻝ‬
‫ﰲ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ ‪ ،cr0‬ﻭﻛﻤﺎ ﻫﻮ ﻣﻌﺮﻭﻑ ﺃﻥ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻻ ﻳﺴﺘﺨﺪﻡ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﻟﺬﺍ ﳚﺐ ﺗﻌﻄﻴﻞ‬
‫ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻗﺒﻞ ﺍﻻﻧﺘﻘﺎﻝ ﺣﱴ ﻻ ﲢﺪﺙ ﺃﻱ ﻣﺸﺎﻛﻞ‪.‬‬
‫ﻭﺑﻌﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻓﺎﻥ ﳚﺐ ﺗﻌﻴﲔ ﺍﻟﻮﺍﺻﻔﺔ ﺍﻟﱵ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﳌﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ‪ ،‬ﻭﺑﺎﻟﻨﺴﺒﺔ‬
‫ﳌﺴﺠﻞ ‪ CS‬ﻓﺎﻧﻪ ﳝﻜﻦ ﺗﻌﺪﻳﻞ ﻗﻴﻤﺘﻪ ﻭﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺗﻨﻔﻴﺬ ‪، far jump‬ﻭﺍﻟﻜﻮﺩ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺍﻻﻧﺘﻘﺎﻝ‬
‫ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻭﺗﻌﺪﻳﻞ ﻗﻴﻢ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ‪.‬‬
‫‪١‬ﺑﻔﺮﺽ ﺃﻥ ﺑﻮﺍﺑﺔ ‪ A20‬ﰎ ﺗﻔﻌﻴﻠﻬﺎ‪.‬‬

‫‪٧٢‬‬
‫ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬.١.٤

Example ٤.٣: Switching to Protected Mode

١ ;−−−−−−−−−−−−−−−−−−−−
٢ ; Load gdt into gdtr.
٣ ;−−−−−−−−−−−−−−−−−−−−
٤
٥ call load gdt
٦
٧ ;−−−−−−−−−−−−−−−−
٨ ; Go to PMode.
٩ ;−−−−−−−−−−−−−−−−
١٠ ; just set bit 0 from cr0 (Control Register 0).
١١
١٢ cli ; important.
١٣ mov eax,cr0
١٤ or eax,0x1
١٥ mov cr0,eax ; entering pmode.
١٦
١٧
١٨ ;−−−−−−−−−−−−−−−−−−−
١٩ ; Fix CS value
٢٠ ;−−−−−−−−−−−−−−−−−−−−
٢١ ; select the code descriptor
٢٢ jmp 0x8:stage3
٢٣
٢٤
٢٥ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٦ ; entry point of stage3
٢٧ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٨
٢٩ bits 32 ; code now 32−bit
٣٠
٣١ stage3:
٣٢
٣٣ ;−−−−−−−−−−−−−−−−;
٣٤ ; Set Registers.
٣٥ ;−−−−−−−−−−−−−−−−;
٣٦
٣٧ mov ax,0x10 ; address of data descriptor.
٣٨ mov ds,ax
٣٩ mov ss,ax

٧٣
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪٤٠‬‬ ‫‪mov es,ax‬‬

‫‪٤١‬‬ ‫‪mov esp,0x90000‬‬ ‫‪; stack begin from 0x90000.‬‬
‫‪٤٢‬‬
‫‪٤٣‬‬
‫‪٤٤‬‬ ‫;‪;−−−−−−−−−−−−−−−−−‬‬
‫‪٤٥‬‬ ‫‪; Hlat the system.‬‬
‫‪٤٦‬‬ ‫;‪;−−−−−−−−−−−−−−−−−‬‬
‫‪٤٧‬‬ ‫‪cli‬‬ ‫‪; clear interrupt.‬‬
‫‪٤٨‬‬ ‫‪hlt‬‬ ‫‪; halt the system.‬‬

‫‪A20‬‬ ‫‪ .٢.٤‬ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ‬

‫ﺑﻮﺍﺑﺔ ‪ A20 Gate‬ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ‪ OR Gate‬ﻣﻮﺟﻮﺩﺓ ﻋﻠﻰ ﻧﺎﻗﻞ ﺍﻟﻨﻈﺎﻡ ‪٢ System Bus‬ﻭﺍﳍﺪﻑ ﻣﻨﻬﺎ ﻫﻮ ﺍﻟﺘﺤﻜﻢ ﰲ‬
‫ﻋﺪﺩ ﺧﻄﻮﻁ ﺍﻟﻌﻨﺎﻭﻳﻦ ‪ ،Address Line‬ﺣﻴﺚ ﻛﺎﻧﺖ ﺍﻻﺟﻬﺰﺓ ﻗﺪﳝﺎ )ﺫﺍﺕ ﺍﳌﻌﺎﳉﺎﺕ ﺍﻟﱵ ﺗﺴﺒﻖ ﻣﻌﺎﰿ ‪(80286‬‬
‫ﲢﻮﻱ ﻋﻠﻰ ‪ 20‬ﺑﺖ )ﺧﻂ( ﻟﻠﻌﻨﺎﻭﻳﻦ )‪ ، (20 address line‬ﻭﻋﻨﺪﻣﺎ ﺻﺪﺭﺕ ﺍﺟﻬﺰﺓ ‪ IBM PC‬ﻭﺍﻟﱵ ﺍﺣﺘﻮﺕ‬
‫ﻋﻠﻰ ﻣﻌﺎﰿ ‪ 80286‬ﰎ ﺯﻳﺎﺩﺓ ﺧﻂ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﱃ ‪ 32‬ﺧﻂ ﻭﻫﻜﺬﺍ ﺃﺻﺒﺢ ﻣﻦ ﺍﳌﻤﻜﻦ ﻋﻨﻮﻧﺔ ‪ 4‬ﺟﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ‬
‫‪ ،‬ﻭﺣﱴ ﻳﺘﻢ ﺍﳊﻔﺎﻅ ﻋﻠﻰ ﺍﻟﺘﻮﺍﻓﻘﻴﺔ ﻣﻊ ﺍﻻﺟﻬﺰﺓ ﺍﻟﺴﺎﺑﻘﺔ ﻓﺎﻧﻪ ﳝﻜﻦ ﺍﻟﺘﺤﻜﻢ ﰲ ﺑﻮﺍﺑﺔ ‪ A20‬ﻣﻦ ﻓﺘﺢ ﺍﳋﻄﻮﻁ‬
‫‪ A31-A20‬ﻭﺍﻏﻼﻗﻬﺎ‪.‬‬
‫ﻫﺬﻩ ﺍﻟﺒﻮﺍﺑﺔ ﻣﺮﺗﺒﻄﺔ ﻣﻊ ﻣﺘﺤﻜﻢ ‪ 8042‬ﻭﻫﻮ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ )‪ ، (Keyboard Controller‬ﻭﻋﻨﺪ ﺗﻔﻌﻴﻞ‬
‫ﺍﻟﺒﺖ ﺭﻗﻢ ‪ 1‬ﰲ ﻣﻨﻔﺬ ﺧﺮﻭﺝ ﺍﻟﺒﻴﺎﻧﺎﺕ )‪ (output data port‬ﺍﻟﺘﺎﺑﻊ ﳌﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻓﺎﻥ ﻫﺬﺍ ﻳﻔﺘﺢ ﺑﻮﺍﺑﺔ‬
‫‪ A20‬ﻭ‪‬ﺬﺍ ﻧﺴﺘﻄﻴﻊ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ‪ 4‬ﺟﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﺍﺑﺘﺪﺍءﴽ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪0xffffffff-0x0‬‬
‫ﻭﻋﻨﺪ ﺍﻗﻼﻉ ﺍﳊﺎﺳﺐ ﻓﺎﻥ ﺍﻟﺒﺎﻳﻮﺱ ﻳﻘﻮﻡ ﺑﺘﻔﻌﻴﻞ ﻫﺬﻩ ﺍﻟﺒﻮﺍﺑﺔ ﻷﻏﺮﺍﺽ ﺣﺴﺎﺏ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺍﺧﺘﺒﺎﺭﻫﺎ ﻭﻣﻦ‬
‫ﰒ ﻳﻘﻮﻡ ﺑﻐﻠﻘﻬﺎ ﳎﺪﺩﴽ ﻟﻠﺤﻔﺎﻅ ﻋﻠﻰ ﺍﻟﺘﻮﺍﻓﻘﻴﺔ ﻣﻊ ﺍﻻﺟﻬﺰﺓ ﺍﻟﻘﺪﳝﺔ‪.‬‬
‫ﻭﺗﻮﺟﺪ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻄﺮﻕ ﻟﺘﻔﻌﻴﻞ ﻫﺬﻩ ﺍﻟﺒﻮﺍﺑﺔ ‪ ،‬ﺍﻟﻌﺪﻳﺪ ﻣﻨﻬﺎ ﻳﻌﻤﻞ ﻋﻠﻰ ﺃﺟﻬﺰﺓ ﻣﻌﻴﻨﺔ ﻟﺬﻟﻚ ﺳﻴﺘﻢ ﺫﻛﺮ ﺍﻟﻌﺪﻳﺪ‬
‫ﻣﻦ ﺍﻟﻄﺮﻕ ﻭﺍﺳﺘﺨﺪﺍﻡ ﺃﻛﺜﺮ ﺍﻟﻄﺮﻕ ﳏﻤﻮﻟﻴﺔ ﻋﻠﻰ ﺻﻌﻴﺪ ﺍﻻﺟﻬﺰﺓ ﺍﳌﺨﺘﻠﻔﺔ‪.‬‬

‫‪A20‬‬ ‫‪ .١.٢.٤‬ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ‪ 8042‬ﻭﺍﻟﺒﻮﺍﺑﺔ‬

‫ﻋﻨﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (PMode‬ﻓﺎﻧﻪ ﻟﻦ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﻭﳚﺐ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ‬
‫ﻣﺘﺤﻜﻢ ﺃﻱ ﻋﺘﺎﺩ ﻭﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻣﺴﺠﻼﺕ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺪﺍﺧﻠﻴﺔ ‪ .‬ﻭﺑﺴﺒﺐ ﺍﺭﺗﺒﺎﻁ ﺑﻮﺍﺑﺔ ‪ A20‬ﻣﻊ ﻣﺘﺤﻜﻢ‬
‫ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻓﺎﻧﻪ ﻻ ﺑﺪ ﻣﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﻟﺘﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪ ،‬ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺍﺳﺘﺨﺪﺍﻡ ﺃﻭﺍﻣﺮ‬
‫ﺍﳌﻌﺎﰿ ‪ in‬ﻭﺍﻻﻣﺮ ‪.out‬‬
‫‪20‬‬ ‫‪٢‬ﺗﻮﺟﺪ ﺍﻟﺒﻮﺍﺑﺔ ﲢﺪﻳﺪﴽ ﻋﻠﻰ ﺧﻂ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺭﻗﻢ‬

‫‪٧٤‬‬
‫‪A20‬‬ ‫‪ .٢.٤‬ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ‬

‫ﻭﲞﺼﻮﺹ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ )ﻣﺘﺤﻜﻢ ‪ (8042‬ﻓﻐﺎﻟﺒﺎ ﻣﺎ ﺗﺄﰐ ﻋﻠﻰ ﺷﻜﻞ ﺷﺮﳛﺔ ‪ Integrated Circuit‬ﺃﻭ‬
‫ﺗﻜﻮﻥ ﻣﻀﻤﻨﺔ ﺩﺍﺧﻞ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ )‪ (Motherboard‬ﻭﺗﻜﻮﻥ ﰲ ﺍﻝ ‪.South Bridge‬ﻭﻳﺮﺗﺒﻂ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﻣﻊ‬
‫ﻣﺘﺤﻜﻢ ﺁﺧﺮ ﺑﺪﺍﺧﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ‪ ،‬ﻭﻋﻨﺪ ﺍﻟﻀﻐﻂ ﻋﻠﻰ ﺯﺭ ﻣﺎ ﻓﺎﻧﻪ ﻳﺘﻢ ﺗﻮﻟﻴﺪ ‪ Make Code‬ﻭﻳُﺮﺳﻞ ﺍﱃ‬
‫ﺍﳌﺘﺤﻜﻢ ﺍﳌﻮﺟﻮﺩ ﺑﺪﺍﺧﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻭﺍﻟﺬﻱ ﺑﺪﺭﻭﻩ ﻳﻘﻮﻡ ﺑﺎﺭﺳﺎﻟﻪ ﺍﱃ ﻣﺘﺤﻜﻢ ‪ 8042‬ﻋﻦ ﻃﺮﻳﻖ ﻣﻨﻔﺬ ﺍﳊﺎﺳﺐ‬
‫)‪. (Hardware Port‬ﻭﻫﻨﺎ ﻳﺄﰐ ﺩﻭﺭ ﻣﺘﺤﻜﻢ ‪ 8042‬ﺣﻴﺚ ﻳﻘﻮﻡ ﺑﺘﺤﻮﻳﻞ ‪ Make code‬ﺍﱃ ‪ Scan Code‬ﻭﳛﻔﻈﻬﺎ‬
‫ﰲ ﻣﺴﺠﻼﺗﻪ ﺍﻟﺪﺍﺧﻠﻴﺔ ‪ Buffer‬ﻫﺬﺍ ﺍﳌﺴﺠﻞ ﳛﻤﻞ ﺍﻟﺮﻗﻢ ‪ 0x60‬ﰲ ﺃﺟﻬﺰﺓ ‪ ،IBM and Compa ble PC‬ﻭﻫﺬﺍ‬
‫ﻳﻌﲏ ﺃﻧﻪ ﰲ ﺣﺎﻟﺔ ﻗﺮﺍءﺓ ﻫﺬﺍ ﺍﳌﺴﺠﻞ )ﻋﻦ ﻃﺮﻳﻖ ﺍﻷﻣﺮ ‪ (in‬ﻓﺎﻧﻪ ﳝﻜﻦ ﻗﺮﺍءﺓ ﺍﻟﻘﻴﻤﺔ ﺍﳌﺪﺧﻠﺔ‪.‬‬
‫ﻭﰲ ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻣﻦ ﺳﻴﺘﻢ ﻣﻨﺎﻗﺸﺔ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﺑﺎﻟﺘﻔﺼﻴﻞ ‪ ،‬ﻭﺳﻨﻜﺘﻔﻲ ﻫﻨﺎ ﻓﻘﻂ ﺑﺘﻮﺿﻴﺢ ﺍﻷﺟﺰﺍء ﺍﳌﺘﻌﻠﻘﺔ‬
‫ﺑﺘﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪.A20‬‬

‫‪A20‬‬ ‫‪ .٢.٢.٤‬ﻃﺮﻕ ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ‬

‫‪System Control Port 0x92‬‬ ‫ﺑﻮﺍﺳﻄﺔ‬
‫ﰲ ﺑﻌﺾ ﺍﻻﺟﻬﺰﺓ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺃﺣﺪ ﻣﻨﺎﻓﺬ ﺍﻻﺩﺧﺎﻝ ﻭﺍﻻﺧﺮﺍﺝ ﻭﻫﻮ ‪ I/O part 0x92‬ﻟﺘﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪، A20‬‬
‫ﻭﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺳﻬﻮﻟﺔ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻻ ﺃ‪‬ﺎ ﺗﻌﺘﱪ ﺃﻗﻞ ﳏﻤﻮﻟﻴﺔ ﻭﺑﻌﺾ ﺍﻻﺟﻬﺰﺓ ﻻ ﺗﺪﻋﻤﻬﺎ ‪ ،‬ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺗﻮﺿﻴﺢ‬
‫ﻟﻠﺒﺘﺎﺕ ﻋﻠﻰ ﻫﺬﺍ ﺍﳌﻨﻔﺬ‪:‬‬
‫ﺍﻟﺒﺖ ‪ :0‬ﺗﻔﻌﻴﻞ ﻫﺬﺍ ﺍﻟﺒﺖ ﻳﺆﺩﻱ ﺍﱃ ﻋﻤﻞ ‪ reset‬ﻟﻠﻨﻈﺎﻡ ﻭﺍﻟﻌﻮﺩﺓ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :1‬ﺍﻟﻘﻴﻤﺔ ‪ 0‬ﻟﺘﻌﻄﻴﻞ ﺑﻮﺍﺑﺔ ‪ ، A20‬ﻭﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﺘﻔﻌﻴﻠﻬﺎ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :2‬ﻻ ﺗﺴﺘﺨﺪﻡ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪power on password bytes :3‬‬ ‫•‬

‫ﺍﻟﺒﺘﺎﺕ ‪ :5-4‬ﻻ ﺗﺴﺘﺨﺪﻡ‪.‬‬ ‫•‬

‫‪.on‬‬ ‫ﺍﻟﺒﺘﺎﺕ ‪ : HDD ac vity LED :7-6‬ﺍﻟﻘﻴﻤﺔ ‪ ،off :0‬ﺍﻟﻘﻴﻤﺔ ‪:1‬‬ ‫•‬

‫ﻭﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪.‬‬

‫‪Example‬‬ ‫‪٤.٤: Enable A20 by System Control Port 0x92‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١‬‬
‫‪٢ ; enable a20 port 0x92:‬‬
‫; ‪٣‬‬ ‫‪Enable A20 with System Control port 0x92‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٤‬‬
‫‪٥‬‬
‫‪٦ enable a20 port 0x92:‬‬
‫‪٧‬‬

‫‪٧٥‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪٨‬‬ ‫‪push ax‬‬ ‫‪; save register.‬‬

‫‪٩‬‬
‫‪١٠‬‬ ‫‪mov al,2‬‬ ‫‪; set bit 2 to enable A20‬‬
‫‪١١‬‬ ‫‪out 0x92,al‬‬
‫‪١٢‬‬
‫‪١٣‬‬ ‫‪pop ax‬‬ ‫‪; restore register.‬‬
‫‪١٤‬‬ ‫‪ret‬‬

‫ﻭﳚﺐ ﻣﻼﺣﻈﺔ ﺃﻥ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻻ ﺗﻌﻤﻞ ﰲ ﻛﻞ ﺍﻻﺟﻬﺰﺓ ﻭﺭﲟﺎ ﻳﻜﻮﻥ ﻫﻨﺎﻙ ﺍﺭﻗﺎﻡ ﳐﺘﻠﻔﺔ ﻟﻠﻤﻨﺎﻓﺬ ‪ ،‬ﻭﻳﻌﺘﻤﺪ ﰲ‬
‫ﺍﻵﺧﺮ ﻋﻠﻰ ﻣﺼﻨﻌﻲ ﺍﻟﻠﻮﺣﺎﺕ ﺍﻻﻡ ﻭﳚﺐ ﻗﺮﺍءﺓ ﻛﺘﻴﺒﺎ‪‬ﺎ ﳌﻌﺮﻓﺔ ﺍﻟﻌﻨﺎﻭﻳﻦ‪.‬‬

‫ﺑﻮﺍﺳﻄﺔ ﺍﻟﺒﺎﻳﻮﺱ‬
‫‪0x2400‬‬ ‫ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪ int 0x15‬ﺍﻟﺪﺍﻟﺔ ‪ 0x2401‬ﻟﺘﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪ ، A20‬ﻭﺍﻟﺪﺍﻟﺔ‬
‫ﻟﺘﻌﻄﻴﻠﻬﺎ‪.‬ﻣﻊ ﺍﻟﺘﺬﻛﲑ ﺑﺄﻥ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﺍﳌﻌﺎﰿ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﺳﺘﺪﻋﺎء ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ‪،‬‬
‫ﻭﺍﻟﻜﻮﺩ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺍﻟﺘﻔﻌﻴﻞ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺒﺎﻳﻮﺱ‪.‬‬
‫‪Example‬‬ ‫‪٤.٥: Enable A20 by BIOS int 0x15‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١‬‬
‫‪٢ ; enable a20 bios:‬‬
‫; ‪٣‬‬ ‫‪Enable A20 with BIOS int 0x15 routine 0x2401‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٤‬‬
‫‪٥‬‬
‫‪٦ enable a20 bios:‬‬
‫‪٧‬‬
‫‪٨‬‬ ‫‪pusha‬‬ ‫‪; save all registers‬‬
‫‪٩‬‬
‫‪١٠‬‬ ‫‪mov ax,0x2401 ; Enable A20 routine.‬‬
‫‪١١‬‬ ‫‪int 0x15‬‬
‫‪١٢‬‬
‫‪١٣‬‬ ‫‪popa‬‬ ‫‪; restore registers‬‬
‫‪١٤‬‬ ‫‪ret‬‬

‫ﺑﻮﺍﺳﻄﺔ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬

‫‪Output‬‬ ‫ﻳﻮﺟﺪ ﻣﻨﻔﺬﻳﻦ ﳌﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‪ :‬ﺍﳌﻨﻔﺬ ‪ 0x60‬ﻭﻫﻮ ﳝﺜﻞ ﺍﻝ ‪) buffer‬ﰲ ﺣﺎﻟﺔ ﺍﻟﻘﺮﺍءﺓ ﻣﻨﻪ ﻳﺴﻤﻰ‬
‫‪ Buffer‬ﻭﰲ ﺣﺎﻟﺔ ﺍﻟﻜﺘﺎﺑﺔ ﻳﺴﻤﻰ ‪ ،Input Buffer‬ﻭﺍﳌﻨﻔﺬ ‪ 0x64‬ﻭﻫﻮ ﻹﺭﺳﺎﻝ ﺍﻻﻭﺍﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﻭﻟﻘﺮﺍءﺓ ﺣﺎﻟﺔ‬

‫‪٧٦‬‬
‫‪A20‬‬ ‫‪ .٢.٤‬ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ‬

‫ﺍﳌﺘﺤﻜﻢ )‪ .(Status‬ﺣﻴﺚ ﻳﺘﻢ ﺍﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﻋﻦ ﻃﺮﻳﻖ ﺍﳌﻨﻔﺬ ‪ 0x64‬ﻭﺍﺫﺍ ﻛﺎﻥ ﻫﻨﺎﻙ ﻭﺳﺎﺋﻂ‬
‫ﳍﺬﺍ ﺍﻷﻣﺮ ﻓﺘﺮﺳﻞ ﺍﱃ ﺍﻝ ‪) buffer‬ﺍﳌﻨﻔﺬ ‪ (0x60‬ﻭﻛﺬﻟﻚ ﺗﻘﺮﺃ ﺍﻟﻨﺘﺎﺋﺞ ﻣﻦ ﺍﳌﻨﻔﺬ ‪.0x60‬‬
‫ﻭﺣﻴﺚ ﺍﻥ ﺗﻨﻔﻴﺬ ﺃﻭﺍﻣﺮ ﺍﻟﱪﻧﺎﻣﺞ )ﻋﻦ ﻃﺮﻳﻖ ﺍﳌﻌﺎﰿ( ﺃﺳﺮﻉ ﺑﻜﺜﲑ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﺮﺳﻠﺔ ﺍﱃ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ‬
‫ﺍﳌﻔﺎﺗﻴﺢ )ﻭﺑﺸﻜﻞ ﻋﺎﻡ ﺍﱃ ﺃﻱ ﻣﺘﺤﻜﻢ ﻟﻌﺘﺎﺩ ﻣﺎ( ﻓﺎﻧﻪ ﳚﺐ ﺍﻥ ﻧﻮﻓﺮ ﻃﺮﻗﴼ ﻻﻧﺘﻈﺎﺭ ﺍﳌﺘﺤﻜﻢ ﻗﺒﻞ ﺍﻟﻌﻮﺩﺓ ﺍﱃ‬
‫ﺍﻟﱪﻧﺎﻣﺞ ﻻﺳﺘﻜﻤﺎﻝ ﺍﻟﺘﻨﻔﻴﺬ ‪.‬‬
‫ﻭﳝﻜﻦ ﻋﻦ ﻃﺮﻳﻖ ﻗﺮﺍءﺓ ﺣﺎﻟﺔ ﺍﳌﺘﺤﻜﻢ )ﻋﻦ ﻃﺮﻳﻖ ﻗﺮﺍءﺓ ﺍﳌﻨﻔﺬ ‪ (0x64‬ﺃﻥ ﻧﻌﺮﻑ ﻣﺎ ﺍﺫﺍ ﰎ ﺗﻨﻔﻴﺬ ﺍﻻﻭﺍﻣﺮ ﺍﳌﺮﺳﻠﺔ‬
‫ﺍﻡ ﻻ ‪ ،‬ﻭﻛﺬﻟﻚ ﻫﻞ ﻫﻨﺎﻙ ﻧﺘﻴﺠﺔ ﻟﻜﻲ ﻳﺘﻢ ﻗﺮﺍﺋﺘﻬﺎ ﰲ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻡ ﻻ‪.‬‬
‫ﻭﻣﺎ ﻳﻬﻤﻨﺎ ﻣﻦ ﺍﻟﺒﺘﺎﺕ ﻋﻨﺪ ﻗﺮﺍءﺓ ﺣﺎﻟﺔ ﺍﳌﺘﺤﻜﻢ ﺣﺎﻟﻴﺎ ﻫﻮ ﺃﻭﻝ ﺑﺘﲔ ﻓﻘﻂ ‪ ،‬ﻭﻭﻇﻴﻔﺘﻬﻤﺎ ﻫﻲ‪:‬‬
‫ﺍﻟﺒﺖ ‪ :0‬ﺣﺎﻟﺔ ﺍﻝ ‪:Output Buffer‬‬ ‫•‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :0‬ﺍﻝ ‪ Output Buffer‬ﺧﺎﱄ )ﻻ ﺗﻮﺟﺪ ﻧﺘﻴﺠﺔ ‪ ،‬ﻻ ﺗﻘﺮﺃ ﺍﻻﻥ(‪.‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :1‬ﺍﻝ ‪ Output Buffer‬ﳑﺘﻠﺊ )ﺗﻮﺟﺪ ﻧﺘﻴﺠﺔ ‪ ،‬ﻗﻢ ﺑﺎﻟﻘﺮﺍءﺓ ﺍﻻﻥ(‪.‬‬
‫ﺍﻟﺒﺖ ‪ :1‬ﺣﺎﻟﺔ ﺍﻝ ‪:Input Buffer‬‬ ‫•‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :0‬ﺍﻝ ‪ Input Buffer‬ﺧﺎﱄ )ﻻ ﺗﻮﺟﺪ ﺃﻭﺍﻣﺮ ﻏﲑ ﻣﻨﻔﺬﺓ ‪ ،‬ﳝﻜﻦ ﺍﻟﻜﺘﺎﺑﺔ ﺍﻻﻥ(‪.‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :1‬ﺍﻝ ‪ Input Buffer‬ﳑﺘﻠﺊ )ﺗﻮﺟﺪ ﺃﻭﺍﻣﺮ ﻏﲑ ﻣﻨﻔﺬﺓ ‪ ،‬ﻻ ﺗﻜﺘﺐ ﺍﻻﻥ(‪.‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺍﻧﺘﻈﺎﺭ ﺍﳌﺘﺤﻜﻢ ﺣﱴ ﻳﻨﻔﺬ ﺍﻻﻭﺍﻣﺮ ﺍﳌﺮﺳﻠﻪ ﺍﻟﻴﻪ )‪ (wait input‬ﻭﻛﻴﻔﻴﺔ ﺍﻧﺘﻈﺎﺭ‬
‫ﺍﳌﺘﺤﻜﻢ ﺍﱃ ﺍﻥ ﻳﺄﰐ ﺑﻨﺘﻴﺠﺔ ﻣﺎ )‪.(wait output‬‬
‫‪Example‬‬ ‫‪٤.٦: Wait Input/Output‬‬
‫‪١‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٢‬‬
‫‪٣ ; wait output: wait output buffer to be full.‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٤‬‬
‫‪٥‬‬
‫‪٦ wait output:‬‬
‫‪٧‬‬
‫‪٨‬‬ ‫‪in al,0x64‬‬ ‫‪; read status‬‬
‫‪٩‬‬ ‫‪test al,0x1‬‬ ‫?‪; is output buffer is empty‬‬
‫‪١٠‬‬ ‫‪je wait output ; yes, hang.‬‬
‫‪١١‬‬
‫‪١٢‬‬ ‫‪ret‬‬ ‫‪; no,there is a result.‬‬
‫‪١٣‬‬
‫‪١٤‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٥‬‬
‫‪١٦ ; wait input: wait input buffer to be empty.‬‬

‫‪٧٧‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪١٧‬‬ ‫‪command executed already.‬‬

‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٨‬‬
‫‪١٩‬‬
‫‪٢٠ wait input:‬‬
‫‪٢١‬‬
‫‪٢٢‬‬ ‫‪in al,0x64‬‬ ‫‪; read status‬‬
‫‪٢٣‬‬ ‫‪test al,0x2‬‬ ‫?‪; is input buffer is full‬‬
‫‪٢٤‬‬ ‫‪jne wait input ; yes, hang.‬‬
‫‪٢٥‬‬
‫‪٢٦‬‬ ‫‪ret‬‬ ‫‪; no,command executed.‬‬

‫ﻭﻹﺭﺳﺎﻝ ﺍﻭﺍﻣﺮ ﺍﱄ ﺍﳌﺘﺤﻜﻢ ﻓﺎﻥ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﻨﻔﺬ ‪ 0x64‬ﻭﺗﻮﺟﺪ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﻷﻭﺍﻣﺮ ‪ ،‬ﻭﻧﻈﺮﺍ ﻻﻥ ﻫﺬﺍ ﺍﳉﺰء‬
‫ﻏﲑ ﳐﺼﺺ ﻟﱪﳎﺔ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻓﺎﻧﻨﺎ ﺳﻨﻨﺎﻗﺶ ﻓﻘﻂ ﺍﻻﻭﺍﻣﺮ ﺍﻟﱵ ‪‬ﻤﻨﺎ ﺣﺎﻟﻴﺎ ‪ ،‬ﻭﰲ ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺩﺱ‬
‫ﺳﻨﻌﻮﺩ ﺍﱃ ﺍﳌﻮﺿﻮﻉ ﺑﺎﻟﺘﻔﺼﻴﻞ ﺍﻥ ﺷﺎء ﺍﷲ‪.‬‬
‫ﻭﻗﺎﺋﻤﺔ ﺍﻻﻭﺍﻣﺮ ﺣﺎﻟﻴﺎ‪:‬‬
‫• ﺍﻷﻣﺮ ‪ :0xad‬ﺗﻌﻄﻴﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‪.‬‬
‫ﺍﻷﻣﺮ ‪ :0xae‬ﺗﻔﻌﻴﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‪.‬‬ ‫•‬

‫ﺍﻷﻣﺮ ‪ :0xd0‬ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ‪.Output Port‬‬ ‫•‬

‫ﺍﻷﻣﺮ ‪ :0xd1‬ﺍﻟﻜﺘﺎﺑﺔ ﺍﱃ ‪.Output Port‬‬ ‫•‬

‫ﺍﻷﻣﺮ ‪ :0xdd‬ﺗﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪.A20‬‬ ‫•‬

‫ﺍﻷﻣﺮ ‪ :0xdf‬ﺗﻌﻄﻴﻞ ﺑﻮﺍﺑﺔ ‪.A20‬‬ ‫•‬

‫ﻭﻋﻦ ﻃﺮﻳﻖ ﺍﻷﻣﺮ ‪ 0xdd‬ﻓﺎﻧﻪ ﳝﻜﻦ ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ ‪ A20‬ﺑﺴﻬﻮﻟﺔ ﻛﻤﺎ ﰲ ﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ‪ ،‬ﻟﻜﻦ ﺃﻳﻀﺎ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ‬
‫ﻻ ﺗﻌﻤﻞ ﻋﻠﻰ ﻛﻞ ﺍﻻﺟﻬﺰﺓ ﺣﻴﺚ ﻫﻨﺎﻙ ﺑﻌﺾ ﺍﳌﺘﺤﻜﻤﺎﺕ ﻻ ﺗﺪﻋﻢ ﻫﺬﺍ ﺍﻷﻣﺮ‪.‬‬
‫‪Example‬‬ ‫‪٤.٧: Enable A20 by Send 0xdd‬‬
‫‪١‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٢‬‬
‫‪٣ ; enable a20 keyboard controller:‬‬
‫; ‪٤‬‬ ‫‪Enable A20 with command 0xdd‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٥‬‬
‫‪٦‬‬
‫‪٧ enable a20 keyboard controller:‬‬
‫‪٨‬‬
‫‪٩‬‬ ‫‪;cli‬‬

‫‪٧٨‬‬
‫‪A20‬‬ ‫‪ .٢.٤‬ﺗﻔﻌﻴﻞ ﺍﻟﺒﻮﺍﺑﺔ‬

‫‪١٠‬‬ ‫‪push ax‬‬ ‫‪; save register.‬‬

‫‪١١‬‬
‫‪١٢‬‬ ‫‪mov al,0xdd‬‬ ‫‪; Enable A20 Keyboard Controller Command.‬‬
‫‪١٣‬‬ ‫‪out 0x64,al‬‬
‫‪١٤‬‬
‫‪١٥‬‬ ‫‪pop ax‬‬ ‫‪; restore register.‬‬
‫‪١٦‬‬ ‫‪ret‬‬

‫ﻭﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﺃﺧﺮﻯ ﺃﻛﺜﺮ ﳏﻤﻮﻟﻴﺔ ﻭﻫﻲ ﻋﻦ ﻃﺮﻳﻖ ﻣﻨﻔﺬ ﺍﳋﺮﻭﺝ ‪ Output Port‬ﰲ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬
‫ﻭﳝﻜﻦ ﻗﺮﺍءﺓ ﻫﺬﺍ ﺍﳌﻨﻔﺬ ﻭﺍﻟﻜﺘﺎﺑﺔ ﺍﻟﻴﻪ ﻋﻦ ﻃﺮﻳﻖ ﺍﺭﺳﺎﻝ ﺍﻻﻭﺍﻣﺮ ‪ 0xd0‬ﻭ ‪ 0xd1‬ﻋﻠﻰ ﺍﻟﺘﻮﺍﱄ‪.‬‬
‫ﻭﻋﻨﺪ ﻗﺮﺍءﺓ ﻫﺬﺍ ﺍﳌﻨﻔﺬ )ﺑﺎﺭﺳﺎﻝ ﺍﻻﻣﺮ ‪ d0‬ﺍﱃ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ( ﻓﺎﻥ ﺍﻟﻘﻴﻢ ﺗﻌﲏ‪:‬‬
‫ﺍﻟﺒﺖ ‪:System Reset :0‬‬ ‫•‬
‫– ﺍﻟﻘﻴﻤﺔ ‪.Reset Computer :0‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪.Normal Opera on :1‬‬
‫ﺍﻟﺒﺖ ‪ :1‬ﺑﻮﺍﺑﺔ ‪:A20‬‬ ‫•‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :0‬ﺗﻌﻄﻴﻞ‪.‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪ :1‬ﺗﻔﻌﻴﻞ‪.‬‬
‫ﺍﻟﺒﺘﺎﺕ ‪ :3-2‬ﻏﲑ ﻣﻌﺮﻑ‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪.Input Buffer Full :4‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪.Output Buffer Empty :5‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪:Keyboard Clock :6‬‬ ‫•‬

‫– ﺍﻟﻘﻴﻤﺔ ‪.High-Z :0‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪.Pull Clock Low :1‬‬
‫ﺍﻟﺒﺖ ‪:Keyboard Data :7‬‬ ‫•‬
‫– ﺍﻟﻘﻴﻤﺔ ‪.High-Z :0‬‬
‫– ﺍﻟﻘﻴﻤﺔ ‪.Pull Data Low :1‬‬
‫ﻭﻋﻨﺪ ﺗﻔﻌﻴﻞ ﺍﻟﺒﺖ ﺭﻗﻢ ‪ 1‬ﻓﺎﻥ ﻫﺬﺍ ﻳﻔﻌﻞ ﺑﻮﺍﺑﺔ ‪ A20‬ﻭﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻻﻣﺮ ‪ or‬ﺣﱴ ﻳﺘﻢ ﺍﳊﻔﺎﻅ ﻋﻠﻰ ﺑﻘﻴﺔ ﺍﻟﺒﺘﺎﺕ‬
‫‪.‬ﻭﺑﻌﺪ ﺫﻟﻚ ﳚﺐ ﻛﺘﺎﺑﺔ ﺍﻟﻘﻴﻢ ﺍﱃ ﻧﻔﺲ ﺍﳌﻨﻔﺬ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻻﻣﺮ ‪. 0xd1‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺗﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪ A20‬ﻋﻦ ﻃﺮﻳﻖ ﻣﻨﻔﺬ ﺍﳋﺮﻭﺝ ‪ Output Port‬ﳌﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‪.‬‬

‫‪٧٩‬‬
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

Example ٤.٨: Enable A20 by write to output port of Keyboard Controller

١
٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٣ ; enable a20 keyboard controller output port:
٤ ; Enable A20 with write to keyboard output port.
٥ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٦
٧ enable a20 keyboard controller output port:
٨
٩ cli
١٠ pusha ; save all registers
١١
١٢ call wait input ; wait last operation to be finished.
١٣
١٤ ;−−−−−−−−−−−−−−−−−−
١٥ ; Disable Keyboard
١٦ ;−−−−−−−−−−−−−−−−−−
١٧ mov al,0xad ; disable keyboard command.
١٨ out 0x64,al
١٩ call wait input
٢٠
٢١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٢ ; send read output port command
٢٣ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٤ mov al,0xd0 ; read output port command
٢٥ out 0x64,al
٢٦ call wait output ; wait output to come.
٢٧ ; we don't need to wait input bescause when output came we know
that operation are executed.
٢٨
٢٩ ;−−−−−−−−−−−−−−−−−−−−−−
٣٠ ; read input buffer
٣١ ;−−−−−−−−−−−−−−−−−−−−−−
٣٢ in al,0x60
٣٣ push eax ; save data.
٣٤ call wait input
٣٥
٣٦ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٧ ; send write output port command.
٣٨ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

٨٠
‫‪VGA‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬

‫‪٣٩‬‬ ‫‪mov al,0xd1‬‬ ‫‪; write output port command.‬‬

‫‪٤٠‬‬ ‫‪out 0x64,al‬‬
‫‪٤١‬‬ ‫‪call wait input‬‬
‫‪٤٢‬‬
‫‪٤٣‬‬ ‫‪;−−−−−−−−−−−−‬‬
‫‪٤٤‬‬ ‫‪; enable a20.‬‬
‫‪٤٥‬‬ ‫‪;−−−−−−−−−−−−‬‬
‫‪٤٦‬‬ ‫‪pop eax‬‬
‫‪٤٧‬‬ ‫‪or al,2‬‬ ‫‪; set bit 2.‬‬
‫‪٤٨‬‬ ‫‪out 0x60,al‬‬
‫‪٤٩‬‬ ‫‪call wait input‬‬
‫‪٥٠‬‬
‫‪٥١‬‬ ‫‪;−−−−−−−−−−−−−−−−−‬‬
‫‪٥٢‬‬ ‫‪; Enable Keyboard.‬‬
‫‪٥٣‬‬ ‫‪;−−−−−−−−−−−−−−−−−‬‬
‫‪٥٤‬‬ ‫‪mov al,0xae‬‬ ‫‪; Enable Keyboard command.‬‬
‫‪٥٥‬‬ ‫‪out 0x64,al‬‬
‫‪٥٦‬‬ ‫‪call wait input‬‬
‫‪٥٧‬‬
‫‪٥٨‬‬
‫‪٥٩‬‬ ‫‪popa‬‬ ‫‪; restore registers‬‬
‫‪٦٠‬‬ ‫‪sti‬‬
‫‪٦١‬‬
‫‪٦٢‬‬ ‫‪ret‬‬

‫ﺣﻴﺚ ﰲ ﺍﻟﺒﺪﺍﻳﺔ ﰎ ﺗﻌﻄﻴﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ )ﻋﻦ ﻃﺮﻳﻖ ﺍﺭﺳﺎﻝ ﺍﻻﻣﺮ ‪ (0xad‬ﻭﺍﺳﺘﺪﻋﺎء ﺍﻟﺪﺍﻟﺔ ‪ wait input‬ﻟﻠﺘﺄﻛﺪ‬
‫ﻣﻦ ﺃﻥ ﺍﻻﻣﺮ ﻗﺪ ﰎ ﺗﻨﻔﻴﺬﻩ ﻭﻣﻦ ﰒ ﰎ ﺍﺭﺳﺎﻝ ﺃﻣﺮ ﻗﺮﺍءﺓ ﻣﻨﻔﺬ ﺍﳋﺮﻭﺝ ﳌﺘﺤﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ )ﺍﻻﻣﺮ ‪(0xda‬‬
‫ﻭﺍﻧﺘﻈﺎﺭ ﺍﳌﺘﺤﻜﻢ ﺣﱴ ﻳﻨﺘﻬﻲ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻻﻣﺮ ‪ ،‬ﻭﻗﺪ ﰎ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ ‪ wait output‬ﻻﻧﺘﻈﺎﺭ ﻗﻴﻤﺔ ﻣﻨﻔﺬ ﺍﳋﺮﻭﺝ‬
‫‪ ،‬ﻭﺑﻌﺪﻫﺎ ﰎ ﻗﺮﺍءﺓ ﻫﺬﻩ ﺍﻟﻘﻴﻤﺔ ﻭﺣﻔﻈﻬﺎ ﰲ ﺍﳌﻜﺪﺱ )‪، (Stack‬ﻭﺑﻌﺪ ﺫﻟﻚ ﰎ ﺍﺭﺳﺎﻝ ﺃﻣﺮ ﺍﻟﻜﺘﺎﺑﺔ ﺍﱃ ﻣﻨﻔﺬ ﺍﳋﺮﻭﺝ‬
‫ﳌﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ )ﺍﻻﻣﺮ ‪ (0xd1‬ﻭﺍﻧﺘﻈﺎﺭ ﺍﳌﺘﺤﻜﻢ ﺣﻰ ﻳﻨﺘﻬﻲ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻻﻣﺮ ﻭﻣﻦ ﻗﻤﻨﺎ ﺑﺎﺭﺳﺎﻝ ﻗﻴﻤﺔ‬
‫ﺍﳌﻨﻔﺬ ﺍﳋﺮﻭﺝ ﺍﳉﺪﻳﺪﺓ ﺑﻌﺪ ﺃﻥ ﰎ ﺗﻔﻌﻴﻞ ﺍﻟﺒﺖ ﺭﻗﻢ ‪ 1‬ﻭﻫﻮ ﺍﻟﺒﺖ ﺍﻟﺬﻱ ﻳﻔﻌﻞ ﺑﻮﺍﺑﺔ ‪ ، A20‬ﻭﰲ ﺍﻻﺧﲑ ﰎ ﺗﻔﻌﻴﻞ‬
‫ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﳎﺪﺩﺍ‪.‬‬

‫‪VGA‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬

‫ﰲ ﻋﺎﻡ ‪ 1987‬ﻗﺎﻣﺖ ‪ IBM‬ﺑﺘﻄﻮﻳﺮ ﻣﻘﻴﺎﺱ ﳌﺘﺤﻜﻤﺎﺕ ﺷﺎﺷﺔ ﺍﳊﺎﺳﺐ ﻭﻫﻮ ‪ Video Graphics Array‬ﻭﺍﺧﺘﺼﺎﺭﴽ‬
‫‪ VGA‬ﻭﺟﺎﺋﺖ ﺗﺴﻤﻴﺘﻪ ﺏ ‪ Array‬ﻧﻈﺮﺍ ﻻﻧﻪ ﰎ ﺗﻄﻮﻳﺮﻩ ﻛﺸﺮﳛﺔ ﻭﺍﺣﺪﺓ ‪ signle chip‬ﺣﻴﺚ ﺍﺳﺘﺒﺪﻟﺖ ﺍﻟﻌﺪﻳﺪ‬
‫ﻣﻦ ﺍﻟﺸﺮﺍﺋﺢ ﻭﺍﻟﱵ ﻛﺎﻧﺖ ﺗﺴﺘﺨﺪﻡ ﰲ ﻣﻘﺎﻳﻴﺲ ﺍﺧﺮﻯ ﻣﺜﻞ ‪ MDA‬ﻭ ‪ CGA‬ﻭ ‪ ، EGA‬ﻭﻳﺘﻜﻮﻥ ﺍﻝ ‪ VGA‬ﻣﻦ‬

‫‪٨١‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪A ribute‬‬ ‫‪ Graphics Controller , Sequencer unit , CRT Controller , Video DAC ,Video Buffer‬ﻭ‬
‫‪.٣ Controller‬‬
‫ﺍﻝ ‪ Video Buffer‬ﻫﻮ ﻣﻘﻄﻊ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ segment of memory‬ﻳﻌﻤﻞ ﻛﺬﺍﻛﺮﺓ ﻟﻠﺸﺎﺷﺔ ‪Memory Mapped‬‬
‫‪ ،‬ﻭﻋﻨﺪ ﺑﺪﺍﻳﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻓﺎﻥ ﺍﻟﺒﺎﻳﻮﺱ ﳜﺼﺺ ﻣﺴﺎﺣﺔ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﺑﺪءﺍ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0xa0000‬ﻛﺬﺍﻛﺮﺓ ﻟﻠﺸﺎﺷﺔ‬
‫ﻭﰲ ﺣﺎﻟﺔ ﰎ ﺍﻟﻜﺘﺎﺑﺔ ﺍﱃ ﻫﺬﻩ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺎﻥ ﻫﺬﺍ ﺳﻮﻑ ﻳﻐﲑ ﰲ ﺍﻟﺸﺎﺷﺔ ‪ ،‬ﻫﺬﺍ ﺍﻟﺮﺑﻂ ﻳﺴﻤﻰ ‪،Memory Mapping‬‬
‫ﺃﻣﺎ ﺍﻝ ‪ Graphics Controller‬ﻓﻬﻮ ﺍﻟﺬﻱ ﻳﻘﻮﻡ ﺑﺘﺤﺪﻳﺚ ﳏﺘﻮﻳﺎﺕ ﺍﻟﺸﺎﺷﺔ ﺑﻨﺎءﴽ ﻋﻠﻰ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﺍﻝ‬
‫‪.Video buffer‬‬
‫ﻭﺗﺪﻋﻢ ﺍﻝ ‪ VGA‬ﳕﻄﲔ ﻟﻠﻌﺮﺽ ﺍﻻﻭﻝ ﻫﻮ ﺍﻟﻨﻤﻂ ﺍﻟﻨﺼﻲ ‪ Text Mode‬ﻭﺍﻻﺧﺮ ﻫﻮ ﺍﻟﻨﻤﻂ ﺍﻟﺮﺳﻮﻣﻲ ‪APA Graphics‬‬
‫‪ Mode‬ﻭﳛﺪﺩ ﺍﻟﻨﻤﻂ ﻃﺮﻳﻘﺔ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻝ ‪ Video buffer‬ﻭﻛﻴﻔﺔ ﻋﺮﺽ ﺍﻟﺒﻴﺎﻧﺎﺕ‪.‬‬
‫ﺍﻟﻨﻤﻂ ﺍﻟﺮﺳﻮﻣﻲ ‪ All Point Addressable Graphics Mode‬ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺍﻟﺒﻜﺴﻼﺕ ‪ ،‬ﺣﻴﺚ ﳝﻜﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ‬
‫ﻛﻞ ﺑﺴﻜﻞ ﻣﻮﺟﻮﺩ ﻋﻠﻰ ﺣﺪﺓ ‪ .‬ﻭﺍﻟﺒﻜﺴﻞ ﻫﻮ ﺃﺻﻐﺮ ﻭﺣﺪﺓ ﰲ ﺍﻟﺸﺎﺷﺔ ﻭﺗﻌﺎﺩﻝ ﻧﻘﻄﺔ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‪ .‬ﺃﻣﺎ ﺍﻟﻨﻤﻂ‬
‫ﺍﻟﻨﺼﻲ ‪ Text Mode‬ﻓﻴﻌﺘﻤﺪ ﻋﻠﻰ ﺍﳊﺮﻭﻑ ‪ ، Characters‬ﻭﻟﺘﻄﺒﻴﻖ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻓﺎﻥ ﻣﺘﺤﻜﻢ ﺍﻟﺸﺎﺷﺔ ‪Video‬‬
‫‪ Controller‬ﻳﺴﺘﺨﺪﻡ ﺫﺍﻛﺮﺗﲔ ‪ two buffers‬ﺍﻻﻭﱃ ﻭﻫﻲ ﺧﺮﻳﻄﺔ ﺍﳊﺮﻭﻑ ‪ Character Map‬ﻭﻫﻲ ﺗﻌﺮﻑ‬
‫ﺍﻟﺒﻜﺴﻼﺕ ﻟﻜﻞ ﺣﺮﻑ ﻭﳝﻜﻦ ﺗﻐﻴﲑ ﻫﺬﻩ ﺍﳋﺮﻳﻄﺔ ﻟﺪﻋﻢ ﺃﻧﻈﻤﺔ ﳏﺎﺭﻑ ﺃﺧﺮﻯ‪ ،‬ﺃﻣﺎ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻬﻲ‪Screen‬‬
‫‪ Buffer‬ﻭﲟﺠﺮﺩ ﺍﻟﻜﺘﺎﺑﺔ ﻋﻠﻴﻬﺎ ﻓﺎﻥ ﺍﻟﺘﺄﺛﲑ ﺳﻴﻈﻬﺮ ﻣﺒﺎﺷﺮﺓ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‪.‬‬
‫ﻭﻣﻘﻴﺎﺱ ‪ VGA‬ﻫﻮ ﻣﺒﲏ ﻋﻠﻰ ﺍﳌﻘﺎﻳﻴﺲ ﺍﻟﺴﺎﺑﻘﺔ ‪ ،‬ﺍﺑﺘﺪﺍءﺍ ﻣﻦ ﻣﻘﻴﺎﺱ ‪ Monochrome Display Adapter‬ﻭﻳﺴﻤﻰ‬
‫ﺍﺧﺘﺼﺎﺭﺍ ‪ MDA‬ﻭﺍﻟﺬﻱ ﻃﻮﺭﺗﻪ ‪ IBM‬ﰲ ﻋﺎﻡ ‪ ، 1981‬ﻭ ‪ MDA‬ﻻ ﺗﺪﻋﻢ ﺍﻟﻨﻤﻂ ﺍﻟﺮﺳﻮﻣﻲ ﻭﺍﻟﻨﻤﻂ ﺍﻟﻨﺼﻲ ‪‬ﺎ‬
‫)ﻳﺴﻤﻰ ‪ (Mode 7‬ﻳﺪﻋﻢ ‪ 80‬ﻋﻤﻮﺩ ﻭ ‪ 24‬ﺻﻒ ) ‪ .(25*80‬ﻭﰲ ﻧﻔﺲ ﺍﻟﻌﺎﻡ ﻗﺎﻣﺖ ‪ IBM‬ﺑﺘﻄﻮﻳﺮ ﻣﻘﻴﺎﺱ‬
‫‪) Color Graphics Adapter‬ﻭﺍﺧﺘﺼﺎﺭﺍ ‪ (CGA‬ﺍﻟﺬﻱ ﻛﺎﻥ ﺃﻭﻝ ﻣﺘﺤﻜﻢ ﻳﺪﻋﻢ ﺍﻻﻟﻮﺍﻥ ﺣﻴﺚ ﳝﻜﻦ ﻋﺮﺽ ‪16‬‬
‫ﻟﻮﻥ ﳐﺘﻠﻒ‪.‬ﻭﺑﻌﺪ ﺫﻟﻚ ﰎ ﺗﻄﻮﻳﺮ ‪.Enhanced Graphics Adapter‬‬
‫ﻭﳚﺪﺭ ﺑﻨﺎ ﺍﻟﺘﺬﻛﲑ ﺑﺎﻥ ﻣﺘﺤﻜﻤﺎﺕ ‪ VGA‬ﻣﺘﻮﺍﻓﻘﺔ ﻣﻊ ﺍﳌﻘﺎﻳﻴﺲ ﺍﻟﺴﺎﺑﻘﺔ ‪ Backward Compa ble‬ﻓﻌﻨﺪﻣﺎ ﻳﺒﺪﺃ‬
‫ﺍﳊﺎﺳﺐ ﰲ ﺍﻟﻌﻤﻞ ﻓﺎﻥ ﺍﻟﻨﻤﻂ ﺳﻴﻜﻮﻥ ﺍﻟﻨﻤﻂ ﺍﻟﻨﺼﻲ ‪) Mode 7‬ﺍﻟﺬﻱ ﻇﻬﺮ ﰲ ‪ ، (MDA‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺍﻧﻨﺎ ﺳﻨﺘﻌﺎﻣﻞ‬
‫ﻣﻊ ‪ 80‬ﻋﻤﻮﺩ ﻭ ‪ 25‬ﺻﻒ‪.‬‬

‫‪VGA‬‬ ‫‪ .١.٣.٤‬ﻋﻨﻮﻧﺔ ﺍﻟﺬﺍﻛﺮﺓ ﰲ ﻣﺘﺤﻜﻤﺎﺕ‬

‫ﻋﻨﺪﻣﺎ ﻳﺒﺪﺃ ﺍﳊﺎﺳﺐ ﺑﺎﻟﻌﻤﻞ ﻓﺎﻥ ﺍﻟﺒﺎﻳﻮﺱ ﳜﺼﺺ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻣﻦ ‪ 0xa0000‬ﺍﱃ ‪ 0xbffff‬ﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺪﻳﻮ‬
‫‪) Video memroy‬ﻣﻮﺟﻮﺩﺓ ﻋﻠﻰ ﻣﺘﺤﻜﻢ ‪ ، (VGA‬ﻫﺬﻩ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻣﻘﺴﻤﺔ ﻛﺎﻻﰐ‪:‬‬
‫ﻣﻦ ‪ 0xb0000‬ﺍﱃ ‪ :0xb7777‬ﻟﻠﻨﻤﻂ ﺍﻟﻨﺼﻲ ﺃﺣﺎﺩﻱ ﺍﻟﻠﻮﻥ ‪.Monochrome Text Mode‬‬ ‫•‬

‫ﻣﻦ ‪ 0xb8000‬ﺍﱃ ‪.Color Text Mode :0xbffff‬‬ ‫•‬

‫ﻭﻋﻨﺪ ﺍﻟﻜﺘﺎﺑﺔ ﰲ ﻫﺬﻩ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻓﺎﻥ ﻫﺬﺍ ﺳﻮﻑ ﻳﺆﺛﺮ ﰲ ﺍﻟﺸﺎﺷﺔ ﻭﺍﻇﻬﺎﺭ ﺍﻟﻘﻴﻢ ﺍﻟﱵ ﰎ ﻛﺘﺎﺑﺘﻬﺎ ‪ ،‬ﻭﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ‬
‫ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ ﺣﺮﻑ ‪ A‬ﺑﻠﻮﻥ ﺃﺑﻴﺾ ﻭﺧﻠﻔﻴﺔ ﺳﻮﺩﺍء‪.‬‬
‫‪٣‬ﺷﺮﺡ ﻫﺬﻩ ﺍﳌﻜﻮﻧﺎﺕ ﺳﻴﻜﻮﻥ ﻻﺣﻘﺎ ﺑﺎﺫﻥ ﺍﷲ ‪ ،‬ﻭﺳﻴﺘﻢ ﺍﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﺑﻌﺾ ﺍﻻﺷﻴﺎء ﲝﺴﺐ ﺍﳊﺎﺟﺔ ﺣﺎﻟﻴﺎ‪.‬‬

‫‪٨٢‬‬
‫‪VGA‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬

‫‪Example‬‬ ‫‪٤.٩: Print 'A' character on screen‬‬

‫‪١‬‬
‫‪٢ %define VIDEO MEMORY‬‬ ‫‪0xb8000‬‬ ‫‪; Base Address of Mapped Video‬‬
‫‪Memory.‬‬
‫‪٣ %define CHAR ATTRIBUTE‬‬ ‫‪0x7‬‬ ‫‪; White chracter on black background.‬‬
‫‪٤‬‬
‫‪٥ mov edi,VIDEO MEMORY‬‬
‫‪٦‬‬
‫'‪٧ mov [edi],'A‬‬ ‫‪; print A‬‬
‫‪٨ mov [edi+1],CHAR ATTRIBUTE‬‬ ‫‪; in white foreground black‬‬
‫‪background.‬‬

‫‪ .٢.٣.٤‬ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ‬

‫ﻟﻄﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﳚﺐ ﺍﺭﺳﺎﻝ ﺍﳊﺮﻑ ﺍﱃ ﻋﻨﻮﺍﻥ ﺍﻝ ‪ Video Memory‬ﻭﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﻃﺒﺎﻋﺔ‬
‫ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳊﺮﻭﻑ ﻓﺎﻧﻪ ﳚﺐ ﺍﻧﺸﺎء ﻣﺘﻐﲑﺍﻥ )‪ (x,y‬ﳊﻔﻆ ﺍﳌﻜﺎﻥ ﺍﳊﺎﱄ ﻟﻠﺼﻒ ﻭﺍﻟﻌﻤﻮﺩ ﻭﻣﻦ ﰒ ﲢﻮﻳﻞ ﻫﺬﺍ‬
‫ﺍﳌﻜﺎﻥ ﺍﱃ ﻋﻨﻮﺍﻥ ﰲ ﺍﻝ ‪ .Video Memoey‬ﻭﰲ ﺍﻟﺒﺪﺍﻳﺔ ﺳﺘﻜﻮﻥ ﻗﻴﻢ )‪ (x,y‬ﻫﻲ )‪ (0,0‬ﺃﻱ ﺍﻥ ﺍﳊﺮﻑ ﺳﻴﻜﻮﻥ‬
‫ﰲ ﺍﳉﺰء ﺍﻻﻋﻠﻲ ﻣﻦ ﺍﻟﻴﺴﺎﺭ ﰲ ﺍﻟﺸﺎﺷﺔ ﻭﳚﺐ ﺍﺭﺳﺎﻝ ﻫﺬﺍ ﺍﳊﺮﻑ ﺍﱃ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﻝ ‪ Video Memory‬ﻭﻫﻮ‬
‫‪ .(Color text Mode) 0xb8000‬ﻭﻟﻄﺒﺎﻋﺔ ﺣﺮﻑ ﺁﺧﺮ ﻓﺎﻥ ﻗﻴﻢ )‪ (x,y‬ﻟﻪ ﻫﻲ )‪ (0,1‬ﻭﳚﺐ ﺍﺭﺳﺎﻝ ﺍﳊﺮﻑ‬
‫ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ ، 0xb8001‬ﻭﺳﻨﺴﺘﺨﺪﻡ ﺍﻟﻌﻼﻗﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺘﺤﻮﻳﻞ ﺑﲔ ﻗﻴﻢ )‪ (x,y‬ﺍﱃ ﻋﻨﺎﻭﻳﻦ ﻟﺬﺍﻛﺮﺓ ﺍﻟﻌﺮﺽ ‪Video‬‬
‫‪:Memory‬‬
‫‪videomemory = 0xb0000‬‬
‫‪videomemory+ = x + y ∗ 80‬‬

‫ﻭﺑﺴﺒﺐ ﺃﻥ ﻫﻨﺎﻙ ‪ 80‬ﺣﺮﻑ ﰲ ﻛﻞ ﻋﻤﻮﺩ ﻓﺎﻧﻪ ﳚﺐ ﺿﺮﺏ ﻗﻴﻤﺔ ‪ y‬ﺏ ‪ . 80‬ﻭﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ‬
‫ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻨﺪ )‪. (4,4‬‬
‫‪address = x + y ∗ 80‬‬

‫‪address = 4 + 4 ∗ 80 = 324‬‬

‫‪; now add the base address of video memory.‬‬

‫‪address = 324 + 0xb8000 = 0xb8144‬‬

‫ﻭﺑﺎﺭﺳﺎﻝ ﺍﳊﺮﻑ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0xb8144‬ﻓﺎﻥ ﺍﳊﺮﻑ ﺳﻮﻑ ﻳﻈﻬﺮ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﰲ ﺍﻟﺼﻒ ﺍﳋﺎﻣﺲ ﻭﺍﻟﻌﻤﻮﺩ‬
‫ﺍﳋﺎﻣﺲ )ﺍﻟﺘﺮﻗﻴﻢ ﻳﺒﺪﺃ ﻣﻦ ﺻﻔﺮ ﻭﺃﻭﻝ ﺻﻒ ﻭﻋﻤﻮﺩ ﺭﻗﻤﻬﺎ ﺻﻔﺮ(‪.‬‬
‫ﻭﻛﻤﺎ ﺫﻛﺮﻧﺎ ﺍﻥ ﺍﻟﻨﻤﻂ ﺍﻟﻨﺼﻲ ‪ Mode 7‬ﻫﻮ ﺍﻟﺬﻱ ﻳﺒﺪﺃ ﺍﳊﺎﺳﺐ ﺑﻪ ‪ ،‬ﰲ ﻫﺬﺍ ﺍﻟﻨﻤﻂ ﻳﺘﻌﺎﻣﻞ ﻣﺘﺤﻜﻢ ﺍﻟﻌﺮﺽ‬

‫‪٨٣‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫ﻣﻊ ﺑﺎﻳﺘﲔ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻞ ﺣﺮﻑ ﻳﺮﺍﺩ ﻃﺒﺎﻋﺘﻪ ‪ ،‬ﲟﻌﲎ ﺍﺫﺍ ﻣﺎ ﺃﺭﺩﻧﺎ ﻃﺒﺎﻋﺔ ﺍﳊﺮﻑ ‪ A‬ﻓﺎﻧﻪ ﳚﺐ ﺍﺭﺳﺎﻝ ﺍﳊﺮﻑ‬
‫ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0xb8000‬ﻭﺧﺼﺎﺋﺺ ﺍﳊﺮﻑ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﺘﺎﱄ ﻟﻪ ‪ 0xb8001‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺍﻧﻪ ﳚﺐ ﺗﻌﺪﻳﻞ ﻗﺎﻧﻮﻥ‬
‫ﺍﻟﺘﺤﻮﻳﻞ ﺍﻟﺴﺎﺑﻖ ﻭﺍﻋﺘﺒﺎﺭ ﺃﻥ ﻛﻞ ﺣﺮﻑ ﻳﺄﺧﺬ ﺑﺎﻳﺘﲔ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻟﻴﺲ ﺑﺎﻳﺖ ﻭﺍﺣﺪ‪.‬‬
‫ﺍﻟﺒﺎﻳﺖ ﺍﻟﺜﺎﱐ ﻟﻠﺤﺮﻑ ﳛﺪﺩ ﻟﻮﻥ ﺍﳊﺮﻑ ﻭﻛﺜﺎﻓﺔ ﺍﻟﻠﻮﻥ )ﻏﺎﻣﻖ ﻭﻓﺎﺗﺢ( ﻭﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﺍﻟﺒﺘﺎﺕ ﻓﻴﻪ‪:‬‬
‫ﺍﻟﺒﺘﺎﺕ ‪ :2-0‬ﻟﻮﻥ ﺍﳊﺮﻑ‪:‬‬ ‫•‬
‫– ﺍﻟﺒﺖ ‪ :0‬ﺃﲪﺮ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :1‬ﺃﺧﻀﺮ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :2‬ﺃﺯﺭﻕ‪.‬‬
‫ﺍﻟﺒﺖ ‪ :3‬ﻛﺜﺎﻓﺔ ﻟﻮﻥ ﺍﳊﺮﻑ ) ‪ 0‬ﻏﺎﻣﻖ ‪ 1 ،‬ﻓﺎﺗﺢ(‪.‬‬ ‫•‬

‫ﺍﻟﺒﺖ ‪ :6-4‬ﻟﻮﻥ ﺧﻠﻔﻴﺔ ﺍﳊﺮﻑ‪:‬‬ ‫•‬

‫– ﺍﻟﺒﺖ ‪ :0‬ﺃﲪﺮ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :1‬ﺃﺧﻀﺮ‪.‬‬
‫– ﺍﻟﺒﺖ ‪ :2‬ﺃﺯﺭﻕ‪.‬‬
‫ﺍﻟﺒﺖ ‪ :7‬ﻛﺜﺎﻓﺔ ﻟﻮﻥ ﺧﻠﻔﻴﺔ ﺍﳊﺮﻑ ) ‪ 0‬ﻏﺎﻣﻖ ‪ 1 ،‬ﻓﺎﺗﺢ(‪.‬‬ ‫•‬

‫ﻭﻫﻜﺬﺍ ﺗﻮﺟﺪ ‪ 4‬ﺑﺖ ﻟﺘﺤﺪﻳﺪ ﺍﻟﻠﻮﻥ ‪ ،‬ﻭﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﻫﺬﻩ ﺍﻷﻟﻮﺍﻥ‪:‬‬
‫‪• 0: Black.‬‬

‫‪• 1: Blue.‬‬

‫‪• 2: Green.‬‬

‫‪• 3: Cyan.‬‬

‫‪• 4: Red.‬‬

‫‪• 5: Magneta.‬‬

‫‪• 6: Brown.‬‬

‫‪• 7: Light gray.‬‬

‫‪• 8: Dark Gray.‬‬

‫‪• 9: Light Blue.‬‬

‫‪• 10: Light Green.‬‬

‫‪• 11: Light Cyan.‬‬

‫‪٨٤‬‬
VGA ‫ ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬.٣.٤

• 12: Light Red.

• 13: Light Magneta.

• 14: Light Brown.

• 15: White.

‫ ﻛﻤﺎ ﳚﺐ‬، ‫ ﻓﺎﻧﻪ ﳚﺐ ﺍﺭﺳﺎﻝ ﺍﳊﺮﻑ ﻭﺧﺼﺎﺋﺼﻪ ﺍﱃ ﺫﺍﻛﺮﺓ ﺍﻟﻌﺮﺽ‬Mode 7 ‫ﺍﺫﴽ ﻟﻄﺒﺎﻋﺔ ﺣﺮﻑ ﻋﻠﻰ ﺍﻟﻨﻤﻂ‬
(‫ ﻳﻈﻬﺮ ﻭﳜﺘﻔﻲ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ ﺍﳌﻮﻗﻊ ﺍﳊﺎﱄ‬underline ‫ )ﻫﻮ ﺧﻂ‬Cursor ‫ﻣﺮﺍﻋﺎﺓ ﺑﻌﺾ ﺍﻻﻣﻮﺭ ﻣﻦ ﲢﺪﻳﺚ ﺍﳌﺆﺷﺮ‬
‫ﻭ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﺼﻒ ﺍﻟﺘﺎﱄ ﰲ ﺣﺎﻟﺔ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺍﺧﺮ ﺣﺮﻑ ﰲ ﺍﻟﻌﻤﻮﺩ ﺃﻭ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺍﳊﺮﻑ ﺍﳌﺮﺍﺩ ﻃﺒﺎﻋﺘﻪ‬
‫ ﻭﺍﻟﱵ ﺗﺴﺘﺨﺪﻡ ﻟﻄﺒﺎﻋﺔ ﺣﺮﻑ‬putch32 ‫ ﻭﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﺍﻟﺪﺍﻟﺔ‬. 0xa ‫ﻫﻮ ﺣﺮﻑ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺳﻄﺮ ﺟﺪﻳﺪ‬
.PMode ‫ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬
Example ٤.١٠: putch32 rou ne
١
٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٣ ; putch32: print character in protected mode.
٤ ; input:
٥ ; bl: character to print.
٦ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٧
٨ bits 32
٩
١٠ %define VIDEO MEMORY 0xb8000 ; Base Address of Mapped Video
Memory.
١١ %define COLUMNS 80 ; text mode (mode 7) has 80 columns,
١٢ %define ROWS 25 ; and 25 rows.
١٣ %define CHAR ATTRIBUTE 31 ; white on blue.
١٤
١٥ x pos db 0 ; current x position.
١٦ y pos db 0 ; current y position.
١٧
١٨ putch32:
١٩
٢٠ pusha ; Save Registers.
٢١
٢٢ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٣ ; Check if bl is new line ?
٢٤ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٥

٨٥
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

٢٦ cmp bl,0xa ; if character is newline ?

٢٧ je new row ; yes, jmp at end.
٢٨
٢٩ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٠ ; Calculate the memory offset
٣١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٢ ; because in text mode every character take 2 bytes: one for the
character and one for the attribute, we must calculate the
memory offset with the follwing formula:
٣٣ ; offset = x pos ∗2 + y pos ∗COLUMNS∗2
٣٤
٣٥ xor eax,eax
٣٦
٣٧ mov al,2
٣٨ mul byte[x pos]
٣٩ push eax ; save the first section of formula.
٤٠
٤١ xor eax,eax
٤٢ xor ecx,ecx
٤٣
٤٤ mov ax,COLUMNS∗2 ; 80∗2
٤٥ mov cl,byte[y pos]
٤٦ mul ecx
٤٧
٤٨ pop ecx
٤٩ add eax,ecx
٥٠
٥١ add eax,VIDEO MEMORY ; eax = address to print the character.
٥٢
٥٣ ;−−−−−−−−−−−−−−−−−−−−−
٥٤ ; Print the chracter.
٥٥ ;−−−−−−−−−−−−−−−−−−−−−
٥٦
٥٧ mov edi,eax
٥٨
٥٩ mov byte[edi],bl ; print the character,
٦٠ mov byte[edi+1],CHAR ATTRIBUTE ; with respect to the
attribute.
٦١
٦٢ ;−−−−−−−−−−−−−−−−−−−−−
٦٣ ; Update the postions.

٨٦
‫‪VGA‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬

‫‪٦٤‬‬ ‫‪;−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٦٥‬‬
‫‪٦٦‬‬ ‫]‪inc byte[x pos‬‬
‫‪٦٧‬‬ ‫‪cmp byte[x pos],COLUMNS‬‬
‫‪٦٨‬‬ ‫‪je new row‬‬
‫‪٦٩‬‬
‫‪٧٠‬‬ ‫‪jmp putch32 end‬‬
‫‪٧١‬‬
‫‪٧٢‬‬
‫‪٧٣‬‬ ‫‪new row:‬‬
‫‪٧٤‬‬
‫‪٧٥‬‬ ‫‪mov byte[x pos],0‬‬ ‫‪; clear the x pos.‬‬
‫‪٧٦‬‬ ‫]‪inc byte[y pos‬‬ ‫‪; increment the y pos.‬‬
‫‪٧٧‬‬
‫‪٧٨‬‬ ‫‪putch32 end:‬‬
‫‪٧٩‬‬
‫‪٨٠‬‬ ‫‪popa‬‬ ‫‪; Restore Registers.‬‬
‫‪٨١‬‬
‫‪٨٢‬‬ ‫‪ret‬‬

‫ﻭﺗﺒﺪﺃ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻔﺤﺺ ﺍﳊﺮﻑ ﺍﳌﺮﺍﺩ ﻃﺒﺎﻋﺘﻪ )ﻣﻮﺟﻮﺩ ﰲ ﺍﳌﺴﺠﻞ ‪ (bl‬ﻣﻊ ﺣﺮﻑ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﺴﻄﺮ ﺍﳉﺪﻳﺪ‬
‫‪ 0xa‬ﻭﰲ ﺣﺎﻟﺔ ﺍﻟﺘﺴﺎﻭﻱ ﻳﺘﻢ ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺁﺧﺮ ﺟﺴﻢ ﺍﻟﺪﺍﻟﺔ ﻭﺍﻟﺬﻱ ﻳﻘﻮﻡ ﺑﺘﺼﻔﲑ ﻗﻴﻤﺔ ‪ x‬ﻭﺯﻳﺎﺩﺓ ﻗﻴﻤﺔ ‪y‬‬
‫ﺩﻻﻟﺔ ﻋﻠﻰ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﺴﻄﺮ ﺍﳉﺪﻳﺪ‪ .‬ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﺍﳊﺮﻑ ﻫﻮ ﺃﻱ ﺣﺮﻑ ﺁﺧﺮ ﻓﺎﻧﻪ ﳚﺐ ﺣﺴﺎﺏ ﺍﻟﻌﻨﻮﺍﻥ‬
‫ﺍﻟﺬﻱ ﳚﺐ ﺍﺭﺳﺎﻝ ﺍﳊﺮﻑ ﺍﻟﻴﻪ ﺣﱴ ﳝﻜﻦ ﻃﺒﺎﻋﺘﻪ ‪ ،‬ﻭﻛﻤﺎ ﺫﻛﺮﻧﺎ ﺃﻥ ﺍﻟﻨﻤﻂ ﺍﻟﻨﺼﻲ ‪ Mode 7‬ﻳﺴﺘﺨﺪﻡ ﺑﺎﻳﺘﲔ‬
‫ﻟﻜﻞ ﺣﺮﻑ ﻟﺬﺍ ﺳﻴﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻌﻼﻗﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﺘﺤﻮﻳﻞ ﻣﺎ ﺑﲔ )‪ (x,y‬ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳌﻄﻠﻮﺏ‪.‬‬
‫‪videomemory = 0xb0000‬‬
‫‪videomemory+ = x ∗ 2 + y ∗ 80 ∗ 2‬‬

‫ﻭﻛﻤﺎ ﻳﻈﻬﺮ ﰲ ﺍﻟﻜﻮﺩ ﺍﻟﺴﺎﺑﻖ ﻓﻘﺪ ﰎ ﺣﺴﺎﺏ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻭﺣﻔﻈﻪ ﰲ ﺍﳌﺴﺠﻞ ‪ eax‬ﻭﺑﻌﺪ ﺫﻟﻚ ﰎ ﻃﺒﺎﻋﺔ‬
‫ﺍﳊﺮﻑ ﺍﳌﻄﻠﻮﺏ ﺑﺎﳋﺼﺎﺋﺺ ﺍﻟﱵ ﰎ ﲢﺪﻳﺪﻫﺎ ﻣﺴﺒﻘﺎ ﻛﺜﺎﺑﺖ‪ .‬ﻭﺁﺧﺮ ﺧﻄﻮﺓ ﰲ ﺍﻟﺪﺍﻟﺔ ﻫﻲ ﺯﻳﺎﺩﺓ ﻗﻴﻢ )‪ (x,y‬ﻟﻠﺪﺍﻟﺔ‬
‫ﺍﱃ ﺍﳌﻜﺎﻥ ﺍﻟﺘﺎﱄ ‪ ،‬ﻭﻫﺬﺍ ﻳﺘﻢ ﺑﺰﻳﺎﺩﺓ ‪ x‬ﻓﻘﻂ ﻭﰲ ﺣﺎﻟﺔ ﺗﺴﺎﻭﺕ ﺍﻟﻘﻴﻤﺔ ﻣﻊ ﻗﻴﻤﺔ ﺁﺧﺮ ﻋﻤﻮﺩ ﰲ ﺍﻟﺼﻒ ﻓﺎﻧﻪ ﻳﺘﻢ‬
‫ﺯﻳﺎﺩﺓ ﻗﻴﻤﺔ ‪ y‬ﻭﺗﺼﻔﲑ ‪ x‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﺼﻒ ﺍﻟﺘﺎﱄ‪.‬‬

‫‪strings‬‬ ‫‪ .٣.٣.٤‬ﻃﺒﺎﻋﺔ ﺍﻟﺴﻼﺳﻞ ﺍﻟﻨﺼﻴﺔ‬

‫ﻟﻄﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ﺳﻨﺴﺘﺨﺪﻡ ﺩﺍﻟﺔ ﻃﺒﺎﻋﺔ ﺍﳊﺮﻑ ﻭﺳﻨﻘﻮﻡ ﺑﺄﺧﺬ ﺣﺮﻑ ﺣﺮﻑ ﻣﻦ ﺍﻟﺴﻠﺴﺔ ﻭﺍﺭﺳﺎﳍﺎ ﺍﱃ ﺩﺍﻟﺔ‬
‫ﻃﺒﺎﻋﺔ ﺍﳊﺮﻑ ﺣﱴ ﺗﻨﺘﻬﻲ ﺍﻟﺴﻠﺴﻠﺔ ‪ ،‬ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﺍﻟﺪﺍﻟﺔ ‪ puts32‬ﻟﻄﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ‪.‬‬
‫‪Example‬‬ ‫‪٤.١١: puts32 rou‬‬ ‫‪ne‬‬

‫‪٨٧‬‬
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

١
٢
٣ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٤ ; puts32: print string in protected mode.
٥ ; input:
٦ ; ebx: point to the string
٧ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٨
٩ bits 32
١٠
١١ puts32:
١٢
١٣ pusha ; Save Registers.
١٤
١٥ mov edi,ebx
١٦
١٧ @loop:
١٨ mov bl,byte[edi] ; read character.
١٩
٢٠ cmp bl,0x0 ; end of string ?
٢١ je puts32 end ; yes, jmp to end.
٢٢
٢٣ call putch32 ; print the character.
٢٤
٢٥ inc edi ; point to the next character.
٢٦
٢٧ jmp @loop
٢٨
٢٩ puts32 end:
٣٠
٣١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٢ ; Update the Hardware Cursor.
٣٣ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٤ ; After print the string update the hardware cursor.
٣٥
٣٦ mov bl,byte[x pos]
٣٧ mov bh,byte[y pos]
٣٨
٣٩ call move cursor
٤٠
٤١ popa ; Restore Registers.

٨٨
‫‪VGA‬‬ ‫‪ .٣.٤‬ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬

‫‪٤٢‬‬
‫‪٤٣‬‬ ‫‪ret‬‬

‫ﰲ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺳﻴﺘﻢ ﻗﺮﺍءﺓ ﺣﺮﻑ ﺣﺮﻑ ﻣﻦ ﺍﻟﺴﻠﺴﺔ ﺍﻟﻨﺼﻴﺔ ﻭﻃﺒﺎﻋﺘﻪ ﺍﱃ ﺃﻥ ﻧﺼﻞ ﺍﱃ ‪‬ﺎﻳﺔ ﺍﻟﺴﻠﺴﻠﺔ )ﺍﻟﻘﻴﻤﺔ‬
‫‪ ، (0x0‬ﻭﺑﻌﺪ ﺫﻟﻚ ﺳﻴﺘﻢ ﲢﺪﻳﺚ ﺍﳌﺆﺷﺮ ﻭﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﻣﺘﺤﻜﻢ ‪ CRT Controller‬ﻭﻧﻈﺮﴽ ﻻﻥ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‬
‫ﺑﻄﺊ ﻗﻠﻴﻼ ﻓﺎﻥ ﲢﺪﻳﺚ ﺍﳌﺆﺷﺮ ﺳﻴﻜﻮﻥ ﺑﻌﺪ ﻃﺒﺎﻋﺔ ﺍﻟﺴﻠﺴﻠﺔ ﻭﻟﻴﺲ ﺑﻌﺪ ﻃﺒﺎﻋﺔ ﻛﻞ ﺣﺮﻑ ‪.‬‬

‫‪Hardware Cursor‬‬ ‫‪ .٤.٣.٤‬ﲢﺪﻳﺚ ﺍﳌﺆﺷﺮ‬

‫ﻋﻨﺪ ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﺍﻭ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ﻓﺎﻥ ﻣﺆﺷﺮ ﺍﻟﻜﺘﺎﺑﺔ ﻻ ﻳﺘﺤﺮﻙ ﻣﻦ ﻣﻜﺎﻧﻪ ﺍﻻ ﻋﻨﺪ ﲢﺪﻳﺪﻩ ﻳﺪﻭﻳﺎ ‪ ،‬ﻭﻫﺬﺍ ﻳﺘﻢ‬
‫ﻋﻦ ﻃﺮﻳﻖ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺘﺤﻜﻢ ‪ . CRT Controller‬ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﳛﻮﻱ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺴﺠﻼﺕ ﻭﻟﻜﻨﻨﺎ ﺳﻮﻑ‬
‫ﻧﺮﻛﺰ ﻋﻠﻰ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ Data Register‬ﻭﻣﺴﺠﻞ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪.Index Register‬‬
‫ﻭﻻﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ ﺍﱃ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ‪ ،‬ﻓﻴﺠﺐ ﺍﻭﻻ ﲢﺪﻳﺪ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺫﻟﻚ ﺑﺎﺭﺳﺎﳍﺎ ﺍﱃ ﻣﺴﺠﻞ ‪Index‬‬
‫‪ Register‬ﻭﻣﻦ ﰒ ﺍﺭﺳﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﱃ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ ، Data Register‬ﻭﰲ ﺣﻮﺍﺳﻴﺐ ‪ x86‬ﻓﺎﻥ ﻣﺴﺠﻞ‬
‫ﺍﻟﺒﻴﺎﻧﺎﺕ ﻳﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x3d5‬ﻭﻣﺴﺠﻞ ‪ Index Register‬ﻳﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ ‪.0x3d4‬‬
‫ﻭﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﺍﻟﻘﻴﻢ ﺍﻟﱵ ﳝﻜﻦ ﺍﺭﺳﺎﳍﺎ ﺍﱃ ﻣﺴﺠﻞ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪.Index Register‬‬
‫‪• 0x0: Horizontal Total.‬‬

‫‪• 0x1: Horizontal Display Enable End.‬‬

‫‪• 0x2: Start Horizontal Blanking.‬‬

‫‪• 0x3: End Horizontal Blanking.‬‬

‫‪• 0x4: Start Horizontal Retrace Pulse.‬‬

‫‪• 0x5: End Horizontal Retrace.‬‬

‫‪• 0x6: Ver cal Total.‬‬

‫‪• 0x7: Overflow.‬‬

‫‪• 0x8: Preset Row Scan.‬‬

‫‪• 0x9: Maximum Scan Line.‬‬

‫‪• 0xa: Cursor Start.‬‬

‫‪• 0xb: Cursor End.‬‬

‫‪• 0xc: Start Address High.‬‬

‫‪٨٩‬‬
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫‪• 0xd: Start Address Low.‬‬

‫‪• 0xe: Cursor Loca on High.‬‬

‫‪• 0xf : Cursor Loca on Low.‬‬

‫‪• 0x10: Ver cal Retrace Start.‬‬

‫‪• 0x11: Ver cal Retrace End.‬‬

‫‪• 0x12: Ver cal Display Enable End.‬‬

‫‪• 0x13: Offset.‬‬

‫‪• 0x14: Underline Loca on.‬‬

‫‪• 0x15: Start Ver cal Blanking.‬‬

‫‪• 0x16: End Ver cal Blanking.‬‬

‫‪• 0x17: CRT Mode Control.‬‬

‫‪• 0x18: Line Compare.‬‬

‫ﻭﻋﻨﺪ ﺍﺭﺳﺎﻝ ﺃﻱ ﻣﻦ ﺍﻟﻘﻴﻢ ﺍﻟﺴﺎﺑﻘﺔ ﺍﱃ ﻣﺴﺠﻞ ‪ Index Reigster‬ﻓﺎﻥ ﻫﺬﺍ ﺳﻴﺤﺪﺩ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﱵ ﺳﺘﺮﺳﻞ‬
‫ﺍﱃ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪ .Data Register‬ﻭﻣﻦ ﺍﳉﺪﻭﻝ ﺍﻟﺴﺎﺑﻖ ﺳﻨﺠﺪ ﺃﻥ ﺍﻟﻘﻴﻤﺔ ‪ 0xf‬ﺳﺘﺤﺪﺩ ﻗﻴﻤﺔ ‪ x‬ﻟﻠﻤﺆﺷﺮ ‪،‬‬
‫ﻭﺍﻟﻘﻴﻤﺔ ‪ 0xe‬ﺳﺘﺤﺪﺩ ﻗﻴﻤﺔ ‪ y‬ﻟﻠﻤﺆﺷﺮ‪.‬ﻭﺑﻌﺪ ﺫﻟﻚ ﳚﺐ ﺍﺭﺳﺎﻝ ﻗﻴﻢ ‪ x,y‬ﺍﱃ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻋﻠﻰ ﺍﻟﺘﻮﺍﱄ ﻣﻊ‬
‫ﻣﻼﺣﻈﺔ ﺃﻥ ﻣﺘﺤﻜﻢ ‪ CRT‬ﻳﺘﻌﺎﻣﻞ ﻣﻊ ﺑﺎﻳﺖ ﻭﺍﺣﺪ ﻟﻜﻞ ﺣﺮﻑ ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻧﻨﺎ ﺳﻨﺴﺘﺨﺪﻡ ﺍﻟﻘﺎﻧﻮﻥ ﺍﻟﺘﺎﱄ ﻟﻠﺘﺤﻮﻳﻞ‬
‫ﻣﻦ ﻗﻴﻢ )‪ (x,y‬ﺍﱃ ﻋﻨﺎﻭﻳﻦ‪.‬‬
‫‪videomemory = x + y ∗ 80‬‬

‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻋﻤﻞ ﺍﻟﺪﺍﻟﺔ ‪ move cursor‬ﻭﺍﻟﱵ ﺗﻌﻤﻞ ﻋﻠﻰ ﲢﺮﻳﻚ ﺍﳌﺆﺷﺮ‪.‬‬
‫‪Example‬‬ ‫‪٤.١٢: Move Hardware Cursor‬‬
‫‪١‬‬
‫; ‪٢‬‬ ‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗‬
‫‪٣ ; move cursor: Move the Hardware Cursor.‬‬
‫; ‪٤‬‬ ‫‪input:‬‬
‫; ‪٥‬‬ ‫‪bl: x pos.‬‬
‫; ‪٦‬‬ ‫‪bh: y pos.‬‬
‫; ‪٧‬‬ ‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗‬
‫‪٨‬‬
‫‪٩ bits‬‬ ‫‪32‬‬
‫‪١٠‬‬

‫‪٩٠‬‬
VGA ‫ ﺃﺳﺎﺳﻴﺎﺕ ﺍﻝ‬.٣.٤

١١ move cursor:
١٢
١٣ pusha ; Save Registers.
١٤
١٥ ;−−−−−−−−−−−−−−−−−−−−−−
١٦ ; Calculate the offset.
١٧ ;−−−−−−−−−−−−−−−−−−−−−−
١٨ ; offset = x pos + y pos ∗COLUMNS
١٩
٢٠ xor ecx,ecx
٢١ mov cl,byte[x pos]
٢٢
٢٣ mov eax,COLUMNS
٢٤ mul byte[y pos]
٢٥
٢٦ add eax,ecx
٢٧ mov ebx,eax
٢٨
٢٩ ;−−−−−−−−−−−−−−−−−−−−
٣٠ ; Cursor Location Low.
٣١ ;−−−−−−−−−−−−−−−−−−−−−
٣٢
٣٣ mov al,0xf
٣٤ mov dx,0x3d4
٣٥ out dx,al
٣٦
٣٧ mov al,bl
٣٨ mov dx,0x3d5
٣٩ out dx,al
٤٠
٤١ ;−−−−−−−−−−−−−−−−−−−−−−
٤٢ ; Cursor Location High.
٤٣ ;−−−−−−−−−−−−−−−−−−−−−−
٤٤
٤٥ mov al,0xe
٤٦ mov dx,0x3d4
٤٧ out dx,al
٤٨
٤٩ mov al,bh
٥٠ mov dx,0x3d5
٥١ out dx,al

٩١
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

٥٢
٥٣
٥٤ popa ; Restore Registers.
٥٥
٥٦ ret

Clear Screen ‫ ﺗﻨﻈﻴﻒ ﺍﻟﺸﺎﺷﺔ‬.٥.٣.٤

‫( ﻭ ﺗﺼﻔﲑ‬Mode 7 ‫ ﰲ ﳕﻂ‬25*80) ‫ﺗﻨﻈﻴﻒ ﺍﻟﺸﺎﺷﺔ ﻫﻲ ﻋﻤﻠﻴﺔ ﺍﺭﺳﺎﻝ ﺣﺮﻑ ﺍﳌﺴﺎﻓﺔ ﺑﻌﺪﺩ ﺍﳊﺮﻭﻑ ﺍﳌﻮﺟﻮﺩﺓ‬
.‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺗﻨﻈﻴﻒ ﺍﻟﺸﺎﺷﺔ ﻭﲢﺪﻳﺪ ﺍﻟﻠﻮﻥ ﺍﻻﺯﺭﻕ ﻛﺨﻠﻔﻴﺔ ﻟﻜﻞ ﺣﺮﻑ‬. (x,y) ‫ﻗﻴﻢ‬
Example ٤.١٣: Clear Screen
١
٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٣ ; clear screen: Clear Screen in protected mode.
٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٥
٦ bits 32
٧
٨ clear screen:
٩
١٠ pusha ; Save Registers.
١١ cld
١٢
١٣ mov edi,VIDEO MEMORY ; base address of video memory.
١٤ mov cx,2000 ; 25∗80
١٥ mov ah,CHAR ATTRIBUTE ; 31 = white character on blue
background.
١٦ mov al,' '
١٧
١٨ rep stosw
١٩
٢٠ mov byte[x pos],0
٢١ mov byte[y pos],0
٢٢
٢٣ popa ; Restore Registers.
٢٤
٢٥ ret

٩٢
‫‪ .٤.٤‬ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ‬

‫‪ .٤.٤‬ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ‬
‫ﺍﱃ ﻫﻨﺎ ﺗﻨﺘﻬﻲ ﻣﻬﻤﺔ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ Second Stage Bootloader‬ﻭﻳﺘﺒﻘﻰ ﻓﻘﻂ ﺍﻟﺒﺤﺚ ﻋﻦ‬
‫ﺍﻟﻨﻮﺍﺓ ﻭﻧﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﻟﻴﻬﺎ ‪ .٤‬ﻭﰲ ﻫﺬﺍ ﺍﳉﺰء ﺳﻴﺘﻢ ﻛﺘﺎﺑﺔ ﻧﻮﺍﺓ ﲡﺮﻳﺒﻴﺔ ‪‬ﺪﻑ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﻋﻤﻠﻴﺔ ﻧﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﱃ‬
‫ﺍﻟﻨﻮﺍﺓ ﻭﻛﺬﻟﻚ ‪‬ﺪﻑ ﺇﻋﺎﺩﺓ ﻛﺘﺎﺑﺔ ﺷﻔﺮﺓ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺑﺸﻜﻞ ﺃﻓﻀﻞ‪.‬‬
‫ﻭﺳﻴﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﻟﻜﺘﺎﺑﺔ ﻫﺬﻩ ﺍﻟﻨﻮﺍﺓ ﺍﻟﺘﺠﺮﻳﺒﻴﺔ ﺣﻴﺚ ﺃﻥ ﺍﳌﻠﻒ ﺍﻟﻨﺎﺗﺞ ﺳﻴﻜﻮﻥ ‪ Pure Binary‬ﻭﻻ‬
‫ﳛﺘﺎﺝ ﺍﱃ ﳏﻤﻞ ﺧﺎﺹ ‪ ،‬ﻭﺍﺑﺘﺪﺍءﴽ ﻣﻦ ﺍﻟﻔﺼﻞ ﺍﻟﻘﺎﺩﻡ ﺳﻨﺘﺮﻙ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﺟﺎﻧﺒﺎ ﻭﻧﺒﺪﺃ ﺍﻟﻌﻤﻞ ﺑﻠﻐﺔ ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‪++‬‬
‫‪.‬‬
‫ﻭﲟﺎ ﺃﻧﻨﺎ ﻧﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ‪ PMode‬ﻓﻼ ﳝﻜﻨﻨﺎ ﺃﻥ ﻧﺴﺘﺨﺪﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪ int 0x13‬ﻟﺘﺤﻤﻴﻞ‬
‫ﻗﻄﺎﻋﺎﺕ ﺍﻟﻨﻮﺍﺓ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻭﳚﺐ ﺃﻥ ﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺩﺭﺍﻳﻔﺮ ﳌﺤﺮﻙ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺃﻭ ﻧﻘﻮﻡ ﺑﺘﺤﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﺍﱃ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻗﺒﻞ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻭﻫﺬﺍ ﻣﺎ ﺳﻨﻔﻌﻠﻪ ﺍﻻﻥ ‪ ،‬ﻭﺳﻨﺘﺮﻙ ﺟﺰﺋﻴﺔ ﺑﺮﳎﺔ ﳏﺮﻙ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻻﺣﻘﺎ‪.‬‬
‫ﻭﺣﻴﺚ ﺃﻥ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻳﺴﻤﺢ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺫﺍﻛﺮﺓ ﺣﱴ ‪ 4‬ﺟﻴﺠﺎ ‪ ،‬ﻓﺎﻥ ﺍﻟﻨﻮﺍﺓ ﺳﻨﻘﻮﻡ ﺑﺘﺤﻤﻴﻠﻬﺎ ﻋﻠﻰ ﺍﻟﻌﻨﻮﺍﻥ‬
‫‪ 0x100000‬ﺃﻱ ﻋﻨﺪ ‪ 1‬ﻣﻴﺠﺎ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪.‬ﻟﻜﻦ ﻋﻠﻴﻨﺎ ﺍﻟﺘﺬﻛﺮ ﺑﺄﻥ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻻ ﻳﺪﻋﻢ ﺍﻟﻮﺻﻮﻝ ﺍﱃ‬
‫ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x100000‬ﻟﺬﻟﻚ ﺳﻨﻘﻮﻡ ﺑﺘﺤﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﺃﻭﻻ ﰲ ﺃﻱ ﻋﻨﻮﺍﻥ ﺧﺎﱄ ﻭﻟﻴﻜﻦ ‪ 0x3000‬ﻭﻋﻨﺪ ﺍﻻﻧﺘﻘﺎﻝ‬
‫ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﺳﻨﻘﻮﻡ ﺑﻨﺴﺨﻬﺎ ﺍﱃ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x100000‬ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﻭﺍﻟﺘﺤﻜﻢ ﺍﻟﻴﻬﺎ‪.‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻧﻮﺍﺓ ﺗﺮﺣﻴﺒﻴﺔ‪.‬‬

‫‪Example‬‬ ‫‪٤.١٤: Hello Kernel‬‬

‫‪١‬‬
‫‪٢ org‬‬ ‫‪0x100000‬‬ ‫‪; kernel will load at 1 MB.‬‬
‫‪٣‬‬
‫‪٤ bits‬‬ ‫‪32‬‬ ‫‪; PMode.‬‬
‫‪٥‬‬
‫‪٦ jmp kernel entry‬‬
‫‪٧‬‬
‫"‪٨ %include "stdio.inc‬‬
‫‪٩‬‬
‫‪١٠‬‬
‫‪١١‬‬
‫‪١٢ kernel message‬‬ ‫‪db‬‬ ‫"‪0xa,0xa,0xa,‬‬ ‫‪eqraOS v0.1‬‬
‫"‪Copyright (C) 2010 Ahmad Essam‬‬
‫‪١٣‬‬ ‫‪db‬‬ ‫‪0xa,0xa,‬‬ ‫"‬ ‫‪University of Khartoum − Faculty‬‬
‫‪of Mathematical Sceinces.",0‬‬
‫‪١٤‬‬
‫‪١٥‬‬

‫‪٤‬ﺍﻟﻔﺼﻞ ﺍﻟﺘﺎﱄ ﺳﻴﺘﻨﺎﻭﻝ ﻣﻮﺿﻮﻉ ﺍﻟﻨﻮﺍﺓ ﻭﻛﻴﻔﻴﺔ ﺑﺮﳎﺘﻬﺎ ﺑﺎﻟﺘﻔﺼﻴﻞ‪.‬‬

‫‪٩٣‬‬
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

١٦ logo message db 0xa,0xa,0xa,"

/ \ / /"
١٧ db 0xa, " / − ) `/ / `/ / / / /
\ \ "
١٨ db 0xa, " \ /\ , / / \ , / \ //
/ "
١٩ db 0xa, " / /
",0
٢٠ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢١ ; Entry point.
٢٢ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٣
٢٤ kernel entry:
٢٥
٢٦ ;−−−−−−−−−−−−−−−
٢٧ ; Set Registers
٢٨ ;−−−−−−−−−−−−−−−
٢٩
٣٠ mov ax,0x10 ; data selector.
٣١ mov ds,ax
٣٢ mov es,ax
٣٣ mov ss,ax
٣٤ mov esp,0x90000 ; set stack.
٣٥
٣٦ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٧ ; Clear Screen and print message.
٣٨ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٣٩
٤٠ call clear screen
٤١
٤٢ mov ebx,kernel message
٤٣ call puts32
٤٤
٤٥ mov ebx,logo message
٤٦ call puts32
٤٧
٤٨ ;−−−−−−−−−−−−−−−−−
٤٩ ; Halt the system.
٥٠ ;−−−−−−−−−−−−−−−−−
٥١
٥٢ cli

٩٤
‫‪ .٤.٤‬ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ‬

‫‪٥٣‬‬ ‫‪hlt‬‬

‫ﻭﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺳﺘﻜﻮﻥ ﻫﻲ ﺍﳌﺴﺆﻭﻟﺔ ﻋﻦ ﺍﻟﺒﺤﺚ ﻋﻦ ﺍﻟﻨﻮﺍﺓ ﻭﲢﻤﻴﻠﻬﺎ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ ‪،‬‬
‫ﻭﺳﻴﺘﻢ ﲢﻤﻴﻠﻬﺎ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻗﺒﻞ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻭﺫﻟﻚ ﺣﱴ ﻧﺘﻜﻤﻦ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ‬
‫‪ int 0x13‬ﻭﻋﻨﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﺳﻴﺘﻢ ﻧﺴﺦ ﺍﻟﻨﻮﺍﺓ ﺍﱃ ﻋﻨﻮﺍﻥ ‪ 1‬ﻣﻴﺠﺎ ﻭﻧﻘﻞ ﺍﻟﺘﺤﻜﻢ ﺍﱃ ﺍﻟﻨﻮﺍﺓ‪.‬‬
‫ﻭﻟﺘﺤﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﳚﺐ ﺃﻭﻻ ﲢﻤﻴﻞ ‪ Root Directory‬ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺍﻟﺒﺤﺚ ﻋﻦ ﻣﻠﻒ ﺍﻟﻨﻮﺍﺓ ﻭﰲ ﺣﺎﻟﺔ‬
‫ﻛﺎﻥ ﺍﳌﻠﻒ ﻣﻮﺟﻮﺩﺍ ﺳﻴﺘﻢ ﻗﺮﺍءﺓ ﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻛﻠﺴﺘﺮ ﻟﻪ ‪ ،‬ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﺳﻴﻌﻤﻞ ﻙ ‪ index‬ﰲ ﺟﺪﻭﻝ ‪) FAT‬ﻭﺍﻟﺬﻱ‬
‫ﳚﺐ ﲢﻤﻴﻠﻪ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻳﻀﺎ( ﻭﺳﻴﺘﻢ ﻗﺮﺍءﺓ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻘﺎﺑﻠﺔ ﳍﺬﺍ ﺍﻝ ‪ index‬ﻭﺍﻟﱵ ﺳﺘﺨﱪﻧﺎ ﻫﻞ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﻫﺬﺍ‬
‫ﺍﻟﻜﻠﺴﺘﺮ ﻫﻮ ﺁﺧﺮ ﻛﻠﺴﺘﺮ ﻟﻠﻤﻠﻒ ﺃﻡ ﻻ ‪.٥‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻣﻠﻒ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﺍﳌﺤﻤﻞ ‪ ، stage2.asm‬ﻭﰎ ﺗﻘﺴﻴﻢ ﺍﻟﻜﻮﺩ ﺑﺸﻜﻞ ﺃﻛﺜﺮ ﺗﻨﻈﻴﻤﺎ‬
‫ﺣﻴﺚ ﰎ ﻧﻘﻞ ﺃﻱ ﺩﺍﻟﺔ ﺗﺘﻌﻠﻖ ﺑﺎﻟﻘﺮﺹ ﺍﳌﺮﻥ ﺍﱃ ﺍﳌﻠﻒ ‪) floppy.inc‬ﻣﻠﻒ ‪ .inc‬ﻫﻮ ﻣﻠﻒ ﻟﻠﺘﻀﻤﲔ ﰲ ﻣﻠﻒ ﺁﺧﺮ(‬
‫‪ ،‬ﻭﺍﻟﺪﻭﺍﻝ ﺍﳌﺘﻌﻠﻘﺔ ﺑﻨﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻣﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﳌﻠﻒ ‪ fat12.inc‬ﻭﺩﻭﺍﻝ ﺍﻻﺧﺮﺍﺝ ﻣﻮﺟﻮﺩﺓ ﰲ ‪ stdio.inc‬ﻭﺩﻭﺍﻝ‬
‫ﺗﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ ‪ A20‬ﻣﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺍﳌﻠﻒ ‪ a20.inc‬ﻭﺩﺍﻟﺔ ﺗﻌﻴﲔ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ﻭﻛﺬﻟﻚ ﺗﻔﺎﺻﻴﻞ ﺍﳉﺪﻭﻝ‬
‫ﻣﻮﺟﻮﺩﺓ ﰲ ﺍﳌﻠﻒ ‪ ، gdt.inc‬ﺍﺧﲑﺍ ﰎ ﺍﻧﺸﺎء ﻣﻠﻒ ‪ common.inc‬ﳊﻔﻆ ﺑﻌﺾ ﺍﻟﺜﻮﺍﺑﺖ ﺍﳌﺴﺘﺨﺪﻣﺔ ﺩﺍﺋﻤﺎ ‪.٦‬‬
‫‪Example‬‬ ‫‪٤.١٥: Loading and Execu‬‬ ‫‪ng Kernel: Full Example‬‬
‫‪١‬‬
‫‪٢‬‬
‫‪٣ bits 16‬‬ ‫‪; 16−bit real mode.‬‬
‫‪٤ org 0x500‬‬
‫‪٥‬‬
‫‪٦ start:‬‬ ‫‪jmp stage2‬‬
‫‪٧‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪٨‬‬
‫‪٩ ; include files:‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٠‬‬
‫"‪١١ %include "stdio.inc‬‬ ‫;‬ ‫‪standard I/O routines.‬‬
‫"‪١٢ %include "gdt.inc‬‬ ‫;‬ ‫‪GDT load routine.‬‬
‫"‪١٣ %include "a20.inc‬‬ ‫;‬ ‫‪Enable A20 routines.‬‬
‫"‪١٤ %include "fat12.inc‬‬ ‫;‬ ‫‪FAT12 driver.‬‬
‫"‪١٥ %include "common.inc‬‬ ‫;‬ ‫‪common declarations.‬‬
‫‪١٦‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٧‬‬
‫‪١٨ ; data and variable‬‬
‫∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ; ‪١٩‬‬
‫‪٢٠‬‬

‫‪٥‬ﺭﺍﺟﻊ ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺑﻖ ﳌﻌﺮﻓﺔ ﺍﻟﺘﻔﺎﺻﻴﻞ‪.‬‬

‫‪٦‬ﲨﻴﻊ ﺷﻔﺮﺍﺕ ﺍﳌﻠﻔﺎﺕ ﻣﺮﻓﻘﺔ ﻣﻊ ﺍﻟﺒﺤﺚ ﰲ ﳎﻠﺪ ‪ example/ch3/boot/‬ﻭﺷﻔﺮﺓ ﺍﳌﺤﻤﻞ ﺍﻟﻨﻬﺎﺋﻴﺔ ﺳﺘﻜﻮﻥ ﻣﻠﺤﻘﺔ ﰲ ‪‬ﺎﻳﺔ ﺍﻟﺒﺤﺚ‪.‬‬

‫‪٩٥‬‬
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

٢١ hello msg db 0xa,0xd,"Welcome to eqraOS Stage2",0xa,0xd,0

٢٢ fail message db 0xa,0xd,"KERNEL.SYS is Missing. press any key to
reboot...",0
٢٣
٢٤
٢٥
٢٦ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٧ ; entry point of stage2 bootloader.
٢٨ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
٢٩
٣٠ stage2:
٣١
٣٢ ;−−−−−−−−−−−−−−−
٣٣ ; Set Registers.
٣٤ ;−−−−−−−−−−−−−−−
٣٥
٣٦ cli
٣٧
٣٨ xor ax, ax
٣٩ mov ds, ax
٤٠ mov es, ax
٤١
٤٢ mov ax, 0x0
٤٣ mov ss, ax
٤٤ mov sp, 0xFFFF
٤٥
٤٦ sti
٤٧
٤٨ ;−−−−−−−−−−−−−−−−−−−−
٤٩ ; Load gdt into gdtr.
٥٠ ;−−−−−−−−−−−−−−−−−−−−
٥١
٥٢ call load gdt
٥٣
٥٤ ;−−−−−−−−−−−−−−−−−−−−
٥٥ ; Enable A20.
٥٦ ;−−−−−−−−−−−−−−−−−−−−
٥٧ call enable a20 keyboard controller output port
٥٨
٥٩ ;−−−−−−−−−−−−−−−−
٦٠ ; Display Message.

٩٦
 ‫ ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ‬.٤.٤

٦١ ;−−−−−−−−−−−−−−−−−
٦٢ mov si,hello msg
٦٣ call puts16
٦٤
٦٥ ;−−−−−−−−−−−−−−−−−−−−−
٦٦ ; Load Root Directory
٦٧ ;−−−−−−−−−−−−−−−−−−−−−−
٦٨ call load root
٦٩
٧٠ ;−−−−−−−−−−−−−−−−−−−−−
٧١ ; Load Kernel
٧٢ ;−−−−−−−−−−−−−−−−−−−−−
٧٣ xor ebx,ebx
٧٤ mov bp,KERNEL RMODE BASE ; bx:bp buffer to load kernel
٧٥
٧٦ mov si,kernel name
٧٧ call load file
٧٨
٧٩ mov dword[kernel size],ecx
٨٠ cmp ax,0
٨١ je enter stage3
٨٢
٨٣ mov si,fail message
٨٤ call puts16
٨٥
٨٦ mov ah,0
٨٧ int 0x16 ; wait any key.
٨٨ int 0x19 ; warm boot.
٨٩ cli ; cannot go here!
٩٠ hlt
٩١
٩٢
٩٣ ;−−−−−−−−−−−−−−−−
٩٤ ; Go to PMode.
٩٥ ;−−−−−−−−−−−−−−−−
٩٦
٩٧ enter stage3:
٩٨
٩٩ ; just set bit 0 from cr0 (Control Register 0).
١٠٠
١٠١ cli ; important.

٩٧
 ‫ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬- ‫ ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ‬.٤

١٠٢ mov eax,cr0

١٠٣ or eax,0x1
١٠٤ mov cr0,eax ; entering pmode.
١٠٥
١٠٦
١٠٧ ;−−−−−−−−−−−−−−−−−−−
١٠٨ ; Fix CS value
١٠٩ ;−−−−−−−−−−−−−−−−−−−−
١١٠ ; select the code descriptor
١١١ jmp CODE DESCRIPTOR:stage3
١١٢
١١٣
١١٤ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١١٥ ; entry point of stage3
١١٦ ; ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
١١٧
١١٨ bits 32 ; code now 32−bit
١١٩
١٢٠ stage3:
١٢١
١٢٢ ;−−−−−−−−−−−−−−−−;
١٢٣ ; Set Registers.
١٢٤ ;−−−−−−−−−−−−−−−−;
١٢٥
١٢٦ mov ax,DATA DESCRIPTOR ; address of data descriptor.
١٢٧ mov ds,ax
١٢٨ mov ss,ax
١٢٩ mov es,ax
١٣٠ mov esp,0x90000 ; stack begin from 0x90000.
١٣١
١٣٢ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
١٣٣ ; Clear Screen and print message.
١٣٤ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
١٣٥
١٣٦ call clear screen
١٣٧
١٣٨ mov ebx,stage2 message
١٣٩ call puts32
١٤٠
١٤١ mov ebx,logo message
١٤٢ call puts32

٩٨
 ‫ ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ‬.٤.٤

١٤٣
١٤٤
١٤٥
١٤٦ ;−−−−−−−−−−−−−−−−−−−−−−−−
١٤٧ ; Copy Kernel at 1 MB.
١٤٨ ;−−−−−−−−−−−−−−−−−−−−−−−
١٤٩ mov eax,dword[kernel size]
١٥٠ movzx ebx,word[bytes per sector]
١٥١ mul ebx
١٥٢ mov ebx,4
١٥٣ div ebx
١٥٤
١٥٥ cld
١٥٦
١٥٧ mov esi,KERNEL RMODE BASE
١٥٨ mov edi,KERNEL PMODE BASE
١٥٩ mov ecx,eax
١٦٠ rep movsd
١٦١
١٦٢ ;−−−−−−−−−−−−−−−−−−−−
١٦٣ ; Execute the kernel.
١٦٤ ;−−−−−−−−−−−−−−−−−−−−
١٦٥ jmp CODE DESCRIPTOR:KERNEL PMODE BASE
١٦٦
١٦٧ ;−−−−−−−−−−−−−−−−−;
١٦٨ ; Hlat the system.
١٦٩ ;−−−−−−−−−−−−−−−−−;
١٧٠ cli ; clear interrupt.
١٧١ hlt ; halt the system.

:‫ﺍﻟﻨﺘﻴﺠﺔ‬

٩٩
 ‫‪ .٤‬ﺑﺮﳎﺔ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ -‬ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ‬

‫ﺷﻜﻞ ‪ :.١.٤‬ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺃﺛﻨﺎء ﺍﻟﻌﻤﻞ‬

‫ﺷﻜﻞ ‪ :.٢.٤‬ﺑﺪء ﺗﻨﻔﻴﺬ ﺍﻟﻨﻮﺍﺓ‬

‫‪١٠٠‬‬
 ‫ﺍﻟﻘﺴﻢ ‪.III‬‬
‫‪Kernel‬‬ ‫ﺍﻟﻨﻮﺍﺓ‬
 ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﺃﺣﺪ ﺃﻫﻢ ﺍﳌﻜﻮﻧﺎﺕ ﰲ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻫﻲ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ )‪ (Kernel‬ﺣﻴﺚ ﺗﺪﻳﺮ ﻫﺬﻩ ﺍﻟﻨﻮﺍﺓ ﻋﺘﺎﺩ ﻭﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ‬
‫ﻭﺗﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺑﺮﳎﻴﺔ ﻋﺎﻟﻴﺔ ﺗﺴﻤﺢ ﻟﱪﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﻣﻦ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻫﺬﻩ ﺍﳌﻮﺍﺭﺩ ﺑﺸﻜﻞ ﺟﻴﺪ‪.‬ﻭﺗﻌﺘﱪ ﺑﺮﳎﺔ‬
‫ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻣﻦ ﺃﺻﻌﺐ ﺍﳌﻬﻤﺎﺕ ﺍﻟﱪﳎﻴﺔ ﻋﻠﻰ ﺍﻻﻃﻼﻕ ‪ ،‬ﺣﻴﺚ ﺗﺆﺛﺮ ﻫﻴﻜﻠﺘﻪ ﻭﺗﺼﻤﻴﻤﻪ ﻋﻠﻰ ﻛﺎﻓﺔ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﻭﻫﺬﺍ ﻣﺎ ﳝﻴﺰ ﺑﻌﺾ ﺍﻻﻧﻈﻤﺔ ﻭﳚﻌﻠﻬﺎ ﻗﺎﺑﻠﺔ ﻟﻠﻌﻤﻞ ﰲ ﺃﺟﻬﺰﺓ ﻣﻌﻴﻨﺔ‪ .‬ﻭﰲ ﻫﺬﺍ ﺍﻟﻔﺼﻞ ﺳﻨﻠﻘﻲ ﻧﻈﺮﺓ ﻋﻠﻰ ﺍﻟﻨﻮﺍﺓ‬
‫ﻭﺑﺮﳎﺘﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺍﻟﺴﻲ ﻭ ﺍﻟﺴﻲ‪ ++‬ﻭﻛﺬﻟﻚ ﺳﻴﺘﻢ ﺍﳊﺪﻳﺚ ﻋﻦ ﻃﺮﻕ ﺗﺼﻤﻴﻢ ﺍﻟﻨﻮﺍﺓ ﻭﻣﻴﺰﺍﺕ ﻭﻋﻴﻮﺏ‬
‫ﻛﻞٌ ﻋﻠﻰ ﺣﺪﺓ‪.‬‬

‫‪ .١.٥‬ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺗﻌﺮ‪‬ﻑ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺑﺄ‪‬ﺎ ﺍﳉﺰء ﺍﻷﺳﺎﺳﻲ ﰲ ﺍﻟﻨﻈﺎﻡ ﻭﺍﻟﺬﻱ ﺗﻌﺘﻤﺪ ﻋﻠﻴﻪ ﺑﻘﻴﺔ ﻣﻜﻮﻧﺎﺕ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‪.‬‬
‫ﻭﻳﻜﻤﻦ ﺩﻭﺭ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﰲ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﻋﺘﺎﺩ ﺍﳊﺎﺳﺐ ﻭﺇﺩﺍﺭﺗﻪ ﲝﻴﺚ ﺗﻜﻮ‪‬ﻥ ﻃﺒﻘﺔ ﺑﺮﳎﻴﺔ ﺗﺒﻌﺪ ﺑﺮﺍﻣﺞ‬
‫ﺍﳌﺴﺘﺨﺪﻡ ﻣﻦ ﺗﻔﺎﺻﻴﻞ ﻭﺗﻌﻘﻴﺪﺍﺕ ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻭﻻ ﺗﻘﺘﺼﺮ ﻋﻠﻰ ﺫﻟﻚ ﺑﻞ ﺗﻮﻓﺮ ﻭﺍﺟﻬﺔ ﺑﺮﳎﻴﺔ ﻣﺒﺴﻄﺔ )ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ‬
‫ﻣﻦ ﻟﻐﺔ ﺍﻟﱪﳎﺔ ﺍﳌﺪﻋﻮﻣﺔ ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ( ﲝﻴﺚ ﲤﻜﻦ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ‪ .‬ﻭﰲ ﺍﳊﻘﻴﻘﺔ‬
‫ﻻ ﻳﻮﺟﺪ ﻗﺎﻧﻮﻥ ﻳﻨﺺ ﻋﻠﻰ ﺇﻟﺰﺍﻣﻴﺔ ﻭﺟﻮﺩ ﻧﻮﺍﺓ ﻟﻠﻨﻈﺎﻡ ‪ ،‬ﺣﻴﺚ ﳝﻜﻦ ﻟﱪﻧﺎﻣﺞ ﻣﺎ )ﻳﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ( ﺍﻟﺘﻌﺎﻣﻞ‬
‫ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﻭﻣﻊ ﻛﻞ ﺍﳉﺪﺍﻭﻝ ﰲ ﺍﳊﺎﺳﺐ ﻭﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﺑﺎﻳﺖ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻦ ﻫﺬﺍ ﻣﺎ ﺳﻴﺠﻌﻞ ﻋﻤﻠﻴﺔ‬
‫ﻛﺘﺎﺑﺔ ﺍﻟﱪﺍﻣﺞ ﻋﻤﻠﻴﺔ ﺷﺒﻪ ﻣﺴﺘﺤﻴﻠﺔ ! ﺣﻴﺚ ﳚﺐ ﻋﻠﻰ ﻛﻞ ﻣﱪﻣﺞ ﻳﺮﻳﺪ ﻛﺘﺎﺑﺔ ﺗﻄﺒﻴﻖ ﺑﺴﻴﻂ ﺃﻥ ﳚﻴﺪ ﺑﺮﳎﺔ‬
‫ﺍﻟﻌﺘﺎﺩ ﻭﺃﺳﺎﺳﻴﺎﺕ ﺍﻻﻗﻼﻉ ﺣﱴ ﻳﻌﻤﻞ ﺑﺮﻧﺎﳎﻪ ‪ ،‬ﺍﺿﺎﻓﺔ ﻋﻠﻰ ﺫﻟﻚ ﻻ ﳝﻜﻦ ﺗﺸﻐﻴﻞ ﺃﻛﺜﺮ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﰲ ﻧﻔﺲ‬
‫ﺍﻟﻮﻗﺖ ﻧﻈﺮﺍ ﻟﻌﺪﻡ ﻭﺟﻮﺩ ﺑﻨﻴﺔ ﲢﺘﻴﺔ ﺗﻮﻓﺮ ﻣﺜﻞ ﻫﺬﻩ ﺍﳋﺼﺎﺋﺺ ‪ ،‬ﻭﻻﻧﻨﺴﻰ ﺍﻋﺪﺍﺩ ﻭ‪‬ﻴﺌﺔ ﺟﺪﺍﻭﻝ ﺍﻟﻨﻈﺎﻡ ﻭﻛﺘﺎﺑﺔ‬
‫ﻭﻇﺎﺋﻒ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻭﺍﻷﺧﻄﺎء‪ ،‬ﻭﺩﻭﺍﻝ ﺣﺠﺰ ﻭﲢﺮﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻏﲑﻫﺎ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﺍﻟﻀﺮﻭﺭﻳﺔ ﻷﻱ‬
‫ﺑﺮﻧﺎﻣﺞ‪.‬ﻛﻞ ﻫﺬﺍ ﳚﻌﻞ ﻋﻤﻠﻴﺔ ﺗﻄﻮﻳﺮ ﺑﺮﻧﺎﻣﺞ ﻟﻠﻌﻤﻞ ﻋﻠﻰ ﺣﺎﺳﺐ ﻣﺎ ﺑﺪﻭﻥ ﻧﻮﺍﺓ ﻟﻪ ﺃﻣﺮﴽ ﻏﲑ ﻣﺮﻏﻮﺑﺎ ‪ ،‬ﺧﺎﺻﺔ ﺇﺫﺍ‬
‫ﺫﻛﺮﻧﺎ ﺃﻥ ﺍﻟﱪﻧﺎﻣﺞ ﳚﺐ ﲢﺪﻳﺜﻪ ﳎﺪﺩﴽ ﻋﻨﺪ ﻧﻘﻠﻪ ﺍﱃ ﻣﻨﺼﺔ ﺃﺧﺮﻯ ﺫﺍﺕ ﻋﺘﺎﺩ ﳐﺘﻠﻒ‪ .‬ﺍﺫﴽ ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻝ ﺃﻥ ﻧﻮﺍﺓ‬
‫ﺍﻟﻨﻈﺎﻡ ﻫﻲ ﺍﳉﺰء ﺍﻻﻫﻢ ﰲ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻛﻜﻞ ‪،‬ﺣﻴﺚ ﺗﺪﻳﺮ ﺍﻟﻨﻮﺍﺓ ﻋﺘﺎﺩ ﺍﳊﺎﺳﺐ ﻣﻦ ﺍﳌﻌﺎﰿ ﻭﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ‬
‫ﻭﺍﻷﻗﺮﺍﺹ ﺍﻟﺼﻠﺒﺔ ﻭﺍﳌﺮﻧﺔ ﻭﻏﲑﻫﺎ ﻣﻦ ﺍﻷﺟﻬﺰﺓ ﺍﳌﺤﻴﻄﺔ ﺑﺎﳊﺎﺳﺐ‪.‬‬
‫ﻭﺣﱴ ﻧﻔﻬﻢ ﻋﻼﻗﺔ ﺍﻟﻨﻮﺍﺓ ﻣﻊ ﺑﻘﻴﺔ ﺃﺟﺰﺍء ﺍﻟﻨﻈﺎﻡ ‪ ،‬ﻓﺎﻧﻪ ﳝﻜﻦ ﺗﻘﺴﻴﻢ ﺍﳊﺎﺳﺐ ﺍﱃ ﻋﺪﺓ ﻣﺴﺘﻮﻳﺎﺕ ﻣﻦ ﺍﻟﺘﺠﺮﻳﺪ‬
‫ﲝﻴﺚ ﻛﻞ ﻣﺴﺘﻮﻯ ﳜﺪﻡ ﺍﳌﺴﺘﻮﻯ ﺍﻟﺬﻱ ﻳﻠﻴﻪ ‪.‬‬

‫‪١٠٣‬‬
 ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪ .١.١.٥‬ﻣﺴﺘﻮﻳﺎﺕ ﺍﻟﺘﺠﺮﻳﺪ‬
‫ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﱪﳎﻴﺎﺕ ﻳﺘﻢ ﺑﻨﺎﺋﻬﺎ ﻋﻠﻰ ﺷﻜﻞ ﻣﺴﺘﻮﻳﺎﺕ ‪ ،‬ﻭﻇﻴﻔﺔ ﻛﻞ ﻣﺴﺘﻮﻯ ﻫﻮ ﺗﻮﻓﲑ ﻭﺍﺟﻬﺔ ﻟﻠﻤﺴﺘﻮﻯ ﺍﻟﺬﻱ‬
‫ﻳﻠﻴﻪ ﲝﻴﺚ ﲣﻔﻲ ﻫﺬﻩ ﺍﻟﻮﺍﺟﻬﺔ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﺘﻌﻘﻴﺪﺍﺕ ﻭﺍﻟﺘﻔﺎﺻﻴﻞ ﻭﻛﺬﻟﻚ ﺭﲟﺎ ﳛﻤﻲ ﻣﺴﺘﻮﻯ ﻣﺎ ﺑﻌﺾ ﺍﳋﺼﺎﺋﺺ‬
‫ﻣﻦ ﺍﳌﺴﺘﻮﻯ ﺍﻟﺬﻱ ﻳﻠﻴﻪ ‪ ،‬ﻭﻏﺎﻟﺒﺎ ﻣﺎ ﻳﺘﺒﻊ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﳍﺬﺍ ﺍﻟﻨﻮﻉ ﻣﻦ ﺍﻟﱪﳎﻴﺎﺕ ﺣﻴﺚ ﳝﻜﻦ ﺗﻘﺴﻴﻢ ﺍﻟﻨﻈﺎﻡ ﻛﻜﻞ‬
‫ﺍﱃ ﻋﺪﺓ ﻣﺴﺘﻮﻳﺎﺕ‪.‬‬

‫ﺍﳌﺴﺘﻮﻯ ﺍﻷﻭﻝ‪ :‬ﻣﺴﺘﻮﻯ ﺍﻟﻌﺘﺎﺩ‬

‫ﻣﺴﺘﻮﻯ ﺍﻟﻌﺘﺎﺩ ﻫﻮ ﺃﺩﱏ ﻣﺴﺘﻮﻯ ﳝﻜﻦ ﺃﻥ ﻧﻌﺮﻓﻪ ﻭﻳﻈﻬﺮ ﻋﻠﻰ ﺷﻜﻞ ﻣﺘﺤﻜﻤﺎﺕ ﻟﻌﺘﺎﺩ ﺍﳊﺎﺳﺐ ‪ ،‬ﺣﻴﺚ ﻳﺮﺗﺒﻂ‬
‫ﻣﺘﺤﻜﻢ ﻣﺎ ﰲ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ ﻣﻊ ﻣﺘﺤﻜﻢ ﺁﺧﺮ ﰲ ﺍﻟﻌﺘﺎﺩ ﻧﻔﺴﻪ‪ .‬ﻭﻇﻴﻔﺔ ﺍﳌﺘﺤﻜﻢ ﰲ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ ﻫﻲ ﺍﻟﺘﺨﺎﻃﺐ ﻣﻊ‬
‫ﺍﳌﺘﺤﻜﻢ ﺍﻻﺧﺮ ﰲ ﺍﻟﻌﺘﺎﺩ ﻭﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻳﻘﻮﻡ ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﺴﺘﻘﺒﻠﺔ‪ .‬ﻛﻴﻒ ﻳﻘﻮﻡ ﺍﳌﺘﺤﻜﻢ ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ؟‬
‫ﻫﺬﺍ ﻫﻮ ﺩﻭﺭ ﺍﳌﺴﺘﻮﻯ ﺍﻟﺜﺎﱐ‪.‬‬

‫‪Firmware‬‬ ‫ﺍﳌﺴﺘﻮﻯ ﺍﻟﺜﺎﱐ‪ :‬ﻣﺴﺘﻮﻯ ﺑﺮﺍﻣﺞ ﺍﻟﻌﺘﺎﺩ‬

‫ﺑﺮﺍﻣﺞ ﺍﻟﻌﺘﺎﺩ )‪ (Firmware‬ﻫﻲ ﺑﺮﺍﻣﺞ ﻣﻮﺟﻮﺩﺓ ﻋﻠﻰ ﺫﺍﻛﺮﺓ ﺑﺪﺍﺧﻞ ﺍﳌﺘﺤﻜﻢ )ﻏﺎﻟﺒﺎ ﺫﺍﻛﺮﺓ ‪ ، (EEPROM‬ﻭﻇﻴﻔﺔ‬
‫ﻫﺬﻩ ﺍﻟﱪﺍﻣﺞ ﻫﻲ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﺮﺳﻠﺔ ﺍﱃ ﺍﳌﺘﺤﻜﻢ‪ .‬ﻭﻣﻦ ﺍﻻﻣﺜﻠﺔ ﻋﻠﻰ ﻣﺜﻞ ﻫﺬﻩ ﺍﻟﱪﳎﻴﺎﺕ ﺑﺮﻧﺎﻣﺞ ﺍﻟﺒﺎﻳﻮﺱ ﻭﺃﻱ‬
‫ﺑﺮﻧﺎﻣﺞ ﻣﻮﺟﻮﺩ ﰲ ﺃﻱ ﻣﺘﺤﻜﻢ ﻣﺜﻞ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‪.‬‬

‫ﺍﳌﺴﺘﻮﻯ ﺍﻟﺜﺎﻟﺚ‪ :‬ﻣﺴﺘﻮﻯ ﺍﻟﻨﻮﺍﺓ )ﺍﳊﻠﻘﺔ ﺻﻔﺮ(‬

‫ﺍﻟﻨﻮﺍﺓ ﻭﻫﻲ ﺃﺳﺎﺱ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ‪ ،‬ﻭﻇﻴﻔﺘﻬﺎ ﺍﺩﺍﺭﺓ ﻣﻮﺍﺭﺩ ﺍﳊﺎﺳﺐ ﻭﺗﻮﻓﲑ ﻭﺍﺟﻬﺔ ﻟﺒﻘﻴﺔ ﺃﺟﺰﺍء ﺍﻟﻨﻈﺎﻡ ‪ ،‬ﻭﺗﻌﻤﻞ‬
‫ﺍﻟﻨﻮﺍﺓ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ‪ ،‬ﺍﻱ ﺃﻧﻪ ﳝﻜﻦ ﺗﻨﻔﻴﺬ ﺃﻱ ﺃﻣﺮ ﻭﺍﻟﻮﺻﻮﻝ ﺍﳌﺒﺎﺷﺮ ﺍﱃ ﺃﻱ ﻋﻨﻮﺍﻥ ﰲ ﺍﻟﺬﺍﻛﺮﺓ‪.‬‬

‫ﺍﳌﺴﺘﻮﻯ ﺍﻟﺮﺍﺑﻊ‪ :‬ﻣﺴﺘﻮﻯ ﻣﺸﻐﻼﺕ ﺍﻷﺟﻬﺰﺓ )ﺍﳊﻠﻘﺔ ‪ ١‬ﻭ ‪(٢‬‬

‫ﻣﺸﻐﻼﺕ ﺍﻷﺟﻬﺰﺓ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﺑﺮﺍﻣﺞ ﻟﻠﻨﻈﺎﻡ ﻭﻇﻴﻔﺘﻬﺎ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺘﺤﻜﻤﺎﺕ ﺍﻟﻌﺘﺎﺩ )ﻭﺫﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺍﻟﻨﻮﺍﺓ(‬
‫ﺳﻮﺍءﺍ ﻟﻘﺮﺍءﺓ ﺍﻟﻨﺘﺎﺋﺞ ﺍﻭ ﻻﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ‪ ،‬ﻫﺬﻩ ﺍﻟﱪﺍﻣﺞ ﲢﺘﺎﺝ ﺍﱃ ﺃﻥ ﺗﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ‪ ١‬ﻭ ‪ ٢‬ﺣﱴ ﺗﺘﻤﻜﻦ ﻣﻦ‬
‫ﺗﻨﻔﻴﺬ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﻭﺍﻣﺮ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﰎ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ﻓﺎﻥ ﻫﺬﺍ ﻗﺪ ﻳﺆﺩﻱ ﺍﱃ ﺧﻄﻮﺭﺓ ﺗﻌﻄﻞ ﺍﻟﻨﻈﺎﻡ‬
‫ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﻫﻨﺎﻙ ﻋﻄﻞ ﰲ ﺍﺣﺪ ﺍﳌﺸﻐﻼﺕ ﻛﺬﻟﻚ ﺳﺘﻜﻮﻥ ﺻﻼﺣﻴﺎﺕ ﺍﳌﺸﻐﻞ ﻋﺎﻟﻴﺔ ﻓﻘﺪ ﻳﻘﻮﻡ ﺃﺣﺪ ﺍﳌﺸﻐﻼﺕ‬
‫ﺑﺘﻐﻴﲑ ﺃﺣﺪ ﺟﺪﺍﻭﻝ ﺍﳌﻌﺎﰿ ﻣﺜﻞ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ )‪ (GDT‬ﻭﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻗﺪ ﻳﻌﻄﻞ ﺍﻟﻨﻈﺎﻡ‪.‬‬

‫‪١٠٤‬‬
‫‪ .٢.٥‬ﻭﻇﺎﺋﻒ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫ﺍﳌﺴﺘﻮﻯ ﺍﳋﺎﻣﺲ‪ :‬ﻣﺴﺘﻮﻯ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ )ﺍﳊﻠﻘﺔ ‪(٣‬‬

‫ﺍﳌﺴﺘﻮﻯ ﺍﻻﺧﲑ ﻭﻫﻮ ﻣﺴﺘﻮﻯ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﺣﻴﺚ ﻻ ﳝﻜﻦ ﳍﺬﻩ ﺍﻟﱪﺍﻣﺞ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺍﻟﻨﻮﺍﺓ ﻭﺍﳕﺎ ﺗﺘﻌﺎﻣﻞ ﻓﻘﻂ‬
‫ﻣﻊ ﻭﺍﺟﻬﺔ ﺑﺮﳎﺔ ﺍﻟﺘﻄﺒﻴﻘﺎﺕ )‪ (Applica on Progeamming Interface‬ﻭﺍﻟﱵ ﺗﻌﺮﻑ ﺑﺪﻭﺍﻝ )‪.(API‬‬

‫‪ .٢.٥‬ﻭﻇﺎﺋﻒ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫ﲣﺘﻠﻒ ﻣﻜﻮﻧﺎﺕ ﻭﻭﻇﺎﺋﻒ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺗﺒﻌﴼ ﻟﻄﺮﻳﻘﺔ ﺍﻟﺘﺼﻤﻴﻢ ﺍﳌﺘﺒﻌﺔ ‪،‬ﻓﻬﻨﺎﻙ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻄﺮﻕ ﻟﺘﺼﻤﻴﻢ‬
‫ﺍﻻﻧﻮﻳﺔ ﺑﻌﻀﴼ ﻣﻨﻬﺎ ﳚﻌﻞ ﻣﺎ ﻫﻮ ﻣﺘﻌﺎﺭﻑ ﻋﻠﻴﻪ ﺑﺄﻧﻪ ﻳﺘﺒﻊ ﻟﻨﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﺑﱪﻧﺎﻣﺞ ﻟﻠﻤﺴﺘﺨﺪﻡ )‪١ (User Program‬‬
‫ﻭﺍﻟﺒﻌﺾ ﺍﻻﺧﺮ ﻋﻜﺲ ﺫﻟﻚ ‪ .‬ﻟﺬﻟﻚ ﺳﻨﺬﻛﺮ ﺣﺎﻟﻴﴼ ﺍﳌﻜﻮﻧﺎﺕ ﺍﻟﺸﺎﺋﻌﺔ ﰲ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻭﰲ ﺍﻟﻘﺴﻢ ﺍﻟﺘﺎﱄ ﻋﻨﺪ‬
‫ﺍﳊﺪﻳﺚ ﻋﻦ ﻫﻴﻜﻠﺔ ﻭﻃﺮﻕ ﺗﺼﻤﻴﻢ ﺍﻷﻧﻮﺑﺔ ﺳﻨﻔﺼﻞ ﺃﻛﺜﺮ ﰲ ﻫﺬﻩ ﺍﳌﻜﻮﻧﺎﺕ ﻭﻧﻘﺴﻤﻬﺎ ﲝﺴﺐ ﻃﺮﻳﻘﺔ ﺍﻟﺘﺼﻤﻴﻢ‪.‬‬

‫‪ .١.٢.٥‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺃﻫﻢ ﻭﻇﻴﻔﺔ ﻟﻨﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻫﻲ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺣﻴﺚ ﺃﻥ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﳚﺐ ﺍﻥ ﻳﺘﻢ ﲢﻤﻠﻴﻪ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻗﺒﻞ‬
‫ﺃﻥ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻩ ‪ ،‬ﻟﺬﻟﻚ ﻣﻦ ﻣﻬﺎﻡ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﻫﻲ ﻣﻌﺮﻓﺔ ﺍﻷﻣﺎﻛﻦ ﺍﻟﺸﺎﻏﺮﺓ ‪ ،‬ﻭﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺸﺎﻛﻞ ﺍﻟﺘﺠﺰﺋﺔ‬
‫)‪ (Fragmenta on‬ﺣﻴﺚ ﻣﻦ ﺍﳌﻤﻜﻦ ﺃﻥ ﲢﻮﻱ ﺍﻟﺬﺍﻛﺮﺓ ﻋﻠﻰ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﳌﺴﺎﺣﺎﺕ ﺍﻟﺼﻐﲑﺓ ﻭﺍﻟﱵ ﻻ ﺗﻜﻔﻲ‬
‫ﻟﺘﺤﻤﻴﻞ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﺃﻭ ﺣﱴ ﺣﺠﺰ ﻣﺴﺎﺣﺔ ﻟﱪﻧﺎﻣﺞ ﻣﺎ‪ .‬ﺃﺣﺪ ﺍﳌﺸﺎﻛﻞ ﺍﻟﱵ ﻋﻠﻰ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻫﻲ‬
‫ﻣﻌﺮﻓﺔ ﻣﻜﺎﻥ ﲢﻤﻴﻞ ﺍﻟﱪﻧﺎﻣﺞ ‪ ،‬ﺣﻴﺚ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﺍﻟﱪﻧﺎﻣﺞ ﻣﺴﺘﻘﻼ ﻋﻦ ﺍﻟﻌﻨﻮﺍﻳﻦ )‪(Posi on Independent‬‬
‫ﻟﻜﻲ ﻳﺘﻢ ﲢﻤﻠﻴﻪ ﻭﺇﻻ ﻓﻠﻦ ﻧﻌﺮﻑ ﻣﺎ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﻟﺒﺪﺍﻳﺔ )‪ (Base Address‬ﳍﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ‪ .‬ﻓﻠﻮ ﻓﺮﺿﻨﺎ ﺍﻥ ﻟﺪﻳﻨﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪ binary‬ﻭﻧﺮﻳﺪ ﲢﻤﻴﻠﻪ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻓﻬﻨﺎ ﻟﻦ ﻧﺘﻤﻜﻦ ﻣﻦ ﻣﻌﺮﻓﺔ ﻣﺎ ﻫﻮ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﺬﻱ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﻋﻠﻴﻪ‬
‫ﺍﻟﱪﻧﺎﻣﺞ ‪ ،‬ﻟﺬﻟﻚ ﻋﺎﺩﺓ ﻓﺎﻥ ﺍﻟﻨﺎﺗﺞ ﻣﻦ ﻋﻤﻠﻴﺔ ﺗﺮﲨﺔ ﻭﺭﺑﻂ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﻫﻮ ﺍ‪‬ﺎ ﺗﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ ،0x0‬ﻭﻫﻜﺬﺍ‬
‫ﺳﻨﺘﻤﻜﻦ ﺩﻭﻣﺎ ﻣﻦ ﲢﻤﻴﻞ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﰲ ﺑﺪﺍﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ‪ .‬ﺬﺍ ﺍﻟﺸﻜﻞ ﻟﻦ ﻧﺘﻤﻜﻦ ﻣﻦ ﺗﻨﻔﻴﺬ ﺃﻛﺜﺮ ﻣﻦ ﺑﺮﻧﺎﻣﺞ‬
‫ﻭﺍﺣﺪ ‪ ،‬ﺣﻴﺚ ﺳﻴﻜﻮﻥ ﻫﻨﺎﻙ ﺑﺮﻧﺎﳎﺎ ﻭﺍﺣﺪﺍ ﻓﻘﻂ ﻳﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ ، 0x0‬ﻭﺍﳊﻞ ﳍﺬﻩ ﺍﳌﺸﺎﻛﻞ ﻫﻮ ﺑﺎﺳﺘﺨﺪﺍﻡ‬
‫ﻣﺴﺎﺣﺔ ﺍﻟﻌﻨﻮﻧﺔ ﺍﻟﺘﺨﻴﻠﻴﺔ )‪ (Virtual Address Space‬ﺣﻴﺚ ﻳﺘﻢ ﲣﺼﻴﺺ ﻣﺴﺎﺣﺔ ﲣﻴﻠﻴﺔ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻞ ﺑﺮﻧﺎﻣﺞ‬
‫ﲝﻴﺚ ﺗﺒﺪﺃ ﺍﻟﻌﻨﻮﻧﺔ ﲣﻴﻠﻴﺎ ﻣﻦ ‪ 0x0‬ﻭ‪‬ﺬﺍ ﰎ ﺣﻞ ﻣﺸﻜﻠﺔ ﲢﻤﻴﻞ ﺃﻛﺜﺮ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﻭﺣﻞ ﻣﺸﻜﻠﺔ ‪.reloca on‬‬
‫ﻭﻣﺴﺎﺣﺔ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﺘﺨﻴﻠﻴﺔ )‪ (VAS‬ﻫﻲ ﻣﺴﺎﺣﺔ ﻣﻦ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻟﻜﻞ ﺑﺮﻧﺎﻣﺞ ﲝﻴﺚ ﺗﻴﺪﺃ ﻣﻦ ﺍﻝ ‪ 0x0‬ﻭﻣﻔﻬﻮﻡ ﻫﺬﻩ‬
‫ﺍﳌﺴﺎﺣﺔ ﻫﻮ ﺃﻥ ﻛﻞ ﺑﺮﻧﺎﻣﺞ ﺳﻴﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺴﺎﺣﺔ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﳋﺎﺻﺔ ﺑﻪ ﻭﻫﺬﺍ ﻣﺎ ﻳﺆﺩﻱ ﺍﱃ ﲪﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﺣﻴﺚ‬
‫ﻟﻦ ﻳﺴﺘﻄﻴﻊ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﺍﻟﻮﺻﻮﻝ ﺍﱃ ﺃﻱ ﻋﻨﻮﺍﻥ ﺁﺧﺮ ﲞﻼﻑ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ‪ .VAS‬ﻭﻧﻈﺮﴽ ﻟﻌﺪﻡ ﺍﺭﺗﺒﺎﻁ‬
‫ﺍﻝ ‪ VAS‬ﻣﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻓﺎﻧﻪ ﳝﻜﻦ ﺍﻥ ﻳﺸﲑ ﻋﻨﻮﺍﻥ ﲣﻴﻠﻲ ﺍﱃ ﺫﺍﻛﺮﺓ ﺍﺧﺮﻯ ﲞﻼﻑ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ )ﻣﺜﻼ‬
‫ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ(‪ .‬ﻭﻫﺬﺍ ﳛﻞ ﻣﺸﻜﻠﺔ ﺍﻧﺘﻬﺎء ﺍﳌﺴﺎﺣﺎﺕ ﺍﳋﺎﻟﻴﺔ ﰲ ﺍﻟﺬﺍﻛﺮﺓ‪ .‬ﻭﳚﺪﺭ ﺑﻨﺎ ﺫﻛﺮ ﺃﻥ ﺍﻟﺘﺤﻮﻳﻞ ﺑﲔ‬
‫ﺍﻟﻌﻨﺎﻭﻳﻦ ﺍﻟﺘﺨﻴﻠﻴﻪ ﺍﱃ ﺍﳊﻘﻴﻘﻴﺔ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺍﻟﻌﺘﺎﺩ ﺑﻮﺍﺳﻄﺔ ﻭﺣﺪﺓ ﺍﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺑﺪﺍﺧﻞ ﺍﳌﻌﺎﰿ )‪Memory‬‬

‫‪١‬ﺍﳌﻘﺼﻮﺩ ﺃ‪‬ﺎ ﺑﺮﺍﻣﺞ ﺗﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ‪.٣‬‬

‫‪١٠٥‬‬
 ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪.(Management Unit‬ﻭﻛﺬﻟﻚ ﻣﻬﻤﺔ ﲪﺎﻳﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺍﻟﺘﺤﻜﻢ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ‪ Cache‬ﻭﻏﲑﻫﺎ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﻭﺍﻟﱵ‬
‫ﺳﻴﺘﻢ ﺍﻹﻃﻼﻉ ﻋﻠﻴﻬﺎ ﰲ ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺑﻊ ‪ -‬ﲟﺸﻴﺌﺔ ﺍﷲ‪.-‬‬

‫‪ .٣.٥‬ﻫﻴﻜﻠﺔ ﻭﺗﺼﻤﻴﻢ ﺍﻟﻨﻮﺍﺓ‬

‫ﺗﻮﺟﺪ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻄﺮﻕ ﻟﺘﺼﻤﻴﻢ ﺍﻷﻧﻮﻳﺔ ﻭﺳﻨﺴﺘﻌﺮﺽ ﺑﻌﺾ ﻣﻨﻬﺎ ﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ‪ ،‬ﻟﻜﻦ ﻗﺒﻞ ﺫﻟﻚ ﳚﺐ ﺍﳊﺪﻳﺚ‬
‫ﻋﻦ ﻃﺮﻳﻘﺔ ﻣﻔﻴﺪﺓ ﰲ ﻫﻴﻜﻠﺔ ﻭﺗﺼﻤﻴﻢ ﺍﻷﻧﻮﻳﺔ ﺍﻻ ﻭﻫﻲ ﲡﺮﻳﺪ ﺍﻟﻌﺘﺎﺩ )‪ (Hardware Abstrac on‬ﺃﻱ ﲟﻌﲎ ﻓﺼﻞ‬
‫ﺍﻟﻨﻮﺍﺓ ﻣﻦ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻭﺍﻧﺸﺎء ﻃﺒﻘﺔ ﺑﺮﳎﻴﺔ )‪ (So ware Layer‬ﺗﺴﻤﻰ ﻃﺒﻘﺔ ‪) HAL‬ﺍﺧﺘﺼﺎﺭﺍ‬
‫ﻟﻜﻠﻤﺔ ‪ (Hardware Abstrac on Layer‬ﺑﲔ ﺍﻟﻨﻮﺍﺓ ﻭﺑﲔ ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻭﻇﻴﻔﺔ ﻃﺒﻘﺔ ‪ HAL‬ﻫﻲ ﺗﻮﻓﲑ ﻭﺍﺟﻬﺔ ﻟﻌﺘﺎﺩ‬
‫ﺍﳊﺎﺳﺐ ﲝﻴﺚ ﲤﻜﱢﻦ ﺍﻟﻨﻮﺍﺓ ﻣﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻌﺘﺎﺩ‪.‬‬
‫ﻓﺼﻞ ﺍﻟﻨﻮﺍﺓ ﻣﻦ ﺍﻟﻌﺘﺎﺩ ﺗ‪‬ﺘﻴﺢ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻔﻮﺍﺋﺪ ‪،‬ﺃﻭﻻﹰ ﺷﻔﺮﺓ ﺍﻟﻨﻮﺍﺓ ﺳﺘﻜﻮﻥ ﺃﻛﺜﺮ ﻣﻘﺮﻭﺋﻴﺔ ﻭﺃﺳﻬﻞ ﰲ ﺍﻟﺼﻴﺎﻧﺔ‬
‫ﻭﺍﻟﺘﻌﺪﻳﻞ ﻷﻥ ﺍﻟﻨﻮﺍﺓ ﺳﺘﺘﻌﺎﻣﻞ ﻣﻊ ﻭﺍﺟﻬﺔ ﺃﺧﺮﻯ ﺃﻛﺜﺮ ﺳﻬﻮﻟﺔ ﻣﻦ ﺗﻌﻘﻴﺪﺍﺕ ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﺍﳌﻴﺰﺓ ﺍﻟﺜﺎﻧﻴﺔ ﻭﺍﻷﻛﺜﺮ ﺃﳘﻴﺔ‬
‫ﻫﻲ ﺍﻣﻜﺎﻧﻴﺔ ﻧﻘﻞ ﺍﻟﻨﻮﺍﺓ )‪ (Por ng‬ﻷﺟﻬﺰﺓ ﺫﺍﺕ ﻋﺘﺎﺩ ﳐﺘﻠﻒ )ﻣﺜﻞ ‪ (SPARC,MIPS,...etc‬ﺑﺪﻭﻥ ﺍﻟﺘﻐﻴﲑ ﰲ‬
‫ﺷﻔﺮﺓ ﺍﻟﻨﻮﺍﺓ ‪ ،‬ﻓﻘﻂ ﺳﻴﺘﻢ ﺗﻌﺪﻳﻞ ﻃﺒﻘﺔ ‪ HAL‬ﻣﻦ ﻧﺎﺣﻴﺔ ﺍﻟﺘﻄﺒﻴﻖ )‪ (Implementa on‬ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﺇﻋﺎﺩﺓ ﻛﺘﺎﺑﺔ‬
‫ﻣﺸﻐﻼﺕ ﺍﻷﺟﻬﺰﺓ )‪ (Devcie Drivers‬ﳎﺪﺩﴽ ‪.٢‬‬

‫‪Monolithic Kernel‬‬ ‫‪ .١.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﻟﻀﺨﻤﺔ‬

‫ﺗﻌﺘﱪ ﺍﻷﻧﻮﻳﺔ ﺍﳌﺼﻤﻤﺔ ﺑﻄﺮﻳﻘﺔ ‪ ٣ Monoli c‬ﺃﺳﺮﻉ ﻭﺃﻛﻔﺄ ﺃﻧﻮﻳﺔ ﰲ ﺍﻟﻌﻤﻞ ﻭﺫﻟﻚ ﻧﻈﺮﺍ ﻻﻥ ﻛﻞ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ‬
‫)‪ (System Process‬ﺗﻜﻮﻥ ﺿﻤﻦ ﺍﻟﻨﻮﺍﺓ ﻭﺗﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ‪.‬‬
‫ﺍﳌﺸﻜﻠﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﳍﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻫﻮ ﺍﻧﻪ ﻋﻨﺪ ﺣﺪﻭﺙ ﺃﻱ ﻣﺸﻜﻠﺔ ﰲ ﺃﻱ ﻣﻦ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﻓﺎﻥ ﺍﻟﻨﻈﺎﻡ ﺳﻮﻑ‬
‫ﻳﺘﻮﻗﻒ ﻋﻦ ﺍﻟﻌﻤﻞ ﻭﺫﻟﻚ ﻧﻈﺮﺍ ﻻ‪‬ﺎ ﺗﻌﻤﻞ ﰲ ﺍﳊﻠﻘﺔ ﺻﻔﺮ ﻭﻛﻤﺎ ﺫﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ ﺃﻥ ﺃﻱ ﺧﻠﻞ ﰲ ﻫﺬﺍ ﺍﳌﺴﺘﻮﻯ‬
‫ﻳﺆﺩﻱ ﺍﱃ ﺗﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ‪ .‬ﻣﺸﻜﻠﺔ ﺍﺧﺮﻯ ﳝﻜﻦ ﺫﻛﺮﻫﺎ ﻭﻫﻲ ﺍﻥ ﺍﻟﻨﻮﺍﺓ ﻏﲑ ﻣﺮﻧﺔ ﲟﻌﲎ ﺃﻧﻪ ﻟﺘﻐﻴﲑ ﻧﻈﺎﻡ‬
‫ﺍﳌﻠﻔﺎﺕ ﻣﺜﻼ ﳚﺐ ﺍﻋﺎﺩﺓ ﺗﺸﻐﻴﻞ ﺍﻟﻨﻈﺎﻡ ﳎﺪﺩﺍ‪.‬‬
‫ﻭﻛﺄﻣﺜﻠﺔ ﻋﻠﻰ ﺃﻧﻈﻤﺔ ﺗﺸﻐﻴﻞ ﺗﻌﻤﻞ ‪‬ﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻫﻲ ﺃﻧﻈﻤﺔ ﻳﻮﻧﻜﺲ ﻭﻟﻴﻨﻮﻛﺲ ‪ ،‬ﻭﺃﻧﻈﻤﺔ ﺍﻝ ‪ DOS‬ﺍﻟﻘﺪﳝﺔ‬
‫ﻭﻭﻳﻨﺪﻭﺯ ﻣﺎ ﻗﺒﻞ ‪.NT‬‬

‫‪٢‬ﺃﻏﻠﺐ ﺃﻧﻮﻳﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺍﳊﺎﻟﻴﺔ ﺗﺴﺘﺨﺪﻡ ﻃﺒﻘﺔ ‪ ،HAL‬ﻫﻞ ﺗﺴﺎﺋﻠﺖ ﻳﻮﻣﺎ ﻛﻴﻒ ﻳﻌﻤﻞ ﻧﻈﺎﻡ ﺟﻨﻮ‪/‬ﻟﻴﻨﻮﻛﺲ ﻋﻠﻰ ﺃﺟﻬﺰﺓ ﺳﻄﺢ‬
‫ﺍﳌﻜﺘﺐ ﻭﺍﻷﺟﻬﺰﺓ ﺍﳌﻀﻤﻨﺔ!‬
‫‪٣‬ﻛﻠﻤﺔ ‪ Mono‬ﺗﻌﲏ ﻭﺍﺣﺪ ‪ ،‬ﺃﻣﺎ ﻛﻠﻤﺔ ‪ Lithic‬ﻓﺘﻌﲏ ﺣﺠﺮﻱ ‪ ،‬ﻭﺍﳌﻘﺼﻮﺩ ﺑﺄﻥ ﺍﻟﻨﻮﺍﺓ ﺗﻜﻮﻥ ﻋﻠﻰ ﺷﻜﻞ ﻛﺘﻠﺔ ﺣﺠﺮﻳﺔ ﻟﻴﺴﺖ ﻣﺮﻧﺔ‬
‫ﻭﺗﻄﻮﻳﺮﻫﺎ ﻭﺻﻴﺎﻧﺘﻬﺎ ﻣﻌﻘﺪ‪.‬‬

‫‪١٠٦‬‬
‫‪ .٤.٥‬ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫‪MicroKernel‬‬ ‫‪ .٢.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﳌﺼﻐﺮﺓ‬

‫ﺍﻷﻧﻮﻳﺔ ‪ MicroKernel‬ﻫﻲ ﺍﻷﻛﺜﺮ ﺛﺒﺎﺗﺎ ﻭﺍﺳﺘﻘﺮﺍﺭ ﻭﻣﺮﻭﻧﺔ ﻭﺍﻷﺳﻬﻞ ﰲ ﺍﻟﺼﻴﺎﻧﺔ ﻭﺍﻟﺘﻌﺪﻳﻞ ﻭﺍﻟﺘﻄﻮﻳﺮ ﻭﺫﻟﻚ ﻧﻈﺮﺍ‬
‫ﻻﻥ ﺍﻟﻨﻮﺍﺓ ﺗﻜﻮﻥ ﺃﺻﻐﺮ ﻣﺎ ﳝﻜﻦ ‪ ،‬ﺣﻴﺚ ﺃﻥ ﺍﻟﻮﻇﺎﺋﻒ ﺍﻷﺳﺎﺳﻴﺔ ﻓﻘﻂ ﺗﻜﻮﻥ ﺿﻤﻦ ﺍﻟﻨﻮﺍﺓ ﻭﻫﻲ ﺍﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﻭﺍﺩﺍﺭﺓ ﺍﻟﻌﻤﻠﻴﺎﺕ )ﳎﺪﻭﻝ ﺍﻟﻌﻤﻠﻴﺎﺕ‪،‬ﺃﺳﺎﺳﻴﺎﺕ ‪ ،(IPC‬ﺃﻣﺎ ﺑﻘﻴﺔ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﻣﺜﻞ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ ﻭﻣﺸﻐﻼﺕ‬
‫ﺍﻷﺟﻬﺰﺓ ﻭﻏﲑﻫﺎ ﺗﺘﺒﻊ ﻟﱪﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ﻭﺗﻌﻤﻞ ﰲ ﳕﻂ ﺍﳌﺴﺘﺨﺪﻡ )ﺍﳊﻠﻘﺔ ‪ ، (٣‬ﻭﻫﺬﺍ ﻳﻌﲏ ﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ‬
‫ﺧﻄﺄ ﰲ ﻫﺬﻩ ﺍﻟﱪﺍﻣﺞ ﻓﺎﻥ ﺍﻟﻨﻈﺎﻡ ﻟﻦ ﻳﺘﺄﺛﺮ ﻛﺬﻟﻚ ﳝﻜﻦ ﺗﻐﻴﲑ ﻫﺬﻩ ﺍﻟﱪﺍﻣﺞ )ﻣﺜﻼ ﺗﻐﻴﲑ ﻧﻈﺎﻡ ﺍﳌﻠﻔﺎﺕ( ﺩﻭﻥ ﺍﳊﺎﺟﺔ‬
‫ﺍﱃ ﺍﻋﺎﺩﺓ ﺗﺸﻐﻴﻞ ﺍﳉﻬﺎﺯ ﺣﻴﺚ ﺃﻥ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﺗﻌﻤﻞ ﻛﱪﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ ‪ .‬ﺍﳌﺸﻜﻠﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﳍﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻫﻮ‬
‫ﺑﻄﺊ ﻋﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃﻥ ﺑﺮﺍﻣﺞ ﺍﻟﻨﻈﺎﻡ ﻋﻠﻴﻬﺎ ﺃﻥ ﺗﺘﺨﺎﻃﺐ ﻣﻊ ﺑﻌﻀﻬﺎ ﺍﻟﺒﻌﺾ ﻋﻦ ﻃﺮﻳﻖ ﲤﺮﻳﺮ ﺍﻟﺮﺳﺎﺋﻞ‬
‫)‪ (Message Passing‬ﺃﻭ ﻣﺸﺎﺭﻛﺔ ﺟﺰء ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ )‪ (Shared Memory‬ﻭﻫﺬﺍ ﻣﺎ ﻳﻌﺮﻑ ﺏ ‪Interprocess‬‬
‫‪ .Communica on‬ﻭﺃﺷﻬﺮ ﻣﺜﺎﻝ ﻟﻨﻈﺎﻡ ﺗﺸﻐﻴﻞ ﻳﺘﺒﻊ ﻫﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻫﻮ ﻧﻈﺎﻡ ﻣﻴﻨﻜﺲ ﺍﻻﺻﺪﺍﺭ ﺍﻟﺜﺎﻟﺚ‪.‬‬

‫‪Hybrid Kernel‬‬ ‫‪ .٣.٣.٥‬ﺍﻟﻨﻮﺍﺓ ﺍﳍﺠﻴﻨﺔ‬

‫ﻫﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻟﻠﻨﻮﺍﺓ ﻣﺎ ﻫﻮ ﺇﻻ ﻣﺰﻳﺞ ﻣﻦ ﺍﻟﺘﺼﻤﻴﻤﲔ ﺍﻟﺴﺎﺑﻘﲔ ‪ ،‬ﺣﻴﺚ ﺗﻜﻮﻥ ﺍﻟﻨﻮﺍﺓ ‪ MicroKernel‬ﻟﻜﻨﻬﺎ ﺗﻄﺒﻖ‬
‫ﻙ ‪ ، Monolithic Kernel‬ﻭﻳﺴﻤﻰ ﻫﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ‪ Hybrid Kernel‬ﺃﻭ ‪ .Modified MicroKernel‬ﻭﻛﺄﻣﺜﻠﺔ ﻋﻠﻰ‬
‫ﺃﻧﻈﻤﺔ ﺗﻌﻤﻞ ‪‬ﺬﺍ ﺍﻟﺘﺼﻤﻴﻢ ﻫﻮ ﺃﻧﻈﻤﺔ ﻭﻳﻨﺪﻭﺯ ﺍﻟﱵ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻣﻌﻤﺎﺭﻳﺔ ‪ ، NT‬ﻭﻧﻈﺎﻡ ‪ BeOS‬ﻭ ‪.Plane 9‬‬

‫‪ .٤.٥‬ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫ﳝﻜﻦ ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺑﺄﻱ ﻟﻐﺔ ﺑﺮﳎﺔ ‪ ،‬ﻟﻜﻦ ﳚﺐ ﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃﻥ ﺍﻟﻠﻐﺔ ﺗﺪﻋﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ‬
‫)‪ (Inline Assemlby‬ﺣﻴﺚ ﺃﻥ ﺍﻟﻨﻮﺍﺓ ﻛﺜﲑﺍ ﻣﺎ ﳚﺐ ﻋﻠﻴﻬﺎ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﺃﻭﺍﻣﺮ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ )ﻣﺜﻼ ﻋﻨﺪ‬
‫ﲢﻤﻴﻞ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ﻭﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻭﻛﺬﻟﻚ ﻋﻨﺪ ﻏﻠﻖ ﺍﳌﻘﻄﺎﻋﺎﺕ ﻭﺗﻔﻌﻴﻠﻬﺎ ﻭﻏﲑﻫﺎ(‪.‬‬
‫ﺍﻟﺸﻲء ﺍﻻﺧﺮ ﺍﻟﺬﻱ ﳚﺐ ﻭﺿﻌﻪ ﰲ ﺍﳊﺴﺒﺎﻥ ﻫﻮ ﺃﻧﻪ ﻻ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺑﺮﳎﺔ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻣﻜﺘﺒﺎﺕ ﰲ ﻭﻗﺖ‬
‫ﺍﻟﺘﺸﻐﻴﻞ )ﻣﻠﻔﺎﺕ ‪ dll‬ﻣﺜﻼ( ﺩﻭﻥ ﺇﻋﺎﺩﺓ ﺑﺮﳎﺔ ﻫﺬﻩ ﺍﳌﻜﺘﺒﺎﺕ)ﻣﺜﺎﻝ ﺫﻟﻚ ﻻ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺎﺕ ﺩﻭﺕ ﻧﺖ ﺩﻭﻥ‬
‫ﺇﻋﺎﺩﺓ ﺑﺮﳎﺔ ﺇﻃﺎﺭ ﺍﻟﻌﻤﻞ(‪ .‬ﻭﻛﺬﻟﻚ ﻻ ﳝﻜﻦ ﺍﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺩﻭﺍﻝ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺬﻱ ﺗﻘﻮﻡ ﺑﺘﻄﻮﻳﺮ ﻧﻈﺎﻣﻚ ﺍﳋﺎﺹ ﻓﻴﻪ‬
‫)ﻣﺜﻼ ﻟﻦ ﺗﺘﻤﻜﻦ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ‪ new‬ﳊﺠﺰ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺫﻟﻚ ﻻ‪‬ﺎ ﺗﻌﺘﻤﺪ ﻛﻠﻴﺎ ﻋﻠﻰ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‪ ،‬ﺃﻳﻀﺎ ﺩﻭﺍﻝ‬
‫ﺍﻻﺩﺧﺎﻝ ﻭﺍﻻﺧﺮﺍﺝ ﺗﻌﺘﻤﺪ ﻛﻠﻴﺎ ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ(‪.‬‬
‫ﻟﺬﻟﻚ ﻏﺎﻟﺒﺎ ﺗﺴﺘﺨﺪﻡ ﻟﻐﺔ ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‪ ++‬ﻟﱪﳎﺔ ﺃﻧﻮﻳﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻧﻈﺮﺍ ﳌﺎ ﺗﺘﻤﺘﻊ ﺑﻪ ﺍﻟﻠﻐﺘﲔ ﻣﻦ ﻣﻴﺰﺍﺕ‬
‫ﻓﺮﻳﺪﺓ ﲤﻴﺰﻫﺎ ﻋﻦ ﺑﺎﻗﻲ ﺍﻟﻠﻐﺎﺕ ‪ ،‬ﻭﺗﻨﺘﺸﺮ ﻟﻐﺔ ﺍﻟﺴﻲ ﺑﺸﻜﻞ ﺃﻛﱪ ﻻﺳﺒﺎﺏ ﻛﺜﲑﺓ ﻣﻨﻬﺎ ﻫﻮ ﺃ‪‬ﺎ ﻻ ﲢﺘﺎﺝ ﺍﱃ ﻣﻜﺘﺒﺔ‬
‫ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ )‪ (RunTime Library‬ﺣﱴ ﺗﻌﻤﻞ ﺍﻟﱪﺍﻣﺞ ﺍﳌﻜﺘﻮﺑﺔ ‪‬ﺎ ﻋﻠﻰ ﻋﻜﺲ ﻟﻐﺔ ﺳﻲ‪ ++‬ﻭﺍﻟﱵ ﲢﺘﺎﺝ ﺍﱃ‬
‫)‪ (RunTime Library‬ﻟﺪﻋﻢ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﻣﺜﻞ ﺍﻻﺳﺘﺜﻨﺎﺋﺎﺕ ﻭ ﺩﻭﺍﻝ ﺍﻟﺒﻨﺎء ﻭﺍﳍﺪﻡ‪.‬‬
‫ﻭﰲ ﺣﺎﻟﺔ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺳﻲ ﺃﻭ ﺳﻲ‪ ++‬ﻓﺎﻧﻪ ﳚﺐ ﺇﻋﺎﺩﺓ ﺗﻄﻮﻳﺮ ﺍﺟﺰﺍء ﻣﻦ ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‪ ++‬ﺍﻟﻘﻴﺎﺳﻴﺔ‬
‫)‪ (Standard C/C++ Library‬ﻭﻫﻲ ﺍﻷﺟﺰﺍء ﺍﻟﱵ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻣﺜﻞ ﺩﻭﺍﻝ ‪ printf‬ﻭ ‪ scanf‬ﻭ‬

‫‪١٠٧‬‬
 ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫ﺩﻭﺍﻝ ﺣﺠﺰ ﺍﻟﺬﻭﺍﻛﺮ ‪ malloc/new‬ﻭﲢﺮﻳﺮﻫﺎ ‪.free/delete‬‬

‫ﻭﻧﻈﺮﺍ ﻻﻧﻨﺎ ﺑﺼﺪﺩ ﺑﺮﳎﺔ ﻧﻈﺎﻡ ‪ 32‬ﺑﺖ ‪ ،‬ﻓﺎﻥ ﺍﻟﻨﻮﺍﺓ ﺃﻳﻀﺎ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ‪ 32‬ﺑﺖ ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻧﻪ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ‬
‫ﻣﺘﺮﺟﻢ ﺳﻲ ﺃﻭ ﺳﻲ‪ 32 ++‬ﺑﺖ ‪ .‬ﻣﺸﻜﻠﺔ ﻫﺬﻩ ﺍﳌﺘﺮﲨﺎﺕ ﺃﻥ ﺍﳌﺨﺮﺝ ﻣﻨﻬﺎ )ﺍﻟﱪﻧﺎﻣﺞ( ﻻ ﻳﺄﰐ ﺑﺎﻟﺸﻜﻞ ﺍﻟﺜﻨﺎﺋﻲ‬
‫ﻓﻘﻂ )‪ ،٤ (Flat Binary‬ﻭﺍﳕﺎ ﻳﻀﺎﻑ ﻋﻠﻰ ﺍﻟﺸﻔﺮﺓ ﺍﻟﺜﻨﺎﺋﻴﺔ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﺷﻴﺎء ‪ .Headers,...etc‬ﻭﻟﺘﺤﻤﻴﻞ ﻣﺜﻞ‬
‫ﻫﺬﻩ ﺍﻟﱪﺍﻣﺞ ﻓﺎﻧﻪ ﳚﺐ ﺍﻟﺒﺤﺚ ﻋﻦ ﻧﻘﻄﺔ ﺍﻹﻧﻄﻼﻕ ﻟﻠﱪﻧﺎﻣﺞ )‪ (main rou ne‬ﻭﻣﻦ ﰒ ﺍﻟﺒﺪء ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﻣﻨﻬﺎ‪.‬‬
‫ﻭﺳﻴﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺘﺮﺟﻢ ﻓﻴﺠﻮﺍﻝ ﺳﻲ‪ ++‬ﻟﺘﺮﲨﺔ ﺍﻟﻨﻮﺍﺓ ‪ ،‬ﻭﰲ ﺍﳌﻠﺤﻖ ﺳﻴﺘﻢ ﺗﻮﺿﻴﺢ ﺧﻄﻮﺍﺕ ‪‬ﻴﺌﺔ ﺍﳌﺸﺮﻭﻉ‬
‫ﻭﺍﺯﺍﻟﺔ ﺃﻱ ﺍﻋﺘﻤﺎﺩﻳﺔ ﻋﻠﻰ ﻣﻜﺘﺒﺎﺕ ﺃﻭ ﻣﻠﻔﺎﺕ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ‪.‬‬
‫ﻭﺳﻨﻌﻴﺪ ﻛﺘﺎﺑﺔ ﺍﻟﻨﻮﺍﺓ ﺍﻟﱵ ﻗﻤﻨﺎ ﺑﱪﳎﺘﻬﺎ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﰲ ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺑﻖ ﻭﻟﻜﻦ ﺑﻠﻐﺔ ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‪ ، ++‬ﻭﺳﻨﻨﺎﻗﺶ‬
‫ﻛﻴﻔﻴﺔ ﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﻫﺬﻩ ﺍﻟﻨﻮﺍﺓ ﺣﻴﺚ ﺃﻥ ﺍﳌﺨﺮﺝ ﻣﻦ ﻣﺘﺮﺟﻢ ﺍﻟﻔﻴﺠﻮﺍﻝ ﺳﻲ‪ ++‬ﻫﻮ ﻣﻠﻒ ﺗﻨﻔﻴﺬﻱ )‪Portable‬‬
‫‪ (Executable‬ﻭﻟﺪﻳﻪ ﺻﻴﻐﺔ ﳏﺪﺩﺓ ﳚﺐ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻟﻠﻨﻮﺍﺓ ))(‪(main‬‬
‫‪ ،‬ﻛﺬﻟﻚ ﺳﻨﺒﺪﺃ ﰲ ﺗﻄﻮﻳﺮ ﻣﻠﻔﺎﺕ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﻟﻠﻐﺔ ﺳﻲ‪ ++‬ﻭﺫﻟﻚ ﺣﱴ ﻳﺘﻢ ﺩﻋﻢ ﺑﻌﺾ ﺧﺼﺎﺋﺺ ﺍﻟﻠﻐﺔ ﻭﺍﻟﱵ‬
‫ﲢﺘﺎﺝ ﺍﱃ ﺩﻋﻢ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﻣﺜﻞ ﺩﻭﺍﻝ ﺍﻟﺒﻨﺎء ﻭﺍﳍﺪﻡ ﻭﺍﻟﺪﻭﺍﻝ ﺍﻟﻈﺎﻫﺮﻳﺔ )‪ ، (Pure Virtual Func on‬ﻭﰲ‬
‫ﺍﻟﻮﻗﺖ ﺍﳊﺎﱄ ﻻ ﻳﻮﺟﺪ ﺩﻋﻢ ﻟﻺﺳﺘﺜﻨﺎﺋﺎﺕ )‪ (Excep ons‬ﰲ ﻟﻐﺔ ﺍﻟﺴﻲ‪. ++‬‬

‫‪PE‬‬ ‫‪ .١.٤.٥‬ﲢﻤﻴﻞ ﻭﺗﻨﻔﻴﺬ ﻧﻮﺍﺓ‬

‫ﲟﺎ ﺃﻧﻨﺎ ﺳﻨﺴﺘﺨﺪﻡ ﻣﺘﺮﺟﻢ ﻓﻴﺠﻮﺍﻝ ﺳﻲ‪ ++‬ﻭﺍﻟﺬﻱ ﳜﺮﺝ ﻟﻨﺎ ﻣﻠﻒ ﺗﻨﻔﻴﺬﻱ )‪ (Portable Executable‬ﻓﺎﻧﻪ ﳚﺐ‬
‫ﺃﻥ ﻧﻌﺮﻑ ﻣﺎ ﻫﻲ ﺷﻜﻞ ﻫﺬﻩ ﺍﻟﺼﻴﻐﺔ ﺣﱴ ﻧﺘﻤﻜﻦ ﻋﻨﺪ ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﺃﻥ ﻧﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﻟﻴﺴﺖ‬
‫ﺍﱃ ﺃﻣﺎﻛﻦ ﺃﺧﺮﻯ‪.‬ﻭﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺘﺮﲨﺎﺕ ﺳﻲ‪ ++‬ﺃﺧﺮﻯ )ﻣﺜﻞ ﻣﺘﺮﺟﻢ ‪ (g++‬ﻟﻜﻦ ﳚﺐ ﻣﻼﺣﻈﺔ ﺃﻥ ﻫﺬﺍ‬
‫ﺍﳌﺘﺮﺟﻢ ﳜﺮﺝ ﻟﻨﺎ ﻣﻠﻒ ﺑﺼﻴﻐﺔ ‪ ELF‬ﻭﻫﻲ ﺻﻴﻐﺔ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺘﻨﻔﻴﺬﻳﺔ ﻋﻠﻰ ﻧﻈﺎﻡ ﺟﻨﻮ‪/‬ﻟﻴﻨﻮﻛﺲ‪ .‬ﻭﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﱄ‬
‫ﻳﻮﺿﺢ ﺻﻴﻐﺔ ﻣﻠﻒ ‪ PE‬ﺍﻟﺬﻱ ﳓﻦ ﺑﺼﺪﺩ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‪.‬‬
‫ﻳﻮﺟﺪ ﺃﺭﺑﻊ ﺍﺿﺎﻓﺎﺕ)‪ (headers‬ﻟﺼﻴﻐﺔ ‪ PE‬ﺳﻨﻄﻠﻊ ﻋﻠﻴﻬﺎ ﺑﺸﻜﻞ ﺳﺮﻳﻊ ﻭﰲ ﺣﺎﻟﺔ ﻗﻤﻨﺎ ﺑﺘﻄﻮﻳﺮ ﳏﻤﻞ ﺧﺎﺹ ﳍﺬﻩ‬
‫ﺍﻟﺼﻴﻐﺔ ﻓﺴﻴﺘﻢ ﺩﺭﺍﺳﺘﻬﺎ ﺑﺎﻟﺘﻔﺼﻴﻞ‪ .‬ﻭ ﳝﻜﻦ ﺃﻥ ﻧﺼﻒ ﻫﺬﻩ ﺍﻻﺿﺎﻓﺎﺕ ﺑﻠﻐﺔ ﺍﻟﺴﻲ‪ ++‬ﻛﺎﻟﺘﺎﱄ‪.‬‬
‫‪Example‬‬ ‫‪٥.١: Portable Executable Header‬‬
‫‪١‬‬
‫‪٢ // header information format for PE files‬‬
‫‪٣‬‬
‫‪٤ typedef struct‬‬ ‫‪IMAGE DOS HEADER { // DOS .EXE header‬‬
‫‪٥‬‬ ‫‪unsigned‬‬ ‫‪short e magic; // Magic number (Should be MZ‬‬
‫‪٦‬‬ ‫‪unsigned‬‬ ‫;‪short e cblp‬‬ ‫‪// Bytes on last page of file‬‬
‫‪٧‬‬ ‫‪unsigned‬‬ ‫;‪short e cp‬‬ ‫‪// Pages in file‬‬
‫‪٨‬‬ ‫‪unsigned‬‬ ‫;‪short e crlc‬‬ ‫‪// Relocations‬‬
‫‪٩‬‬ ‫‪unsigned‬‬ ‫‪short e cparhdr; // Size of header in paragraphs‬‬
‫‪١٠‬‬ ‫‪unsigned‬‬ ‫;‪short e minalloc‬‬ ‫‪// Minimum extra paragraphs needed‬‬

‫‪٤‬ﻛﱪﻧﺎﻣﺞ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺬﻱ ﻗﻤﻨﺎ ﺑﺘﻄﻮﻳﺮﻩ ﰲ ﺑﺪﺍﻳﺔ ﻫﺬﺍ ﺍﻟﺒﺤﺚ‪.‬‬

‫‪١٠٨‬‬
‫ ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬.٤.٥

١١ unsigned short e maxalloc; // Maximum extra paragraphs needed

١٢ unsigned short e ss; // Initial (relative) SS value
١٣ unsigned short e sp; // Initial SP value
١٤ unsigned short e csum; // Checksum
١٥ unsigned short e ip; // Initial IP value
١٦ unsigned short e cs; // Initial (relative) CS value
١٧ unsigned short e lfarlc; // File address of relocation table
١٨ unsigned short e ovno; // Overlay number
١٩ unsigned short e res[4]; // Reserved words
٢٠ unsigned short e oemid; // OEM identifier (for e oeminfo)
٢١ unsigned short e oeminfo; // OEM information; e oemid specific
٢٢ unsigned short e res2[10]; // Reserved words
٢٣ long e lfanew; // File address of new exe header
٢٤ } IMAGE DOS HEADER, ∗ PIMAGE DOS HEADER;
٢٥
٢٦
٢٧ // Real mode stub program
٢٨
٢٩ typedef struct IMAGE FILE HEADER {
٣٠ unsigned short Machine;
٣١ unsigned short NumberOfSections;
٣٢ unsigned long TimeDateStamp;
٣٣ unsigned long PointerToSymbolTable;
٣٤ unsigned long NumberOfSymbols;
٣٥ unsigned short SizeOfOptionalHeader;
٣٦ unsigned short Characteristics;
٣٧ } IMAGE FILE HEADER, ∗ PIMAGE FILE HEADER;
٣٨
٣٩ typedef struct IMAGE OPTIONAL HEADER {
٤٠ unsigned short Magic;
٤١ unsigned char MajorLinkerVersion;
٤٢ unsigned char MinorLinkerVersion;
٤٣ unsigned long SizeOfCode;
٤٤ unsigned long SizeOfInitializedData;
٤٥ unsigned long SizeOfUninitializedData;
٤٦ unsigned long AddressOfEntryPoint; // offset of kernel entry
٤٧ unsigned long BaseOfCode;
٤٨ unsigned long BaseOfData;
٤٩ unsigned long ImageBase; // Base address of kernel entry
٥٠ unsigned long SectionAlignment;
٥١ unsigned long FileAlignment;

١٠٩
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

٥٢ unsigned short MajorOperatingSystemVersion;

٥٣ unsigned short MinorOperatingSystemVersion;
٥٤ unsigned short MajorImageVersion;
٥٥ unsigned short MinorImageVersion;
٥٦ unsigned short MajorSubsystemVersion;
٥٧ unsigned short MinorSubsystemVersion;
٥٨ unsigned long Reserved1;
٥٩ unsigned long SizeOfImage;
٦٠ unsigned long SizeOfHeaders;
٦١ unsigned long CheckSum;
٦٢ unsigned short Subsystem;
٦٣ unsigned short DllCharacteristics;
٦٤ unsigned long SizeOfStackReserve;
٦٥ unsigned long SizeOfStackCommit;
٦٦ unsigned long SizeOfHeapReserve;
٦٧ unsigned long SizeOfHeapCommit;
٦٨ unsigned long LoaderFlags;
٦٩ unsigned long NumberOfRvaAndSizes;
٧٠ IMAGE DATA DIRECTORY DataDirectory[DIRECTORY ENTRIES];
٧١ } IMAGE OPTIONAL HEADER, ∗ PIMAGE OPTIONAL HEADER;

‫( ﻭﺍﻟﱵ ﺳﻴﺒﺪﺃ ﺗﻨﻔﻴﺬ ﺍﻟﻨﻮﺍﺓ ﻣﻨﻬﺎ‬kernel entry()) ‫ﻣﺎ ﻧﺮﻳﺪ ﺍﳊﺼﻮﻝ ﻋﻠﻴﻪ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻟﻠﻨﻮﺍﺓ‬
، IMAGE OPTIONAL HEADER ‫( ﻭﻫﻲ‬header) ‫ ﻫﺬﺍ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻮﺟﻮﺩ ﰲ ﺃﺣﺪ ﺍﳌﺘﻐﲑﺍﺕ ﰲ ﺁﺧﺮ ﺇﺿﺎﻓﺔ‬،
‫ﻭﺣﱴ ﳓﺼﻞ ﻋﻠﻰ ﻋﻨﻮﺍﻥ ﻫﺬﻩ ﺍﻷﺿﺎﻓﺔ ﳚﺐ ﺃﻥ ﻧﺒﺪﺃ ﻣﻦ ﺃﻭﻝ ﺇﺿﺎﻓﺔ ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃﻥ ﺍﻻﺿﺎﻓﺔ ﺍﻟﺜﺎﻧﻴﺔ ﺫﺍﺕ‬
.‫ﺣﺠﻢ ﻣﺘﻐﲑ ﻭﻟﻴﺴﺖ ﺛﺎﺑﺘﻪ ﻣﺜﻞ ﺑﻘﻴﺔ ﺍﻻﺿﺎﻓﺎﺕ‬
‫ ﺣﻴﺚ ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻹﺿﺎﻓﺔ‬e lfanew ‫ ﻭﺑﺎﻟﺘﺤﺪﻳﺪ ﺍﱃ ﺍﳌﺘﻐﲑ‬IMAGE DOS HEADER ‫ﻭﺑﺎﻟﻨﻈﺮ ﺍﱃ ﺃﻭﻝ ﺇﺿﺎﻓﺔ‬
‫ ﻭﻣﻨﻬﺎ ﻧﺼﻞ ﺍﱃ ﺁﺧﺮ ﺇﺿﺎﻓﺔ ﻭﻧﻘﺮﺃ ﺍﳌﺘﻐﲑ‬، ‫ ﻭﺍﻟﱵ ﻫﻲ ﺍﺿﺎﻓﺔ ﺛﺎﺑﺘﻪ ﺍﳊﺠﻢ‬IMAGE FILE HEADER ‫ﺍﻟﺜﺎﻟﺜﺔ‬
‫ ﻭﺍﻟﺬﻱ‬ImageBase ‫ ﻟﻠﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﻛﺬﻟﻚ ﻧﻘﺮﺃ ﺍﳌﺘﻐﲑ‬offset ‫ ﺍﻟﺬﻱ ﳛﻮﻱ ﻋﻨﻮﺍﻥ‬AddressOfEntryPoint
‫ ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺘﻢ ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﺪﺍﻟﺔ ﺑﻮﺍﺳﻄﺔ ﺍﻻﻣﺮ‬، offset ‫ﳛﻮﻱ ﻋﻨﻮﺍﻥ ﺍﻟﺒﺪﺍﻳﺔ ﻟﻠﺪﺍﻟﺔ ﻭﳚﺐ ﺍﺿﺎﻓﺘﻪ ﻟﻘﻴﻤﺔ ﺍﻝ‬
‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺫﻟﻚ )ﻭﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﰲ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪﻣﺎ‬.call
.(KERNEL PMODE BASE ‫ﻳﺘﻢ ﲢﻤﻴﻞ ﺍﻟﻨﻮﺍﺓ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﻋﻠﻰ ﺍﻟﻌﻨﻮﺍﻥ‬
Example ٥.٢: Ge ng Kernel entry
١
٢
٣ mov ebx,[KERNEL PMODE BASE+60]
٤ add ebx,KERNEL PMODE BASE ; ebx = IMAGE FILE HEADER
٥
٦ add ebx,24 ; ebx = IMAGE OPTIONAL HEADER

١١٠
‫‪ .٤.٥‬ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫‪٧‬‬
‫‪٨‬‬ ‫‪add ebx,16‬‬ ‫‪; ebx point to AddressOfEntryPoint‬‬
‫‪٩‬‬
‫‪١٠‬‬ ‫]‪mov ebp,dword[ebx‬‬ ‫‪; epb = AddressOfEntryPoint‬‬
‫‪١١‬‬
‫‪١٢‬‬ ‫‪add ebx,12‬‬ ‫‪; ebx point to ImageBase‬‬
‫‪١٣‬‬
‫‪١٤‬‬ ‫]‪add ebp,dword[ebx‬‬ ‫‪; epb = kernel entry‬‬
‫‪١٥‬‬
‫‪١٦‬‬ ‫‪cli‬‬
‫‪١٧‬‬
‫‪١٨‬‬ ‫‪call ebp‬‬

‫‪ .٢.٤.٥‬ﺗﻄﻮﻳﺮ ﺑﻴﺌﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻟﻠﻐﺔ ﺳﻲ‪++‬‬

‫ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﲨﻴﻊ ﺧﺼﺎﺋﺺ ﻟﻐﺔ ﺳﻲ‪ ++‬ﻓﺎﻧﻪ ﳚﺐ ﻛﺘﺎﺑﺔ ﺑﻌﺾ ﺍﻟﺸﻔﺮﺍﺕ ﺍﻟﺘﺸﻐﻴﻠﻴﺔ )‪(startup‬‬
‫ﻭﺍﻟﱵ ﲤﻬﺪ ﻭﺗﻌﺮﻑ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﰲ ﺍﻟﻠﻐﺔ ‪ ،‬ﻭﰲ ﻫﺬﺍ ﺍﳉﺰء ﺳﻴﺘﻢ ﺗﻄﻮﻳﺮ ﻣﻜﺘﺒﺔ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﻟﻠﻐﺔ‬
‫ﺳﻲ‪ (C++ Run me Library) ++‬ﻭﺫﻟﻚ ﻧﻈﺮﴽ ﻷﻧﻨﺎ ﻗﺪ ﺍﻟﻐﻴﻨﺎ ﺍﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﻣﻜﺘﺒﺔ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﺍﻟﱵ ﺗﺄﰐ ﻣﻊ‬
‫ﺍﳌﺘﺮﺟﻢ ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﺑﻨﺎء ﺍﻟﻨﻈﺎﻡ )ﺍﻟﻨﻈﺎﻡ ﺍﳋﺎﺹ ﺑﻨﺎ( ﺣﻴﺚ ﺃﻥ ﻫﺬﻩ ﺍﳌﻜﺘﺒﺔ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺍﳌﺴﺘﺨﺪﻡ‬
‫ﰲ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻄﻮﻳﺮ ﳑﺎ ﻳﺴﺒﺐ ﻣﺸﺎﻛﻞ ﺍﺳﺘﺪﻋﺎء ﺩﻭﺍﻝ ﻟﻴﺴﺖ ﻣﻮﺟﻮﺩﺓ‪.‬‬
‫ﻭﺑﺪﻭﻥ ﺗﻄﻮﻳﺮ ﻫﺬﻩ ﺍﳌﻜﺘﺒﺔ ﻓﻠﻦ ﳝﻜﻦ ‪‬ﻴﺌﺔ ﺍﻟﻜﺎﺋﻨﺎﺕ ﺍﻟﻌﺎﻣﺔ )‪ (Global Object‬ﻭ ﺣﺬﻑ ﺍﻟﻜﺎﺋﻨﺎﺕ ‪ ،‬ﻭﻛﺬﻟﻚ‬
‫ﻟﻦ ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻡ ﺑﻌﺾ ﺍﳌﻌﺎﻣﻼﺕ )‪ (new,delete‬ﻭ ‪ RTTI‬ﻭﺍﻻﺳﺘﺜﻨﺎﺋﺎﺕ )‪.(Excep ons‬‬

‫‪Global Operator‬‬ ‫ﺍﳌﻌﺎﻣﻼﺕ ﺍﻟﻌﺎﻣﺔ‬

‫ﺳﻴﺘﻢ ﺗﻌﺮﻳﻒ ﻣﻌﺎﻣﻞ ﺣﺠﺰ ﺍﻟﺬﺍﻛﺮﺓ )‪ (new‬ﻭﲢﺮﻳﺮﻫﺎ )‪ (delete‬ﰲ ﻟﻐﺔ ﺍﻟﺴﻲ‪ ، ++‬ﻭﻟﻜﻦ ﻻﻧﻨﺎ ﺣﺎﻟﻴﺎ ﱂ‬
‫ﻧﱪﻣﺞ ﻣﺪﻳﺮﴽ ﻟﻠﺬﺍﻛﺮﺓ ﻓﺎﻥ ﺍﻟﺘﻌﺮﻳﻒ ﺳﻴﻜﻮﻥ ﺧﺎﻟﻴﺎ‪.‬ﻭﺍﳌﻘﻄﻊ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﺫﻟﻚ‪.‬‬
‫‪Example‬‬ ‫‪٥.٣: Global new/delete operator‬‬
‫‪١‬‬
‫∗‪٢ void‬‬ ‫‪cdecl ::operator new (unsigned‬‬ ‫};‪int size){return 0‬‬
‫∗‪٣ void‬‬ ‫‪cdecl operator new[] (unsigned‬‬ ‫};‪int size){return 0‬‬
‫‪٤ void‬‬ ‫∗ ‪cdecl ::operator delete (void‬‬ ‫}{)‪p‬‬
‫‪٥ void‬‬ ‫∗ ‪cdecl operator delete[] (void‬‬ ‫}{)‪p‬‬

‫‪١١١‬‬
 ‫‪ .٥‬ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬

‫‪Pure virtual func on call handler‬‬

‫ﺍﻳﻀﺎ ﳚﺐ ﺗﻌﺮﻳﻒ ﺩﺍﻟﺔ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﺪﻭﺍﻝ ﺍﻟﻈﺎﻫﺮﻳﺔ ﺍﻟﻨﻘﻴﺔ ) ‪ ،٥ (Pure virtual func on‬ﺣﻴﺚ ﺳﻴﻘﻮﻡ ﺍﳌﺘﺮﺟﻢ‬
‫ﺑﺎﺳﺘﺪﻋﺎء ﺍﻟﺪﺍﻟﺔ )(‪ ٦ purecall‬ﺃﻳﻨﻤﺎ ﻭﺟﺪ ﻋﻤﻠﻴﺔ ﺍﺳﺘﺪﻋﺎء ﻟﺪﺍﻟﺔ ‪ ، Pure virtual‬ﻟﺬﻟﻚ ﺃﻥ ﺃﺭﺩﻧﺎ ﺩﻋﻢ‬
‫ﺍﻟﺪﻭﺍﻝ ‪ Pure virtual‬ﳚﺐ ﺗﻌﺮﻳﻒ ﺍﻟﺪﺍﻟﺔ ‪ ، purecall‬ﻭﺣﺎﻟﻴﺎ ﺳﻴﻜﻮﻥ ﺍﻟﺘﻌﺮﻳﻒ ﻛﺎﻻﰐ‪.‬‬

‫‪Example‬‬ ‫‪٥.٤: Pure virtual func‬‬ ‫‪on call handler‬‬

‫‪١‬‬
‫‪٢ int‬‬ ‫} ;‪cdecl :: purecall() { for (;;); return 0‬‬

‫‪Floa ng Point Support‬‬ ‫ﺩﻋﻢ ﺍﻟﻔﺎﺻﻠﺔ ﺍﻟﻌﺎﺋﻤﺔ‬

‫ﻟﺪﻋﻢ ﺍﻟﻔﺎﺻﻠﺔ ﺍﻟﻌﺎﺋﻤﺔ )‪ (Floa ng Point‬ﰲ ﺳﻲ‪ ++‬ﻓﺎﻧﻪ ﳚﺐ ﺗﻌﻴﲔ ﺍﻟﻘﻴﻤﺔ ‪ 1‬ﻟﻠﻤﺘﻐﲑ ‪ ، fltused‬ﻭﻛﺬﻟﻚ‬
‫ﳚﺐ ﺗﻌﺮﻳﻒ ﺍﻟﺪﺍﻟﺔ )(‪ ftol2 sse‬ﻭﺍﻟﱵ ﲢﻮﻝ ﻣﻦ ﺍﻟﻨﻮﻉ ‪ float‬ﺍﱃ ﺍﻟﻨﻮﻉ ‪ long‬ﻛﺎﻟﺘﺎﱄ‪.‬‬

‫‪Example‬‬ ‫‪٥.٥: Floa‬‬ ‫‪ng Point Support‬‬

‫‪١‬‬
‫‪٢‬‬
‫‪٣ extern "C" long‬‬ ‫)‪declspec (naked‬‬ ‫{ )(‪ftol2 sse‬‬
‫‪٤‬‬ ‫;‪int a‬‬
‫‪٥‬‬ ‫‪#ifdef i386‬‬
‫‪٦‬‬ ‫{ ‪asm‬‬
‫‪٧‬‬ ‫]‪fistp [a‬‬
‫‪٨‬‬ ‫‪mov ebx, a‬‬
‫‪٩‬‬ ‫}‬
‫‪١٠ #endif‬‬
‫‪١١‬‬ ‫}‬
‫‪١٢‬‬
‫‪١٣ extern "C" int‬‬ ‫;‪fltused = 1‬‬

‫‪٥‬ﻋﻨﺪ ﺗﻌﺮﻳﻒ ﺩﺍﻟﺔ ﺑﺄ‪‬ﺎ ‪ Pure virtual‬ﺩﺍﺧﻞ ﺃﻱ ﻓﺌﺔ ﻓﺈﻥ ﻫﺬﺍ ﻳﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﻟﻔﺌﺔ ﳎﺮﺩﺓ )‪ (Abstract‬ﻭﳚﺐ ﺇﻋﺎﺩﺓ ﺗﻌﺮﻳﻒ ﺍﻟﺪﺍﻟﺔ‬
‫)‪ (Override‬ﰲ ﺍﻟﻔﺌﺎﺕ ﺍﳌﺸﺘﻘﺔ ﻣﻦ ﺍﻟﻔﺌﺔ ﺍﻟﱵ ﲢﻮﻱ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ‪ ،‬ﻭﺍﻻ ﺳﺘﻜﻮﻥ ﺍﻟﻔﺌﺔ ﺍﳌﺸﺘﻘﺔ ‪.‬‬
‫‪٦‬ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻳﻘﻮﻡ ﻣﺘﺮﺟﻢ ﺍﻟﻔﻴﺠﻮﺍﻝ ﺳﻲ‪ ++‬ﺑﺎﺳﺘﺪﻋﺎﺋﻬﺎ‪.‬ﻭﻗﺪ ﲣﺘﻠﻒ ﻣﻦ ﻣﺘﺮﺟﻢ ﻵﺧﺮ‪.‬‬

‫‪١١٢‬‬
‫‪ .٤.٥‬ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬

‫‪‬ﻴﺌﺔ ﺍﻟﻜﺎﺋﻨﺎﺕ ﺍﻟﻌﺎﻣﺔ ﻭﺍﻟﺴﺎﻛﻨﺔ‬

‫ﺍﻟﱪﻧﺎﻣﺞ ‪٧‬‬ ‫ﻋﻨﺪﻣﺎ ﳚﺪ ﺍﳌﺘﺮﺟﻢ ﻛﺎﺋﻨﺎ ﻓﺎﻧﻪ ﻳﻀﻴﻒ ﻣﻬﻴﺌﴼ ﺩﻳﻨﺎﻣﻴﻜﻴﺎ ﻟﻪ )‪ (Dynamic ini alizer‬ﰲ ﻗﺴﻢ ﺧﺎﺹ ﻣﻦ‬
‫ﻭﻫﻮ ﺍﻟﻘﺴﻢ ‪ ..crt‬ﻭﻗﺒﻞ ﺃﻥ ﻳﻌﻤﻞ ﺍﻟﱪﻧﺎﻣﺞ ﻓﺎﻥ ﻭﻇﻴﻔﺔ ﻣﻜﺘﺒﺔ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﻫﻲ ﺍﺳﺘﺪﻋﺎء ﻭﺗﻨﻔﻴﺬ ﻛﻞ‬
‫ﺍﳌﻬﻴﺌﺎﺕ ﻭﺫﻟﻚ ﺣﱴ ﺗﺄﺧﺬ ﺍﻟﻜﺎﺋﻨﺎﺕ ﻗﻴﻤﻬﺎ ﺍﻻﺑﺘﺪﺍﺋﻴﺔ )ﻋﱪ ﺩﺍﻟﺔ ﺍﻟﺒﻨﺎء ‪ .(Constructor‬ﻭﺑﺴﺒﺐ ﺃﻧﻨﺎ ﺃﺯﻟﻨﺎ ﻣﻜﺘﺒﺔ‬
‫ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ ﻓﺎﻧﻪ ﳚﺐ ﺍﻧﺸﺎء ﺍﻟﻘﺴﻢ ‪ .crt‬ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﻣﻮﺟﻬﺎﺕ ﺍﳌﻌﺎﰿ ﺍﻟﺘﻤﻬﻴﺪﻱ)‪(Preprocessor‬‬
‫ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﺍﳌﺘﺮﺟﻢ‪.‬‬
‫ﻫﺬﺍ ﺍﻟﻘﺴﻢ ‪ .crt‬ﳛﻮﻱ ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﻣﺆﺷﺮﺍﺕ ﺍﻟﺪﻭﺍﻝ )‪ ، (Func on Pointer‬ﻭﻭﻇﻴﻔﺔ ﻣﻜﺘﺒﺔ ﻭﻗﺖ ﺍﻟﺘﺸﻐﻴﻞ‬
‫ﻫﻲ ﺍﺳﺘﺪﻋﺎء ﻛﻞ ﺍﻟﺪﻭﺍﻝ ﺍﳌﻮﺟﻮﺩﺓ ﻭﺫﻟﻚ ﺑﺎﳌﺮﻭﺭ ﻋﻠﻰ ﻣﺼﻔﻮﻓﺔ ﺍﳌﺆﺷﺮﺍﺕ ﺍﳌﻮﺟﻮﺩﺓ ‪ .‬ﻭ ﳚﺐ ﺃﻥ ﻧﻌﻠﻢ ﺃﻥ‬
‫ﻣﺼﻔﻮﻓﺔ ﺍﳌﺆﺷﺮﺍﺕ ﻣﻮﺟﻮﺩﺓ ﺣﻘﻴﻘﺔ ﺩﺍﺧﻞ ﺍﻟﻘﺴﻢ ‪ .crt:xcu‬ﺣﻴﺚ ﺃﻥ ﺍﳉﺰء ﺍﻟﺬﻱ ﻳﻠﻲ ﺍﻟﻌﻼﻣﺔ ‪dollar sign‬‬
‫ﳛﺪﺩ ﺍﳌﻜﺎﻥ ﺑﺪﺍﺧﻞ ﺍﻟﻘﺴﻢ ‪ ،‬ﻭﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﺳﺘﺪﻋﺎء ﻭﺗﻨﻔﻴﺬ ﺍﻟﺪﻭﺍﻝ ﻋﻦ ﻃﺮﻳﻖ ﻣﺼﻔﻮﻓﺔ ﺍﳌﺆﺷﺮﺍﺕ ﻓﺎﻧﻪ‬
‫ﳚﺐ ﺍﻧﺸﺎء ﻣﺆﺷﺮ ﺍﱃ ﺑﺪﺍﻳﺔ ﺍﻟﻘﺴﻢ ‪ .crt:xcu‬ﻭﰲ ‪‬ﺎﻳﺘﻪ ‪ ،‬ﻣﺆﺷﺮ ﺍﻟﺒﺪﺍﻳﺔ ﺳﻴﻜﻮﻥ ﰲ ﺍﻟﻘﺴﻢ ‪.crt:xca‬‬
‫ﻭﻫﻮ ﻳﺴﺒﻖ ﺍﻟﻘﺴﻢ ‪ .crt:xcu‬ﻣﺒﺎﺷﺮﺓ ‪ ،‬ﻭﻣﺆﺷﺮ ﺍﻟﻨﻬﺎﻳﺔ ﺳﻴﻜﻮﻥ ﰲ ﺍﻟﻘﺴﻢ ‪ .crt:xcz‬ﻭﻳﻠﻲ ﺍﻟﻘﺴﻢ‬
‫‪ .crt:xcu‬ﻣﺒﺎﺷﺮﺓ ‪.‬‬
‫ﻭﲞﺼﻮﺹ ﺍﻟﻘﺴﻢ ‪ .crt‬ﺍﻟﺬﻱ ﺳﻨﻨﺸﺌﻪ ﻓﺎﻧﻨﺎ ﻻ ﳕﻠﻚ ﺻﻼﺣﻴﺎﺕ ﻗﺮﺍءﺓ ﻭﻛﺘﺎﺑﺔ ﻓﻴﻪ ‪ ،‬ﻟﺬﻟﻚ ﺍﳊﻞ ﰲ ﺃﻥ ﻧﻘﻮﻡ‬
‫ﺑﺪﻣﺞ ﻫﺬﺍ ﺍﻟﻘﺴﻢ ﻣﻊ ﻗﺴﻢ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪. .data‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻣﺎ ﺳﺒﻖ‪.‬‬
‫‪Example‬‬ ‫‪٥.٦: Object Ini‬‬ ‫‪alizer‬‬
‫‪١‬‬
‫‪٢ // Function pointer typedef for less typing‬‬
‫( ‪٣ typedef void‬‬ ‫;)‪cdecl ∗ PVFV)(void‬‬
‫‪٤‬‬
‫‪٥ //‬‬ ‫‪x c a points to beginning of initializer table‬‬
‫)"‪٦ #pragma data seg(".CRT$XCA‬‬
‫‪٧‬‬ ‫‪PVFV‬‬ ‫;} ‪x c a [] = { 0‬‬
‫‪٨‬‬
‫‪٩ //‬‬ ‫‪x c z points to end of initializer table‬‬
‫)"‪١٠ #pragma data seg(".CRT$XCZ‬‬
‫‪١١ PVFV‬‬ ‫;} ‪x c z [] = { 0‬‬
‫‪١٢‬‬
‫‪١٣ // Select the default data segment again (.data) for the rest of the‬‬
‫‪unit‬‬
‫)(‪١٤ #pragma data seg‬‬
‫‪١٥‬‬

‫‪.stack‬‬ ‫ﻭﺍﳌﻜﺪﺱ‬ ‫‪.code‬‬ ‫ﻭﻗﺴﻢ ﺍﻟﺸﻔﺮﺓ‬ ‫‪.data‬‬ ‫‪٧‬ﰲ ﺃﻱ ﺑﺮﻧﺎﻣﺞ ﺗﻨﻔﻴﺬﻱ ﻳﻮﺟﺪ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﻗﺴﺎﻡ‪ ،‬ﻣﺜﻼ ﻗﺴﻢ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
‫ﻭﻏﲑﻫﺎ‪.‬‬

‫‪١١٣‬‬
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

١٦ // Now, move the CRT data into .data section so we can read/write to
it
١٧ #pragma comment(linker, "/merge:.CRT=.data")
١٨
١٩
٢٠ // initialize all global initializers (ctors, statics, globals, etc
..)
٢١ void cdecl initterm ( PVFV ∗ pfbegin, PVFV ∗ pfend ) {
٢٢
٢٣ //! Go through each initializer
٢٤ while ( pfbegin < pfend )
٢٥ {
٢٦ //! Execute the global initializer
٢٧ if ( ∗pfbegin != 0 )
٢٨ (∗∗pfbegin) ();
٢٩
٣٠ //! Go to next initializer inside the initializer table
٣١ ++pfbegin;
٣٢ }
٣٣ }
٣٤
٣٥ // execute all constructors and other dynamic initializers
٣٦ void cdecl init ctor() {
٣٧
٣٨ atexit init();
٣٩ initterm( xc a , x c z );
٤٠ }

‫ﺣﺬﻑ ﺍﻟﻜﺎﺋﻨﺎﺕ‬
، (deini alizer array) ‫( ﳚﺐ ﺍﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﻣﺆﺷﺮﺍﺕ ﺩﻭﺍﻝ ﺍﳍﺪﻡ‬Objects) ‫ﻟﻜﻲ ﻳﺘﻢ ﺣﺬﻑ ﺍﻟﻜﺎﺋﻨﺎﺕ‬
‫ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃﻥ ﺍﳌﺘﺮﺟﻢ ﻋﻨﺪﻣﺎ ﳚﺪ ﺩﺍﻟﺔ ﻫﺪﻡ ﻓﺎﻧﻪ ﻳﻀﻴﻒ ﻣﺆﺷﺮﴽ ﺍﱃ ﺩﺍﻟﺔ ﺍﳍﺪﻡ ﺑﺪﺍﺧﻞ ﻫﺬﻩ ﺍﳌﺼﻔﻮﻓﺔ ﻭﺫﻟﻚ‬
‫ ﺣﻴﺚ ﺃﻥ ﻣﺘﺮﺟﻢ‬atexit ‫ ﻭﳚﺐ ﺗﻌﺮﻳﻒ ﺍﻟﺪﺍﻟﺔ‬،(exit() ‫ﺣﱴ ﻳﺘﻢ ﺍﺳﺘﺪﻋﺎﺋﻬﺎ ﻻﺣﻘﺎ )ﻋﻨﺪ ﺍﺳﺘﺪﻋﺎء ﺍﻟﺪﺍﻟﺔ‬
‫ ﻭﻇﻴﻔﺔ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻫﻲ ﺍﺿﺎﻓﺔ ﻣﺆﺷﺮ ﻟﺪﺍﻟﺔ ﻫﺪﻡ‬، ‫ ﻳﻘﻮﻡ ﺑﺎﺳﺘﺪﻋﺎﺋﻬﺎ ﻋﻨﺪﻣﺎ ﳚﺪ ﺃﻱ ﻛﺎﺋﻦ‬++‫ﺍﻟﻔﻴﺠﻮﺍﻝ ﺳﻲ‬
. ‫ﻭﲞﺼﻮﺹ ﻣﺼﻔﻮﻓﺔ ﺍﳌﺆﺷﺮﺍﺕ ﻓﺎﻧﻪ ﳝﻜﻦ ﺣﻔﻈﻬﺎ ﰲ ﺃﻱ ﻣﻜﺎﻥ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ‬، ‫ﺍﻟﻜﺎﺋﻦ ﺍﱃ ﻣﺼﻔﻮﻓﺔ ﺍﳌﺆﺷﺮﺍﺕ‬
.‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻣﺎ ﺳﺒﻖ‬
Example ٥.٧: Delete Object

١١٤
‫ ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬.٤.٥

١
٢ /! function pointer table to global deinitializer table
٣ static PVFV ∗ pf atexitlist = 0;
٤
٥ // Maximum entries allowed in table. Change as needed
٦ static unsigned max atexitlist entries = 32;
٧
٨ // Current amount of entries in table
٩ static unsigned cur atexitlist entries = 0;
١٠
١١ //! initialize the de−initializer function table
١٢ void cdecl atexit init(void) {
١٣
١٤ max atexitlist entries = 32;
١٥
١٦ // Warning: Normally, the STDC will dynamically allocate this.
Because we have no memory manager, just choose
١٧ // a base address that you will never use for now
١٨ pf atexitlist = ( PVFV ∗)0x5000;
١٩ }
٢٠
٢١ //! adds a new function entry that is to be called at shutdown
٢٢ int cdecl atexit( PVFV fn) {
٢٣
٢٤ //! Insure we have enough free space
٢٥ if (cur atexitlist entries>=max atexitlist entries)
٢٦ return 1;
٢٧ else {
٢٨
٢٩ //! Add the exit routine
٣٠ ∗(pf atexitlist++) = fn;
٣١ cur atexitlist entries++;
٣٢ }
٣٣ return 0;
٣٤ }
٣٥
٣٦ //! shutdown the C++ runtime; calls all global de−initializers
٣٧ void cdecl exit () {
٣٨
٣٩ //! Go through the list, and execute all global exit routines
٤٠ while (cur atexitlist entries−−) {

١١٥
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

٤١
٤٢ //! execute function
٤٣ (∗(−−pf atexitlist)) ();
٤٤ }
٤٥ }

‫ ﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﻨﻮﺍﺓ‬.٣.٤.٥

‫ ﻭﺍﻟﱵ ﺗﻌﺘﱪ‬kernel entry() ‫ ﻭﻧﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺍﻟﺪﺍﻟﺔ‬PE ‫( ﻟﺼﻴﻐﺔ ﻣﻠﻒ‬Parsing) ‫ﺑﻌﺪ ﺃﻥ ﻗﻤﻨﺎ ﺑﻌﻤﻞ ﲢﻠﻴﻞ‬
‫ ﻭﺃﻭﻝ ﻣﺎ ﳚﺐ ﺗﻨﻔﻴﺬﻩ ﻓﻴﻬﺎ ﻫﻮ ﲢﺪﻳﺪ ﻗﻴﻢ ﻣﺴﺠﻼﺕ ﺍﳌﻘﺎﻃﻊ ﻭﺍﻧﺸﺎء‬، ‫ﺃﻭﻝ ﺩﺍﻟﺔ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﰲ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‬
‫ ﺍﻟﱵ ﲢﻮﻱ ﺷﻔﺮﺓ‬main() ‫ﺌﻴﺔ ﺍﻟﻜﺎﺋﻨﺎﺕ ﺍﻟﻌﺎﻣﺔ ﻭﻣﻦ ﰒ ﺍﺳﺘﺪﻋﺎء ﺍﻟﺪﺍﻟﺔ‬ ‫( ﻭﺑﻌﺪ ﺫﻟﻚ ﳚﺐ‬Stack) ‫ﻣﻜﺪﺱ‬
‫ ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ‬.(Hang) ‫ ﻳﺘﻢ ﺣﺬﻑ ﺍﻟﻜﺎﺋﻨﺎﺕ ﻭﺍﻳﻘﺎﻑ ﺍﻟﻨﻈﺎﻡ‬main() ‫ ﻭﺍﺧﲑﺍ ﻋﻨﺪﻣﺎ ﺗﻌﻮﺩ ﺍﻟﺪﺍﻟﺔ‬، ‫ﺍﻟﻨﻮﺍﺓ‬
‫ﺗﻮﺿﺢ ﺫﻟﻚ‬
Example ٥.٨: Kernel Entry rou ne
١
٢ extern void cdecl main (); // main function.
٣ extern void cdecl init ctor(); // init constructor.
٤ extern void cdecl exit (); // exit.
٥
٦ void cdecl kernel entry ()
٧ {
٨
٩ #ifdef i386
١٠ asm {
١١ cli
١٢
١٣ mov ax, 10h // select data descriptor in GDT.
١٤ mov ds, ax
١٥ mov es, ax
١٦ mov fs, ax
١٧ mov gs, ax
١٨ mov ss, ax // Set up base stack
١٩ mov esp, 0x90000
٢٠ mov ebp, esp // store current stack pointer
٢١ push ebp
٢٢ }
٢٣ #endif

١١٦
‫‪ .٥.٥‬ﻧﻈﺮﺓ ﻋﻠﻰ ﺷﻔﺮﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‬

‫‪٢٤‬‬
‫‪٢٥‬‬ ‫‪// Execute global constructors‬‬
‫‪٢٦‬‬ ‫;)(‪init ctor‬‬
‫‪٢٧‬‬
‫‪٢٨‬‬ ‫‪// Call kernel entry point‬‬
‫‪٢٩‬‬ ‫;)(‪main‬‬
‫‪٣٠‬‬
‫‪٣١‬‬ ‫‪// Cleanup all dynamic dtors‬‬
‫‪٣٢‬‬ ‫;)(‪exit‬‬
‫‪٣٣‬‬
‫‪٣٤ #ifdef i386‬‬
‫‪٣٥‬‬ ‫‪asm cli‬‬
‫‪٣٦ #endif‬‬
‫‪٣٧‬‬
‫‪٣٨‬‬ ‫;);;(‪for‬‬
‫‪٣٩‬‬ ‫}‬

‫ﻭﺗﻌﺮﻳﻒ ﺍﻟﺪﺍﻟﺔ )(‪ main‬ﺣﺎﻟﻴﴼ ﺳﻴﻜﻮﻥ ﺧﺎﻟﻴﺎ‪.‬‬

‫‪ .٥.٥‬ﻧﻈﺮﺓ ﻋﻠﻰ ﺷﻔﺮﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‬

‫ﺃﻫﻢ ﺍﳋﺼﺎﺋﺺ ﺍﻟﱵ ﳚﺐ ﻣﺮﺍﻋﺘﻬﺎ ﺃﺛﻨﺎء ﺑﺮﳎﺔ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻫﻲ ﺧﺎﺻﻴﺔ ﺍﳌﺤﻤﻮﻟﻴﺔ ﻋﻠﻰ ﺻﻌﻴﺪ ﺍﻷﺟﻬﺰﺓ‬
‫ﻭﺍﳌﻨﺼﺎﺕ ‪ ٨‬ﻭﺧﺎﺻﻴﺔ ﻗﺎﺑﻠﻴﺔ ﺗﻮﺳﻌﺔ ﺍﻟﻨﻮﺍﺓ )‪ (Expandibility‬ﻭ ﻟﺬﻟﻚ ﰎ ﺍﻹﺗﻔﺎﻕ ﻋﻠﻰ ﺃﻥ ﺗﺼﻤﻴﻢ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ‬
‫ﺇﻗﺮﺃ ﺳﻴﺘﻢ ﺑﻨﺎﺋﻬﺎ ﻋﻠﻰ ﻃﺒﻘﺔ ‪ HAL‬ﺣﱴ ﺗﺴﻤﺢ ﻷﻱ ﻣﻄﻮﺭ ﻓﻴﻤﺎ ﺑﻌﺪ ﺇﻋﺎﺩﺓ ﺗﻄﺒﻴﻖ ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﻟﺪﻋﻢ ﺃﺟﻬﺰﺓ ﻭﻋﺘﺎﺩ‬
‫ﺁﺧﺮ‪ .‬ﻭﺣﱴ ﳓﺼﻞ ﻋﻠﻰ ﺃﻋﻠﻰ ﻗﺪﺭ ﻣﻦ ﺍﳌﺤﻤﻮﻟﻴﺔ ﻭﻗﺎﺑﻠﻴﺔ ﺍﻟﺘﻮﺳﻌﺔ ﰲ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻓﺎﻧﻪ ﺳﻴﺘﻢ ﺗﻘﺴﻴﻢ ﺍﻟﺸﻔﺮﺍﺕ‬
‫ﺍﻟﱪﳎﻴﺔ ﻟﻠﻨﻮﺍﺓ ﺍﱃ ﻭﺣﺪﺍﺕ ﻣﺴﺘﻘﻠﺔ ﲝﻴﺚ ﺗﺆﺩﻱ ﻛﻞ ﻭﺣﺪﺓ ﻭﻇﻴﻔﺔ ﻣﺎ ‪ ،‬ﻭﰲ ﻧﻔﺲ ﺍﻟﻮﻗﺖ ﳚﺐ ﺃﻥ ﺗﺘﻮﺍﻓﺮ‬
‫ﻭﺍﺟﻬﺔ ﻋﺎﻣﺔ )‪ (Interface‬ﻟﻜﻞ ﻭﺣﺪﺓ ﲝﻴﺚ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﻻﺳﺘﻔﺎﺩﺓ ﻣﻦ ﺧﺪﻣﺎﺕ ﻫﺬﻩ ﺍﻟﻮﺣﺪﺓ ﺩﻭﻥ ﺍﳊﺎﺟﺔ‬
‫ﳌﻌﺮﻓﺔ ﺗﻔﺎﺻﻴﻠﻬﺎ ﺍﻟﺪﺍﺧﻠﻴﺔ‪ .‬ﻭﰲ ﺑﺪﺍﻳﺔ ﺗﺼﻤﻴﻢ ﺍﳌﺸﺮﻭﻉ ﻓﺎﻥ ﻋﻤﻠﻴﺔ ﺗﺼﻤﻴﻢ ﺍﻟﻮﺍﺟﻬﺔ ﺗﻌﺘﱪ ﺃﻫﻢ ﺑﻜﺜﲑ ﻣﻦ ﻋﻤﻠﻴﺔ‬
‫ﺑﺮﳎﺔ ﳏﺘﻮﻳﺎﺕ ﺍﻟﻮﺣﺪﺓ ﺃﻭ ﻣﺎ ﻳﺴﻤﻰ ﺑﺎﻟﺘﻨﻔﻴﺬ )‪ (Impelmenta on‬ﻧﻈﺮﴽ ﻻﻥ ﺍﻟﺘﻨﻔﻴﺬ ﻗﺪ ﻻ ﻳﺆﺛﺮ ﻋﻠﻰ ﻫﻴﻜﻠﺔ‬
‫ﺍﳌﺸﺮﻭﻉ ﻭﻣﻌﻤﺎﺭﻳﺘﻪ ﻣﺜﻠﻤﺎ ﺗﺆﺛﺮ ﺍﻟﻮﺍﺟﻬﺔ ‪.‬‬
‫‪• eqraOS:‬‬
‫‪– boot: first-stage and second-stage bootloader.‬‬
‫‪– core:‬‬
‫‪∗ kernel:Kernel program PE executable file type.‬‬
‫‪٨‬ﻋﻠﻰ ﻋﻜﺲ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ‪ Bootloader‬ﻭﺍﻟﺬﻱ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﻣﻌﻤﺎﺭﻳﺔ ﺍﻟﻌﺘﺎﺩ ﻭﺍﳌﻌﺎﰿ‪.‬‬

‫‪١١٧‬‬
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

∗ hal:Hardware abstrac on layer.

∗ lib:Standard library run me and standard C/C++ library.
∗ include:Standard include headers.
∗ debug:Debug version of eqraOS.
∗ release:Final release of eqraOS.

‫ ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﺍﻟﻘﻴﺎﺳﻴﺔ‬.٦.٥

‫ ﺍﻟﻘﻴﺎﺳﻴﺔ ﺃﺛﻨﺎء ﺗﻄﻮﻳﺮ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻓﺎﻧﻪ ﳚﺐ‬++‫ﻧﻈﺮﺍّ ﻷﻧﻪ ﻗﺪ ﰎ ﺇﻟﻐﺎء ﺍﻻﻋﺘﻤﺎﺩ ﻋﻠﻰ ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﻭﺍﻟﺴﻲ‬
‫ ﻭﺑﺴﺒﺐ ﺃﻥ ﻋﻤﻠﻴﺔ ﺇﻋﺎﺩﺓ ﺑﺮﳎﺔ ﻫﺬﻩ ﺍﳌﻜﺘﺒﺎﺕ‬، ++‫ﺍﻧﺸﺎء ﻫﺬﻩ ﺍﳌﻜﺘﺒﺔ ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺳﻲ ﻭﺳﻲ‬
.‫ﻳﺘﻄﻠﺐ ﻭﻗﺘﺎّ ﻭﺟﻬﺪﺍ ﻓﺎﻧﻨﺎ ﺳﻨﺮﻛﺰ ﻋﻠﻰ ﺑﻌﺾ ﺍﳌﻠﻔﺎﺕ ﺍﳌﺴﺘﺨﺪﻣﺔ ﺑﻜﺜﺮﺓ ﻭﻧﺘﺮﻙ ﺍﻟﺒﻘﻴﺔ ﻟﻠﺘﻄﻮﻳﺮ ﻻﺣﻘﺎ‬

NULL ‫ﺗﻌﺮﻳﻒ‬
.(void*)0 ‫ ﺑﻴﻨﻤﺎ ﰲ ﻟﻐﺔ ﺍﻟﺴﻲ ﺗﻌﺮﻑ ﺏ‬0 ‫ﺎ ﺍﻟﻘﻴﻤﺔ‬‫ ﻋﻠﻰ ﺃ‬NULL ‫ ﻳﺘﻢ ﺗﻌﺮﻳﻒ‬++‫ﰲ ﻟﻐﺔ ﺳﻲ‬
Example ٥.٩: null.h:Defini on of NULL in C and C++
١
٢ #ifndef NULL H
٣ #define NULL H
٤
٥ #if define ( MSC VER) && ( MSC VER > = 1020)
٦ #pargma once
٧ #endif
٨
٩ #ifdef NULL
١٠ #undev NULL
١١ #endif
١٢
١٣ #ifdef cplusplus
١٤ extern "C"
١٥ {
١٦ #endif
١٧
١٨ /∗ C++ NULL definition ∗/

١١٨
‫ ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﺍﻟﻘﻴﺎﺳﻴﺔ‬.٦.٥

١٩ #define NULL 0
٢٠
٢١ #ifdef cplusplus
٢٢ }
٢٣ #else
٢٤
٢٥ /∗ C NULL definition ∗/
٢٦ #define NULL (void∗)0
٢٧
٢٨ #endif
٢٩
٣٠ #endif //NULL H

‫ ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺗﺮﲨﺔ ﺍﻟﻨﻮﺍﺓ‬، ‫ﻓﺔ ﻟﺪﻳﻪ‬‫ﺗﻜﻮﻥ ﻣﻌﺮ‬ cplusplus ‫ ﻓﺎﻥ ﺍﻟﻘﻴﻤﺔ‬++‫ﻭﻋﻨﺪ ﺗﺮﲨﺔ ﺍﻟﻨﻮﺍﺓ ﲟﺘﺮﺟﻢ ﺳﻲ‬
.‫ﻌﺮﱢﻑ ﺗﻠﻚ ﺍﻟﻘﻴﻤﺔ‬‫ﲟﺘﺮﺟﻢ ﺳﻲ ﻓﺎﻥ ﺍﳌﺘﺮﺟﻢ ﻻ ﻳ‬

size t ‫ﺗﻌﺮﻳﻒ‬
.(unsigned) ‫ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ‬32-bit ‫ﺎ ﻋﺪﺩ ﺻﺤﻴﺢ‬‫ ﻋﻠﻰ ﺃ‬size t ‫ﻳﺘﻢ ﺗﻌﺮﻳﻒ‬
Example ٥.١٠: size t.h:Defini on of size t in C/C++
١
٢ #ifndef SIZE T H
٣ #define SIZE T H
٤
٥ #ifdef cplusplus
٦ extern "C"
٧ {
٨ #endif
٩
١٠ /∗ Stdandard definition of size t ∗/
١١ typedef unsigned size t;
١٢
١٣ #ifdef cplusplus
١٤ }
١٥ #endif
١٦
١٧
١٨ #endif //SIZE T H

١١٩
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

‫ﺇﻋﺎﺩﺓ ﺗﻌﺮﻳﻒ ﺃﻧﻮﺍﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ‬

‫ ﻭﻳﻔﻀﻞ‬، ‫( ﲣﺘﻠﻒ ﺣﺠﻤﻬﺎ ﲝﺴﺐ ﺍﳌﺘﺮﺟﻢ ﻭﺍﻟﻨﻈﺎﻡ ﺍﻟﺬﻱ ﰎ ﺗﺮﲨﺔ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻠﻴﻪ‬Data Types) ‫ﺃﻧﻮﺍﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ‬
. ‫( ﻟﺘﻮﺿﻴﺢ ﺍﳊﺠﻢ ﻭﺍﻟﻨﻮﻉ ﰲ ﺁﻥ ﻭﺍﺣﺪ‬typedef) ‫ﺃﻥ ﻳﺘﻢ ﺍﻋﺎﺩﺓ ﺗﻌﺮﻳﻔﻬﺎ‬
Example ٥.١١: stdint.h:typedef data type
١
٢ #ifndef STDINT H
٣ #define STDINT H`
٤
٥ #define need wint t
٦ #define need wchar t
٧
٨ /∗ Exact−width integer type ∗/
٩ typedef char int8 t;
١٠ typedef unsigned char uint8 t;
١١ typedef short int16 t;
١٢ typedef unsigned short uint16 t;
١٣ typedef int int32 t;
١٤ typedef unsigned int uint32 t;
١٥ typedef long long int64 t;
١٦ typedef unsigned long long uint64 t;
١٧
١٨
١٩ // to be continue..
٢٠
٢١ #endif //STDINT H

‫ ﻭﻫﻲ ﺍﻟﺘﺴﻤﻴﺔ ﺍﻟﱵ‬cstdint ‫ ﻓﺎﻥ ﺍﳌﻠﻒ ﺍﻟﺴﺎﺑﻖ ﺳﻴﺘﻢ ﺗﻀﻤﻴﻨﻪ ﰲ ﻣﻠﻒ‬++‫ﻭﻟﺪﻋﻢ ﻣﻠﻔﺎﺕ ﺍﻟﺮﺃﺱ ﻟﻠﻐﺔ ﺳﻲ‬
.٩ ‫ ﰲ ﻣﻠﻔﺎﺕ ﺍﻟﺮﺃﺱ‬++‫ﺗﺘﺒﻌﻬﺎ ﺍﻟﺴﻲ‬
Example ٥.١٢: cstdint:C++ typedef data type
١
٢ #ifndef CSTDINT H

.‫ ﺗﺘﺒﻊ ﻧﻔﺲ ﻫﺬﺍ ﺍﻷﺳﻠﻮﺏ ﻟﺬﻟﻚ ﻟﻦ ﻳﺘﻢ ﺫﻛﺮﻫﺎ ﳎﺪﺩﺍ ﻭﺳﻨﻜﺘﻔﻲ ﺑﺬﻛﺮ ﻣﻠﻔﺎﺕ ﺍﻟﺮﺃﺱ ﻟﻠﻐﺔ ﺳﻲ‬++‫ﻣﻠﻔﺎﺕ ﺍﻟﺮﺃﺱ ﻟﻠﻐﺔ ﺳﻲ‬٩

١٢٠
‫ ﻣﻜﺘﺒﺔ ﺍﻟﺴﻲ ﺍﻟﻘﻴﺎﺳﻴﺔ‬.٦.٥

٣ #define CSTDINT H
٤
٥ #include <stdint.h>
٦
٧ #endif //CSTDINT H

‫ﻧﻮﻉ ﺍﳊﺮﻑ‬
‫ﺣﺮﻑ‬،‫ﻣﺴﺎﻓﺔ‬،‫ﺣﺮﻑ ﺻﻐﲑ‬،‫ﺣﺮﻑ‬،‫( ﻭﺍﻟﱵ ﲢﺪﺩ ﻧﻮﻉ ﺍﳊﺮﻑ )ﻋﺪﺩ‬Macros) ‫ ﳛﻮﻱ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺎﻛﺮﻭ‬ctype.h ‫ﻣﻠﻒ‬
.(‫ﺍﱁ‬...،‫ﲢﻜﻢ‬
Example ٥.١٣: ctype.h:determine character type
١
٢ #ifndef CTYPE H
٣ #define CTYPE H
٤
٥ #ifdef MSC VER
٦ #pragma warning (disable:4244)
٧ #endif
٨
٩ #ifdef cplusplus
١٠ extern "C"
١١ {
١٢ #endif
١٣
١٤ extern char ctype[];
١٥
١٦ /∗ constants ∗/
١٧
١٨ #define CT UP 0x01 // upper case
١٩ #define CT LOW 0x02 // lower case
٢٠ #define CT DIG 0x04 // digit
٢١ #define CT CTL 0x08 // control
٢٢ #define CT PUN 0x10 // punctuation
٢٣ #define CT WHT 0x20 // white space (space,cr,lf,tab).
٢٤ #define CT HEX 0x40 // hex digit
٢٥ #define CT SP 0x80 // sapce.
٢٦

١٢١
 ‫ ﻣﻘﺪﻣﺔ ﺣﻮﻝ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬.٥

٢٧ /∗ macros ∗/
٢٨
٢٩ #define isalnum(c) ( ( ctype+1)[(unsigned)(c)] & (CT UP | CT LOW |
CT DIG) )
٣٠ #define isalpha(c) (( ctype + 1)[(unsigned)(c)] & (CT UP | CT LOW)
)
٣١ #define iscntrl(c) (( ctype + 1)[(unsigned)(c)] & (CT CTL))
٣٢
٣٣
٣٤ // to be continue..
٣٥
٣٦ #ifdef cplusplus
٣٧ }
٣٨ #endif
٣٩
٤٠ #endif // CTYPE H

١٢٢
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬
‫ﺍﳌﻘﺎﻃﻌﺎﺕ ﻫﻲ ﻃﺮﻳﻘﺔ ﻹﻳﻘﺎﻑ ﺍﳌﻌﺎﰿ ﺑﺸﻜﻞ ﻣﺆﻗﺖ ﻣﻦ ﺗﻨﻔﻴﺬ ﻋﻤﻠﻴﺔ ﻣﺎ )‪ (Current Process‬ﻭﺍﻟﺒﺪء ﺑﺘﻨﻔﻴﺬ‬
‫ﺃﻭﺍﻣﺮ ﺃﺧﺮﻯ ‪ .‬ﻭﻛﻤﺜﺎﻝ ﻋﻠﻰ ﺫﻟﻚ ﻫﻮ ﻋﻨﺪ ﺍﻟﻀﻐﻂ ﻋﻠﻰ ﺃﻱ ﺣﺮﻑ ﰲ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻓﺎﻥ ﻫﺬﺍ ﻳﻮﻟﺪ ﻣﻘﺎﻃﻌﺔ‬
‫)‪ (Interrupt‬ﺗﺄﰐ ﻛﺈﺷﺎﺭﺓ ﺍﱃ ﺍﳌﻌﺎﰿ ﺑﺄﻥ ﻳﻮﻗﻒ ﻣﺎ ﻳﻌﻤﻞ ﻋﻠﻴﻪ ﺣﺎﻟﻴﺎ ﻭﳛﻔﻆ ﻛﻞ ﺍﻟﻘﻴﻢ ﺍﻟﱵ ﳛﺘﺎﺟﻬﺎ ﻟﻜﻲ‬
‫ﻳﺴﺘﻄﻴﻊ ﻣﻮﺍﺻﻠﺔ ﻣﺎ ﰎ ﻗﻄﻌﻪ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﻭﺟﻮﺩ ﺩﺍﻟﺔ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ )ﻣﻘﺎﻃﻌﺔ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ( ﻭﺗﺴﻤﻰ‬
‫ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ )‪ (Interrupt Handler‬ﺃﻭ ﺩﺍﻟﺔ ﺧﺪﻣﺔ ﺍﳌﻘﺎﻃﻌﺔ )‪ (Interrupt Service Roun ne‬ﻓﺎﻥ ﺍﻟﺘﻨﻔﻴﺬ‬
‫ﻳﺘﻨﻘﻞ ﺍﻟﻴﻬﺎ ﺗﻠﻘﺎﺋﻴﺎ ‪ ،‬ﻭ ﻳﺘﻢ ﻓﻴﻬﺎ ﻣﻌﺎﳉﺔ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ )ﻣﺜﻼ ﻳﺘﻢ ﻗﺮﺍءﺓ ﺍﳊﺮﻑ ﺍﻟﺬﻱ ﰎ ﺍﺩﺧﺎﻟﻪ ﻣﻦ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ‬
‫ﺍﳌﻔﺎﺗﻴﺢ ﻭﻣﻦ ﰒ ﺍﺭﺳﺎﻟﻪ ﺍﱃ ﻣﺘﻐﲑ ﰲ ﺍﻟﺬﺍﻛﺮﺓ( ﻭﻋﻨﺪﻣﺎ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ ﻣﻦ ﻋﻤﻠﻬﺎ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻌﻮﺩ‬
‫ﻟﻴُﻜﹾﻤ‪‬ﻞ ﺗﻨﻔﻴﺬ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﱵ ﻛﺎﻥ ﻳﻌﻤﻞ ﻋﻠﻴﻬﺎ‪ .‬ﻭﺍﳌﻘﺎﻃﻌﺎﺕ ﺇﻣﺎ ﺗﻜﻮﻥ ﻣﻘﺎﻃﻌﺎﺕ ﻋﺘﺎﺩﻳﺔ )‪(Hardware Interrupt‬‬
‫ﻭﺗﺼﺪﺭ ﻣﻦ ﻋﺘﺎﺩ ﺍﳊﺎﺳﺐ ﺃﻭ ﺗﻜﻮﻥ ﺑﺮﳎﻴﺔ )‪ (So ware Interrupt‬ﻭﺗﺼﺪﺭ ﻣﻦ ﺧﻼﻝ ﺍﻟﱪﺍﻣﺞ ﻋﻦ ﻃﺮﻳﻖ ﺗﻌﻠﻴﻤﺔ‬
‫‪ .int n‬ﻛﺬﻟﻚ ﻫﻨﺎﻙ ﻣﻘﺎﻃﻌﺎﺕ ﻳﺼﺪﺭﻫﺎ ﺍﳌﻌﺎﰿ ﻧﻔﺴﻪ ﻋﻨﺪ ﺣﺪﻭﺙ ﺧﻄﺄ ﻣﺎ )ﻣﺜﻼ ﻋﻦ ﺍﻟﻘﺴﻤﺔ ﻋﻠﻰ ﺍﻟﻌﺪﺩ‬
‫ﺻﻔﺮ ﺃﻭ ﻋﻨﺪ ﺣﺪﻭﺙ ‪ (Page Fault‬ﻭﺗﺴﻤﻰ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺑﺄﺧﻄﺎء ﺍﳌﻌﺎﰿ ﺃﻭ ﺍﺳﺘﺜﻨﺎﺋﺎﺕ ﺍﳌﻌﺎﰿ )‪(Excep ons‬‬
‫ﻭﳚﺐ ﻣﻌﺎﳉﺔ ﻫﺬﻩ ﺍﻷﺧﻄﺎء )‪ (Error Handler‬ﻷ‪‬ﺎ ﺗﻮﻗﻒ ﻋﻤﻞ ﺍﻟﻨﻈﺎﻡ ﰲ ﺣﺎﻟﺔ ﱂ ﺗﺘﻮﻓﺮ ﺩﺍﻟﺔ ﳌﻌﺎﳉﺘﻬﺎ‪.‬‬

‫‪So ware Interrupts‬‬ ‫‪ .١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ‬

‫ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ ﻫﻲ ﻣﻘﺎﻃﻌﺎﺕ ﻳﺘﻢ ﺍﻃﻼﻗﻬﺎ ﻣﻦ ﺩﺍﺧﻞ ﺍﻟﱪﻧﺎﻣﺞ )ﻋﻦ ﻃﺮﻳﻖ ﺍﻷﻣﺮ ‪ (int n‬ﻟ‪‬ﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ‬
‫ﺩﺍﻟﺔ ﺃﺧﺮﻯ ﺗﻌﺎﰿ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ )‪ ،(Interrupt handler‬ﻭﻏﺎﻟﺒﺎ ﻣﺎ ﺗﺴﺘﺨﺪﻡ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺑﺮﺍﻣﺞ ﺍﳌﺴﺘﺨﺪﻡ‬
‫)‪ (Ring3 user mode‬ﻟﻼﺳﺘﻔﺎﺩﺓ ﻣﻦ ﺧﺪﻣﺎﺕ ﺍﻟﻨﻈﺎﻡ )ﻣﺜﻼ ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﰲ ﺃﺟﻬﺰﺓ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ‬
‫ﺣﻴﺚ ﻻ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﺍﺧﺮﻯ ﻟﺬﻟﻚ ﰲ ﳕﻂ ﺍﳌﺴﺘﺨﺪﻡ(‪.‬‬

‫‪ .١.١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ‬

‫ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﺃﻣﺮ ﺍﳌﻘﺎﻃﻌﺔ )ﻭﻫﻮ ﻣﺎ ﻳﺴﻤﻰ ﺑﻄﻠﺐ ﺗﻨﻔﻴﺬ ﺍﳌﻘﺎﻃﻌﺔ )‪(Interrupt Request‬‬
‫ﻭﲣﺘﺼﺮ ﺑـ‪ (IRQ‬ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﺄﺧﺬ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﺍﳌﻄﻠﻮﺏ ﺗﻨﻔﻴﺬﻫﺎ ﻭﻳﺬﻫﺐ ‪‬ﺎ ﺍﱃ ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ )‪Interrupt‬‬
‫‪ ، (Vector Table‬ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ﺍﳊﻘﻴﻘﻲ ‪ 0x0‬ﻭﻳﻨﺘﻬﻲ ﻋﻨﺪ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x3ff‬ﻭﳛﻮﻱ ﻛﻞ ﺳﺠﻞ‬
‫ﻓﻴﻪ ﻋﻠﻰ ﻋﻨﻮﺍﻥ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ )‪ (IR‬ﻭﺍﻟﱵ ﳚﺐ ﺗﻨﻔﻴﺬﻫﺎ ﻟﺘﺨﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﺍﳌﻄﻠﻮﺑﺔ‪ .‬ﺣﺠﻢ ﺍﻟﻌﻨﻮﺍﻥ ﻫﻮ ﺃﺭﺑﻊ‬
‫ﺑﺎﻳﺖ ﻭﺗﻜﻮﻥ ﻛﺎﻟﺘﺎﱄ‪:‬‬

‫‪١٢٣‬‬
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

Interrupt Vector Table :.١.٦ ‫ﺟﺪﻭﻝ‬

Descrip on Interrupt Number Base Address
Divide by 0 0 0x000
Single step (Debugger) 1 0x004
Non Maskable Interrupt (NMI) Pin 2 0x008
Breakpoint (Debugger) 3 0x00C
Overflow 4 0x010
Bounds check 5 0x014
Undefined Opera on Code 6 0x018
No coprocessor 7 0x01C
Double Fault 8 0x020
Coprocessor Segment Overrun 9 0x024
nvalid Task State Segment (TSS)I 10 0x028
Segment Not Present 11 0x02C
Stack Segment Overrun 12 0x030
General Protec on Fault (GPF) 13 0x034
tPage Faul 14 0x038
Unassigned 15 0x03C
Coprocessor error 16 0x040
Alignment Check (486+ Only) 17 0x044
Machine Check (Pen um/586+ Only) 18 0x048
Reserved excep ons 19-31 0x05C
Interrupts free for so ware use 32-255 0x068 - 0x3FF

• Byte 0: Low offset address of IR.

• Byte 1: High offset address of IR.

• Byte 2: Low Segment address of IR.

• Byte 3: High Segment Address of IR.

‫ ﺑﺎﻳﺖ ﻭﻫﻲ ﻧﺎﲡﺔ ﻣﻦ‬1024 ‫ ﻣﻘﺎﻃﻌﺔ )ﻭﲝﺴﺒﺔ ﺑﺴﻴﻄﺔ ﻳﻜﻮﻥ ﺣﺠﻢ ﺍﳉﺪﻭﻝ ﻫﻮ‬256 ‫ﻭﻳﺘﻜﻮﻥ ﺍﳉﺪﻭﻝ ﻣﻦ‬
‫ ﺑﻌﺾ ﻣﻨﻬﺎ ﳏﺠﻮﺯ ﻭﺍﻟﺒﻌﺾ ﺍﻻﺧﺮ ﻳﺴﺘﺨﺪﻣﻪ ﺍﳌﻌﺎﰿ ﻭﺍﻟﺒﻘﻴﺔ‬،( ‫ﺿﺮﺏ ﻋﺪﺩ ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺣﺠﻢ ﻛﻞ ﺳﺠﻞ‬
‫ ﻭﺑﺴﺒﺐ ﺃﻥ ﺍﳉﺪﻭﻝ ﻳﺘﻜﻮﻥ ﻓﻘﻂ ﻣﻦ ﻋﻨﺎﻭﻳﻦ ﻟﺪﻭﺍﻝ‬.‫ﻣﺘﺮﻭﻛﺔ ﳌﱪﻣﺞ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻟﺪﻋﻢ ﺍﳌﺰﻳﺪ ﻣﻦ ﺍﳌﻘﻄﺎﻋﺎﺕ‬
‫ﺎ ﺩﺍﺧﻞ ﻫﺬﺍ‬‫ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻓﺎﻥ ﻫﺬﺍ ﳝﻜﻨﻨﺎ ﻣﻦ ﻭﺿﻊ ﺍﻟﺪﺍﻟﺔ ﰲ ﺃﻱ ﻣﻜﺎﻥ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻣﻦ ﰒ ﻭﺿﻊ ﻋﻨﻮﺍ‬
.‫ ﻭﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﳌﻮﺟﻮﺩﺓ ﻓﻴﻪ‬IVT ‫ ﻳﻮﺿﺢ‬١.٦ ‫ ﻭﺍﳉﺪﻭﻝ‬،(‫ﺍﻟﺴﺠﻞ )ﻳﺘﻢ ﻫﺬﺍ ﻋﻦ ﻃﺮﻳﻖ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ‬

١٢٤
So ware Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ‬.١.٦

‫ ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ‬.٢.١.٦

Interrupt Descriptor) ‫ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻳﺴﺘﺨﺪﻡ ﺍﳌﻌﺎﰿ ﺟﺪﻭﻻً ﺧﺎﺻﴼ ﻳﺴﻤﻰ ﲜﺪﻭﻝ ﻭﺍﺻﻔﺎﺕ ﺍﳌﻘﺎﻃﻌﺎﺕ‬
‫ ﻭﺍﺻﻔﺔ ﻛﻞ ﻭﺍﺻﻔﺔ ﳐﺼﺼﺔ‬256 ‫ ﺣﻴﺚ ﻳﺘﻜﻮﻥ ﻣﻦ‬IVT ‫ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﺸﺎﺑﻪ ﺟﺪﻭﻝ‬، IDT ‫( ﻭﳜﺘﺼﺮ ﺏ‬Table
‫ ﺑﺎﻳﺖ ﲢﻮﻱ ﻋﻨﻮﺍﻥ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ‬8 ‫ ﺣﺠﻢ ﻛﻞ ﻭﺍﺻﻔﺔ ﻫﻮ‬، (‫ ﻣﻘﺎﻃﻌﺔ‬256 ‫ﳌﻘﺎﻃﻌﺔ ﻣﺎ )ﺍﺫﴽ ﺍﳉﺪﻭﻝ ﳛﻮﻱ‬
‫ ﺍﻟﺬﻱ ﺗﻌﻤﻞ ﻋﻠﻴﻪ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ‬GDT ‫( ﰲ ﺟﺪﻭﻝ‬selector type: code or data) ‫( ﻭ ﻧﻮﻉ ﺍﻟﻨﺎﺧﺐ‬IR)
.‫ ﺑﺎﻻﺿﺎﻓﺔ ﺍﱃ ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ ﺍﳌﻄﻠﻮﺏ ﻭﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳋﺼﺎﺋﺺ ﺗﻮﺿﺤﻬﺎ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﺘﺎﻟﻴﺔ‬،
• Bits 0-15:
– Interrupt / Trap Gate: Offset address Bits 0-15 of IR
– Task Gate: Not used.

• Bits 16-31:
– Interrupt / Trap Gate: Segment Selector (Useually 0x10)
– Task Gate: TSS Selector

• Bits 31-35: Not used

• Bits 36-38:
– Interrupt / Trap Gate: Reserved. Must be 0.
– Task Gate: Not used.

• Bits 39-41:
– Interrupt Gate: Of the format 0D110, where D determins size
∗ 01110 - 32 bit descriptor
∗ 00110 - 16 bit descriptor
– Task Gate: Must be 00101
– Trap Gate: Of the format 0D111, where D determins size
∗ 01111 - 32 bit descriptor
∗ 00111 - 16 bit descriptor

• Bits 42-44: Descriptor Privedlge Level (DPL)

– 00: Ring 0
– 01: Ring 1
– 10: Ring 2
– 11: Ring 3

١٢٥
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫)‪• Bit 45: Segment is present (1: Present, 0:Not present‬‬

‫‪• Bits 46-62:‬‬
‫‪– Interrupt / Trap Gate: Bits 16-31 of IR address‬‬
‫‪– Task Gate: Not used‬‬

‫ﻭﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ ﻳﻮﺿﺢ ﺍﻧﺸﺎء ﻭﺍﺻﻔﺔ ﻭﺍﺣﺪﺓ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﺣﱴ ﻳﺴﻬﻞ ﺗﺘﺒﻊ ﺍﻟﻘﻴﻢ ‪ ،‬ﻭﺳﻴﺘﻢ ﻛﺘﺎﺑﺔ ﻣﺜﺎﻝ ﻛﺎﻣﻞ‬
‫ﻻﺣﻘﺎ ﺑﻠﻐﺔ ﺍﻟﺴﻲ‪.‬‬
‫‪Example‬‬ ‫‪٦.١: Example of interrupt descriptor‬‬
‫‪١‬‬
‫‪٢ idt descriptor:‬‬
‫‪٣‬‬ ‫‪baseLow‬‬ ‫‪dw‬‬ ‫‪0x0‬‬
‫‪٤‬‬ ‫‪selector‬‬ ‫‪dw‬‬ ‫‪0x8‬‬
‫‪٥‬‬ ‫‪reserved‬‬ ‫‪db‬‬ ‫‪0x0‬‬
‫‪٦‬‬ ‫‪flags‬‬ ‫‪db‬‬ ‫‪0x8e‬‬ ‫‪; 010001110‬‬
‫‪٧‬‬ ‫‪baseHi‬‬ ‫‪dw‬‬ ‫‪0x0‬‬

‫ﺍﳌﺘﻐﲑ ﺍﻷﻭﻝ ‪ baseLow‬ﻫﻮ ﺃﻭﻝ ‪ 16‬ﺑﺖ ﻣﻦ ﻋﻨﻮﺍﻥ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ ‪ IR‬ﻭﻳﻜﻤﻞ ﺍﳉﺰء ﺍﻻﺧﺮ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ‬
‫ﺍﳌﺘﻐﲑ ‪ baseHi‬ﻭﰲ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﺍﻟﻌﻨﻮﺍﻥ ﻫﻮ ‪ 0x0‬ﲟﻌﲎ ﺃﻥ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﺳﺘﻜﻮﻥ ﰲ ﺍﻟﻌﻨﻮﺍﻥ ‪ .0x0‬ﻭﲟﺎ ﺃﻥ‬
‫ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ )ﲣﺪﱘ( ﺍﳌﻘﺎﻃﻌﺔ ﲢﻮﻱ ﺷﻔﺮﺓ ﺑﺮﳎﻴﺔ ﻟﻠﺘﻨﻔﻴﺬ ﻭﻟﻴﺴﺖ ﺑﻴﺎﻧﺎﺕ )‪ (Data‬ﻓﺎﻥ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ ‪selector‬‬
‫ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ‪ 0x8‬ﻟﻺﺷﺎﺭﺓ ﺍﱃ ﻧﺎﺧﺐ ﺍﻟﺸﻔﺮﺓ )‪ (Code Selector‬ﰲ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ )‪ .(GDT‬ﺃﻣﺎ‬
‫ﺍﳌﺘﻐﲑ ‪ flags‬ﻓﺎﻥ ﻗﻴﻤﺘﻪ ﻫﻲ ‪ 010001110b‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﺍﻟﻮﺍﺻﻔﺔ ﻫﻲ ‪ 32-bit‬ﻭﺃﻥ ﻣﺴﺘﻮﻯ ﺍﳊﻤﺎﻳﺔ‬
‫ﻫﻮ ﺍﳊﻠﻘﺔ ﺻﻔﺮ )‪.(Ring0‬‬
‫ﻭﺑﻌﺪ ﺃﻥ ﻳﺘﻢ ﺍﻧﺸﺎء ﺃﻏﻠﺐ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ )ﰲ ﺃﻱ ﻣﻜﺎﻥ ﻋﻠﻰ ﺍﻟﺬﺍﻛﺮﺓ( ‪ ،‬ﳚﺐ ﺃﻥ ﻧﻨﺸﺊ ﺟﺪﻭﻝ‬
‫‪ IDT‬ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺣﻔﻆ ﻋﻨﻮﺍﻥ ﺃﻭﻝ ﻭﺍﺻﻔﺔ ﰲ ﻣﺘﻐﲑ ﻭﻟﻴﻜﻦ ‪ idt start‬ﻭﻋﻨﻮﺍﻥ ‪‬ﺎﻳﺔ ﺍﻟﻮﺍﺻﻔﺎﺕ‬
‫ﰲ ﺍﳌﺘﻐﲑ ‪ idt end‬ﻭﻣﻦ ﰒ ﺍﻧﺸﺎء ﻣﺆﺷﺮﴽ ﻳﺴﻤﻰ ‪ idt ptr‬ﻭﺍﻟﺬﻱ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﰲ ﺻﻮﺭﺓ ﻣﻌﻴﻨﺔ ﲝﻴﺚ‬
‫ﳛﻔﻆ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳉﺪﻭﻝ ﻭ‪‬ﺎﻳﺘﻪ ‪:‬‬
‫‪Example‬‬ ‫‪٦.٢: Value to put in IDTR‬‬
‫‪١ idt ptr:‬‬
‫‪٢‬‬ ‫‪limit dw idt end − idt start ; bits 0−15 is size of idt‬‬
‫‪٣‬‬ ‫‪base dd idt start‬‬ ‫‪; base of idt‬‬

‫ﻫﺬﺍ ﺍﳌﺆﺷﺮ ﳚﺐ ﺃﻥ ﻳﺘﻢ ﲢﻤﻴﻠﻪ ﺍﱃ ﺍﳌﺴﺠﻞ ‪) IDTR‬ﻭﻫﻮ ﻣﺴﺠﻞ ﺩﺍﺧﻞ ﺍﳌﻌﺎﰿ( ﻋﻦ ﻃﺮﻳﻖ ﺗﻨﻔﻴﺬ ﺍﻻﻣﺮ ‪١ lidt‬‬
‫‪.lidt‬‬ ‫]‪[idt ptr‬‬ ‫ﺑﺎﻟﺸﻜﻞ ﺍﻟﺘﺎﱄ‬
‫‪١‬ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﻫﺬﺍ ﺍﻷﻣﺮ ﻓﺎﻥ ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺳﻴﺘﻢ ﺍﺳﺘﺒﺪﺍﻟﻪ ﺑﺎﳉﺪﻭﻝ ﺍﳉﺪﻳﺪ ﻭﺍﻟﺬﻱ ﳒﺪ ﻋﻨﻮﺍﻧﻪ ﺑﺪﺍﺧﻞ ﺍﳌﺴﺠﻞ ‪ ، idtr‬ﻭﻫﺬﺍ‬
‫ﺍﻷﻣﺮ ﻻ ﻳ‪‬ﻨﻔﱠﺬ ﺇﻻﱠ ﺍﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﻌﻠﻢ )‪ (CPL flag‬ﻫﻲ ﺻﻔﺮ‪.‬‬

‫‪١٢٦‬‬
‫‪So ware Interrupts‬‬ ‫‪ .١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ‬

‫ﻭﻋﻨﺪ ﺣﺪﻭﺙ ﺃﻱ ﻣﻘﺎﻃﻌﺔ ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻨﻬﻲ ﺍﻷﻣﺮ ﺍﻟﺬﻱ ﻳﻌﻤﻞ ﻋﻠﻴﻪ ﻭ ﻳﺄﺧﺬ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻭﻳﺬﻫﺐ ﺑﻪ ﺍﱃ ﺟﺪﻭﻝ‬
‫‪) IDT‬ﻋﻨﻮﺍﻥ ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﺘﻮﺍﺟﺪ ﺑﺪﺍﺧﻞ ﺍﳌﺴﺠﻞ ‪ ، (IDTR‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﻘﻮﻡ ﲝﺴﺎﺏ ﻣﻜﺎﻥ ﺍﻟﻮﺍﺻﻔﺔ ﺑﺎﳌﻌﺎﺩﻟﺔ‬
‫‪ int num * 8‬ﻭﺫﻟﻚ ﺑﺴﺒﺐ ﺃﻥ ﺣﺠﻢ ﻛﻞ ﻭﺍﺻﻔﺔ ﰲ ﺟﺪﻭﻝ ‪ IDT‬ﻫﻮ ‪ 8‬ﺑﺎﻳﺖ‪ .‬ﻭﻗﺒﻞ ﺃﻥ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ‬
‫ﺍﱃ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ ﻓﺎﻧﻪ ﳚﺐ ﺃﻥ ﻳﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ ﺣﻔﻆ ﻟﻠﻤﻜﺎﻥ ﺍﻟﺬﻱ ﺗﻮﻗﻒ ﻓﻴﻪ ﺣﱴ ﻳﺴﺘﻄﻴﻊ ﺃﻥ ﻳﺘﺎﺑﻊ ﻋﻤﻠﻪ‬
‫ﻋﻨﺪﻣﺎ ﺗﻌﻮﺩ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ ‪ .‬ﻭﻳﺘﻢ ﺣﻔﻆ ﺍﻷﻋﻼﻡ ‪ EFLAGS‬ﻭﻣﺴﺠﻞ ﻣﻘﻄﻊ ﺍﻟﺸﻔﺮﺓ ‪ CS‬ﻭﻣﺴﺠﻞ ﻋﻨﻮﺍﻥ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺎﻟﻴﺔ ‪ IP‬ﰲ ﺍﳌﻜﺪﺱ )‪ (Stack‬ﺍﳊﺎﱄ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ ﺧﻄﺄ ﻣﺎ ﻓﺎﻧﻪ ﻳﺘﻢ ﺩﻓﻊ ﺷﻔﺮﺓ ﺍﳋﻄﺄ )‪Error‬‬
‫‪ (Code‬ﺍﱃ ﺍﳌﻜﺪﺱ ﺃﻳﻀﺎ‪ .‬ﻭﺷﻔﺮﺓ ﺍﳋﻄﺄ ﻫﻲ ﺑﻄﻮﻝ ‪ 32-bit‬ﻭﺗﺘﺒﻊ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﺘﺎﻟﻴﺔ‪.‬‬
‫‪• Bit 0: External event‬‬
‫‪– 0: Internal or so ware event triggered the error.‬‬
‫‪– 1: External or hardware event triggered the error.‬‬

‫‪• Bit 1: Descrip on loca on‬‬

‫‪– 0: Index por on of error code refers to descriptor in GDT or current LDT.‬‬
‫‪– 1: Index por on of error code refers to gate descriptor in IDT.‬‬

‫‪• Bit 2: GDT/LDT. Only use if the descriptor loca on is 0.‬‬

‫‪– 0: This indicates the index por on of the error code refers to a descriptor in the current GDT.‬‬
‫‪– 1: This indicates the index por on of the error code refers to a segment or gate descriptor in‬‬
‫‪the LDT.‬‬

‫‪• Bits 3-15: Segment selector index. This is an index into the IDT, GDT, or current LDT to the segment‬‬
‫‪or gate selector bring refrenced by the error code.‬‬

‫‪• Bits 16-31: Reserved.‬‬

‫ﻭﻋﻨﺪﻣﺎ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ ﻣﻦ ﻋﻤﻠﻬﺎ ﻓﺎﻧﻪ ﳚﺐ ﺃﻥ ﺗﻨﻔﺬ ﺍﻷﻣﺮ ‪ iret‬ﺃﻭ ‪ iretd‬ﺣﱴ ﻳﺘﻢ ﺍﺭﺟﺎﻉ‬
‫ﺍﻟﻘﻴﻢ ﺍﻟﱵ ﰎ ﺩﻓﻌﻬﺎ ﺍﱃ ﺍﳌﻜﺪﺱ )ﻗﻴﻢ ﺍﻷﻋﻼﻡ ‪ .(FLAGS‬ﻭﺑﺎﻟﺘﺎﱄ ‪‬ﻳﻜﹾﻤ‪‬ﻞ ﺍﳌﻌﺎﰿ ﻋﻤﻠﻪ‪.‬‬

‫‪ .٣.١.٦‬ﺃﺧﻄﺎء ﺍﳌﻌﺎﰿ‬
‫ﺧﻼﻝ ﺗﻨﻔﻴﺬ ﺍﳌﻌﺎﰿ ﻟﻸﻭﺍﻣﺮ ﻓﺎﻧﻪ ﺭﲟﺎ ﳛﺪﺙ ﺧﻄﺄ ﻣﺎ ﳑﺎ ﳚﻌﻞ ﺍﳌﻌﺎﰿ ﻳﻘﻮﻡ ﺑﺘﻮﻟﻴﺪ ﺍﺳﺘﺜﻨﺎء ﻳﻌﺮﻑ ﺑﺎﺳﺘﺜﻨﺎء ﺍﳌﻌﺎﰿ‬
‫‪ ،‬ﻭﻳﻮﺟﺪ ﻟﻪ ﻋﺪﺓ ﺃﻧﻮﺍﻉ‪:‬‬
‫ﺍﳋﻄﺄ ‪ :Fault‬ﻋﻨﺪﻣﺎ ﺗﻌﻤﻞ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﻫﺬﺍ ﺍﻟﻨﻮﻉ ﻣﻦ ﺍﻻﺳﺘﺜﻨﺎء ﻓﺮﲟﺎ ﻳﺘﻢ ﺍﺻﻼﺡ ﻫﺬﺍ ﺍﳋﻄﺄ ‪ ،‬ﻭﻋﻨﻮﺍﻥ‬ ‫•‬
‫ﺍﻟﻌﻮﺩﺓ ﺍﻟﺬﻱ ﻳﺘﻢ ﺩﻓﻌﻪ ﺍﱃ ﺍﳌﻜﺪﺱ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﻷﻣﺮ ﺍﻟﺬﻱ ﺗﺴﺒﺐ ﰲ ﻫﺬﺍ ﺍﳋﻄﺄ‪.‬‬
‫ﺍﳋﻄﺄ ‪ :Trap‬ﻋﻨﻮﺍﻥ ﺍﻟﻌﻮﺩﺓ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﱵ ﺗﻠﻲ ﺍﻷﻣﺮ ﺍﻟﺬﻱ ﺗﺴﺒﺐ ﰲ ﺍﳋﻄﺄ‪.‬‬ ‫•‬

‫‪١٢٧‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫ﺟﺪﻭﻝ ‪x86 Processor Excep ons Table :.٢.٦‬‬

‫‪Descrip on‬‬ ‫‪Class‬‬ ‫‪Interrupt Number‬‬
‫‪Divide by 0‬‬ ‫‪Fault‬‬ ‫‪0‬‬
‫‪Single step‬‬ ‫‪Trap/Fault 1‬‬
‫‪Non Maskable Interrupt (NMI) Pin Unclassed 2‬‬
‫‪Breakpoint‬‬ ‫‪Trap‬‬ ‫‪3‬‬
‫‪Overflow‬‬ ‫‪Trap‬‬ ‫‪4‬‬
‫‪Bounds check‬‬ ‫‪Fault‬‬ ‫‪5‬‬
‫‪Unvalid OPCode‬‬ ‫‪Fault‬‬ ‫‪6‬‬
‫‪Device not available‬‬ ‫‪Fault‬‬ ‫‪7‬‬
‫‪Double Fault‬‬ ‫‪Abort‬‬ ‫‪8‬‬
‫‪Coprocessor Segment Overrun‬‬ ‫‪Abort‬‬ ‫‪9‬‬
‫‪Invalid Task State Segment‬‬ ‫‪Fault‬‬ ‫‪10‬‬
‫‪Segment Not Present‬‬ ‫‪Fault‬‬ ‫‪11‬‬
‫‪Stack Fault Excep on‬‬ ‫‪Fault‬‬ ‫‪12‬‬
‫‪General Protec on Fault‬‬ ‫‪Fault‬‬ ‫‪13‬‬
‫‪Page Fault‬‬ ‫‪Fault‬‬ ‫‪14‬‬
‫‪Unassigned‬‬ ‫‪-‬‬ ‫‪15‬‬
‫‪x87 FPU Error‬‬ ‫‪Fault‬‬ ‫‪16‬‬
‫‪Alignment Check‬‬ ‫‪Fault‬‬ ‫‪17‬‬
‫‪Machine Check‬‬ ‫‪Abort‬‬ ‫‪18‬‬
‫‪SIMD FPU Excep on‬‬ ‫‪Fault‬‬ ‫‪19‬‬
‫‪Reserved‬‬ ‫‪-‬‬ ‫‪20-31‬‬
‫‪Avilable for so ware use‬‬ ‫‪-‬‬ ‫‪32-255‬‬

‫ﺍﳋﻄﺄ ‪ :Abort‬ﻻ ﻳﻮﺟﺪ ﻋﻨﻮﺍﻥ ﻟﻠﻌﻮﺩﺓ ‪ ،‬ﻭﻟﻦ ﻳﻜﻤﻞ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻤﻠﻪ ﺑﻌﺪ ﺍﻧﺘﻬﺎء ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳋﻄﺄ‪.‬‬ ‫•‬

‫ﻭﺍﳉﺪﻭﻝ ‪ ٢.٦‬ﻳﻮﺿﺢ ﺃﺧﻄﺎء ﺍﳌﻌﺎﰿ ﻭﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﻳﻘﻮﻡ ﺑﺘﻮﻟﻴﺪﻫﺎ‪.‬‬

‫ﻭﳚﺪﺭ ﺑﻨﺎ ﺍﻟﻮﻗﻮﻑ ﻋﻠﻰ ﻣﻼﺣﻈﺔ ﻛﻨّﺎ ﻗﺪ ﺫﻛﺮﻧﺎﻫﺎ ﰲ ﺍﻟﻔﺼﻮﻝ ﺍﻟﺴﺎﺑﻘﺔ ﻭﻫﻲ ﺇﻟﻐﺎء ﺍﳌﻘﺎﻃﻌﺎﺕ )ﺑﻮﺍﺳﻄﺔ ﺍﻷﻣﺮ‬
‫‪ (cli‬ﻋﻨﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﺣﱴ ﻻ ﻳﺘﺴﺒﺐ ﰲ ﺣﺪﻭﺙ ﺧﻄﺄ ‪ General Protec on Fault‬ﻭﺑﺎﻟﺘﺎﱄ‬
‫ﺗﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﺍﻟﻌﻤﻞ ﻭﺳﺒﺐ ﺫﻟﻚ ﻫﻮ ﺃﻥ ﻋﺪﻡ ﺗﻨﻔﻴﺬ ﺍﻷﻣﺮ ‪ cli‬ﻳﻌﲏ ﺃﻥ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ﻣﻔﻌﻠﺔ ﻭﺑﺎﻟﺘﺎﱄ‬
‫ﺃﻱ ﻋﺘﺎﺩ ﳝﻜﻨﻪ ﺃﻥ ﻳﺮﺳﻞ ﻣﻘﺎﻃﻌﺔ ﺍﱃ ﺍﳌﻌﺎﰿ ﻟﻜﻲ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺩﺍﻟﺔ ﲣﺪﳝﻬﺎ ‪ .‬ﻭﻋﻨﺪ ﺑﺪﺍﻳﺔ ﺍﻻﻧﺘﻘﺎﻝ ﺍﱃ‬
‫ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻓﺎﻥ ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪ IDT‬ﱂ ﻳﺘﻢ ﺍﻧﺸﺎﺋﻪ ﻭﺃﻱ ﳏﺎﻭﻟﺔ ﻻﺳﺘﺨﺪﺍﻣﻪ ﺳﻴﺆﺩﻱ ﺍﱃ ﻫﺬﺍ ﺍﳋﻄﺄ‪.‬‬
‫ﺃﺣﺪ ﺍﳌﺘﺤﻜﻤﺎﺕ ﺍﻟﱵ ﺗﺮﺳﻞ ﻣﻘﺎﻃﻌﺎﺕ ﺍﱃ ﺍﳌﻌﺎﰿ ﺑﺸﻜﻞ ﺛﺎﺑﺖ ﻫﻮ ﻣﺘﺤﻜﻢ ‪Prpgrammable Interval Timer‬‬
‫ﻭﲣﺘﺼﺮ ﲟﺘﺤﻜﻢ ‪ PIT‬ﻭﻫﻲ ﲤﺜﻞ ﺳﺎﻋﺔ ﺍﻟﻨﻈﺎﻡ ‪ System Timer‬ﲝﻴﺚ ﺗﺮﺳﻞ ﻣﻘﺎﻃﻌﺔ ﺑﺸﻜﻞ ﺩﺍﺋﻢ ﺍﱃ ﺍﳌﻌﺎﰿ‬
‫ﻭﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺩﺍﻟﺔ ﲣﺪﱘ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ ‪ .‬ﻭﺑﺴﺒﺐ ﺃﻥ ﺟﺪﻭﻝ ﺍﳌﻘﻄﺎﻋﺎﺕ ﻏﲑ ﻣﺘﻮﺍﺟﺪ ﰲ ﺑﺪﺍﻳﺔ‬
‫ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻭﻛﺬﻟﻚ ﻻ ﺗﻮﺟﺪ ﺩﺍﻟﺔ ﻟﺘﺨﺪﱘ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ ﻓﺎﻥ ﻫﺬﺍ ﻳﺆﺩﻱ ﺍﱃ ﺗﻮﻗﻒ ﺍﻟﻨﻈﺎﻡ ‪،‬‬

‫‪١٢٨‬‬
‫‪So ware Interrupts‬‬ ‫‪ .١.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ‬

‫ﻟﺬﻟﻚ ﳚﺐ ﺍﻳﻘﺎﻑ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ﳊﲔ ﺍﻧﺸﺎء ﺟﺪﻭﻝ ﺍﳌﻘﻄﺎﻋﺎﺕ ﻭﻛﺘﺎﺑﺔ ﺩﻭﺍﻝ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺎﺕ‪ .‬ﻛﺬﻟﻚ‬
‫ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ ﺃﺧﺮﻯ ﻟﺒﻌﺾ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ﺣﻴﺚ ﺍ‪‬ﺎ ﺗﺴﺘﺨﺪﻡ ﻧﻔﺲ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﻳﺴﺘﺨﺪﻣﻬﺎ‬
‫ﺍﳌﻌﺎﰿ ﻟﻺﺳﺘﺜﻨﺎءﺍﺕ ﻭﺣﻠﻬﺎ ﻫﻮ ﺑﺈﻋﺎﺩﺓ ﺑﺮﳎﺔ ﺍﻟﺸﺮﳛﺔ ﺍﳌﺴﺆﻭﻟﺔ ﻋﻦ ﺍﺳﺘﻘﺒﺎﻝ ﺍﻻﺷﺎﺭﺍﺕ ﻣﻦ ﺍﻟﻌﺘﺎﺩ ﻭﲢﻮﻳﻠﻬﺎ ﺍﱃ‬
‫ﻣﻘﺎﻃﻌﺎﺕ ﻭﺍﺭﺳﺎﳍﺎ ﺍﱃ ﺍﳌﻌﺎﰿ ‪ ،‬ﻫﺬﻩ ﺍﻟﺸﺮﳛﺔ ﺗﺴﻤﻰ ‪ Programmable Interrupt Controller‬ﻭﲣﺘﺼﺮ ﺏ ‪PIC‬‬
‫ﻭﳚﺐ ﺇﻋﺎﺩﺓ ﺑﺮﳎﺘﻬﺎ ﻭﺗﻐﻴﲑ ﺍﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻟﻸﺟﻬﺰﺓ ﺍﻟﱵ ﺗﺴﺘﺨﺪﻡ ﺃﺭﻗﺎﻣﴼ ﻣﺘﺸﺎ‪‬ﺔ‪.‬‬
‫ﻭﻓﻴﻤﺎ ﻳﻠﻲ ﺳﻴﺘﻢ ﺇﻧﺸﺎء ﺟﺪﻭﻝ ﺍﳌﻘﺎﻃﻌﺎﺕ )‪ (IDT‬ﺑﺎﺳﺘﺨﺪﺍﻡ ﻟﻐﺔ ﺍﻟﺴﻲ ﻭﺗﻮﻓﲑ ﺍﻝ ‪ 256‬ﺩﺍﻟﺔ ﳌﻌﺎﳉﺔ ﺍﳌﻘﻄﺎﻋﺎﺕ‬
‫ﻭﺣﺎﻟﻴﺎ ﺳﻴﻘﺘﺼﺮ ﻋﻤﻞ ﺍﻟﺪﻭﺍﻝ ﻋﻠﻰ ﻃﺒﺎﻋﺔ ﺭﺳﺎﻟﺔ ‪ ،‬ﻭﻗﺒﻞ ﺫﻟﻚ ﺳﻨﻘﻮﻡ ﺑﺎﻧﺸﺎء ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ )‪(GDT‬‬
‫ﳎﺪﺩﺍ )ﺃﻱ ﺳﻴﺘﻢ ﺍﻟﻐﺎء ﺍﳉﺪﻭﻝ ﺍﻟﺬﻱ ﻗﻤﻨﺎ ﺑﺎﻧﺸﺎﺋﻪ ﰲ ﻣﺮﺣﻠﺔ ﺍﻻﻗﻼﻉ( ﻭﺑﻌﺪ ﺫﻟﻚ ﺳﻨﺒﺪﺃ ﰲ ﺑﺮﳎﺔ ﻣﺘﺤﻜﻢ ‪PIC‬‬
‫ﻭﺍﻋﺎﺩﺓ ﺗﺮﻗﻴﻢ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻷﺟﻬﺰﺓ ﻭﻛﺬﻟﻚ ﺑﺮﳎﺔ ﺳﺎﻋﺔ ﺍﻟﻨﻈﺎﻡ ﻻﺭﺳﺎﻝ ﻣﻘﺎﻃﻌﺔ ﺑﻮﻗﺖ ﳏﺪﺩ‪.‬‬

‫‪GDT‬‬ ‫‪ .٤.١.٦‬ﺇﻧﺸﺎء ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ‬

‫ﺍﳍﺪﻑ ﺍﻟﺮﺋﻴﺴﻲ ﰲ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﻫﻲ ﺍﳌﺤﻤﻮﻟﻴﺔ ﻋﻠﻰ ﺻﻌﻴﺪ ﺍﳌﻨﺼﺎﺕ ‪ ،‬ﻭﻫﺬﺍ ﻣﺎ ﺃﺩﻯ ﺍﱃ ﺍﻋﺘﻤﺎﺩ ﻓﻜﺮﺓ‬
‫ﻃﺒﻘﺔ ‪ HAL‬ﻭﺍﻟﱵ ﻳﻘﺒﻊ ﲢﺘﻬﺎ ﻛﻞ ﻣﺎ ﻳﺘﻌﻠﻖ ﺑﻌﺘﺎﺩ ﺍﳊﺎﺳﺐ ﻭﺍﺩﺍﺭﺗﻪ ﻭﻛﻞ ﻣﺎ ﳚﻌﻞ ﺍﻟﻨﻈﺎﻡ ﻣﻌﺘﻤﺪﴽ ﻋﻠﻰ ﻣﻌﻤﺎﺭﻳﺔ‬
‫ﻣﻌﻴﻨﺔ ﺃﻳﻀﺎ ﳒﺪﻩ ﲢﺖ ﻃﺒﻘﺔ ‪ ، HAL‬ﻭﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ ‪ -‬ﻛﻤﺎ ﺫﻛﺮﻧﺎ ﰲ ﺍﻟﻔﺼﻮﻝ ﺍﻟﺴﺎﺑﻘﺔ‪ -‬ﳛﺪﺩ ﻭﻳﻘﺴﻢ‬
‫ﻟﻨﺎ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻛﺄﺟﺰﺍء ﻗﺎﺑﻠﺔ ﻟﻠﺘﻨﻔﻴﺬ ﻭﺃﺟﺰﺍء ﲢﻮﻱ ﺑﻴﺎﻧﺎﺕ ﻭﻏﲑﻫﺎ ‪ ،‬ﻭﻧﻈﺮﴽ ﻷﻥ ﺇﻧﺸﺎء ﻫﺬﺍ ﺍﳉﺪﻭﻝ ﻳﻌﺘﻤﺪ‬
‫ﻋﻠﻰ ﻣﻌﻤﺎﺭﻳﺔ ﺍﳌﻌﺎﰿ ﻭﺍﻷﻭﺍﻣﺮ ﺍﳌﺪﻋﻮﻣﺔ ﻓﻴﻪ ﻓﺎﻧﻪ ﳚﺐ ﺍﻥ ﻳﻘﻊ ﲢﺖ ﻃﺒﻘﺔ ‪ ٢ HAL‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ﻧﻘﻞ ﺍﻟﻨﻈﺎﻡ ﺍﱃ‬
‫ﻣﻌﻤﺎﺭﻳﺔ ﺣﺎﺳﻮﺏ ﺁﺧﺮ ﻳﺘﻄﻠﺐ ﻓﻘﻂ ﺇﻋﺎﺩﺓ ﺑﺮﳎﺔ ﻃﺒﻘﺔ ‪. HAL‬‬
‫ﺑﺪﺍﻳﺔ ﺳﻨﺒﺪﺃ ﺑﺘﺼﻤﻴﻢ ﺍﻟﻮﺍﺟﻬﺔ ﺍﻟﻌﺎﻣﺔ ﻟﻄﺒﻘﺔ ‪ HAL‬ﻭﳚﺐ ﺃﻥ ﻧﺮﺍﻋﻲ ﺃﻥ ﺗﻜﻮﻥ ﺍﻟﻮﺍﺟﻬﺔ ﻣﻔﺼﻮﻟﺔ ﲤﺎﻣﺎ ﻋﻦ ﺍﻟﺘﻄﺒﻴﻖ‬
‫ﺣﱴ ﻳﺘﻤﻜﻦ ﺃﻱ ﻣﻄﻮﺭ ﻣﻦ ﺇﻋﺎﺩﺓ ﺗﻄﺒﻴﻘﻬﺎ ﻻﺣﻘﺎّ ﻋﻠﻰ ﻣﻌﻤﺎﺭﻳﺔ ﺣﺎﺳﻮﺏ ﺁﺧﺮ‪.‬‬
‫‪Example‬‬ ‫‪٦.٣: include/hal.h:Hardware Abstrac‬‬ ‫‪on Layer Interface‬‬
‫‪١‬‬
‫‪٢ #ifndef HAL H‬‬
‫‪٣ #define HAL H‬‬
‫‪٤‬‬
‫‪٥ #ifndef i386‬‬
‫"‪٦ #error "HAL is not implemented in this platform‬‬
‫‪٧ #endif‬‬
‫‪٨‬‬
‫‪٩ #include‬‬ ‫>‪<stdint.h‬‬
‫‪١٠‬‬
‫‪١١ #ifdef‬‬ ‫‪MSC VER‬‬
‫‪١٢ #define interrupt‬‬ ‫)‪declspec(naked‬‬
‫‪١٣ #else‬‬

‫‪٢‬ﻣﻦ ﻣﻨﻈﻮﺭ ﺁﺧﺮ ﻫﺬﻩ ﺍﳉﺪﺍﻭﻝ )‪ (GDT,LDT and IDT‬ﻫﻲ ﺟﺪﺍﻭﻝ ﻟﻠﻤﻌﺎﰿ ﻟﺬﻟﻚ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﰲ ﻃﺒﻘﺔ ‪.HAL‬‬

‫‪١٢٩‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫‪١٤ #define interrupt‬‬

‫‪١٥ #endif‬‬
‫‪١٦‬‬
‫‪١٧ #define far‬‬
‫‪١٨ #define near‬‬
‫‪١٩‬‬
‫‪٢٠‬‬
‫∗‪٢١ /‬‬ ‫‪Interface ∗/‬‬
‫‪٢٢‬‬
‫‪٢٣ extern int‬‬ ‫;)(‪cdecl hal init‬‬
‫‪٢٤ extern int‬‬ ‫;)(‪cdecl hal close‬‬
‫;)‪٢٥ extern void cdecl gen interrupt(int‬‬
‫‪٢٦‬‬
‫‪٢٧‬‬
‫‪٢٨ #endif // HAL H‬‬

‫ﻭﺣﺎﻟﻴﴼ ﻭﺍﺟﻬﺔ ﻃﺒﻘﺔ ‪ HAL‬ﻣﻜﻮﻧﺔ ﻣﻦ ﺛﻼﺙ ﺩﻭﺍﻝ ﰎ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﺑﺄ‪‬ﺎ ‪ extern‬ﻭﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ﺃﻱ ﺗﻄﺒﻴﻖ‬
‫)‪ (Implementa on‬ﳍﺬﻩ ﺍﻟﻮﺍﺟﻬﺔ ﳚﺐ ﺃﻥ ﻳ‪‬ﻌﺮﱢﻑ ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ‪ .‬ﺍﻟﺪﺍﻟﺔ ﺍﻻﻭﱃ ﻫﻲ )(‪ hal init‬ﻭﺍﻟﱵ ﺗﻘﻮﻡ‬
‫ﺑﺘﻬﻴﺌﺔ ﺍﻟﻌﺘﺎﺩ ﻭﺟﺪﺍﻭﻝ ﺍﳌﻌﺎﰿ ﺑﻴﻨﻤﺎ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺜﺎﻧﻴﺔ )(‪ hal close‬ﺗﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ ﺍﳊﺬﻑ ﻭﺍﻟﺘﺤﺮﻳﺮ ﻭﺃﺧﲑﺍ ﺍﻟﺪﺍﻟﺔ‬
‫‪ gen interrupt‬ﻭﺍﻟﱵ ﰎ ﻭﺿﻌﻬﺎ ﻟﻐﺮﺽ ﲡﺮﺑﺔ ﺇﺭﺳﺎﻝ ﻣﻘﺎﻃﻌﺔ ﺑﺮﳎﻴﺔ ﻭﺍﻟﺘﺄﻛﺪ ﻣﻦ ﺃﻥ ﺩﺍﻟﺔ ﻣﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺔ‬
‫ﺗﻌﻤﻞ ﻛﻤﺎ ﻳﺮﺍﻡ‪.‬‬
‫ﻧﻌﻮﺩ ﺑﺎﳊﺪﻳﺚ ﺍﱃ ﺟﺪﻭﻝ ﺍﻟﻮﺍﺻﻔﺎﺕ ﺍﻟﻌﺎﻡ )‪ ٣ (GDT‬ﺣﻴﺚ ﺳﻴﺘﻢ ﺍﻧﺸﺎﺋﻪ ﺑﻠﻐﺔ ﺍﻟﺴﻲ ﻭﻫﺬﺍ ﻣﺎ ﺳﻴﺴﻤﺢ ﻟﻨﺎ‬
‫ﺑﺎﺳﺘﺨﺪﺍﻡ ﺗﺮﺍﻛﻴﺐ ﻋﺎﻟﻴﺔ ﻟﻠﺘﻌﺒﲑ ﻋﻦ ﺍﳉﺪﻭﻝ ﻭ ﺍﳌﺆﺷﺮ ﳑﺎ ﻳﻌﻄﻲ ﻭﺿﻮﺡ ﻭﻣﻘﺮﻭﺋﻴﺔ ﺃﻛﺜﺮ ﰲ ﺍﻟﺸﻔﺮﺓ‪.‬ﻭﺳﻮﻑ‬
‫ﳓﺘﺎﺝ ﺍﱃ ﺗﻌﺮﻳﻒ ﺛﻼﺙ ﺩﻭﺍﻝ ‪:٤‬‬
‫ﺍﻟﺪﺍﻟﺔ ‪ :i386 gdt init‬ﺗﻘﻮﻡ ﺑﺘﻬﻴﺌﺔ ﻭﺍﺻﻔﺔ ﺧﺎﻟﻴﺔ ﻭﻭﺍﺻﻔﺔ ﻟﻠﺸﻔﺮﺓ ﻭﻟﻠﺒﻴﺎﻧﺎﺕ ﻭﻛﺬﻟﻚ ﺍﻧﺸﺎء ﻣﺆﺷﺮ‬ ‫•‬
‫ﺍﳉﺪﻭﻝ‪.‬‬
‫ﺍﻟﺪﺍﻟﺔ ‪ :i386 gdt set desc‬ﺩﺍﻟﺔ ‪‬ﻴﺌﺔ ﺍﻟﻮﺍﺻﻔﺔ ﺣﻴﺚ ﺗﺴﺘﻘﺒﻞ ﺍﻟﻘﻴﻢ ﻭﺗﻌﻴﻨﻬﺎ ﺍﱃ ﺍﻟﻮﺍﺻﻔﺔ ﺍﳌﻄﻠﻮﺑﺔ‪.‬‬ ‫•‬

‫ﺍﻟﺪﺍﻟﺔ ‪ :gdt install‬ﺗﻘﻮﻡ ﺑﺘﺤﻤﻴﻞ ﺍﳌﺆﺷﺮ ﺍﻟﺬﻱ ﳛﻮﻱ ﺣﺠﻢ ﺍﳉﺪﻭﻝ ﻭﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺘﻪ ﺍﱃ ﺍﳌﺴﺠﻞ‬ ‫•‬
‫‪.GDTR‬‬
‫ﻭﺍﻟﺸﻔﺮﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺍﻧﺸﺎء ﺍﳉﺪﻭﻝ ‪.٥‬‬
‫‪Example‬‬ ‫‪٦.٤: hal/gdt.cpp:Install GDT‬‬
‫‪٣‬ﺭﺍﺟﻊ ‪.١.١.٤‬‬
‫‪٤‬ﻟﻐﺮﺽ ﺍﻟﺘﻨﻈﻴﻢ ﻭﺍﻟﺘﻘﺴﻴﻢ ﻻ ﺃﻛﺜﺮ ﻭﻻ ﺃﻗﻞ‪.‬‬
‫‪٥‬ﺭﺍﺟﻊ ﺷﻔﺮﺓ ﺍﻟﻨﻈﺎﻡ ﻟﻘﺮﺍءﺓ ﻣﻠﻒ ﺍﻟﺮﺃﺱ ‪.hal/gdt.h‬‬

‫‪١٣٠‬‬
So ware Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ‬.١.٦

١
٢ #include <string.h>
٣ #include "gdt.h"
٤
٥ static struct gdt desc gdt[MAX GDT DESC];
٦ static struct gdtr gdtr;
٧
٨
٩ static void gdt install();
١٠
١١
١٢ static void gdt install() {
١٣ #ifdef MSC VER
١٤ asm lgdt [ gdtr];
١٥ #endif
١٦ }
١٧
١٨ extern void i386 gdt set desc(uint32 t index,uint64 t base,uint64 t
limit,uint8 t access,uint8 t grand) {
١٩
٢٠ if ( index > MAX GDT DESC )
٢١ return;
٢٢
٢٣ // clear the desc.
٢٤ memset((void∗)& gdt[index],0,sizeof(struct gdt desc));
٢٥
٢٦ // set limit and base.
٢٧ gdt[index].low base = uint16 t(base & 0xffff);
٢٨ gdt[index].mid base = uint8 t((base >> 16) & 0xff);
٢٩ gdt[index].high base = uint8 t((base >> 24) & 0xff);
٣٠ gdt[index].limit = uint16 t(limit & 0xffff);
٣١
٣٢ // set flags and grandularity bytes
٣٣ gdt[index].flags = access;
٣٤ gdt[index].grand = uint8 t((limit >> 16) & 0x0f);
٣٥ gdt[index].grand = gdt[index].grand | grand & 0xf0;
٣٦ }
٣٧
٣٨ extern gdt desc ∗ i386 get gdt desc(uint32 t index) {
٣٩ if ( index >= MAX GDT DESC )
٤٠ return 0;

١٣١
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٤١ else
٤٢ return & gdt[index];
٤٣ }
٤٤
٤٥ extern int i386 gdt init() {
٤٦
٤٧ // init gdtr
٤٨ gdtr.limit = sizeof(struct gdt desc) ∗ MAX GDT DESC − 1;
٤٩ gdtr.base = (uint32 t)& gdt[0];
٥٠
٥١ // set null desc.
٥٢ i386 gdt set desc(0,0,0,0,0);
٥٣
٥٤ // set code desc.
٥٥ i386 gdt set desc(1,0,0xffffffff,
٥٦ I386 GDT CODE DESC | I386 GDT DATA DESC | I386 GDT READWRITE |
I386 GDT MEMORY, // 10011010
٥٧ I386 GDT LIMIT HI | I386 GDT 32BIT | I386 GDT 4K //
11001111
٥٨
٥٩ );
٦٠
٦١ // set data desc.
٦٢ i386 gdt set desc(2,0,0xffffffff,
٦٣ I386 GDT DATA DESC | I386 GDT READWRITE | I386 GDT MEMORY, //
10010010
٦٤ I386 GDT LIMIT HI | I386 GDT 32BIT | I386 GDT 4K // 11001111
٦٥ );
٦٦
٦٧ // install gdtr
٦٨ gdt install();
٦٩
٧٠ return 0;
٧١ }

١٣٢
‫‪Programmable Interrupt Controller‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪Programmable Interrupt‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪Controller‬‬

‫ﺍﻟﺴﺒﺐ ﺍﻟﺮﺋﻴﺴﻲ ﰲ ﺗﻌﻄﻴﻞ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ﻋﻨﺪ ﺍﻹﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ )‪ (PMode‬ﻫﻮ ﺑﺴﺒﺐ ﻋﺪﻡ‬
‫ﺗﻮﻓﺮ ﺩﻭﺍﻝ ﳌﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺎﺕ ﰲ ﺗﻠﻚ ﺍﻟﻠﺤﻈﺔ ‪ ،‬ﻭﺣﱴ ﻟﻮ ﻗﻤﻨﺎ ﺑﺘﻮﻓﲑ ﺍﻝ ‪ ٢٥٦‬ﺩﺍﻟﺔ ﳌﻌﺎﳉﺔ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻓﺎﻥ‬
‫ﻫﻨﺎﻟﻚ ﻣﺸﻜﻠﺔ ﺍﺳﺘﺨﺪﺍﻡ ﻧﻔﺲ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻷﻛﺜﺮ ﻣﻦ ﻏﺮﺽ ‪ ،‬ﻓﻤﺜﻼ ﻣﺆﻗﺘﺔ ﺍﻟﻨﻈﺎﻡ ‪ PIT‬ﺍﻟﱵ ﺗﺮﺳﻞ ﻣﻘﺎﻃﻌﺎﺕ‬
‫ﺑﺸﻜﻞ ﺩﺍﺋﻢ ﺗﺴﺘﺨﺪﻡ ﺍﳌﻘﺎﻃﻌﺔ ﺭﻗﻢ ‪ ٨‬ﻭﺍﻟﱵ ﻫﻲ ﺃﻳﻀﺎ ﺃﺣﺪ ﺍﺳﺘﺜﻨﺎءﺍﺕ ﺍﳌﻌﺎﰿ ‪ ،‬ﻟﺬﻟﻚ ﰲ ﻛﻠﺘﺎ ﺍﳊﺎﻻﺕ ﺳﻴﺘﻢ‬
‫ﺍﺳﺘﺪﻋﺎء ﺩﺍﻟﺔ ﲣﺪﱘ ﻭﺍﺣﺪﺓ ﻭﻫﻮ ﺷﻲء ﻣﺮﻓﻮﺽ ﲤﺎﻣﴼ‪ .‬ﻟﺬﻟﻚ ﺍﳊﻞ ﺍﻟﻮﺣﻴﺪ ﻫﻮ ﺑﺈﻋﺎﺩﺓ ﺑﺮﳎﺔ ﺍﳌﺘﺤﻜﻢ ﺍﳌﺴﺆﻭﻝ‬
‫ﻋﻦ ﺍﺳﺘﻘﺒﺎﻝ ﺍﻹﺷﺎﺭﺍﺕ ﻣﻦ ﻣﺘﺤﻜﻤﺎﺕ ﺍﻟﻌﺘﺎﺩ ﻭﺗﻌﻴﲔ ﺃﺭﻗﺎﻡ ﳐﺘﻠﻔﺔ ﲞﻼﻑ ﺗﻠﻚ ﺍﻷﺭﻗﺎﻡ ﺍﻟﱵ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﻌﺎﰿ‬
‫ﻟﻸﺧﻄﺎء ﻭﺍﻻﺳﺘﺜﻨﺎءﺍﺕ ‪ ،‬ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ )ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ (١.٦‬ﻭﻇﻴﻔﺘﻪ ﻫﻲ ﺍﺳﺘﻘﺒﺎﻝ ﺇﺷﺎﺭﺍﺕ ﻣﻦ ﻣﺘﺤﻜﻤﺎﺕ‬
‫ﺍﻟﻌﺘﺎﺩ ﻭﻣﻦ ﰒ ﻳﻘﻮﻡ ﺑﺘﺤﻮﻳﻠﻬﺎ ﺍﱃ ﺃﺭﻗﺎﻡ ﻣﻘﺎﻃﻌﺎﺕ ﺗ‪‬ﺮﺳﻞ ﺑﻌﺪ ﺫﻟﻚ ﺍﱃ ﺍﳌﻌﺎﰿ ﺍﻟﺬﻱ ﻳﻘﻮﻡ ﺑﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ ‪،‬‬
‫ﻭﻳﻌﺮﻑ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﲟﺘﺤﻜﻢ ‪ PIC‬ﺍﺧﺘﺼﺎﺭﴽ ﻝ ‪ Programmable Interrupt Controller‬ﻭﻳﻌﺮﻑ ﺃﻳﻀﺎ ﺑﺎﻹﺳﻢ‬
‫‪ ، 8259A‬ﻭﰲ ﻫﺬﺍ ﺍﻟﺒﺤﺚ ﺳﻨﺴﺘﺨﺪﻡ ﺍﳌﺴﻤﻰ ﻣﺘﺤﻜﻢ ‪.PIC‬‬

‫‪8259A‬‬ ‫ﺷﻜﻞ ‪ :.١.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪Hardware Interrupts‬‬ ‫‪ .١.٢.٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ‬

‫ﻗﺒﻞ ﺃﻥ ﻧﺒﺪﺃ ﰲ ﺍﻟﺪﺧﻮﻝ ﰲ ﺗﻔﺎﺻﻴﻞ ﻣﺘﺤﻜﻢ ‪ PIC‬ﳚﺐ ﺇﻋﻄﺎء ﻧﺒﺬﺓ ﻋﻦ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩﻳﺔ ﺣﻴﺚ ﺫﻛﺮﻧﺎ ﺃ‪‬ﺎ‬
‫ﻣﻘﺎﻃﻌﺎﺕ ﲣﺘﻠﻒ ﻋﻦ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱪﳎﻴﺔ ﻣﻦ ﻧﺎﺣﻴﺔ ﺃﻥ ﻣﺼﺪﺭﻫﺎ ﻳﻜﻮﻥ ﻣﻦ ﺍﻟﻌﺘﺎﺩ ﻭﻟﻴﺲ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﻣﺎ ‪ ،‬ﻭﻫﺬﺍ‬
‫ﻣﺎ ﺃﺩﻯ ﺍﱃ ﻇﻬﻮﺭ ﻟﻘﺐ ﻣﺴﲑ ﻟﻸﺣﺪﺍﺙ )‪ (Interrupt Driven‬ﻋﻠﻰ ﺃﺟﻬﺰﺓ ﺍﳊﺎﺳﺐ‪ .‬ﺣﻴﺚ ﻗﺪﳝﺎ ﱂ ﻳﻜﻦ ﻫﻨﺎﻙ‬
‫ﻃﺮﻳﻘﺔ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﺇﻻ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺣﻠﻘﺔ ﺑﺮﳎﻴﺔ )‪ (loop‬ﻋﻠﻰ ﻣﺴﺠﻞ ﻣﺎ ﰲ ﻣﺘﺤﻜﻢ ﺍﻟﻌﺘﺎﺩ ﺣﱴ ﺗﺘﻐﲑ ﻗﻴﻤﺘﻪ‬
‫ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﻨﺎﻙ ﻗﻴﻤﺔ ﺃﻭ ﻧﺘﻴﺠﺔ ﻗﺪ ﺟﺎءﺕ ﻣﻦ ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﰲ ﺍﻟﺘﺨﺎﻃﺐ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﺗﺴﻤﻰ ‪٦ Polling‬‬
‫ﻭﻫﻲ ﺗﻀﻴﻊ ﻭﻗﺖ ﺍﳌﻌﺎﰿ ﰲ ﺍﻧﺘﻈﺎﺭ ﻗﻴﻤﺔ ﻻ ﻳ‪‬ﻌﺮﻑ ﻫﻞ ﺳﺘﻈﻬﺮ ﺃﻡ ﻻ ﻭﻗﺪ ﰎ ﺇﻟﻐﺎﺋﻬﺎ ﰲ ﺍﻟﺘﺨﺎﻃﺐ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﺣﻴﺚ‬
‫ﺍﻻﻥ ﺃﺻﺒﺢ ﺃﻱ ﻣﺘﺤﻜﻢ ﻋﺘﺎﺩ ﻳﺪﻋﻢ ﺇﺭﺳﺎﻝ ﺍﻹﺷﺎﺭﺍﺕ )ﻭﺑﺎﻟﺘﺎﱄ ﺍﳌﻘﺎﻃﻌﺎﺕ( ﺍﱃ ﺍﳌﻌﺎﰿ ﻭﺍﻟﺬﻱ ﻗﺪ ﻳﻌﻤﻞ ﻋﻠﻰ‬
‫ﻋﻤﻠﻴﺔ ﺃﺧﺮﻯ ‪ ،‬ﻭﻫﻜﺬﺍ ﰎ ﺍﻹﺳﺘﻔﺎﺩﺓ ﻣﻦ ﻭﻗﺖ ﺍﳌﻌﺎﰿ ﻭﺃﺻﺒﺢ ﺍﻟﺘﺨﺎﻃﺐ ﻫﻮ ﻏﲑ ﻣﺘﺰﺍﻣﻦ )‪(Asynchronous‬‬
‫ﺑﺪﻻﹰ ﻣﻦ ﻣﺘﺰﺍﻣﻦ )‪ .(Synchronous‬ﻭﻋﻨﺪﻣﺎ ﻳﺒﺪﺃ ﺍﳊﺎﺳﺐ ﰲ ﺍﻹﻗﻼﻉ ﻓﺎﻥ ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ ﻳﻘﻮﻡ ﺑﺘﺮﻗﻴﻢ ﻋﺘﺎﺩ‬
‫‪.Busy Wai‬‬ ‫‪ng‬‬ ‫‪٦‬ﻭﺗﺴﻤﻰ ﺃﻳﻀﺎ ﺏ‬

‫‪١٣٣‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫‪x86‬‬ ‫ﺟﺪﻭﻝ ‪ :.٣.٦‬ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩ ﳊﻮﺍﺳﻴﺐ‬

‫ﺭﻗﻢ ﺍﳌﺸﺒﻚ)ﺍﻟﺪﺑﻮﺱ( ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﺍﻟﻮﺻﻒ‬
‫ﺍﳌﺆﻗﺘﺔ ‪Timer‬‬ ‫‪0x08‬‬ ‫‪IRQ0‬‬
‫ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬ ‫‪0x09‬‬ ‫‪IRQ1‬‬
‫ﻳ‪‬ﺮﺑﻂ ﻣﻊ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺛﺎﻧﻮﻱ‬ ‫‪0x0a‬‬ ‫‪IRQ2‬‬
‫ﺍﳌﻨﻔﺬ ﺍﻟﺘﺴﻠﺴﻠﻲ ‪٢‬‬ ‫‪0x0b‬‬ ‫‪IRQ3‬‬
‫ﺍﳌﻨﻔﺬ ﺍﻟﺘﺴﻠﺴﻠﻲ ‪١‬‬ ‫‪0x0c‬‬ ‫‪IRQ4‬‬
‫ﻣﻨﻔﺬ ﺍﻟﺘﻮﺍﺯﻱ ‪٢‬‬ ‫‪0x0d‬‬ ‫‪IRQ5‬‬
‫ﻣﺘﺤﻜﻢ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ‬ ‫‪0x0e‬‬ ‫‪IRQ6‬‬
‫ﻣﻨﻔﺬ ﺍﻟﺘﻮﺍﺯﻱ ‪١‬‬ ‫‪0x0f‬‬ ‫‪IRQ7‬‬
‫ﺳﺎﻋﺔ ﺍﻝ ‪CMOS‬‬ ‫‪0x70‬‬ ‫‪IRQ8/IRQ0‬‬
‫‪CGA ver cal retrace‬‬ ‫‪0x71‬‬ ‫‪IRQ9/IRQ1‬‬
‫ﳏﺠﻮﺯﺓ‬ ‫‪0x72‬‬ ‫‪IRQ10/IRQ2‬‬
‫ﳏﺠﻮﺯﺓ‬ ‫‪0x73‬‬ ‫‪IRQ11/IRQ3‬‬
‫ﳏﺠﻮﺯﺓ‬ ‫‪0x74‬‬ ‫‪IRQ12/IRQ4‬‬
‫ﻭﺣﺪﺓ ‪FPU‬‬ ‫‪0x75‬‬ ‫‪IRQ13/IRQ5‬‬
‫ﻣﺘﺤﻜﻢ ﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ‬ ‫‪0x76‬‬ ‫‪IRQ14/IRQ6‬‬
‫ﳏﺠﻮﺯﺓ‬ ‫‪0x77‬‬ ‫‪IRQ15/IRQ7‬‬

‫ﺍﳊﺎﺳﺐ ﻭﺇﻋﻄﺎء ﺭﻗﻢ ﻣﻘﺎﻃﻌﺔ ﻟﻜﻞ ﻣﺘﺤﻜﻢ ﻭﺑﺴﺒﺐ ﺗﻜﺮﺍﺭ ﻫﺬﻩ ﺍﻷﺭﻗﺎﻡ ﻓﺎﻧﻪ ﳚﺐ ﺗﻐﻴﲑﻫﺎ ﻷﺭﻗﺎﻡ ﺃﺧﺮﻯ ﻭﻫﺬﺍ‬
‫ﻳﺘﻢ ﺑﺴﻬﻮﻟﺔ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻭﺫﻟﻚ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﺃﻣﺎ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻓﻴﺠﺐ ﺃﻥ ﻧﻘﻮﻡ‬
‫ﺑﺎﻟﺘﺨﺎﻃﺐ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺬﻱ ﻟﺪﻳﻪ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻭﻣﻦ ﰒ ﺗﻐﻴﲑﻫﺎ ‪ .‬ﻭﺍﳉﺪﻭﻝ ‪ ٣.٦‬ﻳﻮﺿﺢ ﺃﺭﻗﺎﻡ‬
‫ﺍﳌﻘﺎﻃﻌﺎﺕ ﳌﺘﺤﻜﻤﺎﺕ ﺍﳊﺎﺳﺐ‪.‬‬

‫‪PIC‬‬ ‫‪ .٢.٢.٦‬ﺑﺮﳎﺔ ﻣﺘﺤﻜﻢ‬

‫ﻣﺘﺤﻜﻢ ‪ PIC‬ﻳﺴﺘﻘﺒﻞ ﺇﺷﺎﺭﺍﺕ )‪ (Signals‬ﻣﻦ ﻣﺘﺤﻜﻤﺎﺕ ﺍﻟﻌﺘﺎﺩ ﻭﺍﻟﱵ ﺗﻜﻮﻥ ﻣﻮﺻﻮﻟﺔ ﺑﻪ ﻭﻣﻦ ﰒ ﻳﻘﻮﻡ ﺑﺘﺤﻮﻳﻠﻬﺎ‬
‫ﺍﱃ ﺃﺭﻗﺎﻡ ﻣﻘﺎﻃﻌﺎﺕ ﻟﻜﻲ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﱃ ﺩﺍﻟﺔ ﲣﺪﳝﻬﺎ ‪ ،‬ﻭﻳﺮﺍﻋﻲ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺃﻭﻟﻴﺔ ﻣﺘﺤﻜﻤﺎﺕ‬
‫ﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻓﻤﺜﻼ ﻟﻮ ﰎ ﺇﺭﺳﺎﻝ ﺇﺷﺎﺭﺗﲔ ﰲ ﻧﻔﺲ ﺍﻟﻮﻗﺖ ﺍﱃ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻓﺎﻥ ﺍﳌﺘﺤﻜﻢ ﺳﻮﻑ ﻳﺮﺍﻋﻲ ﺍﻷﻭﻟﻴﺔ ﻭﻳﻘﻮﻡ‬
‫ﺑﺎﺭﺳﺎﻝ ﺭﻗﻢ ﻣﻘﺎﻃﻌﺔ ﺍﻟﻌﺘﺎﺩ ﺫﻭ ﺍﻷﻭﻟﻴﺔ ﺃﻭﻻ ﻭﺑﻌﺪ ﺃﻥ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﻳﻘﻮﻡ ﺍﳌﺘﺤﻜﻢ ﺑﺎﺭﺳﺎﻝ ﺍﻟﺮﻗﻢ‬
‫ﺍﻵﺧﺮ ‪ .‬ﻭﻧﻈﺮﴽ ﻟﺘﻌﻘﻴﺪﺍﺕ ﺑﻨﺎء ﺍﳌﺘﺤﻜﻢ ﻓﺎﻧﻪ ﻳﺘﻌﺎﻣﻞ ﻓﻘﻂ ﻣﻊ ‪ ٨‬ﺃﺟﻬﺰﺓ ﳐﺘﻠﻔﺔ )ﺃﻱ ‪ ٨‬ﻣﻘﺎﻃﻌﺎﺕ ‪ (IRQ‬ﻭﻫﺬﺍ‬
‫ﻣﺎ ﺃﺩﻯ ﻣﺼﻨﻌﻰ ﺍﳊﺎﺳﺐ ﺍﱃ ﺗﻮﻓﲑ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺁﺧﺮ ﻳﻌﺮﻑ ﺑﺎﳌﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ )‪. (Secondary/Slave PIC‬‬
‫ﺍﳌﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ )‪ (Primary PIC‬ﻳﻮﺟﺪ ﺩﺍﺧﻞ ﺍﳌﻌﺎﰿ ﻭﻳﺮﺗﺒﻂ ﻣﻊ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ ﻭﺍﻟﺬﻱ ﻳﺘﻮﺍﺟﺪ ﰲ ﺍﳉﺴﺮ‬
‫ﺍﳉﻨﻮﰊ )‪. (SouthBridge‬‬

‫‪١٣٤‬‬
‫‪Programmable Interrupt Controller‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪PIC's Pins‬‬ ‫ﻣﺸﺎﺑﻚ ﺍﳌﺘﺤﻜﻢ‬

‫ﺗﻌﺘﱪ ﻣﺸﺎﺑﻚ ﺍﳌﺘﺤﻜﻢ ﻫﻲ ﻃﺮﻳﻘﺔ ﺍﺭﺳﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻣﻦ ﺍﳌﺘﺤﻜﻢ ﺍﱃ ﺍﳌﻌﺎﰿ )ﺃﻭ ﺍﱃ ﻣﺘﺤﻜﻢ ﺭﺋﻴﺴﻲ( ‪ ،‬ﻭﻧﻈﺮﴽ‬
‫ﻻﻥ ﻛﻞ ﻣﺸﺒﻚ ﻟﺪﻳﻪ ﻭﻇﻴﻔﺔ ﳏﺪﺩﺓ ﻓﺎﻧﻪ ﳚﺐ ﺩﺭﺍﺳﺔ ﻫﺬﻩ ﺍﳌﺸﺎﺑﻚ ﻭﻟﻜﻦ ﻟﻦ ﻧﻔﺼ‪‬ﻞ ﻛﺜﲑﴽ ﺣﻴﺚ ﺃﻥ ﺍﳌﻮﺿﻮﻉ‬
‫ﻣﺘﺸﻌﺐ ﻭﳜﺺ ﺩﺭﺍﺳﻲ ﺍﳌﻨﻄﻖ ﺍﻟﺮﻗﻤﻲ )‪ .(Digital Logic‬ﻭﻳﻮﺿﺢ ﺍﻟﺸﻜﻞ ‪ ٢.٦‬ﻫﺬﻩ ﺍﳌﺸﺎﺑﻚ‪.‬‬
‫ﺣﻴﺚ ﺃﻥ ﺍﳌﺸﺎﺑﻚ ‪ D0-D7‬ﻫﻲ ﻹﺭﺳﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﱃ ﻣﺘﺤﻜﻢ‬
‫‪ PIC‬ﺃﻣﺎ ﺍﳌﺸﺎﺑﻚ ‪ CAS0, CAS1, CAS2‬ﺗﺴﺘﺨﺪﻡ ﻟﻠﺘﺨﺎﻃﺐ ﺑﲔ‬
‫ﻣﺘﺤﻜﻤﺎﺕ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭﺍﻟﺜﺎﻧﻮﻳﺔ ‪ ،‬ﻭﺍﳌﺸﺒﻚ ‪ INT‬ﻳﺮﺗﺒﻂ ﻣﻊ‬
‫ﻣﺸﺒﻚ ﻟﻠﻤﻌﺎﰿ ﻭﻫﻮ ‪ INTR‬ﻛﺬﻟﻚ ﺍﳌﺸﺒﻚ ‪ INTA‬ﻳﺮﺗﺒﻂ ﻣﻊ‬
‫ﻣﺸﺒﻚ ﺍﳌﻌﺎﰿ ‪ INTA‬ﻭﻫﺬﻩ ﺍﳌﺸﺎﺑﻚ ﳍﺎ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻟﻔﻮﺍﺋﺪ ﺣﻴﺚ‬
‫ﻋﻨﺪﻣﺎ ﻳﻘﻮﻡ ﺍﳌﻌﺎﰿ ﺑﺘﻨﻔﻴﺬ ﺃﻱ ﻣﻘﺎﻃﻌﺔ ﻓﺎﻧﻪ ﻳﻘﻮﻡ ﺑﺘﻌﻄﻴﻞ ﻗﻴﻢ‬
‫ﺍﻟﻌﻠﻤﲔ ‪ IF and TF‬ﻭﻫﺬﺍ ﻣﺎ ﳚﻌﻞ ﻣﺸﺒﻚ ﺍﳌﻌﺎﰿ ‪ INTR‬ﻳﻐﻠﻖ‬
‫ﻣﺒﺎﺷﺮﺓ ﻭﺑﺎﻟﺘﺎﱄ ﻻ ﳝﻜﻦ ﳌﺘﺤﻜﻢ ‪ PIC‬ﺇﺭﺳﺎﻝ ﺃﻱ ﻣﻘﺎﻃﻌﺔ ﻋﱪ‬
‫ﺷﻜﻞ ‪ :.٢.٦‬ﻣﺸﺎﺑﻚ ﻣﺘﺤﻜﻢ ‪PIC‬‬
‫ﻣﺸﺒﻜﻪ ‪ INT‬ﺣﻴﺚ ﺃﻥ ﺍﳉﻬﺔ ﺍﳌﻘﺎﺑﻠﺔ ﳍﺎ ﰎ ﻏﻠﻘﻬﺎ ﻭﺑﺎﻟﺘﺎﱄ ﻻ ﳝﻜﻦ‬
‫ﳌﻘﺎﻃﻌﺔ ﺃﻥ ﺗﻘﻄﻊ ﻣﻘﺎﻃﻌﺔ ﺃﺧﺮﻯ ﻭﺇﳕﺎ ﻳﺘﻢ ﺣﺠﺮﻫﺎ ﰲ ﻣﺴﺠﻞ‬
‫ﺩﺍﺧﻞ ‪ PIC‬ﺍﱃ ﺃﻥ ﻳﻨﺘﻬﻲ ﺍﳌﻌﺎﰿ ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﳌﻘﺎﻃﻌﺔ ﻭﺍﻟﻌﻮﺩﺓ ﺑﺈﺷﺎﺭﺓ )ﺗﺴﻤﻰ ﺇﺷﺎﺭﺓ ‪‬ﺎﻳﺔ ﺍﳌﻘﺎﻃﻌﺔ ‪End Of‬‬
‫‪ (Interrupt‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﳌﻘﺎﻃﻌﺔ ﻗﺪ ﺍﻧﺘﻬﺖ‪ .‬ﺃﺧﲑﺍ ﻣﺎ ﻳﻬﻤﻨﺎ ﰲ ﻫﺬﻩ ﺍﳌﺸﺎﺑﻚ ﻫﻲ ﻣﺸﺎﺑﻚ ‪ IR0...IR7‬ﻭﻫﻲ‬
‫ﻣﺸﺎﺑﻚ ﺗﺮﺗﺒﻂ ﻣﻊ ﻣﺘﺤﻜﻤﺎﺕ ﺍﻟﻌﺘﺎﺩ ﺍﳌﺮﺍﺩ ﺍﺳﺘﻘﺒﺎﻝ ﺍﻹﺷﺎﺭﺍﺕ ﻣﻨﻪ ﻋﻨﺪ ﺣﺪﻭﺙ ﺷﻲء ﻣﻌﲔ )ﺍﻟﻀﻐﻂ ﻋﻠﻰ‬
‫ﺣﺮﻑ ﰲ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻣﺜﻼﹰ( ﻭﳝﻜﻦ ﳍﺬﻩ ﺍﳌﺸﺎﺑﻚ ﺃﻥ ﺗﺮﺗﺒﻂ ﻣﻊ ﻣﺘﺤﻜﻤﺎﺕ ‪ PIC‬ﺃﺧﺮﻯ ﻭﻻ ﻳﻮﺟﺪ ﺷﺮﻁ‬
‫ﻳﻨﺺ ﻋﻠﻰ ﻭﺟﻮﺏ ﺗﻮﻓﺮ ﻣﺘﺤﻜﻤﲔ ‪ PIC‬ﻭﺇﳕﺎ ﳝﻜﻦ ﺭﺑﻂ ﻛﻞ ﻣﺸﺒﻚ ﻣﻦ ﻫﺬﻩ ﺍﳌﺸﺎﺑﻚ ﺍﻟﺜﻤﺎﻧﻴﺔ ﻣﻊ ﻣﺘﺤﻜﻢ ‪PIC‬‬
‫ﻭﻫﻜﺬﺍ ﺳﻴﺘﻮﺍﺟﺪ ‪ ٨‬ﻣﺘﺤﻜﻤﺎﺕ ﺗﺪﻋﻢ ﺣﱴ ‪ ٢٥٦‬ﻣﻘﺎﻃﻌﺔ ﻋﺘﺎﺩﻳﺔ ﳐﺘﻠﻔﺔ‪ .‬ﻭﳚﺐ ﻣﻼﺣﻈﺔ ﺃﻥ ﻣﺘﺤﻜﻢ ﺍﻟﻌﺘﺎﺩ‬
‫ﺍﻟﺬﻱ ﻳﺮﺗﺒﻂ ﺑﺄﻭﻝ ﻣﺸﺒﻚ ‪ IR0‬ﻟﺪﻳﻪ ﺍﻷﻭﻟﻴﺔ ﺍﻷﻭﱃ ﰲ ﺍﻟﺘﻨﻔﻴﺬ ﻭﻫﻜﺬﺍ ﻋﻠﻰ ﺍﻟﺘﻮﺍﱄ‪.‬‬

‫‪PIC‬‬ ‫ﻣﺴﺠﻼﺕ ﻣﺘﺤﻜﻢ‬

‫ﳛﻮﻱ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻋﻠﻰ ﻋﺪﺓ ﻣﺴﺠﻼﺕ ﺩﺍﺧﻠﻴﺔ ﻭﻫﻲ‪:‬‬
‫ﻣﺴﺠﻞ ﺍﻷﻭﺍﻣﺮ )‪ :(Command Reigster‬ﻭﻳﺴﺘﺨﺪﻡ ﻹﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ‪ ،‬ﻭﻫﻨﺎﻙ ﻋﺪﺩ ﻣﻦ‬ ‫•‬
‫ﺍﻷﻭﺍﻣﺮ ﻣﺜﻞ ﺃﻣﺮ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ ﻣﺴﺠﻞ ﻣﺎ ﺃﻭ ﺃﻣﺮ ﺍﺭﺳﺎﻝ ﺍﺷﺎﺭﺓ ‪.EOI‬‬
‫ﻣﺴﺠﻞ ﺍﳊﺎﻟﺔ )‪ :(Status Register‬ﻭﻫﻮ ﻣﺴﺠﻞ ﻟﻠﻘﺮﺍءﺓ ﻓﻘﻂ ﺣﻴﺚ ﺗﻈﻬﺮ ﻋﻠﻴﻪ ﺣﺎﻟﺔ ﺍﳌﺘﺤﻜﻢ‪.‬‬ ‫•‬

‫ﻣﺴﺠﻞ ﻃﻠﺒﺎﺕ ﺍﳌﻘﺎﻃﻌﺎﺕ )‪ :(Interrupt Request Register‬ﳛﻔﻆ ﻫﺬﺍ ﺍﳌﺴﺠﻞ ﺍﻷﺟﻬﺰﺓ ﺍﻟﱵ ﻃﻠﺒﺖ‬ ‫•‬
‫ﺗﻨﻔﻴﺬ ﻣﻘﺎﻃﻌﺘﻬﺎ ﻭﻫﻲ ﺑﺎﻧﺘﻈﺎﺭ ﻭﺻﻮﻝ ﺇﺷﻌﺎﺭ )‪ (Acnowledges‬ﻣﻦ ﺍﳌﻌﺎﰿ ‪ ،‬ﻭﺍﳉﺪﻭﻝ ‪ ٤.٦‬ﻳﻮﺿﺢ ﺑﺘﺎﺕ‬
‫ﻫﺬﺍ ﺍﳌﺴﺠﻞ‪.‬‬

‫‪١٣٥‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫ﺟﺪﻭﻝ ‪ :.٤.٦‬ﻣﺴﺠﻞ ‪IRR/ISR/IMR‬‬

‫)‪IRQ Number (Slave controller) IRQ Number (Primary controller‬‬ ‫‪Bit Number‬‬
‫‪IRQ8‬‬ ‫‪IRQ0‬‬ ‫‪0‬‬
‫‪IRQ9‬‬ ‫‪IRQ1‬‬ ‫‪1‬‬
‫‪IRQ10‬‬ ‫‪IRQ2‬‬ ‫‪2‬‬
‫‪IRQ11‬‬ ‫‪IRQ3‬‬ ‫‪3‬‬
‫‪IRQ12‬‬ ‫‪IRQ4‬‬ ‫‪4‬‬
‫‪IRQ13‬‬ ‫‪IRQ5‬‬ ‫‪5‬‬
‫‪IRQ14‬‬ ‫‪IRQ6‬‬ ‫‪6‬‬
‫‪IRQ15‬‬ ‫‪IRQ7‬‬ ‫‪7‬‬

‫‪PIC‬‬ ‫ﺟﺪﻭﻝ ‪ :.٥.٦‬ﻋﻨﺎﻭﻳﻦ ﺍﳌﻨﺎﻓﺬ ﳌﺘﺤﻜﻢ‬

‫ﺍﻟﻮﺻﻒ‬ ‫ﺭﻗﻢ ﺍﳌﻨﻔﺬ‬
‫‪Primary PIC Command and Status Register‬‬ ‫‪0x20‬‬
‫‪Primary PIC Interrupt Mask Register and Data Register‬‬ ‫‪0x21‬‬
‫‪Secondary (Slave) PIC Command and Status Register‬‬ ‫‪0xA0‬‬
‫‪Secondary (Slave) PIC Interrupt Mask Register and Data Register‬‬ ‫‪0xA1‬‬

‫ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺃﻱ ﺑﺖ ﻫﻲ ‪ ١‬ﻓﻬﺬﺍ ﻳﻌﲏ ﺃﻥ ﻣﺘﺤﻜﻢ ﺍﻟﻌﺘﺎﺩ ﺑﺎﻧﺘﻈﺎﺭ ﺍﻹﺷﻌﺎﺭ ﻣﻦ ﺍﳌﻌﺎﰿ‪.‬‬
‫ﻣﺴﺠﻞ ﺍﳋﺪﻣﺔ ))‪ :(In Service Register (ISR‬ﻳﺪﻝ ﻋﻠﻰ ﺍﳌﺴﺠﻞ ﻋﻠﻰ ﺃﻥ ﻃﻠﺐ ﺍﳌﻘﺎﻃﻌﺔ ﻗﺪ ﳒﺢ ﻭﺃﻥ‬ ‫•‬
‫ﺍﻹﺷﻌﺎﺭ ﻗﺪ ﻭﺻﻞ ﻟﻜﻦ ﱂ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﻣﻦ ﻋﻤﻠﻬﺎ‪.‬‬
‫ﻣﺴﺠﻞ ))‪ :(Interrupt Mask Register (IMR‬ﳛﺪﺩ ﻫﺬﺍ ﺍﳌﺴﺠﻞ ﻣﺎ ﻫﻲ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﳚﺐ ﲡﺎﻫﻠﻬﺎ‬ ‫•‬
‫ﻭﻋﺪﻡ ﺍﺭﺳﺎﻝ ﺇﺷﻌﺎﺭ ﳍﺎ ﻭﺫﻟﻚ ﺣﱴ ﻳﺘﻢ ﺍﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻷﻫﻢ‪.‬‬
‫ﻭﺍﳉﺪﻭﻝ ‪ ٥.٦‬ﻳﻮﺿﺢ ﻋﻨﺎﻭﻳﻦ ﻣﻨﺎﻓﺬ ﺍﳌﺴﺠﻼﺕ ﰲ ﺣﻮﺍﺳﻴﺐ ‪.x86‬‬

‫‪PIC‬‬ ‫ﺑﺮﳎﺔ ﻣﺘﺤﻜﻢ‬

‫ﻟﱪﳎﺔ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﺇﻋﺎﺩﺓ ﺗﺮﻗﻴﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻓﺈﻥ ﺫﻟﻚ ﻳﺘﻄﻠﺐ ﺇﺭﺳﺎﻝ ﺑﻌﺾ ﺍﻷﻭﺍﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﲝﻴﺚ ﺗﺄﺧﺬ‬
‫ﻫﺬﻩ ﺍﻷﻭﺍﻣﺮ ﳕﻂ ﻣﻌﲔ ﺗ‪‬ﺤ‪‬ﺪ‪‬ﺩ ‪‬ﺎ ﻋﻤﻞ ﺍﳌﺘﺤﻜﻢ‪ .‬ﻭﺗﻮﺟﺪ ﺃﺭﻳﻊ ﺃﻭﺍﻣﺮ ‪‬ﻴﺌﺔ ﳚﺐ ﺇﺭﺳﺎﳍﺎ ﻟﺘﻬﻴﺌﺔ ﺍﳌﺘﺤﻜﻢ ﺗﻌﺮﻑ‬
‫ﺏ ‪ Ini aliza on Control Words‬ﻭﲣﺘﺼﺮ ﺑﺄﻭﺍﻣﺮ ‪‬ﻴﺌﺔ ‪ ، ICW‬ﻭﻛﺬﻟﻚ ﺗﻮﺟﺪ ﺛﻼﺙ ﺃﻭﺍﻣﺮ ﲢﻜﻢ ﰲ ﻋﻤﻞ‬
‫ﻣﺘﺤﻜﻢ ‪ PIC‬ﺗﻌﺮﻑ ﺏ ‪ Opera on Control Words‬ﻭﲣﺘﺼﺮ ﺏ ‪ . OCW‬ﻭﰲ ﺣﺎﻟﺔ ﺗﻮﻓﺮ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﺤﻜﻢ‬
‫‪ PIC‬ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ ﻓﻴﺠﺐ ﺃﻥ ﺗ‪‬ﺮﺳﻞ ﺃﻭﺍﻣﺮ ﺍﻟﺘﻬﻴﺌﺔ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﺍﻵﺧﺮ ﻛﺬﻟﻚ‪ .‬ﺍﻷﻣﺮ ﺍﻷﻭﻝ ‪ ICW1‬ﻭﻫﻮ ﺃﻣﺮ ﺍﻟﺘﻬﻴﺌﺔ‬

‫‪١٣٦‬‬
‫‪Programmable Interrupt Controller‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪ICW1‬‬ ‫ﺟﺪﻭﻝ ‪ :.٦.٦‬ﺍﻷﻣﺮ ﺍﻷﻭﻝ‬

‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻮﺻﻒ‬
‫ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ‪ICW4‬‬ ‫‪IC4‬‬ ‫‪0‬‬
‫‪ SNGL‬ﻫﻞ ﻳﻮﺟﺪ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﺍﺣﺪ‬ ‫‪1‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪ADI‬‬ ‫‪2‬‬
‫‪ LTIM‬ﳕﻂ ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺔ‬ ‫‪3‬‬
‫ﺑﺖ ﺍﻟﺘﻬﻴﺌﺔ‬ ‫‪1‬‬ ‫‪4‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪0‬‬ ‫‪5‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪0‬‬ ‫‪6‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪0‬‬ ‫‪7‬‬

‫ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺬﻱ ﳚﺐ ﺇﺭﺳﺎﻟﻪ ﺃﻭﻻ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺜﺎﻧﻮﻱ ﻭﻳﺄﺧﺬ ‪ ٧‬ﺑﺘﺎﺕ ﻭﻳﻮﺿﺢ ﺍﳉﺪﻭﻝ ‪ ٦.٦‬ﻫﺬﻩ‬
‫ﺍﻟﺒﺘﺎﺕ ﻭﻭﻇﻴﻔﺔ ﻛﻞ ﺑﺖ‪.‬‬
‫ﺣﻴﺚ ﺃﻥ ﺍﻟﺒﺖ ﺍﻷﻭﻝ ﳛﺪﺩ ﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﳚﺐ ﺇﺭﺳﺎﻝ ﺃﻣﺮ ﺍﻟﺘﺤﻜﻢ ‪ ICW4‬ﺃﻡ ﻻ ﻭﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﻗﻴﻤﺔ ﺍﻟﺒﺖ ﻫﻲ ‪١‬‬
‫ﻓﺈﻧﻪ ﳚﺐ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ‪ ICW4‬ﺃﻣﺎ ﺍﻟﺒﺖ ﺍﻟﺜﺎﱐ ﻓﻐﺎﻟﺒﴼ ﻳﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﻨﺎﻙ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﺤﻜﻢ‬
‫‪ PIC‬ﰲ ﺍﻟﻨﻈﺎﻡ ‪ ،‬ﻭﺍﻟﺒﺖ ﺍﻟﺜﺎﻟﺚ ﻏﲑ ﻣﺴﺘﺨﺪﻡ ﺃﻣﺎ ﺍﻟﺮﺍﺑﻊ ﻓﻴﺤﺪﺩ ﳕﻂ ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺔ ﻫﻞ ﻫﻲ ‪Level Triggered‬‬
‫‪ Mode‬ﺃﻡ ‪ ، Edge Triggered Mode‬ﺃﻣﺎ ﺍﻟﺒﺖ ﺍﳋﺎﻣﺲ ﻓﻴﺠﺐ ﺃﻥ ﻳﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ‪ ١‬ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻧﻨﺎ ﺳﻨﻘﻮﻡ ﺑﺘﻬﻴﺌﺔ‬
‫ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﺑﻘﻴﺔ ﺍﻟﺒﺘﺎﺕ ﻏﲑ ﻣﺴﺘﺨﺪﻣﺔ ﰲ ﺣﻮﺍﺳﻴﺐ ‪ .x86‬ﻭﺍﻟﺸﻔﺮﺓ ‪ ٦.٥‬ﺗﻮﺿﺢ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ﺍﻷﻭﻝ ﺍﱃ‬
‫ﻣﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺜﺎﻧﻮﻱ‪.‬‬
‫‪Example‬‬ ‫‪٦.٥: Ini‬‬ ‫‪aliza on Control Words 1‬‬
‫‪١‬‬ ‫‪; Setup to initialize the primary PIC. Send ICW 1‬‬
‫‪٢‬‬ ‫‪mov al, 0x11‬‬ ‫‪; 00010001‬‬
‫‪٣‬‬ ‫‪out 0x20, al‬‬
‫‪٤‬‬
‫‪٥‬‬ ‫‪; Send ICW 1 to second PIC command register‬‬
‫‪٦‬‬ ‫‪out 0xA0, al‬‬

‫ﺍﻷﻣﺮ ﺍﻟﺜﺎﱐ ‪ ICW2‬ﻳﺴﺘﺨﺪﻡ ﻹﻋﺎﺩﺓ ﺗﻐﻴﲑ ﻋﻨﻮﺍﻳﻦ ﺟﺪﻭﻝ ‪ IVT‬ﺍﻟﺮﺋﻴﺴﻴﺔ ﻟﻠﻄﻠﺒﺎﺕ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪ IRQ‬ﻭﺑﺎﻟﺘﺎﱄ ﻋﻦ‬
‫ﻃﺮﻳﻖ ﻫﺬﺍ ﺍﻷﻣﺮ ﳝﻜﻦ ﺃﻥ ﻧﻐﲑ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﻟﻞ ‪ IRQ‬ﺍﱃ ﺃﺭﻗﺎﻡ ﺃﺧﺮﻯ ‪ .‬ﻭﳚﺐ ﺃﻥ ﻳﺮﺳﻞ ﻫﺬﺍ ﺍﻷﻣﺮ ﻣﺒﺎﺷﺮﺓ‬
‫ﺑﻌﺪ ﺍﻷﻣﺮ ﺍﻷﻭﻝ ﻛﺬﻟﻚ ﳚﺐ ﺃﻥ ﻳﺘﻢ ﺍﺧﺘﻴﺎﺭ ﺃﺭﻗﺎﻣﺎ ﻏﲑ ﻣﺴﺘﺨﺪﻣﺔ ﻣﻦ ﻗﺒﻞ ﺍﳌﻌﺎﰿ ﺣﱴ ﻻ ﻧﻘﻊ ﰲ ﻧﻔﺲ ﺍﳌﺸﻜﻠﺔ‬
‫ﺍﻟﺴﺎﺑﻘﺔ ) ﻭﻫﻲ ﺃﻛﺜﺮ ﻣﻦ ‪ IRQ‬ﻳﺴﺘﺨﺪﻡ ﻧﻔﺲ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻭﺑﺎﻟﺘﺎﱄ ﻟﺪﻳﻬﻢ ﺩﺍﻟﺔ ﲣﺪﱘ ﻭﺍﺣﺪﺓ(‪ .‬ﻭﺍﳌﺜﺎﻝ ‪٦.٦‬‬
‫ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺗﻐﻴﲑ ﺃﺭﻗﺎﻡ ‪ IRQ‬ﳌﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺜﺎﻧﻮﻱ ﲝﻴﺚ ﻳﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ‪٣٩-٣٢‬‬
‫ﻟﻠﻤﺘﺤﻜﻢ ﺍﻷﻭﻝ ﻭﺍﻷﺭﻗﺎﻡ ﻣﻦ ‪ ٤٧-٤٠‬ﻟﻠﻤﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ ﻭﻫﻲ ﺃﺭﻗﺎﻣﴼ ﺧﺎﻟﻴﺔ ﻻ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﻌﺎﰿ ﻭﺗﻘﻊ ﻣﺒﺎﺷﺮﺓ‬
‫ﺑﻌﺪ ﺁﺧﺮ ﻣﻘﺎﻃﻌﺔ ﻟﻠﻤﻌﺎﰿ ﺍﻟﺬﻱ ﻳﺴﺘﺨﺪﻡ ‪ ٣٢‬ﻣﻘﺎﻃﻌﺔ ﺑﺪءﴽ ﻣﻦ ﺍﻟﺼﻔﺮ ﻭﺍﻧﺘﻬﺎءﴽ ﺑﺎﳌﻘﺎﻃﻌﺔ ‪.٣١‬‬

‫‪١٣٧‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫‪ICW3 for Primary PIC‬‬ ‫ﺟﺪﻭﻝ ‪ :.٧.٦‬ﺍﻷﻣﺮ ﺍﻟﺜﺎﻟﺚ ﻟﻠﻤﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ‬

‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻮﺻﻒ‬
‫‪ S0-S7‬ﺭﻗﻢ ‪ IRQ‬ﺍﻟﱵ ﻳﺘﺼﻞ ‪‬ﺎ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ‬ ‫‪0-7‬‬

‫‪ICW3 for Slave PIC‬‬ ‫ﺟﺪﻭﻝ ‪ :.٨.٦‬ﺍﻷﻣﺮ ﺍﻟﺜﺎﻟﺚ ﻟﻠﻤﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ‬

‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻮﺻﻒ‬
‫‪ ID0‬ﺭﻗﻢ ‪ IRQ‬ﺍﻟﱵ ﻳﺘﺼﻞ ‪‬ﺎ ﻣﻊ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ‬ ‫‪0-2‬‬
‫‪ 3-7‬ﳏﺠﻮﺯﺓ‬ ‫‪3-7‬‬

‫‪Example‬‬ ‫‪٦.٦: Ini‬‬ ‫‪aliza on Control Words 2‬‬

‫‪١‬‬ ‫‪; send ICW 2 to primary PIC‬‬
‫‪٢‬‬ ‫‪mov al, 0x20‬‬
‫‪٣‬‬ ‫‪out 0x21, al‬‬
‫‪٤‬‬ ‫‪; Primary PIC handled IRQ 0..7. IRQ 0 is now mapped to interrupt‬‬
‫‪number 0x20‬‬
‫‪٥‬‬
‫‪٦‬‬
‫‪٧‬‬ ‫‪; send ICW 2 to secondary PIC‬‬
‫‪٨‬‬ ‫‪mov al, 0x28‬‬
‫‪٩‬‬ ‫‪out 0xA1, al‬‬
‫‪١٠‬‬ ‫‪; Secondary PIC handles IRQ's 8..15. IRQ 8 is now mapped to use‬‬
‫‪interrupt 0x28‬‬

‫ﺍﻷﻣﺮ ﺍﻟﺜﺎﻟﺚ ‪ ICW3‬ﻳﺴﺘﺨﺪﻡ ﰲ ﺣﺎﻟﺔ ﻛﺎﻥ ﻫﻨﺎﻙ ﺃﻛﺜﺮ ﻣﻦ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺣﻴﺚ ﳚﺐ ﺃﻥ ﳓﺪﺩ ﺭﻗﻢ ﻃﻠﺐ‬
‫ﺍﳌﻘﺎﻃﻌﺔ ‪ IRQ‬ﺍﻟﱵ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ ﻟﻠﺘﺨﺎﻃﺐ ﻣﻊ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ‪ .‬ﻭﰲ ﺣﻮﺍﺳﻴﺐ ‪ x86‬ﻏﺎﻟﺒﴼ ﻣﺎ‬
‫ﻳﺴﺘﺨﺪﻡ ‪ IRQ2‬ﻟﺬﺍ ﳚﺐ ﺇﺭﺳﺎﻝ ﻫﺬﺍ ﺍﻷﻣﺮ ﺍﱃ ﺍﳌﺘﺤﻜﻢ‪ ،‬ﻟﻜﻦ ﻛﻞ ﻣﺘﺤﻜﻢ ﻳﺘﻮﻗﻊ ﺍﻷﻣﺮ ﺑﺼﻴﻐﺔ ﻣﻌﻴﻨﺔ ﻳﻮﺿﺤﻬﺎ‬
‫ﺍﳉﺪﻭﻻﻥ ‪ ٧.٦‬ﻭ ‪. ٨.٦‬‬
‫ﻭﳚﺐ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ﲝﺴﺐ ﺍﻟﺼﻴﻐﺔ ﺍﻟﱵ ﻳﻘﺒﻠﻬﺎ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻟﻠﻤﺘﺤﻜﻢ ‪ ،‬ﻓﻤﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻲ ﻳﺴﺘﻘﺒﻞ‬
‫ﺭﻗﻢ ‪ IRQ‬ﻋﻠﻰ ﺷﻜﻞ ‪ ٧‬ﺑﺖ ﲝﻴﺚ ﻳﺘﻢ ﺗﻔﻌﻴﻞ ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﳌﻘﺎﺑﻞ ﻟﺮﻗﻢ ‪ IRQ‬ﻭﰲ ﻣﺜﺎﻟﺜﺎ ﻳﺮﺗﺒﻂ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺮﺋﻴﺴﻲ‬
‫ﻣﻊ ﺍﻟﺜﺎﻧﻮﻱ ﻋﱪ ‪ IRQ2‬ﻟﺬﻟﻚ ﳚﺐ ﺗﻔﻌﻴﻞ ﻗﻴﻤﺔ ﺍﻟﺒﺖ ‪) ٢‬ﺃﻱ ﳚﺐ ﺇﺭﺳﺎﻝ ﺍﻟﻘﻴﻤﺔ ‪ 0000100b‬ﻭﻫﻲ ﺗﻌﺎﺩﻝ ‪(0x4‬‬
‫ﺑﻴﻨﻤﺎ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺜﺎﻧﻮﻱ ﻳﻘﺒﻞ ﺭﻗﻢ ‪ IRQ‬ﻋﻦ ﻃﺮﻳﻖ ﺇﺭﺳﺎﻝ ﻗﻴﻤﺘﻪ ﻋﻠﻰ ﺍﻟﺸﻜﻞ ﺍﻟﺜﻨﺎﺋﻲ ﻭﻫﻲ ‪) ٢‬ﻭﺗﻌﺎﺩﻝ ﺑﺎﻟﺘﺮﻣﻴﺰ‬
‫ﺍﻟﺜﻨﺎﺋﻲ ‪ (010‬ﻭﺑﻘﻴﺔ ﺍﻟﺒﺘﺎﺕ ﳏﺠﻮﺯﺓ )ﺍﻧﻈﺮ ﺟﺪﻭﻝ ‪ ، (٨.٦‬ﻭﺍﳌﺜﺎﻝ ‪ ٦.٧‬ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ﺍﻟﺜﺎﻟﺚ ﺍﱃ‬
‫ﺍﳌﺘﺤﻜﻤﲔ‪.‬‬
‫‪Example‬‬ ‫‪٦.٧: Ini‬‬ ‫‪aliza on Control Words 3‬‬

‫‪١٣٨‬‬
‫‪Programmable Interrupt Controller‬‬ ‫‪ .٢.٦‬ﻣﺘﺤﻜﻢ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﻘﺎﺑﻞ ﻟﻠﱪﳎﺔ‬

‫‪ICW4‬‬ ‫ﺟﺪﻭﻝ ‪ :.٩.٦‬ﺍﻷﻣﺮ ﺍﻟﺮﺍﺑﻊ‬

‫ﺍﻟﻮﺻﻒ‬ ‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﻟﻘﻴﻤﺔ‬
‫ﳚﺐ ﺗﻔﻌﻴﻞ ﻫﺬﺍ ﺍﻟﺒﺖ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪uPM‬‬ ‫‪0‬‬
‫ﺟﻌﻞ ﺍﳌﺘﺤﻜﻢ ﻳﻘﻮﻡ ﺑﺈﺭﺳﺎﻝ ﺇﺷﺎﺭﺓ ‪EOI‬‬ ‫‪AEOI‬‬ ‫‪1‬‬
‫‪If set (1), selects buffer master. Cleared if buffer slave.‬‬ ‫‪M/S‬‬ ‫‪2‬‬
‫‪If set, controller operates in buffered mode‬‬ ‫‪BUF‬‬ ‫‪3‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪SFNM‬‬ ‫‪4‬‬
‫ﺗﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺣﻮﺍﺳﻴﺐ ‪x86‬‬ ‫‪0‬‬ ‫‪5-7‬‬

‫‪١‬‬ ‫‪; Send ICW 3 to primary PIC‬‬

‫‪٢‬‬ ‫‪mov al, 0x4‬‬ ‫)‪; 0x04 => 0100, second bit (IR line 2‬‬
‫‪٣‬‬ ‫‪out 0x21, al ; write to data register of primary PIC‬‬
‫‪٤‬‬
‫‪٥‬‬ ‫‪; Send ICW 3 to secondary PIC‬‬
‫‪٦‬‬ ‫‪mov al, 0x2‬‬ ‫‪; 010=> IR line 2‬‬
‫‪٧‬‬ ‫‪out 0xA1, al ; write to data register of secondary PIC‬‬

‫ﻫﻮ ﺁﺧﺮ ﺃﻣﺮ ﲢﻜﻢ ﳚﺐ ﺇﺭﺳﺎﻟﻪ ﺍﱃ ﺍﳌﺘﺤﻜﻤﲔ ﻭﻳﺄﺧﺬ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﱵ ﻳﻮﺿﺤﻬﺎ ﺟﺪﻭﻝ‬ ‫ﺍﻷﻣﺮ ﺍﻟﺮﺍﺑﻊ‬
‫‪ICW4‬‬
‫‪.٩.٦‬‬
‫ﻭﰲ ﺍﻟﻐﺎﻟﺐ ﻻ ﻳﻮﺟﺪ ﺣﻮﺟﺔ ﻟﺘﻔﻌﻴﻞ ﻛﻞ ﻫﺬﻩ ﺍﳋﺼﺎﺋﺺ ‪ ،‬ﻓﻘﻂ ﺃﻭﻝ ﺑﺖ ﳚﺐ ﺗﻔﻌﻴﻠﻪ ﺣﻴﺚ ﻳﺴﺘﺨﺪﻡ ﻣﻊ‬
‫ﺣﻮﺍﺳﻴﺐ ‪ . x86‬ﻭﺍﳌﺜﺎﻝ ‪ ٦.٨‬ﻳﻮﺿﺢ ﻛﻴﻔﺔ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ﺍﻟﺮﺍﺑﻊ ﺍﱃ ﺍﳌﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺜﺎﻧﻮﻱ‪.‬‬
‫‪Example‬‬ ‫‪٦.٨: Ini‬‬ ‫‪aliza on Control Words 4‬‬
‫‪١‬‬ ‫‪mov al, 1‬‬ ‫‪; bit 0 enables 80x86 mode‬‬
‫‪٢‬‬
‫‪٣‬‬ ‫‪; send ICW 4 to both primary and secondary PICs‬‬
‫‪٤‬‬ ‫‪out 0x21, al‬‬
‫‪٥‬‬ ‫‪out 0xA1, al‬‬

‫ﻭﺑﻌﺪ ﺇﺭﺳﺎﻝ ﻫﺬﻩ ﺍﻷﻭﺍﻣﺮ ﺍﻷﺭﺑﻊ ﺗﻜﺘﻤﻞ ﻋﻤﻠﻴﺔ ‪‬ﻴﺌﺔ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺮﺋﻴﺴﻲ ﻭﺍﻟﺜﺎﻧﻮﻱ ‪ ،‬ﻭﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ ﺃﻱ‬
‫ﻣﻘﺎﻃﻌﺔ ﻣﻦ ﻣﺘﺤﻜﻢ ﻟﻌﺘﺎﺩ ﻣﺎ ‪ ،‬ﻓﺈﻥ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻟﱵ ﺳﺘﺮﺳﻞ ﺍﱃ ﺍﳌﻌﺎﰿ ﻫﻲ ﺍﻷﺭﻗﺎﻡ ﺍﻟﱵ ﻗﻤﻨﺎ ﺑﺘﻌﻴﻴﻨﻬﺎ ﰲ‬
‫ﺍﻷﻣﺮ ﺍﻟﺜﺎﱐ )ﻭﺗﺒﺪﺃ ﻣﻦ ‪ ٣٢‬ﺍﱃ ‪ (٤٧‬ﻭﻫﻲ ﲣﺘﻠﻒ ﺑﺎﻟﻄﺒﻊ ﻋﻦ ﺍﻷﺭﻗﺎﻡ ﺍﻟﱵ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﳌﻌﺎﰿ‪ .‬ﻭﲞﺼﻮﺹ ﺃﻭﺍﻣﺮ‬
‫ﺍﻟﺘﺤﻜﻢ ﺍﻟﺜﻼﺙ ‪ OCW‬ﻓﻠﻦ ﳓﺘﺎﺝ ﺍﻟﻴﻬﺎ ﲨﻴﻌﴼ ﻭﺳﻴﺘﻢ ﺍﳊﺪﻳﺚ ﻋﻦ ﺍﻷﻣﺮ ﺍﻟﺜﺎﱐ ‪ OCW2‬ﻧﻈﺮﴽ ﻷﻧﻪ ﳚﺐ ﺃﻥ ﻳ‪‬ﺮﺳﻞ‬
‫ﺩﺍﺋﻤﴼ ﺑﻌﺪ ﺃﻥ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﻣﻦ ﻋﻤﻠﻬﺎ ﻭﺫﻟﻚ ﺣﱴ ﻳﺘﻢ ﺍﻟﺴﻤﺎﺡ ﻟﺒﻘﻴﺔ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺃﻥ ﺗﺄﺧﺬ ﺩﻭﺭﴽ‬
‫ﳌﻌﺎﳉﺘﻬﺎ‪ .‬ﻭﺍﳉﺪﻭﻝ ‪ ١٠.٦‬ﻳﻮﺿﺢ ﺍﻟﺒﺘﺎﺕ ﺍﻟﱵ ﳚﺐ ﺇﺭﺳﺎﳍﺎ ﺍﱃ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ ‪ .‬ﻭﻳﻬﻤﻨﺎ ﺍﻟﺒﺘﺎﺕ ‪ ٧-٥‬ﺣﻴﺚ‬
‫ﺃﻥ ﻗﻴﻤﻬﻢ ﲢﺪﺩ ﺑﻌﺾ ﺍﳋﺼﺎﺋﺺ ﺍﻟﱵ ﻳﻮﺿﺤﻬﺎ ﺍﳉﺪﻭﻝ ‪ .١١.٦‬ﻭﺍﳌﺜﺎﻝ ‪ ٦.٩‬ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺇﺭﺳﺎﻝ ﺇﺷﺎﺭﺓ ‪‬ﺎﻳﺔ‬

‫‪١٣٩‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫‪OCW2‬‬ ‫ﺟﺪﻭﻝ ‪ :.١٠.٦‬ﺃﻣﺮ ﺍﻟﺘﺤﻜﻢ ﺍﻟﺜﺎﱐ‬

‫ﺍﻟﻮﺻﻒ‬ ‫ﺭﻗﻢ ﺍﻟﺒﺖ ﺍﻟﻘﻴﻤﺔ‬
‫‪Interrupt level upon which the controller must react‬‬ ‫‪L0/L1/L2‬‬ ‫‪0-2‬‬
‫ﳏﺠﻮﺯﺓ‬ ‫‪0‬‬ ‫‪3-4‬‬
‫)‪End of Interrupt (EOI‬‬ ‫‪EOI‬‬ ‫‪5‬‬
‫‪Selec on‬‬ ‫‪SL‬‬ ‫‪6‬‬
‫‪Rota on op on‬‬ ‫‪R‬‬ ‫‪7‬‬

‫‪OCW2‬‬ ‫ﺟﺪﻭﻝ ‪ :.١١.٦‬ﺃﻣﺮ‬

‫‪Descrip on‬‬ ‫‪EOI Bit‬‬ ‫‪SL Bit‬‬ ‫‪R Bit‬‬
‫)‪Rotate in Automa c EOI mode (CLEAR‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪Non specific EOI command‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪No opera on‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪Specific EOI command‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫)‪Rotate in Automa c EOI mode (SET‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪Rotate on non specific EOI‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪Set priority command‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪Rotate on specific EOI‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬

‫ﻋﻤﻞ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ )‪ (EOI‬ﺣﻴﺚ ﳚﺐ ﺿﺒﻂ ﺍﻟﺒﺘﺎﺕ ﻹﺧﺘﻴﺎﺭ ‪.Non specific EOI command‬‬
‫‪Example‬‬ ‫‪٦.٩: Send EOI‬‬
‫‪١‬‬ ‫‪; send EOI to primary PIC‬‬
‫‪٢‬‬
‫‪٣‬‬ ‫‪mov al, 0x20‬‬ ‫‪; set bit 4 of OCW 2‬‬
‫‪٤‬‬ ‫‪out 0x20, al‬‬ ‫‪; write to primary PIC command register‬‬

‫ﻛﻴﻒ ﺗﻌﻤﻞ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﻌﺘﺎﺩ‬

‫ﻋﻨﺪﻣﺎ ﳛﺘﺎﺝ ﻣﺘﺤﻜﻢ ﺃﻱ ﻋﺘﺎﺩ ﻟﻔﺖ ﺍﻧﺘﺒﺎﻩ ﺍﳌﻌﺎﰿ ﺍﱃ ﺷﻲء ﻣﺎ ﻓﺄﻭﻝ ﺧﻄﻮﺓ ﻳﻘﻮﻡ ‪‬ﺎ ﻫﻲ ﺇﺭﺳﺎﻝ ﺇﺷﺎﺭﺓ ﺍﱃ‬
‫ﻣﺘﺤﻜﻢ ‪) PIC‬ﻭﻋﻠﻰ ﺳﺒﻴﻞ ﺍﳌﺜﺎﻝ ﺳﻨﻔﺮﺽ ﺃﻥ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﻫﻮ ﻣﺘﺤﻜﻢ ﺍﳌﺆﻗﺘﺔ ‪ PIT‬ﻭﺍﻟﱵ ﺗﺮﺗﺒﻂ ﺑﺎﳌﺸﺒﻚ ‪(IR0‬‬
‫ﻫﺬﻩ ﺍﻹﺷﺎﺭﺓ ﺗﺮﺳﻞ ﻋﱪ ﻣﺸﺒﻚ ‪ ، IR0‬ﺣﻴﻨﻬﺎ ﻳﻘﻮﻡ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺑﺘﺴﺠﻴﻞ ﻃﻠﺐ ﺍﳌﺘﺤﻜﻢ ‪ IRQ‬ﰲ ﻣﺴﺠﻞ ﻳﺴﻤﻰ‬
‫ﻣﺴﺠﻞ ﻃﻠﺒﺎﺕ ﺍﳌﻘﺎﻃﻌﺎﺕ )‪ (Interrupt Request Register‬ﻭﻳﻌﺮﻑ ﺍﺧﺘﺼﺎﺭﴽ ﲟﺴﺠﻞ ‪ . IRR‬ﻫﺬﺍ ﺍﳌﺴﺠﻞ‬
‫ﺑﻄﻮﻝ ‪ ٨‬ﺑﺖ ﻛﻞ ﺑﺖ ﻓﻴﻪ ﳝﺜﻞ ﺭﻗﻢ ‪ IRQ‬ﻭﻳﺘﻢ ﺗﻔﻌﻴﻞ ﺃﻱ ﺑﺖ ﻋﻨﺪ ﻃﻠﺐ ﻣﻘﺎﻃﻌﺔ ﻣﻦ ﺍﳌﺘﺤﻜﻢ ‪ ،‬ﻭﰲ ﻣﺜﺎﻟﻨﺎ‬
‫ﺳﻴﺘﻢ ﺗﻔﻌﻴﻞ ﺍﻟﺒﺖ ‪ 0‬ﺑﺴﺒﺐ ﺃﻥ ﺍﳌﺆﻗﺘﺔ ﺗﺮﺗﺒﻂ ﻣﻊ ‪ .IR0‬ﺑﻌﺪ ﺫﻟﻚ ﻳﻘﻮﻡ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺑﻔﺤﺺ ﻣﺴﺠﻞ ‪Interrupt‬‬

‫‪١٤٠‬‬
‫‪Programmable Interval Timer‬‬ ‫‪ .٣.٦‬ﺍﳌﺆﻗﺘﺔ‬

‫‪ Mask Register‬ﻟﻴﺘﺄﻛﺪ ﻣﻦ ﺃﻧﻪ ﻻ ﺗﻮﺟﺪ ﻫﻨﺎﻙ ﻣﻘﺎﻃﻌﺔ ﺫﺍﺕ ﺃﻭﻟﻴﺔ ﺃﻋﻠﻰ ﺣﻴﺚ ﰲ ﻫﺬﻩ ﺍﳊﺎﻟﺔ ﻋﻠﻰ ﺍﳌﻘﺎﻃﻌﺔ‬
‫ﺍﳉﺪﻳﺪﺓ ﺃﻥ ﺗﻨﻨﻈﺮ ﺣﱴ ﻳﺘﻢ ﲣﺪﱘ ﻛﻞ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺫﺍﺕ ﺍﻷﻭﻟﻮﻳﺔ‪ .‬ﻭﺑﻌﺪ ﺫﻟﻚ ﻳ‪‬ﺮﺳﻞ ‪ PIC‬ﺇﺷﺎﺭﺓ ﺍﱃ ﺍﳌﻌﺎﰿ ﻣﻦ‬
‫ﺧﻼﻝ ﻣﺸﺒﻚ ‪ INTA‬ﻷﺧﺒﺎﺭ ﺍﳌﻌﺎﰿ ﺑﺄﻥ ﻫﻨﺎﻙ ﻣﻘﺎﻃﻌﺔ ﳚﺐ ﺗﻨﻔﻴﺬﻫﺎ‪ .‬ﻭﻫﻨﺎ ﻳﺄﰐ ﺩﻭﺭ ﺍﳌﻌﺎﰿ ﺣﻴﺚ ﻳﻘﻮﻡ ﺑﺎﻹﻧﺘﻬﺎء‬
‫ﻣﻦ ﺗﻨﻔﻴﺬ ﺍﻷﻣﺮ ﺍﳊﺎﱄ ﺍﻟﺬﻱ ﻳﻌﻤﻞ ﻋﻠﻴﻪ ﻭﻣﻦ ﰒ ﻳﻘﻮﻡ ﺑﻔﺤﺺ ﻗﻴﻤﺔ ﺍﻟﻌﻠﻢ ‪ IF‬ﺣﻴﺚ ﰲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ ﻏﲑ ﻣﻔﻌﻠﺔ‬
‫ﻓﺎﻥ ﺍﳌﻌﺎﰿ ﺳﻮﻑ ﻳﺘﺠﺎﻫﻞ ﻃﻠﺐ ﺗﻨﻔﻴﺬ ﺍﳌﻘﺎﻃﻌﺔ‪ ،‬ﺃﻣﺎ ﺇﺫﺍ ﻭﺟﺪ ﺍﳌﻌﺎﰿ ﻗﻴﻤﺔ ﺍﻟﻌﻠﻢ ﻣﻔﻌﻠﺔ ﻓﺎﻧﻪ ﻳﻘﻮﻡ ﺑﺎﺭﺳﺎﻝ ﺇﺷﻌﺎﺭ‬
‫)‪ (Acnowledges‬ﻋﱪ ﻣﺸﺒﻚ ‪ INTR‬ﺍﱃ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﺬﻱ ﺑﺪﻭﺭﻩ ﻳﺴﺘﻘﺒﻠﻬﺎ ﻣﻦ ﻣﺸﺒﻚ ‪ INTA‬ﻭﻳﻀﻊ ﺭﻗﻢ‬
‫ﺍﳌﻘﺎﻃﻌﺔ ﻭﺭﻗﻢ ‪ IRQ‬ﰲ ﺍﳌﺸﺎﺑﻚ ‪ ، D0-D7‬ﻭﺃﺧﲑﺍ ﻳﻔﻌﻞ ﻗﻴﻤﺔ ﺍﻟﺒﺖ ‪ ٠‬ﰲ ﻣﺴﺠﻞ ‪ In Service Register‬ﺩﻻﻟﺔ‬
‫ﻋﻠﻰ ﺃﻥ ﻣﻘﺎﻃﻌﺔ ﺍﳌﺆﻗﺘﺔ ﺟﺎﺭﻱ ﺗﻨﻔﻴﺬﻫﺎ‪ .‬ﻭﻋﻨﺪﻣﺎ ﳛﺼﻞ ﺍﳌﻌﺎﰿ ﻋﻠﻰ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻓﺎﻧﻪ ﻳﻘﻮﻡ ﺑﻮﻗﻒ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﱵ‬
‫ﻳﻌﻤﻞ ﻋﻠﻴﻬﺎ ﻭﳛﻔﻆ ﻗﻴﻢ ﻣﺴﺠﻞ ﺍﻷﻋﻼﻡ ﻭﻣﺴﺠﻞ ‪ CS and EIP‬ﻭﺇﺫﺍ ﻛﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ﻓﺈﻧﻪ‬
‫ﻳﺄﺧﺬ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻭﻳﺬﻫﺐ ‪‬ﺎ ﻛﺪﻟﻴﻞ ﺍﱃ ﺟﺪﻭﻝ ﺍﳌﻘﻄﺎﻋﺎﺕ ‪ IVT‬ﺣﻴﺚ ﳚﺪ ﻋﻨﻮﺍﻥ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﻭﻣﻦ ﰒ‬
‫ﻳﻨﻘﻞ ﺍﻟﺘﻨﻔﻴﺬ ﺍﻟﻴﻬﺎ ‪ ،‬ﺃﻣﺎ ﺍﺫﺍ ﻛﺎﻥ ﺍﳌﻌﺎﰿ ﻳﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ ﻓﺎﻧﻪ ﻳﺄﺧﺬ ﺭﻗﻢ ﺍﳌﻘﺎﻃﻌﺔ ﻭﻳﺬﻫﺐ ‪‬ﺎ ﺍﱃ ﺟﺪﻭﻝ‬
‫ﻭﺍﺻﻔﺎﺕ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺣﻴﺚ ﳚﺪ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ‪ .‬ﻭﻋﻨﺪﻣﺎ ﺗﻨﺘﻬﻲ ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺔ ﻣﻦ ﻋﻤﻠﻬﺎ ﻓﺎ‪‬ﺎ ﳚﺐ‬
‫ﺃﻥ ﺗﺮﺳﻞ ﺇﺷﺎﺭﺓ ‪ EOI‬ﺣﱴ ﻳﺘﻢ ﺗﻔﻌﻴﻞ ﺍﳌﻘﺎﻃﻌﺎﺕ ﳎﺪﺩﴽ‪.‬‬

‫‪Programmable Interval Timer‬‬ ‫‪ .٣.٦‬ﺍﳌﺆﻗﺘﺔ‬

‫ﺍﳌﺆﻗﺘﺔ ﻫﻲ ﺷﺮﳛﺔ )‪ Dual Inline Package (DIP‬ﲢﻮﻱ ﺛﻼﺙ ﻋﺪﺍﺩﺍﺕ )‪ (Counters or Channels‬ﺗﻌﻤﻞ‬
‫ﻛﻤﺆﻗﺘﺎﺕ ﻹﺩﺍﺭﺓ ﺛﻼﺙ ﺃﺷﻴﺎء )ﺍﻧﻈﺮ ﺍﻟﺸﻜﻞ ‪ .(٣.٦‬ﺍﻟﻌﺪﺍﺩ ﺍﻷﻭﻝ ﻭﻳُﻌﺮﻑ ﲟﺆﻗﺖ ﺍﻟﻨﻈﺎﻡ )‪(System Timer‬‬
‫ﻭﻇﻴﻔﺘﻪ ﺍﺭﺳﺎﻝ ﻃﻠﺐ ﻣﻘﺎﻃﻌﺔ )‪ (IRQ0‬ﺍﱃ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﺫﻟﻚ ﻟﺘﻨﻔﻴﺬ ﻣﻘﺎﻃﻌﺔ ﻣﺎ ﻛﻞ ﻓﺘﺮﺓ ﳏﺪﺩﺓ ‪ ،‬ﻫﺬﻩ ﺍﻟﻔﺘﺮﺓ‬
‫ﻳﺘﻢ ﲢﺪﻳﺪﻫﺎ ﻋﻨﺪ ﺑﺮﳎﺔ ﻫﺬﻩ ﺍﳌﺆﻗﺘﺔ ﻭﻳُﺴﺘﻔﺎﺩ ﻣﻦ ﻫﺬﻩ ﺍﳌﺆﻗﺘﺔ ﰲ ﻋﻤﻠﻴﺔ ﺗﺰﺍﻣﻦ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻭﺗﻮﻓﲑ ﺑﻨﻴﺔ ﲢﺘﻴﺔ ﳌﻔﻬﻮﻡ‬
‫ﺗﻌﺪﺩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻭﺍﳌﺴﺎﻟﻚ )‪ (Mul task and Mul thread‬ﺣﻴﺚ ﺃﻥ ﺍﻟﻔﺘﺮﺓ ﺍﻟﱵ ﺗﻘﻮﻡ ‪‬ﺎ ﻣﺆﻗﺘﺔ ﺍﻟﻨﻈﺎﻡ ﻻﺻﺪﺍﺭ‬
‫ﻃﻠﺐ ﺍﳌﻘﺎﻃﻌﺔ ﺳﻴﻜﻮﻥ ﻫﻮ ﺍﻟﻮﻗﺖ ﺍﳌﺤﺪﺩ ﻷﻱ ﻋﻤﻠﻴﺔ )‪ (Process‬ﻣﻮﺟﻮﺩﺓ ﰲ ﻃﺎﺑﻮﺭ ﺍﻟﻌﻤﻠﻴﺎﺕ )‪Process‬‬
‫‪ (Queue‬ﻭﺑﻌﺪ ﺫﻟﻚ ﺗﺮُﺳﻞ ﺍﻟﻌﻤﻠﻴﺔ ﺍﱃ ﺁﺧﺮ ﺍﻟﺼﻒ ﰲ ﺣﺎﻟﺔ ﱂ ﺗﻨﺘﻬﻲ ﻣﻦ ﻋﻤﻠﻬﺎ ﺑﻌﺪ ﻭﻳﺒﺪﺃ ﺍﳌﻌﺎﰿ ﰲ ﺗﻨﻔﻴﺬ‬
‫ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺘﺎﻟﻴﺔ ﲢﺖ ﻧﻔﺲ ﺍﻟﻔﺘﺮﺓ ﺍﳌﺤﺪﺩﺓ‪ .‬ﺃﻣﺎ ﺍﻟﻌﺪﺍﺩ ﺍﻟﺜﺎﱐ ﻓﻴُﺴﺘﺨﺪﻡ ﰲ ﻋﻤﻠﻴﺔ ﺗﻨﻌﻴﺶ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ‬
‫)‪ (RAM refreshing‬ﺣﱴ ﲢﺎﻓﻆ ﻋﻠﻰ ﳏﺘﻮﻳﺎ‪‬ﺎ ﻣﻦ ﺍﻟﻔﻘﺪﺍﻥ ﺃﺛﻨﺎء ﻋﻤﻞ ﺍﳊﺎﺳﺐ ﻭﳚﺪﺭ ﺑﻨﺎ ﺫﻛﺮ ﺃﻥ ﻫﺬﻩ ﺍﳌﻬﻤﺔ‬
‫ﻗﺪ ﺃﹸﺣﻴﻠﺖ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ )‪ (Memory Controller‬ﻭﺃﺻﺒﺤﺖ ﻫﺬﻩ ﺍﳌﺆﻗﺘﺔ ﻻ ﺗﺴﺘﺨﺪﻡ ﰲ ﺍﻟﻌﺎﺩﺓ‪ .‬ﺃﻣﺎ‬
‫ﺍﻟﻌﺪﺍﺩ ﺍﻷﺧﲑ ﻓﻴﺴﺘﺨﺪﻡ ﰲ ﻋﻤﻠﻴﺔ ﺇﺭﺳﺎﻝ ﺍﻟﺼﻮﺕ ﺍﱃ ﲰﺎﻋﺎﺕ ﺍﳊﺎﺳﺐ ‪.(PC Speaker) ٧‬‬

‫‪٧‬ﻻ ﻳ‪‬ﻘﺼﺪ ‪‬ﺬﻩ ﻛﺮﺕ ﺍﻟﺼﻮﺕ ﻭﺇﳕﺎ ﻳﻮﺟﺪ ﰲ ﻛﻞ ﺣﺎﺳﺐ ﲰﺎﻋﺎﺕ ﺩﺍﺧﻠﻴﺔ ﺗﺴﺘﺨﺪﻡ ﰲ ﺇﺻﺪﺍﺭ ﺍﻟﺼﻮﺕ ﻭﺍﻟﻨﻐﻤﺎﺕ ﻭﺃﺣﺪ ﺍﺳﺘﺨﺪﺍﻣﺎ‪‬ﺎ‬
‫ﻹﺻﺪﺍﺭ ﺭﺳﺎﺋﻞ ﺍﳋﻄﺄ ﺑﻌﺪ ﻋﻤﻠﻴﺔ ﻓﺤﺺ ﺍﳊﺎﺳﺐ )‪ (POST‬ﰲ ﻣﺮﺣﻠﺔ ﺍﻹﻗﻼﻉ‪.‬‬

‫‪١٤١‬‬
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫‪8253‬‬ ‫ﺷﻜﻞ ‪ :.٣.٦‬ﺍﳌﺆﻗﺘﺔ ﺍﻟﻘﺎﺑﻠﺔ ﻟﻠﱪﳎﺔ‬

‫‪PIT‬‬ ‫‪ .١.٣.٦‬ﺑﺮﳎﺔ ﺍﳌﺆﻗﺘﺔ‬

‫ﻣﺆﺧﺮﺍ ﰎ ﻧﻘﻞ ﺍﳌﺆﻗﺘﺔ ﻣﻦ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ )‪ (MotherBoard‬ﻛﺸﺮﳛﺔ ‪ DIP‬ﻣﺴﺘﻠﻘﺔ ﺍﱃ ﺍﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ )‪.(SouthBridge‬‬
‫ﻭﺳﻮﻑ ﻧﺮﻛﺰ ﻋﻠﻰ ﺑﺮﳎﺔ ﺍﻟﻌﺪﺍﺩ ﺍﻷﻭﻝ ﻭﻫﻮ ﻣﺆﻗﺖ ﺍﻟﻨﻈﺎﻡ ﺣﻴﺚ ﺃﻧﻪ ﻳﻮﻓﺮ ﺍﻟﺪﻋﻢ ﺍﻟﻌﺘﺎﺩﻱ ﺍﻟﻼﺯﻡ ﻟﻠﻨﻈﺎﻡ ﺣﱴ‬
‫ﻳﺪﻋﻢ ﺗﻌﺪﺩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻭﺍﳌﺴﺎﻟﻚ‪.‬‬

‫‪PIT's Pins‬‬ ‫ﻣﺸﺎﺑﻚ ﺍﳌﺆﻗﺘﺔ‬

‫ﺗ‪‬ﺮﺳَﻞ ﺍﻷﻭﺍﻣﺮ ﻭﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﱃ ﺍﳌﺆﻗﺘﺔ ﻭﺫﻟﻚ ﻋﱪ ﻣﺴﺎﺭ‬
‫ﺍﻟﺒﻴﺎﻧﺎﺕ )‪ (Data Bus‬ﺣﻴﺚ ﻳﺮﺗﺒﻂ ﻫﺬﺍ ﺍﳌﺴﺎﺭ ﻣﻊ‬
‫ﻣﺸﺎﺑﻚ ﺍﻟﺒﻴﺎﻧﺎﺕ ﰲ ﺍﳌﺆﻗﺘﺔ ﻭﻫﻲ ‪ ٨‬ﻣﺸﺎﺑﻚ ‪D0...D7‬‬
‫ﻭﺗُﻤﺜﻞ ‪ ٨‬ﺑﺘﺎﺕ‪ .‬ﻭﻋﻨﺪ ﺇﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ ﺍﱃ ﺍﳌﺆﻗﺘﺔ‬
‫)ﻋﻤﻠﻴﺔ ﻛﺘﺎﺑﺔ( ﻓﺎﻥ ﻣﺸﺒﻚ ﺍﻟﻜﺘﺎﺑﺔ ‪ WR‬ﻳﺄﺧﺬ ﻗﻴﻤﺔ‬
‫ﻣﻨﺨﻔﻀﺔ ﺩﻻﻟﺔ ﻋﻠﻰ ﺃﻥ ﻫﻨﺎﻙ ﻋﻤﻠﻴﺔ ﺇﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ‬
‫ﺍﱃ ﺍﳌﺆﻗﺘﺔ ﻭﻛﺬﻟﻚ ﰲ ﺣﺎﻟﺔ ﻗﺮﺍءﺓ ﺑﻴﺎﻧﺎﺕ ﻣﻦ ﺍﳌﺆﻗﺘﺔ‬
‫ﻓﺈﻥ ﻣﺸﺒﻚ ﺍﻟﻘﺮﺍءﺓ ‪ RD‬ﻳﺄﺧﺬ ﻗﻴﻤﺔ ﻣﻨﺨﻔﻀﺔ ﺩﻻﻟﺔ‬
‫ﺷﻜﻞ ‪ :.٤.٦‬ﻣﺸﺎﺑﻚ ﺍﳌﺆﻗﺘﺔ ‪PIT‬‬ ‫ﻋﻠﻰ ﺃﻥ ﻫﻨﺎﻙ ﻋﻤﻠﻴﺔ ﻗﺮﺍءﺓ ﻣﻦ ﺍﳌﺆﻗﺘﺔ‪ .‬ﻭﻳﺘﺤﻜﻢ ﰲ‬
‫ﻣﺸﺒﻚ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﺸﺒﻚ ‪ CS‬ﺣﻴﺚ ﲢﺪﺩ ﻗﻴﻤﺘﻪ‬
‫ﺗﻌﻄﻴﻞ ﺃﻭ ﺗﻔﻌﻴﻞ ﻋﻤﻞ ﺍﻟﺸﺒﻜﲔ ﺍﻟﺴﺎﺑﻘﲔ ‪ ،‬ﻭﻳﺮﺗﺒﻂ ﻣﺸﺒﻚ ‪ CS‬ﻣﻊ ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ )‪ (Address Bus‬ﺑﻴﻨﻤﺎ ﻳﺮﺗﺒﻂ‬
‫ﻣﺸﺒﻚ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﻊ ﻣﺴﺎﺭ ﺍﻟﺘﺤﻜﻢ )‪ .(Control Bus‬ﻭﺗُﺤﺪﺩ ﻗﻴﻤﺔ ﺍﳌﺸﺒﻜﲔ ‪- A0,A1‬ﻭﺍﻟﻠﺬﺍﻥ ﻳﺮﺗﺒﻄﺎﻥ‬
‫ﻣﻊ ﻣﺴﺎﺭ ﺍﻟﻌﻨﻮﺍﻳﻦ‪ -‬ﺍﳌﺴﺠﻼﺕ ﺍﳌﻄﻠﻮﺏ ﺍﻟﻮﺻﻮﻝ ﺍﻟﻴﻬﺎ ﺩﺍﺧﻞ ﺍﳌﺆﻗﺘﺔ‪ .‬ﺃﻣﺎ ﺍﳌﺸﺎﺑﻚ )‪(CLK, OUT, and GATE‬‬
‫ﻓﻬﻲ ﻟﻜﻞ ﻋﺪﺍﺩ ﺑﺪﺍﺧﻞ ﺍﳌﺆﻗﺘﺔ ﺃﻱ ﲟﻌﲎ ﺃﻧﻪ ﺗﻮﺟﺪ ﺛﻼﺙ ﻣﺸﺎﺑﻚ ﻣﻦ ﻛﻞ ﻭﺍﺣﺪﺓ ﻣﻨﻬﻢ ‪ ،‬ﻭﻳﻌﺘﱪ ﺍﳌﺸﺒﻜﲔ‬
‫)‪ (CLK (Clock Input) and GATE‬ﻣﺸﺎﺑﻚ ﺇﺩﺧﺎﻝ ﻟﻠﻌﺪﺍﺩ ﺑﻴﻨﻤﺎ ﺍﳌﺸﺒﻚ )‪ (OUT‬ﻣﺸﺒﻚ ﺇﺧﺮﺍﺝ ﺣﻴﺚ ﻳﺴﺘﺨﺪﻡ‬
‫ﻟﺮﺑﻂ ﺍﻟﻌﺪﺍﺩ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﻓﻤﺜﻼ ﻣﺸﺒﻚ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﻟﻌﺪﺍﺩ ﺍﻷﻭﻝ )ﻣﺆﻗﺘﺔ ﺍﻟﻨﻈﺎﻡ( ﻳﺮﺗﺒﻂ ﻣﻊ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺣﻴﺚ‬
‫ﻣﻦ ﺧﻼﻟﻪ ﺗﺴﺘﻄﻴﻊ ﻣﺆﻗﺘﺔ ﺍﻟﻨﻈﺎﻡ ﺇﺭﺳﺎﻝ ﻃﻠﺐ ﺍﳌﻘﺎﻃﻌﺔ )‪ (IRQ0‬ﺍﱃ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﺍﻟﺬﻱ ﻳﻘﻮﻡ ﺑﺘﺤﻮﻳﻞ ﺍﻟﻄﻠﺐ‬
‫ﺍﱃ ﺍﳌﻌﺎﰿ ﻟﻜﻲ ﻳﻨﻔﺬ ﺩﺍﻟﺔ ﺍﻟﺘﺨﺪﱘ‪.‬‬

‫‪١٤٢‬‬
‫‪Programmable Interval Timer‬‬ ‫‪ .٣.٦‬ﺍﳌﺆﻗﺘﺔ‬

‫‪PIT‬‬ ‫ﻣﺴﺠﻼﺕ ﺍﳌﺆﻗﺘﺔ‬

‫ﺗﻮﺟﺪ ‪ ٤‬ﻣﺴﺠﻼﺕ ﺑﺪﺍﺧﻞ ﺍﳌﺆﻗﺘﺔ ‪ ، PIT‬ﺛﻼﺙ ﻣﻨﻬﺎ ﺗﺴﺘﺨﺪﻡ ﻟﻠﻌﺪﺍﺩﺍﺕ )ﺍﻷﻭﻝ ﻭﺍﻟﺜﺎﱐ ﻭﺍﻟﺜﺎﻟﺚ( ﺣﻴﺚ ﻣﻦ‬
‫ﺧﻼﳍﺎ ﳝﻜﻦ ﻗﺮﺍءﺓ ﻗﻴﻤﺔ ﺍﻟﻌﺪﺍﺩ ﺃﻭ ﺍﻟﻜﺘﺎﺑﺔ ﻓﻴﻪ ‪ ،‬ﻭﻃﻮﻝ ﻣﺴﺠﻞ ﺍﻟﻌﺪﺍﺩ ﻫﻮ ‪ ١٦‬ﺑﺖ ‪ .‬ﻭﺑﺴﺒﺐ ﺃﻥ ﻣﺸﺎﺑﻚ‬
‫ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﱵ ﺗﺮﺑﻂ ﺍﳌﺆﻗﺘﺔ ﻭﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻫﻲ ﻣﻦ ﺍﻟﻄﻮﻝ ‪ ٨‬ﺑﺖ ﻓﺎﻧﻪ ﻟﻦ ﻧﺘﻤﻜﻦ ﻣﻦ ﺇﺭﺳﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ‪‬ﺬ ﺍﻟﺸﻜﻞ‬
‫‪ .‬ﻟﺬﻟﻚ ﳚﺐ ﺇﺳﺘﺨﺪﺍﻡ ﻣﺴﺠﻞ ﺍﺧﺮ ﻭﻫﻮ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ )‪ (Control Word‬ﲝﻴﺚ ﻗﺒﻞ ﺇﺭﺳﺎﻝ ﺑﻴﺎﻧﺎﺕ ﺃﻭ ﻗﺮﺍءﺓ‬
‫ﺑﻴﺎﻧﺎﺕ ﻣﻦ ﺃﻱ ﻋﺪﺍﺩ ﻓﺎﻧﻪ ﳚﺐ ﺇﺭﺳﺎﻝ ﺍﻷﻣﺮ ﺍﳌﻄﻠﻮﺏ ﺍﱃ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ ﻭﺑﻌﺪ ﺫﻟﻚ ﻳﺘﻢ ﺇﺭﺳﺎﻝ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺃﻭ‬
‫ﻗﺮﺍﺋﺘﻬﺎ‪ .‬ﻭﺍﳉﺪﻭﻝ ‪ ١٢.٦‬ﻳﻮﺿﺢ ﻫﺬﺍ ﺍﳌﺴﺠﻼﺕ ﻭﻋﻨﻮﺍﻥ ﻣﻨﺎﻓﺬ ﺍﻹﺩﺧﺎﻝ ﻭﺍﻹﺧﺮﺍﺝ ﺍﳌﺴﺘﺨﺪﻣﺔ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‬
‫‪ ،‬ﻭﳚﺐ ﻣﻼﺣﻈﺔ ﻗﻴﻢ ﺧﻂ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻭﺧﻂ ﺍﻟﻌﻨﻮﺍﻥ )‪ (A0,A1‬ﺣﻴﺚ ﺗﺆﺛﺮ ﻗﻴﻤﻬﻢ ﰲ ﲢﺪﻳﺪ ﻧﻮﻉ ﺍﻟﻌﻤﻠﻴﺔ‬
‫ﺍﳌﻄﻠﻮﺑﺔ )ﻗﺮﺍءﺓ ﺃﻡ ﻛﺘﺎﺑﺔ ﻭﺭﻗﻢ ﺍﻟﻌﺪﺍﺩ(‪ .‬ﻭﺗﻮﺿﺢ ﺍﻟﺘﺮﻛﻴﺒﺔ ﺍﻟﺘﺎﻟﻴﺔ ﻣﺎﻫﻴﺔ ﺍﻟﺒﺘﺎﺕ ﺍﳌﺴﺘﺨﺪﻣﺔ ﰲ ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ‬

‫ﺟﺪﻭﻝ ‪ :.١٢.٦‬ﻣﺴﺠﻼﺕ ﺍﳌﺆﻗﺘﺔ ‪8253 PIT‬‬

‫ﺍﻟﻮﻇﻴﻔﺔ‬ ‫ﺍﳌﻨﻔﺬ ﺧﻂ ‪ RD‬ﺧﻂ ‪ WR‬ﺧﻂ ‪ A0‬ﺧﻂ ‪A1‬‬ ‫ﺭﻗﻢ‬ ‫ﺍﺳﻢ ﺍﳌﺴﺠﻞ‬
‫ﻛﺘﺎﺑﺔ ﺍﱃ ﺍﳌﺴﺠﻞ ‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x40‬‬ ‫‪Counter 0‬‬
‫ﻗﺮﺍءﺓ ﺍﳌﺴﺠﻞ ‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫ﻛﺘﺎﺑﺔ ﺍﱃ ﺍﳌﺴﺠﻞ ‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x41‬‬ ‫‪Counter 1‬‬
‫ﻗﺮﺍءﺓ ﺍﳌﺴﺠﻞ ‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫ﻛﺘﺎﺑﺔ ﺍﱃ ﺍﳌﺴﺠﻞ ‪2‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x42‬‬ ‫‪Counter 2‬‬
‫ﻗﺮﺍءﺓ ﺍﳌﺴﺠﻞ ‪2‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫ﻛﺘﺎﺑﺔ ‪Control Word‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0x43‬‬ ‫‪Control Word‬‬
‫ﻻ ﺗﻮﺟﺪ ﻋﻤﻠﻴﺔ‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬

‫)ﻭﻫﻮ ﻣﺴﺠﻞ ﺑﻄﻮﻝ ‪ ٨‬ﺑﺖ( ﺣﻴﺚ ﳚﺐ ﺇﺭﺳﺎﻝ ﻗﻴﻢ ﻣﻌﻴﻨﺔ ﺣﱴ ﻧﺘﻤﻜﻦ ﻣﻦ ﺍﻟﻘﺮﺍءﺓ ﺃﻭ ﺍﻟﻜﺘﺎﺑﺔ ﰲ ﻋﺪﺍﺩ ﻣﺎ‪.‬‬
‫‪• Bit 0: (BCP) Binary Counter‬‬
‫‪– 0: Binary‬‬
‫)‪– 1: Binary Coded Decimal (BCD‬‬

‫‪• Bit 1-3: (M0, M1, M2) Opera ng Mode. See above sec ons for a descrip on of each.‬‬
‫‪– 000: Mode 0: Interrupt or Terminal Count‬‬
‫‪– 001: Mode 1: Programmable one-shot‬‬
‫‪– 010: Mode 2: Rate Generator‬‬
‫‪– 011: Mode 3: Square Wave Generator‬‬
‫‪– 100: Mode 4: So ware Triggered Strobe‬‬
‫‪– 101: Mode 5: Hardware Triggered Strobe‬‬
‫‪– 110: Undefined; Don't use‬‬

‫‪١٤٣‬‬
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

– 111: Undefined; Don't use

• Bits 4-5: (RL0, RL1) Read/Load Mode. We are going to read or send data to a counter register
– 00: Counter value is latched into an internal control register at the me of the I/O write
opera on.
– 01: Read or Load Least Significant Byte (LSB) only
– 10: Read or Load Most Significant Byte (MSB) only
– 11: Read or Load LSB first then MSB

• Bits 6-7: (SC0-SC1) Select Counter. See above sec ons for a descrip on of each.
– 00: Counter 0
– 01: Counter 1
– 10: Counter 2
– 11: Illegal value

(milliseconds ١٠ ‫ )ﻛﻞ‬100Hz ‫ ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺑﺮﳎﺔ ﻋﺪﺍﺩ ﻣﺆﻗﺖ ﺍﻟﻨﻈﺎﻡ ﻹﺭﺳﺎﻝ ﻃﻠﺐ ﻣﻘﺎﻃﻌﺔ ﻛﻞ‬٦.١٠ ‫ﻭﺍﳌﺜﺎﻝ‬
.‫ ﻭﻫﺬﺍ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺇﺭﺳﺎﻝ ﺃﻣﺮ ﺍﻟﺘﺤﻜﻢ ﺃﻭﻻﹰ ﻭﻣﻦ ﰒ ﺇﺭﺳﺎﻝ ﺍﻟﻮﻗﺖ ﺍﳌﻄﻠﻮﺏ ﺍﱃ ﺍﻟﻌﺪﺍﺩ ﺍﳌﻄﻠﻮﺏ‬،
Example ٦.١٠: PIT programming
١ ; COUNT = input hz / frequency
٢
٣ mov dx, 1193180 / 100 ; 100hz, or 10 milliseconds
٤
٥ ; FIRST send the command word to the PIT. Sets binary counting,
٦ ; Mode 3, Read or Load LSB first then MSB, Channel 0
٧
٨ mov al, 110110b
٩ out 0x43, al
١٠
١١ ; Now we can write to channel 0. Because we set the "Load LSB first
then MSB" bit, that is
١٢ ; the way we send it
١٣
١٤ mov ax, dx
١٥ out 0x40, al ;LSB
١٦ xchg ah, al
١٧ out 0x40, al ;MSB

١٤٤
‫‪HAL‬‬ ‫‪ .٤.٦‬ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬

‫‪HAL‬‬ ‫‪ .٤.٦‬ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬

‫ﻃﺒﻘﺔ ‪ HAL‬ﺗﺒﻌﺪ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻣﻦ ﺍﻟﺘﻌﺎﻣﻞ ﺍﳌﺒﺎﺷﺮ ﻣﻊ ﺍﻟﻌﺘﺎﺩ ﻭﺗﻌﻤﻞ ﻛﻮﺍﺟﻬﺔ ﺃﻭ ﻃﺒﻘﺔ ﻣﺎ ﺑﲔ ﺍﻟﻨﻮﺍﺓ ﻭﺍﻟﻌﺘﺎﺩ ‪ ،‬ﻭﻓﻴﻬﺎ‬
‫ﳒﺪ ﺗﻌﺮﻳﻔﺎﺕ ﺍﻟﻌﺘﺎﺩ‪ .‬ﻭﺳﻴﺘﻢ ﺇﺿﺎﻓﺔ ﺃﻭﺍﻣﺮ ﺑﺮﳎﺔ ﻣﺘﺤﻜﻢ ‪ PIC‬ﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺈﻋﺎﺩﺓ ﺗﻌﻴﲔ ﺃﺭﻗﺎﻡ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺑﺪﺍﺧﻞ‬
‫ﻫﺬﻩ ﺍﻟﻄﺒﻘﺔ ﻭﻛﺬﻟﻚ ﺳﻴﺘﻢ ﺇﺿﺎﻓﺔ ﺷﻔﺮﺓ ﺑﺮﳎﺔ ﺍﳌﺆﻗﺘﺔ ﻭ ﺍﻟﱵ ﲢﺪﺩ ﺍﻟﻮﻗﺖ ﺍﻟﻼﺯﻡ ﻟﻠﻤﺆﻗﺘﺔ ﻟﻜﻲ ﺗﻘﻮﻡ ﺑﺎﺭﺳﺎﻝ‬
‫ﻃﻠﺐ ﺍﳌﻘﺎﻃﻌﺔ )‪. (IRQ0‬‬

‫‪PIC‬‬ ‫‪ .١.٤.٦‬ﺩﻋﻢ‬
‫ﰲ ﺍﻟﻘﺴﻢ ‪ ٢.٢.٦‬ﰎ ﻋﺮﺽ ﻣﺘﺤﻜﻢ ‪ PIC‬ﻭﻛﻴﻔﻴﺔ ﺑﺮﳎﺘﻪ ﺑﺎﻟﺘﻔﺼﻴﻞ ‪ ،‬ﻭﰲ ﻫﺬﺍ ﺍﻟﻘﺴﻢ ﺳﻴﺘﻢ ﺗﻄﺒﻴﻖ ﻣﺎ ﰎ ﻋﺮﺿﻪ‬
‫ﻋﻠﻰ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‪ .‬ﻭﻳﻮﺟﺪ ﻣﻠﻔﲔ ﳌﺘﺤﻜﻢ ‪ PIC‬ﺍﻷﻭﻝ ﻫﻮ ﻣﻠﻒ ﺍﻟﺮﺃﺱ )‪ (hal/pic.h‬ﺍﻟﺬﻱ ﳛﻮﻱ ﺍﻹﻋﻼﻥ‬
‫ﻋﻦ ﺍﻟﺪﻭﺍﻝ ﻭﻛﺬﻟﻚ ﺍﻟﺜﻮﺍﺑﺖ ﻭﺍﻟﺜﺎﱐ ﻫﻮ ﻣﻠﻒ ﺍﻟﺘﻄﺒﻴﻖ )‪ (hal/pic.cpp‬ﺍﻟﺬﻱ ﳛﻮﻱ ﻋﻠﻰ ﺗﻌﺮﻳﻒ ﺗﻠﻚ ﺍﻟﺪﻭﺍﻝ‪.‬‬
‫ﻭﺍﳌﺜﺎﻝ ‪ ٦.١١‬ﻳﻌﺮﺽ ﻣﻠﻒ ﺍﻟﺮﺃﺱ ﺍﻟﺬﻱ ﻳﻐﻠﻒ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻷﺭﻗﺎﻡ ﻭﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﺻﻮﺭﺓ ﺛﻮﺍﺑﺖ )ﺑﺎﺳﺘﺨﺪﺍﻡ‬
‫ﺍﳌﺎﻛﺮﻭ( ﲝﻴﺚ ﺗﺰﻳﺪ ﻣﻦ ﻣﻘﺮﻭﺋﻴﺔ ﻭﻭﺿﻮﺡ ﺍﻟﺸﻔﺮﺓ ‪.٨‬‬
‫‪Example‬‬ ‫‪٦.١١: hal/pic.h: PIC Interface‬‬
‫‪١ // PIC 1 Devices IRQ‬‬
‫‪٢ #define I386 PIC IRQ TIMER‬‬ ‫‪0‬‬
‫‪٣ #define I386 PIC IRQ KEYBOARD‬‬ ‫‪1‬‬
‫‪٤ #define I386 PIC IRQ SERIAL2‬‬ ‫‪3‬‬
‫‪٥ #define I386 PIC IRQ SERIAL1‬‬ ‫‪4‬‬
‫‪٦ #define I386 PIC IRQ PARALLEL2‬‬ ‫‪5‬‬
‫‪٧ #define I386 PIC IRQ DESKETTE‬‬ ‫‪6‬‬
‫‪٨ #define I386 PIC IRQ PARALLEL1‬‬ ‫‪7‬‬
‫‪٩‬‬
‫‪١٠ // PIC 2 Devices IRQ‬‬
‫‪١١ #define I386 PIC IRQ CMOSTIMER‬‬ ‫‪0‬‬
‫‪١٢ #define I386 PIC IRQ CGARETRACE‬‬ ‫‪1‬‬
‫‪١٣ #define I386 PIC IRQ AUXILIRY‬‬ ‫‪4‬‬
‫‪١٤ #define I386 PIC IRQ FPU‬‬ ‫‪5‬‬
‫‪١٥ #define I386 PIC IRQ HDC‬‬ ‫‪6‬‬
‫‪١٦‬‬
‫)‪١٧ // Operation Commamd Word 2 (OCW2‬‬
‫‪١٨ #define I386 PIC OCW2 MASK L1‬‬ ‫‪1‬‬
‫‪١٩ #define I386 PIC OCW2 MASK L2‬‬ ‫‪2‬‬
‫‪٢٠ #define I386 PIC OCW2 MASK L3‬‬ ‫‪4‬‬

‫‪٨‬ﺇﺭﺟﻊ ﺍﱃ ﺍﻟﻘﺴﻢ ‪ ٢.٢.٦‬ﳌﻌﺮﻓﺔ ﻭﻇﻴﻔﺔ ﻫﺬﻩ ﺍﻟﻘﻴﻢ ﺍﻟﺜﺎﺑﺘﺔ‪.‬‬

‫‪١٤٥‬‬
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٢١ #define I386 PIC OCW2 MASK EOI 0x20

٢٢ #define I386 PIC OCW2 MASK SL 0x40
٢٣ #define I386 PIC OCW2 MASK ROTATE 0x80
٢٤
٢٥
٢٦ // Operation Commamd Word 3 (OCW3)
٢٧ #define I386 PIC OCW3 MASK RIS 1
٢٨ #define I386 PIC OCW3 MASK RIR 2
٢٩ #define I386 PIC OCW3 MASK MODE 4
٣٠ #define I386 PIC OCW3 MASK SMM 0x20
٣١ #define I386 PIC OCW3 MASK ESMM 0x40
٣٢ #define I386 PIC OCW3 MASK D7 0x80
٣٣
٣٤
٣٥ // PIC 1 port address
٣٦ #define I386 PIC1 COMMAND REG 0x20
٣٧ #define I386 PIC1 STATUS REG 0x20
٣٨ #define I386 PIC1 IMR REG 0x21
٣٩ #define I386 PIC1 DATA REG 0x21
٤٠
٤١
٤٢ // PIC 2 port address
٤٣ #define I386 PIC2 COMMAND REG 0xa0
٤٤ #define I386 PIC2 STATUS REG 0xa0
٤٥ #define I386 PIC2 IMR REG 0xa1
٤٦ #define I386 PIC2 DATA REG 0xa1
٤٧
٤٨ // Initializing Commamd Word 1 (ICW1) Mask
٤٩ #define I386 PIC ICW1 MASK IC4 0x1
٥٠ #define I386 PIC ICW1 MASK SNGL 0x2
٥١ #define I386 PIC ICW1 MASK ADI 0x4
٥٢ #define I386 PIC ICW1 MASK LTIM 0x8
٥٣ #define I386 PIC ICW1 MASK INIT 0x10
٥٤
٥٥
٥٦ // Initializing Commamd Word 4 (ICW4) Mask
٥٧ #define I386 PIC ICW4 MASK UPM 0x1
٥٨ #define I386 PIC ICW4 MASK AEOI 0x2
٥٩ #define I386 PIC ICW4 MASK MS 0x4
٦٠ #define I386 PIC ICW4 MASK BUF 0x8
٦١ #define I386 PIC ICW4 MASK SFNM 0x10

١٤٦
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٦٢
٦٣
٦٤ // Initializing command 1 control bits
٦٥ #define I386 PIC ICW1 IC4 EXPECT 1
٦٦ #define I386 PIC ICW1 IC4 NO 0
٦٧ #define I386 PIC ICW1 SNGL YES 2
٦٨ #define I386 PIC ICW1 SNGL NO 0
٦٩ #define I386 PIC ICW1 ADI CALLINTERVAL4 4
٧٠ #define I386 PIC ICW1 ADI CALLINTERVAL8 0
٧١ #define I386 PIC ICW1 LTIM LEVELTRIGGERED 8
٧٢ #define I386 PIC ICW1 LTIM EDGETRIGGERED 0
٧٣ #define I386 PIC ICW1 INIT YES 0x10
٧٤ #define I386 PIC ICW1 INIT NO 0
٧٥
٧٦ // Initializing command 4 control bits
٧٧ #define I386 PIC ICW4 UPM 86MODE 1
٧٨ #define I386 PIC ICW4 UPM MCSMODE 0
٧٩ #define I386 PIC ICW4 AEOI AUTOEOI 2
٨٠ #define I386 PIC ICW4 AEOI NOAUTOEOI 0
٨١ #define I386 PIC ICW4 MS BUFFERMASTER 4
٨٢ #define I386 PIC ICW4 MS BUFFERSLAVE 0
٨٣ #define I386 PIC ICW4 BUF MODEYES 8
٨٤ #define I386 PIC ICW4 BUF MODENO 0
٨٥ #define I386 PIC ICW4 SFNM NESTEDMODE 0x10
٨٦ #define I386 PIC ICW4 SFNM NOTNESTED 0
٨٧
٨٨
٨٩ extern uint8 t i386 pic read data(uint8 t pic num);
٩٠ extern void i386 pic send data(uint8 t data,uint8 t pic num);
٩١ extern void i386 pic send command(uint8 t cmd,uint8 t pic num);
٩٢ extern void i386 pic init(uint8 t base0,uint8 t base1);

‫ ﺩﻭﺍﻝ ﻣﻨﻬﺎ ﺩﺍﻟﺘﺎﻥ ﻟﻠﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ ﻣﻦ ﻣﺴﺠﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺩﺍﻟﺔ ﻹﺭﺳﺎﻝ ﺍﻷﻭﺍﻣﺮ ﺍﱃ ﻣﺴﺠﻞ‬٤ ‫ﻭﲢﻮﻱ ﺍﻟﻮﺍﺟﻬﺔ‬
‫ ﻳﻮﺿﺢ ﺗﻌﺮﻳﻒ‬٦.١٢ ‫ ﻭﺍﳌﺜﺎﻝ‬.‫ﺍﻟﺘﺤﻜﻢ ﻭﺍﻟﺪﺍﻟﺔ ﺍﻷﺧﲑﺓ ﻫﻲ ﻟﺘﻬﺌﻴﺔ ﺍﳌﺘﺤﻜﻢ ﻭﻫﻲ ﺍﻟﺪﺍﻟﺔ ﺍﻟﱵ ﳚﺐ ﺍﺳﺘﺪﻋﺎﺋﻬﺎ‬
.‫ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ‬
Example ٦.١٢: hal/pic.cpp: PIC Implementa on
١ uint8 t i386 pic read data(uint8 t pic num) {
٢ if (pic num > 1)
٣ return 0;

١٤٧
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٤
٥ uint8 t reg = (pic num == 1)?I386 PIC2 DATA REG:I386 PIC1 DATA REG;
٦ return inportb(reg);
٧ }
٨
٩ void i386 pic send data(uint8 t data,uint8 t pic num) {
١٠ if (pic num > 1)
١١ return;
١٢
١٣ uint8 t reg = (pic num == 1)?I386 PIC2 DATA REG:I386 PIC1 DATA REG;
١٤ outportb(reg,data);
١٥ }
١٦
١٧ void i386 pic send command(uint8 t cmd,uint8 t pic num) {
١٨
١٩ if (pic num > 1)
٢٠ return;
٢١
٢٢ uint8 t reg = (pic num == 1)?I386 PIC2 COMMAND REG:
I386 PIC1 COMMAND REG;
٢٣ outportb(reg,cmd);
٢٤ }
٢٥
٢٦
٢٧
٢٨ void i386 pic init(uint8 t base0,uint8 t base1) {
٢٩
٣٠ uint8 t icw = 0;
٣١
٣٢ disable irq(); /∗ disable hardware interrupt (cli) ∗/
٣٣
٣٤ /∗ init PIC, send ICW1 ∗/
٣٥ icw = (icw & ˜ I386 PIC ICW1 MASK INIT) | I386 PIC ICW1 INIT YES;
٣٦ icw = (icw & ˜ I386 PIC ICW1 MASK IC4) | I386 PIC ICW1 IC4 EXPECT;
٣٧ /∗ icw = 0x11 ∗/
٣٨
٣٩ i386 pic send command(icw,0);
٤٠ i386 pic send command(icw,1);
٤١
٤٢ /∗ ICW2 : remapping irq ∗/
٤٣ i386 pic send data(base0,0);

١٤٨
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٤٤ i386 pic send data(base1,1);

٤٥
٤٦ /∗ ICW3 : irq for master/slave pic∗/
٤٧ i386 pic send data(0x4,0);
٤٨ i386 pic send data(0x2,1);
٤٩
٥٠ /∗ ICW4: enable i386 mode. ∗/
٥١ icw = (icw & ˜ I386 PIC ICW4 MASK UPM) | I386 PIC ICW4 UPM 86MODE ;
/∗ icw = 1 ∗/
٥٢ i386 pic send data(icw,0);
٥٣ i386 pic send data(icw,1);
٥٤
٥٥ }

PIT ‫ ﺩﻋﻢ‬.٢.٤.٦

Example ٦.١٣: hal/pit.h: PIt Interface

١ #define I386 PIT COUNTER0 REG 0x40
٢ #define I386 PIT COUNTER1 REG 0x41
٣ #define I386 PIT COUNTER2 REG 0x42
٤ #define I386 PIT COMMAND REG 0x43
٥
٦ #define I386 PIT OCW MASK BINCOUNT 0x1
٧ #define I386 PIT OCW MASK MODE 0xe
٨ #define I386 PIT OCW MASK RL 0x30
٩ #define I386 PIT OCW MASK COUNTER 0xc0
١٠
١١
١٢ #define I386 PIT OCW BINCOUNT BINARY 0x0
١٣ #define I386 PIT OCW BINCOUNT BCD 0x1
١٤
١٥ #define I386 PIT OCW MODE TERMINALCOUNT 0x0
١٦ #define I386 PIT OCW MODE ONESHOT 0x2
١٧ #define I386 PIT OCW MODE RATEGEN 0x4
١٨ #define I386 PIT OCW MODE SQUAREWAVEGEN 0x6
١٩ #define I386 PIT OCW MODE SOFTWARETRIG 0x8
٢٠ #define I386 PIT OCW MODE HARDWARETRIG 0xa
٢١

١٤٩
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٢٢ #define I386 PIT OCW RL LATCH 0x0

٢٣ #define I386 PIT OCW RL LSBONLY 0x10
٢٤ #define I386 PIT OCW RL MSBONLY 0x20
٢٥ #define I386 PIT OCW RL DATA 0x30
٢٦
٢٧ #define I386 PIT OCW COUNTER 0 0x0
٢٨ #define I386 PIT OCW COUNTER 1 0x40
٢٩ #define I386 PIT OCW COUNTER 2 0x80
٣٠
٣١ extern void i386 pit send command(uint8 t cmd);
٣٢ extern void i386 pit send data(uint16 t data,uint8 t counter);
٣٣ extern uint8 t i386 pit read data(uint16 t counter);
٣٤ extern uint32 t i386 pit set tick count(uint32 t i);
٣٥ extern uint32 t i386 pit get tick count();
٣٦ extern void i386 pit start counter(uint32 t freq,uint8 t counter,
uint8 t mode);
٣٧ extern void cdecl i386 pit init();
٣٨ extern bool cdecl i386 pit is initialized();

Example ٦.١٤: hal/pit.cpp: PIT Implementa on

١ static volatile uint32 t pit ticks = 0;
٢ static bool pit is init = false;
٣
٤ void cdecl i386 pit irq();
٥
٦ void i386 pit send command(uint8 t cmd) {
٧ outportb(I386 PIT COMMAND REG,cmd);
٨ }
٩
١٠ void i386 pit send data(uint16 t data,uint8 t counter) {
١١ uint8 t port;
١٢
١٣ if (counter == I386 PIT OCW COUNTER 0)
١٤ port = I386 PIT COUNTER0 REG;
١٥ else if ( counter == I386 PIT OCW COUNTER 1)
١٦ port = I386 PIT COUNTER1 REG;
١٧ else
١٨ port = I386 PIT COUNTER2 REG;
١٩

١٥٠
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٢٠ outportb(port,uint8 t(data));
٢١ }
٢٢
٢٣ uint8 t i386 pit read data(uint16 t counter) {
٢٤ uint8 t port;
٢٥
٢٦ if (counter == I386 PIT OCW COUNTER 0)
٢٧ port = I386 PIT COUNTER0 REG;
٢٨ else if ( counter == I386 PIT OCW COUNTER 1)
٢٩ port = I386 PIT COUNTER1 REG;
٣٠ else
٣١ port = I386 PIT COUNTER2 REG;
٣٢
٣٣ return inportb(port);
٣٤ }
٣٥
٣٦ uint32 t i386 pit set tick count(uint32 t i) {
٣٧ uint32 t prev = pit ticks;
٣٨ pit ticks = i;
٣٩ return prev;
٤٠ }
٤١
٤٢ uint32 t i386 pit get tick count() {
٤٣ return pit ticks;
٤٤ }
٤٥
٤٦ void i386 pit start counter(uint32 t freq,uint8 t counter,uint8 t
mode) {
٤٧ if (freq == 0)
٤٨ return;
٤٩
٥٠ uint16 t divisor = uint16 t(1193181/uint16 t(freq));
٥١
٥٢ /∗ send operation command ∗/
٥٣ uint8 t ocw = 0;
٥٤
٥٥ ocw = (ocw & ˜ I386 PIT OCW MASK MODE) | mode;
٥٦ ocw = (ocw & ˜ I386 PIT OCW MASK RL) | I386 PIT OCW RL DATA;
٥٧ ocw = (ocw & ˜ I386 PIT OCW MASK COUNTER) | counter;
٥٨
٥٩ i386 pit send command(ocw);

١٥١
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٦٠
٦١ /∗ set frequency rate ∗/
٦٢ i386 pit send data(divisor & 0xff,0);
٦٣ i386 pit send data((divisor >> 8) & 0xff,0);
٦٤
٦٥ /∗ reset ticks count ∗/
٦٦ pit ticks = 0;
٦٧ }
٦٨
٦٩ void cdecl i386 pit init() {
٧٠ set vector(32,i386 pit irq);
٧١ pit is init = true;
٧٢ }
٧٣
٧٤ bool cdecl i386 pit is initialized() {
٧٥ return pit is init;
٧٦ }
٧٧
٧٨ void cdecl i386 pit irq() {
٧٩
٨٠ asm {
٨١ add esp,12
٨٢ pushad
٨٣ }
٨٤
٨٥ pit ticks++;
٨٦
٨٧ int done(0);
٨٨
٨٩ asm {
٩٠ popad
٩١ iretd
٩٢ }
٩٣ }

‫ ﺍﳉﺪﻳﺪﺓ‬HAL ‫ ﻭﺍﺟﻬﺔ‬.٣.٤.٦
HAL ‫ ﻳﻮﺿﺢ ﺍﻟﻮﺍﺟﻬﺔ ﺍﻟﻌﺎﻣﺔ ﻟﻄﺒﻘﺔ‬٦.١٥ ‫ﺍﳌﺜﺎﻝ‬

Example ٦.١٥: New HAL Interface

١٥٢
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

١ extern int cdecl hal init();

٢ extern int cdecl hal close();
٣ extern void cdecl gen interrupt(int);
٤ extern void cdecl int done(unsigned int n);
٥ extern void cdecl sound(unsigned int f);
٦ extern unsigned char cdecl inportb(unsigned short port num);
٧ extern void cdecl outportb(unsigned short port num,unsigned char
value);
٨ extern void cdecl enable irq();
٩ extern void cdecl disable irq();
١٠ extern void cdecl set vector(unsigned int int num,void ( cdecl far &
vect)());
١١ extern void ( cdecl far ∗ cdecl get vector(unsigned int int num))();
١٢ extern const char∗ cdecl get cpu vendor();
١٣ extern int cdecl get tick count();

Example ٦.١٦: New HAL Impelmenta on

١ int cdecl hal init() {
٢ i386 cpu init();
٣ i386 pic init(0x20,0x28);
٤ i386 pit init();
٥ i386 pit start counter(100,I386 PIT OCW COUNTER 0,
I386 PIT OCW MODE SQUAREWAVEGEN);
٦
٧ /∗ enable irq ∗/
٨ enable irq();
٩
١٠ return 0;
١١ }
١٢
١٣ int cdecl hal close() {
١٤ i386 cpu close();
١٥ return 0;
١٦ }
١٧
١٨ void cdecl gen interrupt(int n) {
١٩ #ifdef MSC VER
٢٠ asm {
٢١ mov al, byte ptr [n]

١٥٣
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٢٢ mov byte ptr [address+1], al

٢٣ jmp address
٢٤
٢٥ address:
٢٦ int 0 // will execute int n.
٢٧ }
٢٨ #endif
٢٩ }
٣٠
٣١
٣٢ void cdecl int done(unsigned int n) {
٣٣ if (n > 16)
٣٤ return;
٣٥
٣٦ if (n > 7)
٣٧ /∗ send EOI to pic2 ∗/
٣٨ i386 pic send command(I386 PIC OCW2 MASK EOI,1);
٣٩
٤٠ /∗ also send toi the primary pic ∗/
٤١ i386 pic send command(I386 PIC OCW2 MASK EOI,0);
٤٢ }
٤٣
٤٤ void cdecl sound(unsigned int f) {
٤٥ outportb(0x61,3 | unsigned char(f << 2));
٤٦ }
٤٧
٤٨ unsigned char cdecl inportb(unsigned short port num) {
٤٩ #ifdef MSC VER
٥٠ asm {
٥١ mov dx,word ptr [port num]
٥٢ in al,dx
٥٣ mov byte ptr [port num],al
٥٤ }
٥٥ #endif
٥٦
٥٧ return unsigned char(port num);
٥٨ }
٥٩
٦٠
٦١ void cdecl outportb(unsigned short port num,unsigned char value) {
٦٢ #ifdef MSC VER

١٥٤
 HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٦٣ asm {
٦٤ mov al,byte ptr[value]
٦٥ mov dx,word ptr[port num]
٦٦ out dx,al
٦٧ }
٦٨ #endif
٦٩ }
٧٠
٧١ void cdecl enable irq() {
٧٢ #ifdef MSC VER
٧٣ asm sti
٧٤ #endif
٧٥ }
٧٦
٧٧ void cdecl disable irq() {
٧٨ #ifdef MSC VER
٧٩ asm cli
٨٠ #endif
٨١ }
٨٢
٨٣ void cdecl set vector(unsigned int int num,void ( cdecl far & vect)
()) {
٨٤ i386 idt install ir(int num,I386 IDT 32BIT | I386 IDT PRESENT /∗
10001110∗/,0x8 /∗code desc∗/,vect);
٨٥ }
٨٦
٨٧ void ( cdecl far ∗ cdecl get vector(unsigned int int num))() {
٨٨ idt desc ∗ desc = i386 get idt ir(int num);
٨٩
٩٠ if (desc == 0)
٩١ return 0;
٩٢
٩٣ uint32 t address = desc−>base low | (desc−>base high << 16);
٩٤
٩٥ I386 IRQ HANDLER irq = (I386 IRQ HANDLER) address;
٩٦ return irq;
٩٧ }
٩٨
٩٩ const char∗ cdecl get cpu vendor() {
١٠٠ return i386 cpu vendor();
١٠١ }

١٥٥
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

١٠٢
١٠٣ int cdecl get tick count() {
١٠٤ return i386 pit get tick count();
١٠٥ }

Example ٦.١٧: kernel/main.cpp

١ int cdecl main()
٢ {
٣ hal init();
٤ enable irq();
٥
٦ set vector(0,(void ( cdecl &)(void))divide by zero fault);
٧ set vector(1,(void ( cdecl &)(void))single step trap);
٨ set vector(2,(void ( cdecl &)(void))nmi trap);
٩ set vector(3,(void ( cdecl &)(void))breakpoint trap);
١٠ set vector(4,(void ( cdecl &)(void))overflow trap);
١١ set vector(5,(void ( cdecl &)(void))bounds check fault);
١٢ set vector(6,(void ( cdecl &)(void))invalid opcode fault);
١٣ set vector(7,(void ( cdecl &)(void))no device fault);
١٤ set vector(8,(void ( cdecl &)(void))double fault abort);
١٥ set vector(10,(void ( cdecl &)(void))invalid tss fault);
١٦ set vector(11,(void ( cdecl &)(void))no segment fault);
١٧ set vector(12,(void ( cdecl &)(void))stack fault);
١٨ set vector(13,(void ( cdecl &)(void))general protection fault);
١٩ set vector(14,(void ( cdecl &)(void))page fault);
٢٠ set vector(16,(void ( cdecl &)(void))fpu fault);
٢١ set vector(17,(void ( cdecl &)(void))alignment check fault);
٢٢ set vector(18,(void ( cdecl &)(void))machine check abort);
٢٣ set vector(19,(void ( cdecl &)(void))simd fpu fault);
٢٤
٢٥ ...

Example ٦.١٨: kernel/excep on.h

١ /∗ Execption Handler ∗/
٢
٣ /∗ Divide by zero ∗/
٤ extern void cdecl divide by zero fault(uint32 t cs,uint32 t eip,
uint32 t eflags);

١٥٦
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٥
٦ /∗ Single step ∗/
٧ extern void cdecl single step trap(uint32 t cs,uint32 t eip,uint32 t
eflags);
٨
٩ /∗ No Maskable interrupt trap ∗/
١٠ extern void cdecl nmi trap(uint32 t cs,uint32 t eip,uint32 t eflags)
;
١١
١٢ /∗ Breakpoint hit ∗/
١٣ extern void cdecl breakpoint trap(uint32 t cs,uint32 t eip,uint32 t
eflags);
١٤
١٥ /∗ Overflow trap ∗/
١٦ extern void cdecl overflow trap(uint32 t cs,uint32 t eip,uint32 t
eflags);
١٧
١٨ /∗ Bounds check ∗/
١٩ extern void cdecl bounds check fault(uint32 t cs,uint32 t eip,
uint32 t eflags);
٢٠
٢١ /∗ invalid opcode instruction ∗/
٢٢ extern void cdecl invalid opcode fault(uint32 t cs,uint32 t eip,
uint32 t eflags);
٢٣
٢٤ /∗ Device not available ∗/
٢٥ extern void cdecl no device fault(uint32 t cs,uint32 t eip,uint32 t
eflags);
٢٦
٢٧ /∗ Double Fault ∗/
٢٨ extern void cdecl double fault abort(uint32 t cs,uint32 t err,
uint32 t eip,uint32 t eflags);
٢٩
٣٠ /∗ Invalid TSS ∗/
٣١ extern void cdecl invalid tss fault(uint32 t cs,uint32 t err,
uint32 t eip,uint32 t eflags);
٣٢
٣٣ /∗ Segment not present ∗/
٣٤ extern void cdecl no segment fault(uint32 t cs,uint32 t err,uint32 t
eip,uint32 t eflags);
٣٥

١٥٧
 Interrupts ‫ ﺍﳌﻘﺎﻃﻌﺎﺕ‬.٦

٣٦ /∗ Stack fault ∗/
٣٧ extern void cdecl stack fault(uint32 t cs,uint32 t err,uint32 t eip,
uint32 t eflags);
٣٨
٣٩ /∗ General Protection Fault ∗/
٤٠ extern void cdecl general protection fault(uint32 t cs,uint32 t err,
uint32 t eip,uint32 t eflags);
٤١
٤٢ /∗ Page Fault ∗/
٤٣ extern void cdecl page fault(uint32 t cs,uint32 t err,uint32 t eip,
uint32 t eflags);
٤٤
٤٥ /∗ FPU error ∗/
٤٦ extern void cdecl fpu fault(uint32 t cs,uint32 t eip,uint32 t eflags
);
٤٧
٤٨ /∗ Alignment Check ∗/
٤٩ extern void cdecl alignment check fault(uint32 t cs,uint32 t err,
uint32 t eip,uint32 t eflags);
٥٠
٥١ /∗ Machine Check ∗/
٥٢ extern void cdecl machine check abort(uint32 t cs,uint32 t eip,
uint32 t eflags);
٥٣
٥٤ /∗ FPU Single Instruction Multiple Data (SIMD) error ∗/
٥٥ extern void cdecl simd fpu fault(uint32 t cs,uint32 t eip,uint32 t
eflags);

Example ٦.١٩: kernel/excep on.cpp

١ /∗ Divide by zero ∗/
٢ void cdecl divide by zero fault(uint32 t cs,uint32 t eip,uint32 t
eflags) {
٣ kernel panic("Divide by 0");
٤ for (;;);
٥ }

Example ٦.٢٠: kernel/panic.cpp

١ void cdecl kernel panic(const char∗ msg,...) {

١٥٨
HAL ‫ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬.٤.٦

٢
٣ disable irq();
٤
٥ va list args;
٦ va start(args,msg);
٧ /∗ missing ∗/
٨ va end(args);
٩
١٠ char∗ panic = "\nSorry, eqraOS has encountered a problem and has
been shutdown.\n\n";
١١
١٢ kclear(0x1f);
١٣ kgoto xy(0,0);
١٤ kset color(0x1f);
١٥ kputs(panic);
١٦ kprintf(" ∗∗∗ STOP: %s",msg);
١٧
١٨ /∗ hang ∗/
١٩ for (;;) ;
٢٠ }

HAL ‫ ﻭﺍﺟﻬﺔ ﺍﻟﻨﻈﺎﻡ ﺑﻌﺪ ﺗﻮﺳﻌﺔ ﻃﺒﻘﺔ‬:.٥.٦ ‫ﺷﻜﻞ‬

١٥٩
 ‫‪Interrupts‬‬ ‫‪ .٦‬ﺍﳌﻘﺎﻃﻌﺎﺕ‬

‫ﺷﻜﻞ ‪ :.٦.٦‬ﺩﺍﻟﺔ ﲣﺪﱘ ﺍﳌﻘﺎﻃﻌﺎﺕ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ‬

‫‪١٦٠‬‬
 ‫‪ .٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺗﻌﺘﱪ ﺫﺍﻛﺮﺓ ﺍﳊﺎﺳﺐ ﺍﻟﺮﺋﻴﺴﻴﺔ )‪ (RAM‬ﻣﻦ ﺃﻫﻢ ﺍﳌﻮﺍﺭﺩ ﺍﻟﱵ ﳚﺐ ﻋﻠﻰ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﺇﺩﺍﺭ‪‬ﺎ ﺣﻴﺚ ﳝﺜﻞ ﺍﳌﺨﺰﻥ‬
‫ﺍﻟﺬﻱ ﻳﻘﺮﺃ ﺍﳌﻌﺎﰿ ﻣﻨﻪ ﺍﻷﻭﺍﻣﺮ ﻭﻳﻘﻮﻡ ﺑﺘﻨﻔﻴﺬﻫﺎ ‪ ،‬ﻭﻻ ﳝﻜﻦ ﻟﻠﻤﻌﺎﰿ ﺍﻟﻮﺻﻮﻝ ﺍﳌﺒﺎﺷﺮ ﺍﱃ ﺃﺣﺪ ﺍﻟﺬﻭﺍﻛﺮ ﺍﻟﺜﺎﻧﻮﻳﺔ‬
‫ﻣﺒﺎﺷﺮﺓ ﻭﺇﳕﺎ ﻳﺘﻢ ﲢﻤﻴﻞ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻭﺍﻟﱪﺍﻣﺞ ﺍﱃ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ ﺣﱴ ﺗﺼﺒﺢ ﻣﺘﺎﺣﺔ ﻟﻠﻤﻌﺎﰿ‪ .‬ﻭﻫﻨﺎ ﻳﺄﰐ ﺩﻭﺭ‬
‫ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ )‪ (Memory Manager‬ﺣﻴﺚ ﻳﺮﺍﻗﺐ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﺃﺟﺰﺍء ﺍﻟﺬﺍﻛﺮﺓ ﻭﻳﺘﻌﺮﻑ ﻋﻠﻰ ﻣﺎ ﻫﻮ ﻣﺴﺘﺨﺪﻡ‬
‫ﻭﻣﺎ ﻫﻮ ﻏﲑ ﻣﺴﺘﺨﺪﻡ ﻛﻤﺎ ﻳﻮﻓﺮ ﺩﻭﺍﻻ ﳊﺠﺰ ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ ﻭﲢﺮﻳﺮﻫﺎ ‪ ،‬ﻛﺬﻟﻚ ﻣﻦ ﺍﳌﻤﻜﻦ ﺃﻥ ﻳﻘﻮﻡ ﺑﻌﻤﻠﻴﺔ‬
‫ﺇﻋﺎﺩﺓ ﲡﺰﺋﺔ ﳌﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺫﻟﻚ ﻟﺘﻮﻓﲑ ﻣﺴﺎﺣﺔ ﻭﺍﺳﺘﻐﻼﻝ ﺃﻓﻀﻞ‪.‬ﻭﰲ ﻫﺬﺍ ﺍﻟﻔﺼﻞ ﺳﻴﺘﻢ ﺩﺭﺍﺳﺔ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﻭﺍﻟﺘﺨﻴﻠﻴﺔ ﻭﻛﻴﻔﻴﺔ ﺑﺮﳎﺘﻬﻢ ﻛﺬﻟﻚ ﺳﻴﺘﻢ ﻋﺮﺽ ﺑﻌﺾ ﺍﻟﻄﺮﻕ ﳊﺴﺎﺏ ﺍﳌﺴﺎﺣﺔ ﺍﻟﻜﻠﻴﺔ ﻟﻠﺬﺍﻛﺮﺓ ﻭﻋﺮﺽ‬
‫ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺍﳌﺴﺘﺨﺪﻣﺔ ﻣﻦ ﻗﺒﻞ ﺍﻟﻨﻈﺎﻡ‪.‬‬

‫‪Physical Memory Management‬‬ ‫‪ .١.٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬

‫‪RAM‬‬ ‫ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ )‪ (Physical Memoery‬ﻫﻲ ﻛﺘﻠﺔ ﺫﺍﻛﺮﻳﺔ ﺗﻮﺟﺪ ﺑﺪﺍﺧﻞ ﺷﺮﳛﺔ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺮﺋﻴﺴﻴﺔ‬
‫ﻭﲣﺘﻠﻒ ﻃﺮﻳﻘﺔ ﺣﻔﻆ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻓﻴﻬﺎ ﲝﺴﺐ ﻧﻮﻉ ﺍﻟﺬﺍﻛﺮﺓ )ﻓﻤﺜﻼ ﺗﺴﺘﺨﺪﻡ ﺍﳌﻜﺜﻔﺎﺕ ﻭﺍﻟﺘﺮﺍﻧﺰﺳﺘﻮﺭﺍﺕ ﳊﻔﻆ‬
‫ﺍﻟﺒﺘﺎﺕ ﰲ ﺫﺍﻛﺮﺓ ‪ ، (DRAM‬ﻭﻳﺘﻢ ﺍﻟﺘﺤﻜﻢ ﰲ ﻫﺬﻩ ﺍﻟﻜﺘﻠﺔ ﺑﻮﺍﺳﻄﺔ ﺷﺮﳛﺔ ﺩﺍﺧﻞ ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ ﺗﺴﻤﻰ ﲟﺘﺤﻜﻢ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﺃﻭ ﺑﺎﳉﺴﺮ ﺍﻟﺸﻤﺎﱄ )‪ (North Bridge‬ﺣﻴﺚ ﻳﻘﻮﻡ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﺑﻌﻤﻠﻴﺔ ﺇﻧﻌﺎﺵ ﺍﳌﻜﺜﻔﺎﺕ ﺑﺪﺍﺧﻞ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺣﱴ ﲢﺎﻓﻆ ﻋﻠﻰ ﳏﺘﻮﻳﺎ‪‬ﺎ ﻣﻦ ﺍﻟﻀﻴﺎﻉ ﻛﺬﻟﻚ ﻳﻌﻨﻮﻥ ﻫﺬﺍ ﺍﳌﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﺑﺪﺍﻳﺔ ﻣﻦ ﺃﻭﻝ ‪ ٨‬ﺑﺘﺎﺕ‬
‫ﺣﻴﺚ ﺗﺄﺧﺬ ﺍﻟﻌﻨﻮﺍﻥ ﺍﻟﻔﻴﺰﻳﺎﺋﻲ ‪ 0x0‬ﻭﻳﻠﻴﻬﺎ ﺍﻟﻌﻨﻮﺍﻥ ‪ 0x1‬ﻟﻠﺜﻤﺎﻧﻴﺔ ﺑﺘﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ‪ ،‬ﻭﻫﻜﺬﺍ ﺗﺘﻢ ﻋﻨﻮﻧﺔ ﺍﻟﺬﺍﻛﺮﺓ ﻣﻦ‬
‫ﻗﺒﻞ ﺍﳌﺘﺤﻜﻢ‪ .‬ﻭﻋﻨﺪ ﻭﺻﻮﻝ ﻃﻠﺐ ﻗﺮﺍءﺓ ﺃﻭ ﻛﺘﺎﺑﺔ ﺍﱃ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻓﺎﻥ ﺍﳌﺘﺤﻜﻢ ﻳﻘﻮﻡ ﺑﻘﺮﺍءﺓ ﺍﻟﻌﻨﻮﺍﻥ ﻣﻦ‬
‫ﻣﺴﺎﺭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻭﺑﺎﻟﺘﺎﱄ ﻳﺘﻤﻜﻦ ﻣﻦ ﺗﻔﺴﲑ ﺍﻟﻌﻨﻮﺍﻥ ﻭﺗﻮﺟﻴﻬﻪ ﺍﱃ ﺍﳌﻜﺎﻥ ﺍﻟﺼﺤﻴﺢ ﺣﻴﺚ ﻏﺎﻟﺒﺎ ﻣﺎ ﺗﻮﺟﺪ ﺃﻛﺜﺮ ﻣﻦ‬
‫ﺷﺮﳛﺔ ﺭﺍﻡ ﺑﺪﺍﺧﻞ ﺍﳊﺎﺳﺐ‪ .‬ﻭﺗﺸﻜﻞ ﳎﻤﻮﻋﺔ ﻛﻞ ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﻛﻞ ﺷﺮﺍﺋﺢ ﺍﻟﺬﺍﻛﺮﺓ ﻣﺴﺎﺣﺔ ﻋﻨﺎﻭﻳﻦ ﻓﻴﺰﻳﺎﺋﻴﺔ‬
‫)‪. (Physical Address Space‬ﻟﻜﻦ ﻗﺪ ﻳﻜﻮﻥ ﻫﻨﺎﻙ ﻋﺪﺩﺍ ﻣﻦ ﻫﺬﻩ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻏﲑ ﻣﺴﺘﺨﺪﻣﺔ ﻓﻌﻠﻴﺎ ﻭﺫﻟﻚ ﰲ‬
‫ﺣﺎﻟﺔ ﻭﺟﻮﺩ ﺷﺮﳛﺔ ﺫﺍﻛﺮﺓ ﰲ ﺍﳌﻨﻔﺬ ﺍﻷﻭﻝ ﻭﺍﻟﺜﺎﻟﺚ ﻭﻋﺪﻡ ﻭﺟﻮﺩ ﺷﺮﳛﺔ ﺫﺍﻛﺮﺓ ﰲ ﺍﳌﻨﻔﺬ ﺍﻟﺜﺎﱐ ﻭﰲ ﻫﺬﻩ ﺍﳊﺎﻟﺔ‬
‫ﺍﺫﺍ ﻛﺎﻥ ﺣﺠﻢ ﻛﻞ ﺷﺮﳛﺔ ﺫﺍﻛﺮﺓ ﻫﻲ ‪ n‬ﻓﺎﻥ ﺍﻟﻌﻨﺎﻭﻳﻦ ﻣﻦ ‪ n-1‬ﺍﱃ ‪ 2n-1‬ﻫﻲ ﻋﻨﺎﻭﻳﻦ ﻏﲑ ﻣﻮﺟﻮﺩﺓ ﺣﻘﻴﻘﺔ‬
‫ﻭﺗﺴﻤﻰ ﻓﺘﺤﺎﺕ )‪ ، (Holes‬ﻭﻋﻤﻠﻴﺔ ﺍﻟﻜﺘﺎﺑﺔ ﰲ ﻫﺬﻩ ﺍﻟﻔﺘﺤﺎﺕ ﻻ ﺗﺆﺛﺮ ﺷﻲء ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ ﺑﻴﻨﻤﺎ ﻋﻨﺪ ﺍﻟﻘﺮﺍءﺓ ﻣﻦ‬
‫ﻫﺬﻩ ﺍﻟﻔﺘﺤﺎﺕ ﻓﺎﻥ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﻣﺴﺎﺭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﻫﻲ ﺍﻟﱵ ﻳﺘﻢ ﻗﺮﺍﺋﺘﻬﺎ ﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃ‪‬ﺎ ﻏﲑ ﺻﺤﻴﺤﺔ‪.‬‬
‫ﻭﻗﺒﻞ ﺍﳋﻮﺽ ﰲ ﺑﺮﳎﺔ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﳚﺐ ﺗﻮﻓﲑ ﻋﺪﺩﺍ ﻣﻦ ﺍﳌﻌﻠﻮﻣﺎﺕ ﻣﺜﻞ ﺟﺤﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻜﻠﻲ ﻭﻣﻨﺎﻃﻖ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺍﳌﺴﺘﺨﺪﻣﺔ ﻭﻏﲑ ﺍﳌﺴﺘﺨﺪﻣﺔ ﻭ ﺍﻟﻔﺘﺤﺎﺕ ﺍﳌﻮﺟﻮﺩﺓ ﺍﻥ ﻛﺎﻧﺖ ﻫﻨﺎﻙ ﻓﺘﺤﺎﺕ ‪ ،‬ﻭﻫﺬﺍ ﺣﱴ ﻳﺘﻤﻜﻦ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﻣﻦ ﺇﺩﺍﺭ‪‬ﺎ ﻋﻠﻰ ﺍﻟﻨﺤﻮ ﺍﳌﻄﻠﻮﺏ‪.‬‬

‫‪١٦١‬‬
 ‫‪ .٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬

‫‪ .١.١.٧‬ﺣﺴﺎﺏ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ‬

‫ﺗﻮﺟﺪ ﻋﺪﺓ ﻃﺮﻕ ﳊﺴﺎﺏ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺑﻌﻀﻬﺎ ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﺍﻟﻨﻈﺎﻡ ﻭﺍﻷﺧﺮﻯ ﻻ ﺗﻌﺘﻤﺪ ‪ ،‬ﻭﰲ ﺑﺪﺍﻳﺔ ﺇﻗﻼﻉ‬
‫ﺍﳊﺎﺳﺐ ﻳﻘﻮﻡ ﻧﻈﺎﻡ ﺍﻟﺒﺎﻳﻮﺱ ﺑﺎﻟﺘﺨﺎﻃﺐ ﻣﻊ ﻣﺘﺤﻜﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺃﺧﺬ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﻳﻘﻮﻡ ﲝﻔﻈﻬﺎ ﰲ ﺃﺣﺪ‬
‫ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﻣﻨﻄﻘﺔ ﺑﻴﺎﻧﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﰲ ﺍﻟﺬﺍﻛﺮﺓ‪ .‬ﻭﺗﻌﺘﱪ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻫﻲ ﺍﻷﻛﺜﺮ ﺩﻗﺔ ﰲ ﺍﳊﺼﻮﻝ ﻋﻠﻰ ﺣﺠﻢ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﻭﻟﻜﻦ ﺗﺒﻘﻰ ﻣﺸﻜﻠﺔ ﺃﻥ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﻻ ﳝﻜﻦ ﺍﺳﺘﺪﻋﺎﺋﻬﺎ ﺑﺪﺍﺧﻞ ﺍﻟﻨﻮﺍﺓ ﻭﺍﻟﱵ ﺗﻌﻤﻞ ﰲ ﺍﻟﻨﻤﻂ‬
‫ﺍﳌﺤﻤﻲ‪ .‬ﻟﺬﻟﻚ ﺳﻴﺘﻢ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﻘﺎﻃﻌﺔ ﺍﳋﺎﺻﺔ ﲜﻠﺐ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻗﺒﻞ ﺃﻥ ﺗﺒﺪﺃ ﺍﻟﻨﻮﺍﺓ ﰲ ﻋﻤﻠﻬﺎ ﻭﲤﺮﻳﺮ ﻫﺬﺍ‬
‫ﺍﳊﺠﻢ ﻣﻊ ﺑﻌﺾ ﺍﳌﻌﻠﻮﻣﺎﺕ ﺍﻻﺧﺮﻯ ﻭ ﺗﺴﻤﻰ ﻣﻌﻠﻮﻣﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ ﺍﱃ ﺍﻟﻨﻮﺍﺓ‪.‬‬

‫‪int 0x12‬‬ ‫ﺍﳌﻘﺎﻃﻌﺔ‬

‫ﺗﻘﻮﻡ ﻫﺬﺍ ﺍﳌﻘﺎﻃﻌﺔ ﲜﻠﺐ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻣﻦ ﻣﻨﻄﻘﺔ ﺑﻴﺎﻧﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ )ﺑﺎﻟﺘﺤﺪﻳﺪ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ (0x413‬ﻟﻜﻨﻬﺎ ﻻ‬
‫ﺗﺴﺘﺨﺪﻡ ﺣﺎﻟﻴﺎ ﻧﻈﺮﺍ ﻷ‪‬ﺎ ﲡﻠﺐ ﺣﺠﻢ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ ﻛﺤﺪ ﺃﻗﺼﻰ ﻭﺑﺎﻟﺘﺎﱄ ﺍﺫﺍ ﻛﺎﻧﺖ ﺍﻟﺬﺍﻛﺮﺓ ﻟﺪﻳﻚ ﺃﻛﱪ ﻣﻦ‬
‫ﻫﺬﺍ ﺍﳊﺠﻢ ﻓﺎ‪‬ﺎ ﻻ ﲡﻠﺐ ﺍﳊﺠﻢ ﺍﻟﺼﺤﻴﺢ ‪ ،‬ﻟﺬﻟﻚ ﻻ ﺗﺴﺘﺨﺪﻡ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ ﺍﻻﻥ‪ .‬ﻭﺍﳌﺜﺎﻝ ‪ ٧.١‬ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ‬
‫ﺍﺳﺘﺨﺪﺍﻣﻬﺎ‬
‫‪Example‬‬ ‫‪٧.١: Using int 0x12 to get size of memory‬‬
‫‪١‬‬
‫‪٢ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٣ ; get conventional memory size‬‬
‫‪٤ ; ret ax=KB size from address 0‬‬
‫‪٥ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٦ get conventional memory size:‬‬
‫‪٧‬‬ ‫‪int 0x12‬‬
‫‪٨‬‬ ‫‪ret‬‬

‫‪0xe801‬‬ ‫ﺍﳌﻘﺎﻃﻌﺔ ‪ 0x15‬ﺍﻟﺪﺍﻟﺔ‬

‫ﲡﻠﺐ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ ﺍﳊﺠﻢ ﺍﻟﺼﺤﻴﺢ ﻭﺗﺴﺘﺨﺪﻡ ﺩﺍﺋﻤﺎ ﳍﺬﺍ ﺍﻟﻐﺮﺽ ‪ ،‬ﻭﺗﻌﻮﺩ ﺑﺎﻟﻘﻴﻢ‪:‬‬
‫ﺍﻟﻌﻠﻢ ‪ :CF‬ﺻﻔﺮ ﰲ ﺣﺎﻟﺔ ﳒﺎﺡ ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺔ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :EAX‬ﻋﺪﺩ ﺍﻟﻜﻴﻠﻮﺑﺎﻳﺘﺎﺕ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ 1 MB‬ﺍﱃ ‪.16 MB‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :EBX‬ﻋﺪﺩ ﺍﻟﻮﺣﺪﺍﺕ ﺍﳌﻜﻮﻧﺔ ﻣﻦ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ ﺑﺪﺋﺎ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ ‪ ،16 MB‬ﻭﳚﺐ ﺿﺮ‪‬ﺎ ﻻﺣﻘﺎ‬ ‫•‬
‫ﺑﺎﻟﻌﺪﺩ ‪ ٦٤‬ﺣﱴ ﻳﺘﻢ ﲢﻮﻳﻠﻬﺎ ﺍﱃ ﻋﺪﺩ ﺍﻟﻜﻴﻠﻮﺑﺎﻳﺘﺎﺕ‪.‬‬

‫‪١٦٢‬‬
Physical Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.١.٧

٧.٢ ‫ ﻭﺍﳌﺜﺎﻝ‬.EBX ‫ ﻭ‬EAX ‫ ﺑﺪﻻ ﻣﻦ ﺍﳌﺴﺠﻠﲔ‬EDX ‫ ﻭ‬ECX ‫ﻭﰲ ﺑﻌﺾ ﺍﻷﻧﻈﻤﺔ ﻳﺴﺘﺨﺪﻡ ﺍﻟﺒﺎﻳﻮﺱ ﺍﳌﺴﺠﻠﲔ‬
.‫ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺍﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﳌﻘﺎﻃﻌﺔ‬

Example ٧.٢: Using int 0x15 Func on 0xe801 to get size of memory
١
٢ ; −−−−−−−−−−−−−−−−−−−−−−−−−−
٣ ; get memory size:
٤ ; get a total memory size.except the first MB.
٥ ; return:
٦ ; ax=KB between 1MB and 16MB
٧ ; bx=number of 64K blocks above 16MB
٨ ; bx=0 and ax= −1 on error
٩ ; −−−−−−−−−−−−−−−−−−−−−−−−−−
١٠ get memory size:
١١
١٢ push ecx
١٣ push edx
١٤ xor ecx,ecx
١٥ xor edx,edx
١٦
١٧ mov ax,0x801 ; BIOS get memory size
١٨ int 0x15
١٩
٢٠ jc .error
٢١ cmp ah,0x86
٢٢ je .error
٢٣ cmp ah,0x80
٢٤ je .error
٢٥
٢٦ jcxz .use eax
٢٧
٢٨ mov ax,cx
٢٩ mov bx,dx
٣٠
٣١ .use eax:
٣٢ pop edx
٣٣ pop ecx
٣٤ ret
٣٥
٣٦ .error:

١٦٣
 ‫‪ .٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬

‫‪٣٧‬‬ ‫‪mov‬‬ ‫‪ax,−1‬‬

‫‪٣٨‬‬ ‫‪mov‬‬ ‫‪bx,0‬‬
‫‪٣٩‬‬ ‫‪pop‬‬ ‫‪edx‬‬
‫‪٤٠‬‬ ‫‪pop‬‬ ‫‪ecx‬‬
‫‪٤١‬‬ ‫‪ret‬‬

‫ﻭﳚﺪﺭ ﻣﻼﺣﻈﺔ ﺃﻥ ﻫﺬﺍ ﺍﳌﻘﺎﻃﻌﺔ ﻻ ﲢﺴﺐ ﺃﻭﻝ ﻣﻴﺠﺎ ﺑﺎﻳﺖ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ ‪ ،‬ﻟﺬﻟﻚ ﻋﻨﺪ ﺍﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﳚﺐ‬
‫ﺯﻳﺎﺩﺓ ﺍﳊﺠﻢ ﺍﻟﻜﻠﻲ ﲟﻘﺪﺍﺭ ‪ ١٠٢٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ )ﺍﻟﺰﻳﺎﺩﺓ ﺗﻜﻮﻥ ﰲ ﻣﺴﺠﻞ ‪ ، (ax‬ﻛﺬﻟﻚ ﳚﺐ ﺿﺮﺏ ﺍﳌﺴﺠﻞ‬
‫‪ bx‬ﺑﺎﻟﻌﺪﺩ ‪ ٦٤‬ﻧﻈﺮﺍ ﻻﻥ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﺗﻀﻌﻬﺎ ﺍﻟﺪﺍﻟﺔ ﻫﻲ ﻋﺪﺩ ﺍﻟﻮﺣﺪﺍﺕ ﺍﳌﻜﻮﻧﺔ ﻣﻦ ‪ ٦٤‬ﻛﻴﻠﻮﺑﺎﻳﺖ ‪ ،‬ﻭﻫﺬﺍ ﻳﻌﲏ‬
‫ﺍﻥ ﻛﺎﻥ ﺍﻟﻌﺪﺩ ﻫﻮ ‪ ٢‬ﻣﺜﻼ ﻓﺎﻥ ﺍﻟﻨﺘﻴﺠﺔ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ‪ 2*64‬ﻭﺗﺴﺎﻭﻱ ‪ 128‬ﻛﻴﻠﻮﺑﺎﻳﺖ‪.‬‬

‫‪Memory Map‬‬ ‫‪ .٢.١.٧‬ﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ‬

‫ﺑﻌﺪ ﺃﻥ ﰎ ﺣﺴﺎﺏ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﳚﺐ ﺍﻻﻧﺘﺒﺎﻩ ﺍﱃ ﺃﻥ ﻋﺪﺩﺍ ﻣﻨﻬﺎ ﳏﺠﻮﺯ ﻟﺒﻌﺾ ﺍﻷﻏﺮﺍﺽ )ﺭﺍﺟﻊ ﻓﻘﺮﺓ ﺧﺮﻳﻄﺔ‬
‫ﺍﻟﺬﺍﻛﺮﺓ ﰲ ﻓﺼﻞ ﺇﻗﻼﻉ ﺍﳊﺎﺳﺐ( ﻭﻫﻨﺎ ﻳﺄﰐ ﺩﻭﺭ ﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﱵ ﺗﻌﺮﻑ ﻭﲢﺪﺩ ﻟﻨﺎ ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﺍﳌﺴﺘﺨﺪﻣﺔ ﻭﺍﻟﻐﲑ ﻣﺴﺘﺨﺪﻣﺔ‪ .‬ﻭﳝﻜﻦ ﺍﳊﺼﻮﻝ ﻋﻠﻰ ﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ ﺑﻮﺍﺳﻄﺔ ﻣﻘﺎﻃﻌﺔ ﺍﻟﺒﺎﻳﻮﺱ ‪ int 0x15‬ﺍﻟﺪﺍﻟﺔ‬
‫‪ e820‬ﺍﻟﱵ ﺗﺄﺧﺬ ﺍﳌﺪﺧﻼﺕ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﺍﻟﻌﻠﻢ ‪ :CF‬ﺻﻔﺮ ﰲ ﺣﺎﻟﺔ ﳒﺎﺡ ﻋﻤﻞ ﺍﳌﻘﺎﻃﻌﺔ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :eax‬ﺍﻟﻘﻴﻤﺔ ‪ 0x534d4150‬ﻭﺗﺴﺎﻭﻱ ‪ SMAP‬ﺑﺘﺮﻣﻴﺰ ‪ ،ASCII‬ﻭﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ ﺧﻄﺄ ﻓﺎﻥ ﺭﻗﻢ‬ ‫•‬
‫ﺍﳋﻄﺄ ﺳﻴﺤﻔﻆ ﰲ ﺍﳌﺴﺠﻞ ‪.ah‬‬
‫ﺍﳌﺴﺠﻞ ‪ :ebx‬ﻋﻨﻮﺍﻥ ﺍﻟﺴﺠﻞ ﺍﻟﺘﺎﱄ ﺃﻭ ﺻﻔﺮ ﰲ ﺣﺎﻟﺔ ﺍﻹﻧﺘﻬﺎء‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :ecx‬ﻃﻮﻝ ﺍﳌﻘﻄﻊ ﺑﺎﻟﺒﺎﻳﺖ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻼﻥ ‪ :es:di‬ﺳﺠﻞ ﻭﺍﺻﻔﺔ ﺍﳌﻘﻄﻊ‪.‬‬ ‫•‬

‫ﻭﺗﻌﻮﺩ ﺑﺎﳌﺨﺮﺟﺎﺕ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪ :eax‬ﺭﻗﻢ ﺍﻟﺪﺍﻟﺔ ﻭﻫﻲ ‪.0xe820‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :ebx‬ﻋﻨﻮﺍﻥ ﺍﻟﺒﺪﺍﻳﺔ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :ecx‬ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﳌﺆﻗﺘﺔ )‪ (buffer‬ﻭﺗﺴﺎﻭﻱ ‪ ٢٠‬ﺑﺎﻳﺖ ﻋﻠﻰ ﺍﻷﻗﻞ‪.‬‬ ‫•‬

‫ﺍﳌﺴﺠﻞ ‪ :edx‬ﺍﻟﻘﻴﻤﺔ ‪ 0x534d4150‬ﻭﺗﺴﺎﻭﻱ ‪ SMAP‬ﺑﺘﺮﻣﻴﺰ ‪.ASCII‬‬ ‫•‬

‫ﺍﳌﺴﺠﻼﻥ ‪ :es:di‬ﻋﻨﻮﺍﻥ ﺍﻟﺬﺍﻛﺮﺓ ‪ buffer‬ﺍﻟﱵ ﺳﺘﺤﻔﻆ ‪‬ﺎ ﺍﻟﻨﺘﺎﺋﺞ‪.‬‬ ‫•‬

‫‪١٦٤‬‬
‫‪Physical Memory Management‬‬ ‫‪ .١.٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬

‫ﻭﺑﻌﺪ ﺗﻨﻔﻴﺬ ﺍﳌﻘﺎﻃﻌﺔ ﻓﺎﻥ ﺍﻟﺬﺍﻛﺮﺓ ‪ Buffer‬ﻳﺘﻢ ﻣﻠﺌﻬﺎ ﺑﺄﻭﻝ ﺳﺠﻞ ﻭﻫﻮ ﺑﻄﻮﻝ ‪ ٢٤‬ﺑﺎﻳﺖ ﻭﻳﺘﻢ ﺗﻜﺮﺍﺭ ﺍﺳﺘﺪﻋﺎء‬
‫ﺍﳌﻘﺎﻃﻌﺔ ﺍﱃ ﺃﻥ ﺗﻜﻮﻥ ﻗﻴﻤﺔ ﺍﳌﺴﺠﻞ ‪ ebx‬ﻣﺴﺎﻭﻳﺔ ﻟﻠﺼﻔﺮ‪ .‬ﻭﳏﺘﻮﻳﺎﺕ ﻛﻞ ﺳﺠﻞ ﻳﻮﺿﺤﻬﺎ ﺍﳌﺜﺎﻝ ‪.٧.٣‬‬
‫‪Example‬‬ ‫‪٧.٣: Memory Map Entry Structure‬‬
‫‪١‬‬
‫‪٢ ; Memory Map Entry Structure‬‬
‫‪٣ struc memory map entry‬‬
‫‪٤‬‬ ‫‪.base addr resq 1‬‬
‫‪٥‬‬ ‫‪.length‬‬ ‫‪resq 1‬‬
‫‪٦‬‬ ‫‪.type‬‬ ‫‪resd 1‬‬
‫‪٧‬‬ ‫‪.acpi null resd 1‬‬
‫‪٨‬‬ ‫‪endstruc‬‬

‫ﻭﻫﻲ ﺗﻮﺻﻒ ﻣﻘﻄﻊ ﺍﻟﺬﺍﻛﺮﺓ ﺣﻴﺚ ﲢﻮﻱ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﺍﳌﻘﻄﻊ ﻭﻃﻮﻟﻪ ﻭﻧﻮﻉ ﺍﳌﻘﻄﻊ ﻭﺃﺧﲑﺍ ﺑﻴﺎﻧﺎﺕ ﳏﺠﻮﺯﺓ‪.‬‬
‫ﻭﻧﻮﻉ ﺍﳌﻘﻄﻊ ﳛﺪﺩ ﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﺍﳌﻘﻄﻊ ﻣﺴﺘﺨﺪﻣﺎ ﺃﻭ ﳏﺠﻮﺯﺍ ﻭﻳﺄﺧﺬ ﻋﺪﺓ ﻗﻴﻢ‪:‬‬
‫ﺍﻟﻘﻴﻤﺔ ‪ :1‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﳌﻘﻄﻊ ﻣﺘﻮﻓﺮﺍ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻤﺔ ‪ :2‬ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﳌﻘﻄﻊ ﳏﺠﻮﺯﺍ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻤﺔ ‪ ACPI Reclaim Memory :3‬ﻭﻫﻲ ﻣﻨﻄﻘﺔ ﳏﺠﻮﺯﺓ ﻟﻜﻲ ﻳﺴﺘﺨﺪﻣﻬﺎ ﺍﻟﻨﻈﺎﻡ‪.‬‬ ‫•‬

‫ﺍﻟﻘﻴﻤﺔ ‪ ACPI NVS Memory:4‬ﻛﺬﻟﻚ ﻫﻲ ﻣﻨﻘﻄﺔ ﳏﺠﻮﺯﺓ ﻟﻠﻨﻈﺎﻡ‪.‬‬ ‫•‬

‫ﺑﻘﻴﺔ ﺍﻟﻘﻴﻢ ﺍﻷﺧﺮﻯ ﺗﺪﻝ ﻋﻠﻰ ﺃﻥ ﺍﳌﻘﻄﻊ ﻏﲑ ﻣﻌﺮﻑ ﺃﻭ ﻏﲑ ﻣﻮﺟﻮﺩ‪.‬‬ ‫•‬

‫ﻭﺍﳌﺜﺎﻝ ‪ ٧.٤‬ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺟﻠﺐ ﻣﻘﺎﻃﻊ ﺍﻟﺬﺍﻛﺮﺓ ﻟﻜﻲ ﻳﺴﺘﻔﻴﺪ ﻣﻨﻬﺎ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﻻﺣﻘﺎ‪.‬‬
‫‪Example‬‬ ‫‪٧.٤: Get Memory Map‬‬
‫; ‪١‬‬ ‫‪−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−‬‬
‫‪٢ ; get memory map:‬‬
‫‪٣ ; Input:‬‬
‫; ‪٤‬‬ ‫= ‪EAX‬‬ ‫‪0x0000E820‬‬
‫; ‪٥‬‬ ‫= ‪EBX‬‬ ‫‪continuation value or 0 to start at beginning of map‬‬
‫; ‪٦‬‬ ‫= ‪ECX‬‬ ‫)‪size of buffer for result (Must be >= 20 bytes‬‬
‫; ‪٧‬‬ ‫= ‪EDX‬‬ ‫)'‪0x534D4150h ('SMAP‬‬
‫; ‪٨‬‬ ‫‪ES:DI‬‬ ‫‪= Buffer for result‬‬
‫; ‪٩‬‬
‫‪١٠ ; Return:‬‬
‫; ‪١١‬‬ ‫‪CF = clear if successful‬‬

‫‪١٦٥‬‬
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

١٢ ; EAX = 0x534D4150h ('SMAP')

١٣ ; EBX = offset of next entry to copy from or 0 if done
١٤ ; ECX = actual length returned in bytes
١٥ ; ES:DI = buffer filled
١٦ ; If error, AH containes error code
١٧ ; −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
١٨ get memory map:
١٩
٢٠ pushad
٢١ xor ebx,ebx
٢٢ xor bp,bp
٢٣ mov edx,'PAMS' ; 0x534D4150
٢٤ mov eax,0xe820
٢٥ mov ecx,24
٢٦ int 0x15 ; BIOS get memory map.
٢٧
٢٨ jc .error
٢٩ cmp eax,'PAMS'
٣٠ jne .error
٣١
٣٢ test ebx,ebx
٣٣ je .error
٣٤
٣٥ jmp .start
٣٦
٣٧ .next entry:
٣٨ mov edx,'PAMS' ; 0x534D4150
٣٩ mov eax,0xe820
٤٠ mov ecx,24
٤١ int 0x15 ; BIOS get memory map.
٤٢
٤٣ .start:
٤٤ jcxz .skip entry
٤٥
٤٦ mov ecx,[es:di + memory map entry.length]
٤٧ test ecx,ecx
٤٨ jne short .good entry
٤٩ mov ecx,[es:di + memory map entry.length+4]
٥٠ jecxz .skip entry
٥١
٥٢ .good entry:

١٦٦
‫‪Physical Memory Management‬‬ ‫‪ .١.٧‬ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬

‫‪٥٣‬‬ ‫‪inc bp‬‬

‫‪٥٤‬‬ ‫‪add di,24‬‬
‫‪٥٥‬‬
‫‪٥٦‬‬ ‫‪.skip‬‬ ‫‪entry:‬‬
‫‪٥٧‬‬ ‫‪cmp‬‬ ‫‪ebx,0‬‬
‫‪٥٨‬‬ ‫‪jne‬‬ ‫‪.next entry‬‬
‫‪٥٩‬‬ ‫‪jmp‬‬ ‫‪.done‬‬
‫‪٦٠‬‬
‫‪٦١‬‬ ‫‪.error:‬‬
‫‪٦٢‬‬ ‫‪stc‬‬ ‫‪; set carry flag‬‬
‫‪٦٣‬‬
‫‪٦٤‬‬ ‫‪.done:‬‬
‫‪٦٥‬‬ ‫‪popad‬‬
‫‪٦٦‬‬ ‫‪ret‬‬
‫‪٦٧‬‬
‫‪٦٨ endstruc‬‬

‫‪ .٣.١.٧‬ﻣﻮﺍﺻﻔﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‬

‫ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﳏﻤﻼﺕ ﺍﻟﻨﻈﺎﻡ )‪ (Bootloader‬ﺗﺪﻋﻢ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ ﳌﺨﺘﻠﻒ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﻭﺫﻟﻚ ﻋﱪ ﻣﻮﺍﺻﻔﺎﺕ‬
‫ﻭﻣﻘﺎﻳﻴﺲ ﳏﺪﺩﺓ ﳚﺐ ﺃﻥ ﻳﻠﺘﺰﻡ ‪‬ﺎ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻋﻨﺪ ﲢﻤﻴﻞ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ‪ .‬ﻭﻣﻦ ﺿﻤﻦ ﻫﺬﺍ ﺍﳌﻘﻴﺎﺱ ﲤﺮﻳﺮ ﺑﻴﺎﻧﺎﺕ‬
‫ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ )‪ (Mul boot Informa on‬ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﱃ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﻭﻣﺎ ﻳﻬﻤﻨﺎ ﺣﺎﻟﻴﺎ ﻫﻮ ﲤﺮﻳﺮ‬
‫ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ ﺍﱃ ﺍﻟﻨﻮﺍﺓ ﺣﱴ ﻳﺘﻤﻜﻦ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﻣﻦ ﺇﺩﺍﺭ‪‬ﺎ ﺑﻨﺎءﺍ ﻋﻠﻰ ﺧﺮﻳﻄﺔ ﺍﻟﺬﺍﻛﺮﺓ‬
‫ﻭﺣﺠﻤﻬﺎ‪ .‬ﺣﻴﺚ ﺫﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ ﺃﻧﻪ ﺃﺛﻨﺎء ﻋﻤﻞ ﺍﻟﻨﻮﺍﺓ ﻻ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﻣﺒﺴﻄﺔ ﻟﺘﺤﺪﻳﺪ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﻭﳐﻄﻂ‬
‫ﺍﳌﻘﺎﻃﻊ ﻓﻴﻬﺎ ‪ ،‬ﻟﺬﻟﻚ ﰎ ﺍﻟﻠﺠﻮء ﺍﱃ ﻣﻘﺎﻃﻌﺎﺕ ﺍﻟﺒﺎﻳﻮﺱ ﻭﺍﻹﺳﺘﻔﺎﺩﺓ ﻣﻦ ﺧﺪﻣﺎﺗﻪ ﻭﻣﻦ ﰒ ﲤﺮﻳﺮ ﺍﻟﻨﺘﺎﺋﺞ ﺍﱃ ﻧﻮﺍﺓ‬
‫ﺍﻟﻨﻈﺎﻡ ﻋﻦ ﻃﺮﻳﻖ ﻫﻴﻜﻠﺔ ﻗﻴﺎﺳﻴﺔ ‪.١‬‬

‫ﺣﺎﻟﺔ ﺍﳊﺎﺳﺐ‬
‫ﻣﻦ ﺿﻤﻦ ﻫﺬﻩ ﺍﳌﻘﺎﻳﻴﺲ ﺃﻳﻀﺎ ﺗﻮﻓﺮ ﺣﺎﻟﺔ ﻣﻌﻴﻨﺔ ﻟﻠﺤﺎﺳﺐ )‪، (Machine State‬ﻭﻫﻲ ﺗﻨﺺ ﻋﻠﻰ ﺃﻧﻪ ﻋﻨﺪ ﲢﻤﻴﻞ‬
‫ﻧﻮﺍﺓ ﺃﻱ ﻧﻈﺎﻡ ﺗﺸﻐﻴﻞ ﻓﺎﻥ ﺑﻌﺾ ﺍﳌﺴﺠﻼﺕ ﳚﺐ ﺃﻥ ﺗﺄﺧﺬ ﻗﻴﻤﺎ ﳏﺪﺩﺓ ﻛﺎﻻﰐ‪:‬‬
‫ﺍﳌﺴﺠﻞ ‪ :eax‬ﳚﺐ ﺃﻥ ﻳﺄﺧﺬ ﺍﻟﺮﻗﻢ ‪ 0x2BADB002‬ﻭﻫﻲ ﺇﺷﺎﺭﺓ ﻟﻨﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﺑﺄﻥ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻳﺪﻋﻢ‬ ‫•‬
‫ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‪.‬‬
‫ﺍﳌﺴﺠﻞ ‪ :ebx‬ﲢﺘﻮﻱ ﻋﻠﻰ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﻫﻴﻜﻠﺔ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‪.‬‬ ‫•‬

‫‪١‬ﻋﻠﻰ ﺍﻟﺮﻏﻢ ﻣﻦ ﺃﻧﻪ ﳝﻜﻦ ﲤﺮﻳﺮ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﺄﻱ ﻃﺮﻳﻘﺔ ﺇﻻ ﺃﻥ ﺍﻹﻟﺘﺰﺍﻡ ‪‬ﻴﻜﻠﺔ ﻗﻴﺎﺳﻴﺔ ﺳﻴﻔﻴﺪ ﻻﺣﻘﺎ ﻋﻨﺪ ﺩﻋﻢ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‪.‬‬

‫‪١٦٧‬‬
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

‫ ﻭﺍﻧﺘﻬﺎءﺍ ﺑﺎﻟﻌﻨﻮﺍﻥ‬0x0 ‫ﺗﻨﻔﻴﺬ ﺑﺪءﺍ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ‬/‫ ﺑﺖ ﻗﺮﺍءﺓ‬٣٢ ‫ ﻭﺍﺻﻔﺔ ﺍﻟﺸﻔﺮﺓ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ‬:cs ‫ﺍﳌﺴﺠﻞ‬ •
.0xffffffff
0x0 ‫ ﺑﺖ ﻭﺗﺒﺪﺃ ﻣﻦ ﺍﻟﻌﻨﻮﺍﻥ‬٣٢ ‫ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﻣﻘﺎﻃﻊ ﺍﻟﻘﺮﺍءﺓ ﻭﺍﻟﻜﺘﺎﺑﺔ‬:ds,es,fs,gs,ss ‫ﺍﳌﺴﺠﻼﺕ‬ •
.0xffffffff ‫ﻭﺗﻨﺘﻬﻲ ﺑﺎﻟﻌﻨﻮﺍﻥ‬
.a20 ‫ﳚﺐ ﺗﻔﻌﻴﻞ ﺑﻮﺍﺑﺔ‬ •

‫ ﳚﺐ ﺃﻥ ﻳﻌﻄﻞ )ﺗﻌﻄﻴﻞ‬٣١ ‫ ﳚﺐ ﺃﻥ ﻳﻔﻌﻞ )ﺗﻔﻌﻴﻞ ﺍﻟﻨﻤﻂ ﺍﳌﺤﻤﻲ( ﻭﺍﻟﺒﺖ‬0 ‫ ﺍﻟﺒﺖ‬:cr0 ‫ﻣﺴﺠﻞ ﺍﻟﺘﺤﻜﻢ‬ •
.(‫ﺍﻟﺘﺼﻔﻴﺢ‬

‫ﻣﻌﻠﻮﻣﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‬

ebx ‫ﺎ ﰲ ﺍﳌﺴﺠﻞ‬‫ ﻭﻳﺘﻢ ﺣﻔﻆ ﻋﻨﻮﺍ‬، ‫ﺗﻌﺘﱪ ﻫﻴﻜﻠﺔ ﻣﻌﻠﻮﻣﺎﺕ ﺍﳌﺘﻌﺪﺩ ﻣﻦ ﺃﻫﻢ ﺍﳍﻴﺎﻛﻞ ﺍﻟﱵ ﳚﺐ ﲤﺮﻳﺮﻫﺎ ﺍﱃ ﺍﻟﻨﻮﺍﺓ‬
‫ ﻟﻜﻦ ﺑﺴﺒﺐ ﺃﻧﻨﺎ ﰲ ﻫﺬﻩ ﺍﳌﺮﺣﻠﺔ ﻻ ﻧﺪﻋﻢ ﺍﻹﻗﻼﻉ‬، ‫ﺎ ﲤﺮﻳﺮ ﺍﳍﻴﻜﻠﺔ ﺍﱃ ﺍﻟﻨﻮﺍﺓ‬ ‫ﻭﻫﻲ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ ﺍﻟﱵ ﻳﺘﻢ‬
‫ ﻳﻮﺿﺢ‬٧.٥ ‫ ﻭﺍﳌﺜﺎﻝ‬.(stack) ‫ﺎ ﺍﱃ ﺍﳌﻜﺪﺱ‬‫ﺍﳌﺘﻌﺪﺩ ﻓﻴﻤﻜﻦ ﺃﻥ ﳕﺮﺭ ﻫﺬﻩ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺑﺄﻱ ﺷﻜﻞ ﻛﺎﻥ ﻛﺪﻓﻊ ﻋﻨﻮﺍ‬
.‫ﻫﻴﻜﻠﺔ ﻣﻌﻠﻮﻣﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ‬
Example ٧.٥: Mul boot Inforam on Structure
١ boot info:
٢
٣ istruc multiboot info
٤ at multiboot info.flags, dd 0
٥ at multiboot info.mem low, dd 0
٦ at multiboot info.mem high, dd 0
٧ at multiboot info.boot device, dd 0
٨ at multiboot info.cmd line, dd 0
٩ at multiboot info.mods count, dd 0
١٠ at multiboot info.mods addr, dd 0
١١ at multiboot info.sym0, dd 0
١٢ at multiboot info.sym1, dd 0
١٣ at multiboot info.sym2, dd 0
١٤ at multiboot info.mmap length, dd 0
١٥ at multiboot info.mmap addr, dd 0
١٦ at multiboot info.drives length, dd 0
١٧ at multiboot info.drives addr, dd 0
١٨ at multiboot info.config table, dd 0
١٩ at multiboot info.bootloader name, dd 0
٢٠ at multiboot info.apm table, dd 0

١٦٨
Physical Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.١.٧

٢١ at multiboot info.vbe control info, dd 0

٢٢ at multiboot info.vbe mode info, dw 0
٢٣ at multiboot info.vbe interface seg, dw 0
٢٤ at multiboot info.vbe interface off, dw 0
٢٥ at multiboot info.vbe interface len, dw 0
٢٦ iend

‫ ﻟﺘﺤﺪﻳﺪ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﺴﺘﺨﺪﻣﺔ ﰲ ﻫﻴﻜﻠﺔ ﻣﻌﻠﻮﻣﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ ﻣﻦ‬flags ‫ﻭﳛﺪﺩ ﺍﳌﻘﻴﺎﺱ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﺘﻐﲑ‬
mem high ‫ ﻭ‬mem low ‫ ﻓﺎﻥ ﺍﳌﺘﻐﲑﺍﺕ‬١ ‫ ﻫﻲ‬flags[0] ‫ ﻓﻤﺜﻼ ﰲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺍﻟﺒﺖ‬، ‫ﻏﲑ ﺍﳌﺴﺘﺨﺪﻣﺔ‬
mem low ‫ ﻭﺳﻴﺘﻢ ﻭﺿﻊ ﻗﻴﻢ ﻟﻠﻤﺘﻐﲑﺍﺕ‬flags ‫ﻭﺣﺎﻟﻴﺎ ﻟﻦ ﻳﺘﻢ ﺍﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﺍﳌﺘﻐﲑ‬.‫ﳝﻜﻦ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻭﻫﻜﺬﺍ‬
‫ ﻭﻛﺬﻟﻚ ﺍﳌﺘﻐﲑﺍﺕ‬، ‫ ﻭﺍﻟﱵ ﲢﻮﻱ ﺣﺠﻢ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ ﻭﺍﻟﱵ ﰎ ﺟﻠﺒﻬﺎ ﺑﻮﺍﺳﻄﺔ ﺍﻟﺒﺎﻳﻮﺱ‬mem high ‫ﻭ‬
‫ ﻭﺍﻟﱵ ﺗﻮﺿﺢ ﻋﻨﻮﺍﻥ ﺑﺪﺍﻳﺔ ﳐﻄﻂ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺬﻱ ﰎ ﺟﻠﺒﻪ ﺃﻳﻀﺎ ﺑﻮﺍﺳﻄﺔ ﺍﻟﺒﺎﻳﻮﺱ‬mmap length ‫ ﻭ‬mmap addr
‫ ﻳﻮﺿﺢ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﰎ ﺇﺿﺎﻓﺘﻬﺎ ﺍﱃ ﺍﳌﺮﺣﻠﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻣﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﻟﺪﻋﻢ ﺍﻹﻗﻼﻉ‬٧.٦ ‫ﻭﺍﳌﺜﺎﻝ‬.‫ﻭﻛﺬﻟﻚ ﻃﻮﳍﺎ‬
.‫ﺍﳌﺘﻌﺪﺩ ﻭﻛﻴﻔﻴﺔ ﺣﻔﻆ ﻣﻌﻠﻮﻣﺎﺕ ﺍﻹﻗﻼﻉ ﺍﳌﺘﻌﺪﺩ ﻭﺍﺭﺳﺎﳍﺎ ﺍﱃ ﻧﻮﺍﺓ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ‬
Example ٧.٦: snippet from stage2 bootloader
١
٢ ...
٣ ; when stage2 begin started, BIOS put drive number where stage1 are
loaded from in dl
٤ mov [boot info+multiboot info.boot device],dl
٥ ...
٦
٧ ;−−−−−−−−−−−−−−−−
٨ ; Get Memory Size
٩ ;−−−−−−−−−−−−−−−−
١٠ xor eax,eax
١١ xor ebx,ebx
١٢ call get memory size
١٣
١٤ mov [boot info+multiboot info.mem low],ax
١٥ mov [boot info+multiboot info.mem high],bx
١٦
١٧ ...
١٨
١٩ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٠ ; Pass MultiBoot Info to the Kernel
٢١ ;−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
٢٢ mov eax,0x2badb002

١٦٩
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

٢٣ mov ebx,0
٢٤ mov edx,[kernel size]
٢٥ push dword boot info
٢٦
٢٧ call ebp ; Call Kernel

‫ ﻭﰎ ﺍﻧﺸﺎء ﻫﻴﻜﻠﺔ ﺑﻠﻐﺔ‬، ‫ﻭﻋﻨﺪ ﺍﺳﺘﺪﻋﺎء ﺍﻟﻨﻮﺍﺓ ﻓﺎﻥ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﱵ ﰎ ﺩﻓﻌﻬﺎ ﺍﱃ ﺍﳌﻜﺪﺱ ﺗﻌﺘﱪ ﻛﻮﺳﻴﻂ ﻟﻠﺪﺍﻟﺔ‬
‫ﺎ ﺑﺸﻜﻞ ﻣﺒﺴﻂ‬‫ﺍﻟﺴﻲ )ﺑﺪﺍﺧﻞ ﺍﻟﻨﻮﺍﺓ( ﺑﻨﻔﺲ ﺣﺠﻢ ﺍﳍﻴﻜﻠﺔ ﺍﻟﱵ ﰎ ﺩﻓﻌﻬﺎ ﺍﱃ ﺍﳌﻜﺪﺱ ﻭﺫﻟﻚ ﻟﻘﺮﺍءﺓ ﳏﺘﻮﻳﺎ‬
.‫ ﻳﻮﺿﺢ ﻛﻴﻔﻴﺔ ﺍﺳﺘﻘﺒﺎﻝ ﺍﻟﻨﻮﺍﺓ ﳍﺬﻩ ﺍﳍﻴﻜﻠﺔ‬٧.٧ ‫ﻭﺍﳌﺜﺎﻝ‬.‫ﻭﻣﻘﺮﻭء‬
Example ٧.٧: Kernel Entry
١
٢ void cdecl kernel entry (multiboot info ∗ boot info)
٣ {
٤
٥ #ifdef i386
٦ asm {
٧ cli
٨
٩ mov ax, 10h // select data descriptor in GDT.
١٠ mov ds, ax
١١ mov es, ax
١٢ mov fs, ax
١٣ mov gs, ax
١٤ }
١٥ #endif
١٦
١٧ // Execute global constructors
١٨ init ctor();
١٩
٢٠ // Call kernel entry point
٢١ main(boot info);
٢٢
٢٣ // Cleanup all dynamic dtors
٢٤ exit();
٢٥
٢٦ #ifdef i386
٢٧ asm {
٢٨ cli
٢٩ hlt

١٧٠
Physical Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.١.٧

٣٠ }
٣١ #endif
٣٢
٣٣ for(;;);
٣٤ }

‫ ﻣﺪﻳﺮ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.٤.١.٧

Example ٧.٨: Physical Memory Manager Interface

١
٢ #ifndef PMM H
٣ #define PMM H
٤
٥ #include <stdint.h>
٦
٧ extern void pmm init(size t size,uint32 t base);
٨ extern void pmm init region(uint32 t base,size t size);
٩ extern void pmm deinit region(uint32 t base,size t size);
١٠ extern void∗ pmm alloc();
١١ extern void∗ pmm allocs(size t size);
١٢ extern void pmm dealloc(void∗);
١٣ extern void pmm deallocs(void∗,size t);
١٤ extern size t pmm get mem size();
١٥ extern uint32 t pmm get block count();
١٦ extern uint32 t pmm get used block count();
١٧ extern uint32 t pmm get free block count();
١٨ extern uint32 t pmm get block size();
١٩ extern void pmm enable paging(bool);
٢٠ extern bool pmm is paging();
٢١ extern void pmm load PDBR(uint32 t);
٢٢ extern uint32 t pmm get PDBR();
٢٣
٢٤ #endif // PMM H

Example ٧.٩: Physical Memory Manager Implemeta on

١

١٧١
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

٢ #include <string.h>
٣ #include "pmm.h"
٤ #include "kdisplay.h"
٥
٦ #define PMM BLOCK PER BYTE 8
٧ #define PMM PAGE SIZE 4096
٨ #define PMM BLOCK SIZE PMM PAGE SIZE
٩ #define PMM BLOCK ALIGN PMM BLOCK SIZE
١٠
١١ static uint32 t pmm mem size = 0;
١٢ static uint32 t pmm max blocks = 0;
١٣ static uint32 t pmm used blocks = 0;
١٤ static uint32 t ∗ pmm mmap = 0;
١٥
١٦ inline void mmap set(int bit) {
١٧ pmm mmap[bit/32] = pmm mmap[bit/32] | (1 << (bit%32)) ;
١٨ }
١٩
٢٠ inline void mmap unset(int bit) {
٢١ pmm mmap[bit/32] = pmm mmap[bit/32] & ˜(1 << (bit%32));
٢٢ }
٢٣
٢٤ inline bool mmap test(int bit) {
٢٥ return pmm mmap[bit/32] & (1 << (bit%32));
٢٦ }
٢٧
٢٨ int mmap find first() {
٢٩
٣٠ for (uint32 t i=0;i<pmm get free block count()/32;++i) {
٣١ if ( pmm mmap[i] != 0xffffffff) {
٣٢ for (int j=0;j<32;++j) {
٣٣ int bit = 1 << j;
٣٤ if (!( pmm mmap[i] & bit))
٣٥ return i∗32+j;
٣٦ }
٣٧ }
٣٨ }
٣٩
٤٠ return −1;
٤١ }
٤٢

١٧٢
Physical Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.١.٧

٤٣ int mmap find squence(size t s) {

٤٤ if (s == 0)
٤٥ return −1;
٤٦
٤٧ if (s == 1)
٤٨ return mmap find first();
٤٩
٥٠ for (uint32 t i=0;i<pmm get free block count()/32;++i) {
٥١ if ( pmm mmap[i] != 0xffffffff) {
٥٢ for (int j=0;j<32;++j) {
٥٣ int bit = 1 << j;
٥٤ if (!( pmm mmap[i] & bit)) {
٥٥
٥٦ int start bit = i∗32 + bit;
٥٧ uint32 t free bit = 0;
٥٨
٥٩ for (uint32 t count=0;count<=s;++count) {
٦٠ if (!(mmap test(start bit+count)))
٦١ free bit++;
٦٢
٦٣ if (free bit == s)
٦٤ return i∗32+j;
٦٥ }
٦٦ }
٦٧ }
٦٨ }
٦٩ }
٧٠
٧١ return −1;
٧٢ }
٧٣
٧٤
٧٥ void pmm init(size t size,uint32 t mmap base) {
٧٦ pmm mem size = size;
٧٧ pmm mmap = (uint32 t ∗)mmap base;
٧٨ pmm max blocks = pmm mem size ∗1024 / PMM BLOCK SIZE;
٧٩ pmm used blocks = pmm max blocks; // all memory used by default
٨٠
٨١ memset( pmm mmap,0xf, pmm max blocks/PMM BLOCK PER BYTE);
٨٢ }
٨٣

١٧٣
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

٨٤ void pmm init region(uint32 t base,size t size) {

٨٥ int align = base/PMM BLOCK SIZE;
٨٦ int blocks = size/PMM BLOCK SIZE;
٨٧
٨٨ for (;blocks >=0;blocks−−) {
٨٩ mmap unset(align++);
٩٠ pmm used blocks−−;
٩١ }
٩٢
٩٣ mmap set(0);
٩٤ }
٩٥
٩٦ void pmm deinit region(uint32 t base,size t size) {
٩٧ int align = base/PMM BLOCK SIZE;
٩٨ int blocks = size/PMM BLOCK SIZE;
٩٩
١٠٠ for (;blocks >=0;blocks−−) {
١٠١ mmap set(align++);
١٠٢ pmm used blocks++;
١٠٣ }
١٠٤ }
١٠٥
١٠٦ void∗ pmm alloc() {
١٠٧ if (pmm get free block count() <= 0)
١٠٨ return 0;
١٠٩
١١٠ int block = mmap find first();
١١١
١١٢ if (block == −1)
١١٣ return 0;
١١٤
١١٥ mmap set(block);
١١٦
١١٧ uint32 t addr = block ∗ PMM BLOCK SIZE;
١١٨ pmm used blocks++;
١١٩
١٢٠ return (void∗) addr;
١٢١ }
١٢٢
١٢٣ void∗ pmm allocs(size t s) {
١٢٤ if (pmm get free block count() <= s)

١٧٤
 Physical Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﻔﻴﺰﻳﺎﺋﻴﺔ‬.١.٧

١٢٥ return 0;
١٢٦
١٢٧ int block = mmap find squence(s);
١٢٨
١٢٩ if (block == −1)
١٣٠ return 0;
١٣١
١٣٢ for (uint32 t i=0;i<s;++i)
١٣٣ mmap set(block+i);
١٣٤
١٣٥ uint32 t addr = block ∗ PMM BLOCK SIZE;
١٣٦ pmm used blocks += s;
١٣٧
١٣٨ return (void∗) addr;
١٣٩ }
١٤٠
١٤١ void pmm dealloc(void∗ p) {
١٤٢ uint32 t addr = (uint32 t)p;
١٤٣ int block = addr / PMM BLOCK SIZE;
١٤٤ mmap unset(block);
١٤٥ pmm used blocks−−;
١٤٦ }
١٤٧
١٤٨ void pmm deallocs(void∗ p,size t s) {
١٤٩ uint32 t addr = (uint32 t)p;
١٥٠ int block = addr / PMM BLOCK SIZE;
١٥١
١٥٢ for (uint32 t i=0;i<s;++i)
١٥٣ mmap unset(block+i);
١٥٤
١٥٥ pmm used blocks −= s;
١٥٦ }
١٥٧
١٥٨ size t pmm get mem size() {
١٥٩ return pmm mem size;
١٦٠ }
١٦١
١٦٢ uint32 t pmm get block count() {
١٦٣ return pmm max blocks;
١٦٤ }
١٦٥

١٧٥
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

١٦٦ uint32 t pmm get used block count() {

١٦٧ return pmm used blocks;
١٦٨ }
١٦٩
١٧٠ uint32 t pmm get free block count() {
١٧١ return pmm max blocks − pmm used blocks;
١٧٢ }
١٧٣
١٧٤ uint32 t pmm get block size() {
١٧٥ return PMM BLOCK SIZE;
١٧٦ }
١٧٧
١٧٨ void pmm enable paging(bool val) {
١٧٩ #ifdef MSC VER
١٨٠ asm {
١٨١
١٨٢ mov eax,cr0
١٨٣ cmp [val],1
١٨٤ je enable
١٨٥ jmp disable
١٨٦
١٨٧ enable:
١٨٨ or eax,0x80000000 // set last bit
١٨٩ mov cr0,eax
١٩٠ jmp done
١٩١
١٩٢ disable:
١٩٣ and eax,0x7fffffff // unset last bit
١٩٤ mov cr0,eax
١٩٥
١٩٦ done:
١٩٧ }
١٩٨
١٩٩ #endif
٢٠٠ }
٢٠١
٢٠٢ bool pmm is paging() {
٢٠٣ uint32 t val = 0;
٢٠٤ #ifdef MSC VER
٢٠٥ asm {
٢٠٦ mov eax,cr0

١٧٦
 Virtual Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ‬.٢.٧

٢٠٧ mov [val],eax

٢٠٨ }
٢٠٩
٢١٠ if ( val & 0x80000000 )
٢١١ false;
٢١٢ else
٢١٣ true;
٢١٤ #endif
٢١٥ }
٢١٦
٢١٧ void pmm load PDBR(uint32 t addr) {
٢١٨ #ifdef MSC VER
٢١٩ asm {
٢٢٠ mov eax,[addr]
٢٢١ mov cr3,eax
٢٢٢ }
٢٢٣ #endif
٢٢٤ }
٢٢٥
٢٢٦ uint32 t pmm get PDBR() {
٢٢٧ #ifdef MSC VER
٢٢٨ asm {
٢٢٩ mov eax,cr3
٢٣٠ ret
٢٣١ }
٢٣٢ #endif
٢٣٣ }

Virtual Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ‬.٢.٧

Example ٧.١٠: Virtual Memory Manager Interface

١
٢ #ifndef VMM H
٣ #define VMM H
٤
٥ #include <stdint.h>
٦
٧ #include "vmm pte.h"
٨ #include "vmm pde.h"

١٧٧
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

٩
١٠ #define PTE N 1024
١١ #define PDE N 1024
١٢
١٣ struct page table {
١٤ uint32 t pte[PTE N];
١٥ };
١٦
١٧ struct page dir table {
١٨ uint32 t pde[PDE N];
١٩ };
٢٠
٢١ extern void vmm init();
٢٢ extern bool vmm alloc page(uint32 t ∗ e);
٢٣ extern void vmm free page(uint32 t ∗ e);
٢٤ extern bool vmm switch page dir table(page dir table ∗);
٢٥ extern page dir table ∗ vmm get page dir table();
٢٦ extern void vmm flush tlb entry(uint32 t addr);
٢٧ extern void vmm page table clear(page table ∗ pt);
٢٨ extern uint32 t vmm vir to page table index(uint32 t addr);
٢٩ extern uint32 t ∗ vmm page table lookup entry(page table ∗ pt,uint32 t
addr);
٣٠ extern uint32 t vmm vir to page dir table index(uint32 t addr);
٣١ extern void vmm page dir table clear(page dir table ∗ pd);
٣٢ extern uint32 t ∗ vmm page dir table lookup entry(page dir table ∗ pd,
uint32 t addr);
٣٣
٣٤
٣٥ #endif // VMM H

Example ٧.١١: Virtual Memory Manager Implemeta on

١
٢ #include "vmm.h"
٣
٤ #include <string.h>
٥ #include "vmm.h"
٦ #include "pmm.h"
٧
٨ #define PAGE SIZE 4096

١٧٨
Virtual Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ‬.٢.٧

٩ #define PT ADDRESS SPACE SIZE 0x400000

١٠ #define PD ADDRESS SPACE SIZE 0x100000000
١١
١٢ page dir table ∗ cur page dir = 0;
١٣ uint32 t cur page dir base register = 0;
١٤
١٥ void vmm init() {
١٦ page table ∗ pt = (page table ∗) pmm alloc();
١٧ if (!pt)
١٨ return ;
١٩
٢٠ vmm page table clear(pt);
٢١
٢٢ for (int i=0, frame =0; i < 1024 ; ++i, frame += 4096) {
٢٣ uint32 t page = 0;
٢٤ pte add attrib(&page,I386 PTE PRESENT);
٢٥ pte set frame(&page,frame);
٢٦
٢٧ pt−>pte[vmm vir to page table index(frame)] = page;
٢٨ }
٢٩
٣٠ page dir table ∗ pd = (page dir table ∗) pmm allocs(3);
٣١ if (!pd)
٣٢ return ;
٣٣
٣٤ vmm page dir table clear(pd);
٣٥
٣٦ uint32 t ∗ pde = vmm page dir table lookup entry(pd,0);
٣٧ pde add attrib(pde,I386 PDE PRESENT);
٣٨ pde add attrib(pde,I386 PDE WRITABLE);
٣٩ pde set frame(pde,(uint32 t)pt);
٤٠
٤١ cur page dir base register = (uint32 t) &pd−>pde;
٤٢ vmm switch page dir table(pd);
٤٣
٤٤ pmm enable paging(true);
٤٥
٤٦ }
٤٧
٤٨ bool vmm alloc page(uint32 t ∗ e) {
٤٩ void∗ p = pmm alloc();

١٧٩
 ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ‬.٧

٥٠ if (!p)
٥١ return false;
٥٢
٥٣ pte set frame(e,(uint32 t)p);
٥٤ pte add attrib(e,I386 PTE PRESENT);
٥٥
٥٦ return true;
٥٧ }
٥٨
٥٩ void vmm free page(uint32 t ∗ e) {
٦٠ void∗ p = (void∗)pte get frame(∗e);
٦١
٦٢ if (p)
٦٣ pmm dealloc(p);
٦٤
٦٥ pte del attrib(e,I386 PTE PRESENT);
٦٦
٦٧ }
٦٨
٦٩
٧٠ bool vmm switch page dir table(page dir table ∗ pd) {
٧١ if (!pd)
٧٢ return false;
٧٣
٧٤ cur page dir = pd;
٧٥ pmm load PDBR( cur page dir base register);
٧٦ return true;
٧٧ }
٧٨
٧٩ page dir table ∗ vmm get page dir table() {
٨٠ return cur page dir;
٨١ }
٨٢
٨٣ void vmm flush tlb entry(uint32 t addr) {
٨٤ #ifdef MSC VER
٨٥ asm {
٨٦ cli
٨٧ invlpg addr
٨٨ sti
٨٩ }
٩٠ #endif

١٨٠
 Virtual Memory Management ‫ ﺇﺩﺍﺭﺓ ﺍﻟﺬﺍﻛﺮﺓ ﺍﻟﺘﺨﻴﻠﻴﺔ‬.٢.٧

٩١ }
٩٢
٩٣ void vmm page table clear(page table ∗ pt) {
٩٤ if (pt)
٩٥ memset(pt,0,sizeof(page table));
٩٦ }
٩٧
٩٨ uint32 t vmm vir to page table index(uint32 t addr) {
٩٩ if ( addr >= PT ADDRESS SPACE SIZE )
١٠٠ return 0;
١٠١ else
١٠٢ return addr / PAGE SIZE;
١٠٣ }
١٠٤
١٠٥ uint32 t ∗ vmm page table lookup entry(page table ∗ pt,uint32 t addr) {
١٠٦ if (pt)
١٠٧ return &pt−>pte[vmm vir to page table index(addr)];
١٠٨ else
١٠٩ return 0;
١١٠ }
١١١
١١٢ uint32 t vmm vir to page dir table index(uint32 t addr) {
١١٣ if ( addr >= PD ADDRESS SPACE SIZE )
١١٤ return 0;
١١٥ else
١١٦ return addr / PAGE SIZE;
١١٧ }
١١٨
١١٩ void vmm page dir table clear(page dir table ∗ pd) {
١٢٠ if (pd)
١٢١ memset(pd,0,sizeof(page dir table));
١٢٢ }
١٢٣
١٢٤ uint32 t ∗ vmm page dir table lookup entry(page dir table ∗ pd,uint32 t
addr) {
١٢٥ if (pd)
١٢٦ return &pd−>pde[vmm vir to page table index(addr)];
١٢٧ else
١٢٨ return 0;
١٢٩ }

١٨١
 Device Driver ‫ ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬.٨
Keyboard Driver ‫ ﺑﺮﳎﺔ ﻣﺸﻐﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬.١.٨

Example ٨.١: Keybaord Driver Interface

١
٢ #ifndef KEYBOARD H
٣ #define KEYBOARD H
٤
٥ #include <stdint.h>
٦
٧ enum KEY CODE {
٨ KEY SPACE = ' ',
٩ KEY 0 = '0',
١٠ KEY 1 = '1',
١١ KEY 2 = '2',
١٢ KEY 3 = '3',
١٣ KEY 4 = '4',
١٤ KEY 5 = '5',
١٥ KEY 6 = '6',
١٦ KEY 7 = '7',
١٧ KEY 8 = '8',
١٨ KEY 9 = '9',
١٩ KEY A = 'a',
٢٠ KEY B = 'b',
٢١ KEY C = 'c',
٢٢ KEY D = 'd',
٢٣ KEY E = 'e',
٢٤ KEY F = 'f',
٢٥ KEY G = 'g',
٢٦ KEY H = 'h',
٢٧ KEY I = 'i',
٢٨ KEY J = 'j',
٢٩ KEY K = 'k',

١٨٣
 Device Driver ‫ ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬.٨

٣٠ KEY L = 'l',
٣١ KEY M = 'm',
٣٢ KEY N = 'n',
٣٣ KEY O = 'o',
٣٤ KEY P = 'p',
٣٥ KEY Q = 'q',
٣٦ KEY R = 'r',
٣٧ KEY S = 's',
٣٨ KEY T = 't',
٣٩ KEY U = 'u',
٤٠ KEY V = 'v',
٤١ KEY W = 'w',
٤٢ KEY X = 'x',
٤٣ KEY Y = 'y',
٤٤ KEY Z = 'z',
٤٥ KEY RETURN = '\r',
٤٦ KEY ESCAPE = 0x1001,
٤٧ KEY BACKSPACE = '\b',
٤٨ KEY UP = 0x1100,
٤٩ KEY DOWN = 0x1101,
٥٠ KEY LEFT = 0x1102,
٥١ KEY RIGHT = 0x1103,
٥٢ KEY F1 = 0x1201,
٥٣ KEY F2 = 0x1202,
٥٤ KEY F3 = 0x1203,
٥٥ KEY F4 = 0x1204,
٥٦ KEY F5 = 0x1205,
٥٧ KEY F6 = 0x1206,
٥٨ KEY F7 = 0x1207,
٥٩ KEY F8 = 0x1208,
٦٠ KEY F9 = 0x1209,
٦١ KEY F10 = 0x120a,
٦٢ KEY F11 = 0x120b,
٦٣ KEY F12 = 0x120b,
٦٤ KEY F13 = 0x120c,
٦٥ KEY F14 = 0x120d,
٦٦ KEY F15 = 0x120e,
٦٧ KEY DOT = '.',
٦٨ KEY COMMA = ',',
٦٩ KEY COLON = ':',
٧٠ KEY SEMICOLON = ';',

١٨٤
 Keyboard Driver ‫ ﺑﺮﳎﺔ ﻣﺸﻐﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬.١.٨

٧١ KEY SLASH = '/',

٧٢ KEY BACKSLASH = ' \\ ',
٧٣ KEY PLUS = '+',
٧٤ KEY MINUS = '−',
٧٥ KEY ASTERISK = '∗',
٧٦ KEY EXCLAMATION = '!',
٧٧ KEY QUESTION = '?',
٧٨ KEY QUOTEDOUBLE = '\"',
٧٩ KEY QUOTE = '\'',
٨٠ KEY EQUAL = '=',
٨١ KEY HASH = '#',
٨٢ KEY PERCENT = '%',
٨٣ KEY AMPERSAND = '&',
٨٤ KEY UNDERSCORE = ' ',
٨٥ KEY LEFTPARENTHESIS = '(',
٨٦ KEY RIGHTPARENTHESIS = ')',
٨٧ KEY LEFTBRACKET = '[',
٨٨ KEY RIGHTBRACKET = ']',
٨٩ KEY LEFTCURL = '{',
٩٠ KEY RIGHTCURL = '}',
٩١ KEY DOLLAR = '$',
٩٢ KEY POUND = '£',
٩٣ KEY EURO = '$',
٩٤ KEY LESS = '<',
٩٥ KEY GREATER = '>',
٩٦ KEY BAR = ' | ',
٩٧ KEY GRAVE = '`',
٩٨ KEY TILDE = '˜',
٩٩ KEY AT = '@',
١٠٠ KEY CARRET = 'ˆ',
١٠١ KEY KP 0 = '0',
١٠٢ KEY KP 1 = '1',
١٠٣ KEY KP 2 = '2',
١٠٤ KEY KP 3 = '3',
١٠٥ KEY KP 4 = '4',
١٠٦ KEY KP 5 = '5',
١٠٧ KEY KP 6 = '6',
١٠٨ KEY KP 7 = '7',
١٠٩ KEY KP 8 = '8',
١١٠ KEY KP 9 = '9',
١١١ KEY KP PLUS = '+',

١٨٥
 Device Driver ‫ ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬.٨

١١٢ KEY KP MINUS = '−',

١١٣ KEY KP DECIMAL = '.',
١١٤ KEY KP DIVIDE = '/',
١١٥ KEY KP ASTERISK = '∗',
١١٦ KEY KP NUMLOCK = 0x300f,
١١٧ KEY KP ENTER = 0x3010,
١١٨ KEY TAB = 0x4000,
١١٩ KEY CAPSLOCK = 0x4001,
١٢٠ KEY LSHIFT = 0x4002,
١٢١ KEY LCTRL = 0x4003,
١٢٢ KEY LALT = 0x4004,
١٢٣ KEY LWIN = 0x4005,
١٢٤ KEY RSHIFT = 0x4006,
١٢٥ KEY RCTRL = 0x4007,
١٢٦ KEY RALT = 0x4008,
١٢٧ KEY RWIN = 0x4009,
١٢٨ KEY INSERT = 0x400a,
١٢٩ KEY DELETE = 0x400b,
١٣٠ KEY HOME = 0x400c,
١٣١ KEY END = 0x400d,
١٣٢ KEY PAGEUP = 0x400e,
١٣٣ KEY PAGEDOWN = 0x400f,
١٣٤ KEY SCROLLLOCK = 0x4010,
١٣٥ KEY PAUSE = 0x4011,
١٣٦ KEY UNKNOWN,
١٣٧ KEY NUMKEYCODES
١٣٨ };
١٣٩
١٤٠ extern bool keyboard get scroll lock();
١٤١ extern bool keyboard get caps lock();
١٤٢ extern bool keyboard get num lock();
١٤٣ extern bool keyboard get alt();
١٤٤ extern bool keyboard get ctrl();
١٤٥ extern bool keyboard get shift();
١٤٦ extern void keyboard ignore resend();
١٤٧ extern bool keyboard check resend();
١٤٨ extern bool keyboard get diagnostic res();
١٤٩ extern bool keyboard get bat res();
١٥٠ extern bool keyboard self test();
١٥١ extern uint8 t keyboard get last scan();
١٥٢ extern KEY CODE keyboard get last key();

١٨٦
 Keyboard Driver ‫ ﺑﺮﳎﺔ ﻣﺸﻐﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬.١.٨

١٥٣ extern void keyboard discard last key();

١٥٤ extern void keyboard set leds(bool nums,bool caps,bool scroll);
١٥٥ extern char keyboard key to ascii(KEY CODE k);
١٥٦ extern void keyboard enable();
١٥٧ extern void keyboard disable();
١٥٨ extern bool keyboard is disabled();
١٥٩ extern void keyboard reset system();
١٦٠ extern void keyboard install(int);
١٦١
١٦٢ #endif // KEYBOARD H

Example ٨.٢: Keybaord Driver Implemeta on

١
٢ void keyboard install(int irq) {
٣ // Install interrupt handler (irq 1 uses interrupt 33)
٤ set vector(irq, i386 keyboard irq);
٥
٦ // assume BAT test is good. If there is a problem, the IRQ handler
where catch the error
٧ keyboard bat res = true;
٨ scancode = 0;
٩
١٠ // set lock keys and led lights
١١ numlock = scrolllock = capslock = false;
١٢ keyboard set leds (false, false, false);
١٣
١٤ // shift, ctrl, and alt keys
١٥ shift = alt = ctrl = false;
١٦ }
١٧
١٨
١٩ // keyboard interrupt handler
٢٠ void cdecl i386 keyboard irq () {
٢١
٢٢ asm add esp, 12
٢٣ asm pushad
٢٤ asm cli
٢٥
٢٦ static bool extended = false;

١٨٧
 Device Driver ‫ ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬.٨

٢٧
٢٨ int code = 0;
٢٩
٣٠ // read scan code only if the keyboard controller output buffer is
full (scan code is in it)
٣١ if (keyboard ctrl read status () & KEYBOARD CTRL STATS MASK OUT BUF
) {
٣٢
٣٣ // read the scan code
٣٤ code = keyboard enc read buf ();
٣٥
٣٦ // is this an extended code? If so, set it and return
٣٧ if (code == 0xE0 | | code == 0xE1)
٣٨ extended = true;
٣٩ else {
٤٠
٤١ // either the second byte of an extended scan code or a single
byte scan code
٤٢ extended = false;
٤٣
٤٤ // test if this is a break code (Original XT Scan Code Set
specific)
٤٥ if (code & 0x80) { //test bit 7
٤٦
٤٧ // covert the break code into its make code equivelant
٤٨ code −= 0x80;
٤٩
٥٠ // grab the key
٥١ int key = keyboard scancode std [code];
٥٢
٥٣ // test if a special key has been released & set it
٥٤ switch (key) {
٥٥
٥٦ case KEY LCTRL:
٥٧ case KEY RCTRL:
٥٨ ctrl = false;
٥٩ break;
٦٠
٦١ case KEY LSHIFT:
٦٢ case KEY RSHIFT:
٦٣ shift = false;

١٨٨
 Keyboard Driver ‫ ﺑﺮﳎﺔ ﻣﺸﻐﻞ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ‬.١.٨

٦٤ break;
٦٥
٦٦ case KEY LALT:
٦٧ case KEY RALT:
٦٨ alt = false;
٦٩ break;
٧٠ }
٧١ }
٧٢ else {
٧٣
٧٤ // this is a make code − set the scan code
٧٥ scancode = code;
٧٦
٧٧ // grab the key
٧٨ int key = keyboard scancode std [code];
٧٩
٨٠ // test if user is holding down any special keys & set it
٨١ switch (key) {
٨٢
٨٣ case KEY LCTRL:
٨٤ case KEY RCTRL:
٨٥ ctrl = true;
٨٦ break;
٨٧
٨٨ case KEY LSHIFT:
٨٩ case KEY RSHIFT:
٩٠ shift = true;
٩١ break;
٩٢
٩٣ case KEY LALT:
٩٤ case KEY RALT:
٩٥ alt = true;
٩٦ break;
٩٧
٩٨ case KEY CAPSLOCK:
٩٩ capslock = ( capslock) ? false : true;
١٠٠ keyboard set leds ( numlock, capslock, scrolllock);
١٠١ break;
١٠٢
١٠٣ case KEY KP NUMLOCK:
١٠٤ numlock = ( numlock) ? false : true;

١٨٩
 Device Driver ‫ ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬.٨

١٠٥ keyboard set leds ( numlock, capslock, scrolllock);

١٠٦ break;
١٠٧
١٠٨ case KEY SCROLLLOCK:
١٠٩ scrolllock = ( scrolllock) ? false : true;
١١٠ keyboard set leds ( numlock, capslock, scrolllock);
١١١ break;
١١٢ }
١١٣ }
١١٤ }
١١٥
١١٦ // watch for errors
١١٧ switch (code) {
١١٨
١١٩ case KEYBOARD ERR BAT FAILED:
١٢٠ keyboard bat res = false;
١٢١ break;
١٢٢
١٢٣ case KEYBOARD ERR DIAG FAILED:
١٢٤ keyboard diag res = false;
١٢٥ break;
١٢٦
١٢٧ case KEYBOARD ERR RESEND CMD:
١٢٨ keyboard resend res = true;
١٢٩ break;
١٣٠ }
١٣١ }
١٣٢
١٣٣ // tell hal we are done
١٣٤ int done(0);
١٣٥
١٣٦ // return from interrupt handler
١٣٧ asm sti
١٣٨ asm popad
١٣٩ asm iretd
١٤٠ }

١٩٠
 ‫ﺍﳋﺎﲤﺔ‬
‫ﻭﻫﻜﺬﺍ ﻧﺼﻞ ﺍﱃ ‪‬ﺎﻳﺔ ﺍﳌﻄﺎﻑ ﳍﺬﺍ ﺍﻟﺒﺤﺚ ﺍﳌﺘﻮﺍﺿﻊ ﻭﺍﻟﺬﻱ ﻧﺮﺟﻮ ﺃﻥ ﻳﻜﻮﻥ ﺇﺿﺎﻓﺔ ﻭﻟﻮ ﻳﺴﲑﺓ ﻟﻠﻤﻜﺘﺒﺔ ﺍﻟﻌﺮﺑﻴﺔ‬
‫ﻭﻟﻠﻘﺎﺭﺉ ﺍﻟﻌﺮﰊ ﰲ ﳎﺎﻝ ﺑﺮﳎﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﻭﻧﺴﺄﻝ ﺍﷲ ﺗﻌﺎﱃ ﺃﻥ ﻳﻨﻔﻌﻨﺎ ﲟﺎ ﻋﻠﻤﻨﺎ ﻭﺃﻥ ﻳﻨﻔﻊ ﺑﻨﺎ ﺍﻹﺳﻼﻡ‬
‫ﻭﺍﳌﺴﻠﻤﲔ ﻭﺃﻥ ﻳﻌﻴﻨﻨﺎ ﻋﻠﻰ ﺗﻌﻠﻢ ﺍﻟﻌﻠﻢ ﻭﺗﺒﻠﻴﻐﻪ ﺍﻧﻪ ﻭﱄ ﺫﻟﻚ ﻭﺍﻟﻘﺎﺩﺭ ﻋﻠﻴﻪ‪ .‬ﻭﺃﺧﲑﺍ ﻣﺎ ﻛﺎﻥ ﻣﻦ ﺧﻄﺄ ﻓﻤﻦ ﻧﻔﺴﻲ‬
‫ﻭﺍﻟﺸﻴﻄﺎﻥ ﻭﻣﺎ ﻛﺎﻥ ﻣﻦ ﺻﻮﺍﺏ ﻓﻤﻦ ﺍﷲ ﻋﺰ ﻭﺟﻞ‪.‬‬
‫ﻭﺻﻠﻰ ﺍﻟﻠﻬﻢ ﻭﺳﻠﻢ ﻋﻠﻰ ﻧﺒﻴﻨﺎ ﳏﻤﺪ ﻭﻋﻠﻰ ﺁﻟﻪ ﻭﺻﺤﺒﻪ ﺃﲨﻌﲔ ‪ .‬ﻭﺁﺧﺮ ﺩﻋﻮﺍﻧﺎ ﺃﻥ ﺍﳊﻤﺪ ﷲ ﺭﺏ ﺍﻟﻌﺎﳌﲔ‪.‬‬

‫ﺍﻟﻨﺘﺎﺋﺞ‬
‫ﺍﻟﺘﻮﺻﻴﺎﺕ‬
‫ﺣﱴ ﻳﺼﻞ ﺍﻟﺒﺤﺚ ﳌﺮﺣﻠﺔ ﻣﻨﺎﺳﺒﺔ ﻓﺎﻧﻪ ﳚﺐ ﺍﳊﺪﻳﺚ ﻋﻦ ﻋﺪﺩﺍ ﻣﻦ ﺍﳌﻮﺿﻴﻊ ﺍﻟﱵ ﰎ ﲡﺎﻫﻠﻬﺎ ﻟﺴﺒﺐ ﺃﻭ ﻵﺧﺮ‬
‫‪ ،‬ﻓﺒﺪﺍﻳﺔ ﻣﻦ ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ ﻭﺍﻟﺬﻱ ﻳﻌﺘﱪ ﻣﻘﺪﻣﺔ ﻋﺎﻣﺔ ﺍﱃ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ ﺣﻴﺚ ﳝﻜﻦ ﺃﻥ ﺗﻀﺎﻑ ﻟﻪ ﺍﻟﻌﺪﻳﺪ‬
‫ﻣﻦ ﺍﳌﻌﻠﻮﻣﺎﺕ ﻋﻦ ﺍﻷﻧﻈﻤﺔ ﺍﳊﺎﻟﻴﺔ ﻭﻛﺬﻟﻚ ﻣﺰﻳﺪﺍ ﻣﻦ ﺍﻟﺘﻮﺿﻴﺤﺎﺕ ﻋﻦ ﻣﺎﻫﻴﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﺃﻣﺎ ﺍﻟﻔﺼﻞ‬
‫ﺍﻟﺜﺎﱐ ﻓﻠﻢ ﻳﺘﺤﺪﺙ ﺳﻮﻯ ﻋﻦ ﺍﻟﻘﺸﻮﺭ ﰲ ﻣﻌﻤﺎﺭﻳﺔ ﺍﳊﺎﺳﺐ ﺣﻴﺚ ﺃﻧﻪ ﻳﺘﻄﻠﺐ ﻛﺘﺎﺑﺎ ﻣﺘﻜﺎﻣﻼ ﻟﺸﺮﺡ ﻛﻞ ﺟﺰﺋﻴﺔ‬
‫ﻭﻟﻜﻦ ﰎ ﺍﻹﳚﺎﺯ ﻭﺍﳊﺪﻳﺚ ﻋﻦ ﺍﳌﻮﺍﺿﻴﻊ ﺍﻟﱵ ﻳﻜﺜﺮ ﺗﻨﺎﻭﳍﺎ ﻋﻨﺪ ﺑﺮﳎﺔ ﺃﻧﻈﻤﺔ ﺍﻟﺘﺸﻐﻴﻞ‪ .‬ﻭﻗﺒﻞ ﺍﻹﻧﺘﻘﺎﻝ ﺍﱃ ﺍﻟﻔﺼﻞ‬
‫ﺍﻟﺜﺎﻟﺚ ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﻓﺼﻞ ﺟﺪﻳﺪ ﻋﻦ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﲝﻴﺚ ﻳﺸﺮﺡ ﺃﺳﺎﺳﻴﺎﺕ ﺍﻟﻠﻐﺔ ﻣﻊ ﻣﺘﺮﺟﻢ ‪ NASM‬ﻻﻧﻪ ﺍﳌﺘﺮﺟﻢ‬
‫ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﻋﻤﻠﻴﺔ ﲡﻤﻴﻊ ﺍﻟﱪﺍﻣﺞ ﺣﻴﺚ ﺃﻧﻪ ﳛﻮﻱ ﺃﻭﺍﻣﺮ ﺧﺎﺻﺔ ﺑﻪ ﳚﺐ ﺍﻟﻮﻗﻮﻑ ﻋﻨﺪﻫﺎ ﻭﺗﻮﺿﻴﺤﻬﺎ ﺑﺸﻜﻞ‬
‫ﺟﻴﺪ‪ .‬ﺃﻣﺎ ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ ﻭﺍﻟﺮﺍﺑﻊ ﻓﺘﻢ ﺍﳊﺪﻳﺚ ﻓﻴﻬﺎ ﻋﻦ ﳏﻤﻞ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺬﻱ ﰎ ﺑﺮﳎﺘﻪ ﻟﺘﺤﻤﻴﻞ ﻧﻈﺎﻡ ﺇﻗﺮﺃ ﻭﳝﻜﻦ‬
‫ﻫﻨﺎ ﺍﳊﺪﻳﺚ ﻋﻦ ﺃﻱ ﻣﻦ ﺍﳌﺤﻤﻼﺕ ﺍﳌﻔﺘﻮﺣﺔ ﺍﳌﺼﺪﺭ )ﻣﺜﻞ ﳏﻤﻞ ‪ GRUB‬ﻭﺍﻟﺬﻱ ﻳﻌﺘﱪ ﻣﻦ ﺃﺷﻬﺮ ﺍﳌﺤﻤﻼﺕ‬
‫ﻭﺃﻛﺜﺮﻫﻢ ﺍﺳﺘﺨﺪﺍﻣﺎ( ﻭﻛﻴﻔﻴﺔ ﲢﻤﻴﻞ ﻧﻮﺍﺓ ﺍﻟﻨﻈﺎﻡ ﻣﺒﺎﺷﺮﺓ ﻣﻦ ﺧﻼﳍﻢ‪ .‬ﻭﺍﻟﻔﺼﻞ ﺍﳋﺎﻣﺲ ﲢﺪﺙ ﻋﻦ ﺍﻟﻨﻮﺍﺓ ﻭﻃﺮﻕ‬
‫ﺗﺼﻤﻴﻤﻬﺎ ﺑﺸﻜﻞ ﳐﺘﺼﺮ ﻭﱂ ﻳﺘﻨﺎﻭﻝ ﺍﻻﺧﺘﻼﻑ ﺑﻴﻨﻬﻢ ﻭﻃﺮﻕ ﺑﺮﳎﺔ ﻛﻞ ﻣﻨﻬﻢ ﻋﻠﻰ ﺣﺪﺓ ﻭﻳﻌﺘﱪ ﻫﺬﺍ ﺍﻟﻔﺼﻞ ﳎﺎﻻ‬
‫ﻛﺎﻣﻼ ﻟﻠﺒﺤﺚ ﻓﻴﻪ ‪ .‬ﺃﻣﺎ ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺩﺱ ﻓﻬﻮ ﻣﻜﺘﻤﻞ ﺗﻘﺮﻳﺒﺎ ﻭﳝﻜﻦ ﺍﺿﺎﻓﺔ ﺍﳌﺰﻳﺪ ﻣﻦ ﺍﻟﻌﻠﻮﻣﺎﺕ ‪ ،‬ﺑﻴﻨﻤﺎ ﺍﻟﻔﺼﻞ‬
‫ﺍﻟﺴﺎﺑﻊ ﱂ ﻳﺘﺤﺪﺙ ﻋﻦ ﺧﻮﺍﺭﺯﻣﻴﺎﺕ ﺍﺩﺭﺍﺓ ﺍﻟﺬﺍﻛﺮﺓ ﻭﰎ ﺗﻄﺒﻴﻖ ﺧﻮﺍﺭﺯﻣﻴﺔ ‪ First Fit‬ﻟﻠﺒﺤﺚ ﻋﻦ ﺃﻣﺎﻛﻦ ﺷﺎﻏﺮﺓ‬
‫ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﻭﳝﻜﻦ ﺗﻄﺒﻴﻖ ﺃﻱ ﻣﻦ ﺍﳋﻮﺍﺭﺯﻣﻴﺎﺕ ﺍﻟﺸﻬﲑﺓ ‪ ،‬ﻛﺬﻟﻚ ﳝﻜﻦ ﺗﻄﺒﻴﻖ ﺍﻟﻘﺎﺋﻤﺔ ﺍﳌﺘﺼﻠﺔ ﳌﺘﺎﺑﻌﺔ ﺍﻷﻣﺎﻛﻦ‬
‫ﺍﻟﺸﺎﻏﺮﺓ ﰲ ﺍﻟﺬﺍﻛﺮﺓ ﺑﺪﻻ ﻣﻦ ﺍﺳﺘﺨﺪﺍﻡ ‪ .Bit Map‬ﺃﻣﺎ ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻣﻦ ﻓﻬﻮ ﻋﻦ ﻣﺸﻐﻼﺕ ﺍﻷﺟﻬﺰﺓ ﻟﻜﻦ ﻧﻈﺮﺍ‬
‫ﻟﻀﻴﻖ ﺍﻟﻮﻗﺖ ﻓﻘﺪ ﰎ ﺍﳊﺪﻳﺚ ﻋﻦ ﻣﺘﺤﻜﻢ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ ﻭﻛﻴﻔﻴﺔ ﻗﺮﺍءﺓ ﺍﻷﺣﺮﻑ ﺍﳌﺪﺧﻠﺔ ﻣﻨﻪ ‪ ،‬ﻭﳝﻜﻦ ﰲ ﻫﺬﺍ‬
‫ﺍﻟﻔﺼﻞ ﺍﺿﺎﻓﺔ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﻣﺸﻐﻼﺕ ﺍﻷﺟﻬﺰﺓ ﻣﺜﻞ ﻣﺸﻐﻞ ﺍﻟﻘﺮﺹ ﺍﳌﺮﻥ ﻭﺍﻟﻘﺮﺹ ﺍﻟﺼﻠﺐ ﻭﻣﺸﻐﻞ ﻟﻜﺮﺕ ﺍﻟﺸﺒﻜﺔ‬

‫‪١٩١‬‬
 ‫‪Device Driver‬‬ ‫‪ .٨‬ﻣﺸﻐﻼﺕ ﺍﻻﺟﻬﺰﺓ‬

‫ﻭﻛﺮﺕ ﺍﻟﺼﻮﺕ ﻭﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﺸﻐﻼﺕ ﺍﻟﻀﺮﻭﺭﻳﺔ‪ .‬ﺃﺧﲑﺍ ﳝﻜﻦ ﺇﺿﺎﻓﺔ ﻓﺼﻞ ﻟﻠﺤﺪﻳﺚ ﻋﻦ ﺃﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ‬
‫ﻭﻛﻴﻔﻴﺔ ﺑﺮﳎﺘﻬﻢ ﻣﺜﻞ ‪ FAT12,FAT16,FAT32,EXT3,EXT4,...etc‬ﻭﻓﺼﻞ ﻟﱪﳎﺔ ﺍﳌﺠﺪﻭﻝ ﻟﺪﻋﻢ ﺗﻌﺪﺩ ﺍﳌﻬﺎﻡ‪.‬‬

‫ﻭﻣﻦ ﻧﺎﺣﻴﺔ ﻧﻈﺎﻡ ﺇﻗﺮﺃ ﻓﺎﻧﻪ ﲝﺎﺟﺔ ﺍﱃ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﻹﺿﺎﻓﺎﺕ ﻭﺍﻟﺘﺤﺴﻴﻨﺎﺕ‪:‬‬

‫• ﺩﻋﻢ ﻭﺍﺟﻬﺔ ‪.POSIX‬‬
‫ﺩﻋﻢ ﻷﻧﻈﻤﺔ ﺍﳌﻠﻔﺎﺕ ‪.FAT12,FAT16,FAT32,EXT3,EXT4,...etc‬‬ ‫•‬

‫ﺩﻋﻢ ﻟﺘﻌﺪﺩ ﺍﳌﻬﺎﻡ‪.‬‬ ‫•‬

‫ﻧﻘﻞ )‪ (port‬ﻣﺘﺮﺟﻢ ‪ gcc,g++‬ﻭﻭﺍﺟﻬﺔ ‪ x11‬ﺍﱃ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‪.‬‬ ‫•‬

‫‪١٩٢‬‬
Bibliography
[١] William Stallings, Operating System: Internals and Design Principles. Prentice Hall, 5th
Edition, 2004.

[٢] Andrew S. Tanenbaum ,Albert S Woodhull, Operating Systems Design and Implementation.
Prentice Hall, 3rd Edition, 2006.

[٣] Michael Tischer, Bruno Jennrich, PC Intern: The Encyclopedia of System Programming.
Abacus Software, 6th Edition, 1996.

[٤] Hans-Peter Messmer, The Indispensable PC Hardware Book. Addison-Wesley Profes-

sional, 4th Edition, 2001.

[٥] Andrew S. Tanenbaum, Structured Computer Organization. Prentice Hall, 4th Edition,
1998.

[٦] Ytha Yu,Charles Marut, Asssembly Language Programming and Organization IBM PC.
McGraw-Hill/Irwin, 1st Edition, 1992.

[٧] Intel® Manuals, Intel® 64 and IA-32 Architectures Software Developer's Manuals. http:
//www.intel.com/products/processor/manuals/

[٨] OSDev: http://wiki.osdev.org

[٩] brokenthorn: http://brokenthorn.com

[١٠] Computer Sciense Student's Community in Sudan: http://sudancs.com

[١١] Wikipedia: http://wikipedia.org

١٩٣
 ‫ﺍ‪ .‬ﺗﺮﲨﺔ ﻭﺗﺸﻐﻴﻞ ﺍﻟﱪﺍﻣﺞ‬
‫ﻟﺘﻄﻮﻳﺮ ﻧﻈﺎﻡ ﺍﻟﺘﺸﻐﻴﻞ ﳚﺐ ﺍﺳﺘﺨﺪﺍﻡ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻻﺩﻭﺍﺕ ﻭﺍﻟﻠﻐﺎﺕ ﺍﻟﱵ ﺗﺴﺎﻋﺪ ﻭﺗﻴﺴﲑ ﻋﻤﻠﻴﺔ ﺍﻟﺘﻄﻮﻳﺮ ﻭﰲ ﻫﺬﺍ‬
‫ﺍﻟﻔﺼﻞ ﺳﻴﺘﻢ ﻋﺮﺽ ﻫﺬﻩ ﺍﻷﺩﻭﺍﺕ ﻭﻛﻴﻔﻴﺔ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ‪.‬‬
‫ﺍﻋﺪﺍﺩ ﻣﺘﺮﺟﻢ ﻓﻴﺠﻮﺍﻝ ﺳﻲ‪ ++‬ﻟﱪﳎﺔ ﺍﻟﻨﻮﺍﺓ‪.‬‬

‫ﺍ‪ .١.‬ﻧﻈﺎﻡ ﻭﻳﻨﺪﻭﺯ‬

‫ﺍ‪ .٢.‬ﻧﻈﺎﻡ ﻟﻴﻨﻮﻛﺲ‬

‫‪١٩٥‬‬
 ‫ﺏ‪ .‬ﺷﻔﺮﺓ ﻧﻈﺎﻡ ﺇﻗﺮﺃ‬
‫ﻛﻮﺩ ﺍﻟﻨﻈﺎﻡ‬

‫‪١٩٧‬‬