lib/kernel.ml

   1 (* WARNING: This file and the corresponding mli (interface) are
   2  * automatically generated by the extract/codegen/ program.
   3  *
   4  * Any edits you make to this file will be lost.
   5  *
   6  * To update this file from the latest kernel database, it is recommended
   7  * that you do 'make update-kernel-structs'.
   8  *)
   9
  10 type ('a, 'b) task_struct =
  11   { task_struct_shape : 'a; task_struct_content : 'b
  12   };;
  13 type task_struct_shape_fields_2 =
  14   { task_struct_shape_fields_2_tasks'next : Virt_mem_mmap.addr;
  15     task_struct_shape_fields_2_tasks'prev : Virt_mem_mmap.addr
  16   };;
  17 type task_struct_shape_fields_1 =
  18   { task_struct_shape_fields_1_run_list'next : Virt_mem_mmap.addr;
  19     task_struct_shape_fields_1_run_list'prev : Virt_mem_mmap.addr;
  20     task_struct_shape_fields_1_tasks'next : Virt_mem_mmap.addr;
  21     task_struct_shape_fields_1_tasks'prev : Virt_mem_mmap.addr
  22   };;
  23 type task_struct_content_fields_3 =
  24   { task_struct_content_fields_3_comm : string;
  25     task_struct_content_fields_3_normal_prio : int64;
  26     task_struct_content_fields_3_pid : int64;
  27     task_struct_content_fields_3_prio : int64;
  28     task_struct_content_fields_3_state : int64;
  29     task_struct_content_fields_3_static_prio : int64
  30   };;
  31 type ('a, 'b) net_device = { net_device_shape : 'a; net_device_content : 'b };;
  32 type net_device_shape_fields_12 =
  33   { net_device_shape_fields_12_ip6_ptr : Virt_mem_mmap.addr;
  34     net_device_shape_fields_12_ip_ptr : Virt_mem_mmap.addr;
  35     net_device_shape_fields_12_next : Virt_mem_mmap.addr
  36   };;
  37 type net_device_shape_fields_13 =
  38   { net_device_shape_fields_13_dev_list'next : Virt_mem_mmap.addr;
  39     net_device_shape_fields_13_dev_list'prev : Virt_mem_mmap.addr;
  40     net_device_shape_fields_13_ip6_ptr : Virt_mem_mmap.addr;
  41     net_device_shape_fields_13_ip_ptr : Virt_mem_mmap.addr
  42   };;
  43 type net_device_content_fields_14 =
  44   { net_device_content_fields_14_addr_len : int64;
  45     net_device_content_fields_14_flags : int64;
  46     net_device_content_fields_14_mtu : int64;
  47     net_device_content_fields_14_name : string;
  48     net_device_content_fields_14_operstate : int64;
  49     net_device_content_fields_14_perm_addr : string
  50   };;
  51 type ('a, 'b) net = { net_shape : 'a; net_content : 'b };;
  52 type net_shape_fields_22 =
  53   { net_shape_fields_22_dev_base_head'next : Virt_mem_mmap.addr;
  54     net_shape_fields_22_dev_base_head'prev : Virt_mem_mmap.addr
  55   };;
  56 type net_content_fields_23 = unit;;
  57 type ('a, 'b) in_device = { in_device_shape : 'a; in_device_content : 'b };;
  58 type in_device_shape_fields_28 =
  59   { in_device_shape_fields_28_ifa_list : Virt_mem_mmap.addr
  60   };;
  61 type in_device_content_fields_29 = unit;;
  62 type ('a, 'b) inet6_dev = { inet6_dev_shape : 'a; inet6_dev_content : 'b };;
  63 type inet6_dev_shape_fields_34 =
  64   { inet6_dev_shape_fields_34_addr_list : Virt_mem_mmap.addr
  65   };;
  66 type inet6_dev_content_fields_35 = unit;;
  67 type ('a, 'b) in_ifaddr = { in_ifaddr_shape : 'a; in_ifaddr_content : 'b };;
  68 type in_ifaddr_shape_fields_40 =
  69   { in_ifaddr_shape_fields_40_ifa_next : Virt_mem_mmap.addr
  70   };;
  71 type in_ifaddr_content_fields_41 =
  72   { in_ifaddr_content_fields_41_ifa_address : int64;
  73     in_ifaddr_content_fields_41_ifa_broadcast : int64;
  74     in_ifaddr_content_fields_41_ifa_local : int64;
  75     in_ifaddr_content_fields_41_ifa_mask : int64
  76   };;
  77 type ('a, 'b) inet6_ifaddr =
  78   { inet6_ifaddr_shape : 'a; inet6_ifaddr_content : 'b
  79   };;
  80 type inet6_ifaddr_shape_fields_46 =
  81   { inet6_ifaddr_shape_fields_46_lst_next : Virt_mem_mmap.addr
  82   };;
  83 type inet6_ifaddr_content_fields_47 =
  84   { inet6_ifaddr_content_fields_47_prefix_len : int64
  85   };;
  86 module StringMap = Map.Make(String);;
  87 let offset_of_net_device_dev_list'next =
  88   let map =
  89     StringMap.add "2.6.27-0.226.rc1.git5.fc10.ppc" 48
  90       (StringMap.add "2.6.26.1-9.fc9.ppc64" 72
  91          (StringMap.add "2.6.25.14-69.fc8.x86_64" 72
  92             (StringMap.add "2.6.24-0.167.rc8.git4.fc9.ppc64" 72
  93                (StringMap.add "2.6.22-0.23.rc7.git6.fc8.ppc" 48 StringMap.
  94                   empty))))
  95   in fun kernel_version -> StringMap.find kernel_version map;;
  96 let match_err = "failed to match kernel structure";;
  97 let zero = 0;;
  98 let task_struct_parser_4 kernel_version bits =
  99   bitmatch bits with
 100   | { state : zero+32 : offset(0), littleendian;
 101       prio : zero+32 : offset(192), littleendian;
 102       static_prio : zero+32 : offset(224), littleendian;
 103       normal_prio : zero+32 : offset(256), littleendian;
 104       run_list'next : zero+32 : offset(288), littleendian;
 105       run_list'prev : zero+32 : offset(320), littleendian;
 106       tasks'next : zero+32 : offset(992), littleendian;
 107       tasks'prev : zero+32 : offset(1024), littleendian;
 108       pid : zero+32 : offset(1344), littleendian;
 109       comm : 128 : offset(3232), string } ->
 110       let shape =
 111       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 112         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 113         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 114         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 115       let content =
 116       { task_struct_content_fields_3_comm = comm;
 117         task_struct_content_fields_3_normal_prio = normal_prio;
 118         task_struct_content_fields_3_pid = pid;
 119         task_struct_content_fields_3_prio = prio;
 120         task_struct_content_fields_3_state = state;
 121         task_struct_content_fields_3_static_prio = static_prio } in
 122       { task_struct_shape = shape; task_struct_content = content }
 123   | { _ } ->
 124       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_4", match_err));;
 125 let task_struct_parser_5 kernel_version bits =
 126   bitmatch bits with
 127   | { state : zero+64 : offset(0), bigendian;
 128       prio : zero+32 : offset(320), bigendian;
 129       static_prio : zero+32 : offset(352), bigendian;
 130       normal_prio : zero+32 : offset(384), bigendian;
 131       run_list'next : zero+64 : offset(448), bigendian;
 132       run_list'prev : zero+64 : offset(512), bigendian;
 133       tasks'next : zero+64 : offset(1600), bigendian;
 134       tasks'prev : zero+64 : offset(1664), bigendian;
 135       pid : zero+32 : offset(2208), bigendian;
 136       comm : 128 : offset(5440), string } ->
 137       let shape =
 138       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 139         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 140         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 141         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 142       let content =
 143       { task_struct_content_fields_3_comm = comm;
 144         task_struct_content_fields_3_normal_prio = normal_prio;
 145         task_struct_content_fields_3_pid = pid;
 146         task_struct_content_fields_3_prio = prio;
 147         task_struct_content_fields_3_state = state;
 148         task_struct_content_fields_3_static_prio = static_prio } in
 149       { task_struct_shape = shape; task_struct_content = content }
 150   | { _ } ->
 151       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_5", match_err));;
 152 let task_struct_parser_6 kernel_version bits =
 153   bitmatch bits with
 154   | { state : zero+64 : offset(0), littleendian;
 155       prio : zero+32 : offset(320), littleendian;
 156       static_prio : zero+32 : offset(352), littleendian;
 157       normal_prio : zero+32 : offset(384), littleendian;
 158       run_list'next : zero+64 : offset(448), littleendian;
 159       run_list'prev : zero+64 : offset(512), littleendian;
 160       tasks'next : zero+64 : offset(1536), littleendian;
 161       tasks'prev : zero+64 : offset(1600), littleendian;
 162       pid : zero+32 : offset(2144), littleendian;
 163       comm : 128 : offset(5440), string } ->
 164       let shape =
 165       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 166         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 167         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 168         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 169       let content =
 170       { task_struct_content_fields_3_comm = comm;
 171         task_struct_content_fields_3_normal_prio = normal_prio;
 172         task_struct_content_fields_3_pid = pid;
 173         task_struct_content_fields_3_prio = prio;
 174         task_struct_content_fields_3_state = state;
 175         task_struct_content_fields_3_static_prio = static_prio } in
 176       { task_struct_shape = shape; task_struct_content = content }
 177   | { _ } ->
 178       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_6", match_err));;
 179 let task_struct_parser_7 kernel_version bits =
 180   bitmatch bits with
 181   | { state : zero+32 : offset(0), bigendian;
 182       prio : zero+32 : offset(160), bigendian;
 183       static_prio : zero+32 : offset(192), bigendian;
 184       normal_prio : zero+32 : offset(224), bigendian;
 185       run_list'next : zero+32 : offset(256), bigendian;
 186       run_list'prev : zero+32 : offset(288), bigendian;
 187       tasks'next : zero+32 : offset(2176), bigendian;
 188       tasks'prev : zero+32 : offset(2208), bigendian;
 189       pid : zero+32 : offset(2528), bigendian;
 190       comm : 128 : offset(4416), string } ->
 191       let shape =
 192       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 193         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 194         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 195         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 196       let content =
 197       { task_struct_content_fields_3_comm = comm;
 198         task_struct_content_fields_3_normal_prio = normal_prio;
 199         task_struct_content_fields_3_pid = pid;
 200         task_struct_content_fields_3_prio = prio;
 201         task_struct_content_fields_3_state = state;
 202         task_struct_content_fields_3_static_prio = static_prio } in
 203       { task_struct_shape = shape; task_struct_content = content }
 204   | { _ } ->
 205       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_7", match_err));;
 206 let task_struct_parser_8 kernel_version bits =
 207   bitmatch bits with
 208   | { state : zero+64 : offset(0), bigendian;
 209       prio : zero+32 : offset(224), bigendian;
 210       static_prio : zero+32 : offset(256), bigendian;
 211       normal_prio : zero+32 : offset(288), bigendian;
 212       run_list'next : zero+64 : offset(320), bigendian;
 213       run_list'prev : zero+64 : offset(384), bigendian;
 214       tasks'next : zero+64 : offset(3648), bigendian;
 215       tasks'prev : zero+64 : offset(3712), bigendian;
 216       pid : zero+32 : offset(4160), bigendian;
 217       comm : 128 : offset(7752), string } ->
 218       let shape =
 219       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 220         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 221         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 222         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 223       let content =
 224       { task_struct_content_fields_3_comm = comm;
 225         task_struct_content_fields_3_normal_prio = normal_prio;
 226         task_struct_content_fields_3_pid = pid;
 227         task_struct_content_fields_3_prio = prio;
 228         task_struct_content_fields_3_state = state;
 229         task_struct_content_fields_3_static_prio = static_prio } in
 230       { task_struct_shape = shape; task_struct_content = content }
 231   | { _ } ->
 232       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_8", match_err));;
 233 let task_struct_parser_9 kernel_version bits =
 234   bitmatch bits with
 235   | { state : zero+64 : offset(0), littleendian;
 236       prio : zero+32 : offset(224), littleendian;
 237       static_prio : zero+32 : offset(256), littleendian;
 238       normal_prio : zero+32 : offset(288), littleendian;
 239       tasks'next : zero+64 : offset(3840), littleendian;
 240       tasks'prev : zero+64 : offset(3904), littleendian;
 241       pid : zero+32 : offset(4352), littleendian;
 242       comm : 128 : offset(8392), string } ->
 243       let shape =
 244       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 245         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 246       let content =
 247       { task_struct_content_fields_3_comm = comm;
 248         task_struct_content_fields_3_normal_prio = normal_prio;
 249         task_struct_content_fields_3_pid = pid;
 250         task_struct_content_fields_3_prio = prio;
 251         task_struct_content_fields_3_state = state;
 252         task_struct_content_fields_3_static_prio = static_prio } in
 253       { task_struct_shape = shape; task_struct_content = content }
 254   | { _ } ->
 255       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_9", match_err));;
 256 let task_struct_parser_10 kernel_version bits =
 257   bitmatch bits with
 258   | { state : zero+64 : offset(0), bigendian;
 259       prio : zero+32 : offset(256), bigendian;
 260       static_prio : zero+32 : offset(288), bigendian;
 261       normal_prio : zero+32 : offset(320), bigendian;
 262       tasks'next : zero+64 : offset(4096), bigendian;
 263       tasks'prev : zero+64 : offset(4160), bigendian;
 264       pid : zero+32 : offset(4608), bigendian;
 265       comm : 128 : offset(8712), string } ->
 266       let shape =
 267       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 268         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 269       let content =
 270       { task_struct_content_fields_3_comm = comm;
 271         task_struct_content_fields_3_normal_prio = normal_prio;
 272         task_struct_content_fields_3_pid = pid;
 273         task_struct_content_fields_3_prio = prio;
 274         task_struct_content_fields_3_state = state;
 275         task_struct_content_fields_3_static_prio = static_prio } in
 276       { task_struct_shape = shape; task_struct_content = content }
 277   | { _ } ->
 278       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_10", match_err));;
 279 let task_struct_parser_11 kernel_version bits =
 280   bitmatch bits with
 281   | { state : zero+32 : offset(0), bigendian;
 282       prio : zero+32 : offset(192), bigendian;
 283       static_prio : zero+32 : offset(224), bigendian;
 284       normal_prio : zero+32 : offset(256), bigendian;
 285       tasks'next : zero+32 : offset(3712), bigendian;
 286       tasks'prev : zero+32 : offset(3744), bigendian;
 287       pid : zero+32 : offset(4064), bigendian;
 288       comm : 128 : offset(6464), string } ->
 289       let shape =
 290       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 291         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 292       let content =
 293       { task_struct_content_fields_3_comm = comm;
 294         task_struct_content_fields_3_normal_prio = normal_prio;
 295         task_struct_content_fields_3_pid = pid;
 296         task_struct_content_fields_3_prio = prio;
 297         task_struct_content_fields_3_state = state;
 298         task_struct_content_fields_3_static_prio = static_prio } in
 299       { task_struct_shape = shape; task_struct_content = content }
 300   | { _ } ->
 301       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_11", match_err));;
 302 let net_device_parser_15 kernel_version bits =
 303   bitmatch bits with
 304   | { name : 128 : offset(0), string;
 305       next : zero+32 : offset(384), littleendian;
 306       flags : zero+32 : offset(704), littleendian;
 307       operstate : zero+8 : offset(784), littleendian;
 308       mtu : zero+32 : offset(800), littleendian;
 309       perm_addr : 256 : offset(896), string;
 310       addr_len : zero+8 : offset(1152), littleendian;
 311       ip_ptr : zero+32 : offset(1344), littleendian;
 312       ip6_ptr : zero+32 : offset(1408), littleendian } ->
 313       let shape =
 314       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 315         net_device_shape_fields_12_ip_ptr = ip_ptr;
 316         net_device_shape_fields_12_next = next } in
 317       let content =
 318       { net_device_content_fields_14_addr_len = addr_len;
 319         net_device_content_fields_14_flags = flags;
 320         net_device_content_fields_14_mtu = mtu;
 321         net_device_content_fields_14_name = name;
 322         net_device_content_fields_14_operstate = operstate;
 323         net_device_content_fields_14_perm_addr = perm_addr } in
 324       { net_device_shape = shape; net_device_content = content }
 325   | { _ } ->
 326       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_15", match_err));;
 327 let net_device_parser_16 kernel_version bits =
 328   bitmatch bits with
 329   | { name : 128 : offset(0), string;
 330       next : zero+64 : offset(576), bigendian;
 331       flags : zero+32 : offset(1152), bigendian;
 332       operstate : zero+8 : offset(1232), bigendian;
 333       mtu : zero+32 : offset(1248), bigendian;
 334       perm_addr : 256 : offset(1408), string;
 335       addr_len : zero+8 : offset(1664), bigendian;
 336       ip_ptr : zero+64 : offset(1984), bigendian;
 337       ip6_ptr : zero+64 : offset(2112), bigendian } ->
 338       let shape =
 339       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 340         net_device_shape_fields_12_ip_ptr = ip_ptr;
 341         net_device_shape_fields_12_next = next } in
 342       let content =
 343       { net_device_content_fields_14_addr_len = addr_len;
 344         net_device_content_fields_14_flags = flags;
 345         net_device_content_fields_14_mtu = mtu;
 346         net_device_content_fields_14_name = name;
 347         net_device_content_fields_14_operstate = operstate;
 348         net_device_content_fields_14_perm_addr = perm_addr } in
 349       { net_device_shape = shape; net_device_content = content }
 350   | { _ } ->
 351       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_16", match_err));;
 352 let net_device_parser_17 kernel_version bits =
 353   bitmatch bits with
 354   | { name : 128 : offset(0), string;
 355       next : zero+64 : offset(576), littleendian;
 356       flags : zero+32 : offset(1152), littleendian;
 357       operstate : zero+8 : offset(1232), littleendian;
 358       mtu : zero+32 : offset(1248), littleendian;
 359       perm_addr : 256 : offset(1408), string;
 360       addr_len : zero+8 : offset(1664), littleendian;
 361       ip_ptr : zero+64 : offset(1984), littleendian;
 362       ip6_ptr : zero+64 : offset(2112), littleendian } ->
 363       let shape =
 364       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 365         net_device_shape_fields_12_ip_ptr = ip_ptr;
 366         net_device_shape_fields_12_next = next } in
 367       let content =
 368       { net_device_content_fields_14_addr_len = addr_len;
 369         net_device_content_fields_14_flags = flags;
 370         net_device_content_fields_14_mtu = mtu;
 371         net_device_content_fields_14_name = name;
 372         net_device_content_fields_14_operstate = operstate;
 373         net_device_content_fields_14_perm_addr = perm_addr } in
 374       { net_device_shape = shape; net_device_content = content }
 375   | { _ } ->
 376       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_17", match_err));;
 377 let net_device_parser_18 kernel_version bits =
 378   bitmatch bits with
 379   | { name : 128 : offset(0), string;
 380       dev_list'next : zero+32 : offset(384), bigendian;
 381       dev_list'prev : zero+32 : offset(416), bigendian;
 382       flags : zero+32 : offset(1472), bigendian;
 383       operstate : zero+8 : offset(1552), bigendian;
 384       mtu : zero+32 : offset(1568), bigendian;
 385       perm_addr : 256 : offset(1664), string;
 386       addr_len : zero+8 : offset(1920), bigendian;
 387       ip_ptr : zero+32 : offset(2112), bigendian;
 388       ip6_ptr : zero+32 : offset(2176), bigendian } ->
 389       let shape =
 390       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 391         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 392         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 393         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 394       let content =
 395       { net_device_content_fields_14_addr_len = addr_len;
 396         net_device_content_fields_14_flags = flags;
 397         net_device_content_fields_14_mtu = mtu;
 398         net_device_content_fields_14_name = name;
 399         net_device_content_fields_14_operstate = operstate;
 400         net_device_content_fields_14_perm_addr = perm_addr } in
 401       { net_device_shape = shape; net_device_content = content }
 402   | { _ } ->
 403       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_18", match_err));;
 404 let net_device_parser_19 kernel_version bits =
 405   bitmatch bits with
 406   | { name : 128 : offset(0), string;
 407       dev_list'next : zero+64 : offset(576), bigendian;
 408       dev_list'prev : zero+64 : offset(640), bigendian;
 409       flags : zero+32 : offset(2880), bigendian;
 410       operstate : zero+8 : offset(2960), bigendian;
 411       mtu : zero+32 : offset(2976), bigendian;
 412       perm_addr : 256 : offset(3136), string;
 413       addr_len : zero+8 : offset(3392), bigendian;
 414       ip_ptr : zero+64 : offset(3840), bigendian;
 415       ip6_ptr : zero+64 : offset(3968), bigendian } ->
 416       let shape =
 417       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 418         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 419         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 420         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 421       let content =
 422       { net_device_content_fields_14_addr_len = addr_len;
 423         net_device_content_fields_14_flags = flags;
 424         net_device_content_fields_14_mtu = mtu;
 425         net_device_content_fields_14_name = name;
 426         net_device_content_fields_14_operstate = operstate;
 427         net_device_content_fields_14_perm_addr = perm_addr } in
 428       { net_device_shape = shape; net_device_content = content }
 429   | { _ } ->
 430       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_19", match_err));;
 431 let net_device_parser_20 kernel_version bits =
 432   bitmatch bits with
 433   | { name : 128 : offset(0), string;
 434       dev_list'next : zero+64 : offset(576), littleendian;
 435       dev_list'prev : zero+64 : offset(640), littleendian;
 436       flags : zero+32 : offset(2880), littleendian;
 437       operstate : zero+8 : offset(2960), littleendian;
 438       mtu : zero+32 : offset(2976), littleendian;
 439       perm_addr : 256 : offset(3136), string;
 440       addr_len : zero+8 : offset(3392), littleendian;
 441       ip_ptr : zero+64 : offset(3840), littleendian;
 442       ip6_ptr : zero+64 : offset(3968), littleendian } ->
 443       let shape =
 444       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 445         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 446         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 447         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 448       let content =
 449       { net_device_content_fields_14_addr_len = addr_len;
 450         net_device_content_fields_14_flags = flags;
 451         net_device_content_fields_14_mtu = mtu;
 452         net_device_content_fields_14_name = name;
 453         net_device_content_fields_14_operstate = operstate;
 454         net_device_content_fields_14_perm_addr = perm_addr } in
 455       { net_device_shape = shape; net_device_content = content }
 456   | { _ } ->
 457       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_20", match_err));;
 458 let net_device_parser_21 kernel_version bits =
 459   bitmatch bits with
 460   | { name : 128 : offset(0), string;
 461       dev_list'next : zero+32 : offset(384), bigendian;
 462       dev_list'prev : zero+32 : offset(416), bigendian;
 463       flags : zero+32 : offset(1536), bigendian;
 464       operstate : zero+8 : offset(1616), bigendian;
 465       mtu : zero+32 : offset(1632), bigendian;
 466       perm_addr : 256 : offset(1760), string;
 467       addr_len : zero+8 : offset(2016), bigendian;
 468       ip_ptr : zero+32 : offset(2432), bigendian;
 469       ip6_ptr : zero+32 : offset(2496), bigendian } ->
 470       let shape =
 471       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 472         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 473         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 474         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 475       let content =
 476       { net_device_content_fields_14_addr_len = addr_len;
 477         net_device_content_fields_14_flags = flags;
 478         net_device_content_fields_14_mtu = mtu;
 479         net_device_content_fields_14_name = name;
 480         net_device_content_fields_14_operstate = operstate;
 481         net_device_content_fields_14_perm_addr = perm_addr } in
 482       { net_device_shape = shape; net_device_content = content }
 483   | { _ } ->
 484       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_21", match_err));;
 485 let net_parser_24 kernel_version bits =
 486   bitmatch bits with
 487   | { dev_base_head'next : zero+64 : offset(704), bigendian;
 488       dev_base_head'prev : zero+64 : offset(768), bigendian } ->
 489       let shape =
 490       { net_shape_fields_22_dev_base_head'next = (
 491                       let offset = offset_of_net_device_dev_list'next kernel_version in
 492                       let offset = Int64.of_int offset in
 493                       Int64.sub dev_base_head'next offset
 494                     );
 495         net_shape_fields_22_dev_base_head'prev = (
 496                       let offset = offset_of_net_device_dev_list'next kernel_version in
 497                       let offset = Int64.of_int offset in
 498                       Int64.sub dev_base_head'prev offset
 499                     ) } in
 500       let content =
 501       () in
 502       { net_shape = shape; net_content = content }
 503   | { _ } ->
 504       raise (Virt_mem_types.ParseError ("net", "net_parser_24", match_err));;
 505 let net_parser_25 kernel_version bits =
 506   bitmatch bits with
 507   | { dev_base_head'next : zero+64 : offset(768), littleendian;
 508       dev_base_head'prev : zero+64 : offset(832), littleendian } ->
 509       let shape =
 510       { net_shape_fields_22_dev_base_head'next = (
 511                       let offset = offset_of_net_device_dev_list'next kernel_version in
 512                       let offset = Int64.of_int offset in
 513                       Int64.sub dev_base_head'next offset
 514                     );
 515         net_shape_fields_22_dev_base_head'prev = (
 516                       let offset = offset_of_net_device_dev_list'next kernel_version in
 517                       let offset = Int64.of_int offset in
 518                       Int64.sub dev_base_head'prev offset
 519                     ) } in
 520       let content =
 521       () in
 522       { net_shape = shape; net_content = content }
 523   | { _ } ->
 524       raise (Virt_mem_types.ParseError ("net", "net_parser_25", match_err));;
 525 let net_parser_26 kernel_version bits =
 526   bitmatch bits with
 527   | { dev_base_head'next : zero+64 : offset(768), bigendian;
 528       dev_base_head'prev : zero+64 : offset(832), bigendian } ->
 529       let shape =
 530       { net_shape_fields_22_dev_base_head'next = (
 531                       let offset = offset_of_net_device_dev_list'next kernel_version in
 532                       let offset = Int64.of_int offset in
 533                       Int64.sub dev_base_head'next offset
 534                     );
 535         net_shape_fields_22_dev_base_head'prev = (
 536                       let offset = offset_of_net_device_dev_list'next kernel_version in
 537                       let offset = Int64.of_int offset in
 538                       Int64.sub dev_base_head'prev offset
 539                     ) } in
 540       let content =
 541       () in
 542       { net_shape = shape; net_content = content }
 543   | { _ } ->
 544       raise (Virt_mem_types.ParseError ("net", "net_parser_26", match_err));;
 545 let net_parser_27 kernel_version bits =
 546   bitmatch bits with
 547   | { dev_base_head'next : zero+32 : offset(448), bigendian;
 548       dev_base_head'prev : zero+32 : offset(480), bigendian } ->
 549       let shape =
 550       { net_shape_fields_22_dev_base_head'next = (
 551                       let offset = offset_of_net_device_dev_list'next kernel_version in
 552                       let offset = Int64.of_int offset in
 553                       Int64.sub dev_base_head'next offset
 554                     );
 555         net_shape_fields_22_dev_base_head'prev = (
 556                       let offset = offset_of_net_device_dev_list'next kernel_version in
 557                       let offset = Int64.of_int offset in
 558                       Int64.sub dev_base_head'prev offset
 559                     ) } in
 560       let content =
 561       () in
 562       { net_shape = shape; net_content = content }
 563   | { _ } ->
 564       raise (Virt_mem_types.ParseError ("net", "net_parser_27", match_err));;
 565 let in_device_parser_30 kernel_version bits =
 566   bitmatch bits with
 567   | { ifa_list : zero+32 : offset(96), littleendian } ->
 568       let shape =
 569       { in_device_shape_fields_28_ifa_list = ifa_list } in
 570       let content =
 571       () in
 572       { in_device_shape = shape; in_device_content = content }
 573   | { _ } ->
 574       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_30", match_err));;
 575 let in_device_parser_33 kernel_version bits =
 576   bitmatch bits with
 577   | { ifa_list : zero+32 : offset(96), bigendian } ->
 578       let shape =
 579       { in_device_shape_fields_28_ifa_list = ifa_list } in
 580       let content =
 581       () in
 582       { in_device_shape = shape; in_device_content = content }
 583   | { _ } ->
 584       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_33", match_err));;
 585 let in_device_parser_32 kernel_version bits =
 586   bitmatch bits with
 587   | { ifa_list : zero+64 : offset(128), littleendian } ->
 588       let shape =
 589       { in_device_shape_fields_28_ifa_list = ifa_list } in
 590       let content =
 591       () in
 592       { in_device_shape = shape; in_device_content = content }
 593   | { _ } ->
 594       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_32", match_err));;
 595 let in_device_parser_31 kernel_version bits =
 596   bitmatch bits with
 597   | { ifa_list : zero+64 : offset(128), bigendian } ->
 598       let shape =
 599       { in_device_shape_fields_28_ifa_list = ifa_list } in
 600       let content =
 601       () in
 602       { in_device_shape = shape; in_device_content = content }
 603   | { _ } ->
 604       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_31", match_err));;
 605 let inet6_dev_parser_36 kernel_version bits =
 606   bitmatch bits with
 607   | { addr_list : zero+32 : offset(32), littleendian } ->
 608       let shape =
 609       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 610       let content =
 611       () in
 612       { inet6_dev_shape = shape; inet6_dev_content = content }
 613   | { _ } ->
 614       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_36", match_err));;
 615 let inet6_dev_parser_39 kernel_version bits =
 616   bitmatch bits with
 617   | { addr_list : zero+32 : offset(32), bigendian } ->
 618       let shape =
 619       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 620       let content =
 621       () in
 622       { inet6_dev_shape = shape; inet6_dev_content = content }
 623   | { _ } ->
 624       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_39", match_err));;
 625 let inet6_dev_parser_38 kernel_version bits =
 626   bitmatch bits with
 627   | { addr_list : zero+64 : offset(64), littleendian } ->
 628       let shape =
 629       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 630       let content =
 631       () in
 632       { inet6_dev_shape = shape; inet6_dev_content = content }
 633   | { _ } ->
 634       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_38", match_err));;
 635 let inet6_dev_parser_37 kernel_version bits =
 636   bitmatch bits with
 637   | { addr_list : zero+64 : offset(64), bigendian } ->
 638       let shape =
 639       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 640       let content =
 641       () in
 642       { inet6_dev_shape = shape; inet6_dev_content = content }
 643   | { _ } ->
 644       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_37", match_err));;
 645 let in_ifaddr_parser_42 kernel_version bits =
 646   bitmatch bits with
 647   | { ifa_next : zero+32 : offset(0), littleendian;
 648       ifa_local : zero+32 : offset(128), littleendian;
 649       ifa_address : zero+32 : offset(160), littleendian;
 650       ifa_mask : zero+32 : offset(192), littleendian;
 651       ifa_broadcast : zero+32 : offset(224), littleendian } ->
 652       let shape =
 653       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 654       let content =
 655       { in_ifaddr_content_fields_41_ifa_address = ifa_address;
 656         in_ifaddr_content_fields_41_ifa_broadcast = ifa_broadcast;
 657         in_ifaddr_content_fields_41_ifa_local = ifa_local;
 658         in_ifaddr_content_fields_41_ifa_mask = ifa_mask } in
 659       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 660   | { _ } ->
 661       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_42", match_err));;
 662 let in_ifaddr_parser_45 kernel_version bits =
 663   bitmatch bits with
 664   | { ifa_next : zero+32 : offset(0), bigendian;
 665       ifa_local : zero+32 : offset(128), bigendian;
 666       ifa_address : zero+32 : offset(160), bigendian;
 667       ifa_mask : zero+32 : offset(192), bigendian;
 668       ifa_broadcast : zero+32 : offset(224), bigendian } ->
 669       let shape =
 670       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 671       let content =
 672       { in_ifaddr_content_fields_41_ifa_address = ifa_address;
 673         in_ifaddr_content_fields_41_ifa_broadcast = ifa_broadcast;
 674         in_ifaddr_content_fields_41_ifa_local = ifa_local;
 675         in_ifaddr_content_fields_41_ifa_mask = ifa_mask } in
 676       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 677   | { _ } ->
 678       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_45", match_err));;
 679 let in_ifaddr_parser_43 kernel_version bits =
 680   bitmatch bits with
 681   | { ifa_next : zero+64 : offset(0), bigendian;
 682       ifa_local : zero+32 : offset(256), bigendian;
 683       ifa_address : zero+32 : offset(288), bigendian;
 684       ifa_mask : zero+32 : offset(320), bigendian;
 685       ifa_broadcast : zero+32 : offset(352), bigendian } ->
 686       let shape =
 687       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 688       let content =
 689       { in_ifaddr_content_fields_41_ifa_address = ifa_address;
 690         in_ifaddr_content_fields_41_ifa_broadcast = ifa_broadcast;
 691         in_ifaddr_content_fields_41_ifa_local = ifa_local;
 692         in_ifaddr_content_fields_41_ifa_mask = ifa_mask } in
 693       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 694   | { _ } ->
 695       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_43", match_err));;
 696 let in_ifaddr_parser_44 kernel_version bits =
 697   bitmatch bits with
 698   | { ifa_next : zero+64 : offset(0), littleendian;
 699       ifa_local : zero+32 : offset(256), littleendian;
 700       ifa_address : zero+32 : offset(288), littleendian;
 701       ifa_mask : zero+32 : offset(320), littleendian;
 702       ifa_broadcast : zero+32 : offset(352), littleendian } ->
 703       let shape =
 704       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 705       let content =
 706       { in_ifaddr_content_fields_41_ifa_address = ifa_address;
 707         in_ifaddr_content_fields_41_ifa_broadcast = ifa_broadcast;
 708         in_ifaddr_content_fields_41_ifa_local = ifa_local;
 709         in_ifaddr_content_fields_41_ifa_mask = ifa_mask } in
 710       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 711   | { _ } ->
 712       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_44", match_err));;
 713 let inet6_ifaddr_parser_48 kernel_version bits =
 714   bitmatch bits with
 715   | { prefix_len : zero+32 : offset(128), littleendian;
 716       lst_next : zero+32 : offset(1024), littleendian } ->
 717       let shape =
 718       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 719       let content =
 720       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 721       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 722   | { _ } ->
 723       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_48", match_err));;
 724 let inet6_ifaddr_parser_50 kernel_version bits =
 725   bitmatch bits with
 726   | { prefix_len : zero+32 : offset(128), littleendian;
 727       lst_next : zero+64 : offset(1856), littleendian } ->
 728       let shape =
 729       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 730       let content =
 731       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 732       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 733   | { _ } ->
 734       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_50", match_err));;
 735 let inet6_ifaddr_parser_49 kernel_version bits =
 736   bitmatch bits with
 737   | { prefix_len : zero+32 : offset(128), bigendian;
 738       lst_next : zero+64 : offset(1472), bigendian } ->
 739       let shape =
 740       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 741       let content =
 742       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 743       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 744   | { _ } ->
 745       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_49", match_err));;
 746 let inet6_ifaddr_parser_51 kernel_version bits =
 747   bitmatch bits with
 748   | { prefix_len : zero+32 : offset(128), littleendian;
 749       lst_next : zero+64 : offset(1472), littleendian } ->
 750       let shape =
 751       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 752       let content =
 753       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 754       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 755   | { _ } ->
 756       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_51", match_err));;
 757 let inet6_ifaddr_parser_52 kernel_version bits =
 758   bitmatch bits with
 759   | { prefix_len : zero+32 : offset(128), bigendian;
 760       lst_next : zero+32 : offset(928), bigendian } ->
 761       let shape =
 762       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 763       let content =
 764       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 765       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 766   | { _ } ->
 767       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_52", match_err));;
 768 let inet6_ifaddr_parser_53 kernel_version bits =
 769   bitmatch bits with
 770   | { prefix_len : zero+32 : offset(128), littleendian;
 771       lst_next : zero+64 : offset(1280), littleendian } ->
 772       let shape =
 773       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 774       let content =
 775       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 776       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 777   | { _ } ->
 778       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_53", match_err));;
 779 let inet6_ifaddr_parser_54 kernel_version bits =
 780   bitmatch bits with
 781   | { prefix_len : zero+32 : offset(128), bigendian;
 782       lst_next : zero+64 : offset(1280), bigendian } ->
 783       let shape =
 784       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 785       let content =
 786       { inet6_ifaddr_content_fields_47_prefix_len = prefix_len } in
 787       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 788   | { _ } ->
 789       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_54", match_err));;