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 open Printf;;
  11 module StringMap = Map.Make(String);;
  12 module AddrMap = Map.Make(Int64);;
  13 type kernel_version = string;;
  14 let match_err = "failed to match kernel structure";;
  15 let unknown_kernel_version version struct_name =
  16   invalid_arg
  17     (sprintf
  18        "%s: unknown kernel version or
  19 struct %s is not supported in this kernel.
  20 Try a newer version of virt-mem, or if the guest is not from a
  21 supported Linux distribution, see this page about adding support:
  22   http://et.redhat.com/~rjones/virt-mem/faq.html
  23 "
  24        version struct_name);;
  25 let zero = 0;;
  26 type task_struct =
  27   { task_struct_comm : string; task_struct_normal_prio : int64;
  28     task_struct_pid : int64; task_struct_prio : int64;
  29     task_struct_run_list'next : Virt_mem_mmap.addr option;
  30     task_struct_run_list'next_offset : int;
  31     task_struct_run_list'next_adjustment : int;
  32     task_struct_run_list'prev : Virt_mem_mmap.addr option;
  33     task_struct_state : int64; task_struct_static_prio : int64;
  34     task_struct_tasks'next : Virt_mem_mmap.addr;
  35     task_struct_tasks'next_offset : int;
  36     task_struct_tasks'next_adjustment : int;
  37     task_struct_tasks'prev : Virt_mem_mmap.addr
  38   };;
  39 type net_device =
  40   { net_device_addr_len : int64;
  41     net_device_dev_list'next : Virt_mem_mmap.addr option;
  42     net_device_dev_list'next_offset : int;
  43     net_device_dev_list'next_adjustment : int;
  44     net_device_dev_list'prev : Virt_mem_mmap.addr option;
  45     net_device_flags : int64; net_device_ip6_ptr : Virt_mem_mmap.addr;
  46     net_device_ip_ptr : Virt_mem_mmap.addr; net_device_mtu : int64;
  47     net_device_name : string; net_device_next : Virt_mem_mmap.addr option;
  48     net_device_operstate : int64; net_device_perm_addr : string
  49   };;
  50 type net =
  51   { net_dev_base_head'next : Virt_mem_mmap.addr;
  52     net_dev_base_head'next_offset : int;
  53     net_dev_base_head'next_adjustment : int;
  54     net_dev_base_head'prev : Virt_mem_mmap.addr;
  55     net_dev_base_head'prev_offset : int;
  56     net_dev_base_head'prev_adjustment : int
  57   };;
  58 type in_device = { in_device_ifa_list : Virt_mem_mmap.addr };;
  59 type inet6_dev = { inet6_dev_addr_list : Virt_mem_mmap.addr };;
  60 type in_ifaddr =
  61   { in_ifaddr_ifa_address : int64; in_ifaddr_ifa_broadcast : int64;
  62     in_ifaddr_ifa_local : int64; in_ifaddr_ifa_mask : int64;
  63     in_ifaddr_ifa_next : Virt_mem_mmap.addr
  64   };;
  65 type inet6_ifaddr =
  66   { inet6_ifaddr_lst_next : Virt_mem_mmap.addr;
  67     inet6_ifaddr_prefix_len : int64
  68   };;
  69 type kernel_struct =
  70   Task_struct of task_struct
  71   | Net_device of net_device
  72   | Net of net
  73   | In_device of in_device
  74   | Inet6_dev of inet6_dev
  75   | In_ifaddr of in_ifaddr
  76   | Inet6_ifaddr of inet6_ifaddr;;
  77 let offset_of_net_device_dev_list'next =
  78   let map =
  79     StringMap.add "2.6.25.14-69.fc8.i686" 48
  80       (StringMap.add "2.6.25.14-108.fc9.ppc" 48
  81          (StringMap.add "2.6.25.11-97.fc9.i686" 48
  82             (StringMap.add "2.6.25.14-69.fc8.ppc64" 72
  83                (StringMap.add "2.6.25.14-69.fc8.i586" 48
  84                   (StringMap.add "2.6.25.11-97.fc9.x86_64" 72
  85                      (StringMap.add "2.6.25.14-108.fc9.x86_64" 72
  86                         (StringMap.add "2.6.25.14-69.fc8.ppc" 48
  87                            (StringMap.add "2.6.25.14-108.fc9.i686" 48
  88                               (StringMap.add "2.6.25.14-108.fc9.i586" 48
  89                                  (StringMap.add "2.6.25.14-108.fc9.ppc64" 72
  90                                     (StringMap.add "2.6.25.14-69.fc8.x86_64"
  91                                        72 StringMap.empty)))))))))))
  92   in fun kernel_version -> StringMap.find kernel_version map;;
  93 let task_struct_parser_1 kernel_version bits =
  94   bitmatch bits with
  95   | { state : zero+64 : offset(0), littleendian;
  96       prio : zero+32 : offset(224), littleendian;
  97       static_prio : zero+32 : offset(256), littleendian;
  98       normal_prio : zero+32 : offset(288), littleendian;
  99       tasks'next : zero+64 : offset(3840), littleendian;
 100       tasks'prev : zero+64 : offset(3904), littleendian;
 101       pid : zero+32 : offset(4352), littleendian;
 102       comm : 128 : offset(8392), string } ->
 103       { task_struct_comm = comm;
 104         task_struct_normal_prio = normal_prio;
 105         task_struct_pid = pid;
 106         task_struct_prio = prio;
 107         task_struct_run_list'next = None;
 108           task_struct_run_list'next_offset = -1;
 109           task_struct_run_list'next_adjustment = -1;
 110         task_struct_run_list'prev = None;
 111         task_struct_state = state;
 112         task_struct_static_prio = static_prio;
 113         task_struct_tasks'next = tasks'next;
 114           task_struct_tasks'next_offset = 480;
 115           task_struct_tasks'next_adjustment = 480;
 116         task_struct_tasks'prev = tasks'prev }
 117   | { _ } ->
 118       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_1", match_err));;
 119 let task_struct_parser_2 kernel_version bits =
 120   bitmatch bits with
 121   | { state : zero+64 : offset(0), bigendian;
 122       prio : zero+32 : offset(224), bigendian;
 123       static_prio : zero+32 : offset(256), bigendian;
 124       normal_prio : zero+32 : offset(288), bigendian;
 125       tasks'next : zero+64 : offset(3840), bigendian;
 126       tasks'prev : zero+64 : offset(3904), bigendian;
 127       pid : zero+32 : offset(4352), bigendian;
 128       comm : 128 : offset(8392), string } ->
 129       { task_struct_comm = comm;
 130         task_struct_normal_prio = normal_prio;
 131         task_struct_pid = pid;
 132         task_struct_prio = prio;
 133         task_struct_run_list'next = None;
 134           task_struct_run_list'next_offset = -1;
 135           task_struct_run_list'next_adjustment = -1;
 136         task_struct_run_list'prev = None;
 137         task_struct_state = state;
 138         task_struct_static_prio = static_prio;
 139         task_struct_tasks'next = tasks'next;
 140           task_struct_tasks'next_offset = 480;
 141           task_struct_tasks'next_adjustment = 480;
 142         task_struct_tasks'prev = tasks'prev }
 143   | { _ } ->
 144       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_2", match_err));;
 145 let task_struct_parser_3 kernel_version bits =
 146   bitmatch bits with
 147   | { state : zero+32 : offset(0), littleendian;
 148       prio : zero+32 : offset(160), littleendian;
 149       static_prio : zero+32 : offset(192), littleendian;
 150       normal_prio : zero+32 : offset(224), littleendian;
 151       tasks'next : zero+32 : offset(3200), littleendian;
 152       tasks'prev : zero+32 : offset(3232), littleendian;
 153       pid : zero+32 : offset(3552), littleendian;
 154       comm : 128 : offset(5896), string } ->
 155       { task_struct_comm = comm;
 156         task_struct_normal_prio = normal_prio;
 157         task_struct_pid = pid;
 158         task_struct_prio = prio;
 159         task_struct_run_list'next = None;
 160           task_struct_run_list'next_offset = -1;
 161           task_struct_run_list'next_adjustment = -1;
 162         task_struct_run_list'prev = None;
 163         task_struct_state = state;
 164         task_struct_static_prio = static_prio;
 165         task_struct_tasks'next = tasks'next;
 166           task_struct_tasks'next_offset = 400;
 167           task_struct_tasks'next_adjustment = 400;
 168         task_struct_tasks'prev = tasks'prev }
 169   | { _ } ->
 170       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_3", match_err));;
 171 let task_struct_parser_4 kernel_version bits =
 172   bitmatch bits with
 173   | { state : zero+32 : offset(0), littleendian;
 174       prio : zero+32 : offset(160), littleendian;
 175       static_prio : zero+32 : offset(192), littleendian;
 176       normal_prio : zero+32 : offset(224), littleendian;
 177       tasks'next : zero+32 : offset(3232), littleendian;
 178       tasks'prev : zero+32 : offset(3264), littleendian;
 179       pid : zero+32 : offset(3584), littleendian;
 180       comm : 128 : offset(5928), string } ->
 181       { task_struct_comm = comm;
 182         task_struct_normal_prio = normal_prio;
 183         task_struct_pid = pid;
 184         task_struct_prio = prio;
 185         task_struct_run_list'next = None;
 186           task_struct_run_list'next_offset = -1;
 187           task_struct_run_list'next_adjustment = -1;
 188         task_struct_run_list'prev = None;
 189         task_struct_state = state;
 190         task_struct_static_prio = static_prio;
 191         task_struct_tasks'next = tasks'next;
 192           task_struct_tasks'next_offset = 404;
 193           task_struct_tasks'next_adjustment = 404;
 194         task_struct_tasks'prev = tasks'prev }
 195   | { _ } ->
 196       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_4", match_err));;
 197 let task_struct_parser_5 kernel_version bits =
 198   bitmatch bits with
 199   | { state : zero+32 : offset(0), bigendian;
 200       prio : zero+32 : offset(160), bigendian;
 201       static_prio : zero+32 : offset(192), bigendian;
 202       normal_prio : zero+32 : offset(224), bigendian;
 203       tasks'next : zero+32 : offset(3328), bigendian;
 204       tasks'prev : zero+32 : offset(3360), bigendian;
 205       pid : zero+32 : offset(3680), bigendian;
 206       comm : 128 : offset(6056), string } ->
 207       { task_struct_comm = comm;
 208         task_struct_normal_prio = normal_prio;
 209         task_struct_pid = pid;
 210         task_struct_prio = prio;
 211         task_struct_run_list'next = None;
 212           task_struct_run_list'next_offset = -1;
 213           task_struct_run_list'next_adjustment = -1;
 214         task_struct_run_list'prev = None;
 215         task_struct_state = state;
 216         task_struct_static_prio = static_prio;
 217         task_struct_tasks'next = tasks'next;
 218           task_struct_tasks'next_offset = 416;
 219           task_struct_tasks'next_adjustment = 416;
 220         task_struct_tasks'prev = tasks'prev }
 221   | { _ } ->
 222       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_5", match_err));;
 223 let task_struct_parser_6 kernel_version bits =
 224   bitmatch bits with
 225   | { state : zero+32 : offset(0), bigendian;
 226       prio : zero+32 : offset(192), bigendian;
 227       static_prio : zero+32 : offset(224), bigendian;
 228       normal_prio : zero+32 : offset(256), bigendian;
 229       run_list'next : zero+32 : offset(288), bigendian;
 230       run_list'prev : zero+32 : offset(320), bigendian;
 231       tasks'next : zero+32 : offset(1024), bigendian;
 232       tasks'prev : zero+32 : offset(1056), bigendian;
 233       pid : zero+32 : offset(1376), bigendian;
 234       comm : 128 : offset(3264), string } ->
 235       { task_struct_comm = comm;
 236         task_struct_normal_prio = normal_prio;
 237         task_struct_pid = pid;
 238         task_struct_prio = prio;
 239         task_struct_run_list'next = Some run_list'next;
 240           task_struct_run_list'next_offset = 36;
 241           task_struct_run_list'next_adjustment = 36;
 242         task_struct_run_list'prev = Some run_list'prev;
 243         task_struct_state = state;
 244         task_struct_static_prio = static_prio;
 245         task_struct_tasks'next = tasks'next;
 246           task_struct_tasks'next_offset = 128;
 247           task_struct_tasks'next_adjustment = 128;
 248         task_struct_tasks'prev = tasks'prev }
 249   | { _ } ->
 250       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_6", match_err));;
 251 let task_struct_parser_7 kernel_version bits =
 252   bitmatch bits with
 253   | { state : zero+64 : offset(0), littleendian;
 254       prio : zero+32 : offset(320), littleendian;
 255       static_prio : zero+32 : offset(352), littleendian;
 256       normal_prio : zero+32 : offset(384), littleendian;
 257       run_list'next : zero+64 : offset(448), littleendian;
 258       run_list'prev : zero+64 : offset(512), littleendian;
 259       tasks'next : zero+64 : offset(1536), littleendian;
 260       tasks'prev : zero+64 : offset(1600), littleendian;
 261       pid : zero+32 : offset(2144), littleendian;
 262       comm : 128 : offset(5440), string } ->
 263       { task_struct_comm = comm;
 264         task_struct_normal_prio = normal_prio;
 265         task_struct_pid = pid;
 266         task_struct_prio = prio;
 267         task_struct_run_list'next = Some run_list'next;
 268           task_struct_run_list'next_offset = 56;
 269           task_struct_run_list'next_adjustment = 56;
 270         task_struct_run_list'prev = Some run_list'prev;
 271         task_struct_state = state;
 272         task_struct_static_prio = static_prio;
 273         task_struct_tasks'next = tasks'next;
 274           task_struct_tasks'next_offset = 192;
 275           task_struct_tasks'next_adjustment = 192;
 276         task_struct_tasks'prev = tasks'prev }
 277   | { _ } ->
 278       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_7", match_err));;
 279 let task_struct_parser_8 kernel_version bits =
 280   bitmatch bits with
 281   | { state : zero+32 : offset(0), littleendian;
 282       prio : zero+32 : offset(192), littleendian;
 283       static_prio : zero+32 : offset(224), littleendian;
 284       normal_prio : zero+32 : offset(256), littleendian;
 285       run_list'next : zero+32 : offset(288), littleendian;
 286       run_list'prev : zero+32 : offset(320), littleendian;
 287       tasks'next : zero+32 : offset(992), littleendian;
 288       tasks'prev : zero+32 : offset(1024), littleendian;
 289       pid : zero+32 : offset(1344), littleendian;
 290       comm : 128 : offset(3232), string } ->
 291       { task_struct_comm = comm;
 292         task_struct_normal_prio = normal_prio;
 293         task_struct_pid = pid;
 294         task_struct_prio = prio;
 295         task_struct_run_list'next = Some run_list'next;
 296           task_struct_run_list'next_offset = 36;
 297           task_struct_run_list'next_adjustment = 36;
 298         task_struct_run_list'prev = Some run_list'prev;
 299         task_struct_state = state;
 300         task_struct_static_prio = static_prio;
 301         task_struct_tasks'next = tasks'next;
 302           task_struct_tasks'next_offset = 124;
 303           task_struct_tasks'next_adjustment = 124;
 304         task_struct_tasks'prev = tasks'prev }
 305   | { _ } ->
 306       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_8", match_err));;
 307 let task_struct_parser_9 kernel_version bits =
 308   bitmatch bits with
 309   | { state : zero+64 : offset(0), bigendian;
 310       prio : zero+32 : offset(320), bigendian;
 311       static_prio : zero+32 : offset(352), bigendian;
 312       normal_prio : zero+32 : offset(384), bigendian;
 313       run_list'next : zero+64 : offset(448), bigendian;
 314       run_list'prev : zero+64 : offset(512), bigendian;
 315       tasks'next : zero+64 : offset(1600), bigendian;
 316       tasks'prev : zero+64 : offset(1664), bigendian;
 317       pid : zero+32 : offset(2208), bigendian;
 318       comm : 128 : offset(5440), string } ->
 319       { task_struct_comm = comm;
 320         task_struct_normal_prio = normal_prio;
 321         task_struct_pid = pid;
 322         task_struct_prio = prio;
 323         task_struct_run_list'next = Some run_list'next;
 324           task_struct_run_list'next_offset = 56;
 325           task_struct_run_list'next_adjustment = 56;
 326         task_struct_run_list'prev = Some run_list'prev;
 327         task_struct_state = state;
 328         task_struct_static_prio = static_prio;
 329         task_struct_tasks'next = tasks'next;
 330           task_struct_tasks'next_offset = 200;
 331           task_struct_tasks'next_adjustment = 200;
 332         task_struct_tasks'prev = tasks'prev }
 333   | { _ } ->
 334       raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_9", match_err));;
 335 let net_device_parser_10 kernel_version bits =
 336   bitmatch bits with
 337   | { name : 128 : offset(0), string;
 338       dev_list'next : zero+64 : offset(576), littleendian;
 339       dev_list'prev : zero+64 : offset(640), littleendian;
 340       flags : zero+32 : offset(2880), littleendian;
 341       operstate : zero+8 : offset(2960), littleendian;
 342       mtu : zero+32 : offset(2976), littleendian;
 343       perm_addr : 256 : offset(3136), string;
 344       addr_len : zero+8 : offset(3392), littleendian;
 345       ip_ptr : zero+64 : offset(3840), littleendian;
 346       ip6_ptr : zero+64 : offset(3968), littleendian } ->
 347       { net_device_addr_len = addr_len;
 348         net_device_dev_list'next = Some dev_list'next;
 349           net_device_dev_list'next_offset = 72;
 350           net_device_dev_list'next_adjustment = 72;
 351         net_device_dev_list'prev = Some dev_list'prev;
 352         net_device_flags = flags;
 353         net_device_ip6_ptr = ip6_ptr;
 354         net_device_ip_ptr = ip_ptr;
 355         net_device_mtu = mtu;
 356         net_device_name = name;
 357         net_device_next = None;
 358         net_device_operstate = operstate;
 359         net_device_perm_addr = perm_addr }
 360   | { _ } ->
 361       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_10", match_err));;
 362 let net_device_parser_11 kernel_version bits =
 363   bitmatch bits with
 364   | { name : 128 : offset(0), string;
 365       dev_list'next : zero+64 : offset(576), bigendian;
 366       dev_list'prev : zero+64 : offset(640), bigendian;
 367       flags : zero+32 : offset(2880), bigendian;
 368       operstate : zero+8 : offset(2960), bigendian;
 369       mtu : zero+32 : offset(2976), bigendian;
 370       perm_addr : 256 : offset(3136), string;
 371       addr_len : zero+8 : offset(3392), bigendian;
 372       ip_ptr : zero+64 : offset(3840), bigendian;
 373       ip6_ptr : zero+64 : offset(3968), bigendian } ->
 374       { net_device_addr_len = addr_len;
 375         net_device_dev_list'next = Some dev_list'next;
 376           net_device_dev_list'next_offset = 72;
 377           net_device_dev_list'next_adjustment = 72;
 378         net_device_dev_list'prev = Some dev_list'prev;
 379         net_device_flags = flags;
 380         net_device_ip6_ptr = ip6_ptr;
 381         net_device_ip_ptr = ip_ptr;
 382         net_device_mtu = mtu;
 383         net_device_name = name;
 384         net_device_next = None;
 385         net_device_operstate = operstate;
 386         net_device_perm_addr = perm_addr }
 387   | { _ } ->
 388       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_11", match_err));;
 389 let net_device_parser_12 kernel_version bits =
 390   bitmatch bits with
 391   | { name : 128 : offset(0), string;
 392       dev_list'next : zero+32 : offset(384), littleendian;
 393       dev_list'prev : zero+32 : offset(416), littleendian;
 394       flags : zero+32 : offset(1568), littleendian;
 395       operstate : zero+8 : offset(1648), littleendian;
 396       mtu : zero+32 : offset(1664), littleendian;
 397       perm_addr : 256 : offset(1760), string;
 398       addr_len : zero+8 : offset(2016), littleendian;
 399       ip_ptr : zero+32 : offset(2304), littleendian;
 400       ip6_ptr : zero+32 : offset(2368), littleendian } ->
 401       { net_device_addr_len = addr_len;
 402         net_device_dev_list'next = Some dev_list'next;
 403           net_device_dev_list'next_offset = 48;
 404           net_device_dev_list'next_adjustment = 48;
 405         net_device_dev_list'prev = Some dev_list'prev;
 406         net_device_flags = flags;
 407         net_device_ip6_ptr = ip6_ptr;
 408         net_device_ip_ptr = ip_ptr;
 409         net_device_mtu = mtu;
 410         net_device_name = name;
 411         net_device_next = None;
 412         net_device_operstate = operstate;
 413         net_device_perm_addr = perm_addr }
 414   | { _ } ->
 415       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_12", match_err));;
 416 let net_device_parser_13 kernel_version bits =
 417   bitmatch bits with
 418   | { name : 128 : offset(0), string;
 419       dev_list'next : zero+32 : offset(384), bigendian;
 420       dev_list'prev : zero+32 : offset(416), bigendian;
 421       flags : zero+32 : offset(1568), bigendian;
 422       operstate : zero+8 : offset(1648), bigendian;
 423       mtu : zero+32 : offset(1664), bigendian;
 424       perm_addr : 256 : offset(1760), string;
 425       addr_len : zero+8 : offset(2016), bigendian;
 426       ip_ptr : zero+32 : offset(2304), bigendian;
 427       ip6_ptr : zero+32 : offset(2368), bigendian } ->
 428       { net_device_addr_len = addr_len;
 429         net_device_dev_list'next = Some dev_list'next;
 430           net_device_dev_list'next_offset = 48;
 431           net_device_dev_list'next_adjustment = 48;
 432         net_device_dev_list'prev = Some dev_list'prev;
 433         net_device_flags = flags;
 434         net_device_ip6_ptr = ip6_ptr;
 435         net_device_ip_ptr = ip_ptr;
 436         net_device_mtu = mtu;
 437         net_device_name = name;
 438         net_device_next = None;
 439         net_device_operstate = operstate;
 440         net_device_perm_addr = perm_addr }
 441   | { _ } ->
 442       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_13", match_err));;
 443 let net_device_parser_14 kernel_version bits =
 444   bitmatch bits with
 445   | { name : 128 : offset(0), string;
 446       next : zero+32 : offset(384), bigendian;
 447       flags : zero+32 : offset(704), bigendian;
 448       operstate : zero+8 : offset(784), bigendian;
 449       mtu : zero+32 : offset(800), bigendian;
 450       perm_addr : 256 : offset(896), string;
 451       addr_len : zero+8 : offset(1152), bigendian;
 452       ip_ptr : zero+32 : offset(1344), bigendian;
 453       ip6_ptr : zero+32 : offset(1408), bigendian } ->
 454       { net_device_addr_len = addr_len;
 455         net_device_dev_list'next = None;
 456           net_device_dev_list'next_offset = -1;
 457           net_device_dev_list'next_adjustment = -1;
 458         net_device_dev_list'prev = None;
 459         net_device_flags = flags;
 460         net_device_ip6_ptr = ip6_ptr;
 461         net_device_ip_ptr = ip_ptr;
 462         net_device_mtu = mtu;
 463         net_device_name = name;
 464         net_device_next = Some next;
 465         net_device_operstate = operstate;
 466         net_device_perm_addr = perm_addr }
 467   | { _ } ->
 468       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_14", match_err));;
 469 let net_device_parser_15 kernel_version bits =
 470   bitmatch bits with
 471   | { name : 128 : offset(0), string;
 472       next : zero+64 : offset(576), littleendian;
 473       flags : zero+32 : offset(1152), littleendian;
 474       operstate : zero+8 : offset(1232), littleendian;
 475       mtu : zero+32 : offset(1248), littleendian;
 476       perm_addr : 256 : offset(1408), string;
 477       addr_len : zero+8 : offset(1664), littleendian;
 478       ip_ptr : zero+64 : offset(1984), littleendian;
 479       ip6_ptr : zero+64 : offset(2112), littleendian } ->
 480       { net_device_addr_len = addr_len;
 481         net_device_dev_list'next = None;
 482           net_device_dev_list'next_offset = -1;
 483           net_device_dev_list'next_adjustment = -1;
 484         net_device_dev_list'prev = None;
 485         net_device_flags = flags;
 486         net_device_ip6_ptr = ip6_ptr;
 487         net_device_ip_ptr = ip_ptr;
 488         net_device_mtu = mtu;
 489         net_device_name = name;
 490         net_device_next = Some next;
 491         net_device_operstate = operstate;
 492         net_device_perm_addr = perm_addr }
 493   | { _ } ->
 494       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_15", match_err));;
 495 let net_device_parser_16 kernel_version bits =
 496   bitmatch bits with
 497   | { name : 128 : offset(0), string;
 498       next : zero+32 : offset(384), littleendian;
 499       flags : zero+32 : offset(704), littleendian;
 500       operstate : zero+8 : offset(784), littleendian;
 501       mtu : zero+32 : offset(800), littleendian;
 502       perm_addr : 256 : offset(896), string;
 503       addr_len : zero+8 : offset(1152), littleendian;
 504       ip_ptr : zero+32 : offset(1344), littleendian;
 505       ip6_ptr : zero+32 : offset(1408), littleendian } ->
 506       { net_device_addr_len = addr_len;
 507         net_device_dev_list'next = None;
 508           net_device_dev_list'next_offset = -1;
 509           net_device_dev_list'next_adjustment = -1;
 510         net_device_dev_list'prev = None;
 511         net_device_flags = flags;
 512         net_device_ip6_ptr = ip6_ptr;
 513         net_device_ip_ptr = ip_ptr;
 514         net_device_mtu = mtu;
 515         net_device_name = name;
 516         net_device_next = Some next;
 517         net_device_operstate = operstate;
 518         net_device_perm_addr = perm_addr }
 519   | { _ } ->
 520       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_16", match_err));;
 521 let net_device_parser_17 kernel_version bits =
 522   bitmatch bits with
 523   | { name : 128 : offset(0), string;
 524       next : zero+64 : offset(576), bigendian;
 525       flags : zero+32 : offset(1152), bigendian;
 526       operstate : zero+8 : offset(1232), bigendian;
 527       mtu : zero+32 : offset(1248), bigendian;
 528       perm_addr : 256 : offset(1408), string;
 529       addr_len : zero+8 : offset(1664), bigendian;
 530       ip_ptr : zero+64 : offset(1984), bigendian;
 531       ip6_ptr : zero+64 : offset(2112), bigendian } ->
 532       { net_device_addr_len = addr_len;
 533         net_device_dev_list'next = None;
 534           net_device_dev_list'next_offset = -1;
 535           net_device_dev_list'next_adjustment = -1;
 536         net_device_dev_list'prev = None;
 537         net_device_flags = flags;
 538         net_device_ip6_ptr = ip6_ptr;
 539         net_device_ip_ptr = ip_ptr;
 540         net_device_mtu = mtu;
 541         net_device_name = name;
 542         net_device_next = Some next;
 543         net_device_operstate = operstate;
 544         net_device_perm_addr = perm_addr }
 545   | { _ } ->
 546       raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_17", match_err));;
 547 let net_parser_20 kernel_version bits =
 548   bitmatch bits with
 549   | { dev_base_head'next : zero+32 : offset(416), littleendian;
 550       dev_base_head'prev : zero+32 : offset(448), littleendian } ->
 551       { net_dev_base_head'next = dev_base_head'next;
 552           net_dev_base_head'next_offset = 52;
 553           net_dev_base_head'next_adjustment = offset_of_net_device_dev_list'next kernel_version;
 554         net_dev_base_head'prev = dev_base_head'prev;
 555           net_dev_base_head'prev_offset = 56;
 556           net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
 557   | { _ } ->
 558       raise (Virt_mem_types.ParseError ("net", "net_parser_20", match_err));;
 559 let net_parser_21 kernel_version bits =
 560   bitmatch bits with
 561   | { dev_base_head'next : zero+32 : offset(416), bigendian;
 562       dev_base_head'prev : zero+32 : offset(448), bigendian } ->
 563       { net_dev_base_head'next = dev_base_head'next;
 564           net_dev_base_head'next_offset = 52;
 565           net_dev_base_head'next_adjustment = offset_of_net_device_dev_list'next kernel_version;
 566         net_dev_base_head'prev = dev_base_head'prev;
 567           net_dev_base_head'prev_offset = 56;
 568           net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
 569   | { _ } ->
 570       raise (Virt_mem_types.ParseError ("net", "net_parser_21", match_err));;
 571 let net_parser_18 kernel_version bits =
 572   bitmatch bits with
 573   | { dev_base_head'next : zero+64 : offset(768), littleendian;
 574       dev_base_head'prev : zero+64 : offset(832), littleendian } ->
 575       { net_dev_base_head'next = dev_base_head'next;
 576           net_dev_base_head'next_offset = 96;
 577           net_dev_base_head'next_adjustment = offset_of_net_device_dev_list'next kernel_version;
 578         net_dev_base_head'prev = dev_base_head'prev;
 579           net_dev_base_head'prev_offset = 104;
 580           net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
 581   | { _ } ->
 582       raise (Virt_mem_types.ParseError ("net", "net_parser_18", match_err));;
 583 let net_parser_19 kernel_version bits =
 584   bitmatch bits with
 585   | { dev_base_head'next : zero+64 : offset(768), bigendian;
 586       dev_base_head'prev : zero+64 : offset(832), bigendian } ->
 587       { net_dev_base_head'next = dev_base_head'next;
 588           net_dev_base_head'next_offset = 96;
 589           net_dev_base_head'next_adjustment = offset_of_net_device_dev_list'next kernel_version;
 590         net_dev_base_head'prev = dev_base_head'prev;
 591           net_dev_base_head'prev_offset = 104;
 592           net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
 593   | { _ } ->
 594       raise (Virt_mem_types.ParseError ("net", "net_parser_19", match_err));;
 595 let in_device_parser_24 kernel_version bits =
 596   bitmatch bits with
 597   | { ifa_list : zero+32 : offset(96), littleendian } ->
 598       { in_device_ifa_list = ifa_list }
 599   | { _ } ->
 600       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_24", match_err));;
 601 let in_device_parser_25 kernel_version bits =
 602   bitmatch bits with
 603   | { ifa_list : zero+32 : offset(96), bigendian } ->
 604       { in_device_ifa_list = ifa_list }
 605   | { _ } ->
 606       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_25", match_err));;
 607 let in_device_parser_22 kernel_version bits =
 608   bitmatch bits with
 609   | { ifa_list : zero+64 : offset(128), littleendian } ->
 610       { in_device_ifa_list = ifa_list }
 611   | { _ } ->
 612       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_22", match_err));;
 613 let in_device_parser_23 kernel_version bits =
 614   bitmatch bits with
 615   | { ifa_list : zero+64 : offset(128), bigendian } ->
 616       { in_device_ifa_list = ifa_list }
 617   | { _ } ->
 618       raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_23", match_err));;
 619 let inet6_dev_parser_28 kernel_version bits =
 620   bitmatch bits with
 621   | { addr_list : zero+32 : offset(32), littleendian } ->
 622       { inet6_dev_addr_list = addr_list }
 623   | { _ } ->
 624       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_28", match_err));;
 625 let inet6_dev_parser_29 kernel_version bits =
 626   bitmatch bits with
 627   | { addr_list : zero+32 : offset(32), bigendian } ->
 628       { inet6_dev_addr_list = addr_list }
 629   | { _ } ->
 630       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_29", match_err));;
 631 let inet6_dev_parser_26 kernel_version bits =
 632   bitmatch bits with
 633   | { addr_list : zero+64 : offset(64), littleendian } ->
 634       { inet6_dev_addr_list = addr_list }
 635   | { _ } ->
 636       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_26", match_err));;
 637 let inet6_dev_parser_27 kernel_version bits =
 638   bitmatch bits with
 639   | { addr_list : zero+64 : offset(64), bigendian } ->
 640       { inet6_dev_addr_list = addr_list }
 641   | { _ } ->
 642       raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_27", match_err));;
 643 let in_ifaddr_parser_32 kernel_version bits =
 644   bitmatch bits with
 645   | { ifa_next : zero+32 : offset(0), littleendian;
 646       ifa_local : zero+32 : offset(128), littleendian;
 647       ifa_address : zero+32 : offset(160), littleendian;
 648       ifa_mask : zero+32 : offset(192), littleendian;
 649       ifa_broadcast : zero+32 : offset(224), littleendian } ->
 650       { in_ifaddr_ifa_address = ifa_address;
 651         in_ifaddr_ifa_broadcast = ifa_broadcast;
 652         in_ifaddr_ifa_local = ifa_local;
 653         in_ifaddr_ifa_mask = ifa_mask;
 654         in_ifaddr_ifa_next = ifa_next }
 655   | { _ } ->
 656       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_32", match_err));;
 657 let in_ifaddr_parser_33 kernel_version bits =
 658   bitmatch bits with
 659   | { ifa_next : zero+32 : offset(0), bigendian;
 660       ifa_local : zero+32 : offset(128), bigendian;
 661       ifa_address : zero+32 : offset(160), bigendian;
 662       ifa_mask : zero+32 : offset(192), bigendian;
 663       ifa_broadcast : zero+32 : offset(224), bigendian } ->
 664       { in_ifaddr_ifa_address = ifa_address;
 665         in_ifaddr_ifa_broadcast = ifa_broadcast;
 666         in_ifaddr_ifa_local = ifa_local;
 667         in_ifaddr_ifa_mask = ifa_mask;
 668         in_ifaddr_ifa_next = ifa_next }
 669   | { _ } ->
 670       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_33", match_err));;
 671 let in_ifaddr_parser_30 kernel_version bits =
 672   bitmatch bits with
 673   | { ifa_next : zero+64 : offset(0), littleendian;
 674       ifa_local : zero+32 : offset(256), littleendian;
 675       ifa_address : zero+32 : offset(288), littleendian;
 676       ifa_mask : zero+32 : offset(320), littleendian;
 677       ifa_broadcast : zero+32 : offset(352), littleendian } ->
 678       { in_ifaddr_ifa_address = ifa_address;
 679         in_ifaddr_ifa_broadcast = ifa_broadcast;
 680         in_ifaddr_ifa_local = ifa_local;
 681         in_ifaddr_ifa_mask = ifa_mask;
 682         in_ifaddr_ifa_next = ifa_next }
 683   | { _ } ->
 684       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_30", match_err));;
 685 let in_ifaddr_parser_31 kernel_version bits =
 686   bitmatch bits with
 687   | { ifa_next : zero+64 : offset(0), bigendian;
 688       ifa_local : zero+32 : offset(256), bigendian;
 689       ifa_address : zero+32 : offset(288), bigendian;
 690       ifa_mask : zero+32 : offset(320), bigendian;
 691       ifa_broadcast : zero+32 : offset(352), bigendian } ->
 692       { in_ifaddr_ifa_address = ifa_address;
 693         in_ifaddr_ifa_broadcast = ifa_broadcast;
 694         in_ifaddr_ifa_local = ifa_local;
 695         in_ifaddr_ifa_mask = ifa_mask;
 696         in_ifaddr_ifa_next = ifa_next }
 697   | { _ } ->
 698       raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_31", match_err));;
 699 let inet6_ifaddr_parser_36 kernel_version bits =
 700   bitmatch bits with
 701   | { prefix_len : zero+32 : offset(128), littleendian;
 702       lst_next : zero+32 : offset(832), littleendian } ->
 703       { inet6_ifaddr_lst_next = lst_next;
 704         inet6_ifaddr_prefix_len = prefix_len }
 705   | { _ } ->
 706       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_36", match_err));;
 707 let inet6_ifaddr_parser_34 kernel_version bits =
 708   bitmatch bits with
 709   | { prefix_len : zero+32 : offset(128), littleendian;
 710       lst_next : zero+64 : offset(1280), littleendian } ->
 711       { inet6_ifaddr_lst_next = lst_next;
 712         inet6_ifaddr_prefix_len = prefix_len }
 713   | { _ } ->
 714       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_34", match_err));;
 715 let inet6_ifaddr_parser_35 kernel_version bits =
 716   bitmatch bits with
 717   | { prefix_len : zero+32 : offset(128), bigendian;
 718       lst_next : zero+64 : offset(1280), bigendian } ->
 719       { inet6_ifaddr_lst_next = lst_next;
 720         inet6_ifaddr_prefix_len = prefix_len }
 721   | { _ } ->
 722       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_35", match_err));;
 723 let inet6_ifaddr_parser_37 kernel_version bits =
 724   bitmatch bits with
 725   | { prefix_len : zero+32 : offset(128), bigendian;
 726       lst_next : zero+32 : offset(800), bigendian } ->
 727       { inet6_ifaddr_lst_next = lst_next;
 728         inet6_ifaddr_prefix_len = prefix_len }
 729   | { _ } ->
 730       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_37", match_err));;
 731 let inet6_ifaddr_parser_39 kernel_version bits =
 732   bitmatch bits with
 733   | { prefix_len : zero+32 : offset(128), littleendian;
 734       lst_next : zero+64 : offset(1216), littleendian } ->
 735       { inet6_ifaddr_lst_next = lst_next;
 736         inet6_ifaddr_prefix_len = prefix_len }
 737   | { _ } ->
 738       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_39", match_err));;
 739 let inet6_ifaddr_parser_41 kernel_version bits =
 740   bitmatch bits with
 741   | { prefix_len : zero+32 : offset(128), bigendian;
 742       lst_next : zero+64 : offset(1216), bigendian } ->
 743       { inet6_ifaddr_lst_next = lst_next;
 744         inet6_ifaddr_prefix_len = prefix_len }
 745   | { _ } ->
 746       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_41", match_err));;
 747 let inet6_ifaddr_parser_38 kernel_version bits =
 748   bitmatch bits with
 749   | { prefix_len : zero+32 : offset(128), bigendian;
 750       lst_next : zero+32 : offset(736), bigendian } ->
 751       { inet6_ifaddr_lst_next = lst_next;
 752         inet6_ifaddr_prefix_len = prefix_len }
 753   | { _ } ->
 754       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_38", match_err));;
 755 let inet6_ifaddr_parser_40 kernel_version bits =
 756   bitmatch bits with
 757   | { prefix_len : zero+32 : offset(128), littleendian;
 758       lst_next : zero+32 : offset(736), littleendian } ->
 759       { inet6_ifaddr_lst_next = lst_next;
 760         inet6_ifaddr_prefix_len = prefix_len }
 761   | { _ } ->
 762       raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_40", match_err));;
 763 let size_of_task_struct =
 764   let map =
 765     StringMap.add "2.6.25.14-69.fc8.x86_64" 2496
 766       (StringMap.add "2.6.25.14-108.fc9.ppc64" 2524
 767          (StringMap.add "2.6.25.14-108.fc9.i586" 1832
 768             (StringMap.add "2.6.25.14-108.fc9.i686" 1832
 769                (StringMap.add "2.6.25.14-69.fc8.ppc" 1952
 770                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 2496
 771                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 2496
 772                         (StringMap.add "2.6.25.14-69.fc8.i586" 1832
 773                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 1592
 774                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 1920
 775                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 2524
 776                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 777                                        1832
 778                                        (StringMap.add
 779                                           "2.6.20-1.2933.fc6.i686" 1400
 780                                           (StringMap.add
 781                                              "2.6.20-1.2933.fc6.i586" 1400
 782                                              (StringMap.add
 783                                                 "2.6.25.14-108.fc9.ppc" 1952
 784                                                 (StringMap.add
 785                                                    "2.6.20-1.2933.fc6.ppc64"
 786                                                    2112
 787                                                    (StringMap.add
 788                                                       "2.6.25.14-69.fc8.i686"
 789                                                       1832 StringMap.empty))))))))))))))))
 790   in
 791     fun kernel_version ->
 792       try StringMap.find kernel_version map
 793       with | Not_found -> unknown_kernel_version kernel_version "task_struct";;
 794 let size_of_net_device =
 795   let map =
 796     StringMap.add "2.6.25.14-69.fc8.x86_64" 1752
 797       (StringMap.add "2.6.25.14-108.fc9.ppc64" 1776
 798          (StringMap.add "2.6.25.14-108.fc9.i586" 1212
 799             (StringMap.add "2.6.25.14-108.fc9.i686" 1212
 800                (StringMap.add "2.6.25.14-69.fc8.ppc" 904
 801                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 1752
 802                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 1752
 803                         (StringMap.add "2.6.25.14-69.fc8.i586" 1212
 804                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 668
 805                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 1260
 806                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 1776
 807                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 808                                        1212
 809                                        (StringMap.add
 810                                           "2.6.20-1.2933.fc6.i686" 912
 811                                           (StringMap.add
 812                                              "2.6.20-1.2933.fc6.i586" 912
 813                                              (StringMap.add
 814                                                 "2.6.25.14-108.fc9.ppc" 904
 815                                                 (StringMap.add
 816                                                    "2.6.20-1.2933.fc6.ppc64"
 817                                                    1260
 818                                                    (StringMap.add
 819                                                       "2.6.25.14-69.fc8.i686"
 820                                                       1212 StringMap.empty))))))))))))))))
 821   in
 822     fun kernel_version ->
 823       try StringMap.find kernel_version map
 824       with | Not_found -> unknown_kernel_version kernel_version "net_device";;
 825 let size_of_net =
 826   let map =
 827     StringMap.add "2.6.25.14-69.fc8.x86_64" 488
 828       (StringMap.add "2.6.25.14-108.fc9.ppc64" 488
 829          (StringMap.add "2.6.25.14-108.fc9.i586" 284
 830             (StringMap.add "2.6.25.14-108.fc9.i686" 284
 831                (StringMap.add "2.6.25.14-69.fc8.ppc" 276
 832                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 488
 833                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 488
 834                         (StringMap.add "2.6.25.14-69.fc8.i586" 284
 835                            (StringMap.add "2.6.25.14-69.fc8.ppc64" 488
 836                               (StringMap.add "2.6.25.11-97.fc9.i686" 284
 837                                  (StringMap.add "2.6.25.14-108.fc9.ppc" 276
 838                                     (StringMap.add "2.6.25.14-69.fc8.i686"
 839                                        284 StringMap.empty)))))))))))
 840   in
 841     fun kernel_version ->
 842       try StringMap.find kernel_version map
 843       with | Not_found -> unknown_kernel_version kernel_version "net";;
 844 let size_of_in_device =
 845   let map =
 846     StringMap.add "2.6.25.14-69.fc8.x86_64" 368
 847       (StringMap.add "2.6.25.14-108.fc9.ppc64" 368
 848          (StringMap.add "2.6.25.14-108.fc9.i586" 244
 849             (StringMap.add "2.6.25.14-108.fc9.i686" 244
 850                (StringMap.add "2.6.25.14-69.fc8.ppc" 236
 851                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 368
 852                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 368
 853                         (StringMap.add "2.6.25.14-69.fc8.i586" 244
 854                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 212
 855                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 328
 856                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 368
 857                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 858                                        244
 859                                        (StringMap.add
 860                                           "2.6.20-1.2933.fc6.i686" 216
 861                                           (StringMap.add
 862                                              "2.6.20-1.2933.fc6.i586" 216
 863                                              (StringMap.add
 864                                                 "2.6.25.14-108.fc9.ppc" 236
 865                                                 (StringMap.add
 866                                                    "2.6.20-1.2933.fc6.ppc64"
 867                                                    328
 868                                                    (StringMap.add
 869                                                       "2.6.25.14-69.fc8.i686"
 870                                                       244 StringMap.empty))))))))))))))))
 871   in
 872     fun kernel_version ->
 873       try StringMap.find kernel_version map
 874       with | Not_found -> unknown_kernel_version kernel_version "in_device";;
 875 let size_of_inet6_dev =
 876   let map =
 877     StringMap.add "2.6.25.14-69.fc8.x86_64" 536
 878       (StringMap.add "2.6.25.14-108.fc9.ppc64" 536
 879          (StringMap.add "2.6.25.14-108.fc9.i586" 356
 880             (StringMap.add "2.6.25.14-108.fc9.i686" 356
 881                (StringMap.add "2.6.25.14-69.fc8.ppc" 348
 882                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 536
 883                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 536
 884                         (StringMap.add "2.6.25.14-69.fc8.i586" 356
 885                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 284
 886                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 464
 887                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 536
 888                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 889                                        356
 890                                        (StringMap.add
 891                                           "2.6.20-1.2933.fc6.i686" 292
 892                                           (StringMap.add
 893                                              "2.6.20-1.2933.fc6.i586" 292
 894                                              (StringMap.add
 895                                                 "2.6.25.14-108.fc9.ppc" 348
 896                                                 (StringMap.add
 897                                                    "2.6.20-1.2933.fc6.ppc64"
 898                                                    464
 899                                                    (StringMap.add
 900                                                       "2.6.25.14-69.fc8.i686"
 901                                                       356 StringMap.empty))))))))))))))))
 902   in
 903     fun kernel_version ->
 904       try StringMap.find kernel_version map
 905       with | Not_found -> unknown_kernel_version kernel_version "inet6_dev";;
 906 let size_of_in_ifaddr =
 907   let map =
 908     StringMap.add "2.6.25.14-69.fc8.x86_64" 71
 909       (StringMap.add "2.6.25.14-108.fc9.ppc64" 71
 910          (StringMap.add "2.6.25.14-108.fc9.i586" 55
 911             (StringMap.add "2.6.25.14-108.fc9.i686" 55
 912                (StringMap.add "2.6.25.14-69.fc8.ppc" 55
 913                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 71
 914                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 71
 915                         (StringMap.add "2.6.25.14-69.fc8.i586" 55
 916                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 55
 917                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 71
 918                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 71
 919                                     (StringMap.add "2.6.25.11-97.fc9.i686" 55
 920                                        (StringMap.add
 921                                           "2.6.20-1.2933.fc6.i686" 55
 922                                           (StringMap.add
 923                                              "2.6.20-1.2933.fc6.i586" 55
 924                                              (StringMap.add
 925                                                 "2.6.25.14-108.fc9.ppc" 55
 926                                                 (StringMap.add
 927                                                    "2.6.20-1.2933.fc6.ppc64"
 928                                                    71
 929                                                    (StringMap.add
 930                                                       "2.6.25.14-69.fc8.i686"
 931                                                       55 StringMap.empty))))))))))))))))
 932   in
 933     fun kernel_version ->
 934       try StringMap.find kernel_version map
 935       with | Not_found -> unknown_kernel_version kernel_version "in_ifaddr";;
 936 let size_of_inet6_ifaddr =
 937   let map =
 938     StringMap.add "2.6.25.14-69.fc8.x86_64" 200
 939       (StringMap.add "2.6.25.14-108.fc9.ppc64" 200
 940          (StringMap.add "2.6.25.14-108.fc9.i586" 128
 941             (StringMap.add "2.6.25.14-108.fc9.i686" 128
 942                (StringMap.add "2.6.25.14-69.fc8.ppc" 124
 943                   (StringMap.add "2.6.25.14-108.fc9.x86_64" 200
 944                      (StringMap.add "2.6.25.11-97.fc9.x86_64" 200
 945                         (StringMap.add "2.6.25.14-69.fc8.i586" 128
 946                            (StringMap.add "2.6.20-1.2933.fc6.ppc" 116
 947                               (StringMap.add "2.6.20-1.2933.fc6.x86_64" 192
 948                                  (StringMap.add "2.6.25.14-69.fc8.ppc64" 200
 949                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 950                                        128
 951                                        (StringMap.add
 952                                           "2.6.20-1.2933.fc6.i686" 116
 953                                           (StringMap.add
 954                                              "2.6.20-1.2933.fc6.i586" 116
 955                                              (StringMap.add
 956                                                 "2.6.25.14-108.fc9.ppc" 124
 957                                                 (StringMap.add
 958                                                    "2.6.20-1.2933.fc6.ppc64"
 959                                                    192
 960                                                    (StringMap.add
 961                                                       "2.6.25.14-69.fc8.i686"
 962                                                       128 StringMap.empty))))))))))))))))
 963   in
 964     fun kernel_version ->
 965       try StringMap.find kernel_version map
 966       with
 967       | Not_found -> unknown_kernel_version kernel_version "inet6_ifaddr";;
 968 let parser_of_task_struct =
 969   let map =
 970     StringMap.add "2.6.25.14-69.fc8.x86_64" task_struct_parser_1
 971       (StringMap.add "2.6.25.14-108.fc9.ppc64" task_struct_parser_2
 972          (StringMap.add "2.6.25.14-108.fc9.i586" task_struct_parser_3
 973             (StringMap.add "2.6.25.14-108.fc9.i686" task_struct_parser_4
 974                (StringMap.add "2.6.25.14-69.fc8.ppc" task_struct_parser_5
 975                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
 976                      task_struct_parser_1
 977                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
 978                         task_struct_parser_1
 979                         (StringMap.add "2.6.25.14-69.fc8.i586"
 980                            task_struct_parser_3
 981                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
 982                               task_struct_parser_6
 983                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
 984                                  task_struct_parser_7
 985                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
 986                                     task_struct_parser_2
 987                                     (StringMap.add "2.6.25.11-97.fc9.i686"
 988                                        task_struct_parser_4
 989                                        (StringMap.add
 990                                           "2.6.20-1.2933.fc6.i686"
 991                                           task_struct_parser_8
 992                                           (StringMap.add
 993                                              "2.6.20-1.2933.fc6.i586"
 994                                              task_struct_parser_8
 995                                              (StringMap.add
 996                                                 "2.6.25.14-108.fc9.ppc"
 997                                                 task_struct_parser_5
 998                                                 (StringMap.add
 999                                                    "2.6.20-1.2933.fc6.ppc64"
1000                                                    task_struct_parser_9
1001                                                    (StringMap.add
1002                                                       "2.6.25.14-69.fc8.i686"
1003                                                       task_struct_parser_4
1004                                                       StringMap.empty))))))))))))))))
1005   in
1006     fun kernel_version ->
1007       try StringMap.find kernel_version map
1008       with | Not_found -> unknown_kernel_version kernel_version "task_struct";;
1009 let parser_of_net_device =
1010   let map =
1011     StringMap.add "2.6.25.14-69.fc8.x86_64" net_device_parser_10
1012       (StringMap.add "2.6.25.14-108.fc9.ppc64" net_device_parser_11
1013          (StringMap.add "2.6.25.14-108.fc9.i586" net_device_parser_12
1014             (StringMap.add "2.6.25.14-108.fc9.i686" net_device_parser_12
1015                (StringMap.add "2.6.25.14-69.fc8.ppc" net_device_parser_13
1016                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
1017                      net_device_parser_10
1018                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
1019                         net_device_parser_10
1020                         (StringMap.add "2.6.25.14-69.fc8.i586"
1021                            net_device_parser_12
1022                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
1023                               net_device_parser_14
1024                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
1025                                  net_device_parser_15
1026                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
1027                                     net_device_parser_11
1028                                     (StringMap.add "2.6.25.11-97.fc9.i686"
1029                                        net_device_parser_12
1030                                        (StringMap.add
1031                                           "2.6.20-1.2933.fc6.i686"
1032                                           net_device_parser_16
1033                                           (StringMap.add
1034                                              "2.6.20-1.2933.fc6.i586"
1035                                              net_device_parser_16
1036                                              (StringMap.add
1037                                                 "2.6.25.14-108.fc9.ppc"
1038                                                 net_device_parser_13
1039                                                 (StringMap.add
1040                                                    "2.6.20-1.2933.fc6.ppc64"
1041                                                    net_device_parser_17
1042                                                    (StringMap.add
1043                                                       "2.6.25.14-69.fc8.i686"
1044                                                       net_device_parser_12
1045                                                       StringMap.empty))))))))))))))))
1046   in
1047     fun kernel_version ->
1048       try StringMap.find kernel_version map
1049       with | Not_found -> unknown_kernel_version kernel_version "net_device";;
1050 let parser_of_net =
1051   let map =
1052     StringMap.add "2.6.25.14-69.fc8.x86_64" net_parser_18
1053       (StringMap.add "2.6.25.14-108.fc9.ppc64" net_parser_19
1054          (StringMap.add "2.6.25.14-108.fc9.i586" net_parser_20
1055             (StringMap.add "2.6.25.14-108.fc9.i686" net_parser_20
1056                (StringMap.add "2.6.25.14-69.fc8.ppc" net_parser_21
1057                   (StringMap.add "2.6.25.14-108.fc9.x86_64" net_parser_18
1058                      (StringMap.add "2.6.25.11-97.fc9.x86_64" net_parser_18
1059                         (StringMap.add "2.6.25.14-69.fc8.i586" net_parser_20
1060                            (StringMap.add "2.6.25.14-69.fc8.ppc64"
1061                               net_parser_19
1062                               (StringMap.add "2.6.25.11-97.fc9.i686"
1063                                  net_parser_20
1064                                  (StringMap.add "2.6.25.14-108.fc9.ppc"
1065                                     net_parser_21
1066                                     (StringMap.add "2.6.25.14-69.fc8.i686"
1067                                        net_parser_20 StringMap.empty)))))))))))
1068   in
1069     fun kernel_version ->
1070       try StringMap.find kernel_version map
1071       with | Not_found -> unknown_kernel_version kernel_version "net";;
1072 let parser_of_in_device =
1073   let map =
1074     StringMap.add "2.6.25.14-69.fc8.x86_64" in_device_parser_22
1075       (StringMap.add "2.6.25.14-108.fc9.ppc64" in_device_parser_23
1076          (StringMap.add "2.6.25.14-108.fc9.i586" in_device_parser_24
1077             (StringMap.add "2.6.25.14-108.fc9.i686" in_device_parser_24
1078                (StringMap.add "2.6.25.14-69.fc8.ppc" in_device_parser_25
1079                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
1080                      in_device_parser_22
1081                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
1082                         in_device_parser_22
1083                         (StringMap.add "2.6.25.14-69.fc8.i586"
1084                            in_device_parser_24
1085                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
1086                               in_device_parser_25
1087                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
1088                                  in_device_parser_22
1089                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
1090                                     in_device_parser_23
1091                                     (StringMap.add "2.6.25.11-97.fc9.i686"
1092                                        in_device_parser_24
1093                                        (StringMap.add
1094                                           "2.6.20-1.2933.fc6.i686"
1095                                           in_device_parser_24
1096                                           (StringMap.add
1097                                              "2.6.20-1.2933.fc6.i586"
1098                                              in_device_parser_24
1099                                              (StringMap.add
1100                                                 "2.6.25.14-108.fc9.ppc"
1101                                                 in_device_parser_25
1102                                                 (StringMap.add
1103                                                    "2.6.20-1.2933.fc6.ppc64"
1104                                                    in_device_parser_23
1105                                                    (StringMap.add
1106                                                       "2.6.25.14-69.fc8.i686"
1107                                                       in_device_parser_24
1108                                                       StringMap.empty))))))))))))))))
1109   in
1110     fun kernel_version ->
1111       try StringMap.find kernel_version map
1112       with | Not_found -> unknown_kernel_version kernel_version "in_device";;
1113 let parser_of_inet6_dev =
1114   let map =
1115     StringMap.add "2.6.25.14-69.fc8.x86_64" inet6_dev_parser_26
1116       (StringMap.add "2.6.25.14-108.fc9.ppc64" inet6_dev_parser_27
1117          (StringMap.add "2.6.25.14-108.fc9.i586" inet6_dev_parser_28
1118             (StringMap.add "2.6.25.14-108.fc9.i686" inet6_dev_parser_28
1119                (StringMap.add "2.6.25.14-69.fc8.ppc" inet6_dev_parser_29
1120                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
1121                      inet6_dev_parser_26
1122                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
1123                         inet6_dev_parser_26
1124                         (StringMap.add "2.6.25.14-69.fc8.i586"
1125                            inet6_dev_parser_28
1126                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
1127                               inet6_dev_parser_29
1128                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
1129                                  inet6_dev_parser_26
1130                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
1131                                     inet6_dev_parser_27
1132                                     (StringMap.add "2.6.25.11-97.fc9.i686"
1133                                        inet6_dev_parser_28
1134                                        (StringMap.add
1135                                           "2.6.20-1.2933.fc6.i686"
1136                                           inet6_dev_parser_28
1137                                           (StringMap.add
1138                                              "2.6.20-1.2933.fc6.i586"
1139                                              inet6_dev_parser_28
1140                                              (StringMap.add
1141                                                 "2.6.25.14-108.fc9.ppc"
1142                                                 inet6_dev_parser_29
1143                                                 (StringMap.add
1144                                                    "2.6.20-1.2933.fc6.ppc64"
1145                                                    inet6_dev_parser_27
1146                                                    (StringMap.add
1147                                                       "2.6.25.14-69.fc8.i686"
1148                                                       inet6_dev_parser_28
1149                                                       StringMap.empty))))))))))))))))
1150   in
1151     fun kernel_version ->
1152       try StringMap.find kernel_version map
1153       with | Not_found -> unknown_kernel_version kernel_version "inet6_dev";;
1154 let parser_of_in_ifaddr =
1155   let map =
1156     StringMap.add "2.6.25.14-69.fc8.x86_64" in_ifaddr_parser_30
1157       (StringMap.add "2.6.25.14-108.fc9.ppc64" in_ifaddr_parser_31
1158          (StringMap.add "2.6.25.14-108.fc9.i586" in_ifaddr_parser_32
1159             (StringMap.add "2.6.25.14-108.fc9.i686" in_ifaddr_parser_32
1160                (StringMap.add "2.6.25.14-69.fc8.ppc" in_ifaddr_parser_33
1161                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
1162                      in_ifaddr_parser_30
1163                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
1164                         in_ifaddr_parser_30
1165                         (StringMap.add "2.6.25.14-69.fc8.i586"
1166                            in_ifaddr_parser_32
1167                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
1168                               in_ifaddr_parser_33
1169                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
1170                                  in_ifaddr_parser_30
1171                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
1172                                     in_ifaddr_parser_31
1173                                     (StringMap.add "2.6.25.11-97.fc9.i686"
1174                                        in_ifaddr_parser_32
1175                                        (StringMap.add
1176                                           "2.6.20-1.2933.fc6.i686"
1177                                           in_ifaddr_parser_32
1178                                           (StringMap.add
1179                                              "2.6.20-1.2933.fc6.i586"
1180                                              in_ifaddr_parser_32
1181                                              (StringMap.add
1182                                                 "2.6.25.14-108.fc9.ppc"
1183                                                 in_ifaddr_parser_33
1184                                                 (StringMap.add
1185                                                    "2.6.20-1.2933.fc6.ppc64"
1186                                                    in_ifaddr_parser_31
1187                                                    (StringMap.add
1188                                                       "2.6.25.14-69.fc8.i686"
1189                                                       in_ifaddr_parser_32
1190                                                       StringMap.empty))))))))))))))))
1191   in
1192     fun kernel_version ->
1193       try StringMap.find kernel_version map
1194       with | Not_found -> unknown_kernel_version kernel_version "in_ifaddr";;
1195 let parser_of_inet6_ifaddr =
1196   let map =
1197     StringMap.add "2.6.25.14-69.fc8.x86_64" inet6_ifaddr_parser_34
1198       (StringMap.add "2.6.25.14-108.fc9.ppc64" inet6_ifaddr_parser_35
1199          (StringMap.add "2.6.25.14-108.fc9.i586" inet6_ifaddr_parser_36
1200             (StringMap.add "2.6.25.14-108.fc9.i686" inet6_ifaddr_parser_36
1201                (StringMap.add "2.6.25.14-69.fc8.ppc" inet6_ifaddr_parser_37
1202                   (StringMap.add "2.6.25.14-108.fc9.x86_64"
1203                      inet6_ifaddr_parser_34
1204                      (StringMap.add "2.6.25.11-97.fc9.x86_64"
1205                         inet6_ifaddr_parser_34
1206                         (StringMap.add "2.6.25.14-69.fc8.i586"
1207                            inet6_ifaddr_parser_36
1208                            (StringMap.add "2.6.20-1.2933.fc6.ppc"
1209                               inet6_ifaddr_parser_38
1210                               (StringMap.add "2.6.20-1.2933.fc6.x86_64"
1211                                  inet6_ifaddr_parser_39
1212                                  (StringMap.add "2.6.25.14-69.fc8.ppc64"
1213                                     inet6_ifaddr_parser_35
1214                                     (StringMap.add "2.6.25.11-97.fc9.i686"
1215                                        inet6_ifaddr_parser_36
1216                                        (StringMap.add
1217                                           "2.6.20-1.2933.fc6.i686"
1218                                           inet6_ifaddr_parser_40
1219                                           (StringMap.add
1220                                              "2.6.20-1.2933.fc6.i586"
1221                                              inet6_ifaddr_parser_40
1222                                              (StringMap.add
1223                                                 "2.6.25.14-108.fc9.ppc"
1224                                                 inet6_ifaddr_parser_37
1225                                                 (StringMap.add
1226                                                    "2.6.20-1.2933.fc6.ppc64"
1227                                                    inet6_ifaddr_parser_41
1228                                                    (StringMap.add
1229                                                       "2.6.25.14-69.fc8.i686"
1230                                                       inet6_ifaddr_parser_36
1231                                                       StringMap.empty))))))))))))))))
1232   in
1233     fun kernel_version ->
1234       try StringMap.find kernel_version map
1235       with
1236       | Not_found -> unknown_kernel_version kernel_version "inet6_ifaddr";;
1237 let rec task_struct_follower kernel_version load map addr =
1238   if (addr <> 0L) && (not (AddrMap.mem addr map))
1239   then
1240     (let parser_ = parser_of_task_struct kernel_version in
1241      let total_size = size_of_task_struct kernel_version in
1242      let bits = load "task_struct" addr total_size in
1243      let data = parser_ kernel_version bits in
1244      let map =
1245        AddrMap.add addr
1246          ("task_struct", (Some (total_size, bits, Task_struct data))) map in
1247      let map =
1248        match data.task_struct_run_list'next with
1249        | None -> map
1250        | Some dest_addr ->
1251            let offset = data.task_struct_run_list'next_offset
1252            and adj = data.task_struct_run_list'next_adjustment in
1253            let offset = Int64.of_int offset and adj = Int64.of_int adj in
1254            let addr = Int64.sub (Int64.add addr offset) adj in
1255            let map = AddrMap.add addr ("task_struct", None) map in
1256            let dest_addr = Int64.sub dest_addr adj in
1257            let map = task_struct_follower kernel_version load map dest_addr
1258            in map in
1259      let dest_addr = data.task_struct_tasks'next in
1260      let map =
1261        let offset = data.task_struct_tasks'next_offset
1262        and adj = data.task_struct_tasks'next_adjustment in
1263        let offset = Int64.of_int offset and adj = Int64.of_int adj in
1264        let addr = Int64.sub (Int64.add addr offset) adj in
1265        let map = AddrMap.add addr ("task_struct", None) map in
1266        let dest_addr = Int64.sub dest_addr adj in
1267        let map = task_struct_follower kernel_version load map dest_addr
1268        in map
1269      in map)
1270   else map
1271 and net_device_follower kernel_version load map addr =
1272   if (addr <> 0L) && (not (AddrMap.mem addr map))
1273   then
1274     (let parser_ = parser_of_net_device kernel_version in
1275      let total_size = size_of_net_device kernel_version in
1276      let bits = load "net_device" addr total_size in
1277      let data = parser_ kernel_version bits in
1278      let map =
1279        AddrMap.add addr
1280          ("net_device", (Some (total_size, bits, Net_device data))) map in
1281      let map =
1282        match data.net_device_dev_list'next with
1283        | None -> map
1284        | Some dest_addr ->
1285            let offset = data.net_device_dev_list'next_offset
1286            and adj = data.net_device_dev_list'next_adjustment in
1287            let offset = Int64.of_int offset and adj = Int64.of_int adj in
1288            let addr = Int64.sub (Int64.add addr offset) adj in
1289            let map = AddrMap.add addr ("net_device", None) map in
1290            let dest_addr = Int64.sub dest_addr adj in
1291            let map = net_device_follower kernel_version load map dest_addr
1292            in map in
1293      let dest_addr = data.net_device_ip6_ptr in
1294      let map =
1295        let map = inet6_dev_follower kernel_version load map dest_addr in map in
1296      let dest_addr = data.net_device_ip_ptr in
1297      let map =
1298        let map = in_device_follower kernel_version load map dest_addr in map in
1299      let map =
1300        match data.net_device_next with
1301        | None -> map
1302        | Some dest_addr ->
1303            let map = net_device_follower kernel_version load map dest_addr
1304            in map
1305      in map)
1306   else map
1307 and net_follower kernel_version load map addr =
1308   if (addr <> 0L) && (not (AddrMap.mem addr map))
1309   then
1310     (let parser_ = parser_of_net kernel_version in
1311      let total_size = size_of_net kernel_version in
1312      let bits = load "net" addr total_size in
1313      let data = parser_ kernel_version bits in
1314      let map =
1315        AddrMap.add addr ("net", (Some (total_size, bits, Net data))) map in
1316      let dest_addr = data.net_dev_base_head'next in
1317      let map =
1318        let offset = data.net_dev_base_head'next_offset
1319        and adj = data.net_dev_base_head'next_adjustment in
1320        let offset = Int64.of_int offset and adj = Int64.of_int adj in
1321        let addr = Int64.sub (Int64.add addr offset) adj in
1322        let map = AddrMap.add addr ("net_device", None) map in
1323        let dest_addr = Int64.sub dest_addr adj in
1324        let map = net_device_follower kernel_version load map dest_addr in map in
1325      let dest_addr = data.net_dev_base_head'prev in
1326      let map =
1327        let offset = data.net_dev_base_head'prev_offset
1328        and adj = data.net_dev_base_head'prev_adjustment in
1329        let offset = Int64.of_int offset and adj = Int64.of_int adj in
1330        let addr = Int64.sub (Int64.add addr offset) adj in
1331        let map = AddrMap.add addr ("net_device", None) map in
1332        let dest_addr = Int64.sub dest_addr adj in
1333        let map = net_device_follower kernel_version load map dest_addr in map
1334      in map)
1335   else map
1336 and in_device_follower kernel_version load map addr =
1337   if (addr <> 0L) && (not (AddrMap.mem addr map))
1338   then
1339     (let parser_ = parser_of_in_device kernel_version in
1340      let total_size = size_of_in_device kernel_version in
1341      let bits = load "in_device" addr total_size in
1342      let data = parser_ kernel_version bits in
1343      let map =
1344        AddrMap.add addr
1345          ("in_device", (Some (total_size, bits, In_device data))) map in
1346      let dest_addr = data.in_device_ifa_list in
1347      let map =
1348        let map = in_ifaddr_follower kernel_version load map dest_addr in map
1349      in map)
1350   else map
1351 and inet6_dev_follower kernel_version load map addr =
1352   if (addr <> 0L) && (not (AddrMap.mem addr map))
1353   then
1354     (let parser_ = parser_of_inet6_dev kernel_version in
1355      let total_size = size_of_inet6_dev kernel_version in
1356      let bits = load "inet6_dev" addr total_size in
1357      let data = parser_ kernel_version bits in
1358      let map =
1359        AddrMap.add addr
1360          ("inet6_dev", (Some (total_size, bits, Inet6_dev data))) map in
1361      let dest_addr = data.inet6_dev_addr_list in
1362      let map =
1363        let map = inet6_ifaddr_follower kernel_version load map dest_addr
1364        in map
1365      in map)
1366   else map
1367 and in_ifaddr_follower kernel_version load map addr =
1368   if (addr <> 0L) && (not (AddrMap.mem addr map))
1369   then
1370     (let parser_ = parser_of_in_ifaddr kernel_version in
1371      let total_size = size_of_in_ifaddr kernel_version in
1372      let bits = load "in_ifaddr" addr total_size in
1373      let data = parser_ kernel_version bits in
1374      let map =
1375        AddrMap.add addr
1376          ("in_ifaddr", (Some (total_size, bits, In_ifaddr data))) map in
1377      let dest_addr = data.in_ifaddr_ifa_next in
1378      let map =
1379        let map = in_ifaddr_follower kernel_version load map dest_addr in map
1380      in map)
1381   else map
1382 and inet6_ifaddr_follower kernel_version load map addr =
1383   if (addr <> 0L) && (not (AddrMap.mem addr map))
1384   then
1385     (let parser_ = parser_of_inet6_ifaddr kernel_version in
1386      let total_size = size_of_inet6_ifaddr kernel_version in
1387      let bits = load "inet6_ifaddr" addr total_size in
1388      let data = parser_ kernel_version bits in
1389      let map =
1390        AddrMap.add addr
1391          ("inet6_ifaddr", (Some (total_size, bits, Inet6_ifaddr data))) map in
1392      let dest_addr = data.inet6_ifaddr_lst_next in
1393      let map =
1394        let map = inet6_ifaddr_follower kernel_version load map dest_addr
1395        in map
1396      in map)
1397   else map;;