การเรียกระบบ brk () ทำหน้าที่อะไร?

ตามคู่มือโปรแกรมเมอร์ Linux:

brk () และ sbrk () เปลี่ยนตำแหน่งของตัวแบ่งโปรแกรมซึ่งกำหนดจุดสิ้นสุดของส่วนข้อมูลของกระบวนการ

ส่วนข้อมูลหมายถึงอะไรที่นี่ เป็นเพียงส่วนข้อมูลหรือข้อมูล BSS และฮีปรวมกันหรือไม่

ตามวิกิ:

บางครั้งข้อมูลพื้นที่ BSS และกองรวมเรียกว่า "ส่วนข้อมูล"

ฉันไม่เห็นเหตุผลที่จะเปลี่ยนขนาดของกลุ่มข้อมูล ถ้าเป็นข้อมูลBSSและกองรวมกันมันก็สมเหตุสมผลแล้วเพราะกองจะได้พื้นที่มากขึ้น

ซึ่งนำฉันไปที่คำถามที่สองของฉัน ในบทความทั้งหมดที่ฉันอ่านจนถึงตอนนี้ผู้เขียนบอกว่ากองเติบโตขึ้นและกองทับลง แต่สิ่งที่พวกเขาไม่อธิบายก็คือจะเกิดอะไรขึ้นเมื่อฮีปใช้พื้นที่ทั้งหมดระหว่างฮีปกับสแต็ค

ในแผนภาพที่คุณโพสต์ "ตัวแบ่ง" - ที่อยู่ที่จัดการโดยbrkและsbrk- เป็นเส้นประที่ด้านบนของฮีป

เอกสารที่คุณอ่านอธิบายสิ่งนี้ว่าเป็นจุดสิ้นสุดของ "ส่วนข้อมูล" เพราะในแบบดั้งเดิม (pre-shared-libraries ก่อนล่วงหน้าmmap) Unix ส่วนข้อมูลนั้นต่อเนื่องกับฮีป ก่อนที่โปรแกรมจะเริ่มต้นเคอร์เนลจะโหลดบล็อก "text" และ "data" ลงใน RAM เริ่มต้นที่ address zero (อันที่จริงแล้วข้างบน address zero เล็กน้อยดังนั้นตัวชี้ NULL จะไม่ชี้ไปที่อะไรเลย) และตั้งค่า break address เป็น จุดสิ้นสุดของส่วนข้อมูล การเรียกครั้งแรกไปยังmallocจะใช้sbrkเพื่อย้ายตัวแบ่งและสร้างฮีประหว่างส่วนบนของส่วนข้อมูลและที่อยู่ตัวแบ่งใหม่ที่สูงกว่าดังที่แสดงในแผนภาพและการใช้ในภายหลังmallocจะใช้เพื่อทำให้กองใหญ่ขึ้น เท่าที่จำเป็น

ในขณะเดียวกันสแต็กจะเริ่มที่ด้านบนของหน่วยความจำและโตขึ้น สแต็คไม่ต้องการการเรียกระบบที่ชัดเจนเพื่อทำให้ใหญ่ขึ้น มันเริ่มต้นด้วย RAM ที่จัดสรรให้มากที่สุดเท่าที่จะทำได้ (นี่เป็นวิธีการแบบดั้งเดิม) หรือมีพื้นที่ของที่อยู่ที่สงวนไว้ด้านล่างสแต็กซึ่งเคอร์เนลจะจัดสรร RAM โดยอัตโนมัติเมื่อสังเกตเห็นความพยายามในการเขียน (นี่คือวิธีการที่ทันสมัย) ไม่ว่าจะด้วยวิธีใดอาจมีหรือไม่มีภูมิภาค "การ์ด" ที่ด้านล่างของพื้นที่ที่อยู่ที่สามารถใช้สำหรับสแต็ก หากภูมิภาคนี้มีอยู่ (ระบบที่ทันสมัยทั้งหมดทำสิ่งนี้) จะไม่มีการแมปอย่างถาวร ถ้าอย่างใดอย่างหนึ่งสแต็กหรือฮีปพยายามที่จะเติบโตขึ้นมาคุณจะได้รับการแบ่งเซ็กเมนต์ ตามเนื้อผ้าแม้ว่าเคอร์เนลไม่ได้พยายามที่จะบังคับใช้ขอบเขต กองสามารถเติบโตเป็นกองหรือกองสามารถเติบโตเป็นกองและวิธีที่พวกเขาจะเขียนลวกข้อมูลของกันและกันและโปรแกรมจะผิดพลาด ถ้าคุณโชคดีมากมันจะพังทันที

ฉันไม่แน่ใจว่าหมายเลข 512GB ในแผนภาพนี้มาจากที่ใด มันแสดงถึงพื้นที่ที่อยู่เสมือน 64 บิตซึ่งไม่สอดคล้องกับแผนที่หน่วยความจำที่ง่ายมากที่คุณมี พื้นที่ที่อยู่ 64- บิตที่แท้จริงมีลักษณะดังนี้:

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

นี่ไม่ได้เป็นการขยายจากระยะไกลและไม่ควรตีความว่าระบบปฏิบัติการใด ๆ ที่ได้รับ (หลังจากที่ฉันวาดมันฉันค้นพบว่า Linux ทำให้การปฏิบัติการใกล้กับศูนย์มากกว่าที่ฉันคิดและไลบรารีที่ใช้ร่วมกัน ที่ที่อยู่สูงอย่างน่าประหลาดใจ) พื้นที่สีดำของแผนภาพนี้ไม่มีการแมป - การเข้าถึงใด ๆ ที่ทำให้เกิด segfault ทันที - และพวกมันมีขนาดมหึมาเมื่อเทียบกับพื้นที่สีเทา พื้นที่สีเทาอ่อนเป็นโปรแกรมและไลบรารีที่ใช้ร่วมกัน (อาจมีไลบรารีที่ใช้ร่วมกันหลายสิบ) แต่ละคนมีอิสระส่วนข้อความและข้อมูล (และส่วน "bss" ซึ่งยังมีข้อมูลทั่วโลก แต่เริ่มต้นได้ที่ all-bits-zero แทนที่จะใช้พื้นที่ในการปฏิบัติการหรือไลบรารีบนดิสก์) ฮีปไม่จำเป็นต้องต่อเนื่องกับเซ็กเมนต์ข้อมูลของปฏิบัติการอีกต่อไป - ฉันวาดมันด้วยวิธีนี้ แต่ดูเหมือนว่า Linux อย่างน้อยก็ไม่ได้ทำเช่นนั้น สแต็กไม่ได้ถูกตรึงไว้ที่ส่วนบนของพื้นที่ที่อยู่เสมือนอีกต่อไปและระยะห่างระหว่างฮีปและสแต็คนั้นมากจนคุณไม่ต้องกังวลกับการข้ามมัน

การแบ่งยังคงเป็นขีด จำกัด สูงสุดของกอง แต่สิ่งที่ผมไม่ได้แสดงให้เห็นว่าอาจจะมีหลายสิบของการจัดสรรเป็นอิสระของหน่วยความจำออกมีในบางสีดำที่ทำด้วยแทนmmap brk(ระบบปฏิบัติการจะพยายามทำให้สิ่งเหล่านี้อยู่ห่างไกลจากbrkพื้นที่เพื่อไม่ให้ชนกัน)

ตัวอย่างที่เรียกใช้น้อยที่สุด

การเรียกระบบ brk () ทำอะไรได้บ้าง?

ขอเคอร์เนลให้คุณอ่านและเขียนหน่วยความจำต่อเนื่องที่เรียกว่าฮีป

ถ้าคุณไม่ถามมันอาจเป็นการแยกคุณออก

โดยไม่ต้อง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;
}

ด้วย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 ต้นน้ำ

ด้านบนอาจไม่ตีหน้าใหม่และไม่แยก segfault แม้จะไม่มีbrkดังนั้นนี่เป็นเวอร์ชั่นที่ก้าวร้าวมากขึ้นซึ่งจัดสรร 16MiB และมีแนวโน้มที่จะ segfault โดยไม่ต้อง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

การสร้างภาพพื้นที่ที่อยู่เสมือน

ก่อนbrk:

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

หลังbrk(p + 2):

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

หลังbrk(b):

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

เพื่อให้เข้าใจถึงช่องว่างที่อยู่ได้ดีขึ้นคุณควรทำความคุ้นเคยกับการเพจ: การเพจจิ้ง x86 ทำงานอย่างไร? .

ทำไมเราต้องการทั้งสองอย่างbrkและsbrk?

brkสามารถนำไปใช้กับการsbrkคำนวณ + ออฟเซ็ตซึ่งทั้งสองมีอยู่เพื่อความสะดวก

ในส่วนแบ็คเอนด์เคอร์เนล Linux v5.0 มีการเรียกระบบเดียวbrkที่ใช้ในการดำเนินการทั้งสองอย่าง: https://github.com/torvalds/linux/blob/v5.0/arch/x86/entry/syscalls/syscall_64 tbl # L23

12  common  brk         __x64_sys_brk

brkPOSIX คืออะไร

brkเคยเป็น POSIX แต่มันถูกลบใน POSIX 2001 ดังนั้นจึงจำเป็นต้อง_GNU_SOURCEเข้าถึง glibc wrapper

การลบนี้น่าจะเกิดจากการแนะนำmmapซึ่งเป็น superset ที่อนุญาตให้มีการจัดสรรหลายช่วงและตัวเลือกการจัดสรรเพิ่มเติม

ฉันคิดว่าไม่มีกรณีที่ถูกต้องที่คุณควรใช้brkแทนmallocหรือmmapทุกวันนี้

brk VS malloc

brkmallocเป็นหนึ่งในความเป็นไปได้ของการใช้เก่า

mmapเป็นรุ่นใหม่ที่มีประสิทธิภาพมากขึ้น stricly กลไกซึ่งมีแนวโน้มที่ทุกระบบ POSIX mallocใช้อยู่ในปัจจุบันในการดำเนินการ นี่คือที่ทำงานได้น้อยที่สุดmmapเช่นการจัดสรรหน่วยความจำ

ฉันสามารถผสมbrkและ malloc ได้หรือไม่?

หากคุณmallocนำไปใช้กับbrkฉันไม่ทราบว่าวิธีการที่ไม่สามารถระเบิดสิ่งต่าง ๆ เนื่องจากbrkจัดการหน่วยความจำช่วงเดียวเท่านั้น

อย่างไรก็ตามฉันไม่พบอะไรเกี่ยวกับเรื่องนี้ในเอกสาร glibc เช่น:

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

สิ่งที่อาจจะเป็นเพียงแค่ทำงานที่นั่นผมคิดว่าตั้งแต่มีแนวโน้มที่จะใช้สำหรับการmmapmalloc

ดูสิ่งนี้ด้วย:

• ไม่ปลอดภัย / เป็นมรดกเกี่ยวกับ brk / sbrk คืออะไร?
• ทำไมการเรียก sbrk (0) สองครั้งให้ค่าที่ต่างกัน

ข้อมูลเพิ่มเติม

ภายในเคอร์เนลจะตัดสินว่ากระบวนการสามารถมีหน่วยความจำขนาดนั้นหรือไม่และหน้าหน่วยความจำ earmarks สำหรับการใช้งานนั้น

สิ่งนี้อธิบายถึงการเปรียบเทียบสแต็กกับฮีป: ฟังก์ชันของคำแนะนำการกด / ป๊อปที่ใช้กับการลงทะเบียนในแอสเซมบลี x86 คืออะไร

คุณสามารถใช้brkและsbrkตัวคุณเองเพื่อหลีกเลี่ยง "malloc ค่าใช้จ่าย" ทุกคนมักจะบ่นเกี่ยวกับ แต่คุณไม่สามารถใช้วิธีนี้ร่วมกับmallocดังนั้นจึงเป็นเรื่องที่เหมาะสมเมื่อคุณไม่ต้องทำfreeอะไรเลย เพราะคุณทำไม่ได้ นอกจากนี้คุณควรหลีกเลี่ยงการเรียกใช้ไลบรารีที่อาจใช้เป็นการmallocภายใน กล่าวคือ strlenอาจปลอดภัย แต่fopenอาจจะไม่

โทรเช่นเดียวกับที่คุณจะเรียกsbrk mallocส่งคืนตัวชี้ไปยังตัวแบ่งปัจจุบันและเพิ่มการแบ่งตามจำนวนนั้น

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

ขณะที่คุณสามารถจัดสรรของแต่ละบุคคลไม่ฟรี (เพราะไม่มีmalloc โสหุ้ยจำ) คุณสามารถปลดปล่อยพื้นที่ทั้งหมดโดยการเรียกbrkกับค่าส่งกลับโดยสายแรกที่sbrkจึงrewinding brk

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

คุณสามารถสแต็กภูมิภาคเหล่านี้ทิ้งพื้นที่ล่าสุดโดยย้อนกลับการหยุดพักเพื่อเริ่มต้นของพื้นที่

อีกหนึ่งสิ่ง ...

sbrkนอกจากนี้ยังจะเป็นประโยชน์ในกอล์ฟรหัสเพราะมัน 2 mallocตัวอักษรที่สั้นกว่า

มีการแม็พหน่วยความจำส่วนตัวแบบไม่ระบุชื่อที่กำหนดพิเศษ (โดยปกติจะอยู่นอกเหนือจาก data / bss แต่ Linux สมัยใหม่จะปรับตำแหน่งด้วย ASLR) ในหลักการก็ไม่ได้ดีไปกว่าการทำแผนที่อื่น ๆ ที่คุณสามารถสร้างขึ้นด้วยmmapแต่ Linux มีการเพิ่มประสิทธิภาพบางอย่างที่ทำให้มันเป็นไปได้ที่จะขยายจุดสิ้นสุดของการทำแผนที่นี้ (โดยใช้brksyscall) ขึ้นด้วยต้นทุนที่ลดลงล็อคเมื่อเทียบกับสิ่งที่mmapหรือmremapจะเกิดขึ้น สิ่งนี้ทำให้มันน่าสนใจสำหรับmallocการใช้งานที่จะใช้เมื่อใช้งานฮีปหลัก

ฉันสามารถตอบคำถามที่สองของคุณ Malloc จะล้มเหลวและส่งคืนพอยน์เตอร์พอยน์เตอร์ นั่นเป็นเหตุผลที่คุณตรวจสอบพอยน์เตอร์พอยน์เตอร์เสมอเมื่อทำการจัดสรรหน่วยความจำแบบไดนามิก

ฮีปจะอยู่ในส่วนสุดท้ายของโปรแกรม brk()ใช้เพื่อเปลี่ยน (ขยาย) ขนาดของฮีป เมื่อฮีปไม่สามารถเติบโตได้อีกต่อไปการmallocโทรใด ๆก็จะล้มเหลว

ส่วนของข้อมูลคือส่วนของหน่วยความจำที่เก็บข้อมูลสแตติกทั้งหมดของคุณอ่านจากไฟล์เรียกทำงานเมื่อเปิดใช้งานและมักจะเต็มไปด้วยศูนย์

malloc ใช้การเรียกระบบ brk เพื่อจัดสรรหน่วยความจำ

ประกอบด้วย

int main(void){

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

เรียกใช้โปรแกรมอย่างง่าย ๆ ด้วย strace มันจะเรียกระบบ brk