¿Cuál es la necesidad de una matriz con elementos cero?

En el código del kernel de Linux encontré lo siguiente que no puedo entender.

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

El código está aquí: http://lxr.free-electrons.com/source/include/linux/ti_wilink_st.h

¿Cuál es la necesidad y el propósito de una matriz de datos con cero elementos?

Esta es una forma de tener tamaños variables de datos, sin tener que llamar malloc( kmallocen este caso) dos veces. Lo usarías así:

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

Esto solía no ser estándar y se consideraba un truco (como dijo Aniket), pero estaba estandarizado en C99 . El formato estándar para él ahora es:

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

Tenga en cuenta que no menciona ningún tamaño para el datacampo. Tenga en cuenta también que esta variable especial solo puede aparecer al final de la estructura.

En C99, este asunto se explica en 6.7.2.1.16 (énfasis mío):

Como caso especial, el último elemento de una estructura con más de un miembro nombrado puede tener un tipo de matriz incompleta; esto se llama un miembro de matriz flexible. En la mayoría de situaciones, se ignora el miembro de matriz flexible. En particular, el tamaño de la estructura es como si se omitiera el miembro de matriz flexible, excepto que puede tener más relleno final del que implicaría la omisión. Sin embargo, cuando a. (o ->) el operador tiene un operando izquierdo que es (un puntero a) una estructura con un miembro de matriz flexible y el operando derecho nombra ese miembro, se comporta como si ese miembro fuera reemplazado por la matriz más larga (con el mismo tipo de elemento ) que no agrandaría la estructura que el objeto al que se accede; el desplazamiento de la matriz seguirá siendo el del miembro de la matriz flexible, incluso si esto difiera de la de la matriz de reemplazo. Si esta matriz no tuviera elementos,

O en otras palabras, si tiene:

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

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

Puedes acceder var->datacon índices en formato [0, extra). Tenga en cuenta que sizeof(struct something)solo dará el tamaño teniendo en cuenta las otras variables, es decir, da dataun tamaño de 0.

También puede ser interesante observar cómo el estándar realmente da ejemplos de malloctal construcción (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]));

Otra nota interesante por el estándar en la misma ubicación es (énfasis mío):

asumiendo que la llamada a malloc tiene éxito, el objeto apuntado por p se comporta, para la mayoría de los propósitos, como si p se hubiera declarado como:

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

(hay circunstancias en las que se rompe esta equivalencia; en particular, las compensaciones del miembro d pueden no ser las mismas ).

Este es un truco en realidad, de hecho para GCC ( C90 ).

También se llama truco de estructura .

Entonces, la próxima vez, diría:

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

Sería equivalente a decir:

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

Y puedo crear cualquier número de tales objetos de estructura.

La idea es permitir una matriz de tamaño variable al final de la estructura. Presumiblemente, bts_actiones un paquete de datos con un encabezado de tamaño fijo (los campos typey size) y un datamiembro de tamaño variable . Al declararlo como una matriz de longitud 0, se puede indexar como cualquier otra matriz. Luego, asignaría una bts_actionestructura, por ejemplo, de 1024 bytes de datatamaño, así:

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

Véase también: http://c2.com/cgi/wiki?StructHack

El código no es válido C ( ver esto ). El kernel de Linux, por razones obvias, no se preocupa en lo más mínimo por la portabilidad, por lo que utiliza mucho código no estándar.

Lo que están haciendo es una extensión no estándar de GCC con un tamaño de matriz 0. Un programa compatible con el estándar se habría escrito u8 data[];y habría significado exactamente lo mismo. A los autores del kernel de Linux aparentemente les encanta hacer las cosas innecesariamente complicadas y no estándar, si se revela una opción para hacerlo.

En los estándares C más antiguos, terminar una estructura con una matriz vacía se conocía como "el truco de estructura". Otros ya han explicado su propósito en otras respuestas. El hack de struct, en el estándar C90, era un comportamiento indefinido y podría causar bloqueos, principalmente porque un compilador de C es libre de agregar cualquier número de bytes de relleno al final de la estructura. Estos bytes de relleno pueden colisionar con los datos que intentó "piratear" al final de la estructura.

GCC al principio hizo una extensión no estándar para cambiar este comportamiento de indefinido a bien definido. Luego, el estándar C99 adaptó este concepto y, por lo tanto, cualquier programa C moderno puede utilizar esta función sin riesgo. Se conoce como miembro de matriz flexible en C99 / C11.

Otro uso de la matriz de longitud cero es como una etiqueta con nombre dentro de una estructura para ayudar a compilar la verificación de compensación de la estructura en el tiempo.

Suponga que tiene algunas definiciones de estructuras grandes (abarcan varias líneas de caché) que desea asegurarse de que estén alineadas con el límite de la línea de caché tanto al principio como en el medio donde cruza el límite.

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

En el código, puede declararlos usando extensiones GCC como:

__attribute__((aligned(CACHE_LINE_BYTES)))

Pero aún desea asegurarse de que esto se aplique en tiempo de ejecución.

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

Esto funcionaría para una sola estructura, pero sería difícil cubrir muchas estructuras, cada una tiene un nombre de miembro diferente para alinear. Lo más probable es que obtenga un código como el siguiente, donde tiene que encontrar los nombres del primer miembro de cada estructura:

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

En lugar de ir de esta manera, puede declarar una matriz de longitud cero en la estructura que actúa como una etiqueta con nombre con un nombre coherente pero no consume ningún espacio.

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

Entonces el código de aserción en tiempo de ejecución sería mucho más fácil de mantener:

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