Commit 02a562bb authored by Jakub Kicinski's avatar Jakub Kicinski Committed by Paolo Abeni
Browse files

tools: ynl-gen: support sub-type for binary attributes 



Sub-type annotation on binary attributes may indicate that the attribute
carries an array of simple types (also referred to as "C array" in docs).
Support rendering them as such in the C user code. For example for u32,
instead of:

  struct {
    u32 arr;
  } _len;

  void *arr;

render:

  struct {
    u32 arr;
  } _count;

  __u32 *arr;

Note that count is the number of elements while len was the length in bytes.

Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
Reviewed-by: default avatarDonald Hunter <donald.hunter@gmail.com>
Link: https://patch.msgid.link/20250509154213.1747885-2-kuba@kernel.org


Signed-off-by: default avatarPaolo Abeni <pabeni@redhat.com>
parent ac4d1baf

tools/net/ynl/pyynl/ynl_gen_c.py

+40 −3
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ class Type(SpecAttr): 
        return False



    def _free_lines(self, ri, var, ref):

        if self.is_multi_val() or self.presence_type() == 'len':

        if self.is_multi_val() or self.presence_type() in {'count', 'len'}:

            return [f'free({var}->{ref}{self.c_name});']

        return []
@@ -566,6 +566,40 @@ class TypeBinary(Type): 
                f'memcpy({member}, {self.c_name}, {presence});']





class TypeBinaryScalarArray(TypeBinary):

    def arg_member(self, ri):

        return [f'__{self.get("sub-type")} *{self.c_name}', 'size_t count']



    def presence_type(self):

        return 'count'



    def struct_member(self, ri):

        ri.cw.p(f'__{self.get("sub-type")} *{self.c_name};')



    def attr_put(self, ri, var):

        presence = self.presence_type()

        ri.cw.block_start(line=f"if ({var}->_{presence}.{self.c_name})")

        ri.cw.p(f"i = {var}->_{presence}.{self.c_name} * sizeof(__{self.get('sub-type')});")

        ri.cw.p(f"ynl_attr_put(nlh, {self.enum_name}, " +

                f"{var}->{self.c_name}, i);")

        ri.cw.block_end()



    def _attr_get(self, ri, var):

        len_mem = var + '->_count.' + self.c_name

        return [f"{len_mem} = len / sizeof(__{self.get('sub-type')});",

                f"len = {len_mem} * sizeof(__{self.get('sub-type')});",

                f"{var}->{self.c_name} = malloc(len);",

                f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \

               ['len = ynl_attr_data_len(attr);'], \

               ['unsigned int len;']



    def _setter_lines(self, ri, member, presence):

        return [f"{presence} = count;",

                f"count *= sizeof(__{self.get('sub-type')});",

                f"{member} = malloc(count);",

                f'memcpy({member}, {self.c_name}, count);']





class TypeBitfield32(Type):

    def _complex_member_type(self, ri):

        return "struct nla_bitfield32"
@@ -672,7 +706,7 @@ class TypeMultiAttr(Type): 
        lines = []

        if self.attr['type'] in scalars:

            lines += [f"free({var}->{ref}{self.c_name});"]

        elif self.attr['type'] == 'binary' and 'struct' in self.attr:

        elif self.attr['type'] == 'binary':

            lines += [f"free({var}->{ref}{self.c_name});"]

        elif self.attr['type'] == 'string':

            lines += [
@@ -976,6 +1010,9 @@ class AttrSet(SpecAttrSet): 
        elif elem['type'] == 'string':

            t = TypeString(self.family, self, elem, value)

        elif elem['type'] == 'binary':

            if elem.get('sub-type') in scalars:

                t = TypeBinaryScalarArray(self.family, self, elem, value)

            else:

                t = TypeBinary(self.family, self, elem, value)

        elif elem['type'] == 'bitfield32':

            t = TypeBitfield32(self.family, self, elem, value)