Brk () sistem çağrısı ne yapar?

Linux programcıları el kitabına göre:

brk () ve sbrk (), işlemin veri segmentinin sonunu tanımlayan program sonu konumunu değiştirir.

Veri segmenti burada ne anlama geliyor? Yalnızca veri segmenti veya veri, BSS ve yığın birleştirildi mi?

Wiki'ye göre:

Bazen veriler, BSS ve yığın alanları topluca "veri segmenti" olarak adlandırılır.

Yalnızca veri segmentinin boyutunu değiştirmek için bir neden göremiyorum. Veri ise, BSS ve yığın toplu olarak, yığın daha fazla alan alacağından mantıklıdır.

Bu da beni ikinci soruma getiriyor. Şimdiye kadar okuduğum tüm makalelerde yazar, yığının yukarı doğru büyüdüğünü ve yığının aşağı doğru büyüdüğünü söylüyor. Ama açıklamamış oldukları şey, yığın yığın ve yığın arasındaki tüm alanı kapladığında ne olur?

Gönderdiğiniz şemada, "sonu" - tarafından değiştirilen adres brkve sbrk- yığının üstündeki noktalı çizgidir.

Okuduğunuz belgeler bunu "veri segmentinin" sonu olarak tanımlıyor çünkü geleneksel (önceden paylaşılan kütüphaneler, ön- mmap) Unix'te veri segmenti yığınla süreklidir; program başlamadan önce, çekirdek "metin" ve "veri" bloklarını sıfır adresinden başlayarak RAM'e yükler (aslında adres sıfırının biraz üzerindedir, böylece NULL işaretçisi gerçekten hiçbir şeye işaret etmez) ve kesme adresini veri segmentinin sonu. Daha mallocsonra yapılan ilk çağrı sbrk, kesmeyi yukarı taşımak ve veri segmentinin üst kısmı ile şemada gösterildiği gibi yeni, daha yüksek kesme adresi arasında yığın oluşturmak için kullanılır ve daha sonra kullanılması malloc, yığını daha büyük hale getirmek için kullanır gerektiği gibi.

Bu arada, yığın hafızanın en üstünde başlar ve büyür. Yığının daha büyük olması için açık sistem çağrılarına ihtiyacı yoktur; ya olabildiğince fazla RAM tahsis edilir (bu geleneksel yaklaşımdı) ya da yığının altında ayrılmış adreslerin bulunduğu bir bölge var, oraya yazma girişimi fark ettiğinde çekirdek otomatik olarak RAM'i ayırıyor (bu modern yaklaşımdır). Her iki durumda da, adres alanının altında yığın için kullanılabilecek bir "koruma" bölgesi olabilir veya olmayabilir. Bu bölge varsa (tüm modern sistemler bunu yapar) kalıcı olarak eşleştirilmez; eğer ikisinden biriyığın veya yığın içine büyümeye çalışır, bir segmentasyon hatası alırsınız. Bununla birlikte, geleneksel olarak, çekirdek bir sınırı zorlama girişiminde bulunmamıştır; yığın yığının içine büyüyebilir veya yığın yığının içine büyüyebilir ve her iki şekilde de birbirlerinin verilerinin üzerine yazılabilir ve program çökebilir. Çok şanslı olsaydın hemen çökecekti.

Bu diyagramdaki 512GB sayısının nereden geldiğinden emin değilim. Orada sahip olduğunuz çok basit bellek haritasına aykırı olan 64 bitlik sanal adres alanı anlamına geliyor. Gerçek bir 64 bit adres alanı daha çok şuna benzer:

              Legend:  t: text, d: data, b: BSS

Bu uzaktan ölçeklenmek değildir ve herhangi bir işletim sisteminin tam olarak nasıl yaptığını yorumlamamalıdır (çizdikten sonra Linux'un çalıştırılabilir dosyayı aslında düşündüğümden daha fazla adrese yakınlaştırdığını keşfettim ve paylaşılan kütüphaneler şaşırtıcı derecede yüksek adreslerde). Bu diyagram siyah bölgeler bağlanılmayan - herhangi bir erişim acil segfault neden olur - ve bunlar devasa gri alanlarda göreli. Açık gri bölgeler program ve onun paylaşılan kütüphaneleridir (düzinelerce paylaşılan kütüphane olabilir); her birinin bağımsızmetin ve veri segmenti (ve global veri de içeren "ancak" bss "segmenti, ancak diskteki yürütülebilir dosyada veya kütüphanede yer kaplamak yerine tamamen sıfır olarak başlatılır). Yığın artık yürütülebilir dosyanın veri segmentiyle sürekli değil - bu şekilde çizdim, ancak en azından Linux bunu yapmıyor gibi görünüyor. Yığın artık sanal adres alanının üst kısmına sabitlenmemiştir ve yığın ile yığın arasındaki mesafe o kadar büyüktür ki onu geçme konusunda endişelenmenize gerek yoktur.

Mola hala yığının üst sınırıdır. Ancak, göstermediğim şey, siyah mmapyerine bir yerde düzinelerce bağımsız bellek tahsisi yapılabileceğiydi brk. (OS, brkçarpışmamak için bunları alandan uzak tutmaya çalışacaktır .)

Minimum çalıştırılabilir örnek

Brk () sistem çağrısı ne yapar?

Çekirdekten, yığın adı verilen bitişik bir bellek yığınını okumanıza ve yazmanıza izin vermesini ister.

Eğer sormazsanız, sizi parçalayabilir.

Olmadan brk:

#define _GNU_SOURCE
#include <unistd.h>

int main(void) {
    /* Get the first address beyond the end of the heap. */
    void *b = sbrk(0);
    int *p = (int *)b;
    /* May segfault because it is outside of the heap. */
    *p = 1;
    return 0;
}

İle brk:

#define _GNU_SOURCE
#include <assert.h>
#include <unistd.h>

int main(void) {
    void *b = sbrk(0);
    int *p = (int *)b;

    /* Move it 2 ints forward */
    brk(p + 2);

    /* Use the ints. */
    *p = 1;
    *(p + 1) = 2;
    assert(*p == 1);
    assert(*(p + 1) == 2);

    /* Deallocate back. */
    brk(b);

    return 0;
}

GitHub akış yukarı .

Yukarıdakiler, yeni bir sayfaya brkçarpmayabilir ve olmadan bile segfault yapamaz , bu nedenle 16MiB'yi ayıran ve agresif olmayan brk:

#define _GNU_SOURCE
#include <assert.h>
#include <unistd.h>

int main(void) {
    void *b;
    char *p, *end;

    b = sbrk(0);
    p = (char *)b;
    end = p + 0x1000000;
    brk(end);
    while (p < end) {
        *(p++) = 1;
    }
    brk(b);
    return 0;
}

Ubuntu 18.04'te test edildi.

Sanal adres alanı görselleştirme

Önce brk:

+------+ <-- Heap Start == Heap End

Sonra brk(p + 2):

+------+ <-- Heap Start + 2 * sizof(int) == Heap End 
|      |
| You can now write your ints
| in this memory area.
|      |
+------+ <-- Heap Start

Sonra brk(b):

+------+ <-- Heap Start == Heap End

Adres alanlarını daha iyi anlamak için, disk belleği hakkında bilgi sahibi olmalısınız: x86 disk belleği nasıl çalışır? .

Neden ikisine de ihtiyacımız var brkve sbrk?

brkElbette sbrk+ ofset hesaplamaları ile uygulanabilir , her ikisi de sadece kolaylık sağlamak için mevcuttur.

Arka uçta, Linux çekirdeği v5.0, brkher ikisini de uygulamak için kullanılan tek bir sistem çağrısına sahiptir: https://github.com/torvalds/linux/blob/v5.0/arch/x86/entry/syscalls/syscall_64. tbl # L23

12  common  brk         __x64_sys_brk

Mı brkPOSIX?

brkeskiden POSIX idi, ancak POSIX 2001'de kaldırıldı, bu nedenle _GNU_SOURCEglibc sarmalayıcısına erişme ihtiyacı .

Kaldırma işlemi büyük olasılıkla mmap, birden fazla aralığın atanmasına izin veren bir üst küme ve daha fazla ayırma seçeneğinden kaynaklanmaktadır.

Bugün brkyerine mallocya da yerine kullanmanız gereken geçerli bir durum olmadığını düşünüyorum mmap.

brk vs malloc

brkeski bir uygulama olasılığıdır malloc.

mmapşu anda tüm POSIX sistemlerinin uygulamak için kullandığı daha yeni ve daha güçlü bir mekanizmadır malloc. İşte asgari çalıştırılabilir mmapbellek ayırma örneği .

Karıştırıp brkyanlış yerleştirebilir miyim ?

Eğer mallocuygulandıysa brk, bunun nasıl bir şeyleri havaya uçuramayacağı hakkında hiçbir fikrim yok, çünkü brksadece tek bir bellek aralığını yönetiyor.

Ancak glibc belgelerinde bu konuda bir şey bulamadım, örneğin:

• https://www.gnu.org/software/libc/manual/html_mono/libc.html#Resizing-the-Data-Segment

Muhtemelen orada mmapkullanıldığından beri işler muhtemelen orada çalışacaktır malloc.

Ayrıca bakınız:

• BRK / SBBRK hakkında güvensiz / miras nedir?
• Sbrk (0) çağrısı neden iki kez farklı bir değer veriyor?

Daha fazla bilgi

Dahili olarak, işlemin bu kadar fazla belleğe sahip olup olamayacağına karar verir ve bu kullanım için bellek sayfalarını belirler .

Bu, yığının yığınla nasıl karşılaştırıldığını açıklar: x86 derlemesindeki kayıtlarda kullanılan push / pop yönergelerinin işlevi nedir?

Sen kullanabilirsiniz brkve sbrkkendinizi "malloc havai" herkes her zaman hakkında şikayetçi önlemek için. Ancak bu yöntemi kolayca birlikte kullanamazsınız, bu mallocyüzden sadece freehiçbir şeye ihtiyacınız olmadığında uygundur . Çünkü yapamazsın. Ayrıca, mallocdahili olarak kullanılabilecek kütüphane çağrılarından kaçınmalısınız . Yani. strlenmuhtemelen güvenli, ama fopenmuhtemelen değil.

Çağrı sbrksadece çağırır gibi malloc. Geçerli kesmeye bir işaretçi döndürür ve kesmeyi bu miktar kadar artırır.

void *myallocate(int n){
    return sbrk(n);
}

Özgür birey tahsisleri (hayır olmadığından edemesek malloc-havai unutmayın), sen yapabilirsiniz özgür tüm alanı arayarak brkilk çağrı tarafından döndürülen değerle sbrkböylece brk geri sarma .

void *memorypool;
void initmemorypool(void){
    memorypool = sbrk(0);
}
void resetmemorypool(void){
    brk(memorypool);
}

Bölgeyi başlangıç ​​noktasına geri sararak en son bölgeyi atayarak bu bölgeleri yığınlayabilirsiniz.

Bir şey daha ...

sbrk2 karakterden daha kısa olduğu için kod golfünde de kullanışlıdır malloc.

Özel olarak belirlenmiş anonim bir özel bellek eşlemesi vardır (geleneksel olarak veri / bss'nin hemen dışında bulunur, ancak modern Linux aslında konumu ASLR ile ayarlayacaktır). Prensipte, oluşturabileceğiniz diğer eşlemelerden daha iyi değildir mmap, ancak Linux, bu eşlemenin sonunu ( brksistem çağrısı kullanarak) ortaya çıkan mmapveya ne mremapolacağına göre düşük kilitleme maliyetiyle yukarı doğru genişletmeyi mümkün kılan bazı optimizasyonlara sahiptir . Bu malloc, ana yığını uygularken uygulamaların kullanılmasını cazip hale getirir .

İkinci sorunuza cevap verebilirim. Malloc başarısız olur ve bir boş gösterici döndürür. Bu nedenle, belleği dinamik olarak ayırırken her zaman boş gösterici olup olmadığını kontrol edersiniz.

Yığın en son programın veri segmentine yerleştirilir. brk()yığının boyutunu değiştirmek (genişletmek) için kullanılır. Yığın daha fazla büyüyemezse, mallocçağrı başarısız olur.

Veri segmenti, belleğin açılışta yürütülebilir dosyadan okunan ve genellikle sıfır dolu olan tüm statik verilerinizi tutan kısmıdır.

malloc belleği ayırmak için brk sistem çağrısını kullanır.

Dahil etmek

int main(void){

char *a = malloc(10); 
return 0;
}

strace ile bu basit programı çalıştırmak, brk sistemi çağırır.