דליפות זיכרון ב-C: איך הן קורות ואיך מוצאים אותן

דליפת זיכרון היא לא זיכרון שנעלם. זה זיכרון שעדיין שלכם, עדיין שמור, ושאיבדתם את היכולת להחזיר אותו, כי המצביע האחרון אליו נעלם. שום דבר לא קורס. התוכנית ממשיכה לרוץ, קצת יותר כבדה בכל פעם, עד שבסוף משהו נכשל במקום שנראה לא קשור.

העמוד הזה מכסה איך דליפות נוצרות, את המשמעת שמונעת את רובן, ואת שני הכלים שמוצאים את השאר.

איך נראית דליפה

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    for (int i = 0; i < 3; i++) {
        int *block = malloc(1000 * sizeof *block);
        if (block == NULL) {
            return 1;
        }
        block[0] = i;
        printf("pass %d wrote %d\n", i, block[0]);
        /* אין free: כל סבב נוטש 4000 בתים */
    }

    printf("done (3 blocks leaked)\n");
    return 0;
}

כל איטרציה דורסת את block עם מצביע חדש. הבלוק הקודם עדיין מוקצה; אף משתנה לא מחזיק את הכתובת שלו; אי אפשר לשחרר אותו לעולם. שלוש איטרציות מאבדות שנים עשר קילובייט. שרת שעושה את זה פעם בכל בקשה מאבד את הזיכרון לתמיד, בכל קצב שבו הבקשות מגיעות.

התיקון הוא שורה אחת, free(block); בסוף הגוף, אבל לזהות איפה היא צריכה להיות זו המיומנות האמיתית.

איך דליפות קורות

1. המצביע האבוד

כל השמה למצביע שעדיין מחזיק את ההפניה היחידה לבלוק חי מדליפה אותו.

char *name = malloc(32);
name = malloc(64);     /* 32 הבתים הראשונים כבר לא נגישים */

הלולאה למעלה היא אותו באג בתחפושת של לולאה. כך גם השמה מחדש לשדה של struct, וכך גם הקיצור של realloc מהעמוד על calloc ו-realloc:

p = realloc(p, n);     /* בכישלון: p הופך ל-NULL, הבלוק הישן נשאר יתום */

2. היציאה המוקדמת

כל מסלול החוצה מפונקציה חייב לשחרר את מה שהפונקציה כבר לקחה. זה שנשכח הוא תמיד מסלול שגיאה.

#include <stdio.h>
#include <stdlib.h>

/* באג: מסלול הכישלון השני מדליף את 'a' */
int broken(int n) {
    int *a = malloc((size_t)n * sizeof *a);
    if (a == NULL) {
        return 0;
    }

    int *b = malloc((size_t)n * sizeof *b);
    if (b == NULL) {
        return 0;          /* 'a' עדיין מוקצה ועכשיו לא נגיש */
    }

    for (int i = 0; i < n; i++) {
        a[i] = i;
        b[i] = i * i;
    }
    int total = a[n - 1] + b[n - 1];

    free(a);
    free(b);
    return total;
}

int main(void) {
    printf("%d\n", broken(5));
    return 0;
}

המסלול השמח נכון ומסלול השגיאה דולף, ולכן זה שורד בדיקות: הענף שנכשל כמעט אף פעם לא רץ בזמן הפיתוח. התיקון הוא אזור ניקוי אחד שכל מסלול קופץ אליו:

#include <stdio.h>
#include <stdlib.h>

int fixed(int n) {
    int *a = NULL;
    int *b = NULL;
    int total = 0;

    a = malloc((size_t)n * sizeof *a);
    if (a == NULL) {
        goto cleanup;
    }

    b = malloc((size_t)n * sizeof *b);
    if (b == NULL) {
        goto cleanup;
    }

    for (int i = 0; i < n; i++) {
        a[i] = i;
        b[i] = i * i;
    }
    total = a[n - 1] + b[n - 1];

cleanup:
    free(a);       /* free(NULL) מוגדר כפעולה שלא עושה כלום */
    free(b);
    return total;
}

int main(void) {
    printf("%d\n", fixed(5));
    return 0;
}

זה השימוש היחיד ב-goto שמתכנתי C מנוסים ממליצים עליו באופן פעיל. זה עובד כי כל מצביע מתחיל ב-NULL ו-free(NULL) לא עושה כלום, כך שבלוק יציאה אחד נכון לא משנה עד כמה רחוק הפונקציה הגיעה.

3. בעלות לא ברורה

הדליפות העדינות ביותר הן בכלל לא שגיאות קוד: אלה שתי פונקציות שלא מסכימות על מי התפקיד.

char *build_message(void);   /* האם הקוראת משחררת את זה? */
void  store(char *text);     /* האם store לוקחת בעלות? */

אם build_message מחזירה זיכרון מוקצה ו-store מעתיקה אותו, הקוראת חייבת לשחרר. אם store שומרת את המצביע, הקוראת אסור לה לשחרר. שום דבר בקוד לא אומר מה נכון, כך שאחת משתי ההנחות נעשית פעמיים, ומקבלים או דליפה או double free.

התרופה היא מוסכמה, שנכתבת בהערה ליד כל פונקציה שמקצה:

/* מחזירה מחרוזת חדשה שהוקצתה; הקוראת חייבת לשחרר אותה. */
char *build_message(void);

/* לוקחת בעלות על 'text'; היא תשוחרר על ידי store_free(). */
void store(char *text);

כתבו את הכלל ליד הפונקציה, לא במסמך עיצוב. זה ההרגל בעל הערך הגבוה ביותר בניהול זיכרון ב-C.

משמעת הבעלות

ארבעה כללים מכסים כמעט הכול:

1. לכל הקצאה יש בעלים אחד בדיוק: קטע קוד אחד שאחראי לשחרר אותה.
2. צמדו לכל פונקציה שמקצה פונקציה שמשחררת. vec_init / vec_free, config_load / config_free. הסימטריה הופכת קריאה חסרה לגלויה.
3. שחררו באותה שכבה שהקצתה, אלא אם ההערה של הפונקציה מעבירה בעלות במפורש.
4. הציבו NULL במצביע אחרי ששחררתם אותו, כך ששימוש מקרי מאוחר יותר יקרוס במקום התקלה במקום להשחית את ה-heap בשקט.

מציאת דליפות: valgrind

ב-Linux, valgrind לא דורש קומפילציה מחדש, אם כי סמלי debug הופכים את הדוח לקריא:

gcc -g -O0 program.c -o program
valgrind --leak-check=full --show-leak-kinds=all ./program

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

==12345== HEAP SUMMARY:
==12345==     in use at exit: 12,000 bytes in 3 blocks
==12345==   total heap usage: 3 allocs, 0 frees, 12,000 bytes allocated
==12345==
==12345== 12,000 bytes in 3 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2FB0F: malloc (vg_replace_malloc.c:299)
==12345==    by 0x108671: main (program.c:6)
==12345==
==12345== LEAK SUMMARY:
==12345==    definitely lost: 12,000 bytes in 3 blocks

קראו אותו מלמטה. "definitely lost" פירושו שלא היה שום מצביע לבלוק ביציאה: דליפה אמיתית. ה-stack trace מציין את השורה של ה-malloc שיצר אותו, לא את השורה שבה הוא אבד, ובדרך כלל זה מספיק כדי למצוא את ה-free החסר.

מופיעות עוד שתי קטגוריות:

• indirectly lost: בלוקים שאפשר להגיע אליהם רק דרך בלוק שבעצמו אבד, כמו האיברים של רשימה מקושרת שדלפה. תקנו את ה-"definitely lost" והם ייעלמו.
• still reachable: מוקצים ביציאה אבל עם מצביע חי, בדרך כלל cache גלובלי. לא דליפה במובן המסוכן, אבל שווה לשחרר אותם כדי שהדוח יישאר ריק.

valgrind תופס גם קריאות של זיכרון לא מאותחל וכתיבות מעבר לסוף של בלוק, ולעתים קרובות כך מגלים את הבאג שמאחורי הדליפה.

מציאת דליפות: AddressSanitizer

AddressSanitizer מובנה ב-GCC וב-Clang, רץ הרבה יותר מהר מ-valgrind ועובד במקומות שבהם valgrind לא עובד (כולל macOS עדכני):

gcc -g -fsanitize=address -fno-omit-frame-pointer program.c -o program
./program

דוח הדליפות מודפס אוטומטית ביציאה:

=================================================================
==12345==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 12000 byte(s) in 3 object(s) allocated from:
    #0 0x7f... in malloc
    #1 0x1086... in main program.c:6

SUMMARY: AddressSanitizer: 12000 byte(s) leaked in 3 allocation(s).

ASan גם הופך use-after-free ו-heap buffer overflow לעצירות מיידיות עם תיאור ברור, במקום השחתה מסתורית מאוחר יותר. בנו את הרצות הבדיקה איתו; בנו גרסאות release בלעדיו, כי הוא עולה בזיכרון ובמהירות.

אם זיהוי הדליפות לא מופעל בפלטפורמה שלכם, הגדירו ASAN_OPTIONS=detect_leaks=1 בסביבה לפני ההרצה.

תיקון תוכנית דולפת צעד אחר צעד

הנה תוכנית קטנה עם שלוש דליפות נפרדות:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *shout(const char *text) {
    size_t len = strlen(text);
    char *out = malloc(len + 1);
    if (out == NULL) {
        return NULL;
    }
    for (size_t i = 0; i < len; i++) {
        out[i] = (char)(text[i] - 32 * (text[i] >= 'a' && text[i] <= 'z'));
    }
    out[len] = '\0';
    return out;
}

int main(void) {
    /* דליפה 1: התוצאה של shout אף פעם לא משוחררת */
    printf("%s\n", shout("hello"));

    /* דליפה 2: buf נדרס, והבלוק הראשון אובד */
    char *buf = malloc(16);
    buf = malloc(32);
    strcpy(buf, "second block");
    printf("%s\n", buf);
    free(buf);

    /* דליפה 3: היציאה המוקדמת מדלגת על ה-free */
    int *nums = malloc(4 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    nums[0] = 1;
    if (nums[0] != 0) {
        printf("bailing out\n");
        return 0;
    }
    free(nums);
    return 0;
}

valgrind מדווח על שלוש רשומות "definitely lost" עם שלושה מספרי שורות שונים. מתוקנות אחת אחת:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* מחזירה מחרוזת חדשה שהוקצתה; הקוראת חייבת לשחרר אותה. */
char *shout(const char *text) {
    size_t len = strlen(text);
    char *out = malloc(len + 1);
    if (out == NULL) {
        return NULL;
    }
    for (size_t i = 0; i < len; i++) {
        out[i] = (char)(text[i] - 32 * (text[i] >= 'a' && text[i] <= 'z'));
    }
    out[len] = '\0';
    return out;
}

int main(void) {
    /* תיקון 1: מחזיקים את המצביע, משתמשים בו, משחררים אותו */
    char *loud = shout("hello");
    if (loud == NULL) {
        return 1;
    }
    printf("%s\n", loud);
    free(loud);

    /* תיקון 2: הקצאה אחת, בגודל הנכון כבר בפעם הראשונה */
    char *buf = malloc(32);
    if (buf == NULL) {
        return 1;
    }
    strcpy(buf, "second block");
    printf("%s\n", buf);
    free(buf);
    buf = NULL;

    /* תיקון 3: כל מסלול יציאה משחרר */
    int *nums = malloc(4 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    nums[0] = 1;
    if (nums[0] != 0) {
        printf("bailing out\n");
        free(nums);
        return 0;
    }
    free(nums);
    return 0;
}

תיקון 1 הוא הערת הבעלות שהפכה למציאות: shout מקצה, main משחררת. תיקון 2 מסיר את ההקצאה הכפולה לגמרי במקום לשחרר את הראשונה: הקוד הפשוט יותר הוא גם הקוד הנכון. תיקון 3 מוסיף את ה-free החסר ביציאה המוקדמת; כשיש יותר הקצאות, התווית היחידה cleanup: שהוצגה קודם מתרחבת טוב יותר מחזרה על ה-free.

הרגלים שמונעים דליפות

• כתבו את ה-free מיד אחרי שכתבתם את ה-malloc, ואז מלאו את הקוד שביניהם.
• תנו לכל פונקציה שמקצה פונקציית שחרור תואמת.
• ציינו בעלות בהערה על כל פונקציה שמחזירה או מקבלת מצביע שהיא הקצתה.
• השתמשו בבלוק יציאה אחד cleanup: בפונקציות שמחזיקות כמה הקצאות.
• הריצו את הבדיקות שלכם תחת -fsanitize=address כדבר שבשגרה, לא רק כשמשהו נראה לא בסדר.
• התייחסו ל-"definitely lost: 0 bytes" כחלק מהרצת בדיקות שעוברת.