อาร์เรย์ที่มีองค์ประกอบศูนย์ต้องการอะไร

ในโค้ดเคอร์เนลของลินุกซ์ฉันพบสิ่งต่อไปนี้ซึ่งฉันไม่เข้าใจ

 struct bts_action {
         u16 type;
         u16 size;
         u8 data[0];
 } __attribute__ ((packed));

รหัสอยู่ที่นี่: http://lxr.free-electrons.com/source/include/linux/ti_wilink_st.h

ความต้องการและวัตถุประสงค์ของอาร์เรย์ข้อมูลที่มีองค์ประกอบเป็นศูนย์คืออะไร?

นี่เป็นวิธีที่จะมีขนาดของข้อมูลที่แปรผันโดยไม่ต้องเรียกmalloc( kmallocในกรณีนี้) สองครั้ง คุณจะใช้มันดังนี้:

struct bts_action *var = kmalloc(sizeof(*var) + extra, GFP_KERNEL);

นี้เคยเป็นไม่ได้มาตรฐานและได้รับการพิจารณาสับ (ตามที่กล่าว Aniket) แต่มันก็เป็นมาตรฐานใน C99 รูปแบบมาตรฐานสำหรับตอนนี้คือ:

struct bts_action {
     u16 type;
     u16 size;
     u8 data[];
} __attribute__ ((packed)); /* Note: the __attribute__ is irrelevant here */

โปรดทราบว่าคุณไม่ได้ระบุขนาดใด ๆ สำหรับdataฟิลด์ โปรดทราบว่าตัวแปรพิเศษนี้สามารถอยู่ที่ส่วนท้ายของโครงสร้างเท่านั้น

ใน C99 เรื่องนี้อธิบายไว้ใน 6.7.2.1.16 (เน้นของฉัน):

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

หรือกล่าวอีกนัยหนึ่งถ้าคุณมี:

struct something
{
    /* other variables */
    char data[];
}

struct something *var = malloc(sizeof(*var) + extra);

คุณสามารถเข้าถึงvar->dataด้วยดัชนีในรูปแบบ[0, extra). โปรดทราบว่าsizeof(struct something)จะให้การบัญชีขนาดสำหรับตัวแปรอื่น ๆ เท่านั้นเช่นให้dataขนาด 0

อาจเป็นเรื่องที่น่าสนใจที่จะสังเกตว่ามาตรฐานให้ตัวอย่างของโครงสร้างmallocดังกล่าวอย่างไร (6.7.2.1.17):

struct s { int n; double d[]; };

int m = /* some value */;
struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));

ข้อสังเกตที่น่าสนใจอีกประการหนึ่งตามมาตรฐานในตำแหน่งเดียวกันคือ (เน้นของฉัน):

สมมติว่าการโทรไปยัง malloc สำเร็จวัตถุที่ชี้โดย p จะทำงานตามวัตถุประสงค์ส่วนใหญ่ราวกับว่า p ได้รับการประกาศเป็น:

struct { int n; double d[m]; } *p;

(มีบางกรณีที่การเทียบเท่านี้หักโดยเฉพาะอย่างยิ่งการชดเชยของสมาชิก d อาจไม่เหมือนกัน )

นี่คือการแฮ็กสำหรับGCC ( C90 ) ในความเป็นจริง

เรียกอีกอย่างว่าแฮ็คโครงสร้าง

ครั้งต่อไปฉันจะพูดว่า:

struct bts_action *bts = malloc(sizeof(struct bts_action) + sizeof(char)*100);

จะเทียบเท่ากับการพูดว่า:

struct bts_action{
    u16 type;
    u16 size;
    u8 data[100];
};

และฉันสามารถสร้างวัตถุโครงสร้างจำนวนเท่าใดก็ได้

แนวคิดคือการอนุญาตให้มีอาร์เรย์ขนาดตัวแปรที่ส่วนท้ายของโครงสร้าง สันนิษฐานว่าbts_actionเป็นแพ็กเก็ตข้อมูลบางส่วนที่มีส่วนหัวขนาดคงที่ ( typeและsizeฟิลด์) และdataสมาชิกขนาดตัวแปร การประกาศเป็นอาร์เรย์ความยาว 0 ทำให้สามารถสร้างดัชนีได้เช่นเดียวกับอาร์เรย์อื่น ๆ จากนั้นคุณจะจัดสรรโครงสร้างที่มีbts_actionขนาด 1024 ไบต์dataดังนี้:

size_t size = 1024;
struct bts_action* action = (struct bts_action*)malloc(sizeof(struct bts_action) + size);

ดูเพิ่มเติมที่: http://c2.com/cgi/wiki?StructHack

รหัสไม่ถูกต้อง C ( ดูสิ่งนี้ ) เคอร์เนลลินุกซ์นั้นมีเหตุผลที่ชัดเจนไม่เกี่ยวข้องกับการพกพาเลยแม้แต่น้อยดังนั้นจึงใช้โค้ดที่ไม่ได้มาตรฐานจำนวนมาก

สิ่งที่พวกเขากำลังทำคือส่วนขยายที่ไม่ได้มาตรฐาน GCC ที่มีขนาดอาร์เรย์ 0 โปรแกรมที่เป็นไปตามมาตรฐานจะเขียนขึ้นu8 data[];และมันจะมีความหมายเหมือนกัน เห็นได้ชัดว่าผู้เขียนเคอร์เนลลินุกซ์ชอบที่จะทำให้สิ่งต่างๆซับซ้อนและไม่ได้มาตรฐานโดยไม่จำเป็นหากตัวเลือกในการทำเช่นนั้นเปิดเผยตัวเอง

ในมาตรฐาน C รุ่นเก่าการสิ้นสุดโครงสร้างด้วยอาร์เรย์ว่างเรียกว่า "การแฮ็กโครงสร้าง" คนอื่น ๆ ได้อธิบายจุดประสงค์แล้วในคำตอบอื่น ๆ การแฮ็กโครงสร้างในมาตรฐาน C90 เป็นพฤติกรรมที่ไม่ได้กำหนดไว้และอาจทำให้เกิดปัญหาได้เนื่องจากคอมไพเลอร์ C มีอิสระที่จะเพิ่มไบต์ช่องว่างภายในจำนวนเท่าใดก็ได้ที่ส่วนท้ายของโครงสร้าง ไบต์ช่องว่างภายในดังกล่าวอาจชนกับข้อมูลที่คุณพยายาม "แฮ็ก" ในตอนท้ายของโครงสร้าง

GCC ในช่วงต้นได้สร้างส่วนขยายที่ไม่ได้มาตรฐานเพื่อเปลี่ยนจากพฤติกรรมที่ไม่ได้กำหนดเป็นพฤติกรรมที่กำหนดไว้อย่างชัดเจน จากนั้นมาตรฐาน C99 จึงปรับแนวคิดนี้และโปรแกรม C สมัยใหม่ใด ๆ จึงสามารถใช้คุณลักษณะนี้ได้โดยไม่มีความเสี่ยง เรียกว่าสมาชิกอาร์เรย์แบบยืดหยุ่นใน C99 / C11

การใช้อาร์เรย์ที่มีความยาวเป็นศูนย์อีกอย่างหนึ่งคือการตั้งชื่อป้ายกำกับภายในโครงสร้างเพื่อช่วยในการคอมไพล์การตรวจสอบการชดเชยโครงสร้างเวลา

สมมติว่าคุณมีคำจำกัดความของโครงสร้างขนาดใหญ่ (ครอบคลุมบรรทัดแคชหลายบรรทัด) ที่คุณต้องการตรวจสอบให้แน่ใจว่ามีการจัดแนวให้ตรงกับขอบเขตบรรทัดแคชทั้งในจุดเริ่มต้นและตรงกลางโดยที่มันข้ามขอบเขต

struct example_large_s
{
    u32 first; // align to CL
    u32 data;
    ....
    u64 *second;  // align to second CL after the first one
    ....
};

ในโค้ดคุณสามารถประกาศได้โดยใช้ส่วนขยาย GCC เช่น:

__attribute__((aligned(CACHE_LINE_BYTES)))

แต่คุณยังคงต้องการให้แน่ใจว่าสิ่งนี้ถูกบังคับใช้ในรันไทม์

ASSERT (offsetof (example_large_s, first) == 0);
ASSERT (offsetof (example_large_s, second) == CACHE_LINE_BYTES);

สิ่งนี้ใช้ได้กับโครงสร้างเดียว แต่มันยากที่จะครอบคลุมหลายโครงสร้างแต่ละส่วนมีชื่อสมาชิกที่แตกต่างกันเพื่อจัดแนว คุณมักจะได้รับรหัสด้านล่างซึ่งคุณต้องหาชื่อของสมาชิกตัวแรกของแต่ละโครงสร้าง:

assert (offsetof (one_struct,     <name_of_first_member>) == 0);
assert (offsetof (one_struct,     <name_of_second_member>) == CACHE_LINE_BYTES);
assert (offsetof (another_struct, <name_of_first_member>) == 0);
assert (offsetof (another_struct, <name_of_second_member>) == CACHE_LINE_BYTES);

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

#define CACHE_LINE_ALIGN_MARK(mark) u8 mark[0] __attribute__((aligned(CACHE_LINE_BYTES)))
struct example_large_s
{
    CACHE_LINE_ALIGN_MARK (cacheline0);
    u32 first; // align to CL
    u32 data;
    ....
    CACHE_LINE_ALIGN_MARK (cacheline1);
    u64 *second;  // align to second CL after the first one
    ....
};

จากนั้นรหัสยืนยันรันไทม์จะดูแลรักษาง่ายกว่ามาก:

assert (offsetof (one_struct,     cacheline0) == 0);
assert (offsetof (one_struct,     cacheline1) == CACHE_LINE_BYTES);
assert (offsetof (another_struct, cacheline0) == 0);
assert (offsetof (another_struct, cacheline1) == CACHE_LINE_BYTES);