Apa yang dilakukan oleh panggilan sistem brk ()?

Menurut manual pemrogram Linux:

brk () dan sbrk () mengubah lokasi jeda program, yang menentukan akhir dari segmen data proses.

Apa arti segmen data di sini? Apakah hanya segmen data atau data, BSS, dan heap yang digabungkan?

Menurut wiki:

Terkadang data, BSS, dan area tumpukan secara kolektif disebut sebagai "segmen data".

Saya tidak melihat alasan untuk mengubah ukuran hanya segmen data. Jika ini adalah data, BSS dan heap secara kolektif maka masuk akal karena heap akan mendapatkan lebih banyak ruang.

Yang membawa saya ke pertanyaan kedua saya. Dalam semua artikel yang saya baca sejauh ini, penulis mengatakan bahwa tumpukan tumbuh ke atas dan tumpukan tumbuh ke bawah. Tapi apa yang tidak mereka jelaskan adalah apa yang terjadi ketika tumpukan menempati semua ruang antara tumpukan dan tumpukan?

Dalam diagram yang Anda poskan, "break" - alamat yang dimanipulasi oleh brkdan sbrk- adalah garis putus-putus di bagian atas tumpukan.

Dokumentasi yang Anda baca menggambarkan ini sebagai akhir dari "segmen data" karena dalam tradisional (pra-berbagi-perpustakaan, pra- mmap) Unix segmen data terus menerus dengan heap; sebelum program dimulai, kernel akan memuat blok "teks" dan "data" ke dalam RAM mulai dari alamat nol (sebenarnya sedikit di atas alamat nol, sehingga penunjuk NULL benar-benar tidak menunjuk ke apa pun) dan mengatur alamat break ke akhir segmen data. Panggilan pertama untuk mallockemudian akan digunakan sbrkuntuk memindahkan break up dan membuat tumpukan di antara bagian atas segmen data dan yang baru, alamat break yang lebih tinggi, seperti yang ditunjukkan dalam diagram, dan penggunaan selanjutnya mallocakan menggunakannya untuk membuat heap lebih besar seperlunya.

Sementara itu, tumpukan mulai di bagian atas memori dan tumbuh turun. Tumpukan tidak perlu pemanggilan sistem yang eksplisit untuk membuatnya lebih besar; baik itu dimulai dengan RAM yang dialokasikan sebanyak mungkin seperti yang pernah ada (ini adalah pendekatan tradisional) atau ada wilayah alamat yang dicadangkan di bawah tumpukan, di mana kernel secara otomatis mengalokasikan RAM ketika memperhatikan upaya untuk menulis di sana (ini adalah pendekatan modern). Apa pun itu, mungkin ada atau tidak ada wilayah "penjaga" di bagian bawah ruang alamat yang dapat digunakan untuk tumpukan. Jika wilayah ini ada (semua sistem modern melakukan ini), ia tidak dipetakan secara permanen; jika salahtumpukan atau tumpukan mencoba tumbuh ke dalamnya, Anda mendapatkan kesalahan segmentasi. Namun, secara tradisional, kernel tidak berusaha untuk menegakkan batasan; tumpukan bisa tumbuh menjadi tumpukan, atau tumpukan itu bisa tumbuh ke tumpukan, dan baik cara mereka akan mencoret-coret data masing-masing dan program akan macet. Jika Anda sangat beruntung itu akan langsung crash.

Saya tidak yakin dari mana angka 512GB dalam diagram ini berasal. Ini menyiratkan ruang alamat virtual 64-bit, yang tidak konsisten dengan peta memori yang sangat sederhana yang Anda miliki di sana. Ruang alamat 64-bit yang nyata terlihat lebih seperti ini:

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

Ini bukan untuk skala jauh, dan itu tidak boleh ditafsirkan sebagai persis bagaimana OS yang diberikan melakukan hal-hal (setelah saya menggambar saya menemukan bahwa Linux sebenarnya menempatkan executable lebih dekat ke alamat nol daripada yang saya kira, dan perpustakaan bersama di alamat yang sangat tinggi). Wilayah hitam dari diagram ini tidak dipetakan - akses apa pun menyebabkan segfault langsung - dan mereka relatif besar terhadap area abu-abu. Daerah abu-abu terang adalah program dan pustaka bersama (bisa ada lusinan pustaka bersama); masing-masing memiliki yang independensegmen teks dan data (dan segmen "bss", yang juga berisi data global tetapi diinisialisasi ke semua-bit-nol daripada mengambil ruang di executable atau library pada disk). Tumpukan tidak lagi harus terus-menerus dengan segmen data yang dapat dieksekusi - saya menggambar seperti itu, tetapi sepertinya Linux, setidaknya, tidak melakukan itu. Tumpukan tidak lagi dipatok ke atas ruang alamat virtual, dan jarak antara tumpukan dan tumpukan sangat besar sehingga Anda tidak perlu khawatir tentang melewatinya.

Break masih merupakan batas atas heap. Namun, apa yang tidak saya tunjukkan adalah bahwa mungkin ada lusinan alokasi memori independen di sana dalam warna hitam di suatu tempat, dibuat dengan mmapalih - alih brk. (OS akan mencoba untuk menjauhkan ini dari brkdaerah sehingga mereka tidak bertabrakan.)

Contoh runnable minimal

Apa yang dilakukan dengan panggilan sistem brk ()?

Meminta kernel untuk memberi Anda Anda membaca dan menulis ke sepotong memori yang berdekatan yang disebut heap.

Jika Anda tidak bertanya, itu mungkin akan membuat kesalahan Anda.

Tanpa 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;
}

Dengan 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 hulu .

Hal di atas mungkin tidak mengenai halaman baru dan bahkan tanpa segfault brk, jadi di sini adalah versi yang lebih agresif yang mengalokasikan 16MiB dan sangat mungkin untuk melakukan segmentasi tanpa 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;
}

Diuji pada Ubuntu 18.04.

Visualisasi ruang alamat virtual

Sebelum brk:

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

Setelah brk(p + 2):

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

Setelah brk(b):

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

Untuk lebih memahami ruang alamat, Anda harus membiasakan diri dengan paging: Bagaimana cara kerja paging x86? .

Mengapa kita membutuhkan keduanya brkdan sbrk?

brktentu saja dapat diimplementasikan dengan sbrkperhitungan + offset, keduanya ada hanya untuk kenyamanan.

Di backend, kernel Linux v5.0 memiliki panggilan sistem tunggal brkyang digunakan untuk mengimplementasikan keduanya: https://github.com/torvalds/linux/blob/v5.0/arch/x86/entry/syscalls/syscall_64. tbl # L23

12  common  brk         __x64_sys_brk

Apakah brkPOSIX?

brkdulu POSIX, tetapi dihapus pada POSIX 2001, sehingga kebutuhan untuk _GNU_SOURCEmengakses pembungkus glibc.

Penghapusan ini kemungkinan disebabkan oleh pengantar mmap, yang merupakan superset yang memungkinkan beberapa rentang untuk dialokasikan dan lebih banyak opsi alokasi.

Saya pikir tidak ada kasus yang valid di mana Anda harus menggunakan, brkbukan mallocatau mmapsaat ini.

brk vs. malloc

brkadalah salah satu kemungkinan lama implementasi malloc.

mmapadalah mekanisme baru yang lebih kuat yang kemungkinan besar semua sistem POSIX saat ini gunakan untuk mengimplementasikan malloc. Berikut adalah contoh alokasi memori runnable minimalmmap .

Bisakah saya campur brkdan malloc?

Jika Anda mallocdiimplementasikan dengan brk, saya tidak tahu bagaimana itu mungkin tidak dapat meledakkan sesuatu, karena brkhanya mengelola satu rentang memori.

Namun saya tidak dapat menemukan apa pun tentang itu di dokumen glibc, misalnya:

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

Hal kemungkinan hanya bekerja di sana saya kira karena mmapkemungkinan digunakan untuk malloc.

Lihat juga:

• Apa yang tidak aman / warisan tentang brk / sbrk?
• Mengapa memanggil sbrk (0) dua kali memberikan nilai yang berbeda?

Info lebih lanjut

Secara internal, kernel memutuskan apakah proses dapat memiliki banyak memori, dan menyediakan halaman memori untuk penggunaan itu.

Ini menjelaskan bagaimana tumpukan dibandingkan dengan tumpukan: Apa fungsi instruksi push / pop yang digunakan pada register dalam rakitan x86?

Anda dapat menggunakan brkdan sbrkdiri Anda sendiri untuk menghindari "malloc overhead" yang selalu dikeluhkan semua orang. Tetapi Anda tidak dapat dengan mudah menggunakan metode ini dalam hubungannya dengan mallocsehingga hanya tepat ketika Anda tidak perlu freeapa - apa. Karena kamu tidak bisa. Anda juga harus menghindari panggilan perpustakaan apa pun yang dapat digunakan secara mallocinternal. Yaitu. strlenmungkin aman, tapi fopenmungkin juga tidak.

Panggil sbrkpersis seperti Anda akan menelepon malloc. Ini mengembalikan pointer ke break saat ini dan menambah break dengan jumlah itu.

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

Meskipun Anda tidak dapat membebaskan alokasi individual (karena tidak ada malloc-overhead , ingat), Anda dapat membebaskan seluruh ruang dengan menelepon brkdengan nilai yang dikembalikan oleh panggilan pertama sbrk, sehingga memutar brk .

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

Anda bahkan bisa menumpuk wilayah ini, membuang wilayah paling baru dengan memutar ulang jeda ke awal wilayah.

Satu hal lagi ...

sbrkjuga berguna dalam golf kode karena 2 karakter lebih pendek dari malloc.

Ada pemetaan memori pribadi anonim khusus yang ditunjuk (secara tradisional terletak tepat di luar data / bss, tetapi Linux modern benar-benar akan menyesuaikan lokasi dengan ASLR). Pada prinsipnya itu tidak lebih baik daripada pemetaan lainnya Anda bisa membuat dengan mmap, tetapi Linux memiliki beberapa optimasi yang memungkinkan untuk memperluas akhir pemetaan ini (menggunakan brksyscall) ke atas dengan biaya berkurang penguncian relatif terhadap apa mmapatau mremapakan dikenakan. Ini membuatnya menarik untuk mallocimplementasi untuk digunakan ketika mengimplementasikan tumpukan utama.

Saya bisa menjawab pertanyaan kedua Anda. Malloc akan gagal dan mengembalikan pointer nol. Itu sebabnya Anda selalu memeriksa penunjuk nol saat mengalokasikan memori secara dinamis.

Tumpukan ditempatkan terakhir di segmen data program. brk()digunakan untuk mengubah (memperluas) ukuran heap. Ketika tumpukan tidak dapat tumbuh lagi, mallocpanggilan apa pun akan gagal.

Segmen data adalah bagian dari memori yang menyimpan semua data statis Anda, dibaca dari yang dapat dijalankan pada saat peluncuran dan biasanya diisi nol.

malloc menggunakan panggilan sistem brk untuk mengalokasikan memori.

termasuk

int main(void){

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

Jalankan program sederhana ini dengan strace, itu akan memanggil sistem brk.