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