@@ -31,6 +31,7 @@ pub mod common; // pub to disable dead_code warning
3131use crate :: common:: {
3232 new_rust_sandbox, new_rust_uninit_sandbox, with_all_sandboxes, with_c_sandbox,
3333 with_c_uninit_sandbox, with_rust_sandbox, with_rust_sandbox_cfg, with_rust_uninit_sandbox,
34+ with_rust_uninit_sandbox_cfg,
3435} ;
3536
3637// A host function cannot be interrupted, but we can at least make sure after requesting to interrupt a host call,
@@ -801,6 +802,167 @@ fn log_test_messages(levelfilter: Option<tracing_core::LevelFilter>) {
801802 }
802803}
803804
805+ // The following tests depend on a global SimpleLogger or TracingSubscriber and
806+ // cannot run in parallel with other tests. They are marked #[ignore] and run
807+ // sequentially via `just test-isolated`.
808+
809+ #[ test]
810+ #[ ignore]
811+ fn virtq_log_delivery ( ) {
812+ use hyperlight_testing:: simplelogger:: { LOGGER , SimpleLogger } ;
813+
814+ SimpleLogger :: initialize_test_logger ( ) ;
815+ LOGGER . clear_log_calls ( ) ;
816+
817+ with_rust_uninit_sandbox ( |mut sbox| {
818+ sbox. set_max_guest_log_level ( tracing_core:: LevelFilter :: TRACE ) ;
819+ let mut sandbox = sbox. evolve ( ) . unwrap ( ) ;
820+
821+ sandbox
822+ . call :: < ( ) > ( "LogMessage" , ( "virtq log test message" . to_string ( ) , 3_i32 ) )
823+ . unwrap ( ) ;
824+
825+ let count = LOGGER . num_log_calls ( ) ;
826+ let mut found = false ;
827+ for i in 0 ..count {
828+ if let Some ( call) = LOGGER . get_log_call ( i)
829+ && call. target == "hyperlight_guest"
830+ && call. args . contains ( "virtq log test" )
831+ {
832+ found = true ;
833+ break ;
834+ }
835+ }
836+ assert ! ( found, "expected 'virtq log test' message from guest" ) ;
837+ LOGGER . clear_log_calls ( ) ;
838+ } ) ;
839+ }
840+
841+ #[ test]
842+ #[ ignore]
843+ fn virtq_log_backpressure ( ) {
844+ use hyperlight_testing:: simplelogger:: { LOGGER , SimpleLogger } ;
845+
846+ SimpleLogger :: initialize_test_logger ( ) ;
847+ LOGGER . clear_log_calls ( ) ;
848+
849+ let mut cfg = SandboxConfiguration :: default ( ) ;
850+ cfg. set_g2h_pool_pages ( 2 ) ;
851+
852+ with_rust_uninit_sandbox_cfg ( cfg, |mut sbox| {
853+ sbox. set_max_guest_log_level ( tracing_core:: LevelFilter :: INFO ) ;
854+ let mut sandbox = sbox. evolve ( ) . unwrap ( ) ;
855+
856+ sandbox. call :: < ( ) > ( "LogMessageN" , 50_i32 ) . unwrap ( ) ;
857+
858+ let res: i32 = sandbox
859+ . call ( "ThisIsNotARealFunctionButTheNameIsImportant" , ( ) )
860+ . unwrap ( ) ;
861+ assert_eq ! ( res, 99 ) ;
862+
863+ let guest_count = ( 0 ..LOGGER . num_log_calls ( ) )
864+ . filter_map ( |i| LOGGER . get_log_call ( i) )
865+ . filter ( |c| c. target == "hyperlight_guest" && c. args . contains ( "log entry" ) )
866+ . count ( ) ;
867+ assert_eq ! ( guest_count, 50 , "expected 50 guest logs, got {guest_count}" ) ;
868+ LOGGER . clear_log_calls ( ) ;
869+ } ) ;
870+ }
871+
872+ #[ test]
873+ #[ ignore]
874+ fn virtq_log_backpressure_repeated ( ) {
875+ let mut cfg = SandboxConfiguration :: default ( ) ;
876+ cfg. set_g2h_pool_pages ( 2 ) ;
877+
878+ with_rust_sandbox_cfg ( cfg, |mut sandbox| {
879+ for _ in 0 ..5 {
880+ sandbox. call :: < ( ) > ( "LogMessageN" , 30_i32 ) . unwrap ( ) ;
881+ }
882+ } ) ;
883+ }
884+
885+ #[ test]
886+ #[ ignore]
887+ fn virtq_backpressure_small_ring ( ) {
888+ use hyperlight_testing:: simplelogger:: { LOGGER , SimpleLogger } ;
889+
890+ SimpleLogger :: initialize_test_logger ( ) ;
891+ LOGGER . clear_log_calls ( ) ;
892+
893+ let mut cfg = SandboxConfiguration :: default ( ) ;
894+ cfg. set_g2h_queue_depth ( 4 ) ;
895+
896+ with_rust_uninit_sandbox_cfg ( cfg, |mut sbox| {
897+ sbox. set_max_guest_log_level ( tracing_core:: LevelFilter :: INFO ) ;
898+ let mut sandbox = sbox. evolve ( ) . unwrap ( ) ;
899+
900+ sandbox. call :: < ( ) > ( "LogMessageN" , 20_i32 ) . unwrap ( ) ;
901+
902+ let guest_count = ( 0 ..LOGGER . num_log_calls ( ) )
903+ . filter_map ( |i| LOGGER . get_log_call ( i) )
904+ . filter ( |c| c. target == "hyperlight_guest" && c. args . contains ( "log entry" ) )
905+ . count ( ) ;
906+ assert_eq ! ( guest_count, 20 , "expected 20 guest logs, got {guest_count}" ) ;
907+ LOGGER . clear_log_calls ( ) ;
908+ } ) ;
909+ }
910+
911+ #[ test]
912+ #[ ignore]
913+ fn virtq_log_tracing_delivery ( ) {
914+ use hyperlight_testing:: tracing_subscriber:: TracingSubscriber ;
915+
916+ let subscriber = TracingSubscriber :: new ( tracing:: Level :: TRACE ) ;
917+
918+ tracing:: subscriber:: with_default ( subscriber. clone ( ) , || {
919+ with_rust_uninit_sandbox ( |mut sbox| {
920+ sbox. set_max_guest_log_level ( tracing_core:: LevelFilter :: INFO ) ;
921+ let mut sandbox = sbox. evolve ( ) . unwrap ( ) ;
922+
923+ subscriber. clear ( ) ;
924+
925+ sandbox
926+ . call :: < ( ) > ( "LogMessage" , ( "tracing delivery test" . to_string ( ) , 3_i32 ) )
927+ . unwrap ( ) ;
928+
929+ let events = subscriber. get_events ( ) ;
930+ assert ! (
931+ !events. is_empty( ) ,
932+ "expected tracing events after guest log call, got none"
933+ ) ;
934+ } ) ;
935+ } ) ;
936+ }
937+
938+ #[ test]
939+ #[ ignore]
940+ fn virtq_log_tracing_levels ( ) {
941+ use hyperlight_testing:: tracing_subscriber:: TracingSubscriber ;
942+
943+ let subscriber = TracingSubscriber :: new ( tracing:: Level :: TRACE ) ;
944+
945+ tracing:: subscriber:: with_default ( subscriber. clone ( ) , || {
946+ with_rust_uninit_sandbox ( |mut sbox| {
947+ sbox. set_max_guest_log_level ( tracing_core:: LevelFilter :: TRACE ) ;
948+ let mut sandbox = sbox. evolve ( ) . unwrap ( ) ;
949+
950+ for level in [ 1_i32 , 2 , 3 , 4 , 5 ] {
951+ subscriber. clear ( ) ;
952+ let msg = format ! ( "level-test-{}" , level) ;
953+ sandbox. call :: < ( ) > ( "LogMessage" , ( msg, level) ) . unwrap ( ) ;
954+
955+ let events = subscriber. get_events ( ) ;
956+ assert ! (
957+ !events. is_empty( ) ,
958+ "expected tracing events for guest log level {}" ,
959+ level
960+ ) ;
961+ }
962+ } ) ;
963+ } ) ;
964+ }
965+
804966/// Tests whether host is able to return Bool as return type
805967/// or not
806968#[ test]
0 commit comments