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.25.14-69.fc8.i686" 48
task_struct_tasks'next_adjustment = 480;
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 = 480;
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), littleendian;
task_struct_tasks'next_adjustment = 400;
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+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_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+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_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 = 128;
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), littleendian;
task_struct_tasks'next_adjustment = 192;
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+32 : offset(0), littleendian;
task_struct_tasks'next_adjustment = 124;
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+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_9", match_err));;
+ raise (ParseError ("task_struct", "task_struct_parser_9", match_err));;
let net_device_parser_10 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_10", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_10", match_err));;
let net_device_parser_11 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_11", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_11", match_err));;
let net_device_parser_12 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_12", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_12", match_err));;
let net_device_parser_13 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_13", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_13", match_err));;
let net_device_parser_14 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_14", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_14", match_err));;
let net_device_parser_15 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_15", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_15", match_err));;
let net_device_parser_16 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_16", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_16", match_err));;
let net_device_parser_17 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_17", match_err));;
+ raise (ParseError ("net_device", "net_device_parser_17", match_err));;
let net_parser_20 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_20", match_err));;
+ raise (ParseError ("net", "net_parser_20", match_err));;
let net_parser_21 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_21", match_err));;
+ raise (ParseError ("net", "net_parser_21", match_err));;
let net_parser_18 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_18", match_err));;
+ raise (ParseError ("net", "net_parser_18", match_err));;
let net_parser_19 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_19", match_err));;
+ raise (ParseError ("net", "net_parser_19", match_err));;
let in_device_parser_24 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_24", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_24", match_err));;
let in_device_parser_25 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_25", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_25", match_err));;
let in_device_parser_22 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_22", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_22", match_err));;
let in_device_parser_23 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_23", match_err));;
+ raise (ParseError ("in_device", "in_device_parser_23", match_err));;
let inet6_dev_parser_28 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_28", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_28", match_err));;
let inet6_dev_parser_29 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_29", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_29", match_err));;
let inet6_dev_parser_26 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_26", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_26", match_err));;
let inet6_dev_parser_27 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_27", match_err));;
+ raise (ParseError ("inet6_dev", "inet6_dev_parser_27", match_err));;
let in_ifaddr_parser_32 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_32", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_32", match_err));;
let in_ifaddr_parser_33 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_33", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_33", match_err));;
let in_ifaddr_parser_30 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_30", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_30", match_err));;
let in_ifaddr_parser_31 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_31", match_err));;
+ raise (ParseError ("in_ifaddr", "in_ifaddr_parser_31", match_err));;
let inet6_ifaddr_parser_36 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_36", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_36", match_err));;
let inet6_ifaddr_parser_34 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_34", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_34", match_err));;
let inet6_ifaddr_parser_35 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_35", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_35", match_err));;
let inet6_ifaddr_parser_37 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_37", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_37", match_err));;
let inet6_ifaddr_parser_39 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_39", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_39", match_err));;
let inet6_ifaddr_parser_41 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_41", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_41", match_err));;
let inet6_ifaddr_parser_38 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_38", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_38", match_err));;
let inet6_ifaddr_parser_40 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_40", match_err));;
+ raise (ParseError ("inet6_ifaddr", "inet6_ifaddr_parser_40", match_err));;
let size_of_task_struct =
let map =
StringMap.add "2.6.25.14-69.fc8.x86_64" 2496
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