Qual é a necessidade de um array com zero elementos?

No código do kernel do Linux, encontrei a seguinte coisa que não consigo entender.

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

O código está aqui: http://lxr.free-electrons.com/source/include/linux/ti_wilink_st.h

Qual é a necessidade e o objetivo de uma matriz de dados com zero elementos?

Essa é uma maneira de ter tamanhos variáveis ​​de dados, sem precisar chamar malloc( kmallocnesse caso) duas vezes. Você usaria assim:

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

Isso costumava não ser padrão e era considerado um hack (como disse Aniket), mas era padronizado no C99 . O formato padrão para ele agora é:

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

Observe que você não menciona nenhum tamanho para o datacampo. Observe também que essa variável especial pode vir apenas no final da estrutura.

Em C99, esse assunto é explicado em 6.7.2.1.16 (grifo meu):

Como um caso especial, o último elemento de uma estrutura com mais de um membro nomeado pode ter um tipo de matriz incompleto; isso é chamado de membro flexível da matriz. Na maioria das situações, o membro flexível da matriz é ignorado. Em particular, o tamanho da estrutura é como se o membro da matriz flexível fosse omitido, exceto que ele pode ter mais preenchimento à direita do que a omissão implicaria. No entanto, quando a. O operador (ou ->) possui um operando esquerdo que é (um ponteiro para) uma estrutura com um membro flexível da matriz e o operando direito nomeia esse membro, se comporta como se esse membro fosse substituído pela matriz mais longa (com o mesmo tipo de elemento ) que não tornariam a estrutura maior que o objeto que está sendo acessado; o deslocamento da matriz deve permanecer o do membro flexível da matriz, mesmo que isso seja diferente do da matriz de substituição. Se essa matriz não tiver elementos,

Ou, em outras palavras, se você tiver:

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

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

Você pode acessar var->datacom índices em [0, extra). Observe que sizeof(struct something)apenas o tamanho é responsável pelas demais variáveis, ou seja, o datatamanho é 0.

Também pode ser interessante observar como o padrão realmente fornece exemplos de malloctais construções (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]));

Outra observação interessante do padrão no mesmo local é (ênfase minha):

supondo que a chamada ao malloc tenha êxito, o objeto apontado por p se comporta, para a maioria dos propósitos, como se p tivesse sido declarado como:

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

(há circunstâncias em que essa equivalência é quebrada; em particular, as compensações do membro d podem não ser as mesmas ).

Na verdade, esse é um truque, para o GCC ( C90 ).

Também é chamado de struct hack .

Então, da próxima vez, eu diria:

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

Será equivalente a dizer:

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

E eu posso criar qualquer número desses objetos struct.

A idéia é permitir uma matriz de tamanho variável no final da estrutura. Presumivelmente, bts_actionhá alguns pacotes de dados com um cabeçalho de tamanho fixo (os campos typee size) e um datamembro de tamanho variável . Ao declará-lo como uma matriz de comprimento 0, pode ser indexado como qualquer outra matriz. Você bts_actionalocaria uma estrutura, com datatamanho de 1024 bytes , da seguinte forma:

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

Veja também: http://c2.com/cgi/wiki?StructHack

O código não é válido C ( veja isso ). O kernel do Linux, por razões óbvias, não se preocupa nem um pouco com a portabilidade, por isso usa bastante código não-padrão.

O que eles estão fazendo é uma extensão não-padrão do GCC com tamanho de matriz 0. Um programa compatível com o padrão teria sido escrito u8 data[];e significaria o mesmo. Os autores do kernel Linux aparentemente adoram tornar as coisas desnecessariamente complicadas e não padronizadas, se uma opção para isso se revelar.

Nos padrões C mais antigos, o final de uma estrutura com uma matriz vazia era conhecido como "o truque da estrutura". Outros já explicaram seu objetivo em outras respostas. O truque de estrutura, no padrão C90, era um comportamento indefinido e poderia causar falhas, principalmente porque um compilador C é livre para adicionar qualquer número de bytes de preenchimento no final da estrutura. Esses bytes de preenchimento podem colidir com os dados que você tentou "invadir" no final da estrutura.

No início, o GCC fez uma extensão não padrão para alterar esse comportamento de indefinido para bem definido. O padrão C99 adaptou esse conceito e qualquer programa C moderno pode, portanto, usar esse recurso sem risco. É conhecido como membro flexível da matriz em C99 / C11.

Outro uso da matriz de comprimento zero é como um rótulo nomeado dentro de uma estrutura para auxiliar na verificação do deslocamento da estrutura do tempo de compilação.

Suponha que você tenha algumas definições grandes de estrutura (que abrangem várias linhas de cache) que deseja garantir que elas estejam alinhadas ao cache da fronteira da linha, tanto no começo quanto no meio em que ela cruza a fronteira.

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

No código, você pode declará-las usando extensões do GCC, como:

__attribute__((aligned(CACHE_LINE_BYTES)))

Mas você ainda deseja garantir que isso seja imposto em tempo de execução.

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

Isso funcionaria para uma única estrutura, mas seria difícil cobrir muitas estruturas, cada uma com um nome de membro diferente a ser alinhado. Você provavelmente obteria código como abaixo, onde você precisa encontrar os nomes do primeiro membro de cada estrutura:

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

Em vez de seguir esse caminho, você pode declarar uma matriz de comprimento zero na estrutura, atuando como um rótulo nomeado com um nome consistente, mas não consome nenhum espaço.

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

Então, o código de asserção de tempo de execução seria muito mais fácil de manter:

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