ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಹ್ಯಾಲೋವೀನ್: ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೇಗೆ ಕೊಲ್ಲುವುದು

ಹ್ಯಾಲೋವೀನ್ ಸ್ಟಾಂಪ್

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

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

ಒಳ್ಳೆಯದು, ಈ ರೀತಿಯ ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನಡೆಸುವುದು ಆಸಕ್ತಿದಾಯಕವಲ್ಲವಾದ್ದರಿಂದ, ಅವುಗಳು ಆಗಾಗ್ಗೆ ಆಗದಿದ್ದರೂ, ಇಲ್ಲಿ ಸೂಚಿಸಿದಂತೆ ನಾವು ಅವುಗಳನ್ನು ಹುಡುಕಬಹುದು ಮತ್ತು ತೆಗೆದುಹಾಕಬಹುದು. ಮೊದಲನೆಯದು ನಮ್ಮ ಡಿಸ್ಟ್ರೊದಲ್ಲಿ ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಗಳಿವೆಯೇ ಎಂದು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತು ಅದಕ್ಕಾಗಿ ನಾವು ನಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು ಟಾಪ್ ಅಥವಾ ಪಿಎಸ್ ನಂತಹ ಉಪಕರಣಗಳು. ಉದಾಹರಣೆಗೆ, ಈ ಎರಡು ಆಯ್ಕೆಗಳಲ್ಲಿ ಒಂದು:

ps -el | grep 'Z'

ps aux | grep defunct

ಮತ್ತು ಒಮ್ಮೆ ಪತ್ತೆಯಾದ ನಂತರ, ನಾವು ಮಾಡಬಹುದು ಅವನನ್ನು ಕೊಲ್ಲು ನೇರವಾಗಿ ಇದರೊಂದಿಗೆ:

kill -HUP `ps -A -ostat,ppid,pid,cmd | grep -e ‘^[Zz]’ | awk ‘{print $2}’`

ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತೊಂದು ಪರ್ಯಾಯವಾಗಿದ್ದರೂ, ಅಂದಿನಿಂದ ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲು ನೀವು ಕಳೆಯುವಂತಹ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನೀವು ಕೊಲ್ಲಬೇಕು:

ps -eo pid,ppid | grep <PID>

kill -9 <PPID>

ನೀವು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ ನೀವು ಕಂಡುಕೊಂಡ ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆಯ ID ಯಿಂದ ಮತ್ತು ಅದನ್ನು ಕೊಲ್ಲುವ ಮೂಲಕ ಕೊಲ್ಲಲು, ಬದಲಿಸುವ ಮೂಲ ಪ್ರಕ್ರಿಯೆಯ ID ಯನ್ನು ಬಳಸಿ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸ್ಪಷ್ಟವಾಗಿ.


ನಿಮ್ಮ ಅಭಿಪ್ರಾಯವನ್ನು ಬಿಡಿ

ನಿಮ್ಮ ಈಮೇಲ್ ವಿಳಾಸ ಪ್ರಕಟವಾದ ಆಗುವುದಿಲ್ಲ. ಅಗತ್ಯವಿರುವ ಜಾಗ ಗುರುತಿಸಲಾಗಿದೆ *

*

*

  1. ಡೇಟಾಗೆ ಜವಾಬ್ದಾರಿ: AB ಇಂಟರ್ನೆಟ್ ನೆಟ್ವರ್ಕ್ಸ್ 2008 SL
  2. ಡೇಟಾದ ಉದ್ದೇಶ: ನಿಯಂತ್ರಣ SPAM, ಕಾಮೆಂಟ್ ನಿರ್ವಹಣೆ.
  3. ಕಾನೂನುಬದ್ಧತೆ: ನಿಮ್ಮ ಒಪ್ಪಿಗೆ
  4. ಡೇಟಾದ ಸಂವಹನ: ಕಾನೂನುಬದ್ಧ ಬಾಧ್ಯತೆಯನ್ನು ಹೊರತುಪಡಿಸಿ ಡೇಟಾವನ್ನು ಮೂರನೇ ವ್ಯಕ್ತಿಗಳಿಗೆ ಸಂವಹನ ಮಾಡಲಾಗುವುದಿಲ್ಲ.
  5. ಡೇಟಾ ಸಂಗ್ರಹಣೆ: ಆಕ್ಸೆಂಟಸ್ ನೆಟ್‌ವರ್ಕ್‌ಗಳು (ಇಯು) ಹೋಸ್ಟ್ ಮಾಡಿದ ಡೇಟಾಬೇಸ್
  6. ಹಕ್ಕುಗಳು: ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನೀವು ನಿಮ್ಮ ಮಾಹಿತಿಯನ್ನು ಮಿತಿಗೊಳಿಸಬಹುದು, ಮರುಪಡೆಯಬಹುದು ಮತ್ತು ಅಳಿಸಬಹುದು.

  1.   ಚೆಂಡುಗಳನ್ನು ಮಾಡಿದರು ಡಿಜೊ

    ಉತ್ತಮ ಸೈಟ್!
    ಅವರು ಯಾವಾಗಲೂ ನಮ್ಮನ್ನು ತೊಂದರೆಯಿಂದ ಹೊರತರುತ್ತಾರೆ.

    ಎಲ್ಲಿ ಹೇಳುತ್ತದೆ:
    ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತೊಂದು ಪರ್ಯಾಯವಾಗಿದ್ದರೂ, ಜಡಭರತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಲು ನೀವು ಅದನ್ನು ಬೆಂಬಲಿಸುವ ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕೊಲ್ಲಬೇಕು, ನೀವು ಊಹಿಸಿರಬಹುದು:

    1 | ps -eo pid, ppid | grep
    2|
    3 | ಕೊಲ್ಲು -9

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

    ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸೇರಿಸಬಹುದು:

    $ ಬೆಕ್ಕು killppid.sh
    #! / ಬಿನ್ / ಬ್ಯಾಷ್
    ಕೊಲ್ಲು -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')

    ಸಹಜವಾಗಿ, ಇದು ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರು ಎಲ್ಲಾ ಸಮಯದಲ್ಲೂ ನಿರ್ವಹಿಸುವ ಕಾರ್ಯವಲ್ಲ.
    ಇದು ನಿರ್ವಾಹಕರಿಗೆ ಮಾತ್ರ ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಅದನ್ನು ರೂಟ್ ಆಗಿ ಚಲಾಯಿಸಲು ಅಪಾಯಕಾರಿ, ಏಕೆಂದರೆ ಇದು ಸಿಸ್ಟಮ್ನಲ್ಲಿ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲುತ್ತದೆ.

    ಮನುಷ್ಯ ಹತ್ಯೆಯಲ್ಲಿ ಈ ಟಿಪ್ಪಣಿ ಇದೆ:

    ಟಿಪ್ಪಣಿಗಳು ನಿಮ್ಮ ಶೆಲ್ (ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಪ್ರಿಟರ್) ಅಂತರ್ನಿರ್ಮಿತ ಕಿಲ್ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿರಬಹುದು. ನೀವು ಮಾಡಬಹುದು
    ಸಂಘರ್ಷವನ್ನು ಪರಿಹರಿಸಲು ಇಲ್ಲಿ ವಿವರಿಸಿದ ಆಜ್ಞೆಯನ್ನು / ಬಿನ್ / ಕಿಲ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಅಗತ್ಯವಿದೆ.

    ಬ್ಯಾಷ್ ಆ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿದೆ, ಇದು ಮ್ಯಾನ್ ಬ್ಯಾಷ್‌ನ ಭಾಗವಾಗಿದೆ:

    ಕೊಲ್ಲು [-s sigspec | -ಎನ್ ಸಿಗ್ನಮ್ | -ಸಿಗ್ಸ್ಪೆಕ್] [ಪಿಡ್ | ಉದ್ಯೋಗಾವಕಾಶ]...
    ಕೊಲ್ಲು -l | -L [ಸಿಗ್ಸ್ಪೆಕ್ | ನಿರ್ಗಮನ_ಸ್ಥಿತಿ]
    ಪಿಡ್ ಅಥವಾ ಜಾಬ್ ಮೂಲಕ ಹೆಸರಿಸಲಾದ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಸಿಗ್ಸ್ಪೆಕ್ ಅಥವಾ ಸಿಗ್ನಮ್ ಮೂಲಕ ಹೆಸರಿಸಲಾದ ಸಂಕೇತವನ್ನು ಕಳುಹಿಸಿ
    ವಿಶೇಷಣ sigspec ಎನ್ನುವುದು SIGKILL ನಂತಹ ಕೇಸ್-ಇನ್ಸೆನ್ಸಿಟಿವ್ ಸಿಗ್ನಲ್ ಹೆಸರು (ಜೊತೆ ಅಥವಾ
    SIG ಪೂರ್ವಪ್ರತ್ಯಯವಿಲ್ಲದೆ) ಅಥವಾ ಸಂಕೇತ ಸಂಖ್ಯೆ; signum ಒಂದು ಸಂಕೇತ ಸಂಖ್ಯೆ. ಒಂದು ವೇಳೆ
    sigspec ಇರುವುದಿಲ್ಲ, ನಂತರ SIGTERM ಅನ್ನು ಊಹಿಸಲಾಗಿದೆ. -l ನ ವಾದವು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ
    ಸಿಗ್ನಲ್ ಹೆಸರುಗಳು. -l ಅನ್ನು ನೀಡಿದಾಗ ಯಾವುದೇ ವಾದಗಳನ್ನು ಒದಗಿಸಿದರೆ, ಹೆಸರುಗಳು
    ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಿಗೆ ಅನುಗುಣವಾದ ಸಂಕೇತಗಳನ್ನು ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುವ ಸ್ಥಿತಿಯು 0 ಆಗಿದೆ.
    -l ಗೆ exit_status ಆರ್ಗ್ಯುಮೆಂಟ್ ಸಿಗ್ನಲ್ ಸಂಖ್ಯೆ ಅಥವಾ ಸೂಚಿಸುವ ಸಂಖ್ಯೆಯಾಗಿದೆ
    ಸಿಗ್ನಲ್‌ನಿಂದ ಕೊನೆಗೊಂಡ ಪ್ರಕ್ರಿಯೆಯ ನಿರ್ಗಮನ ಸ್ಥಿತಿ. -L ಆಯ್ಕೆಯು ಸಮಾನವಾಗಿರುತ್ತದೆ
    -l ಗೆ ಸಾಲ ನೀಡಲಾಯಿತು. ಕನಿಷ್ಠ ಒಂದು ಸಿಗ್ನಲ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಕಳುಹಿಸಿದರೆ, ನಿಜವಾದ ರಿಟರ್ನ್ಸ್ ಅನ್ನು ಕೊಲ್ಲು, ಅಥವಾ
    ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ಅಥವಾ ಅಮಾನ್ಯ ಆಯ್ಕೆಯು ಎದುರಾದರೆ ತಪ್ಪು.

    ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಬ್ಯಾಷ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಹೇಗೆ ರಕ್ಷಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಆರಂಭದಲ್ಲಿ ಅವರು ವಿವರಿಸುತ್ತಾರೆ, ಆದರೆ ರೂಟ್ ಆಗಿ ಚಲಾಯಿಸಲು ನಾನು ಸುರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೇಗೆ ತಯಾರಿಸಬಹುದು ಎಂಬುದು ನನಗೆ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ.
    ನಾನು ಯೋಚಿಸಬಹುದಾದ ಏಕೈಕ ವಿಷಯವೆಂದರೆ ಅದನ್ನು ಈ ರೀತಿ ರಕ್ಷಿಸುವುದು:

    $ ಬೆಕ್ಕು killppid.sh
    #! / ಬಿನ್ / ಬ್ಯಾಷ್
    ಒಂದು ವೇಳೆ [$ USER == "ರೂಟ್"]
    ನಂತರ ಪ್ರತಿಧ್ವನಿ $ 0 ಅನ್ನು ರೂಟ್ ಆಗಿ ಚಲಾಯಿಸಬೇಡಿ !!! ಇದು ಅಪಾಯಕಾರಿ!
    ನಿರ್ಗಮಿಸಲು
    fi

    ಕೊಲ್ಲು -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')

    $

    ಬ್ಯಾಷ್ ಕಿಲ್ ಅನ್ನು ಬಳಸಿ, ಅಲ್ಲ / ಬಿನ್ / ಕಿಲ್

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

    $ ಸು;
    $ ಕಿಲ್ -9 $ (ps -eo pid, ppid | awk '$ 1 ==' $ {1} '{print $ 2}')