let min_kallsyms_tabsize = 1_000L
let max_kallsyms_tabsize = 250_000L
-let kernel_size = 0x100_0000
-let max_memory_peek = 0x1_000
+(* Make the kernel size around 16 MB, but just a bit smaller than
+ * maximum string length so we can still run this on a 32 bit platform.
+ *)
+let kernel_size =
+ if Sys.word_size = 32 then Sys.max_string_length
+ else 0x100_0000
+let max_memory_peek = 0x1000
type ksym = string
(* List of kernel images. *)
let images = ref [] in
let uri = ref "" in
+ let anon_args = ref [] in
let memory_image filename =
images :=
" " ^ s_"Display version and exit";
] in
- let anon_fun str =
- raise (Arg.Bad (sprintf (f_"%s: unknown parameter") str)) in
+ let anon_arg str = anon_args := str :: !anon_args in
let usage_msg = usage_msg ^ s_"\n\nOPTIONS" in
- Arg.parse argspec anon_fun usage_msg;
+ Arg.parse argspec anon_arg usage_msg;
let images = !images in
let debug = !debug in
let uri = if !uri = "" then None else Some !uri in
+ let anon_args = List.rev !anon_args in
(* Get the kernel images. *)
let images =
);
exit 1 in
- (* List of active domains. *)
+ (* If we have a list of parameters, then it is the domain names / UUIDs /
+ * IDs ONLY that we wish to display. Otherwise, display all active.
+ *)
let doms =
- let nr_active_doms = C.num_of_domains conn in
- let active_doms =
- Array.to_list (C.list_domains conn nr_active_doms) in
- let active_doms =
- List.map (D.lookup_by_id conn) active_doms in
- active_doms in
+ if anon_args = [] then (
+ (* List of active domains. *)
+ let nr_active_doms = C.num_of_domains conn in
+ let active_doms =
+ Array.to_list (C.list_domains conn nr_active_doms) in
+ List.map (D.lookup_by_id conn) active_doms
+ ) else (
+ List.map (
+ fun arg ->
+ let dom =
+ try D.lookup_by_uuid_string conn arg
+ with _ ->
+ try D.lookup_by_name conn arg
+ with _ ->
+ try D.lookup_by_id conn (int_of_string arg)
+ with _ ->
+ failwith (sprintf (f_"%s: unknown domain (not a UUID, name or ID of any active domain)") arg) in
+
+ (* XXX Primitive test to see if the domain is active. *)
+ let is_active = try D.get_id dom >= 0 with _ -> false in
+ if not is_active then
+ failwith (sprintf (f_"%s: domain is not running") arg);
+
+ dom
+ ) anon_args
+ ) in
(* Get their XML. *)
let xmls = List.map (fun dom -> dom, D.get_xml_desc dom) doms in
if !def_text_addr = 0L then
failwith
- (sprintf (f_"%s: use -T to define kernel load address for this image")
- name);
+ (sprintf (f_"%s: use -T to define kernel load address for this image") name);
+
+ let start_t = gettimeofday () in
(* Read the kernel memory.
* Maximum 64K can be read over remote connections.
in
loop 0;
+ if debug then (
+ let end_t = gettimeofday () in
+ eprintf "timing: downloading kernel took %f seconds\n%!"
+ (end_t -. start_t)
+ );
+
(* Map the virtual memory. *)
let mem = MMap.of_string str !def_text_addr in
(name, arch, mem)
) xmls
- ) else
+ ) else (
+ (* One or more -t options passed. *)
+ if anon_args <> [] then
+ 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) ->
(* Quite a lot of limitations on the kernel images we can
let mem = MMap.set_endian mem endian in
(filename, arch, mem)
- ) images in
+ ) images
+ ) in
let images =
List.map (
(* Searching for <NUL>string<NUL> *)
let common_ksyms_nul = List.map (sprintf "\000%s\000") common_ksyms in
+ let start_t = gettimeofday () in
+
(* Search for these strings in the memory image. *)
let ksym_strings = List.map (MMap.find_all mem) common_ksyms_nul in
let ksym_strings = List.concat ksym_strings in
(* Adjust found addresses to start of the string (skip <NUL>). *)
let ksym_strings = List.map Int64.succ ksym_strings in
+ if debug then (
+ let end_t = gettimeofday () in
+ eprintf "timing: searching for common_ksyms took %f seconds\n%!"
+ (end_t -. start_t)
+ );
+
+ let start_t = gettimeofday () in
+
(* For any we found, try to look up the symbol table
* base addr and size.
*)
let ksymtabs = List.filter (fun (_, size) -> size > 64L) ksymtabs in
if debug then (
- printf "%s: candidate symbol tables at:\n" name;
+ eprintf "%s: candidate symbol tables at:\n" name;
List.iter (
fun (addr, size) ->
- printf "\t%Lx\t%Lx\t%!" addr size;
- printf "first symbol: %s\n%!"
+ eprintf "\t%Lx\t%Lx\t%!" addr size;
+ eprintf "first symbol: %s\n%!"
(MMap.get_string mem
(MMap.follow_pointer mem
(MMap.succ_long mem addr)))
| (_, (ksymtab_addr, ksymtab_size)) :: _ ->
if debug then
- printf
+ eprintf
"%s: Kernel symbol table found at %Lx, size %Lx bytes\n%!"
name ksymtab_addr ksymtab_size;
lookup_ksym
in
+ if debug then (
+ let end_t = gettimeofday () in
+ eprintf "timing: searching for ordinary ksyms took %f seconds\n%!"
+ (end_t -. start_t)
+ );
+
+ let start_t = gettimeofday () in
+
(* Now try to find the /proc/kallsyms table. This is in an odd
* compressed format (but not a very successful compression
* format). However if it exists we know that it will contain
* If found, jump backwards by length and check all addresses.
*)
if debug then
- printf "%s: testing candidate kallsyms at %Lx\n" name addr;
+ eprintf "%s: testing candidate kallsyms at %Lx\n" name addr;
let rec loop addr =
let addrp = MMap.follow_pointer mem addr in
if MMap.is_mapped mem addrp then
(* ok! *)
let names_addr = MMap.succ_long mem end_addr in
if debug then
- printf "%s: candidate kallsyms found at %Lx (names_addr at %Lx, num_entries %d)\n"
+ eprintf "%s: candidate kallsyms found at %Lx (names_addr at %Lx, num_entries %d)\n"
name start_addr names_addr num_entries;
Some (start_addr, num_entries, names_addr)
in
let names_addr = names_addr +^ Int64.of_int len +^ 2L in
let sym_value = MMap.follow_pointer mem start_addr in
let start_addr = MMap.succ_long mem start_addr in
- (*printf "%S -> %Lx\n" name sym_value;*)
+ (*eprintf "%S -> %Lx\n" name sym_value;*)
names := (name, sym_value) :: !names;
loop names_addr start_addr (num-1)
)
) ksym_addrs in
if debug then (
- printf "%s: candidate kallsyms at:\n" name;
+ eprintf "%s: candidate kallsyms at:\n" name;
List.iter (
function
| (start_addr, num_entries, names_addr, Uncompressed _) ->
- printf "\t%Lx %d entries names_addr=%Lx old-style\n%!"
+ eprintf "\t%Lx %d entries names_addr=%Lx old-style\n%!"
start_addr num_entries names_addr
| (start_addr, num_entries, names_addr,
Compressed (_, markers_addr)) ->
- printf "\t%Lx %d entries names_addr=%Lx markers_addr=%Lx\n%!"
+ eprintf "\t%Lx %d entries names_addr=%Lx markers_addr=%Lx\n%!"
start_addr num_entries names_addr markers_addr
) kallsymtabs
);
*)
(*let typ = name.[0] in*)
let name = String.sub name 1 (String.length name - 1) in
- (*printf "%S -> %Lx\n" name sym_value;*)
+ (*eprintf "%S -> %Lx\n" name sym_value;*)
Some (name, sym_value)
) compressed_names in
lookup_ksym in
+ if debug then (
+ let end_t = gettimeofday () in
+ eprintf "timing: searching for kallsyms took %f seconds\n%!"
+ (end_t -. start_t)
+ );
+
(* Just wrap the lookup_ksym call in something which prints
* the query when debug is set.
*)
let lookup_ksym sym =
try
let value = lookup_ksym sym in
- printf "lookup_ksym %S = %Lx\n%!" sym value;
+ eprintf "lookup_ksym %S = %Lx\n%!" sym value;
value
with Not_found ->
- printf "lookup_ksym %S failed\n%!" sym;
+ eprintf "lookup_ksym %S failed\n%!" sym;
raise Not_found
in
lookup_ksym