let kernel_size =
if Sys.word_size = 32 then Sys.max_string_length
else 0x100_0000
-let max_memory_peek = 65536 (* XXX Use D.max_peek function *)
(* When tools register themselves, they are added to this list.
* Later, we will alphabetize the list.
let tools = ref []
(* Registration function used by the tools. *)
-let register ?(external_cmd = true) ?(extra_args = [])
- ?argcheck ?beforeksyms ?beforeutsname ?run
+let register
+ ?(needs_ksyms = false) ?(needs_utsname = false)
+ ?(needs_tasks = false) ?(needs_net_devices = false)
+ ?(needs_everything = false)
+ ~run
+ ?(external_cmd = true)
+ ?(extra_args = [])
+ ?argcheck
name summary description =
tools :=
- (name, (name, summary, description, external_cmd, extra_args,
- argcheck, beforeksyms, beforeutsname, run))
+ (name, (name, summary, description,
+ needs_ksyms, needs_utsname, needs_tasks, needs_net_devices,
+ needs_everything,
+ run, external_cmd, extra_args, argcheck))
:: !tools
(* Main program, called from mem/virt_mem_main.ml when all the
match tool with
| None -> (* Generic usage message. *)
let tools = List.map (
- fun (name, (_, summary, _, external_cmd, _, _, _, _, _)) ->
+ fun (name, (_, summary, _, _, _, _, _, _, _, external_cmd, _, _)) ->
if external_cmd then "virt-"^name, summary
else "virt-mem "^name, summary
) tools in
<tool> [-options] [domains...]
To display extra help for a single tool, do:
- virt-mem help <tool>
+ virt-mem --help <tool>
Options:") tools
(* Tool-specific usage message. *)
- | Some (name, summary, description, external_cmd, _, _, _, _, _) ->
+ | Some (name, summary, description, _, _, _, _, _, _, external_cmd, _, _) ->
let cmd =
if external_cmd then "virt-" ^ name else "virt-mem " ^ name in
let uri = ref "" in
let anon_args = ref [] in
- (* Default wordsize. *)
+ (* Default wordsize (-W). *)
let def_wordsize = ref None in
let set_wordsize = function
| "32" -> def_wordsize := Some W32
| str -> failwith (sprintf (f_"set_wordsize: %s: unknown wordsize") str)
in
- (* Default endianness. *)
+ (* Default endianness (-E). *)
let def_endian = ref None in
let set_endian = function
| "auto" -> def_endian := None
| str -> failwith (sprintf (f_"set_endian: %s: unknown endianness") str)
in
- (* Default architecture. *)
+ (* Default architecture (-A). *)
let def_architecture = ref None in
let set_architecture = function
| "auto" -> def_architecture := None
def_wordsize := Some (wordsize_of_architecture arch)
in
- (* Default text address. *)
+ (* Default text address (-T). *)
let def_text_addr = ref 0L (* 0 = auto-detect *) in
+ let def_kernel_min = ref 0L in
+ let def_kernel_max = ref 0L in
let set_text_addr = function
| "auto" -> def_text_addr := 0L
- | "i386" -> def_text_addr := 0xc010_0000_L (* common for x86 *)
- | "x86-64"|"x86_64" -> def_text_addr := 0xffffffff_81000000_L (* x86-64? *)
- | str -> def_text_addr := Int64.of_string str
+ | "i386" ->
+ (* common for x86, but we should be able to try a selection *)
+ def_text_addr := 0xc010_0000_L;
+ def_kernel_min := 0xc010_0000_L;
+ def_kernel_max := 0xffff_ffff_L
+ | "x86-64"|"x86_64" ->
+ def_text_addr := 0xffffffff_81000000_L;
+ def_kernel_min := 0xffffffff_81000000_L;
+ def_kernel_max := 0xffffffff_ffffffff_L;
+ | str ->
+ let strs = String.nsplit str "," in
+ match strs with
+ | [str] ->
+ def_text_addr := Int64.of_string str;
+ def_kernel_min := !def_text_addr;
+ def_kernel_max :=
+ if !def_text_addr < 0x1_0000_0000_L
+ then 0xffff_ffff_L
+ else 0xffffffff_ffffffff_L
+ | [str1;str2;str3] ->
+ def_text_addr := Int64.of_string str1;
+ def_kernel_min := Int64.of_string str2;
+ def_kernel_max := Int64.of_string str3
+ | _ -> failwith (sprintf (f_"set_text_addr: %s: incorrect number of parameters to -T option") str)
in
(* Handle -t option. *)
let memory_image filename =
testimages :=
- (!def_wordsize, !def_endian, !def_architecture, !def_text_addr, filename)
+ (!def_wordsize, !def_endian, !def_architecture,
+ !def_text_addr, !def_kernel_min, !def_kernel_max, filename)
:: !testimages
in
exit 0
in
+ (* Handle --list-kernels option. *)
+ let list_kernels () =
+ List.iter print_endline Virt_mem_kernels.kernels;
+ exit 0
+ in
+
(* Function to collect up any anonymous args (domain names/IDs). *)
let anon_arg str = anon_args := str :: !anon_args in
let argspec =
let extra_args = match tool with
| None -> []
- | Some (_, _, _, _, extra_args, _, _, _, _) -> extra_args in
+ | Some (_, _,_, _, _, _, _, _, _, _, extra_args, _) -> extra_args in
let argspec = [
"-A", Arg.String set_architecture,
"arch " ^ s_"Set kernel architecture, endianness and word size";
"uri " ^ s_ "Connect to URI";
"--debug", Arg.Set debug,
" " ^ s_"Debug mode (default: false)";
+ "--list-kernels", Arg.Unit list_kernels,
+ " " ^ s_"List known kernels";
"-t", Arg.String memory_image,
"image " ^ s_"Use saved kernel memory image";
"--version", Arg.Unit version,
* or the user didn't give us a valid tool (eg. "virt-mem foobar").
* Detect that final case now and give an error.
*)
- let name, _, _, _, _, argcheck, beforeksyms, beforeutsname, run =
+ let name, _, _,
+ needs_ksyms, needs_utsname, needs_tasks, needs_net_devices,
+ needs_everything,
+ run, external_cmd, extra_args, argcheck =
match tool with
| Some t -> t
| None ->
);
(* Get the kernel images. *)
- let images =
+ let kimages =
if testimages = [] then (
let conn =
let name = uri in
List.map (
fun (dom, _) ->
- let id = D.get_id dom in
- let name = D.get_name dom in
+ let domname = D.get_name dom in
let wordsize =
match !def_wordsize with
| None ->
failwith
(sprintf (f_"%s: use -W to define word size for this image")
- name);
+ domname);
| Some ws -> ws in
let endian =
match !def_endian with
| None ->
failwith
(sprintf (f_"%s: use -E to define endianness for this image")
- name);
+ domname);
| Some e -> e in
let arch =
| Some I386 -> I386 | Some X86_64 -> X86_64
| _ ->
failwith
- (sprintf (f_"%s: use -A to define architecture (i386/x86-64 only) for this image") name) in
+ (sprintf (f_"%s: use -A to define architecture (i386/x86-64 only) for this image") domname) in
- if !def_text_addr = 0L then
- failwith
- (sprintf (f_"%s: use -T to define kernel load address for this image") name);
+ if !def_text_addr = 0L ||
+ !def_kernel_min = 0L ||
+ !def_kernel_max = 0L then
+ failwith
+ (sprintf (f_"%s: use -T to define kernel load address for this image") domname);
+ (* Download the static part of the kernel. *)
let start_t = gettimeofday () in
- (* Read the kernel memory.
- * Maximum 64K can be read over remote connections.
- *)
- let str = String.create kernel_size in
- let rec loop i =
- let remaining = kernel_size - i in
- if remaining > 0 then (
- let size = min remaining max_memory_peek in
- D.memory_peek dom [D.Virtual]
- (!def_text_addr +^ Int64.of_int i) size str i;
- loop (i + size)
- )
- in
- loop 0;
+ let kimage =
+ try
+ load_static_memory ~dom ~domname ~arch
+ ~wordsize ~endian
+ ~kernel_min:!def_kernel_min ~kernel_max:!def_kernel_max
+ !def_text_addr kernel_size
+ with
+ | LoadMemoryError (AddressOutOfRange, _) ->
+ prerr_endline (s_"virt-mem: error loading kernel memory: address out of range
+Possibly the '-T' command line parameter was used inconsistently.");
+ exit 1
+ (* Allow any other exceptions to escape & kill the program. *) in
if debug then (
let end_t = gettimeofday () in
(end_t -. start_t)
);
- (* Map the virtual memory. *)
- let mem = Virt_mem_mmap.of_string str !def_text_addr in
+ kimage
- (* Force the wordsize and endianness. *)
- let mem = Virt_mem_mmap.set_wordsize mem wordsize in
- let mem = Virt_mem_mmap.set_endian mem endian in
-
- ((Some id, name, arch, mem) : image0)
) xmls
) else (
(* One or more -t options passed. *)
failwith (s_"virt-mem: if -t given on command line, then no domain arguments should be listed");
List.map (
- fun (wordsize, endian, arch, text_addr, filename) ->
+ fun (wordsize, endian, arch,
+ text_addr, kernel_min, kernel_max, filename) ->
(* Quite a lot of limitations on the kernel images we can
* handle at the moment ...
*)
let mem = Virt_mem_mmap.set_wordsize mem wordsize in
let mem = Virt_mem_mmap.set_endian mem endian in
- ((None, filename, arch, mem) : image0)
+ { dom = None; domname = filename; arch = arch;
+ kernel_min = kernel_min; kernel_max = kernel_max;
+ mem = mem; addrmap = Kernel.AddrMap.empty;
+ ksyms = Ksymmap.empty; have_ksyms = false; have_kallsyms = false;
+ utsname = None;
+ have_tasks = false; have_net_devices = false }
) testimages
) in
- (* Optional callback into the tool before we start looking for
- * kernel symbols.
- *)
- (match beforeksyms with
- | None -> ()
- | Some beforeksyms -> beforeksyms debug images
- );
-
- (* If there are no more callback functions, then there is no point
- * continuing with the rest of the program (kernel symbol analysis) ...
- *)
- if beforeutsname = None && run = None then exit 0;
-
- (* Do the kernel symbol analysis. *)
- let images =
- List.map (
- fun image ->
- (* Look for ordinary kernel symbols: *)
- let image = Virt_mem_ksyms.find_kernel_symbols debug image in
- (* Look for kallsyms: *)
- let image = Virt_mem_kallsyms.find_kallsyms debug image in
-
- (* Finally, just wrap the lookup_ksym call in something
- * which prints the query when debug is set.
- *)
- let image =
- if debug then
- let (domid, name, arch, mem, lookup_ksym) = image in
- let lookup_ksym sym =
- try
- let value = lookup_ksym sym in
- eprintf "lookup_ksym %S = %Lx\n%!" sym value;
- value
- with Not_found ->
- eprintf "lookup_ksym %S failed\n%!" sym;
- raise Not_found
- in
- (domid, name, arch, mem, lookup_ksym)
- else
- image in
-
- image
- ) images in
-
- (* Before utsname analysis. *)
- (match beforeutsname with
- | None -> ()
- | Some beforeutsname -> List.iter (beforeutsname debug) images
- );
-
- (* If there are no more callback functions, then there is no point
- * continuing with the rest of the program (kernel version analysis) ...
- *)
- if run = None then exit 0;
-
- (* Get the kernel version (utsname analysis). *)
- let images = List.map (Virt_mem_utsname.find_utsname debug) images in
-
- (* Run the tool's main function. *)
- (match run with
- | None -> ()
- | Some run -> List.iter (run debug) images
- )
+ (* Certain needs are dependent on others ... *)
+ let needs_ksyms =
+ if needs_utsname then true
+ else needs_ksyms in
+ let needs_ksyms, needs_utsname =
+ if needs_tasks then true, true
+ else needs_ksyms, needs_utsname in
+ let needs_ksyms, needs_utsname =
+ if needs_net_devices then true, true
+ else needs_ksyms, needs_utsname in
+ let needs_ksyms, needs_utsname, needs_tasks, needs_net_devices =
+ if needs_everything then true, true, true, true
+ else needs_ksyms, needs_utsname, needs_tasks, needs_net_devices in
+
+ let errors = ref 0 in
+
+ List.iter (
+ fun kimage ->
+ try
+ (* Do the kernel symbol analysis. *)
+ let kimage =
+ if not needs_ksyms then kimage
+ else (
+ (* Look for ordinary kernel symbols: *)
+ let kimage = Virt_mem_ksyms.find_kernel_symbols debug kimage in
+
+ if kimage.have_ksyms then
+ (* Look for kallsyms: *)
+ Virt_mem_kallsyms.find_kallsyms debug kimage
+ else kimage
+ ) in
+
+ (* Get the kernel version (utsname analysis). *)
+ let kimage =
+ if not needs_utsname then kimage
+ else (
+ if kimage.have_ksyms then
+ Virt_mem_utsname.find_utsname debug kimage
+ else
+ kimage
+ ) in
+
+ (* Get the tasks. *)
+ let kimage =
+ if not needs_tasks then kimage
+ else (
+ let { ksyms = ksyms; have_ksyms = have_ksyms; utsname = utsname;
+ addrmap = addrmap } = kimage in
+ match have_ksyms, utsname with
+ | true, Some { uts_kernel_release = kernel_version } ->
+ let kimage = ref kimage in
+ let load struct_name addr size =
+ if debug then
+ eprintf "load for task, %s: %Lx %d ...\n"
+ struct_name addr size;
+ let mapped =
+ Virt_mem_mmap.is_mapped_range !kimage.mem addr size in
+ if not mapped then kimage := load_memory !kimage addr size;
+ let bits = Virt_mem_mmap.get_bytes !kimage.mem addr size in
+ Bitstring.bitstring_of_string bits
+ in
+ let addrmap =
+ try
+ let init_task = Ksymmap.find "init_task" ksyms in
+ Some (Kernel.task_struct_follower debug kernel_version
+ load addrmap init_task)
+ with
+ Not_found ->
+ eprintf (f_"%s: cannot find init_task symbol in kernel image.\n") !kimage.domname;
+ None in
+ (match addrmap with
+ | None -> !kimage
+ | Some addrmap ->
+ { !kimage with addrmap = addrmap; have_tasks = true }
+ )
+ | _, _ -> kimage
+ ) in
+
+ (* Get the net devices. *)
+ let kimage =
+ if not needs_net_devices then kimage
+ else (
+ let { ksyms = ksyms; have_ksyms = have_ksyms; utsname = utsname;
+ addrmap = addrmap } = kimage in
+ match have_ksyms, utsname with
+ | true, Some { uts_kernel_release = kernel_version } ->
+ let kimage = ref kimage in
+ let load struct_name addr size =
+ if debug then
+ eprintf "load for net dev, %s: %Lx %d ...\n"
+ struct_name addr size;
+ let mapped =
+ Virt_mem_mmap.is_mapped_range !kimage.mem addr size in
+ if not mapped then kimage := load_memory !kimage addr size;
+ let bits = Virt_mem_mmap.get_bytes !kimage.mem addr size in
+ Bitstring.bitstring_of_string bits
+ in
+ let addrmap =
+ try
+ let dev_base = Ksymmap.find "dev_base" ksyms in
+ Some (Kernel.net_device_follower debug kernel_version
+ load addrmap dev_base)
+ with Not_found ->
+ try
+ let dev_base_head = Ksymmap.find "dev_base_head" ksyms in
+ (* XXX adjust to get offset of start of net_device *)
+ assert false
+ with Not_found ->
+ try
+ let init_net = Ksymmap.find "init_net" ksyms in
+ Some (Kernel.net_follower debug kernel_version
+ load addrmap init_net)
+ with Not_found ->
+ eprintf (f_"%s: cannot find dev_base, dev_base_head or init_net symbols in kernel image.\n") !kimage.domname;
+ None in
+ (match addrmap with
+ | None -> !kimage
+ | Some addrmap ->
+ { !kimage with addrmap = addrmap; have_net_devices = true }
+ )
+ | _, _ -> kimage
+ ) in
+
+ (* Run the tool's main function. *)
+ if not needs_everything then (
+ if needs_ksyms && kimage.have_ksyms = false then
+ failwith (s_"could not read kernel symbols")
+ else if needs_utsname && kimage.utsname = None then
+ failwith (s_"could not read kernel version")
+ else if needs_tasks && kimage.have_tasks = false then
+ failwith (s_"could not read process table")
+ else if needs_net_devices && kimage.have_net_devices = false then
+ failwith (s_"could not read net device table")
+ );
+ run debug kimage
+ with exn ->
+ eprintf "%s: %s\n" kimage.domname (Printexc.to_string exn);
+ incr errors
+ ) kimages;
+
+ exit (if !errors > 0 then 1 else 0)