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 let match_err = "failed to match kernel structure";;
  87 let zero = 0;;
  88 let task_struct_parser_4 bits =
  89   bitmatch bits with
  90   | { state : zero+32 : offset(0), littleendian;
  91       prio : zero+32 : offset(192), littleendian;
  92       static_prio : zero+32 : offset(224), littleendian;
  93       normal_prio : zero+32 : offset(256), littleendian;
  94       run_list'next : zero+32 : offset(288), littleendian;
  95       run_list'prev : zero+32 : offset(320), littleendian;
  96       tasks'next : zero+32 : offset(992), littleendian;
  97       tasks'prev : zero+32 : offset(1024), littleendian;
  98       pid : zero+32 : offset(1344), littleendian;
  99       comm : 128 : offset(3232), string } ->
 100       let shape =
 101       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 102         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 103         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 104         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 105       let content =
 106       { task_struct_shape_fields_1_run_list'next = run_list'next;
 107         task_struct_shape_fields_1_run_list'prev = run_list'prev;
 108         task_struct_shape_fields_1_tasks'next = tasks'next;
 109         task_struct_shape_fields_1_tasks'prev = tasks'prev } in
 110       { task_struct_shape = shape; task_struct_content = content }
 111   | { _ } ->
 112       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_4", match_err));;
 113 let task_struct_parser_5 bits =
 114   bitmatch bits with
 115   | { state : zero+64 : offset(0), bigendian;
 116       prio : zero+32 : offset(320), bigendian;
 117       static_prio : zero+32 : offset(352), bigendian;
 118       normal_prio : zero+32 : offset(384), bigendian;
 119       run_list'next : zero+64 : offset(448), bigendian;
 120       run_list'prev : zero+64 : offset(512), bigendian;
 121       tasks'next : zero+64 : offset(1600), bigendian;
 122       tasks'prev : zero+64 : offset(1664), bigendian;
 123       pid : zero+32 : offset(2208), bigendian;
 124       comm : 128 : offset(5440), string } ->
 125       let shape =
 126       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 127         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 128         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 129         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 130       let content =
 131       { task_struct_shape_fields_1_run_list'next = run_list'next;
 132         task_struct_shape_fields_1_run_list'prev = run_list'prev;
 133         task_struct_shape_fields_1_tasks'next = tasks'next;
 134         task_struct_shape_fields_1_tasks'prev = tasks'prev } in
 135       { task_struct_shape = shape; task_struct_content = content }
 136   | { _ } ->
 137       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_5", match_err));;
 138 let task_struct_parser_6 bits =
 139   bitmatch bits with
 140   | { state : zero+64 : offset(0), littleendian;
 141       prio : zero+32 : offset(320), littleendian;
 142       static_prio : zero+32 : offset(352), littleendian;
 143       normal_prio : zero+32 : offset(384), littleendian;
 144       run_list'next : zero+64 : offset(448), littleendian;
 145       run_list'prev : zero+64 : offset(512), littleendian;
 146       tasks'next : zero+64 : offset(1536), littleendian;
 147       tasks'prev : zero+64 : offset(1600), littleendian;
 148       pid : zero+32 : offset(2144), littleendian;
 149       comm : 128 : offset(5440), string } ->
 150       let shape =
 151       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 152         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 153         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 154         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 155       let content =
 156       { task_struct_shape_fields_1_run_list'next = run_list'next;
 157         task_struct_shape_fields_1_run_list'prev = run_list'prev;
 158         task_struct_shape_fields_1_tasks'next = tasks'next;
 159         task_struct_shape_fields_1_tasks'prev = tasks'prev } in
 160       { task_struct_shape = shape; task_struct_content = content }
 161   | { _ } ->
 162       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_6", match_err));;
 163 let task_struct_parser_7 bits =
 164   bitmatch bits with
 165   | { state : zero+32 : offset(0), bigendian;
 166       prio : zero+32 : offset(160), bigendian;
 167       static_prio : zero+32 : offset(192), bigendian;
 168       normal_prio : zero+32 : offset(224), bigendian;
 169       run_list'next : zero+32 : offset(256), bigendian;
 170       run_list'prev : zero+32 : offset(288), bigendian;
 171       tasks'next : zero+32 : offset(2176), bigendian;
 172       tasks'prev : zero+32 : offset(2208), bigendian;
 173       pid : zero+32 : offset(2528), bigendian;
 174       comm : 128 : offset(4416), string } ->
 175       let shape =
 176       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 177         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 178         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 179         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 180       let content =
 181       { task_struct_shape_fields_1_run_list'next = run_list'next;
 182         task_struct_shape_fields_1_run_list'prev = run_list'prev;
 183         task_struct_shape_fields_1_tasks'next = tasks'next;
 184         task_struct_shape_fields_1_tasks'prev = tasks'prev } in
 185       { task_struct_shape = shape; task_struct_content = content }
 186   | { _ } ->
 187       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_7", match_err));;
 188 let task_struct_parser_8 bits =
 189   bitmatch bits with
 190   | { state : zero+64 : offset(0), bigendian;
 191       prio : zero+32 : offset(224), bigendian;
 192       static_prio : zero+32 : offset(256), bigendian;
 193       normal_prio : zero+32 : offset(288), bigendian;
 194       run_list'next : zero+64 : offset(320), bigendian;
 195       run_list'prev : zero+64 : offset(384), bigendian;
 196       tasks'next : zero+64 : offset(3648), bigendian;
 197       tasks'prev : zero+64 : offset(3712), bigendian;
 198       pid : zero+32 : offset(4160), bigendian;
 199       comm : 128 : offset(7752), string } ->
 200       let shape =
 201       { task_struct_shape_fields_1_run_list'next = Int64.sub run_list'next 36L;
 202         task_struct_shape_fields_1_run_list'prev = Int64.sub run_list'prev 40L;
 203         task_struct_shape_fields_1_tasks'next = Int64.sub tasks'next 124L;
 204         task_struct_shape_fields_1_tasks'prev = Int64.sub tasks'prev 128L } in
 205       let content =
 206       { task_struct_shape_fields_1_run_list'next = run_list'next;
 207         task_struct_shape_fields_1_run_list'prev = run_list'prev;
 208         task_struct_shape_fields_1_tasks'next = tasks'next;
 209         task_struct_shape_fields_1_tasks'prev = tasks'prev } in
 210       { task_struct_shape = shape; task_struct_content = content }
 211   | { _ } ->
 212       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_8", match_err));;
 213 let task_struct_parser_9 bits =
 214   bitmatch bits with
 215   | { state : zero+64 : offset(0), littleendian;
 216       prio : zero+32 : offset(224), littleendian;
 217       static_prio : zero+32 : offset(256), littleendian;
 218       normal_prio : zero+32 : offset(288), littleendian;
 219       tasks'next : zero+64 : offset(3840), littleendian;
 220       tasks'prev : zero+64 : offset(3904), littleendian;
 221       pid : zero+32 : offset(4352), littleendian;
 222       comm : 128 : offset(8392), string } ->
 223       let shape =
 224       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 225         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 226       let content =
 227       { task_struct_shape_fields_2_tasks'next = tasks'next;
 228         task_struct_shape_fields_2_tasks'prev = tasks'prev } in
 229       { task_struct_shape = shape; task_struct_content = content }
 230   | { _ } ->
 231       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_9", match_err));;
 232 let task_struct_parser_10 bits =
 233   bitmatch bits with
 234   | { state : zero+64 : offset(0), bigendian;
 235       prio : zero+32 : offset(256), bigendian;
 236       static_prio : zero+32 : offset(288), bigendian;
 237       normal_prio : zero+32 : offset(320), bigendian;
 238       tasks'next : zero+64 : offset(4096), bigendian;
 239       tasks'prev : zero+64 : offset(4160), bigendian;
 240       pid : zero+32 : offset(4608), bigendian;
 241       comm : 128 : offset(8712), string } ->
 242       let shape =
 243       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 244         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 245       let content =
 246       { task_struct_shape_fields_2_tasks'next = tasks'next;
 247         task_struct_shape_fields_2_tasks'prev = tasks'prev } in
 248       { task_struct_shape = shape; task_struct_content = content }
 249   | { _ } ->
 250       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_10", match_err));;
 251 let task_struct_parser_11 bits =
 252   bitmatch bits with
 253   | { state : zero+32 : offset(0), bigendian;
 254       prio : zero+32 : offset(192), bigendian;
 255       static_prio : zero+32 : offset(224), bigendian;
 256       normal_prio : zero+32 : offset(256), bigendian;
 257       tasks'next : zero+32 : offset(3712), bigendian;
 258       tasks'prev : zero+32 : offset(3744), bigendian;
 259       pid : zero+32 : offset(4064), bigendian;
 260       comm : 128 : offset(6464), string } ->
 261       let shape =
 262       { task_struct_shape_fields_2_tasks'next = Int64.sub tasks'next 480L;
 263         task_struct_shape_fields_2_tasks'prev = Int64.sub tasks'prev 488L } in
 264       let content =
 265       { task_struct_shape_fields_2_tasks'next = tasks'next;
 266         task_struct_shape_fields_2_tasks'prev = tasks'prev } in
 267       { task_struct_shape = shape; task_struct_content = content }
 268   | { _ } ->
 269       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_11", match_err));;
 270 let net_device_parser_15 bits =
 271   bitmatch bits with
 272   | { name : 128 : offset(0), string;
 273       next : zero+32 : offset(384), littleendian;
 274       flags : zero+32 : offset(704), littleendian;
 275       operstate : zero+8 : offset(784), littleendian;
 276       mtu : zero+32 : offset(800), littleendian;
 277       perm_addr : 256 : offset(896), string;
 278       addr_len : zero+8 : offset(1152), littleendian;
 279       ip_ptr : zero+32 : offset(1344), littleendian;
 280       ip6_ptr : zero+32 : offset(1408), littleendian } ->
 281       let shape =
 282       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 283         net_device_shape_fields_12_ip_ptr = ip_ptr;
 284         net_device_shape_fields_12_next = next } in
 285       let content =
 286       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 287         net_device_shape_fields_12_ip_ptr = ip_ptr;
 288         net_device_shape_fields_12_next = next } in
 289       { net_device_shape = shape; net_device_content = content }
 290   | { _ } ->
 291       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_15", match_err));;
 292 let net_device_parser_16 bits =
 293   bitmatch bits with
 294   | { name : 128 : offset(0), string;
 295       next : zero+64 : offset(576), bigendian;
 296       flags : zero+32 : offset(1152), bigendian;
 297       operstate : zero+8 : offset(1232), bigendian;
 298       mtu : zero+32 : offset(1248), bigendian;
 299       perm_addr : 256 : offset(1408), string;
 300       addr_len : zero+8 : offset(1664), bigendian;
 301       ip_ptr : zero+64 : offset(1984), bigendian;
 302       ip6_ptr : zero+64 : offset(2112), bigendian } ->
 303       let shape =
 304       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 305         net_device_shape_fields_12_ip_ptr = ip_ptr;
 306         net_device_shape_fields_12_next = next } in
 307       let content =
 308       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 309         net_device_shape_fields_12_ip_ptr = ip_ptr;
 310         net_device_shape_fields_12_next = next } in
 311       { net_device_shape = shape; net_device_content = content }
 312   | { _ } ->
 313       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_16", match_err));;
 314 let net_device_parser_17 bits =
 315   bitmatch bits with
 316   | { name : 128 : offset(0), string;
 317       next : zero+64 : offset(576), littleendian;
 318       flags : zero+32 : offset(1152), littleendian;
 319       operstate : zero+8 : offset(1232), littleendian;
 320       mtu : zero+32 : offset(1248), littleendian;
 321       perm_addr : 256 : offset(1408), string;
 322       addr_len : zero+8 : offset(1664), littleendian;
 323       ip_ptr : zero+64 : offset(1984), littleendian;
 324       ip6_ptr : zero+64 : offset(2112), littleendian } ->
 325       let shape =
 326       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 327         net_device_shape_fields_12_ip_ptr = ip_ptr;
 328         net_device_shape_fields_12_next = next } in
 329       let content =
 330       { net_device_shape_fields_12_ip6_ptr = ip6_ptr;
 331         net_device_shape_fields_12_ip_ptr = ip_ptr;
 332         net_device_shape_fields_12_next = next } in
 333       { net_device_shape = shape; net_device_content = content }
 334   | { _ } ->
 335       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_17", match_err));;
 336 let net_device_parser_18 bits =
 337   bitmatch bits with
 338   | { name : 128 : offset(0), string;
 339       dev_list'next : zero+32 : offset(384), bigendian;
 340       dev_list'prev : zero+32 : offset(416), bigendian;
 341       flags : zero+32 : offset(1472), bigendian;
 342       operstate : zero+8 : offset(1552), bigendian;
 343       mtu : zero+32 : offset(1568), bigendian;
 344       perm_addr : 256 : offset(1664), string;
 345       addr_len : zero+8 : offset(1920), bigendian;
 346       ip_ptr : zero+32 : offset(2112), bigendian;
 347       ip6_ptr : zero+32 : offset(2176), bigendian } ->
 348       let shape =
 349       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 350         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 351         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 352         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 353       let content =
 354       { net_device_shape_fields_13_dev_list'next = dev_list'next;
 355         net_device_shape_fields_13_dev_list'prev = dev_list'prev;
 356         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 357         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 358       { net_device_shape = shape; net_device_content = content }
 359   | { _ } ->
 360       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_18", match_err));;
 361 let net_device_parser_19 bits =
 362   bitmatch bits with
 363   | { name : 128 : offset(0), string;
 364       dev_list'next : zero+64 : offset(576), bigendian;
 365       dev_list'prev : zero+64 : offset(640), bigendian;
 366       flags : zero+32 : offset(2880), bigendian;
 367       operstate : zero+8 : offset(2960), bigendian;
 368       mtu : zero+32 : offset(2976), bigendian;
 369       perm_addr : 256 : offset(3136), string;
 370       addr_len : zero+8 : offset(3392), bigendian;
 371       ip_ptr : zero+64 : offset(3840), bigendian;
 372       ip6_ptr : zero+64 : offset(3968), bigendian } ->
 373       let shape =
 374       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 375         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 376         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 377         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 378       let content =
 379       { net_device_shape_fields_13_dev_list'next = dev_list'next;
 380         net_device_shape_fields_13_dev_list'prev = dev_list'prev;
 381         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 382         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 383       { net_device_shape = shape; net_device_content = content }
 384   | { _ } ->
 385       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_19", match_err));;
 386 let net_device_parser_20 bits =
 387   bitmatch bits with
 388   | { name : 128 : offset(0), string;
 389       dev_list'next : zero+64 : offset(576), littleendian;
 390       dev_list'prev : zero+64 : offset(640), littleendian;
 391       flags : zero+32 : offset(2880), littleendian;
 392       operstate : zero+8 : offset(2960), littleendian;
 393       mtu : zero+32 : offset(2976), littleendian;
 394       perm_addr : 256 : offset(3136), string;
 395       addr_len : zero+8 : offset(3392), littleendian;
 396       ip_ptr : zero+64 : offset(3840), littleendian;
 397       ip6_ptr : zero+64 : offset(3968), littleendian } ->
 398       let shape =
 399       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 400         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 401         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 402         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 403       let content =
 404       { net_device_shape_fields_13_dev_list'next = dev_list'next;
 405         net_device_shape_fields_13_dev_list'prev = dev_list'prev;
 406         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 407         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 408       { net_device_shape = shape; net_device_content = content }
 409   | { _ } ->
 410       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_20", match_err));;
 411 let net_device_parser_21 bits =
 412   bitmatch bits with
 413   | { name : 128 : offset(0), string;
 414       dev_list'next : zero+32 : offset(384), bigendian;
 415       dev_list'prev : zero+32 : offset(416), bigendian;
 416       flags : zero+32 : offset(1536), bigendian;
 417       operstate : zero+8 : offset(1616), bigendian;
 418       mtu : zero+32 : offset(1632), bigendian;
 419       perm_addr : 256 : offset(1760), string;
 420       addr_len : zero+8 : offset(2016), bigendian;
 421       ip_ptr : zero+32 : offset(2432), bigendian;
 422       ip6_ptr : zero+32 : offset(2496), bigendian } ->
 423       let shape =
 424       { net_device_shape_fields_13_dev_list'next = Int64.sub dev_list'next 48L;
 425         net_device_shape_fields_13_dev_list'prev = Int64.sub dev_list'prev 52L;
 426         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 427         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 428       let content =
 429       { net_device_shape_fields_13_dev_list'next = dev_list'next;
 430         net_device_shape_fields_13_dev_list'prev = dev_list'prev;
 431         net_device_shape_fields_13_ip6_ptr = ip6_ptr;
 432         net_device_shape_fields_13_ip_ptr = ip_ptr } in
 433       { net_device_shape = shape; net_device_content = content }
 434   | { _ } ->
 435       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_21", match_err));;
 436 let net_parser_24 bits =
 437   bitmatch bits with
 438   | { dev_base_head'next : zero+64 : offset(704), bigendian;
 439       dev_base_head'prev : zero+64 : offset(768), bigendian } ->
 440       let shape =
 441       { net_shape_fields_22_dev_base_head'next = Int64.sub dev_base_head'next 666L;
 442         net_shape_fields_22_dev_base_head'prev = Int64.sub dev_base_head'prev 666L } in
 443       let content =
 444       { net_shape_fields_22_dev_base_head'next = dev_base_head'next;
 445         net_shape_fields_22_dev_base_head'prev = dev_base_head'prev } in
 446       { net_shape = shape; net_content = content }
 447   | { _ } ->
 448       raise (Virt_mem_types.ParseError ("net", "net_parser_24", match_err));;
 449 let net_parser_25 bits =
 450   bitmatch bits with
 451   | { dev_base_head'next : zero+64 : offset(768), littleendian;
 452       dev_base_head'prev : zero+64 : offset(832), littleendian } ->
 453       let shape =
 454       { net_shape_fields_22_dev_base_head'next = Int64.sub dev_base_head'next 666L;
 455         net_shape_fields_22_dev_base_head'prev = Int64.sub dev_base_head'prev 666L } in
 456       let content =
 457       { net_shape_fields_22_dev_base_head'next = dev_base_head'next;
 458         net_shape_fields_22_dev_base_head'prev = dev_base_head'prev } in
 459       { net_shape = shape; net_content = content }
 460   | { _ } ->
 461       raise (Virt_mem_types.ParseError ("net", "net_parser_25", match_err));;
 462 let net_parser_26 bits =
 463   bitmatch bits with
 464   | { dev_base_head'next : zero+64 : offset(768), bigendian;
 465       dev_base_head'prev : zero+64 : offset(832), bigendian } ->
 466       let shape =
 467       { net_shape_fields_22_dev_base_head'next = Int64.sub dev_base_head'next 666L;
 468         net_shape_fields_22_dev_base_head'prev = Int64.sub dev_base_head'prev 666L } in
 469       let content =
 470       { net_shape_fields_22_dev_base_head'next = dev_base_head'next;
 471         net_shape_fields_22_dev_base_head'prev = dev_base_head'prev } in
 472       { net_shape = shape; net_content = content }
 473   | { _ } ->
 474       raise (Virt_mem_types.ParseError ("net", "net_parser_26", match_err));;
 475 let net_parser_27 bits =
 476   bitmatch bits with
 477   | { dev_base_head'next : zero+32 : offset(448), bigendian;
 478       dev_base_head'prev : zero+32 : offset(480), bigendian } ->
 479       let shape =
 480       { net_shape_fields_22_dev_base_head'next = Int64.sub dev_base_head'next 666L;
 481         net_shape_fields_22_dev_base_head'prev = Int64.sub dev_base_head'prev 666L } in
 482       let content =
 483       { net_shape_fields_22_dev_base_head'next = dev_base_head'next;
 484         net_shape_fields_22_dev_base_head'prev = dev_base_head'prev } in
 485       { net_shape = shape; net_content = content }
 486   | { _ } ->
 487       raise (Virt_mem_types.ParseError ("net", "net_parser_27", match_err));;
 488 let in_device_parser_30 bits =
 489   bitmatch bits with
 490   | { ifa_list : zero+32 : offset(96), littleendian } ->
 491       let shape =
 492       { in_device_shape_fields_28_ifa_list = ifa_list } in
 493       let content =
 494       { in_device_shape_fields_28_ifa_list = ifa_list } in
 495       { in_device_shape = shape; in_device_content = content }
 496   | { _ } ->
 497       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_30", match_err));;
 498 let in_device_parser_33 bits =
 499   bitmatch bits with
 500   | { ifa_list : zero+32 : offset(96), bigendian } ->
 501       let shape =
 502       { in_device_shape_fields_28_ifa_list = ifa_list } in
 503       let content =
 504       { in_device_shape_fields_28_ifa_list = ifa_list } in
 505       { in_device_shape = shape; in_device_content = content }
 506   | { _ } ->
 507       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_33", match_err));;
 508 let in_device_parser_32 bits =
 509   bitmatch bits with
 510   | { ifa_list : zero+64 : offset(128), littleendian } ->
 511       let shape =
 512       { in_device_shape_fields_28_ifa_list = ifa_list } in
 513       let content =
 514       { in_device_shape_fields_28_ifa_list = ifa_list } in
 515       { in_device_shape = shape; in_device_content = content }
 516   | { _ } ->
 517       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_32", match_err));;
 518 let in_device_parser_31 bits =
 519   bitmatch bits with
 520   | { ifa_list : zero+64 : offset(128), bigendian } ->
 521       let shape =
 522       { in_device_shape_fields_28_ifa_list = ifa_list } in
 523       let content =
 524       { in_device_shape_fields_28_ifa_list = ifa_list } in
 525       { in_device_shape = shape; in_device_content = content }
 526   | { _ } ->
 527       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_31", match_err));;
 528 let inet6_dev_parser_36 bits =
 529   bitmatch bits with
 530   | { addr_list : zero+32 : offset(32), littleendian } ->
 531       let shape =
 532       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 533       let content =
 534       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 535       { inet6_dev_shape = shape; inet6_dev_content = content }
 536   | { _ } ->
 537       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_36", match_err));;
 538 let inet6_dev_parser_39 bits =
 539   bitmatch bits with
 540   | { addr_list : zero+32 : offset(32), bigendian } ->
 541       let shape =
 542       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 543       let content =
 544       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 545       { inet6_dev_shape = shape; inet6_dev_content = content }
 546   | { _ } ->
 547       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_39", match_err));;
 548 let inet6_dev_parser_38 bits =
 549   bitmatch bits with
 550   | { addr_list : zero+64 : offset(64), littleendian } ->
 551       let shape =
 552       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 553       let content =
 554       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 555       { inet6_dev_shape = shape; inet6_dev_content = content }
 556   | { _ } ->
 557       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_38", match_err));;
 558 let inet6_dev_parser_37 bits =
 559   bitmatch bits with
 560   | { addr_list : zero+64 : offset(64), bigendian } ->
 561       let shape =
 562       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 563       let content =
 564       { inet6_dev_shape_fields_34_addr_list = addr_list } in
 565       { inet6_dev_shape = shape; inet6_dev_content = content }
 566   | { _ } ->
 567       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_37", match_err));;
 568 let in_ifaddr_parser_42 bits =
 569   bitmatch bits with
 570   | { ifa_next : zero+32 : offset(0), littleendian;
 571       ifa_local : zero+32 : offset(128), littleendian;
 572       ifa_address : zero+32 : offset(160), littleendian;
 573       ifa_mask : zero+32 : offset(192), littleendian;
 574       ifa_broadcast : zero+32 : offset(224), littleendian } ->
 575       let shape =
 576       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 577       let content =
 578       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 579       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 580   | { _ } ->
 581       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_42", match_err));;
 582 let in_ifaddr_parser_45 bits =
 583   bitmatch bits with
 584   | { ifa_next : zero+32 : offset(0), bigendian;
 585       ifa_local : zero+32 : offset(128), bigendian;
 586       ifa_address : zero+32 : offset(160), bigendian;
 587       ifa_mask : zero+32 : offset(192), bigendian;
 588       ifa_broadcast : zero+32 : offset(224), bigendian } ->
 589       let shape =
 590       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 591       let content =
 592       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 593       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 594   | { _ } ->
 595       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_45", match_err));;
 596 let in_ifaddr_parser_43 bits =
 597   bitmatch bits with
 598   | { ifa_next : zero+64 : offset(0), bigendian;
 599       ifa_local : zero+32 : offset(256), bigendian;
 600       ifa_address : zero+32 : offset(288), bigendian;
 601       ifa_mask : zero+32 : offset(320), bigendian;
 602       ifa_broadcast : zero+32 : offset(352), bigendian } ->
 603       let shape =
 604       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 605       let content =
 606       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 607       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 608   | { _ } ->
 609       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_43", match_err));;
 610 let in_ifaddr_parser_44 bits =
 611   bitmatch bits with
 612   | { ifa_next : zero+64 : offset(0), littleendian;
 613       ifa_local : zero+32 : offset(256), littleendian;
 614       ifa_address : zero+32 : offset(288), littleendian;
 615       ifa_mask : zero+32 : offset(320), littleendian;
 616       ifa_broadcast : zero+32 : offset(352), littleendian } ->
 617       let shape =
 618       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 619       let content =
 620       { in_ifaddr_shape_fields_40_ifa_next = ifa_next } in
 621       { in_ifaddr_shape = shape; in_ifaddr_content = content }
 622   | { _ } ->
 623       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_44", match_err));;
 624 let inet6_ifaddr_parser_48 bits =
 625   bitmatch bits with
 626   | { prefix_len : zero+32 : offset(128), littleendian;
 627       lst_next : zero+32 : offset(1024), littleendian } ->
 628       let shape =
 629       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 630       let content =
 631       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 632       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 633   | { _ } ->
 634       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_48", match_err));;
 635 let inet6_ifaddr_parser_50 bits =
 636   bitmatch bits with
 637   | { prefix_len : zero+32 : offset(128), littleendian;
 638       lst_next : zero+64 : offset(1856), littleendian } ->
 639       let shape =
 640       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 641       let content =
 642       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 643       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 644   | { _ } ->
 645       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_50", match_err));;
 646 let inet6_ifaddr_parser_49 bits =
 647   bitmatch bits with
 648   | { prefix_len : zero+32 : offset(128), bigendian;
 649       lst_next : zero+64 : offset(1472), bigendian } ->
 650       let shape =
 651       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 652       let content =
 653       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 654       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 655   | { _ } ->
 656       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_49", match_err));;
 657 let inet6_ifaddr_parser_51 bits =
 658   bitmatch bits with
 659   | { prefix_len : zero+32 : offset(128), littleendian;
 660       lst_next : zero+64 : offset(1472), littleendian } ->
 661       let shape =
 662       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 663       let content =
 664       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 665       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 666   | { _ } ->
 667       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_51", match_err));;
 668 let inet6_ifaddr_parser_52 bits =
 669   bitmatch bits with
 670   | { prefix_len : zero+32 : offset(128), bigendian;
 671       lst_next : zero+32 : offset(928), bigendian } ->
 672       let shape =
 673       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 674       let content =
 675       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 676       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 677   | { _ } ->
 678       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_52", match_err));;
 679 let inet6_ifaddr_parser_53 bits =
 680   bitmatch bits with
 681   | { prefix_len : zero+32 : offset(128), littleendian;
 682       lst_next : zero+64 : offset(1280), littleendian } ->
 683       let shape =
 684       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 685       let content =
 686       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 687       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 688   | { _ } ->
 689       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_53", match_err));;
 690 let inet6_ifaddr_parser_54 bits =
 691   bitmatch bits with
 692   | { prefix_len : zero+32 : offset(128), bigendian;
 693       lst_next : zero+64 : offset(1280), bigendian } ->
 694       let shape =
 695       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 696       let content =
 697       { inet6_ifaddr_shape_fields_46_lst_next = lst_next } in
 698       { inet6_ifaddr_shape = shape; inet6_ifaddr_content = content }
 699   | { _ } ->
 700       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_54", match_err));;