X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=lib%2Fvirt_mem.ml;h=69a08215daaff6e01d4618733819b619cfad656c;hb=6029405541d12dedfce7998deefa0e6b0d04f3d5;hp=fcefa3cc4bc8492df585f19417441e21d0525cd1;hpb=8eb1c2c4f71819108ceea4731f4dad75775ce6ae;p=virt-mem.git diff --git a/lib/virt_mem.ml b/lib/virt_mem.ml index fcefa3c..69a0821 100644 --- a/lib/virt_mem.ml +++ b/lib/virt_mem.ml @@ -27,10 +27,7 @@ module D = Libvirt.Domain open Virt_mem_gettext.Gettext open Virt_mem_utils -module MMap = Virt_mem_mmap - -let min_kallsyms_tabsize = 1_000L -let max_kallsyms_tabsize = 250_000L +open Virt_mem_types (* 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. @@ -38,26 +35,6 @@ let max_kallsyms_tabsize = 250_000L 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 *) - -type ksym = string - -type image = - int option - * string - * Virt_mem_utils.architecture - * ([`Wordsize], [`Endian]) Virt_mem_mmap.t - -type image_with_ksyms = - int option - * string - * Virt_mem_utils.architecture - * ([`Wordsize], [`Endian]) Virt_mem_mmap.t - * (ksym -> MMap.addr) - -type kallsyms_compr = - | Compressed of (string * MMap.addr) list * MMap.addr - | Uncompressed of (string * MMap.addr) list (* When tools register themselves, they are added to this list. * Later, we will alphabetize the list. @@ -66,11 +43,11 @@ let tools = ref [] (* Registration function used by the tools. *) let register ?(external_cmd = true) ?(extra_args = []) - ?argcheck ?beforeksyms ?run + ?argcheck ?beforeksyms ?beforeutsname ?run name summary description = tools := (name, (name, summary, description, external_cmd, extra_args, - argcheck, beforeksyms, run)) + argcheck, beforeksyms, beforeutsname, run)) :: !tools (* Main program, called from mem/virt_mem_main.ml when all the @@ -128,7 +105,7 @@ let main () = 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 @@ -155,7 +132,7 @@ To display extra help for a single tool, do: 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 @@ -170,11 +147,11 @@ Options:") cmd summary description in (* Now begin proper parsing of the command line arguments. *) let debug = ref false in - let images = ref [] in + let testimages = ref [] 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 @@ -183,7 +160,7 @@ Options:") cmd summary description in | 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 @@ -194,7 +171,7 @@ Options:") cmd summary description in | 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 @@ -205,20 +182,44 @@ Options:") cmd summary description in 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 = - images := - (!def_wordsize, !def_endian, !def_architecture, !def_text_addr, filename) - :: !images + testimages := + (!def_wordsize, !def_endian, !def_architecture, + !def_text_addr, !def_kernel_min, !def_kernel_max, filename) + :: !testimages in (* Handle --version option. *) @@ -241,7 +242,7 @@ Options:") cmd summary description 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"; @@ -276,7 +277,7 @@ Options:") cmd summary description in (* Parse the command line. This will exit if --version or --help found. *) Arg.parse argspec anon_arg usage_msg; - let images = !images in + let testimages = !testimages in let debug = !debug in let uri = if !uri = "" then None else Some !uri in @@ -292,7 +293,7 @@ Options:") cmd summary description in * 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, run = + let name, _, _, _, _, argcheck, beforeksyms, beforeutsname, run = match tool with | Some t -> t | None -> @@ -311,7 +312,7 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); (* Get the kernel images. *) let images = - if images = [] then ( + if testimages = [] then ( let conn = let name = uri in try C.connect_readonly ?name () @@ -372,22 +373,21 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); 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 = @@ -395,28 +395,29 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); | 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 image = + 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 @@ -424,14 +425,8 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); (end_t -. start_t) ); - (* Map the virtual memory. *) - let mem = MMap.of_string str !def_text_addr in + image - (* Force the wordsize and endianness. *) - let mem = MMap.set_wordsize mem wordsize in - let mem = MMap.set_endian mem endian in - - ((Some id, name, arch, mem) : image) ) xmls ) else ( (* One or more -t options passed. *) @@ -439,7 +434,8 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); 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 ... *) @@ -473,14 +469,15 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); (* Map the virtual memory. *) let fd = openfile filename [O_RDONLY] 0 in - let mem = MMap.of_file fd text_addr in + let mem = Virt_mem_mmap.of_file fd text_addr in (* Force the wordsize and endianness. *) - let mem = MMap.set_wordsize mem wordsize in - let mem = MMap.set_endian mem endian in + let mem = Virt_mem_mmap.set_wordsize mem wordsize in + let mem = Virt_mem_mmap.set_endian mem endian in - ((None, filename, arch, mem) : image) - ) images + { dom = None; domname = filename; mem = mem; arch = arch; + kernel_min = kernel_min; kernel_max = kernel_max } + ) testimages ) in (* Optional callback into the tool before we start looking for @@ -491,405 +488,27 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); | Some beforeksyms -> beforeksyms debug images ); - (* If there is no run function, then there is no point continuing - * with the rest of the program (kernel symbol analysis) ... + (* If there are no more callback functions, then there is no point + * continuing with the rest of the program (kernel symbol analysis) ... *) - if run = None then exit 0; + if beforeutsname = None && run = None then exit 0; - (* Now kernel symbol analysis starts ... *) + (* Do the kernel symbol analysis. *) let images = List.map ( - fun (domid, name, arch, mem) -> - (* Look for some common entries in the exported symbol table and - * from that find the symbol table itself. These are just - * supposed to be symbols which are very likely to be present - * in any Linux kernel, although we only need one of them to be - * present to find the symbol table. - * - * NB. Must not be __initdata, must be in EXPORT_SYMBOL. - *) - let common_ksyms = [ - "init_task"; (* first task_struct *) - "root_mountflags"; (* flags for mounting root fs *) - "init_uts_ns"; (* uname strings *) - "sys_open"; (* open(2) entry point *) - "sys_chdir"; (* chdir(2) entry point *) - "sys_chroot"; (* chroot(2) entry point *) - "sys_umask"; (* umask(2) entry point *) - "schedule"; (* scheduler entry point *) - ] in - (* Searching for string *) - 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 ). *) - 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.map ( - fun addr -> - (* Search for 'addr' appearing in the image. *) - let addrs = MMap.find_pointer_all mem addr in - - (* Now consider each of these addresses and search back - * until we reach the beginning of the (possible) symbol - * table. - * - * Kernel symbol table struct is: - * struct kernel_symbol { - * unsigned long value; - * const char *name; <-- initial pointer - * } symbols[]; - *) - let pred_long2 addr = - MMap.pred_long mem (MMap.pred_long mem addr) - in - let base_addrs = List.map ( - fun addr -> - let rec loop addr = - (* '*addr' should point to a C identifier. If it does, - * step backwards to the previous symbol table entry. - *) - let addrp = MMap.follow_pointer mem addr in - if MMap.is_C_identifier mem addrp then - loop (pred_long2 addr) - else - MMap.succ_long mem addr - in - loop addr - ) addrs in - - (* Also look for the end of the symbol table and - * calculate its size. - *) - let base_addrs_sizes = List.map ( - fun base_addr -> - let rec loop addr = - let addr2 = MMap.succ_long mem addr in - let addr2p = MMap.follow_pointer mem addr2 in - if MMap.is_C_identifier mem addr2p then - loop (MMap.succ_long mem addr2) - else - addr - in - let end_addr = loop base_addr in - base_addr, end_addr -^ base_addr - ) base_addrs in - - base_addrs_sizes - ) ksym_strings in - let ksymtabs = List.concat ksymtabs in - - (* Simply ignore any symbol table candidates which are too small. *) - let ksymtabs = List.filter (fun (_, size) -> size > 64L) ksymtabs in - - if debug then ( - eprintf "%s: candidate symbol tables at:\n" name; - List.iter ( - fun (addr, size) -> - 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))) - ) ksymtabs - ); - - (* Vote for the most popular symbol table candidate and from this - * generate a function to look up ksyms. - *) - let lookup_ksym = - let freqs = frequency ksymtabs in - match freqs with - | [] -> - eprintf (f_"%s: cannot find start of kernel symbol table\n") name; - (fun _ -> raise Not_found) - - | (_, (ksymtab_addr, ksymtab_size)) :: _ -> - if debug then - eprintf - "%s: Kernel symbol table found at %Lx, size %Lx bytes\n%!" - name ksymtab_addr ksymtab_size; - - (* Load the whole symbol table as a bitstring. *) - let ksymtab = - Bitstring.bitstring_of_string - (MMap.get_bytes mem ksymtab_addr - (Int64.to_int ksymtab_size)) in - - (* Function to look up an address in the symbol table. *) - let lookup_ksym sym = - let bits = bits_of_wordsize (MMap.get_wordsize mem) in - let e = MMap.get_endian mem in - let rec loop bs = - bitmatch bs with - | { value : bits : endian(e); - name_ptr : bits : endian(e) } - when MMap.get_string mem name_ptr = sym -> - value - | { _ : bits : endian(e); - _ : bits : endian(e); - bs : -1 : bitstring } -> - loop bs - | { _ } -> raise Not_found - in - loop ksymtab - in - - 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 - * addresses of the common ksyms above, and it has some - * characteristics which make it easy to detect in the - * memory. - * - * kallsyms contains a complete list of symbols so is much - * more useful than the basic list of exports. + 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 ksym_addrs = List.filter_map ( - fun ksym -> try Some (lookup_ksym ksym) with Not_found -> None - ) common_ksyms in - - (* Search for those kernel addresses in the image. We're looking - * for the table kallsyms_addresses followed by kallsyms_num_syms - * (number of symbols in the table). - *) - let ksym_addrs = List.map (MMap.find_pointer_all mem) ksym_addrs in - let ksym_addrs = List.concat ksym_addrs in - - (* Test each one to see if it's a candidate list of kernel - * addresses followed by length of list. - *) - let kallsymtabs = List.filter_map ( - fun addr -> - (* Search upwards from address until we find the length field. - * If found, jump backwards by length and check all addresses. - *) - if debug then - 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 - loop (MMap.succ_long mem addr) (* continue up the table *) - else - if addrp >= min_kallsyms_tabsize && - addrp <= max_kallsyms_tabsize then ( - (* addrp might be the symbol count. Count backwards and - * check the full table. - *) - let num_entries = Int64.to_int addrp in - let entry_size = bytes_of_wordsize (MMap.get_wordsize mem) in - let start_addr = - addr -^ Int64.of_int (entry_size * num_entries) in - let end_addr = addr in - let rec loop2 addr = - if addr < end_addr then ( - let addrp = MMap.follow_pointer mem addr in - if MMap.is_mapped mem addrp then - loop2 (MMap.succ_long mem addr) - else - None (* can't verify the full address table *) - ) else - (* ok! *) - let names_addr = MMap.succ_long mem end_addr in - if debug then - 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 - loop2 start_addr - ) - else - None (* forget it *) - in - match loop addr with - | None -> None - | Some (start_addr, num_entries, names_addr) -> - (* As an additional verification, check the list of - * kallsyms_names. - *) - try - (* If the first byte is '\000' and is followed by a - * C identifier, then this is old-school list of - * symbols with prefix compression as in 2.6.9. - * Otherwise Huffman-compressed kallsyms as in - * 2.6.25. - *) - if MMap.get_byte mem names_addr = 0 && - MMap.is_C_identifier mem (names_addr+^1L) then ( - let names = ref [] in - let prev = ref "" in - let rec loop names_addr start_addr num = - if num > 0 then ( - let prefix = MMap.get_byte mem names_addr in - let prefix = String.sub !prev 0 prefix in - let name = MMap.get_string mem (names_addr+^1L) in - let len = String.length name in - let name = prefix ^ name in - prev := name; - 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 - (*eprintf "%S -> %Lx\n" name sym_value;*) - names := (name, sym_value) :: !names; - loop names_addr start_addr (num-1) - ) - in - loop names_addr start_addr num_entries; - let names = List.rev !names in - - Some (start_addr, num_entries, names_addr, - Uncompressed names) - ) - else ( (* new-style "compressed" names. *) - let compressed_names = ref [] in - let rec loop names_addr start_addr num = - if num > 0 then ( - let len = MMap.get_byte mem names_addr in - let name = MMap.get_bytes mem (names_addr+^1L) len in - let names_addr = names_addr +^ Int64.of_int len +^ 1L in - let sym_value = MMap.follow_pointer mem start_addr in - let start_addr = MMap.succ_long mem start_addr in - compressed_names := - (name, sym_value) :: !compressed_names; - loop names_addr start_addr (num-1) - ) else - names_addr - in - let markers_addr = loop names_addr start_addr num_entries in - let markers_addr = MMap.align mem markers_addr in - let compressed_names = List.rev !compressed_names in - - Some (start_addr, num_entries, names_addr, - Compressed (compressed_names, markers_addr)) - ) - with - Invalid_argument _ -> None (* bad names list *) - ) ksym_addrs in - - if debug then ( - eprintf "%s: candidate kallsyms at:\n" name; - List.iter ( - function - | (start_addr, num_entries, names_addr, Uncompressed _) -> - 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)) -> - eprintf "\t%Lx %d entries names_addr=%Lx markers_addr=%Lx\n%!" - start_addr num_entries names_addr markers_addr - ) kallsymtabs - ); - - (* Vote for the most popular symbol table candidate and - * enhance the function for looking up ksyms. - *) - let lookup_ksym = - let freqs = frequency kallsymtabs in - match freqs with - | [] -> - (* Can't find any kallsymtabs, just return the lookup_ksym - * function generated previously from the exported symbols. - *) - lookup_ksym - - | (_, (_, _, _, Uncompressed names)) :: _ -> - let lookup_ksym name = - try (* first look it up in kallsyms table. *) - List.assoc name names - with Not_found -> (* try the old exports table instead *) - lookup_ksym name - in - lookup_ksym - - | (_, (start_addr, num_entries, names_addr, - Compressed (compressed_names, markers_addr))) :: _ -> - (* Skip the markers and look for the token table. *) - let num_markers = Int64.of_int ((num_entries + 255) / 256) in - let marker_size = - Int64.of_int (bytes_of_wordsize (MMap.get_wordsize mem)) in - let tokens_addr = markers_addr +^ marker_size *^ num_markers in - - (* Now read out the compression tokens, which are just - * 256 ASCIIZ strings that map bytes in the compression - * names to substrings. - *) - let tokens = Array.make 256 "" in - let rec loop i addr = - if i < 256 then ( - let str = MMap.get_string mem addr in - let len = String.length str in - let addr = addr +^ Int64.of_int (len+1) in - tokens.(i) <- str; - loop (i+1) addr - ) - in - loop 0 tokens_addr; - - (* Expand the compressed names using the tokens. *) - let names = List.filter_map ( - fun (name, sym_value) -> - let f c = tokens.(Char.code c) in - let name = String.replace_chars f name in - (* First character in uncompressed output is the symbol - * type, eg. 'T'/'t' for text etc. - *) - (* NOTE: Symbol names are NOT unique - * (eg. 'con_start' is both a function and data in - * some kernels). XXX We need to handle this situation - * better. - *) - (*let typ = name.[0] in*) - let name = String.sub name 1 (String.length name - 1) in - (*eprintf "%S -> %Lx\n" name sym_value;*) - Some (name, sym_value) - ) compressed_names in - - let lookup_ksym name = - try (* first look it up in kallsyms table. *) - List.assoc name names - with Not_found -> (* try the old exports table instead *) - lookup_ksym name - 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 = + 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 @@ -899,17 +518,30 @@ Use 'virt-mem --help' for more help or read the manual page virt-mem(1)"); eprintf "lookup_ksym %S failed\n%!" sym; raise Not_found in - lookup_ksym + (domid, name, arch, mem, lookup_ksym) else - lookup_ksym - in + image in +*) - ((domid, name, arch, mem, lookup_ksym) : image_with_ksyms) + 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 -> - run debug images + | Some run -> List.iter (run debug) images )