What’s the need of array with zero elements?

by

This is a way to have variable sizes of data, without having to call malloc (kmalloc in this case) twice. You would use it like this:

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

This used to be not standard and was considered a hack (as Aniket said), but it was standardized in C99. The standard format for it now is:

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

Note that you don’t mention any size for the data field. Note also that this special variable can only come at the end of the struct.

In C99, this matter is explained in 6.7.2.1.16 (emphasis mine):

As a special case, the last element of a structure with more than one named member may
have an incomplete array type; this is called a flexible array member. In most situations,
the flexible array member is ignored. In particular, the size of the structure is as if the
flexible array member were omitted except that it may have more trailing padding than
the omission would imply. However, when a . (or ->) operator has a left operand that is
(a pointer to) a structure with a flexible array member and the right operand names that
member, it behaves as if that member were replaced with the longest array (with the same
element type) that would not make the structure larger than the object being accessed; the
offset of the array shall remain that of the flexible array member, even if this would differ
from that of the replacement array. If this array would have no elements, it behaves as if
it had one element but the behavior is undefined if any attempt is made to access that
element or to generate a pointer one past it.

Or in other words, if you have:

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

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

You can access var->data with indices in [0, extra). Note that sizeof(struct something) will only give the size accounting for the other variables, i.e. gives data a size of 0.

It may be interesting also to note how the standard actually gives examples of mallocing such a construct (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]));

Another interesting note by the standard in the same location is (emphasis mine):

assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if p had been declared as:

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

(there are circumstances in which this equivalence is broken; in particular, the offsets of member d might not be the same).

More Related Contents:

  1. Access element of array of pointer of structure
  2. I need help trying to understand this piece of code about structures and pointers [closed]
  3. Structure padding and packing
  4. Is using flexible array members in C bad practice?
  5. Unsized array declaration in a struct
  6. Padding in structures in C
  7. Flexible array member in C-structure
  8. c structure array initializing
  9. C, reading from file into structure
  10. How to initialize a structure with flexible array member
  11. zero length arrays [duplicate]
  12. Writing and reading (fwrite – fread) structures with pointers
  13. Struct Inheritance in C
  14. Arrow Operator vs. Dot Operator [closed]
  15. Flexible array member not getting copied when I make a shallow copy of a struct
  16. Why does static initialization of flexible array member work?
  17. Assign string to element in structure in C
  18. How to declare a structure in a header that is to be used by multiple files in c?
  19. How can I get a text file into a string but whith the “\n” in C?
  20. Reading and analyzing rooms from text file
  21. How to read / parse input in C? The FAQ
  22. How can I suppress “unused parameter” warnings in C?
  23. Check substring exists in a string in C
  24. What does i = (i, ++i, 1) + 1; do?
  25. What is the purpose of the RBP register in x86_64 assembler?
  26. Scatter Matrix Blocks of Different Sizes using MPI
  27. fork and existing threads?
  28. Why we need Clobbered registers list in Inline Assembly?
  29. Using true and false in C
  30. How to set the IP address from C in linux

Leave a Comment