Linux
Basic Linux Commands & Utilities
פקודות בסיסיות בלינוקס: grep, ps, top, kill, awk וקבצי מערכת כמו /etc/passwd.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Basic Linux Commands & Utilities: סינון לוגים, בדיקת תהליכים וניטור מערכת
כששרת בלינוקס מאט או ששירות מפסיק להגיב, העבודה מתחילה תמיד באותם כלים בסיסיים במעטפת: סינון שורות רלוונטיות מתוך קבצי לוג, בדיקה אילו תוכניות פעילות כרגע, ושליטה בתהליכים תקועים.
בפרק המלא תלמדו להפעיל חמש קבוצות של כלי שורת פקודה משלימים:
grepוביטויים רגולריים: איתור שורות בקבצים ובפלט של פקודות, עבודה עםBREמולERE, ספירת שורות לעומת הופעות, שורות הקשר וצביעה במסוף.psלתמונת מצב רגעית: הבחירה ביןps auxל-ps -ef, סינון תהליכים ובחירת עמודות, מיון עם--sort, פענוח קשרי אב-בן (PPID) והבנת מצביSTAT.topלניטור מתעדכן: קריאת נתוני המעבד, הזיכרון והעומס (load average), שימוש במקשי הקיצור והפקת פלט נקי לסקריפטים עםtop -b.- אותות (
Signals) ופקודות שליטה: ההבדלים ביןSIGTERM,SIGKILL,SIGSTOP,SIGCONT,SIGHUPו-SIGQUIT, והפעלתkill,pgrep,pidof,pkillו-killall. awkלעיבוד טבלאי: פירוק שורות לשדות עם-F, המשתניםNR,NF,FSו-OFS, סינון לפי תנאים, בלוקיBEGIN/ENDוצינור משולב עםgrep.
bash, GNU grep, gawk ו-procps-ng). חלק מהפלטים בפרק הם פלט אמיתי מהרצה, וחלקם (בעיקר של ps, top ופקודות ניהול התהליכים) פלט טיפוסי שתלוי במערכת, ולכן המספרים אצלכם ייראו אחרת.grep: סינון שורות לפי תבנית
מה grep עושה ואיך מריצים אותו
כשיש קובץ לוג ענק ואתם מחפשים בו אירוע אחד, grep עוברת על הקלט שורה אחר שורה ומדפיסה רק את מה שמתאים לתבנית (pattern); כל השאר נעלם מהפלט. השם בא מפקודת g/re/p של העורך ed: global, regular expression, print.
מה grep אינה יכולה לעשות? לתקן ערך בקובץ, לחשב סכום או להוציא עמודה: היא רק מסננת, מעתיקה שורות שלמות לפלט, והקובץ נשאר כפי שהיה. הגרשיים הבודדים סביב התבנית ('...') נחוצים מסיבה אחרת: בלעדיהם המעטפת bash מנסה להרחיב בעצמה תווים כמו *, ?, [ ] ו-$ עוד לפני ש-grep רואה אותם.
# Read from one or more files
grep 'connection reset' proxy.log
grep 'connection reset' proxy.log backup.log
# Read from standard input via a pipe
journalctl -u ssh | grep 'Failed password'בקריאה מצינור (pipe) אין שם קובץ, ולכן מודפסות השורות לבדן, ואילו בחיפוש על כמה קבצים grep מקדימה לכל שורה את שם הקובץ ונקודתיים. בנוסף היא מחזירה קוד יציאה ($?) שמאפשר להשתמש בה בתנאי if בסקריפטים:
קוד יציאה ($?) | משמעות |
|---|---|
0 | נמצאה שורה מתאימה אחת לפחות |
1 | החיפוש הסתיים בלי אף התאמה |
2 | תקלה בהרצה, למשל קובץ שלא נמצא או חוסר הרשאה |
# Useful in scripts with -q (quiet) to test exit status only
if grep -q 'CRITICAL' health.log; then
echo "Alert detected"
fiתרחיש 1: שירות שקרס אבל נספר כחי
סקריפט ניטור בודק אם השירות quietd פעיל לפי ps -eo args | grep -c quietd (האופציה -eo args פשוט מדפיסה את שורות הפקודה של כל התהליכים, ומוסברת בהמשך), ומתריע כשהמספר הוא 0. השירות קרס כבר מזמן, אבל ההתראה לא נשלחת: הספירה מחזירה 1.
ps -eo args | grep -c quietd # service is down
ps -eo args | grep quietd
ps -eo args | grep -c '[q]uietd'
pgrep -c quietd1
grep quietd
0
0ה-1 הוא שורת ההרצה של grep -c quietd עצמה: שני צדי הצינור מתחילים יחד, ולכן כש-ps מצלמת את הטבלה grep כבר רצה, ושורת הפקודה שלה כוללת את המילה quietd. בתבנית [q]uietd המחרוזת שמתאימה היא quietd, ואילו שורת ההרצה של grep מכילה את הטקסט [q]uietd על הסוגריים שלו, שאינו מתאים, ולכן הספירה היא 0.
הפקודה pgrep (שנלמדת בהמשך הפרק) פותרת את הבעיה מראש ומחזירה 0 ישירות.
האופציות החשובות
כדי להתאים את החיפוש לצרכים שונים אפשר לצרף דגלים קצרים זה לזה, כך ש-grep -nv זהה לגמרי ל-grep -n -v. נוח לחלק את הדגלים המרכזיים לפי המטרה שלהם:
| קטגוריה | אופציות | הסבר |
|---|---|---|
| כללי התאמה | -i, -v, -w, -x | -i מתעלמת מאותיות גדולות/קטנות (בלי לשנות את הקובץ); -v הופכת בחירה (מדפיסה שורות שלא התאימו); -w דורשת מילה שלמה; -x דורשת התאמה של כל השורה. |
| ריבוי תבניות | -e PATTERN, -f FILE | -e מאפשרת לציין כמה תבניות (OR) בשורת הפקודה; -f טוענת תבניות מתוך קובץ, תבנית אחת לשורה. |
| עיצוב פלט ושגיאות | -n, -c, -o, -q, -s, -h, -H | -n מוסיפה מספר שורה מקורי; -c סופרת שורות; -o מדפיסה רק את החלק המתאים (כל מופע בשורה); -q שקט (קוד יציאה בלבד); -s מסתירה שגיאות פתיחה; -h/-H מסתירות או כופות שם קובץ. |
| שמות קבצים | -l, -L | -l מדפיסה רק שמות קבצים שיש בהם התאמה אחת לפחות; -L מדפיסה רק שמות קבצים ללא אף התאמה. |
| חיפוש בתיקיות | -r, -R, --include | -r סורקת תיקיות רקורסיבית; -R עוקבת גם אחרי כל הקישורים הסימבוליים; --include='*.c' מסננת קבצים לפי שם. |
מה יקרה אם תכתבו grep -e deny.list web.log בתקווה שהקובץ deny.list ייקרא? שום קובץ לא ייפתח: הטקסט deny.list הוא עצמו התבנית, ו-grep תחפש אותו בתוך web.log. רק -f טוענת תבניות מקובץ, ואילו -i ו--l הם דגלים בלי ארגומנט, כך שהמילה שאחריהם היא תבנית רגילה.
הבחנה חשובה נוספת היא בין -w ל--x: בדגל -w, גבולות המילה נקבעים לפי תווים שאינם אות, ספרה או קו תחתון, ולכן בשורה dev:1001:ops המחרוזת dev מתאימה כמילה שלמה, בעוד שבמילה developer היא נפסלת. הדגל -x מחמיר בהרבה ומחייב שהשורה כולה תהיה זהה לתבנית.
# Load patterns from file vs multiple -e patterns
grep -f blocked_ips.txt firewall.log
grep -e 'REFUSED' -e 'DROPPED' firewall.log
# Case-insensitive whole word match
grep -iw 'dev' accounts.txtתרחיש 2: מספרי השורות שנראים שגויים
בקובץ crontab.txt חמש שורות: # backup, 0 2 * * * dump, # old job, # disabled ו-15 6 * * * rotate. סטודנט מריץ את הפקודה הבאה, ומתפלא שהשורה האחרונה מסומנת 5 ולא 2:
grep -nv '^#' crontab.txt2:0 2 * * * dump
5:15 6 * * * rotateנסתכל על השורה 15 6 * * * rotate לבדה: היא יושבת במקום החמישי בקובץ, ו--n מדביקה לכל שורה מודפסת את המקום שלה בקלט, ולא מונה את שורות הפלט. לכן המספרים אינם רציפים.
ומדוע נבחרו דווקא שתי השורות האלה? התבנית ^# תופסת שורות שפותחות בסולמית, ו--v מחליפה אותן בכל השאר. כדי לראות את ההערות 1, 3 ו-4, מורידים את -v ומשאירים את -n.
תרחיש 3: מי מזכיר legacy: שלוש צורות פלט
בתיקייה שלושה קבצים: a.cfg (השורות mode=safe ו-legacy=on), b.cfg (השורה mode=fast) ו-c.cfg (השורות legacy=off ו-legacy_x=1). קודם מבקשים את השורות עצמן עם מיקומן:
grep -n legacy *.cfga.cfg:2:legacy=on
c.cfg:1:legacy=off
c.cfg:2:legacy_x=1בחיפוש על כמה קבצים כל שורה מקבלת קודם את שם הקובץ ואז את מספר השורה, והקובץ c.cfg מופיע פעמיים כי שתי שורות בו מתאימות. כשרק רשימת הקבצים חשובה, -l מקצרת את הפלט, ו--L מחזירה את המשלים:
grep -l legacy *.cfg
grep -L legacy *.cfga.cfg
c.cfg
b.cfgכל שם מודפס פעם אחת בלבד: -l נותנת את a.cfg ו-c.cfg, ו--L נותנת את b.cfg שאין בו אף התאמה.
טעויות נפוצות
-vמפעילה מצב מפורט (verbose).-vהופכת את ההתאמה (invert) ומדפיסה שורות שלא התאימו.-iמסתירה שגיאות קריאה או מפעילה ביטויים רגולריים מורחבים. הסתרת שגיאות היא-s, וביטויים מורחבים הם-E;-iאינה מבדילה בין אותיות רישיות לקטנות.-lמסתירה את שם הקובץ בפלט או מציגה קבצים בלי התאמה. הסתרת שם הקובץ היא-h, וקבצים ללא התאמה הם-Lהגדולה.-wמתאימה שורה שלמה, ו--rמתעלמת מאותיות גדולות (או-cסורקת תיקיות). שורה שלמה היא-x, סריקה רקורסיבית היא-r, וספירת שורות היא-c.grep -e list.txt app.logקוראת תבניות מתוך הקובץlist.txt. רק-fטוענת תבניות מקובץ; אחרי-eהמחרוזתlist.txtהיא תבנית חיפוש רגילה.-nממספרת את הפלט החל מ-1. המספר שמופיע הוא מספר השורה המקורי בקובץ הקלט.
בדקו את עצמכם
השלימו את הפקודה כך שתציג מ-staff.txt שורות עם guest כמילה שלמה, גם כשנכתבה Guest: grep ___ 'guest' staff.txt.
-iw (או -wi): -i מתעלמת מרישיות ו--w דורשת מילה שלמה.
הקובץ deny.txt מכיל כתובות, אחת בכל שורה, ומישהו כתב grep -e deny.txt nginx.log. מה לא תקין, ומה הפקודה הנכונה?
אחרי -e המחרוזת deny.txt היא עצמה תבנית טקסט ואין קריאה של הקובץ. הפקודה הנכונה היא grep -f deny.txt nginx.log.
ספירה: -c סופרת שורות ולא הופעות
כמה פעמים הופיעה המילה warn ב-audit.log? מי שמריץ grep -c מקבל מספר, אבל המספר עונה על שאלה אחרת: כמה שורות מכילות את התבנית, ולא כמה פעמים היא נכתבה.
# audit.log: "warn warn disk", "ok", "warn once", "Warn cap", "WARN WARN net"
grep -c warn audit.log
grep -o warn audit.log | wc -l
grep -ic warn audit.log
grep -io warn audit.log | wc -l2
3
4
6הפקודה הראשונה נותנת 2: רק שתי שורות מכילות warn באותיות קטנות, והשורה הראשונה נספרת פעם אחת למרות שהיא מכילה אותה פעמיים. כדי לספור הופעות מפצלים כל התאמה לשורה משלה עם -o וסופרים עם wc -l (3), ו--ic סופרת שורות בלי תלות ברישיות (4), ובשילוב -io מקבלים את כל ההופעות בכל רישיות (6).
כשנותנים ל--c כמה קבצים, מתקבלת שורה לכל קובץ: שמו, נקודתיים והספירה שלו (למשל audit.log:2).
תרחיש 4: סקריפט שלא מתריע לעולם
בסקריפט ניטור כתוב count=$(grep -l 'denied' gate.log | wc -l), וההתראה אמורה להישלח כש-count גדול מ-3. בקובץ gate.log ארבע שורות עם denied, וההתראה אף פעם לא יוצאת:
grep -l 'denied' gate.log | wc -l
grep -c 'denied' gate.log1
4המספר 1 חושף את הטעות: wc -l סופרת שורות פלט, ו--l מוציאה שורת פלט אחת בלבד, את שם הקובץ, בלי קשר לכמה שורות בו מתאימות. כלומר נספרו קבצים, ואילו -c עונה על השאלה שהסקריפט באמת שאל, ולכן 4 כבר חוצה את הסף.
בקובץ בודד התוצאה של -l | wc -l תהיה לכל היותר 1, ו-0 כשאין התאמה. גם -n אינה פתרון: היא מדפיסה את השורות עצמן עם מספריהן ואינה סופרת.
טעויות נפוצות
grep -cמחזירה את סך ההופעות של התבנית בקובץ. היא סופרת שורות שבהן הייתה התאמה; הופעות מרובות באותה שורה נספרות פעם אחת.grep -l pat file | wc -lסופרת שורות מתאימות.-lפולטת שמות קבצים בלבד, ולכןwc -lתספור קבצים.-cמדפיסה שמות קבצים. הדפסת שמות קבצים היא תפקידו של הדגל-l.
בדקו את עצמכם
בקובץ שלוש שורות: hit hit, miss, hit. איזו פקודה נותנת את מספר השורות המתאימות ואיזו את מספר ההופעות, ומה המספרים?
grep -c 'hit' נותנת 2 (שתי שורות), ו-grep -o 'hit' | wc -l נותנת 3 (שלוש הופעות).
שורות הקשר: האופציות -A, -B, -C
בניתוח תקלות, שורת השגיאה עצמה לרוב אינה מספיקה כדי להבין מה הוביל אליה או מה קרה מיד אחריה. שלוש אופציות מאפשרות להדפיס שורות הקשר (context) מסביב לכל התאמה:
| דגל | משמעות | כיוון ההקשר |
|---|---|---|
-B N | Before | N שורות שלפני השורה המתאימה |
-A N | After | N שורות שאחרי השורה המתאימה |
-C N | Context | N שורות לפני ו-N שורות אחרי |
המספר N קובע תמיד כמה שורות הקשר לצרף (בין אם כותבים -A2 או -A 2), והוא אינו מדלג על התאמות קודמות. אפשר לשלב דגלים יחד, למשל -B1 -A3, וכאשר בין שתי קבוצות של שורות מודפסות נשארות שורות שלא הודפסו, GNU grep מפרידה ביניהן בשורת --.
תרחיש 5: שתי אזהרות ומה שביניהן
בקובץ batch.log שמונה שורות: init, load users, WARN slow disk, sync, sync done, compact, WARN retry, exit. נתחיל משורה אחת אחרי כל אזהרה:
grep -A1 WARN batch.logWARN slow disk
sync
--
WARN retry
exitכל התאמה קיבלה שורת הקשר משלה, ו-sync done עם compact נשארו בחוץ, ולכן GNU grep הפרידה בין שני הבלוקים בשורת --. עכשיו שורה מכל צד, ואחר כך שתיים מכל צד:
grep -C1 WARN batch.logload users
WARN slow disk
sync
--
compact
WARN retry
exitgrep -C2 WARN batch.loginit
load users
WARN slow disk
sync
sync done
compact
WARN retry
exitעם -C2 ההקשר של האזהרה הראשונה מגיע עד שורה 5 וההקשר של השנייה מתחיל בשורה 5, כך שהם חופפים ומתקבל רצף אחד של שמונה שורות בלי -- ובלי שורה שמודפסת פעמיים. ואילו -A4 תתחיל בשורה 3 עצמה: ארבע שורות אחרי ואפס לפני.
טעויות נפוצות
-A 3מציגה שורות לפני ההתאמה, או מדלגת לשורה המתאימה השלישית.Aהיא After (אחרי), ו-3הוא מספר שורות ההקשר לאחר כל התאמה.-A4שקולה ל--C2, כי בשתיהן מודפסות ארבע שורות הקשר.-C2מוסיפה שתיים לפני ושתיים אחרי, ואילו-A4מוסיפה ארבע אחרי ואף אחת לפני.-A 3מוסיפה שלוש שורות מכל צד של ההתאמה. מכל צד זו-C 3;-A 3מוסיפה שלוש שורות אחרי בלבד.
בדקו את עצמכם
בקובץ חמש שורות: s1, s2, BOOM, s4, s5. איזו אופציה אחת, עם מספר, תדפיס את s2, BOOM ו-s4 ותו לא?
-C1: שורה אחת מכל צד של BOOM.
ביטויים רגולריים: BRE, ERE ו-egrep
תבנית החיפוש של grep היא ביטוי רגולרי (regular expression), שבו חלק מהתווים משמשים כאופרטורים מיוחדים. אלה האופרטורים הבסיסיים שפועלים כברירת מחדל:
| תו | משמעות | דוגמה |
|---|---|---|
^ | עוגן לתחילת השורה (מיקום, לא תו) | ^warn מתאימה רק לשורה שמתחילה ב-warn |
$ | עוגן לסוף השורה | ok$ מתאימה לשורה שמסתיימת ב-ok |
. | תו אחד כלשהו | h.t מתאימה ל-hat ול-h9t |
* | אפס חזרות או יותר של הפריט הקודם | go*d מתאימה ל-gd, god, good |
[...] | תו אחד מתוך הרשימה | [0-9] מתאימה לספרה בודדת |
[^...] | תו אחד שאינו ברשימה | [^0-9] מתאימה לתו שאינו ספרה |
\ | ביטול המשמעות המיוחדת של התו הבא | \. מתאימה לנקודה מילולית |
התו ^ משנה תפקיד לפי מיקומו: בתחילת תבנית הוא דורש התאמה לתחילת השורה כולה (מילה באמצע השורה או שורה שמתחילה ברווח לפני warn לא יתאימו ל-^warn), ואילו בתוך סוגריים מרובעים ([^...]) הוא הופך לשלילה. הצירוף ^$ מזהה שורה ריקה.
לתווים +, ?, |, { } ו-( ) יש שתי קריאות אפשריות, וההבדל נראה היטב על אותה תבנית. בקובץ ver.txt ארבע שורות: a+b, aab, a.b ו-axb:
grep 'a+b' ver.txta+bgrep -E 'a+b' ver.txtaabgrep 'a.b' ver.txt
grep -F 'a.b' ver.txta+b
aab
a.b
axb
a.bבפקודה הראשונה + הוא סתם פלוס ולכן נמצאה רק השורה a+b; עם -E הוא אומר "אחת או יותר", ולכן נמצאה aab (ב-a+b אחרי ה-a בא פלוס ולא b). בזוג האחרון הנקודה בלי -F מתאימה לכל תו, ולכן כל ארבע השורות עולות, ואילו -F מחפשת את הטקסט a.b כפשוטו ומחזירה שורה אחת.
BRE: ברירת המחדל. התווים+ ? | { } ( )הם תווים רגילים, ורק לוכסן הפוך לפניהם מפעיל אותם. אפשר לראות זאת עםgrep 'a\+b' ver.txt, שמחזירה אתaab. הצורות\{n,m\}ו-\( \)הן חלק מתקן POSIX, והצורות\+,\?,\|הן הרחבה של GNU.ERE(מופעל עם-E): אותם תווים פועלים כאופרטורים בלי לוכסן:+אחת או יותר,?אפס או אחת,|"או",{n,m}טווח חזרות,( )קיבוץ.-Fו--P:-Fאינה משתמשת בביטוי רגולרי בכלל והתבנית שלה היא טקסט רגיל;-Pפותחת ביטויים בסגנון Perl, ורקGNU grepתומכת בה.
תרחיש 6: חתול או כלב: מי מדפיס מה
בקובץ tags.txt שלוש שורות: cat, dog ו-cat|dog. השורה השלישית מתאימה תמיד, כי היא מכילה את שתי המילים וגם את הקו האנכי עצמו, ולכן השורות cat ו-dog הן המבחן האמיתי. הנה שתי הרצות:
grep 'cat|dog' tags.txtcat|doggrep -E 'cat|dog' tags.txtcat
dog
cat|dogמה שונה בין השתיים? הדגל -E מעביר את grep מ-BRE ל-ERE, ושם | הוא "או"; בלעדיו | הוא תו רגיל, והחיפוש הוא אחר הטקסט cat|dog כפי שנכתב. הצורות הבאות שקולות ל--E ומדפיסות את שלוש השורות:
| פקודה | מדוע זה עובד |
|---|---|
grep 'cat\|dog' tags.txt | הרחבה של GNU: לוכסן הפוך לפני | ב-BRE הופך אותו לאופרטור |
egrep 'cat|dog' tags.txt | שם היסטורי של grep -E |
בהיסטוריה egrep ו-fgrep היו פקודות נפרדות. כיום הן רק כינויים ל-grep -E ול-grep -F, בלי שום יכולת נוספת, ומגרסה 3.8 של GNU grep הן מדפיסות אזהרה שהן מיושנות, ולכן בקוד חדש כותבים את הדגלים.
טעויות נפוצות
egrepמתאימה מילים שלמות, הופכת בחירה או מדפיסה רק את החלק המתאים. אלו תפקידים של-w,-vו--o;egrepרק מפעילה את מצבEREשלgrep -E.- ב-
grepרגילa|bמוצאaאוb. ב-BREהתו|הוא תו מילולי; נדרש-Eאו\|. ^abcמוצאת שורות שמסתיימות ב-abc, או שורות שאחת המילים באמצען מתחילה ב-abc.^מחייב את תחילת השורה כולה (סוף שורה הוא$, ומילה שלמה היא-w).
בדקו את עצמכם
כתבו פקודה שמדפיסה מ-ports.txt רק שורות שהתו הראשון בהן הוא ספרה.
grep '^[0-9]' ports.txt.
הפקודה grep -E 'err+' log.txt מוצאת גם errr, ואילו grep 'err+' log.txt מחפשת את הטקסט err+. מדוע?
בלי -E הפקודה פועלת ב-BRE, ושם + הוא תו רגיל שנחפש כפשוטו; עם -E הוא אופרטור של "פעם אחת או יותר" ולכן err ו-errr מתאימות.
צבע בפלט: --color=auto
מדוע המילה שחיפשתם נצבעת באדום כשאתם מריצים grep לבדה, אך הצבע נעלם ברגע שאתם מעבירים את הפלט ל-cat או לקובץ? התשובה טמונה באופן שבו --color מזריקה קודי בקרה של טרמינל (ANSI escape codes).
auto: צובע אך ורק כשהפלט מופנה ישירות למסוף. כשהפלט נשלח לצינור או לקובץ,grepמשמיטה את קודי הצבע כדי לא לשבש תוכניות אחרות.always: מזריק קודי צבע תמיד, כולל לתוך צינורות וקבצים.never: מכבה צביעה לחלוטין.
הפצות לינוקס רבות מגדירות כינוי (alias) שמריץ grep --color=auto מאחורי הקלעים. כשהצביעה פועלת, מודגשת כל התאמה בשורה ולא רק הראשונה.
תרחיש 7: קודי הצבע בתוך קובץ
בקובץ l.txt שלוש שורות: err one, ok ו-err err two. מריצים את grep פעם עם --color=always ופעם עם --color=auto, בכל פעם עם הפניה לקובץ, ומציגים כל קובץ עם cat -v שמראה תווי בקרה בגלוי:
grep --color=always err l.txt > c1.txt
cat -v c1.txt
grep --color=auto err l.txt > c2.txt
cat -v c2.txt^[[01;31m^[[Kerr^[[m^[[K one
^[[01;31m^[[Kerr^[[m^[[K ^[[01;31m^[[Kerr^[[m^[[K two
err one
err err twoבקובץ הראשון כל הופעה של err עטופה ברצפי ^[[, קודי הצבע של הטרמינל, ובשורה השנייה רואים שגם ההתאמה השנייה בשורה נצבעה. בקובץ השני אין אף רצף כזה: במצב auto grep זיהתה שהפלט הולך לקובץ ולא למסוף, ולכן לא הוסיפה קודים.
אותו דבר קורה ב-grep --color=auto 'err' l.txt | cat. הפקודה cat לא מוחקת צבע, כי הצבע לא נוצר מלכתחילה; כדי לשמר אותו בצינור צריך --color=always.
טעויות נפוצות
catמסירה קודי צבע מפלט שלgrep. במצבauto,grepכלל אינה מוסיפה קודי צבע כשהפלט מופנה לצינור.--color=autoצובעת רק את ההתאמה הראשונה בשורה, או שהדגל-oשומר צבע בצינור. כל ההתאמות בשורה נצבעות, ושמירת צבע בצינור מתבצעת רק עם--color=always.
בדקו את עצמכם
הרצתם grep --color=auto 'warn' sys.log > saved.txt. האם saved.txt יכיל קודי צבע?
לא, כי הפלט הופנה לקובץ ולא למסוף, ולכן מצב auto אינו מוסיף קודי צבע.
ps: תמונת מצב של התהליכים
מה ps מציג
ps אינה מסך חי: כל הרצה שלה היא צילום חדש (snapshot), ושום דבר לא מתרענן בה מעצמו. היא קוראת את נתוני התהליכים מ-/proc, מערכת הקבצים הווירטואלית שבה הקרנל חושף מידע על כל תהליך (גם top קוראת משם), מדפיסה אותם וחוזרת למעטפת, ואינה מפעילה או מסיימת אף תהליך.
ומה מודפס כשמריצים אותה בלי דגלים בכלל? רק התהליכים שמשויכים לטרמינל שבו אתם יושבים ולמשתמש שלכם, בדרך כלל המעטפת עצמה ו-ps, בארבע עמודות: PID (מזהה התהליך), TTY (המסוף), TIME (זמן מעבד שהתהליך צרך עד כה) ו-CMD (שם הפקודה).
ps aux מול ps -ef
כדי לראות את כל התהליכים של כל המשתמשים במערכת, מקובלות שתי פקודות משתי מסורות UNIX שונות: סגנון BSD בלי מקף (ps aux) וסגנון UNIX עם מקף (ps -ef). שתיהן מציגות את אותם תהליכים, אך בוחרות עמודות שונות:
| פקודה | משמעות הדגלים | עמודות בפלט |
|---|---|---|
ps aux | a: כל המשתמשים עם טרמינל; u: תצוגת משתמש; x: כולל תהליכים בלי טרמינל | USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND |
ps -ef | -e: כל התהליכים; -f: פורמט מלא (full) | UID PID PPID C STIME TTY TIME CMD |
ההבדל הפרקטי ביניהן ברור: ps aux מתאימה לבדיקת צריכת משאבים (%CPU, %MEM, VSZ, RSS) ומצב התהליך (STAT), ואילו ps -ef חושפת את PPID (מזהה תהליך האב).
כמה עמודות של ps aux נוטות לבלבל, ולכן כדאי לקרוא אותן יחד עם מה שהן לא אומרות:
| עמודה | מה היא מראה | מה חשוב לדעת |
|---|---|---|
%CPU | חלק מזמן המעבד שהתהליך צרך | ב-ps זה זמן המעבד חלקי כל משך חיי התהליך, כלומר ממוצע מצטבר; ב-top החישוב נעשה מאז הרענון האחרון |
%MEM | אחוז הזיכרון הפיזי שהתהליך תופס | מתייחס לזיכרון הפיזי בלבד |
VSZ | גודל המרחב הווירטואלי של התהליך | אינו מעיד על שימוש ב-RAM, ולכן ערך גבוה לבדו לא אומר שהמכונה עמוסה |
RSS | הזיכרון שיושב בפועל ב-RAM | מוצג ביחידות של KiB |
TTY | המסוף שהתהליך מחובר אליו | הסימן ? אומר שאין מסוף, מצב אופייני לדמונים (שירותי רקע) |
[...] בעמודת הפקודה | שם בסוגריים מרובעים, כמו [kthreadd] | זה תהליכון של הקרנל (kernel thread) ולא תוכנית משתמש |
תרחיש 8: חקירה של שרת איטי
שרת מגיב לאט, ואתם חושדים בתהליך indexer שתפח. נבחן את הצעדים לפי הסדר, כולל נסיון שנכשל בדרך:
- מנסים
psבלי דגלים ומקבלים רק את המעטפת ואתpsעצמה.indexerרץ כשירות רקע, ו-psמוגבלת לטרמינל ולמשתמש שלכם, ולכן הוא לא מופיע. - עוברים ל-
ps aux: עכשיו רואים גם שירותים ללא טרמינל, וב-%MEMוב-RSSמזהים ש-indexer(נניחPID 7301) תופס הרבה. - רוצים לדעת מי הפעיל אותו, אבל ל-
ps auxאין עמודתPPID. מריציםps -efובשורה של7301קוראים את מזהה האב, נניח7188. - אחרי דקה חוזרים לבדוק אם הוא עדיין תפוח: צריך להריץ שוב, כי הצילום הקודם לא התעדכן.
טעויות נפוצות
ps auxמוגבלת למשתמש הנוכחי, אוps -efמוגבלת לטרמינל הנוכחי. שתיהן מציגות את כל התהליכים של כל המשתמשים; רקpsבלי דגלים מוגבלת לטרמינל ולמשתמש הנוכחיים.VSZגבוה אומר שהתהליך תופס הרבה RAM. הזיכרון הפיזי ב-RAM מופיע בעמודהRSS.psמתעדכנת אוטומטית, מריצה תהליכים ברקע או מסיימת תהליכים תקועים. היא מדפיסה תמונת מצב רגעית ומסתיימת, ואינה מפעילה או הורגת תהליכים.
בדקו את עצמכם
באיזו פקודה תראו את ה-PID של תהליך האב: ps aux או ps -ef?
ב-ps -ef, בעמודה PPID.
בחירת תהליכים ועמודות
אפשר לסנן מראש אילו תהליכים יוצגו ולקבוע אילו עמודות יודפסו ובאיזה סדר. טעות תחבירית שכיחה היא לכתוב שם משתמש כארגומנט חופשי בסוף הפקודה (ps -ef dana או ps aux dana) - ps אינה עובדת כך ודורשת דגל ייעודי:
| אופציה | תפקיד |
|---|---|
-u USER / -U USER | -u מסננת לפי המשתמש האפקטיבי (effective, כולל דמונים בלי טרמינל); -U מסננת לפי המשתמש האמיתי (real). |
-p PID | סינון לפי מזהי PID מספריים בלבד, למשל -p 410,415. |
-C NAME | סינון לפי שם הקובץ המבצעי של הפקודה (ולא לפי בעל התהליך). |
-e | בחירת כל התהליכים במערכת. |
-o LIST / -eo LIST | בחירת עמודות מותאמת (למשל -eo pid,user,comm). הצירוף -eo הוא פשוט -e יחד עם -o: כל התהליכים, בעמודות שביקשתם. |
-L / -T | הצגת תהליכונים (threads) עם עמודת LWP או SPID. |
-Z | הוספת הקשרי האבטחה של SELinux. |
ברוב התוכניות המשתמש האמיתי והאפקטיבי זהים, וההבדל בין -U ל--u מתגלה רק בכלים כמו sudo או passwd שרצים בהרשאות משתמש אחר. בבחירת עמודות עם -o, העמודה comm נותנת את שם הפקודה בלי פרמטרים, בעוד cmd (או args) מדפיסה את שורת ההרצה המלאה.
בסקריפטים כמעט אף פעם לא רוצים את שורת הכותרת. הוספת = מיד אחרי שם עמודה ב--o (למשל -o pid=) מוחקת את הכותרת של אותה עמודה, וכשכל העמודות המבוקשות נכתבו כך שורת הכותרת אינה מודפסת בכלל והפלט נקי.
תרחיש 9: איזו פקודה מחזירה רשימת PID נקייה
סקריפט צריך את מזהי התהליכים של המשתמש build, כולל דמונים שלו בלי טרמינל, ובלי שורת כותרת, כדי להעביר אותם ללולאה. שלוש מועמדות:
| פקודה | מה מתקבל |
|---|---|
ps -u build -o pid= | כל המזהים של build, גם של תהליכי רקע, שורה לכל מזהה וללא כותרת: זו הפקודה הנכונה |
ps -u build -o pid | אותם מזהים, אבל שורה ראשונה היא המילה PID, והלולאה תתקל בה |
ps -C build -o pid= | -C מחפשת תוכנית ששמה build, לא תהליכים שבעליהם build, ולכן זו בחירה שגויה |
דבר נוסף שכדאי לבדוק הוא שמיון אינו סינון. כאן הופעלו שלושה תהליכי sleep עם ערכי nice שונים (0, 5 ו-9), והדגל --sort=-ni ממיין בסדר יורד לפי NI: הסדר התהפך, ואף שורה לא נעלמה.
sleep 100 &
nice -n 5 sleep 100 &
nice -n 9 sleep 100 &
ps -C sleep -o ni,comm
ps -C sleep -o ni,comm --sort=-ni NI COMMAND
0 sleep
5 sleep
9 sleep
NI COMMAND
9 sleep
5 sleep
0 sleepכך גם ps -eo pid,user,comm --sort=user: כל התהליכים נשארים, והשורות מסודרות לפי שם המשתמש כמחרוזת ולא לפי מספרו.
טעויות נפוצות
ps -ef liorאוps aux liorמסננות לפי המשתמשlior.psאינה מקבלת שם משתמש כארגומנט חופשי; יש להשתמש ב--u liorאו-U lior.ps -p liorמסננת לפי משתמש, אוps -C liorבוחרת לפי בעלים.-pדורשת מספרי PID, ו--Cמסננת לפי שם התוכנית.-o pidמדפיסה בלי כותרת, או--sort=userמסננת למשתמש הנוכחי. הסרת כותרת דורשתpid=, ומיון אינו מסנן תהליכים.
בדקו את עצמכם
איזו פקודה תדפיס את ה-PID ואת שורת הפקודה המלאה של כל התהליכים של postgres?
ps -C postgres -o pid,cmd.
מיון עם --sort
כשמנסים לשלוף את חמשת התהליכים שצורכים הכי הרבה זיכרון ומריצים ps aux --sort=-%mem | head -5, מקבלים בפועל רק ארבעה תהליכים. הסיבה היא שהשורה הראשונה בפלט היא תמיד שורת הכותרת, ולכן head -5 משאירה כותרת וארבעה תהליכים בלבד (כדי לקבל חמישה תהליכים צריך head -6).
ל---sort אפשר לתת רשימת מפתחות מופרדת בפסיקים, ולכל מפתח כיוון משלו: מינוס פירושו סדר יורד, וחוסר סימן או + פירושו סדר עולה. המפתח השני נכנס לפעולה רק כשיש שוויון במפתח הראשון, ואז הוא מסדר בין השורות השוות בלבד ואינו מערבב מחדש את הטבלה כולה.
ps aux --sort=-%cpu # descending by CPU usage
ps aux --sort=-%mem | head -6 # top 5 memory consumers (+ header line)
ps aux --sort=pid # ascending by PIDתרחיש 10: קבוצות לפי משתמש ושובר שוויון בתוכן
חמישה תהליכים פועלים ברגע ההרצה, עם הערכים הבאים:
| USER | PID | RSS |
|---|---|---|
dev | 310 | 4000 |
ann | 450 | 9000 |
dev | 320 | 12000 |
ann | 460 | 2000 |
root | 1 | 800 |
ps -eo user,pid,rss --sort=user,-rss | head -4המפתח הראשון, user, מסדר אלפביתית: קודם ann (שני תהליכים), אחריה dev ולבסוף root. בתוך ann שני הערכים שווים במפתח הראשון, ולכן -rss מכריע ביניהם בסדר יורד: 450 (9000) לפני 460 (2000).
השורה הראשונה בפלט היא הכותרת, ולכן head -4 מציגה אותה ואחריה שלושה תהליכים: 450, 460 ו-320, ו-root נחתך. אילו המפתח השני היה rss בלי מינוס, שני תהליכי ann היו מתחלפים: 460 לפני 450.
טעויות נפוצות
- מינוס לפני המפתח ב-
--sortמסדר בסדר עולה. מינוס מגדיר סדר יורד; סדר עולה הוא ללא סימן או עם+. - המפתח השני ממיין מחדש את כל הטבלה, או
ps aux | grep cpuממיינת לפי מעבד. המפתח השני מכריע רק במקרי שוויון במפתח הראשון, ו-grepמסננת טקסט ואינה ממיינת. head -3מדפיסה שלושה תהליכים. השורה הראשונה היא הכותרת, כך ש-head -3מחזירה שני תהליכים בלבד.
בדקו את עצמכם
איזו פקודה תציג את שלושת התהליכים שצורכים הכי הרבה זיכרון?
ps aux --sort=-%mem | head -4 (כותרת ושלושה תהליכים).
אב ובן: PPID ועץ התהליכים
בלינוקס כל תהליך נולד מתהליך קיים שנקרא תהליך האב שלו, ומזהה האב מופיע בעמודה PPID (Parent PID). בראש העץ עומד תהליך האתחול (systemd או init) ש-PID שלו הוא 1 (רמה 0), ותהליכים בעלי אותו PPID הם אחים.
כדי לראות את הקשרים מוזחים חזותית עם סימן \_ לפני כל בן, מריצים ps --forest, ps axjf, ps -ejH או את הכלי הנפרד pstree. חשוב לזכור שהקשר נקבע אך ורק לפי השוואת PPID ל-PID, ולא לפי מיקום השורה מעל או מתחת.
תרחיש 11: בניית עץ מלמעלה למטה
נניח שהפקודה ps -eo pid,ppid,comm הדפיסה את הרשימה הבאה (דוגמה לצורך התרגול):
PID PPID COMMAND
1 0 systemd
412 1 sshd
530 1 cron
980 412 sshd-session
985 980 bash
1010 985 vim
1012 985 lessהפעם הולכים מהשורש כלפי מטה: מחפשים את כל השורות ש-PPID שלהן הוא 1. אלה sshd ו-cron, שני אחים ברמה 1. כל הצאצאים הם צעד אחד נוסף בכל חיפוש חוזר: ל-sshd (412) יש בן אחד, sshd-session (980) ברמה 2, ולו בן bash (985) ברמה 3.
ל-985 יש שני ילדים, vim (1010) ו-less (1012), כי לשניהם PPID של 985; הם אחים וברמה 4. מכאן ש-sshd הוא הסב של bash ולא האב שלו, ושורה שנמצאת מתחת לשורה אחרת בפלט (כמו cron ליד sshd) אינה בהכרח הבן שלה.
טעויות נפוצות
- תהליך האב הוא השורה שמופיעה מיד מעל התהליך בפלט. הקשר נקבע אך ורק לפי התאמת
PPIDל-PID. - עמודת
PPIDמופיעה ב-ps aux. היא קיימת ב-ps -efאו כשמוסיפים-o ppid. - כשהשורש ברמה 0, רמת התהליך היא מספר האבות פחות 1. רמת התהליך שווה בדיוק למספר הקפיצות (האבות) עד לשורש.
בדקו את עצמכם
בפלט שלמעלה, באיזו רמה נמצא bash (PID 985) ומי האב הישיר שלו?
רמה 3, והאב הישיר שלו הוא sshd-session (PID 980).
מצבי תהליך: העמודה STAT
העמודה STAT ב-ps aux (והעמודה S ב-top) היא אות שמתארת מה התהליך עושה ברגע הצילום:
| קוד | משמעות המצב |
|---|---|
R | רץ כרגע על המעבד או ממתין בתור כדי לרוץ |
S | ישן, אבל אפשר להעיר אותו (interruptible sleep): ממתין לאירוע |
D | שינה שאי אפשר להפריע לה, לרוב בזמן המתנה להשלמת קלט/פלט; כל אות, גם SIGKILL, ממתין עד שהפעולה מסתיימת |
T | מוקפא בגלל אות עצירה (SIGSTOP או SIGTSTP) |
t | מוקפא בידי דיבאגר |
Z | זומבי (<defunct>): התהליך כבר סיים, אך נשאר ברשימה כי האב עדיין לא קרא את קוד היציאה שלו |
I | תהליכון קרנל סרק (idle) |
בסגנון BSD מופיעים אחרי האות הראשונה גם תווי עזר, והדרך הקלה ללמוד אותם היא לקרוא ערך מורכב אות אחר אות. כאן הורצו שני תהליכי sleep, אחד רגיל ואחד עם nice -n 5:
sleep 100 &
nice -n 5 sleep 100 & # run from a script, so both stay in the terminal's foreground group
ps -o stat,ni,comm -C sleepSTAT NI COMMAND
S+ 0 sleep
SN+ 5 sleepS+: האותSאומרת שינה רגילה, והתו+אומר שהתהליך בקבוצת החזית של הטרמינל.SN+: אותו תהליך, אך התוNמצביע על עדיפות נמוכה (ה-NIשלו הוא5).- תווים נוספים:
sמוביל סשן (כמוSsשלsystemd),lתוכנית מרובת-תהליכונים (Ssl) ו-<עדיפות גבוהה (S<).
top: תצוגה חיה של התהליכים
מה top מציג
בניגוד ל-ps שמדפיסה צילום רגעי ונסגרת, top פותחת מסך ניטור אינטראקטיבי שמתעדכן אוטומטית (כל 3 שניות כברירת מחדל). כברירת מחדל מוצגים כל התהליכים במערכת ממוינים לפי %CPU (הכלי htop הוא תוכנית נפרדת וצבעונית יותר שאינה מותקנת תמיד).
את ראש המסך קוראים שורה אחר שורה. זה צילום אמיתי של חמש השורות הראשונות במכונה עם שמונה ליבות (nproc מדפיסה את מספר הליבות, והדגל -b מדפיס טקסט פשוט ויוסבר בסוף הנושא):
nproc
top -b -n 1 | head -58
top - 05:50:02 up 0 min, 1 user, load average: 1.70, 0.38, 0.12
Tasks: 44 total, 1 running, 43 sleeping, 0 stopped, 0 zombie
%Cpu(s): 8.5 us, 5.9 sy, 0.0 ni, 72.0 id, 11.9 wa, 0.0 hi, 1.7 si, 0.0 st
MiB Mem : 7763.7 total, 6568.4 free, 422.3 used, 772.9 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 7191.9 avail Mem| שורה | השאלה שהיא עונה עליה | איך קוראים אותה |
|---|---|---|
load average | כמה משימות המתינו למעבד או עבדו? | שלושה מספרים, לדקה האחרונה, ל-5 ול-15: מדד מוחלק של משימות שמתחרות על המעבד (רצות, מוכנות לרוץ או חסומות במצב D). אין בו אחוזים, ולכן מספר כמו 1.70 נבחן מול כמות הליבות (כאן 8) |
Tasks | כמה תהליכים יש בכל מצב? | מניין לפי מצב, כולל תהליכי zombie |
%Cpu(s) | על מה הלך זמן המעבד? | us קוד משתמש, sy קרנל, ni תהליכים עם nice, id סרק, wa המתנה לקלט/פלט, hi ו-si פסיקות, st זמן שנלקח על ידי היפרביזור |
MiB Mem ו-MiB Swap | כמה זיכרון בשימוש? | total, free, used, buff/cache לזיכרון הפיזי, ובשורת ה-Swap גם avail Mem |
בטבלת התהליכים שתי עמודות נוספות מתארות עדיפות. NI הוא ערך ה-nice, מעין "נימוס" של תהליך כלפי האחרים: הוא נע בין -20 (הכי תובעני) ל-19 (הכי מתחשב), ברירת המחדל היא 0, ומשתמש רגיל יכול רק להעלות אותו, בעוד שהורדה שלו שמורה ל-root. PR היא העדיפות כפי שהקרנל רואה אותה, ולתהליכים רגילים היא 20 + NI.
המקשים בתוך top
בזמן ש-top רצה ניתן לשלוט בה בלחיצת מקש בודד (יש הבדל בין אותיות קטנות לגדולות). חלק מהמקשים, כמו c, H ו-1, פועלים כמתגים (toggle) שמדליקים ומכבים מצב:
| קטגוריה | מקש | פעולה |
|---|---|---|
| מיון | P, M, N, T | P לפי %CPU (ברירת מחדל); M לפי %MEM; N לפי PID; T לפי זמן מעבד מצטבר (TIME+). |
| מתגי תצוגה | c, H, 1 | c מחליפה בין שם תוכנית לשורת פקודה מלאה; H מפצלת לשורה לכל תהליכון (thread); 1 מפצלת את %Cpu לשורה לכל ליבה. |
| סינון ועמודות | u, f, d / s, W | u סינון לפי משתמש; f מסך ניהול שדות (בחירת עמודות, סידורן ושדה מיון); d/s שינוי קצב רענון; W שמירת הגדרות (~/.toprc או ~/.config/procps/toprc). |
| פעולה ויציאה | k, r, h, q | k שליחת אות לתהליך לפי PID (ברירת מחדל 15, SIGTERM); r שינוי nice (renice); h עזרה; q יציאה. |
תרחיש 12: ארבע לחיצות על שרת בדיקות
בשרת בדיקות עם שמונה ליבות לוחצים בזה אחר זה על c, T, 1 ו-H. כמה שורות נוספו אחרי כל לחיצה?
c: אפס. עמודתCOMMANDמציגה עכשיו את שורת הפקודה המלאה, אבל מספר השורות לא השתנה.T: אפס. רק הסדר השתנה, כי הטבלה ממוינת לפיTIME+.1: שורת%Cpu(s)המסכמת הוחלפה בשמונה שורות,%Cpu0עד%Cpu7, אחת לכל ליבה.H: הטבלה מציגה שורה לכל תהליכון (thread) ולא לכל תהליך, כמו בהרצהtop -H, ולכן היא יכולה לגדול הרבה.
אם רוצים לגלות איזו ליבה עמוסה או אילו תהליכונים של שירות עובדים קשה, המקשים הם 1 ו-H, ולא T או c.
תרחיש 13: העמודה שנעלמת למחרת
ההנחה הרווחת היא שכדי לראות את ה-PPID של תהליך חשוד חייבים לצאת מ-top ולהריץ ps -ef. זה לא נכון: top יודעת להציג את העמודה, והיא פשוט כבויה כברירת מחדל.
לוחצים f, ובמסך ניהול השדות מדליקים את PPID (במסך הזה אפשר גם לקבוע את סדר העמודות ואת שדה המיון). אחרי היציאה העמודה בטבלה, אבל רק לחיצה על W תכתוב את ההגדרות לקובץ ההגדרות, וכך העמודה תחזור גם בהרצה הבאה; מיון לפי זיכרון, לעומת זאת, אינו דורש כלום מזה והוא פשוט M.
טעויות נפוצות
fממיינת לפי זיכרון, מסננת משתמש, שולחת אות או מפצלת ליבות.fפותחת את מסך ניהול השדות. מיון זיכרון הואM, סינון משתמש הואu, שליחת אות היאk, וליבות הן1.kמשנהniceאו סוגרת אתtop. שינויniceהואr, ויציאה היאq;kשולחת אות לתהליך לפי PID.cממיינת לפיPIDאו מציגה תהליכונים, ו-Tמציגה תהליכונים.cמציגה שורת פקודה מלאה,Nממיינת לפיPID,Hמציגה תהליכונים ו-Tממיינת לפיTIME+.
בדקו את עצמכם
בעמודת COMMAND מופיעה רק המילה python3, ואתם רוצים לראות איזה קובץ סקריפט כל תהליך מפעיל. על איזה מקש תלחצו?
c, שמחליף לשורת הפקודה המלאה עם הנתיב והארגומנטים.
הטבלה ממוינת כרגע לפי צריכת מעבד. איך תעברו למיון לפי זיכרון ואיך תחזרו?
M ממיין לפי %MEM, ו-P מחזיר למיון לפי %CPU.
top -b ושאר האופציות
מה קורה כשמעבירים את top בצינור בלי שום דגל? בהרצה מטרמינל זה עובד, אבל הפלט מלא בתווי בקרה שמציירים את המסך, ובלי טרמינל בכלל, למשל במשימת cron, היא נכשלת עם שגיאה:
top -n 1 | head -3 # run without a terminal, as cron wouldtop: failed tty getהדגל -b (batch mode) מבטל את הציור ושולח טקסט פשוט לפלט הסטנדרטי, שאפשר להפנות לקובץ או לצינור. בלי הגבלה top -b ממשיכה להדפיס רענון אחרי רענון עד שעוצרים אותה, ולכן מוסיפים -n N למספר הדגימות ולעיתים -d SECONDS למרווח ביניהן; ומכיוון שאין קלט מקשים, אי אפשר מתוכה לשנות nice או לשלוח אות.
top -b -n 1 > cpu_snap.txt # single snapshot saved to file
top -b -n 4 -d 2 | grep 'Cpu(s)' # 4 samples, 2 seconds apart| אופציה | תפקיד |
|---|---|
-b | מצב batch: פלט טקסט נקי לצינורות ולקבצים, ללא מקשים |
-n N | עצירה אוטומטית לאחר N רענונים |
-d SECONDS | השהיה בשניות בין רענונים |
-p PID | ניטור מזהי תהליכים מסוימים בלבד |
-u USER | הצגת תהליכי משתמש מסוים בלבד |
-H | הצגת תהליכונים (threads) |
טעויות נפוצות
top -bהופכת את התוכנית לשירות רקע שאינו תלוי בסגירת הטרמינל.-bקובעת רק את פורמט הפלט ואינה מנתקת את התהליך מהטרמינל.-bחושפת תהליכים מוסתרים של משתמשים אחרים, או מאפשרתreniceבלחיצת מקש.topמציגה את כל התהליכים גם במצב הרגיל, ובמצבbatchאין מקשים אינטראקטיביים.
בדקו את עצמכם
שמרו לקובץ snap.txt שתי דגימות של top שביניהן עשר שניות. איזו פקודה תריצו?
top -b -n 2 -d 10 > snap.txt.
אותות (Signals)
מהו אות ומי רשאי להתעלם ממנו
תוכנית נתקעה בלולאה ואתם לוחצים Ctrl+C. המקלדת לא מחסלת כלום בעצמה: הטרמינל מבקש מהקרנל להעביר לתהליך אות (signal), כלומר הודעת התראה זעירה על אירוע. לכל אות יש שם שמתחיל ב-SIG ומספר שלם צמוד אליו, וכך Ctrl+C מייצר את SIGINT, שמספרו 2.
מה שקורה לתהליך אחרי שהאות מגיע תלוי בפעולת ברירת המחדל של אותו אות: סיום, סיום עם כתיבת תמונת הזיכרון לקובץ core (קובץ שמאפשר לנתח אחר כך מדוע התוכנית קרסה), הקפאה, חידוש ריצה או התעלמות. הפעולה הזו היא רק נקודת מוצא, כי תוכנית יכולה לוותר עליה.
תוכנית רשאית לתפוס כמעט כל אות ולהריץ במקומו פונקציית טיפול משלה (handler), או להודיע שהיא מתעלמת ממנו. שני אותות אינם נתונים לבחירה כזו: SIGKILL ו-SIGSTOP מטופלים בתוך הקרנל ואף פעם לא מגיעים לקוד התוכנית.
את האות אפשר לשלוח משלושה כיוונים: תהליך אחר שמריץ kill, צירוף מקשים בטרמינל כמו זה שפתח את הסעיף, או הקרנל עצמו כשמשהו השתבש או כשהטרמינל התנתק.
האותות המרכזיים שצריך להכיר
הטבלה שלפניכם מסכמת את האותות החשובים ביותר למבחן: המספר בכל ארכיטקטורה נפוצה, מי שולח אותו ומה קורה כברירת מחדל. הערה על מונח: דמון הוא שירות שרץ ברקע בלי טרמינל, כמו שרת אינטרנט או שרת SSH.
| אות | מספר | שולח אופייני | ברירת מחדל ומשמעות |
|---|---|---|---|
SIGTERM | 15 | kill ללא דגלים | בקשה מסודרת לסיום; התוכנית יכולה ללכוד ולבצע ניקוי |
SIGINT | 2 | Ctrl+C | הפרעה (interrupt) מהמקלדת; מסיים כברירת מחדל |
SIGQUIT | 3 | Ctrl+\ | מסיים ושומר תמונת זיכרון (core) אם המגבלה מאפשרת |
SIGKILL | 9 | kill -9 | סיום מיידי בידי הקרנל; בלתי ניתן ללכידה או חסימה |
SIGSTOP | 19 | kill -STOP | הקפאה כפויה של התהליך; בלתי ניתן ללכידה או חסימה |
SIGTSTP | 20 | Ctrl+Z | בקשת עצירה מהטרמינל; התוכנית רשאית לטפל בה |
SIGCONT | 18 | fg, bg, kill -CONT | מחזיר לריצה תהליך שנעצר |
SIGHUP | 1 | ניתוק טרמינל, kill -HUP | מסיים תהליך רגיל; בדמונים מקובל לטעון מחדש תצורה |
SIGUSR1 / SIGUSR2 | 10 / 12 | kill -USR1 | אותות לשימוש עצמי של התוכנית (למשל הדפסת התקדמות ב-dd) |
כשמפעילים פקודה בחזית הטרמינל, שלושה צירופי מקשים שולחים אליה אותות מיידית: Ctrl+Z מקפיא עם SIGTSTP, Ctrl+C מפסיק עם SIGINT, ו-Ctrl+\ שולח SIGQUIT.
לעומת זאת, ל-SIGTERM אין צירוף מקשים משלו והוא נשלח כברירת מחדל מ-kill, ואילו SIGHUP נוצר אוטומטית כשהטרמינל נסגר או מתנתק. מבחינת ניידות, המספרים 1, 2, 3, 9 ו-15 זהים בכל ארכיטקטורות לינוקס, אך 10, 12, 18, 19 ו-20 נכונים ל-x86 ול-ARM ועלולים להשתנות בחומרות אחרות, ולכן מומלץ לכתוב שמות ולא מספרים.
כדי לראות את כל האותות ומספריהם במערכת הנוכחית מריצים kill -l, והעברת מספר כמו kill -l 15 תדפיס את שם האות בלבד (TERM).
kill -l # list signal numbers and names on this host
kill -l 15 # translate number 15 to TERMטעויות נפוצות
- הקשה על
Ctrl+CשולחתSIGTERMלתוכנית. הטרמינל שולחSIGINT(מספר 2);SIGTERM(15) נשלח כברירת מחדל מפקודתkill. - הקשה על
Ctrl+CשולחתSIGQUIT. האותSIGQUIT(מספר 3) משויך לצירוףCtrl+\, לא ל-Ctrl+C. - הקשה על
Ctrl+Zמחסלת את התהליך. ב-psתראו שהתהליך נשאר חי במצבT(עצור), משום ש-Ctrl+ZשולחתSIGTSTP.
בדקו את עצמכם
איזה אות יוצר צירוף המקשים Ctrl+Z, ומהו מספרו בארכיטקטורת x86?
SIGTSTP, שמספרו 20.
אותות שאפשר ללכוד מול אותות שאי אפשר לתפוס
לפני שמחסלים שרת או סקריפט, חשוב לאפשר לו לסיים כתיבות פתוחות, למחוק קובצי נעילה וקובצי PID ולסגור חיבורים. את ההזדמנות הזו מעניקים אותות שאפשר לתפוס או להתעלם מהם - SIGTERM, SIGINT, SIGHUP, SIGQUIT ו-SIGTSTP - שמגיעים ישירות לקוד התוכנית ומפעילים את שגרת הטיפול שלה.
לעומתם, SIGKILL ו-SIGSTOP לעולם אינם מועברים לקוד המשתמש: הקרנל מבצע אותם בלי לשאול את התוכנית, ואי אפשר לחסום אותם או להתקין להם handler. SIGKILL מסיים מיד, ו-SIGSTOP רק מקפיא את הריצה.
בגלל המחיר של SIGKILL - קבצים זמניים שנותרים בדיסק, כתיבה שנקטעת באמצע ותהליכי בן שעלולים להישאר יתומים - נוהגים לבקש סיום מנומס עם SIGTERM, להמתין כמה שניות, ורק אם התהליך עדיין חי לשלוח SIGKILL.
PID=6240
kill -TERM "$PID" # polite shutdown request first
sleep 3
if kill -0 "$PID" 2>/dev/null; then # check if process still exists
kill -KILL "$PID" # force termination only as last resort
fiתרחיש 14: תהליך שמתעלם מ-SIGTERM ומ-SIGHUP
תהליך גיבוי בבעלותכם (PID 6240) נתקע בלולאה ומחזיק קוד שלוכד ומתעלם גם מ-SIGTERM וגם מ-SIGHUP. פקודות כמו kill 6240 או kill -HUP 6240 יגיעו לתוכנית אך לא יסיימו אותה.
אם תנסו kill -STOP 6240, הקרנל אמנם יקפיא את התהליך למצב T כי אי אפשר לתפוס SIGSTOP, אבל הזיכרון והנעילות שלו יישארו תפוסים. הדרך היחידה לסיים אותו בוודאות היא kill -9 6240 (או kill -KILL 6240), שגורמת לקרנל להוריד את התהליך מיידית בלי לעבור בקוד שלו.
טעויות נפוצות
- תמיד עדיף להתחיל מ-
kill -9כדי לחסוך זמן.SIGKILLאינו מאפשר ניקוי משאבים ועלול להשחית נתונים; מתחילים מ-SIGTERM. SIGTERMהורג מיד בלי שהתוכנית תוכל למנוע זאת. רקSIGKILLבלתי ניתן לתפיסה; אתSIGTERMהתוכנית יכולה ללכוד או להתעלם ממנו.SIGKILLמשאיר לתהליך רגע לשחרר נעילות לפני היציאה. התוכנית לא מקבלת שום התראה ואינה מריצה קוד ניקוי ב-SIGKILL.SIGKILLמקפיא תהליך זמנית לצורך בדיקה, ו-killסוגרת את חלון המסוף. הקפאה היאSIGSTOP, ו-killשולחת אות לתהליך ולא לחלון הטרמינל.
בדקו את עצמכם
אילו שני אותות התוכנית אינה יכולה לתפוס או לחסום, ומה עושה כל אחד מהם?
SIGKILL (מסיים את התהליך מיד) ו-SIGSTOP (מקפיא את התהליך בלי להרוג אותו).
הקפאה והמשך: SIGSTOP, SIGTSTP ו-SIGCONT
תהליך במצב עצור (T בפלט של ps) קפוא לגמרי ואינו מקבל זמן מעבד, אך כל תמונת הזיכרון, המחסנית והאוגרים שלו נשמרים. אפשר להביא תהליך למצב זה באמצעות SIGTSTP מ-Ctrl+Z (שהתוכנית יכולה לתפוס) או באמצעות SIGSTOP מ-kill -STOP (שאי אפשר לתפוס).
שליחת SIGCONT מעירה תהליך עצור וממשיכה אותו מאותה הוראה בדיוק שבה נעצר, ולא מאתחלת את התוכנית מחדש; על תהליך שכבר רץ, SIGCONT חסר השפעה. על בסיס זה פועלת בקרת העבודות (job control) של ה-shell: fg ו-bg שולחות SIGCONT לחזית או לרקע, ואפשר גם להעיר תהליך מכל טרמינל אחר עם kill -CONT <PID>.
מה קורה אם שולחים אות רגיל כמו SIGTERM לתהליך שכבר נמצא במצב T? הקרנל שומר את האות כממתין (pending) והתהליך נשאר קפוא במצב T בלי לעבור למצב Z (כי מצב זומבי נוצר רק אחרי סיום ריצה).
האות הממתין אינו נזרק ואינו דורש שליחה חוזרת: ברגע שהתהליך יקבל SIGCONT ויתעורר, ה-SIGTERM יימסר לו והוא יסתיים (אם אינו לוכד אותו). לעומת זאת, SIGKILL מסיים גם תהליך עצור באותו רגע בלי לחכות ל-SIGCONT.
kill של bash עם מזהה עבודה (כגון kill %1), המעטפת מוסיפה אוטומטית SIGCONT אחרי SIGTERM או SIGHUP כדי שהתהליך העצור יתעורר ויסיים.תרחיש 15: מעקב אחרי תהליך שהוקפא ב-SIGSTOP וקיבל SIGTERM
הקפאתם תהליך אריזה (PID 4815) בעזרת kill -STOP 4815, ובדיקת ps -o pid,stat,comm -p 4815 מראה שהוא במצב T. כעת אתם שולחים לו kill 4815 (SIGTERM).
kill -STOP 4815
ps -o pid,stat,comm -p 4815 # STAT shows T
kill 4815 # SIGTERM is queued as pending; still T
kill -CONT 4815 # wakes up -> pending SIGTERM is delivered -> exitsבזמן שהתהליך עצור הוא לא מריץ שום קוד, ולכן אינו יכול להגיב ל-SIGTERM: הוא נשאר ב-T ולא הופך ל-Z. האות נמסר רק אחרי kill -CONT 4815 (או fg בטרמינל שבו עצרתם אותו) והתהליך מסתיים אז. לעומת זאת kill -KILL 4815 היה מסיים אותו מיד, גם בלי להעיר אותו קודם.
טעויות נפוצות
SIGTERMשנשלח לתהליך במצבTמסיים אותו מיד. האות ממתין בקרנל עד שהתהליך יתעורר ב-SIGCONT; רקSIGKILLמסיים תהליך עצור מיד.- אם שולחים
SIGTERMלתהליך קפוא, האות אובד וצריך לשלוח שוב. הקרנל שומר אותות ממתינים ומוסר אותם מיד כשהתהליך מתחדש. SIGCONTמפעיל את התוכנית מההתחלה. היא ממשיכה בדיוק מנקודת ההקפאה עם המחסנית והאוגרים שלה.- רק
fgיכול להמשיך תהליך עצור, ו--CONTעוצר תהליך.kill -CONT <PID>עובד מכל טרמינל וממשיך ריצה; הקפאה היא-STOP.
בדקו את עצמכם
תהליך במצב T קיבל SIGTERM ולאחר מכן SIGCONT. מה יקרה?
התהליך יתעורר עם SIGCONT, ה-SIGTERM הממתין יימסר מיד, והתהליך יסתיים (אלא אם הוא לוכד אותו).
SIGHUP וטעינה מחדש של הגדרות
איך מעדכנים קובץ תצורה של שרת פעיל בלי להפיל חיבורי משתמשים? היסטורית, SIGHUP (hang up) נועד להתריע על ניתוק טרמינל או קו מודם, ובתהליך אינטראקטיבי רגיל ברירת המחדל שלו היא סיום.
אולם לדמונים שרצים ברקע אין טרמינל מחובר, ולכן התפתחה מוסכמה: שירותים כמו nginx ו-sshd לוכדים את SIGHUP כדי לקרוא מחדש את קובצי ההגדרות בלי להיסגר. בשרתים עם תהליך ראשי (master) ותהליכי עבודה (workers), שולחים את האות לתהליך הוותיק ביותר בעזרת pgrep -o.
# Target the oldest (master) process so workers reload cleanly
sudo kill -HUP $(pgrep -o nginx)זו מוסכמה ולא חוק של הקרנל, ולכן כל תוכנית מחליטה בעצמה מה לעשות עם SIGHUP. למשל rsyslog משתמש בו כדי לסגור את קובצי הלוג ולפתוח אותם שוב.
תרחיש 16: עדכון הגדרות של שרת SSH בלי לנתק חיבורים
עדכנתם את התצורה של שרת sshd (תהליך ראשי PID 1890) ואתם רוצים שהשינוי ייקלט בלי להפיל סשנים פתוחים. שליחת kill -SIGHUP 1890 גורמת לדמון לטעון מחדש את הקובץ ולהמשיך לעבוד.
אותות אחרים יחמיצו את המטרה: kill -SIGTERM או kill -SIGINT מבקשים סגירה של השרת, kill -SIGKILL מוריד אותו מיד בלי ניקוי, kill -SIGSTOP מקפיא את השירות, ו-kill -SIGCONT אינו משפיע כלל על תהליך שכבר רץ.
טעויות נפוצות
SIGHUPתמיד הורג דמונים או משהה אותם עד המשך. השהיה היאSIGSTOP, ובדמונים רביםSIGHUPדווקא גורם לטעינת הגדרות מחדש בלי להיסגר.- כל דמון בהכרח טוען מחדש קובצי תצורה בקבלת
SIGHUP. זו מוסכמה נפוצה ולא חוק; יש דמונים שפותחים מחדש לוגים ויש כאלה שמסיימים.
בדקו את עצמכם
מהו המספר של SIGHUP, ומה קורה לתהליך רגיל שאינו מגדיר לו handler?
מספרו 1, וברירת המחדל לתהליך רגיל היא סיום.
SIGQUIT ויצירת קובץ core
אם לחצתם Ctrl+\ על תוכנית, היא נסגרה אך לא נוצר קובץ core לניתוח ב-gdb - הסיבה הנפוצה היא מגבלת ulimit -c. בהפצות רבות ברירת המחדל היא ulimit -c 0, שחוסמת כתיבת תמונת זיכרון, ולכן יש להריץ ulimit -c unlimited לפני ההפעלה.
SIGQUIT (מספר 3) נשלח ב-Ctrl+\ או בפקודה kill -QUIT. התהליך מסתיים מיד, ואם ulimit -c מתיר, נכתב גם קובץ core. אם התוכנית לוכדת את האות או מתעלמת ממנו, לא יהיה לא סיום ולא קובץ.
ulimit -c unlimited # enable core dump creation in this shell
sleep 200
# Ctrl+\ terminates the process and writes a core fileטעויות נפוצות
SIGQUITתמיד מסיים בלי לכתוב קובץ, או שומרcoreכשהתהליך ממשיך לרוץ. התהליך מסתיים יחד עם הכתיבה, והקובץ נוצר כל עודulimit -cמאפשר זאת (בניגוד ל-SIGTERMשיוצא בליcore).- תהליכים מתעלמים מ-
SIGQUITכברירת מחדל. ברירת המחדל היא סיום עםcore; התעלמות קיימת רק אם הקוד ביקש זאת.
בדקו את עצמכם
תוכנית נסגרה אחרי Ctrl+\, אבל אין קובץ core בתיקייה. מה ההסבר הסביר?
המגבלה ulimit -c היא 0 במעטפת הנוכחית ולכן כתיבת תמונת הזיכרון נחסמה.
הפקודה kill
דרכים לכתוב את האות ב-kill
הפקודה kill מקבלת אך ורק מזהה תהליך (PID) או מזהה עבודה (%1, הזמין בפקודה הפנימית של bash לצד הקובץ /bin/kill). אם תעבירו לה שם של תוכנית כמו kill -TERM postgres, הפקודה תיכשל עם הודעה שהארגומנט חייב להיות PID או מזהה עבודה, ולא תשלח שום אות.
כדי לאתר PID לפי שם משתמשים ב-pgrep או ב-pidof, וכדי לשלוח אות ישירות לפי שם משתמשים ב-pkill או ב-killall. למרות שמה, kill שולחת כל אות שתרצו - וברירת המחדל ללא דגל היא SIGTERM (15), לא חיסול מיידי.
לאחר המקף אפשר לכתוב מספר אות, שם ללא קידומת SIG, שם מלא, או להשתמש בדגל -s:
kill -19 7412 # by signal number (SIGSTOP on x86/ARM)
kill -STOP 7412 # by short name
kill -SIGSTOP 7412 # by full name
kill -s STOP 7412 # using explicit -s flagטעויות נפוצות
- אפשר להריץ
killעם שם של תוכנית או שם משתמש.killעובדת רק עם PID או מזהה עבודה של ה-shell. - הרצת
killבלי דגלים הורגת בכוח (SIGKILL). ברירת המחדל היאSIGTERM, שמאפשר לתוכנית לנקות לפני היציאה. - מותר להפריד ברווח כך:
kill -SIG STOP 7412. לא שמים רווח אחריSIG; כותבים-STOP,-SIGSTOPאו-s STOP.
בדקו את עצמכם
כתבו שתי צורות תקניות לשליחת SIGSTOP לתהליך 1450.
kill -STOP 1450 ו-kill -s STOP 1450 (וגם kill -SIGSTOP 1450).
הבדיקה kill -0 ו-PID שלילי
נניח שסקריפט ניטור רוצה לבדוק אם שירות עדיין חי בלי להפריע לפעולתו. המספר 0 אינו אות אמיתי: kill -0 <PID> לא משגרת אות לתהליך, אלא בודקת רק אם הוא קיים ואם יש לכם הרשאה לאותת לו.
התוצאה חוזרת בקוד היציאה ($?): ערך 0 מאשר שהתהליך קיים ומותר לאותת לו, וערך אחר פירושו שאין תהליך כזה או שאין הרשאה. כך סקריפטים בודקים חיות של תהליך (או של המעטפת עצמה דרך $$).
kill -0 $$ 2>/dev/null; echo $? # prints 0 (current shell is alive)
kill -0 999999; echo $? # error text goes to stderr, then prints 1כאשר מעבירים ל-kill מספר שלילי, הפנייה היא לקבוצת תהליכים (process group) שלמה: למשל kill -TERM -5120 משגר SIGTERM לכל התהליכים בקבוצה 5120. המקרה הקיצוני kill -9 -1 שולח SIGKILL לכל תהליך שמותר לכם לאותת לו חוץ מ-init (PID 1) ומהתהליך עצמו - ואצל root הפקודה משביתה כמעט את המערכת כולה.
טעויות נפוצות
kill -0עוצרת או הורגת את התהליך. היא אינה שולחת אות כלל אלא בודקת קיום והרשאה דרך קוד היציאה.kill -0שולחתSIGHUPלכל קבוצת התהליכים. פנייה לקבוצה נעשית עם PID שלילי (כמו-5120), ו--0אינו אות.
בדקו את עצמכם
סקריפט מריץ kill -0 912 ומקבל $? שווה ל-1. מהן שתי הסיבות האפשריות?
או שאין תהליך עם PID 912, או שהוא שייך למשתמש אחר ואין לכם הרשאה לאותת לו.
הרשאות ומצבים שבהם גם kill -9 לא מעלים תהליך
משתמש רגיל יכול לשלוח אותות רק לתהליכים שבבעלותו (אותו מזהה משתמש), ואילו root מחזיק ביכולת CAP_KILL שמאפשרת לו לאותת לכל תהליך.
עם זאת, יש שלושה מצבים שבהם גם SIGKILL לא יגרום לשורה להיעלם מטבלת התהליכים:
- מצב שינה בלתי ניתנת להפרעה (
D): התהליך תקוע בתוך קריאת קלט/פלט בקרנל (כגון דיסק או NFS שלא מגיב), והאות יעובד רק כשהפעולה תסתיים ותחזור מהקרנל. - תהליך זומבי (
Z): התוכנית כבר סיימה לרוץ ואינה חיה, ורק רשומת קוד היציאה מחכה שהאב יקרא אותה; היא תיעלם רק כשהאב יאסוף אותה, או כשהאב ימות ו-initיאמץ ויאסוף אותו. - תהליך
PID 1: מתעלם מאותות שלא הותקן עבורם טיפול מפורש, כוללSIGKILLשנשלח מתוך אותו PID namespace.
טעויות נפוצות
kill -9מנקה תהליך זומבי מטבלת התהליכים. אי אפשר להרוג תהליך שכבר מת; רק האב (אוinitלאחר מות האב) אוסף את הרשומה.- משתמש רגיל יכול לחסל עם
kill -9כל תהליך במערכת. משתמש רגיל מוגבל לתהליכים שלו; רקroot(CAP_KILL) עוקף זאת.
איתור תהליכים לפי שם: pgrep, pidof, pkill, killall
pgrep ו-pidof: מציאת מספרי PID
בניגוד ל-pkill ול-killall, הפקודות pgrep ו-pidof הן כלי קריאה בלבד: הן רק מדפיסות מספרי PID ואינן שולחות שום אות.
pgrep PATTERN מתאימה גם לחלק משם התהליך (אפשר להוסיף -l להצגת השם ו--u USER לסינון לפי בעלים), ו-pgrep -o מחזירה רק את התהליך הוותיק ביותר. לעומתה, pidof NAME דורשת שם תוכנית מדויק ומדפיסה מספרים בסדר יורד (מהגבוה לנמוך), כך ש-pidof -s תחזיר לרוב דווקא את התהליך החדש ביותר.
pgrep -l redis-server # list PIDs and names matching pattern
pgrep -o redis-server # oldest matching PID only
pidof -s redis-server # single PID (typically the newest)pkill: שליחת אות לפי תבנית או משתמש
pkill בוחרת תהליכים באותה שיטה של pgrep, אך שולחת לכולם אות (כברירת מחדל SIGTERM, ואפשר לציין -9, -TERM או -SIGTERM כמו ב-kill). מאחר שההתאמה היא חלקית, pkill ruby תפגע גם בתהליך בשם ruby2.7.
כדי להתאים מול שורת הפקודה המלאה (כולל ארגומנטים של סקריפט) מוסיפים -f, וכדי לפנות לכל התהליכים של משתמש מסוים משתמשים בדגל -u.
| פקודה | פעולה |
|---|---|
pkill -TERM memcached | שולחת SIGTERM לכל תהליך ששמו מכיל memcached |
pkill -f 'sync_data.sh' | בודקת התאמה מול שורת הפקודה המלאה |
pkill -SIGTERM -u tamar | שולחת SIGTERM לכל התהליכים בבעלות המשתמשת tamar |
pkill -HUP tamar | שולחת SIGHUP לתהליכים ששמם מכיל tamar (בלי קשר לבעלים) |
הבדל חשוב בין שתי השורות האחרונות: בלי -u, הארגומנט tamar נבדק כתבנית של שם תוכנית ולא כשם משתמש.
תרחיש 17: שליחת אות לכל מופעי השירות בלי לדעת PID
נניח שרץ שרת memcached בכמה מופעים ואתם רוצים לסיים את כולם מסודר בפקודה אחת בלי לחפש מזהים. הפקודה הנכונה היא pkill -TERM memcached.
למה האלטרנטיבות לא יבצעו זאת? pgrep -l memcached ו-pidof -s memcached רק מדפיסות מזהים בלי לשלוח אות, ו-kill -TERM memcached תיכשל כי kill דורשת PID מספרי.
תרחיש 18: פינוי מסודר של תהליכי משתמשת
המשתמשת tamar סיימה משמרת ו-root רוצה לבקש מכל התהליכים שלה להיסגר נקי. הפקודה pkill -SIGTERM -u tamar מסננת לפי בעלים ושולחת SIGTERM לכולם.
אם תשכחו את -u ותכתבו pkill -SIGTERM tamar, הפקודה תחפש תוכנית ששמה מכיל tamar במקום משתמשת; ואם תריצו killall -9 tamar, תשלחו SIGKILL לתוכנית בשם tamar.
טעויות נפוצות
pgrep -lאוpidof -sשולחות אותות לתהליכים שנמצאו. שתיהן מדפיסות מספרי PID בלבד ואינן מאותתות.pkill tamarמסננת לפי שם המשתמשת. חובה להוסיף-u tamar; אחרתtamarמתפרשת כתבנית שם תוכנית.
בדקו את עצמכם
איך תשלחו SIGHUP לכל התהליכים שבשורת ההפעלה שלהם מופיע queue_worker.py?
pkill -HUP -f queue_worker.py.
killall: שליחת אות לפי שם מדויק
הכלל המרכזי של killall NAME הוא התאמה מדויקת של שם התוכנית, בניגוד להתאמה החלקית של pkill. כאשר נמצאים תהליכים בשם הזהה, killall שולחת אות לכולם (ולא עוצרת אחרי ההתאמה הראשונה), וברירת המחדל שלה היא SIGTERM.
אם אין אף תהליך בשם המדויק, killall מדווחת no process found ואינה מאותתת לאף אחד. אפשר להוסיף -u לסינון לפי משתמש או -9 לשליחת SIGKILL מיידי לכל המופעים.
killall -9 haproxy # force-kill every process named exactly haproxy
killall -u tamar # send SIGTERM to all processes owned by tamarkillall מחסלת את כלל התהליכים במערכת, ולכן היא אינה נחשבת ניידת.תרחיש 19: killall node מול תהליכי nodejs
בטבלת התהליכים רצים מופעים ששם התוכנית שלהם הוא nodejs. הרצת killall node תחפש התאמה מדויקת ל-node, תיכשל עם node: no process found ולא תשלח שום אות.
כדי לאותת לתהליכים האלה אפשר לציין את השם המלא (killall nodejs) או לעבור להתאמת תבנית חלקית עם pkill node.
טעויות נפוצות
killallתופסת גם שמות חלקיים ועוצרת אחרי ההתאמה הראשונה. התאמה חלקית שייכת ל-pkill, ו-killallשולחת לכל התהליכים בעלי השם המדויק.killallשולחתSIGKILLכברירת מחדל. ברירת המחדל היאSIGTERM; נדרש-9או-KILLכדי לשלוחSIGKILL.killall -9שולחתSIGTERMמנומס או מקפיאה למצבSTOP.-9היא תמידSIGKILLומחסלת מיד בלי לסיים בקשות; הקפאה היא-STOP.killallמקבלת מספרי PID. היא עובדת לפי שם תוכנית מדויק (או-uלמשתמש), לא לפי PID.
בדקו את עצמכם
רצים תהליכים בשם worker-node. מה ההבדל בין killall worker לבין pkill worker?
killall worker לא תמצא התאמה מדויקת ולא תשלח אות; pkill worker תשלח SIGTERM לתהליכי worker-node.
awk: עיבוד טקסט לפי שדות
איך awk עובדת ולמה היא מתאימה
כדי לחלץ עמודה שלישית מלוג או לסנן שורות עם מילת מפתח, awk מפרקת אוטומטית כל שורה לשדות ($1, $2 ועד $NF) ומאפשרת להריץ תנאים וחישובים בפקודה אחת. הכלי קרוי על שם יוצריו - Aho, Weinberger ו-Kernighan - וקיים בלינוקס בכמה מימושים, בהם gawk של GNU, mawk, nawk ו-BusyBox.
# Given events.log: '10 WARN disk', '20 OK mem', '30 WARN net'
awk '/WARN/' events.log # no action -> prints matching lines 1 and 3
awk '{print $3}' events.log # no pattern -> prints field 3 of every lineהתחביר הכללי awk 'pattern { action }' file פועל רשומה אחר רשומה (כברירת מחדל כל שורה היא רשומה): כשהתנאי מתקיים מתבצעת הפעולה, בלי תנאי הפעולה רצה על כל שורה, ובלי פעולה מודפסת השורה כולה.
אין כאן שלב הידור משום ש-awk מפרשת ומריצה מיד, מה שהופך אותה למתאימה במיוחד לקובצי /etc/passwd, CSV ולוגים. כברירת מחדל הפלט יוצא ל-stdout בלי לשנות את הקובץ (עריכה במקום דורשת הרחבה כמו gawk -i inplace), והשורות אינן ממוינות אוטומטית (למיון משתמשים ב-sort).
טעויות נפוצות
awkמעדכנת את קובץ הקלט במקום כברירת מחדל. היא מדפיסה ל-stdout ומשאירה את הקובץ המקורי שלם.awkמקמפלת לקוד מכונה וממיינת את הפלט. היא שפה מפורשת שמעבדת שורות לפי סדר הופעתן בלי למיין.
שדות ומפריד הקלט -F
בכל שורה שנקראת, $0 הוא השורה המלאה, ואילו השדות עצמם ממוספרים מ-1 ($1, $2 וכן הלאה) עד לשדה האחרון $NF ולפניו $(NF-1).
כברירת מחדל הפיצול מתבצע לפי רצפי רווחים וטאבים (תוך התעלמות מרווחים בקצוות השורה). האופציה -F מחליפה את המפריד הזה ובפועל שקולה להשמת BEGIN { FS = "..." }.
| דגל | מפריד | דוגמת שימוש |
|---|---|---|
-F: | נקודתיים | שורות /etc/passwd |
-F, או -F ',' | פסיק | קבצי CSV פשוטים (בלי פסיקים בתוך מירכאות) |
-F'[,:]' | ביטוי רגולרי (פסיק או נקודתיים) | שורות עם מפרידים מעורבים |
חשוב להבחין בין פירוק הקלט לעיצוב הפלט: -F קובעת אך ורק היכן לחתוך את שורת הקלט (שורה ללא המפריד פשוט נשארת בשלמותה ב-$1), ואינה משנה תווים בפלט או כותבת CSV; את המפריד בפלט קובעים בנפרד במשתנה OFS.
בקובץ /etc/passwd שבעה שדות מופרדים בנקודתיים: name:x:UID:GID:comment:home:shell, כאשר x הוא מציין מקום היסטורי לסיסמה. עם -F:, השדה $3 הוא ה-UID ו-$4 הוא ה-GID; בלי -F:, אין רווחים בשורה ולכן הכול נכנס ל-$1 ו-print $3 פולטת שורות ריקות.
# Input: noa:x:1002:1002:Noa:/home/noa:/bin/zsh
awk -F: '{print $3}' users_sample # prints 1002
awk '{print $3}' users_sample # prints blank line ($3 is empty)תרחיש 20: שילוב מפריד רגולרי בקלט עם OFS בפלט
נתונה שורה בקובץ db.txt: host=db1;port=5432. נריץ עליה awk -F'[;=]' -v OFS=' -> ' '{print $2, $4 $1}' db.txt.
הדגל -F'[;=]' מפצל בכל ; ובכל =, וכך נוצרים ארבעה שדות: $1=host, $2=db1, $3=port, $4=5432. בפקודת print, ההצמדה $4 $1 מחברת ישירות ל-5432host בלי רווח, ואילו הפסיק אחרי $2 מכניס את OFS, כך שמתקבל db1 -> 5432host (ובלי -v OFS היה מתקבל רווח: db1 5432host).
טעויות נפוצות
$0הוא השדה הראשון ו-awkמזהה נקודתיים מעצמה.$0הוא כל השורה, ובלי-F:הפירוק הוא לפי רווחים וטאבים.-F ','מחליפה פסיקים ברווחים בפלט, כותבת CSV או מדלגת על שורות בלי פסיק.-Fמשפיעה רק על הקריאה; שורה בלי פסיק היא שדה אחד ($1), והפלט נשלט על ידיOFS.
בדקו את עצמכם
איך מדפיסים את תיקיית הבית ($6) ואת ה-shell (השדה האחרון) מ-/etc/passwd בלי לספור שדות?
awk -F: '{print $6, $NF}' /etc/passwd.
מה תדפיס awk -F';' '{print $2}' על השורה red;green;blue?
green.
משתנים מובנים: NR, FNR, NF, FS, OFS
הטעות הנפוצה ביותר במשתנים של awk היא לבלבל בין NR ל-NF: המשתנה NR סופר רשומות (שורות), ואילו NF סופר שדות בתוך השורה הנוכחית (ולכן $NF ניגש לשדה האחרון). כדי למספר שורות של קובץ מריצים awk '{print NR, $0}'.
במעבר בין כמה קבצים, NR ממשיך לגדול ברצף ואילו FNR מתאפס ל-1 בתחילת כל קובץ. הטבלה מרכזת את המשתנים המובנים המרכזיים:
| משתנה | משמעות | התנהגות |
|---|---|---|
NR | Number of Records | מונה שורות מצטבר מתחילת הריצה (אינו מתאפס בין קבצים) |
FNR | File Number of Records | מונה שורות בתוך הקובץ הנוכחי; מתאפס ל-1 בכל קובץ חדש |
NF | Number of Fields | כמות השדות בשורה הנוכחית |
FS | Field Separator | מפריד הקלט (נקבע גם דרך -F) |
OFS | Output Field Separator | מוכנס במקום פסיק ב-print; ברירת מחדל רווח |
RS / ORS | Record Separators | מפריד רשומות בקלט ובפלט; ברירת מחדל ירידת שורה |
FILENAME | Filename | שם הקובץ שמעובד כרגע |
# NR keeps counting across files; FNR resets at fileB.txt
awk '{print FILENAME, NR, FNR}' fileA.txt fileB.txtfileA.txt 1 1
fileA.txt 2 2
fileB.txt 3 1
fileB.txt 4 2
fileB.txt 5 3awk '{print NR, $0}' items.txtטעויות נפוצות
NRהוא מספר העמודות או מפריד השדות, ומתאפס בכל קובץ. מספר השדות הואNF, מפריד השדות הואFS, וזה שמתאפס לקובץ הואFNR.RSהוא מספר השורות או העמודות.RSהוא תו הפרדת הרשומות בקלט.print NR, $0מדפיסה רק את המספר או רק את השדה האחרון.$0היא השורה כולה, ולכן מודפסים מספר השורה והשורה במלואה.
בדקו את עצמכם
מה תדפיס awk '{print NF}' על השורה north south east west?
4.
איך תדפיסו אך ורק את השורה השמינית בקובץ?
awk 'NR == 8' file.
הפקודה print: פסיק מול הצמדה
כאשר מפרידים ערכים בפסיק בתוך print, awk מכניסה ביניהם את OFS (רווח כברירת מחדל), ואילו ביטויים שכתובים צמוד ללא פסיק מתחברים (concatenation) ישירות בלי שום תו ביניהם. בנוסף, כל פקודת print מסתיימת בירידת שורה (ORS), כך ששתי פקודות print ברצף ייצרו שתי שורות פלט.
| תחביר | מה נכנס בין הערכים | תוצאה על alpha beta gamma |
|---|---|---|
print $1, $2 | OFS (ברירת מחדל רווח) | alpha beta |
print $1 $2 | כלום (הצמדה) | alphabeta |
print $1 " " $2 | מחרוזת רווח מפורשת | alpha beta |
print $1 "-" $3 | המחרוזת "-" | alpha-gamma |
בניגוד ל-print, הפקודה printf עובדת כמו ב-C ואינה מוסיפה ירידת שורה מעצמה. הדגל -v name=val מאפשר להעביר ערכים למשתנים מבחוץ, למשל -v OFS=':'.
תרחיש 21: בחירת התחביר הנכון להדפסת שני שדות עם רווח
כדי להדפיס את $1 ואת $3 עם רווח ביניהם בשורה אחת מקובץ rows.txt, תוכלו לכתוב awk '{print $1 " " $3}' rows.txt או awk '{print $1, $3}' rows.txt (כש-OFS הוא ברירת המחדל).
לעומת זאת, print $1 $3 ידביק אותם בלי רווח, printf "%s %s", $1, $3 ישמיט את ירידת השורה בסוף, ו-print $1 + $3 ינסה לחבר אותם אריתמטית כמספרים.
טעויות נפוצות
print $1 $2מוסיפה רווח או משתמשת ב-OFS. הצמדה ללא פסיק מחברת מחרוזות ישירות;OFSנכנס רק במקום פסיק.- שתי פקודות
printבאותו בלוק מדפיסות באותה שורה. כלprintמוסיפהORS(ירידת שורה) בסופה.
בדקו את עצמכם
מה תדפיס echo 'x y z' | awk -v OFS='/' '{print $3, $1 $2}'?
z/xy.
תנאים: סינון השורות שיעובדו
התנאי נכתב לפני הסוגריים המסולסלים והפעולה בתוכם, ואפשר לחבר תנאים עם &&, || ו-!. אם משמיטים את הסוגריים המסולסלים לגמרי (כגון awk '$1 > 100' file), awk מדפיסה את כל השורה בכל פעם שהתנאי מתקיים.
| תנאי | אילו שורות נבחרות |
|---|---|
/timeout/ | שורות המכילות timeout |
$1 > 100 | שורות שבהן השדה הראשון גדול ממש מ-100 (לא כולל 100) |
$NF > 100 | שורות שבהן השדה האחרון גדול מ-100 |
NR > 100 | שורות מהשורה ה-101 ואילך לפי מיקום בקובץ |
NR == 5 | השורה החמישית בלבד |
$3 == "root" | שורות שהשדה השלישי בהן הוא root |
$2 ~ /^srv/ | השדה השני מתאים לביטוי (!~ בודק אי-התאמה) |
awk '$1 > 100' prices.txt # prints matching lines (excludes 100)
awk -v min=100 '$1 >= min {print $2}' prices.txtטעויות נפוצות
NR > 100בודק את ערך השדה הראשון.NRהוא מספר השורה בקלט, לא תוכן של שדה.$NFהוא השדה הראשון בשורה.$NFהוא השדה האחרון; הראשון הוא$1.$2 > 100בודק את השדה הראשון בשורה. השדות סופרים מ-1, ולכן$2הוא השדה השני; הראשון הוא$1.
בדקו את עצמכם
איך מדפיסים מ-/etc/passwd את שמות המשתמשים שה-UID שלהם 1000 ומעלה?
awk -F: '$3 >= 1000 {print $1}' /etc/passwd.
בלוקים BEGIN, END וסכימת עמודות
לבד מתנאים רגילים, ל-awk יש שני בלוקים מיוחדים: BEGIN שרץ פעם אחת לפני קריאת השורה הראשונה, ו-END שרץ פעם אחת אחרי סיום כל הקלט. משתנה לא מאותחל מתחיל כ-0 בחישוב וכמחרוזת ריקה בהדפסה, ולכן אתחול ב-BEGIN אינו חובה אם כי מוסיף קריאות.
כדי לסכם עמודה שנייה של קובץ CSV צוברים בכל שורה ומדפיסים רק ב-END: awk -F, '{total+=$2} END {print total}' items.csv. גם אם יש שורת כותרת כמו item,amount, המילה amount מתפרשת כ-0 בחיבור מספרי ולא פוגעת בתוצאה.
# Correct CSV column sum
awk -F, '{total += $2} END {print total}' items.csv
# Bug: BEGIN prints blank line before reading input, and -F, is missing
awk '{total += $2} BEGIN {print total}' items.csvהדפסה בתוך BEGIN מתרחשת לפני קריאת שורות ולכן תוציא שורה ריקה, והזרמה ל-wc -l תספור את כמות השורות במקום לסכם מספרים.
תרחיש 22: סכימת השדה הראשון מול וריאציות מטעות
בקובץ orders.txt יש שלוש שורות: 40 apple, 120 banana, 85 cherry. הפקודה awk 'BEGIN {total=0} {total+=$1} END {print total}' orders.txt מסכמת את העמודה הראשונה ומדפיסה 245.
שימו לב למה שמדפיסות פקודות דומות: awk '{print NF + 1}' orders.txt מדפיסה 3 לכל שורה (שני שדות ועוד 1); awk 'END {print $NF}' orders.txt מדפיסה cherry (כי ב-END עדיין שמורה השורה האחרונה); ו-awk '{total+=NF} END {print total}' orders.txt סוכמת את מספר השדות ומדפיסה 6.
תרחיש 23: ספירת שכיחויות עם מערך אסוציאטיבי
כאשר העמודה הראשונה בלוג היא קוד סטטוס (200, 404, 500), מערך אסוציאטיבי סופר כמה פעמים הופיע כל קוד. מכיוון שסדר הלולאה for-in אינו מובטח, נהוג למיין את הפלט:
awk '{freq[$1]++} END {for (code in freq) print code, freq[code]}' access.log | sortלרשותכם ב-awk גם פונקציות מובנות למחרוזות: length, substr, index, split, sub, gsub, toupper ו-tolower.
טעויות נפוצות
- מדפיסים את הסכום בבלוק
BEGIN.BEGINרץ לפני קריאת הקלט; הסכום מוכן רק ב-END. sum += NFסוכמת את הערכים שבעמודה.NFהוא מספר השדות בשורה, לא הערך שבהם.- צינור ל-
wc -lמחבר מספרים או ש--F:מתאים ל-CSV.wc -lסופר שורות, וב-CSV המפריד הוא פסיק (-F,).
בדקו את עצמכם
איך מחשבים ממוצע של העמודה השלישית בקובץ המופרד ברווחים?
awk '{s += $3} END {print s / NR}' file (ב-END המשתנה NR שווה לסך השורות).
grep ו-awk יחד בצינור
חלוקת העבודה בצינור (Pipeline)
נניח שרוצים לשלוף את העמודה הרביעית רק משורות שמופיעה בהן המילה ERROR מתוך קובץ לוג גדול: grep ERROR app.log | awk '{print $4}'. כאן grep קוראת את הקובץ ומסננת שורות, ו-awk מפרקת לשדות רק את השורות שעברו.
הצינור (|) מחבר את הפלט הסטנדרטי של הפקודה הראשונה לקלט הסטנדרטי של השנייה. שתיהן רצות במקביל והנתונים עוברים דרך חוצץ בזיכרון של הקרנל, בלי קובץ ביניים בדיסק. awk אינה פותחת את app.log בכלל: היא קוראת מ-stdin רק את מה ש-grep העבירה לה (ו-grep מצידה אינה מפרקת לשדות).
אפשר אמנם לבצע את הסינון והפירוק יחד בפקודת awk יחידה (awk '/ERROR/ {print $4}' app.log), אך החיבור בצינור עם grep מקובל בזכות פשטות הקריאה שלו.
תרחיש 24: שליפת תיקיית הבית או שם המשתמש מ-/etc/passwd
כל שורה ב-/etc/passwd מורכבת משבעה שדות המופרדים בנקודתיים: name:x:UID:GID:comment:home:shell. אם מריצים grep 'tamar' /etc/passwd | awk -F: '{print $1}', הפקודה grep מעבירה לצינור רק את השורה של tamar, ו-awk -F: חותכת אותה לפי נקודתיים ($1=tamar, $2=x, $3=1003, $4=1003, $5=Tamar, $6=/home/tamar, $7=/bin/bash) ומדפיסה את $1.
grep 'tamar' /etc/passwd | awk -F: '{print $1}' # grep filters, awk extracts field 1
awk -F: '/tamar/ {print $1}' /etc/passwd # equivalent single awk commandטעויות נפוצות
awkמסננת שורות ו-grepמפרקת לעמודות. התפקידים הפוכים:grepמסננת שורות, ו-awkמפרקת לשדות.- הצינור שומר קובץ זמני בדיסק או ששתי הפקודות קוראות את הקובץ בנפרד. המידע זורם בחוצץ זיכרון בקרנל, ו-
awkקוראת רק מהצינור.
בדקו את עצמכם
מה תדפיס grep '/bin/bash' /etc/passwd | awk -F: '{print $6}'?
את תיקיות הבית (השדה השישי) של כל המשתמשים שה-shell שלהם הוא /bin/bash.
סיכום
לסיכום הפרק כולו, הטבלה שלפניכם מארגנת את כל הכלים והכללים החשובים לפי משימות עבודה נפוצות:
| משימה | כלים, דגלים וכללים מרכזיים |
|---|---|
סינון שורות וביטויים (grep) | התאמה: -i התעלמות מרישיות, -v היפוך, -w מילה שלמה, -x שורה שלמה, -f תבניות מקובץ; פלט: -c ספירת שורות (לא הופעות), -n מספרי שורות, -l/-L שמות קבצים עם/בלי התאמה; הקשר וצבע: -A אחרי, -B לפני, -C משני הצדדים, --color=auto רק לטרמינל; רגקס: ^ תחילת שורה, $ סוף שורה, | ליטרלי ב-BRE ואופרטור או ב-ERE (grep -E, egrep) |
תמונת מצב ומעקב חי (ps, top) | ps מציגה צילום רגעי (aux או -ef לכל התהליכים; -u/-U למשתמש; -p ל-PID; -C לשם תוכנית; -o pid= בלי כותרת; --sort=-key יורד ומרובה מפתחות; הורה לפי PPID ו---forest כעץ); top מתעדכנת בזמן אמת (k אות, r nice, M זיכרון, P מעבד, c פקודה מלאה, H תהליכונים, 1 ליבות, u משתמש, f עמודות, q יציאה; -b לפלט טקסט) |
| אותות ומקשי טרמינל | Ctrl+C שולח SIGINT (2), Ctrl+\ שולח SIGQUIT (3, כותב core לפי ulimit -c), Ctrl+Z שולח SIGTSTP (20); SIGTERM (15) ברירת המחדל של kill; SIGKILL (9) ו-SIGSTOP (19) לא ניתנים לתפיסה; SIGCONT (18) ממשיך; SIGHUP (1) טוען הגדרות בדמונים במוסכמה |
| שליחת אותות ואיתור לפי שם | kill מקבלת PID או מזהה עבודה בלבד (kill -0 בודקת קיום והרשאה, תהליך במצב T שומר SIGTERM כממתין עד SIGCONT); pgrep ו-pidof מדפיסות מזהים בלבד; pkill מתאימה תבנית חלקית או -u משתמש; killall דורשת שם מדויק ושולחת SIGTERM כברירת מחדל |
פירוק עמודות ושילוב בצינור (awk + grep) | -F קובע מפריד קלט, $0 שורה שלמה, $NF שדה אחרון, NR סופר שורות מצטבר, FNR מתאפס בכל קובץ, NF כמות שדות בשורה; ב-print פסיק מוסיף OFS והצמדה מחברת ישירות; סיכומים מבצעים ב-END; בצינור grep מסננת שורות ו-awk מעבדת שדות |