பாடம் 2 / 2 · Dynamic Memory · படிக்க 3 min · புதுப்பிக்கப்பட்டது

Memory-ல நடக்கிற நாலு தப்பு

Memory leak, double free, use-after-free, off-by-one — இந்த நாலு பிரச்சினையும் எப்படி வருது, அதை எப்படி avoid பண்ணலாம்.

C-ல வர்ற கிட்டத்தட்ட எல்லா memory bugs-ம் இந்த நாலுல ஏதாவது ஒண்ணா இருக்கும். இதுல எதுவுமே புரிஞ்சுக்க ரொம்ப கஷ்டம் இல்ல; ஆனா அவசரமா code எழுதும்போது, இந்த நாலுல ஏதாவது ஒண்ணை பண்ணிடுறது ரொம்ப easy.

1. Leak

c
void leaky(void)
{
    int *p = malloc(100 * sizeof(int));
    p[0] = 42;
    /* no free — the memory is never given back */
}

அதை ஒரு loop-ல call பண்ணா, machine-ல memory தீரும் வரைக்கும் program வளர்ந்துட்டே இருக்கும். சீக்கிரம் முடியுற program-ல leak இருந்தா பரவாயில்ல; வாரக்கணக்கா ஓடுறதுல leak இருந்தா, அதனால தான் servers நடு ராத்திரில விழுது.

2. Free பண்ணப்புறம் use பண்றது

c
int *p = malloc(sizeof(int));
*p = 5;

free(p);
printf("%d\n", *p);   /* the memory is not yours any more */

/* The fix: make the pointer say so. */
free(p);
p = NULL;              /* now using it crashes loudly */

Note

Free பண்ணினதுக்கப்புறம் அந்த pointer-ஐ NULL-ஆ set பண்ணி வெச்சுக்கலாம். அப்படி பண்ணினா, அமைதியா நடக்குற, எங்கன்னு கண்டுபிடிக்க முடியாத ஒரு bug-ஐ, தப்பு நடக்குற இடத்துக்கு கிட்டத்தட்ட உடனே crash ஆகுற மாதிரி மாத்திடலாம். கண்டுபிடிக்கவே முடியாத memory corruption-ஐ விட, சீக்கிரம் கண்டுபிடிக்கக்கூடிய crash நல்லது.

3. ரெண்டு தடவை free பண்றது

c
free(p);
free(p);   /* corrupts the memory allocator itself */

/* Setting p = NULL after the first free prevents this too:
   free(NULL) is defined to do nothing. */

4. ஒண்ணு தப்பு

c
int *a = malloc(5 * sizeof(int));

for (int i = 0; i <= 5; i++) {   /* <= writes 6 values into room for 5 */
    a[i] = i;
}

for (int i = 0; i < 5; i++) {    /* correct */
    a[i] = i;
}

நாலையும் தடுக்கிற பழக்கங்கள்

  • malloc எழுதின உடனே, அதுக்கான free-யும் முதல்ல எழுதிடுங்க. அப்புறம் நடுவுல தேவையான code-ஐ எழுதிக்கலாம்.
  • free பண்ணின உடனே அந்த pointer-ஐ NULL-ஆ set பண்ணி வெச்சுக்கோங்க.
  • ஒவ்வொரு malloc-ஓட result-ஐயும் use பண்ணுறதுக்கு முன்னாடி NULL-ஆ இருக்கான்னு check பண்ணுங்க.
  • Loop-ல count compare பண்ணும்போது < use பண்ணுங்க; தேவையில்லாம <= use பண்ணாதீங்க.
  • Develop பண்ணும்போது gcc -Wall -fsanitize=address வெச்சு build பண்ணுங்க. Memory leaks, buffer overruns-ஐ கண்டுபிடிச்சு, எந்த line-ல தப்புன்னும் காட்டும்.

free பண்ணப்புறம் pointer-ஐ NULL-ஆ வெக்கிறது எதை தடுக்குது?

இப்பவே try பண்ணுங்க

  1. எத்தனை பேரோட பேரை store பண்ணணும்னு user-கிட்ட கேட்டு, அதுக்கேத்த மாதிரி memory allocate பண்ணி, names-ஐ படிச்சு, print பண்ணி, கடைசில எல்லா memory-யையும் free பண்ற function எழுதுங்க.
  2. gcc -Wall -fsanitize=address வெச்சு build பண்ணி run பண்ணுங்க. Leaks எதுவும் இல்லன்னு காட்டுதான்னு check பண்ணுங்க.
  3. வேணும்னே free-ஐ remove பண்ணிட்டு மறுபடியும் run பண்ணுங்க — தற்செயலா ஒரு leak வர்றதுக்கு முன்னாடியே, leak report எப்படி இருக்கும்னு தெரிஞ்சுக்கோங்க.

Create a free account to save your progress, or sign in.