C “free(): double free detected in tcache 2” hatası, malloc() ile ayrılan aynı bellek bloğuna free() fonksiyonunun ikinci kez uygulanmasıyla oluşur. Çözüm için her dinamik bellek bloğunun sahipliğini belirlemek, bloğu hangi fonksiyonun serbest bırakacağını netleştirmek ve aynı bloğa yalnızca bir kez free() uygulamak gerekir.
Hatalı programı Linux ve gcc ortamında çalıştırırken belirli bir hata mesajı ya da sonlanma biçimi beklenmemelidir. Bu davranış tanımsızdır. Aşağıdaki örnek, hatanın nasıl oluştuğunu ve sahiplik main fonksiyonunda bırakıldığında nasıl düzeltileceğini gösterir.
Double free hatası neden oluşur?

Double free hatası, daha önce free() ile serbest bırakılmış aynı bellek bloğuna tekrar free() uygulanması nedeniyle oluşur. İşaretçi, bir bellek adresini tutan değişkendir. Heap, program çalışırken malloc() gibi işlevlerle dinamik bellek ayırmak için kullanılan alandır. Serbest bırakma ise artık kullanılmayan bloğun yeniden kullanılabilmesi için bellek yöneticisine iade edilmesidir.
Bir malloc() çağrısı başarılı olduğunda elde edilen bloğun sorumluluğu bir fonksiyonda veya belirli bir veri yapısında tutulmalıdır. Blok kullanılmayı bıraktığında bu sorumluluğa sahip olan kod onu bir kez serbest bırakır. Aynı adresi tutan başka bir işaretçinin bulunması, ikinci işaretçiye de free() uygulama hakkı vermez. İki işaretçi aynı adresi gösteriyorsa, ikisi de aynı heap bloğuna ulaşır.
Mesajdaki tcache ifadesi, GNU C Library içindeki malloc uygulamasının bazı küçük bellek bloklarını iş parçacığına ait önbellekte takip etmesiyle ilişkilidir. Bu yapı, bir bloğun daha önce serbest bırakılmış olabileceğini belirlemek için kullanılır. İlgili denetimin GNU C Library malloc kaynak kodundaki uygulamasını inceleyebilirsin: GNU C Library malloc kaynak kodu.
Hata mesajının tam biçimi kullanılan işletim sistemine, bellek ayırıcısına, çalışma ortamına ve programın o sırada oluşturduğu bellek düzenine göre değişebilir. Mesaj hiç görünmeden programın farklı davranması da mümkündür. Hata mesajını görmemek, kodun doğru olduğu anlamına gelmez; ikinci free() çağrısı yine tanımsız davranıştır. Çift serbest bırakma bellek bozulmasına ve bazı durumlarda güvenlik açıklarına yol açabileceği için, mesajı bastırmak yerine sahiplik hatasının düzeltilmesi gerekir.
Yardımcı fonksiyonda serbest bırakılan dizi nasıl düzeltilir?
Dizi main() içinde ayrıldıysa, sahipliği main fonksiyonunda bırakmak ve yardımcı fonksiyonun yalnızca diziyi kullanmasını sağlamak güvenli bir düzen oluşturur. Bir işaretçinin yardımcı fonksiyona parametre olarak gönderilmesi, belleğin sahipliğini kendiliğinden o fonksiyona devretmez.
Hatalı sahiplik akışı
Aşağıdaki programda yardımcı fonksiyon diziyi serbest bırakıyor. main() fonksiyonu ise aynı işaretçiyle tekrar free() çağırıyor.
#include <stdio.h>
#include <stdlib.h>
void diziyi_kullan_ve_serbest_birak(int *dizi)
{
printf("%dn", dizi[0]);
free(dizi);
}
int main(void)
{
int *dizi = malloc(3 * sizeof *dizi);
if (dizi == NULL) {
return 1;
}
dizi[0] = 10;
dizi[1] = 20;
dizi[2] = 30;
diziyi_kullan_ve_serbest_birak(dizi);
free(dizi);
return 0;
}
Bu dosyayı double_free.c adıyla kaydedip Linux üzerinde gcc ile derlemek için şu komutları kullanabilirsin:
gcc -std=c17 -Wall -Wextra -pedantic -g double_free.c -o double_free
./double_free
Programın ilk free() çağrısından sonra dizi artık geçerli bir dinamik bellek bloğunu göstermemektedir. Hatalı program için belirli bir çıktı, glibc hata mesajı veya normal sonlanma biçimi vaat edilemez. Bazı ortamlarda free(): double free detected in tcache 2 benzeri bir mesaj görülebilir, ancak bu mesajın görünmemesi hatayı ortadan kaldırmaz.
Sahipliği main fonksiyonunda bırakan sürüm
Düzeltilmiş sürümde yardımcı fonksiyon dizinin içeriğini kullanır, fakat belleği serbest bırakmaz. Bloğun yaşam döngüsünü başlatan main() fonksiyonu, sonlandırma sorumluluğunu da üstlenir.
#include <stdio.h>
#include <stdlib.h>
void diziyi_kullan(const int *dizi)
{
printf("%dn", dizi[0]);
}
int main(void)
{
int *dizi = malloc(3 * sizeof *dizi);
if (dizi == NULL) {
return 1;
}
dizi[0] = 10;
dizi[1] = 20;
dizi[2] = 30;
diziyi_kullan(dizi);
free(dizi);
return 0;
}
Bu sürümü fixed.c adıyla kaydedip şu komutlarla derleyebilirsin:
gcc -std=c17 -Wall -Wextra -pedantic -g fixed.c -o fixed
./fixed
Bu düzeltilmiş kodun akışından çıkarılabilen çıktı 10 satırıdır. Bellek yalnızca main() içinde ve tek bir noktada serbest bırakıldığı için aynı blok üzerinde ikinci bir free() çağrısı yapılmaz.
İşaretçi paylaşımı ve NULL kullanımı hangi riskleri taşır?

İşaretçi paylaşımı, iki işaretçinin aynı heap bloğunu göstermesiyle oluşur. Heap, çalışma sırasında malloc gibi işlevlerle ayrılan dinamik bellek alanıdır; işaretçi bu alanın adresini tutan değişkendir. Serbest bırakma ise artık kullanılmayan bloğu free() ile bellek yöneticisine geri vermektir. İşaretçilerden biri serbest bırakıldığında diğer işaretçinin değeri kendiliğinden değişmez, fakat gösterdiği blok artık geçerli değildir.
İşaretçi alanı içeren bir struct sıradan atamayla kopyalandığında gösterilen verinin yeni bir kopyası oluşturulmaz. Yalnızca işaretçi değeri kopyalanır. Bu nedenle iki yapı aynı heap bloğunu paylaşabilir.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char *text;
} Note;
int main(void) {
Note first = { malloc(6) };
if (first.text == NULL) {
return 1;
}
strcpy(first.text, "hello");
Note second = first;
printf("%pn", (void *)first.text);
printf("%pn", (void *)second.text);
free(first.text);
first.text = NULL;
/* second.text artık serbest bırakılmış bloğu gösteriyor. */
second.text = NULL;
free(second.text);
return 0;
}
Bu program Linux ve gcc ile çalıştırıldığında iki adresin aynı olduğunu görmelisin. Adresin kendisi her çalıştırmada veya farklı sistemlerde değişebilir. first.text NULL yapıldığında second.text otomatik olarak NULL olmaz; ikinci işaretçiyi ayrıca etkisiz hâle getirmek gerekir.
Serbest bırakma işleminden hemen sonra ilgili işaretçiyi NULL yapmak, aynı değişken üzerinden yapılabilecek ikinci bir free() çağrısını güvenli hâle getirir. free(NULL) çağrısında işlem yapılmaz. Ancak başka bir kopya aynı adresi tutuyorsa yalnızca bir işaretçiyi NULL yapmak sorunu çözmez. Serbest bırakılmış belleği okumaktan, üzerine yazmaktan veya başka bir işaretçi üzerinden yeniden serbest bırakmaktan kaçınmalısın.
Bellek sahipliği nasıl belirlenir ve hata nasıl bulunur?
Bellek sahipliği, bir bloğu hangi kod parçasının serbest bırakacağını açıkça belirleyen bir arayüz sözleşmesiyle yönetilir. Bu sözleşme yazılmadığında çağıran ve çağrılan fonksiyon aynı bloğu serbest bırakabilir veya free() sonrasında işaretçiyi kullanabilir.
- Fonksiyon açıklamasında verilen işaretçinin yalnızca ödünç alındığını ve fonksiyon tarafından serbest bırakılmayacağını belirt.
- Sahiplik devrediliyorsa çağıranın bloğu kullanmayacağını ve serbest bırakmayacağını açıkça yaz.
- Fonksiyon bir işaretçi döndürüyorsa, dönen bloğu kimin ve hangi noktada serbest bırakacağını belirle.
- Bir
structkopyalandığında işaretçi alanlarının aynı bloğu paylaşabileceğini kontrol et. free()sonrasında ilgili işaretçiyi NULL yap ve aynı bloğu gösteren diğer işaretçileri ayrıca yönet.- Aynı bloğun hem çağıran hem de çağrılan fonksiyon tarafından serbest bırakılmasına izin verme.
Hatayı izole etmek için önce küçük bir test dosyası oluşturabilirsin:
#include <stdlib.h>
int main(void) {
char *p = malloc(16);
if (p == NULL) {
return 1;
}
free(p);
free(p);
return 0;
}
Dosyayı double_free.c adıyla kaydettikten sonra hata ayıklama bilgisi içeren normal derlemeyi yap:
gcc -std=c17 -Wall -Wextra -g -O0 -o double_free double_free.c
Ardından programı Valgrind Memcheck altında çalıştır:
valgrind --tool=memcheck --leak-check=full ./double_free
Valgrind Memcheck kılavuzu, hatalı serbest bırakma ve serbest bırakılmış belleğe erişim gibi durumların raporlanabildiğini açıklar. Raporun serbest bırakma hatasını bildiren bölümünde mevcut free() çağrısının yığını, daha önceki serbest bırakma konumu ve bloğun ayrıldığı malloc() konumu aranır. -g seçeneği sayesinde bu bilgiler mümkün olduğunda kaynak dosyadaki satırlarla eşleştirilir.
GCC ile AddressSanitizer kullanmak için programı şu seçeneklerle yeniden derleyebilirsin:
gcc -std=c17 -Wall -Wextra -g -O0
-fsanitize=address -fno-omit-frame-pointer
-o double_free_asan double_free.c
./double_free_asan
-fsanitize=address bellek erişimlerini izlemek için derleyici enstrümantasyonu ekler. -g, -O0 ve -fno-omit-frame-pointer seçenekleri hata raporundaki çağrı yığınlarını kaynak kodla eşleştirmeyi kolaylaştırabilir. Çıktıdaki adresler, dosya yolları ve satır numaraları çalışma ortamına göre değişir; bu nedenle sabit bir rapor metni yerine kendi çalıştırmandaki ilk hata konumunu, önceki free() çağrısını ve malloc() satırını karşılaştırmalısın.
Sık Sorulan Sorular
free(NULL) çağrısı neden güvenlidir?
free(NULL) çağrısında serbest bırakılacak bir bellek bloğu bulunmadığı için hiçbir işlem yapılmaz. Bu nedenle free() sonrasında işaretçiyi NULL yapmak, aynı değişken üzerinden yapılacak sonraki çağrıyı güvenli hâle getirir.
Bir işaretçiyi NULL yapmak aynı bloğu gösteren diğer işaretçileri de değiştirir mi?
Bir işaretçiyi NULL yapmak yalnızca o işaretçi değişkeninin değerini değiştirir. Aynı bloğun adresini tutan diğer işaretçiler otomatik olarak NULL olmaz ve serbest bırakılmış belleği gösteren geçersiz işaretçiler olarak kalır.
Double free hatasını önlemek için her dinamik bellek bloğunun sahipliğini, kullanım süresini ve serbest bırakılacağı noktayı kodun arayüzünde açıkça belirlemek gerekir.