# HG changeset patch
# User Jon Ludlam <Jonathan.Ludlam@xxxxxxxxxxxxx>
# Date 1285345650 -3600
# Node ID 243ef81d48f72655dc409b127eb39785e4a5f5c0
# Parent  e8da99c62c3e9ae692285a3b5d016547bc503192
Local disk caching API work. Added pool-level API calls to enable/disable caching, host-level API calls for same, per VDI on_boot and allow_caching parameters, and CLI calls for all.

Signed-off-by: Jon Ludlam <Jonathan.Ludlam@xxxxxxxxxxxxx>

diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/client_records/record_util.ml
--- a/ocaml/client_records/record_util.ml
+++ b/ocaml/client_records/record_util.ml
@@ -324,6 +324,11 @@
 let i642sm_to_string sep x =
   String.concat sep (List.map (fun (a,b) -> Printf.sprintf "%Ld %s" a b) x)
 
+let on_boot_to_string onboot =
+	match onboot with
+		| `reset -> "reset"
+		| `persist -> "persist"
+
 (** Parse a string which might have a units suffix on the end *)
 let bytes_of_string field x = 
   let isdigit c = c >= '0' && c <= '9' in
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/client_records/records.ml
--- a/ocaml/client_records/records.ml
+++ b/ocaml/client_records/records.ml
@@ -1057,6 +1057,7 @@
     make_field ~name:"power-on-mode" ~get:(fun () -> (x ()).API.host_power_on_mode) ();
     make_field ~name:"power-on-config" ~get:(fun () -> Record_util.s2sm_to_string "; " (x ()).API.host_power_on_config)
       ~get_map:(fun () -> (x ()).API.host_power_on_config) ();
+	make_field ~name:"local-cache-sr" ~get:(fun () -> get_uuid_from_ref (x ()).API.host_local_cache_sr) ();
   ]}
 
 let vdi_record rpc session_id vdi =
@@ -1113,6 +1114,10 @@
       ~get_map:(fun () -> (x ()).API.vDI_xenstore_data) ();
     make_field ~name:"sm-config" ~get:(fun () -> Record_util.s2sm_to_string "; " (x ()).API.vDI_sm_config) 
       ~get_map:(fun () -> (x ()).API.vDI_sm_config) ();
+	make_field ~name:"on-boot" ~get:(fun () -> Record_util.on_boot_to_string (x ()).API.vDI_on_boot) 
+		~set:(fun onboot -> Client.VDI.set_on_boot rpc session_id vdi (match onboot with "persist" -> `persist | "reset" -> `reset)) ();
+		make_field ~name:"allow-caching" ~get:(fun () -> string_of_bool (x ()).API.vDI_allow_caching) 
+		~set:(fun b -> Client.VDI.set_allow_caching rpc session_id vdi (bool_of_string b)) ();
   ]}
 
 let vbd_record rpc session_id vbd =
@@ -1272,6 +1277,7 @@
     make_field ~name:"sm-config" ~get:(fun () -> Record_util.s2sm_to_string "; " (x ()).API.sR_sm_config) 
       ~get_map:(fun () -> (x ()).API.sR_sm_config) ();
     make_field ~name:"blobs" ~get:(fun () -> Record_util.s2brm_to_string get_uuid_from_ref "; " (x ()).API.sR_blobs) ();
+	make_field ~name:"local-cache-enabled" ~get:(fun () -> string_of_bool (x ()).API.sR_local_cache_enabled) ();
   ]}
     
 let pbd_record rpc session_id pbd =
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/idl/api_errors.ml
--- a/ocaml/idl/api_errors.ml
+++ b/ocaml/idl/api_errors.ml
@@ -62,6 +62,9 @@
 let host_is_slave = "HOST_IS_SLAVE"
 let host_name_invalid = "HOST_NAME_INVALID"
 let host_has_resident_vms = "HOST_HAS_RESIDENT_VMS"
+let hosts_failed_to_enable_caching = "HOSTS_FAILED_TO_ENABLE_CACHING"
+let hosts_failed_to_disable_caching = "HOSTS_FAILED_TO_DISABLE_CACHING"
+let host_cannot_see_SR = "HOST_CANNOT_SEE_SR"
 
 (* Host errors which explain why the host is in emergency mode *)
 let host_its_own_slave = "HOST_ITS_OWN_SLAVE"
@@ -181,6 +184,7 @@
 let vdi_incompatible_type = "VDI_INCOMPATIBLE_TYPE"
 let vdi_not_managed = "VDI_NOT_MANAGED"
 let vdi_io_error = "VDI_IO_ERROR"
+let vdi_on_boot_mode_incompatable_with_operation = "VDI_ON_BOOT_MODE_INCOMPATABLE_WITH_OPERATION"
 let cannot_create_state_file = "CANNOT_CREATE_STATE_FILE"
 
 
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/idl/datamodel.ml
--- a/ocaml/idl/datamodel.ml
+++ b/ocaml/idl/datamodel.ml
@@ -3653,6 +3653,28 @@
 	~hide_from_docs:true
 	() 
   
+let host_enable_local_storage_caching = call ~flags:[`Session]
+	~name:"enable_local_storage_caching"
+	~in_product_since:rel_cowley
+	~doc:"Enable the use of a local SR for caching purposes"
+	~params:[
+		Ref _host, "host", "The host";
+		Ref _sr, "sr", "The SR to use as a local cache"
+	]
+	~allowed_roles:_R_POOL_OP
+	()
+
+let host_disable_local_storage_caching = call ~flags:[`Session]
+	~name:"disable_local_storage_caching"
+	~in_product_since:rel_cowley
+	~doc:"Disable the use of a local SR for caching purposes"
+	~params:[
+		Ref _host, "host", "The host"
+	]
+	~allowed_roles:_R_POOL_OP
+	()
+
+
 (** Hosts *)
 let host =
     create_obj ~in_db:true ~in_product_since:rel_rio ~in_oss_since:oss_since_303 ~internal_deprecated_since:None ~persist:PersistEverything ~gen_constructor_destructor:false ~name:_host ~descr:"A physical host" ~gen_events:true
@@ -3726,6 +3748,8 @@
 		 host_set_cpu_features;
 		 host_reset_cpu_features;
 		 host_reset_networking;
+		 host_enable_local_storage_caching;
+		 host_disable_local_storage_caching;
 		 ]
       ~contents:
         ([ uid _host;
@@ -3767,7 +3791,7 @@
     field ~qualifier:DynamicRO ~in_product_since:rel_midnight_ride ~default_value:(Some (VMap [])) ~ty:(Map (String,String)) "bios_strings" "BIOS strings";
 	field ~qualifier:DynamicRO ~in_product_since:rel_midnight_ride ~default_value:(Some (VString "")) ~ty:String "power_on_mode" "The power on mode";  
 	field ~qualifier:DynamicRO ~in_product_since:rel_midnight_ride ~default_value:(Some (VMap [])) ~ty:(Map(String, String)) "power_on_config" "The power on config";
-
+	field ~qualifier:DynamicRO ~in_product_since:rel_cowley ~default_value:(Some (VRef (Ref.string_of Ref.null))) ~ty:(Ref _sr) "local_cache_sr" "The SR that is used as a local cache";
  ])
 	()
 
@@ -4430,6 +4454,7 @@
  	field ~ty:Bool ~qualifier:DynamicRO ~in_oss_since:None ~internal_only:true "default_vdi_visibility" "";
 	field ~in_oss_since:None ~ty:(Map(String, String)) ~in_product_since:rel_miami ~qualifier:RW "sm_config" "SM dependent data" ~default_value:(Some (VMap []));
 	field ~qualifier:DynamicRO ~in_product_since:rel_orlando ~ty:(Map(String, Ref _blob)) ~default_value:(Some (VMap [])) "blobs" "Binary blobs associated with this SR";
+	field ~qualifier:DynamicRO ~in_product_since:rel_cowley ~ty:Bool ~default_value:(Some (VBool false)) "local_cache_enabled" "True if this SR is assigned to be the local cache for its host";
       ])
 	()
 
@@ -4665,6 +4690,31 @@
    ~allowed_roles:_R_VM_ADMIN
    ()
 
+let on_boot = Enum ("on_boot", [ "reset", "The VDI will be reset to the state it was in at the last clone";
+"persist", "The VDIs contents are persistent" ])
+
+ let vdi_set_on_boot = call
+	 ~name:"set_on_boot"
+	 ~in_oss_since:None
+	 ~in_product_since:rel_cowley
+	 ~params:[Ref _vdi, "self", "The VDI to modify";
+	          on_boot, "value", "The value to set"]
+	 ~doc:"Set the value of the on_boot parameter"
+	 ~hide_from_docs:true
+	 ~allowed_roles:_R_VM_ADMIN
+	 ()
+
+let vdi_set_allow_caching = call
+	~name:"set_allow_caching"
+	~in_oss_since:None
+	~in_product_since:rel_cowley
+	~params:[Ref _vdi, "self", "The VDI to modify";
+	Bool, "value", "The value to set"]
+	~doc:"Set the value of the allow_caching parameter"
+	~hide_from_docs:true
+	~allowed_roles:_R_VM_ADMIN
+	()
+			  
 (** A virtual disk *)
 let vdi =
     create_obj ~in_db:true ~in_product_since:rel_rio ~in_oss_since:oss_since_303 ~internal_deprecated_since:None ~persist:PersistEverything ~gen_constructor_destructor:true ~name:_vdi ~descr:"A virtual disk image"
@@ -4685,6 +4735,8 @@
 		 vdi_set_virtual_size;
 		 vdi_set_physical_utilisation;
 		 vdi_generate_config;
+		 vdi_set_on_boot;
+		 vdi_set_allow_caching;
 		]
       ~contents:
       ([ uid _vdi;
@@ -4713,6 +4765,9 @@
 	field ~in_product_since:rel_orlando                                              ~qualifier:DynamicRO ~ty:(Set (Ref _vdi)) "snapshots" "List pointing to all the VDIs snapshots.";
 	field ~in_product_since:rel_orlando ~default_value:(Some (VDateTime Date.never)) ~qualifier:DynamicRO ~ty:DateTime         "snapshot_time" "Date/time when this snapshot was created.";
 	field ~writer_roles:_R_VM_OP ~in_product_since:rel_orlando ~default_value:(Some (VSet [])) ~ty:(Set String) "tags" "user-specified tags for categorization purposes";
+	field ~in_product_since:rel_cowley ~qualifier:DynamicRO ~ty:Bool ~default_value:(Some (VBool false)) "allow_caching" "true if this VDI is to be cached in the local cache SR";
+	field ~in_product_since:rel_cowley ~qualifier:DynamicRO ~ty:on_boot ~default_value:(Some (VEnum "persist")) "on_boot" "The behaviour of this VDI on a VM boot";
+	
       ])
 	()
 
@@ -5294,6 +5349,24 @@
   ~result:(String, "An XMLRPC result")
   ()
 
+let pool_enable_local_storage_caching = call 
+	~name:"enable_local_storage_caching"
+	~in_oss_since:None
+	~in_product_since:rel_cowley
+	~params:[Ref _pool, "self", "Reference to the pool"]
+	~doc:"This call attempts to enable pool-wide local storage caching"
+	~allowed_roles:_R_POOL_OP
+	()
+
+let pool_disable_local_storage_caching = call 
+	~name:"disable_local_storage_caching"
+	~in_oss_since:None
+	~in_product_since:rel_cowley
+	~params:[Ref _pool, "self", "Reference to the pool"]
+	~doc:"This call disables pool-wide local storage caching"
+	~allowed_roles:_R_POOL_OP
+	()
+
 (** A pool class *)
 let pool =
 	create_obj
@@ -5356,6 +5429,8 @@
 			; pool_audit_log_append
 			; pool_set_vswitch_controller
 			; pool_test_archive_target
+			; pool_enable_local_storage_caching
+			; pool_disable_local_storage_caching
 			]
 		~contents:
 			[uid ~in_oss_since:None _pool
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/cli_frontend.ml
--- a/ocaml/xapi/cli_frontend.ml
+++ b/ocaml/xapi/cli_frontend.ml
@@ -450,6 +450,42 @@
       flags=[Host_selectors];
     };
 
+   "host-enable-local-storage-caching",
+	{ 
+		reqd=["sr-uuid"];
+		optn=[];
+		help="Enable local storage caching on the specified host";
+		implementation=No_fd Cli_operations.host_enable_local_storage_caching;
+		flags=[Host_selectors];
+	};
+
+   "host-disable-local-storage-caching",
+	{ 
+		reqd=[];
+		optn=[];
+		help="Disable local storage caching on the specified host";
+		implementation=No_fd Cli_operations.host_disable_local_storage_caching;
+		flags=[Host_selectors];
+	};
+	  
+   "pool-enable-local-storage-caching",
+	{
+		reqd=["uuid"];
+		optn=[];
+		help="Enable local storage caching across the pool";
+		implementation=No_fd Cli_operations.pool_enable_local_storage_caching;
+		flags=[];
+	};
+
+   "pool-disable-local-storage-caching",
+	{
+		reqd=["uuid"];
+		optn=[];
+		help="Disable local storage caching across the pool";
+		implementation=No_fd Cli_operations.pool_disable_local_storage_caching;
+		flags=[];
+	};
+
    "host-shutdown",
     {
       reqd=[];
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/cli_operations.ml
--- a/ocaml/xapi/cli_operations.ml
+++ b/ocaml/xapi/cli_operations.ml
@@ -3338,6 +3338,23 @@
   in
   ignore(do_host_op rpc session_id op params [])
   
+let host_enable_local_storage_caching printer rpc session_id params =
+	ignore(do_host_op rpc session_id (fun _ host -> 
+		let sr_uuid = List.assoc "sr-uuid" params in
+		let sr = Client.SR.get_by_uuid rpc session_id sr_uuid in
+		Client.Host.enable_local_storage_caching rpc session_id (host.getref ()) sr
+	) params ["sr-uuid"])
+
+let host_disable_local_storage_caching printer rpc session_id params =
+	ignore(do_host_op rpc session_id (fun _ host -> Client.Host.disable_local_storage_caching rpc session_id (host.getref ())) params [])
+
+let pool_enable_local_storage_caching printer rpc session_id params =
+	let pool = List.hd (Client.Pool.get_all rpc session_id) in
+	Client.Pool.enable_local_storage_caching rpc session_id pool
+	
+let pool_disable_local_storage_caching printer rpc session_id params =
+	let pool = List.hd (Client.Pool.get_all rpc session_id) in
+	Client.Pool.disable_local_storage_caching rpc session_id pool
   
 let host_set_power_on_mode printer rpc session_id params =
   let power_on_mode = List.assoc "power-on-mode" params in
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/message_forwarding.ml
--- a/ocaml/xapi/message_forwarding.ml
+++ b/ocaml/xapi/message_forwarding.ml
@@ -2184,6 +2184,14 @@
     let reset_networking ~__context ~host = 
       info "Host.reset_networking: host = '%s'" (host_uuid ~__context host);
       Local.Host.reset_networking ~__context ~host
+
+	let enable_local_storage_caching ~__context ~host ~sr =
+		let local_fn = Local.Host.enable_local_storage_caching ~host ~sr in
+		do_op_on ~local_fn ~__context ~host (fun session_id rpc -> Client.Host.enable_local_storage_caching rpc session_id host sr)
+
+	let disable_local_storage_caching ~__context ~host =
+		let local_fn = Local.Host.disable_local_storage_caching ~host in
+		do_op_on ~local_fn ~__context ~host (fun session_id rpc -> Client.Host.disable_local_storage_caching rpc session_id host)
 end
 
   module Host_crashdump = struct
@@ -2793,6 +2801,24 @@
       Sm.assert_session_has_internal_sr_access ~__context ~sr;
       Local.VDI.set_physical_utilisation ~__context ~self ~value
 
+	let ensure_vdi_not_on_running_vm ~__context ~self =
+		let vbds = Db.VDI.get_VBDs ~__context ~self in
+		List.iter (fun vbd ->
+			let vm = Db.VBD.get_VM ~__context ~self:vbd in
+			let state = Db.VM.get_power_state ~__context ~self:vm in
+			match state with
+				| `Halted -> ()
+				| _ -> raise (Api_errors.Server_error(Api_errors.vm_bad_power_state, 
+				        [Ref.string_of vm; "halted"; Record_util.power_to_string state]))) vbds
+
+	let set_on_boot ~__context ~self ~value =
+		ensure_vdi_not_on_running_vm ~__context ~self;
+		Local.VDI.set_on_boot ~__context ~self ~value
+
+	let set_allow_caching ~__context ~self ~value =
+		ensure_vdi_not_on_running_vm ~__context ~self;
+		Local.VDI.set_allow_caching ~__context ~self ~value
+
     (* know sr so just use SR forwarding policy direct here *)
     let create ~__context ~name_label ~name_description ~sR ~virtual_size ~_type ~sharable ~read_only ~other_config ~xenstore_data ~sm_config ~tags =
       info "VDI.create: SR = '%s'; name label = '%s'" (sr_uuid ~__context sR) name_label;
@@ -2912,7 +2938,7 @@
 	(fun () ->
 	   forward_vdi_op ~local_fn ~__context ~self:vdi
 	     (fun session_id rpc -> Client.VDI.force_unlock rpc session_id vdi))
-	
+
   end
   module VBD = struct
 
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/sm_exec.ml
--- a/ocaml/xapi/sm_exec.ml
+++ b/ocaml/xapi/sm_exec.ml
@@ -57,10 +57,14 @@
   vdi_ref: API.ref_VDI option;
   vdi_location: string option;
   vdi_uuid: string option;
+  vdi_on_boot: string option;
+  vdi_allow_caching : string option;
 
   (* Reference to the task which performs the call *)
   subtask_of: API.ref_task option;
 
+  local_cache_sr: string option;
+
   cmd: string;
   args: string list;
 }
@@ -73,6 +77,10 @@
 	 then vdi_location
 	 else may (fun self -> Db.VDI.get_location ~__context ~self) vdi_ref in
        let vdi_uuid = may (fun self -> Db.VDI.get_uuid ~__context ~self) vdi_ref in
+	   let vdi_on_boot = may (fun self -> 
+		   match Db.VDI.get_on_boot ~__context ~self with `persist -> "persist" | `reset -> "reset") vdi_ref in
+	   let vdi_allow_caching = may (fun self -> string_of_bool (Db.VDI.get_allow_caching ~__context ~self)) vdi_ref in
+	   let local_cache_sr = try Some (Db.SR.get_uuid ~__context ~self:(Db.Host.get_local_cache_sr ~__context ~self:(Helpers.get_localhost __context))) with _ -> None in
        let sr_uuid = may (fun self -> Db.SR.get_uuid ~__context ~self) sr_ref in
        { host_ref = !Xapi_globs.localhost_ref;
 	 session_ref = None; (* filled in at the last minute *)
@@ -85,8 +93,11 @@
 	 vdi_ref = vdi_ref;
 	 vdi_location = vdi_location;
 	 vdi_uuid = vdi_uuid;
+	 vdi_on_boot = vdi_on_boot;
+	 vdi_allow_caching = vdi_allow_caching;
 	 new_uuid = new_uuid;
 	 subtask_of = subtask_of;
+	 local_cache_sr = local_cache_sr;
 	 cmd = cmd;
 	 args = args
        })
@@ -108,13 +119,15 @@
   let vdi_ref = default [] (may (fun x -> [ "vdi_ref", XMLRPC.To.string (Ref.string_of x) ]) call.vdi_ref) in
   let vdi_location = default [] (may (fun x -> [ "vdi_location", XMLRPC.To.string x ]) call.vdi_location) in
   let vdi_uuid = default [] (may (fun x -> [ "vdi_uuid", XMLRPC.To.string x ]) call.vdi_uuid) in
+  let vdi_on_boot = default [] (may (fun x -> [ "vdi_on_boot", XMLRPC.To.string x ]) call.vdi_on_boot) in
+  let vdi_allow_caching = default [] (may (fun x -> [ "vdi_allow_caching", XMLRPC.To.string x ]) call.vdi_allow_caching) in
   let new_uuid = default [] (may (fun x -> [ "new_uuid", XMLRPC.To.string x ]) call.new_uuid) in
 
   let driver_params = default [] (may (fun x -> [ "driver_params", kvpairs x ]) call.driver_params) in
   let vdi_sm_config = default [] (may (fun x -> [ "vdi_sm_config", kvpairs x ]) call.vdi_sm_config) in
   let subtask_of = default [] (may (fun x -> [ "subtask_of", XMLRPC.To.string (Ref.string_of x) ]) call.subtask_of) in
-
-  let all = common @ dc @ session_ref @ sr_sm_config @ sr_ref @ sr_uuid @ vdi_ref @ vdi_location @ vdi_uuid @ driver_params @ vdi_sm_config @ new_uuid @ subtask_of in
+  let local_cache_sr = default [] (may (fun x -> ["local_cache_sr", XMLRPC.To.string x]) call.local_cache_sr) in
+  let all = common @ dc @ session_ref @ sr_sm_config @ sr_ref @ sr_uuid @ vdi_ref @ vdi_location @ vdi_uuid @ driver_params @ vdi_sm_config @ new_uuid @ subtask_of @ vdi_on_boot @ vdi_allow_caching @ local_cache_sr in
   XMLRPC.To.methodCall call.cmd [ XMLRPC.To.structure all ]
 
 let methodResponse xml =
@@ -260,6 +273,7 @@
   let lookup_table = 
     [ "SR_PROBE",       Sr_probe;
       "SR_UPDATE",      Sr_update;
+	  "SR_SUPPORTS_LOCAL_CACHING", Sr_supports_local_caching;
       "VDI_CREATE",     Vdi_create;
       "VDI_DELETE",     Vdi_delete;
       "VDI_ATTACH",     Vdi_attach;
@@ -273,6 +287,7 @@
       "VDI_UPDATE",     Vdi_update;
       "VDI_INTRODUCE",  Vdi_introduce;
       "VDI_GENERATE_CONFIG", Vdi_generate_config;
+	  "VDI_RESET_ON_BOOT", Vdi_reset_on_boot;
     ] in
   let strings = XMLRPC.From.array XMLRPC.From.string (safe_assoc "capabilities" info) in
   List.iter (fun s -> 
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/smint.ml
--- a/ocaml/xapi/smint.ml
+++ b/ocaml/xapi/smint.ml
@@ -32,15 +32,18 @@
 
 (** Very primitive first attempt at a set of backend capabilities *)
 type capability =
-    | Sr_create | Sr_delete | Sr_attach | Sr_detach | Sr_scan | Sr_probe | Sr_update
+    | Sr_create | Sr_delete | Sr_attach | Sr_detach | Sr_scan | Sr_probe | Sr_update 
+	| Sr_supports_local_caching
     | Vdi_create | Vdi_delete | Vdi_attach | Vdi_detach
     | Vdi_clone | Vdi_snapshot | Vdi_resize | Vdi_activate | Vdi_deactivate
     | Vdi_update | Vdi_introduce 
     | Vdi_resize_online
     | Vdi_generate_config
+	| Vdi_reset_on_boot
 
 let all_capabilities =
   [ Sr_create; Sr_delete; Sr_attach; Sr_detach; Sr_scan; Sr_probe; Sr_update;
+    Sr_supports_local_caching; 
     Vdi_create; Vdi_delete; Vdi_attach; Vdi_detach;
     Vdi_clone; Vdi_resize; Vdi_activate; Vdi_deactivate;
     Vdi_update; Vdi_introduce;
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_host.ml
--- a/ocaml/xapi/xapi_host.ml
+++ b/ocaml/xapi/xapi_host.ml
@@ -96,8 +96,14 @@
     end
 
 (** Check that a) there are no running VMs present on the host, b) there are no VBDs currently 
-    attached to dom0, and c) that there are no tasks running *)
-let assert_can_shutdown ~__context ~host =
+    attached to dom0, c) host is disabled.
+
+	This is approximately maintainance mode as defined by the gui. However, since 
+	we haven't agreed on an exact definition of this mode, we'll not call this maintainance mode here, but we'll
+	use a synonym. According to http://thesaurus.com/browse/maintenance, bacon is a synonym 
+	for maintainance, hence the name of the following function.
+*)
+let assert_bacon_mode ~__context ~host =
   if Db.Host.get_enabled ~__context ~self:host 
   then raise (Api_errors.Server_error (Api_errors.host_not_disabled, []));
 
@@ -107,14 +113,14 @@
   (* We always expect a control domain to be resident on a host *)
   if List.length vms > 1 then
     raise (Api_errors.Server_error (Api_errors.host_in_use, [ selfref; "vm"; List.hd (List.map Ref.string_of vms) ]));
-  debug "Shutdown test: VMs OK - %d running VMs" (List.length vms);
+  debug "Bacon test: VMs OK - %d running VMs" (List.length vms);
   let controldomain = List.find (fun vm -> Db.VM.get_resident_on ~__context ~self:vm = host &&
       Db.VM.get_is_control_domain ~__context ~self:vm) (Db.VM.get_all ~__context) in  
   let vbds = List.filter (fun vbd -> Db.VBD.get_VM ~__context ~self:vbd = controldomain &&
       Db.VBD.get_currently_attached ~__context ~self:vbd) (Db.VBD.get_all ~__context) in
   if List.length vbds > 0 then
     raise (Api_errors.Server_error (Api_errors.host_in_use, [ selfref; "vbd"; List.hd (List.map Ref.string_of vbds) ]));
-  debug "Shutdown test: VBDs OK"
+  debug "Bacon test: VBDs OK"
 
 let pif_update_dhcp_address ~__context ~self =
   let network = Db.PIF.get_network ~__context ~self in
@@ -463,7 +469,7 @@
   end
 
 let shutdown_and_reboot_common ~__context ~host label description operation cmd = 
-  assert_can_shutdown ~__context ~host;
+  assert_bacon_mode ~__context ~host;
   Xapi_ha.before_clean_shutdown_or_reboot ~__context ~host;
   Remote_requests.stop_request_thread();
 
@@ -648,6 +654,7 @@
     ~bios_strings:[]
     ~power_on_mode:""
     ~power_on_config:[]
+	  ~local_cache_sr:Ref.null
   ;
   (* If the host we're creating is us, make sure its set to live *)
   Db.Host_metrics.set_last_updated ~__context ~self:metrics ~value:(Date.of_float (Unix.gettimeofday ()));
@@ -1354,3 +1361,31 @@
 	let physical_features = List.assoc "physical_features" cpu_info in
 	let cpu_info = List.replace_assoc "features_after_reboot" physical_features cpu_info in
 	Db.Host.set_cpu_info ~__context ~self:host ~value:cpu_info
+
+let enable_local_storage_caching ~__context ~host ~sr =
+	assert_bacon_mode ~__context ~host;
+	let ty = Db.SR.get_type ~__context ~self:sr in
+	let pbds = Db.SR.get_PBDs ~__context ~self:sr in
+	let shared = Db.SR.get_shared ~__context ~self:sr in
+	let has_required_capability = 
+		let caps = Sm.capabilities_of_driver ty in
+		List.mem Smint.Sr_supports_local_caching caps
+	in
+	debug "shared: %b. List.length pbds: %d. has_required_capability: %b" shared (List.length pbds) has_required_capability;
+	if (shared=false) && (List.length pbds = 1) && has_required_capability then begin
+		let pbd_host = Db.PBD.get_host ~__context ~self:(List.hd pbds) in
+		if pbd_host <> host then raise (Api_errors.Server_error (Api_errors.host_cannot_see_SR,[Ref.string_of host; Ref.string_of sr]));
+		Db.Host.set_local_cache_sr ~__context ~self:host ~value:sr;
+		Db.SR.set_local_cache_enabled ~__context ~self:sr ~value:true
+	end else begin
+		raise (Api_errors.Server_error (Api_errors.sr_operation_not_supported,[]))
+	end
+
+let disable_local_storage_caching ~__context ~host =
+	assert_bacon_mode ~__context ~host;
+	let sr = Db.Host.get_local_cache_sr ~__context ~self:host in
+	Db.Host.set_local_cache_sr ~__context ~self:host ~value:Ref.null;
+	try Db.SR.set_local_cache_enabled ~__context ~self:sr ~value:false with _ -> () 
+
+
+		
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_host.mli
--- a/ocaml/xapi/xapi_host.mli
+++ b/ocaml/xapi/xapi_host.mli
@@ -252,6 +252,10 @@
 (** Remove the feature mask, such that after a reboot all features of the CPU are enabled. *)
 val reset_cpu_features : __context:Context.t -> host:API.ref_host -> unit
 
+(** Control the local caching behaviour of the host *)
+val enable_local_storage_caching : __context:Context.t -> host:API.ref_host -> sr:API.ref_SR -> unit
+val disable_local_storage_caching : __context:Context.t -> host:API.ref_host -> unit
+
 (** Purge all network-related metadata associated with the given host. *)
 val reset_networking : __context:Context.t -> host:API.ref_host -> unit
 
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_pool.ml
--- a/ocaml/xapi/xapi_pool.ml
+++ b/ocaml/xapi/xapi_pool.ml
@@ -16,6 +16,7 @@
 open Pervasiveext
 open Threadext
 open Stringext
+open Listext
 
 module L = Debug.Debugger(struct let name="license" end)
 module D=Debug.Debugger(struct let name="xapi" end)
@@ -1464,4 +1465,50 @@
     "test_archive_target"
     config
 
-               
+let enable_local_storage_caching ~__context ~self =
+    let srs = Db.SR.get_all_records ~__context in
+	let pbds = Db.PBD.get_all_records ~__context in
+	let hosts = Db.Host.get_all ~__context in
+
+	(* Exception handler is to cope with transient PBDs with invalid references *)
+	let hosts_and_srs = List.filter_map (fun (pbdref,pbdrec) -> 
+		try Some (pbdrec.API.pBD_host, pbdrec.API.pBD_SR, List.assoc pbdrec.API.pBD_SR srs) with _ -> None) pbds 
+	in
+	
+	let acceptable = List.filter (fun (href,srref,srrec) -> 
+		(not srrec.API.sR_shared) && 
+			(List.length srrec.API.sR_PBDs = 1) && 
+			(List.mem Smint.Sr_supports_local_caching (Sm.capabilities_of_driver srrec.API.sR_type))
+	) hosts_and_srs in
+
+	let failed_hosts = 
+		Helpers.call_api_functions ~__context
+			(fun rpc session_id -> 
+				let failed = List.filter_map (fun host ->
+					let result = ref (Some host) in
+					let acceptable_srs = List.filter (fun (href,srref,srrec) -> href=host) acceptable in
+					List.iter (fun (href,ref,sr) -> 
+						try Client.Host.enable_local_storage_caching rpc session_id host ref; result := None with _ -> ()) acceptable_srs;
+					!result
+				) hosts in
+				failed)
+	in
+	if List.length failed_hosts > 0 then 
+		raise (Api_errors.Server_error (Api_errors.hosts_failed_to_enable_caching, List.map Ref.string_of failed_hosts))
+	else ()
+
+		
+let disable_local_storage_caching ~__context ~self =
+	let hosts = Db.Host.get_all ~__context in
+	let failed_hosts = Helpers.call_api_functions ~__context
+		(fun rpc session_id -> 
+			List.filter_map (fun host -> 
+				try 
+					Client.Host.disable_local_storage_caching ~rpc ~session_id ~host;
+					None
+				with _ -> 
+					Some host) hosts)
+	in
+	if List.length failed_hosts > 0 then
+		raise (Api_errors.Server_error (Api_errors.hosts_failed_to_disable_caching, List.map Ref.string_of failed_hosts))
+	else ()
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_pool.mli
--- a/ocaml/xapi/xapi_pool.mli
+++ b/ocaml/xapi/xapi_pool.mli
@@ -194,3 +194,5 @@
 val audit_log_append : __context:Context.t -> line:string -> unit
 
 val test_archive_target : __context:Context.t -> self:API.ref_pool -> config:API.string_to_string_map -> string
+val enable_local_storage_caching : __context:Context.t -> self:API.ref_pool -> unit
+val disable_local_storage_caching : __context:Context.t -> self:API.ref_pool -> unit
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_sr.ml
--- a/ocaml/xapi/xapi_sr.ml
+++ b/ocaml/xapi/xapi_sr.ml
@@ -232,7 +232,7 @@
       ~physical_size: (-1L)
       ~content_type
       ~_type ~shared ~other_config:[] ~default_vdi_visibility:true
-      ~sm_config ~blobs:[] ~tags:[] in
+      ~sm_config ~blobs:[] ~tags:[] ~local_cache_enabled:false in
 
     update_allowed_operations ~__context ~self:sr_ref;
     (* Return ref of newly created sr *)
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_vdi.ml
--- a/ocaml/xapi/xapi_vdi.ml
+++ b/ocaml/xapi/xapi_vdi.ml
@@ -30,6 +30,9 @@
   let _ref = Ref.string_of _ref' in
   let current_ops = record.Db_actions.vDI_current_operations in
   let vdi_is_sharable = record.Db_actions.vDI_sharable in
+
+  let reset_on_boot = record.Db_actions.vDI_on_boot = `reset in
+
   (* Policy:
      1. any current_operation implies exclusivity; fail everything else
      2. if doing a VM start then assume the sharing check is done elsewhere
@@ -111,6 +114,8 @@
 	  else None	    
 	  | `snapshot when record.Db_actions.vDI_sharable ->
 			Some (Api_errors.vdi_is_sharable, [ _ref ])
+	  | `snapshot when reset_on_boot ->
+		    Some (Api_errors.vdi_on_boot_mode_incompatable_with_operation, [])
       | _ -> None
     )
 
@@ -236,7 +241,8 @@
     ~physical_utilisation:(-1L) ~_type
     ~sharable ~read_only
     ~xenstore_data ~sm_config
-    ~other_config ~storage_lock:false ~location ~managed:true ~missing:false ~parent:Ref.null ~tags:[];
+    ~other_config ~storage_lock:false ~location ~managed:true ~missing:false ~parent:Ref.null ~tags:[]
+	  ~on_boot:`persist ~allow_caching:false;
   ref
 
 let internal_db_introduce ~__context ~uuid ~name_label ~name_description ~sR ~_type ~sharable ~read_only ~other_config ~location ~xenstore_data ~sm_config =
@@ -330,6 +336,9 @@
   Db.VDI.set_sharable ~__context ~self:newvdi ~value:a.Db_actions.vDI_sharable;
   Db.VDI.set_other_config ~__context ~self:newvdi ~value:a.Db_actions.vDI_other_config;
   Db.VDI.set_xenstore_data ~__context ~self:newvdi ~value:a.Db_actions.vDI_xenstore_data;
+  Db.VDI.set_on_boot ~__context ~self:newvdi ~value:a.Db_actions.vDI_on_boot;
+  Db.VDI.set_allow_caching ~__context ~self:newvdi ~value:a.Db_actions.vDI_allow_caching;
+
   (* Record the fact this is a snapshot *)
  
   (*(try Db.VDI.remove_from_other_config ~__context ~self:newvdi ~key:Xapi_globs.snapshot_of with _ -> ());
@@ -421,6 +430,8 @@
     Db.VDI.set_sharable ~__context ~self:newvdi ~value:a.Db_actions.vDI_sharable;
     Db.VDI.set_other_config ~__context ~self:newvdi ~value:a.Db_actions.vDI_other_config;
     Db.VDI.set_xenstore_data ~__context ~self:newvdi ~value:a.Db_actions.vDI_xenstore_data;
+	Db.VDI.set_on_boot ~__context ~self:newvdi ~value:a.Db_actions.vDI_on_boot;
+	Db.VDI.set_allow_caching ~__context ~self:newvdi ~value:a.Db_actions.vDI_allow_caching;
 
     update_allowed_operations ~__context ~self:newvdi;
     newvdi
@@ -467,7 +478,7 @@
   let dst =
     Helpers.call_api_functions ~__context
       (fun rpc session_id ->
-	 Client.VDI.create ~rpc ~session_id
+	let result = Client.VDI.create ~rpc ~session_id
 	   ~name_label:src.API.vDI_name_label
 	   ~name_description:src.API.vDI_name_description
 	   ~sR:sr
@@ -477,9 +488,15 @@
 	   ~read_only:src.API.vDI_read_only
 	   ~other_config:src.API.vDI_other_config
 	   ~xenstore_data:src.API.vDI_xenstore_data
-	   ~sm_config:src.API.vDI_sm_config ~tags:[]
+	   ~sm_config:src.API.vDI_sm_config ~tags:[] in
+    if src.API.vDI_on_boot = `reset then begin
+		try Client.VDI.set_on_boot ~rpc ~session_id ~self:result ~value:(`reset) with _ -> ()
+	end;
+	result
       ) in
   try
+	Db.VDI.set_allow_caching ~__context ~self:dst ~value:src.API.vDI_allow_caching;
+
     Sm_fs_ops.copy_vdi ~__context vdi dst;
 
     Db.VDI.remove_from_current_operations ~__context ~self:dst ~key:task_id;
@@ -514,3 +531,24 @@
 
 let set_physical_utilisation ~__context ~self ~value = 
   Db.VDI.set_physical_utilisation ~__context ~self ~value
+
+let set_on_boot ~__context ~self ~value =
+	let sr = Db.VDI.get_SR ~__context ~self in
+	let ty = Db.SR.get_type ~__context ~self:sr in
+	let caps = Sm.capabilities_of_driver ty in
+	if not (List.mem Smint.Vdi_reset_on_boot caps) then 
+		raise (Api_errors.Server_error(Api_errors.sr_operation_not_supported,[Ref.string_of sr]));
+	Sm.assert_pbd_is_plugged ~__context ~sr;
+	Sm.call_sm_vdi_functions ~__context ~vdi:self
+		(fun srconf srtype sr ->
+			let vdi_info = Sm.vdi_clone srconf srtype [] __context sr self in
+			let uuid = require_uuid vdi_info in
+			let ref = Db.VDI.get_by_uuid ~__context ~uuid in
+			Sm.vdi_delete srconf srtype sr ref);
+	Db.VDI.set_on_boot ~__context ~self ~value
+
+let set_allow_caching ~__context ~self ~value =
+	Db.VDI.set_allow_caching ~__context ~self ~value
+
+	
+		
diff -r e8da99c62c3e -r 243ef81d48f7 ocaml/xapi/xapi_vm_lifecycle.ml
--- a/ocaml/xapi/xapi_vm_lifecycle.ml
+++ b/ocaml/xapi/xapi_vm_lifecycle.ml
@@ -16,6 +16,7 @@
  *)
 
 open Xapi_pv_driver_version
+open Listext
 
 module D = Debug.Debugger(struct let name="xapi" end)
 open D
@@ -202,7 +203,7 @@
 
 (** Take an internal VM record and a proposed operation, return true if the operation
     would be acceptable *)
-let check_operation_error ~vmr ~vmgmr ~ref ~clone_suspended_vm_enabled ~op =
+let check_operation_error ~vmr ~vmgmr ~ref ~clone_suspended_vm_enabled vdis_reset_and_caching ~op =
 	let ref_str = Ref.string_of ref in
 	let power_state = vmr.Db_actions.vM_power_state in
 	let current_ops = vmr.Db_actions.vM_current_operations in
@@ -245,6 +246,18 @@
 		&& op <> `changing_dynamic_range
 	then Some (Api_errors.operation_not_allowed, ["Operations on domain 0 are not allowed"])
 
+	(* Check for an error due to VDI caching/reset behaviour *)
+	else if op = `checkpoint || op = `snapshot || op = `suspend || op = `snapshot_with_quiesce
+ 	then (* If any vdi exists with on_boot=reset, then disallow checkpoint, snapshot, suspend *)
+		if List.exists fst vdis_reset_and_caching 
+		then Some (Api_errors.vdi_on_boot_mode_incompatable_with_operation,[]) 
+		else None
+	else if op = `pool_migrate then
+		(* If any vdi exists with on_boot=reset and caching is enabled, disallow migrate *)
+		if List.exists (fun (reset,caching) -> reset && caching) vdis_reset_and_caching
+		then Some (Api_errors.vdi_on_boot_mode_incompatable_with_operation,[]) 
+		else None
+
 	(* check PV drivers constraints if needed *)
 	else if need_pv_drivers_check ~power_state ~op
 	then check_drivers ~vmr ~vmgmr ~op ~ref
@@ -271,24 +284,32 @@
 	let all = Db.VM.get_record_internal ~__context ~self in
 	let gm = maybe_get_guest_metrics ~__context ~ref:(all.Db_actions.vM_guest_metrics) in
 	let clone_suspended_vm_enabled = Helpers.clone_suspended_vm_enabled ~__context in
-	all, gm, clone_suspended_vm_enabled
+	let vdis_reset_and_caching = List.filter_map (fun vbd -> 
+		try 
+			let vdi = Db.VBD.get_VDI ~__context ~self:vbd in
+	        let sm_config = Db.VDI.get_sm_config ~__context ~self:vdi in
+			Some 
+				((try List.assoc "on_boot" sm_config = "reset" with _ -> false),
+				(try String.lowercase (List.assoc "caching" sm_config) = "true" with _ -> false))
+		with _ -> None) all.Db_actions.vM_VBDs in	
+	all, gm, clone_suspended_vm_enabled, vdis_reset_and_caching
 
 let is_operation_valid ~__context ~self ~op =
-	let all, gm, clone_suspended_vm_enabled = get_info ~__context ~self in
-	match check_operation_error all gm self clone_suspended_vm_enabled op with
+	let all, gm, clone_suspended_vm_enabled, vdis_reset_and_caching = get_info ~__context ~self in
+	match check_operation_error all gm self clone_suspended_vm_enabled vdis_reset_and_caching op with
 	| None   -> true
 	| Some _ -> false
 
 let assert_operation_valid ~__context ~self ~op =
-	let all, gm, clone_suspended_vm_enabled = get_info ~__context ~self in
-	match check_operation_error all gm self clone_suspended_vm_enabled op with
+	let all, gm, clone_suspended_vm_enabled, vdis_reset_and_caching = get_info ~__context ~self in
+	match check_operation_error all gm self clone_suspended_vm_enabled vdis_reset_and_caching op with
 	| None       -> ()
 	| Some (a,b) -> raise (Api_errors.Server_error (a,b))
 
 let update_allowed_operations ~__context ~self =
-	let all, gm, clone_suspended_vm_enabled = get_info ~__context ~self in
+	let all, gm, clone_suspended_vm_enabled, vdis_reset_and_caching = get_info ~__context ~self in
 	let check accu op =
-		match check_operation_error all gm self clone_suspended_vm_enabled op with
+		match check_operation_error all gm self clone_suspended_vm_enabled vdis_reset_and_caching op with
 		| None -> op :: accu
 		| _    -> accu
 	in