‫ﺑﻪ ﻧﺎم ﺧﺪا‬

‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫ﻧﯿﻢﺳﺎل اول ‪۰۳-۰۲‬‬
‫اﺳﺘﺎد‪ :‬دﮐﺘﺮ ﺣﺴﯿﻦ اﺳﺪی‬

‫داﻧﺸﮑﺪه ﻣﻬﻨﺪﺳﯽ ﮐﺎﻣﭙﯿﻮﺗﺮ‬

‫ﺗﻤﺮﯾﻦ ﺳﺮی دوم‬

‫• ﭘﺮﺳﺶﻫﺎی ﺧﻮد را در ﺻﻔﺤﻪ ﮐﻮﺋﺮای ﻣﺮﺑﻮط ﺑﻪ ﺗﻤﺮﯾﻦ ﻣﻄﺮح ﮐﻨﯿﺪ‪.‬‬

‫• ﺳﻮاﻻت را ﺑﻪ ﺻﻮرت ﺗﺎﯾﭙﯽ ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬
‫• اﺳﮑﺮﯾﻦﺷﺎتﻫﺎ‪ ،‬ﻋﮑﺲﻫﺎ و ﻓﺎﯾﻞﻫﺎی ﻣﺮﺑﻮط ﺑﻪ ﺳﻮال ﻋﻤﻠﯽ را در ﻓﺎﯾﻞ ﻓﺸﺮده ﻣﺮﺑﻮﻃﻪ در ‪ cw‬و ‪ quera‬ﻗﺮار دﻫﯿﺪ‪ .‬ﻫﺮ ﮔﻮﻧﻪ ﻋﺪم‬
‫ﺗﻄﺎﺑﻖ ﺑﯿﻦ دو ﺗﻤﺮﯾﻦ آﭘﻠﻮد ﺷﺪه در دو ﺳﺎﯾﺖ ﻣﻨﺠﺮ ﺑﻪ از دﺳﺖ رﻓﺘﻦ ﻧﻤﺮه ﺗﻤﺮﯾﻦ ﻣﺮﺑﻮﻃﻪ ﻣﯽﺷﻮد‪.‬‬
‫• ﭘﯽ دی اف ﻗﺴﻤﺖ ﺗﺌﻮری را در ﺳﺎﻣﺎﻧﻪ ‪ cw‬و ‪ quera‬آﭘﻠﻮد ﮐﻨﯿﺪ‪.‬‬
‫• ﺳﻮاﻻت ﺑﺎ ﻋﻨﻮان اﺧﺘﯿﺎری ﻧﻤﺮهای ﻧﺪارﻧﺪ اﻣﺎ ﺟﻮاب دادن ﺑﻪ آﻧﻬﺎ ﮐﻤﮏ ﺑﻪﺳﺰاﯾﯽ در ﯾﺎدﮔﯿﺮی درس ﻣﯽﮐﻨﺪ‪.‬‬

‫ﺗﻤﺎرﯾﻦ ﺗﺌﻮری‬
‫‪ .۱‬در زﻣﯿﻨﻪ ﻣﺎﺷﯿﻦﻫﺎی ﻣﺠﺎزی‪ ،‬ﺗﻔﺎوتﻫﺎی اﺻﻠﯽ ‪ full virtualization‬و ‪ para-virtualization‬را ﺗﻮﺿﯿﺢ دﻫﯿﺪ‪ .‬ﻫﻤﭽﻨﯿﻦ‬
‫ﭼﺎﻟﺶﻫﺎﯾﯽ ﮐﻪ در ﺳﺎﻣﺎﻧﻪﻫﺎی ﻧﺎﻫﻤﮕﻮن ﮐﻪ از ﻫﺮ دو روش ﻣﺠﺎزیﺳﺎزی اﺳﺘﻔﺎده ﻣﯽﮐﻨﻨﺪ را ﺷﺮح دﻫﯿﺪ و درﺑﺎره روشﻫﺎﯾﯽ‬
‫ﮐﻪ ﺑﺮای ﺗﺨﺼﯿﺺ ﻣﻨﺎﺑﻊ و ﺗﻐﯿﯿﺮ ﻣﻨﺎﺑﻊ اﺧﺘﺼﺎص ﯾﺎﻓﺘﻪ در ﭼﻨﯿﻦ ﺳﺎﻣﺎﻧﻪﻫﺎﯾﯽ وﺟﻮد دارد ﺑﺤﺚ ﮐﻨﯿﺪ‪.‬‬
‫‪ .۲‬ﺑﻪ ﺳﻮاﻻت زﯾﺮ ﮐﻪ در ﻣﻮرد ‪API‬ﻫﺎی ﻟﯿﻨﻮﮐﺲ ﻫﺴﺘﻨﺪ ﺑﻪ ﻃﻮر ﻣﺨﺘﺼﺮ ﭘﺎﺳﺦ دﻫﯿﺪ‪.‬‬
‫آ( در ﭼﻪ ﺳﻨﺎرﯾﻮﻫﺎﯾﯽ اﺳﺘﻔﺎده از )(‪ mmap‬ﺑﻪ ﺟﺎی )(‪ malloc‬ﻣﻨﺎﺳﺐﺗﺮ اﺳﺖ؟‬
‫ب( ﭼﺮا )(‪ epoll‬در ﻣﻘﺎﯾﺴﻪ ﺑﺎ )(‪ select‬و )(‪ poll‬ﮐﺎرآﻣﺪﺗﺮ اﺳﺖ؟‬
‫ج( ﭼﻪ ﺗﻔﺎوتﻫﺎی اﺻﻠﯽ ﺑﯿﻦ ﺳﯿﺴﺘﻢﮐﺎلﻫﺎی )(‪ read‬و )(‪ mmap‬وﺟﻮد دارد؟‬
‫‪ .۳‬در دﻧﯿﺎی اﻣﺮوزی‪ ،‬ﺑﺴﯿﺎری از ﻣﺮدم و ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﺎن ﺑﻪ دﻧﺒﺎل ﺧﺮﯾﺪ ﺳﺮور ﻣﺠﺎزی ﺷﺨﺼﯽ ‪ ۱‬ﻫﺴﺘﻨﺪ‪ VPS .‬ﻫﺎ ﻣﻌﻤﻮﻻ ﻣﺎﺷﯿﻦﻫﺎﯾﯽ‬
‫ﻣﺠﺎزی ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﺮروی ﯾﮏ ﺳﺮور ﻗﺪرﺗﻤﻨﺪ درﺣﺎل اﺟﺮا ﺷﺪن ﻫﺴﺘﻨﺪ ﮐﻪ از اﯾﻨﺘﺮﻧﺖ ﻗﺎﺑﻞ دﺳﺘﺮﺳﯽ ﻫﺴﺘﻨﺪ‪ .‬ﯾﮑﯽ از ﭘﺎراﻣﺘﺮﻫﺎﯾﯽ‬
‫ﮐﻪ زﻣﺎن ﺧﺮﯾﺪ ﺳﺮور ﺑﺎﯾﺪ ﺑﻪ آن ﺗﻮﺟﻪ ﮐﺮد‪ ،‬ﻣﺪل ﻣﺠﺎزیﺳﺎزی ‪ ۲‬اﺳﺖ‪ .‬ﺳﻪ ﻣﺪل ﻣﺠﺎزیﺳﺎزی ﻣﻌﺮوف وﺟﻮد دارد‪:‬‬
‫‪ESXi - OpenVZ - KVM‬‬

‫ﯾﮏ ﻣﻮرد ﺗﻔﺎوت و ﺷﺒﺎﻫﺖ ‪ ESXi‬و ‪ KVM‬را ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬ ‫آ(‬

‫ﺗﺤﻘﯿﻖ ﮐﻨﯿﺪ ﮐﻪ ‪ OpenVZ‬ﭼﯿﺴﺖ و ﭼﮕﻮﻧﻪ ﮐﺎر ﻣﯽﮐﻨﺪ‪ .‬آﯾﺎ ‪ OpenVZ‬ﻓﺮاﯾﻨﺪ ﻣﺠﺎزیﺳﺎزی را ﻣﺎﻧﻨﺪ ﺑﻘﯿﻪ اﻧﺠﺎم ﻣﯽدﻫﺪ؟‬ ‫ب(‬
‫ﯾﮏ ﻣﻮرد ﻣﺰﯾﺖ و ﯾﮏ ﻣﻮرد ﻋﯿﺐ ‪ OpenVZ‬ﻧﺴﺒﺖ ﺑﻪ ‪ hypervisor‬ﻫﺎی ﻧﻮع اول را ذﮐﺮ ﮐﻨﯿﺪ‪.‬‬ ‫ج(‬
‫ﭼﺮا ﺑﻪ ﺟﺎی ‪ OpenVZ‬از ‪ Docker‬اﺳﺘﻔﺎده ﻧﻤﯽﮐﻨﯿﻢ؟ اﯾﻦ دو را ﺑﺎ ﯾﮑﺪﯾﮕﺮ ﻣﻘﺎﯾﺴﻪ ﮐﻨﯿﺪ‪.‬‬ ‫د(‬
‫‪ .۴‬ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﻣﻌﮑﻮس ‪ ۳‬ﻓﺮاﯾﻨﺪی اﺳﺖ ﮐﻪ ﻃﯽ آن‪ ،‬ﮐﺪ ﻣﻨﺒﻊ ﯾﮏ ﺑﺮﻧﺎﻣﻪی ﮐﺎﻣﭙﯿﻮﺗﺮی ﺑﺎزﺳﺎزی ﻣﯽﺷﻮد‪ .‬ﺑﻪ ﻋﺒﺎرﺗﯽ دﯾﮕﺮ در اﯾﻦ‬
‫ﻓﺮاﯾﻨﺪ از ﻃﺮﯾﻖ ﻓﺎﯾﻞ اﺟﺮاﯾﯽ و ﺑﺎﯾﻨﺮی ﺑﻪ ﮐﺪ اوﻟﯿﻪ ﺑﺮﻧﺎﻣﻪ دﺳﺖ ﻣﯽﯾﺎﺑﯿﻢ‪ .‬رادار ﯾﮏ اﺑﺰار ﻣﺘﻦﺑﺎز ‪ ۴‬اﺳﺖ ﮐﻪ ﺑﺮای ﺗﺠﺰﯾﻪ و ﺗﺤﻠﯿﻞ‬
‫‪Virtual Private Server ۱‬‬
‫‪Virtualization type ۲‬‬
‫‪Reverse Engineering ۳‬‬
‫‪Open Source ۴‬‬
‫ﺻﻔﺤﻪ ‪ ۲‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫ﺑﺎﯾﻨﺮیﻫﺎ در ﻣﻬﻨﺪﺳﯽ ﻣﻌﮑﻮس اﺳﺘﻔﺎده ﻣﯽﺷﻮد‪ .‬اﯾﻦ اﺑﺰار از ﻃﺮﯾﻖ ﺗﺠﺰﯾﻪ ﮐﺪ ﻣﺎﺷﯿﻦ ﺑﻪ ﻣﺎ ﮐﻤﮏ ﻣﯽﮐﻨﺪ ﺗﺎ ﻓﻬﻢ ﺑﻬﺘﺮی از ﻧﺤﻮه‬
‫ﻋﻤﻠﮑﺮد ﺑﺮﻧﺎﻣﻪ داﺷﺘﻪ ﺑﺎﺷﯿﻢ‪.‬‬
‫آ( ﺣﺎل ﺑﺮﻧﺎﻣﻪ زﯾﺮ ﺑﻪ ﮐﻤﮏ اﯾﻦ اﺑﺰار ﺑﺪﺳﺖ آﻣﺪه اﺳﺖ ﮐﻪ ﯾﮏ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ را ﻧﺸﺎن ﻣﯽدﻫﺪ ﮐﻪ ﺻﺮﻓﺎ ﺑﺎﯾﺖﮐﺪ آن‬
‫را دارﯾﻢ‪ .‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻮاﺑﻌﯽ ﮐﻪ ﺻﺪا زده ﺷﺪه و ﺑﯿﺎن ﻋﻤﻠﮑﺮد ﻫﺮ ﯾﮏ از ﺗﻮاﺑﻊ ﺳﯿﺴﺘﻤﯽ ﺣﺪس ﺑﺰﻧﯿﺪ ﮐﻪ اﯾﻦ ﻓﺮﺧﻮاﻧﯽ‬
‫ﺳﯿﺴﺘﻤﯽ ﭼﻪ ﺑﻮده اﺳﺖ‪.‬‬

‫ب( اﺣﺘﻤﺎﻻ ﺗﺎ اﻻن در ﺑﺮﺧﯽ از دروس دﯾﺪهاﯾﺪ ﮐﻪ ﺑﺮﺧﯽ ﻧﺮماﻓﺰارﻫﺎ ﻣﺎﻧﻨﺪ ‪ Protues‬ﻓﻘﻂ روی وﯾﻨﺪوز اﺟﺮا ﻣﯽﺷﻮﻧﺪ‪ .‬ﯾﮏ‬
‫ﺳﺮی راه وﺟﻮد دارد ﮐﻪ ﻣﯽﺗﻮان اﯾﻦ ﻧﺮماﻓﺰارﻫﺎ را روی ﺳﯿﺴﺘﻢﻋﺎﻣﻞﻫﺎی دﯾﮕﺮ ﻣﺜﻞ ‪ Linux‬اﺟﺮا ﮐﺮد‪ .‬ﺗﺤﻘﯿﻖ ﮐﻨﯿﺪ‬
‫ﮐﻪ اﯾﻦ ﻧﺮماﻓﺰارﻫﺎ ﭼﮕﻮﻧﻪ ﺑﺎ ﻣﻌﻤﺎری ﺳﯿﺴﺘﻢﻋﺎﻣﻞ دﯾﮕﺮ اﺧﺖ ﻣﯽﺷﻮﻧﺪ و از ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻢﻋﺎﻣﻞ ﺟﺪﯾﺪ اﺳﺘﻔﺎده‬
‫ﻣﯽﮐﻨﻨﺪ‪ .‬ﻣﯽﺗﻮاﻧﯿﺪ راﺟﻊ ﺑﻪ ‪ wine‬در ﺳﯿﺴﺘﻢﻋﺎﻣﻞ ‪ Linux‬ﺗﺤﻘﯿﻖ ﮐﻨﯿﺪ‪.‬‬
‫ج( ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻗﺴﻤﺖ ﻗﺒﻞ ﺑﺮرﺳﯽ ﮐﻨﯿﺪ ﮐﻪ ﯾﮏ وﯾﺮوس ﮐﺎﻣﭙﯿﻮﺗﺮی ﮐﻪ در ﯾﮏ ﻣﺎﺷﯿﻦ ﻣﺠﺎزی اﺟﺮا ﻣﯽﺷﻮد آﯾﺎ ﻣﯽﺗﻮاﻧﺪ در‬
‫ﺳﯿﺴﺘﻢﻋﺎﻣﻞ ﻣﯿﺰﺑﺎن ‪ ۵‬ﺧﺮاﺑﮑﺎری اﻧﺠﺎم دﻫﺪ؟‬
‫‪ .۵‬در درس ﺑﺎ ﺳﺎﺧﺘﺎر ‪ ۶‬ﻫﺎی ﻣﺨﺘﻠﻒ ﺳﯿﺴﺘﻢﻋﺎﻣﻞ آﺷﻨﺎ ﺷﺪﯾﺪ‪ .‬دو ﺳﺎﺧﺘﺎر ﻻﯾﻪای ‪ ۷‬و ﻣﯿﮑﺮوﮐﺮﻧﻞ ‪ ۸‬را درﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ و ﺑﺮ اﺳﺎس‬
‫آﻧﻬﺎ ﺑﻪ ﺳﻮاﻻت زﯾﺮ ﭘﺎﺳﺦ دﻫﯿﺪ‪.‬‬
‫‪ .۱‬ﻫﺮ دو ﺳﺎﺧﺘﺎر را ﺑﻪ اﺧﺘﺼﺎر ﺗﻮﺿﯿﺢ دﻫﯿﺪ‪.‬‬
‫‪ .۲‬در ﻫﺮ ﮐﺪام از ﻣﻮارد زﯾﺮ ﺑﺎ ذﮐﺮ دﻟﯿﻞ ﻣﺸﺨﺺ ﮐﻨﯿﺪ ﮐﻪ اﺳﺘﻔﺎده از ﮐﺪام ﻧﻮع ﺳﯿﺴﺘﻢﻋﺎﻣﻞ ﻣﻨﺎﺳﺐﺗﺮ اﺳﺖ‪.‬‬
‫آ( ﯾﮏ ﺳﯿﺴﺘﻢ اﯾﻤﻨﯽ‪-‬ﺑﺤﺮاﻧﯽ ‪ ۹‬ﻣﺜﻞ ﺳﯿﺴﺘﻢﻫﺎی ﻣﻮرد اﺳﺘﻔﺎده در ﻫﻮاﭘﯿﻤﺎﻫﺎ‬
‫ب( ﺳﯿﺴﺘﻢ ﺑﺰرﮔﯽ ﮐﻪ ﻧﯿﺎز ﺑﻪ ﺳﯿﺴﺘﻢﻋﺎﻣﻠﯽ ﺑﺎ ﻫﺴﺘﻪ ﭘﯿﺸﺮﻓﺘﻪ دارد‪.‬‬
‫ج( ﺳﯿﺴﺘﻤﯽ ﺧﺎصﻣﻨﻈﻮره ﻃﺮاﺣﯽ ﺷﺪه ﺑﺮای ﯾﮏ ﺷﺮﮐﺖ ﮐﻪ اﻣﮑﺎن دارد ﺑﺮ اﺳﺎس ﻧﯿﺎز ﻗﺎﺑﻠﯿﺖﻫﺎی ﻣﺨﺘﻠﻔﯽ ﺑﻪ‬
‫ﺳﯿﺴﺘﻢﻋﺎﻣﻞ اﻓﺰوده ﺷﻮد‪.‬‬
‫د( ﺳﯿﺴﺘﻤﯽ ﮐﻪ ﻻزم اﺳﺖ ﺳﺮوﯾﺲﻫﺎی ﻣﺨﺘﻠﻔﯽ ﺑﻪ ﮐﺎرﺑﺮان ﺑﺴﯿﺎر زﯾﺎدی ﺑﺪﻫﺪ و ﺑﺮﺧﯽ از اﯾﻦ ﮐﺎرﺑﺮان ﻧﯿﺰ ﻣﻤﮑﻦ‬
‫اﺳﺖ ﻣﻬﺎﺟﻢ ﺑﺎﺷﻨﺪ و ﯾﺎ ﺳﯿﺴﺘﻢ را ﺑﻪ ﺻﻮرت ﻧﺎﺧﻮاﺳﺘﻪ ﺗﺨﺮﯾﺐ ﮐﻨﻨﺪ‪.‬‬
‫ه( ﺳﯿﺴﺘﻢﻋﺎﻣﻠﯽ ﮐﻪ ﻻزم اﺳﺖ داﺋﻤﺎ ﻣﻮرد ﺑﺎزرﺳﯽ و رﻓﻊ اﺷﮑﺎل ﻗﺮار ﮔﯿﺮد‪.‬‬
‫و( ﺷﺮﮐﺘﯽ ﮐﻪ ﺗﯿﻢ ﺑﺰرﮔﯽ در اﺧﺘﯿﺎر دارد و ﻗﺼﺪ دارد ﺳﯿﺴﺘﻢﻋﺎﻣﻞ را ﺗﻮﺳﻌﻪ دﻫﺪ‪.‬‬
‫ز( ﯾﮏ ﺳﯿﺴﺘﻢ ﻧﻬﻔﺘﻪ ‪ ۱۰‬ﮐﻪ ﺣﺎﻓﻈﻪ ﺑﺴﯿﺎر ﮐﻤﯽ در اﺧﺘﯿﺎر دارد ‪ ،‬اﻣﺎ ﺑﻪ ﺑﺨﺶ ﺑﺴﯿﺎر ﮐﻮﭼﮑﯽ از ﻗﺎﺑﻠﯿﺖﻫﺎی ﺳﯿﺴﺘﻢﻋﺎﻣﻞ‬
‫ﻧﯿﺎزﻣﻨﺪ اﺳﺖ‪.‬‬
‫‪ .۶‬ﺑﻪ ﺳﻮاﻻت زﯾﺮ در ﻣﻮرد ‪ system call‬ﻫﺎ ﭘﺎﺳﺦ دﻫﯿﺪ‪:‬‬
‫‪Host OS ۵‬‬
‫‪Structure ۶‬‬
‫‪Layered ۷‬‬
‫‪Microkernel ۸‬‬
‫‪Safety Critical ۹‬‬
‫‪Embedded System ۱۰‬‬
‫ﺻﻔﺤﻪ ‪ ۳‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫ﻫﻨﮕﺎم ﻓﺮاﺧﻮاﻧﯽ ‪ system call‬روﯾﻪی ﻣﺘﺪاول ﺑﻪ اﯾﻦ ﺷﮑﻞ اﺳﺖ ﮐﻪ اﺑﺘﺪا آرﮔﻮﻣﺎنﻫﺎی داده ﺷﺪه از ﭘﺸﺘﻪی ﮐﺎرﺑﺮ ﺑﻪ‬ ‫آ(‬
‫ﭘﺸﺘﻪی ﮐﺮﻧﻞ ﮐﭙﯽ ﻣﯽﺷﻮﻧﺪ‪ ،‬ﺳﭙﺲ ﺻﺤﺖ آرﮔﻮﻣﺎنﻫﺎی داده ﺷﺪه ﭼﮏ ﻣﯽﺷﻮد‪ .‬ﭼﺮا ﺗﺮﺗﯿﺐ اﯾﻦ دو ﻣﺮﺣﻠﻪ ﻧﻤﯽﺗﻮاﻧﺪ‬
‫ﺑﺮﻋﮑﺲ ﺑﺎﺷﺪ‪ ،‬ﯾﻌﻨﯽ اﺑﺘﺪا ﺻﺤﺖ ﺑﺮرﺳﯽ ﺷﻮد و ﺳﭙﺲ ﺑﻪ ﭘﺸﺘﻪی ﮐﺮﻧﻞ ﮐﭙﯽﺷﻮﻧﺪ؟‬
‫آﯾﺎ راﻫﯽ ﺑﺪون اﺳﺘﻔﺎده از ‪ system call‬وﺟﻮد دارد ﮐﻪ ﮐﺎرﺑﺮ ﺑﺎ دﺳﺘﺮﺳﯽ ﺳﻄﺢ ﮐﺎرﺑﺮ ﮐﺪی ﺑﻨﻮﯾﺴﺪ و اﺟﺮا ﮐﻨﺪ ﮐﻪ ﺳﯿﺴﺘﻢ‬ ‫ب(‬
‫را وادار ﺑﻪ اﻧﺘﻘﺎل ﺑﻪ ﺣﺎﻟﺖ ﮐﺮﻧﻞ ﮐﻨﺪ؟ اﮔﺮ ﻧﺪارد ﭼﺮا و اﮔﺮ دارد ﻣﺜﺎل ﺑﺰﻧﯿﺪ‪.‬‬
‫در اﯾﻦ ﻗﺴﻤﺖ از درس‪ ،‬ﺑﺎ ارﺗﺒﺎط ﻣﯿﺎن ﺑﺮﻧﺎﻣﻪﻫﺎ آﺷﻨﺎ ﺷﺪﯾﺪ‪ .‬ﯾﮑﯽ از راهﻫﺎی ارﺗﺒﺎط ﻣﯿﺎن دو ﺑﺮﻧﺎﻣﻪ ﭘﺎﯾﭗ اﺳﺖ‪ ،‬و ﯾﮏ راه‬ ‫ج(‬
‫ﻣﺘﺪاول دﯾﮕﺮ اﺳﺘﻔﺎده از ﯾﮏ ﻓﺎﯾﻞ اﺳﺖ ﮐﻪ دو ﺑﺮﻧﺎﻣﻪ اﻣﮑﺎن دﺳﺘﺮﺳﯽ ﺑﻪ آن را دارﻧﺪ‪ .‬ﭼﺮا‪ ،‬از ﻧﻈﺮ ﺳﺨﺖاﻓﺰاری‪ ،‬راهﺣﻞ‬
‫اول ﺳﺮﻋﺖ زﯾﺎدﺗﺮی ﺧﻮاﻫﺪ داﺷﺖ؟‬
‫ﺑﺮای اﺟﺮای ﯾﮏ ‪ system call‬ﻣﻌﻤﻮﻻ از ﯾﮏ ﺟﺪول اﺳﺘﻔﺎده ﻣﯽﺷﻮد‪ ،‬ﺑﻪ اﯾﻦ ﺻﻮرت ﮐﻪ در ﺳﻄﺢ ﮐﺎرﺑﺮ ﺷﻤﺎرهی‬ ‫د(‬
‫ﻣﺘﻨﺎﻇﺮ ﺑﺎ ‪ syscall‬ﻣﺪ ﻧﻈﺮ وارد ﯾﮏ رﺟﯿﺴﺘﺮ ﻣﯽﺷﻮد و ﺑﻌﺪ از اﻧﺘﻘﺎل ﺑﻪ ﺳﻄﺢ ﮐﺮﻧﻞ‪ ،‬ﺑﺎ ﺑﺮرﺳﯽ ﺷﻤﺎرهی ‪ syscall،‬آدرس‬
‫دﺳﺘﻮراﻟﻌﻤﻞﻫﺎﯾﯽ ﮐﻪ ﺑﺎﯾﺪ اﺟﺮا ﺷﻮﻧﺪ ﺑﻪ دﺳﺖ ﻣﯽآﯾﺪ‪ .‬ﭼﺮا اﯾﻦ روﻧﺪ اﻧﺘﺨﺎب ﺷﺪه اﺳﺖ و در ﺳﻄﺢ ﮐﺎرﺑﺮ ﻣﺴﺘﻘﯿﻤﺎ آدرس‬
‫دﺳﺘﻮراﻟﻌﻤﻞﻫﺎی ﻣﺪ ﻧﻈﺮ وارد رﺟﯿﺴﺘﺮ ﻧﻤﯽﺷﻮد؟‬
‫‪ .۷‬ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﻣﯿﺪاﻧﯿﺪ ﯾﮑﯽ از ﺑﺨﺶ ﻫﺎی اﺳﺎﺳﯽ ﻫﺮ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ‪ command interpreter‬آن اﺳﺖ‪ .‬در اﯾﻦ ﺑﺎره ﺑﻪ ﺳﻮاﻻت‬
‫ذﯾﻞ ﭘﺎﺳﺦ دﻫﯿﺪ‪:‬‬
‫آ( ﻫﺪف از اﯾﺠﺎد و اﺳﺘﻔﺎده از اﯾﻦ ﺑﺨﺶ از ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﭼﯿﺴﺖ؟‬
‫ب( ﭼﻪ ﻣﺰﯾﺘﯽ در ﺟﺪاﺳﺎزی ﻣﻔﺴﺮ ﻓﺮﻣﺎن از ﻫﺴﺘﻪ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ وﺟﻮد دارد؟‬
‫ج( از ﭼﻪ ﻓﺮاﺧﻮاﻧﯽ ﻫﺎی ﺳﯿﺴﺘﻤﯽ ﺑﺎﯾﺪ درد ﻣﻔﺴﺮ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﺑﺮای اﺟﺮای دﺳﺘﻮرات اﺳﺘﻔﺎده ﮐﺮد؟ آﯾﺎ ﺑﺎ اﺳﺘﻔﺎده از‬
‫ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻤﯽ ﮐﻪ در اﺧﺘﯿﺎر ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺲ ﻗﺮار ﻣﯽﮔﯿﺮد‪ ،‬ﻣﯽﺗﻮان ﯾﮏ ﻣﻔﺴﺮ ﻓﺮﻣﺎن ﻧﻮﺷﺖ؟‬
‫ﺻﻔﺤﻪ ‪ ۴‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫ﺗﻤﺎرﯾﻦ ﻋﻤﻠﯽ‬
‫در اﯾﻦ ﺗﻤﺮﯾﻦ ﻗﺼﺪ دارﯾﻢ ﺗﺎ ﺗﺎ ﯾﮏ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ﺑﻪ ‪ xv6‬اﺿﺎﻓﻪ ﮐﻨﯿﻢ ﮐﻪ ﻣﻨﺠﺮ ﺑﻪ درک ﺑﻬﺘﺮ از ﻧﺤﻮه ﮐﺎرﮐﺮد ﻓﺮاﺧﻮاﻧﯽﻫﺎی‬
‫ﺳﯿﺴﺘﻤﯽ و آﺷﻨﺎﯾﯽ ﺑﯿﺸﺘﺮ ﺑﺎ ﻫﺴﺘﻪ ‪ xv6‬ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫ﭘﯿﺶ از ﺷﺮوع ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﭘﯿﺸﻨﻬﺎد ﻣﯽﺷﻮد ﻓﺼﻞ دوم ﮐﺘﺎب ‪ xv6‬و ﺑﺨﺶﻫﺎی ‪ ۴.۳‬و ‪ ۴.۴‬ﻓﺼﻞ ﭼﻬﺎرم و ﻫﻤﭽﻨﯿﻦ ﻓﺎﯾﻞﻫﺎی زﯾﺮ را‬
‫ﻣﻄﺎﻟﻌﻪ ﮐﻨﯿﺪ‪:‬‬

‫• ‪stub‬ﻫﺎی ﻓﻀﺎی ﮐﺎرﺑﺮ ﮐﻪ ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻤﯽ را ﺑﻪ ﻫﺴﺘﻪ ﻣﻨﺘﻘﻞ ﻣﯽﮐﻨﻨﺪ در ﻓﺎﯾﻞ ‪ user/usys.S‬ﻗﺮار دارد ﮐﻪ ﺗﻮﺳﻂ‬
‫‪ user/usys.pl‬و ﭘﺲ از اﺟﺮای دﺳﺘﻮر ‪ make‬ﺳﺎﺧﺘﻪ ﻣﯽﺷﻮد‪ .‬ﺗﻌﺮﯾﻔﺎت ﻧﯿﺰ در ﻓﺎﯾﻞ ‪ user/user.h‬ﻗﺮار دارﻧﺪ‪.‬‬
‫• ﮐﺪﻫﺎی ﻓﻀﺎی ﻫﺴﺘﻪ ﮐﻪ ﯾﮏ ﻓﺮاﺧﻮاﻧﯽ را ﺑﻪ ﺗﺎﺑﻌﯽ ﮐﻪ آن را ﭘﯿﺎدهﺳﺎزی ﮐﺮده اﺳﺖ ﻫﺪاﯾﺖ ﻣﯽﮐﻨﺪ در ﻓﺎﯾﻞﻫﺎی‬
‫‪ kernel/syscall.c‬و ‪ kernel/syscall.h‬ﻗﺮار دارﻧﺪ‪.‬‬
‫• ﮐﺪﻫﺎی ﻣﺮﺗﺒﻂ ﺑﺎ ﭘﺮدازه ﻧﯿﺰ در ﻓﺎﯾﻞﻫﺎی ‪ kernel/proc.h‬و ‪ kernel/proc.c‬ﻣﻮﺟﻮد اﺳﺖ‪.‬‬

‫ﺑﺮای ﺷﺮوع ﺗﻤﺮﯾﻦ ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮرات زﯾﺮ ﺑﻪ ﺷﺎﺧﻪ ‪ syscall‬ﺑﺮوﯾﺪ‪:‬‬

‫‪git clone git clone git ://g. csail .mit.edu/xv6 -labs -2023‬‬
‫‪cd xv6 -labs -2023‬‬
‫‪git checkout syscall‬‬
‫‪make clean‬‬

‫‪ .۱‬در ﺑﺴﯿﺎری از ﻣﻮارد اﺳﺘﻔﺎده از دﺳﺘﻮرات ﭼﺎپ ﺑﺮای دﯾﺒﺎگ ﮐﺮدن ﮐﺮﻧﻞ ﮐﺎﻓﯽ اﺳﺖ‪ ،‬اﻣﺎ در ﺑﻌﻀﯽ ﻣﻮارد اﻣﮑﺎن ﺣﺮﮐﺖ ﮐﺮدن‬
‫ﺑﯿﻦ دﺳﺘﻮرات اﺳﻤﺒﻠﯽ ﯾﺎ ﺑﺮرﺳﯽ ﻣﺘﻐﯿﺮﻫﺎی درون ﭘﺸﺘﻪ ﻣﯽﺗﻮاﻧﺪ ﻓﺮاﯾﻨﺪ دﯾﺒﺎگ را ﺑﺮای ﻣﺎ آﺳﺎنﺗﺮ ﮐﻨﺪ‪.‬‬
‫ﺑﺮای اﯾﻨﮑﻪ ﺑﯿﺸﺘﺮ ﺑﺎ ‪ GDB‬آﺷﻨﺎ ﺷﻮﯾﺪ‪ ،‬اﺑﺘﺪا دو ﭘﻨﺠﺮه ﺑﺎز ﮐﻨﯿﺪ‪ .‬در ﭘﻨﺠﺮه اول دﺳﺘﻮر ‪ make qemu-gdb‬را اﺟﺮا ﮐﻨﯿﺪ و ‪gdb‬‬
‫را در ﭘﻨﺠﺮه دﯾﮕﺮ ﺑﺎز ﮐﻨﯿﺪ‪ .‬زﻣﺎﻧﯽ ﮐﻪ دو ﭘﻨﺠﺮه را ﺑﺎز ﮐﺮدهاﯾﺪ‪ ،‬دﺳﺘﻮر ﻣﻘﺎﺑﻞ را در ﭘﻨﺠﺮه ‪ gdb‬اﺟﺮا ﮐﻨﯿﺪ‪:‬‬
‫‪(gdb) b syscall‬‬
‫‪Breakpoint 1 at 0 x80002142 : file kernel / syscall .c, line 243.‬‬
‫‪(gdb) c‬‬
‫‪Continuing .‬‬
‫]‪[ Switching to Thread 1.2‬‬

‫‪Thread 2 hit Breakpoint 1, syscall () at kernel / syscall .c:243‬‬

‫‪243‬‬ ‫{‬
‫‪(gdb) layout src‬‬
‫‪(gdb) backtrace‬‬

‫دﺳﺘﻮر ‪ layout‬ﭘﻨﺠﺮه را ﺑﻪ دو ﺗﮑﻪ ﺗﻘﺴﯿﻢ ﻣﯽﮐﻨﺪ ﮐﻪ ﻧﺸﺎن ﻣﯽدﻫﺪ ‪ gdb‬در ﮐﺪام ﺧﻂ از ﺑﺮﻧﺎﻣﻪ ﻗﺮار دارد‪ .‬دﺳﺘﻮر ‪backtrace‬‬
‫ﺗﺎرﯾﺨﭽﻪ ﺗﻮاﺑﻊ ﺻﺪا زده ﺷﺪه در رﯾﺴﻤﺎن ﻓﻌﻠﯽ را ﻧﺸﺎن ﻣﯽدﻫﺪ‪ .‬ﺑﺮای آﺷﻨﺎﯾﯽ ﺑﺎ دﺳﺘﻮرات ‪ gdb‬ﻣﯽﺗﻮاﻧﯿﺪ ﺑﻪ اﯾﻦ ﻟﯿﻨﮏ ﻣﺮاﺟﻌﻪ‬
‫ﮐﻨﯿﺪ‪.‬‬
‫ﭘﺎﺳﺦ ﺳﻮاﻻت اﯾﻦ ﻗﺴﻤﺖ را در ﻗﺎﻟﺐ ﯾﮏ ﻓﺎﯾﻞ ‪ pdf‬ﮐﻪ دارای ﺗﺼﺎوﯾﺮ اﻧﺠﺎم ﻣﺮاﺣﻞ ﺳﻮال اﺳﺖ‪ ،‬ﺗﻬﯿﻪ ﻧﻤﺎﯾﯿﺪ و در ﺳﺎﻣﺎﻧﻪﻫﺎی‬
‫درس اﻓﺰار ﺷﺮﯾﻒ )‪ (CW‬و ﮐﻮﺋﺮا ﺑﺎرﮔﺬاری ﻧﻤﺎﯾﯿﺪ‪.‬‬
‫ﺳﻮال( ﺑﺎ ﺑﺮرﺳﯽ ﺧﺮوﺟﯽ دﺳﺘﻮر ‪ backtrace‬ﺑﮕﻮﯾﯿﺪ ﮐﺪام ﺗﺎﺑﻊ ‪ syscall‬را ﺻﺪا زده اﺳﺖ‪.‬‬
‫ﭼﻨﺪ ﺑﺎر ‪ n‬را ﻓﺸﺎر دﻫﯿﺪ ﺗﺎ از ﺧﻂ ;)(‪ proc *p = myproc‬ﻋﺒﻮر ﮐﻨﯿﺪ‪ .‬ﭘﺲ از ﻋﺒﻮر از اﯾﻦ دﺳﺘﻮر‪ ،‬ﻋﺒﺎرت ‪ p /x *p‬را‬
‫اﺟﺮا ﮐﻨﯿﺪ‪ .‬اﯾﻦ دﺳﺘﻮر ‪ proc struct‬ﭘﺮدازه ﻓﻌﻠﯽ را در ﻫﮕﺰ ﺑﺮای ﻣﺎ ﭼﺎپ ﻣﯽﮐﻨﺪ )ﻓﺎﯾﻞ ‪ kernel/proc.h‬را ﺑﺒﯿﻨﯿﺪ(‪.‬‬
‫ﺳﻮال( ﻣﻘﺪار ‪ p->trapframe->a7‬را ﺑﺪﺳﺖ آورﯾﺪ‪ .‬اﯾﻦ ﻣﻘﺪار ﭼﻪ ﭼﯿﺰی را ﻧﻤﺎﯾﺶ ﻣﯽدﻫﺪ؟ )راﻫﻨﻤﺎﯾﯽ‪ :‬ﻓﺎﯾﻞ‬
‫‪ user/initcode.S‬ﮐﻪ اوﻟﯿﻦ ﺑﺮﻧﺎﻣﻪ ﮐﺎرﺑﺮ اﺟﺮا ﺷﺪه ﺗﻮﺳﻂ ‪ xv6‬اﺳﺖ را ﺑﺮرﺳﯽ ﮐﻨﯿﺪ‪(.‬‬
‫ﭘﺮدازه در ﺣﺎل اﺟﺮا در ﺣﺎﻟﺖ ﮐﺮﻧﻞ ﻣﯽﺑﺎﺷﺪ و ﻣﯽﺗﻮاﻧﯿﻢ ﺛﺒﺎتﻫﺎی ‪ privileged‬ﻣﺎﻧﻨﺪ ‪ sstatus‬را ﭼﺎپ ﮐﻨﯿﻢ )ﺑﺮای ﺗﻮﺿﯿﺤﺎت‬
‫ﺑﯿﺸﺘﺮﻣﯽﺗﻮاﻧﯿﺪ ﺑﻪ اﯾﻦ ﻣﺴﺘﻨﺪ ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ(‪:‬‬
‫ﺻﻔﺤﻪ ‪ ۵‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫‪(gdb) p /x $sstatus‬‬

‫ﺳﻮال( ﺣﺎﻟﺖ ﻗﺒﻠﯽای ﮐﻪ ﭘﺮدازﻧﺪه در آن ﻗﺮار داﺷﺖ ﭼﻪ ﺑﻮد؟‬

‫در اﯾﻦ ﺗﻤﺮﯾﻦ )ﯾﺎ ﺗﻤﺎرﯾﻦ ﺑﻌﺪی( ﻣﻤﮑﻦ اﺳﺖ دﭼﺎر ﯾﮏ ﺧﻄﺎی ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﺷﻮﯾﺪ ﮐﻪ ﺑﺎﻋﺚ ﺷﻮد ‪ xv6‬دﭼﺎر ‪ panic‬ﺷﻮد‪ .‬ﺑﻪ‬
‫ﻋﻨﻮان ﻣﺜﺎل دﺳﺘﻮر ;‪ num = p->trapframe->a7‬را ﺑﺎ دﺳﺘﻮر ;‪ num = * (int *) 0‬در اﺑﺘﺪای ‪ syscall‬ﺟﺎﯾﮕﺰﯾﻦ‬
‫ﮐﻨﯿﺪ‪ .‬دﺳﺘﻮر ‪ make qemu‬را اﺟﺮا ﮐﻨﯿﺪ‪ ،‬ﺧﺮوﺟﯽ ﺷﻤﺎ ﺑﺎﯾﺪ ﻣﺸﺎﺑﻪ ﭘﯿﺎمﻫﺎی ﻣﻘﺎﺑﻞ ﺑﺎﺷﺪ‪.‬‬
‫‪xv6 kernel is booting‬‬

‫‪hart 2 starting‬‬
‫‪hart 1 starting‬‬
‫‪scause 0 x000000000000000d‬‬
‫‪sepc =0 x000000008000215a stval =0 x0000000000000000‬‬
‫‪panic: kerneltrap‬‬

‫از ‪ qemu‬ﺧﺎرج ﺷﻮﯾﺪ‪.‬‬

‫ﺑﺮای ﯾﺎﻓﺘﻦ ﻣﻨﺸﺄ ‪ page-fault panic‬ﻫﺴﺘﻪ‪ ،‬ﻣﻘﺪار ‪ sepc‬ﮐﻪ ﺑﺮای ‪ panic‬ای ﮐﻪ دﯾﺪه اﯾﺪ اﺳﺖ‪ ،‬را در ﻓﺎﯾﻞ ‪kernel/kernel.asm‬‬
‫ﺟﺴﺘﺠﻮ ﮐﻨﯿﺪ‪ .‬اﯾﻦ ﻓﺎﯾﻞ اﺳﻤﺒﻠﯽ ﮐﺮﻧﻞ ﮐﺎﻣﭙﺎﯾﻞ ﺷﺪه را درون ﺧﻮد دارد‪.‬‬
‫ﺳﻮال( دﺳﺘﻮر اﺳﻤﺒﻠﯽای ﮐﻪ ﺑﺎﻋﺚ ‪ panic‬ﮐﺮدن ﮐﺮﻧﻞ ﺷﺪه اﺳﺖ را ﺑﻨﻮﯾﺴﯿﺪ‪ .‬ﻣﺘﻐﯿﺮ ‪ num‬ﻣﻘﺪار ﻣﺘﻨﺎﻇﺮ ﺑﺎ ﮐﺪام ﺛﺒﺎت را ﻧﺸﺎن‬
‫ﻣﯽدﻫﺪ‪.‬‬
‫ﺑﺮای اﯾﻨﮑﻪ وﺿﻌﯿﺖ ﭘﺮدازﻧﺪه و ﮐﺮﻧﻞ را در زﻣﺎن اﺟﺮای دﺳﺘﻮری ﮐﻪ دﭼﺎر ﺧﻄﺎ ﺷﺪه اﺳﺖ‪ gdb ،‬را اﺟﺮا ﮐﻨﯿﺪ و ﯾﮏ ‪breakpoint‬‬
‫در ﺛﺒﺎت ‪ epc‬ﺑﻪ ﺻﻮرت ﻣﻘﺎﺑﻞ ﻗﺮار دﻫﯿﺪ‪.‬‬
‫‪(gdb) b *0 x000000008000215a‬‬
‫‪Breakpoint 1 at 0 x8000215a : file kernel / syscall .c, line 247.‬‬
‫‪(gdb) layout asm‬‬
‫‪(gdb) c‬‬
‫‪Continuing .‬‬
‫]‪[ Switching to Thread 1.3‬‬

‫‪Thread 3 hit Breakpoint 1, syscall () at kernel / syscall .c:247‬‬

‫ﺗﺎﯾﯿﺪ ﮐﻨﯿﺪ ﮐﻪ دﺳﺘﻮر اﺳﻤﺒﻠﯽای ﮐﻪ دﭼﺎر ﺧﻄﺎ ﺷﺪه اﺳﺖ ﺑﺎ دﺳﺘﻮری ﮐﻪ در ﺑﺨﺶ ﻗﺒﻞ ﭘﯿﺪا ﮐﺮدهاﯾﺪ ﯾﮑﺴﺎن اﺳﺖ‪.‬‬
‫ﺳﻮال( ﭼﺮا ﮐﺮﻧﻞ ﮐﺮش ﻣﯽﮐﻨﺪ؟ آﯾﺎ آدرس ‪ 0‬در ﻓﻀﺎی آدرس ﮐﺮﻧﻞ ﻗﺮار دارد؟ آﯾﺎ ﺟﻮاب ﺷﻤﺎ ﺗﻮﺳﻂ ﻣﻘﺪار ‪ scause‬در ﺑﺨﺶﻫﺎی‬
‫ﻗﺒﻞ ﺗﺎﯾﯿﺪ ﻣﯽﺷﻮد؟ )ﺑﺮای ﺗﻮﺿﯿﺤﺎت ﺑﯿﺸﺘﺮ راﺟﻊ ﺑﻪ ‪ scause‬ﺑﻪ اﯾﻦ ﻣﺴﺘﻨﺪ ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ(‬
‫دﻗﺖ ﮐﻨﯿﺪ ‪ scause‬زﻣﺎﻧﯽ ﮐﻪ ﮐﺮﻧﻞ دﭼﺎر ‪ panic‬ﺷﺪ ﺑﻪ ﺻﻮرت ﺧﻮدﮐﺎر ﭼﺎپ ﺷﺪ‪ ،‬اﻣﺎ در ﺑﻌﻀﯽ از ﻣﻮاﻗﻊ ﺑﻪ اﻃﻼﻋﺎت ﺑﯿﺸﺘﺮی‬
‫ﺑﺮای ﭘﯿﺪا ﮐﺮدن دﻟﯿﻞ رخ دادن ‪ panic‬دارﯾﻢ‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﺑﺮای اﯾﻨﮑﻪ ﺑﺪاﻧﯿﻢ ﭼﻪ ﭘﺮدازه ﮐﺎرﺑﺮی زﻣﺎن ‪ panic‬در ﺣﺎل اﺟﺮا‬
‫ﺑﻮد ﻣﯽﺗﻮاﻧﯿﻢ ﻧﺎم ﭘﺮدازه را ﺑﺎ دﺳﺘﻮر ﻣﻘﺎﺑﻞ ﭼﺎپ ﮐﻨﯿﻢ‪:‬‬
‫‪(gdb) p p->name‬‬

‫ﺳﻮال( ﻧﺎم ﭘﺮدازهای ﮐﻪ زﻣﺎن ‪ panic‬در ﺣﺎل اﺟﺮا ﺑﻮد را ﺑﺪﺳﺖ آورﯾﺪ و آﯾﺪی )‪ (pid‬آن را ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬
‫‪ .۲‬در اﯾﻦ ﺳﻮال‪ ،‬ﺷﻤﺎ ﯾﮏ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ‪ ،‬ﺑﺮای ردﯾﺎﺑﯽ )‪ (tracing‬ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻤﯽ‪ ،‬ﺑﻪ ﮐﺮﻧﻞ اﺿﺎﻓﻪ ﺧﻮاﻫﯿﺪ ﮐﺮد‪.‬‬
‫ﺷﻤﺎ ﺑﺎﯾﺪ ﯾﮏ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ﺟﺪﯾﺪ ﺑﻪ ﻧﺎم ‪ trace‬اﯾﺠﺎد ﮐﻨﯿﺪ ﮐﻪ ﻋﻤﻠﯿﺎت ﮐﻨﺘﺮل ردﯾﺎﺑﯽ )‪ (tracing‬را اﻧﺠﺎم دﻫﺪ‪ .‬اﯾﻦ‬
‫ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ﯾﮏ آرﮔﻮﻣﺎن‪ ،‬ﮐﻪ ﺑﯿﺖ ﻫﺎی آن ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﮐﺪام ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻢ ﺑﺎﯾﺪ ردﯾﺎﺑﯽ ﺷﻮﻧﺪ‪ ،‬را‬
‫ورودی ﻣﯽﮔﯿﺮد‪ .‬ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﺑﺮای ردﯾﺎﺑﯽ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ‪ ،fork‬ﺑﺮﻧﺎﻣﻪ )‪ trace(1 << SYS_fork‬را ﻓﺮاﺧﻮاﻧﯽ‬
‫ﻣﯽﮐﻨﺪ ﮐﻪ در آن ‪ SYS_fork‬ﯾﮏ ﺷﻤﺎره ‪ syscall‬از ‪ kernel/syscall.h‬اﺳﺖ‪ .‬ﺷﻤﺎ ﺑﺎﯾﺪ ﮐﺪﻫﺎی ﮐﺮﻧﻞ ‪ xv6‬را ﺗﻐﯿﯿﺮ‬
‫دﻫﯿﺪ ﺗﺎ وﻗﺘﯽ ﻫﺮ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ در ﺣﺎل ﺑﺎزﮔﺸﺖ اﺳﺖ‪ ،‬اﮔﺮ ﺷﻤﺎره ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ در ‪ mask‬ﻣﺸﺨﺺ ﺷﺪه ﺑﺎﺷﺪ‪،‬‬
‫ﯾﮏ ﺧﻂ ﭼﺎپ ﺷﻮد‪ .‬اﯾﻦ ﺧﻂ ﺑﺎﯾﺪ ﺷﺎﻣﻞ ‪ id‬ﻓﺮآﯾﻨﺪ‪ ،‬ﻧﺎم ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ و ﻣﻘﺪار ﺑﺎزﮔﺸﺖ ﺑﺎﺷﺪ‪ ،‬اﻣﺎ ﻧﯿﺎز ﻧﯿﺴﺖ آرﮔﻮﻣﺎن ﻫﺎی‬
‫ﺻﻔﺤﻪ ‪ ۶‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ را ﭼﺎپ ﮐﻨﯿﺪ‪ .‬ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ‪ trace‬ﺑﺎﯾﺪ ﻋﻤﻠﯿﺎت ‪ tracing‬را ﺑﺮای ﭘﺮدازه ﻓﺮاﺧﻮاﻧﺪه ﺷﺪه و ﻫﻤﻪی‬
‫ﭘﺮدازهﻫﺎی ﻓﺮزﻧﺪ ﮐﻪ ﺗﻮﺳﻂ ‪ fork‬اﯾﺠﺎد ﺷﺪهاﻧﺪ اﻧﺠﺎم دﻫﺪ‪ ،‬اﻣﺎ ﻧﺒﺎﯾﺪ ﺑﺮ روﻧﺪ اﺟﺮای آنﻫﺎ اﺛﺮی ﺑﮕﺬارد‪.‬‬
‫ﺧﺮوﺟﯽ ﮐﺪ ﺷﻤﺎ‪ ،‬ﺑﺎﯾﺪ ﻣﺸﺎﺑﻪ ﺧﺮوﺟﯽ زﯾﺮ ﺑﺎﺷﺪ‪:‬‬
‫‪$ trace 32 grep hello README‬‬
‫‪3: syscall read -> 1023‬‬
‫‪3: syscall read -> 966‬‬
‫‪3: syscall read -> 70‬‬
‫‪3: syscall read -> 0‬‬
‫‪$‬‬
‫‪$ trace 2147483647 grep hello README‬‬
‫‪4: syscall trace -> 0‬‬
‫‪4: syscall exec -> 3‬‬
‫‪4: syscall open -> 3‬‬
‫‪4: syscall read -> 1023‬‬
‫‪4: syscall read -> 966‬‬
‫‪4: syscall read -> 70‬‬
‫‪4: syscall read -> 0‬‬
‫‪4: syscall close -> 0‬‬
‫‪$‬‬
‫‪$ grep hello README‬‬
‫‪$‬‬
‫‪$ trace 2 usertests forkforkfork‬‬
‫‪usertests starting‬‬
‫‪test forkforkfork : 407: syscall fork -> 408‬‬
‫‪408: syscall fork -> 409‬‬
‫‪409: syscall fork -> 410‬‬
‫‪410: syscall fork -> 411‬‬
‫‪409: syscall fork -> 412‬‬
‫‪410: syscall fork -> 413‬‬
‫‪409: syscall fork -> 414‬‬
‫‪411: syscall fork -> 415‬‬
‫‪...‬‬
‫‪$‬‬

‫در ﻧﻤﻮﻧﻪ اول‪ trace ،‬ﻓﻘﻂ ﻓﺮاﺧﻮاﻧﯽ ﺳﯿﺴﺘﻤﯽ ‪ read‬را ﺑﺎ اﺳﺘﻔﺎده از ‪ grep‬ردﯾﺎﺑﯽ ﻣﯽ ﮐﻨﺪ ﮐﻪ در آن ‪ ۳۲‬ﻫﻤﺎن ‪SYS_read‬‬
‫ﻣﯽﺑﺎﺷﺪ‪ .‬در ﻧﻤﻮﻧﻪ دوم‪ trace ،‬در ﺣﺎﻟﯽ ﮐﻪ ﺗﻤﺎم ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻢ را ردﯾﺎﺑﯽ ﻣﯽ ﮐﻨﺪ‪ grep ،‬را ﻧﯿﺰ اﺟﺮا ﻣﯽ ﮐﻨﺪ‪ .‬در‬
‫اﯾﻦ ﺣﺎﻟﺖ ﻋﺪد ‪ 2147483647‬ﻣﻌﺎدل ﺗﻤﺎم ‪ ۳۱‬ﺑﯿﺖ ﭘﺎﯾﯿﻦ اﺳﺖ )ﯾﻌﻨﯽ ﺗﻤﺎﻣﯽ ﻓﺮاﺧﻮاﻧﯽﻫﺎی ﺳﯿﺴﺘﻤﯽ ﻣﻮﺟﻮد در ﻓﺎﯾﻞ‬
‫‪ .(kernel/syscall.h‬در ﻧﻤﻮﻧﻪ ﺳﻮم‪ ،‬ﻫﯿﭻ ﺑﺮﻧﺎﻣﻪای ردﮔﯿﺮی ﻧﺸﺪه اﺳﺖ‪ ،‬ﺑﻨﺎﺑﺮاﯾﻦ ﻫﯿﭻ ﺧﺮوﺟﯽای ﭼﺎپ ﻧﻤﯽﺷﻮد‪.‬‬
‫در ﻧﻤﻮﻧﻪ ﭼﻬﺎرم‪ ،‬ﮐﺪ ﺷﻤﺎ ﺑﺎﯾﺪ ﻓﺮاﺧﻮاﻧﯽﻫﺎی ‪ SYS_fork‬ﺗﻤﺎم ﭘﺮدازهﻫﺎی اﯾﺠﺎد ﺷﺪه ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪی ‪ forkforkfork‬در‬
‫‪ usertests‬را ردﮔﯿﺮی ﮐﻨﺪ‪.‬‬
‫ﭼﻨﺪ راﻫﻨﻤﺎﯾﯽ در ﻣﻮرد اﻧﺠﺎم ﺳﻮال‪:‬‬
‫• اﺑﺘﺪا ‪ $U/_trace‬را ﺑﻪ ‪ UPROGS‬در ‪ Makefile‬اﺿﺎﻓﻪ ﮐﻨﯿﺪ‪.‬‬
‫• دﺳﺘﻮر ‪ make qemu‬را اﺟﺮا ﮐﻨﯿﺪ‪ .‬در اداﻣﻪ ﺧﻮاﻫﯿﺪ دﯾﺪ ﮐﻪ ﮐﺎﻣﭙﺎﯾﻠﺮ ﻧﻤﯽ ﺗﻮاﻧﺪ ‪ user/trace.c‬را ﮐﺎﻣﭙﺎﯾﻞ ﮐﻨﺪ‪ ،‬زﯾﺮا‬
‫‪ stub‬ﻫﺎی ﻓﻀﺎی ﮐﺎرﺑﺮ ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺳﺎﻣﺎﻧﻪ ﻫﻨﻮز وﺟﻮد ﻧﺪارد‪ :‬ﯾﮏ ‪ prototype‬ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺳﺎﻣﺎﻧﻪ ﺑﻪ ‪user/user.h‬‬
‫اﺿﺎﻓﻪ ﮐﻨﯿﺪ‪ ،‬ﯾﮏ ‪ stub‬ﺑﻪ ‪ user/usys.pl‬و ﯾﮏ ﺷﻤﺎره ‪ syscall‬ﺑﻪ ‪ Makefile .kernel/syscall.h‬اﺳﮑﺮﯾﭙﺖ‬
‫‪ perl user/usys.pl‬را ﻓﺮاﺧﻮاﻧﺪه و ‪ stub ،user/usys.S‬ﻫﺎی ﻓﺮاﺧﻮاﻧﯽ ﺳﺎﻣﺎﻧﻪ واﻗﻌﯽ را ﺗﻮﻟﯿﺪ ﻣﯽﮐﻨﺪ‪ ،‬ﮐﻪ‬
‫از دﺳﺘﻮر ‪ ecall‬در اﺳﻤﺒﻠﯽ ‪ RISC-V‬ﺑﺮای اﻧﺘﻘﺎل ﺑﻪ ‪ kernel‬اﺳﺘﻔﺎده ﻣﯽ ﮐﻨﺪ‪ .‬وﻗﺘﯽ ﺷﻤﺎ ﻣﺸﮑﻼت ﮐﺎﻣﭙﺎﯾﻞ را ﺣﻞ‬
‫ﮐﺮدﯾﺪ‪ trace 32 grep hello README ،‬را اﺟﺮا ﮐﻨﯿﺪ؛ اﯾﻦ دﺳﺘﻮر ﺑﺎ ﺷﮑﺴﺖ ﻣﻮاﺟﻪ ﺧﻮاﻫﺪ ﺷﺪ زﯾﺮا ﺷﻤﺎ ﻫﻨﻮز‬
‫ﻓﺮاﺧﻮاﻧﯽ ﺳﺎﻣﺎﻧﻪ را در ‪ kernel‬ﭘﯿﺎده ﺳﺎزی ﻧﮑﺮده اﯾﺪ‪.‬‬
‫• در اداﻣﻪ ﺗﺎﺑﻊ )(‪ sys_trace‬را در ‪ kernel/sysproc.c‬اﺿﺎﻓﻪ ﮐﻨﯿﺪ‪.‬‬
‫ﺻﻔﺤﻪ ‪ ۷‬از ‪۷‬‬ ‫درس ﺳﯿﺴﺘﻢﻫﺎی ﻋﺎﻣﻞ‬

‫• ﺗﺎﺑﻊ )(‪ syscall‬را در ‪ kernel/syscall.c‬ﺗﻐﯿﯿﺮ دﻫﯿﺪ ﺗﺎ ﺧﺮوﺟﯽ ‪ trace‬را ﭼﺎپ ﮐﻨﺪ‪.‬‬

‫ﺑﻪ ﻣﻨﻈﻮر ﺗﺴﺖ ﭘﯿﺎدهﺳﺎزی ﺧﻮد دﺳﺘﻮر ‪ ./grade-lab-syscall trace‬را اﺟﺮا ﻧﻤﺎﯾﯿﺪ‪ .‬ﺑﺎﯾﺪ ﺗﻤﺎم ﺗﺴﺖﻫﺎ درﺳﺖ اﻧﺠﺎم‬
‫ﺑﺸﻮﻧﺪ‪.‬‬
‫ﺑﺮای ﺑﺎرﮔﺬاری ﺗﻤﺮﯾﻦ‪ ،‬اﺑﺘﺪا ﺗﻤﺎﻣﯽ ﺗﻐﯿﯿﺮات را ‪ commit‬ﮐﻨﯿﺪ و ﺳﭙﺲ دﺳﺘﻮر ‪ make zipball‬را اﺟﺮا ﮐﻨﯿﺪ ﮐﻪ ﻣﻨﺠﺮ ﺑﻪ‬
‫ﺗﻮﻟﯿﺪ ﻓﺎﯾﻞ ‪ lab.zip‬ﺧﻮاﻫﺪ ﺷﺪ‪ .‬ﻓﺎﯾﻞ ﻓﺸﺮده را در ﻫﺮ دو ﺳﺎﻣﺎﻧﻪﻫﺎی درساﻓﺰار ﺷﺮﯾﻒ )‪ (CW‬و ﮐﻮﺋﺮا ﺑﺎرﮔﺬاری ﻧﻤﺎﯾﯿﺪ‪.‬‬