කර්නල් මොඩියුලයක ව්‍යුහය සහ එහි සම්පාදන ක්‍රම. මොඩියුලර් ව්‍යුහයක් සහිත වැඩසටහනක් සම්පාදනය කිරීමේ විශේෂාංග. හැඳින්වීම සහ පසුබිම

එවැනි මොඩියුලයක් සම්පාදනය කිරීම සඳහා, ඔබට පහත Makefile භාවිතා කළ හැකිය. $(CC) ... වලින් ආරම්භ වන රේඛාවට පෙර ටැබ් අක්ෂරයක් දැමීමට අමතක නොකරන්න.

Rubini & Corbet විසින් යෝජනා කරන ලද මුල් Hello world කේතයට සාපේක්ෂව මෙය විශේෂාංග දෙකක් භාවිතා කරයි. පළමුව, මොඩියුලය කර්නල් අනුවාදයට සමාන අනුවාදයක් ඇත. මෙය සාක්ෂාත් කරගනු ලබන්නේ PARAM විචල්‍යය සම්පාදනය කිරීමේ ස්ක්‍රිප්ටයේ සැකසීමෙනි. දෙවනුව, මොඩියුලය දැන් GPL යටතේ බලපත්‍ර ලබා දෙනු ඇත (MODULE_LICENSE() macro භාවිතා කරමින්). මෙය සිදු නොකළේ නම්, මොඩියුලය කර්නලයට ස්ථාපනය කරන විට ඔබට පහත අනතුරු ඇඟවීම වැනි දෙයක් දැකිය හැකිය:

# insmod hello_knz.o අවවාදයයි: hello_knz.o පූරණය කිරීම කර්නලය අපවිත්‍ර කරයි: බලපත්‍රයක් නැත, අවවාද සහිත, දූෂිත මොඩියුල පිළිබඳ තොරතුරු සඳහා http://www.tux.org/lkml/#export-tainted මොඩියුලය hello_knz පූරණය කර ඇත.

අපි දැන් මොඩියුල සම්පාදන විකල්ප පැහැදිලි කරමු (සාර්ව අර්ථ දැක්වීම් පසුව පැහැදිලි කරනු ඇත):

-සමග- මෙම විකල්පය සමඟ, gcc සම්පාදකය විසින් වස්තු ගොනුව නිර්මාණය කළ වහාම, ක්‍රියාත්මක කළ හැකි ද්විමය නිර්මාණය කිරීමට උත්සාහ නොකර ගොනු සම්පාදන ක්‍රියාවලිය නවත්වනු ඇත.

- බිත්තිය- gcc ධාවනය වන විට උපරිම අනතුරු ඇඟවීමේ මට්ටම.

-ඩී- සාර්ව සංකේතවල අර්ථ දැක්වීම්. සම්පාදනය කරන ලද ගොනුවේ #define විධානය හා සමාන වේ. මෙම මොඩියුලයේ භාවිතා වන සාර්ව සංකේත නිර්වචනය කරන ආකාරය, මූලාශ්‍ර ගොනුවේ #define භාවිතා කිරීම හෝ සම්පාදකය සඳහා -D විකල්පය භාවිතා කිරීම කිසිදු වෙනසක් නොකරයි.

-මම- ගොනු ඇතුළත් කිරීම සඳහා අමතර සෙවුම් මාර්ග. "uname -r" ආදේශක භාවිතය සැලකිල්ලට ගන්න, දැනට භාවිතා කරන කර්නල් අනුවාදයේ නියම නම තීරණය කරනු ඇත.

ඊළඟ කොටස මොඩියුලයක තවත් උදාහරණයක් සපයයි. එය ස්ථාපනය කර කර්නලයෙන් බාගන්නා ආකාරය ද විස්තරාත්මකව පැහැදිලි කරයි.

ඔරිජිනල් Hello world!

දැන් අපි Rubini & Corbet විසින් පිරිනමනු ලබන සරල "Hello, World" මොඩියුලයේ මුල් කේතය දෙස බලමු. මෙම කේතය කර්නල් අනුවාද 2.0 සිට 2.4 දක්වා සම්පාදනය කළ හැක. මෙම උදාහරණය සහ පොතේ ඉදිරිපත් කර ඇති අනෙකුත් සියල්ල O'Reilly FTP වෙබ් අඩවියෙන් ලබා ගත හැකිය (1 වන පරිච්ඡේදය බලන්න).

//file hello.c #define MODULE #include int init_module(void) ( printk("<1>Hello, world\n"); return 0; ) void cleanup_module(void) ( printk("<1>සමුගන්න කුරිරු ලෝකය\n"); )

කාර්යය printk()ලිනක්ස් කර්නලයේ අර්ථ දක්වා ඇති අතර සම්මත පුස්තකාල ශ්‍රිතයක් ලෙස ක්‍රියා කරයි printf() C භාෂාවෙන්. කර්නලයට තමන්ගේම, වඩාත් සුදුසු කුඩා, අනුමාන ශ්‍රිතයක් අවශ්‍ය වේ, එය පරිශීලක මට්ටමේ පුස්තකාලවල නොව, කර්නලයේ කෙලින්ම අඩංගු වේ. මොඩියුලයකට ශ්‍රිතයක් ඇමතිය හැක printk()මන්ද විධානය භාවිතයෙන් මොඩියුලය පැටවීමෙන් පසුවය insmodමොඩියුලය කර්නලය සමඟ සන්නිවේදනය කරන අතර ප්‍රකාශිත (අපනයන කරන ලද) කර්නල් ශ්‍රිත සහ විචල්‍යයන් වෙත ප්‍රවේශය ඇත.

තන්තු පරාමිතිය "<1>” printk() ශ්‍රිතයට ලබා දීම පණිවිඩයේ ප්‍රමුඛතාවයයි. මුල් ඉංග්‍රීසි මූලාශ්‍ර loglevel යන යෙදුම භාවිතා කරයි, එහි අර්ථය පණිවිඩ ලොග් වීමේ මට්ටම. මෙහිදී, අපි මුල් "ලොග් මට්ටම" වෙනුවට ප්‍රමුඛතා යන පදය භාවිතා කරමු. මෙම උදාහරණයේදී, අඩු අංකයක් ඇති පණිවිඩය සඳහා අපි ඉහළ ප්‍රමුඛතාවයක් භාවිතා කරමු. ඉහළ පණිවිඩ ප්‍රමුඛතාවය හිතාමතාම සකසා ඇත, මන්ද පෙරනිමි ප්‍රමුඛතාවය සහිත පණිවිඩයක් මොඩියුලය ස්ථාපනය කර ඇති කොන්සෝලයේ නොපෙන්වයි. පෙරනිමි ප්‍රමුඛතාවය සහිත කර්නල් පණිවිඩවල ප්‍රතිදාන දිශාව ධාවනය වන කර්නලයේ අනුවාදය, ඩීමන් අනුවාදය මත රඳා පවතී. klogd, සහ ඔබේ වින්‍යාසය. වඩාත් විස්තරාත්මකව, කාර්යය සමඟ වැඩ කිරීම printk()අපි 4 වන පරිච්ඡේදයේ දෝශ නිරාකරණ ශිල්පීය ක්‍රම විස්තර කරන්නෙමු.

ඔබට විධානය භාවිතයෙන් මොඩියුලය පරීක්ෂා කළ හැකිය insmodකර්නලය සහ විධාන වල මොඩියුලය ස්ථාපනය කිරීමට rmmodකර්නලයෙන් මොඩියුලයක් ඉවත් කිරීමට. මෙය සිදු කරන්නේ කෙසේදැයි අපි පහතින් පෙන්වන්නෙමු. මෙම අවස්ථාවෙහිදී, init_module() පිවිසුම් ලක්ෂ්‍යය කර්නලයට මොඩියුලයක් ස්ථාපනය කරන විට ක්‍රියාත්මක වන අතර, එය කර්නලයෙන් ඉවත් කළ විට cleanup_module() ක්‍රියාත්මක වේ. මොඩියුල පැටවීම සහ බෑම කළ හැක්කේ වරප්‍රසාද ලත් පරිශීලකයෙකුට පමණක් බව මතක තබා ගන්න.

ඉහත මොඩියුල උදාහරණය භාවිතා කළ හැක්කේ "මොඩියුල අනුවාද සහාය" ධජය අක්‍රිය කර ඇති කර්නලයක් සමඟ පමණි. අවාසනාවකට, බොහෝ බෙදාහැරීම් අනුවාද-පාලිත කර්නල් භාවිතා කරයි (මෙය 11 වන පරිච්ඡේදයේ "කිමෝඩ් සහ උසස් මොඩියුලරීකරණය" හි "මොඩියුලවල අනුවාද පාලනය" කොටසේ සාකච්ඡා කෙරේ). පැකේජයේ පැරණි අනුවාදයන් වුවද මොඩියුලස්එවැනි මොඩියුල තවදුරටත් කළ නොහැකි අනුවාද-පාලිත කර්නල් වෙත පැටවීමට ඉඩ දෙන්න. modutils පැකේජයේ insmod සහ rmmod වැඩසටහන් ඇතුළත් වැඩසටහන් මාලාවක් අඩංගු බව මතක තබා ගන්න.

කාර්යය: ඔබේ බෙදාහැරීමේ සිට මොඩුටිල්ස් පැකේජයේ අනුවාද අංකය සහ සංයුතිය තීරණය කරන්න.

ඔබ එවැනි මොඩියුලයක් අනුවාද පාලනයට සහය දක්වන කර්නලයකට ඇතුළු කිරීමට උත්සාහ කරන විට, ඔබට පහත දැක්වෙන ආකාරයේ දෝෂ පණිවිඩයක් දැකිය හැක:

# insmod hello.o hello.o: kernel-module අනුවාදය නොගැලපීම hello.o කර්නල් අනුවාදය 2.4.20 සඳහා සම්පාදනය කරන ලද අතර මෙම කර්නලය 2.4.20-9asp අනුවාදය වේ.

නාමාවලියෙහි විවිධ මොඩියුලඋදාහරණ ftp.oreilly.com වෙතින් ඔබට මුල් උදාහරණ වැඩසටහන hello.c සොයා ගත හැකි අතර, එය තව ටිකක් රේඛා අඩංගු වන අතර, අනුවාද-පාලිත සහ අනුවාද නොවන කර්නල් දෙකෙහිම ස්ථාපනය කළ හැක. කෙසේ වෙතත්, අනුවාද පාලන සහාය නොමැතිව ඔබේම කර්නලයක් ගොඩනගා ගන්නා ලෙස අපි තරයේ නිර්දේශ කරමු. ඒ සමගම, www.kernel.org වෙබ් අඩවියේ මුල් කර්නල් මූලාශ්‍ර ගැනීම නිර්දේශ කෙරේ.

ඔබ කර්නල් එකලස් කිරීමට අලුත් නම්, http://www.linux.it/kerneldocs/kconf හි Alessandro Rubini (මුල් පොතේ කතුවරුන්ගෙන් එක් අයෙක්) පළ කර ඇති ලිපිය කියවීමට උත්සාහ කරන්න, එය ඔබට ක්‍රියාවලිය ප්‍රගුණ කිරීමට උපකාරී වේ.

ඉහත මුල් උදාහරණ මොඩියුලය සම්පාදනය කිරීමට සහ පරීක්ෂා කිරීමට පෙළ කොන්සෝලය තුළ පහත විධානයන් ක්‍රියාත්මක කරන්න.

Root# gcc -c hello.c root# insmod ./hello.o හෙලෝ, ලෝක මූල# rmmod හලෝ සමුගැනීම කුරිරු ලෝක මූල#

පණිවිඩ තන්තු යැවීමට ඔබේ පද්ධතිය භාවිතා කරන යාන්ත්‍රණය මත පදනම්ව, ශ්‍රිතය මඟින් එවන පණිවිඩවල ප්‍රතිදාන දිශාව printk(), වෙනස් විය හැක. මොඩියුලයක් සම්පාදනය කිරීම සහ පරීක්ෂා කිරීම සඳහා ලබා දී ඇති උදාහරණයේ, printk() ශ්‍රිතයෙන් එවන ලද පණිවිඩ මොඩියුල ස්ථාපනය කිරීමට සහ ක්‍රියාත්මක කිරීමට විධාන ලබා දුන් එකම කොන්සෝලයට ප්‍රතිදානය කරන ලදී. මෙම උදාහරණය පෙළ කොන්සෝලයකින් උපුටා ගන්නා ලදී. ඔබ විධාන ක්රියාත්මක කරන්නේ නම් insmodසහ rmmodවැඩසටහන යටතේ සිට xterm, එවිට බොහෝ විට ඔබට ඔබගේ ටර්මිනලයේ කිසිවක් නොපෙනේ. ඒ වෙනුවට, පණිවිඩය පද්ධති ලොග් එකකින් අවසන් විය හැක, උදාහරණයක් ලෙස in /var/log/messages.ගොනුවේ නිශ්චිත නම බෙදා හැරීම මත රඳා පවතී. ලොග් ගොනු වල වෙනස්වීම් කාලය දෙස බලන්න. printk() ශ්‍රිතයෙන් පණිවිඩ යැවීමට භාවිතා කරන යාන්ත්‍රණය 4 වන පරිච්ඡේදයේ "Techniques" හි "පණිවිඩ ලොග් වන්නේ කෙසේද" කොටසේ විස්තර කර ඇත.
නිදොස් කිරීම".

පද්ධති ලොග් ගොනුව /val/log/messages හි මොඩියුල පණිවිඩ බැලීම සඳහා එය භාවිතා කිරීම පහසුය පද්ධති උපයෝගීතාව tail, පෙරනිමියෙන්, එය වෙත ගිය ගොනුවේ අවසාන පේළි 10 පෙන්වයි. මෙම උපයෝගීතාවයේ සිත්ගන්නා විකල්පයක් වන්නේ -f විකල්පයයි, එය ගොනුවේ අවසාන පේළි නිරීක්ෂණය කිරීමේ මාදිලියේ උපයෝගීතාව ක්රියාත්මක කරයි, i.e. ගොනුවේ නව රේඛා දිස්වන විට, ඒවා ස්වයංක්රීයව මුද්රණය කරනු ලැබේ. මෙම අවස්ථාවේදී විධානය ක්‍රියාත්මක කිරීම නැවැත්වීමට, ඔබ Ctrl + C ඔබන්න. මේ අනුව, පද්ධති ලොග් ගොනුවේ අවසාන පේළි දහය බැලීමට, විධාන රේඛාවේදී පහත සඳහන් දෑ ඇතුළත් කරන්න:

Root# tail /var/log/messages

ඔබට පෙනෙන පරිදි, මොඩියුලයක් ලිවීම පෙනෙන තරම් අපහසු නොවේ. අමාරුම කොටස වන්නේ ඔබේ උපාංගය ක්‍රියා කරන ආකාරය සහ මොඩියුලයේ ක්‍රියාකාරිත්වය වැඩි දියුණු කරන්නේ කෙසේද යන්න තේරුම් ගැනීමයි. අපි මෙම පරිච්ඡේදය දිගටම කරගෙන යන විට, අපි සරල මොඩියුල ලිවීම ගැන වැඩිදුර ඉගෙන ගනිමු, පසුව පරිච්ඡේද සඳහා උපාංගයේ විශේෂතා තබමු.

කර්නල් මොඩියුල සහ යෙදුම් අතර වෙනස්කම්

යෙදුමට එක් පිවිසුම් ලක්ෂයක් ඇත, එය ස්ථානගත කළ වහාම ක්‍රියාත්මක වීමට පටන් ගනී ධාවනය වන යෙදුමපරිගණකයේ RAM එකේ. මෙම පිවිසුම් ලක්ෂ්‍යය C හි ප්‍රධාන() ශ්‍රිතය ලෙස විස්තර කෙරේ. ප්‍රධාන() ශ්‍රිතය අවසන් කිරීම යනු යෙදුම අවසන් කිරීමයි. මොඩියුලය කර්නලයෙන් මොඩියුලය ස්ථාපනය කිරීමේදී සහ ඉවත් කිරීමේදී මෙන්ම පරිශීලකයාගේ ඉල්ලීම් සැකසීමේදී ක්‍රියාත්මක වන ප්‍රවේශ ස්ථාන කිහිපයක් ඇත. මේ අනුව, මොඩියුලය කර්නලය තුළට පටවන විට ඇතුල් වීමේ ලක්ෂ්‍යය init_module() ක්‍රියාත්මක වේ. මොඩියුලයක් බාන විට cleanup_module() ශ්‍රිතය ක්‍රියාත්මක වේ. අනාගතයේදී, මොඩියුලයට විවිධ ඉල්ලීම් ක්‍රියාත්මක කිරීමේදී ක්‍රියාත්මක වන මොඩියුලයට ඇතුළු වන වෙනත් ස්ථාන සමඟ අපි දැන හඳුනා ගන්නෙමු.

මොඩියුල පැටවීම සහ බෑම කිරීමේ හැකියාව මොඩියුලේෂන් යාන්ත්රණයේ කුළුණු දෙකකි. ඒවා විවිධ ආකාරවලින් තක්සේරු කළ හැකිය. සංවර්ධකයා සඳහා, මෙයින් අදහස් කරන්නේ, පළමුවෙන්ම, සංවර්ධන කාලය අඩු කිරීමයි දිගු නැවත පණගැන්වීමේ ක්‍රියාවලියකින් තොරව ඔබට ධාවක ක්‍රියාකාරිත්වය පරීක්ෂා කළ හැක.

ක්‍රමලේඛකයෙකු ලෙස, යෙදුමකට යෙදුමේ ප්‍රකාශ නොකළ ශ්‍රිතයක් ඇමතීමට හැකි බව ඔබ දන්නවා. ස්ථිතික හෝ ගතික සම්බන්ධ කිරීමේ අදියරේදී, අනුරූප පුස්තකාල වලින් එවැනි කාර්යයන්හි ලිපිනයන් තීරණය කරනු ලැබේ. කාර්යය printf()පුස්තකාලයේ අර්ථ දක්වා ඇති මෙම කැඳවිය හැකි කාර්යයන් වලින් එකක් libc. අනෙක් අතට, මොඩියුලය කර්නලය සමඟ පමණක් සම්බන්ධ වන අතර කර්නලය මගින් අපනයනය කරන කාර්යයන් පමණක් ඇමතීමට හැකිය. කර්නලය තුළ ක්‍රියාත්මක කරන ලද කේතය බාහිර පුස්තකාල භාවිතා කළ නොහැක. ඉතින්, උදාහරණයක් ලෙස, කාර්යය printk(), උදාහරණයේ භාවිතා කරන ලදී hello.c, සුප්රසිද්ධ ශ්රිතයේ ප්රතිසමයකි printf(), පරිශීලක මට්ටමේ යෙදුම් වලින් ලබා ගත හැක. කාර්යය printk()හරය තුළ පිහිටා ඇති අතර හැකි තරම් කුඩා විය යුතුය. එබැවින්, printf() මෙන් නොව, දත්ත වර්ග සඳහා ඉතා සීමිත සහයක් ඇති අතර, උදාහරණයක් ලෙස, පාවෙන ලක්ෂ්‍ය සංඛ්‍යා සඳහා කිසිසේත්ම සහය නොදක්වයි.

2.0 සහ 2.2 කර්නල් ක්‍රියාත්මක කිරීම් වර්ග පිරිවිතර සඳහා සහය නොදක්වයි එල්සහ Z. ඒවා හඳුන්වා දුන්නේ කර්නල් අනුවාදය 2.4 හි පමණි.

රූප සටහන 2-1 පෙන්නුම් කරන්නේ මොඩියුලයට ඇතුල් වීමේ ස්ථාන වන කාර්යයන් ඇමතීම සඳහා යාන්ත්රණය ක්රියාත්මක කිරීමයි. එසේම, මෙම රූපය කර්නලය සමඟ ස්ථාපිත හෝ ස්ථාපිත මොඩියුලයක අන්තර්ක්රියා යාන්ත්රණය පෙන්වයි.

සහල්. 2-1. මොඩියුලය සහ කර්නලය අතර සන්නිවේදනය

Unix/Linux මෙහෙයුම් පද්ධතිවල ඇති එක් ලක්ෂණයක් වන්නේ කර්නල් මොඩියුල සමඟ සම්බන්ධ කළ හැකි පුස්තකාල නොමැති වීමයි. ඔබ දැනටමත් දන්නා පරිදි, මොඩියුල, පූරණය වූ විට, කර්නලය වෙත සම්බන්ධ කර ඇත, එබැවින් ඔබගේ මොඩියුලයට පිටතින් ඇති සියලුම කාර්යයන් කර්නල් ශීර්ෂ ගොනු තුළ ප්‍රකාශ කර කර්නලය තුළ තිබිය යුතුය. මොඩියුල මූලාශ්ර කවදාවත්පරිශීලක අභ්‍යවකාශ පුස්තකාලවලින් සාමාන්‍ය ශීර්ෂ ගොනු ඇතුළත් නොකළ යුතුය. කර්නල් මොඩියුලවල, ඔබට භාවිතා කළ හැක්කේ කර්නලයේ සැබෑ කොටසක් වන කාර්යයන් පමණි.

සම්පූර්ණ කර්නල් අතුරුමුහුණත නාමාවලිවල ඇති ශීර්ෂ ගොනු වල විස්තර කර ඇත ඇතුළත්/ලිනක්ස්සහ ඇතුළත් / asmකර්නල් ප්‍රභවයන් ඇතුළත (සාමාන්‍යයෙන් පිහිටා ඇත /usr/src/linux-x.y.z(x.y.z යනු ඔබේ කර්නල අනුවාදයයි)). පැරණි බෙදාහැරීම් (පදනම් libcඅනුවාදය 5 හෝ ඊට අඩු) සංකේතාත්මක සබැඳි භාවිතා කරන ලදී /usr/include/linuxසහ /usr/include/asmකර්නල් මූලාශ්‍රවල අනුරූප නාමාවලි වෙත. මෙම සංකේතාත්මක සබැඳි මඟින් අවශ්‍ය නම්, පරිශීලක යෙදුම්වල කර්නල් අතුරුමුහුණත් භාවිතා කිරීමට හැකි වේ.

පරිශීලක-අවකාශ පුස්තකාලවල අතුරුමුහුණත දැන් කර්නල් අතුරුමුහුණතෙන් වෙන්ව තිබුණද, සමහර විට පරිශීලක ක්‍රියාවලි සඳහා කර්නල් අතුරුමුහුණත් භාවිතා කිරීමට අවශ්‍ය වේ. කෙසේ වෙතත්, කර්නල් ශීර්ෂ ගොනු වල බොහෝ යොමු කිරීම් කර්නලයට පමණක් යොමු වන අතර පරිශීලක යෙදුම් වෙත ප්‍රවේශ විය නොහැක. එබැවින් මෙම වෙළඳ දැන්වීම් ආරක්ෂා කර ඇත #ifdef __KERNEL__කුට්ටි. ඔබගේ ධාවකය, අනෙකුත් කර්නල් කේතයන් මෙන්, මැක්‍රෝ ප්‍රකාශනයකින් සම්පාදනය කළ යුත්තේ එබැවිනි __ කර්නලය__.

තනි කර්නල් ශීර්ෂ ගොනු වල කාර්යභාරය පොත පුරා සුදුසු පරිදි සාකච්ඡා කෙරේ.

ඕනෑම විශාල මෘදුකාංග ව්‍යාපෘතිවල (කර්නලය වැනි) වැඩ කරන සංවර්ධකයින් දැනුවත් විය යුතු අතර වැළකී සිටිය යුතුය. "නාම අවකාශය දූෂණය". මෙම ගැටලුව ඇති වන්නේ ශ්‍රිත විශාල සංඛ්‍යාවක් සහ ගෝලීය විචල්‍යයන් ඇති විට ඒවායේ නම් ප්‍රමාණවත් ලෙස ප්‍රකාශිත නොවන (වෙන්කර හඳුනාගත හැකි) ය. පසුකාලීනව එවැනි යෙදුම් සමඟ කටයුතු කිරීමට සිදුවන ක්‍රමලේඛකයාට "වෙන්කර ඇති" නම් මතක තබා ගැනීමට සහ නව මූලද්‍රව්‍ය සඳහා අද්විතීය නම් ඉදිරිපත් කිරීමට වැඩි කාලයක් ගත කිරීමට බල කෙරෙයි. නාම ගැටීම් (අපැහැදිලි) මඟින් මොඩියුලයක් පූරණය කිරීමේදී ඇති වන දෝෂවල සිට වෙනස් වින්‍යාසයකින් ගොඩනගා ඇති කර්නලයක් භාවිතා කරන පරිශීලකයින් සඳහා සිදුවිය හැකි අස්ථායී හෝ පැහැදිලි කළ නොහැකි වැඩසටහන් හැසිරීම් දක්වා පුළුල් පරාසයක ගැටලු නිර්මාණය කළ හැකිය.

සංවර්ධකයින්ට කර්නල් කේතය ලිවීමේදී එවැනි වැරදි සිදු කළ නොහැක, මන්ද කුඩාම මොඩියුලය පවා සම්පූර්ණ කර්නලය වෙත සම්බන්ධ වනු ඇත. නාම ගැටීම් වලක්වා ගැනීමට ඇති හොඳම විසඳුම නම් මුලින්ම ඔබගේ වැඩසටහන් වස්තු ලෙස ප්‍රකාශ කිරීමයි ස්ථිතික, සහ, දෙවනුව, ගෝලීය වස්තු නම් කිරීම සඳහා පද්ධතිය තුළ, අද්විතීය උපසර්ගයක් භාවිතා කිරීම. අතිරේකව, මොඩියුල සංවර්ධකයෙකු ලෙස, ඔබට පසුව "කර්නල් සබැඳි වගුව" කොටසේ විස්තර කර ඇති පරිදි, ඔබගේ කේතයේ ඇති වස්තූන්ගේ විෂය පථය පාලනය කළ හැක.

විධානයේ බොහෝ (නමුත් සියල්ලම නොවේ) අනුවාද insmodලෙස ප්‍රකාශ කර නොමැති සියලුම මොඩියුල වස්තූන් අපනයනය කරන්න ස්ථිතික, පෙරනිමියෙන්, i.e. මොඩියුලය මෙම කාර්යය සඳහා විශේෂ උපදෙස් අර්ථ දක්වා නොමැති නම්. එබැවින්, ඔබ අපනයනය කිරීමට අදහස් නොකරන මොඩියුල වස්තූන් ප්‍රකාශ කිරීම තරමක් සාධාරණ ය ස්ථිතික.

මොඩියුලයක් තුළ දේශීය වස්තු සඳහා අද්විතීය උපසර්ගයක් භාවිතා කිරීම නිදොස්කරණය පහසු කරන බැවින් හොඳ භාවිතයක් විය හැකිය. ඔබගේ ධාවකය පරීක්ෂා කරන අතරතුර, ඔබට කර්නලය වෙත අමතර වස්තු අපනයනය කිරීමට අවශ්‍ය විය හැක. නම් නියම කිරීමට අනන්‍ය උපසර්ගයක් භාවිතා කිරීමෙන්, ඔබ කර්නල් නාම අවකාශයට ගැටීම් හඳුන්වා දීමේ අවදානමක් නැත. කර්නලයේ භාවිතා වන උපසර්ග, සම්මුතිය අනුව, කුඩා අකුරු වන අතර, අපි එම සම්මුතියට ඇලී සිටින්නෙමු.

කර්නලය සහ පරිශීලක ක්‍රියාවලි අතර තවත් සැලකිය යුතු වෙනසක් වන්නේ දෝෂ හැසිරවීමේ යාන්ත්‍රණයයි. කර්නලය පරිශීලක ක්‍රියාවලිය ක්‍රියාත්මක කිරීම පාලනය කරයි, එබැවින් පරිශීලක ක්‍රියාවලියේ දෝෂයක් පද්ධතියට හානිකර නොවන පණිවිඩයක් ඇති කරයි: ඛණ්ඩනය කිරීමේ දෝෂය. ඒ අතරම, පරිශීලක යෙදුමේ ප්‍රභව කේතයේ දෝෂ නිරීක්ෂණය කිරීමට නිදොස්කරණයක් සැමවිටම භාවිතා කළ හැක. කර්නලයේ සිදුවන දෝෂ මාරාන්තික වේ - සමස්ත පද්ධතිය සඳහා නොවේ නම්, අවම වශයෙන් වත්මන් ක්‍රියාවලිය සඳහා. 4 වන පරිච්ඡේදයේ "නිදොස් කිරීමේ පද්ධති දෝෂ" කොටසේ, "නිදොස් කිරීමේ ක්‍රම," අපි කර්නල් දෝෂ හඹා යා හැකි ක්‍රම දෙස බලමු.

පරිශීලක අවකාශය සහ කර්නල් අවකාශය

මොඩියුලය ඊනියා තුළ ක්රියාත්මක වේ කර්නල් අවකාශය, යෙදුම් ධාවනය වන අතරතුර . මෙම සංකල්පය මෙහෙයුම් පද්ධති න්‍යායේ පදනම වේ.

මෙහෙයුම් පද්ධතියේ එක් ප්‍රධාන අරමුණක් වන්නේ පරිඝනක සම්පත් සමඟ පරිශීලක සහ පරිශීලක වැඩසටහන් සැපයීමයි, ඒවායින් බොහොමයක් බාහිර උපාංග මගින් නිරූපණය කෙරේ. මෙහෙයුම් පද්ධතිය සම්පත් වෙත ප්රවේශය ලබා දීම පමණක් නොව, ඒවා වෙන් කිරීම සහ භාවිතය පාලනය කිරීම, ගැටුම් සහ අනවසර ප්රවේශයන් වළක්වා ගත යුතුය. මීට අමතරව, මෙහෙයුම් පද්ධතියවැඩසටහන් සඳහා ස්වාධීන මෙහෙයුම් නිර්මාණය කළ හැකි අතර සම්පත් වෙත අනවසරයෙන් ප්රවේශ වීමෙන් ආරක්ෂා විය හැක. මෙම සුළු නොවන ගැටළුව විසඳීම කළ හැක්කේ ප්‍රොසෙසරය පරිශීලක යෙදුම් වලින් පද්ධති වැඩසටහන් ආරක්ෂා කරන්නේ නම් පමණි.

සෑම නවීන ප්‍රොසෙසරයක්ම පාහේ ක්‍රියාත්මක කිරීමේ කේතය සඳහා විවිධ මට්ටමේ වරප්‍රසාද ක්‍රියාත්මක කිරීමෙන් (අවම වශයෙන් මට්ටම් දෙකක් අවශ්‍ය වේ) එවැනි වෙන්වීමක් ලබා දීමට සමත් වේ. උදාහරණයක් ලෙස, I32 ගෘහ නිර්මාණ සැකසුම් සකසනයන් 0 සිට 3 දක්වා වරප්‍රසාද මට්ටම් හතරක් ඇත. එපමණක් නොව, 0 මට්ටමේ ඉහළම වරප්‍රසාද ඇත. එවැනි ප්‍රොසෙසර සඳහා, වරප්‍රසාදිත මට්ටම්වලදී පමණක් ක්‍රියාත්මක කළ හැකි වරප්‍රසාදිත උපදෙස් පන්තියක් ඇත. Unix පද්ධති ප්‍රොසෙසර වරප්‍රසාද මට්ටම් දෙකක් භාවිතා කරයි. ප්‍රොසෙසරයකට වරප්‍රසාද මට්ටම් දෙකකට වඩා තිබේ නම්, අඩුම සහ ඉහළම ඒවා භාවිතා වේ. Unix කර්නලය ක්‍රියාත්මක වේ ඉහළම මට්ටමවරප්‍රසාද, පරිශීලකයාගේ උපකරණ සහ ක්‍රියාවලි පාලනය කිරීම සහතික කිරීම.

ගැන කතා කරන විට කර්නල් අවකාශයසහ පරිශීලක ක්රියාවලිය අවකාශයමෙයින් අදහස් කරන්නේ ක්‍රියාත්මක කළ හැකි කේතය සඳහා විවිධ මට්ටමේ වරප්‍රසාද පමණක් නොව, විවිධ ලිපින අවකාශයන් ද වේ.

Unix ක්‍රියාත්මක කිරීම පරිශීලක ක්‍රියාවලි අවකාශයේ සිට කර්නල් අවකාශයට අවස්ථා දෙකකදී මාරු කරයි. පළමුව, පරිශීලක යෙදුමක් කර්නලය වෙත ඇමතුමක් ලබා දෙන විට (පද්ධති ඇමතුම), සහ දෙවනුව, දෘඪාංග බාධා කිරීම් සේවා කිරීමේදී. පද්ධති ඇමතුමකදී ක්‍රියාත්මක වන කර්නල් කේතය ක්‍රියාවලියක සන්දර්භය තුළ ක්‍රියාත්මක වේ, i.e. ඇමතුම් ක්‍රියාවලිය වෙනුවෙන් ක්‍රියා කරන අතර, එය ක්‍රියාවලියේ ලිපින අවකාශ දත්ත වෙත ප්‍රවේශය ඇත. අනෙක් අතට, දෘඪාංග බාධාවකට සේවා කිරීමේදී ක්‍රියාත්මක කරන කේතය ක්‍රියාවලියට අදාළව අසමමුහුර්ත වන අතර කිසිදු විශේෂ ක්‍රියාවලියකට අයත් නොවේ.

මොඩියුලවල අරමුණ වන්නේ කර්නලයේ ක්රියාකාරිත්වය පුළුල් කිරීමයි. මොඩියුල කේතය කර්නල් අවකාශයේ ක්‍රියාත්මක වේ. සාමාන්‍යයෙන්, මොඩියුලයක් කලින් සඳහන් කළ කාර්යයන් දෙකම ඉටු කරයි: සමහර මොඩියුල කාර්යයන් පද්ධති ඇමතුම්වල කොටසක් ලෙස ක්‍රියාත්මක වන අතර සමහරක් බාධා කිරීම් කළමනාකරණය කිරීම සඳහා වගකිව යුතුය.

කර්නලයේ සමාන්තරකරණය

ක්‍රමලේඛන යෙදුම් වලට ප්‍රතිවිරුද්ධව උපාංග ධාවක ක්‍රමලේඛනය කරන විට, ක්‍රියාත්මක කළ හැකි කේතය සමාන්තරකරණය කිරීමේ ගැටළුව විශේෂයෙන් උග්‍ර වේ. සාමාන්‍යයෙන්, යෙදුමක් එහි පරිසරයේ වෙනස්කම් ගැන කරදර නොවී ආරම්භයේ සිට අවසානය දක්වා අනුපිළිවෙලින් ක්‍රියාත්මක වේ. කර්නල් කේතය එකවර කිහිප වතාවක් ප්‍රවේශ විය හැකි බව අවබෝධයෙන් ක්‍රියා කළ යුතුය.

කර්නල් කේතය සමාන්තර කිරීමට බොහෝ හේතු තිබේ. Linux හි සාමාන්‍යයෙන් බොහෝ ක්‍රියාවලි ක්‍රියාත්මක වන අතර සමහර ඒවා ඔබගේ මොඩියුල කේතයට එකවර ප්‍රවේශ වීමට උත්සාහ කළ හැක. බොහෝ උපාංග ප්‍රොසෙසරයේ දෘඪාංග බාධා ඇති කළ හැක. බාධා හසුරුවන්නන් අසමමිතික ලෙස හඳුන්වනු ලබන අතර ඔබේ රියදුරු වෙනත් ඉල්ලීමක් ක්‍රියාත්මක කරන අතරතුර ඇමතිය හැක. සමහර මෘදුකාංග වියුක්ත කිරීම් (කර්නල් ටයිමර් වැනි, 6 වන පරිච්ඡේදයේ විස්තර කර ඇත, “කාල ප්‍රවාහය”) ද අසමමිතිකව ක්‍රියාත්මක වේ. මීට අමතරව, Linux සමමිතික බහු සකසන (SMP) සහිත පද්ධතියක් මත ධාවනය කළ හැක, එයින් අදහස් වන්නේ ඔබේ ධාවක කේතය එකවර ප්‍රොසෙසර කිහිපයක් මත සමාන්තරව ක්‍රියාත්මක විය හැකි බවයි.

මෙම හේතූන් නිසා, ධාවක කේතය ඇතුළුව Linux කර්නල් කේතය නැවත ඇතුළත් කළ යුතුය, i.e. එකවර දත්ත සන්දර්භය එකකට වඩා වැඩ කිරීමට හැකි විය යුතුය. බහු නූල් සමාන්තරව ක්‍රියාත්මක කිරීම සඳහා දත්ත ව්‍යුහයන් සැලසුම් කළ යුතුය. අනෙක් අතට, කර්නල් කේතයට සමාන්තර දත්ත ප්‍රවාහ කිහිපයකට හානි නොකර හැසිරවීමට හැකි විය යුතුය. සමාන්තරව ක්‍රියාත්මක කළ හැකි කේතයක් ලිවීමට සහ වෙනස් ක්‍රියාත්මක කිරීමේ අනුපිළිවෙලක් අනවශ්‍ය පද්ධති හැසිරීම් වලට තුඩු දෙන අවස්ථා වළක්වා ගැනීමට බොහෝ කාලයක් අවශ්‍ය වන අතර සමහර විට බොහෝ උපක්‍රම අවශ්‍ය වේ. මෙම පොතේ සෑම රියදුරු උදාහරණයක්ම සමාන්තර ක්‍රියාත්මක කිරීම මනසේ තබාගෙන ලියා ඇත. අවශ්ය නම්, එවැනි කේතයක් ලිවීමේ තාක්ෂණයේ විශේෂතා අපි පැහැදිලි කරන්නෙමු.

බොහෝ සාමාන්ය දෝෂයක්‍රමලේඛකයින් කරන ප්‍රශ්නය නම් සමහර කේත කොටස් නින්දට යාමට නොහැකි නිසා සමගාමී බව ගැටලුවක් නොවන බව ඔවුන් උපකල්පනය කිරීමයි. ඇත්ත වශයෙන්ම, ලිනක්ස් කර්නලය පිටු නොපවතින අතර, බාධාකාරී හසුරුවන්නා හැර, විවේචනාත්මක කර්නල් කේතය ක්‍රියාත්මක වන විට CPU ලබා ගත නොහැක. මෑතකාලීනව, බොහෝ අවස්ථාවලදී අනවශ්‍ය සමාන්තරකරණය වැලැක්වීමට පිටු නොවීමේ හැකියාව ප්‍රමාණවත් විය. කෙසේ වෙතත්, SMP පද්ධති මත, සමාන්තර ගණනය කිරීම හේතුවෙන් කේත බාගත කිරීම අවශ්ය නොවේ.

ඔබගේ කේතය එය ගොඩ නොගනු ඇතැයි උපකල්පනය කරන්නේ නම්, එය SMP පද්ධති මත නිවැරදිව ක්‍රියා නොකරනු ඇත. ඔබට එවැනි පද්ධතියක් නොමැති වුවද, ඔබගේ කේතය භාවිතා කරන වෙනත් අයෙකුට එය තිබිය හැක. අනාගතයේදී කර්නලය පිටු හැකියාව භාවිතා කිරීමට ඉඩ ඇත, එබැවින් තනි-ප්‍රොසෙසර පද්ධති පවා සමගාමීව කටයුතු කිරීමට සිදුවනු ඇත. එවැනි කර්නල් ක්රියාත්මක කිරීම සඳහා දැනටමත් විකල්ප තිබේ. මේ අනුව, විචක්ෂණශීලී ක්‍රමලේඛකයෙකු එය SMP ධාවනය වන පද්ධතියක් මත ක්‍රියාත්මක වේ යැයි උපකල්පනය කරමින් කර්නල් කේතයක් ලියයි.

සටහන පරිවර්තක:කණගාටුයි, නමුත් අවසාන ඡේද දෙක මට පැහැදිලි නැත. මෙය වැරදි පරිවර්තනයක ප්‍රතිඵලයක් විය හැක. ඒ නිසා මම මුල් පිටපත ඉදිරිපත් කරනවා.

ධාවක ක්‍රමලේඛකයින් විසින් කරන ලද පොදු වැරැද්දක් නම්, යම් කේතයක් පවතින තාක් දුරට සමගාමීත්වය ගැටළුවක් නොවන බව උපකල්පනය කිරීමයි.
කරන්නේ නැහැනින්දට යන්න (හෝ "බ්ලොක්"). ලිනක්ස් කර්නලය පෙරදැරි නොවන බව සත්‍යයකි; වැදගත් ව්යතිරේකයක් සමඟ
සේවා බාධා කිරීම්, එය කැමැත්තෙන් ලබා නොදෙන කර්නල් කේතයෙන් ප්‍රොසෙසරය ඉවතට නොගනු ඇත. පසුගිය කාලවලදී, මෙය පූර්වගාමී නොවේ
බොහෝ විට අනවශ්‍ය සමපාත වීම වැළැක්වීමට හැසිරීම ප්‍රමාණවත් විය. කෙසේ වෙතත්, SMP පද්ධති මත, ඇතිවීමට පූර්වාරක්ෂාවන් අවශ්‍ය නොවේ
සමගාමී ක්රියාත්මක කිරීම.

ඔබගේ කේතය එය පූර්වාපේක්‍ෂා නොකරනු ඇතැයි උපකල්පනය කරන්නේ නම්, එය SMP පද්ධති මත නිසි ලෙස ක්‍රියාත්මක නොවේ. ඔබට එවැනි පද්ධතියක් නොමැති වුවද,
ඔබගේ කේතය ක්‍රියාත්මක කරන අනෙක් අයට එකක් තිබිය හැක. අනාගතයේදී, කර්නලය පූර්වාරක්ෂක මෙහෙයුම් ආකාරයකට මාරු වීමටද ඉඩ ඇත.
එම අවස්ථාවේදී යුනිප්‍රොසෙසර පද්ධතිවලට පවා සෑම තැනකම සමගාමීත්වය සමඟ කටයුතු කිරීමට සිදුවනු ඇත (කර්නලයේ සමහර ප්‍රභේද දැනටමත් ක්‍රියාත්මක වේ
එය).

වත්මන් ක්රියාවලිය පිළිබඳ තොරතුරු

කර්නල් මොඩියුල කේතය යෙදුම් මෙන් අනුක්‍රමිකව ක්‍රියාත්මක නොකළද, කර්නලය වෙත ලැබෙන බොහෝ ඇමතුම් එය ඇමතීමේ ක්‍රියාවලියට සාපේක්ෂව ක්‍රියාත්මක වේ. ව්‍යුහයට යොමු වන ගෝලීය දර්ශකයකට ප්‍රවේශ වීමෙන් කර්නල් කේතයට එය හැඳින්වූ ක්‍රියාවලිය හඳුනාගත හැකිය struct task_struct, ගොනුවේ කර්නල් අනුවාදය 2.4 සඳහා අර්ථ දක්වා ඇත ඇතුළත් . පොයින්ටර් දැනටදැනට ක්රියාත්මක වන පරිශීලක ක්රියාවලිය පෙන්නුම් කරයි. වැනි පද්ධති ඇමතුම් ක්‍රියාත්මක කරන විට විවෘත()හෝ සමීප (), ඒවාට හේතු වූ ක්‍රියාවලියක් තිබිය යුතුය. කර්නල් කේතයට, අවශ්‍ය නම්, ඇමතුම් ක්‍රියාවලිය පිළිබඳ නිශ්චිත තොරතුරු දර්ශකයක් හරහා ඇමතීමට හැකිය දැනට. මෙම දර්ශකය භාවිතා කිරීමේ උදාහරණ සඳහා, 5 වන පරිච්ඡේදයේ "උපාංග ගොනු ප්‍රවේශ පාලනය" කොටස බලන්න, "වැඩිදියුණු කළ Char Driver මෙහෙයුම්."

අද, දර්ශකය දැනටකර්නලයේ පෙර අනුවාද වල මෙන් තවදුරටත් ගෝලීය විචල්‍යයක් නොවේ. සංවර්ධකයින් වත්මන් ක්‍රියාවලිය විස්තර කරන ව්‍යුහයට ප්‍රවේශය අට්ටි පිටුවට ගෙන යාමෙන් ප්‍රශස්ත කර ඇත. ඔබට ගොනුවේ වත්මන් ක්රියාත්මක කිරීමේ විස්තර දෙස බැලිය හැක . ඔබ එහි දකින කේතය ඔබට සරල නොවිය හැක. Linux යනු SMP කේන්ද්‍රීය පද්ධතියක් බව මතක තබා ගන්න, ඔබ බහු CPU සමඟ ගනුදෙනු කරන විට ගෝලීය විචල්‍යයක් ක්‍රියා නොකරනු ඇත. ක්‍රියාත්මක කිරීමේ විස්තර වෙනත් කර්නල් උප පද්ධති වෙත සැඟවී පවතින අතර උපාංග ධාවකයට දර්ශකය වෙත ප්‍රවේශ විය හැක. දැනටඅතුරු මුහුණත හරහා පමණි .

මොඩියුලයේ දෘෂ්ටි කෝණයෙන්, දැනටබාහිර සබැඳියක් වගේ printk(). මොඩියුලය භාවිතා කළ හැකිය දැනටඅවශ්ය ඕනෑම තැනක. උදාහරණයක් ලෙස, පහත කේත කොටස මඟින් ක්‍රියාවලි හැඳුනුම්පත (PID) සහ මොඩියුලය ලෙස හැඳින්වෙන ක්‍රියාවලියේ විධාන නාමය මුද්‍රණය කරයි, ඒවා ව්‍යුහයේ අනුරූප ක්ෂේත්‍ර හරහා ලබා ගනී. struct task_struct:

Printk("ක්‍රියාවලිය \"%s\" (pid %i)\n", current->comm, current->pid);

වත්මන්->කොම් ක්ෂේත්‍රය යනු වත්මන් ක්‍රියාවලියට හේතු වූ විධාන ගොනුවේ නමයි.

මොඩියුල සම්පාදනය කිරීම සහ පැටවීම

මෙම පරිච්ඡේදයේ ඉතිරි කොටස සම්පූර්ණ, විකෘති මොඩියුලයක් ලිවීමට කැප කර ඇත. එම. මොඩියුලය 1 වන පරිච්ඡේදයේ "උපාංගය සහ මොඩියුල පන්ති" කොටසේ විස්තර කර ඇති කිසිදු පන්තියකට අයත් නොවේ, "උපාංග ධාවක සඳහා හැඳින්වීම." මෙම පරිච්ඡේදයේ පෙන්වා ඇති උදාහරණ ධාවකය හිස් කබල ලෙස හැඳින්වේ (ප්‍රදේශයන් පැටවීම සඳහා සරල කර්නල් උපයෝගීතාව). ඔබට ඔබේම දේශීය කේතයක් ලිවීමට අච්චුවක් ලෙස ස්කල් මොඩියුලය භාවිතා කළ හැක.

පැරණි යුනික්ස් සම්ප්‍රදායේ (/usr/local) ඔබගේ පුද්ගලික කේත වෙනස් කිරීම් අවධාරණය කිරීමට අපි "දේශීය කේතය" (දේශීය) සංකල්පය භාවිතා කරමු.

කෙසේ වෙතත්, අපි init_module() සහ cleanup_module() ශ්‍රිතයන් පිරවීමට පෙර, අපි මොඩියුලයේ වස්තු කේතය සෑදීමට භාවිතා කරන Makefile ස්ක්‍රිප්ට් එකක් ලියන්නෙමු.

ප්‍රොසෙසරයට ඕනෑම ශීර්ෂ ගොනුවක් ඇතුළත් කිරීමට පෙර, __KERNEL__ මැක්‍රෝ සංකේතය #define විධානයක් සමඟින් අර්ථ දැක්විය යුතුය. කලින් සඳහන් කළ පරිදි, කර්නල් අතුරුමුහුණත් ගොනු තුළ කර්නල්-විශේෂිත සන්දර්භයක් අර්ථ දැක්විය හැක, පෙර සැකසුම් කිරීමේදී __KERNEL__ සංකේතය පූර්වයෙන් අර්ථ දක්වා තිබේ නම් පමණි.

#define විධානය මගින් අර්ථ දක්වා ඇති තවත් වැදගත් සංකේතයක් වන්නේ MODULE සංකේතයයි. අතුරු මුහුණත සක්රිය කිරීමට පෙර අර්ථ දැක්විය යුතුය (කර්නලය සමඟ සම්පාදනය කරනු ලබන එම ධාවක හැර). කර්නලයට එකලස් කරන ලද රියදුරන් මෙම පොතෙහි විස්තර නොකෙරේ, එබැවින් අපගේ සියලුම උදාහරණවල මොඩියුල සංකේතය පවතී.

ඔබ SMP සහිත පද්ධතියක් සඳහා මොඩියුලයක් ගොඩනඟන්නේ නම්, කර්නල් අතුරුමුහුණත් සක්‍රීය කිරීමට පෙර ඔබ __SMP__ සාර්ව සංකේතය ද අර්ථ දැක්විය යුතුය. කර්නල් අනුවාදය 2.2 හි, කර්නල් වින්‍යාසයේ වෙනම අයිතමයක් තනි-ප්‍රොසෙසරයක් සහ බහු ප්‍රොසෙසර පද්ධතියක් අතර තේරීමක් හඳුන්වා දුන්නේය. එබැවින්, පහත පේළි ඔබේ මොඩියුලයේ පළමු පේළි ලෙස ඇතුළත් කිරීම බහු ප්‍රොසෙසර සහාය ඇති කරයි.

#ඇතුළත් #ifdef CONFIG_SMP # __SMP__ #endif නිර්වචනය කරන්න

බොහෝ කාර්යයන් කර්නල් ශීර්ෂ ගොනු තුළ පේළිගතව ප්‍රකාශ කර ඇති නිසා මොඩියුල සංවර්ධකයින් සම්පාදකය සඳහා -O ප්‍රශස්තිකරණ ධජය නිර්වචනය කළ යුතුය. ප්‍රශස්තකරණය සක්‍රීය කර ඇත්නම් මිස gcc සම්පාදකය ශ්‍රිතවල පේළිගත ප්‍රසාරණය සිදු නොකරයි. -g සහ -O විකල්පයන් භාවිතයෙන් පේළිගත ආදේශන දිගු කිරීමට ඉඩ දීමෙන් ඔබට නිදොස්කරණයේ පේළිගත ශ්‍රිත භාවිතා කරන කේතය පසුව නිදොස් කිරීමට ඉඩ ලබා දේ. කර්නලය පේළිගත ශ්‍රිතයන් පුළුල් ලෙස භාවිතා කරන බැවින්, ඒවා නිවැරදිව දිගු කිරීම ඉතා වැදගත් වේ.

කෙසේ වෙතත්, -O2 මට්ටමට ඉහලින් ඕනෑම ප්‍රශස්තකරණයක් භාවිතා කිරීම අවදානම් සහගත බව සලකන්න, මන්ද සම්පාදනය කරන්නා විසින් පේළිගතව ප්‍රකාශ නොකළ කාර්යයන් දිගු කළ හැක. මෙය ගැටළු වලට තුඩු දිය හැකි නිසා ... සමහර ක්‍රියාකාරී කේතය එහි ඇමතුමේ සම්මත තොගය සොයා ගැනීමට අපේක්ෂා කරයි. පේළිගත දිගුවක් යනු අදාළ ශ්‍රිත ඇමතුම් උපදෙස් වෙනුවට එහි ඇමතුමේ ස්ථානයේ ශ්‍රිත කේතයක් ඇතුළත් කිරීම ලෙසයි. ඒ අනුව, මෙම අවස්ථාවෙහිදී, ක්රියාකාරී ඇමතුමක් නොමැති බැවින්, එහි ඇමතුමෙහි තොගයක් නොමැත.

ඔබ මොඩියුලය ස්ථාපනය කරන කර්නලය තැනීමට භාවිතා කරන ලද මොඩියුල සම්පාදනය කිරීමට භාවිතා කරන එකම සම්පාදකය බව සහතික කිරීමට ඔබට අවශ්‍ය විය හැක. විස්තර සඳහා, ගොනුවේ මුල් ලේඛනය බලන්න ලේඛන/වෙනස් කිරීම්කර්නල් මූලාශ්‍ර නාමාවලියෙහි පිහිටා ඇත. කර්නලය සහ සම්පාදක සංවර්ධනය සාමාන්‍යයෙන් සංවර්ධන කණ්ඩායම් හරහා සමමුහුර්ත වේ. මෙම මූලද්‍රව්‍යවලින් එකක් යාවත්කාලීන කිරීමෙන් තවත් එකක දෝෂ අනාවරණය වන අවස්ථා තිබිය හැකිය. සමහර බෙදාහැරීමේ නිෂ්පාදකයින් ඔවුන් භාවිතා කරන කර්නලයට නොගැලපෙන සම්පාදකයේ අති-නව අනුවාදයන් සපයයි. මෙම අවස්ථාවේදී, ඔවුන් සාමාන්යයෙන් වෙනම පැකේජයක් සපයයි (බොහෝ විට හැඳින්වේ kgcc) සඳහා විශේෂයෙන් නිර්මාණය කර ඇති සම්පාදකයක් සමඟ
කර්නල් සම්පාදනය.

අවසාන වශයෙන්, අප්රසන්න දෝෂ වළක්වා ගැනීම සඳහා, අපි ඔබට compile විකල්පය භාවිතා කිරීමට යෝජනා කරමු - බිත්තිය(සියලු අනතුරු ඇඟවීම් - සියලුම අනතුරු ඇඟවීම්). මෙම සියලු අනතුරු ඇඟවීම් තෘප්තිමත් කිරීමට, ඔබට ඔබේ සුපුරුදු ක්‍රමලේඛන විලාසය වෙනස් කිරීමට අවශ්‍ය විය හැක. කර්නල් කේතය ලිවීමේදී, Linus Torvalds විසින් යෝජනා කරන ලද කේතීකරණ විලාසය භාවිතා කිරීම වඩාත් සුදුසුය. ඔව්, ලේඛනය ප්‍රලේඛනය/කෝඩිං ස්ටයිල්,කර්නල් මූලාශ්‍ර නාමාවලියෙන්, ඉතා රසවත් වන අතර කර්නල් මට්ටමේ ක්‍රමලේඛනය ගැන උනන්දුවක් දක්වන සියලු දෙනාටම නිර්දේශ කෙරේ.

අපි මෑතකදී දැන හඳුනා ගත් මොඩියුල සම්පාදන කොඩි කට්ටලයක් විචල්‍යයක තැබීම නිර්දේශ කෙරේ. CFLAGSඔබගේ Makefile. Make utility සඳහා, මෙය විශේෂ විචල්‍යයක් වන අතර, එහි භාවිතය පහත විස්තරයෙන් පැහැදිලි වනු ඇත.

විචල්‍යයේ කොඩි වලට අමතරව CFLAGS, ඔබට ඔබේ Makefile හි විවිධ වස්තු ගොනු ඒකාබද්ධ කරන ඉලක්කයක් අවශ්‍ය විය හැකිය. එවැනි ඉලක්කයක් අවශ්ය වන්නේ මොඩියුල කේතය මූලාශ්ර ගොනු කිහිපයකට බෙදා ඇති විට පමණි, එය සාමාන්යයෙන් අසාමාන්ය නොවේ. වස්තු ගොනු විධානය සමඟ ඒකාබද්ධ වේ ld -r, සම්බන්ධකයක් භාවිතා කළද, පොදුවේ පිළිගත් අර්ථයෙන් සම්බන්ධ කිරීමේ මෙහෙයුමක් නොවේ( ld) විධානය ක්රියාත්මක කිරීමේ ප්රතිඵලය ld -rසම්බන්ධක ආදාන ගොනු වල වස්තු කේත ඒකාබද්ධ කරන තවත් වස්තු ගොනුවකි. විකල්පය -ආර්අදහස් වන්නේ " නැවත ස්ථානගත කළ හැකි - නැවත ස්ථානගත කිරීමේ හැකියාව”, i.e. අපි විධානයේ ප්‍රතිදාන ගොනුව ලිපින අවකාශයේ ගෙනයමු, මන්ද එය තවමත් ශ්‍රිත ඇමතුම්වල නිරපේක්ෂ ලිපින අඩංගු නොවේ.

පහත උදාහරණය මඟින් මූලාශ්‍ර ගොනු දෙකකින් සමන්විත මොඩියුලයක් සම්පාදනය කිරීමට අවශ්‍ය අවම Makefile පෙන්වයි. ඔබේ මොඩියුලය තනි මූලාශ්‍ර ගොනුවකින් සමන්විත නම්, ලබා දී ඇති උදාහරණයෙන් ඔබට විධානය අඩංගු ඉලක්කය ඉවත් කළ යුතුය. ld -r.

# ඔබේ කර්නල් ප්‍රභව නාමාවලියට යන මාර්ගය මෙතැනින් වෙනස් කළ හැක, # නැතහොත් “make” ලෙස ඇමතීමේ දී ඔබට එය පරාමිතියක් ලෙස ලබා දිය හැක KERNELDIR = /usr/src/linux ඇතුළුව $(KERNELDIR)/.config CFLAGS = -D__KERNEL__ -DMODULE - I$(KERNELDIR) /ඇතුළත් \ -O -Wall ifdef CONFIG_SMP CFLAGS += -D__SMP__ -DSMP endif all: skull.o skull.o: skull_init.o skull_clean.o $(LD) -r $^ -o $@ පිරිසිදු කරන්න : rm -f * .o *~core

ඔබ සාදන ආකාරය ගැන අලුත් නම්, *.c ගොනු *.o වස්තු ගොනු තුළට සම්පාදනය කිරීම සඳහා නීති රීති නොමැති වීම ගැන ඔබ පුදුම විය හැක. එවැනි නීති නිර්වචනය කිරීම අවශ්ය නොවේ, මන්ද අවශ්‍ය නම්, සෑදීමේ උපයෝගීතාව විසින්ම *.c ගොනු පෙරනිමි සම්පාදකය හෝ විචල්‍යයකින් දක්වා ඇති සම්පාදකය භාවිතයෙන් *.o ගොනු බවට පරිවර්තනය කරයි. $(CC). මෙම අවස්ථාවේදී, විචල්යයේ අන්තර්ගතය $(CFLAGS)සම්පාදන කොඩි නියම කිරීමට භාවිතා කරයි.

මොඩියුලයක් තැනීමෙන් පසු ඊළඟ පියවර වන්නේ එය කර්නලයට පැටවීමයි. මේ සඳහා අපි මොඩියුලයේ සියලුම නිර්වචනය නොකළ සංකේත (ක්‍රියාකාරී ඇමතුම්, ආදිය) ධාවනය වන කර්නලයේ සංකේත වගුව සමඟ සම්බන්ධ කරන insmod උපයෝගීතාව භාවිතා කරන බව අපි දැනටමත් පවසා ඇත. කෙසේ වෙතත්, සම්බන්ධකයක් මෙන් නොව (උදාහරණයක් ලෙස, ld වැනි), එය මොඩියුල තැටි ගොනුව වෙනස් නොකරයි, නමුත් කර්නලයට සම්බන්ධ කර ඇති මොඩියුල වස්තුව RAM වෙත පූරණය කරයි. insmod උපයෝගීතාවයට සමහර විධාන රේඛා විකල්ප පිළිගත හැක. හරහා විස්තර නැරඹිය හැක මිනිසා insmod. මෙම විකල්පයන් භාවිතා කිරීමෙන් ඔබට, උදාහරණයක් ලෙස, මොඩියුලය කර්නලයට සම්බන්ධ කිරීමට පෙර නිශ්චිත අගයන් සඳහා ඔබේ මොඩියුලයේ නිශ්චිත පූර්ණ සංඛ්‍යා සහ නූල් විචල්‍යයන් පැවරිය හැකිය. මේ අනුව, මොඩියුලය නිවැරදිව නිර්මාණය කර ඇත්නම්, එය ආරම්භක වේලාවේදී වින්යාසගත කළ හැක. මොඩියුලයක් වින්‍යාස කිරීමේ මෙම ක්‍රමය මඟින් සම්පාදනය කරන අවස්ථාවේ වින්‍යාස කිරීමට වඩා පරිශීලකයාට වැඩි නම්‍යශීලී බවක් ලබා දේ. මෙම පරිච්ඡේදයේ පසුව "අතින් සහ ස්වයංක්‍රීය වින්‍යාසය" කොටසේ ඇරඹුම් කාල වින්‍යාසය විස්තර කෙරේ.

සමහර පාඨකයින් insmod උපයෝගීතාව ක්රියා කරන ආකාරය පිළිබඳ විස්තර ගැන උනන්දු වනු ඇත. insmod ක්‍රියාත්මක කිරීම kernel/module.c හි අර්ථ දක්වා ඇති පද්ධති ඇමතුම් කිහිපයක් මත පදනම් වේ. sys_create_module() ශ්‍රිතය මඟින් මොඩියුලය පූරණය කිරීමට අවශ්‍ය මතක ප්‍රමාණය කර්නල් ලිපින අවකාශයේ වෙන් කරයි. මෙම මතකය vmalloc() ශ්‍රිතය භාවිතයෙන් වෙන් කර ඇත (7 වන පරිච්ඡේදයේ "Vmalloc සහ මිතුරන්" කොටස බලන්න, "මතකය අල්ලා ගැනීම"). get_kernel_sysms() පද්ධති ඇමතුම මඟින් කර්නල් සංකේත වගුව ආපසු ලබා දෙයි, එය සම්බන්ධ කිරීමේදී වස්තු වල සැබෑ ලිපින තීරණය කිරීමට භාවිතා කරනු ඇත. sys_init_module() ශ්‍රිතය මඟින් මොඩියුල වස්තු කේතය කර්නල් ලිපින අවකාශයට පිටපත් කර මොඩියුලයේ ආරම්භක ශ්‍රිතය කැඳවයි.

ඔබ කර්නල් කේත මූලාශ්‍ර දෙස බැලුවහොත්, sys_ උපසර්ගය සමඟින් ආරම්භ වන පද්ධති ඇමතුම් නම් ඔබට හමුවනු ඇත. මෙම උපසර්ගය පද්ධති ඇමතුම් සඳහා පමණක් භාවිතා වේ. වෙනත් කාර්යයන් එය භාවිතා නොකළ යුතුය. grep සෙවුම් උපයෝගීතාව සමඟ කර්නල් කේත මූලාශ්‍ර සැකසීමේදී මෙය මතක තබා ගන්න.

අනුවාද පරායත්තතා

ඔබ මෙහි ආවරණය කර ඇති දේට වඩා වැඩි යමක් නොදන්නේ නම්, බොහෝ විට ඔබ නිර්මාණය කරන මොඩියුල ඒවා සම්බන්ධ කර ඇති කර්නලයේ එක් එක් අනුවාදය සඳහා නැවත සම්පාදනය කිරීමට සිදුවනු ඇත. සෑම මොඩියුලයක්ම හැඳින්වෙන සංකේතයක් අර්ථ දැක්විය යුතුය __module_kernel_version, කාගේ වටිනාකම
insmod උපයෝගීතාව භාවිතයෙන් වත්මන් කර්නලයේ අනුවාදය සමඟ සංසන්දනය කරයි. මෙම සංකේතය කොටසේ පිහිටා ඇත .modinfo ELF (ක්‍රියාත්මක කළ හැකි සහ සබැඳි ආකෘතිය) ගොනු. මෙය වඩාත් විස්තරාත්මකව 11 වන පරිච්ඡේදයේ "kmod සහ උසස් මොඩියුලරීකරණය" විස්තර කර ඇත. මෙම අනුවාද පාලන ක්‍රමය අදාළ වන්නේ කර්නල් අනුවාද 2.2 සහ 2.4 සඳහා පමණක් බව කරුණාවෙන් සලකන්න. 2.0 කර්නලය තුළ මෙය තරමක් වෙනස් ආකාරයකින් සිදු කෙරේ.

ශීර්ෂ ගොනුව අඩංගු ඕනෑම තැනක සම්පාදකය මෙම සංකේතය නිර්වචනය කරයි . ඒ නිසා කලින් දුන්න hello.c උදාහරණයේ අපි මේ සංකේතය විස්තර කළේ නැහැ. මෙයින් අදහස් කරන්නේ ඔබේ මොඩියුලය බොහෝ මූලාශ්‍ර ගොනු වලින් සමන්විත නම්, ඔබ ගොනුව ඇතුළත් කළ යුතු බවයි ඔබගේ කේතයට එක් වරක් පමණි. අර්ථ දැක්වීම භාවිතා කරන විට ව්යතිරේකයකි __NO_VERSION__, අපි පසුව හමුවෙමු.

2.4.25 කර්නල් කේතයෙන් උපුටා ගත් module.h ගොනුවෙන් විස්තර කරන ලද සංකේතයේ නිර්වචනය පහත දැක්වේ.

ස්ථිතික const char __module_kernel_versio/PRE__attribute__((section(".modinfo"))) = "kernel_version=" UTS_RELEASE;

අනුවාද නොගැලපීම හේතුවෙන් මොඩියුලයක් පූරණය කිරීමට අපොහොසත් වුවහොත්, ඔබට insmod යතුර උපයෝගීතාවයේ පරාමිති රේඛාව වෙත යැවීමෙන් මෙම මොඩියුලය පූරණය කිරීමට උත්සාහ කළ හැක. -එෆ්(බලය). මොඩියුලයක් පැටවීමේ මෙම ක්රමය ආරක්ෂිත නොවන අතර සෑම විටම සාර්ථක නොවේ. සිදුවිය හැකි අසාර්ථකත්වයට හේතු පැහැදිලි කිරීම තරමක් අපහසුය. සම්බන්ධ කිරීමේදී සංකේත විසඳිය නොහැකි නිසා මොඩියුලය පූරණය නොවනු ඇත. මෙම අවස්ථාවේදී, ඔබට සුදුසු දෝෂ පණිවිඩයක් ලැබෙනු ඇත. අසාර්ථක වීමට හේතු කර්නලයේ ක්‍රියාකාරිත්වයේ හෝ ව්‍යුහයේ වෙනස්වීම් ද විය හැකිය. මෙම අවස්ථාවෙහිදී, මොඩියුලය පැටවීම බරපතල ධාවන දෝෂ වලට මෙන්ම පද්ධතියේ භීතියට හේතු විය හැක. දෙවැන්න අනුවාද පාලන පද්ධතියක් භාවිතා කිරීමට හොඳ දිරිගැන්වීමක් ලෙස සේවය කළ යුතුය. කර්නලයේ අනුවාද පාලනය භාවිතා කිරීමෙන් අනුවාද නොගැලපීම් වඩාත් අලංකාර ලෙස හැසිරවිය හැක. 11 වන පරිච්ඡේදයේ "kmod සහ Advanced Modularization" හි "Modules හි අනුවාද පාලනය" කොටසේ අපි මේ ගැන විස්තරාත්මකව කතා කරමු.

ඔබට නිශ්චිත කර්නල් අනුවාදයක් සඳහා ඔබේ මොඩියුලය සම්පාදනය කිරීමට අවශ්‍ය නම්, ඔබ එම විශේෂිත කර්නල් අනුවාදය සඳහා ශීර්ෂ ගොනු ඇතුළත් කළ යුතුය. ඉහත විස්තර කර ඇති Makefile උදාහරණයේ, මෙම ගොනු සඳහා නාමාවලිය තීරණය කිරීමට විචල්‍යය භාවිතා කරන ලදී KERNELDIR. කර්නල් මූලාශ්‍ර ඇති විට එවැනි අභිරුචි සම්පාදනය සාමාන්‍ය දෙයක් නොවේ. එසේම, බහලුම ගසෙහි කර්නලයේ විවිධ අනුවාද තිබීම සාමාන්‍ය දෙයක් නොවේ. මෙම පොතේ ඇති සියලුම මොඩියුල උදාහරණ විචල්‍යය භාවිතා කරයි KERNELDIRඑකලස් කරන ලද මොඩියුලය සම්බන්ධ කළ යුතු කර්නලයේ අනුවාදය සඳහා මූලාශ්‍ර නාමාවලියෙහි පිහිටීම දැක්වීමට. මෙම ඩිරෙක්ටරිය නියම කිරීමට ඔබට පද්ධති විචල්‍යයක් භාවිතා කළ හැක, නැතහොත් එය සෑදීමට විධාන රේඛා විකල්ප හරහා ඔබට එහි ස්ථානය ලබා දිය හැක.

මොඩියුලයක් පූරණය කරන විට, insmod උපයෝගීතාව මොඩියුලයේ වස්තු ගොනු සඳහා තමන්ගේම සෙවුම් මාර්ග භාවිතා කරයි, අනුවාද මත යැපෙන නාමාවලි හරහා ආරම්භ වේ. /lib/මොඩියුල. සහ පැරණි උපයෝගිතා අනුවාද සෙවුම් මාර්ගයේ වත්මන් නාමාවලිය ඇතුළත් කර ඇතත්, ආරක්ෂක හේතූන් මත මෙම හැසිරීම දැන් පිළිගත නොහැකි යැයි සැලකේ (පද්ධති විචල්‍යය භාවිතා කිරීම හා සමාන ගැටළු මාර්ගය) එබැවින් ඔබට වත්මන් නාමාවලියෙන් මොඩියුලයක් පැටවීමට අවශ්ය නම්, ඔබට එය ශෛලිය තුල සඳහන් කළ හැකිය ./module.o. මොඩියුලයේ පිහිටීම පිළිබඳ මෙම ඇඟවීම insmod උපයෝගීතාවයේ ඕනෑම අනුවාදයක් සඳහා ක්‍රියා කරයි.

සමහර විට ඔබට 2.0.x සහ 2.4.x අතර වෙනස් වන කර්නල් අතුරුමුහුණත් හමුවිය හැක. මෙම අවස්ථාවේදී, ඔබ වත්මන් කර්නල් අනුවාදය තීරණය කරන මැක්රෝ වෙත යොමු වීමට අවශ්ය වනු ඇත. මෙම සාර්ව ශීර්ෂ ගොනුවේ පිහිටා ඇත . ඒවා භාවිතා කරන විට අතුරුමුහුණත්වල වෙනස්කම් ඇති අවස්ථා අපි දක්වන්නෙමු. මෙය විස්තරය දිගේ වහාම හෝ කොටසේ අවසානයේ අනුවාද පරායත්තතා සඳහා කැප වූ විශේෂ කොටසක සිදු කළ හැකිය. සමහර අවස්ථාවලදී, විස්තර වෙනම කොටසක තැබීමෙන් මෙම පොතට අදාළ වන කර්නල් අනුවාදය 2.4.x හි විස්තරය සංකීර්ණ වීම වළක්වා ගත හැක.

ශීර්ෂ ගොනුවේ linux/version.hකර්නල් අනුවාදය නිර්ණය කිරීම සම්බන්ධ පහත මැක්‍රෝස් අර්ථ දක්වා ඇත.

ගොනුවේ අන්තර්ගතය මෙන්න: linux/version.hකර්නලය 2.4.25 සඳහා (ශීර්ෂ ගොනුවේ පෙළ සම්පූර්ණයෙන්ම ලබා දී ඇත).

# define UTS_RELEASE "2.4.25" # define LINUX_VERSION_CODE 132121 # define KERNEL_VERSION(a,b,c) (((a)<< 16) + ((b) << 8) + (c))

version.h ශීර්ෂ ගොනුව module.h ගොනුවේ ඇතුළත් කර ඇත, එබැවින් ඔබට සාමාන්‍යයෙන් ඔබේ මොඩියුල කේතයට පැහැදිලිවම version.h ඇතුළත් කිරීමට අවශ්‍ය නොවේ. අනෙක් අතට, මැක්‍රෝ එකක් ප්‍රකාශ කිරීමෙන් ඔබට version.h ශීර්ෂ ගොනුව module.h හි ඇතුළත් කිරීම වැළැක්විය හැකිය. __NO_VERSION__. ඔබ භාවිතා කරනු ඇත __NO_VERSION__, උදාහරණයක් ලෙස ඔබට සක්‍රීය කිරීමට අවශ්‍ය අවස්ථාවක මූලාශ්‍ර ගොනු කිහිපයකට, පසුව එය එක් මොඩියුලයකට සම්බන්ධ කෙරේ. නිවේදනය __NO_VERSION__ module.h ශීර්ෂ ගොනුව ඇතුළු කිරීමට පෙර
ස්වයංක්‍රීය තන්තු විස්තරය __module_kernel_versionහෝ මූලාශ්‍ර ගොනු වල එය සමාන වේ. සම්බන්ධකයාගේ පැමිණිලි තෘප්තිමත් කිරීමට ඔබට මෙය අවශ්‍ය විය හැක ld -r, සබැඳි වගු වල සංකේතවල බහුවිධ විස්තර වලට කැමති නැති අය. සාමාන්‍යයෙන්, මොඩියුල කේතය ශීර්ෂ ගොනුවක් ඇතුළුව බහු මූලාශ්‍ර ගොනු වලට බෙදී ඇත්නම් , පසුව නිවේදනය __NO_VERSION__එකක් හැර මෙම සියලුම ගොනු වල සිදු කෙරේ. පොතේ අවසානයේ භාවිතා කරන මොඩියුලයක උදාහරණයක් තිබේ __NO_VERSION__.

බොහෝ කර්නල් අනුවාද පරායත්තතා සාර්ව නිර්වචන භාවිතයෙන් පූර්ව සැකසුම් විධාන මත ගොඩනගා ඇති තර්කනය භාවිතයෙන් හැසිරවිය හැක. KERNEL_VERSIONසහ LINUX_VERSION_CODE. කෙසේ වෙතත්, අනුවාද පරායත්තතා පරීක්ෂා කිරීම විෂමජාතීය නියෝග හේතුවෙන් මොඩියුල කේතයේ කියවීමේ හැකියාව බෙහෙවින් සංකීර්ණ කළ හැකිය. #ifdef. එමනිසා, සමහර විට හොඳම විසඳුම වන්නේ පරායත්ත චෙක්පත වෙනම ශීර්ෂ ගොනුවක තැබීමයි. අපගේ උදාහරණයට ශීර්ෂ ගොනුවක් ඇතුළත් වන්නේ එබැවිනි sysdep.h, අනුවාද පරායත්තතා චෙක්පත් හා සම්බන්ධ සියලුම සාර්ව නිර්වචන තැන්පත් කිරීමට භාවිතා කරයි.

අපට නියෝජනය කිරීමට අවශ්‍ය පළමු අනුවාද පරායත්තතාවය ඉලක්ක ප්‍රකාශනයේ ඇත" ස්ථාපනය කරන්න" අපගේ ධාවක සම්පාදන ස්ක්‍රිප්ටය. ඔබ අපේක්ෂා කළ හැකි පරිදි, භාවිතා කරන කර්නල් අනුවාදය අනුව වෙනස් වන ස්ථාපන නාමාවලිය, version.h ගොනුව බැලීම මත තෝරා ගනු ලැබේ. මෙන්න ගොනුවේ කේත කොටසකි. නීති හදන්න, සියලුම කර්නල් Makefiles විසින් භාවිතා කරනු ලැබේ.

VERSIONFILE = $(INCLUDEDIR)/linux/version.h VREION = $(shell awk -F\" "/REL/ (මුද්‍රණය $$2)" $(VERSIONFILE)) ස්ථාපනය කරන්න = /lib/modules/$(VERSION)/misc

අපගේ සියලුම ධාවක ස්ථාපනය කිරීමට අපි විවිධ නාමාවලිය භාවිතා කරන බව සලකන්න (ඉහත Makefile උදාහරණයේ INSTALLDIR ප්‍රකාශය). කර්නල් අනුවාදය 2.4 සිට, මෙම නාමාවලිය අභිරුචි ධාවක තැබීම සඳහා නිර්දේශිත නාමාවලිය වේ. මීට අමතරව, මොඩුටිල්ස් පැකේජයේ පැරණි සහ නව අනුවාද දෙකෙහිම ඔවුන්ගේ සෙවුම් මාර්ගවල විවිධ නාමාවලියක් අඩංගු වේ.

ඉහත INSTALLDIR නිර්වචනය භාවිතා කරමින්, Makefile හි ස්ථාපන ඉලක්කය මෙසේ විය හැක:

ස්ථාපනය කරන්න: ස්ථාපනය -d $(INSTALLDIR) ස්ථාපනය -c $(OBJS) $(INSTALLDIR)

වේදිකාවේ යැපීම

සෑම පරිගණක වේදිකාවකටම තමන්ගේම ලක්ෂණ ඇති අතර ඒවා ඉහළම කාර්ය සාධනය ලබා ගැනීම සඳහා කර්නල් සංවර්ධකයින් විසින් සැලකිල්ලට ගත යුතුය.

යෙදුම් සංවර්ධකයින්ට වඩා කර්නල් සංවර්ධකයින්ට තේරීමේ සහ තීරණ ගැනීමේ නිදහස ඇත. එක් එක් විශේෂිත වේදිකාවෙන් උපරිම ප්‍රයෝජන ලබා ගනිමින් ඔබේ කේතය ප්‍රශස්ත කිරීමට ඔබට ඉඩ සලසන මෙම නිදහසයි.

මොඩියුල කේතය සම්පාදනය කළ යුත්තේ කර්නලය සම්පාදනය කිරීමට භාවිතා කරන ලද සම්පාදක විකල්ප භාවිතා කරමිනි. මෙය එකම ප්‍රොසෙසර රෙජිස්ටර් භාවිත රටා භාවිතා කිරීම සහ එකම මට්ටමේ ප්‍රශස්තිකරණය කිරීම යන දෙකටම අදාළ වේ. ගොනුව නීති හදන්න, කර්නල් ප්‍රභව ගසෙහි මූලයේ පිහිටා ඇති, සියලුම Makefiles සම්පාදනයට ඇතුළත් කළ යුතු වේදිකාවට විශේෂිත නිර්වචන ඇතුළත් වේ. සියලුම වේදිකා-විශේෂිත සම්පාදන විධානාවලිය Makefiles ලෙස හැඳින්වේ. වේදිකාවසහ වත්මන් කර්නල් වින්‍යාසයට අනුව සාදන උපයෝගීතාව සඳහා විචල්‍යවල අගයන් අඩංගු වේ.

Makefile හි තවත් රසවත් අංගයක් වන්නේ හරස් වේදිකාව හෝ සරලව හරස් සම්පාදනය සඳහා සහය වීමයි. ඔබට වෙනත් වේදිකාවක් සඳහා කේතය සම්පාදනය කිරීමට අවශ්‍ය වූ විට මෙම පදය භාවිතා වේ. උදාහරණයක් ලෙස, i86 වේදිකාව භාවිතයෙන් ඔබ M68000 වේදිකාව සඳහා කේතයක් නිර්මාණය කිරීමට යන්නේ ය. ඔබ හරස් සම්පාදනය කිරීමට යන්නේ නම්, ඔබට ඔබේ සම්පාදන මෙවලම් ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය වනු ඇත ( gcc, ld, ආදිය) වෙනත් අනුරූප මෙවලම් කට්ටලයක් සමඟ
(උදාහරණ වශයෙන්, m68k-linux-gcc, m68k-linux-ld) භාවිතා කරන උපසර්ගය $(CROSS_COMPILE) Makefile විචල්‍යය මගින්, make utility වෙත විධාන රේඛා විකල්පයකින් හෝ පද්ධති පරිසර විචල්‍යයක් මගින් නියම කළ හැක.

SPARC ගෘහ නිර්මාණ ශිල්පය යනු Makefile හි ඒ අනුව හැසිරවිය යුතු විශේෂ අවස්ථාවකි. SPARC64 (SPARC V9) වේදිකාව මත ධාවනය වන පරිශීලක වැඩසටහන් ද්විමය වේ, සාමාන්‍යයෙන් SPARC32 (SPARC V8) වේදිකාව සඳහා නිර්මාණය කර ඇත. එබැවින්, SPARC64 වේදිකාවේ (gcc) පෙරනිමි සම්පාදකය SPARC32 සඳහා වස්තු කේතය ජනනය කරයි. අනෙක් අතට, SPARC V9 මත ධාවනය කිරීමට නිර්මාණය කර ඇති කර්නලයක SPARC V9 සඳහා වස්තු කේතය අඩංගු විය යුතුය, එබැවින් එසේ වුවද හරස් සම්පාදකයක් අවශ්‍ය වේ. SPARC64 සඳහා නිර්මාණය කර ඇති සියලුම GNU/Linux බෙදාහැරීම් සඳහා සුදුසු හරස් සම්පාදකයක් ඇතුළත් වේ, එය කර්නල් සම්පාදනය සඳහා වන Makefile හි තෝරාගත යුතුය.

තවද සම්පූර්ණ අනුවාදය සහ වේදිකා පරායත්තතා ලැයිස්තුව මෙහි විස්තර කර ඇති ප්‍රමාණයට වඩා ටිකක් සංකීර්ණ වුවද, හරස් සම්පාදනය කිරීමට එය ප්‍රමාණවත් වේ. වැඩි විස්තර සඳහා, ඔබට Makefile compilation scripts සහ kernel source files දෙස බැලිය හැක.

කර්නලයේ විශේෂාංග 2.6

කාලය නිශ්චල නොවේ. දැන් අපි නව පරම්පරාවේ කර්නල් 2.6 බිහිවීම දකිනවා. අවාසනාවකට මෙන්, මෙම පොතේ මුල් පිටපත නව හරය ආවරණය නොකරයි, එබැවින් පරිවර්තකයා නව දැනුම සමඟ පරිවර්තනයට අතිරේකයක් ලබා දෙනු ඇත.

ඔබට TimeSys' TimeStorm වැනි ඒකාබද්ධ සංවර්ධන පරිසරයන් භාවිතා කළ හැක, එමඟින් අවශ්‍ය කර්නල් අනුවාදය අනුව ඔබේ මොඩියුලය සඳහා ඇටසැකිල්ල සහ සම්පාදන ස්ක්‍රිප්ට් නිවැරදිව ජනනය කරනු ඇත. ඔබ මේ සියල්ල ඔබම ලිවීමට යන්නේ නම්, නව කර්නලය විසින් හඳුන්වා දුන් ප්‍රධාන වෙනස්කම් පිළිබඳ අමතර තොරතුරු ඔබට අවශ්‍ය වනු ඇත.

2.6 කර්නලයේ එක් අංගයක් නම්, ආරම්භක සහ අවසන් කිරීමේ ශ්‍රිතවල නම් පැහැදිලිව ලියාපදිංචි කිරීමට module_init() සහ module_exit() macros භාවිතා කිරීමේ අවශ්‍යතාවයයි.

2.4 කර්නලය තුළ හඳුන්වා දී ඇති MODULE_LISENCE() මැක්‍රෝ, මොඩියුලයක් පූරණය කිරීමේදී ඔබට අනුරූප අනතුරු ඇඟවීම් දැකීමට අවශ්‍ය නැතිනම් තවමත් අවශ්‍ය වේ. ඔබට මැක්‍රෝ වෙත මාරු කිරීමට පහත බලපත්‍ර තන්තු තේරිය හැක: "GPL", "GPL v2", "GPL සහ අමතර අයිතිවාසිකම්", "Dual BSD/GPL" (BSD හෝ GPL බලපත්‍ර අතර තේරීම), "ද්විත්ව MPL/GPL "(Mozilla හෝ GPL බලපත්‍ර අතර තේරීම) සහ
"හිමිකාර".

නව කර්නලය සඳහා වඩාත් වැදගත් වන්නේ නව මොඩියුල සම්පාදන ක්‍රමයක් වන අතර, එය මොඩියුලයේ කේතයේ පමණක් නොව එහි සම්පාදනය සඳහා Makefile ස්ක්‍රිප්ට් හි ද වෙනස්කම් ඇති කරයි.

මේ අනුව, මොඩියුල කේතයේ හෝ Makefile හි මොඩියුල මැක්‍රෝ සංකේතයේ නිර්වචනය තවදුරටත් අවශ්‍ය නොවේ. අවශ්ය නම්, නව සම්පාදන යෝජනා ක්රමය විසින්ම මෙම macrosymbol තීරණය කරනු ඇත. එසේම, ඔබට __KERNEL__ සාර්ව සංකේත හෝ KBUILD_BASENAME සහ KBUILD_MODNAME වැනි නව ඒවා පැහැදිලිව නිර්වචනය කිරීමට අවශ්‍ය නොවනු ඇත.

එසේම, ඔබ සම්පාදනය කිරීමේදී (-O2 හෝ වෙනත්) ප්‍රශස්තිකරණ මට්ටම සඳහන් නොකළ යුතුය, මන්ද ඔබගේ මොඩියුලය ඔබගේ කර්නලයේ අනෙකුත් සියලුම මොඩියුල සම්පාදනය කර ඇති ප්‍රශස්තිකරණ කොඩි ඇතුළුව සම්පූර්ණ කොඩි කට්ටලය සමඟ සම්පාදනය කෙරේ - සෑදීමේ උපයෝගීතාව ස්වයංක්‍රීයව අවශ්‍ය සියලුම කොඩි කට්ටලයම භාවිතා කරයි.

මෙම හේතූන් නිසා, 2.6 කර්නලය සඳහා මොඩියුලයක් සම්පාදනය කිරීම සඳහා Makefile වඩා සරල ය. එබැවින් hello.c මොඩියුලය සඳහා Makefile මේ ආකාරයෙන් පෙනෙනු ඇත:

Obj-m:= hello.o

කෙසේ වෙතත්, මොඩියුලය සම්පාදනය කිරීම සඳහා, ඔබට තාවකාලික ගොනු සහ නාමාවලි සාදනු ලබන කර්නල් ප්‍රභව ගස වෙත ලිවීමට ප්‍රවේශය අවශ්‍ය වේ. එබැවින්, 2.6 කර්නලය සඳහා මොඩියුලයක් සම්පාදනය කිරීම සඳහා වන විධානය, මොඩියුල ප්‍රභව කේතය අඩංගු වත්මන් නාමාවලියෙන් දක්වා ඇති පරිදි, මේ ආකාරයෙන් දිස්විය යුතුය:

# make -C /usr/src/linux-2.6.1 SUBDIRS=`pwd` මොඩියුල

ඉතින්, අපි මොඩියුලයේ මූලාශ්රය ඇත hello-2.6.c, කර්නලය 2.6 හි සම්පාදනය සඳහා:

//hello-2.6.c #ඇතුළත් #ඇතුළත් #ඇතුළත් MODULE_LICENSE("GPL"); static int __init my_init(void) ( printk("Hello world\n"); return 0; ); static void __exit my_cleanup(void) ( printk("Good bye\n"); ); module_init (my_init); module_exit (my_cleanup);

ඒ අනුව, අපට Makefile එකක් තිබේ:

Obj-m:= hello-2.6.o

පහත පරාමිතීන් සමඟ අපගේ Makefile සැකසීමට අපි Make utility ලෙස හඳුන්වමු:

# make -C/usr/src/linux-2.6.3 SUBDIRS=`pwd` මොඩියුල

සාමාන්‍ය සම්පාදන ක්‍රියාවලිය පහත සම්මත ප්‍රතිදානය නිපදවයි:

සාදන්න: නාමාවලිය ඇතුළත් කරන්න `/usr/src/linux-2.6.3" *** අවවාදයයි: විධාන රේඛාවේ SUBDIRS අභිබවා යාම *** නොගැලපීම් ඇති කළ හැක: `arch/i386/kernel/asm-offsets.s" නොවේ යාවත්කාලීන කිරීම අවශ්ය වේ. CHK ඇතුලත්/asm-i386/asm_offsets.h CC [M] /home/knz/j.kernel/3/hello-2.6.o ගොඩනැගිලි මොඩියුල, අදියර 2. /usr/src/linux-2.6.3/scripts/Makefile .modpost:17: *** අහ්-ඔහ්, ඔබට පරණ මොඩියුල ඇතුළත් කිරීම් තිබේ. ඔබ SUBDIRS සමඟ පටලවා ඇත, /usr/src/linux-2.6.3/scripts/Makefile.modpost:18: යමක් වැරදී ගියහොත් පැමිණිලි නොකරන්න. MODPOST CC /home/knz/j.kernel/3/hello-2.6.mod.o LD [M] /home/knz/j.kernel/3/hello-2.6.ko සෑදීම: නාමාවලියෙන් පිටවන්න `/usr/src / linux-2.6.3"

සම්පාදනයේ අවසාන ප්‍රති result ලය වනුයේ කර්නලය තුළ ස්ථාපනය කළ හැකි මොඩියුල ගොනුවක් hello-2.6.ko වේ.

2.6 කර්නලයේ, මොඩියුල ගොනු 2.4 කර්නලයේ මෙන් .o වෙනුවට .ko සමඟ උපසර්ග කර ඇති බව සලකන්න.

කර්නල් සංකේත වගුව

මොඩියුලයක් කර්නලයට සම්බන්ධ කිරීමේදී insmod උපයෝගීතාව කර්නල් පොදු සංකේත වගුව භාවිතා කරන ආකාරය ගැන අපි දැනටමත් කතා කර ඇත්තෙමු. මොඩියුලර් ධාවක විකල්ප ක්‍රියාත්මක කිරීමට අවශ්‍ය ගෝලීය කර්නල් වස්තු - ශ්‍රිත සහ විචල්‍ය - ලිපිනයන් මෙම වගුවේ අඩංගු වේ. ඔබගේ කර්නලය /proc ගොනු පද්ධතියට සහය දක්වන්නේ නම්, කර්නලයේ පොදු සංකේත වගුව /proc/ksyms ගොනුවෙන් පෙළ ආකාරයෙන් කියවිය හැක.

කර්නලය 2.6 හි, /proc/ksyms /proc/modules ලෙස නැවත නම් කරන ලදී.

මොඩියුලයක් පූරණය වූ විට, මොඩියුලය මඟින් අපනයනය කරන ලද සංකේත කර්නල් සංකේත වගුවේ කොටසක් බවට පත් වන අතර, ඔබට ඒවා /proc/ksyms හි බැලිය හැක.

නව මොඩියුලවලට ඔබේ මොඩියුලය මඟින් අපනයනය කළ සංකේත භාවිත කළ හැක. උදාහරණයක් ලෙස, msdos මොඩියුලය මේදය මොඩියුලය මගින් අපනයනය කරන ලද අක්ෂර මත රඳා පවතී, සහ කියවීමේ මාදිලියේ භාවිතා කරන සෑම USB උපාංගයක්ම usbcore සහ ආදාන මොඩියුල වලින් අක්ෂර භාවිතා කරයි. මොඩියුල අනුක්‍රමික පැටවීම මගින් අවබෝධ කරගත් මෙම සම්බන්ධතාවය මොඩියුල තොගයක් ලෙස හැඳින්වේ.

සංකීර්ණ මොඩියුල ව්‍යාපෘති නිර්මාණය කිරීමේදී මොඩියුල තොගය භාවිතා කිරීමට පහසුය. උපාංග ධාවක කේතය දෘඪාංග මත යැපෙන සහ දෘඪාංග ස්වාධීන කොටස් වලට වෙන් කිරීම සඳහා මෙම සාරාංශය ප්රයෝජනවත් වේ. උදාහරණයක් ලෙස, video-for-linux ධාවක කට්ටලය සමන්විත වන්නේ භාවිතා කරන දෘඪාංගවල විශේෂතා සැලකිල්ලට ගන්නා පහත් මට්ටමේ ධාවකයක් සඳහා සංකේත අපනයනය කරන මූලික මොඩියුලයකි. ඔබේ වින්‍යාසය අනුව, ඔබ ප්‍රධාන වීඩියෝ මොඩියුලය සහ ඔබේ දෘඪාංගයට විශේෂිත වූ මොඩියුලයක් පූරණය කරයි. එලෙසම, සමාන්තර වරායන් සඳහා සහය සහ USB උපාංග වැනි සම්බන්ධිත උපාංගවල පුළුල් පන්තියක් ක්‍රියාත්මක වේ. සමාන්තර වරාය පද්ධති තොගය රූපයේ දැක්වේ. 2-2. ඊතල මඟින් මොඩියුල සහ කර්නල් ක්‍රමලේඛන අතුරුමුහුණත අතර අන්තර්ක්‍රියා පෙන්වයි. අන්තර්ක්‍රියා ශ්‍රිත මට්ටමින් සහ ශ්‍රිත මගින් කළමනාකරණය වන දත්ත ව්‍යුහ මට්ටමින් සිදු කළ හැක.

රූපය 2-2. සමාන්තර වරාය මොඩියුල තොගය

Stack මොඩියුල භාවිතා කරන විට, modprobe උපයෝගීතාව භාවිතා කිරීම පහසුය. modprobe උපයෝගීතාවයේ ක්‍රියාකාරිත්වය බොහෝ ආකාරවලින් insmod උපයෝගීතාවයට සමාන වේ, නමුත් මොඩියුලයක් පැටවීමේදී එය එහි යටින් පවතින පරායත්තතා පරීක්ෂා කරයි, අවශ්‍ය නම්, අවශ්‍ය මොඩියුල තොගය පුරවන තෙක් අවශ්‍ය මොඩියුල පටවනු ලැබේ. මේ අනුව, එක් modprobe විධානයක් insmod විධානයට බහු ඇමතුම් ලබා ගත හැක. modprobe විධානය insmod වටා ඇති බුද්ධිමත් ආවරණයක් බව ඔබට පැවසිය හැකිය. ඔබට දැනට පවතින ඩිරෙක්ටරියෙන් ඔබේම මොඩියුල පූරණය කිරීමේදී හැර, සෑම තැනකම insmod වෙනුවට modprobe භාවිතා කළ හැක. modprobe විශේෂිත මොඩියුල නාමාවලි දෙස පමණක් බලන අතර, හැකි පරායත්තතා සපුරාලීමට නොහැකි වනු ඇත.

මොඩියුල කොටස් වලට බෙදීම ගැටළු නිර්වචනය සරල කිරීම මගින් සංවර්ධන කාලය අඩු කිරීමට උපකාරී වේ. මෙය ක්‍රියාත්මක කිරීමේ යාන්ත්‍රණය සහ පාලන ප්‍රතිපත්තිය අතර වෙන්වීම හා සමාන වන අතර එය 1 වන පරිච්ඡේදයේ “උපාංග ධාවක හැඳින්වීම” හි සාකච්ඡා කෙරේ.

සාමාන්‍යයෙන් මොඩියුලයක් සංකේත අපනයනය කිරීමකින් තොරව එහි ක්‍රියාකාරීත්වය ක්‍රියාත්මක කරයි. වෙනත් මොඩියුලවලට එයින් ප්‍රයෝජන ගත හැකි නම් ඔබට සංකේත අපනයනය කිරීමට අවශ්‍ය වනු ඇත. ස්ථිතික නොවන අක්ෂර අපනයනය වැළැක්වීම සඳහා ඔබට විශේෂ විධානයක් ඇතුළත් කිරීමට අවශ්‍ය විය හැක, මන්ද මොඩියුල්වල බොහෝ ක්‍රියාත්මක කිරීම් පෙරනිමියෙන් ඒවා සියල්ලම අපනයනය කරයි.

Linux කර්නල් ශීර්ෂ ගොනු මඟින් ඔබේ සංකේතවල දෘශ්‍යතාව පාලනය කිරීමට පහසු ක්‍රමයක් ලබා දෙයි, එමඟින් කර්නල් සංකේත වගුවේ නාම අවකාශය දූෂණය වීම වළක්වයි. මෙම පරිච්ඡේදයේ විස්තර කර ඇති යාන්ත්‍රණය 2.1.18 අනුවාදයෙන් ආරම්භ වන කර්නලවල ක්‍රියා කරයි. කර්නල් 2.0 සතුව සම්පූර්ණයෙන්ම වෙනස් පාලන යාන්ත්‍රණයක් තිබුණි
සංකේත දෘශ්‍යතාව, එය පරිච්ඡේදයේ අවසානයේ විස්තර කෙරේ.

ඔබගේ මොඩියුලයට කිසිසේත්ම සංකේත අපනයනය කිරීමට අවශ්‍ය නොවන්නේ නම්, ඔබට මොඩියුලයේ මූලාශ්‍ර ගොනුවෙහි පහත මැක්‍රෝ ඇමතුම පැහැදිලිව තැබිය හැක:

EXPORT_NO_SYMBOLS;

මෙම සාර්ව ඇමතුම, linux/module.h ගොනුව තුළ අර්ථ දක්වා ඇත, එකලස් කිරීමේ විධානයක් දක්වා පුළුල් වන අතර මොඩියුලයේ ඕනෑම තැනක සඳහන් කළ හැක. කෙසේ වෙතත්, විවිධ කර්නල් වෙත ගෙන යා හැකි කේතයක් නිර්මාණය කිරීමේදී, මෙම මැක්‍රෝ ඇමතුම මොඩියුලයේ ආරම්භක ශ්‍රිතය (init_module) තුළ තැබීම අවශ්‍ය වේ, මන්ද යත් පැරණි කර්නල් අනුවාද සඳහා අපගේ sysdep.h ගොනුවේ අප විසින් අර්ථ දක්වා ඇති මෙම මැක්‍රෝ අනුවාදය පමණක් ක්‍රියා කරයි. මෙතන.

අනෙක් අතට, ඔබට ඔබේ මොඩියුලයෙන් සමහර සංකේත අපනයනය කිරීමට අවශ්‍ය නම්, ඔබ සාර්ව සංකේතයක් භාවිතා කළ යුතුය.
EXPORT_SYMTAB. මෙම සාර්ව සංකේතය අර්ථ දැක්විය යුතුය කලින් module.h ශීර්ෂ ගොනුව ඇතුළත් කිරීමෙන්. එය සාමාන්‍ය භාවිතයකි
ධජයක් හරහා මෙම සාර්ව චරිතය නිර්වචනය කිරීම -ඩී Makefile හි.

සාර්ව සංකේතය නම් EXPORT_SYMTABනිර්වචනය කර ඇත, පසුව තනි සංකේත මැක්‍රෝ යුගලයක් භාවිතයෙන් අපනයනය කළ හැක:

EXPORT_SYMBOL(නම); EXPORT_SYMBOL_NOVERS(නම);

මෙම මැක්‍රෝ දෙකෙන් එකක් හෝ දී ඇති සංකේතය මොඩියුලයෙන් පිටත ලබා ගත හැකි කරයි. වෙනස වන්නේ මැක්රෝ ය EXPORT_SYMBOL_NOVERSඅනුවාද තොරතුරු නොමැතිව සංකේතය අපනයනය කරයි (11 වන පරිච්ඡේදය "kmod සහ උසස් මොඩියුලරීකරණය" බලන්න). වැඩි විස්තර සඳහා
ශීර්ෂ ගොනුව පරීක්ෂා කරන්න ප්‍රායෝගික භාවිතය සඳහා ප්‍රකාශ කර ඇති දේ ප්‍රමාණවත් වුවද
මැක්රෝස්.

මොඩියුල ආරම්භ කිරීම සහ සම්පූර්ණ කිරීම

සඳහන් කළ පරිදි, init_module() ශ්‍රිතය මොඩියුලයක ක්‍රියාකාරී සංරචක කර්නලය සමඟ ලියාපදිංචි කරයි. එවැනි ලියාපදිංචියකින් පසුව, මොඩියුලය භාවිතා කරන යෙදුමට කර්නලය මගින් සපයන ලද අතුරු මුහුණත හරහා මොඩියුලයේ ඇතුල් වීමේ ස්ථාන වෙත ප්‍රවේශය ඇත.

මොඩියුලවලට විවිධ සංරචක ලියාපදිංචි කළ හැකිය, ඒවා ලියාපදිංචි කළ විට, මොඩියුලයේ ශ්‍රිතවල නම් වේ. යෝජිත ක්‍රියාකාරීත්වය ක්‍රියාවට නංවන ශ්‍රිත සඳහා දර්ශක අඩංගු දත්ත ව්‍යුහයකට දර්ශකයක් කර්නල් ලියාපදිංචි ශ්‍රිතයට යවනු ලැබේ.

1 වන පරිච්ඡේදයේ, "උපාංග ධාවක සඳහා හැඳින්වීම", ප්රධාන උපාංග වර්ග වර්ගීකරණය සඳහන් කර ඇත. ඔබට එහි සඳහන් කර ඇති උපාංග වර්ග පමණක් නොව, වෙනත් ඕනෑම, මෘදුකාංග වියුක්ත කිරීම්, උදාහරණයක් ලෙස, /proc ගොනු, ආදිය ලියාපදිංචි කළ හැක. ධාවක ක්‍රමලේඛන අතුරුමුහුණත හරහා කර්නලයේ ක්‍රියා කළ හැකි සෑම දෙයක්ම ධාවකයක් ලෙස ලියාපදිංචි කළ හැකිය. .

ඔබට උදාහරණයක් ලෙස ඔබගේ කර්නලය භාවිතයෙන් ලියාපදිංචි වන ධාවක වර්ග ගැන වැඩිදුර දැන ගැනීමට අවශ්‍ය නම්, ඔබට කර්නල් මූලාශ්‍රවල EXPORT_SYMBOL උපස්ථරය සඳහා සෙවුමක් ක්‍රියාත්මක කර විවිධ ධාවක විසින් ඉදිරිපත් කරන ලද ප්‍රවේශ ස්ථාන සොයා ගත හැක. රීතියක් ලෙස, ලියාපදිංචි කිරීමේ කාර්යයන් ඔවුන්ගේ නමේ උපසර්ගයක් භාවිතා කරයි ලියාපදිංචි_,
එබැවින් ඒවා සොයා ගැනීමට හැකි තවත් ක්රමයක් වන්නේ උපස්ථරයක් සෙවීමයි ලියාපදිංචි_/proc/ksyms ගොනුව තුළ grep උපයෝගීතාව භාවිතා කරයි. දැනටමත් සඳහන් කර ඇති පරිදි, 2.6.x කර්නලය තුළ /proc/ksyms ගොනුව /proc/modules මගින් ප්‍රතිස්ථාපනය විය.

init_module හි හැසිරවීමේ දෝෂයකි

මොඩියුලයක් ආරම්භ කිරීමේදී කිසියම් ආකාරයක දෝෂයක් සිදු වුවහොත්, ඔබ විසින් මොඩියුලය පූරණය වීම නැවැත්වීමට පෙර දැනටමත් සම්පූර්ණ කර ඇති ආරම්භය අහෝසි කළ යුතුය. දත්ත ව්‍යුහයන් වෙන් කිරීමේදී පද්ධතියේ ප්‍රමාණවත් මතකයක් නොමැති වීම හේතුවෙන් දෝෂය සිදුවිය හැක. අවාසනාවකට මෙන්, මෙය සිදු විය හැකි අතර, එවැනි තත්ත්වයන් සමඟ කටයුතු කිරීමට හොඳ කේතයක් සමත් විය යුතුය.

init_module() ආරම්භක ශ්‍රිතයේ දෝෂය ඇතිවීමට පෙර ලියාපදිංචි වූ හෝ වෙන් කරන ලද ඕනෑම දෙයක් අවලංගු කර හෝ නිදහස් කළ යුතුය, මන්ද Linux කර්නලය ආරම්භක දෝෂ හඹා නොයන අතර මොඩියුල කේතය මගින් ණය ලබා ගැනීම සහ ලබා දීම අවලංගු නොකරන බැවිනි. ඔබ ආපසු පෙරළන්නේ නැතිනම්, හෝ සම්පූර්ණ කළ ලියාපදිංචිය ආපසු පෙරළීමට නොහැකි වූයේ නම්, කර්නලය අස්ථායී තත්ත්වයක පවතිනු ඇත, සහ මොඩියුලය නැවත පටවන විට
ඔබට දැනටමත් ලියාපදිංචි වී ඇති මූලද්‍රව්‍ය ලියාපදිංචි කිරීම නැවත කිරීමට නොහැකි වනු ඇති අතර, කලින් සිදු කරන ලද ලියාපදිංචිය අවලංගු කිරීමට ඔබට නොහැකි වනු ඇත, මන්ද init_module() ශ්‍රිතයේ නව අවස්ථාවෙහි ලියාපදිංචි ශ්‍රිතවල ලිපින වල නිවැරදි අගය ඔබට නොලැබෙනු ඇත. පද්ධතිය එහි පෙර තත්වයට ප්‍රතිස්ථාපනය කිරීම සඳහා විවිධ සංකීර්ණ උපක්‍රම භාවිතා කිරීම අවශ්‍ය වන අතර මෙය බොහෝ විට සිදු කරනු ලබන්නේ පද්ධතිය නැවත ආරම්භ කිරීමෙනි.

මොඩියුලය ආරම්භ කිරීමේ දෝෂ ඇති වූ විට පද්ධතියේ පෙර තත්වය යථා තත්ත්වයට පත් කිරීම ක්රියාත්මක කිරීම goto ක්රියාකරු භාවිතයෙන් වඩාත් හොඳින් ක්රියාත්මක වේ. සාමාන්යයෙන් මෙම ක්රියාකරු අතිශයින්ම නිෂේධාත්මක ලෙස සලකනු ලබන අතර, වෛරයෙන් පවා සලකනු ලැබේ, නමුත් මෙම තත්වය තුළ ඔහු ඉතා ප්රයෝජනවත් වේ. එබැවින්, කර්නලය තුළ, මොඩියුල ආරම්භක දෝෂ හැසිරවීමට බොහෝ විට goto ප්රකාශය භාවිතා කරයි.

පහත දැක්වෙන සරල කේතය, ව්යාජ ලියාපදිංචි කිරීම සහ ලියාපදිංචි නොකිරීමේ කාර්යයන් උදාහරණයක් ලෙස භාවිතා කරමින්, මෙම දෝෂ හැසිරවීමේ ආකාරය පෙන්නුම් කරයි.

Int init_module(void) ( int err; /* ලියාපදිංචිය පොයින්ටරයක් ​​සහ නමක් ගනී */ err = register_this(ptr1, "skull"); if (err) goto fail_this; err = register_that(ptr2, "skull"); නම් (err) fail_that යන්න; err = register_those(ptr3, "හිස් කබල"); (වැරදි) ගියොත් fail_those; return 0; /* success */ fail_those: unregister_that(ptr2, "skull"); fail_that: unregister_this(ptr1, " හිස් කබල"); fail_this: return err; /* දෝෂය ප්‍රචාරණය කරන්න */ )

මෙම උදාහරණය මොඩියුල සංරචක තුනක් ලියාපදිංචි කිරීමට උත්සාහ කරයි. ලියාපදිංචි දෝෂයක් සිදු වූ විට සහ මොඩියුල පැටවීම නැවැත්වීමට පෙර ලියාපදිංචි සංරචක ලියාපදිංචි නොකිරීමට හේතු වන විට goto ප්‍රකාශය භාවිතා වේ.

කේතය කියවීමට පහසු කිරීම සඳහා goto ප්‍රකාශයක් භාවිතා කිරීමේ තවත් උදාහරණයක් නම්, සාර්ථක මොඩියුල ලියාපදිංචි කිරීම් "මතක තබා ගැනීමේ" උපක්‍රමය සහ දෝෂයක් ඇති වූ විට මෙම තොරතුරු යැවීමට cleanup_module() ඇමතීමයි. cleanup_module() ශ්‍රිතය නිර්මාණය කර ඇත්තේ සම්පුර්ණ කරන ලද ආරම්භක මෙහෙයුම් ආපසු හැරවීමට සහ මොඩියුලය බාන විට ස්වයංක්‍රීයව කැඳවනු ලැබේ. init_module() ශ්‍රිතය ලබා දෙන අගය විය යුතුය
මොඩියුලයේ ආරම්භක දෝෂ කේතය නියෝජනය කරන්න. ලිනක්ස් කර්නලයේ, දෝෂ කේතය ශීර්ෂ ගොනුවේ නිර්වචන සමූහයකින් සෘණ අංකයකි. . -ENODEV, -ENOMEM වැනි වෙන්කර ඇති දෝෂ කේත සඳහා සංකේතාත්මක සිහිවටන භාවිතා කිරීම සඳහා මෙම ශීර්ෂ ගොනුව ඔබේ මොඩියුලයට ඇතුළත් කරන්න. එවැනි සිහිවටන භාවිතා කිරීම හොඳ ක්‍රමලේඛන විලාසයක් ලෙස සැලකේ. කෙසේ වෙතත්, මොඩුටිල්ස් පැකේජයේ උපයෝගිතා වල සමහර අනුවාද ආපසු ලබා දුන් දෝෂ කේත නිවැරදිව ක්‍රියා නොකරන අතර “උපාංගය කාර්යබහුල” යන පණිවිඩය ප්‍රදර්ශනය නොකරන බව සැලකිල්ලට ගත යුතුය.
init_modules() ශ්‍රිතය මඟින් සම්පුර්ණයෙන්ම වෙනස් ස්වභාවයේ දෝෂ සමූහයකට ප්‍රතිචාර වශයෙන් ආපසු ලබාදේ. පැකේජයේ නවතම අනුවාද වල මෙය
කරදරකාරී දෝෂය නිවැරදි කර ඇත.

ඉහත අවස්ථාව සඳහා cleanup_module() ශ්‍රිත කේතය, උදාහරණයක් ලෙස, මේ වගේ විය හැක:

Void cleanup_module(void) ( unregister_those(ptr3, "skull"); unregister_that(ptr2, "skull"); unregister_this(ptr1, "skull"); return; )

ඔබගේ ආරම්භ කිරීම සහ අවසන් කිරීමේ කේතය මෙහි විස්තර කර ඇති ප්‍රමාණයට වඩා සංකීර්ණ නම්, goto ප්‍රකාශයක් භාවිතා කිරීමෙන් වැඩසටහන් පෙළ කියවීමට අපහසු විය හැක, මන්ද යත් අවසන් කිරීමේ කේතය init_module() ශ්‍රිතයේ goto සංක්‍රාන්ති සඳහා බහු ලේබල් භාවිතයෙන් නැවත නැවතත් කළ යුතු බැවිනි. මෙම හේතුව නිසා, වඩාත් දක්ෂ උපක්‍රමයක් නම්, init_module() ශ්‍රිතය තුළ cleanup_module() ශ්‍රිතයට ඇමතුමක් භාවිතා කිරීම, මොඩියුලය පැටවීමේ දෝෂයක් ඇති වූ විට සාර්ථක ආරම්භයේ තරම පිළිබඳ තොරතුරු ලබා දීමයි.

පහත දැක්වෙන්නේ init_module() සහ cleanup_module() ශ්‍රිතයන් ලියන ආකාරය පිළිබඳ උදාහරණයකි. මෙම උදාහරණය සාර්ථක ආරම්භයේ විෂය පථය පිළිබඳ තොරතුරු රැගෙන යන ගෝලීය වශයෙන් නිර්වචනය කරන ලද දර්ශක භාවිතා කරයි.

යමක් සකස් කරන්න * අයිතම 1; struct something else *item2; int stuff_ok; void cleanup_module(void) ((item1) release_thing(item1); නම් (item2) release_thing2(item2); නම් (stuff_ok) unregister_stuff(); return; ) int init_module(void) ( int err = -ENOMEM; item1 = වෙන් කරන්න (තර්ක); item2 = allocate_thing2(arguments2); (!item2 success */ fail: cleanup_module(); return err; )

ඔබගේ මොඩියුලයේ ආරම්භක මෙහෙයුම් වල සංකීර්ණත්වය මත පදනම්ව, ඔබට මොඩියුලයේ ආරම්භක දෝෂ පාලනය කිරීමට මෙහි ලැයිස්තුගත කර ඇති ක්‍රම වලින් එකක් භාවිතා කිරීමට අවශ්‍ය විය හැක.

මොඩියුල භාවිත කවුන්ටරය

මොඩියුලය ආරක්ෂිතව ගොඩබෑම කළ හැකිද යන්න තීරණය කිරීම සඳහා පද්ධතියේ එක් එක් මොඩියුලය සඳහා භාවිත කවුන්ටරයක් ​​අඩංගු වේ. පද්ධතියට මෙම තොරතුරු අවශ්‍ය වන්නේ මොඩියුලයක් යම් අයෙකු හෝ වෙනත් අයෙකු විසින් අල්ලාගෙන තිබේ නම් එය බාගැනීමට නොහැකි බැවිනි - එම ගොනු පද්ධතිය සවිකර ඇත්නම් ඔබට ගොනු පද්ධති ධාවකයක් ඉවත් කළ නොහැක, නැතහොත් යම් ක්‍රියාවලියක් මෙම උපාංගය භාවිතා කරන්නේ නම් ඔබට අක්ෂර උපාංග මොඩියුලයක් බාගැනීමට නොහැක. එසේ නොමැති නම්,
මෙය පද්ධති බිඳවැටීමකට තුඩු දිය හැකිය - ඛණ්ඩනය කිරීමේ දෝෂයක් හෝ කර්නල් භීතියක්.

නවීන කර්නල් වලදී, පද්ධතියට ඔබට ස්වයංක්‍රීය මොඩියුල භාවිත කවුන්ටරයක් ​​ලබා දිය හැක යාන්ත්‍රණයක් භාවිතා කරමින් අපි ඊළඟ පරිච්ඡේදයෙන් බලමු. කර්නල් අනුවාදය කුමක් වුවත්, ඔබට මෙම කවුන්ටරයේ අතින් පාලනය භාවිතා කළ හැකිය. මේ අනුව, කර්නලයේ පැරණි අනුවාදවල භාවිතා කළ යුතු කේතය පහත මැක්‍රෝ තුන මත ගොඩනගා ඇති මොඩියුල භාවිත ගිණුම්කරණ ආකෘතියක් භාවිතා කළ යුතුය:

මෙම මැක්‍රෝ නිර්වචනය කර ඇත , සහ ඔවුන් සෘජු ප්‍රවේශය යෝග්‍ය නොවන විශේෂ අභ්‍යන්තර දත්ත ව්‍යුහයක් හසුරුවයි. කාරණය නම්, මෙම දත්ත කළමනාකරණය කිරීමේ අභ්‍යන්තර ව්‍යුහය සහ අනුවාදයෙන් අනුවාදයට වෙනස් විය හැකි අතර, මෙම මැක්‍රෝස් භාවිතා කිරීම සඳහා බාහිර අතුරු මුහුණත නොවෙනස්ව පවතී.

ඔබ පරීක්ෂා කිරීමට අවශ්ය නොවන බව සලකන්න MOD_IN_USE cleanup_module() ශ්‍රිත කේතයේ, kernel/module.c හි අර්ථ දක්වා ඇති sys_delete_module() පද්ධති ඇමතුමේදී cleanup_module() කැඳවීමට පෙර මෙම පරීක්‍ෂණය ස්වයංක්‍රීයව සිදු වන බැවිනි.

මොඩියුල භාවිත කවුන්ටරය නිවැරදිව කළමනාකරණය කිරීම පද්ධතියේ ස්ථායීතාවය සඳහා ඉතා වැදගත් වේ. ඕනෑම අවස්ථාවක භාවිතා නොකළ මොඩියුලයක් ස්වයංක්‍රීයව බාගැනීමට කර්නලය තීරණය කළ හැකි බව මතක තබා ගන්න. මොඩියුල ක්‍රමලේඛනයේ පොදු වැරැද්දක් වන්නේ මෙම කවුන්ටරයේ වැරදි පාලනයයි. උදාහරණයක් ලෙස, යම් ඉල්ලීමකට ප්‍රතිචාර වශයෙන්, මොඩියුල කේතය සමහර ක්‍රියා සිදු කරන අතර, සැකසීම අවසන් වූ විට, මොඩියුල භාවිත කවුන්ටරය වැඩි කරයි. එම. එවැනි ක්‍රමලේඛකයෙකු උපකල්පනය කරන්නේ මෙම කවුන්ටරය මොඩියුල භාවිත සංඛ්‍යාලේඛන එකතු කිරීමට අදහස් කරන අතර, ඇත්ත වශයෙන්ම, එය මොඩියුලයේ වත්මන් පදිංචිය සඳහා කවුන්ටරයක් ​​වන අතර, i.e. මේ මොහොතේ මොඩියුල කේතය භාවිතා කරන ක්‍රියාවලි ගණන නිරීක්ෂණය කරයි. මේ අනුව, මොඩියුලයකට ඉල්ලීමක් සැකසීමේදී, ඔබ ඇමතිය යුතුය MOD_INC_USE_COUNTකිසියම් ක්රියාවක් කිරීමට පෙර, සහ MOD_DEC_USE_COUNTඒවා අවසන් වූ පසු.

පැහැදිලි හේතූන් මත, ඔබට එහි භාවිත කවුන්ටරයේ පාලනය නැති වුවහොත්, ඔබට මොඩියුලයක් බාගැනීමට නොහැකි වන අවස්ථා තිබිය හැකිය. මෙම තත්වය බොහෝ විට මොඩියුල සංවර්ධන අදියරේදී සිදු වේ. උදාහරණයක් ලෙස, NULL දර්ශකයක් ප්‍රතික්ෂේප කිරීමට උත්සාහ කිරීමේදී ක්‍රියාවලියක් ක්‍රියා විරහිත විය හැකි අතර, ඔබ එහි භාවිත කවුන්ටරය බිංදුවට ගෙන එන තෙක් ඔබට එවැනි මොඩියුලයක් බාගැනීමට නොහැකි වනු ඇත. මොඩියුල නිදොස් කිරීමේ අදියරේදී මෙම ගැටලුවට ඇති එක් විසඳුමක් නම් නැවත අර්ථ දැක්වීමෙන් මොඩියුල භාවිත කවුන්ටරයේ පාලනය සම්පූර්ණයෙන්ම අත්හැර දැමීමයි. MOD_INC_USE_COUNTසහ MOD_DEC_USE_COUNTහිස් කේතයට. තවත් විසඳුමක් වන්නේ මොඩියුලයේ භාවිත කවුන්ටරය ශුන්‍යයට බල කරන ioctl() ඇමතුමක් නිර්මාණය කිරීමයි. අපි මෙය 5 වන පරිච්ඡේදයේ, “වැඩිදියුණු කළ Char Driver මෙහෙයුම්” හි “ioctl තර්කය භාවිතා කිරීම” කොටසින් ආවරණය කරන්නෙමු. ඇත්ත වශයෙන්ම, භාවිතා කිරීමට සූදානම් ධාවකයක් තුළ, කවුන්ටරය සමඟ එවැනි වංචනික උපාමාරු බැහැර කළ යුතුය, කෙසේ වෙතත්, දෝශ නිරාකරණය කිරීමේ අදියරේදී, ඔවුන් සංවර්ධක කාලය ඉතිරි කර තරමක් පිළිගත හැකිය.

එක් එක් මොඩියුලය සඳහා වත්මන් පද්ධති භාවිත කවුන්ටරය /proc/modules ගොනුවේ එක් එක් ප්‍රවේශයේ තුන්වන ක්ෂේත්‍රයේ ඔබ සොයා ගනු ඇත. මෙම ගොනුවේ දැනට පටවා ඇති මොඩියුල පිළිබඳ තොරතුරු අඩංගු වේ - මොඩියුලයකට එක් පේළියක්. පේළියේ පළමු ක්ෂේත්‍රයේ මොඩියුලයේ නම අඩංගු වේ, දෙවන ක්ෂේත්‍රය මතකයේ මොඩියුලය විසින් අල්ලාගෙන ඇති ප්‍රමාණය වන අතර තෙවන ක්ෂේත්‍රය භාවිත කවුන්ටරයේ වත්මන් අගය වේ. මෙම තොරතුරු, ආකෘතිගත ආකාරයෙන්,
lsmod උපයෝගීතාව ඇමතීමෙන් ලබා ගත හැක. පහත දැක්වෙන්නේ /proc/modules ගොනුවක උදාහරණයකි:

Parport_pc 7604 1 (autoclean) lp 4800 0 (භාවිතා නොකළ) parport 8084 1 lockd 33256 1 (autoclean) sunrpc 56612 1 (autoclean) ds 6252 1 i823465 2230 2230

මෙහිදී අපි පද්ධතියට පටවා ඇති මොඩියුල කිහිපයක් දකිමු. ධජ ක්ෂේත්‍රයේ (රේඛාවේ අවසාන ක්ෂේත්‍රය), මොඩියුල පරායත්තතා තොගය හතරැස් වරහන් තුළ ප්‍රදර්ශනය කෙරේ. වෙනත් දේ අතර, රූපයේ දැක්වෙන පරිදි සමාන්තර වරාය මොඩියුල මොඩියුල තොගයක් හරහා සන්නිවේදනය කරන බව ඔබට දැක ගත හැකිය. 2-2. (autoclean) ධජය kmod හෝ kernald මගින් පාලනය වන මොඩියුල සලකුණු කරයි. මෙය 11 වන පරිච්ඡේදයේ “kmod සහ Advanced Modularization”) ආවරණය කෙරේ. (භාවිතා නොකළ) ධජය යනු මොඩියුලය දැනට භාවිතයේ නොමැති බවයි. කර්නලය 2.0 හි, ප්‍රමාණයේ ක්ෂේත්‍රය බයිට් වලින් නොව, බොහෝ වේදිකා සඳහා 4kB ප්‍රමාණයේ පිටු වල තොරතුරු පෙන්වයි.

මොඩියුලයක් බාගැනීම

මොඩියුලයක් බාගැනීමට, rmmod උපයෝගීතාව භාවිතා කරන්න. මොඩියුලයක් බෑම එය පැටවීමට වඩා සරල කාර්යයකි, එය කර්නලය සමඟ ගතිකව සම්බන්ධ කිරීම ඇතුළත් වේ. මොඩියුලයක් බාන විට, delete_module() පද්ධති ඇමතුම ක්‍රියාත්මක වේ, එය එක්කෝ බාන ලද මොඩියුලයේ භාවිත ගණන ශුන්‍ය නම් එහි cleanup_module() ශ්‍රිතය අමතයි, නැතහොත් දෝෂයකින් අවසන් වේ.

දැනටමත් සඳහන් කර ඇති පරිදි, cleanup_module() ශ්‍රිතය, cleanup_module() ශ්‍රිතය සමඟ මොඩියුලය පූරණය කරන විට සිදු කරන ලද ආරම්භක මෙහෙයුම් ආපසු හරවයි. එසේම, අපනයනය කරන ලද මොඩියුල සංකේත ස්වයංක්‍රීයව මකා දමනු ලැබේ.

අවසන් කිරීම සහ ආරම්භ කිරීමේ කාර්යයන් පැහැදිලිව නිර්වචනය කිරීම

දැනටමත් සඳහන් කර ඇති පරිදි, මොඩියුලයක් පූරණය කිරීමේදී කර්නලය init_module() ශ්‍රිතය අමතයි, එය බාගැනීමේදී cleanup_module() ලෙස හැඳින්වේ. කෙසේ වෙතත්, කර්නලයේ නවීන අනුවාද වල මෙම කාර්යයන් බොහෝ විට විවිධ නම් ඇත. කර්නලය 2.3.23 සමඟින් පටන් ගෙන, මොඩියුලයක් පැටවීමේ සහ බෑමේ කාර්යය සඳහා නමක් පැහැදිලිව නිර්වචනය කිරීමට හැකි විය. වර්තමානයේ, මෙම ශ්‍රිතවල මෙම පැහැදිලි නම් කිරීම නිර්දේශිත ක්‍රමලේඛන විලාසය වේ.

අපි උදාහරණයක් දෙමු. ඔබට පිළිවෙළින් init_module() සහ cleanup_module() වෙනුවට my_init() ශ්‍රිතය ඔබේ මොඩියුලයේ ආරම්භක ශ්‍රිතය ලෙසත්, my_cleanup() ශ්‍රිතය අවසාන ශ්‍රිතය ලෙසත් ප්‍රකාශ කිරීමට අවශ්‍ය නම්, ඔබට පහත දෙක එකතු කිරීමට අවශ්‍ය වනු ඇත. මැක්රෝස් මොඩියුල පෙළට (සාමාන්යයෙන් ඒවා අවසානයේ ඇතුල් කරනු ලැබේ
මොඩියුල කේත මූලාශ්‍ර ගොනුව):

Module_init(my_init); module_exit (my_cleanup);

මෙම මැක්‍රෝ භාවිතා කිරීමට ඔබට ඔබගේ මොඩියුලයට ශීර්ෂ ගොනුවක් ඇතුළත් කිරීමට අවශ්‍ය බව සලකන්න .

මෙම විලාසය භාවිතා කිරීමේ පහසුව නම් කර්නලයේ ඇති එක් එක් මොඩියුලය ආරම්භ කිරීම සහ අවසන් කිරීමේ ශ්‍රිතය සඳහා තමන්ගේම අනන්‍ය නමක් තිබිය හැකි අතර එය දෝෂහරණයට බෙහෙවින් උපකාරී වේ. එපමනක් නොව, ඔබ ඔබේ ධාවක කේතය මොඩියුලයක් ලෙස ක්‍රියාත්මක කරන්නේද නැතහොත් එය කෙලින්ම කර්නලය තුළට කාවැද්දීමට යන්නේද යන්න නොසලකා, මෙම කාර්යයන් භාවිතා කිරීම නිදොස්කරණය සරල කරයි. ඇත්ත වශයෙන්ම, ඔබගේ ආරම්භක සහ අවසන් කිරීමේ කාර්යයන් සඳහා වෙන්කර ඇති නම් තිබේ නම්, module_init සහ module_exit macros භාවිතා කිරීම අවශ්‍ය නොවේ, i.e. init_module() සහ cleanup_module() පිළිවෙලින්.

ඔබ 2.2 හෝ ඊට පසු කර්නල් මූලාශ්‍ර දෙස බැලුවහොත්, ආරම්භක සහ අවසන් කිරීමේ කාර්යයන් සඳහා තරමක් වෙනස් ආකාරයේ විස්තරයක් ඔබට දැකගත හැක. උදාහරණ වශයෙන්:

ස්ථිතික int __init my_init(void) ( .... ) static void __exit my_cleanup(void) ( .... )

ගුණාංග භාවිතය __initආරම්භක කාර්යය සම්පූර්ණ කිරීමෙන් පසු මතකයෙන් මුදා හැරීමට හේතු වනු ඇත. කෙසේ වෙතත්, මෙය kernel build-in drivers සඳහා පමණක් ක්‍රියා කරන අතර, මොඩියුල සඳහා නොසලකා හරිනු ඇත. එසේම, කර්නලය තුළට ගොඩනගා ඇති ධාවකයන් සඳහා, ගුණාංගය __පිටවීමමෙම ගුණාංගය සමඟ ලකුණු කර ඇති සම්පූර්ණ කාර්යය නොසලකා හැරීමට හේතු වනු ඇත. මොඩියුල සඳහා, මෙම ධජය ද නොසලකා හරිනු ඇත.

ගුණාංග භාවිතා කිරීම __init(සහ __initdataදත්ත විස්තර කිරීමට) කර්නලය භාවිතා කරන මතක ප්‍රමාණය අඩු කළ හැක. ධජ __initමොඩියුලයේ ආරම්භක කාර්යය ප්රතිලාභයක් හෝ හානියක් ගෙන එන්නේ නැත. මෙම ආකාරයේ ආරම්භ කිරීම පාලනය කිරීම මොඩියුල සඳහා තවම ක්‍රියාත්මක කර නැත, නමුත් අනාගතයේදී එය කළ හැකිය.

සාරාංශගත කිරීම

එබැවින්, ඉදිරිපත් කරන ලද ද්රව්යයේ ප්රතිඵලයක් ලෙස, "Hello world" මොඩියුලයේ පහත දැක්වෙන අනුවාදය ඉදිරිපත් කළ හැකිය:

මොඩියුල මූලාශ්‍ර ගොනු කේතය ==================================================== = #ඇතුළත් #ඇතුළත් #ඇතුළත් static int __init my_init_module (හිස්) ( EXPORT_NO_SYMBOLS; printk("<1>Hello world\n"); return 0; ); static void __exit my_cleanup_module (void) ( printk("<1>ආයුබෝවන්\n"); ); module_init(my_init_module); module_exit(my_cleanup_module); MODULE_LICENSE("GPL"); ========================= ====================== මොඩියුලය සම්පාදනය කිරීම සඳහා සාදන ගොනුව ========================== =================================== CFLAGS = -Wall -D__KERNEL__ -DMODULE -I/lib/modules/ $(shell uname -r)/build/include hello.o: ====================================== ============================

Makefile ලිවීමේදී, CFLAGS විචල්‍යය සහ පද්ධතියේ පවතින සම්පාදකය මත පදනම්ව වස්තු ගොනුවක් උත්පාදනය කරන්නේ කෙසේද යන්න GNU Make utility ස්වාධීනව තීරණය කළ හැකි සම්මුතිය අපි භාවිතා කළ බව කරුණාවෙන් සලකන්න.

සම්පත් භාවිතය

මතකය, I/O ports, I/O මතකය, බාධා කිරීම් රේඛා සහ DMA නාලිකා වැනි පද්ධති සම්පත් භාවිතා නොකර මොඩියුලයකට එහි කාර්යය සම්පූර්ණ කළ නොහැක.

ක්‍රමලේඛකයෙකු ලෙස, ඔබ දැනටමත් ගතික මතක කළමනාකරණය පිළිබඳව හුරුපුරුදු විය යුතුය. කර්නලයේ ගතික මතක කළමනාකරණය මූලික වශයෙන් වෙනස් නොවේ. ඔබගේ වැඩසටහනට ශ්‍රිතය භාවිතයෙන් මතකය ලබා ගත හැක kmalloc()සහ උපකාරයෙන් ඇයව නිදහස් කරන්න kfree(). මෙම ශ්‍රිත ඔබට හුරුපුරුදු malloc() සහ free() ශ්‍රිතවලට බෙහෙවින් සමාන වේ, kmalloc() ශ්‍රිතය අතිරේක තර්කයක් - ප්‍රමුඛතාවයෙන් සම්මත කර ඇත. සාමාන්‍යයෙන් ප්‍රමුඛතාවය GFP_KERNEL හෝ GFP_USER වේ. GFP යනු "නොමිලේ ලබාගන්න පිටුව" යන්නෙහි කෙටි යෙදුමකි. කර්නලයේ ගතික මතකය කළමනාකරණය කිරීම "මතකය අල්ලා ගැනීම" 7 වන පරිච්ඡේදයේ විස්තරාත්මකව ආවරණය කර ඇත.

නවක ධාවක සංවර්ධකයෙකු I/O ports, I/O මතකය සහ බාධා කිරීම් රේඛා පැහැදිලිව වෙන් කිරීමේ අවශ්‍යතාවය ගැන පුදුම විය හැක. කර්නල් මොඩියුලයට මෙම සම්පත් වෙත පහසුවෙන් ප්‍රවේශ විය හැක්කේ එවිට පමණි. පද්ධති මතකය ඕනෑම තැනකට වෙන් කළ හැකි වුවද, I/O මතකය, වරායන් සහ බාධා කිරීම් රේඛා විශේෂ කාර්යභාරයක් ඉටු කරන අතර ඒවා වෙනස් ලෙස වෙන් කරනු ලැබේ. උදාහරණයක් ලෙස, ධාවකයට ඇතැම් වරායන් වෙන් කිරීමට අවශ්‍ය වේ, නොවේ
සියල්ල, නමුත් ඔහුට උපාංගය පාලනය කිරීමට අවශ්‍ය ඒවා. නමුත් රියදුරුට මෙම සම්පත් වෙනත් අයෙකු විසින් භාවිතා නොකරන බව සහතික වන තුරු භාවිතා කළ නොහැක.

පර්යන්ත උපාංගයක් සතු මතක ප්‍රදේශය සාමාන්‍යයෙන් I/O මතකය ලෙස හැඳින්වේ, එය පද්ධති RAM (RAM) වෙතින් වෙන්කර හඳුනා ගැනීම සඳහා එය සරලව මතකය ලෙස හැඳින්වේ.

වරාය සහ I/O මතකය

සාමාන්‍ය රියදුරෙකුගේ කාර්යය බොහෝ දුරට සමන්විත වන්නේ වරාය කියවීම සහ ලිවීම සහ I/O මතකය. වරාය සහ I/O මතකය පොදු නාමයකින් එක්සත් වේ - I/O කලාපය (හෝ ප්‍රදේශය).

අවාසනාවන්ත ලෙස, සෑම බස් ගෘහ නිර්මාණ ශිල්පයකටම එක් එක් උපාංගයට අයත් I/O කලාපය පැහැදිලිව නිර්වචනය කළ නොහැකි අතර, රියදුරුට එය අයත් කලාපයේ පිහිටීම අනුමාන කිරීමට හෝ හැකි ලිපිනය මත කියවීමට/ලිවීමට උත්සාහ කිරීමට පවා සිදු විය හැකිය. අවකාශයන්. මෙම ගැටළුව විශේෂයෙන්
පුද්ගලික පරිගණකයක සරල උපාංග ස්ථාපනය කිරීමට තවමත් භාවිතා කරන ISA බසයට යොමු වන අතර PC/104 ක්‍රියාත්මක කිරීමේදී කාර්මික ලෝකයේ ඉතා ජනප්‍රිය වේ (15 වන පරිච්ඡේදයේ "PC/104 සහ PC/104+" කොටස බලන්න "පර්යන්ත බස් රථ පිළිබඳ දළ විශ්ලේෂණය" ).

දෘඪාංග උපාංගයක් සම්බන්ධ කිරීම සඳහා කුමන බස් රථයක් භාවිතා කළත්, රියදුරන් අතර ගැටීම් වැළැක්වීම සඳහා උපාංග ධාවකයට එහි I/O කලාපයට පමණක් ප්‍රවේශය සහතික කළ යුතුය. මොඩියුලයක්, තමන්ගේම උපාංගයට ප්‍රවේශ වීම, එයට අයත් නොවන උපාංගයකට ලියන්නේ නම්, මෙය මාරාන්තික ප්‍රතිවිපාකවලට තුඩු දිය හැකිය.

Linux සංවර්ධකයින් විසින් I/O කලාප ඉල්ලීම්/නිදහස් කිරීම සඳහා යාන්ත්‍රණයක් ක්‍රියාත්මක කළේ මූලික වශයෙන් විවිධ උපාංග අතර ගැටීම් වැලැක්වීම සඳහා ය. මෙම යාන්ත්‍රණය I/O ports සඳහා දිගු කලක් භාවිතා කර ඇති අතර මෑතකදී පොදුවේ සම්පත් කළමනාකරණයට සාමාන්‍යකරණය කර ඇත. මෙම යාන්ත්‍රණය මෘදුකාංග සාරාංශයක් නියෝජනය කරන අතර දෘඪාංග හැකියාවන් දක්වා විහිදෙන්නේ නැති බව සලකන්න. උදාහරණයක් ලෙස, දෘඪාංග මට්ටමින් I/O ports වෙත අනවසරයෙන් පිවිසීම "ඛණ්ඩාංක දෝෂයකට" සමාන කිසිදු දෝෂයක් ඇති නොකරයි, මන්ද දෘඪාංගය එහි සම්පත් වෙන් කර අවසර නොදෙන බැවිනි.

ලියාපදිංචි සම්පත් පිළිබඳ තොරතුරු /proc/ioports සහ /proc/iomem ගොනු තුළ පෙළ ආකාරයෙන් ලබා ගත හැකිය. මෙම තොරතුරු Linux හි kernel 2.3 සිට හඳුන්වා දී ඇත. මතක් කිරීමක් ලෙස, මෙම පොත මූලික වශයෙන් 2.4 කර්නලය කෙරෙහි අවධානය යොමු කරයි, සහ ගැළපුම් සටහන් පරිච්ඡේදය අවසානයේ ඉදිරිපත් කෙරේ.

වරායන්

පහත දැක්වෙන්නේ /proc/ioports ගොනුවේ සාමාන්‍ය අන්තර්ගතයයි:

0000-001f: dma1 0020-003f: pic1 0040-005f: ටයිමරය 0060-006f: යතුරුපුවරුව 0080-008f: dma පිටුව reg 00a0-00bf: pic2 00c0-00df:fff01070 ide1 01 f0- 01f7 : ide0 02f8-02ff: අනුක්‍රමික(සැකසුම) 0300-031f: NE2000 0376-0376: ide1 03c0-03df: vga+ 03f6-03f6: ide0 03f8-03ff: සංස්ථාපිතය 03f8-03ff: ABserial1030 X4 ACPI 1000- 1 003 : acpi 1004-1005: acpi 1008-100b: acpi 100c-100f: acpi 1100-110f: Intel Corporation 82371AB PIIX4 IDE 1300-131f: pcnet140IXtel14030_c ACPI 1800-18ff: PCI CardBus #02 1c00- 1cff: PCI CardBus #04 5800-581f: Intel Corporation 82371AB PIIX4 USB d000-dfff: PCI Bus #01 d000-d0ff: ATI Technologies Inc 3D Rage LT Pro AGP-13

මෙම ගොනුවේ සෑම පේළියක්ම ධාවක හෝ උපාංග හිමිකරු සමඟ සම්බන්ධිත වරාය පරාසය ෂඩාස්‍රයෙන් පෙන්වයි. කර්නලයේ පෙර අනුවාද වල, ගොනුව එකම ආකෘතියක් ඇත, හැර වරාය ධූරාවලිය නොපෙන්වයි.

පද්ධතියට නව උපාංගයක් එකතු කිරීමේදී වරාය ගැටීම් වළක්වා ගැනීමට ගොනුව භාවිතා කළ හැක. ජම්පර් මාරු කිරීමෙන් ස්ථාපිත උපකරණ අතින් වින්‍යාස කිරීමේදී මෙය විශේෂයෙන් පහසු වේ. මෙම අවස්ථාවෙහිදී, පරිශීලකයාට භාවිතා කළ වරායන් ලැයිස්තුව පහසුවෙන් දැක ගත හැකි අතර උපාංගය ස්ථාපනය කිරීම සඳහා නිදහස් පරාසයක් තෝරාගත හැක. බොහෝ නවීන උපාංග අතින් ජම්පර් භාවිතා නොකළද, ඒවා තවමත් කුඩා පරිමාණ සංරචක නිෂ්පාදනය සඳහා භාවිතා වේ.

වඩා වැදගත් වන්නේ /proc/ioports ගොනුවට ඒ හා සම්බන්ධ ක්‍රමලේඛනගතව ප්‍රවේශ විය හැකි දත්ත ව්‍යුහයක් තිබීමයි. එබැවින්, උපාංග ධාවකය ආරම්භ කරන විට, I/O ports වල වාඩිලාගෙන සිටින පරාසය දැනගත හැක. මෙයින් අදහස් කරන්නේ නව උපාංගයක් සෙවීමේදී වරායන් පරිලෝකනය කිරීමට අවශ්‍ය නම්, වෙනත් උපාංග විසින් අල්ලාගෙන සිටින වරායන් වෙත ලිවීමේ තත්ත්වය මඟහරවා ගැනීමට රියදුරුට හැකි බවයි.

ISA බස් රථය පරිලෝකනය කිරීම අවදානම් කාර්යයක් බව දන්නා කරුණකි. එබැවින්, නිල ලිනක්ස් කර්නලය සමඟ බෙදා හරින ලද සමහර ධාවක මොඩියුලය පැටවීමේදී එවැනි ස්කෑන් කිරීම වළක්වයි. එසේ කිරීමෙන්, ඔවුන් වෙනත් උපකරණ භාවිතා කරන වරායන් වෙත ලිවීමෙන් ධාවන පද්ධතියකට හානි කිරීමේ අවදානම මග හැරේ. වාසනාවකට මෙන්, නවීන බස් ගෘහ නිර්මාණ ශිල්පය මෙම ගැටළු වලින් ආරක්ෂා වේ.

I/O රෙජිස්ටර් වෙත ප්‍රවේශ වීමට භාවිතා කරන මෘදුකාංග අතුරුමුහුණත පහත සඳහන් කාර්යයන් තුනකින් සමන්විත වේ:

Int check_region(අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්); struct resource *request_region (අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්, char * නම); void release_region (අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්);

කාර්යය check_region()නිශ්චිත පරාසයක වරායන් අල්ලාගෙන තිබේදැයි පරීක්ෂා කිරීමට ඇමතිය හැක. ප්‍රතිචාරය සෘණ නම් එය සෘණ දෝෂ කේතයක් (-EBUSY හෝ -EINVAL වැනි) ලබා දෙයි.

කාර්යය request_region()ලබා දී ඇති ලිපින පරාසයක් වෙන් කිරීම සිදු කරයි, සාර්ථක නම්, ශුන්‍ය නොවන දර්ශකයක් ආපසු ලබා දෙයි. රියදුරුට ආපසු ලබා දුන් දර්ශකය ගබඩා කිරීමට හෝ භාවිතා කිරීමට අවශ්‍ය නොවේ. ඔබ කළ යුත්තේ NULL සඳහා පරීක්ෂා කිරීමයි. 2.4 (හෝ ඊට වැඩි) කර්නලයක් සමඟ පමණක් ක්‍රියා කළ යුතු කේතයට check_region() ශ්‍රිතය ඇමතීමට අවශ්‍ය නොවේ. මෙම බෙදාහැරීමේ ක්රමයේ වාසිය ගැන සැකයක් නැත, මන්ද
check_region() සහ request_region() වෙත වන ඇමතුම් අතර කුමක් සිදු විය හැකිද යන්න නොදනී. ඔබට කර්නලයේ පැරණි අනුවාද සමඟ ගැළපීම පවත්වා ගැනීමට අවශ්‍ය නම්, request_region() ට පෙර check_region() ඇමතීම අවශ්‍ය වේ.

කාර්යය release_region()ධාවකය කලින් භාවිතා කළ වරායන් මුදා හරින විට ඇමතිය යුතුය.

request_region() මඟින් ආපසු ලබා දෙන දර්ශකයේ සත්‍ය අගය භාවිතා කරනු ලබන්නේ කර්නලය තුළ ක්‍රියාත්මක වන සම්පත් වෙන් කිරීමේ උප පද්ධතියෙන් පමණි.

මෙම ශ්‍රිත තුන සැබවින්ම නිර්වචනය කර ඇති මැක්‍රෝ වේ .

වරායන් ලියාපදිංචි කිරීම සඳහා භාවිතා කරන ඇමතුම් අනුපිළිවෙලෙහි උදාහරණයක් පහත දැක්වේ. උදාහරණය හිස් කබල පුහුණු රියදුරු කේතයෙන් ලබාගෙන ඇත. (skull_probe_hw() ශ්‍රිත කේතය මෙහි දෘඪාංග මත යැපෙන කේතය අඩංගු බැවින් මෙහි නොපෙන්වයි.)

#ඇතුළත් #ඇතුළත් static int skull_detect(අත්සන් නොකළ int port, unsigned int පරාසය) ( int err; if ((err = check_region(port,range))< 0) return err; /* busy */ if (skull_probe_hw(port,range) != 0) return -ENODEV; /* not found */ request_region(port,range,"skull"); /* "Can"t fail" */ return 0; }

මෙම උදාහරණය ප්‍රථමයෙන් අවශ්‍ය වරායන් පරාසයේ ඇති බව පරීක්ෂා කරයි. වරායට ප්‍රවේශ විය නොහැකි නම්, උපකරණ වෙත ප්‍රවේශ විය නොහැක.
උපාංග වරායේ සැබෑ ස්ථානය ස්කෑන් කිරීම මගින් පැහැදිලි කළ හැක. මෙම උදාහරණයේ request_region() ශ්‍රිතය නොවිය යුතුය,
අසාර්ථකත්වයෙන් අවසන් වනු ඇත. කර්නලයට වරකට මොඩියුල එකකට වඩා පූරණය කළ නොහැක, එබැවින් වරාය භාවිත ගැටුම් ඇති නොවේ
යුතුය.

රියදුරු විසින් වෙන් කරන ලද ඕනෑම I/O වරායක් පසුව මුදා හැරිය යුතුය. අපගේ හිස් කබල ධාවකය මෙය සිදු කරන්නේ cleanup_module() ශ්‍රිතය තුළ ය:

ස්ථිතික හිස් හිස්කබල_නිදහස් (අත්සන් නොකළ int port, අත්සන් නොකළ int පරාසය) ( release_region(port,range); )

සම්පත් ඉල්ලීම්/නිදහස් කිරීමේ යාන්ත්‍රණය මොඩියුල ලියාපදිංචිය/ලියාපදිංච් කිරීමේ යාන්ත්‍රණයට සමාන වන අතර ඉහත විස්තර කර ඇති goto operator භාවිත යෝජනා ක්‍රමය මත පදනම්ව පරිපූර්ණව ක්‍රියාත්මක වේ.

මතකය

I/O මතකය පිළිබඳ තොරතුරු /proc/iomem ගොනුව හරහා ලබා ගත හැක. පුද්ගලික පරිගණකයක් සඳහා එවැනි ගොනුවක සාමාන්ය උදාහරණයක් පහත දැක්වේ:

00000000-0009fbff: පද්ධති RAM 0009fc00-0009ffff: වෙන් කර ඇති 000a0000-000bffff: වීඩියෝ RAM ප්‍රදේශය 000c0000-000c7fff: වීඩියෝ ROM 000f0000-000 පද්ධති RAM:000 001 00000-0022c557: කර්නල් කේතය 0022c558-0024455f: කර්නල් දත්ත 20000000 - 2fffffff: Intel Corporation 440BX/ZX - 82443BX/ZX ධාරක පාලම 68000000-68000fff: ටෙක්සාස් උපකරණ PCI1225 68001000-68001fff: Texas Instruments (#2122250 e4000000-e7ffff ff: PCI බස් #01 e4000000 -e4ffffff : ATI Technologies Inc 3D Rage LT Pro AGP-133 e6000000-e6000fff: ATI Technologies Inc 3D Rage LT Pro AGP-133 fffc0000-ffffffff: වෙන් කර ඇත

ලිපින පරාසයේ අගයන් ෂඩාස්‍ර අංකනයෙහි දැක්වේ. සෑම කලාපයක් සඳහාම, එහි හිමිකරු පෙන්වා ඇත.

I/O මතක ප්‍රවේශයන් ලියාපදිංචි කිරීම I/O ports ලියාපදිංචි කිරීම හා සමාන වන අතර කර්නලයේ එකම යාන්ත්‍රණය මත ගොඩනගා ඇත.

අවශ්‍ය I/O මතක ලිපින පරාසය ලබා ගැනීමට සහ මුදා හැරීමට, රියදුරු පහත ඇමතුම් භාවිතා කළ යුතුය:

Int check_mem_region (අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්); int request_mem_region (අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්, char *name); int release_mem_region (අත්සන් නොකළ දිගු ආරම්භය, අත්සන් නොකළ දිගු ලෙන්);

සාමාන්‍යයෙන්, ධාවකය I/O මතක ලිපින පරාසය දනී, එබැවින් මෙම සම්පත වෙන් කිරීම සඳහා වන කේතය වරාය පරාසයක් වෙන් කිරීමේ උදාහරණයට සාපේක්ෂව අඩු කළ හැකිය:

නම් (check_mem_region(mem_addr, mem_size)) ( printk("ධාවක නාමය: මතකය දැනටමත් භාවිතාවේ\n"); ආපසු -EBUSY; ) request_mem_region(mem_addr, mem_size, "drivername");

Linux 2.4 හි සම්පත් වෙන් කිරීම

වත්මන් සම්පත් බෙදා හැරීමේ යාන්ත්‍රණය ලිනක්ස් කර්නලය 2.3.11 හි හඳුන්වා දී ඇති අතර පද්ධති සම්පත් කළමනාකරණයට නම්‍යශීලී ප්‍රවේශයක් සපයයි. මෙම කොටස මෙම යාන්ත්රණය කෙටියෙන් විස්තර කරයි. කෙසේ වෙතත්, මූලික සම්පත් වෙන් කිරීමේ කාර්යයන් (request_region() වැනි) තවමත් මැක්‍රෝ ලෙස ක්‍රියාත්මක වන අතර කර්නලයේ පෙර අනුවාද සමඟ පසුගාමී අනුකූලතාව සඳහා භාවිතා වේ. බොහෝ අවස්ථාවලදී ඔබ සැබෑ බෙදාහැරීමේ යාන්ත්රණය ගැන කිසිවක් දැන ගැනීමට අවශ්ය නැත, නමුත් වඩාත් සංකීර්ණ ධාවකයන් නිර්මාණය කිරීමේදී එය රසවත් විය හැක.

ලිනක්ස් හි ක්‍රියාත්මක කරන ලද සම්පත් කළමනාකරණ පද්ධතියට අත්තනෝමතික සම්පත් ඒකාබද්ධ ධූරාවලි ආකාරයෙන් කළමනාකරණය කළ හැකිය. ගෝලීය පද්ධති සම්පත් (උදාහරණයක් ලෙස, I/O ports) උප කුලකවලට බෙදිය හැකිය - උදාහරණයක් ලෙස, විශේෂිත දෘඪාංග බස් නැවතුමකට සම්බන්ධ ඒවා. සමහර රියදුරන්ට ඔවුන්ගේ තාර්කික ව්‍යුහය මත පදනම්ව ග්‍රහණය කරගත් සම්පත් විකල්ප වශයෙන් බෙදිය හැක.

ශීර්ෂ ගොනුවේ ප්‍රකාශ කර ඇති ව්‍යුහාත්මක සම්පත් ව්‍යුහය හරහා වෙන් කරන ලද සම්පත් පරාසය විස්තර කෙරේ :

ව්‍යුහාත්මක සම්පත් (const char *name; අත්සන් නොකළ දිගු ආරම්භය, අවසානය; අත්සන් නොකළ දිගු කොඩි; struct සම්පත් *දෙමව්පියන්, *සහෝදර සහෝදරියන්, *දරුවා; );

ආරම්භයේදී ගෝලීය (මූල) සම්පත් පරාසයක් නිර්මාණය වේ. උදාහරණයක් ලෙස, I/O ports විස්තර කරන සම්පත් ව්‍යුහයක් පහත පරිදි සාදා ඇත:

ව්‍යුහාත්මක සම්පත් ioport_resource = ("PCI IO", 0x0000, IO_SPACE_LIMIT, IORESOURCE_IO);

PCI IO නම් සම්පතක් මෙහි විස්තර කර ඇත, එය බිංදුවේ සිට IO_SPACE_LIMIT දක්වා ලිපින පරාසය ආවරණය කරයි. මෙම විචල්‍යයේ අගය භාවිතා කරන වේදිකාව මත රඳා පවතින අතර 0xFFFF (16-bit ලිපින අවකාශය, x86, IA-64, Alpha, M68k සහ MIPS ගෘහ නිර්මාණ සඳහා), 0xFFFFFFFF (SPARC, PPC සඳහා බිට් 32 ලිපින අවකාශය) ට සමාන විය හැක. , SH) හෝ 0xFFFFFFFFFFFFFF (64-bit, SPARC64).

allocate_resource() වෙත ඇමතුමක් භාවිතයෙන් මෙම සම්පතෙහි උප කොටස් සෑදිය හැක. උදාහරණයක් ලෙස, PCI බස් ආරම්භයේදී, මෙම බසයේ ලිපින කලාපය සඳහා නව සම්පතක් නිර්මාණය කර භෞතික උපාංගයකට පවරා ඇත. PCI කර්නල් කේතය වරාය සහ මතක පැවරුම් සකසන විට, එය එම කලාප සඳහා පමණක් නව සම්පතක් නිර්මාණය කරන අතර ioport_resource() හෝ iomem_resource() වෙත ඇමතුම් භාවිතා කරමින් ඒවා වෙන් කරයි.

එවිට රියදුරුට සම්පතක (සාමාන්‍යයෙන් ගෝලීය සම්පතක කොටසක්) උප කුලකයක් ඉල්ලා එය කාර්ය බහුල ලෙස සලකුණු කළ හැක. ඉල්ලුම් කළ සම්පත විස්තර කරන නව ව්‍යුහාත්මක සම්පත් ව්‍යුහයක් වෙත දර්ශකයක් ආපසු ලබා දෙන request_region() ඇමතීමෙන් සම්පත් අත්පත් කර ගැනීම සිදු කෙරේ, නැතහොත් දෝෂයක් මත NULL. මෙම ව්යුහය ගෝලීය සම්පත් ගසෙහි කොටසකි. දැනටමත් සඳහන් කර ඇති පරිදි, සම්පත ලබා ගැනීමෙන් පසුව, රියදුරුට මෙම දර්ශකයේ වටිනාකම අවශ්ය නොවේ.

උනන්දුවක් දක්වන පාඨකයාට කර්නල් මූලාශ්‍ර නාමාවලියෙහි ඇති kernel/resource.c ගොනුවේ මෙම සම්පත් කළමනාකරණ ක්‍රමයේ විස්තර නැරඹීමෙන් සතුටක් ලැබිය හැක. කෙසේ වෙතත්, බොහෝ සංවර්ධකයින් සඳහා දැනටමත් ඉදිරිපත් කර ඇති දැනුම ප්රමාණවත් වනු ඇත.

ස්ථර සම්පත් වෙන් කිරීමේ යාන්ත්‍රණය ද්විත්ව ප්‍රතිලාභ ගෙන එයි. එක් අතකින්, එය කර්නල් දත්ත ව්‍යුහයන් පිළිබඳ දෘශ්‍ය නිරූපණයක් ලබා දෙයි. අපි නැවතත් උදාහරණ ගොනුව /proc/ioports දෙස බලමු:

E800-e8ff: Adaptec AHA-2940U2/W / 7890 e800-e8be: aic7xxx

e800-e8ff පරාසය ඇඩැප්ටෙක් ඇඩැප්ටරයට වෙන් කර ඇති අතර එය PCI බස් රථයේ රියදුරෙකු ලෙස නම් කර ඇත. මෙම පරාසයෙන් බොහොමයක් aic7xxx ධාවකය විසින් ඉල්ලා ඇත.

මෙම සම්පත් කළමනාකරණයේ තවත් වාසියක් වන්නේ උපකරණවල සත්‍ය අන්තර් සම්බන්ධතාවය පිළිබිඹු කරන ලිපින අවකාශය උප පරාසවලට බෙදීමයි. සම්පත් කළමනාකරුට අතිච්ඡාදනය වන ලිපින උප පරාස වෙන් කළ නොහැක, එය වැරදි ලෙස ක්‍රියා කරන ධාවකයක් ස්ථාපනය කිරීම වැළැක්විය හැකිය.

ස්වයංක්‍රීය සහ අතින් සැකසුම

ධාවකයට අවශ්‍ය සමහර පරාමිතීන් පද්ධතියෙන් පද්ධතියට වෙනස් විය හැක. උදාහරණයක් ලෙස, රියදුරු වලංගු I/O ලිපින සහ මතක පරාසයන් පිළිබඳව දැනුවත් විය යුතුය. හොඳින් සංවිධානය වූ බස් අතුරුමුහුණත් සඳහා මෙය ගැටළුවක් නොවේ. කෙසේ වෙතත්, සමහර විට ඔබට එහි උපාංගය සොයා ගැනීමට උපකාර කිරීම සඳහා ධාවකය වෙත පරාමිති ලබා දීමට සිදු වනු ඇත, නැතහොත් එහි සමහර කාර්යයන් සක්‍රිය / අක්‍රිය කරන්න.

ධාවක ක්‍රියාකාරිත්වයට බලපාන මෙම සැකසුම් උපාංගය අනුව වෙනස් වේ. උදාහරණයක් ලෙස, මෙය ස්ථාපිත උපාංගයේ අනුවාද අංකය විය හැකිය. ඇත්ත වශයෙන්ම, රියදුරුට උපාංගය සමඟ නිවැරදිව වැඩ කිරීම සඳහා එවැනි තොරතුරු අවශ්ය වේ. එවැනි පරාමිතීන් නිර්වචනය කිරීම (ධාවක වින්යාසය) තරමක් a
රියදුරු ආරම්භ කරන විට සිදු කරනු ලබන උපක්‍රමශීලී කාර්යයකි.

සාමාන්‍යයෙන්, මෙම පරාමිතියේ නිවැරදි අගයන් ලබා ගැනීමට ක්‍රම දෙකක් තිබේ - එක්කෝ පරිශීලකයා ඒවා පැහැදිලිව නිර්වචනය කරයි, නැතහොත් උපකරණ මත පදනම්ව රියදුරු ඒවා ස්වාධීනව තීරණය කරයි. ධාවක වින්‍යාසය සඳහා හොඳම විසඳුම ස්වයංක්‍රීයව හඳුනා ගැනීම වුවද,
අභිරුචි වින්‍යාසය ක්‍රියාත්මක කිරීමට වඩා පහසුය. රියදුරු සංවර්ධකයා හැකි සෑම තැනකම ධාවක ස්වයංක්‍රීය වින්‍යාසය ක්‍රියාත්මක කළ යුතුය, නමුත් ඒ සමඟම, ඔහු පරිශීලකයාට අතින් වින්‍යාස කිරීමේ යාන්ත්‍රණයක් ලබා දිය යුතුය. ඇත්ත වශයෙන්ම, ස්වයංක්‍රීය වින්‍යාසයට වඩා අතින් වින්‍යාසයට ඉහළ ප්‍රමුඛතාවයක් තිබිය යුතුය. සංවර්ධනයේ ආරම්භක අදියරේදී, සාමාන්යයෙන් ධාවකය වෙත පරාමිතීන් අතින් සම්ප්රේෂණය කිරීම පමණක් ක්රියාත්මක වේ. ස්වයංක්‍රීය වින්‍යාසය, හැකි නම්, පසුව එකතු කරනු ලැබේ.

බොහෝ රියදුරන්, ඔවුන්ගේ වින්යාස පරාමිතීන් අතර, ධාවක මෙහෙයුම් පාලනය කරන පරාමිතීන් ඇත. උදාහරණයක් ලෙස, Integrated Device Electronics (IDE) අතුරුමුහුණත් ධාවකයන් DMA මෙහෙයුම් පාලනය කිරීමට පරිශීලකයාට ඉඩ සලසයි. එබැවින්, ඔබේ රියදුරු දෘඩාංග ස්වයංක්‍රීයව හඳුනාගැනීමේ හොඳ කාර්යයක් කරන්නේ නම්, ඔබට රියදුරුගේ ක්‍රියාකාරීත්වය පිළිබඳව පරිශීලකයාට පාලනය ලබා දීමට අවශ්‍ය විය හැකිය.

insmod හෝ modprobe විධාන භාවිතයෙන් මොඩියුල පැටවීමේදී පරාමිති අගයන් ලබා දිය හැක. මෑතකදී වින්‍යාස ගොනුවකින් (සාමාන්‍යයෙන් /etc/modules.conf) පරාමිතිවල අගය කියවීමට හැකි වී ඇත. නිඛිල සහ තන්තු අගයන් පරාමිති ලෙස සම්මත කළ හැක. මේ අනුව, ඔබට skull_ival පරාමිතිය සඳහා පූර්ණ සංඛ්‍යා අගයක් සහ skull_sval පරාමිතිය සඳහා තන්තු අගයක් යැවීමට අවශ්‍ය නම්, ඔබට ඒවා insmod විධානයට අමතර පරාමිති සමඟ මොඩියුල පූරණය කිරීමේදී ඒවා ලබා දිය හැකිය:

Insmod හිස් කබල skull_ival=666 skull_sval="මෘගයා"

කෙසේ වෙතත්, insmod විධානයට මොඩියුලයක පරාමිතිවල අගයන් වෙනස් කිරීමට පෙර, මොඩියුලය එම පරාමිති ලබා ගත යුතුය. module.h ශීර්ෂ ගොනුවෙහි අර්ථ දක්වා ඇති MODULE_PARM සාර්ව නිර්වචනය භාවිතයෙන් පරාමිති ප්‍රකාශ කරනු ලැබේ. MODULE_PARM macro පරාමිති දෙකක් ගනී: විචල්‍යයේ නම සහ එහි වර්ගය නිර්වචනය කරන තන්තුවක්. මෙම සාර්ව අර්ථ දැක්වීම ඕනෑම ශ්‍රිතයකින් පිටත තැබිය යුතු අතර සාමාන්‍යයෙන් විචල්‍යයන් අර්ථ දැක්වීමෙන් පසුව ගොනුවේ ආරම්භයේ පිහිටා ඇත. එබැවින්, ඉහත සඳහන් කළ පරාමිතීන් දෙක පහත පරිදි ප්රකාශ කළ හැකිය:

Int skull_ival=0; char * හිස්කබල_sval; MODULE_PARM(skull_ival, "i"); MODULE_PARM(skull_sval, "s");

දැනට සහය දක්වන මොඩියුල පරාමිති වර්ග පහක් ඇත:

• b - එක් බයිට් අගය;
• h - (කෙටි) ද්වි-බයිට් අගය;
• i - පූර්ණ සංඛ්යාව;
• l - දිගු නිඛිල;
• s - string (char *);

තන්තු පරාමිතීන් සම්බන්ධයෙන්, මොඩියුලය තුළ දර්ශකයක් (char *) ප්‍රකාශ කළ යුතුය. insmod විධානය මඟින් ඇතුළත් කළ තන්තුව සඳහා මතකය වෙන් කර අවශ්‍ය අගය සමඟ එය ආරම්භ කරයි. MODULE_PARM මැක්‍රෝ භාවිතයෙන්, ඔබට පරාමිති අරා ආරම්භ කළ හැක. මෙම අවස්ථාවෙහිදී, අරාවේ දිග තීරණය කරනුයේ වර්ගයේ අක්ෂරයට පෙර ඇති පූර්ණ සංඛ්‍යාවයි. නිඛිල දෙකක් නියම කර, ඉරකින් වෙන් කළ විට, ඒවා සම්ප්‍රේෂණය කළ යුතු අවම සහ උපරිම අගයන් තීරණය කරයි. මෙම මැක්‍රෝව ක්‍රියා කරන ආකාරය පිළිබඳ වඩාත් සවිස්තරාත්මක අවබෝධයක් සඳහා, කරුණාකර ශීර්ෂ ගොනුව වෙත යොමු වන්න .

උදාහරණයක් ලෙස, පරාමිති මාලාවක් අවම වශයෙන් දෙකක් සහ අවම වශයෙන් නිඛිල අගයන් හතරකින් ආරම්භ කළ යුතු යැයි සිතමු. එවිට එය මෙසේ විස්තර කළ හැක.

Int හිස්කබල_අරාව; MODULE_PARM(skull_array, "2-4i");

ඊට අමතරව, ක්‍රමලේඛකයාගේ මෙවලම් කට්ටලයට සාර්ව නිර්වචනය MODULE_PARM_DESC ඇත, එමඟින් සම්මත වන මොඩියුල පරාමිතීන් පිළිබඳ අදහස් දැක්වීමට ඔබට ඉඩ සලසයි. මෙම අදහස් මොඩියුල වස්තු ගොනුව තුළ ගබඩා කර ඇති අතර, උදාහරණයක් ලෙස, objdump උපයෝගීතාව භාවිතයෙන් හෝ ස්වයංක්‍රීය පද්ධති පරිපාලන මෙවලම් භාවිතයෙන් නැරඹිය හැක. මෙම සාර්ව නිර්වචනය භාවිතා කිරීමේ උදාහරණයක් මෙන්න:

Int base_port = 0x300; MODULE_PARM(base_port, "i"); MODULE_PARM_DESC (base_port, "The base I/O port (default 0x300)");

සියලුම මොඩියුල පරාමිතීන් පෙරනිමි අගයන් තිබීම යෝග්‍ය වේ. insmod භාවිතයෙන් මෙම අගයන් වෙනස් කිරීම අවශ්‍ය වන්නේ අවශ්‍ය නම් පමණි. මොඩියුලයට ඒවායේ වත්මන් අගයන් පෙරනිමි අගයන් සමඟ පරීක්ෂා කිරීමෙන් පරාමිතිවල පැහැදිලි සැකසුම පරීක්ෂා කළ හැකිය. පසුව, ඔබට පහත රූප සටහන මත පදනම්ව ස්වයංක්‍රීය වින්‍යාස යාන්ත්‍රණයක් ක්‍රියාත්මක කළ හැකිය. පරාමිති අගයන්ට පෙරනිමි අගයන් තිබේ නම්, ස්වයංක්‍රීය වින්‍යාසය සිදු කරනු ලැබේ. එසේ නොමැති නම්, වත්මන් අගයන් භාවිතා වේ. මෙම යෝජනා ක්‍රමය ක්‍රියාත්මක වීමට නම්, පෙරනිමි අගයන් සැබෑ ලෝක පද්ධති වින්‍යාසයන් කිසිවකට අනුරූප නොවීම අවශ්‍ය වේ. එවිට එවැනි අගයන් අතින් සැකසුමේදී පරිශීලකයාට සැකසිය නොහැකි බව උපකල්පනය කෙරේ.

පහත උදාහරණය මඟින් හිස් කබල ධාවකය උපාංග වරායන්හි ලිපින අවකාශය ස්වයංක්‍රීයව හඳුනා ගන්නා ආකාරය පෙන්වයි. ඉහත උදාහරණයේ, ස්වයංක්‍රීයව හඳුනාගැනීම උපාංග කිහිපයක් දෙස බලයි, අතින් වින්‍යාසය මඟින් ධාවකය තනි උපාංගයකට සීමා කරයි. I/O ports විස්තර කරන කොටසේ ඔබ දැනටමත් skull_detect ශ්‍රිතය හමු වී ඇත. skull_init_board() ක්‍රියාත්මක කිරීම නොපෙන්වන්නේ එය නිසාය
දෘඪාංග මත යැපෙන ආරම්භ කිරීම සිදු කරයි.

/* * වරාය පරාසයන්: උපාංගයට * 0x280 සහ 0x300 අතර, 0x10 පියවර තුළ පැවතිය හැක. එය 0x10 ports භාවිතා කරයි. */ #define SKULL_PORT_FLOOR 0x280 #define SKULL_PORT_CEIL 0x300 #define SKULL_PORT_RANGE 0x010 /* * පහත ශ්‍රිතය ස්වයං හඳුනාගැනීම සිදු කරයි, insmod විසින් "skulls_port_batse"_stallba ට නිශ්චිත * අගයක් පවරනු ලැබුවහොත් මිස; /* 0 බලවේග ස්වයං හඳුනාගැනීම */ MODULE_PARM (skull_port_base, "i"); MODULE_PARM_DESC(skull_port_base, "Base I/O port for හිස්කබල"); static int skull_find_hw(void) /* උපාංග # නැවත ලබා දෙයි */ ( /* base යනු load-time අගය හෝ පළමු අත්හදා බැලීම */ int base = skull_port_base ? skull_port_base: SKULL_PORT_FLOOR; int result = 0; /* loop එකක් අගය පවරන්නේ නම් කාලය; ස්වයංක්‍රීයව අනාවරණය කර ඇත්නම් ඒවා සියල්ලම උත්සාහ කරන්න */ do ((skull_detect(base, SKULL_PORT_RANGE) == 0) (skull_init_board(base); result++; ) base += SKULL_PORT_RANGE; /* මීළඟ අත්හදා බැලීම සඳහා සූදානම් වන්න */ ) (skull_port_base == 0 && පදනම< SKULL_PORT_CEIL); return result; }

වින්‍යාස විචල්‍යයන් භාවිතා කරන්නේ ධාවක ඇතුළත පමණක් නම් (එනම්, කර්නල් සංකේත වගුවේ ප්‍රකාශිත නොවේ), එවිට ක්‍රමලේඛකයාට විචල්‍ය නම්වල උපසර්ග භාවිතා නොකිරීමෙන් පරිශීලකයාට ජීවිතය ටිකක් පහසු කළ හැකිය (අපගේ නඩුවේදී, හිස්කබල_ උපසර්ගය) . මෙම උපසර්ගයන් පරිශීලකයාට සුළු දෙයක් අදහස් කරන අතර, ඒවායේ නොපැමිණීම යතුරු පුවරුවෙන් විධානය ටයිප් කිරීම සරල කරයි.

සම්පූර්ණත්වය සඳහා, අපි ඔබට වස්තු ගොනුවේ සමහර අදහස් තැබීමට ඉඩ සලසන තවත් සාර්ව නිර්වචන තුනක විස්තරයක් ලබා දෙන්නෙමු.

ලිනක්ස් කර්නල් මොඩියුලයක් යනු x86-64 ප්‍රොසෙසරයේ අභ්‍යන්තර සහ අවම ආරක්‍ෂිත උපදෙස් ක්‍රියාත්මක කිරීමේ වළල්ල වන 0 මුදුවෙන් ක්‍රියාත්මක වන ලිනක්ස් කර්නලය වෙත සෘජුවම ඇතුළු කරන ලද සම්පාදනය කරන ලද ද්විමය කේතයකි. මෙහිදී කේතය කිසිදු චෙක්පතකින් තොරව සම්පුර්ණයෙන්ම ක්‍රියාත්මක වේ, නමුත් ඇදහිය නොහැකි වේගයකින් සහ ඕනෑම පද්ධති සම්පත් වෙත ප්‍රවේශය ඇත.

හුදු මිනිසුන් සඳහා නොවේ

සාම්ප්‍රදායික යෙදුම් සංවර්ධන ආදර්ශ බොහෝ දුරට අමතක කළ හැකිය. මොඩියුලයක් පැටවීමට සහ බෑමට අමතරව, ඔබ අනුක්‍රමික රටාවක් අනුගමනය කරනවාට වඩා පද්ධති සිදුවීම් වලට ප්‍රතික්‍රියා කරන කේතයක් ලියනු ඇත. කර්නලය සමඟ වැඩ කරන විට, ඔබ API ලියන්නේ, යෙදුම් නොවේ.

ඔබට සම්මත පුස්තකාලයට ප්‍රවේශය ද නැත. කර්නලය printk (printf සඳහා ආදේශකයක්) සහ kmalloc (malloc හා සමානව ක්‍රියා කරන) වැනි සමහර කාර්යයන් සපයන නමුත්, ඔබ බොහෝ දුරට දෘඪාංගයට ඉතිරි වේ. ඊට අමතරව, මොඩියුලය බෑමෙන් පසු ඔබ සම්පූර්ණයෙන්ම පිරිසිදු කළ යුතුය. මෙතන කුණු එකතු කිරීමක් නැහැ.

අවශ්ය සංරචක

දෙවනුව, ඔබට වෙනම භෞතික යන්ත්‍රයක් හෝ අථත්‍ය යන්ත්‍රයක් අවශ්‍ය වේ. පුද්ගලිකව, මම අතථ්‍ය යන්ත්‍රයක වැඩ කිරීමට කැමැත්තෙමි, නමුත් ඔබේ තේරීම ගන්න. ඔබ වැරැද්දක් කළ විට දත්ත නැතිවීම නිසා ඔබේ ප්‍රධාන යන්ත්‍රය භාවිතා කිරීම මම නිර්දේශ නොකරමි. මම කියන්නේ "කවදාද" සහ "නම්" නොවේ, මන්ද ඔබ අනිවාර්යයෙන්ම ක්‍රියාවලියේදී අවම වශයෙන් කිහිප වතාවක්වත් මෝටර් රථය එල්ලා තබනු ඇත. කර්නලය කලබල වන විට ඔබේ නවතම කේත වෙනස් කිරීම් තවමත් ලිවීමේ බෆරයේ තිබිය හැක, එබැවින් ඔබේ මූලාශ්‍ර ද දූෂිත විය හැක. අතථ්‍ය යන්ත්‍රයක පරීක්ෂා කිරීම මෙම අවදානම් ඉවත් කරයි.

අවසාන වශයෙන්, ඔබ අවම වශයෙන් C ටිකක්වත් දැන සිටිය යුතුය. C++ ධාවන කාලය කර්නලයට විශාල වැඩිය, එබැවින් ඔබ පිරිසිදු, හිස් C වලින් ලිවිය යුතුය. එකලස් කිරීමේ භාෂාව පිළිබඳ යම් දැනුමක් දෘඪාංග සමඟ අන්තර්ක්‍රියා කිරීමටද උපකාරී වේ.

සංවර්ධන පරිසරය ස්ථාපනය කිරීම

Apt-get install build-essential linux-headers-`uname -r`
අපි මෙම උදාහරණය සඳහා අවශ්‍ය වඩාත්ම වැදගත් සංවර්ධන මෙවලම් සහ කර්නල් ශීර්ෂ ස්ථාපනය කරමු.

පහත උදාහරණ උපකල්පනය කරන්නේ ඔබ root වෙනුවට සාමාන්‍ය පරිශීලකයෙකු ලෙස ධාවනය වන නමුත් ඔබට sudo වරප්‍රසාද ඇති බවයි. කර්නල් මොඩියුල පැටවීමට Sudo අවශ්‍ය වේ, නමුත් අපට හැකි සෑම විටම root වලින් පිටත වැඩ කිරීමට අවශ්‍යය.

ආරම්භය

Mkdir ~/src/lkm_example cd ~/src/lkm_example
ඔබගේ ප්‍රියතම සංස්කාරකය දියත් කරන්න (මගේ නඩුවේ vim) සහ පහත අන්තර්ගතය සහිත lkm_example.c ගොනුවක් සාදන්න:

#ඇතුළත් #ඇතුළත් #ඇතුළත් MODULE_LICENSE("GPL"); MODULE_AUTHOR("රොබට් ඩබ්ලිව්. ඔලිවර් II"); MODULE_DESCRIPTION("සරල උදාහරණයක් Linux මොඩියුලයක්."); MODULE_VERSION("0.01"); static int __init lkm_example_init(void) ( printk(KERN_INFO “Hello, World!\n”); return 0; ) static void __exit lkm_example_exit(void) ( printk(KERN_INFO “Goodbye, World!\n”); lkinmit_exin; ); module_exit (lkm_example_exit);
අපි හැකි සරලම මොඩියුලය නිර්මාණය කර ඇත, එහි වඩාත්ම වැදගත් කොටස් දෙස සමීපව බලමු:

• ලිනක්ස් කර්නලය සංවර්ධනය කිරීමට අවශ්‍ය ශීර්ෂ ගොනු ලැයිස්තුගත කරයි.
• MODULE_LICENSE මොඩියුලයේ බලපත්‍රය මත පදනම්ව විවිධ අගයන්ට සැකසිය හැක. සම්පූර්ණ ලැයිස්තුව බැලීමට, ධාවනය කරන්න:

  Grep “MODULE_LICENSE” -B 27 /usr/src/linux-headers-`uname -r`/include/linux/module.h

• අපි init (පූරණය) සහ පිටවීම (බෑම) නිඛිල ලබා දෙන ස්ථිතික ශ්‍රිත ලෙස සකස් කරමු.
• printf වෙනුවට printk භාවිතය සැලකිල්ලට ගන්න. එසේම printk සඳහා විකල්ප printf ට වඩා වෙනස් වේ. උදාහරණයක් ලෙස, විශේෂිත රේඛාවක් සඳහා ලොග් වීමේ ප්‍රමුඛතාවය ප්‍රකාශ කිරීමට KERN_INFO ධජය කොමාවකින් තොරව දක්වා ඇත. Stack මතකය සුරැකීමට කර්නලය මෙම දේවල් printk ශ්‍රිතය තුළ හසුරුවයි.
• ගොනුව අවසානයේ, ඔබට module_init සහ module_exit ඇමතීමට සහ පැටවීමේ සහ බෑමේ කාර්යයන් සඳහන් කළ හැකිය. මෙය අත්තනෝමතික ලෙස කාර්යයන් නම් කිරීමට හැකි වේ.

Obj-m += lkm_example.o සියල්ල: -C /lib/modules/$(shell uname -r)/build M=$(PWD) මොඩියුල පිරිසිදු කරන්න: කරන්න -C /lib/modules/$(shell uname -r )/බිල්ඩ් M=$(PWD) පිරිසිදු
අපි Make ධාවනය කරන්නේ නම් එය අපගේ මොඩියුලය සාර්ථකව සම්පාදනය කළ යුතුය. ප්රතිඵලය වනු ඇත්තේ lkm_example.ko ගොනුවයි. කිසියම් දෝෂයක් සිදුවුවහොත්, මූලාශ්‍ර කේතයේ උද්ධෘත නිවැරදිව සකසා ඇති අතර අහම්බෙන් UTF-8 කේතනය කිරීමේදී නොවේදැයි පරීක්ෂා කරන්න.

දැන් ඔබට මොඩියුලය ක්රියාත්මක කර එය පරීක්ෂා කළ හැකිය. මෙය සිදු කිරීම සඳහා අපි ධාවනය කරන්නේ:

Sudo insmod lkm_example.ko
හැම දෙයක්ම හොඳයි නම්, ඔබට කිසිවක් නොපෙනේ. printk ශ්‍රිතය මඟින් ප්‍රතිදානය සපයන්නේ කොන්සෝලයට නොව කර්නල් ලොගයටයි. බැලීම සඳහා ඔබ ධාවනය කළ යුතුය:

Sudo dmesg
ඔබ "හෙලෝ, වර්ල්ඩ්!" යන පේළිය දැකිය යුතුය. ආරම්භයේ කාල මුද්‍රාවක් සමඟ. මෙයින් අදහස් කරන්නේ අපගේ කර්නල් මොඩියුලය පූරණය වී කර්නල් ලොගය වෙත සාර්ථකව ලියා ඇති බවයි. මොඩියුලය තවමත් මතකයේ තිබේදැයි අපට පරීක්ෂා කළ හැකිය:

lsmod | grep "lkm_example"
මොඩියුලයක් ඉවත් කිරීමට, ධාවනය කරන්න:

Sudo rmmod lkm_example
ඔබ නැවත dmesg ධාවනය කරන්නේ නම්, ලොගයේ “Goodbye, World!” යන ප්‍රවේශය ඔබට පෙනෙනු ඇත. ඔබට නැවත lsmod ධාවනය කර මොඩියුලය ඉවත් කර ඇති බවට වග බලා ගත හැකිය.

ඔබට පෙනෙන පරිදි, මෙම පරීක්ෂණ ක්‍රියා පටිපාටිය තරමක් වෙහෙසකාරී ය, නමුත් එය එකතු කිරීමෙන් ස්වයංක්‍රීය කළ හැකිය:

පරීක්ෂණය: sudo dmesg -C sudo insmod lkm_example.ko sudo rmmod lkm_example.ko dmesg
Makefile අවසානයේ සහ පසුව ධාවනය:

පරීක්ෂණයක් කරන්න
මොඩියුලය පරීක්ෂා කිරීමට සහ වෙනම විධාන ක්‍රියාත්මක නොකර කර්නල් ලොගයට ප්‍රතිදානය පරීක්ෂා කිරීමට.

අපට දැන් සම්පූර්ණයෙන්ම ක්‍රියාකාරී, සම්පූර්ණයෙන්ම සුළු සුළු වුවද, කර්නල් මොඩියුලයක් ඇත!

අපි ටිකක් ගැඹුරට හාරමු. කර්නල් මොඩියුලයන් සියලු ආකාරයේ කාර්යයන් ඉටු කිරීමට සමත් වුවද, යෙදුම් සමඟ අතුරු මුහුණත් කිරීම බහුලව භාවිතා වන අවස්ථා වලින් එකකි.

කර්නල් අවකාශයේ මතකය බැලීමට යෙදුම් වලට අවසර නොමැති නිසා, ඔවුන් සමඟ සන්නිවේදනය කිරීමට API භාවිතා කළ යුතුය. තාක්ෂණික වශයෙන් මෙය කිරීමට ක්රම කිහිපයක් ඇතත්, වඩාත් පොදු වන්නේ උපාංග ගොනුවක් නිර්මාණය කිරීමයි.

ඔබ මීට පෙර උපාංග ගොනු සමඟ කටයුතු කර ඇත. /dev/zero , /dev/null වැනි සඳහන් කරන විධාන, අපේක්ෂිත අගයන් ලබා දෙන “ශුන්‍ය” සහ “ශුන්‍ය” උපාංග සමඟ අන්තර් ක්‍රියා කරයි.

අපගේ උදාහරණයේ දී අපි "හෙලෝ, වර්ල්ඩ්" ආපසු ලබා දෙන්නෙමු. මෙය යෙදුම් සඳහා විශේෂයෙන් ප්‍රයෝජනවත් අංගයක් නොවන අතර, එය තවමත් උපාංග ගොනුවක් හරහා යෙදුමක් සමඟ අන්තර්ක්‍රියා කිරීමේ ක්‍රියාවලිය පෙන්නුම් කරයි.

මෙන්න සම්පූර්ණ ලැයිස්තුව:

#ඇතුළත් #ඇතුළත් #ඇතුළත් #ඇතුළත් #ඇතුළත් MODULE_LICENSE("GPL"); MODULE_AUTHOR("රොබට් ඩබ්ලිව්. ඔලිවර් II"); MODULE_DESCRIPTION("සරල උදාහරණයක් Linux මොඩියුලයක්."); MODULE_VERSION("0.01"); #DEVICE_NAME "lkm_example" #define EXAMPLE_MSG "Hello, World!\n" #define MSG_BUFFER_LEN 15 /* උපාංග ශ්‍රිත සඳහා මූලාකෘති */ static int device_open(struct inode *, struct file *); static int device_release (struct inode *, struct file *); ස්ථිතික ssize_t device_read (struct file *, char *, size_t, loff_t *); ස්ථිතික ssize_t device_write (struct file *, const char *, size_t, loff_t *); ස්ථිතික int major_num; ස්ථිතික int device_open_count = 0; ස්ථිතික අක්ෂර msg_buffer; ස්ථිතික අකුරු *msg_ptr; /* මෙම ව්‍යුහය සියලුම උපාංග කාර්යයන් වෙත යොමු කරයි */ static struct file_operations file_ops = ( .read = device_read, .write = device_write, .open = device_open, .release = device_release ); /* ක්‍රියාවලියක් අපගේ උපාංගයෙන් කියවන විට, මෙය කැඳවනු ලැබේ. */ static ssize_t device_read(struct file *flip, char *buffer, size_t len, loff_t *offset) ( int bytes_read = 0; /* අපි අවසානයේ සිටින්නේ නම්, නැවත මුලට ලූප් කරන්න */ if (*msg_ptr = = 0) ( msg_ptr = msg_buffer; ) /* දත්ත බෆරයට දමන්න */ අතරතුර (len && *msg_ptr) ( /* බෆරය ඇත්තේ පරිශීලක දත්තවල මිස කර්නලයේ නොවේ, එබැවින් ඔබට පොයින්ටරයකින් * පමණක් යොමු කළ නොහැක. ශ්‍රිතය put_user මෙය අප වෙනුවෙන් හසුරුවයි */ put_user(*(msg_ptr++), buffer++); len--; bytes_read++; ) return bytes_read; ) /* ක්‍රියාවලියක් අපගේ උපාංගයට ලිවීමට උත්සාහ කරන විට කැඳවනු ලැබේ */ static ssize_t device_write(struct file * flip, const char *buffer, size_t len, loff_t *offset) ( /* මෙය කියවීමට පමණක් වන උපාංගයකි */ printk(KERN_ALERT "මෙම මෙහෙයුම සඳහා සහය නොදක්වයි.\n"); ආපසු -EINVAL; ) /* ඇමතූ විට ක්‍රියාවලියක් අපගේ උපාංගය විවෘත කරයි */ static int device_open (struct inode *inode, struct file *file) ( /* උපාංගය විවෘත නම්, කාර්යබහුල ආපසු */ if (device_open_count) ( return -EBUSY; ) device_open_count++; try_module_get(THIS_MODULE); ආපසු 0; ) /* ක්‍රියාවලියක් අපගේ උපාංගය වසා දැමූ විට කැඳවනු ලැබේ */ static int device_release(struct inode *inode, struct file *file) ( /* විවෘත කවුන්ටරය සහ භාවිත ගණන අඩු කරන්න. මෙය නොමැතිව, මොඩියුලය බාන්නේ නැත. */ device_open_count- -; මොඩියුලය_පොට් (this_module); repic int __init __init lkm_em_eyfter_lenit (/ * msg_ptr (/ msg_ptr = msg_buffer = msg_buffer ; /* අක්ෂර උපාංගය ලියාපදිංචි කිරීමට උත්සාහ කරන්න */ major_num = register_chrdev(0, “lkm_example”, &file_ops); නම් (major_num)< 0) { printk(KERN_ALERT “Could not register device: %d\n”, major_num); return major_num; } else { printk(KERN_INFO “lkm_example module loaded with device major number %d\n”, major_num); return 0; } } static void __exit lkm_example_exit(void) { /* Remember - we have to clean up after ourselves. Unregister the character device. */ unregister_chrdev(major_num, DEVICE_NAME); printk(KERN_INFO “Goodbye, World!\n”); } /* Register module functions */ module_init(lkm_example_init); module_exit(lkm_example_exit);

වැඩිදියුණු කළ ආදර්ශයක් පරීක්ෂා කිරීම

Obj-m += lkm_example.o සියල්ල: -C /lib/modules/$(shell uname -r)/build M=$(PWD) මොඩියුල පිරිසිදු කරන්න: කරන්න -C /lib/modules/$(shell uname -r )/build M=$(PWD) clean test: # අපි rmmod විධානය ඉදිරියෙන් a - තබමු. -sudo rmmod lkm_example # echo sudo dmesg නොමැතිව කර්නල් ලොගය හිස් කරන්න -C # sudo insmod lkm_example.ko මොඩියුලය ඇතුල් කරන්න # කර්නල් ලොගය dmesg පෙන්වන්න
දැන් make test ධාවනය කිරීමෙන් පසු ප්‍රධාන උපාංග අංකය ප්‍රතිදානය වන බව ඔබට පෙනෙනු ඇත. අපගේ උදාහරණයේ දී, එය කර්නලය මගින් ස්වයංක්රීයව පවරනු ලැබේ. කෙසේ වෙතත්, නව උපාංගයක් නිර්මාණය කිරීමට මෙම අංකය අවශ්ය වේ.

පරීක්‍ෂණයෙන් උත්පාදනය කරන ලද අංකය ගෙන එය භාවිතා කර උපාංග ගොනුවක් නිර්මාණය කරන්න එවිට අපට පරිශීලක අවකාශයෙන් අපගේ කර්නල් මොඩියුලය සමඟ සන්නිවේදනය කළ හැකිය.

MAJOR 0 සමඟ Sudo mknod /dev/lkm_example
(මෙම උදාහරණයේදී, Make test හෝ dmesg වෙතින් ලබාගත් අගය සමඟ MAJOR ආදේශ කරන්න)

mknod විධානයේ ඇති c විකල්පය mknod ට පවසන්නේ අපට අක්ෂර උපාංග ගොනුවක් සෑදිය යුතු බවයි.

දැන් අපට උපාංගයෙන් අන්තර්ගතය ලබා ගත හැක:

Cat /dev/lkm_example
හෝ dd විධානය හරහා පවා:

Dd if=/dev/lkm_example of=test bs=14 count=100
ඔබට මෙම ගොනුව යෙදුම් වලින්ද ප්‍රවේශ විය හැක. මේවා සම්පාදනය කළ යෙදුම් විය යුතු නැත - Python, Ruby සහ PHP scripts වලට පවා මෙම දත්ත වලට ප්‍රවේශය ඇත.

අපි උපාංගය සමඟ අවසන් වූ පසු, අපි එය ඉවත් කර මොඩියුලය බාමු:

Sudo rm /dev/lkm_example sudo rmmod lkm_example

නිගමනය

කර්නල් අවකාශයේ සෑම දෙයක්ම ඔබේ වගකීම බව මතක තබා ගන්න. ඔබගේ කේතය සඳහා සහාය හෝ දෙවන අවස්ථාවක් නොමැත. ඔබ සේවාලාභියෙකු සඳහා ව්‍යාපෘතියක් කරන්නේ නම්, දෙගුණයක්, ත්‍රිත්ව නොවේ නම්, නිදොස් කිරීමේ කාලය සැලසුම් කරන්න. කර්නල් කේතය එය ක්රියාත්මක වන පද්ධතිවල අඛණ්ඩතාව සහ විශ්වසනීයත්වය සහතික කිරීම සඳහා හැකි තරම් පරිපූර්ණ විය යුතුය.

මොඩියුලර් ක්‍රමලේඛනයේ සමහර විශේෂාංග සහ මොඩියුලර් ව්‍යුහයක උප වැඩසටහන් තැනීම සඳහා සාමාන්‍ය නිර්දේශ.

මොඩියුල USES ලෙස ප්‍රකාශ කරන අනුපිළිවෙලට ප්‍රධාන වැඩසටහනට සම්බන්ධ කර ඇති අතර එම අනුපිළිවෙලෙහිම වැඩසටහන ක්‍රියාත්මක කිරීම ආරම්භ කිරීමට පෙර ප්‍රධාන වැඩසටහනට සම්බන්ධ මොඩියුලවල ආරම්භක කොටස් වේ.

මොඩියුල ක්‍රියාත්මක කරන අනුපිළිවෙල පුස්තකාල දත්ත ප්‍රවේශයට සහ සාමාන්‍ය ප්‍රවේශයට බලපෑ හැකිය.

උදාහරණයක් ලෙස, M1, M2 යන නම් සහිත මොඩියුලවල එකම වර්ගයේ A, විචල්‍ය B සහ subroutine C අඩංගු වේ නම්, මෙම USES ආකෘති සම්බන්ධ කිරීමෙන් පසු, මෙම PU හි A, B, C වෙත ලැබෙන ඇමතුම් M2 මොඩියුලයට වස්තූන් වෙත කෙරෙන ඇමතුම් වලට සමාන වේ. .

නමුත් විවිධ සම්බන්ධිත මොඩියුල වලින් එකම නමේ අවශ්‍ය වස්තූන් වෙත ඇමතුම් වල නිවැරදි බව සංලක්ෂිත කිරීම සඳහා, මොඩියුලයකට ප්‍රවේශ වන විට පළමුව මොඩියුලයේ නම සඳහන් කිරීම සුදුසුය, ඉන්පසු වස්තුවේ නම තිතකින්: M1. A M1.B M1.C M2.B.

නිසැකවම, විශාල වැඩසටහනක් කොටස් දෙකකට (PU) බෙදීම ඉතා පහසුය, i.e. ප්රධාන වැඩසටහන + මොඩියුල.

සෑම PU එකක්ම එහි මතක කොටසෙහි සහ එහිම තැටි ගොනුවෙහි තැබීම.

සියලුම වර්ගවල ප්‍රකාශයන් මෙන්ම තනි පුද්ගල PU (ප්‍රධාන වැඩසටහන සහ අනාගත මොඩියුල) සඳහා ලබා ගත යුතු එම විචල්‍යයන් හිස් ක්‍රියාත්මක කළ හැකි කොටසක් සහිත වෙනම මොඩියුලයක තැබිය යුතුය. කෙසේ වෙතත්, සමහර PE (උදාහරණයක් ලෙස, මොඩියුලයක්) මෙම සියලු ප්රකාශයන් භාවිතා නොකරන බව ඔබ අවධානය යොමු නොකළ යුතුය. එවැනි මොඩියුලයක ආරම්භක කොටසෙහි ගොනු විචල්‍යයන් සම්මත නොවන පෙළ ගොනු (ASSIGN) සමඟ සම්බන්ධ කරන සහ මෙම ගොනු ආරම්භ කරන ප්‍රකාශ ඇතුළත් විය හැක, i.e. ඔවුන් සඳහා දත්ත හුවමාරු ඇමතුම් (නැවත සැකසීම සහ නැවත ලියන්න).

අනෙකුත් උපසිරැසිවල පළමු කණ්ඩායම, උදාහරණයක් ලෙස, සංයුක්ත ශ්‍රිත කිහිපයක් මොඩියුල 3 හි (අනෙක් අතට), අනෙක් ඒවා, උදාහරණයක් ලෙස, සාමාන්‍ය කාර්ය පටිපාටි - මොඩියුලය 4, ආදියෙහි තැබිය යුතුය.

සංකීර්ණ ව්‍යාපෘතියක මොඩියුලවලට උපසිරැසි බෙදා හැරීමේදී, ඔවුන්ගේ ලිවීමේ අනුපිළිවෙල සහ ස්ථානය කෙරෙහි විශේෂ අවධානයක් යොමු කළ යුතුය.

TP පරිසරයේ මොඩියුල සම්පාදනය කිරීමේ විවිධ ක්‍රම පාලනය කරන මෙවලම් අඩංගු වේ.

Alt+F9 RUN Cntr+F9 සම්පාදනය කරන්න

ගමනාන්ත මතකය

මෙම මාතයන් වෙනස් වන්නේ සන්නිවේදන ක්‍රමයේ සහ ප්‍රධාන වැඩසටහනේ පමණි.

සම්පාදක මාදිලිය

දැනට සක්‍රිය සංස්කාරක කවුළුවේ ඇති ප්‍රධාන වැඩසටහන හෝ මොඩියුලය සම්පාදනය කරයි. මෙම PU හි සම්මත නොවන පරිශීලක මොඩියුල වෙත ප්‍රවේශය තිබේ නම්, මෙම ප්‍රකාරයට එවැනි එක් එක් ප්ලග් ඉන් මොඩියුලය සඳහා ___.tpu දිගුව සමඟ එකම නමේ තැටි ගොනු තිබීම අවශ්‍ය වේ.

ගමනාන්තය මතකයේ ගබඩා කර ඇත්නම්, මෙම ගොනු මතකයේ පමණක් පවතින අතර තැටි ගොනුවක් නිර්මාණය නොවේ.

කෙසේ වෙතත්, ගමනාන්ත විකල්පය සඳහා තැටි සැකසීම අවශ්‍ය නොවන වෙනත් මාතයන් භාවිතා කරමින් සම්පූර්ණ වැඩසටහනේ සම්පාදකය සමඟ එක්ව tpu ගොනු නිර්මාණය කිරීම වඩාත් පහසු වේ.

මාදිලිය සාදන්න

මෙම මාදිලියේ සම්පාදනය කරන විට, එක් එක් මොඩියුලය සඳහා පහත සඳහන් දේ පළමුව (ප්‍රධාන වැඩසටහන සම්පාදනය කිරීමට පෙර) පරීක්ෂා කරනු ලැබේ:

1) තැටි tpu ගොනුවක පැවැත්ම; එය නොපවතියි නම්, මොඩියුලයේ ප්‍රභව කේතය සම්පාදනය කිරීමෙන් එය ස්වයංක්‍රීයව නිර්මාණය වේ, i.e. එහි pas ගොනුව

2) වෙනස් කිරීම් සිදු කළ හැකි වූ මොඩියුලයේ මූලාශ්‍ර පෙළ වෙත සොයාගත් tpu ගොනුවේ ලිපි හුවමාරුව; එසේ නොමැතිනම් tpu ගොනුව ස්වයංක්‍රීයව නැවත සාදනු ලැබේ

3) මොඩියුලයේ අතුරුමුහුණත් කොටසෙහි වෙනස් නොවන බව: එය වෙනස් වී ඇත්නම්, USES වගන්තියේ මෙම මොඩියුලය දක්වා ඇති සියලුම මොඩියුල (ඒවායේ මූලාශ්‍ර pas-ගොනු) ද නැවත සම්පාදනය කෙරේ.

මොඩියුලවල ප්‍රභව කේතවල වෙනසක් නොතිබුනේ නම්, සම්පාදකය මෙම tpu ගොනු සමඟ අන්තර්ක්‍රියා කර සම්පාදන කාලය භාවිතා කරයි.

ගොඩනැගීමේ මාදිලිය

Make mode මෙන් නොව, එයට අවශ්‍යයෙන්ම source pas ගොනු තිබීම අවශ්‍ය වේ; එක් එක් මොඩියුලය සම්පාදනය කරයි (නැවත සම්පාදනය කරයි) එමඟින් pas ගොනු වල පෙළෙහි සියලුම වෙනස්කම් සැලකිල්ලට ගන්නා බව සහතික කරයි. මෙය සමස්තයක් ලෙස වැඩසටහනේ සම්පාදන කාලය වැඩි කරයි.

සම්පාදන ප්‍රකාරය මෙන් නොව, සක්‍රිය ගොනුව (හෝ වැඩසටහනේ කොටසක්) කුමක් වුවත්, ඕනෑම පාස් ගොනුවකින් (එය ප්‍රාථමික ගොනුව ලෙස හැඳින්වේ) මොඩියුලර් ව්‍යුහයක් සහිත වැඩසටහනක් සම්පාදනය කිරීම ආරම්භ කිරීමට Make and Build මාතයන් ඔබට ඉඩ සලසයි. සංස්කාරක කවුළුව. මෙය සිදු කිරීම සඳහා, සම්පාදනය කිරීමේ අයිතමයේ, ප්‍රාථමික ගොනු විකල්පය තෝරන්න, Enter ඔබා ප්‍රාථමික pas-ගොනුවේ නම ලියන්න, ඉන්පසු මෙම ගොනුවෙන් සම්පාදනය ආරම්භ වේ.

ප්‍රාථමික ගොනුව මේ ආකාරයෙන් සඳහන් කර නොමැති නම්, Make, Build සහ RUN මාදිලියේ සම්පාදනය කළ හැක්කේ ප්‍රධාන වැඩසටහන ක්‍රියාකාරී සංස්කාරක කවුළුවේ තිබේ නම් පමණි.

සටහන: අනාගතයේදී, මම Puppy සඳහා කර්නලය සහ මොඩියුල සම්පාදනය කිරීමට T2 පද්ධතිය භාවිතා කිරීමට අදහස් කරමි. T2 දැනට කර්නලය සහ බොහෝ අමතර මොඩියුල සම්පාදනය කිරීමට ස්ථාපනය කර ඇත, නමුත් Puppy හි දැනට භාවිතා වන අනුවාදය නොවේ. මම Puppy හි අනාගත අනුවාද වල සමමුහුර්ත කිරීමට අදහස් කරමි, එවිට T2 හි සම්පාදනය කර ඇති කර්නලය Puppy හි භාවිතා වනු ඇත. Puppy සහ T2 සම්බන්ධ වැඩිදුර තොරතුරු සඳහා http://www.puppyos.net/pfs/ බලන්න.

xxx යනු අනුවාද අංකය වන devx_xxx.sfs යන තනි ගොනුවක් එකතු කිරීමෙන් C/C++ සම්පාදක භාවිතා කිරීමට Puppy හට ඉතා සරල ක්‍රමයක් ඇත. උදාහරණයක් ලෙස, Puppy 2.12 සතුව devx_212.sfs නම් වූ අනුකූලතා සංවර්ධන ගොනුවක් ඇත. LiveCD මාදිලියේ ධාවනය වන විට, devx_xxx.sfs ගොනුව ඔබේ පුද්ගලික සැකසුම් ගොනුව pup_save.3fs ඇති ස්ථානයේම තබන්න, එය සාමාන්‍යයෙන් /mnt/home/ බහලුම තුළ පිහිටා ඇත. මෙය pup_save.3fs ගොනුවක් ඇති අනෙකුත් ස්ථාපන ක්‍රම සඳහාද අදාළ වේ. සම්පූර්ණ "විකල්ප 2" ස්ථාපනයක් සහිත දෘඪ තැටියක Puppy ස්ථාපනය කර ඇත්නම්, පුද්ගලික ගොනුවක් නොමැත, විවිධ වින්‍යාස විකල්ප සමඟ සම්පාදනය කිරීමට Puppy වෙබ් පිටු බලන්න, එබැවින් මොඩියුල නොගැලපේ. මෙම අනුවාද සඳහා ස්කොෂ්ෆ් සඳහා අවශ්‍ය වන්නේ එක් පැච් එකක් පමණි. Puppy 2.12 සතුව කර්නලය 2.6.18.1 ඇති අතර නිවැරදි කිරීම් තුනක් ඇත; squashfs, default console loglevel සහ shutdown fix.

කර්නලය පැච් කිරීමට මෙම විධාන ලබා දී ඇත්තේ ඔබේ ස්වයං අධ්‍යාපනය සඳහා පමණි, මන්ද පැච් කරන ලද කර්නලයක් දැනටමත් තිබේ...

ඔබ මුලින්ම කළ යුතු පළමු දෙය නම් කර්නලය බාගත කිරීමයි. සුදුසු බාගත කිරීමේ අඩවියකට සබැඳියක් සොයා ගැනීමට එය පිහිටා ඇත. මෙය kernel.org හෝ එහි දර්පණවල ඇති "පුරාණ" මූලාශ්‍රයක් විය යුතුය.

අන්තර්ජාලයට සම්බන්ධ වන්න, කර්නලය /usr/src ෆෝල්ඩරයට බාගන්න. ඉන්පසු එය ගලවන්න:

ඔබ මෙම ෆෝල්ඩරය දැකිය යුතුය: /usr/src/linux-2.6.16.7. එවිට ඔබට මෙම සබැඳිය කර්නලය වෙත යොමු වන බවට සහතික විය යුතුය:

Puppy සඳහා කර්නලය සම්පාදනය කිරීමේදී භාවිතා කරන එකම මූලාශ්‍රය ඔබ සතුව ඇති පරිදි පහත නිවැරදි කිරීම් යෙදිය යුතුය. එසේ නොමැතිනම්, ඔබ ධාවකය සම්පාදනය කරන විට ඔබට "නොවිසඳුණු සංකේත" දෝෂ පණිවිඩ ලැබෙනු ඇත, පසුව එය Puppy කර්නලය සමඟ භාවිතා කිරීමට උත්සාහ කරන්න. ස්කොෂ්ෆ්ස් සවි කිරීම යෙදීම

දෙවනුව, Squashfs පැච් එක යොදන්න. Squashfs පැච් එක Squashfs සඳහා සහය එක් කරයි ගොනු පද්ධතිය කියවීමට පමණි.

patch, squashfs2.1-patch-k2.6.9.gz, /usr/src ෆෝල්ඩරය වෙත බාගන්න. මෙම නිවැරදි කිරීම කර්නල් අනුවාදය 2.6.9 සඳහා සිදු කර ඇති නමුත්, linux-2.6.9 සඳහා සඳහනක් පවතින තාක් 2.6.11.x අනුවාදවල දිගටම ක්‍රියා කරන බව සලකන්න. ඉන්පසු, නිවැරදි කිරීම යොදන්න:

Cd/ usr/ src gunzip squashfs2.1-patch-k2.6.9.gz cd/ usr/ src/ linux-2.6.11.11

සටහන, p1 හි ඇත්තේ අංක 1 මිස එල් සංකේතය නොවේ... (විහිලුවක් - ආසන්න වශයෙන් පරිවර්තනය)

සූදානම්! කර්නලය සම්පාදනය කිරීමට සූදානම්!

කර්නලය සම්පාදනය කිරීම

ඔබ කර්නලය සඳහා වින්‍යාස ගොනුවක් ලබා ගත යුතුය. එහි පිටපතක් /lib/modules ෆෝල්ඩරයේ පිහිටා ඇත.

ඉන්පසු මෙම පියවර අනුගමනය කරන්න:

Cd/ usr/ src/ linux-2.6.18.1

.config ගොනුවක් තිබේ නම්, එය කොහේ හරි තාවකාලිකව පිටපත් කරන්න හෝ එය නැවත නම් කරන්න.

Puppy සඳහා .config ගොනුව /usr/src/linux-2.6.18.1 වෙත පිටපත් කරන්න... එයට /lib/modules හි විවිධ නම් ඇත, එබැවින් .config ලෙස නැවත නම් කරන්න... පහත පියවර .config ගොනුව කියවා උත්පාදනය කරන්න. අලුත් එකක්.

...ඔබට අවශ්‍ය ඕනෑම වෙනස් කිරීමක් කර ඒවා සුරකින්න. ඔබට දැන් නව .config ගොනුවක් ඇති අතර ඔබ එය සුරක්ෂිතව තබා ගැනීම සඳහා කොතැනක හෝ පිටපත් කළ යුතුය. පහත සටහන බලන්න

දැන් ඔබ කර්නලය සම්පාදනය කර ඇත.

නියමයි, ඔබ /usr/src/linux-2.6.18.1/arch/i386/boot/bzImage හි Linux කර්නලය සොයා ගනු ඇත.

මොඩියුල සම්පාදනය කිරීම

දැන් /lib/modules වෙත ගොස් දැනටමත් 2.6.18.1 නමින් ෆෝල්ඩරයක් තිබේ නම්, 2.6.18.1 ෆෝල්ඩරය 2.6.18.1-old ලෙස නැවත නම් කරන්න.

දැන් නව මොඩියුල ස්ථාපනය කරන්න:

Cd/ usr/ src/ linux-2.6.18.1 මොඩියුල සාදා modules_install කරන්න

...මෙයින් පසුව ඔබ /lib/modules/2.6.18.1 ෆෝල්ඩරය තුළ ස්ථාපනය කර ඇති නව මොඩියුල සොයා ගත යුතුය.

ඉහත අවසාන පියවර "depmod" වැඩසටහන ක්‍රියාත්මක කරන අතර සමහර මොඩියුල සඳහා අතුරුදහන් වූ සංකේත පිළිබඳ දෝෂ පණිවිඩ ලබා දිය හැකි බව සලකන්න. ඒ ගැන කරදර වෙන්න එපා - සංවර්ධකයින්ගෙන් එක්කෙනෙක් කෙලවෙලා, ඒ කියන්නේ අපිට ඒ මොඩියුලය පාවිච්චි කරන්න බෑ.

නව කර්නලය සහ මොඩියුල භාවිතා කරන්නේ කෙසේද

Puppy Unleshed ඉන්ස්ටෝල් කරලා තියෙනවා නම් හොඳයි. එවිට තාරබෝලය පුළුල් වන අතර නාමාවලි 2 ක් ඇත: "boot" සහ "kernels".

"Boot" හි ආරම්භක අතථ්‍ය තැටිය සෑදීම සඳහා ගොනු ව්‍යුහය සහ ස්ක්‍රිප්ට් අඩංගු වේ. ඔබට එහි කර්නල් මොඩියුල කිහිපයක් තැබිය යුතුය.

"කර්නල්" ඩිරෙක්ටරියේ ඩිරෙක්ටරි කර්නල්/2.6.18.1/ ඇති අතර, ඔබට මොඩියුල ඔබේ යාවත්කාලීන කළ ඒවා සමඟ ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය වනු ඇත. ඔබ එකම කර්නල් අනුවාදය (2.6.18.1) නැවත සම්පාදනය කළේ නම් ඔබට එය ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය නැත.

කර්නල්/2.6.18.1 හි "System.map" නමින් ගොනුවක් ඇති බව සලකන්න. ඔබ එය නැවත නම් කර /usr/src/linux-2.6.18.1 වෙතින් නව එකක් සමඟ ප්‍රතිස්ථාපනය කළ යුතුය. කර්නල්/2.6.18.1/ ෆෝල්ඩරය පිරික්සන්න, යාවත්කාලීන කළ යුතු දේ ඔබ දැනගත යුතුය.

ඔබ සම්පූර්ණ Puppy ස්ථාපනයකින් කර්නලය සම්පාදනය කළේ නම්, ඔබට නව කර්නලය භාවිතයෙන් නැවත ආරම්භ කළ හැක. make modules_install යනු /lib/modules/2.6.18.1 හි නව මොඩියුල ස්ථාපනය කිරීමට ඉහත පියවර වේ, නමුත් ඔබ නව කර්නලයක් ද ස්ථාපනය කළ යුතුය. මම Grub සමඟ ආරම්භ කරමි, සහ නව කර්නලය /boot බහලුම වෙත පිටපත් කරන්න (සහ ගොනුව bzImage සිට vmlinuz ලෙස නැවත නම් කරන්න).

menuconfig සම්බන්ධයෙන් සටහන. මම එය වසර ගණනාවක් තිස්සේ භාවිතා කර ඇත, එබැවින් සමහර දේවල් සුළු කොට සලකන්න, කෙසේ වෙතත් නවකයෙකුට වැඩසටහනෙන් ඉවත් වීමට අවශ්‍ය වීම ව්‍යාකූල විය හැකිය. වින්‍යාසය සුරැකීමට ඉහළ මට්ටමේ මෙනුවේ මෙනුවක් ඇත - එය නොසලකා හරින්න. පිටවීමේ "බොත්තම" උද්දීපනය කිරීමට TAB යතුර (හෝ දකුණු ඊතල යතුර) ඔබන්න සහ ENTER යතුර ඔබන්න. එවිට ඔබට නව වින්‍යාසය සුරැකීමට අවශ්‍ය දැයි අසනු ලබන අතර ඔබේ පිළිතුර ඔව් විය යුතුය.