|
1. 下面的代码看的不是很明白,百为stm32开发板光盘\测试程序\CortexM3\Mode_Privilege\project,堆是程序员分配和使用的,栈是编译器指定的,存放函数参数,临时变量。 - #include "stm32f10x_lib.h"+ [( s& t7 {; }* J. M& X; ?$ Y' j
- #define SP_PROCESS_SIZE 0x200 /* Process stack size */' d0 }# D: b$ n- b+ D0 _( P' h; V
- #define SP_PROCESS 0x02 /* Process stack */" { ]" ^! N5 z8 O
- #define SP_MAIN 0x00 /* Main stack */3 p1 k8 w1 V" v9 A
- #define THREAD_MODE_PRIVILEGED 0x00 /* Thread mode has privileged access */& l7 N# c: |: M4 \7 ~: u
- #define THREAD_MODE_UNPRIVILEGED 0x01 /* Thread mode has unprivileged access */4 \: U0 P5 w7 V" f; R/ v; i. h/ g
. H7 [5 ^) e4 R4 d/ g- ErrorStatus HSEStartUpStatus;( \' J4 g- a1 Z4 S
- vu8 PSPMemAlloc[SP_PROCESS_SIZE];
8 j8 Y, C4 N+ ~' {; e - vu32 Index = 0, PSPValue = 0, CurrentStack = 0, ThreadMode = 0;
E s' S0 x' e; v; t - ( G; y7 U9 w! ]1 Q6 L
- /* Private function prototypes -----------------------------------------------*/; L5 ~ k9 ?" r
- void RCC_Configuration(void);, e4 t2 C W" W; V, j( b
- void NVIC_Configuration(void);8 q: g: L& Q( Z7 J$ a$ Q
; s& `) U9 q6 d& G- ; m" ~( v* s6 b
- int main(void)! Q: b5 e# d% o5 {
- {- d# x: [* k+ R2 D4 c4 y& Q. S
- #ifdef DEBUG
/ H4 j- u/ {' y% E - debug();0 r6 p% b, v. _4 |0 \1 `9 \
- #endif
$ m9 e; d, d4 C' @! Q% c) ]0 m; N
% I0 Q( r( |9 ?1 |$ M7 j7 {- //时钟配置* q) N/ b7 _% ~, d7 Z% U" c
- RCC_Configuration();; |3 `, P' \5 g( B5 u; f' W" D- W
- . }3 y6 I% k+ t6 v! o/ d
- //中断向量表配置 [) `0 S: F+ X% u
- NVIC_Configuration();9 |) O+ l9 ?/ g" f4 b
% `0 Z0 R5 _* i- //STM32有一个主堆栈指针MSP,和线程堆栈指针PSP,把进程堆栈指针指向这个数组的高地址,因为堆栈指针是向下增长的9 R j) N- l" K" {* P$ @2 ]: W1 J
- /* Switch Thread mode Stack from Main to Process -----------------------------*/
8 l3 A7 V; D. _: X) ] - /* Initialize memory reserved for Process Stack */
/ q2 w- r% N; q9 }5 Z/ U - for(Index = 0; Index < SP_PROCESS_SIZE; Index++) E1 y0 F8 `) f
- {
1 ]: m& |, q; T - PSPMemAlloc[Index] = 0x00;5 `/ K( A: q+ _9 p1 E4 j
- }
4 X1 H& \" g- ^$ f6 \ - //系统上电,是在线程模式,特权级别下,所以可以修改CONTROL寄存器,这个寄存器选择特权级和用户级,还有系统选哪个堆栈指针8 b0 I- ?4 C Q6 }
- /* Set Process stack value */
4 I* D/ D. E" x; z. Z+ i - __MSR_PSP((u32)PSPMemAlloc + SP_PROCESS_SIZE);- D+ x0 f4 {! V! x8 e
- //选择线程堆栈作为线程模式的堆栈,有点绕口
3 z! e# h. w z/ n - /* Select Process Stack as Thread mode Stack */3 U3 G) b6 h0 r' i# d: b3 r' x! C3 y5 q
- __MSR_CONTROL(SP_PROCESS);" z+ `- V6 d+ _$ h0 H
- 0 t% |8 S9 b+ n6 n
- /* Get the Thread mode stack used */
/ @% s/ u# Z# w( Q. v, s9 y - if((__MRS_CONTROL() & 0x02) == SP_MAIN)" [( F# z2 t" n* Z2 v6 n
- {3 n. s% o; J* m1 p0 n8 K) I0 u4 z
- /* Main stack is used as the current stack */9 i4 X+ N( @& }
- CurrentStack = SP_MAIN;
6 ~( [9 ?1 D' e" i - }1 Y+ }- a {$ C* ^
- else. i; I" o+ o! F; L
- {/ x# M: j% h+ L1 ]" F; S: @
- /* Process stack is used as the current stack */
k% B" _& x2 U; G- p9 D, T9 O. R0 { - CurrentStack = SP_PROCESS;
; x1 Q I& b* ~3 ]% ?+ C
9 h! d0 I1 G: |/ j( P- /* Get process stack pointer value */: d8 n3 l" |; ~: u4 |- F
- PSPValue = __MRS_PSP();
" l* B q* p4 F/ S - }6 {: ~1 k6 M) S9 z2 a: Q
- ( a) w+ V& D/ o+ ?7 m* V. B0 r
- /* Switch Thread mode from privileged to unprivileged ------------------------*//切换线程模式到非特权
% g( ~. I) O% E' l2 W$ ? - /* Thread mode has unprivileged access */
0 s# v2 T! W) V/ R, v0 }8 s- B/ ? - __MSR_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS);
1 X$ u% M- F1 r& s% } - /* Unprivileged access mainly affect ability to:
; B3 `& t& F" }$ B, H& o" F& q+ D - - Use or not use certain instructions such as MSR fields6 i! T5 j$ O9 M; U4 O: ]& Q$ F) ]
- - Access System Control Space (SCS) registers such as NVIC and SysTick */& u/ q& V$ W% S7 r$ {
- : F, y5 C2 c" N) V4 p7 d
- /* Check Thread mode privilege status */ //检查当前是特权还是用户级别. ~" |' d/ J4 z7 B: J( F4 `
- if((__MRS_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED)' Y. F3 T) k6 ]( Y# D
- {
/ L) J& N2 M2 S6 l8 T$ m6 `" |( X2 g - /* Thread mode has privileged access */( i* O* ]9 w: [8 v0 Z( k
- ThreadMode = THREAD_MODE_PRIVILEGED;
- x$ k; L6 n# m; w4 @- X7 e - } a9 k# D4 i" L
- else
' `$ Q8 l. z- W) y( \8 v - {1 j5 E! ?1 y8 v" f! g l
- /* Thread mode has unprivileged access*/8 T. z' X7 u+ v: I
- ThreadMode = THREAD_MODE_UNPRIVILEGED; //应该是用户级别
8 f6 ]' W4 | B6 }, z0 x8 | - }$ _! e7 c8 }- N2 C9 d+ j6 \& K2 L
- 0 e/ g; q( e" X- O
- /* Switch back Thread mode from unprivileged to privileged -------------------*/ //切换到特权模式6 [- J7 l6 x; w
- /* Try to switch back Thread mode to privileged (Not possible, this can be
& b( J0 Q+ _ e7 }/ }) E+ S& _( S - done only in Handler mode) */- d4 b& H; z9 V, y1 j
- __MSR_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS);1 e; S3 t, x s% d$ o
5 W6 Y* i3 m6 q1 ^- /* Generate a system call exception, and in the ISR switch back Thread mode
{1 T2 {$ O! M B; s' l, D( U4 C6 I - to privileged */* T% l# z6 X* i! o9 W
- __SVC(); //产生中断,进入handler模式,特权级别# ^2 ^9 F. A, Q( D' A" z# _, o* I) }
0 j" E1 \) ]8 K6 O3 L# k4 A9 M; K2 V- /* Check Thread mode privilege status */
: X0 Q4 U& P- m% F% v9 g: C - if((__MRS_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED)
% H9 t0 O+ ]3 ^ - {
/ g8 z t. g! h. H* i* B7 H% ? - /* Thread mode has privileged access */
; q% D7 r7 m" @ - ThreadMode = THREAD_MODE_PRIVILEGED; //应该是特权级别
& c$ ^7 j" k3 h L( L! B+ Y - }
- b, e, M; l# @0 j1 a& J+ n4 q - else1 A, t( C; ]5 q4 q( K
- {' x$ r* y. J0 P9 q8 c3 N3 O
- /* Thread mode has unprivileged access*/5 n9 |% m, g$ @% {# i1 ~
- ThreadMode = THREAD_MODE_UNPRIVILEGED;
5 o8 o% K5 ^# \: E$ S# ? - }. n: o g% z, L4 m
$ B% ]7 s/ w& P0 r+ }; y- while (1)
8 v# z0 P3 K, \9 N8 ` - {* f, B# K& s4 ?$ H( O' m8 K
- }
$ n5 R- {( `( ~! t" q' P* B1 v - }
复制代码 ; ^1 b5 x2 V6 {& l6 O
2. 暂时不明白这个程序什么用途,只是学习的过程中遇到了,拿出来研究一下。 Cortex-M3处理器支持两种处理器的操作模式,还支持两级特权操作。
, M# J. Z# M4 s3 \: H9 U两种操作模式分别为:处理者模式(handler mode)和线程模式(thread mode)。引入两个模式的本意,是用于区别普通应用程序的代码和异常服务例程的代码——包括中断服务例程的代码。Cortex-M3的另一个侧面则是特权的分级——特权级和用户级。这可以提供一种存储器访问的保护机制,使得普通的用户程序代码不能意外地,甚至是恶意地执行涉及到要害的操作。处理器支持两种特权级,这也是一个基本的安全模型。 3. 在CM3运行主应用程序时(线程模式),既可以使用特权级,也可以使用用户级;但是异常服务例程必须在特权级下执行。复位后,处理器默认进入线程模式,特权极访问。在特权级下,程序可以访问所有范围的存储器(如果有MPU,还要在MPU规定的禁地之外),并且可以执行所有指令。 在特权级下的程序可以为所欲为,但也可能会把自己给玩进去——切换到用户级。一旦进入用户级,再想回来就得走“法律程序”了——用户级的程序不能简简单单地试图改写CONTROL寄存器就回到特权级,它必须先“申诉”:执行一条系统调用指令(SVC)。这会触发SVC异常,然后由异常服务例程(通常是操作系统的一部分)接管,如果批准了进入,则异常服务例程修改CONTROL寄存器,才能在用户级的线程模式下重新进入特权级。事实上,从用户级到特权级的唯一途径就是异常:如果在程序执行过程中触发了一个异常,处理器总是先切换入特权级,并且在异常服务例程执行完毕退出时 4.如果根据下表和上面解释重新看代码的话,应该很清楚了。
4 l# `1 l3 E8 ?* {* P
4 _3 S) |3 R; ~0 [) f! A! P
5. 在看下CONTROL寄存器介绍 + q. ] A$ f `- a2 f# d
/ W/ `8 }1 Q& K0 V
6. 如此一来,基本搞明白了。
& r! y1 R$ Z' o- _, y |