lib/virt_mem_types.ml

   1 (** Common types. *)
   2 (* Memory info command for virtual domains.
   3    (C) Copyright 2008 Richard W.M. Jones, Red Hat Inc.
   4    http://libvirt.org/
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20    Common types.
  21  *)
  22
  23 module D = Libvirt.Domain
  24
  25 open Virt_mem_utils
  26 open Virt_mem_mmap
  27
  28 type ksym = string
  29
  30 module Ksymmap = Map.Make (String)
  31
  32 type ksymmap = addr Ksymmap.t
  33
  34 type image = {
  35   dom : Libvirt.ro D.t option;
  36   domname : string;
  37   arch : architecture;
  38   mem : ([`Wordsize], [`Endian], [`HasMapping]) Virt_mem_mmap.t;
  39   kernel_min : addr;
  40   kernel_max : addr;
  41 }
  42
  43 type utsname = {
  44   uts_kernel_name : string;
  45   uts_nodename : string;
  46   uts_kernel_release : string;
  47   uts_kernel_version : string;
  48   uts_machine : string;
  49   uts_domainname : string;
  50 }
  51
  52 type task = {
  53   task_state : int64;
  54   task_prio : int64;
  55   task_normal_prio : int64;
  56   task_static_prio : int64;
  57   task_comm : string;
  58   task_pid : int64;
  59 }
  60
  61 type net_device = {
  62   netdev_name : string;
  63   netdev_flags : int64;
  64   netdev_operstate : int64;
  65   netdev_mtu : int64;
  66   netdev_perm_addr : string;
  67   netdev_addr_len : int64;
  68 }
  69
  70 type kdata = {
  71   ksyms : ksymmap option;
  72   utsname : utsname option;
  73   tasks : task list option;
  74   net_devices : net_device list option;
  75 }
  76
  77 exception ParseError of string * string * string
  78
  79 type fieldsig = {
  80   field_available : bool;
  81   field_offset : int;
  82 }
  83
  84 (* This is the maximum we can download in one go over the libvirt
  85  * remote connection.
  86  *
  87  * XXX Should have a 'D.max_peek' function.
  88  *)
  89 let max_memory_peek = 65536
  90
  91 type load_memory_error =
  92   | AddressOutOfRange
  93   | DomIsNull
  94
  95 exception LoadMemoryError of load_memory_error * string
  96
  97 let _load_memory mem dom start size =
  98   let str = String.create size in
  99   let rec loop i =
 100     let remaining = size - i in
 101     if remaining > 0 then (
 102       let size = min remaining max_memory_peek in
 103       D.memory_peek dom [D.Virtual] (start +^ Int64.of_int i) size str i;
 104       loop (i + size)
 105     )
 106   in
 107   loop 0;
 108
 109   Virt_mem_mmap.add_string mem str start
 110
 111 let load_static_memory ~dom ~domname ~arch ~wordsize ~endian
 112     ~kernel_min ~kernel_max start size =
 113   if start < kernel_min then
 114     raise (LoadMemoryError (AddressOutOfRange,
 115                             "load_memory: start < kernel_min"))
 116   else if start +^ Int64.of_int size > kernel_max then
 117     raise (LoadMemoryError (AddressOutOfRange,
 118                             "load_memory: start+size > kernel_max"))
 119   else (
 120     let mem = Virt_mem_mmap.create () in
 121     let mem = Virt_mem_mmap.set_wordsize mem wordsize in
 122     let mem = Virt_mem_mmap.set_endian mem endian in
 123
 124     let mem = _load_memory mem dom start size in
 125
 126     { dom = Some dom; domname = domname; mem = mem; arch = arch;
 127       kernel_min = kernel_min; kernel_max = kernel_max }
 128   )
 129
 130 let load_memory ({ dom = dom; mem = mem; kernel_min = kernel_min;
 131                    kernel_max = kernel_max } as image) start size =
 132   if start < kernel_min then
 133     raise (LoadMemoryError (AddressOutOfRange,
 134                             "load_memory: start < kernel_min"))
 135   else if start +^ Int64.of_int size > kernel_max then
 136     raise (LoadMemoryError (AddressOutOfRange,
 137                             "load_memory: start+size > kernel_max"))
 138   else if Virt_mem_mmap.is_mapped_range mem start size then image
 139   else (
 140     match dom with
 141     | None ->
 142         raise (LoadMemoryError (DomIsNull, "load_memory: dom = None"))
 143     | Some dom ->
 144         let mem = _load_memory mem dom start size in
 145         { image with mem = mem }
 146   )