open Printf;;
module StringMap = Map.Make(String);;
module AddrMap = Map.Make(Int64);;
-type kernel_version = string;;
+exception ParseError of string * string * string;;
let match_err = "failed to match kernel structure";;
let unknown_kernel_version version struct_name =
invalid_arg
http://et.redhat.com/~rjones/virt-mem/faq.html
"
version struct_name);;
+type kernel_version = string;;
+type load_fn = string -> Virt_mem_mmap.addr -> int -> Bitstring.bitstring;;
let zero = 0;;
type task_struct =
{ task_struct_comm : string; task_struct_normal_prio : int64;
| Inet6_dev of inet6_dev
| In_ifaddr of in_ifaddr
| Inet6_ifaddr of inet6_ifaddr;;
+type addrmap =
+ (string * ((int * Bitstring.bitstring * kernel_struct) option)) AddrMap.t;;
let offset_of_net_device_dev_list'next =
let map =
StringMap.add "2.6.27-0.254.rc3.fc10.i586" 48
task_struct_tasks'next_adjustment = 124;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_1", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_1", match_err));;
let task_struct_parser_2 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 456;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_2", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_2", match_err));;
let task_struct_parser_3 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 272;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_3", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_3", match_err));;
let task_struct_parser_4 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 480;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_4", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_4", match_err));;
let task_struct_parser_5 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 192;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_5", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_5", match_err));;
let task_struct_parser_6 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 464;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_6", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_6", match_err));;
let task_struct_parser_7 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 200;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_7", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_7", match_err));;
let task_struct_parser_8 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 512;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_8", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_8", match_err));;
let task_struct_parser_9 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 288;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_9", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_9", match_err));;
let task_struct_parser_10 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 376;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_10", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_10", match_err));;
let task_struct_parser_11 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 192;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_11", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_11", match_err));;
let task_struct_parser_12 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 352;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_12", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_12", match_err));;
let task_struct_parser_13 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 184;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_13", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_13", match_err));;
let task_struct_parser_14 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 480;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_14", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_14", match_err));;
let task_struct_parser_15 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 420;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_15", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_15", match_err));;
let task_struct_parser_16 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 404;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_16", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_16", match_err));;
let task_struct_parser_17 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 392;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_17", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_17", match_err));;
let task_struct_parser_18 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 268;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_18", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_18", match_err));;
let task_struct_parser_19 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 444;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_19", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_19", match_err));;
let task_struct_parser_20 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 280;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_20", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_20", match_err));;
let task_struct_parser_21 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 560;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_21", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_21", match_err));;
let task_struct_parser_22 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 400;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_22", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_22", match_err));;
let task_struct_parser_23 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 352;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_23", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_23", match_err));;
let task_struct_parser_24 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 352;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_24", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_24", match_err));;
let task_struct_parser_25 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 360;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_25", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_25", match_err));;
let task_struct_parser_26 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 128;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_26", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_26", match_err));;
let task_struct_parser_27 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 360;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_27", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_27", match_err));;
let task_struct_parser_28 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 276;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_28", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_28", match_err));;
let task_struct_parser_29 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 416;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_29", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_29", match_err));;
let task_struct_parser_30 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 560;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_30", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_30", match_err));;
let task_struct_parser_31 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 448;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_31", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_31", match_err));;
let task_struct_parser_32 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 424;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_32", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_32", match_err));;
let task_struct_parser_33 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 456;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_33", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_33", match_err));;
let task_struct_parser_34 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 176;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_34", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_34", match_err));;
let task_struct_parser_35 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 416;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_35", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_35", match_err));;
let task_struct_parser_36 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 352;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_36", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_36", match_err));;
let task_struct_parser_37 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 336;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_37", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_37", match_err));;
let task_struct_parser_38 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 280;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_38", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_38", match_err));;
let task_struct_parser_39 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 268;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_39", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_39", match_err));;
let task_struct_parser_40 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 360;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_40", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_40", match_err));;
let task_struct_parser_41 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 344;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_41", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_41", match_err));;
let task_struct_parser_42 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 268;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_42", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_42", match_err));;
let task_struct_parser_43 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 216;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_43", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_43", match_err));;
let task_struct_parser_44 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 512;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_44", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_44", match_err));;
let task_struct_parser_45 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 272;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_45", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_45", match_err));;
let task_struct_parser_46 kernel_version bits =
bitmatch bits with
| { state : zero+32 : offset(0), bigendian;
task_struct_tasks'next_adjustment = 280;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_46", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_46", match_err));;
let task_struct_parser_47 kernel_version bits =
bitmatch bits with
| { state : zero+64 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 328;
task_struct_tasks'prev = tasks'prev }
| { _ } ->
- raise (Virt_mem_types.ParseError ("task_struct", "task_struct_parser_47", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_47", match_err));;
let net_device_parser_48 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_48", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_48", match_err));;
let net_device_parser_49 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_49", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_49", match_err));;
let net_device_parser_50 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_50", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_50", match_err));;
let net_device_parser_51 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_51", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_51", match_err));;
let net_device_parser_52 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_52", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_52", match_err));;
let net_device_parser_53 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_53", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_53", match_err));;
let net_device_parser_54 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_54", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_54", match_err));;
let net_device_parser_55 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_55", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_55", match_err));;
let net_device_parser_56 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_56", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_56", match_err));;
let net_device_parser_57 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_57", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_57", match_err));;
let net_device_parser_58 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_58", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_58", match_err));;
let net_device_parser_59 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_59", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_59", match_err));;
let net_device_parser_60 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_60", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_60", match_err));;
let net_device_parser_61 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_61", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_61", match_err));;
let net_device_parser_62 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_62", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_62", match_err));;
let net_device_parser_63 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_63", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_63", match_err));;
let net_device_parser_64 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_64", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_64", match_err));;
let net_device_parser_65 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_65", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_65", match_err));;
let net_device_parser_66 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_66", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_66", match_err));;
let net_device_parser_67 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_67", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_67", match_err));;
let net_device_parser_68 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_68", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_68", match_err));;
let net_device_parser_69 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_69", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_69", match_err));;
let net_device_parser_70 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_70", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_70", match_err));;
let net_device_parser_71 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_71", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_71", match_err));;
let net_device_parser_72 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_72", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_72", match_err));;
let net_device_parser_73 kernel_version bits =
bitmatch bits with
| { name : 128 : offset(0), string;
net_device_operstate = operstate;
net_device_perm_addr = perm_addr }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net_device", "net_device_parser_73", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_73", match_err));;
let net_parser_82 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(576), littleendian;
net_dev_base_head'prev_offset = 76;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_82", match_err));;
+ raise (ParseError ("net", "net_parser_82", match_err));;
let net_parser_87 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(960), littleendian;
net_dev_base_head'prev_offset = 128;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_87", match_err));;
+ raise (ParseError ("net", "net_parser_87", match_err));;
let net_parser_88 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(1024), littleendian;
net_dev_base_head'prev_offset = 136;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_88", match_err));;
+ raise (ParseError ("net", "net_parser_88", match_err));;
let net_parser_83 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(1152), littleendian;
net_dev_base_head'prev_offset = 152;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_83", match_err));;
+ raise (ParseError ("net", "net_parser_83", match_err));;
let net_parser_86 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(1152), bigendian;
net_dev_base_head'prev_offset = 152;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_86", match_err));;
+ raise (ParseError ("net", "net_parser_86", match_err));;
let net_parser_74 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(704), bigendian;
net_dev_base_head'prev_offset = 96;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_74", match_err));;
+ raise (ParseError ("net", "net_parser_74", match_err));;
let net_parser_79 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(384), littleendian;
net_dev_base_head'prev_offset = 52;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_79", match_err));;
+ raise (ParseError ("net", "net_parser_79", match_err));;
let net_parser_80 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(416), littleendian;
net_dev_base_head'prev_offset = 56;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_80", match_err));;
+ raise (ParseError ("net", "net_parser_80", match_err));;
let net_parser_81 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(384), bigendian;
net_dev_base_head'prev_offset = 52;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_81", match_err));;
+ raise (ParseError ("net", "net_parser_81", match_err));;
let net_parser_85 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(416), bigendian;
net_dev_base_head'prev_offset = 56;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_85", match_err));;
+ raise (ParseError ("net", "net_parser_85", match_err));;
let net_parser_75 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(768), littleendian;
net_dev_base_head'prev_offset = 104;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_75", match_err));;
+ raise (ParseError ("net", "net_parser_75", match_err));;
let net_parser_76 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(448), bigendian;
net_dev_base_head'prev_offset = 60;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_76", match_err));;
+ raise (ParseError ("net", "net_parser_76", match_err));;
let net_parser_77 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+64 : offset(768), bigendian;
net_dev_base_head'prev_offset = 104;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_77", match_err));;
+ raise (ParseError ("net", "net_parser_77", match_err));;
let net_parser_78 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(512), littleendian;
net_dev_base_head'prev_offset = 68;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_78", match_err));;
+ raise (ParseError ("net", "net_parser_78", match_err));;
let net_parser_84 kernel_version bits =
bitmatch bits with
| { dev_base_head'next : zero+32 : offset(544), littleendian;
net_dev_base_head'prev_offset = 72;
net_dev_base_head'prev_adjustment = offset_of_net_device_dev_list'next kernel_version }
| { _ } ->
- raise (Virt_mem_types.ParseError ("net", "net_parser_84", match_err));;
+ raise (ParseError ("net", "net_parser_84", match_err));;
let in_device_parser_89 kernel_version bits =
bitmatch bits with
| { ifa_list : zero+32 : offset(96), littleendian } ->
{ in_device_ifa_list = ifa_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_89", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_89", match_err));;
let in_device_parser_91 kernel_version bits =
bitmatch bits with
| { ifa_list : zero+32 : offset(96), bigendian } ->
{ in_device_ifa_list = ifa_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_91", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_91", match_err));;
let in_device_parser_92 kernel_version bits =
bitmatch bits with
| { ifa_list : zero+64 : offset(128), littleendian } ->
{ in_device_ifa_list = ifa_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_92", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_92", match_err));;
let in_device_parser_90 kernel_version bits =
bitmatch bits with
| { ifa_list : zero+64 : offset(128), bigendian } ->
{ in_device_ifa_list = ifa_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_device", "in_device_parser_90", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_90", match_err));;
let inet6_dev_parser_93 kernel_version bits =
bitmatch bits with
| { addr_list : zero+32 : offset(32), littleendian } ->
{ inet6_dev_addr_list = addr_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_93", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_93", match_err));;
let inet6_dev_parser_95 kernel_version bits =
bitmatch bits with
| { addr_list : zero+32 : offset(32), bigendian } ->
{ inet6_dev_addr_list = addr_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_95", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_95", match_err));;
let inet6_dev_parser_96 kernel_version bits =
bitmatch bits with
| { addr_list : zero+64 : offset(64), littleendian } ->
{ inet6_dev_addr_list = addr_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_96", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_96", match_err));;
let inet6_dev_parser_94 kernel_version bits =
bitmatch bits with
| { addr_list : zero+64 : offset(64), bigendian } ->
{ inet6_dev_addr_list = addr_list }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_dev", "inet6_dev_parser_94", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_94", match_err));;
let in_ifaddr_parser_97 kernel_version bits =
bitmatch bits with
| { ifa_next : zero+32 : offset(0), littleendian;
in_ifaddr_ifa_mask = ifa_mask;
in_ifaddr_ifa_next = ifa_next }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_97", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_97", match_err));;
let in_ifaddr_parser_99 kernel_version bits =
bitmatch bits with
| { ifa_next : zero+32 : offset(0), bigendian;
in_ifaddr_ifa_mask = ifa_mask;
in_ifaddr_ifa_next = ifa_next }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_99", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_99", match_err));;
let in_ifaddr_parser_98 kernel_version bits =
bitmatch bits with
| { ifa_next : zero+64 : offset(0), bigendian;
in_ifaddr_ifa_mask = ifa_mask;
in_ifaddr_ifa_next = ifa_next }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_98", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_98", match_err));;
let in_ifaddr_parser_100 kernel_version bits =
bitmatch bits with
| { ifa_next : zero+64 : offset(0), littleendian;
in_ifaddr_ifa_mask = ifa_mask;
in_ifaddr_ifa_next = ifa_next }
| { _ } ->
- raise (Virt_mem_types.ParseError ("in_ifaddr", "in_ifaddr_parser_100", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_100", match_err));;
let inet6_ifaddr_parser_101 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_101", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_101", match_err));;
let inet6_ifaddr_parser_108 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_108", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_108", match_err));;
let inet6_ifaddr_parser_116 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_116", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_116", match_err));;
let inet6_ifaddr_parser_106 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_106", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_106", match_err));;
let inet6_ifaddr_parser_111 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_111", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_111", match_err));;
let inet6_ifaddr_parser_114 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_114", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_114", match_err));;
let inet6_ifaddr_parser_115 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_115", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_115", match_err));;
let inet6_ifaddr_parser_102 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_102", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_102", match_err));;
let inet6_ifaddr_parser_105 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_105", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_105", match_err));;
let inet6_ifaddr_parser_109 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_109", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_109", match_err));;
let inet6_ifaddr_parser_103 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_103", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_103", match_err));;
let inet6_ifaddr_parser_112 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_112", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_112", match_err));;
let inet6_ifaddr_parser_119 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_119", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_119", match_err));;
let inet6_ifaddr_parser_104 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_104", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_104", match_err));;
let inet6_ifaddr_parser_107 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_107", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_107", match_err));;
let inet6_ifaddr_parser_110 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_110", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_110", match_err));;
let inet6_ifaddr_parser_113 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_113", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_113", match_err));;
let inet6_ifaddr_parser_120 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_120", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_120", match_err));;
let inet6_ifaddr_parser_117 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), littleendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_117", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_117", match_err));;
let inet6_ifaddr_parser_118 kernel_version bits =
bitmatch bits with
| { prefix_len : zero+32 : offset(128), bigendian;
{ inet6_ifaddr_lst_next = lst_next;
inet6_ifaddr_prefix_len = prefix_len }
| { _ } ->
- raise (Virt_mem_types.ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_118", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_118", match_err));;
let size_of_task_struct =
let map =
StringMap.add "2.6.21-1.3128.fc7.i586" 2704
try StringMap.find kernel_version map
with
| Not_found -> unknown_kernel_version kernel_version "inet6_ifaddr";;
-let rec task_struct_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_task_struct kernel_version in
- let total_size = size_of_task_struct kernel_version in
- let bits = load "task_struct" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("task_struct", (Some (total_size, bits, Task_struct data))) map in
- let map =
- match data.task_struct_run_list'next with
- | None -> map
- | Some dest_addr ->
- let offset = data.task_struct_run_list'next_offset
- and adj = data.task_struct_run_list'next_adjustment in
- let offset = Int64.of_int offset and adj = Int64.of_int adj in
- let addr = Int64.sub (Int64.add addr offset) adj in
- let map = AddrMap.add addr ("task_struct", None) map in
- let dest_addr = Int64.sub dest_addr adj in
- let map = task_struct_follower kernel_version load map dest_addr
- in map in
- let dest_addr = data.task_struct_tasks'next in
- let map =
- let offset = data.task_struct_tasks'next_offset
- and adj = data.task_struct_tasks'next_adjustment in
- let offset = Int64.of_int offset and adj = Int64.of_int adj in
- let addr = Int64.sub (Int64.add addr offset) adj in
- let map = AddrMap.add addr ("task_struct", None) map in
- let dest_addr = Int64.sub dest_addr adj in
- let map = task_struct_follower kernel_version load map dest_addr
- in map
- in map)
- else map
-and net_device_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_net_device kernel_version in
- let total_size = size_of_net_device kernel_version in
- let bits = load "net_device" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("net_device", (Some (total_size, bits, Net_device data))) map in
- let map =
- match data.net_device_dev_list'next with
- | None -> map
- | Some dest_addr ->
- let offset = data.net_device_dev_list'next_offset
- and adj = data.net_device_dev_list'next_adjustment in
- let offset = Int64.of_int offset and adj = Int64.of_int adj in
- let addr = Int64.sub (Int64.add addr offset) adj in
- let map = AddrMap.add addr ("net_device", None) map in
- let dest_addr = Int64.sub dest_addr adj in
- let map = net_device_follower kernel_version load map dest_addr
- in map in
- let dest_addr = data.net_device_ip6_ptr in
- let map =
- let map = inet6_dev_follower kernel_version load map dest_addr in map in
- let dest_addr = data.net_device_ip_ptr in
- let map =
- let map = in_device_follower kernel_version load map dest_addr in map in
- let map =
- match data.net_device_next with
- | None -> map
- | Some dest_addr ->
- let map = net_device_follower kernel_version load map dest_addr
- in map
- in map)
- else map
-and net_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_net kernel_version in
- let total_size = size_of_net kernel_version in
- let bits = load "net" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr ("net", (Some (total_size, bits, Net data))) map in
- let dest_addr = data.net_dev_base_head'next in
- let map =
- let offset = data.net_dev_base_head'next_offset
- and adj = data.net_dev_base_head'next_adjustment in
- let offset = Int64.of_int offset and adj = Int64.of_int adj in
- let addr = Int64.sub (Int64.add addr offset) adj in
- let map = AddrMap.add addr ("net_device", None) map in
- let dest_addr = Int64.sub dest_addr adj in
- let map = net_device_follower kernel_version load map dest_addr in map in
- let dest_addr = data.net_dev_base_head'prev in
- let map =
- let offset = data.net_dev_base_head'prev_offset
- and adj = data.net_dev_base_head'prev_adjustment in
- let offset = Int64.of_int offset and adj = Int64.of_int adj in
- let addr = Int64.sub (Int64.add addr offset) adj in
- let map = AddrMap.add addr ("net_device", None) map in
- let dest_addr = Int64.sub dest_addr adj in
- let map = net_device_follower kernel_version load map dest_addr in map
- in map)
- else map
-and in_device_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_in_device kernel_version in
- let total_size = size_of_in_device kernel_version in
- let bits = load "in_device" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("in_device", (Some (total_size, bits, In_device data))) map in
- let dest_addr = data.in_device_ifa_list in
- let map =
- let map = in_ifaddr_follower kernel_version load map dest_addr in map
- in map)
- else map
-and inet6_dev_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_inet6_dev kernel_version in
- let total_size = size_of_inet6_dev kernel_version in
- let bits = load "inet6_dev" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("inet6_dev", (Some (total_size, bits, Inet6_dev data))) map in
- let dest_addr = data.inet6_dev_addr_list in
- let map =
- let map = inet6_ifaddr_follower kernel_version load map dest_addr
- in map
- in map)
- else map
-and in_ifaddr_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_in_ifaddr kernel_version in
- let total_size = size_of_in_ifaddr kernel_version in
- let bits = load "in_ifaddr" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("in_ifaddr", (Some (total_size, bits, In_ifaddr data))) map in
- let dest_addr = data.in_ifaddr_ifa_next in
- let map =
- let map = in_ifaddr_follower kernel_version load map dest_addr in map
- in map)
- else map
-and inet6_ifaddr_follower kernel_version load map addr =
- if (addr <> 0L) && (not (AddrMap.mem addr map))
- then
- (let parser_ = parser_of_inet6_ifaddr kernel_version in
- let total_size = size_of_inet6_ifaddr kernel_version in
- let bits = load "inet6_ifaddr" addr total_size in
- let data = parser_ kernel_version bits in
- let map =
- AddrMap.add addr
- ("inet6_ifaddr", (Some (total_size, bits, Inet6_ifaddr data))) map in
- let dest_addr = data.inet6_ifaddr_lst_next in
- let map =
- let map = inet6_ifaddr_follower kernel_version load map dest_addr
- in map
- in map)
- else map;;
+let rec task_struct_follower debug kernel_version load map addr =
+ (if debug
+ then eprintf "%s_follower: addr = %Lx
+" "task_struct" addr
+ else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_task_struct kernel_version in
+ let total_size = size_of_task_struct kernel_version in
+ let bits = load "task_struct" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("task_struct", (Some (total_size, bits, Task_struct data))) map in
+ let map =
+ match data.task_struct_run_list'next with
+ | None -> map
+ | Some dest_addr ->
+ (if debug
+ then
+ eprintf "%s_follower: %s: list_head pointing at a %s
+"
+ "task_struct" "run_list'next" "task_struct"
+ else ();
+ let offset = data.task_struct_run_list'next_offset
+ and adj = data.task_struct_run_list'next_adjustment
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: offset=%d adjustment=%d
+"
+ "task_struct" "run_list'next" offset adj
+ else ();
+ let offset = Int64.of_int offset
+ and adj = Int64.of_int adj in
+ let map =
+ if offset <> adj
+ then
+ (let addr = Int64.sub (Int64.add addr offset) adj
+ in AddrMap.add addr ("task_struct", None) map)
+ else map in
+ let dest_addr = Int64.sub dest_addr adj
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: dest_addr=%Lx
+" "task_struct"
+ "run_list'next" dest_addr
+ else ();
+ let map =
+ task_struct_follower debug kernel_version load map
+ dest_addr
+ in map))) in
+ let dest_addr = data.task_struct_tasks'next in
+ let map =
+ (if debug
+ then
+ eprintf "%s_follower: %s: list_head pointing at a %s
+"
+ "task_struct" "tasks'next" "task_struct"
+ else ();
+ let offset = data.task_struct_tasks'next_offset
+ and adj = data.task_struct_tasks'next_adjustment
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: offset=%d adjustment=%d
+"
+ "task_struct" "tasks'next" offset adj
+ else ();
+ let offset = Int64.of_int offset and adj = Int64.of_int adj in
+ let map =
+ if offset <> adj
+ then
+ (let addr = Int64.sub (Int64.add addr offset) adj
+ in AddrMap.add addr ("task_struct", None) map)
+ else map in
+ let dest_addr = Int64.sub dest_addr adj
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: dest_addr=%Lx
+" "task_struct"
+ "tasks'next" dest_addr
+ else ();
+ let map =
+ task_struct_follower debug kernel_version load map dest_addr
+ in map)))
+ in map)
+ else map)
+and net_device_follower debug kernel_version load map addr =
+ (if debug then eprintf "%s_follower: addr = %Lx
+" "net_device" addr else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_net_device kernel_version in
+ let total_size = size_of_net_device kernel_version in
+ let bits = load "net_device" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("net_device", (Some (total_size, bits, Net_device data))) map in
+ let map =
+ match data.net_device_dev_list'next with
+ | None -> map
+ | Some dest_addr ->
+ (if debug
+ then
+ eprintf "%s_follower: %s: list_head pointing at a %s
+"
+ "net_device" "dev_list'next" "net_device"
+ else ();
+ let offset = data.net_device_dev_list'next_offset
+ and adj = data.net_device_dev_list'next_adjustment
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: offset=%d adjustment=%d
+"
+ "net_device" "dev_list'next" offset adj
+ else ();
+ let offset = Int64.of_int offset
+ and adj = Int64.of_int adj in
+ let map =
+ if offset <> adj
+ then
+ (let addr = Int64.sub (Int64.add addr offset) adj
+ in AddrMap.add addr ("net_device", None) map)
+ else map in
+ let dest_addr = Int64.sub dest_addr adj
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: dest_addr=%Lx
+" "net_device"
+ "dev_list'next" dest_addr
+ else ();
+ let map =
+ net_device_follower debug kernel_version load map
+ dest_addr
+ in map))) in
+ let dest_addr = data.net_device_ip6_ptr in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "net_device" "ip6_ptr" "inet6_dev" dest_addr
+ else ();
+ let map = inet6_dev_follower debug kernel_version load map dest_addr
+ in map) in
+ let dest_addr = data.net_device_ip_ptr in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "net_device" "ip_ptr" "in_device" dest_addr
+ else ();
+ let map = in_device_follower debug kernel_version load map dest_addr
+ in map) in
+ let map =
+ match data.net_device_next with
+ | None -> map
+ | Some dest_addr ->
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "net_device" "next" "net_device" dest_addr
+ else ();
+ let map =
+ net_device_follower debug kernel_version load map dest_addr
+ in map)
+ in map)
+ else map)
+and net_follower debug kernel_version load map addr =
+ (if debug then eprintf "%s_follower: addr = %Lx
+" "net" addr else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_net kernel_version in
+ let total_size = size_of_net kernel_version in
+ let bits = load "net" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr ("net", (Some (total_size, bits, Net data))) map in
+ let dest_addr = data.net_dev_base_head'next in
+ let map =
+ (if debug
+ then
+ eprintf "%s_follower: %s: list_head pointing at a %s
+" "net"
+ "dev_base_head'next" "net_device"
+ else ();
+ let offset = data.net_dev_base_head'next_offset
+ and adj = data.net_dev_base_head'next_adjustment
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: offset=%d adjustment=%d
+" "net"
+ "dev_base_head'next" offset adj
+ else ();
+ let offset = Int64.of_int offset and adj = Int64.of_int adj in
+ let map =
+ if offset <> adj
+ then
+ (let addr = Int64.sub (Int64.add addr offset) adj
+ in AddrMap.add addr ("net_device", None) map)
+ else map in
+ let dest_addr = Int64.sub dest_addr adj
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: dest_addr=%Lx
+" "net"
+ "dev_base_head'next" dest_addr
+ else ();
+ let map =
+ net_device_follower debug kernel_version load map dest_addr
+ in map))) in
+ let dest_addr = data.net_dev_base_head'prev in
+ let map =
+ (if debug
+ then
+ eprintf "%s_follower: %s: list_head pointing at a %s
+" "net"
+ "dev_base_head'prev" "net_device"
+ else ();
+ let offset = data.net_dev_base_head'prev_offset
+ and adj = data.net_dev_base_head'prev_adjustment
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: offset=%d adjustment=%d
+" "net"
+ "dev_base_head'prev" offset adj
+ else ();
+ let offset = Int64.of_int offset and adj = Int64.of_int adj in
+ let map =
+ if offset <> adj
+ then
+ (let addr = Int64.sub (Int64.add addr offset) adj
+ in AddrMap.add addr ("net_device", None) map)
+ else map in
+ let dest_addr = Int64.sub dest_addr adj
+ in
+ (if debug
+ then
+ eprintf "%s_follower: %s: dest_addr=%Lx
+" "net"
+ "dev_base_head'prev" dest_addr
+ else ();
+ let map =
+ net_device_follower debug kernel_version load map dest_addr
+ in map)))
+ in map)
+ else map)
+and in_device_follower debug kernel_version load map addr =
+ (if debug then eprintf "%s_follower: addr = %Lx
+" "in_device" addr else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_in_device kernel_version in
+ let total_size = size_of_in_device kernel_version in
+ let bits = load "in_device" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("in_device", (Some (total_size, bits, In_device data))) map in
+ let dest_addr = data.in_device_ifa_list in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "in_device" "ifa_list" "in_ifaddr" dest_addr
+ else ();
+ let map = in_ifaddr_follower debug kernel_version load map dest_addr
+ in map)
+ in map)
+ else map)
+and inet6_dev_follower debug kernel_version load map addr =
+ (if debug then eprintf "%s_follower: addr = %Lx
+" "inet6_dev" addr else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_inet6_dev kernel_version in
+ let total_size = size_of_inet6_dev kernel_version in
+ let bits = load "inet6_dev" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("inet6_dev", (Some (total_size, bits, Inet6_dev data))) map in
+ let dest_addr = data.inet6_dev_addr_list in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "inet6_dev" "addr_list" "inet6_ifaddr" dest_addr
+ else ();
+ let map =
+ inet6_ifaddr_follower debug kernel_version load map dest_addr
+ in map)
+ in map)
+ else map)
+and in_ifaddr_follower debug kernel_version load map addr =
+ (if debug then eprintf "%s_follower: addr = %Lx
+" "in_ifaddr" addr else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_in_ifaddr kernel_version in
+ let total_size = size_of_in_ifaddr kernel_version in
+ let bits = load "in_ifaddr" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("in_ifaddr", (Some (total_size, bits, In_ifaddr data))) map in
+ let dest_addr = data.in_ifaddr_ifa_next in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "in_ifaddr" "ifa_next" "in_ifaddr" dest_addr
+ else ();
+ let map = in_ifaddr_follower debug kernel_version load map dest_addr
+ in map)
+ in map)
+ else map)
+and inet6_ifaddr_follower debug kernel_version load map addr =
+ (if debug
+ then eprintf "%s_follower: addr = %Lx
+" "inet6_ifaddr" addr
+ else ();
+ if (addr <> 0L) && (not (AddrMap.mem addr map))
+ then
+ (let parser_ = parser_of_inet6_ifaddr kernel_version in
+ let total_size = size_of_inet6_ifaddr kernel_version in
+ let bits = load "inet6_ifaddr" addr total_size in
+ let data = parser_ kernel_version bits in
+ let map =
+ AddrMap.add addr
+ ("inet6_ifaddr", (Some (total_size, bits, Inet6_ifaddr data))) map in
+ let dest_addr = data.inet6_ifaddr_lst_next in
+ let map =
+ (if debug
+ then
+ eprintf
+ "%s_follower: %s: is a struct pointer pointing to a %s; dest_addr=%Lx
+"
+ "inet6_ifaddr" "lst_next" "inet6_ifaddr" dest_addr
+ else ();
+ let map =
+ inet6_ifaddr_follower debug kernel_version load map dest_addr
+ in map)
+ in map)
+ else map);;
git.annexia.org / virt-mem.git / blobdiff