ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ನ ರಚನೆ ಮತ್ತು ಅದರ ಸಂಕಲನ ವಿಧಾನಗಳು. ಮಾಡ್ಯುಲರ್ ರಚನೆಯೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ವೈಶಿಷ್ಟ್ಯಗಳು. ಪರಿಚಯ ಮತ್ತು ಹಿನ್ನೆಲೆ

ಅಂತಹ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು, ನೀವು ಈ ಕೆಳಗಿನ Makefile ಅನ್ನು ಬಳಸಬಹುದು. $(CC) ... ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಸಾಲಿನ ಮೊದಲು ಟ್ಯಾಬ್ ಅಕ್ಷರವನ್ನು ಹಾಕಲು ಮರೆಯಬೇಡಿ.

ರೂಬಿನಿ ಮತ್ತು ಕಾರ್ಬೆಟ್ ಪ್ರಸ್ತಾಪಿಸಿದ ಮೂಲ ಹಲೋ ವರ್ಲ್ಡ್ ಕೋಡ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಇದು ಎರಡು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಮಾಡ್ಯೂಲ್ ಕರ್ನಲ್ ಆವೃತ್ತಿಯಂತೆಯೇ ಅದೇ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ PARAM ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ. ಎರಡನೆಯದಾಗಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಈಗ GPL ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿ ನೀಡಲಾಗುತ್ತದೆ (MODULE_LICENSE() ಮ್ಯಾಕ್ರೋ ಬಳಸಿ). ಇದನ್ನು ಮಾಡದಿದ್ದರೆ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕರ್ನಲ್‌ಗೆ ಸ್ಥಾಪಿಸುವಾಗ ನೀವು ಈ ಕೆಳಗಿನ ಎಚ್ಚರಿಕೆಯಂತಹದನ್ನು ನೋಡಬಹುದು:

# insmod hello_knz.o ಎಚ್ಚರಿಕೆ: hello_knz.o ಅನ್ನು ಲೋಡ್ ಮಾಡುವುದರಿಂದ ಕರ್ನಲ್ ಅನ್ನು ಕಳಂಕಗೊಳಿಸುತ್ತದೆ: ಯಾವುದೇ ಪರವಾನಗಿಯನ್ನು ನೋಡಿ http://www.tux.org/lkml/#export-tainted ಮಾಡ್ಯೂಲ್ ಬಗ್ಗೆ ಮಾಹಿತಿಗಾಗಿ http://www.tux.org/lkml/#export-tainted ಮಾಡ್ಯೂಲ್ hello_knz ಲೋಡ್ ಮಾಡಲಾಗಿದೆ, ಎಚ್ಚರಿಕೆಗಳೊಂದಿಗೆ

ಮಾಡ್ಯೂಲ್ ಸಂಕಲನ ಆಯ್ಕೆಗಳನ್ನು ಈಗ ವಿವರಿಸೋಣ (ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ನಂತರ ವಿವರಿಸಲಾಗುವುದು):

- ಜೊತೆ- ಈ ಆಯ್ಕೆಯೊಂದಿಗೆ, ಜಿಸಿಸಿ ಕಂಪೈಲರ್ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಬೈನರಿಯನ್ನು ರಚಿಸಲು ಪ್ರಯತ್ನಿಸದೆಯೇ, ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದ ತಕ್ಷಣ ಫೈಲ್ ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.

-ಗೋಡೆ- gcc ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಗರಿಷ್ಠ ಎಚ್ಚರಿಕೆಯ ಮಟ್ಟ.

-ಡಿ- ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಗಳ ವ್ಯಾಖ್ಯಾನಗಳು. ಕಂಪೈಲ್ ಮಾಡಿದ ಫೈಲ್‌ನಲ್ಲಿನ #ಡಿಫೈನ್ ಡೈರೆಕ್ಟಿವ್‌ನಂತೆಯೇ. ಈ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಬಳಸಲಾದ ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಗಳನ್ನು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಎಂಬುದರಲ್ಲಿ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ, ಮೂಲ ಫೈಲ್‌ನಲ್ಲಿ #ಡಿಫೈನ್ ಅನ್ನು ಬಳಸಿ ಅಥವಾ ಕಂಪೈಲರ್‌ಗಾಗಿ -D ಆಯ್ಕೆಯನ್ನು ಬಳಸಿ.

-ಐ- ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಹೆಚ್ಚುವರಿ ಹುಡುಕಾಟ ಮಾರ್ಗಗಳು. "uname -r" ಪರ್ಯಾಯದ ಬಳಕೆಯನ್ನು ಗಮನಿಸಿ, ಇದು ಪ್ರಸ್ತುತ ಬಳಕೆಯಲ್ಲಿರುವ ಕರ್ನಲ್ ಆವೃತ್ತಿಯ ನಿಖರವಾದ ಹೆಸರನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಮುಂದಿನ ವಿಭಾಗವು ಮಾಡ್ಯೂಲ್‌ನ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದನ್ನು ಹೇಗೆ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವುದು ಮತ್ತು ಅದನ್ನು ಕರ್ನಲ್‌ನಿಂದ ಅನ್‌ಲೋಡ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಸಹ ಇದು ವಿವರವಾಗಿ ವಿವರಿಸುತ್ತದೆ.

ಮೂಲ ಹಲೋ ವರ್ಲ್ಡ್!

ಈಗ ರೂಬಿನಿ ಮತ್ತು ಕಾರ್ಬೆಟ್ ನೀಡುವ ಸರಳ "ಹಲೋ, ವರ್ಲ್ಡ್" ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ ಮೂಲ ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ. ಈ ಕೋಡ್ ಅನ್ನು ಕರ್ನಲ್ ಆವೃತ್ತಿಗಳು 2.0 ರಿಂದ 2.4 ರ ಅಡಿಯಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡಬಹುದು. ಈ ಉದಾಹರಣೆ ಮತ್ತು ಪುಸ್ತಕದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ ಎಲ್ಲಾ ಇತರವುಗಳು O'Reilly FTP ಸೈಟ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ (ಅಧ್ಯಾಯ 1 ನೋಡಿ).

//file hello.c #ಮಾಡ್ಯುಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ #ಸೇರಿಸು int init_module(ಶೂನ್ಯ) ( printk("<1>ಹಲೋ, ವರ್ಲ್ಡ್\n"); 0; ಹಿಂತಿರುಗಿ<1>ವಿದಾಯ ಕ್ರೂರ ಜಗತ್ತು\n"); )

ಕಾರ್ಯ printk()ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿ ಕಾರ್ಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ printf()ಸಿ ಭಾಷೆಯಲ್ಲಿ. ಕರ್ನಲ್‌ಗೆ ತನ್ನದೇ ಆದ, ಮೇಲಾಗಿ ಚಿಕ್ಕದಾದ, ನಿರ್ಣಯ ಕಾರ್ಯದ ಅಗತ್ಯವಿದೆ, ಇದು ನೇರವಾಗಿ ಕರ್ನಲ್‌ನಲ್ಲಿದೆ ಮತ್ತು ಬಳಕೆದಾರ-ಮಟ್ಟದ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಅಲ್ಲ. ಮಾಡ್ಯೂಲ್ ಒಂದು ಕಾರ್ಯವನ್ನು ಕರೆಯಬಹುದು printk()ಏಕೆಂದರೆ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿದ ನಂತರ insmodಮಾಡ್ಯೂಲ್ ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಮತ್ತು ಪ್ರಕಟಿತ (ರಫ್ತು ಮಾಡಲಾದ) ಕರ್ನಲ್ ಕಾರ್ಯಗಳು ಮತ್ತು ವೇರಿಯೇಬಲ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ.

ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾರಾಮೀಟರ್ "<1>” ಪ್ರಿಂಟ್‌ಕೆ() ಫಂಕ್ಷನ್‌ಗೆ ರವಾನಿಸಿರುವುದು ಸಂದೇಶದ ಆದ್ಯತೆಯಾಗಿದೆ. ಮೂಲ ಇಂಗ್ಲಿಷ್ ಮೂಲಗಳು ಲಾಗ್‌ಲೆವೆಲ್ ಎಂಬ ಪದವನ್ನು ಬಳಸುತ್ತವೆ, ಅಂದರೆ ಸಂದೇಶ ಲಾಗಿಂಗ್ ಮಟ್ಟ. ಇಲ್ಲಿ, ನಾವು ಮೂಲ "ಲಾಗ್‌ಲೆವೆಲ್" ಬದಲಿಗೆ ಆದ್ಯತೆಯ ಪದವನ್ನು ಬಳಸುತ್ತೇವೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಕಡಿಮೆ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುವ ಸಂದೇಶಕ್ಕೆ ನಾವು ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಹೆಚ್ಚಿನ ಸಂದೇಶದ ಆದ್ಯತೆಯನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ, ಏಕೆಂದರೆ ಡೀಫಾಲ್ಟ್ ಆದ್ಯತೆಯೊಂದಿಗೆ ಸಂದೇಶವನ್ನು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುವುದಿಲ್ಲ. ಡೀಫಾಲ್ಟ್ ಆದ್ಯತೆಯೊಂದಿಗೆ ಕರ್ನಲ್ ಸಂದೇಶಗಳ ಔಟ್‌ಪುಟ್ ನಿರ್ದೇಶನವು ಚಾಲನೆಯಲ್ಲಿರುವ ಕರ್ನಲ್‌ನ ಆವೃತ್ತಿಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಡೀಮನ್‌ನ ಆವೃತ್ತಿ klogd, ಮತ್ತು ನಿಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್. ಹೆಚ್ಚು ವಿವರವಾಗಿ, ಕಾರ್ಯದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ printk()ನಾವು ಅಧ್ಯಾಯ 4, ಡೀಬಗ್ ಮಾಡುವ ತಂತ್ರಗಳಲ್ಲಿ ವಿವರಿಸುತ್ತೇವೆ.

ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು insmodಕರ್ನಲ್ ಮತ್ತು ಆಜ್ಞೆಗಳಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು rmmodಕರ್ನಲ್‌ನಿಂದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು. ಇದನ್ನು ಹೇಗೆ ಮಾಡಬಹುದೆಂದು ನಾವು ಕೆಳಗೆ ತೋರಿಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕರ್ನಲ್‌ಗೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದಾಗ ಪ್ರವೇಶ ಬಿಂದು init_module() ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕರ್ನಲ್‌ನಿಂದ ತೆಗೆದುಹಾಕಿದಾಗ cleanup_module() ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸವಲತ್ತು ಪಡೆದ ಬಳಕೆದಾರರು ಮಾತ್ರ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮತ್ತು ಅನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

ಮೇಲಿನ ಮಾಡ್ಯೂಲ್ ಉದಾಹರಣೆಯನ್ನು "ಮಾಡ್ಯೂಲ್ ಆವೃತ್ತಿ ಬೆಂಬಲ" ಫ್ಲ್ಯಾಗ್ ಆಫ್ ಮಾಡುವುದರೊಂದಿಗೆ ನಿರ್ಮಿಸಲಾದ ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಬಳಸಬಹುದಾಗಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಹೆಚ್ಚಿನ ವಿತರಣೆಗಳು ಆವೃತ್ತಿ-ನಿಯಂತ್ರಿತ ಕರ್ನಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ (ಇದನ್ನು ಅಧ್ಯಾಯ 11 ರ "ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ" ವಿಭಾಗದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗಿದೆ, "kmod ಮತ್ತು ಸುಧಾರಿತ ಮಾಡ್ಯುಲರೈಸೇಶನ್"). ಮತ್ತು ಪ್ಯಾಕೇಜ್‌ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳು ಮಾಡ್ಯೂಟಿಲ್ಸ್ಅಂತಹ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆವೃತ್ತಿ-ನಿಯಂತ್ರಿತ ಕರ್ನಲ್‌ಗಳಿಗೆ ಲೋಡ್ ಮಾಡಲು ಅನುಮತಿಸಿ, ಅದು ಇನ್ನು ಮುಂದೆ ಸಾಧ್ಯವಿಲ್ಲ. ಮಾಡ್ಯೂಟಿಲ್ಸ್ ಪ್ಯಾಕೇಜ್ insmod ಮತ್ತು rmmod ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರೋಗ್ರಾಂಗಳ ಗುಂಪನ್ನು ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ.

ಕಾರ್ಯ: ನಿಮ್ಮ ವಿತರಣೆಯಿಂದ ಮಾಡ್ಯೂಟಿಲ್ಸ್ ಪ್ಯಾಕೇಜ್‌ನ ಆವೃತ್ತಿ ಸಂಖ್ಯೆ ಮತ್ತು ಸಂಯೋಜನೆಯನ್ನು ನಿರ್ಧರಿಸಿ.

ಆವೃತ್ತಿ ನಿಯಂತ್ರಣವನ್ನು ಬೆಂಬಲಿಸುವ ಕರ್ನಲ್‌ಗೆ ಅಂತಹ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸೇರಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿದಾಗ, ನೀವು ಈ ಕೆಳಗಿನ ರೀತಿಯ ದೋಷ ಸಂದೇಶವನ್ನು ನೋಡಬಹುದು:

# insmod hello.o hello.o: ಕರ್ನಲ್-ಮಾಡ್ಯೂಲ್ ಆವೃತ್ತಿ ಹೊಂದಿಕೆಯಾಗದ hello.o ಅನ್ನು ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.4.20 ಗಾಗಿ ಸಂಕಲಿಸಲಾಗಿದೆ ಆದರೆ ಈ ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.4.20-9asp ಆಗಿದೆ.

ಕ್ಯಾಟಲಾಗ್‌ನಲ್ಲಿ ಇತರೆ ಮಾಡ್ಯೂಲ್‌ಗಳು ftp.oreilly.com ನಿಂದ ಉದಾಹರಣೆಗಳು ನೀವು ಮೂಲ ಉದಾಹರಣೆ ಪ್ರೋಗ್ರಾಂ hello.c ಅನ್ನು ಕಾಣಬಹುದು, ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಆವೃತ್ತಿ-ನಿಯಂತ್ರಿತ ಮತ್ತು ಆವೃತ್ತಿಯಿಲ್ಲದ ಕರ್ನಲ್‌ಗಳಲ್ಲಿ ಸ್ಥಾಪಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ಬೆಂಬಲವಿಲ್ಲದೆಯೇ ನಿಮ್ಮ ಸ್ವಂತ ಕರ್ನಲ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಬಲವಾಗಿ ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, www.kernel.org ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಮೂಲ ಕರ್ನಲ್ ಮೂಲಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ

ನೀವು ಕರ್ನಲ್‌ಗಳನ್ನು ಜೋಡಿಸಲು ಹೊಸಬರಾಗಿದ್ದರೆ, http://www.linux.it/kerneldocs/kconf ನಲ್ಲಿ ಅಲೆಸ್ಸಾಂಡ್ರೊ ರೂಬಿನಿ (ಮೂಲ ಪುಸ್ತಕದ ಲೇಖಕರಲ್ಲಿ ಒಬ್ಬರು) ಪೋಸ್ಟ್ ಮಾಡಿದ ಲೇಖನವನ್ನು ಓದಲು ಪ್ರಯತ್ನಿಸಿ, ಅದು ನಿಮಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಮೇಲಿನ ಮೂಲ ಉದಾಹರಣೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಪಠ್ಯ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಿ.

ರೂಟ್# gcc -c hello.c root# insmod ./hello.o ಹಲೋ, ವರ್ಲ್ಡ್ ರೂಟ್# rmmod ಹಲೋ ಗುಡ್‌ಬೈ ಕ್ರೂರ ವರ್ಲ್ಡ್ ರೂಟ್#

ಸಂದೇಶದ ತಂತಿಗಳನ್ನು ರವಾನಿಸಲು ನಿಮ್ಮ ಸಿಸ್ಟಮ್ ಬಳಸುವ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅವಲಂಬಿಸಿ, ಕಾರ್ಯದಿಂದ ಕಳುಹಿಸಲಾದ ಸಂದೇಶಗಳ ಔಟ್‌ಪುಟ್ ದಿಕ್ಕು printk(), ಭಿನ್ನವಾಗಿರಬಹುದು. ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮತ್ತು ಪರೀಕ್ಷಿಸುವ ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, printk() ಫಂಕ್ಷನ್‌ನಿಂದ ಕಳುಹಿಸಲಾದ ಸಂದೇಶಗಳು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಆಜ್ಞೆಗಳನ್ನು ನೀಡಿದ ಅದೇ ಕನ್ಸೋಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಆಗಿವೆ. ಈ ಉದಾಹರಣೆಯನ್ನು ಪಠ್ಯ ಕನ್ಸೋಲ್‌ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ. ನೀವು ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ insmodಮತ್ತು rmmodಕಾರ್ಯಕ್ರಮದ ಅಡಿಯಲ್ಲಿ xterm, ನಂತರ ಹೆಚ್ಚಾಗಿ ನೀವು ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಏನನ್ನೂ ನೋಡುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಸಂದೇಶವು ಸಿಸ್ಟಮ್ ಲಾಗ್‌ಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ ಕೊನೆಗೊಳ್ಳಬಹುದು, ಉದಾಹರಣೆಗೆ ಇನ್ /var/log/messages.ಫೈಲ್‌ನ ನಿಖರವಾದ ಹೆಸರು ವಿತರಣೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಲಾಗ್ ಫೈಲ್‌ಗಳಲ್ಲಿನ ಬದಲಾವಣೆಗಳ ಸಮಯವನ್ನು ನೋಡಿ. printk() ಫಂಕ್ಷನ್‌ನಿಂದ ಸಂದೇಶಗಳನ್ನು ರವಾನಿಸಲು ಬಳಸುವ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅಧ್ಯಾಯ 4 "ತಂತ್ರಗಳು" ನಲ್ಲಿ "ಸಂದೇಶಗಳು ಹೇಗೆ ಲಾಗ್ ಆಗುತ್ತವೆ" ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ
ಡೀಬಗ್ ಮಾಡುವಿಕೆ".

ಸಿಸ್ಟಮ್ ಲಾಗ್ ಫೈಲ್ /val/log/messages ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಸಂದೇಶಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಇದು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ ಸಿಸ್ಟಮ್ ಉಪಯುಕ್ತತೆಟೈಲ್, ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಅದಕ್ಕೆ ರವಾನಿಸಲಾದ ಫೈಲ್‌ನ ಕೊನೆಯ 10 ಸಾಲುಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಈ ಉಪಯುಕ್ತತೆಯ ಆಸಕ್ತಿದಾಯಕ ಆಯ್ಕೆ -f ಆಯ್ಕೆಯಾಗಿದೆ, ಇದು ಫೈಲ್‌ನ ಕೊನೆಯ ಸಾಲುಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಕ್ರಮದಲ್ಲಿ ಉಪಯುಕ್ತತೆಯನ್ನು ರನ್ ಮಾಡುತ್ತದೆ, ಅಂದರೆ. ಫೈಲ್‌ನಲ್ಲಿ ಹೊಸ ಸಾಲುಗಳು ಕಾಣಿಸಿಕೊಂಡಾಗ, ಅವುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಆಜ್ಞೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸಲು, ನೀವು Ctrl + C ಅನ್ನು ಒತ್ತಬೇಕು. ಹೀಗಾಗಿ, ಸಿಸ್ಟಮ್ ಲಾಗ್ ಫೈಲ್‌ನ ಕೊನೆಯ ಹತ್ತು ಸಾಲುಗಳನ್ನು ವೀಕ್ಷಿಸಲು, ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನಮೂದಿಸಿ:

ರೂಟ್# ಟೈಲ್ /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. ಮಾಡ್ಯೂಲ್ ಮತ್ತು ಕರ್ನಲ್ ನಡುವಿನ ಸಂವಹನ

ಯುನಿಕ್ಸ್/ಲಿನಕ್ಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳೊಂದಿಗೆ ಲಿಂಕ್ ಮಾಡಬಹುದಾದ ಲೈಬ್ರರಿಗಳ ಕೊರತೆ. ನಿಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿರುವಂತೆ, ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡಿದಾಗ, ಕರ್ನಲ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗೆ ಹೊರಗಿನ ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಕರ್ನಲ್ ಹೆಡರ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಘೋಷಿಸಬೇಕು ಮತ್ತು ಕರ್ನಲ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಬೇಕು. ಮಾಡ್ಯೂಲ್ ಮೂಲಗಳು ಎಂದಿಗೂಬಳಕೆದಾರ ಸ್ಪೇಸ್ ಲೈಬ್ರರಿಗಳಿಂದ ನಿಯಮಿತ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಾರದು. ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ ಕರ್ನಲ್‌ನ ಭಾಗವಾಗಿರುವ ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು.

ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿರುವ ಹೆಡರ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಸಂಪೂರ್ಣ ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿವರಿಸಲಾಗಿದೆ ಸೇರಿವೆ/ಲಿನಕ್ಸ್ಮತ್ತು ಸೇರಿವೆ/asmಕರ್ನಲ್ ಮೂಲಗಳ ಒಳಗೆ (ಸಾಮಾನ್ಯವಾಗಿ ಇದೆ /usr/src/linux-x.y.z(x.y.z ನಿಮ್ಮ ಕರ್ನಲ್ ಆವೃತ್ತಿಯಾಗಿದೆ)). ಹಳೆಯ ವಿತರಣೆಗಳು (ಆಧಾರಿತ libcಆವೃತ್ತಿ 5 ಅಥವಾ ಕಡಿಮೆ) ಸಾಂಕೇತಿಕ ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗಿದೆ /usr/include/linuxಮತ್ತು /usr/include/asmಕರ್ನಲ್ ಮೂಲಗಳಲ್ಲಿನ ಅನುಗುಣವಾದ ಡೈರೆಕ್ಟರಿಗಳಿಗೆ. ಈ ಸಾಂಕೇತಿಕ ಲಿಂಕ್‌ಗಳು ಅಗತ್ಯವಿದ್ದರೆ, ಬಳಕೆದಾರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಕರ್ನಲ್ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.

ಯೂಸರ್-ಸ್ಪೇಸ್ ಲೈಬ್ರರಿಗಳ ಇಂಟರ್ಫೇಸ್ ಈಗ ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್‌ನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿದ್ದರೂ ಸಹ, ಕೆಲವೊಮ್ಮೆ ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಗಳು ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕರ್ನಲ್ ಹೆಡರ್ ಫೈಲ್‌ಗಳಲ್ಲಿನ ಅನೇಕ ಉಲ್ಲೇಖಗಳು ಕರ್ನಲ್ ಅನ್ನು ಮಾತ್ರ ಉಲ್ಲೇಖಿಸುತ್ತವೆ ಮತ್ತು ಬಳಕೆದಾರರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಪ್ರವೇಶಿಸಬಾರದು. ಆದ್ದರಿಂದ, ಈ ಜಾಹೀರಾತುಗಳನ್ನು ರಕ್ಷಿಸಲಾಗಿದೆ #ifdef __KERNEL__ಬ್ಲಾಕ್ಗಳನ್ನು. ಇದಕ್ಕಾಗಿಯೇ ನಿಮ್ಮ ಚಾಲಕ, ಇತರ ಕರ್ನಲ್ ಕೋಡ್‌ನಂತೆ, ಮ್ಯಾಕ್ರೋ ಡಿಕ್ಲೇರ್ಡ್‌ನೊಂದಿಗೆ ಕಂಪೈಲ್ ಮಾಡಬೇಕು __ಕರ್ನಲ್__.

ಪ್ರತ್ಯೇಕ ಕರ್ನಲ್ ಹೆಡರ್ ಫೈಲ್‌ಗಳ ಪಾತ್ರವನ್ನು ಪುಸ್ತಕದ ಉದ್ದಕ್ಕೂ ಸೂಕ್ತವಾಗಿ ಚರ್ಚಿಸಲಾಗುವುದು.

ಯಾವುದೇ ದೊಡ್ಡ ಸಾಫ್ಟ್‌ವೇರ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ (ಕರ್ನಲ್‌ನಂತಹ) ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳು ತಿಳಿದಿರಬೇಕು ಮತ್ತು ತಪ್ಪಿಸಬೇಕು "ಹೆಸರಿನ ಮಾಲಿನ್ಯ". ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಕಾರ್ಯಗಳು ಮತ್ತು ಜಾಗತಿಕ ವೇರಿಯಬಲ್‌ಗಳಿರುವಾಗ ಈ ಸಮಸ್ಯೆಯು ಸಂಭವಿಸುತ್ತದೆ, ಅವರ ಹೆಸರುಗಳು ಸಾಕಷ್ಟು ಅಭಿವ್ಯಕ್ತವಾಗಿಲ್ಲ (ಡಿಸ್ಟಿಂಗ್ ಮಾಡಬಹುದಾದ). ನಂತರ ಅಂತಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸಬೇಕಾದ ಪ್ರೋಗ್ರಾಮರ್ "ಕಾಯ್ದಿರಿಸಿದ" ಹೆಸರುಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಮತ್ತು ಹೊಸ ಅಂಶಗಳಿಗೆ ಅನನ್ಯ ಹೆಸರುಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಸಮಯವನ್ನು ಕಳೆಯಲು ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ. ಹೆಸರು ಘರ್ಷಣೆಗಳು (ದ್ವಂದ್ವಾರ್ಥತೆಗಳು) ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ದೋಷಗಳಿಂದ ಹಿಡಿದು ವಿಭಿನ್ನ ಸಂರಚನೆಯಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಕರ್ನಲ್ ಅನ್ನು ಬಳಸುವ ಬಳಕೆದಾರರಿಗೆ ಸಂಭವಿಸಬಹುದಾದ ಅಸ್ಥಿರ ಅಥವಾ ವಿವರಿಸಲಾಗದ ಪ್ರೋಗ್ರಾಂ ವರ್ತನೆಯವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ರಚಿಸಬಹುದು.

ಕರ್ನಲ್ ಕೋಡ್ ಬರೆಯುವಾಗ ಡೆವಲಪರ್‌ಗಳು ಅಂತಹ ತಪ್ಪುಗಳನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಚಿಕ್ಕ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸಹ ಸಂಪೂರ್ಣ ಕರ್ನಲ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತದೆ. ಹೆಸರು ಘರ್ಷಣೆಯನ್ನು ತಪ್ಪಿಸಲು ಉತ್ತಮ ಪರಿಹಾರವೆಂದರೆ ಮೊದಲು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವಸ್ತುಗಳನ್ನು ಎಂದು ಘೋಷಿಸುವುದು ಸ್ಥಿರ, ಮತ್ತು, ಎರಡನೆಯದಾಗಿ, ಜಾಗತಿಕ ವಸ್ತುಗಳನ್ನು ಹೆಸರಿಸಲು ಸಿಸ್ಟಮ್‌ನೊಳಗೆ ವಿಶಿಷ್ಟವಾದ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸುವುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮಾಡ್ಯೂಲ್ ಡೆವಲಪರ್ ಆಗಿ, "ಕರ್ನಲ್ ಲಿಂಕ್ ಟೇಬಲ್" ವಿಭಾಗದಲ್ಲಿ ನಂತರ ವಿವರಿಸಿದಂತೆ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿರುವ ವಸ್ತುಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ನೀವು ನಿಯಂತ್ರಿಸಬಹುದು.

ಆಜ್ಞೆಯ ಹೆಚ್ಚಿನ (ಆದರೆ ಎಲ್ಲಾ ಅಲ್ಲ) ಆವೃತ್ತಿಗಳು insmodಎಂದು ಘೋಷಿಸದ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್ ವಸ್ತುಗಳನ್ನು ರಫ್ತು ಮಾಡಿ ಸ್ಥಿರ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಅಂದರೆ. ಮಾಡ್ಯೂಲ್ ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ವಿಶೇಷ ಸೂಚನೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದ ಹೊರತು. ಆದ್ದರಿಂದ, ನೀವು ರಫ್ತು ಮಾಡಲು ಉದ್ದೇಶಿಸದ ಮಾಡ್ಯೂಲ್ ವಸ್ತುಗಳನ್ನು ಘೋಷಿಸಲು ಇದು ಸಾಕಷ್ಟು ಸಮಂಜಸವಾಗಿದೆ ಸ್ಥಿರ.

ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯ ವಸ್ತುಗಳಿಗೆ ಅನನ್ಯ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಡೀಬಗ್ ಮಾಡುವಿಕೆಯನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ನಿಮ್ಮ ಚಾಲಕವನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ, ನೀವು ಹೆಚ್ಚುವರಿ ವಸ್ತುಗಳನ್ನು ಕರ್ನಲ್‌ಗೆ ರಫ್ತು ಮಾಡಬೇಕಾಗಬಹುದು. ಹೆಸರುಗಳನ್ನು ಗೊತ್ತುಪಡಿಸಲು ಅನನ್ಯ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಕರ್ನಲ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಘರ್ಷಣೆಯನ್ನು ಪರಿಚಯಿಸುವ ಅಪಾಯವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. ಕರ್ನಲ್‌ನಲ್ಲಿ ಪೂರ್ವಪ್ರತ್ಯಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಸಂಪ್ರದಾಯದ ಮೂಲಕ, ಲೋವರ್ಕೇಸ್ ಅಕ್ಷರಗಳು, ಮತ್ತು ನಾವು ಆ ಸಂಪ್ರದಾಯಕ್ಕೆ ಅಂಟಿಕೊಳ್ಳುತ್ತೇವೆ.

ಕರ್ನಲ್ ಮತ್ತು ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವಿನ ಮತ್ತೊಂದು ಗಮನಾರ್ಹ ವ್ಯತ್ಯಾಸವೆಂದರೆ ದೋಷ ನಿರ್ವಹಣೆ ಯಾಂತ್ರಿಕತೆ. ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಕರ್ನಲ್ ನಿಯಂತ್ರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿನ ದೋಷವು ಸಿಸ್ಟಮ್‌ಗೆ ಹಾನಿಯಾಗದ ಸಂದೇಶಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ: ವಿಭಜನೆ ದೋಷ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಬಳಕೆದಾರರ ಅಪ್ಲಿಕೇಶನ್‌ನ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಡೀಬಗರ್ ಅನ್ನು ಯಾವಾಗಲೂ ಬಳಸಬಹುದು. ಕರ್ನಲ್‌ನಲ್ಲಿ ಸಂಭವಿಸುವ ದೋಷಗಳು ಮಾರಣಾಂತಿಕವಾಗಿವೆ - ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್‌ಗೆ ಇಲ್ಲದಿದ್ದರೆ, ಕನಿಷ್ಠ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಗೆ. ಅಧ್ಯಾಯ 4 ರ "ಡೀಬಗ್ ಮಾಡುವಿಕೆ ಸಿಸ್ಟಮ್ ದೋಷಗಳು" ವಿಭಾಗದಲ್ಲಿ, "ಡೀಬಗ್ ಮಾಡುವ ತಂತ್ರಗಳು," ನಾವು ಕರ್ನಲ್ ದೋಷಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ವಿಧಾನಗಳನ್ನು ನೋಡುತ್ತೇವೆ.

ಬಳಕೆದಾರ ಸ್ಥಳ ಮತ್ತು ಕರ್ನಲ್ ಸ್ಥಳ

ಮಾಡ್ಯೂಲ್ ಎಂದು ಕರೆಯಲ್ಪಡುವಲ್ಲಿ ಸಾಗುತ್ತದೆ ಕರ್ನಲ್ ಜಾಗ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ರನ್ ಆಗುತ್ತಿರುವಾಗ . ಈ ಪರಿಕಲ್ಪನೆಯು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಸಿದ್ಧಾಂತದ ಆಧಾರವಾಗಿದೆ.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನ ಮುಖ್ಯ ಉದ್ದೇಶವೆಂದರೆ ಬಳಕೆದಾರ ಮತ್ತು ಬಳಕೆದಾರರ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಕಂಪ್ಯೂಟರ್ ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ ಒದಗಿಸುವುದು, ಇವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಬಾಹ್ಯ ಸಾಧನಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲ್ಪಡುತ್ತವೆ. ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುವುದು ಮಾತ್ರವಲ್ಲ, ಅವುಗಳ ಹಂಚಿಕೆ ಮತ್ತು ಬಳಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಬೇಕು, ಘರ್ಷಣೆಗಳು ಮತ್ತು ಅನಧಿಕೃತ ಪ್ರವೇಶವನ್ನು ತಡೆಯುತ್ತದೆ. ಇದರ ಜೊತೆಗೆ, ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ಕಾರ್ಯಕ್ರಮಗಳಿಗಾಗಿ ಸ್ವತಂತ್ರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಅನಧಿಕೃತ ಪ್ರವೇಶದಿಂದ ರಕ್ಷಿಸಬಹುದು. ಬಳಕೆದಾರರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಸಿಸ್ಟಮ್ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಪ್ರೊಸೆಸರ್ ರಕ್ಷಿಸಿದರೆ ಮಾತ್ರ ಈ ಕ್ಷುಲ್ಲಕವಲ್ಲದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು ಸಾಧ್ಯ.

ಪ್ರತಿಯೊಂದು ಆಧುನಿಕ ಪ್ರೊಸೆಸರ್ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕೋಡ್‌ಗಾಗಿ ವಿವಿಧ ಹಂತದ ಸವಲತ್ತುಗಳನ್ನು ಅಳವಡಿಸುವ ಮೂಲಕ ಅಂತಹ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಒದಗಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ (ಕನಿಷ್ಠ ಎರಡು ಹಂತಗಳು ಅಗತ್ಯವಿದೆ). ಉದಾಹರಣೆಗೆ, I32 ಆರ್ಕಿಟೆಕ್ಚರ್ ಪ್ರೊಸೆಸರ್‌ಗಳು 0 ರಿಂದ 3 ರವರೆಗಿನ ನಾಲ್ಕು ಹಂತದ ಸವಲತ್ತುಗಳನ್ನು ಹೊಂದಿವೆ. ಮೇಲಾಗಿ, ಮಟ್ಟ 0 ಹೆಚ್ಚಿನ ಸವಲತ್ತುಗಳನ್ನು ಹೊಂದಿದೆ. ಅಂತಹ ಸಂಸ್ಕಾರಕಗಳಿಗೆ, ಸವಲತ್ತು ಪಡೆದ ಹಂತಗಳಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ವಿಶೇಷ ಸೂಚನೆಗಳ ವರ್ಗವಿದೆ. ಯುನಿಕ್ಸ್ ವ್ಯವಸ್ಥೆಗಳು ಎರಡು ಹಂತದ ಪ್ರೊಸೆಸರ್ ಸವಲತ್ತುಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಪ್ರೊಸೆಸರ್ ಎರಡಕ್ಕಿಂತ ಹೆಚ್ಚು ಸವಲತ್ತು ಮಟ್ಟವನ್ನು ಹೊಂದಿದ್ದರೆ, ಕಡಿಮೆ ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. Unix ಕರ್ನಲ್ ಚಾಲನೆಯಲ್ಲಿದೆ ಅತ್ಯುನ್ನತ ಮಟ್ಟಸವಲತ್ತುಗಳು, ಬಳಕೆದಾರರ ಉಪಕರಣಗಳು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಳ ನಿಯಂತ್ರಣವನ್ನು ಖಾತ್ರಿಪಡಿಸುವುದು.

ನಾವು ಮಾತನಾಡುವಾಗ ಕರ್ನಲ್ ಜಾಗಮತ್ತು ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಳಇದರರ್ಥ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್‌ಗಾಗಿ ವಿವಿಧ ಹಂತದ ಸವಲತ್ತುಗಳು ಮಾತ್ರವಲ್ಲದೆ ವಿಭಿನ್ನ ವಿಳಾಸ ಸ್ಥಳಗಳೂ ಸಹ.

ಯುನಿಕ್ಸ್ ಎರಡು ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಳದಿಂದ ಕರ್ನಲ್ ಜಾಗಕ್ಕೆ ಮರಣದಂಡನೆಯನ್ನು ವರ್ಗಾಯಿಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಒಂದು ಬಳಕೆದಾರ ಅಪ್ಲಿಕೇಶನ್ ಕರ್ನಲ್‌ಗೆ ಕರೆ ಮಾಡಿದಾಗ (ಸಿಸ್ಟಮ್ ಕರೆ), ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಹಾರ್ಡ್‌ವೇರ್ ಅಡಚಣೆಗಳನ್ನು ಸರ್ವಿಸ್ ಮಾಡುವಾಗ. ಸಿಸ್ಟಮ್ ಕರೆ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಕರ್ನಲ್ ಕೋಡ್ ಪ್ರಕ್ರಿಯೆಯ ಸಂದರ್ಭದಲ್ಲಿ ರನ್ ಆಗುತ್ತದೆ, ಅಂದರೆ ಕರೆ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯ ಪರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ, ಇದು ಪ್ರಕ್ರಿಯೆಯ ವಿಳಾಸ ಸ್ಥಳದ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ. ಮತ್ತೊಂದೆಡೆ, ಹಾರ್ಡ್‌ವೇರ್ ಅಡಚಣೆಯನ್ನು ಪೂರೈಸುವಾಗ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಕೋಡ್ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಅಸಮಕಾಲಿಕವಾಗಿರುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ವಿಶೇಷ ಪ್ರಕ್ರಿಯೆಗೆ ಸೇರಿರುವುದಿಲ್ಲ.

ಮಾಡ್ಯೂಲ್‌ಗಳ ಉದ್ದೇಶವು ಕರ್ನಲ್‌ನ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸುವುದಾಗಿದೆ. ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಕರ್ನಲ್ ಜಾಗದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ, ಮಾಡ್ಯೂಲ್ ಈ ಹಿಂದೆ ಸೂಚಿಸಲಾದ ಎರಡೂ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ: ಕೆಲವು ಮಾಡ್ಯೂಲ್ ಕಾರ್ಯಗಳನ್ನು ಸಿಸ್ಟಮ್ ಕರೆಗಳ ಭಾಗವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕೆಲವು ಅಡಚಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಜವಾಬ್ದಾರರಾಗಿರುತ್ತಾರೆ.

ಕರ್ನಲ್‌ನಲ್ಲಿ ಸಮಾನಾಂತರೀಕರಣ

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ವಿರುದ್ಧವಾಗಿ ಸಾಧನ ಡ್ರೈವರ್‌ಗಳನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುವಾಗ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸುವ ಸಮಸ್ಯೆಯು ವಿಶೇಷವಾಗಿ ತೀವ್ರವಾಗಿರುತ್ತದೆ. ವಿಶಿಷ್ಟವಾಗಿ, ಅಪ್ಲಿಕೇಶನ್ ತನ್ನ ಪರಿಸರದಲ್ಲಿನ ಬದಲಾವಣೆಗಳ ಬಗ್ಗೆ ಚಿಂತಿಸದೆ ಪ್ರಾರಂಭದಿಂದ ಅಂತ್ಯದವರೆಗೆ ಅನುಕ್ರಮವಾಗಿ ಚಲಿಸುತ್ತದೆ. ಕರ್ನಲ್ ಕೋಡ್ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹಲವಾರು ಬಾರಿ ಪ್ರವೇಶಿಸಬಹುದು ಎಂಬ ತಿಳುವಳಿಕೆಯೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು.

ಕರ್ನಲ್ ಕೋಡ್ ಅನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸಲು ಹಲವು ಕಾರಣಗಳಿವೆ. Linux ಸಾಮಾನ್ಯವಾಗಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅನೇಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು. ಅನೇಕ ಸಾಧನಗಳು ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಹಾರ್ಡ್ವೇರ್ ಅಡಚಣೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಇಂಟರಪ್ಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಚಾಲಕ ಮತ್ತೊಂದು ವಿನಂತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವಾಗ ಕರೆಯಬಹುದು. ಕೆಲವು ಸಾಫ್ಟ್‌ವೇರ್ ಅಮೂರ್ತತೆಗಳು (ಕರ್ನಲ್ ಟೈಮರ್‌ಗಳಂತಹವು, ಅಧ್ಯಾಯ 6, “ಸಮಯದ ಹರಿವು” ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ) ಸಹ ಅಸಮಕಾಲಿಕವಾಗಿ ಚಲಿಸುತ್ತವೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಲಿನಕ್ಸ್ ಅನ್ನು ಸಿಮೆಟ್ರಿಕ್ ಮಲ್ಟಿಪ್ರೊಸೆಸರ್‌ಗಳೊಂದಿಗೆ (SMP) ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು, ಅಂದರೆ ನಿಮ್ಮ ಡ್ರೈವರ್ ಕೋಡ್ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಪ್ರೊಸೆಸರ್‌ಗಳಲ್ಲಿ ಸಮಾನಾಂತರವಾಗಿ ಚಲಿಸಬಹುದು.

ಈ ಕಾರಣಗಳಿಗಾಗಿ, ಡ್ರೈವರ್ ಕೋಡ್ ಸೇರಿದಂತೆ ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಕೋಡ್ ಅನ್ನು ಮರುಪ್ರವೇಶಿಸಬೇಕು, ಅಂದರೆ. ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಡೇಟಾ ಸಂದರ್ಭದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಶಕ್ತವಾಗಿರಬೇಕು. ಬಹು ಎಳೆಗಳ ಸಮಾನಾಂತರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಸರಿಹೊಂದಿಸಲು ಡೇಟಾ ರಚನೆಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಬೇಕು. ಪ್ರತಿಯಾಗಿ, ಕರ್ನಲ್ ಕೋಡ್ ಬಹು ಸಮಾನಾಂತರ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಹಾನಿಯಾಗದಂತೆ ನಿರ್ವಹಿಸಲು ಶಕ್ತವಾಗಿರಬೇಕು. ಸಮಾನಾಂತರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಮತ್ತು ವಿಭಿನ್ನವಾದ ಮರಣದಂಡನೆ ಅನುಕ್ರಮವು ಅನಪೇಕ್ಷಿತ ಸಿಸ್ಟಮ್ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗುವ ಸಂದರ್ಭಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಾಕಷ್ಟು ಸಮಯ ಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಬಹುಶಃ ಸಾಕಷ್ಟು ತಂತ್ರಗಳು ಬೇಕಾಗುತ್ತವೆ. ಈ ಪುಸ್ತಕದಲ್ಲಿ ಪ್ರತಿ ಚಾಲಕ ಉದಾಹರಣೆಯನ್ನು ಮನಸ್ಸಿನಲ್ಲಿ ಸಮಾನಾಂತರ ಮರಣದಂಡನೆಯೊಂದಿಗೆ ಬರೆಯಲಾಗಿದೆ. ಅಗತ್ಯವಿದ್ದರೆ, ಅಂತಹ ಕೋಡ್ ಬರೆಯುವ ತಂತ್ರದ ನಿಶ್ಚಿತಗಳನ್ನು ನಾವು ವಿವರಿಸುತ್ತೇವೆ.

ಹೆಚ್ಚಿನವು ಸಾಮಾನ್ಯ ದೋಷಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಮಾಡುವ ಸಮಸ್ಯೆಯೆಂದರೆ, ಕೆಲವು ಕೋಡ್ ವಿಭಾಗಗಳು ನಿದ್ರೆಗೆ ಹೋಗಲು ಸಾಧ್ಯವಾಗದ ಕಾರಣ ಏಕಕಾಲಿಕತೆಯು ಸಮಸ್ಯೆಯಲ್ಲ ಎಂದು ಅವರು ಊಹಿಸುತ್ತಾರೆ. ವಾಸ್ತವವಾಗಿ, Linux ಕರ್ನಲ್ ಪೇಜ್ ಆಗಿಲ್ಲ, ಪ್ರಮುಖವಾದ ಅಡಚಣೆ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಇದು ನಿರ್ಣಾಯಕ ಕರ್ನಲ್ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವಾಗ CPU ಅನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ. ಇತ್ತೀಚೆಗೆ, ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅನಪೇಕ್ಷಿತ ಸಮಾನಾಂತರೀಕರಣವನ್ನು ತಡೆಯಲು ಪುಟವಿಲ್ಲದಿರುವುದು ಸಾಕಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, SMP ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಸಮಾನಾಂತರ ಗಣನೆಯ ಕಾರಣದಿಂದಾಗಿ ಕೋಡ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ.

ನಿಮ್ಮ ಕೋಡ್ ಅದನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಎಂದು ಭಾವಿಸಿದರೆ, ಅದು SMP ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ನೀವು ಅಂತಹ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೂ ಸಹ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬಳಸುವ ಬೇರೆಯವರು ಒಂದನ್ನು ಹೊಂದಿರಬಹುದು. ಭವಿಷ್ಯದಲ್ಲಿ ಕರ್ನಲ್ ಪುಟಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸುವ ಸಾಧ್ಯತೆಯೂ ಇದೆ, ಆದ್ದರಿಂದ ಏಕ-ಸಂಸ್ಕಾರಕ ವ್ಯವಸ್ಥೆಗಳು ಸಹ ಸಮಕಾಲೀನತೆಯನ್ನು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ. ಅಂತಹ ಕರ್ನಲ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಈಗಾಗಲೇ ಆಯ್ಕೆಗಳಿವೆ. ಹೀಗಾಗಿ, ವಿವೇಕಯುತ ಪ್ರೋಗ್ರಾಮರ್ ಕರ್ನಲ್ ಕೋಡ್ ಅನ್ನು SMP ಚಾಲನೆಯಲ್ಲಿರುವ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ರನ್ ಮಾಡುತ್ತದೆ ಎಂಬ ಊಹೆಯೊಂದಿಗೆ ಬರೆಯುತ್ತಾರೆ.

ಸೂಚನೆ ಅನುವಾದಕ:ಕ್ಷಮಿಸಿ, ಆದರೆ ಕೊನೆಯ ಎರಡು ಪ್ಯಾರಾಗಳು ನನಗೆ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ. ಇದು ತಪ್ಪಾದ ಅನುವಾದದ ಫಲಿತಾಂಶವಾಗಿರಬಹುದು. ಆದ್ದರಿಂದ, ನಾನು ಮೂಲ ಪಠ್ಯವನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇನೆ.

ಚಾಲಕ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಮಾಡಿದ ಸಾಮಾನ್ಯ ತಪ್ಪು ಎಂದರೆ, ನಿರ್ದಿಷ್ಟ ಕೋಡ್‌ನ ಭಾಗದವರೆಗೆ ಏಕಕಾಲಿಕತೆಯು ಸಮಸ್ಯೆಯಾಗಿರುವುದಿಲ್ಲ ಎಂದು ಊಹಿಸುವುದು
ಇಲ್ಲನಿದ್ರೆಗೆ ಹೋಗಿ (ಅಥವಾ "ಬ್ಲಾಕ್"). ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಪೂರ್ವಭಾವಿಯಾಗಿಲ್ಲ ಎಂಬುದು ನಿಜ; ಪ್ರಮುಖ ಹೊರತುಪಡಿಸಿ
ಸರ್ವಿಸಿಂಗ್ ಅಡಚಣೆಗಳು, ಇದು ಸ್ವಇಚ್ಛೆಯಿಂದ ನೀಡದ ಕರ್ನಲ್ ಕೋಡ್‌ನಿಂದ ಪ್ರೊಸೆಸರ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಹಿಂದಿನ ಕಾಲದಲ್ಲಿ, ಇದು ಪೂರ್ವಭಾವಿಯಾಗಿಲ್ಲ
ಹೆಚ್ಚಿನ ಸಮಯ ಅನಗತ್ಯ ಹೊಂದಾಣಿಕೆಯನ್ನು ತಡೆಯಲು ನಡವಳಿಕೆಯು ಸಾಕಾಗಿತ್ತು. ಆದಾಗ್ಯೂ, SMP ಸಿಸ್ಟಂಗಳಲ್ಲಿ, ಪೂರ್ವಭಾವಿಯಾಗಿ ಉಂಟಾಗುವ ಅಗತ್ಯವಿಲ್ಲ
ಏಕಕಾಲಿಕ ಮರಣದಂಡನೆ.

ನಿಮ್ಮ ಕೋಡ್ ಪೂರ್ವನಿಯೋಜಿತವಾಗುವುದಿಲ್ಲ ಎಂದು ಭಾವಿಸಿದರೆ, ಅದು SMP ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ರನ್ ಆಗುವುದಿಲ್ಲ. ನಿಮ್ಮಲ್ಲಿ ಅಂತಹ ವ್ಯವಸ್ಥೆ ಇಲ್ಲದಿದ್ದರೂ,
ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಇತರರು ಒಂದನ್ನು ಹೊಂದಿರಬಹುದು. ಭವಿಷ್ಯದಲ್ಲಿ, ಕರ್ನಲ್ ಪೂರ್ವಭಾವಿ ಕಾರ್ಯಾಚರಣೆಯ ವಿಧಾನಕ್ಕೆ ಚಲಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ,
ಆ ಸಮಯದಲ್ಲಿ ಯುನಿಪ್ರೊಸೆಸರ್ ವ್ಯವಸ್ಥೆಗಳು ಸಹ ಎಲ್ಲೆಡೆ ಏಕಕಾಲಿಕತೆಯನ್ನು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ (ಕರ್ನಲ್‌ನ ಕೆಲವು ರೂಪಾಂತರಗಳು ಈಗಾಗಲೇ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ
ಇದು).

ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿ

ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಂತೆ ಅನುಕ್ರಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸದಿದ್ದರೂ, ಕರ್ನಲ್‌ಗೆ ಹೆಚ್ಚಿನ ಕರೆಗಳನ್ನು ಕರೆಯುವ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ರಚನೆಯನ್ನು ಸೂಚಿಸುವ ಜಾಗತಿಕ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ಕರ್ನಲ್ ಕೋಡ್ ಅದನ್ನು ಕರೆಯುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಗುರುತಿಸಬಹುದು struct task_struct, ಕಡತದಲ್ಲಿ ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.4 ಗಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಒಳಗೊಂಡಿತ್ತು . ಪಾಯಿಂಟರ್ ಪ್ರಸ್ತುತಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ತೆರೆದ ()ಅಥವಾ ಮುಚ್ಚಿ (), ಅವರಿಗೆ ಕಾರಣವಾದ ಒಂದು ಪ್ರಕ್ರಿಯೆ ಇರಬೇಕು. ಕರ್ನಲ್ ಕೋಡ್, ಅಗತ್ಯವಿದ್ದರೆ, ಪಾಯಿಂಟರ್ ಮೂಲಕ ಕರೆ ಪ್ರಕ್ರಿಯೆಯ ಬಗ್ಗೆ ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು ಕರೆಯಬಹುದು ಪ್ರಸ್ತುತ. ಈ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳಿಗಾಗಿ, ಅಧ್ಯಾಯ 5 ರಲ್ಲಿ "ಸಾಧನ ಫೈಲ್ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ" ವಿಭಾಗವನ್ನು ನೋಡಿ, "ವರ್ಧಿತ ಚಾರ್ ಡ್ರೈವರ್ ಕಾರ್ಯಾಚರಣೆಗಳು."

ಇಂದು, ಸೂಚ್ಯಂಕ ಪ್ರಸ್ತುತಕರ್ನಲ್‌ನ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳಂತೆ ಇನ್ನು ಮುಂದೆ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಆಗಿರುವುದಿಲ್ಲ. ಡೆವಲಪರ್‌ಗಳು ಸ್ಟಾಕ್ ಪುಟಕ್ಕೆ ಚಲಿಸುವ ಮೂಲಕ ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುವ ರಚನೆಗೆ ಪ್ರವೇಶವನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ್ದಾರೆ. ಫೈಲ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ನೀವು ನೋಡಬಹುದು . ಅಲ್ಲಿ ನೀವು ನೋಡುವ ಕೋಡ್ ನಿಮಗೆ ಸರಳವಾಗಿ ಕಾಣಿಸದಿರಬಹುದು. Linux ಒಂದು SMP-ಕೇಂದ್ರಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ ಮತ್ತು ನೀವು ಬಹು CPUಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ಇತರ ಕರ್ನಲ್ ಉಪವ್ಯವಸ್ಥೆಗಳಿಗೆ ಮರೆಮಾಡಲಾಗಿದೆ, ಮತ್ತು ಸಾಧನ ಚಾಲಕವು ಪಾಯಿಂಟರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಪ್ರಸ್ತುತಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಮಾತ್ರ .

ಮಾಡ್ಯೂಲ್ ದೃಷ್ಟಿಕೋನದಿಂದ, ಪ್ರಸ್ತುತಬಾಹ್ಯ ಲಿಂಕ್‌ನಂತೆ ಕಾಣುತ್ತದೆ printk(). ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು ಪ್ರಸ್ತುತಎಲ್ಲಿ ಬೇಕಾದರೂ. ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಕೋಡ್ ಪ್ರಕ್ರಿಯೆಯ ID (PID) ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಪ್ರಕ್ರಿಯೆಯ ಆಜ್ಞೆಯ ಹೆಸರನ್ನು ಮುದ್ರಿಸುತ್ತದೆ, ರಚನೆಯ ಅನುಗುಣವಾದ ಕ್ಷೇತ್ರಗಳ ಮೂಲಕ ಅವುಗಳನ್ನು ಪಡೆಯುತ್ತದೆ. struct task_struct:

Printk("ಪ್ರಕ್ರಿಯೆಯು \"%s\" (pid %i)\n", current->comm, current->pid);

ಪ್ರಸ್ತುತ->comm ಕ್ಷೇತ್ರವು ಪ್ರಸ್ತುತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹುಟ್ಟುಹಾಕಿದ ಕಮಾಂಡ್ ಫೈಲ್‌ನ ಹೆಸರಾಗಿದೆ.

ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡುವುದು ಮತ್ತು ಲೋಡ್ ಮಾಡುವುದು

ಈ ಅಧ್ಯಾಯದ ಉಳಿದ ಭಾಗವನ್ನು ಸಂಪೂರ್ಣ ಬರೆಯಲು ಮೀಸಲಿಡಲಾಗಿದೆ, ಆದರೂ ವಿಲಕ್ಷಣ, ಮಾಡ್ಯೂಲ್. ಆ. ಮಾಡ್ಯೂಲ್ ಅಧ್ಯಾಯ 1, "ಸಾಧನ ಡ್ರೈವರ್‌ಗಳ ಪರಿಚಯ" ದಲ್ಲಿ "ಸಾಧನ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ತರಗತಿಗಳು" ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಿದ ಯಾವುದೇ ವರ್ಗಗಳಿಗೆ ಸೇರಿಲ್ಲ. ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ತೋರಿಸಿರುವ ಉದಾಹರಣೆ ಚಾಲಕವನ್ನು ಸ್ಕಲ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ (ಲೋಕಲಿಟಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು ಸರಳ ಕರ್ನಲ್ ಉಪಯುಕ್ತತೆ). ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಥಳೀಯ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ನೀವು ಸ್ಕಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಟೆಂಪ್ಲೇಟ್ ಆಗಿ ಬಳಸಬಹುದು.

ಉತ್ತಮ ಹಳೆಯ Unix ಸಂಪ್ರದಾಯದಲ್ಲಿ (/usr/local) ನಿಮ್ಮ ವೈಯಕ್ತಿಕ ಕೋಡ್ ಬದಲಾವಣೆಗಳನ್ನು ಒತ್ತಿಹೇಳಲು ನಾವು "ಸ್ಥಳೀಯ ಕೋಡ್" (ಸ್ಥಳೀಯ) ಪರಿಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

ಆದಾಗ್ಯೂ, ನಾವು init_module() ಮತ್ತು cleanup_module() ಕಾರ್ಯಗಳನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸುವ ಮೊದಲು, ನಾವು ಮಾಡ್ಯೂಲ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸುವ Makefile ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯುತ್ತೇವೆ.

ಪ್ರಿಪ್ರೊಸೆಸರ್ ಯಾವುದೇ ಹೆಡರ್ ಫೈಲ್‌ನ ಸೇರ್ಪಡೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೊದಲು, __KERNEL__ ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಯನ್ನು #ಡಿಫೈನ್ ಡೈರೆಕ್ಟಿವ್‌ನೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಕರ್ನಲ್-ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯಲ್ಲಿ __KERNEL__ ಚಿಹ್ನೆಯನ್ನು ಮೊದಲೇ ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ ಮಾತ್ರ ಗೋಚರಿಸುತ್ತದೆ.

#ಡಿಫೈನ್ ಡೈರೆಕ್ಟಿವ್‌ನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಚಿಹ್ನೆಯು MODULE ಸಂಕೇತವಾಗಿದೆ. ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮೊದಲು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು (ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಕಂಪೈಲ್ ಮಾಡಲಾಗುವ ಡ್ರೈವರ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸಿ). ಕರ್ನಲ್‌ಗೆ ಜೋಡಿಸಲಾದ ಡ್ರೈವರ್‌ಗಳನ್ನು ಈ ಪುಸ್ತಕದಲ್ಲಿ ವಿವರಿಸಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಮಾಡ್ಯೂಲ್ ಚಿಹ್ನೆಯು ನಮ್ಮ ಎಲ್ಲಾ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಇರುತ್ತದೆ.

ನೀವು SMP ಯೊಂದಿಗೆ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದರೆ, ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮೊದಲು ನೀವು __SMP__ ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಯನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾಗುತ್ತದೆ. ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.2 ರಲ್ಲಿ, ಕರ್ನಲ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿನ ಪ್ರತ್ಯೇಕ ಐಟಂ ಏಕ-ಪ್ರೊಸೆಸರ್ ಮತ್ತು ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ಸಿಸ್ಟಮ್ ನಡುವೆ ಆಯ್ಕೆಯನ್ನು ಪರಿಚಯಿಸಿತು. ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನ ಮೊದಲ ಸಾಲುಗಳಾಗಿ ಈ ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ಬೆಂಬಲಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

#ಸೇರಿಸು #ifdef CONFIG_SMP # __SMP__ #endif ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

ಮಾಡ್ಯೂಲ್ ಡೆವಲಪರ್‌ಗಳು ಕಂಪೈಲರ್‌ಗಾಗಿ -O ಆಪ್ಟಿಮೈಸೇಶನ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು ಏಕೆಂದರೆ ಅನೇಕ ಕಾರ್ಯಗಳನ್ನು ಕರ್ನಲ್ ಹೆಡರ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಇನ್‌ಲೈನ್‌ನಲ್ಲಿ ಘೋಷಿಸಲಾಗುತ್ತದೆ. ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸದ ಹೊರತು ಜಿಸಿಸಿ ಕಂಪೈಲರ್ ಫಂಕ್ಷನ್‌ಗಳಲ್ಲಿ ಇನ್‌ಲೈನ್ ವಿಸ್ತರಣೆಯನ್ನು ಮಾಡುವುದಿಲ್ಲ. -g ಮತ್ತು -O ಆಯ್ಕೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಇನ್‌ಲೈನ್ ಪರ್ಯಾಯಗಳನ್ನು ವಿಸ್ತರಿಸಲು ಅನುಮತಿಸುವುದರಿಂದ ಡೀಬಗರ್‌ನಲ್ಲಿ ಇನ್‌ಲೈನ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವ ನಂತರ ಡೀಬಗ್ ಕೋಡ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಕರ್ನಲ್ ಇನ್‌ಲೈನ್ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸುವುದರಿಂದ, ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ವಿಸ್ತರಿಸುವುದು ಬಹಳ ಮುಖ್ಯ.

ಆದಾಗ್ಯೂ, -O2 ಮಟ್ಟಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ಬಳಸುವುದು ಅಪಾಯಕಾರಿ ಏಕೆಂದರೆ ಕಂಪೈಲರ್ ಇನ್‌ಲೈನ್‌ನಲ್ಲಿ ಘೋಷಿಸದ ಕಾರ್ಯಗಳನ್ನು ವಿಸ್ತರಿಸಬಹುದು. ಇದು ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಏಕೆಂದರೆ... ಕೆಲವು ಫಂಕ್ಷನ್ ಕೋಡ್ ಅದರ ಕರೆಯ ಪ್ರಮಾಣಿತ ಸ್ಟಾಕ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ಅನುಗುಣವಾದ ಫಂಕ್ಷನ್ ಕರೆ ಸೂಚನೆಯ ಬದಲಿಗೆ ಅದರ ಕರೆಯ ಹಂತದಲ್ಲಿ ಫಂಕ್ಷನ್ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸುವುದು ಇನ್‌ಲೈನ್ ವಿಸ್ತರಣೆಯನ್ನು ಅರ್ಥೈಸಿಕೊಳ್ಳುತ್ತದೆ. ಅಂತೆಯೇ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಯಾವುದೇ ಫಂಕ್ಷನ್ ಕರೆ ಇಲ್ಲದಿರುವುದರಿಂದ, ಅದರ ಕರೆಯ ಯಾವುದೇ ಸ್ಟಾಕ್ ಇಲ್ಲ.

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ನೀವು ಅದೇ ಕಂಪೈಲರ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ ಎಂಬುದನ್ನು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಬಹುದು, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಕರ್ನಲ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ವಿವರಗಳಿಗಾಗಿ, ಫೈಲ್‌ನಿಂದ ಮೂಲ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ನೋಡಿ ದಾಖಲೆ/ಬದಲಾವಣೆಗಳುಕರ್ನಲ್ ಮೂಲಗಳ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿದೆ. ಕರ್ನಲ್ ಮತ್ತು ಕಂಪೈಲರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಾದ್ಯಂತ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅಂಶಗಳಲ್ಲಿ ಒಂದನ್ನು ನವೀಕರಿಸುವುದು ಇನ್ನೊಂದರಲ್ಲಿ ದೋಷಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುವ ಸಂದರ್ಭಗಳು ಇರಬಹುದು. ಕೆಲವು ವಿತರಣಾ ತಯಾರಕರು ಅವರು ಬಳಸುತ್ತಿರುವ ಕರ್ನಲ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗದ ಕಂಪೈಲರ್‌ನ ಅಲ್ಟ್ರಾ-ಹೊಸ ಆವೃತ್ತಿಗಳನ್ನು ಪೂರೈಸುತ್ತಾರೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತ್ಯೇಕ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಒದಗಿಸುತ್ತಾರೆ (ಸಾಮಾನ್ಯವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ ಕೆಜಿಸಿಸಿ) ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಕಂಪೈಲರ್‌ನೊಂದಿಗೆ
ಕರ್ನಲ್ ಸಂಕಲನ.

ಅಂತಿಮವಾಗಿ, ಅಸಹ್ಯ ದೋಷಗಳನ್ನು ತಡೆಗಟ್ಟಲು, ಕಂಪೈಲ್ ಆಯ್ಕೆಯನ್ನು ಬಳಸಲು ನಾವು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇವೆ -ಗೋಡೆ(ಎಲ್ಲಾ ಎಚ್ಚರಿಕೆ - ಎಲ್ಲಾ ಎಚ್ಚರಿಕೆಗಳು). ಈ ಎಲ್ಲಾ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಪೂರೈಸಲು, ನಿಮ್ಮ ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಯನ್ನು ನೀವು ಬದಲಾಯಿಸಬೇಕಾಗಬಹುದು. ಕರ್ನಲ್ ಕೋಡ್ ಬರೆಯುವಾಗ, ಲಿನಸ್ ಟೊರ್ವಾಲ್ಡ್ಸ್ ಪ್ರಸ್ತಾಪಿಸಿದ ಕೋಡಿಂಗ್ ಶೈಲಿಯನ್ನು ಬಳಸುವುದು ಉತ್ತಮ. ಹೌದು, ಡಾಕ್ಯುಮೆಂಟ್ ಡಾಕ್ಯುಮೆಂಟೇಶನ್/ಕೋಡಿಂಗ್ ಸ್ಟೈಲ್,ಕರ್ನಲ್ ಮೂಲ ಡೈರೆಕ್ಟರಿಯಿಂದ, ಸಾಕಷ್ಟು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಮತ್ತು ಕರ್ನಲ್ ಮಟ್ಟದ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಎಲ್ಲರಿಗೂ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.

ನಾವು ಇತ್ತೀಚೆಗೆ ಪರಿಚಯವಾದ ಮಾಡ್ಯೂಲ್ ಸಂಕಲನ ಫ್ಲ್ಯಾಗ್‌ಗಳ ಗುಂಪನ್ನು ವೇರಿಯಬಲ್‌ನಲ್ಲಿ ಇರಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ CFLAGSನಿಮ್ಮ ಮೇಕ್‌ಫೈಲ್. ಮೇಕ್ ಯುಟಿಲಿಟಿಗಾಗಿ, ಇದು ವಿಶೇಷ ವೇರಿಯಬಲ್ ಆಗಿದೆ, ಇದರ ಬಳಕೆಯು ಈ ಕೆಳಗಿನ ವಿವರಣೆಯಿಂದ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

ವೇರಿಯಬಲ್ನಲ್ಲಿ ಧ್ವಜಗಳ ಜೊತೆಗೆ CFLAGS, ನಿಮ್ಮ ಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿ ವಿಭಿನ್ನ ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಗುರಿ ನಿಮಗೆ ಬೇಕಾಗಬಹುದು. ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಹಲವಾರು ಮೂಲ ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಿದಾಗ ಮಾತ್ರ ಅಂತಹ ಗುರಿಯು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಮಾನ್ಯವಲ್ಲ. ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಆಜ್ಞೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ ld -r, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ಅರ್ಥದಲ್ಲಿ ಲಿಂಕ್ ಮಾಡುವ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲ, ಲಿಂಕರ್‌ನ ಬಳಕೆಯ ಹೊರತಾಗಿಯೂ ( ld) ಆಜ್ಞೆಯ ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶ ld -rಲಿಂಕರ್ ಇನ್‌ಪುಟ್ ಫೈಲ್‌ಗಳ ಆಬ್ಜೆಕ್ಟ್ ಕೋಡ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮತ್ತೊಂದು ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್ ಆಗಿದೆ. ಆಯ್ಕೆ -ಆರ್ಅರ್ಥ " ಸ್ಥಳಾಂತರಿಸಬಹುದಾದ - ಸ್ಥಳಾಂತರಿಸಬಹುದಾದ”, ಅಂದರೆ. ನಾವು ಆಜ್ಞೆಯ ಔಟ್ಪುಟ್ ಫೈಲ್ ಅನ್ನು ವಿಳಾಸ ಜಾಗದಲ್ಲಿ ಸರಿಸುತ್ತೇವೆ, ಏಕೆಂದರೆ ಇದು ಇನ್ನೂ ಫಂಕ್ಷನ್ ಕರೆಗಳ ಸಂಪೂರ್ಣ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಎರಡು ಮೂಲ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಕನಿಷ್ಠ ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ. ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಒಂದೇ ಮೂಲ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀಡಲಾದ ಉದಾಹರಣೆಯಿಂದ ನೀವು ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿರುವ ಗುರಿಯನ್ನು ತೆಗೆದುಹಾಕಬೇಕಾಗುತ್ತದೆ ld -r.

# ನಿಮ್ಮ ಕರ್ನಲ್ ಮೂಲ ಡೈರೆಕ್ಟರಿಗೆ ಮಾರ್ಗವನ್ನು ಇಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು, # ಅಥವಾ "ಮಾಡು" KERNELDIR = /usr/src/linux ಅನ್ನು $(KERNELDIR)/.config CFLAGS = -D__KERNEL__ -DMODULE ಎಂದು ಕರೆಯುವಾಗ ನೀವು ಅದನ್ನು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ರವಾನಿಸಬಹುದು. I$(KERNELDIR) /ಒಳಗೊಂಡಿದೆ \ -O -Wall ifdef CONFIG_SMP CFLAGS += -D__SMP__ -DSMP endif ಎಲ್ಲಾ: skull.o skull.o: skull_init.o skull_clean.o $(LD) -r $^ -o $@ ಕ್ಲೀನ್ : rm -f * .o *~ ಕೋರ್

ನೀವು ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂಬುದರ ಬಗ್ಗೆ ಹೊಸಬರಾಗಿದ್ದರೆ, *.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 ಫೈಲ್‌ನಿಂದ ವಿವರಿಸಿದ ಚಿಹ್ನೆಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ಸ್ಟ್ಯಾಟಿಕ್ ಕಾನ್ಸ್ಟ್ ಚಾರ್ __module_kernel_versio/PRE__attribute__((ವಿಭಾಗ(".modinfo"))) = "kernel_version=" UTS_RELEASE;

ಆವೃತ್ತಿಯ ಅಸಾಮರಸ್ಯದಿಂದಾಗಿ ಮಾಡ್ಯೂಲ್ ಲೋಡ್ ಆಗಲು ವಿಫಲವಾದಲ್ಲಿ, ಯುಟಿಲಿಟಿಯ ಪ್ಯಾರಾಮೀಟರ್ ಲೈನ್‌ಗೆ ಇನ್‌ಸ್ಮೋಡ್ ಕೀಯನ್ನು ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಬಹುದು -ಎಫ್(ಬಲ). ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ ಈ ವಿಧಾನವು ಸುರಕ್ಷಿತವಾಗಿಲ್ಲ ಮತ್ತು ಯಾವಾಗಲೂ ಯಶಸ್ವಿಯಾಗುವುದಿಲ್ಲ. ಸಂಭವನೀಯ ವೈಫಲ್ಯಗಳಿಗೆ ಕಾರಣಗಳನ್ನು ವಿವರಿಸುವುದು ತುಂಬಾ ಕಷ್ಟ. ಲಿಂಕ್ ಮಾಡುವಾಗ ಚಿಹ್ನೆಗಳನ್ನು ಪರಿಹರಿಸಲಾಗದ ಕಾರಣ ಮಾಡ್ಯೂಲ್ ಲೋಡ್ ಆಗದಿರುವ ಸಾಧ್ಯತೆಯಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಸರಿಯಾದ ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೀರಿ. ವೈಫಲ್ಯದ ಕಾರಣಗಳು ಕರ್ನಲ್‌ನ ಕಾರ್ಯಾಚರಣೆ ಅಥವಾ ರಚನೆಯಲ್ಲಿನ ಬದಲಾವಣೆಗಳಲ್ಲಿಯೂ ಇರಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವುದು ಗಂಭೀರ ರನ್ಟೈಮ್ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ಜೊತೆಗೆ ಸಿಸ್ಟಮ್ ಪ್ಯಾನಿಕ್ಗೆ ಕಾರಣವಾಗಬಹುದು. ಎರಡನೆಯದು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ಉತ್ತಮ ಪ್ರೋತ್ಸಾಹಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು. ಕರ್ನಲ್‌ನಲ್ಲಿ ಆವೃತ್ತಿಯ ನಿಯಂತ್ರಣವನ್ನು ಬಳಸಿಕೊಂಡು ಆವೃತ್ತಿಯ ಹೊಂದಾಣಿಕೆಗಳನ್ನು ಹೆಚ್ಚು ಸೊಗಸಾಗಿ ನಿರ್ವಹಿಸಬಹುದು. ಅಧ್ಯಾಯ 11 "kmod ಮತ್ತು ಸುಧಾರಿತ ಮಾಡ್ಯುಲರೈಸೇಶನ್" ನಲ್ಲಿ "ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ" ವಿಭಾಗದಲ್ಲಿ ನಾವು ಇದರ ಬಗ್ಗೆ ವಿವರವಾಗಿ ಮಾತನಾಡುತ್ತೇವೆ.

ನಿರ್ದಿಷ್ಟ ಕರ್ನಲ್ ಆವೃತ್ತಿಗಾಗಿ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ನೀವು ಬಯಸಿದರೆ, ನೀವು ನಿರ್ದಿಷ್ಟ ಕರ್ನಲ್ ಆವೃತ್ತಿಗೆ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಕು. ಮೇಲೆ ವಿವರಿಸಿದ ಮೇಕ್‌ಫೈಲ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ಈ ಫೈಲ್‌ಗಳಿಗಾಗಿ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ಧರಿಸಲು ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸಲಾಗಿದೆ ಕರ್ನೆಲ್ಡಿರ್. ಕರ್ನಲ್ ಮೂಲಗಳು ಲಭ್ಯವಿರುವಾಗ ಇಂತಹ ಕಸ್ಟಮ್ ಸಂಕಲನವು ಸಾಮಾನ್ಯವಲ್ಲ. ಅಲ್ಲದೆ, ಡೈರೆಕ್ಟರಿ ಟ್ರೀಯಲ್ಲಿ ಕರ್ನಲ್‌ನ ವಿಭಿನ್ನ ಆವೃತ್ತಿಗಳು ಇರುವುದು ಅಸಾಮಾನ್ಯವೇನಲ್ಲ. ಈ ಪುಸ್ತಕದಲ್ಲಿನ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್ ಉದಾಹರಣೆಗಳು ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸುತ್ತವೆ ಕರ್ನೆಲ್ಡಿರ್ಜೋಡಿಸಲಾದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲಿಂಕ್ ಮಾಡಬೇಕಾದ ಕರ್ನಲ್ ಆವೃತ್ತಿಗೆ ಮೂಲ ಡೈರೆಕ್ಟರಿಯ ಸ್ಥಳವನ್ನು ಸೂಚಿಸಲು. ಈ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನೀವು ಸಿಸ್ಟಮ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸಬಹುದು ಅಥವಾ ಮಾಡಲು ಆಜ್ಞಾ ಸಾಲಿನ ಆಯ್ಕೆಗಳ ಮೂಲಕ ನೀವು ಅದರ ಸ್ಥಳವನ್ನು ರವಾನಿಸಬಹುದು.

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ, insmod ಯುಟಿಲಿಟಿ ಮಾಡ್ಯೂಲ್‌ನ ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳಿಗಾಗಿ ತನ್ನದೇ ಆದ ಹುಡುಕಾಟ ಮಾರ್ಗಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಪ್ರಾರಂಭವಾಗುವ ಆವೃತ್ತಿ-ಅವಲಂಬಿತ ಡೈರೆಕ್ಟರಿಗಳ ಮೂಲಕ ನೋಡುತ್ತದೆ /ಲಿಬ್/ಮಾಡ್ಯೂಲ್‌ಗಳು. ಮತ್ತು ಉಪಯುಕ್ತತೆಯ ಹಳೆಯ ಆವೃತ್ತಿಗಳು ಹುಡುಕಾಟ ಮಾರ್ಗದಲ್ಲಿ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಒಳಗೊಂಡಿದ್ದರೂ, ಭದ್ರತಾ ಕಾರಣಗಳಿಗಾಗಿ ಈ ನಡವಳಿಕೆಯನ್ನು ಈಗ ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ ಎಂದು ಪರಿಗಣಿಸಲಾಗಿದೆ (ಸಿಸ್ಟಮ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸುವಂತೆಯೇ ಅದೇ ಸಮಸ್ಯೆಗಳು ಮಾರ್ಗ) ಆದ್ದರಿಂದ ನೀವು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಿಂದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಬಯಸಿದರೆ ನೀವು ಅದನ್ನು ಶೈಲಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ./module.o. ಮಾಡ್ಯೂಲ್ ಸ್ಥಾನದ ಈ ಸೂಚನೆಯು insmod ಉಪಯುಕ್ತತೆಯ ಯಾವುದೇ ಆವೃತ್ತಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಕೆಲವೊಮ್ಮೆ ನೀವು 2.0.x ಮತ್ತು 2.4.x ನಡುವೆ ವಿಭಿನ್ನವಾಗಿರುವ ಕರ್ನಲ್ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಎದುರಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರಸ್ತುತ ಕರ್ನಲ್ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಧರಿಸುವ ಮ್ಯಾಕ್ರೋವನ್ನು ನೀವು ಆಶ್ರಯಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ಮ್ಯಾಕ್ರೋ ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿದೆ . ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಬಳಸುವಾಗ ವ್ಯತ್ಯಾಸಗಳ ಪ್ರಕರಣಗಳನ್ನು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ. ಇದನ್ನು ತಕ್ಷಣವೇ ವಿವರಣೆಯ ಉದ್ದಕ್ಕೂ ಅಥವಾ ವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ಆವೃತ್ತಿ ಅವಲಂಬನೆಗಳಿಗೆ ಮೀಸಲಾಗಿರುವ ವಿಶೇಷ ವಿಭಾಗದಲ್ಲಿ ಮಾಡಬಹುದು. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ವಿವರಗಳನ್ನು ಪ್ರತ್ಯೇಕ ವಿಭಾಗದಲ್ಲಿ ಇರಿಸುವುದರಿಂದ ಈ ಪುಸ್ತಕಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.4.x ನ ವಿವರಣೆಯನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ linux/version.hಕರ್ನಲ್ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಧರಿಸಲು ಕೆಳಗಿನ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.

ಫೈಲ್‌ನ ವಿಷಯಗಳು ಇಲ್ಲಿವೆ: linux/version.hಕರ್ನಲ್ 2.4.25 ಗಾಗಿ (ಹೆಡರ್ ಫೈಲ್‌ನ ಪಠ್ಯವನ್ನು ಪೂರ್ಣವಾಗಿ ನೀಡಲಾಗಿದೆ).

#UTS_RELEASE "2.4.25" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ #LINUX_VERSION_CODE 132121 ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ #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, ಆವೃತ್ತಿ ಅವಲಂಬನೆ ಪರಿಶೀಲನೆಗಳೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಇರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ನಾವು ಪ್ರತಿನಿಧಿಸಲು ಬಯಸುವ ಮೊದಲ ಆವೃತ್ತಿಯ ಅವಲಂಬನೆಯು ಗುರಿ ಘೋಷಣೆಯಲ್ಲಿದೆ" ಸ್ಥಾಪಿಸಲು ಮಾಡಿ" ನಮ್ಮ ಚಾಲಕ ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್. ನೀವು ನಿರೀಕ್ಷಿಸಿದಂತೆ, ಅನುಸ್ಥಾಪನಾ ಡೈರೆಕ್ಟರಿ, ಬಳಸಿದ ಕರ್ನಲ್ ಆವೃತ್ತಿಗೆ ಅನುಗುಣವಾಗಿ ಬದಲಾಗುತ್ತದೆ, ಆವೃತ್ತಿ.h ಫೈಲ್ ಅನ್ನು ವೀಕ್ಷಿಸುವುದರ ಆಧಾರದ ಮೇಲೆ ಆಯ್ಕೆಮಾಡಲಾಗಿದೆ. ಫೈಲ್‌ನಿಂದ ಕೋಡ್ ತುಣುಕು ಇಲ್ಲಿದೆ ನಿಯಮಗಳು.ಮಾಡು, ಇದನ್ನು ಎಲ್ಲಾ ಕರ್ನಲ್ ಮೇಕ್‌ಫೈಲ್‌ಗಳು ಬಳಸುತ್ತವೆ.

VERSIONFILE = $(INCLUDEDIR)/linux/version.h VREION = $(shell awk -F\" "/REL/ (ಮುದ್ರಣ $$2)" $(VERSIONFILE)) ಸ್ಥಾಪಿಸಿ = /lib/modules/$(VERSION)/ಮಿಸ್ಕ್

ನಮ್ಮ ಎಲ್ಲಾ ಡ್ರೈವರ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ನಾವು ಇತರೆ ಡೈರೆಕ್ಟರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ (ಮೇಕ್‌ಫೈಲ್ ಉದಾಹರಣೆಯಲ್ಲಿ INSTALLDIR ಘೋಷಣೆ). ಕರ್ನಲ್ ಆವೃತ್ತಿ 2.4 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಈ ಡೈರೆಕ್ಟರಿಯು ಕಸ್ಟಮ್ ಡ್ರೈವರ್‌ಗಳನ್ನು ಇರಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾದ ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮಾಡ್ಯೂಟಿಲ್‌ಗಳ ಪ್ಯಾಕೇಜ್‌ನ ಹಳೆಯ ಮತ್ತು ಹೊಸ ಆವೃತ್ತಿಗಳೆರಡೂ ಅವುಗಳ ಹುಡುಕಾಟ ಮಾರ್ಗಗಳಲ್ಲಿ ಇತರೆ ಡೈರೆಕ್ಟರಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ.

ಮೇಲಿನ INSTALLDIR ವ್ಯಾಖ್ಯಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿನ ಸ್ಥಾಪನೆ ಗುರಿಯು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

ಸ್ಥಾಪಿಸಿ: ಸ್ಥಾಪಿಸಿ -d $(INSTALLDIR) ಸ್ಥಾಪಿಸಿ -c $(OBJS) $(INSTALLDIR)

ವೇದಿಕೆ ಅವಲಂಬನೆ

ಪ್ರತಿಯೊಂದು ಕಂಪ್ಯೂಟರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ತನ್ನದೇ ಆದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ, ಅದನ್ನು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸಲು ಕರ್ನಲ್ ಡೆವಲಪರ್‌ಗಳು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು.

ಅಪ್ಲಿಕೇಶನ್ ಡೆವಲಪರ್‌ಗಳಿಗಿಂತ ಕರ್ನಲ್ ಡೆವಲಪರ್‌ಗಳು ಆಯ್ಕೆ ಮತ್ತು ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುವಲ್ಲಿ ಹೆಚ್ಚಿನ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ಹೊಂದಿದ್ದಾರೆ. ಈ ಸ್ವಾತಂತ್ರ್ಯವೇ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಪ್ರತಿ ನಿರ್ದಿಷ್ಟ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಿಂದ ಹೆಚ್ಚಿನದನ್ನು ಪಡೆಯುತ್ತದೆ.

ಕರ್ನಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಬಳಸಿದ ಅದೇ ಕಂಪೈಲರ್ ಆಯ್ಕೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಬೇಕು. ಇದು ಒಂದೇ ಪ್ರೊಸೆಸರ್ ರಿಜಿಸ್ಟರ್ ಬಳಕೆಯ ನಮೂನೆಗಳನ್ನು ಬಳಸುವುದು ಮತ್ತು ಒಂದೇ ಮಟ್ಟದ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು ಎರಡಕ್ಕೂ ಅನ್ವಯಿಸುತ್ತದೆ. ಫೈಲ್ ನಿಯಮಗಳು.ಮಾಡು, ಕರ್ನಲ್ ಮೂಲ ಮರದ ಮೂಲದಲ್ಲಿ ನೆಲೆಗೊಂಡಿದೆ, ಎಲ್ಲಾ ಸಂಕಲನ ಮೇಕ್‌ಫೈಲ್‌ಗಳಲ್ಲಿ ಸೇರಿಸಬೇಕಾದ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಎಲ್ಲಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್-ನಿರ್ದಿಷ್ಟ ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಮೇಕ್‌ಫೈಲ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ವೇದಿಕೆಮತ್ತು ಪ್ರಸ್ತುತ ಕರ್ನಲ್ ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರಕಾರ ಮೇಕ್ ಯುಟಿಲಿಟಿಗಾಗಿ ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಮೇಕ್‌ಫೈಲ್‌ನ ಮತ್ತೊಂದು ಆಸಕ್ತಿದಾಯಕ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅಥವಾ ಸರಳವಾಗಿ ಕ್ರಾಸ್ ಸಂಕಲನಕ್ಕೆ ಅದರ ಬೆಂಬಲ. ನೀವು ಇನ್ನೊಂದು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಬೇಕಾದಾಗ ಈ ಪದವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, i86 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು M68000 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲಿದ್ದೀರಿ. ನೀವು ಕ್ರಾಸ್ ಕಂಪೈಲ್ ಮಾಡಲು ಹೋದರೆ, ನಿಮ್ಮ ಸಂಕಲನ ಪರಿಕರಗಳನ್ನು ನೀವು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ ( gcc, ld, ಇತ್ಯಾದಿ) ಅನುಗುಣವಾದ ಉಪಕರಣಗಳ ಮತ್ತೊಂದು ಸೆಟ್ನೊಂದಿಗೆ
(ಉದಾಹರಣೆಗೆ, m68k-linux-gcc, m68k-linux-ld) ಬಳಸಿದ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು $(CROSS_COMPILE) ಮೇಕ್‌ಫೈಲ್ ವೇರಿಯೇಬಲ್, ಮೇಕ್ ಯುಟಿಲಿಟಿಗೆ ಕಮಾಂಡ್ ಲೈನ್ ಆಯ್ಕೆಯಿಂದ ಅಥವಾ ಸಿಸ್ಟಮ್ ಪರಿಸರ ವೇರಿಯಬಲ್ ಮೂಲಕ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

SPARC ಆರ್ಕಿಟೆಕ್ಚರ್ ಒಂದು ವಿಶೇಷ ಪ್ರಕರಣವಾಗಿದ್ದು, ಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿ ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ನಿರ್ವಹಿಸಬೇಕು. SPARC64 (SPARC V9) ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ರನ್ ಆಗುವ ಬಳಕೆದಾರರ ಕಾರ್ಯಕ್ರಮಗಳು ಬೈನರಿಗಳಾಗಿವೆ, ಸಾಮಾನ್ಯವಾಗಿ SPARC32 (SPARC V8) ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, SPARC64 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ (gcc) ನಲ್ಲಿನ ಡೀಫಾಲ್ಟ್ ಕಂಪೈಲರ್ SPARC32 ಗಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, SPARC V9 ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಕರ್ನಲ್ SPARC V9 ಗಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು, ಹಾಗಾಗಿ ಕ್ರಾಸ್ ಕಂಪೈಲರ್ ಅಗತ್ಯವಿರುತ್ತದೆ. SPARC64 ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಎಲ್ಲಾ GNU/Linux ವಿತರಣೆಗಳು ಸೂಕ್ತವಾದ ಕ್ರಾಸ್-ಕಂಪೈಲರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಇದನ್ನು ಕರ್ನಲ್ ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಬೇಕು.

ಮತ್ತು ಆವೃತ್ತಿ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅವಲಂಬನೆಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯು ಇಲ್ಲಿ ವಿವರಿಸಿದ್ದಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೂ, ಅಡ್ಡ ಸಂಕಲನವನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಸಾಕಷ್ಟು ಸಾಕು. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ನೀವು ಮೇಕ್‌ಫೈಲ್ ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಕರ್ನಲ್ ಮೂಲ ಫೈಲ್‌ಗಳನ್ನು ನೋಡಬಹುದು.

ಕರ್ನಲ್ 2.6 ನ ವೈಶಿಷ್ಟ್ಯಗಳು

ಸಮಯ ಇನ್ನೂ ನಿಲ್ಲುವುದಿಲ್ಲ. ಮತ್ತು ಈಗ ನಾವು ಹೊಸ ಪೀಳಿಗೆಯ ಕರ್ನಲ್ 2.6 ಹೊರಹೊಮ್ಮುವಿಕೆಯನ್ನು ನೋಡುತ್ತಿದ್ದೇವೆ. ದುರದೃಷ್ಟವಶಾತ್, ಈ ಪುಸ್ತಕದ ಮೂಲವು ಹೊಸ ತಿರುಳನ್ನು ಒಳಗೊಂಡಿಲ್ಲ, ಆದ್ದರಿಂದ ಅನುವಾದಕನು ಹೊಸ ಜ್ಞಾನದೊಂದಿಗೆ ಅನುವಾದವನ್ನು ಪೂರಕಗೊಳಿಸುವ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತಾನೆ.

ನೀವು TimeSys' TimeStorm ನಂತಹ ಸಮಗ್ರ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳನ್ನು ಬಳಸಬಹುದು, ಇದು ಅಗತ್ಯವಿರುವ ಕರ್ನಲ್ ಆವೃತ್ತಿಯನ್ನು ಅವಲಂಬಿಸಿ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ ಅಸ್ಥಿಪಂಜರ ಮತ್ತು ಸಂಕಲನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸರಿಯಾಗಿ ರಚಿಸುತ್ತದೆ. ನೀವೇ ಎಲ್ಲವನ್ನೂ ಬರೆಯಲು ಹೋದರೆ, ಹೊಸ ಕರ್ನಲ್ ಪರಿಚಯಿಸಿದ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ನಿಮಗೆ ಕೆಲವು ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿ ಬೇಕಾಗುತ್ತದೆ.

2.6 ಕರ್ನಲ್‌ನ ಒಂದು ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಮೊಡ್ಯೂಲ್_ಇನಿಟ್() ಮತ್ತು ಮಾಡ್ಯೂಲ್_ಎಕ್ಸಿಟ್() ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಇನಿಶಿಯಲೈಸೇಶನ್ ಮತ್ತು ಟರ್ಮಿನೇಷನ್ ಫಂಕ್ಷನ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನೋಂದಾಯಿಸಲು ಬಳಸಬೇಕಾಗುತ್ತದೆ.

2.4 ಕರ್ನಲ್‌ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ MODULE_LISENCE() ಮ್ಯಾಕ್ರೋ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ಅನುಗುಣವಾದ ಎಚ್ಚರಿಕೆಗಳನ್ನು ನೋಡಲು ನೀವು ಬಯಸದಿದ್ದರೆ ಇನ್ನೂ ಅಗತ್ಯವಿದೆ. ಮ್ಯಾಕ್ರೋಗೆ ವರ್ಗಾಯಿಸಲು ನೀವು ಕೆಳಗಿನ ಪರವಾನಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು: "GPL", "GPL v2", "GPL ಮತ್ತು ಹೆಚ್ಚುವರಿ ಹಕ್ಕುಗಳು", "ಡ್ಯುಯಲ್ BSD/GPL" (BSD ಅಥವಾ GPL ಪರವಾನಗಿಗಳ ನಡುವೆ ಆಯ್ಕೆ), "ಡ್ಯುಯಲ್ MPL/GPL " (ಮೊಜಿಲ್ಲಾ ಅಥವಾ GPL ಪರವಾನಗಿಗಳ ನಡುವೆ ಆಯ್ಕೆ) ಮತ್ತು
"ಸ್ವಾಮ್ಯದ".

ಹೊಸ ಕರ್ನಲ್‌ಗೆ ಹೊಸ ಮಾಡ್ಯೂಲ್ ಸಂಕಲನ ಯೋಜನೆಯು ಹೆಚ್ಚು ಮಹತ್ವದ್ದಾಗಿದೆ, ಇದು ಮಾಡ್ಯೂಲ್‌ನ ಕೋಡ್‌ನಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಅದರ ಸಂಕಲನಕ್ಕಾಗಿ ಮೇಕ್‌ಫೈಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿಯೂ ಬದಲಾವಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಹೀಗಾಗಿ, ಮಾಡ್ಯೂಲ್ ಕೋಡ್‌ನಲ್ಲಿ ಅಥವಾ ಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಯ ವ್ಯಾಖ್ಯಾನವು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲ. ಅಗತ್ಯವಿದ್ದರೆ, ಹೊಸ ಸಂಕಲನ ಯೋಜನೆಯು ಈ ಮ್ಯಾಕ್ರೋಸಿಂಬಲ್ ಅನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಅಲ್ಲದೆ, ನೀವು __KERNEL__ ಮ್ಯಾಕ್ರೋಸಿಂಬಲ್‌ಗಳನ್ನು ಅಥವಾ KBUILD_BASENAME ಮತ್ತು KBUILD_MODNAME ನಂತಹ ಹೊಸದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಅಲ್ಲದೆ, ನೀವು ಸಂಕಲನದಲ್ಲಿ ಆಪ್ಟಿಮೈಸೇಶನ್ ಮಟ್ಟವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಾರದು (-O2 ಅಥವಾ ಇತರರು), ಏಕೆಂದರೆ ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸೇಶನ್ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಸಂಪೂರ್ಣ ಫ್ಲ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಸಂಕಲಿಸಲಾಗುತ್ತದೆ, ಅದರೊಂದಿಗೆ ನಿಮ್ಮ ಕರ್ನಲ್‌ನ ಎಲ್ಲಾ ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸಂಕಲಿಸಲಾಗಿದೆ - ಮೇಕ್ ಯುಟಿಲಿಟಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಗತ್ಯವಿರುವ ಸಂಪೂರ್ಣ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಈ ಕಾರಣಗಳಿಗಾಗಿ, 2.6 ಕರ್ನಲ್‌ಗಾಗಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಮೇಕ್‌ಫೈಲ್ ಹೆಚ್ಚು ಸರಳವಾಗಿದೆ. ಆದ್ದರಿಂದ hello.c ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ Makefile ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

Obj-m:= hello.o

ಆದಾಗ್ಯೂ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು, ನೀವು ಕರ್ನಲ್ ಮೂಲ ಟ್ರೀಗೆ ಬರೆಯುವ ಪ್ರವೇಶವನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಅಲ್ಲಿ ತಾತ್ಕಾಲಿಕ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಮಾಡ್ಯೂಲ್ ಮೂಲ ಕೋಡ್ ಹೊಂದಿರುವ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾದ 2.6 ಕರ್ನಲ್‌ಗಾಗಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಆಜ್ಞೆಯು ಈ ರೀತಿ ಇರಬೇಕು:

# make -C /usr/src/linux-2.6.1 SUBDIRS=`pwd` ಮಾಡ್ಯೂಲ್‌ಗಳು

ಆದ್ದರಿಂದ, ನಾವು ಮಾಡ್ಯೂಲ್ನ ಮೂಲವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಹಲೋ-2.6.c, ಕರ್ನಲ್ 2.6 ರಲ್ಲಿ ಸಂಕಲನಕ್ಕಾಗಿ:

//ಹಲೋ-2.6.c #ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು MODULE_LICENSE("GPL"); ಸ್ಥಿರ ಇಂಟ್ __init my_init(ಶೂನ್ಯ) ( printk("ಹಲೋ ವರ್ಲ್ಡ್\n"); ಹಿಂತಿರುಗಿ 0; ); ಸ್ಥಿರ ಶೂನ್ಯ __exit my_cleanup(ಶೂನ್ಯ) ( printk("Good bye\n"); ); ಮಾಡ್ಯೂಲ್_ಇನಿಟ್ (ಮೈ_ಇನಿಟ್); module_exit (my_cleanup);

ಅಂತೆಯೇ, ನಾವು ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ:

Obj-m:= hello-2.6.o

ಈ ಕೆಳಗಿನ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ನಮ್ಮ ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಾವು ಮೇಕ್ ಯುಟಿಲಿಟಿ ಎಂದು ಕರೆಯುತ್ತೇವೆ:

# ಮಾಡಿ -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 / ಲಿನಕ್ಸ್-2.6.3"

ಸಂಕಲನದ ಅಂತಿಮ ಫಲಿತಾಂಶವು ಕರ್ನಲ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಬಹುದಾದ ಮಾಡ್ಯೂಲ್ ಫೈಲ್ 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 ಮತ್ತು ಇನ್‌ಪುಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳಿಂದ ಅಕ್ಷರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಮಾಡ್ಯೂಲ್‌ಗಳ ಅನುಕ್ರಮ ಲೋಡಿಂಗ್‌ನಿಂದ ಅರಿತುಕೊಂಡ ಈ ಸಂಬಂಧವನ್ನು ಮಾಡ್ಯೂಲ್ ಸ್ಟಾಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಸಂಕೀರ್ಣ ಮಾಡ್ಯೂಲ್ ಯೋಜನೆಗಳನ್ನು ರಚಿಸುವಾಗ ಮಾಡ್ಯೂಲ್ ಸ್ಟಾಕ್ ಅನ್ನು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ. ಸಾಧನ ಚಾಲಕ ಕೋಡ್ ಅನ್ನು ಹಾರ್ಡ್‌ವೇರ್-ಅವಲಂಬಿತ ಮತ್ತು ಹಾರ್ಡ್‌ವೇರ್-ಸ್ವತಂತ್ರ ಭಾಗಗಳಾಗಿ ಬೇರ್ಪಡಿಸಲು ಈ ಅಮೂರ್ತತೆಯು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ವೀಡಿಯೊ-ಫಾರ್-ಲಿನಕ್ಸ್ ಡ್ರೈವರ್ ಸೆಟ್ ಕೋರ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅದು ಕಡಿಮೆ-ಮಟ್ಟದ ಡ್ರೈವರ್‌ಗಾಗಿ ಚಿಹ್ನೆಗಳನ್ನು ರಫ್ತು ಮಾಡುತ್ತದೆ, ಅದು ಬಳಸುತ್ತಿರುವ ಹಾರ್ಡ್‌ವೇರ್‌ನ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಿಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರಕಾರ, ನೀವು ಮುಖ್ಯ ವೀಡಿಯೊ ಮಾಡ್ಯೂಲ್ ಮತ್ತು ನಿಮ್ಮ ಹಾರ್ಡ್‌ವೇರ್‌ಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತೀರಿ. ಅದೇ ರೀತಿಯಲ್ಲಿ, ಸಮಾನಾಂತರ ಪೋರ್ಟ್‌ಗಳಿಗೆ ಬೆಂಬಲ ಮತ್ತು USB ಸಾಧನಗಳಂತಹ ಸಂಪರ್ಕಿತ ಸಾಧನಗಳ ವ್ಯಾಪಕ ವರ್ಗವನ್ನು ಅಳವಡಿಸಲಾಗಿದೆ. ಸಮಾನಾಂತರ ಪೋರ್ಟ್ ಸಿಸ್ಟಮ್ ಸ್ಟಾಕ್ ಅನ್ನು ಅಂಜೂರದಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. 2-2. ಬಾಣಗಳು ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ಕರ್ನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಇಂಟರ್ಫೇಸ್ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ತೋರಿಸುತ್ತವೆ. ಕಾರ್ಯಗಳ ಮಟ್ಟದಲ್ಲಿ ಮತ್ತು ಕಾರ್ಯಗಳಿಂದ ನಿರ್ವಹಿಸಲ್ಪಡುವ ಡೇಟಾ ರಚನೆಗಳ ಮಟ್ಟದಲ್ಲಿ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಕೈಗೊಳ್ಳಬಹುದು.

ಚಿತ್ರ 2-2. ಸಮಾನಾಂತರ ಪೋರ್ಟ್ ಮಾಡ್ಯೂಲ್ ಸ್ಟಾಕ್

ಸ್ಟಾಕ್ ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಬಳಸುವಾಗ, ಮೋಡ್ಪ್ರೋಬ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ. ಮಾಡ್‌ಪ್ರೊಬ್ ಉಪಯುಕ್ತತೆಯ ಕಾರ್ಯವು ಹಲವು ವಿಧಗಳಲ್ಲಿ insmod ಉಪಯುಕ್ತತೆಯನ್ನು ಹೋಲುತ್ತದೆ, ಆದರೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ, ಅದು ಅದರ ಆಧಾರವಾಗಿರುವ ಅವಲಂಬನೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ, ಅಗತ್ಯವಿರುವ ಮಾಡ್ಯೂಲ್ ಸ್ಟಾಕ್ ತುಂಬುವವರೆಗೆ ಅಗತ್ಯ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ, ಒಂದು modprobe ಆಜ್ಞೆಯು insmod ಆಜ್ಞೆಗೆ ಬಹು ಕರೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. modprobe ಆಜ್ಞೆಯು insmod ಸುತ್ತಲೂ ಬುದ್ಧಿವಂತ ಹೊದಿಕೆಯಾಗಿದೆ ಎಂದು ನೀವು ಹೇಳಬಹುದು. ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಿಂದ ನಿಮ್ಮ ಸ್ವಂತ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ಹೊರತುಪಡಿಸಿ, ನೀವು ಇನ್‌ಸ್‌ಮೋಡ್‌ನ ಬದಲಿಗೆ ಎಲ್ಲೆಡೆಯೂ ಮೋಡ್‌ಪ್ರೊಬ್ ಅನ್ನು ಬಳಸಬಹುದು, ಏಕೆಂದರೆ modprobe ನಿರ್ದಿಷ್ಟ ಮಾಡ್ಯೂಲ್ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಮಾತ್ರ ನೋಡುತ್ತದೆ ಮತ್ತು ಸಂಭವನೀಯ ಅವಲಂಬನೆಗಳನ್ನು ಪೂರೈಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುವುದು ಸಮಸ್ಯೆಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಸರಳಗೊಳಿಸುವ ಮೂಲಕ ಅಭಿವೃದ್ಧಿ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಅಧ್ಯಾಯ 1, "ಸಾಧನ ಡ್ರೈವರ್‌ಗಳಿಗೆ ಪರಿಚಯ" ನಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಅನುಷ್ಠಾನ ಕಾರ್ಯವಿಧಾನ ಮತ್ತು ನಿಯಂತ್ರಣ ನೀತಿಯ ನಡುವಿನ ಪ್ರತ್ಯೇಕತೆಯಂತೆಯೇ ಇರುತ್ತದೆ.

ವಿಶಿಷ್ಟವಾಗಿ ಮಾಡ್ಯೂಲ್ ಯಾವುದೇ ಚಿಹ್ನೆಗಳನ್ನು ರಫ್ತು ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದೇ ಅದರ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದಾದರೆ ನೀವು ಚಿಹ್ನೆಗಳನ್ನು ರಫ್ತು ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಸ್ಥಿರವಲ್ಲದ ಅಕ್ಷರಗಳ ರಫ್ತು ತಡೆಯಲು ನೀವು ವಿಶೇಷ ನಿರ್ದೇಶನವನ್ನು ಸೇರಿಸಬೇಕಾಗಬಹುದು, ಏಕೆಂದರೆ ಮಾಡ್ಯೂಟಿಲ್‌ಗಳ ಹೆಚ್ಚಿನ ಅನುಷ್ಠಾನಗಳು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಎಲ್ಲವನ್ನೂ ರಫ್ತು ಮಾಡುತ್ತವೆ.

Linux ಕರ್ನಲ್ ಹೆಡರ್ ಫೈಲ್‌ಗಳು ನಿಮ್ಮ ಚಿಹ್ನೆಗಳ ಗೋಚರತೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ, ಇದರಿಂದಾಗಿ ಕರ್ನಲ್ ಚಿಹ್ನೆಯ ಟೇಬಲ್‌ನ ನೇಮ್‌ಸ್ಪೇಸ್ ಮಾಲಿನ್ಯಗೊಳ್ಳುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ವಿವರಿಸಲಾದ ಕಾರ್ಯವಿಧಾನವು ಆವೃತ್ತಿ 2.1.18 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಕರ್ನಲ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಕರ್ನಲ್ 2.0 ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ನಿಯಂತ್ರಣ ಕಾರ್ಯವಿಧಾನವನ್ನು ಹೊಂದಿತ್ತು
ಚಿಹ್ನೆ ಗೋಚರತೆ, ಇದನ್ನು ಅಧ್ಯಾಯದ ಕೊನೆಯಲ್ಲಿ ವಿವರಿಸಲಾಗುವುದು.

ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ಗೆ ಚಿಹ್ನೆಗಳನ್ನು ರಫ್ತು ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಮ್ಯಾಕ್ರೋ ಕರೆಯನ್ನು ಮಾಡ್ಯೂಲ್‌ನ ಮೂಲ ಫೈಲ್‌ನಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಇರಿಸಬಹುದು:

EXPORT_NO_SYMBOLS;

ಈ ಮ್ಯಾಕ್ರೋ ಕರೆ, linux/module.h ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ, ಅಸೆಂಬ್ಲರ್ ನಿರ್ದೇಶನವಾಗಿ ವಿಸ್ತರಿಸುತ್ತದೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ವಿವಿಧ ಕರ್ನಲ್‌ಗಳಿಗೆ ಪೋರ್ಟಬಲ್ ಆಗಿರುವ ಕೋಡ್ ಅನ್ನು ರಚಿಸುವಾಗ, ಈ ಮ್ಯಾಕ್ರೋ ಕರೆಯನ್ನು ಮಾಡ್ಯೂಲ್‌ನ ಇನಿಶಿಯಲೈಸೇಶನ್ ಫಂಕ್ಷನ್‌ನಲ್ಲಿ (init_module) ಇರಿಸುವ ಅವಶ್ಯಕತೆಯಿದೆ, ಏಕೆಂದರೆ ಹಳೆಯ ಕರ್ನಲ್ ಆವೃತ್ತಿಗಳಿಗಾಗಿ ನಮ್ಮ sysdep.h ಫೈಲ್‌ನಲ್ಲಿ ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಈ ಮ್ಯಾಕ್ರೋ ಆವೃತ್ತಿಯು ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇಲ್ಲಿ.

ಮತ್ತೊಂದೆಡೆ, ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಕೆಲವು ಚಿಹ್ನೆಗಳನ್ನು ನೀವು ರಫ್ತು ಮಾಡಬೇಕಾದರೆ, ನೀವು ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ
EXPORT_SYMTAB. ಈ ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು ಮೊದಲು module.h ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ. ಇದು ಸಾಮಾನ್ಯ ಅಭ್ಯಾಸ
ಧ್ವಜದ ಮೂಲಕ ಈ ಮ್ಯಾಕ್ರೋ ಪಾತ್ರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು -ಡಿಮೇಕ್‌ಫೈಲ್‌ನಲ್ಲಿ.

ಮ್ಯಾಕ್ರೋ ಚಿಹ್ನೆ ಇದ್ದರೆ EXPORT_SYMTABವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ನಂತರ ಒಂದು ಜೋಡಿ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತ್ಯೇಕ ಚಿಹ್ನೆಗಳನ್ನು ರಫ್ತು ಮಾಡಬಹುದು:

EXPORT_SYMBOL(ಹೆಸರು); EXPORT_SYMBOL_NOVERS(ಹೆಸರು);

ಈ ಎರಡು ಮ್ಯಾಕ್ರೋಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ನೀಡಲಾದ ಚಿಹ್ನೆಯನ್ನು ಮಾಡ್ಯೂಲ್‌ನ ಹೊರಗೆ ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ. ವ್ಯತ್ಯಾಸವೆಂದರೆ ಮ್ಯಾಕ್ರೋ EXPORT_SYMBOL_NOVERSಆವೃತ್ತಿಯ ಮಾಹಿತಿಯಿಲ್ಲದೆ ಚಿಹ್ನೆಯನ್ನು ರಫ್ತು ಮಾಡುತ್ತದೆ (ಅಧ್ಯಾಯ 11 “kmod ಮತ್ತು ಸುಧಾರಿತ ಮಾಡ್ಯುಲರೈಸೇಶನ್” ನೋಡಿ). ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ
ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ , ಹೇಳಿರುವುದು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಗೆ ಸಾಕಷ್ಟು ಸಾಕಾಗುತ್ತದೆ
ಮ್ಯಾಕ್ರೋಗಳು.

ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮತ್ತು ಪೂರ್ಣಗೊಳಿಸುವುದು

ಹೇಳಿದಂತೆ, init_module() ಕಾರ್ಯವು ಮಾಡ್ಯೂಲ್‌ನ ಕ್ರಿಯಾತ್ಮಕ ಘಟಕಗಳನ್ನು ಕರ್ನಲ್‌ನೊಂದಿಗೆ ನೋಂದಾಯಿಸುತ್ತದೆ. ಅಂತಹ ನೋಂದಣಿಯ ನಂತರ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸುವ ಅಪ್ಲಿಕೇಶನ್ ಕರ್ನಲ್ ಒದಗಿಸಿದ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರವೇಶ ಬಿಂದುಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಮಾಡ್ಯೂಲ್‌ಗಳು ಹಲವಾರು ವಿಭಿನ್ನ ಘಟಕಗಳನ್ನು ನೋಂದಾಯಿಸಬಹುದು, ಇದು ನೋಂದಾಯಿಸಿದಾಗ ಮಾಡ್ಯೂಲ್ ಕಾರ್ಯಗಳ ಹೆಸರುಗಳು. ಉದ್ದೇಶಿತ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕಾರ್ಯಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಡೇಟಾ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ಕರ್ನಲ್ ನೋಂದಣಿ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾಗುತ್ತದೆ.

ಅಧ್ಯಾಯ 1 ರಲ್ಲಿ, "ಸಾಧನ ಡ್ರೈವರ್‌ಗಳಿಗೆ ಪರಿಚಯ", ಸಾಧನಗಳ ಮುಖ್ಯ ಪ್ರಕಾರಗಳ ವರ್ಗೀಕರಣವನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ. ನೀವು ಅಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಸಾಧನದ ಪ್ರಕಾರಗಳನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಯಾವುದೇ ಇತರ ಸಾಫ್ಟ್‌ವೇರ್ ಅಮೂರ್ತತೆಗಳನ್ನು ಸಹ ನೋಂದಾಯಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, /proc ಫೈಲ್‌ಗಳು, ಇತ್ಯಾದಿ. ಡ್ರೈವರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಕರ್ನಲ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದಾದ ಎಲ್ಲವನ್ನೂ ಡ್ರೈವರ್ ಆಗಿ ನೋಂದಾಯಿಸಬಹುದು. .

ನಿಮ್ಮ ಕರ್ನಲ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಿಕೊಂಡು ನೋಂದಾಯಿಸಲಾದ ಡ್ರೈವರ್‌ಗಳ ಪ್ರಕಾರಗಳ ಕುರಿತು ನೀವು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದರೆ, ನೀವು ಕರ್ನಲ್ ಮೂಲಗಳಲ್ಲಿ EXPORT_SYMBOL ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಹುಡುಕಾಟವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ವಿವಿಧ ಡ್ರೈವರ್‌ಗಳು ನೀಡುವ ಪ್ರವೇಶ ಬಿಂದುಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು. ನಿಯಮದಂತೆ, ನೋಂದಣಿ ಕಾರ್ಯಗಳು ತಮ್ಮ ಹೆಸರಿನಲ್ಲಿ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸುತ್ತವೆ ನೋಂದಣಿ_,
ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತೊಂದು ಸಂಭವನೀಯ ಮಾರ್ಗವೆಂದರೆ ಸಬ್ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹುಡುಕುವುದು ನೋಂದಣಿ_ grep ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು /proc/ksyms ಕಡತದಲ್ಲಿ. ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, 2.6.x ಕರ್ನಲ್‌ನಲ್ಲಿ /proc/ksyms ಫೈಲ್ ಅನ್ನು /proc/modules ನೊಂದಿಗೆ ಬದಲಾಯಿಸಲಾಗಿದೆ.

init_module ನಲ್ಲಿ ನಿರ್ವಹಿಸುವಲ್ಲಿ ದೋಷ

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ಯಾವುದೇ ರೀತಿಯ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸುವ ಮೊದಲು ನೀವು ಈಗಾಗಲೇ ಪೂರ್ಣಗೊಳಿಸಿದ ಪ್ರಾರಂಭವನ್ನು ರದ್ದುಗೊಳಿಸಬೇಕು. ದೋಷ ಸಂಭವಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿಯೋಜಿಸುವಾಗ ಸಿಸ್ಟಮ್ನಲ್ಲಿ ಸಾಕಷ್ಟು ಮೆಮೊರಿಯ ಕೊರತೆಯಿಂದಾಗಿ. ದುರದೃಷ್ಟವಶಾತ್, ಇದು ಸಂಭವಿಸಬಹುದು ಮತ್ತು ಉತ್ತಮ ಕೋಡ್ ಅಂತಹ ಸಂದರ್ಭಗಳನ್ನು ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

init_module() ಇನಿಶಿಯಲೈಸೇಶನ್ ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸುವ ಮೊದಲು ನೋಂದಾಯಿಸಲಾದ ಅಥವಾ ನಿಯೋಜಿಸಲಾದ ಯಾವುದನ್ನಾದರೂ ರದ್ದುಗೊಳಿಸಬೇಕು ಅಥವಾ ಸ್ವತಃ ಮುಕ್ತಗೊಳಿಸಬೇಕು, ಏಕೆಂದರೆ ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಪ್ರಾರಂಭಿಕ ದೋಷಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಕೋಡ್‌ನಿಂದ ಎರವಲು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ನೀಡುವುದನ್ನು ರದ್ದುಗೊಳಿಸುವುದಿಲ್ಲ. ನೀವು ಹಿಂತಿರುಗಿಸದಿದ್ದರೆ ಅಥವಾ ಪೂರ್ಣಗೊಂಡ ನೋಂದಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಕರ್ನಲ್ ಅಸ್ಥಿರ ಸ್ಥಿತಿಯಲ್ಲಿ ಉಳಿಯುತ್ತದೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಮತ್ತೆ ಲೋಡ್ ಮಾಡಿದಾಗ
ಈಗಾಗಲೇ ನೋಂದಾಯಿತ ಅಂಶಗಳ ನೋಂದಣಿಯನ್ನು ಪುನರಾವರ್ತಿಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಮತ್ತು ಹಿಂದೆ ಮಾಡಿದ ನೋಂದಣಿಯನ್ನು ರದ್ದುಗೊಳಿಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ init_module() ಕಾರ್ಯದ ಹೊಸ ನಿದರ್ಶನದಲ್ಲಿ ನೀವು ನೋಂದಾಯಿತ ಕಾರ್ಯಗಳ ವಿಳಾಸಗಳ ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. ಸಿಸ್ಟಮ್ ಅನ್ನು ಅದರ ಹಿಂದಿನ ಸ್ಥಿತಿಗೆ ಮರುಸ್ಥಾಪಿಸಲು ವಿವಿಧ ಸಂಕೀರ್ಣ ತಂತ್ರಗಳ ಬಳಕೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಸಿಸ್ಟಮ್ ಅನ್ನು ಸರಳವಾಗಿ ರೀಬೂಟ್ ಮಾಡುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

ಮಾಡ್ಯೂಲ್ ಪ್ರಾರಂಭಿಕ ದೋಷಗಳು ಸಂಭವಿಸಿದಾಗ ಸಿಸ್ಟಮ್ನ ಹಿಂದಿನ ಸ್ಥಿತಿಯನ್ನು ಮರುಸ್ಥಾಪಿಸುವ ಅನುಷ್ಠಾನವು ಗೊಟೊ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ ಈ ಆಪರೇಟರ್ ಅನ್ನು ಅತ್ಯಂತ ಋಣಾತ್ಮಕವಾಗಿ ಮತ್ತು ದ್ವೇಷದಿಂದ ಕೂಡ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಅವನು ತುಂಬಾ ಉಪಯುಕ್ತನಾಗಿರುತ್ತಾನೆ. ಆದ್ದರಿಂದ, ಕರ್ನಲ್‌ನಲ್ಲಿ, ಮಾಡ್ಯೂಲ್ ಪ್ರಾರಂಭಿಕ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಗೊಟೊ ಹೇಳಿಕೆಯನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಕೆಳಗಿನ ಸರಳ ಕೋಡ್, ಡಮ್ಮಿ ನೋಂದಣಿ ಮತ್ತು ನೋಂದಣಿ ಮಾಡದ ಕಾರ್ಯಗಳನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಿಕೊಂಡು, ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಈ ವಿಧಾನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

Int init_module(noid) ( int err; /* ನೋಂದಣಿ ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು ಹೆಸರನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ */ err = register_this(ptr1, "skull"); if (err) goto fail_this; err = register_that(ptr2, "skull"); ವೇಳೆ (ಎರ್ರ್) ವಿಫಲ_ಅದು; ದೋಷ = ನೋಂದಣಿ_ಅವು(ptr3, "ತಲೆಬುರುಡೆ"); ವೇಳೆ (ತಪ್ಪು) ವಿಫಲವಾದರೆ ತಲೆಬುರುಡೆ"); ವಿಫಲ_ಇದು: ತಪ್ಪು ಹಿಂತಿರುಗಿ; /* ದೋಷವನ್ನು ಪ್ರಚಾರ ಮಾಡಿ */ )

ಈ ಉದಾಹರಣೆಯು ಮೂರು ಮಾಡ್ಯೂಲ್ ಘಟಕಗಳನ್ನು ನೋಂದಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ನೋಂದಣಿ ದೋಷ ಸಂಭವಿಸಿದಾಗ ಗೊಟೊ ಹೇಳಿಕೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಲೋಡ್ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸುವ ಮೊದಲು ನೋಂದಾಯಿತ ಘಟಕಗಳನ್ನು ನೋಂದಾಯಿಸಲಾಗಿಲ್ಲ.

ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಓದಲು ಗೊಟೊ ಹೇಳಿಕೆಯನ್ನು ಬಳಸುವ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯೆಂದರೆ ಯಶಸ್ವಿ ಮಾಡ್ಯೂಲ್ ನೋಂದಣಿಗಳನ್ನು "ನೆನಪಿಸಿಕೊಳ್ಳುವುದು" ಮತ್ತು ದೋಷ ಸಂಭವಿಸಿದಾಗ ಈ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಲು cleanup_module() ಗೆ ಕರೆ ಮಾಡುವುದು. cleanup_module() ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ಪ್ರಾರಂಭಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸಿದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ. init_module() ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯವು ಇರಬೇಕು
ಮಾಡ್ಯೂಲ್ ಪ್ರಾರಂಭಿಕ ದೋಷ ಕೋಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ನಲ್ಲಿ, ದೋಷ ಕೋಡ್ ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ ಮಾಡಿದ ವ್ಯಾಖ್ಯಾನಗಳ ಗುಂಪಿನಿಂದ ನಕಾರಾತ್ಮಕ ಸಂಖ್ಯೆಯಾಗಿದೆ. . -ENODEV, -ENOMEM, ಇತ್ಯಾದಿ ಕಾಯ್ದಿರಿಸಿದ ದೋಷ ಕೋಡ್‌ಗಳಿಗಾಗಿ ಸಾಂಕೇತಿಕ ಜ್ಞಾಪಕವನ್ನು ಬಳಸಲು ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಈ ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿ. ಅಂತಹ ಜ್ಞಾಪಕವನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಮಾಡ್ಯೂಟಿಲ್ಸ್ ಪ್ಯಾಕೇಜ್‌ನಿಂದ ಉಪಯುಕ್ತತೆಗಳ ಕೆಲವು ಆವೃತ್ತಿಗಳು ಹಿಂತಿರುಗಿದ ದೋಷ ಕೋಡ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಿಲ್ಲ ಮತ್ತು “ಸಾಧನ ಕಾರ್ಯನಿರತ” ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುವುದಿಲ್ಲ ಎಂದು ಗಮನಿಸಬೇಕು.
init_modules() ಫಂಕ್ಷನ್‌ನಿಂದ ಹಿಂತಿರುಗಿಸಲಾದ ಸಂಪೂರ್ಣ ವಿಭಿನ್ನ ಸ್ವಭಾವದ ದೋಷಗಳ ಸಂಪೂರ್ಣ ಗುಂಪಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ. ಪ್ಯಾಕೇಜ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಇದು
ಕಿರಿಕಿರಿ ದೋಷವನ್ನು ಸರಿಪಡಿಸಲಾಗಿದೆ.

ಮೇಲಿನ ಪ್ರಕರಣಕ್ಕಾಗಿ cleanup_module() ಫಂಕ್ಷನ್ ಕೋಡ್, ಉದಾಹರಣೆಗೆ, ಹೀಗಿರಬಹುದು:

ಶೂನ್ಯ ಕ್ಲೀನಪ್_ಮಾಡ್ಯೂಲ್(ಶೂನ್ಯ) (ಅನ್ರಿಜಿಸ್ಟರ್_ಅವು(ptr3, "ತಲೆಬುರುಡೆ"); ನೋಂದಣಿ ರದ್ದುಮಾಡಿ

ನಿಮ್ಮ ಆರಂಭಿಸುವಿಕೆ ಮತ್ತು ಮುಕ್ತಾಯದ ಕೋಡ್ ಇಲ್ಲಿ ವಿವರಿಸಿರುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ, ಗೊಟೊ ಹೇಳಿಕೆಯನ್ನು ಬಳಸುವುದರಿಂದ ಹಾರ್ಡ್-ಟು-ರೀಡ್ ಪ್ರೋಗ್ರಾಂ ಪಠ್ಯಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು ಏಕೆಂದರೆ ಟರ್ಮಿನೇಷನ್ ಕೋಡ್ ಅನ್ನು init_module() ಫಂಕ್ಷನ್‌ನಲ್ಲಿ goto ಪರಿವರ್ತನೆಗಳಿಗಾಗಿ ಬಹು ಲೇಬಲ್‌ಗಳನ್ನು ಬಳಸಿ ಪುನರಾವರ್ತಿಸಬೇಕು. ಈ ಕಾರಣಕ್ಕಾಗಿ, init_module() ಫಂಕ್ಷನ್‌ನಲ್ಲಿ cleanup_module() ಫಂಕ್ಷನ್‌ಗೆ ಕರೆಯನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ಟ್ರಿಕ್ ಆಗಿದೆ, ಮಾಡ್ಯೂಲ್ ಲೋಡಿಂಗ್ ದೋಷ ಸಂಭವಿಸಿದಾಗ ಯಶಸ್ವಿ ಆರಂಭದ ವ್ಯಾಪ್ತಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸುತ್ತದೆ.

init_module() ಮತ್ತು cleanup_module() ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂಬುದಕ್ಕೆ ಕೆಳಗೆ ಉದಾಹರಣೆಯಾಗಿದೆ. ಈ ಉದಾಹರಣೆಯು ಜಾಗತಿಕವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಅದು ಯಶಸ್ವಿ ಆರಂಭದ ವ್ಯಾಪ್ತಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಏನನ್ನಾದರೂ ರಚಿಸಿ * ಐಟಂ 1; struct ಏನೋ ಬೇರೆ *ಐಟಂ2; ಇಂಟ್ ಸ್ಟಫ್_ಓಕೆ; void cleanup_module(ಅನೂರ್ಜಿತ) (ಐಟಂ1) ಬಿಡುಗಡೆ_ವಿಷಯ (ಐಟಂ1); ವೇಳೆ (ಐಟಂ2) ಬಿಡುಗಡೆ_ಥಿಂಗ್2(ಐಟಂ2); ವೇಳೆ (ಸ್ಟಫ್_ಒಕೆ) ನೋಂದಾಯಿಸದ_ಸ್ಟಫ್ (); ಹಿಂತಿರುಗಿ; ) int init_module(ಅನೂರ್ಜಿತ) ( int err = -ENOMEM; ಐಟಂ1 = ಹಂಚಿಕೆ (ವಾದಗಳು); item2 = allocate_thing2(arguments2); ಒಂದು ವೇಳೆ (! item2 || ! item2) goto fail ಯಶಸ್ಸು */ ವಿಫಲತೆ: cleanup_module (); ಹಿಂತಿರುಗಿ ದೋಷ; )

ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಾರಂಭಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಕೀರ್ಣತೆಯನ್ನು ಅವಲಂಬಿಸಿ, ಮಾಡ್ಯೂಲ್ ಪ್ರಾರಂಭಿಕ ದೋಷಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ನೀವು ಇಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾದ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸಲು ಬಯಸಬಹುದು.

ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಕೌಂಟರ್

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಇಳಿಸಬಹುದೇ ಎಂದು ನಿರ್ಧರಿಸಲು ಸಿಸ್ಟಮ್ ಪ್ರತಿ ಮಾಡ್ಯೂಲ್‌ಗೆ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸಿಸ್ಟಮ್‌ಗೆ ಈ ಮಾಹಿತಿಯ ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಯಾರಾದರೂ ಅಥವಾ ಯಾವುದಾದರೂ ಆಕ್ರಮಿಸಿಕೊಂಡಿದ್ದರೆ ಅದನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ - ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಅನ್ನು ಆರೋಹಿಸಿದರೆ ನೀವು ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಡ್ರೈವರ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ಕೆಲವು ಪ್ರಕ್ರಿಯೆಯು ಈ ಸಾಧನವನ್ನು ಬಳಸಿದರೆ ನೀವು ಅಕ್ಷರ ಸಾಧನ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಇಲ್ಲದಿದ್ದರೆ,
ಇದು ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ಗೆ ಕಾರಣವಾಗಬಹುದು - ವಿಭಜನೆ ದೋಷ ಅಥವಾ ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್.

ಆಧುನಿಕ ಕರ್ನಲ್‌ಗಳಲ್ಲಿ, ಮುಂದಿನ ಅಧ್ಯಾಯದಲ್ಲಿ ನಾವು ನೋಡುವ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಸ್ಟಮ್ ನಿಮಗೆ ಸ್ವಯಂಚಾಲಿತ ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕರ್ನಲ್ ಆವೃತ್ತಿಯ ಹೊರತಾಗಿಯೂ, ನೀವು ಈ ಕೌಂಟರ್‌ನ ಹಸ್ತಚಾಲಿತ ನಿಯಂತ್ರಣವನ್ನು ಬಳಸಬಹುದು. ಹೀಗಾಗಿ, ಕರ್ನಲ್‌ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಬಳಸಬೇಕಾದ ಕೋಡ್ ಕೆಳಗಿನ ಮೂರು ಮ್ಯಾಕ್ರೋಗಳಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಲೆಕ್ಕಪತ್ರ ಮಾದರಿಯನ್ನು ಬಳಸಬೇಕು:

ಈ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ , ಮತ್ತು ಅವರು ವಿಶೇಷ ಆಂತರಿಕ ಡೇಟಾ ರಚನೆಯನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುತ್ತಾರೆ, ಅದಕ್ಕೆ ನೇರ ಪ್ರವೇಶವು ಅಪೇಕ್ಷಣೀಯವಲ್ಲ. ವಾಸ್ತವವೆಂದರೆ ಆಂತರಿಕ ರಚನೆ ಮತ್ತು ಈ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧಾನವು ಆವೃತ್ತಿಯಿಂದ ಆವೃತ್ತಿಗೆ ಬದಲಾಗಬಹುದು, ಆದರೆ ಈ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸುವ ಬಾಹ್ಯ ಇಂಟರ್ಫೇಸ್ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ.

ನೀವು ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ MOD_IN_USE cleanup_module() ಫಂಕ್ಷನ್ ಕೋಡ್‌ನಲ್ಲಿ, ಏಕೆಂದರೆ kernel/module.c ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ sys_delete_module() ಸಿಸ್ಟಮ್ ಕರೆಯಲ್ಲಿ ಕ್ಲೀನ್‌ಅಪ್_ಮೊಡ್ಯೂಲ್() ಅನ್ನು ಕರೆಯುವ ಮೊದಲು ಈ ಪರಿಶೀಲನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಕೌಂಟರ್‌ನ ಸರಿಯಾದ ನಿರ್ವಹಣೆಯು ಸಿಸ್ಟಮ್ ಸ್ಥಿರತೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಬಳಕೆಯಾಗದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅನ್‌ಲೋಡ್ ಮಾಡಲು ಕರ್ನಲ್ ನಿರ್ಧರಿಸಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ. ಮಾಡ್ಯೂಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿನ ಸಾಮಾನ್ಯ ತಪ್ಪು ಈ ಕೌಂಟರ್‌ನ ತಪ್ಪಾದ ನಿಯಂತ್ರಣವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ವಿನಂತಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಕೆಲವು ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಂಡಾಗ, ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಆ. ಅಂತಹ ಪ್ರೋಗ್ರಾಮರ್ ಈ ಕೌಂಟರ್ ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಅಂಕಿಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಉದ್ದೇಶಿಸಿದೆ ಎಂದು ಊಹಿಸುತ್ತದೆ, ಆದರೆ ವಾಸ್ತವವಾಗಿ, ಇದು ಮಾಡ್ಯೂಲ್ನ ಪ್ರಸ್ತುತ ಆಕ್ಯುಪೆನ್ಸಿಗೆ ಕೌಂಟರ್ ಆಗಿದೆ, ಅಂದರೆ. ಕ್ಷಣದಲ್ಲಿ ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಕ್ರಿಯೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ, ಮಾಡ್ಯೂಲ್ಗೆ ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ, ನೀವು ಕರೆ ಮಾಡಬೇಕು MOD_INC_USE_COUNTಯಾವುದೇ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡುವ ಮೊದಲು, ಮತ್ತು MOD_DEC_USE_COUNTಅವರು ಪೂರ್ಣಗೊಂಡ ನಂತರ.

ನೀವು ಅದರ ಬಳಕೆಯ ಕೌಂಟರ್‌ನ ನಿಯಂತ್ರಣವನ್ನು ಕಳೆದುಕೊಂಡರೆ, ಸ್ಪಷ್ಟ ಕಾರಣಗಳಿಗಾಗಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಮಾಡ್ಯೂಲ್ ಅಭಿವೃದ್ಧಿ ಹಂತದಲ್ಲಿ ಈ ಪರಿಸ್ಥಿತಿಯು ಹೆಚ್ಚಾಗಿ ಸಂಭವಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, NULL ಪಾಯಿಂಟರ್ ಅನ್ನು ಡಿರೆಫರೆನ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಪ್ರಕ್ರಿಯೆಯು ಸ್ಥಗಿತಗೊಳ್ಳಬಹುದು ಮತ್ತು ನೀವು ಅದರ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಹಿಂತಿರುಗಿಸುವವರೆಗೆ ಅಂತಹ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಮಾಡ್ಯೂಲ್ ಡೀಬಗ್ ಮಾಡುವ ಹಂತದಲ್ಲಿ ಈ ಸಮಸ್ಯೆಗೆ ಸಂಭವನೀಯ ಪರಿಹಾರವೆಂದರೆ ಮರು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಮಾಡ್ಯೂಲ್ ಬಳಕೆಯ ಕೌಂಟರ್‌ನ ನಿಯಂತ್ರಣವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತ್ಯಜಿಸುವುದು MOD_INC_USE_COUNTಮತ್ತು MOD_DEC_USE_COUNTಖಾಲಿ ಕೋಡ್ ಆಗಿ. ಮಾಡ್ಯೂಲ್‌ನ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಒತ್ತಾಯಿಸುವ ioctl() ಕರೆಯನ್ನು ರಚಿಸುವುದು ಮತ್ತೊಂದು ಪರಿಹಾರವಾಗಿದೆ. ನಾವು ಇದನ್ನು ಅಧ್ಯಾಯ 5, “ವರ್ಧಿತ ಚಾರ್ ಡ್ರೈವರ್ ಕಾರ್ಯಾಚರಣೆಗಳು” ನಲ್ಲಿ “ioctl ಆರ್ಗ್ಯುಮೆಂಟ್ ಬಳಸುವುದು” ವಿಭಾಗದಲ್ಲಿ ಕವರ್ ಮಾಡುತ್ತೇವೆ. ಸಹಜವಾಗಿ, ಬಳಸಲು ಸಿದ್ಧವಾದ ಡ್ರೈವರ್ನಲ್ಲಿ, ಕೌಂಟರ್ನೊಂದಿಗೆ ಇಂತಹ ಮೋಸದ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ಗಳನ್ನು ಹೊರಗಿಡಬೇಕು, ಆದಾಗ್ಯೂ, ಡೀಬಗ್ ಮಾಡುವ ಹಂತದಲ್ಲಿ, ಅವರು ಡೆವಲಪರ್ ಸಮಯವನ್ನು ಉಳಿಸುತ್ತಾರೆ ಮತ್ತು ಸಾಕಷ್ಟು ಸ್ವೀಕಾರಾರ್ಹರಾಗಿದ್ದಾರೆ.

ಪ್ರತಿ ಮಾಡ್ಯೂಲ್‌ಗೆ ಪ್ರಸ್ತುತ ಸಿಸ್ಟಮ್ ಬಳಕೆಯ ಕೌಂಟರ್ ಅನ್ನು ನೀವು /proc/modules ಫೈಲ್‌ನಲ್ಲಿ ಪ್ರತಿ ಪ್ರವೇಶದ ಮೂರನೇ ಕ್ಷೇತ್ರದಲ್ಲಿ ಕಾಣಬಹುದು. ಈ ಫೈಲ್ ಪ್ರಸ್ತುತ ಲೋಡ್ ಮಾಡಲಾದ ಮಾಡ್ಯೂಲ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ - ಪ್ರತಿ ಮಾಡ್ಯೂಲ್‌ಗೆ ಒಂದು ಸಾಲು. ಸಾಲಿನ ಮೊದಲ ಕ್ಷೇತ್ರವು ಮಾಡ್ಯೂಲ್‌ನ ಹೆಸರನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಎರಡನೇ ಕ್ಷೇತ್ರವು ಮೆಮೊರಿಯಲ್ಲಿ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಆಕ್ರಮಿಸಲ್ಪಟ್ಟ ಗಾತ್ರವಾಗಿದೆ ಮತ್ತು ಮೂರನೇ ಕ್ಷೇತ್ರವು ಬಳಕೆಯ ಕೌಂಟರ್‌ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವಾಗಿದೆ. ಈ ಮಾಹಿತಿಯು ಫಾರ್ಮ್ಯಾಟ್ ರೂಪದಲ್ಲಿ,
lsmod ಯುಟಿಲಿಟಿಗೆ ಕರೆ ಮಾಡುವ ಮೂಲಕ ಪಡೆಯಬಹುದು. ಕೆಳಗೆ /proc/modules ಫೈಲ್‌ನ ಉದಾಹರಣೆಯಾಗಿದೆ:

Parport_pc 7604 1 (autoclean) lp 4800 0 (unused) parport 8084 1 lockd 33256 1 (autoclean) sunrpc 56612 1 (autoclean) ds 6252 1 i823465 1823461 2230 2230

ಇಲ್ಲಿ ನಾವು ಸಿಸ್ಟಮ್ಗೆ ಲೋಡ್ ಮಾಡಲಾದ ಹಲವಾರು ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ನೋಡುತ್ತೇವೆ. ಧ್ವಜಗಳ ಕ್ಷೇತ್ರದಲ್ಲಿ (ರೇಖೆಯ ಕೊನೆಯ ಕ್ಷೇತ್ರ), ಮಾಡ್ಯೂಲ್ ಅವಲಂಬನೆಗಳ ಸ್ಟಾಕ್ ಅನ್ನು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ಅಂಜೂರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಸಮಾನಾಂತರ ಪೋರ್ಟ್ ಮಾಡ್ಯೂಲ್ಗಳು ಮಾಡ್ಯೂಲ್ ಸ್ಟಾಕ್ ಮೂಲಕ ಸಂವಹನ ನಡೆಸುವುದನ್ನು ನೀವು ಗಮನಿಸಬಹುದು. 2-2. (ಆಟೋಕ್ಲೀನ್) ಫ್ಲ್ಯಾಗ್ kmod ಅಥವಾ ಕರ್ನಲ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುವ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ. ಇದನ್ನು ಅಧ್ಯಾಯ 11 “kmod ಮತ್ತು ಸುಧಾರಿತ ಮಾಡ್ಯುಲರೈಸೇಶನ್”) ನಲ್ಲಿ ಒಳಗೊಂಡಿದೆ. (ಬಳಕೆಯಾಗದ) ಫ್ಲ್ಯಾಗ್ ಎಂದರೆ ಮಾಡ್ಯೂಲ್ ಪ್ರಸ್ತುತ ಬಳಕೆಯಲ್ಲಿಲ್ಲ. ಕರ್ನಲ್ 2.0 ರಲ್ಲಿ, ಗಾತ್ರದ ಕ್ಷೇತ್ರವು ಮಾಹಿತಿಯನ್ನು ಬೈಟ್‌ಗಳಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ಪುಟಗಳಲ್ಲಿ ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಇದು ಹೆಚ್ಚಿನ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗೆ 4kB ಗಾತ್ರದಲ್ಲಿದೆ.

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸಲಾಗುತ್ತಿದೆ

ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಲು, rmmod ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿ. ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡುವುದು ಅದನ್ನು ಲೋಡ್ ಮಾಡುವುದಕ್ಕಿಂತ ಸರಳವಾದ ಕೆಲಸವಾಗಿದೆ, ಇದು ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಲಿಂಕ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಅನ್‌ಲೋಡ್ ಮಾಡಿದಾಗ, ಡಿಲೀಟ್_ಮೊಡ್ಯೂಲ್() ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಅದರ ಬಳಕೆಯ ಎಣಿಕೆ ಶೂನ್ಯವಾಗಿದ್ದರೆ, ಅನ್‌ಲೋಡ್ ಮಾಡಲಾದ ಮಾಡ್ಯೂಲ್‌ನ ಕ್ಲೀನ್‌ಅಪ್_ಮೊಡ್ಯೂಲ್() ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ ಅಥವಾ ದೋಷದೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, cleanup_module() ಕಾರ್ಯವು cleanup_module() ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ನಿರ್ವಹಿಸಲಾದ ಆರಂಭಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅಲ್ಲದೆ, ರಫ್ತು ಮಾಡ್ಯೂಲ್ ಚಿಹ್ನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳಿಸಲಾಗುತ್ತದೆ.

ಮುಕ್ತಾಯ ಮತ್ತು ಪ್ರಾರಂಭಿಕ ಕಾರ್ಯಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ಕರ್ನಲ್ init_module() ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಇಳಿಸುವಾಗ cleanup_module() ಎಂದು ಕರೆಯುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕರ್ನಲ್ನ ಆಧುನಿಕ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಈ ಕಾರ್ಯಗಳು ಸಾಮಾನ್ಯವಾಗಿ ವಿಭಿನ್ನ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಕರ್ನಲ್ 2.3.23 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ ಮತ್ತು ಇಳಿಸುವ ಕಾರ್ಯಕ್ಕಾಗಿ ಹೆಸರನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಾಯಿತು. ಇತ್ತೀಚಿನ ದಿನಗಳಲ್ಲಿ, ಈ ಕಾರ್ಯಗಳ ಈ ಸ್ಪಷ್ಟವಾದ ಹೆಸರಿಸುವಿಕೆಯು ಶಿಫಾರಸು ಮಾಡಲಾದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಯಾಗಿದೆ.

ಒಂದು ಉದಾಹರಣೆ ಕೊಡೋಣ. ನೀವು my_init() ಫಂಕ್ಷನ್ ಅನ್ನು ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನ ಇನಿಶಿಯಲೈಸೇಶನ್ ಫಂಕ್ಷನ್ ಎಂದು ಘೋಷಿಸಲು ಬಯಸಿದರೆ, ಮತ್ತು my_cleanup() ಫಂಕ್ಷನ್ ಅನ್ನು ಕ್ರಮವಾಗಿ init_module() ಮತ್ತು cleanup_module() ಗೆ ಬದಲಾಗಿ, ನಂತರ ನೀವು ಈ ಕೆಳಗಿನ ಎರಡನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ ಮಾಡ್ಯೂಲ್ ಪಠ್ಯಕ್ಕೆ ಮ್ಯಾಕ್ರೋಗಳು (ಸಾಮಾನ್ಯವಾಗಿ ಅವುಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ
ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಮೂಲ ಫೈಲ್):

ಮಾಡ್ಯೂಲ್_ಇನಿಟ್ (ಮೈ_ಇನಿಟ್); module_exit (my_cleanup);

ಈ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸಲು ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ನೀವು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ .

ಈ ಶೈಲಿಯನ್ನು ಬಳಸುವ ಅನುಕೂಲವೆಂದರೆ ಕರ್ನಲ್‌ನಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಮಾಡ್ಯೂಲ್ ಪ್ರಾರಂಭ ಮತ್ತು ಮುಕ್ತಾಯ ಕಾರ್ಯವು ತನ್ನದೇ ಆದ ವಿಶಿಷ್ಟ ಹೆಸರನ್ನು ಹೊಂದಬಹುದು, ಇದು ಡೀಬಗ್ ಮಾಡಲು ಹೆಚ್ಚು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದಲ್ಲದೆ, ಈ ಕಾರ್ಯಗಳ ಬಳಕೆಯು ಡೀಬಗ್ ಮಾಡುವಿಕೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ನೀವು ನಿಮ್ಮ ಡ್ರೈವರ್ ಕೋಡ್ ಅನ್ನು ಮಾಡ್ಯೂಲ್ ಆಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೀರೋ ಅಥವಾ ಅದನ್ನು ನೇರವಾಗಿ ಕರ್ನಲ್‌ಗೆ ಎಂಬೆಡ್ ಮಾಡಲು ಹೋಗುತ್ತೀರೋ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ. ಸಹಜವಾಗಿ, module_init ಮತ್ತು module_exit ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ, ನಿಮ್ಮ ಪ್ರಾರಂಭ ಮತ್ತು ಮುಕ್ತಾಯ ಕಾರ್ಯಗಳು ಕಾಯ್ದಿರಿಸಿದ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಅಂದರೆ. init_module() ಮತ್ತು cleanup_module() ಕ್ರಮವಾಗಿ.

ನೀವು 2.2 ಅಥವಾ ನಂತರದ ಕರ್ನಲ್ ಮೂಲಗಳನ್ನು ನೋಡಿದರೆ, ಪ್ರಾರಂಭ ಮತ್ತು ಮುಕ್ತಾಯ ಕಾರ್ಯಗಳಿಗಾಗಿ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾದ ವಿವರಣೆಯನ್ನು ನೀವು ನೋಡಬಹುದು. ಉದಾಹರಣೆಗೆ:

ಸ್ಥಾಯೀ ಇಂಟ್ __init my_init(ಶೂನ್ಯ) (.... ) ಸ್ಥಿರ ನಿರರ್ಥಕ __exit my_cleanup(noid) ( .... )

ಗುಣಲಕ್ಷಣ ಬಳಕೆ __initಇನಿಶಿಯಲೈಸೇಶನ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ ಪ್ರಾರಂಭಿಕ ಕಾರ್ಯವನ್ನು ಮೆಮೊರಿಯಿಂದ ಇಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಕರ್ನಲ್ ಬಿಲ್ಟ್-ಇನ್ ಡ್ರೈವರ್‌ಗಳಿಗೆ ಮಾತ್ರ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಅಲ್ಲದೆ, ಕರ್ನಲ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಡ್ರೈವರ್‌ಗಳಿಗೆ, ಗುಣಲಕ್ಷಣ __ನಿರ್ಗಮನಈ ಗುಣಲಕ್ಷಣದೊಂದಿಗೆ ಗುರುತಿಸಲಾದ ಸಂಪೂರ್ಣ ಕಾರ್ಯವನ್ನು ನಿರ್ಲಕ್ಷಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ, ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸಹ ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ.

ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸುವುದು __init(ಮತ್ತು __initdataಡೇಟಾವನ್ನು ವಿವರಿಸಲು) ಕರ್ನಲ್ ಬಳಸುವ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ಧ್ವಜ __initಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಾರಂಭಿಕ ಕಾರ್ಯವು ಪ್ರಯೋಜನ ಅಥವಾ ಹಾನಿಯನ್ನು ತರುವುದಿಲ್ಲ. ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಈ ರೀತಿಯ ಪ್ರಾರಂಭವನ್ನು ನಿಯಂತ್ರಿಸುವುದು ಇನ್ನೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿಲ್ಲ, ಆದರೂ ಇದು ಭವಿಷ್ಯದಲ್ಲಿ ಸಾಧ್ಯ.

ಸಾರಾಂಶ

ಆದ್ದರಿಂದ, ಪ್ರಸ್ತುತಪಡಿಸಿದ ವಸ್ತುವಿನ ಪರಿಣಾಮವಾಗಿ, ನಾವು "ಹಲೋ ವರ್ಲ್ಡ್" ಮಾಡ್ಯೂಲ್ನ ಕೆಳಗಿನ ಆವೃತ್ತಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಬಹುದು:

ಮಾಡ್ಯೂಲ್ ಮೂಲ ಫೈಲ್ ಕೋಡ್ =================================================== = #ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು ಸ್ಥಿರ ಇಂಟ್ __init my_init_module (ಶೂನ್ಯ) ( EXPORT_NO_SYMBOLS; printk("<1>ಹಲೋ ವರ್ಲ್ಡ್\n"); ರಿಟರ್ನ್ 0; ; ಸ್ಟ್ಯಾಟಿಕ್ ಶೂನ್ಯ __exit my_cleanup_module (ಶೂನ್ಯ) ( printk("<1>ಗುಡ್ ಬೈ\n"); ; module_init(my_init_module); module_exit(my_cleanup_module); MODULE_LICENSE("GPL"); ========================= ====================== ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಮೇಕ್‌ಫೈಲ್ ========================== =================================== CFLAGS = -ವಾಲ್ -D__KERNEL__ -DMODULE -I/lib/modules/ $(shell uname -r)/build/include hello.o: ======================================= ==========================

ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ಬರೆಯುವಾಗ, CFLAGS ವೇರಿಯೇಬಲ್ ಮತ್ತು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಕಂಪೈಲರ್ ಅನ್ನು ಆಧರಿಸಿ ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು GNU ಮೇಕ್ ಯುಟಿಲಿಟಿ ಸ್ವತಂತ್ರವಾಗಿ ನಿರ್ಧರಿಸಬಹುದು ಎಂಬ ಸಂಪ್ರದಾಯವನ್ನು ನಾವು ಬಳಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಸಂಪನ್ಮೂಲ ಬಳಕೆ

ಮೆಮೊರಿ, I/O ಪೋರ್ಟ್‌ಗಳು, I/O ಮೆಮೊರಿ, ಇಂಟರಪ್ಟ್ ಲೈನ್‌ಗಳು ಮತ್ತು DMA ಚಾನಲ್‌ಗಳಂತಹ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸದೆ ಮಾಡ್ಯೂಲ್ ತನ್ನ ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿ, ನೀವು ಈಗಾಗಲೇ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿರಬೇಕು. ಕರ್ನಲ್‌ನಲ್ಲಿನ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯು ಮೂಲಭೂತವಾಗಿ ಭಿನ್ನವಾಗಿರುವುದಿಲ್ಲ. ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೆಮೊರಿಯನ್ನು ಪಡೆಯಬಹುದು kmalloc()ಮತ್ತು ಸಹಾಯದಿಂದ ಅವಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿ kfree(). ಈ ಕಾರ್ಯಗಳು ನಿಮಗೆ ಪರಿಚಿತವಾಗಿರುವ malloc() ಮತ್ತು free() ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಹೋಲುತ್ತವೆ, ಆದರೆ kmalloc() ಫಂಕ್ಷನ್ ಅನ್ನು ಹೆಚ್ಚುವರಿ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ರವಾನಿಸಲಾಗಿದೆ - ಆದ್ಯತೆ. ವಿಶಿಷ್ಟವಾಗಿ ಆದ್ಯತೆಯು GFP_KERNEL ಅಥವಾ GFP_USER ಆಗಿದೆ. GFP ಎನ್ನುವುದು "ಉಚಿತ ಪುಟವನ್ನು ಪಡೆಯಿರಿ" ಎಂಬುದಕ್ಕೆ ಸಂಕ್ಷಿಪ್ತ ರೂಪವಾಗಿದೆ. ಕರ್ನಲ್‌ನಲ್ಲಿ ಡೈನಾಮಿಕ್ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು ಅಧ್ಯಾಯ 7, “ಮೆಮೊರಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದು” ನಲ್ಲಿ ವಿವರವಾಗಿ ಒಳಗೊಂಡಿದೆ.

ಅನನುಭವಿ ಚಾಲಕ ಡೆವಲಪರ್ ಸ್ಪಷ್ಟವಾಗಿ I/O ಪೋರ್ಟ್‌ಗಳು, 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 ಪ್ರದೇಶಕ್ಕೆ ವಿಶೇಷ ಪ್ರವೇಶವನ್ನು ಖಾತರಿಪಡಿಸಬೇಕು. ಮಾಡ್ಯೂಲ್, ತನ್ನದೇ ಆದ ಸಾಧನವನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಅದಕ್ಕೆ ಸೇರದ ಸಾಧನಕ್ಕೆ ಬರೆಯುತ್ತಿದ್ದರೆ, ಇದು ಮಾರಣಾಂತಿಕ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಲಿನಕ್ಸ್ ಡೆವಲಪರ್‌ಗಳು ವಿವಿಧ ಸಾಧನಗಳ ನಡುವೆ ಘರ್ಷಣೆಯನ್ನು ತಡೆಗಟ್ಟಲು ಪ್ರಾಥಮಿಕವಾಗಿ I/O ಪ್ರದೇಶಗಳನ್ನು ವಿನಂತಿಸಲು/ಬಿಡುಗಡೆ ಮಾಡಲು ಕಾರ್ಯವಿಧಾನವನ್ನು ಜಾರಿಗೆ ತಂದರು. ಈ ಕಾರ್ಯವಿಧಾನವನ್ನು I/O ಪೋರ್ಟ್‌ಗಳಿಗಾಗಿ ದೀರ್ಘಕಾಲ ಬಳಸಲಾಗಿದೆ ಮತ್ತು ಇತ್ತೀಚೆಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಗೆ ಸಾಮಾನ್ಯೀಕರಿಸಲಾಗಿದೆ. ಈ ಕಾರ್ಯವಿಧಾನವು ಸಾಫ್ಟ್‌ವೇರ್ ಅಮೂರ್ತತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಹಾರ್ಡ್‌ವೇರ್ ಸಾಮರ್ಥ್ಯಗಳಿಗೆ ವಿಸ್ತರಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಉದಾಹರಣೆಗೆ, ಹಾರ್ಡ್‌ವೇರ್ ಮಟ್ಟದಲ್ಲಿ I/O ಪೋರ್ಟ್‌ಗಳಿಗೆ ಅನಧಿಕೃತ ಪ್ರವೇಶವು "ವಿಭಾಗದ ದೋಷ" ದಂತಹ ಯಾವುದೇ ದೋಷವನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಹಾರ್ಡ್‌ವೇರ್ ತನ್ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿಯೋಜಿಸುವುದಿಲ್ಲ ಮತ್ತು ಅಧಿಕೃತಗೊಳಿಸುವುದಿಲ್ಲ.

ನೋಂದಾಯಿತ ಸಂಪನ್ಮೂಲಗಳ ಕುರಿತು ಮಾಹಿತಿಯು ಪಠ್ಯ ರೂಪದಲ್ಲಿ ಫೈಲ್‌ಗಳಲ್ಲಿ /proc/ioports ಮತ್ತು /proc/iomem ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ಈ ಮಾಹಿತಿಯನ್ನು ಕರ್ನಲ್ 2.3 ರಿಂದ ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾಗಿದೆ. ಜ್ಞಾಪನೆಯಾಗಿ, ಈ ಪುಸ್ತಕವು ಪ್ರಾಥಮಿಕವಾಗಿ 2.4 ಕರ್ನಲ್ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅಧ್ಯಾಯದ ಕೊನೆಯಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯ ಟಿಪ್ಪಣಿಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಲಾಗುತ್ತದೆ.

ಬಂದರುಗಳು

ಕೆಳಗಿನವುಗಳು /proc/ioports ಫೈಲ್‌ನ ವಿಶಿಷ್ಟ ವಿಷಯಗಳಾಗಿವೆ:

0000-001f: dma1 0020-003f: pic1 0040-005f: ಟೈಮರ್ 0060-006f: ಕೀಬೋರ್ಡ್ 0080-008f: dma ಪುಟ ರೆಗ್ 00a0-00bf: pic2 00c0-00df:fff0010 7: ide1 01f0-01f7 : ide0 02f8-02ff: ಸೀರಿಯಲ್(ಸೆಟ್) 0300-031f: NE2000 0376-0376: ide1 03c0-03df: vga+ 03f6-03f6: ide0 03f8-03ff: serial(set) 13000 ಕಾರ್ಪೊರೇಷನ್ ACPI 1000 -1003 : acpi 1004-1005: acpi 1008-100b: acpi 100c-100f: acpi 1100-110f: Intel ಕಾರ್ಪೊರೇಶನ್ 82371AB PIIX4 IDE 1300-131f: pcnet_cs 41823 ಕಾರ್ಪೊರೇಶನ್ 141400-7 800-18ff: PCI CardBus #02 1c00- 1cff: PCI CardBus #04 5800-581f: Intel Corporation 82371AB PIIX4 USB d000-dfff: PCI Bus #01 d000-d0ff: ATI ಟೆಕ್ನಾಲಜೀಸ್ Inc 3D Rage LT Pro AGP-133

ಈ ಫೈಲ್‌ನ ಪ್ರತಿಯೊಂದು ಸಾಲು ಹೆಕ್ಸಾಡೆಸಿಮಲ್‌ನಲ್ಲಿ ಚಾಲಕ ಅಥವಾ ಸಾಧನದ ಮಾಲೀಕರಿಗೆ ಸಂಬಂಧಿಸಿದ ಪೋರ್ಟ್‌ಗಳ ಶ್ರೇಣಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಕರ್ನಲ್‌ನ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ, ಪೋರ್ಟ್ ಕ್ರಮಾನುಗತವನ್ನು ಪ್ರದರ್ಶಿಸದ ಹೊರತು ಫೈಲ್ ಅದೇ ಸ್ವರೂಪವನ್ನು ಹೊಂದಿದೆ.

ಸಿಸ್ಟಮ್‌ಗೆ ಹೊಸ ಸಾಧನವನ್ನು ಸೇರಿಸುವಾಗ ಪೋರ್ಟ್ ಘರ್ಷಣೆಯನ್ನು ತಪ್ಪಿಸಲು ಫೈಲ್ ಅನ್ನು ಬಳಸಬಹುದು. ಜಿಗಿತಗಾರರನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಸ್ಥಾಪಿಸಲಾದ ಉಪಕರಣಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಅನುಕೂಲಕರವಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬಳಕೆದಾರರು ಬಳಸಿದ ಪೋರ್ಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಸುಲಭವಾಗಿ ವೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಸಾಧನವನ್ನು ಸ್ಥಾಪಿಸಲು ಉಚಿತ ಶ್ರೇಣಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಮತ್ತು ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಸಾಧನಗಳು ಹಸ್ತಚಾಲಿತ ಜಿಗಿತಗಾರರನ್ನು ಬಳಸದಿದ್ದರೂ, ಅವುಗಳನ್ನು ಇನ್ನೂ ಸಣ್ಣ-ಪ್ರಮಾಣದ ಘಟಕಗಳ ತಯಾರಿಕೆಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಹೆಚ್ಚು ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ /proc/ioports ಫೈಲ್ ಅದರೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಪ್ರವೇಶಿಸಬಹುದಾದ ಡೇಟಾ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಸಾಧನ ಚಾಲಕವನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಅದು I/O ಪೋರ್ಟ್‌ಗಳ ಆಕ್ರಮಿತ ಶ್ರೇಣಿಯನ್ನು ತಿಳಿಯಬಹುದು. ಇದರರ್ಥ ಹೊಸ ಸಾಧನದ ಹುಡುಕಾಟದಲ್ಲಿ ಪೋರ್ಟ್‌ಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಅಗತ್ಯವಿದ್ದರೆ, ಇತರ ಸಾಧನಗಳು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಪೋರ್ಟ್‌ಗಳಿಗೆ ಬರೆಯುವ ಪರಿಸ್ಥಿತಿಯನ್ನು ತಪ್ಪಿಸಲು ಚಾಲಕರಿಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ISA ಬಸ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವುದು ಅಪಾಯಕಾರಿ ಕೆಲಸ ಎಂದು ತಿಳಿದುಬಂದಿದೆ. ಆದ್ದರಿಂದ, ಅಧಿಕೃತ ಲಿನಕ್ಸ್ ಕರ್ನಲ್ನೊಂದಿಗೆ ವಿತರಿಸಲಾದ ಕೆಲವು ಡ್ರೈವರ್ಗಳು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ ಅಂತಹ ಸ್ಕ್ಯಾನಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸುತ್ತವೆ. ಹಾಗೆ ಮಾಡುವ ಮೂಲಕ, ಇತರ ಉಪಕರಣಗಳು ಬಳಸುವ ಪೋರ್ಟ್‌ಗಳಿಗೆ ಬರೆಯುವ ಮೂಲಕ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಿಸ್ಟಮ್‌ಗೆ ಹಾನಿಯಾಗುವ ಅಪಾಯವನ್ನು ಅವರು ತಪ್ಪಿಸುತ್ತಾರೆ. ಅದೃಷ್ಟವಶಾತ್, ಆಧುನಿಕ ಬಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳು ಈ ಸಮಸ್ಯೆಗಳಿಗೆ ನಿರೋಧಕವಾಗಿರುತ್ತವೆ.

I/O ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಬಳಸುವ ಸಾಫ್ಟ್‌ವೇರ್ ಇಂಟರ್ಫೇಸ್ ಈ ಕೆಳಗಿನ ಮೂರು ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

ಇಂಟ್ ಚೆಕ್_ರೀಜನ್ (ಸಹಿ ಮಾಡದ ಲಾಂಗ್ ಸ್ಟಾರ್ಟ್, ಸಹಿ ಮಾಡದ ಲಾಂಗ್ ಲೆನ್); struct resource *request_region(ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಆರಂಭ, ಸಹಿ ಮಾಡದ ಉದ್ದ ಲೆನ್, ಚಾರ್ *ಹೆಸರು); ನಿರರ್ಥಕ ಬಿಡುಗಡೆ_ಪ್ರದೇಶ (ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಪ್ರಾರಂಭ, ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಲೆನ್);

ಕಾರ್ಯ ಚೆಕ್_ಪ್ರದೇಶ()ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ಪೋರ್ಟ್‌ಗಳನ್ನು ಆಕ್ರಮಿಸಿಕೊಂಡಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಕರೆ ಮಾಡಬಹುದು. ಪ್ರತಿಕ್ರಿಯೆಯು ನಕಾರಾತ್ಮಕವಾಗಿದ್ದರೆ ಅದು ಋಣಾತ್ಮಕ ದೋಷ ಕೋಡ್ ಅನ್ನು (ಉದಾಹರಣೆಗೆ -EBUSY ಅಥವಾ -EINVAL) ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಕಾರ್ಯ ವಿನಂತಿ_ಪ್ರದೇಶ()ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ವಿಳಾಸಗಳ ಹಂಚಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಯಶಸ್ವಿಯಾದರೆ, ಶೂನ್ಯವಲ್ಲದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಚಾಲಕ ಹಿಂತಿರುಗಿದ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುವ ಅಥವಾ ಬಳಸುವ ಅಗತ್ಯವಿಲ್ಲ. ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು NULL ಗಾಗಿ ಪರಿಶೀಲಿಸುವುದು. 2.4 (ಅಥವಾ ಹೆಚ್ಚಿನ) ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕಾದ ಕೋಡ್ ಚೆಕ್_ರೀಜನ್() ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ. ವಿತರಣೆಯ ಈ ವಿಧಾನದ ಪ್ರಯೋಜನದ ಬಗ್ಗೆ ಯಾವುದೇ ಸಂದೇಹವಿಲ್ಲ, ಏಕೆಂದರೆ
check_region() ಮತ್ತು request_region() ಗೆ ಕರೆಗಳ ನಡುವೆ ಏನಾಗಬಹುದು ಎಂಬುದು ತಿಳಿದಿಲ್ಲ. ನೀವು ಕರ್ನಲ್‌ನ ಹಳೆಯ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಬಯಸಿದರೆ, request_region() ಗೆ ಮೊದಲು check_region() ಗೆ ಕರೆ ಮಾಡುವುದು ಅವಶ್ಯಕ.

ಕಾರ್ಯ ಬಿಡುಗಡೆ_ಪ್ರದೇಶ()ಚಾಲಕನು ಹಿಂದೆ ಬಳಸಿದ ಪೋರ್ಟ್‌ಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದಾಗ ಕರೆ ಮಾಡಬೇಕು.

request_region() ಮೂಲಕ ಹಿಂತಿರುಗಿಸಲಾದ ಪಾಯಿಂಟರ್‌ನ ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು ಕರ್ನಲ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಂಪನ್ಮೂಲ ಹಂಚಿಕೆ ಉಪವ್ಯವಸ್ಥೆಯಿಂದ ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ.

ಈ ಮೂರು ಕಾರ್ಯಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ಮ್ಯಾಕ್ರೋಗಳಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ .

ಪೋರ್ಟ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸಲು ಬಳಸುವ ಕರೆ ಅನುಕ್ರಮದ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಉದಾಹರಣೆಯನ್ನು ತಲೆಬುರುಡೆ ತರಬೇತಿ ಚಾಲಕ ಕೋಡ್‌ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ. (skull_probe_hw() ಫಂಕ್ಷನ್ ಕೋಡ್ ಅನ್ನು ಇಲ್ಲಿ ತೋರಿಸಲಾಗಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ಹಾರ್ಡ್‌ವೇರ್-ಅವಲಂಬಿತ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿದೆ.)

#ಸೇರಿಸು #ಸೇರಿಸು ಸ್ಥಿರ ಇಂಟ್ ಸ್ಕಲ್_ಡಿಟೆಕ್ಟ್ (ಸಹಿ ಮಾಡದ ಇಂಟ್ ಪೋರ್ಟ್, ಸಹಿ ಮಾಡದ ಇಂಟ್ ಶ್ರೇಣಿ) (ಇಂಟ್ ದೋಷ; ವೇಳೆ ((ತಪ್ಪು = ಚೆಕ್_ಪ್ರದೇಶ(ಪೋರ್ಟ್, ಶ್ರೇಣಿ))< 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() ಕಾರ್ಯದಲ್ಲಿ ಮಾಡುತ್ತದೆ:

ಸ್ಥಾಯೀ ನಿರರ್ಥಕ ಸ್ಕಲ್_ರಿಲೀಸ್ (ಸಹಿ ಮಾಡದ ಇಂಟ್ ಪೋರ್ಟ್, ಸಹಿ ಮಾಡದ ಇಂಟ್ ಶ್ರೇಣಿ) (ರಿಲೀಸ್_ರೀಜನ್(ಪೋರ್ಟ್, ರೇಂಜ್); )

ಸಂಪನ್ಮೂಲ ವಿನಂತಿ/ಬಿಡುಗಡೆಯ ಕಾರ್ಯವಿಧಾನವು ಮಾಡ್ಯೂಲ್ ನೋಂದಣಿ/ರಜಿಸ್ಟ್ರೇಶನ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಹೋಲುತ್ತದೆ ಮತ್ತು ಮೇಲೆ ವಿವರಿಸಿದ ಗೊಟೊ ಆಪರೇಟರ್ ಬಳಕೆಯ ಯೋಜನೆಯ ಆಧಾರದ ಮೇಲೆ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಸ್ಮರಣೆ

I/O ಮೆಮೊರಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯು /proc/iomem ಫೈಲ್ ಮೂಲಕ ಲಭ್ಯವಿದೆ. ವೈಯಕ್ತಿಕ ಕಂಪ್ಯೂಟರ್ಗಾಗಿ ಅಂತಹ ಫೈಲ್ನ ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

00000000-0009fbff: ಸಿಸ್ಟಮ್ RAM 0009fc00-0009ffff: ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ 000a0000-000bffff: ವೀಡಿಯೊ RAM ಪ್ರದೇಶ 000c0000-000c7fff: ವೀಡಿಯೊ ROM 000f0000-00000000000000 ಸಿಸ್ಟಂ RAM RAM 0 0100000-0022c557: ಕರ್ನಲ್ ಕೋಡ್ 0022c558-0024455f: ಕರ್ನಲ್ ಡೇಟಾ 20000000 - 2fffffff: ಇಂಟೆಲ್ ಕಾರ್ಪೊರೇಷನ್ 440BX/ZX - 82443BX/ZX ಹೋಸ್ಟ್ ಬ್ರಿಡ್ಜ್ 68000000-68000fff: ಟೆಕ್ಸಾಸ್ ಇನ್‌ಸ್ಟ್ರುಮೆಂಟ್ಸ್ PCI1225 68001000-68001fff: ಟೆಕ್ಸಾಸ್ ಇನ್‌ಸ್ಟ್ರುಮೆಂಟ್ಸ್ PCI003020FFF0 01 e4000000-e7 ffffff: PCI ಬಸ್ #01 e4000000 -e4ffffff : ATI ಟೆಕ್ನಾಲಜೀಸ್ Inc 3D Rage LT Pro AGP-133 e6000000-e6000fff: ATI ಟೆಕ್ನಾಲಜೀಸ್ Inc 3D Rage LT Pro AGP-133 fffc0000-ffffffff: ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ

ವಿಳಾಸ ಶ್ರೇಣಿಯ ಮೌಲ್ಯಗಳನ್ನು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಕೇತದಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. ಪ್ರತಿ ಅರೆಸ್ ಶ್ರೇಣಿಗೆ, ಅದರ ಮಾಲೀಕರನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ.

I/O ಮೆಮೊರಿ ಪ್ರವೇಶಗಳನ್ನು ನೋಂದಾಯಿಸುವುದು I/O ಪೋರ್ಟ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸುವಂತೆಯೇ ಇರುತ್ತದೆ ಮತ್ತು ಕರ್ನಲ್‌ನಲ್ಲಿ ಅದೇ ಕಾರ್ಯವಿಧಾನದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.

I/O ಮೆಮೊರಿ ವಿಳಾಸಗಳ ಅಗತ್ಯವಿರುವ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯಲು ಮತ್ತು ಬಿಡುಗಡೆ ಮಾಡಲು, ಚಾಲಕವು ಈ ಕೆಳಗಿನ ಕರೆಗಳನ್ನು ಬಳಸಬೇಕು:

ಇಂಟ್ ಚೆಕ್_ಮೆಮ್_ರೀಜನ್ (ಸಹಿ ಮಾಡದ ಲಾಂಗ್ ಸ್ಟಾರ್ಟ್, ಸಹಿ ಮಾಡದ ಲಾಂಗ್ ಲೆನ್); int request_mem_region (ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಪ್ರಾರಂಭ, ಸಹಿ ಮಾಡದ ಉದ್ದ ಲೆನ್, ಚಾರ್ *ಹೆಸರು); 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(), ಇತ್ಯಾದಿ) ಇನ್ನೂ ಮ್ಯಾಕ್ರೋಗಳಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ ಮತ್ತು ಕರ್ನಲ್‌ನ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಹಿಂದುಳಿದ ಹೊಂದಾಣಿಕೆಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು ನಿಜವಾದ ವಿತರಣಾ ಕಾರ್ಯವಿಧಾನದ ಬಗ್ಗೆ ಏನನ್ನೂ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಚಾಲಕಗಳನ್ನು ರಚಿಸುವಾಗ ಇದು ಆಸಕ್ತಿದಾಯಕವಾಗಿರುತ್ತದೆ.

Linux ನಲ್ಲಿ ಅಳವಡಿಸಲಾದ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯು ಅನಿಯಂತ್ರಿತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಏಕೀಕೃತ ಕ್ರಮಾನುಗತ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸಬಹುದು. ಗ್ಲೋಬಲ್ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, I/O ಪೋರ್ಟ್‌ಗಳು) ಉಪವಿಭಾಗಗಳಾಗಿ ವಿಂಗಡಿಸಬಹುದು - ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಹಾರ್ಡ್‌ವೇರ್ ಬಸ್ ಸ್ಲಾಟ್‌ಗೆ ಸಂಬಂಧಿಸಿದವು. ಕೆಲವು ಚಾಲಕರು ತಮ್ಮ ತಾರ್ಕಿಕ ರಚನೆಯ ಆಧಾರದ ಮೇಲೆ ಸೆರೆಹಿಡಿದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿ ಉಪವಿಭಾಗ ಮಾಡಬಹುದು.

ಹಂಚಿಕೆ ಸಂಪನ್ಮೂಲಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು struct ಸಂಪನ್ಮೂಲ ರಚನೆಯ ಮೂಲಕ ವಿವರಿಸಲಾಗಿದೆ, ಇದನ್ನು ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ ಘೋಷಿಸಲಾಗಿದೆ :

ಸ್ಟ್ರಕ್ಟ್ ಸಂಪನ್ಮೂಲ (ಕಾನ್ಸ್ಟ್ ಚಾರ್ *ಹೆಸರು; ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಪ್ರಾರಂಭ, ಅಂತ್ಯ; ಸಹಿ ಮಾಡದ ಉದ್ದದ ಧ್ವಜಗಳು; ರಚನೆ ಸಂಪನ್ಮೂಲ *ಪೋಷಕರು, *ಸಹೋದರರು, *ಮಗು; );

ಬೂಟ್ ಸಮಯದಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳ ಜಾಗತಿಕ (ಮೂಲ) ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, I/O ಪೋರ್ಟ್‌ಗಳನ್ನು ವಿವರಿಸುವ ಸಂಪನ್ಮೂಲ ರಚನೆಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ರಚಿಸಲಾಗಿದೆ:

ಸ್ಟ್ರಕ್ಟ್ ಸಂಪನ್ಮೂಲ ioport_resource = ("PCI IO", 0x0000, IO_SPACE_LIMIT, IORESOURCE_IO);

ಶೂನ್ಯದಿಂದ IO_SPACE_LIMIT ವರೆಗಿನ ವಿಳಾಸ ವ್ಯಾಪ್ತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ PCI IO ಎಂಬ ಸಂಪನ್ಮೂಲವನ್ನು ಇಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಈ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವು ಬಳಸಿದ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ ಮತ್ತು 0xFFFF (16-ಬಿಟ್ ವಿಳಾಸ ಸ್ಥಳ, x86, IA-64, ಆಲ್ಫಾ, M68k ಮತ್ತು MIPS ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಿಗಾಗಿ), 0xFFFFFFFF (32-ಬಿಟ್ ವಿಳಾಸ ಸ್ಥಳ, SPARC, PPC ಗಾಗಿ) ಗೆ ಸಮನಾಗಿರುತ್ತದೆ. , SH) ಅಥವಾ 0xFFFFFFFFFFFFFFF (64-ಬಿಟ್, 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 ವಿಳಾಸಗಳು ಮತ್ತು ಮೆಮೊರಿ ಶ್ರೇಣಿಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಬೇಕು. ಸುಸಂಘಟಿತ ಬಸ್ ಇಂಟರ್ಫೇಸ್‌ಗಳಿಗೆ ಇದು ಸಮಸ್ಯೆಯಲ್ಲ. ಆದಾಗ್ಯೂ, ಕೆಲವೊಮ್ಮೆ ನೀವು ಅದರ ಸ್ವಂತ ಸಾಧನವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಡ್ರೈವರ್‌ಗೆ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ ಅಥವಾ ಅದರ ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ/ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ.

ಚಾಲಕ ಕಾರ್ಯಾಚರಣೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಸಾಧನದಿಂದ ಬದಲಾಗುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಇದು ಸ್ಥಾಪಿಸಲಾದ ಸಾಧನದ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯಾಗಿರಬಹುದು. ಸಹಜವಾಗಿ, ಚಾಲಕವು ಸಾಧನದೊಂದಿಗೆ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು ಅಂತಹ ಮಾಹಿತಿಯು ಅವಶ್ಯಕವಾಗಿದೆ. ಅಂತಹ ನಿಯತಾಂಕಗಳನ್ನು (ಚಾಲಕ ಸಂರಚನೆ) ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಸಾಕಷ್ಟು ಎ
ಚಾಲಕವನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ ಒಂದು ಟ್ರಿಕಿ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ವಿಶಿಷ್ಟವಾಗಿ, ಈ ನಿಯತಾಂಕದ ಸರಿಯಾದ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಎರಡು ಮಾರ್ಗಗಳಿವೆ - ಬಳಕೆದಾರನು ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತಾನೆ, ಅಥವಾ ಸಾಧನಗಳ ಮತದಾನದ ಆಧಾರದ ಮೇಲೆ ಚಾಲಕ ಸ್ವತಂತ್ರವಾಗಿ ಅವುಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತಾನೆ. ಚಾಲಕ ಸಂರಚನೆಗೆ ಸ್ವಯಂ-ಪತ್ತೆ ನಿಸ್ಸಂದೇಹವಾಗಿ ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ,
ಕಸ್ಟಮ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೆಚ್ಚು ಸುಲಭವಾಗಿದೆ. ಡ್ರೈವರ್ ಡೆವಲಪರ್ ಡ್ರೈವರ್ ಸ್ವಯಂ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸಾಧ್ಯವಿರುವಲ್ಲೆಲ್ಲಾ ಅಳವಡಿಸಬೇಕು, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ, ಅವನು ಬಳಕೆದಾರರಿಗೆ ಹಸ್ತಚಾಲಿತ ಸಂರಚನಾ ಕಾರ್ಯವಿಧಾನವನ್ನು ಒದಗಿಸಬೇಕು. ಸಹಜವಾಗಿ, ಸ್ವಯಂ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಿಂತ ಹಸ್ತಚಾಲಿತ ಸಂರಚನೆಯು ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯನ್ನು ಹೊಂದಿರಬೇಕು. ಅಭಿವೃದ್ಧಿಯ ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ, ಸಾಮಾನ್ಯವಾಗಿ ಚಾಲಕಕ್ಕೆ ನಿಯತಾಂಕಗಳ ಹಸ್ತಚಾಲಿತ ಪ್ರಸರಣವನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸ್ವಯಂ ಕಾನ್ಫಿಗರೇಶನ್, ಸಾಧ್ಯವಾದರೆ, ನಂತರ ಸೇರಿಸಲಾಗುತ್ತದೆ.

ಅನೇಕ ಚಾಲಕರು, ತಮ್ಮ ಸಂರಚನಾ ನಿಯತಾಂಕಗಳಲ್ಲಿ, ಚಾಲಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ. ಉದಾಹರಣೆಗೆ, ಇಂಟಿಗ್ರೇಟೆಡ್ ಡಿವೈಸ್ ಇಲೆಕ್ಟ್ರಾನಿಕ್ಸ್ (IDE) ಇಂಟರ್ಫೇಸ್ ಡ್ರೈವರ್‌ಗಳು ಬಳಕೆದಾರರಿಗೆ DMA ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಚಾಲಕ ಹಾರ್ಡ್‌ವೇರ್ ಅನ್ನು ಸ್ವಯಂ-ಪತ್ತೆಹಚ್ಚುವ ಉತ್ತಮ ಕೆಲಸವನ್ನು ಮಾಡಿದರೆ, ಚಾಲಕನ ಕಾರ್ಯಚಟುವಟಿಕೆಗಳ ಮೇಲೆ ಬಳಕೆದಾರರಿಗೆ ನಿಯಂತ್ರಣವನ್ನು ನೀಡಲು ನೀವು ಬಯಸಬಹುದು.

insmod ಅಥವಾ modprobe ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡ್ಯೂಲ್ ಲೋಡಿಂಗ್ ಸಮಯದಲ್ಲಿ ನಿಯತಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸಬಹುದು. ಇತ್ತೀಚೆಗೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನಿಂದ ನಿಯತಾಂಕಗಳ ಮೌಲ್ಯವನ್ನು ಓದಲು ಸಾಧ್ಯವಾಗಿದೆ (ಸಾಮಾನ್ಯವಾಗಿ /etc/modules.conf). ಪೂರ್ಣಾಂಕ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯತಾಂಕಗಳಾಗಿ ರವಾನಿಸಬಹುದು. ಹೀಗಾಗಿ, ನೀವು skull_ival ಪ್ಯಾರಾಮೀಟರ್‌ಗಾಗಿ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಮತ್ತು skull_sval ಪ್ಯಾರಾಮೀಟರ್‌ಗಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಬೇಕಾದರೆ, ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಮಾಡ್ಯೂಲ್ ಲೋಡ್ ಮಾಡುವಾಗ ನೀವು ಅವುಗಳನ್ನು insmod ಆಜ್ಞೆಗೆ ರವಾನಿಸಬಹುದು:

Insmod ತಲೆಬುರುಡೆ skull_ival=666 skull_sval="ದ ಬೀಸ್ಟ್"

ಆದಾಗ್ಯೂ, insmod ಆಜ್ಞೆಯು ಮಾಡ್ಯೂಲ್‌ನ ನಿಯತಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮೊದಲು, ಮಾಡ್ಯೂಲ್ ಆ ನಿಯತಾಂಕಗಳನ್ನು ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡಬೇಕು. MODULE_PARM ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಿಯತಾಂಕಗಳನ್ನು ಘೋಷಿಸಲಾಗಿದೆ, ಇದನ್ನು module.h ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. MODULE_PARM ಮ್ಯಾಕ್ರೋ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ವೇರಿಯೇಬಲ್‌ನ ಹೆಸರು ಮತ್ತು ಅದರ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸ್ಟ್ರಿಂಗ್. ಈ ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನವನ್ನು ಯಾವುದೇ ಕಾರ್ಯಗಳ ಹೊರಗೆ ಇರಿಸಬೇಕು ಮತ್ತು ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ ಸಾಮಾನ್ಯವಾಗಿ ಫೈಲ್‌ನ ಆರಂಭದಲ್ಲಿ ಇರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಮೇಲೆ ತಿಳಿಸಲಾದ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಘೋಷಿಸಬಹುದು:

Int skull_ival=0; ಚಾರ್ * ತಲೆಬುರುಡೆ_sval; MODULE_PARM(skull_ival, "i"); MODULE_PARM(skull_sval, "s");

ಪ್ರಸ್ತುತ ಐದು ವಿಧದ ಮಾಡ್ಯೂಲ್ ನಿಯತಾಂಕಗಳನ್ನು ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ:

• ಬಿ - ಒಂದು ಬೈಟ್ ಮೌಲ್ಯ;
• h - (ಸಣ್ಣ) ಎರಡು-ಬೈಟ್ ಮೌಲ್ಯ;
• i - ಪೂರ್ಣಾಂಕ;
• l - ದೀರ್ಘ ಪೂರ್ಣಾಂಕ;
• s - ಸ್ಟ್ರಿಂಗ್ (ಚಾರ್ *);

ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಪಾಯಿಂಟರ್ (ಚಾರ್ *) ಅನ್ನು ಘೋಷಿಸಬೇಕು. insmod ಆಜ್ಞೆಯು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಮೌಲ್ಯದೊಂದಿಗೆ ಅದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. MODULE_PARM ಮ್ಯಾಕ್ರೋ ಬಳಸಿ, ನೀವು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಅರೇಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರಕಾರದ ಅಕ್ಷರದ ಹಿಂದಿನ ಪೂರ್ಣಾಂಕವು ರಚನೆಯ ಉದ್ದವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಎರಡು ಪೂರ್ಣಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಾಗ, ಡ್ಯಾಶ್‌ನಿಂದ ಬೇರ್ಪಡಿಸಿದಾಗ, ಅವು ರವಾನಿಸಬೇಕಾದ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತವೆ. ಈ ಮ್ಯಾಕ್ರೋ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚು ವಿವರವಾದ ತಿಳುವಳಿಕೆಗಾಗಿ, ದಯವಿಟ್ಟು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಿ .

ಉದಾಹರಣೆಗೆ, ಕನಿಷ್ಠ ಎರಡು ಮತ್ತು ಕನಿಷ್ಠ ನಾಲ್ಕು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ನಿಯತಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂದು ಭಾವಿಸೋಣ. ನಂತರ ಅದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವಿವರಿಸಬಹುದು:

ಇಂಟ್ ಸ್ಕಲ್_ಅರೇ; MODULE_PARM(skull_array, "2-4i");

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರೋಗ್ರಾಮರ್‌ನ ಟೂಲ್‌ಕಿಟ್ ಮ್ಯಾಕ್ರೋ ಡೆಫಿನಿಷನ್ MODULE_PARM_DESC ಅನ್ನು ಹೊಂದಿದೆ, ಇದು ರವಾನಿಸಲಾದ ಮಾಡ್ಯೂಲ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಮೇಲೆ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಮಾಡ್ಯೂಲ್ ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮತ್ತು ಉದಾಹರಣೆಗೆ, objdump ಯುಟಿಲಿಟಿ ಅಥವಾ ಸ್ವಯಂಚಾಲಿತ ಸಿಸ್ಟಮ್ ಆಡಳಿತ ಸಾಧನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವೀಕ್ಷಿಸಬಹುದು. ಈ ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನವನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ಇಂಟ್ ಬೇಸ್_ಪೋರ್ಟ್ = 0x300; MODULE_PARM(base_port, "i"); MODULE_PARM_DESC (base_port, "ಬೇಸ್ I/O ಪೋರ್ಟ್ (ಡೀಫಾಲ್ಟ್ 0x300)");

ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್ ನಿಯತಾಂಕಗಳು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವುದು ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ. ಇನ್ಸ್ಮೋಡ್ ಬಳಸಿ ಈ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸುವುದು ಅಗತ್ಯವಿದ್ದರೆ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ. ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪ್ರಸ್ತುತ ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಮಾಡ್ಯೂಲ್ ನಿಯತಾಂಕಗಳ ಸ್ಪಷ್ಟ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು. ತರುವಾಯ, ಕೆಳಗಿನ ರೇಖಾಚಿತ್ರವನ್ನು ಆಧರಿಸಿ ನೀವು ಸ್ವಯಂ-ಸಂರಚನಾ ಕಾರ್ಯವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯಗಳು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನಂತರ ಸ್ವಯಂ ಸಂರಚನೆಯನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಪ್ರಸ್ತುತ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಯೋಜನೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳು ಯಾವುದೇ ನೈಜ-ಪ್ರಪಂಚದ ಸಿಸ್ಟಮ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗದಿರುವುದು ಅವಶ್ಯಕ. ಹಸ್ತಚಾಲಿತ ಸಂರಚನೆಯಲ್ಲಿ ಬಳಕೆದಾರರಿಂದ ಅಂತಹ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಸ್ಕಲ್ ಡ್ರೈವರ್ ಸಾಧನ ಪೋರ್ಟ್‌ಗಳ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಹೇಗೆ ಸ್ವಯಂ ಪತ್ತೆ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸ್ವಯಂ ಪತ್ತೆ ಬಹು ಸಾಧನಗಳನ್ನು ನೋಡುತ್ತದೆ, ಹಸ್ತಚಾಲಿತ ಸಂರಚನೆಯು ಚಾಲಕವನ್ನು ಒಂದೇ ಸಾಧನಕ್ಕೆ ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ. I/O ಪೋರ್ಟ್‌ಗಳನ್ನು ವಿವರಿಸುವ ವಿಭಾಗದಲ್ಲಿ ನೀವು ಈಗಾಗಲೇ skull_detect ಕಾರ್ಯವನ್ನು ಈಗಾಗಲೇ ಭೇಟಿ ಮಾಡಿದ್ದೀರಿ. skull_init_board() ನ ಅನುಷ್ಠಾನವನ್ನು ತೋರಿಸಲಾಗಿಲ್ಲ ಏಕೆಂದರೆ ಅದು
ಹಾರ್ಡ್‌ವೇರ್-ಅವಲಂಬಿತ ಪ್ರಾರಂಭವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

/* * ಪೋರ್ಟ್ ಶ್ರೇಣಿಗಳು: ಸಾಧನವು * 0x280 ಮತ್ತು 0x300 ನಡುವೆ, 0x10 ಹಂತಗಳಲ್ಲಿ ವಾಸಿಸಬಹುದು. ಇದು 0x10 ಪೋರ್ಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. */ #ಡಿಫೈನ್ SKULL_PORT_FLOOR 0x280 #ಡಿಫೈನ್ SKULL_PORT_CEIL 0x300 #ಡಿಫೈನ್ SKULL_PORT_RANGE 0x010 /* * "skull_port_FLOOR" ಗೆ ನಿರ್ದಿಷ್ಟ * ಮೌಲ್ಯವನ್ನು insmod ನಿಂದ ನಿಯೋಜಿಸದ ಹೊರತು ಕೆಳಗಿನ ಕಾರ್ಯವು ಸ್ವಯಂ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. /* 0 ಬಲಗಳ ಸ್ವಯಂ ಪತ್ತೆ */ MODULE_PARM (skull_port_base, "i"); MODULE_PARM_DESC(skull_port_base, "Base I/O port for skull"); static int skull_find_hw(noid) /* ಸಾಧನಗಳ # ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ */ ( /* ಬೇಸ್ ಲೋಡ್-ಟೈಮ್ ಮೌಲ್ಯ ಅಥವಾ ಮೊದಲ ಪ್ರಯೋಗ */ int ಬೇಸ್ = skull_port_base ? skull_port_base: SKULL_PORT_FLOOR; ಇಂಟ್ ಫಲಿತಾಂಶ = 0; /* ಲೂಪ್ ಒಂದು ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಿದರೆ ಸಮಯ; ಸ್ವಯಂ ಪತ್ತೆ ಮಾಡಿದರೆ */ ಮಾಡಿದರೆ (ಸ್ಕಲ್_ಡಿಟೆಕ್ಟ್(ಬೇಸ್, SKULL_PORT_RANGE) == 0) (skull_init_board(base); result++; ) ಬೇಸ್ += SKULL_PORT_RANGE; /* ಮುಂದಿನ ಪ್ರಯೋಗಕ್ಕಾಗಿ ತಯಾರಿ ಮಾಡುವಾಗ */ ) ಎಲ್ಲವನ್ನೂ ಪ್ರಯತ್ನಿಸಿ (skull_port_base == 0 && ಬೇಸ್< SKULL_PORT_CEIL); return result; }

ಕಾನ್ಫಿಗರೇಶನ್ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಡ್ರೈವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬಳಸಿದರೆ (ಅಂದರೆ, ಕರ್ನಲ್ ಚಿಹ್ನೆ ಕೋಷ್ಟಕದಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗಿಲ್ಲ), ನಂತರ ಪ್ರೋಗ್ರಾಮರ್ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳಲ್ಲಿ ಪೂರ್ವಪ್ರತ್ಯಯಗಳನ್ನು ಬಳಸದೆ ಬಳಕೆದಾರರಿಗೆ ಜೀವನವನ್ನು ಸ್ವಲ್ಪ ಸುಲಭಗೊಳಿಸಬಹುದು (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, skull_ ಪೂರ್ವಪ್ರತ್ಯಯ) . ಈ ಪೂರ್ವಪ್ರತ್ಯಯಗಳು ಬಳಕೆದಾರರಿಗೆ ಕಡಿಮೆ ಅರ್ಥವನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಅನುಪಸ್ಥಿತಿಯು ಕೀಬೋರ್ಡ್‌ನಿಂದ ಆಜ್ಞೆಯನ್ನು ಟೈಪ್ ಮಾಡುವುದನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಸಂಪೂರ್ಣತೆಗಾಗಿ, ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಕೆಲವು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೂರು ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನಗಳ ವಿವರಣೆಯನ್ನು ನಾವು ಒದಗಿಸುತ್ತೇವೆ.

ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ಎನ್ನುವುದು ಕಂಪೈಲ್ ಮಾಡಿದ ಬೈನರಿ ಕೋಡ್ ಆಗಿದ್ದು ಅದನ್ನು ನೇರವಾಗಿ ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ, ಇದು ರಿಂಗ್ 0 ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ, x86-64 ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿನ ಒಳಗಿನ ಮತ್ತು ಕಡಿಮೆ ಸುರಕ್ಷಿತ ಸೂಚನಾ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ರಿಂಗ್. ಇಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಯಾವುದೇ ತಪಾಸಣೆಗಳಿಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ನಂಬಲಾಗದ ವೇಗದಲ್ಲಿ ಮತ್ತು ಯಾವುದೇ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಪ್ರವೇಶದೊಂದಿಗೆ.

ಕೇವಲ ಮನುಷ್ಯರಿಗಾಗಿ ಅಲ್ಲ

ಸಾಂಪ್ರದಾಯಿಕ ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿ ಮಾದರಿಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಮರೆತುಬಿಡಬಹುದು. ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ ಮತ್ತು ಇಳಿಸುವುದರ ಜೊತೆಗೆ, ಅನುಕ್ರಮ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುವ ಬದಲು ಸಿಸ್ಟಮ್ ಈವೆಂಟ್‌ಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವ ಕೋಡ್ ಅನ್ನು ನೀವು ಬರೆಯುತ್ತೀರಿ. ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ನೀವು API ಅನ್ನು ಬರೆಯುತ್ತೀರಿ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲ.

ನೀವು ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ. ಕರ್ನಲ್ printk (ಇದು printf ಗೆ ಬದಲಿಯಾಗಿದೆ) ಮತ್ತು kmalloc (ಇದು malloc ನಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ) ನಂತಹ ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆಯಾದರೂ, ನೀವು ಹೆಚ್ಚಾಗಿ ಹಾರ್ಡ್‌ವೇರ್‌ಗೆ ಬಿಡುತ್ತೀರಿ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸಿದ ನಂತರ ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಬೇಕು. ಇಲ್ಲಿ ಕಸ ಸಂಗ್ರಹಣೆ ಇಲ್ಲ.

ಅಗತ್ಯವಿರುವ ಘಟಕಗಳು

ಎರಡನೆಯದಾಗಿ, ನಿಮಗೆ ಪ್ರತ್ಯೇಕ ಭೌತಿಕ ಯಂತ್ರ ಅಥವಾ ವರ್ಚುವಲ್ ಯಂತ್ರದ ಅಗತ್ಯವಿದೆ. ವೈಯಕ್ತಿಕವಾಗಿ, ನಾನು ವರ್ಚುವಲ್ ಗಣಕದಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಬಯಸುತ್ತೇನೆ, ಆದರೆ ನಿಮ್ಮ ಆಯ್ಕೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. ನೀವು ತಪ್ಪು ಮಾಡಿದಾಗ ಡೇಟಾ ನಷ್ಟದ ಕಾರಣ ನಿಮ್ಮ ಮುಖ್ಯ ಯಂತ್ರವನ್ನು ಬಳಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ. ನಾನು "ಯಾವಾಗ" ಮತ್ತು "ಇದ್ದರೆ" ಎಂದು ಹೇಳುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಕಾರನ್ನು ಕೆಲವು ಬಾರಿ ಸ್ಥಗಿತಗೊಳಿಸುತ್ತೀರಿ. ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್ ಮಾಡಿದಾಗ ನಿಮ್ಮ ಇತ್ತೀಚಿನ ಕೋಡ್ ಬದಲಾವಣೆಗಳು ಬರೆಯುವ ಬಫರ್‌ನಲ್ಲಿರಬಹುದು, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಮೂಲಗಳು ಸಹ ದೋಷಪೂರಿತವಾಗಬಹುದು. ವರ್ಚುವಲ್ ಗಣಕದಲ್ಲಿ ಪರೀಕ್ಷೆಯು ಈ ಅಪಾಯಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ನೀವು ಕನಿಷ್ಟ ಸ್ವಲ್ಪ C ಅನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. C++ ರನ್‌ಟೈಮ್ ಕರ್ನಲ್‌ಗೆ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಶುದ್ಧವಾದ, ಬೇರ್ C ನಲ್ಲಿ ಬರೆಯಬೇಕಾಗಿದೆ. ಹಾರ್ಡ್‌ವೇರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯ ಕೆಲವು ಜ್ಞಾನವು ಸಹ ಸಹಾಯಕವಾಗಿದೆ.

ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸುವುದು

Apt-get install build-essential linux-headers-`uname -r`
ಈ ಉದಾಹರಣೆಗಾಗಿ ಅಗತ್ಯವಿರುವ ಪ್ರಮುಖ ಅಭಿವೃದ್ಧಿ ಪರಿಕರಗಳು ಮತ್ತು ಕರ್ನಲ್ ಹೆಡರ್‌ಗಳನ್ನು ನಾವು ಸ್ಥಾಪಿಸುತ್ತೇವೆ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಗಳು ನೀವು ರೂಟ್‌ಗಿಂತ ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರಂತೆ ಚಾಲನೆಯಲ್ಲಿರುವಿರಿ ಎಂದು ಊಹಿಸುತ್ತವೆ, ಆದರೆ ನೀವು ಸುಡೋ ಸವಲತ್ತುಗಳನ್ನು ಹೊಂದಿರುವಿರಿ. ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡಲು Sudo ಅಗತ್ಯವಿದೆ, ಆದರೆ ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ನಾವು ರೂಟ್‌ನ ಹೊರಗೆ ಕೆಲಸ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ.

ಆರಂಭಿಸಲು

Mkdir ~/src/lkm_example cd ~/src/lkm_example
ನಿಮ್ಮ ಮೆಚ್ಚಿನ ಸಂಪಾದಕವನ್ನು ಪ್ರಾರಂಭಿಸಿ (ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ vim) ಮತ್ತು ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ lkm_example.c ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:

#ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು MODULE_LICENSE("GPL"); MODULE_AUTHOR("ರಾಬರ್ಟ್ W. ಆಲಿವರ್ II"); MODULE_DESCRIPTION("ಸರಳ ಉದಾಹರಣೆ Linux ಮಾಡ್ಯೂಲ್."); MODULE_VERSION("0.01"); static int __init lkm_example_init(ಶೂನ್ಯ) ( printk(KERN_INFO "ಹಲೋ, ವರ್ಲ್ಡ್!\n"); ಹಿಂತಿರುಗಿ 0; ) ಸ್ಥಿರ ನಿರರ್ಥಕ __exit lkm_example_exit(noid) ( printk(KERN_INFO "ಗುಡ್ ಬೈ, ವರ್ಲ್ಡ್!\n"); ); ಮಾಡ್ಯೂಲ್_ಎಕ್ಸಿಟ್ (lkm_example_exit);
ನಾವು ಸಾಧ್ಯವಾದಷ್ಟು ಸರಳವಾದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದೇವೆ, ಅದರ ಪ್ರಮುಖ ಭಾಗಗಳನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡೋಣ:

• Linux ಕರ್ನಲ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಅಗತ್ಯವಿರುವ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.
• ಮಾಡ್ಯೂಲ್‌ನ ಪರವಾನಗಿಯನ್ನು ಅವಲಂಬಿಸಿ MODULE_LICENSE ಅನ್ನು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳಿಗೆ ಹೊಂದಿಸಬಹುದು. ಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ನೋಡಲು, ರನ್ ಮಾಡಿ:

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

• ನಾವು init (ಲೋಡಿಂಗ್) ಮತ್ತು ನಿರ್ಗಮನ (ಇಳಿಸುವಿಕೆ) ಅನ್ನು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹಿಂದಿರುಗಿಸುವ ಸ್ಥಿರ ಕಾರ್ಯಗಳಾಗಿ ಹೊಂದಿಸುತ್ತೇವೆ.
• printf ಬದಲಿಗೆ printk ಬಳಕೆಯನ್ನು ಗಮನಿಸಿ. ಹಾಗೆಯೇ printk ಗಾಗಿ ಆಯ್ಕೆಗಳು printf ಗಿಂತ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಸಾಲಿಗೆ ಲಾಗಿಂಗ್ ಆದ್ಯತೆಯನ್ನು ಘೋಷಿಸಲು KERN_INFO ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಅಲ್ಪವಿರಾಮವಿಲ್ಲದೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ಸ್ಟಾಕ್ ಮೆಮೊರಿಯನ್ನು ಉಳಿಸಲು ಕರ್ನಲ್ ಈ ವಿಷಯಗಳನ್ನು 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) ಕ್ಲೀನ್
ನಾವು ರನ್ ಮಾಡಿದರೆ ಅದು ನಮ್ಮ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಕಂಪೈಲ್ ಮಾಡಬೇಕು. ಫಲಿತಾಂಶವು lkm_example.ko ಫೈಲ್ ಆಗಿರುತ್ತದೆ. ಯಾವುದೇ ದೋಷಗಳು ಸಂಭವಿಸಿದಲ್ಲಿ, ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿನ ಉಲ್ಲೇಖಗಳನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆಯೇ ಮತ್ತು UTF-8 ಎನ್‌ಕೋಡಿಂಗ್‌ನಲ್ಲಿ ಆಕಸ್ಮಿಕವಾಗಿ ಅಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಈಗ ನೀವು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು. ಇದನ್ನು ಮಾಡಲು ನಾವು ಓಡುತ್ತೇವೆ:

Sudo insmod lkm_example.ko
ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ, ನೀವು ಏನನ್ನೂ ನೋಡುವುದಿಲ್ಲ. printk ಕಾರ್ಯವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಅಲ್ಲ, ಆದರೆ ಕರ್ನಲ್ ಲಾಗ್‌ಗೆ ಒದಗಿಸುತ್ತದೆ. ವೀಕ್ಷಿಸಲು ನೀವು ರನ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ:

ಸುಡೋ ಡಿಎಂಎಸ್ಜಿ
ನೀವು "ಹಲೋ, ವರ್ಲ್ಡ್!" ಎಂಬ ಸಾಲನ್ನು ನೋಡಬೇಕು. ಆರಂಭದಲ್ಲಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನೊಂದಿಗೆ. ಇದರರ್ಥ ನಮ್ಮ ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಕರ್ನಲ್ ಲಾಗ್‌ಗೆ ಯಶಸ್ವಿಯಾಗಿ ಬರೆಯಲಾಗಿದೆ. ಮಾಡ್ಯೂಲ್ ಇನ್ನೂ ಮೆಮೊರಿಯಲ್ಲಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬಹುದು:

lsmod | grep “lkm_example”
ಮಾಡ್ಯೂಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು, ರನ್ ಮಾಡಿ:

Sudo rmmod lkm_example
ನೀವು ಮತ್ತೊಮ್ಮೆ dmesg ಅನ್ನು ರನ್ ಮಾಡಿದರೆ, ಲಾಗ್‌ನಲ್ಲಿ “ಗುಡ್‌ಬೈ, ವರ್ಲ್ಡ್!” ಎಂಬ ನಮೂದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ. ನೀವು ಮತ್ತೆ lsmod ಅನ್ನು ಚಲಾಯಿಸಬಹುದು ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸಲಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ನೀವು ನೋಡುವಂತೆ, ಈ ಪರೀಕ್ಷಾ ವಿಧಾನವು ಸ್ವಲ್ಪ ಬೇಸರದ ಸಂಗತಿಯಾಗಿದೆ, ಆದರೆ ಇದನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು:

ಪರೀಕ್ಷೆ: sudo dmesg -C sudo insmod lkm_example.ko sudo rmmod lkm_example.ko dmesg
ಮೇಕ್‌ಫೈಲ್‌ನ ಕೊನೆಯಲ್ಲಿ ಮತ್ತು ನಂತರ ಚಾಲನೆಯಲ್ಲಿದೆ:

ಪರೀಕ್ಷೆ ಮಾಡಿ
ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ಪ್ರತ್ಯೇಕ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸದೆಯೇ ಕರ್ನಲ್ ಲಾಗ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು.

ನಾವು ಈಗ ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಷುಲ್ಲಕ, ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ!

ಸ್ವಲ್ಪ ಆಳವಾಗಿ ಅಗೆಯೋಣ. ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳು ಎಲ್ಲಾ ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದ್ದರೂ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಇಂಟರ್‌ಫೇಸ್ ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕರ್ನಲ್ ಜಾಗದಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ವೀಕ್ಷಿಸಲು ಅನುಮತಿಸದ ಕಾರಣ, ಅವುಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು API ಅನ್ನು ಬಳಸಬೇಕು. ತಾಂತ್ರಿಕವಾಗಿ ಇದನ್ನು ಮಾಡಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ, ಸಾಧನ ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ.

ನೀವು ಬಹುಶಃ ಮೊದಲು ಸಾಧನ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸಿದ್ದೀರಿ. ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂದಿರುಗಿಸುವ "ಶೂನ್ಯ" ಮತ್ತು "ಶೂನ್ಯ" ಸಾಧನಗಳೊಂದಿಗೆ /dev/zero , /dev/null ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ನಮೂದಿಸುವ ಆಜ್ಞೆಗಳು ಸಂವಹನ ನಡೆಸುತ್ತವೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು "ಹಲೋ, ವರ್ಲ್ಡ್" ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ. ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯವಲ್ಲದಿದ್ದರೂ, ಸಾಧನ ಫೈಲ್ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಇದು ಇನ್ನೂ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ:

#ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು #ಸೇರಿಸು MODULE_LICENSE("GPL"); MODULE_AUTHOR("ರಾಬರ್ಟ್ W. ಆಲಿವರ್ II"); MODULE_DESCRIPTION("ಸರಳ ಉದಾಹರಣೆ Linux ಮಾಡ್ಯೂಲ್."); MODULE_VERSION("0.01"); #DEVICE_NAME "lkm_example" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ #ಉದಾಹರಣೆ_MSG "ಹಲೋ, ವರ್ಲ್ಡ್!\n" #ಡಿಫೈನ್ MSG_BUFFER_LEN 15 /* ಸಾಧನ ಕಾರ್ಯಗಳಿಗಾಗಿ ಮೂಲಮಾದರಿಗಳು */ ಸ್ಟ್ಯಾಟಿಕ್ ಇಂಟ್ ಡಿವೈಸ್_ಓಪನ್ (ಸ್ಟ್ರಕ್ಟ್ ಐನೋಡ್ *, ಸ್ಟ್ರಕ್ಟ್ ಫೈಲ್ *); ಸ್ಥಿರ ಇಂಟ್ ಸಾಧನ_ಬಿಡುಗಡೆ (ಸ್ಟ್ರಕ್ಟ್ ಐನೋಡ್ *, ಸ್ಟ್ರಕ್ಟ್ ಫೈಲ್ *); ಸ್ಥಿರ ssize_t device_read (struct file *, char *, size_t, loff_t *); ಸ್ಥಿರ ssize_t device_write (struct file *, const char *, size_t, loff_t *); ಸ್ಥಿರ ಇಂಟ್ ಪ್ರಮುಖ_ಸಂಖ್ಯೆ; ಸ್ಥಿರ ಇಂಟ್ device_open_count = 0; ಸ್ಥಿರ ಚಾರ್ msg_buffer; ಸ್ಥಿರ ಚಾರ್ *msg_ptr; /* ಈ ರಚನೆಯು ಸಾಧನದ ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ */ ಸ್ಥಿರ struct file_operations file_ops = (.read = device_read, .write = device_write, .open = device_open, .release = device_release ); /* ನಮ್ಮ ಸಾಧನದಿಂದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಓದಿದಾಗ, ಇದನ್ನು ಕರೆಯಲಾಗುವುದು. */ ಸ್ಟ್ಯಾಟಿಕ್ ssize_t device_read (struct file *flip, char *buffer, size_t len, loff_t *offset) ( int bytes_read = 0; /* ನಾವು ಕೊನೆಯಲ್ಲಿದ್ದರೆ, ಪ್ರಾರಂಭಕ್ಕೆ ಹಿಂತಿರುಗಿ */ ವೇಳೆ (*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; ) /* ಯಾವಾಗ ಕರೆ ಮಾಡಿದಾಗ ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ನಮ್ಮ ಸಾಧನವನ್ನು ತೆರೆಯುತ್ತದೆ */ ಸ್ಥಾಯೀ ಇಂಟ್ ಸಾಧನ_ಓಪನ್ (ಸ್ಟ್ರಕ್ಟ್ ಐನೋಡ್ *ಇನೋಡ್, ಸ್ಟ್ರಕ್ಟ್ ಫೈಲ್ *ಫೈಲ್) ( /* ಸಾಧನವು ತೆರೆದಿದ್ದರೆ, ಕಾರ್ಯನಿರತವಾಗಿ ಹಿಂತಿರುಗಿ */ ವೇಳೆ (ಡಿವೈಸ್_ಓಪನ್_ಕೌಂಟ್) ( ರಿಟರ್ನ್ -ಇಬಿಯುಎಸ್‌ವೈ; ) ಡಿವೈಸ್_ಓಪನ್_ಕೌಂಟ್++; ಟ್ರೈ_ಮೊಡ್ಯೂಲ್_ಗೆಟ್(THIS_MODULE); ಹಿಂತಿರುಗಿ 0; ) /* ಪ್ರಕ್ರಿಯೆಯು ನಮ್ಮ ಸಾಧನವನ್ನು ಮುಚ್ಚಿದಾಗ ಕರೆ ಮಾಡಲಾಗಿದೆ */ ಸ್ಟ್ಯಾಟಿಕ್ ಇಂಟ್ device_release(struct inode *inode, struct file *file) ( /* ತೆರೆದ ಕೌಂಟರ್ ಮತ್ತು ಬಳಕೆಯ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ. ಇದು ಇಲ್ಲದೆ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸುವುದಿಲ್ಲ. */ device_open_count- -; ಮಾಡ್ಯೂಲ್_ಪುಟ್ (THIS_MODULE); 0; ಹಿಂತಿರುಗಿ ಅನುಭವಿಸುತ್ತಾರೆ ; /* ಅಕ್ಷರ ಸಾಧನವನ್ನು ನೋಂದಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ */ 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 ಮಾಡಿ )/ಬಿಲ್ಡ್ M=$(PWD) ಕ್ಲೀನ್ ಪರೀಕ್ಷೆ: # ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡದಿದ್ದಲ್ಲಿ ನಿರ್ಲಕ್ಷಿಸಲು # ದೋಷ ಎಂದು ಹೇಳಲು ನಾವು rmmod ಆಜ್ಞೆಯ ಮುಂದೆ - ಅನ್ನು ಇರಿಸಿದ್ದೇವೆ. -sudo rmmod lkm_example # ಎಕೋ sudo dmesg ಇಲ್ಲದೆ ಕರ್ನಲ್ ಲಾಗ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಿ -C # ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸೇರಿಸಿ sudo insmod lkm_example.ko # ಕರ್ನಲ್ ಲಾಗ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಿ dmesg
ಈಗ ಪರೀಕ್ಷೆಯನ್ನು ರನ್ ಮಾಡಿದ ನಂತರ ನೀವು ಪ್ರಮುಖ ಸಾಧನ ಸಂಖ್ಯೆ ಔಟ್‌ಪುಟ್ ಆಗಿರುವುದನ್ನು ನೋಡುತ್ತೀರಿ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರ್ನಲ್ನಿಂದ ನಿಯೋಜಿಸಲ್ಪಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಹೊಸ ಸಾಧನವನ್ನು ರಚಿಸಲು ಈ ಸಂಖ್ಯೆಯ ಅಗತ್ಯವಿದೆ.

ಪರೀಕ್ಷೆಯ ಮೂಲಕ ರಚಿಸಲಾದ ಸಂಖ್ಯೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ ಮತ್ತು ಸಾಧನ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಅದನ್ನು ಬಳಸಿ ಇದರಿಂದ ನಾವು ಬಳಕೆದಾರರ ಸ್ಥಳದಿಂದ ನಮ್ಮ ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ ಸಂವಹನ ಮಾಡಬಹುದು.

MAJOR 0 ನೊಂದಿಗೆ Sudo mknod /dev/lkm_example
(ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, MAJOR ಅನ್ನು ಮೇಕ್ ಟೆಸ್ಟ್ ಅಥವಾ dmesg ನಿಂದ ಪಡೆದ ಮೌಲ್ಯದೊಂದಿಗೆ ಬದಲಾಯಿಸಿ)

mknod ಆಜ್ಞೆಯಲ್ಲಿನ c ಆಯ್ಕೆಯು mknod ಗೆ ನಾವು ಅಕ್ಷರ ಸಾಧನ ಫೈಲ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ.

ಈಗ ನಾವು ಸಾಧನದಿಂದ ವಿಷಯವನ್ನು ಪಡೆಯಬಹುದು:

ಬೆಕ್ಕು /dev/lkm_example
ಅಥವಾ dd ಆಜ್ಞೆಯ ಮೂಲಕವೂ:

Dd if=/dev/lkm_example of=test bs=14 count=100
ನೀವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದಲೂ ಈ ಫೈಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಇವುಗಳು ಕಂಪೈಲ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾಗಿರಬೇಕಾಗಿಲ್ಲ - ಪೈಥಾನ್, ರೂಬಿ ಮತ್ತು PHP ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸಹ ಈ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿವೆ.

ನಾವು ಸಾಧನವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ನಾವು ಅದನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಳಿಸುತ್ತೇವೆ:

Sudo rm /dev/lkm_example sudo rmmod lkm_example

ತೀರ್ಮಾನ

ಕರ್ನಲ್ ಜಾಗದಲ್ಲಿ ಎಲ್ಲವೂ ನಿಮ್ಮ ಜವಾಬ್ದಾರಿ ಎಂದು ನೆನಪಿಡಿ. ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ಯಾವುದೇ ಬೆಂಬಲ ಅಥವಾ ಎರಡನೇ ಅವಕಾಶವಿಲ್ಲ. ನೀವು ಕ್ಲೈಂಟ್‌ಗಾಗಿ ಪ್ರಾಜೆಕ್ಟ್ ಮಾಡುತ್ತಿದ್ದರೆ, ಎರಡು ಬಾರಿ, ಟ್ರಿಪಲ್ ಅಲ್ಲದಿದ್ದಲ್ಲಿ, ಡೀಬಗ್ ಮಾಡುವ ಸಮಯವನ್ನು ಯೋಜಿಸಿ. ಕರ್ನಲ್ ಕೋಡ್ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವ್ಯವಸ್ಥೆಗಳ ಸಮಗ್ರತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾದಷ್ಟು ಪರಿಪೂರ್ಣವಾಗಿರಬೇಕು.

ಮಾಡ್ಯುಲರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಮಾಡ್ಯುಲರ್ ರಚನೆಯ ಉಪಪ್ರೋಗ್ರಾಂಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಮಾನ್ಯ ಶಿಫಾರಸುಗಳು.

ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು USES ಎಂದು ಘೋಷಿಸುವ ಕ್ರಮದಲ್ಲಿ ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂಗೆ ಸಂಪರ್ಕಪಡಿಸಲಾಗಿದೆ ಮತ್ತು ಅದೇ ಕ್ರಮದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂಗೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಮಾಡ್ಯೂಲ್‌ಗಳ ಇನಿಶಿಯಲೈಸೇಶನ್ ಬ್ಲಾಕ್‌ಗಳು.

ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕ್ರಮವು ಲೈಬ್ರರಿ ಡೇಟಾ ಪ್ರವೇಶ ಮತ್ತು ವಾಡಿಕೆಯ ಪ್ರವೇಶದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು.

ಉದಾಹರಣೆಗೆ, M1, M2 ಹೆಸರಿನ ಮಾಡ್ಯೂಲ್‌ಗಳು ಒಂದೇ ರೀತಿಯ A, ವೇರಿಯೇಬಲ್ B ಮತ್ತು ಸಬ್‌ರುಟೀನ್ C ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ಈ USES ಮಾದರಿಗಳನ್ನು ಸಂಪರ್ಕಿಸಿದ ನಂತರ, ಈ PU ನಲ್ಲಿ A, B, C ಗೆ ಕರೆಗಳು M2 ಮಾಡ್ಯೂಲ್‌ಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಮಾಡುವ ಕರೆಗಳಿಗೆ ಸಮನಾಗಿರುತ್ತದೆ. .

ಆದರೆ ವಿಭಿನ್ನ ಸಂಪರ್ಕಿತ ಮಾಡ್ಯೂಲ್‌ಗಳಿಂದ ಒಂದೇ ಹೆಸರಿನ ಅಗತ್ಯ ವಸ್ತುಗಳಿಗೆ ಕರೆಗಳ ಸರಿಯಾದತೆಯನ್ನು ನಿರೂಪಿಸಲು, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ಮೊದಲು ಮಾಡ್ಯೂಲ್‌ನ ಹೆಸರನ್ನು ಸೂಚಿಸಲು ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ, ನಂತರ ವಸ್ತುವಿನ ಹೆಸರನ್ನು ಡಾಟ್ ಮಾಡಿ: M1. A M1.B M1.C M2.B.

ನಿಸ್ಸಂಶಯವಾಗಿ, ದೊಡ್ಡ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಎರಡು ಭಾಗಗಳಾಗಿ (PU) ವಿಭಜಿಸುವುದು ತುಂಬಾ ಸುಲಭ, ಅಂದರೆ. ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂ + ಮಾಡ್ಯೂಲ್ಗಳು.

ಪ್ರತಿ PU ಅನ್ನು ಅದರ ಸ್ವಂತ ಮೆಮೊರಿ ವಿಭಾಗದಲ್ಲಿ ಮತ್ತು ಅದರ ಸ್ವಂತ ಡಿಸ್ಕ್ ಫೈಲ್‌ನಲ್ಲಿ ಇರಿಸುವುದು.

ಪ್ರಕಾರಗಳ ಎಲ್ಲಾ ಘೋಷಣೆಗಳು, ಹಾಗೆಯೇ ಪ್ರತ್ಯೇಕ PU ಗಳಿಗೆ (ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಭವಿಷ್ಯದ ಮಾಡ್ಯೂಲ್‌ಗಳು) ಲಭ್ಯವಾಗಬೇಕಾದ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಖಾಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಭಾಗದೊಂದಿಗೆ ಪ್ರತ್ಯೇಕ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಇರಿಸಬೇಕು. ಆದಾಗ್ಯೂ, ಕೆಲವು PE (ಉದಾಹರಣೆಗೆ, ಮಾಡ್ಯೂಲ್) ಈ ಎಲ್ಲಾ ಘೋಷಣೆಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ ಎಂಬ ಅಂಶಕ್ಕೆ ನೀವು ಗಮನ ಕೊಡಬಾರದು. ಅಂತಹ ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಾರಂಭದ ಭಾಗವು ಫೈಲ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರಮಾಣಿತವಲ್ಲದ ಪಠ್ಯ ಫೈಲ್‌ಗಳೊಂದಿಗೆ (ASSIGN) ಸಂಯೋಜಿಸುವ ಮತ್ತು ಈ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಹೇಳಿಕೆಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು, ಅಂದರೆ. ಅವರಿಗೆ ಡೇಟಾ ವರ್ಗಾವಣೆ ಕರೆಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ (ಮರುಹೊಂದಿಸಿ ಮತ್ತು ಪುನಃ ಬರೆಯಿರಿ).

ಇತರ ಸಬ್ರುಟೀನ್ಗಳ ಮೊದಲ ಗುಂಪು, ಉದಾಹರಣೆಗೆ, ಹಲವಾರು ಕಾಂಪ್ಯಾಕ್ಟ್ ಕಾರ್ಯಗಳನ್ನು ಮಾಡ್ಯೂಲ್ 3 ರಲ್ಲಿ ಇರಿಸಬೇಕು (ಪ್ರತಿಯಾಗಿ), ಇತರರು, ಉದಾಹರಣೆಗೆ, ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಕಾರ್ಯವಿಧಾನಗಳು - ಮಾಡ್ಯೂಲ್ 4 ರಲ್ಲಿ, ಇತ್ಯಾದಿ.

ಸಂಕೀರ್ಣ ಯೋಜನೆಯಲ್ಲಿ ಸಬ್ರುಟೀನ್ಗಳನ್ನು ಮಾಡ್ಯೂಲ್ಗಳಾಗಿ ವಿತರಿಸುವಾಗ, ಅವರ ಬರವಣಿಗೆಯ ಆದೇಶ ಮತ್ತು ಸ್ಥಳಕ್ಕೆ ವಿಶೇಷ ಗಮನ ನೀಡಬೇಕು.

TP ಪರಿಸರವು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಸಾಧನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

Alt+F9 RUN Cntr+F9 ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ

ಗಮ್ಯಸ್ಥಾನದ ಸ್ಮರಣೆ

ಈ ವಿಧಾನಗಳು ಸಂವಹನ ವಿಧಾನ ಮತ್ತು ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಮಾತ್ರ ಭಿನ್ನವಾಗಿರುತ್ತವೆ.

ಕಂಪೈಲ್ ಮೋಡ್

ಪ್ರಸ್ತುತ ಸಕ್ರಿಯ ಸಂಪಾದಕ ವಿಂಡೋದಲ್ಲಿರುವ ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ. ಈ PU ಪ್ರಮಾಣಿತವಲ್ಲದ ಬಳಕೆದಾರ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದರೆ, ಈ ಮೋಡ್‌ಗೆ ಅಂತಹ ಪ್ರತಿಯೊಂದು ಪ್ಲಗ್-ಇನ್ ಮಾಡ್ಯೂಲ್‌ಗೆ ___.tpu ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಅದೇ ಹೆಸರಿನ ಡಿಸ್ಕ್ ಫೈಲ್‌ಗಳ ಉಪಸ್ಥಿತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಗಮ್ಯಸ್ಥಾನವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದರೆ, ಈ ಫೈಲ್‌ಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಮಾತ್ರ ಉಳಿಯುತ್ತವೆ ಮತ್ತು ಡಿಸ್ಕ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿಲ್ಲ.

ಆದಾಗ್ಯೂ, ಗಮ್ಯಸ್ಥಾನ ಆಯ್ಕೆಗಾಗಿ ಡಿಸ್ಕ್ ಅನ್ನು ಹೊಂದಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಇತರ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಪೂರ್ಣ ಪ್ರೋಗ್ರಾಂನ ಕಂಪೈಲರ್ನೊಂದಿಗೆ tpu ಫೈಲ್ಗಳನ್ನು ರಚಿಸುವುದು ತುಂಬಾ ಸುಲಭ.

ಮೋಡ್ ಮಾಡಿ

ಈ ಕ್ರಮದಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡುವಾಗ, ಪ್ರತಿ ಮಾಡ್ಯೂಲ್‌ಗೆ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮೊದಲು (ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮೊದಲು) ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ:

1) ಡಿಸ್ಕ್ ಟಿಪಿಯು ಫೈಲ್ ಅಸ್ತಿತ್ವ; ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಮಾಡ್ಯೂಲ್ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮೂಲಕ ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ. ಅದರ ಪಾಸ್ ಫೈಲ್

2) ಮಾಡ್ಯೂಲ್‌ನ ಮೂಲ ಪಠ್ಯಕ್ಕೆ ಕಂಡುಬಂದ tpu ಫೈಲ್‌ನ ಪತ್ರವ್ಯವಹಾರ, ಅಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬಹುದಾಗಿತ್ತು; ಇಲ್ಲದಿದ್ದರೆ tpu ಫೈಲ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮತ್ತೆ ರಚಿಸಲ್ಪಡುತ್ತದೆ

3) ಮಾಡ್ಯೂಲ್‌ನ ಇಂಟರ್ಫೇಸ್ ವಿಭಾಗದ ಅಸ್ಥಿರತೆ: ಅದು ಬದಲಾಗಿದ್ದರೆ, USES ಷರತ್ತಿನಲ್ಲಿ ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್‌ಗಳು (ಅವುಗಳ ಮೂಲ ಪಾಸ್-ಫೈಲ್‌ಗಳು) ಸಹ ಮರುಸಂಕಲಿಸಲ್ಪಡುತ್ತವೆ.

ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೂಲ ಕೋಡ್‌ಗಳಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆ ಇಲ್ಲದಿದ್ದರೆ, ಕಂಪೈಲರ್ ಈ tpu ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಮತ್ತು ಸಂಕಲನ ಸಮಯವನ್ನು ಬಳಸುತ್ತದೆ.

ಬಿಲ್ಡ್ ಮೋಡ್

ಮೇಕ್ ಮೋಡ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ಇದು ಮೂಲ ಪಾಸ್ ಫೈಲ್‌ಗಳ ಉಪಸ್ಥಿತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ; ಪ್ರತಿ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ (ಮರುಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ) ಮತ್ತು ಆ ಮೂಲಕ ಪಾಸ್ ಫೈಲ್‌ಗಳ ಪಠ್ಯಗಳಲ್ಲಿನ ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಒಟ್ಟಾರೆಯಾಗಿ ಕಾರ್ಯಕ್ರಮದ ಸಂಕಲನ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ಕಂಪೈಲ್ ಮೋಡ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ಮಾಡ್ಯುಲರ್ ರಚನೆಯೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಮೇಕ್ ಮತ್ತು ಬಿಲ್ಡ್ ಮೋಡ್‌ಗಳು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ, ಯಾವುದೇ ಫೈಲ್ (ಅಥವಾ ಪ್ರೋಗ್ರಾಂನ ಭಾಗ) ಸಕ್ರಿಯವಾಗಿದ್ದರೂ ಯಾವುದೇ ಪಾಸ್ ಫೈಲ್‌ನಿಂದ (ಇದನ್ನು ಪ್ರಾಥಮಿಕ ಫೈಲ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ). ಸಂಪಾದಕ ವಿಂಡೋ. ಇದನ್ನು ಮಾಡಲು, ಕಂಪೈಲ್ ಐಟಂನಲ್ಲಿ, ಪ್ರಾಥಮಿಕ ಫೈಲ್ ಆಯ್ಕೆಯನ್ನು ಆರಿಸಿ, Enter ಅನ್ನು ಒತ್ತಿ ಮತ್ತು ಪ್ರಾಥಮಿಕ ಪಾಸ್-ಫೈಲ್ನ ಹೆಸರನ್ನು ಬರೆಯಿರಿ ಮತ್ತು ನಂತರ ಈ ಫೈಲ್ನಿಂದ ಸಂಕಲನ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಪ್ರಾಥಮಿಕ ಫೈಲ್ ಅನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂ ಸಕ್ರಿಯ ಸಂಪಾದಕ ವಿಂಡೋದಲ್ಲಿದ್ದರೆ ಮಾತ್ರ ಮೇಕ್, ಬಿಲ್ಡ್ ಮತ್ತು ರನ್ ಮೋಡ್‌ಗಳಲ್ಲಿ ಸಂಕಲನ ಸಾಧ್ಯ.

ಗಮನಿಸಿ: ಭವಿಷ್ಯದಲ್ಲಿ, ಪಪ್ಪಿಗಾಗಿ ಕರ್ನಲ್ ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು T2 ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸಲು ನಾನು ಯೋಜಿಸುತ್ತೇನೆ. ಕರ್ನಲ್ ಮತ್ತು ಹಲವಾರು ಹೆಚ್ಚುವರಿ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು T2 ಅನ್ನು ಪ್ರಸ್ತುತ ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಆದರೆ ಪ್ರಸ್ತುತ ಪಪ್ಪಿಯಲ್ಲಿ ಬಳಸಲಾದ ಆವೃತ್ತಿಯಲ್ಲ. ಪಪ್ಪಿಯ ಭವಿಷ್ಯದ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಾನು ಉದ್ದೇಶಿಸಿದ್ದೇನೆ, ಇದರಿಂದಾಗಿ T2 ನಲ್ಲಿ ಸಂಕಲಿಸಲಾದ ಕರ್ನಲ್ ಅನ್ನು ಪಪ್ಪಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಾಯಿಮರಿ ಮತ್ತು T2 ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ http://www.puppyos.net/pfs/ ನೋಡಿ.

xxx ಆವೃತ್ತಿಯ ಸಂಖ್ಯೆಯಾಗಿರುವ devx_xxx.sfs ಎಂಬ ಒಂದೇ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ C/C++ ಕಂಪೈಲರ್‌ಗಳನ್ನು ಬಳಸಲು ಪಪ್ಪಿ ತುಂಬಾ ಸರಳವಾದ ಮಾರ್ಗವನ್ನು ಹೊಂದಿದೆ. ಉದಾಹರಣೆಗೆ, ಪಪ್ಪಿ 2.12 devx_212.sfs ಹೆಸರಿನ ಅನುಸರಣೆ ಅಭಿವೃದ್ಧಿ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. LiveCD ಮೋಡ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, devx_xxx.sfs ಫೈಲ್ ಅನ್ನು ನಿಮ್ಮ ವೈಯಕ್ತಿಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಫೈಲ್ pup_save.3fs ಅದೇ ಸ್ಥಳದಲ್ಲಿ ಇರಿಸಿ, ಅದು ಸಾಮಾನ್ಯವಾಗಿ /mnt/home/ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿದೆ. ಇದು pup_save.3fs ಫೈಲ್ ಹೊಂದಿರುವ ಇತರ ಅನುಸ್ಥಾಪನಾ ವಿಧಾನಗಳಿಗೂ ಅನ್ವಯಿಸುತ್ತದೆ. ಪೂರ್ಣ "ಆಯ್ಕೆ 2" ಅನುಸ್ಥಾಪನೆಯೊಂದಿಗೆ ಹಾರ್ಡ್ ಡ್ರೈವಿನಲ್ಲಿ ಪಪ್ಪಿ ಸ್ಥಾಪಿಸಿದ್ದರೆ, ನಂತರ ಯಾವುದೇ ವೈಯಕ್ತಿಕ ಫೈಲ್ ಇಲ್ಲ, ವಿವಿಧ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಸಂಕಲಿಸಲು ಪಪ್ಪಿ ವೆಬ್ ಪುಟಗಳನ್ನು ನೋಡಿ, ಆದ್ದರಿಂದ ಮಾಡ್ಯೂಲ್ಗಳು ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ಈ ಆವೃತ್ತಿಗಳಿಗೆ ಸ್ಕ್ವ್ಯಾಷ್‌ಗಳಿಗೆ ಒಂದು ಪ್ಯಾಚ್ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ. ಪಪ್ಪಿ 2.12 ಕರ್ನಲ್ 2.6.18.1 ಅನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಮೂರು ಪರಿಹಾರಗಳನ್ನು ಹೊಂದಿದೆ; squashfs, ಡೀಫಾಲ್ಟ್ ಕನ್ಸೋಲ್ ಲಾಗ್‌ಲೆವೆಲ್ ಮತ್ತು ಶಟ್‌ಡೌನ್ ಫಿಕ್ಸ್.

ಕರ್ನಲ್ ಅನ್ನು ಪ್ಯಾಚ್ ಮಾಡಲು ಈ ಆಜ್ಞೆಗಳನ್ನು ನಿಮ್ಮ ಸ್ವಯಂ ಶಿಕ್ಷಣಕ್ಕಾಗಿ ಮಾತ್ರ ನೀಡಲಾಗಿದೆ, ಏಕೆಂದರೆ ಪ್ಯಾಚ್ ಮಾಡಿದ ಕರ್ನಲ್ ಈಗಾಗಲೇ ಲಭ್ಯವಿದೆ...

ನೀವು ಮೊದಲು ಮಾಡಬೇಕಾದ ಮೊದಲ ವಿಷಯವೆಂದರೆ ಕರ್ನಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು. ಸೂಕ್ತವಾದ ಡೌನ್‌ಲೋಡ್ ಸೈಟ್‌ಗೆ ಲಿಂಕ್ ಅನ್ನು ಹುಡುಕಲು ಇದು ಇದೆ. ಇದು kernel.org ಅಥವಾ ಅದರ ಕನ್ನಡಿಗಳಲ್ಲಿ ಲಭ್ಯವಿರುವ "ಪ್ರಾಚೀನ" ಮೂಲವಾಗಿರಬೇಕು.

ಇಂಟರ್ನೆಟ್‌ಗೆ ಸಂಪರ್ಕಪಡಿಸಿ, ಕರ್ನಲ್ ಅನ್ನು /usr/src ಫೋಲ್ಡರ್‌ಗೆ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ. ನಂತರ ಅದನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿ:

ನೀವು ಈ ಫೋಲ್ಡರ್ ಅನ್ನು ನೋಡಬೇಕು: /usr/src/linux-2.6.16.7. ನಂತರ ಈ ಲಿಂಕ್ ಕರ್ನಲ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು:

ನೀವು ಈ ಕೆಳಗಿನ ಪರಿಹಾರಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕು ಇದರಿಂದ ನೀವು ಪಪ್ಪಿಗಾಗಿ ಕರ್ನಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವಾಗ ಬಳಸಲಾಗುವ ಅದೇ ಮೂಲವನ್ನು ಹೊಂದಿರುತ್ತೀರಿ. ಇಲ್ಲದಿದ್ದರೆ, ನೀವು ಚಾಲಕವನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ "ಪರಿಹರಿಸದ ಚಿಹ್ನೆಗಳು" ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೀವು ಪಡೆಯುತ್ತೀರಿ ಮತ್ತು ನಂತರ ಅದನ್ನು ಪಪ್ಪಿ ಕರ್ನಲ್‌ನೊಂದಿಗೆ ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿ. ಸ್ಕ್ವ್ಯಾಷ್ ಫಿಕ್ಸ್ ಅನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತಿದೆ

ಎರಡನೆಯದಾಗಿ, Squashfs ಪ್ಯಾಚ್ ಅನ್ನು ಅನ್ವಯಿಸಿ. Squashfs ಪ್ಯಾಚ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಓದಲು-ಮಾತ್ರ ಮಾಡುವ Squashfs ಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಪ್ಯಾಚ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ, 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 ಅನ್ನು ಹೊಂದಿದೆ, ಚಿಹ್ನೆ l ಅಲ್ಲ... (ಗ್ರೇಟ್ ಜೋಕ್ - ಅಂದಾಜು ಅನುವಾದ)

ಸಿದ್ಧವಾಗಿದೆ! ಕರ್ನಲ್ ಕಂಪೈಲ್ ಮಾಡಲು ಸಿದ್ಧವಾಗಿದೆ!

ಕರ್ನಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ನೀವು ಕರ್ನಲ್ಗಾಗಿ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಪಡೆಯಬೇಕು. ಅದರ ನಕಲು /lib/modules ಫೋಲ್ಡರ್‌ನಲ್ಲಿದೆ.

ನಂತರ ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:

CD/ usr/ src/ linux-2.6.18.1

.config ಫೈಲ್ ಇದ್ದರೆ, ಅದನ್ನು ಎಲ್ಲೋ ತಾತ್ಕಾಲಿಕವಾಗಿ ನಕಲಿಸಿ ಅಥವಾ ಮರುಹೆಸರಿಸಿ.

ಪಪ್ಪಿಗಾಗಿ .config ಫೈಲ್ ಅನ್ನು /usr/src/linux-2.6.18.1 ಗೆ ನಕಲಿಸಿ... ಇದು /lib/modules ನಲ್ಲಿ ವಿಭಿನ್ನ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ .config ಗೆ ಮರುಹೆಸರಿಸಿ... ಕೆಳಗಿನ ಹಂತಗಳು .config ಫೈಲ್ ಅನ್ನು ಓದಿ ಮತ್ತು ಉತ್ಪಾದಿಸುತ್ತವೆ ಹೊಸದು.

...ನೀವು ಬಯಸುವ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿ ಮತ್ತು ಅವುಗಳನ್ನು ಉಳಿಸಿ. ನೀವು ಈಗ ಹೊಸ .config ಫೈಲ್ ಅನ್ನು ಹೊಂದಿರುವಿರಿ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರಿಸಲು ನೀವು ಅದನ್ನು ಎಲ್ಲೋ ನಕಲಿಸಬೇಕು. ಕೆಳಗಿನ ಟಿಪ್ಪಣಿಯನ್ನು ನೋಡಿ

ಈಗ ನೀವು ಕರ್ನಲ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದ್ದೀರಿ.

ಅದ್ಭುತವಾಗಿದೆ, ನೀವು ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ಅನ್ನು /usr/src/linux-2.6.18.1/arch/i386/boot/bzImage ನಲ್ಲಿ ಕಾಣಬಹುದು

ಕಂಪೈಲಿಂಗ್ ಮಾಡ್ಯೂಲ್

ಈಗ /lib/modules ಗೆ ಹೋಗಿ ಮತ್ತು ಈಗಾಗಲೇ 2.6.18.1 ಹೆಸರಿನ ಫೋಲ್ಡರ್ ಇದ್ದರೆ, 2.6.18.1 ಫೋಲ್ಡರ್ ಅನ್ನು 2.6.18.1-old ಎಂದು ಮರುಹೆಸರಿಸಿ.

ಈಗ ಹೊಸ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿ:

Cd/ usr/ src/ linux-2.6.18.1 ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಮಾಡಿ_ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ

...ಇದರ ನಂತರ ನೀವು /lib/modules/2.6.18.1 ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾದ ಹೊಸ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.

ಮೇಲಿನ ಕೊನೆಯ ಹಂತವು "depmod" ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇದು ಕೆಲವು ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಕಾಣೆಯಾದ ಚಿಹ್ನೆಗಳ ಬಗ್ಗೆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೀಡಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಅದರ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ - ಡೆವಲಪರ್‌ಗಳಲ್ಲಿ ಒಬ್ಬರು ಸ್ಕ್ರೂ ಅಪ್ ಮಾಡಿದ್ದಾರೆ ಮತ್ತು ನಾವು ಆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಎಂದರ್ಥ.

ಹೊಸ ಕರ್ನಲ್ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ನೀವು ಪಪ್ಪಿ ಅನ್ಲೀಶ್ಡ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದರೆ ಉತ್ತಮವಾಗಿದೆ. ನಂತರ ಟಾರ್ಬಾಲ್ ಅನ್ನು ವಿಸ್ತರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು 2 ಡೈರೆಕ್ಟರಿಗಳಿವೆ: "ಬೂಟ್" ಮತ್ತು "ಕರ್ನಲ್ಗಳು".

ಆರಂಭಿಕ ವರ್ಚುವಲ್ ಡಿಸ್ಕ್ ಅನ್ನು ರಚಿಸಲು "ಬೂಟ್" ಫೈಲ್ ರಚನೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ. ನೀವು ಅಲ್ಲಿ ಕೆಲವು ಕರ್ನಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹಾಕಬೇಕಾಗುತ್ತದೆ.

"ಕರ್ನಲ್‌ಗಳು" ಡೈರೆಕ್ಟರಿಯು ಡೈರೆಕ್ಟರಿ ಕರ್ನಲ್‌ಗಳನ್ನು ಹೊಂದಿದೆ/2.6.18.1/ , ಮತ್ತು ನೀವು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ನಿಮ್ಮ ನವೀಕರಿಸಿದವುಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ನೀವು ಅದೇ ಕರ್ನಲ್ ಆವೃತ್ತಿಯನ್ನು (2.6.18.1) ಮರುಸಂಕಲಿಸಿದರೆ ನೀವು ಅದನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗಿಲ್ಲ.

kernels/2.6.18.1 ರಲ್ಲಿ "System.map" ಎಂಬ ಫೈಲ್ ಇದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನೀವು ಅದನ್ನು ಮರುಹೆಸರಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು /usr/src/linux-2.6.18.1 ನಿಂದ ಹೊಸದರೊಂದಿಗೆ ಬದಲಾಯಿಸಬೇಕು. ಕರ್ನಲ್‌ಗಳು/2.6.18.1/ ಫೋಲ್ಡರ್ ಅನ್ನು ಬ್ರೌಸ್ ಮಾಡಿ ಮತ್ತು ಏನನ್ನು ನವೀಕರಿಸಬೇಕು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿರಬೇಕು.

ನೀವು ಪೂರ್ಣ ಪಪ್ಪಿ ಅನುಸ್ಥಾಪನೆಯಲ್ಲಿ ಕರ್ನಲ್ ಅನ್ನು ಸಂಕಲಿಸಿದರೆ, ನೀವು ಹೊಸ ಕರ್ನಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ರೀಬೂಟ್ ಮಾಡಬಹುದು. /lib/modules/2.6.18.1 ನಲ್ಲಿ ಹೊಸ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು modules_install ಮೇಲಿನ ಹಂತವಾಗಿದೆ, ಆದರೆ ನೀವು ಹೊಸ ಕರ್ನಲ್ ಅನ್ನು ಸಹ ಸ್ಥಾಪಿಸಬೇಕು. ನಾನು Grub ನೊಂದಿಗೆ ಬೂಟ್ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಹೊಸ ಕರ್ನಲ್ ಅನ್ನು /boot ಡೈರೆಕ್ಟರಿಗೆ ನಕಲಿಸುತ್ತೇನೆ (ಮತ್ತು ಫೈಲ್ ಅನ್ನು bzImage ನಿಂದ vmlinuz ಗೆ ಮರುಹೆಸರಿಸಿ).

ಮೆನುಕಾನ್ಫಿಗ್ ಬಗ್ಗೆ ಗಮನಿಸಿ. ನಾನು ಅದನ್ನು ಯುಗಗಳಿಂದ ಬಳಸುತ್ತಿದ್ದೇನೆ ಆದ್ದರಿಂದ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಲಘುವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಿ, ಆದರೆ ಹೊಸಬರು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ತೊರೆಯಲು ಬಯಸಿದಾಗ ಗೊಂದಲಕ್ಕೊಳಗಾಗಬಹುದು. ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಉಳಿಸಲು ಉನ್ನತ ಮಟ್ಟದ ಮೆನುವಿನಲ್ಲಿ ಮೆನು ಇದೆ - ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ. ಎಕ್ಸಿಟ್ "ಬಟನ್" ಅನ್ನು ಹೈಲೈಟ್ ಮಾಡಲು TAB ಕೀಯನ್ನು (ಅಥವಾ ಬಲ ಬಾಣದ ಕೀಲಿಯನ್ನು) ಒತ್ತಿ ಮತ್ತು ENTER ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. ನಂತರ ನೀವು ಹೊಸ ಸಂರಚನೆಯನ್ನು ಉಳಿಸಲು ಬಯಸುತ್ತೀರಾ ಎಂದು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಉತ್ತರ ಹೌದು ಎಂದಾಗಿರಬೇಕು.