Sıfır elemanlı diziye ne gerek var?

Linux çekirdek kodunda anlayamadığım şu şeyi buldum.

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

Kod burada: http://lxr.free-electrons.com/source/include/linux/ti_wilink_st.h

Sıfır elemanlı bir veri dizisinin gerekliliği ve amacı nedir?

Bu, iki kez aramak zorunda kalmadan malloc( kmallocbu durumda) değişken veri boyutlarına sahip olmanın bir yoludur . Bunu şu şekilde kullanırsın:

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

Bu eskiden standart değildi ve bir hack olarak kabul edildi (Aniket'in dediği gibi), ancak C99'da standartlaştırıldı . Şu an için standart biçim:

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

dataAlan için herhangi bir boyuttan bahsetmediğinizi unutmayın . Ayrıca bu özel değişkenin yalnızca yapının sonunda gelebileceğine dikkat edin.

C99'da bu konu 6.7.2.1.16'da açıklanmıştır (vurgu benim):

Özel bir durum olarak, birden fazla adlandırılmış üyeye sahip bir yapının son elemanı eksik bir dizi tipine sahip olabilir; buna esnek dizi üyesi denir. Çoğu durumda, esnek dizi üyesi göz ardı edilir. Özellikle, yapının boyutu, ihmalin ima ettiğinden daha fazla arka dolguya sahip olabilmesi dışında, esnek dizi üyesi çıkarılmış gibidir. Ancak, bir. (veya ->) operatörü, esnek bir dizi üyesine sahip bir yapı olan (bir gösterici) olan bir sol işlenene ve bu üyeye sağ işlenen adlarına sahiptir, bu üye en uzun diziyle (aynı öğe türüne sahip) değiştirilmiş gibi davranır. ) yapıyı erişilen nesneden daha büyük yapmaz; Dizinin ofseti, değiştirilen dizininkinden farklı olsa bile, esnek dizi üyesininki olarak kalacaktır. Bu dizinin hiç elemanı yoksa,

Veya başka bir deyişle, eğer varsa:

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

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

var->dataİçindeki indeksler ile erişebilirsiniz [0, extra). sizeof(struct something)Bunun yalnızca diğer değişkenler için boyut muhasebesi vereceğini unutmayın , yani data0 boyutu verir .

Standardın gerçekte mallocböyle bir yapının örneklerini nasıl verdiğini not etmek de ilginç olabilir (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]));

Aynı konumdaki standardın bir başka ilginç notu da (vurgu benim):

malloc çağrısının başarılı olduğunu varsayarsak, p ile gösterilen nesne, çoğu amaç için p aşağıdaki gibi bildirilmiş gibi davranır:

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

(bu denkliğin bozulduğu durumlar vardır; özellikle d üyesinin ofsetleri aynı olmayabilir ).

Bu aslında GCC ( C90 ) için bir hack'tir .

Aynı zamanda struct hack olarak da adlandırılır .

Yani bir dahaki sefere şunu derdim:

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

Şöyle demeye eşdeğer olacaktır:

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

Ve bu tür yapı nesnelerinden istediğiniz sayıda oluşturabilirim.

Buradaki fikir, yapının sonunda değişken boyutlu bir diziye izin vermektir. Muhtemelen, bts_actionsabit boyutlu bir başlığı ( typeve sizealanları) ve değişken boyutlu dataüyesi olan bazı veri paketleridir . 0 uzunluklu bir dizi olarak bildirilerek, tıpkı diğer diziler gibi dizine alınabilir. Daha sonra bts_action1024 bayt databoyutunda bir yapı ayırırsınız , örneğin:

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

Ayrıca bkz .: http://c2.com/cgi/wiki?StructHack

Kod geçerli değil C (buna bakın ). Linux çekirdeği, bariz nedenlerden ötürü, taşınabilirlikle en ufak bir ilgisi yoktur, bu nedenle çok sayıda standart dışı kod kullanır.

Yaptıkları şey, 0 dizi boyutuna sahip standart olmayan bir GCC genişletmesidir. Standart uyumlu bir program yazardı u8 data[];ve bu da aynı anlama gelirdi. Görünüşe göre Linux çekirdeğinin yazarları, eğer bir seçenek ortaya çıkarsa, işleri gereksiz yere karmaşık ve standart dışı yapmayı seviyorlar.

Daha eski C standartlarında, bir yapının boş bir diziyle sonlandırılması "struct hack" olarak biliniyordu. Diğerleri, amacını başka cevaplarda zaten açıkladı. C90 standardındaki struct hack, tanımsız bir davranıştır ve çökmelere neden olabilir, çünkü bir C derleyicisi yapının sonuna herhangi bir sayıda dolgu baytı eklemekte özgürdür. Bu tür dolgu baytları, yapının sonunda "hacklemeye" çalıştığınız verilerle çarpışabilir.

GCC erken dönemde, bunu tanımsız davranıştan iyi tanımlanmış davranışa dönüştürmek için standart olmayan bir uzantı yaptı. C99 standardı daha sonra bu kavramı uyarladı ve bu nedenle herhangi bir modern C programı bu özelliği risksiz olarak kullanabilir. C99 / C11'de esnek dizi üyesi olarak bilinir .

Sıfır uzunluklu dizinin başka bir kullanımı, derleme zamanı yapı ofset kontrolüne yardımcı olmak için bir yapı içinde adlandırılmış bir etiket gibidir.

Hem başlangıçta hem de sınırı geçtiği yerde önbellek çizgisi sınırına hizalandıklarından emin olmak istediğiniz bazı büyük yapı tanımlarına (birden çok önbellek satırına yayılır) sahip olduğunuzu varsayalım.

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

Kodda bunları aşağıdaki gibi GCC uzantılarını kullanarak bildirebilirsiniz:

__attribute__((aligned(CACHE_LINE_BYTES)))

Ancak yine de bunun çalışma zamanında uygulandığından emin olmak istiyorsunuz.

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

Bu, tek bir yapı için işe yarayacaktır, ancak birçok yapıyı kapsamak zor olacaktır, her birinin hizalanacak farklı üye adı vardır. Büyük olasılıkla, her yapının ilk üyesinin adlarını bulmanız gereken aşağıdaki gibi bir kod alırsınız:

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);

Bu şekilde gitmek yerine, yapı içinde, tutarlı bir ada sahip adlandırılmış bir etiket gibi davranan ancak herhangi bir alan tüketmeyen sıfır uzunlukta bir dizi bildirebilirsiniz.

#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
    ....
};

Daha sonra çalışma zamanı onaylama kodunun bakımı çok daha kolay olacaktır:

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);