Add support for the DISCO_F429ZI target

AlessandroA · AlessandroA · commit a8fc837e9d30 · 2016-12-14T16:14:19.000Z
This commit includes:

* Reduce stack and heap size for all boxes, where necessary and
  possible (printf used in threads is a constraint).
* Use new Thread APIs.
* Add ACLs and configurations for the DISCO_F429ZI target.
diff --git a/source/client_a.cpp b/source/client_a.cpp
@@ -30,19 +30,21 @@ static const UvisorBoxAclItem acl[] = {
 
 static void client_a_main(const void *);
 
-/* Box configuration */
+/* Box configuration
+ * This box has a smaller interrupt and main thread stack sizes as we do nothing
+ * special in them. */
 UVISOR_BOX_NAMESPACE("client_a");
-UVISOR_BOX_HEAPSIZE(8192);
-UVISOR_BOX_MAIN(client_a_main, osPriorityNormal, UVISOR_BOX_STACK_SIZE);
-UVISOR_BOX_CONFIG(secure_number_client_a, acl, UVISOR_BOX_STACK_SIZE, box_context);
+UVISOR_BOX_HEAPSIZE(3072);
+UVISOR_BOX_MAIN(client_a_main, osPriorityNormal, 512);
+UVISOR_BOX_CONFIG(secure_number_client_a, acl, 512, box_context);
 
 static uint32_t get_a_number()
 {
     /* Such random. Many secure. Much bits. Wow. */
     return (uvisor_ctx->number -= 500UL);
 }
 
-static void box_async_runner(const void *)
+static void box_async_runner(void)
 {
     while (1) {
         uvisor_rpc_result_t result;
@@ -67,7 +69,7 @@ static void box_async_runner(const void *)
     }
 }
 
-static void box_sync_runner(const void *)
+static void box_sync_runner(void)
 {
     while (1) {
         /* Synchronous access to the number. */
@@ -87,7 +89,11 @@ static void client_a_main(const void *)
         return;
     }
 
+    /* Create new threads. */
+    /* Note: The stack must be at least 1kB since threads will use printf. */
     srand(uvisor_box_id_self());
-    new Thread(box_sync_runner, NULL);
-    new Thread(box_async_runner, NULL);
+    Thread sync(osPriorityNormal, 1024, NULL);
+    sync.start(box_sync_runner);
+    Thread async(osPriorityNormal, 1024, NULL);
+    async.start(box_async_runner);
 }
diff --git a/source/client_b.cpp b/source/client_b.cpp
@@ -31,11 +31,13 @@ static const UvisorBoxAclItem acl[] = {
 
 static void client_b_main(const void *);
 
-/* Box configuration */
+/* Box configuration
+ * This box has a smaller interrupt stack size as we do nothing special in it.
+ * The main thread uses printf so it needs at least 1kB of stack. */
 UVISOR_BOX_NAMESPACE("client_b");
-UVISOR_BOX_HEAPSIZE(8192);
-UVISOR_BOX_MAIN(client_b_main, osPriorityNormal, UVISOR_BOX_STACK_SIZE);
-UVISOR_BOX_CONFIG(secure_number_client_b, acl, UVISOR_BOX_STACK_SIZE, box_context);
+UVISOR_BOX_HEAPSIZE(3072);
+UVISOR_BOX_MAIN(client_b_main, osPriorityNormal, 1024);
+UVISOR_BOX_CONFIG(secure_number_client_b, acl, 512, box_context);
 
 static uint32_t get_a_number()
 {
diff --git a/source/main-hw.h b/source/main-hw.h
@@ -17,18 +17,15 @@
 #ifndef __UVISOR_HELLOWORLD_MAIN_HW_H__
 #define __UVISOR_HELLOWORLD_MAIN_HW_H__
 
-/* The vector containing the challenge is shared with the push-button ISR, so
- * that it can attempt to access it from an IRQ context. */
+extern DigitalOut led_red;
+extern DigitalOut led_green;
+extern DigitalOut led_blue;
+
+#if defined(TARGET_K64F)
 
 #define LED_ON  false
 #define LED_OFF true
 
-#define MAIN_LED LED_BLUE
-#define HALT_LED LED_RED
-
-#define MAIN_BTN SW2
-#define MAIN_BTN_PUPD PullUp
-
 #define MAIN_ACL(acl_list_name) \
     static const UvisorBoxAclItem acl_list_name[] = {     \
         {SIM,    sizeof(*SIM),    UVISOR_TACLDEF_PERIPH}, \
@@ -48,8 +45,32 @@
         {SPI0,   sizeof(*SPI0),   UVISOR_TACLDEF_PERIPH}, \
     }
 
-extern DigitalOut led_red;
-extern DigitalOut led_green;
-extern DigitalOut led_blue;
+#elif defined(TARGET_DISCO_F429ZI)
+
+#define LED_ON  true
+#define LED_OFF false
+
+#define MAIN_ACL(acl_list_name) \
+    static const UvisorBoxAclItem acl_list_name[] = { \
+        {GPIOA,               sizeof(*GPIOA),  UVISOR_TACLDEF_PERIPH}, \
+        {GPIOB,               sizeof(*GPIOB),  UVISOR_TACLDEF_PERIPH}, \
+        {GPIOC,               sizeof(*GPIOC),  UVISOR_TACLDEF_PERIPH}, \
+        {GPIOD,               sizeof(*GPIOD),  UVISOR_TACLDEF_PERIPH}, \
+        {GPIOE,               sizeof(*GPIOE),  UVISOR_TACLDEF_PERIPH}, \
+        {RTC,                 sizeof(*RTC),    UVISOR_TACLDEF_PERIPH}, \
+        {TIM5,                sizeof(*TIM5),   UVISOR_TACLDEF_PERIPH}, \
+        {USART1,              sizeof(*USART1), UVISOR_TACLDEF_PERIPH}, \
+        {I2C1,                sizeof(*I2C1),   UVISOR_TACLDEF_PERIPH}, \
+        {SPI1,                sizeof(*SPI1),   UVISOR_TACLDEF_PERIPH}, \
+        {RCC,                 sizeof(*RCC),    UVISOR_TACLDEF_PERIPH}, \
+        {FLASH,               sizeof(*FLASH),  UVISOR_TACLDEF_PERIPH}, \
+        {PWR,                 sizeof(*PWR),    UVISOR_TACLDEF_PERIPH}, \
+        {EXTI,                sizeof(*EXTI),   UVISOR_TACLDEF_PERIPH}, \
+        {GPIOG,               sizeof(*GPIOG),  UVISOR_TACLDEF_PERIPH}, \
+        {SYSCFG,              sizeof(*SYSCFG), UVISOR_TACLDEF_PERIPH}, \
+        {(void *) 0x42000000, 0x01000000,      UVISOR_TACLDEF_PERIPH}, /* FIXME */ \
+    }
+
+#endif /* Target-specific settings */
 
 #endif /* __UVISOR_HELLOWORLD_MAIN_HW_H__ */
diff --git a/source/main.cpp b/source/main.cpp
@@ -46,7 +46,7 @@ static uint32_t get_a_number()
     return (number -= 400UL);
 }
 
-static void main_async_runner(const void *)
+static void main_async_runner(void)
 {
     while (1) {
         uvisor_rpc_result_t result;
@@ -71,7 +71,7 @@ static void main_async_runner(const void *)
     }
 }
 
-static void main_sync_runner(const void *)
+static void main_sync_runner(void)
 {
     while (1) {
         /* Synchronous access to the number. */
@@ -90,8 +90,11 @@ int main(void)
     led_green = LED_OFF;
 
     /* Startup a few RPC runners. */
-    Thread sync(main_sync_runner, NULL);
-    Thread async(main_async_runner, NULL);
+    /* Note: The stack must be at least 1kB since threads will use printf. */
+    Thread sync(osPriorityNormal, 1024, NULL);
+    sync.start(main_sync_runner);
+    Thread async(osPriorityNormal, 1024, NULL);
+    async.start(main_async_runner);
 
     size_t count = 0;
 
diff --git a/source/secure_number.cpp b/source/secure_number.cpp
@@ -36,7 +36,7 @@ static int set_number(uint32_t number);
 
 /* Box configuration */
 UVISOR_BOX_NAMESPACE(NULL);
-UVISOR_BOX_HEAPSIZE(8192);
+UVISOR_BOX_HEAPSIZE(3072);
 UVISOR_BOX_MAIN(number_store_main, osPriorityNormal, UVISOR_BOX_STACK_SIZE);
 UVISOR_BOX_CONFIG(box_number_store, acl, UVISOR_BOX_STACK_SIZE, box_context);
 

Original file line number	Diff line number	Diff line change
`@@ -30,19 +30,21 @@ static const UvisorBoxAclItem acl[] = {`
`30`	`30`
`31`	`31`	`static void client_a_main(const void *);`
`32`	`32`
`33`		`-/* Box configuration */`
	`33`	`+/* Box configuration`
	`34`	`+ * This box has a smaller interrupt and main thread stack sizes as we do nothing`
	`35`	`+ * special in them. */`
`34`	`36`	`UVISOR_BOX_NAMESPACE("client_a");`
`35`		`-UVISOR_BOX_HEAPSIZE(8192);`
`36`		`-UVISOR_BOX_MAIN(client_a_main, osPriorityNormal, UVISOR_BOX_STACK_SIZE);`
`37`		`-UVISOR_BOX_CONFIG(secure_number_client_a, acl, UVISOR_BOX_STACK_SIZE, box_context);`
	`37`	`+UVISOR_BOX_HEAPSIZE(3072);`
	`38`	`+UVISOR_BOX_MAIN(client_a_main, osPriorityNormal, 512);`
	`39`	`+UVISOR_BOX_CONFIG(secure_number_client_a, acl, 512, box_context);`
`38`	`40`
`39`	`41`	`static uint32_t get_a_number()`
`40`	`42`	`{`
`41`	`43`	`/* Such random. Many secure. Much bits. Wow. */`
`42`	`44`	`return (uvisor_ctx->number -= 500UL);`
`43`	`45`	`}`
`44`	`46`
`45`		`-static void box_async_runner(const void *)`
	`47`	`+static void box_async_runner(void)`
`46`	`48`	`{`
`47`	`49`	`while (1) {`
`48`	`50`	`uvisor_rpc_result_t result;`
`@@ -67,7 +69,7 @@ static void box_async_runner(const void *)`
`67`	`69`	`}`
`68`	`70`	`}`
`69`	`71`
`70`		`-static void box_sync_runner(const void *)`
	`72`	`+static void box_sync_runner(void)`
`71`	`73`	`{`
`72`	`74`	`while (1) {`
`73`	`75`	`/* Synchronous access to the number. */`
`@@ -87,7 +89,11 @@ static void client_a_main(const void *)`
`87`	`89`	`return;`
`88`	`90`	`}`
`89`	`91`
	`92`	`+ /* Create new threads. */`
	`93`	`+ /* Note: The stack must be at least 1kB since threads will use printf. */`
`90`	`94`	`srand(uvisor_box_id_self());`
`91`		`- new Thread(box_sync_runner, NULL);`
`92`		`- new Thread(box_async_runner, NULL);`
	`95`	`+ Thread sync(osPriorityNormal, 1024, NULL);`
	`96`	`+ sync.start(box_sync_runner);`
	`97`	`+ Thread async(osPriorityNormal, 1024, NULL);`
	`98`	`+ async.start(box_async_runner);`
`93`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ static uint32_t get_a_number()`
`46`	`46`	`return (number -= 400UL);`
`47`	`47`	`}`
`48`	`48`
`49`		`-static void main_async_runner(const void *)`
	`49`	`+static void main_async_runner(void)`
`50`	`50`	`{`
`51`	`51`	`while (1) {`
`52`	`52`	`uvisor_rpc_result_t result;`
`@@ -71,7 +71,7 @@ static void main_async_runner(const void *)`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-static void main_sync_runner(const void *)`
	`74`	`+static void main_sync_runner(void)`
`75`	`75`	`{`
`76`	`76`	`while (1) {`
`77`	`77`	`/* Synchronous access to the number. */`
`@@ -90,8 +90,11 @@ int main(void)`
`90`	`90`	`led_green = LED_OFF;`
`91`	`91`
`92`	`92`	`/* Startup a few RPC runners. */`
`93`		`- Thread sync(main_sync_runner, NULL);`
`94`		`- Thread async(main_async_runner, NULL);`
	`93`	`+ /* Note: The stack must be at least 1kB since threads will use printf. */`
	`94`	`+ Thread sync(osPriorityNormal, 1024, NULL);`
	`95`	`+ sync.start(main_sync_runner);`
	`96`	`+ Thread async(osPriorityNormal, 1024, NULL);`
	`97`	`+ async.start(main_async_runner);`
`95`	`98`
`96`	`99`	`size_t count = 0;`
`97`	`100`