דלגו לתוכן הראשי
גאמא קוד

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 רואה אותם.

Bash
# 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תקלה בהרצה, למשל קובץ שלא נמצא או חוסר הרשאה
Bash
# 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.

Bash
ps -eo args | grep -c quietd     # service is down
ps -eo args | grep quietd
ps -eo args | grep -c '[q]uietd'
pgrep -c quietd
פלט
1
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 מחמיר בהרבה ומחייב שהשורה כולה תהיה זהה לתבנית.

Bash
# 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:

Bash
grep -nv '^#' crontab.txt
פלט
2: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). קודם מבקשים את השורות עצמן עם מיקומן:

Bash
grep -n legacy *.cfg
פלט
a.cfg:2:legacy=on
c.cfg:1:legacy=off
c.cfg:2:legacy_x=1

בחיפוש על כמה קבצים כל שורה מקבלת קודם את שם הקובץ ואז את מספר השורה, והקובץ c.cfg מופיע פעמיים כי שתי שורות בו מתאימות. כשרק רשימת הקבצים חשובה, -l מקצרת את הפלט, ו--L מחזירה את המשלים:

Bash
grep -l legacy *.cfg
grep -L legacy *.cfg
פלט
a.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 מקבל מספר, אבל המספר עונה על שאלה אחרת: כמה שורות מכילות את התבנית, ולא כמה פעמים היא נכתבה.

Bash
# 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 -l
פלט
2
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, וההתראה אף פעם לא יוצאת:

Bash
grep -l 'denied' gate.log | wc -l
grep -c 'denied' gate.log
פלט
1
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 NBeforeN שורות שלפני השורה המתאימה
-A NAfterN שורות שאחרי השורה המתאימה
-C NContextN שורות לפני ו-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. נתחיל משורה אחת אחרי כל אזהרה:

Bash
grep -A1 WARN batch.log
פלט
WARN slow disk
sync
--
WARN retry
exit

כל התאמה קיבלה שורת הקשר משלה, ו-sync done עם compact נשארו בחוץ, ולכן GNU grep הפרידה בין שני הבלוקים בשורת --. עכשיו שורה מכל צד, ואחר כך שתיים מכל צד:

Bash
grep -C1 WARN batch.log
פלט
load users
WARN slow disk
sync
--
compact
WARN retry
exit
Bash
grep -C2 WARN batch.log
פלט
init
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:

Bash
grep 'a+b' ver.txt
פלט
a+b
Bash
grep -E 'a+b' ver.txt
פלט
aab
Bash
grep 'a.b' ver.txt
grep -F 'a.b' ver.txt
פלט
a+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 הן המבחן האמיתי. הנה שתי הרצות:

Bash
grep 'cat|dog' tags.txt
פלט
cat|dog
Bash
grep -E 'cat|dog' tags.txt
פלט
cat
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 שמראה תווי בקרה בגלוי:

Bash
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 auxa: כל המשתמשים עם טרמינל; 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 שתפח. נבחן את הצעדים לפי הסדר, כולל נסיון שנכשל בדרך:

  1. מנסים ps בלי דגלים ומקבלים רק את המעטפת ואת ps עצמה. indexer רץ כשירות רקע, ו-ps מוגבלת לטרמינל ולמשתמש שלכם, ולכן הוא לא מופיע.
  2. עוברים ל-ps aux: עכשיו רואים גם שירותים ללא טרמינל, וב-%MEM וב-RSS מזהים ש-indexer (נניח PID 7301) תופס הרבה.
  3. רוצים לדעת מי הפעיל אותו, אבל ל-ps aux אין עמודת PPID. מריצים ps -ef ובשורה של 7301 קוראים את מזהה האב, נניח 7188.
  4. אחרי דקה חוזרים לבדוק אם הוא עדיין תפוח: צריך להריץ שוב, כי הצילום הקודם לא התעדכן.
טעויות נפוצות
  • 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: הסדר התהפך, ואף שורה לא נעלמה.

Bash
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 אפשר לתת רשימת מפתחות מופרדת בפסיקים, ולכל מפתח כיוון משלו: מינוס פירושו סדר יורד, וחוסר סימן או + פירושו סדר עולה. המפתח השני נכנס לפעולה רק כשיש שוויון במפתח הראשון, ואז הוא מסדר בין השורות השוות בלבד ואינו מערבב מחדש את הטבלה כולה.

Bash
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: קבוצות לפי משתמש ושובר שוויון בתוכן

חמישה תהליכים פועלים ברגע ההרצה, עם הערכים הבאים:

USERPIDRSS
dev3104000
ann4509000
dev32012000
ann4602000
root1800
Bash
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 הדפיסה את הרשימה הבאה (דוגמה לצורך התרגול):

Text
  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:

Bash
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 sleep
פלט
STAT  NI COMMAND
S+     0 sleep
SN+    5 sleep
  • S+: האות S אומרת שינה רגילה, והתו + אומר שהתהליך בקבוצת החזית של הטרמינל.
  • SN+: אותו תהליך, אך התו N מצביע על עדיפות נמוכה (ה-NI שלו הוא 5).
  • תווים נוספים: s מוביל סשן (כמו Ss של systemd), l תוכנית מרובת-תהליכונים (Ssl) ו-< עדיפות גבוהה (S<).
חזרה לתוכן העניינים

top: תצוגה חיה של התהליכים

מה top מציג

בניגוד ל-ps שמדפיסה צילום רגעי ונסגרת, top פותחת מסך ניטור אינטראקטיבי שמתעדכן אוטומטית (כל 3 שניות כברירת מחדל). כברירת מחדל מוצגים כל התהליכים במערכת ממוינים לפי %CPU (הכלי htop הוא תוכנית נפרדת וצבעונית יותר שאינה מותקנת תמיד).

את ראש המסך קוראים שורה אחר שורה. זה צילום אמיתי של חמש השורות הראשונות במכונה עם שמונה ליבות (nproc מדפיסה את מספר הליבות, והדגל -b מדפיס טקסט פשוט ויוסבר בסוף הנושא):

Bash
nproc
top -b -n 1 | head -5
פלט
8
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, TP לפי %CPU (ברירת מחדל); M לפי %MEM; N לפי PID; T לפי זמן מעבד מצטבר (TIME+).
מתגי תצוגהc, H, 1c מחליפה בין שם תוכנית לשורת פקודה מלאה; H מפצלת לשורה לכל תהליכון (thread); 1 מפצלת את %Cpu לשורה לכל ליבה.
סינון ועמודותu, f, d / s, Wu סינון לפי משתמש; f מסך ניהול שדות (בחירת עמודות, סידורן ושדה מיון); d/s שינוי קצב רענון; W שמירת הגדרות (~/.toprc או ~/.config/procps/toprc).
פעולה ויציאהk, r, h, qk שליחת אות לתהליך לפי 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, היא נכשלת עם שגיאה:

Bash
top -n 1 | head -3     # run without a terminal, as cron would
פלט
top: failed tty get

הדגל -b (batch mode) מבטל את הציור ושולח טקסט פשוט לפלט הסטנדרטי, שאפשר להפנות לקובץ או לצינור. בלי הגבלה top -b ממשיכה להדפיס רענון אחרי רענון עד שעוצרים אותה, ולכן מוסיפים -n N למספר הדגימות ולעיתים -d SECONDS למרווח ביניהן; ומכיוון שאין קלט מקשים, אי אפשר מתוכה לשנות nice או לשלוח אות.

Bash
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.

אותמספרשולח אופייניברירת מחדל ומשמעות
SIGTERM15kill ללא דגליםבקשה מסודרת לסיום; התוכנית יכולה ללכוד ולבצע ניקוי
SIGINT2Ctrl+Cהפרעה (interrupt) מהמקלדת; מסיים כברירת מחדל
SIGQUIT3Ctrl+\מסיים ושומר תמונת זיכרון (core) אם המגבלה מאפשרת
SIGKILL9kill -9סיום מיידי בידי הקרנל; בלתי ניתן ללכידה או חסימה
SIGSTOP19kill -STOPהקפאה כפויה של התהליך; בלתי ניתן ללכידה או חסימה
SIGTSTP20Ctrl+Zבקשת עצירה מהטרמינל; התוכנית רשאית לטפל בה
SIGCONT18fg, bg, kill -CONTמחזיר לריצה תהליך שנעצר
SIGHUP1ניתוק טרמינל, kill -HUPמסיים תהליך רגיל; בדמונים מקובל לטעון מחדש תצורה
SIGUSR1 / SIGUSR210 / 12kill -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).

Bash
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.

Bash
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).

Bash
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.

Bash
# 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. אם התוכנית לוכדת את האות או מתעלמת ממנו, לא יהיה לא סיום ולא קובץ.

Bash
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:

Bash
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 מאשר שהתהליך קיים ומותר לאותת לו, וערך אחר פירושו שאין תהליך כזה או שאין הרשאה. כך סקריפטים בודקים חיות של תהליך (או של המעטפת עצמה דרך $$).

Bash
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 תחזיר לרוב דווקא את התהליך החדש ביותר.

Bash
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 מיידי לכל המופעים.

Bash
killall -9 haproxy     # force-kill every process named exactly haproxy
killall -u tamar       # send SIGTERM to all processes owned by tamar
במערכות UNIX ותיקות כגון Solaris, הפקודה killall מחסלת את כלל התהליכים במערכת, ולכן היא אינה נחשבת ניידת.
תרחיש 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.

Bash
# 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 פולטת שורות ריקות.

Bash
# 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 בתחילת כל קובץ. הטבלה מרכזת את המשתנים המובנים המרכזיים:

משתנהמשמעותהתנהגות
NRNumber of Recordsמונה שורות מצטבר מתחילת הריצה (אינו מתאפס בין קבצים)
FNRFile Number of Recordsמונה שורות בתוך הקובץ הנוכחי; מתאפס ל-1 בכל קובץ חדש
NFNumber of Fieldsכמות השדות בשורה הנוכחית
FSField Separatorמפריד הקלט (נקבע גם דרך -F)
OFSOutput Field Separatorמוכנס במקום פסיק ב-print; ברירת מחדל רווח
RS / ORSRecord Separatorsמפריד רשומות בקלט ובפלט; ברירת מחדל ירידת שורה
FILENAMEFilenameשם הקובץ שמעובד כרגע
Bash
# NR keeps counting across files; FNR resets at fileB.txt
awk '{print FILENAME, NR, FNR}' fileA.txt fileB.txt
פלט
fileA.txt 1 1
fileA.txt 2 2
fileB.txt 3 1
fileB.txt 4 2
fileB.txt 5 3
Bash
awk '{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, $2OFS (ברירת מחדל רווח)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/השדה השני מתאים לביטוי (!~ בודק אי-התאמה)
Bash
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 בחיבור מספרי ולא פוגעת בתוצאה.

Bash
# 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 אינו מובטח, נהוג למיין את הפלט:

Bash
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.

Bash
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 מעבדת שדות