ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್

ಒಮ್ಮೆ, ಸಂದರ್ಶನವೊಂದರಲ್ಲಿ, ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶದ ಕೊರತೆಯಿಂದಾಗಿ ಸೇವೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸದಿರುವುದನ್ನು ನೀವು ಕಂಡುಕೊಂಡರೆ ನೀವು ಏನು ಮಾಡುತ್ತೀರಿ ಎಂದು ನನ್ನನ್ನು ಕೇಳಲಾಯಿತು?

ಖಂಡಿತ, ನಾನು ಈ ಸ್ಥಳವನ್ನು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವುದನ್ನು ನಾನು ನೋಡುತ್ತೇನೆ ಮತ್ತು ಸಾಧ್ಯವಾದರೆ, ನಾನು ಸ್ಥಳವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುತ್ತೇನೆ ಎಂದು ಉತ್ತರಿಸಿದೆ.
ನಂತರ ಸಂದರ್ಶಕರು ಕೇಳಿದರು, ವಿಭಜನೆಯಲ್ಲಿ ಯಾವುದೇ ಮುಕ್ತ ಸ್ಥಳವಿಲ್ಲದಿದ್ದರೆ ಏನು, ಆದರೆ ನೀವು ಎಲ್ಲಾ ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಯಾವುದೇ ಫೈಲ್‌ಗಳನ್ನು ಸಹ ನೋಡುವುದಿಲ್ಲವೇ?

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

ಸಂದರ್ಶಕರು ಕೊನೆಯ ಪದದಲ್ಲಿ ನನಗೆ ಅಡ್ಡಿಪಡಿಸಿದರು, ಅವರ ಪ್ರಶ್ನೆಗೆ ಸೇರಿಸಿದರು: "ನಮಗೆ ಡೇಟಾ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ಭಾವಿಸೋಣ, ಇದು ಕೇವಲ ಡೀಬಗ್ ಲಾಗ್ ಆಗಿದೆ, ಆದರೆ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ಡೀಬಗ್ ಅನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ"?

"ಸರಿ," ನಾನು ಉತ್ತರಿಸಿದೆ, "ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಸಂರಚನೆಯಲ್ಲಿ ಡೀಬಗ್ ಅನ್ನು ಆಫ್ ಮಾಡಬಹುದು ಮತ್ತು ಅದನ್ನು ಮರುಪ್ರಾರಂಭಿಸಬಹುದು."
ಸಂದರ್ಶಕರು ಆಕ್ಷೇಪಿಸಿದ್ದಾರೆ: "ಇಲ್ಲ, ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ನಾವು ಇನ್ನೂ ಪ್ರಮುಖ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರಮುಖ ಗ್ರಾಹಕರು ಸೇವೆಗೆ ಸಂಪರ್ಕಗೊಂಡಿದ್ದಾರೆ, ಅದನ್ನು ನಾವು ಮತ್ತೆ ಮರುಸಂಪರ್ಕಿಸಲು ಒತ್ತಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ."

“ಸರಿ,” ನಾನು ಹೇಳಿದೆ, “ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಮತ್ತು ಡೇಟಾ ನಮಗೆ ಮುಖ್ಯವಲ್ಲದಿದ್ದರೆ, ನಾವು ಈ ತೆರೆದ ಫೈಲ್ ಅನ್ನು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಮೂಲಕ ಸರಳವಾಗಿ ತೆರವುಗೊಳಿಸಬಹುದು, ನಾವು ಅದನ್ನು ls ಆಜ್ಞೆಯಲ್ಲಿ ನೋಡದಿದ್ದರೂ ಸಹ ಕಡತ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ.”

ಸಂದರ್ಶಕನಿಗೆ ಸಂತೋಷವಾಯಿತು, ಆದರೆ ನಾನು ಅಲ್ಲ.

ಆಗ ನಾನು ಯೋಚಿಸಿದೆ, ನನ್ನ ಜ್ಞಾನವನ್ನು ಪರೀಕ್ಷಿಸುವ ವ್ಯಕ್ತಿಯು ಏಕೆ ಆಳವಾಗಿ ಅಗೆಯುವುದಿಲ್ಲ? ಆದರೆ ಎಲ್ಲಾ ನಂತರ ಡೇಟಾ ಮುಖ್ಯವಾಗಿದ್ದರೆ ಏನು? ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯು ಯಾವುದೇ ಮುಕ್ತ ಸ್ಥಳಾವಕಾಶವಿಲ್ಲದ ವಿಭಾಗದಲ್ಲಿ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ ಬರೆಯುತ್ತದೆ? ನಾವು ಈಗಾಗಲೇ ಬರೆಯಲಾದ ಡೇಟಾವನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಈ ಪ್ರಕ್ರಿಯೆಯು ಬರೆಯುವ ಅಥವಾ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುವ ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಏನು ಮಾಡಬೇಕು?

ತುಝಿಕ್

ನನ್ನ ವೃತ್ತಿಜೀವನದ ಆರಂಭದಲ್ಲಿ, ಬಳಕೆದಾರರ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸಣ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲು ನಾನು ಪ್ರಯತ್ನಿಸಿದೆ. ತದನಂತರ ನಾನು ಯೋಚಿಸಿದೆ, ನಾನು ಬಳಕೆದಾರರನ್ನು ಅವನ ಡೇಟಾಗೆ ಹೇಗೆ ಹೊಂದಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಾನು ಇವನೊವ್ ಇವಾನ್ ಇವನೊವಿಚ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ ಮತ್ತು ಅವನಿಗೆ ಕೆಲವು ಮಾಹಿತಿ ಇದೆ, ಆದರೆ ನಾನು ಅವರೊಂದಿಗೆ ಹೇಗೆ ಸ್ನೇಹಿತರಾಗಬಹುದು? "ತುಝಿಕ್" ಎಂಬ ನಾಯಿಯು ಈ ಇವಾನ್ಗೆ ಸೇರಿದೆ ಎಂದು ನಾನು ನೇರವಾಗಿ ಸೂಚಿಸಬಹುದು. ಆದರೆ ಅವನು ತನ್ನ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಿದರೆ ಮತ್ತು ಇವಾನ್ ಬದಲಿಗೆ ಓಲಿಯಾ ಆಗಿದ್ದರೆ ಏನು? ನಂತರ ನಮ್ಮ ಒಲ್ಯಾ ಇವನೊವ್ನಾ ಇವನೊವಾ ಇನ್ನು ಮುಂದೆ ನಾಯಿಯನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಮತ್ತು ನಮ್ಮ ತುಜಿಕ್ ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಇವಾನ್‌ಗೆ ಸೇರಿದ್ದಾನೆ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ. ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯನ್ನು (ID) ನೀಡಿದ ಡೇಟಾಬೇಸ್ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡಿತು ಮತ್ತು ನನ್ನ Tuzik ಅನ್ನು ಈ ID ಗೆ ಜೋಡಿಸಲಾಗಿದೆ, ಇದು ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಒಂದು ಸರಣಿ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಹೀಗಾಗಿ, ಏಸ್ನ ಮಾಲೀಕರು ID ಸಂಖ್ಯೆ 2 ಅನ್ನು ಹೊಂದಿದ್ದರು, ಮತ್ತು ಕೆಲವು ಸಮಯದಲ್ಲಿ ಇವಾನ್ ಈ ID ಅಡಿಯಲ್ಲಿದ್ದರು, ಮತ್ತು ನಂತರ Olya ಅದೇ ID ಅಡಿಯಲ್ಲಿ ಆಯಿತು. ಮಾನವೀಯತೆ ಮತ್ತು ಪಶುಸಂಗೋಪನೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಪರಿಹರಿಸಲಾಗಿದೆ.

ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್

ಈ ಫೈಲ್‌ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಫೈಲ್ ಮತ್ತು ಪ್ರೋಗ್ರಾಂನ ಸಮಸ್ಯೆ ನಮ್ಮ ನಾಯಿ ಮತ್ತು ಮನುಷ್ಯನಂತೆಯೇ ಇರುತ್ತದೆ. ನಾನು ivan.txt ಎಂಬ ಫೈಲ್ ಅನ್ನು ತೆರೆದಿದ್ದೇನೆ ಮತ್ತು ಅದರಲ್ಲಿ tuzik ಎಂಬ ಪದವನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಿದೆ ಎಂದು ಭಾವಿಸೋಣ, ಆದರೆ ಫೈಲ್‌ನಲ್ಲಿ ಮೊದಲ ಅಕ್ಷರ "t" ಅನ್ನು ಮಾತ್ರ ಬರೆಯಲು ಸಾಧ್ಯವಾಯಿತು ಮತ್ತು ಈ ಫೈಲ್ ಅನ್ನು ಯಾರೋ ಮರುಹೆಸರಿಸಿದ್ದಾರೆ, ಉದಾಹರಣೆಗೆ, olya.txt ಗೆ. ಆದರೆ ಫೈಲ್ ಒಂದೇ ಆಗಿರುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿ ನನ್ನ ಏಸ್ ಅನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಲು ನಾನು ಇನ್ನೂ ಬಯಸುತ್ತೇನೆ. ಪ್ರತಿ ಬಾರಿ ಸಿಸ್ಟಮ್ ಕರೆ ಮೂಲಕ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲಾಗುತ್ತದೆ ತೆರೆದ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ನಾನು ಫೈಲ್‌ಗೆ ನನ್ನನ್ನು ಸೂಚಿಸುವ ಅನನ್ಯ ID ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇನೆ, ಈ ID ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಆಗಿದೆ. ಮತ್ತು ಈ ಫೈಲ್‌ನೊಂದಿಗೆ ಮುಂದೆ ಏನು ಮತ್ತು ಯಾರು ಮಾಡುತ್ತಾರೆ ಎಂಬುದು ಮುಖ್ಯವಲ್ಲ, ಅದನ್ನು ಅಳಿಸಬಹುದು, ಅದನ್ನು ಮರುಹೆಸರಿಸಬಹುದು, ಮಾಲೀಕರನ್ನು ಬದಲಾಯಿಸಬಹುದು ಅಥವಾ ಓದುವ ಮತ್ತು ಬರೆಯುವ ಹಕ್ಕುಗಳನ್ನು ಕಸಿದುಕೊಳ್ಳಬಹುದು, ನಾನು ಇನ್ನೂ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತೇನೆ ಅದಕ್ಕೆ, ಏಕೆಂದರೆ ಫೈಲ್ ಅನ್ನು ತೆರೆಯುವ ಸಮಯದಲ್ಲಿ, ಅದನ್ನು ಓದಲು ಮತ್ತು / ಅಥವಾ ಬರೆಯಲು ನಾನು ಹಕ್ಕುಗಳನ್ನು ಹೊಂದಿದ್ದೇನೆ ಮತ್ತು ನಾನು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿದೆ, ಅಂದರೆ ನಾನು ಅದನ್ನು ಮುಂದುವರಿಸಬೇಕು.

Linux ನಲ್ಲಿ, libc ಲೈಬ್ರರಿಯು ಪ್ರತಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ (ಪ್ರಕ್ರಿಯೆ) 3 ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಫೈಲ್‌ಗಳನ್ನು ತೆರೆಯುತ್ತದೆ, ಸಂಖ್ಯೆ 0,1,2. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಲಿಂಕ್‌ಗಳಲ್ಲಿ ಕಾಣಬಹುದು ಮನುಷ್ಯ stdio и ಮನುಷ್ಯ stdout

• ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 0 ಅನ್ನು STDIN ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ
• ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 1 ಅನ್ನು STDOUT ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರಿಂಟ್ ಕಮಾಂಡ್‌ಗಳಂತಹ ಡೇಟಾವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಬಳಸುತ್ತವೆ
• ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 2 ಅನ್ನು STDERR ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ದೋಷ ಸಂದೇಶಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಬಳಸುತ್ತವೆ.

ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನೀವು ಓದಲು ಅಥವಾ ಬರೆಯಲು ಯಾವುದೇ ಫೈಲ್ ಅನ್ನು ತೆರೆದರೆ, ಹೆಚ್ಚಾಗಿ ನೀವು ಮೊದಲ ಉಚಿತ ID ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ ಮತ್ತು ಅದು ಸಂಖ್ಯೆ 3 ಆಗಿರುತ್ತದೆ.

ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ಅದರ PID ತಿಳಿದಿದ್ದರೆ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ವೀಕ್ಷಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ನಾವು ಬ್ಯಾಷ್ ಕನ್ಸೋಲ್ ಅನ್ನು ತೆರೆಯೋಣ ಮತ್ತು ನಮ್ಮ ಪ್ರಕ್ರಿಯೆಯ PID ಅನ್ನು ನೋಡೋಣ

[user@localhost ]$ echo $$
15771

ಎರಡನೇ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ರನ್ ಮಾಡೋಣ

[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

ಈ ಲೇಖನದ ಉದ್ದೇಶಗಳಿಗಾಗಿ ನೀವು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಸಂಖ್ಯೆ 255 ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಬಹುದು; ಅದರ ಅಗತ್ಯಗಳಿಗಾಗಿ ಅದನ್ನು ಬ್ಯಾಷ್ ಮೂಲಕ ತೆರೆಯಲಾಗಿದೆ ಮತ್ತು ಲಿಂಕ್ ಮಾಡಿದ ಲೈಬ್ರರಿಯಿಂದ ಅಲ್ಲ.

ಈಗ ಎಲ್ಲಾ 3 ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಫೈಲ್‌ಗಳು ಹುಸಿ ಟರ್ಮಿನಲ್ ಸಾಧನದೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿವೆ /dev/pts, ಆದರೆ ನಾವು ಅವುಗಳನ್ನು ಇನ್ನೂ ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಅವುಗಳನ್ನು ಎರಡನೇ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಿ

[user@localhost ]$ echo "hello world" > /proc/15771/fd/0

ಮತ್ತು ಮೊದಲ ಕನ್ಸೋಲ್ನಲ್ಲಿ ನಾವು ನೋಡುತ್ತೇವೆ

[user@localhost ]$ hello world

ಮರುನಿರ್ದೇಶನ ಮತ್ತು ಪೈಪ್

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

[user@localhost ]$ cat /dev/zero | sleep 10000

ಈ ಆಜ್ಞೆಯನ್ನು ನೀವೇ ಚಲಾಯಿಸಬಹುದು ಸ್ಟ್ರೇಸ್ -ಎಫ್ ಮತ್ತು ಒಳಗೆ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಿ, ಆದರೆ ನಾನು ನಿಮಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುತ್ತೇನೆ.

PID 15771 ನೊಂದಿಗೆ ನಮ್ಮ ಪೋಷಕ ಬ್ಯಾಷ್ ಪ್ರಕ್ರಿಯೆಯು ನಮ್ಮ ಆಜ್ಞೆಯನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾವು ಎಷ್ಟು ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಅವುಗಳಲ್ಲಿ ಎರಡು ಇವೆ: ಬೆಕ್ಕು ಮತ್ತು ನಿದ್ರೆ. ಎರಡು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಪೈಪ್ ಆಗಿ ವಿಲೀನಗೊಳಿಸಬೇಕು ಎಂದು ಬ್ಯಾಷ್ ತಿಳಿದಿದೆ. ಒಟ್ಟಾರೆಯಾಗಿ, ಬ್ಯಾಷ್‌ಗೆ 2 ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳು ಮತ್ತು ಒಂದು ಪೈಪ್ ಅಗತ್ಯವಿದೆ.

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

ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗಾಗಿ, ಈಗಾಗಲೇ ಪೈಪ್ ಇರುವಂತೆ ತೋರುತ್ತಿದೆ, ಆದರೆ ಇನ್ನೂ ಯಾವುದೇ ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳಿಲ್ಲ:

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

ನಂತರ ಸಿಸ್ಟಮ್ ಕರೆ ಬಳಸಿ ಕ್ಲೋನ್ ಬ್ಯಾಷ್ ಎರಡು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನಮ್ಮ ಮೂರು ಪ್ರಕ್ರಿಯೆಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
PID    command
9004  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21
PID    command
9005  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21

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

ಆದ್ದರಿಂದ, ಇದಕ್ಕೆ ಪೈಪ್ ಅಗತ್ಯವಿಲ್ಲ, ಮತ್ತು ಇದು 3 ಮತ್ತು 4 ಸಂಖ್ಯೆಯ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಮುಚ್ಚುತ್ತದೆ.

PID 9004 ನೊಂದಿಗೆ ಮೊದಲ ಚೈಲ್ಡ್ ಬ್ಯಾಷ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಕರೆ dup2, ನಮ್ಮ STDOUT ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಸಂಖ್ಯೆ 1 ಅನ್ನು ಪೈಪ್‌ಗೆ ಸೂಚಿಸುವ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಸಂಖ್ಯೆ 3. ಹೀಗಾಗಿ, PID 9004 ನೊಂದಿಗೆ ಮೊದಲ ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು STDOUT ಗೆ ಬರೆಯುವ ಎಲ್ಲವೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪೈಪ್ ಬಫರ್‌ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

PID 9005 ನೊಂದಿಗೆ ಎರಡನೇ ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ STDIN ಸಂಖ್ಯೆ 2 ಅನ್ನು ಬದಲಾಯಿಸಲು bash dup0 ಅನ್ನು ಬಳಸುತ್ತದೆ. ಈಗ PID 9005 ನೊಂದಿಗೆ ನಮ್ಮ ಎರಡನೇ ಬ್ಯಾಷ್ ಓದುವ ಎಲ್ಲವನ್ನೂ ಪೈಪ್‌ನಿಂದ ಓದಲಾಗುತ್ತದೆ.

ಇದರ ನಂತರ, 3 ಮತ್ತು 4 ಸಂಖ್ಯೆಯ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಮುಚ್ಚಲಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಅವುಗಳನ್ನು ಇನ್ನು ಮುಂದೆ ಬಳಸಲಾಗುವುದಿಲ್ಲ.

ನಾನು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 255 ಅನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ನಿರ್ಲಕ್ಷಿಸುತ್ತೇನೆ; ಇದನ್ನು ಬ್ಯಾಷ್ ಮೂಲಕ ಆಂತರಿಕ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಮುಚ್ಚಲಾಗುತ್ತದೆ.

ಮುಂದೆ, PID 9004 ನೊಂದಿಗೆ ಮೊದಲ ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಬ್ಯಾಷ್ ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ exec ನಾವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಅದು /usr/bin/cat ಆಗಿದೆ.

PID 9005 ನೊಂದಿಗೆ ಎರಡನೇ ಚೈಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ /usr/bin/sleep ನಲ್ಲಿ ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎರಡನೇ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು bash ರನ್ ಮಾಡುತ್ತದೆ.

ತೆರೆದ ಕರೆ ಮಾಡಿದ ಸಮಯದಲ್ಲಿ O_CLOEXEC ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ತೆರೆಯದ ಹೊರತು ಎಕ್ಸಿಕ್ ಸಿಸ್ಟಮ್ ಕರೆ ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳನ್ನು ಮುಚ್ಚುವುದಿಲ್ಲ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ಎಲ್ಲಾ ಪ್ರಸ್ತುತ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ಗಳನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ.

ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪರಿಶೀಲಿಸಿ:

[user@localhost ]$ pgrep -P 15771
9004
9005
[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
[user@localhost ]$ ls -lah /proc/9004/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
l-wx------ 1 user user 64 Oct  7 15:57 1 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lr-x------ 1 user user 64 Oct  7 15:57 3 -> /dev/zero
[user@localhost ]$ ls -lah /proc/9005/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lr-x------ 1 user user 64 Oct  7 15:57 0 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
[user@localhost ]$ ps -up 9004
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9004  0.0  0.0 107972   620 pts/21   S+   15:57   0:00 cat /dev/zero
[user@localhost ]$ ps -up 9005
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9005  0.0  0.0 107952   360 pts/21   S+   15:57   0:00 sleep 10000

ನೀವು ನೋಡುವಂತೆ, ನಮ್ಮ ಪೈಪ್ನ ಅನನ್ಯ ಸಂಖ್ಯೆ ಎರಡೂ ಪ್ರಕ್ರಿಯೆಗಳಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ ನಾವು ಒಂದೇ ಪೋಷಕರೊಂದಿಗೆ ಎರಡು ವಿಭಿನ್ನ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಸಂಪರ್ಕವನ್ನು ಹೊಂದಿದ್ದೇವೆ.

ಬ್ಯಾಷ್ ಬಳಸುವ ಸಿಸ್ಟಂ ಕರೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿಲ್ಲದವರಿಗೆ, ಸ್ಟ್ರೇಸ್ ಮೂಲಕ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಮತ್ತು ಆಂತರಿಕವಾಗಿ ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ನಾನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಉದಾಹರಣೆಗೆ ಈ ರೀತಿ:

strace -s 1024 -f bash -c "ls | grep hello"

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

[user@localhost ]$ cat openforwrite.py 
import datetime
import time

mystr="a"*1024*1024+"n"
with open("123.txt", "w") as f:
    while True:
        try:
            f.write(str(datetime.datetime.now()))
            f.write(mystr)
            f.flush()
            time.sleep(1)
        except:
            pass

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡೋಣ ಮತ್ತು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ಗಳನ್ನು ನೋಡೋಣ

[user@localhost ]$ python openforwrite.py &
[1] 3762
[user@localhost ]$ ps axuf | grep [o]penforwrite
user  3762  0.0  0.0 128600  5744 pts/22   S+   16:28   0:00  |   _ python openforwrite.py
[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt

ನೀವು ನೋಡುವಂತೆ, ನಾವು ನಮ್ಮ 3 ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ನಾವು ತೆರೆದಿರುವ ಇನ್ನೊಂದನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಫೈಲ್ ಗಾತ್ರವನ್ನು ಪರಿಶೀಲಿಸೋಣ:

[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 117M Oct  7 16:30 123.txt

ಡೇಟಾವನ್ನು ಬರೆಯಲಾಗುತ್ತಿದೆ, ನಾವು ಫೈಲ್‌ನಲ್ಲಿ ಅನುಮತಿಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ:

[user@localhost ]$ sudo chown root: 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 168M Oct  7 16:31 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 172M Oct  7 16:31 123.txt

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

[user@localhost ]$ sudo rm 123.txt 
[user@localhost ]$ ls 123.txt
ls: cannot access 123.txt: No such file or directory

ಡೇಟಾವನ್ನು ಎಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ? ಮತ್ತು ಅವುಗಳನ್ನು ಬರೆಯಲಾಗಿದೆಯೇ? ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:

[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt (deleted)

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

ಫೈಲ್ ಗಾತ್ರವನ್ನು ನೋಡೋಣ:

[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5   19923457   2621522 /home/user/123.txt

ಫೈಲ್ ಗಾತ್ರ 19923457. ಫೈಲ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:

[user@localhost ]$ truncate -s 0 /proc/31083/fd/3
[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5  136318390   2621522 /home/user/123.txt

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

with open("123.txt", "w") as f:

ನಾವು ಹಾಕಬೇಕು

with open("123.txt", "a") as f:

"w" ಧ್ವಜದೊಂದಿಗೆ ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3

ಮತ್ತು "ಎ" ಧ್ವಜದೊಂದಿಗೆ

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_APPEND, 0666) = 3

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆ

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

ಫೈಲ್ ಅನ್ನು ಬರೆಯಲು ಸಾಕಷ್ಟು ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶವಿಲ್ಲ ಎಂಬ ಮೂಲ ಪ್ರಶ್ನೆಗೆ ಹಿಂತಿರುಗಿ, ಸಮಸ್ಯೆಯನ್ನು ಅನುಕರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

ನಮ್ಮ ವಿಭಾಗಕ್ಕಾಗಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ, ಅದನ್ನು ನಾವು ಪ್ರತ್ಯೇಕ ಡಿಸ್ಕ್ ಆಗಿ ಆರೋಹಿಸುತ್ತೇವೆ:

[user@localhost ~]$ dd if=/dev/zero of=~/tempfile_for_article.dd bs=1M count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00525929 s, 2.0 GB/s
[user@localhost ~]$

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ರಚಿಸೋಣ:

[user@localhost ~]$ mkfs.ext4 ~/tempfile_for_article.dd
mke2fs 1.42.9 (28-Dec-2013)
/home/user/tempfile_for_article.dd is not a block special device.
Proceed anyway? (y,n) y
...
Writing superblocks and filesystem accounting information: done
[user@localhost ~]$

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಆರೋಹಿಸಿ:

[user@localhost ~]$ sudo mount ~/tempfile_for_article.dd /mnt/
[sudo] password for user: 
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  172K  7.9M   3% /mnt

ನಮ್ಮ ಮಾಲೀಕರೊಂದಿಗೆ ನಾವು ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ:

[user@localhost ~]$ sudo mkdir /mnt/logs
[user@localhost ~]$ sudo chown user: /mnt/logs

ನಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಮಾತ್ರ ಬರೆಯಲು ಫೈಲ್ ಅನ್ನು ತೆರೆಯೋಣ:

with open("/mnt/logs/123.txt", "w") as f:

ಆರಂಭ

[user@localhost ]$ python openforwrite.py 

ನಾವು ಕೆಲವು ಸೆಕೆಂಡುಗಳ ಕಾಲ ಕಾಯುತ್ತೇವೆ

[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

ಆದ್ದರಿಂದ, ಈ ಲೇಖನದ ಆರಂಭದಲ್ಲಿ ವಿವರಿಸಿದ ಸಮಸ್ಯೆಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಉಚಿತ ಸ್ಥಳ 0, 100% ಆಕ್ರಮಿಸಿಕೊಂಡಿದೆ.

ಕಾರ್ಯದ ಪರಿಸ್ಥಿತಿಗಳ ಪ್ರಕಾರ, ಕಳೆದುಹೋಗಲಾಗದ ಪ್ರಮುಖ ಡೇಟಾವನ್ನು ನಾವು ದಾಖಲಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೇವೆ. ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸದೆಯೇ ನಾವು ಸೇವೆಯನ್ನು ಸರಿಪಡಿಸಬೇಕಾಗಿದೆ.

ನಾವು ಇನ್ನೂ ಡಿಸ್ಕ್ ಜಾಗವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ, ಆದರೆ ಬೇರೆ ವಿಭಾಗದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ /ಮನೆಯಲ್ಲಿ.

ನಮ್ಮ ಕೋಡ್ ಅನ್ನು "ಫ್ಲೈನಲ್ಲಿ ರಿಪ್ರೋಗ್ರಾಮ್" ಮಾಡಲು ಪ್ರಯತ್ನಿಸೋಣ.

ನಮ್ಮ ಪ್ರಕ್ರಿಯೆಯ PID ಅನ್ನು ನೋಡೋಣ, ಅದು ಎಲ್ಲಾ ಡಿಸ್ಕ್ ಜಾಗವನ್ನು ತಿನ್ನುತ್ತದೆ:

[user@localhost ~]$ ps axuf | grep [o]penfor
user 10078 27.2  0.0 128600  5744 pts/22   R+   11:06   0:02  |   _ python openforwrite.py

ಜಿಡಿಬಿ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಪರ್ಕಪಡಿಸಿ

[user@localhost ~]$ gdb -p 10078
...
(gdb) 

ತೆರೆದ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ನೋಡೋಣ:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt

ನಮಗೆ ಆಸಕ್ತಿಯಿರುವ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಸಂಖ್ಯೆ 3 ರ ಮಾಹಿತಿಯನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ

(gdb) shell cat /proc/10078/fdinfo/3
pos:    8189952
flags:  0100001
mnt_id: 482

ಪೈಥಾನ್ ಯಾವ ಸಿಸ್ಟಂ ಕರೆ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಂಡು (ನಾವು ಸ್ಟ್ರೇಸ್ ಅನ್ನು ಎಲ್ಲಿ ಓಡಿದ್ದೇವೆ ಮತ್ತು ತೆರೆದ ಕರೆಯನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಮೇಲೆ ನೋಡಿ), ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ, ನಮ್ಮ ಪ್ರಕ್ರಿಯೆಯ ಪರವಾಗಿ ನಾವು ಅದೇ ರೀತಿ ಮಾಡುತ್ತೇವೆ, ಆದರೆ ನಮಗೆ O_WRONLY|O_CREAT| O_TRUNC ಬಿಟ್‌ಗಳನ್ನು ಸಂಖ್ಯಾ ಮೌಲ್ಯದೊಂದಿಗೆ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಕರ್ನಲ್ ಮೂಲಗಳನ್ನು ತೆರೆಯಿರಿ, ಉದಾಹರಣೆಗೆ ಇಲ್ಲಿ ಮತ್ತು ಯಾವ ಧ್ವಜಗಳು ಯಾವುದಕ್ಕೆ ಕಾರಣವಾಗಿವೆ ಎಂಬುದನ್ನು ನೋಡಿ

#ಓ_ತಪ್ಪಾಗಿ 00000001 ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
#O_CREAT 00000100 ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ
#O_TRUNC 00001000 ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

ನಾವು ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಒಂದಾಗಿ ಸಂಯೋಜಿಸುತ್ತೇವೆ, ನಾವು 00001101 ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ

ನಾವು gdb ನಿಂದ ನಮ್ಮ ಕರೆಯನ್ನು ನಡೆಸುತ್ತೇವೆ

(gdb) call open("/home/user/123.txt", 00001101,0666)
$1 = 4

ಆದ್ದರಿಂದ ನಾವು ಸಂಖ್ಯೆ 4 ನೊಂದಿಗೆ ಹೊಸ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ ಮತ್ತು ಇನ್ನೊಂದು ವಿಭಾಗದಲ್ಲಿ ಹೊಸ ತೆರೆದ ಫೈಲ್ ಅನ್ನು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

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

ನಾವು ಒಂದು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ

(gdb) call dup2(4,3)
$2 = 3

ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /home/user/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

ನಾವು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 4 ಅನ್ನು ಮುಚ್ಚುತ್ತೇವೆ, ಏಕೆಂದರೆ ನಮಗೆ ಇದು ಅಗತ್ಯವಿಲ್ಲ:

(gdb) call close (4)
$1 = 0

ಮತ್ತು ಜಿಡಿಬಿಯಿಂದ ನಿರ್ಗಮಿಸಿ

(gdb) quit
A debugging session is active.

    Inferior 1 [process 10078] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 10078

ಹೊಸ ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ:

[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 5.1M Oct  8 11:18 /home/user/123.txt
[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 7.1M Oct  8 11:18 /home/user/123.txt

ನೀವು ನೋಡುವಂತೆ, ಡೇಟಾವನ್ನು ಹೊಸ ಫೈಲ್‌ಗೆ ಬರೆಯಲಾಗಿದೆ, ಹಳೆಯದನ್ನು ಪರಿಶೀಲಿಸೋಣ:

[user@localhost ~]$ ls -lah /mnt/logs/123.txt 
-rw-rw-r-- 1 user user 7.9M Oct  8 11:08 /mnt/logs/123.txt

ಯಾವುದೇ ಡೇಟಾ ಕಳೆದುಹೋಗಿಲ್ಲ, ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಲಾಗ್‌ಗಳನ್ನು ಹೊಸ ಸ್ಥಳಕ್ಕೆ ಬರೆಯಲಾಗುತ್ತದೆ.

ಕಾರ್ಯವನ್ನು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣಗೊಳಿಸೋಣ

ಡೇಟಾವು ನಮಗೆ ಮುಖ್ಯವಾಗಿದೆ ಎಂದು ಊಹಿಸೋಣ, ಆದರೆ ನಾವು ಯಾವುದೇ ವಿಭಾಗಗಳಲ್ಲಿ ಡಿಸ್ಕ್ ಜಾಗವನ್ನು ಹೊಂದಿಲ್ಲ ಮತ್ತು ನಾವು ಡಿಸ್ಕ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

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

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಪರಿಶೀಲಿಸಿ:

[user@localhost ]$ python openforwrite.py 
[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 72.9  0.0 128600  5744 pts/22   R+   11:27   0:20  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

ಯಾವುದೇ ಡಿಸ್ಕ್ ಸ್ಥಳವಿಲ್ಲ, ಆದರೆ ನಾವು ಅಲ್ಲಿ ಹೆಸರಿನ ಪೈಪ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ರಚಿಸುತ್ತೇವೆ:

[user@localhost ~]$ mkfifo /mnt/logs/megapipe
[user@localhost ~]$ ls -lah /mnt/logs/megapipe 
prw-rw-r-- 1 user user 0 Oct  8 11:28 /mnt/logs/megapipe

ಈಗ ನಾವು ಹೇಗಾದರೂ ಈ ಪೈಪ್‌ಗೆ ಹೋಗುವ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ನೆಟ್‌ವರ್ಕ್ ಮೂಲಕ ಮತ್ತೊಂದು ಸರ್ವರ್‌ಗೆ ಸುತ್ತುವ ಅಗತ್ಯವಿದೆ; ಅದೇ ನೆಟ್‌ಕ್ಯಾಟ್ ಇದಕ್ಕೆ ಸೂಕ್ತವಾಗಿದೆ.

ಸರ್ವರ್‌ನಲ್ಲಿ remote-server.example.com ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ

[user@localhost ~]$ nc -l 7777 > 123.txt 

ನಮ್ಮ ಸಮಸ್ಯಾತ್ಮಕ ಸರ್ವರ್‌ನಲ್ಲಿ ನಾವು ಪ್ರತ್ಯೇಕ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ

[user@localhost ~]$ nc remote-server.example.com 7777 < /mnt/logs/megapipe 

ಈಗ ಪೈಪ್‌ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ ಎಲ್ಲಾ ಡೇಟಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನೆಟ್‌ಕ್ಯಾಟ್‌ನಲ್ಲಿರುವ stdin ಗೆ ಹೋಗುತ್ತದೆ, ಅದು ಅದನ್ನು ಪೋರ್ಟ್ 7777 ನಲ್ಲಿನ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಈ ಹೆಸರಿನ ಪೈಪ್‌ಗೆ ನಮ್ಮ ಡೇಟಾವನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸುವುದು.

ನಾವು ಈಗಾಗಲೇ ಅಪ್ಲಿಕೇಶನ್ ಚಾಲನೆಯಲ್ಲಿದೆ:

[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 99.8  0.0 128600  5744 pts/22   R+   11:27 169:27  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt

ಎಲ್ಲಾ ಫ್ಲ್ಯಾಗ್‌ಗಳಲ್ಲಿ, ಫೈಲ್ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ತೆರವುಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಕಾರಣ ನಮಗೆ O_WRONLY ಮಾತ್ರ ಅಗತ್ಯವಿದೆ

[user@localhost ~]$ gdb -p 5946
...
(gdb) call open("/mnt/logs/megapipe", 00000001,0666)
$1 = 4
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call dup2(4,3)
$2 = 3
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call close(4)
$3 = 0
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
(gdb) quit
A debugging session is active.

    Inferior 1 [process 5946] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 5946

ರಿಮೋಟ್ ಸರ್ವರ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ remote-server.example.com

[user@localhost ~]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 38M Oct  8 14:21 123.txt

ಡೇಟಾ ಬರುತ್ತಿದೆ, ನಾವು ಸಮಸ್ಯೆ ಸರ್ವರ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ

[user@localhost ~]$ ls -lah /mnt/logs/
total 7.9M
drwxr-xr-x 2 user user 1.0K Oct  8 11:28 .
drwxr-xr-x 4 root     root     1.0K Oct  8 10:55 ..
-rw-rw-r-- 1 user user 7.9M Oct  8 14:17 123.txt
prw-rw-r-- 1 user user    0 Oct  8 14:22 megapipe

ಡೇಟಾವನ್ನು ಉಳಿಸಲಾಗಿದೆ, ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ.

ಡೆಗಿರೊದಿಂದ ನನ್ನ ಸಹೋದ್ಯೋಗಿಗಳಿಗೆ ಹಲೋ ಹೇಳಲು ನಾನು ಈ ಅವಕಾಶವನ್ನು ಬಳಸುತ್ತೇನೆ.
ರೇಡಿಯೋ-ಟಿ ಪಾಡ್‌ಕಾಸ್ಟ್‌ಗಳನ್ನು ಆಲಿಸಿ.

ಒಳ್ಳೆಯದಾಗಲಿ.

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

[user@localhost ~]$ cat /dev/zero 2>/dev/null| sleep 10000

ಮೂಲ: www.habr.com