ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಪರಿಚಯ
ಹೇ ಹಬ್ರ್! ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸಾಹಿತ್ಯದ ಲೇಖನಗಳು-ಅನುವಾದಗಳ ಸರಣಿಯನ್ನು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ತರಲು ನಾನು ಬಯಸುತ್ತೇನೆ - OSTEP. ಈ ವಸ್ತುವು ಯುನಿಕ್ಸ್ ತರಹದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಕೆಲಸವನ್ನು ಸಾಕಷ್ಟು ಆಳವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ, ಪ್ರಕ್ರಿಯೆಗಳು, ವಿವಿಧ ಶೆಡ್ಯೂಲರ್‌ಗಳು, ಮೆಮೊರಿ ಮತ್ತು ಆಧುನಿಕ OS ಅನ್ನು ರೂಪಿಸುವ ಇತರ ರೀತಿಯ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೂಲವನ್ನು ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು . ಅನುವಾದವನ್ನು ವೃತ್ತಿಪರವಲ್ಲದ (ಸಾಕಷ್ಟು ಮುಕ್ತವಾಗಿ) ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಆದರೆ ನಾನು ಸಾಮಾನ್ಯ ಅರ್ಥವನ್ನು ಉಳಿಸಿಕೊಂಡಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಈ ವಿಷಯದ ಕುರಿತು ಲ್ಯಾಬ್ ಕೆಲಸವನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು:
ಇತರ ಭಾಗಗಳು:
ನೀವು ನನ್ನ ಚಾನಲ್ ಅನ್ನು ಸಹ ಇಲ್ಲಿ ಪರಿಶೀಲಿಸಬಹುದು =)
ಎಚ್ಚರಿಕೆ! ಈ ಉಪನ್ಯಾಸಕ್ಕಾಗಿ ಲ್ಯಾಬ್ ಇದೆ! ನೋಡು
ಪ್ರಕ್ರಿಯೆ API
UNIX ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಇದು ಎರಡು ಸಿಸ್ಟಮ್ ಕರೆಗಳ ಮೂಲಕ ಸಂಭವಿಸುತ್ತದೆ ಫೋರ್ಕ್ () и ಕಾರ್ಯನಿರ್ವಾಹಕ ().
ಕಾಲ್ ಫೋರ್ಕ್()
ಫೋರ್ಕ್ () ಕರೆ ಮಾಡುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಅದರ ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ.
ಮೊದಲನೆಯದಾಗಿ, ನಾವು ಮುಖ್ಯ () ಕಾರ್ಯವನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸುತ್ತೇವೆ. ರೇಖೆಯು ಪ್ರಕ್ರಿಯೆ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿದೆ, ಅದನ್ನು ಮೂಲದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ ಪಿಐಡಿ ಅಥವಾ ಪ್ರಕ್ರಿಯೆ ಗುರುತಿಸುವಿಕೆ. ಪ್ರಕ್ರಿಯೆಯನ್ನು ಉಲ್ಲೇಖಿಸಲು UNIX ನಲ್ಲಿ ಈ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮುಂದಿನ ಆಜ್ಞೆಯು ಫೋರ್ಕ್ () ಎಂದು ಕರೆಯುತ್ತದೆ. ಈ ಹಂತದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯ ಬಹುತೇಕ ನಿಖರವಾದ ನಕಲನ್ನು ರಚಿಸಲಾಗಿದೆ. OS ಗಾಗಿ, ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಒಂದೇ ಪ್ರೋಗ್ರಾಂನ 2 ಪ್ರತಿಗಳು ಚಾಲನೆಯಲ್ಲಿರುವಂತೆ ತೋರುತ್ತಿದೆ, ಅದು ಫೋರ್ಕ್ () ಕಾರ್ಯದಿಂದ ನಿರ್ಗಮಿಸುತ್ತದೆ. ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಯನ್ನು (ಅದನ್ನು ರಚಿಸಿದ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ) ಇನ್ನು ಮುಂದೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ, ಇದು ಮುಖ್ಯ() ಕಾರ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯ ನಿಖರವಾದ ನಕಲು ಅಲ್ಲ ಎಂದು ನೆನಪಿನಲ್ಲಿಡಬೇಕು; ನಿರ್ದಿಷ್ಟವಾಗಿ, ಇದು ತನ್ನದೇ ಆದ ವಿಳಾಸ ಸ್ಥಳ, ತನ್ನದೇ ಆದ ರೆಜಿಸ್ಟರ್‌ಗಳು, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸೂಚನೆಗಳಿಗೆ ತನ್ನದೇ ಆದ ಪಾಯಿಂಟರ್ ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ಹೊಂದಿದೆ. ಹೀಗಾಗಿ, ಫೋರ್ಕ್ () ಕಾರ್ಯದ ಕರೆಗಾರನಿಗೆ ಹಿಂತಿರುಗಿದ ಮೌಲ್ಯವು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಯ PID ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಮಗುವು 0 ಗೆ ಸಮಾನವಾದ ಮೌಲ್ಯವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಈ ರಿಟರ್ನ್ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ನಂತರ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಕೆಲಸವನ್ನು ಮಾಡಲು ಒತ್ತಾಯಿಸಬಹುದು. . ಆದಾಗ್ಯೂ, ಈ ಕಾರ್ಯಕ್ರಮದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ. 2 ಪ್ರಕ್ರಿಯೆಗಳಾಗಿ ವಿಭಜಿಸಿದ ನಂತರ, ಓಎಸ್ ಅವುಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಜೊತೆಗೆ ಅವರ ಕೆಲಸವನ್ನು ಯೋಜಿಸುತ್ತದೆ. ಸಿಂಗಲ್-ಕೋರ್ ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಒಂದಾದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಪೋಷಕರು ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತಾರೆ ಮತ್ತು ನಂತರ ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ನಿಯಂತ್ರಣವನ್ನು ಪಡೆಯುತ್ತದೆ. ಮರುಪ್ರಾರಂಭಿಸುವಾಗ, ಪರಿಸ್ಥಿತಿಯು ವಿಭಿನ್ನವಾಗಿರಬಹುದು.
ಕರೆ ನಿರೀಕ್ಷಿಸಿ ()
ಕೆಳಗಿನ ಕಾರ್ಯಕ್ರಮವನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ, ಕರೆ ಇರುವ ಕಾರಣ ನಿರೀಕ್ಷಿಸಿ () ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಳ್ಳಲು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಯಾವಾಗಲೂ ಕಾಯುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಪರದೆಯ ಮೇಲೆ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪಠ್ಯ ಔಟ್ಪುಟ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ
exec() ಕರೆ
ಸವಾಲನ್ನು ಪರಿಗಣಿಸಿ ಕಾರ್ಯನಿರ್ವಾಹಕ (). ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಬಯಸಿದಾಗ ಈ ಸಿಸ್ಟಮ್ ಕರೆ ಉಪಯುಕ್ತವಾಗಿದೆ. ಇಲ್ಲಿ ನಾವು ಕರೆ ಮಾಡುತ್ತೇವೆ execvp() ಪದ ಎಣಿಕೆಯ ಪ್ರೋಗ್ರಾಂ ಆಗಿರುವ wc ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು. ಎಕ್ಸಿಕ್() ಅನ್ನು ಕರೆದಾಗ ಏನಾಗುತ್ತದೆ? ಈ ಕರೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್‌ನ ಹೆಸರು ಮತ್ತು ಕೆಲವು ನಿಯತಾಂಕಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ. ಅದರ ನಂತರ ಈ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್‌ನಿಂದ ಕೋಡ್ ಮತ್ತು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಕೋಡ್‌ನೊಂದಿಗೆ ಅದರ ಸ್ವಂತ ವಿಭಾಗವನ್ನು ತಿದ್ದಿ ಬರೆಯಲಾಗುತ್ತದೆ. ಸ್ಟಾಕ್ ಮತ್ತು ಹೀಪ್‌ನಂತಹ ಉಳಿದ ಮೆಮೊರಿ ಪ್ರದೇಶಗಳನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲಾಗಿದೆ. ಅದರ ನಂತರ OS ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸರಳವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಅದನ್ನು ವಾದಗಳ ಗುಂಪನ್ನು ರವಾನಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲಿಲ್ಲ, ನಾವು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮತ್ತೊಂದು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಆಗಿ ಪರಿವರ್ತಿಸಿದ್ದೇವೆ. ಡಿಸೆಂಡೆಂಟ್‌ನಲ್ಲಿ ಎಕ್ಸಿಕ್() ಕರೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ಮೂಲ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿಲ್ಲ ಎಂದು ತೋರುತ್ತಿದೆ.
ಈ ಆರಂಭಿಕ ತೊಡಕು ಯುನಿಕ್ಸ್ ಶೆಲ್‌ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಸಾಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ಕರೆ ಮಾಡಿದ ನಂತರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆ ಶೆಲ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಫೋರ್ಕ್ (), ಆದರೆ ಕರೆ ಮೊದಲು ಕಾರ್ಯನಿರ್ವಾಹಕ (). ಅಂತಹ ಕೋಡ್‌ನ ಉದಾಹರಣೆಯೆಂದರೆ ಶೆಲ್ ಪರಿಸರವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಪ್ರಾರಂಭಿಸುವ ಕಾರ್ಯಕ್ರಮದ ಅಗತ್ಯಗಳಿಗೆ ಹೊಂದಿಸುವುದು.
ಶೆಲ್ - ಕೇವಲ ಬಳಕೆದಾರ ಪ್ರೋಗ್ರಾಂ. ಅವಳು ನಿಮಗೆ ಆಮಂತ್ರಣ ರೇಖೆಯನ್ನು ತೋರಿಸುತ್ತಾಳೆ ಮತ್ತು ಅದರಲ್ಲಿ ಏನನ್ನಾದರೂ ಬರೆಯಲು ಕಾಯುತ್ತಾಳೆ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಪ್ರೋಗ್ರಾಂನ ಹೆಸರನ್ನು ಅಲ್ಲಿ ಬರೆದರೆ, ಶೆಲ್ ಅದರ ಸ್ಥಳವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ, ಫೋರ್ಕ್ () ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ, ತದನಂತರ ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಕೆಲವು ರೀತಿಯ ಎಕ್ಸಿಕ್ () ಅನ್ನು ಕರೆ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಕಾಯಿರಿ ನಿರೀಕ್ಷಿಸಿ () ಕರೆ. ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯು ನಿರ್ಗಮಿಸಿದಾಗ, ಶೆಲ್ ವೇಯ್ಟ್() ಕರೆಯಿಂದ ಹಿಂತಿರುಗುತ್ತದೆ ಮತ್ತು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಮತ್ತೆ ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಲು ನಿರೀಕ್ಷಿಸಿ.
ಫೋರ್ಕ್() & ಎಕ್ಸಿಕ್() ವಿಭಜನೆಯು ಶೆಲ್ ಅನ್ನು ಈ ಕೆಳಗಿನ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ:
wc ಫೈಲ್ > new_file.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, wc ಪ್ರೊಗ್ರಾಮ್‌ನ ಔಟ್ಪುಟ್ ಅನ್ನು ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ. ಶೆಲ್ ಇದನ್ನು ಸಾಧಿಸುವ ವಿಧಾನವು ತುಂಬಾ ಸರಳವಾಗಿದೆ - ಕರೆ ಮಾಡುವ ಮೊದಲು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಾಹಕ (), ಶೆಲ್ ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್ ಅನ್ನು ಮುಚ್ಚುತ್ತದೆ ಮತ್ತು ಫೈಲ್ ಅನ್ನು ತೆರೆಯುತ್ತದೆ ಹೊಸ_ಫೈಲ್, ಹೀಗಾಗಿ, ಮತ್ತಷ್ಟು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನಿಂದ ಎಲ್ಲಾ ಔಟ್ಪುಟ್ wc ಪರದೆಯ ಬದಲಿಗೆ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ.
ಯುನಿಕ್ಸ್ ಪೈಪ್ ಪೈಪ್ () ಕರೆಯನ್ನು ಬಳಸುವ ವ್ಯತ್ಯಾಸದೊಂದಿಗೆ ಇದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯ ಔಟ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಕರ್ನಲ್‌ನಲ್ಲಿರುವ ಪೈಪ್ ಕ್ಯೂಗೆ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತದೆ, ಅದಕ್ಕೆ ಮತ್ತೊಂದು ಪ್ರಕ್ರಿಯೆಯ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತದೆ.
ಮೂಲ: www.habr.com