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