6.8 דרייברים פתרון

תרגיל 1 - סיור ב/dev/

1-2. זיהוי סוגי התקנים:
- התקני תו (האות c בתחילת שורת הpermissions):
- crw-rw-rw- 1 root root 1, 3 ... /dev/null
- crw-rw-rw- 1 root root 1, 5 ... /dev/zero
- crw-rw-rw- 1 root root 1, 8 ... /dev/random
- התקני בלוק (האות b בתחילה):
- brw-rw---- 1 root disk 8, 0 ... /dev/sda
- brw-rw---- 1 root disk 8, 1 ... /dev/sda1
- brw-rw---- 1 root disk 8, 2 ... /dev/sda2

המספרים שמופיעים במקום גודל הקובץ (למשל 1, 3) הם המספר הראשי (major) והמספר המשני (minor).

/dev/null - major 1, minor 3
/dev/zero - major 1, minor 5
שניהם חולקים major 1 כי שניהם שייכים לאותו דרייבר (mem). הדרייבר משתמש בminor number כדי לדעת איזה התקן ספציפי לטפל בו.

1. ניתוח של /dev/sda*:
2. כולם חולקים major 8 (הדרייבר sd - SCSI/SATA disk)
3. /dev/sda - minor 0 (הדיסק כולו)
4. /dev/sda1 - minor 1 (מחיצה ראשונה)
5. /dev/sda2 - minor 2 (מחיצה שנייה)
6. הminor number מזהה את המחיצה. 0 = הדיסק כולו, 1-15 = מחיצות

---

תרגיל 2 - הבנת קוד הדרייבר

1. כתיבה של יותר מ-1024 בתים:
   בפונקציה dev_write:
   

   if (len > BUF_SIZE) len = BUF_SIZE;
   

   
   השורה הזו קוטמת את האורך ל-1024 (BUF_SIZE). כלומר, רק 1024 הבתים הראשונים יישמרו, והשאר יאבדו. הפונקציה תחזיר 1024 (לא את האורך המקורי), כך שהתוכנה ביוזר תדע שלא כל המידע נכתב.

הערה: בפועל, הsyscall write עשוי לחזור עם ערך קטן מהמבוקש, והתוכנה אמורה לטפל בזה ולנסות שוב. אבל הדרייבר הזה פשטני - הוא תמיד דורס את כל הבאפר, כך שכתיבה חוזרת תדרוס את מה שנכתב קודם.

1. הפוינטר off (offset):
   הoffset מייצג את המיקום הנוכחי בקובץ. כשcat קורא מההתקן, הוא קורא בלולאה - כל קריאה ממשיכה מאיפה שהקודמת הפסיקה.
2. קריאה ראשונה: off=0, קוראת buffer_len בתים, off מתעדכן ל-buffer_len
3. קריאה שנייה: off=buffer_len, הפונקציה רואה ש-off >= buffer_len ומחזירה 0
4. כשread מחזיר 0, cat יודע שהגיע לסוף ועוצר

בלי off, כל קריאה היתה מתחילה מההתחלה, ו-cat היה נתקע בלולאה אינסופית.

1. למה copy_to_user ולא memcpy:
   שלוש סיבות:
2. אבטחה: copy_to_user מוודאת שהכתובת באמת שייכת ליוזר ולא לקרנל. memcpy היתה מאפשרת לתוכנה זדונית לגרום לקרנל לכתוב לזיכרון שלו עצמו.
3. טיפול ב-page faults: הדף של היוזר אולי לא ממופה כרגע (swapped out). copy_to_user יודעת לטפל בpage fault - memcpy בהקשר של קרנל עלולה לגרום לkernel panic.

4. ערך החזרה: copy_to_user מחזירה את מספר הבתים שלא הועתקו. אם ההעתקה נכשלת באמצע, אפשר לדעת כמה הצלחנו.

5. הפרמטר הראשון של register_chrdev:
   כשמעבירים 0, הקרנל מקצה אוטומטית major number פנוי. זו הדרך המומלצת כי אנחנו לא צריכים לדאוג לקונפליקטים עם דרייברים אחרים. אם היינו מעבירים 200, היינו דורשים ספציפית major 200. אם דרייבר אחר כבר תפס את 200, register_chrdev היתה נכשלת ומחזירה שגיאה.

6. open vs release:

7. open נקרא בכל פעם שמישהו עושה syscall open() על ההתקן
8. release נקרא רק כשהfile descriptor האחרון שמצביע על ה-file object נסגר

לדוגמה: אם תהליך פותח את ההתקן ואז עושה dup() או fork(), יש עכשיו כמה file descriptors שמצביעים לאותו file object. release ייקרא רק כשכולם נסגרו. זה חשוב כי בrelease בדרך כלל משחררים משאבים שמשותפים לכל הFDs.

---

תרגיל 3 - major ו-minor בפעולה

1. ניתוח /proc/devices:

2. דרייבר mem (major 1): ההתקנים שמשתמשים בו:

   • /dev/null (minor 3)
   • /dev/zero (minor 5)
   • /dev/full (minor 7)
   • /dev/random (minor 8)
   • /dev/urandom (minor 9)
   • /dev/kmem (minor 2)
   • /dev/mem (minor 1)

3. דרייבר tty: בד"כ עשרות קבצי tty ב/dev/ - /dev/tty0 עד /dev/tty63, /dev/console, /dev/ptmx ועוד.

4. למה null, zero, random חולקים major?
   כולם שייכים לאותו דרייבר (drivers/char/mem.c בקוד המקור של הקרנל). הדרייבר הזה מטפל ב"התקני זיכרון פסאודו" - התקנים שלא מייצגים חומרה אמיתית אלא שירותים של הקרנל.

הדרייבר בודק את הminor number בפונקציות שלו ומחליט מה לעשות:
- minor 3 (null): read מחזיר 0 (EOF), write מצליח ומשליך הכל
- minor 5 (zero): read מחזיר אפסים אינסופיים, write מצליח ומשליך
- minor 8 (random): read מחזיר בתים אקראיים

מבחינת הקרנל, זה יעיל - דרייבר אחד מטפל בכמה התקנים קשורים, במקום לרשום דרייבר נפרד לכל אחד.

---

תרגיל 4 - מעקב אחרי הנתיב בקרנל

הפקודה cat /dev/null:

1. syscalls של cat:
2. open("/dev/null", O_RDONLY) - פתיחת ההתקן לקריאה
3. read(fd, buf, 4096) - ניסיון לקרוא

4. close(fd) - סגירה

5. open בקרנל:

6. הsyscall open מגיע לVFS (מפרק 6.5)
7. הVFS הולך לפי הנתיב "/dev/null" ומוצא את הinode
8. הinode מסומן כ-character device (דגל S_IFCHR)

9. הVFS רואה שזה קובץ התקן ולא קובץ רגיל

10. מציאת הדרייבר:

11. הVFS קורא את הmajor number מהinode (major 1)
12. מחפש בטבלת cdev_map את הדרייבר שרשום ל-major 1
13. מוצא את דרייבר mem ואת הfile_operations שלו
14. מעתיק את הfile_operations לfile object החדש

15. קורא את פונקציית open של הדרייבר

16. read של /dev/null:
    הפונקציה read של null מחזירה 0 מיד. ערך החזרה 0 מread אומר EOF (סוף הקובץ).

17. cat מקבל 0 מread:
    כשread מחזיר 0, cat מבין שהגיע לסוף הקובץ. הוא לא מדפיס כלום (כי לא קרא כלום) וסוגר את הfile descriptor.

הפקודה echo "hello" > /dev/null:

1. syscalls של echo ושל הshell:
2. הshell פותח את /dev/null לכתיבה (O_WRONLY | O_TRUNC)
3. הshell עושה fork+exec ל-echo, כשstdout מנותב ל-/dev/null

4. echo קורא write(1, "hello\n", 6)

5. write בקרנל:

6. הsyscall write מגיע לVFS

7. הVFS קורא את פונקציית write של הדרייבר

8. write של /dev/null:
   הפונקציה מחזירה את len (מספר הבתים שביקשו לכתוב) בלי לעשות כלום עם הנתונים. היא "בולעת" את הכל.

9. echo מקבל 6 מwrite:
   echo חושב שהכתיבה הצליחה (כי הערך שחזר שווה למה שביקש) ומסיים.

---

תרגיל 5 - sysfs וudev

1. התוכן של /sys/class/ משתנה בין מערכות. כמה classes נפוצים:
2. net - ממשקי רשת
3. block - התקני בלוק
4. input - התקני קלט (מקלדת, עכבר)
5. tty - טרמינלים

6. sound - התקני סאונד

7. ניתוח /sys/class/net/:

8. speed - מהירות החיבור ב-Mbps (למשל 1000 ל-Gigabit). לממשק lo (loopback) אין ערך.
9. address - כתובת הMAC של הממשק (למשל 00:11:22:33:44:55). לlo הכתובת היא 00:00:00:00:00:00.

10. operstate - מצב הממשק: up (פעיל), down (כבוי), unknown. ממשק lo בדרך כלל unknown.

11. udevadm monitor:
    כשמחברים USB device, רואים רצף של אירועים:

12. KERNEL events: הקרנל מזהה התקן חדש על אפיק USB ויוצר ייצוג ב-sysfs
13. UDEV events: udev מקבל את האירוע, מחיל חוקים (rules), ויוצר את קובץ ההתקן ב/dev/

כשמנתקים, רואים אירועים הפוכים - הקרנל מסיר את ההתקן מsysfs ו-udev מוחק את הקובץ מ/dev/.

1. יתרון udev על mknod ידני:
2. אוטומטי: udev יוצר ומוחק קבצי התקנים אוטומטית כשחומרה מתחברת/מתנתקת
3. דינמי: לא צריך ליצור מראש קבצים לכל חומרה אפשרית
4. חוקים: אפשר להגדיר כללים מותאמים (למשל "תמיד תן לUSB flash שם /dev/myflash")
5. הרשאות: udev מגדיר הרשאות נכונות אוטומטית לפי חוקים
6. עקביות: major numbers יכולים להשתנות בין גרסאות קרנל. udev מתאים את עצמו אוטומטית