Move architecture-dependent syscall code to arch/cortex-m #1113

bradjc · 2018-07-13T01:38:17Z

Pull Request Overview

This pull request moves all of the code that is cortex-m syscall specific out of process.rs and into the cortex-m crate. This is part of #985.

It does this by:

Making a new SyscallInterface trait that is implemented in the cortex-m crate. Each process has a reference to the implementing struct.
Making a new ProcessType trait that all process types implement (right now we only have one, Process in process.rs). This allows the Process struct to be templated over the SyscallInterface type while the processes array in the Kernel struct keeps an array of ProcessType implementations:
```
Kernel {
    processes: &'static [Option<&'static process::ProcessType>]
}
```
which means the template parameter stays only in the process.rs file and does not spread to all of Tock.

The panic! prints in process.rs are partially commented out because they relied on many architecture-specific fields. Also the SCB_REGISTERS global static variable still exists. Moving those to the cortex-m crate is forthcoming in a different PR.

This is blocked on #1111.

Testing Strategy

Hail on Hail, but needs more.

TODO or Help Wanted

n/a

Documentation Updated

Updated the relevant files in /docs, or no updates are required.

Formatting

Ran make formatall.

bradjc · 2018-07-13T22:54:27Z

I just updated the branch with two fixes:

It now stores yield_pc per process and not per chip (not sure why I got that wrong the first time).
It goes back to APP_FAULT and SYSCALL_FIRED flags that are set in the svc_handler and hardfault_handler functions. When I tried to combine them for some reason the svc_handler would overwrite the variable that the hardfault handler had set, causing app faults to get missed.

alevy

I think this is really pushing us towards having architecture specific implementations of Process, but this is a big improvement for now anyway.

alevy · 2018-07-13T23:35:37Z

kernel/src/syscall.rs

+/// architecture-agnostic manner.
+pub trait SyscallInterface {
+    /// Some architecture-specific struct containing per-process state that must
+    /// be kept while the process is not running.


Maybe add something like: "e.g., CPU registers"

alevy · 2018-07-13T23:37:03Z

kernel/src/syscall.rs

+    ///
+    /// An implementor of this function is free to reset any state that was
+    /// needed to gather this information when this function is called.
+    fn get_context_switch_reason(&self) -> ContextSwitchReason;


Could we get away with getting rid of the self argument in these methods? Can we imagine cases where the implementation would use some state in self?

alevy · 2018-07-13T23:38:35Z

kernel/src/syscall.rs

+    fn get_context_switch_reason(&self) -> ContextSwitchReason;
+
+    /// Get the syscall that the process called.
+    fn get_syscall_number(&self, stack_pointer: *const usize) -> Option<Syscall>;


These methods should probably all be marked unsafe. Fundamentally the expose unsafe interfaces. For example, this one allows the caller to read arbitrary memory.

What about extending the Syscall enum to include arguments in each of the variants (see below) and combining this method with get_syscall_data:

pub enum Syscall { YIELD, SUBSCRIBE((usize, usize, usize, usize)), // these could potentially be even more typed, but for another time COMMAND((usize, usize, usize, usize)), ALLOW((usize, usize, usize, usize)), MEMOP((usize, usize, usize, usize)), } fn get_syscall(&self, stack_pointer: *const usize) -> Option<Syscall>;

Do you have a preference of the ( version versus the { version? (I don't know what rust calls the two versions of enum args.)

alevy · 2018-07-13T23:39:31Z

kernel/src/syscall.rs

+        &self,
+        stack_pointer: *const usize,
+        state: &mut Self::StoredState,
+    ) -> *mut usize;


Maybe this should return a StoredState (perhaps as a tuple along with the stack pointer)?

So the implementation would take a reference and return it?

alevy · 2018-07-13T23:40:57Z

kernel/src/syscall.rs

+        &self,
+        stack_pointer: *const usize,
+        state: &mut Self::StoredState,
+    ) -> *mut usize;


Ditto with return StoredState in a tuple here

alevy · 2018-07-13T23:43:24Z

arch/cortex-m/src/syscall.rs

+// #[allow(private_no_mangle_statics)]
+#[no_mangle]
+#[used]
+pub static mut SYSCALL_FIRED: usize = 0;


does this need to be public?

It's public because it's used in the cortex-m4 crate but defined in the cortex-m crate. I'm not sure if it is strictly required.

alevy · 2018-07-13T23:43:34Z

arch/cortex-m/src/syscall.rs

+/// fault handler was called.
+#[no_mangle]
+#[used]
+pub static mut APP_FAULT: usize = 0;


ditto about being public?

bradjc · 2018-07-14T19:00:50Z

Made some changes, but I'm not sure about removing &self and the StoredState changes.

bradjc · 2018-07-24T17:49:56Z

I added a commit that updates docs, but just now checked the box.

bradjc · 2018-07-26T13:38:56Z

Please review!

alevy · 2018-07-26T16:37:53Z

kernel/src/process.rs

    kernel: &'static Kernel,
+    syscall: &'static S,


Does this actually need to be a reference? If not, we can avoid the annoying static_init! of a zero-sized value in all the board configurations.

Take a look at the commit I just added. It just removes the static_init!() call with no other changes.

brghena

Some comments for you. This looks like a good change overall. I have not tested it on hardware yet.

brghena · 2018-07-30T17:05:32Z

arch/cortex-m4/src/lib.rs

-
-              ldr r0, =APP_FAULT
+            "ldr r0, =APP_FAULT
+              mov r1, #1 /* Fault */


Where are we actually writing to the SYSCALL_FIRED variable?

I'm not sure what you mean.

The code removed here used to write to SYSCALL_FIRED. We still read the variable to see if there was a syscall, but a glance through code left me unsure of where SYSCALL_FIRED is actually written to now.

Ah, same place we were before: https://github.com/tock/tock/pull/1113/files/a6c2fe1c10227dba72dbe63499f90f8d800d559a#diff-3c4f4f49e6d8b6e9ec96c45e8c737637R146

I think marking that a syscall happened in the fault handler was a hack before.

Okay, that makes a lot of sense now. It was just a hack for routing the failure presumably.

brghena · 2018-07-30T17:20:03Z

kernel/src/syscall.rs

+/// Why the process stopped executing and execution returned to the kernel.
+pub enum ContextSwitchReason {
+    /// Process exceeded its timeslice, otherwise catch-all.
+    Other,


Is Other ever used for reasons apart from timeslices expiring? It seems like we should name it for its purpose TimesliceExpired (or similar). If there really are other possible reasons, we should have a catch-all for them apart from timeslices.

I don't know.

+1 for no Other

I agree with replacing Other with something timeslice specific.

From an API design perspective, I think it doesn't cost anything to add specific reasons later, since the implementer of UserspaceKernelBoundary only produces values of this type, and doesn't pattern match. So if some architecture might have some other reason to interrupt the process at some point later, we can add that reason to the enum with no changes needed to previous implementations.

How does a timeslice expiration manifest? Put another way, does the implementer of get_and_reset_context_switch_reason() know that the reason the process stopped was because of the timeslice expiration? This is not clear in the original implementation, and why Other was created.

You're right...

the systick timer fires, which is also in the arch crate. That logic, as you say, is basically split now between the arch crate (handling the systick interrupt and setting a global flag shared with the kernel crate), and the kernel crate reading the global flag and deciding---yep, this process exceeded it's timeslice.

Is there a global flag? Or is it the absence of a global flag being set that indicates it was the systick firing?

brghena · 2018-07-30T17:23:59Z

kernel/src/syscall.rs

+    ///
+    /// An implementor of this function is free to reset any state that was
+    /// needed to gather this information when this function is called.
+    unsafe fn get_context_switch_reason(&self) -> ContextSwitchReason;


I don't know what I want this to be named, but something better. get_context_switch_reason doesn't imply that this function seems to also clean up a switched process and can only be called once. Maybe something like cleanup_switched_process(&self) -> ContextSwitchReason? Especially because, for comparison, get_syscall can be called as many times as you please with no side effects.

What about get_and_reset_context_switch_reason()?

brghena · 2018-07-30T17:27:53Z

kernel/src/grant.rs

-                            Ok(res)
-                        },
-                    )
+                    let ctr_ptr = process.grant_ptr(self.grant_num) as *mut *mut T;


Could you add a comment to the top of this block that clarifies that you're either getting a pointer to the grant, or else allocating it.

brghena · 2018-07-30T17:29:20Z

kernel/src/syscall.rs

+    /// Add a stack frame with the new function call. This function
+    /// is what should be executed when the process is resumed. Returns the new
+    /// stack pointer.
+    unsafe fn replace_function_call(


Does this really replace at all?

Oops this should be fixed. At one point I was trying to merge it with pop_syscall_stack but that ended up being too radical a change.

brghena · 2018-07-30T17:32:19Z

kernel/src/process.rs

@@ -365,8 +458,8 @@ impl Process<'a> {
                let init_fn = app_flash_address
                    .offset(self.header.get_init_function_offset() as isize)
                    as usize;
-                self.yield_pc.set(init_fn);
-                self.psr.set(0x01000000);
+                // self.yield_pc.set(init_fn);


Leftover removal from testing??

brghena · 2018-07-30T17:35:19Z

kernel/src/process.rs

+            12,
+            // self.lr(),
+            // self.pc(),
+            // self.xpsr(),


I see that this will all likely get fixed in #1115. Should that PR and this one be merged? Without those changes, this is a pretty bad regression for Tock debugging.

It absolutely gets fixed.

brghena · 2018-07-30T17:37:21Z

kernel/src/process.rs

+    pub r1: usize,
+    pub r2: usize,
+    pub r3: usize,
+    pub pc: usize,


The concept of a function call accepting arguments as register0, ... is probably not universal. Maybe rename these to argument0, argument1, ... which is their purpose anyways. And pc could be called functionAddress or similar.

While I agree that arugmentN is a clearer name, I actually looked into this the first time this came around -- more on the bend of understanding if 4 arguments was a reasonable expectation as we look at other architectures. Turns out that syscall argument passing via registers is fairly universal, and ARM is actually the odd fellow out with 4 as a lowball number of supported arguments.

So, leave it?

I think argumentN is a better name, my comment was intended to address Branden's "... is probably not universal"

yeah, argumentN is better. a comment could say something like ("These will typically be passed in the first few registers, but it's architecture specific").

bradjc · 2018-08-01T16:49:37Z

The new interfaces are:

The SyscallInterface that handles all of the architecture-specific operations of switching between userspace and the kernel:

https://github.com/tock/tock/blob/3e315ca0628cb06f73ceabc070475a16ec59868e/kernel/src/syscall.rs#L60-L108

and the ProcessType interface that all process implementations must provide (we currently only have one: Process):

https://github.com/tock/tock/blob/3e315ca0628cb06f73ceabc070475a16ec59868e/kernel/src/process.rs#L72-L194

phil-levis

Overall, I like the trait -- it's very clean. My one major concern is with how it signals errors to callers. Since the functions are unsafe we want them to do lots of error checking and then inform a caller when they fail.

phil-levis · 2018-08-01T16:55:13Z

kernel/src/syscall.rs

+        &self,
+        stack_pointer: *const usize,
+        state: &mut Self::StoredState,
+    ) -> *mut usize;


What if there isn't a stack frame? E.g., suppose there is one frame and you call this twice. I'd suggest either returning some kind of a Result or some other way to denote whether the returned stack pointer location is valid.

I don't know? Is there a way for the implementer to know if the pointer is a valid stack pointer?

The existing code trusts that the stack pointer is a valid stack pointer with a stack frame for a given process, although that code is all implemented in process.rs.

I assumed the contract has to be that stack_pointer is valid, and if it isn't then any bugs are the caller's fault.

I think it's OK to assume that the stack pointer passed in is valid (otherwise it's just random memory, e.g., if you accidentally shifted the stack pointer forward one word). I was wondering more about the stack pointer that's returned. I.e., what if the stack frame passed in is the last valid stack frame?

If the only stack frame is the the syscall, then the returned stack pointer is valid, but the stack is empty. Calling pop_syscall_stack() again would be invalid, but I don't think that the implementer can detect that it is invalid.

phil-levis · 2018-08-01T16:55:33Z

kernel/src/syscall.rs

+        stack_pointer: *const usize,
+        callback: process::FunctionCall,
+        state: &Self::StoredState,
+    ) -> *mut usize;


Same here -- what happens if you try to push past the end of the stack?

Is there a way we can check that we're still within the bounds of process memory before writing to the stack pointer? If we aren't, then the response can be to put the process into a fault state.

Right now, pop and push are the same size, so we currently are fine.

But in general, it is possible that push is a larger frame than what was popped, or that pop isn't required, or we want to push multiple frames for some reason.

What about adding an argument remaining_app_stack_memory to the function that would then enable the implementer to detect an overflow?

phil-levis · 2018-08-01T16:56:53Z

kernel/src/syscall.rs

+        &self,
+        stack_pointer: *const usize,
+        state: &mut Self::StoredState,
+    ) -> *mut usize;


Are there failure cases here? If so, then it should be possible to signal so in the return value.

phil-levis · 2018-08-01T17:01:19Z

kernel/src/syscall.rs

+/// This trait must be implemented by the architecture of the chip Tock is
+/// running on. It allows the kernel to manage processes in an
+/// architecture-agnostic manner.
+pub trait SyscallInterface {


I'd suggest a different name. To me, SyscallInterface would imply what currently Driver is. This is really about function calls across the user/kernel boundary. So I might call it UserKernelBoundary or something similar. But I'm find with SyscallInterface if you want to keep it. Although when typed in a sans serif font llI reads funny.

By making a `ProcessType` trait that the `Process` struct implements, the `Process` struct is now templated on a `SyscallInterface` trait which implements the architecture specific operations for the syscall interface. This means that process.rs is now generic with respect to the architecture.

It is not needed.

also add comments

- update names and comments in UserlandKernelBoundary - Allow `push_function_call` to fail if there is no stack space left

bradjc · 2018-08-05T21:39:31Z

Ok numerous things have been updated. Notably:

get_and_reset_context_switch_reason() is gone. The reason the process stopped running is now returned from the switch_to function.
The ProcessType trait functions have been cleaned up a little.
FunctionCall has argumentN instead of rN.
The code that handles processes stopping because of timeslice expiration has been made consistent with syscalls and faults.
Other is no longer a syscall switch reason. Instead arch/ defaults to the process had a Fault if it stops running for an unexpected reason.
Pushing a frame onto the process stack can fail if there is not enough process memory to add the frame.

Here are the two key traits (updated):

tock/kernel/src/syscall.rs

Lines 60 to 117 in 708f2ed

    
           /// This trait must be implemented by the architecture of the chip Tock is 
        
           /// running on. It allows the kernel to manage switching to and from processes 
        
           /// in an architecture-agnostic manner. 
        
           pub trait UserspaceKernelBoundary { 
        
               /// Some architecture-specific struct containing per-process state that must 
        
               /// be kept while the process is not running. For example, for keeping CPU 
        
               /// registers that aren't stored on the stack. 
        
               type StoredState: Default; 
        
               /// Get the syscall that the process called with the appropriate arguments. 
        
               unsafe fn get_syscall(&self, stack_pointer: *const usize) -> Option<Syscall>; 
        
               /// Set the return value the process should see when it begins executing 
        
               /// again after the syscall. 
        
               unsafe fn set_syscall_return_value(&self, stack_pointer: *const usize, return_value: isize); 
        
               /// Remove the last stack frame from the process and return the new stack 
        
               /// pointer location. 
        
               /// 
        
               /// This function assumes that `stack_pointer` is valid and at the end of 
        
               /// the process stack, that there is at least one stack frame on the 
        
               /// stack, and that that frame is the syscall. 
        
               unsafe fn pop_syscall_stack_frame( 
        
                   &self, 
        
                   stack_pointer: *const usize, 
        
                   state: &mut Self::StoredState, 
        
               ) -> *mut usize; 
        
               /// Add a stack frame with the new function call. This function 
        
               /// is what should be executed when the process is resumed. 
        
               /// 
        
               /// `remaining_stack_memory` is the number of bytes below the 
        
               /// `stack_pointer` that is allocated for the process. This value is checked 
        
               /// by the implementer to ensure that there is room for this stack frame 
        
               /// without overflowing the stack. 
        
               /// 
        
               /// Returns `Ok` with the new stack pointer after adding the stack frame if 
        
               /// there was room for the stack frame, and an error with where the stack 
        
               /// would have ended up if the function call had been added otherwise. 
        
               unsafe fn push_function_call( 
        
                   &self, 
        
                   stack_pointer: *const usize, 
        
                   remaining_stack_memory: usize, 
        
                   callback: process::FunctionCall, 
        
                   state: &Self::StoredState, 
        
               ) -> Result<*mut usize, *mut usize>; 
        
               /// Context switch to a specific process. 
        
               /// 
        
               /// This returns a tuple: 
        
               /// - The new stack pointer address of the process. 
        
               /// - Why the process stopped executing and switched back to the kernel. 
        
               unsafe fn switch_to_process( 
        
                   &self, 
        
                   stack_pointer: *const usize, 
        
                   state: &mut Self::StoredState, 
        
               ) -> (*mut usize, ContextSwitchReason); 
        
           }

tock/kernel/src/process.rs

Lines 72 to 197 in 708f2ed

    
           /// This trait is implemented by process structs. 
        
           pub trait ProcessType { 
        
               /// Queue a `Task` for the process. This will be added to a per-process 
        
               /// buffer and executed by the scheduler. `Task`s are some function the app 
        
               /// should run, for example a callback or an IPC call. 
        
               /// 
        
               /// This function returns `true` if the `Task` was successfully enqueued, 
        
               /// and `false` otherwise. This is represented as a simple `bool` because 
        
               /// this is passed to the capsule that tried to schedule the `Task`. 
        
               fn enqueue_task(&self, task: Task) -> bool; 
        
               /// Remove the scheduled operation from the front of the queue and return it 
        
               /// to be handled by the scheduler. 
        
               /// 
        
               /// If there are no `Task`s in the queue for this process this will return 
        
               /// `None`. 
        
               fn dequeue_task(&self) -> Option<Task>; 
        
               /// Returns the current state the process is in. Common states are "running" 
        
               /// or "yielded". 
        
               fn get_state(&self) -> State; 
        
               /// Move this process from the running state to the yielded state. 
        
               fn set_yielded_state(&self); 
        
               /// Put this process in the fault state. This will trigger the 
        
               /// `FaultResponse` for this process to occur. 
        
               unsafe fn set_fault_state(&self); 
        
               /// Get the name of the process. Used for IPC. 
        
               fn get_process_name(&self) -> &[u8]; 
        
               // memop operations 
        
               /// Change the location of the program break. 
        
               fn brk(&self, new_break: *const u8) -> Result<*const u8, Error>; 
        
               /// Change the location of the program break and return the previous break 
        
               /// address. 
        
               fn sbrk(&self, increment: isize) -> Result<*const u8, Error>; 
        
               /// The start address of allocated RAM for this process. 
        
               fn mem_start(&self) -> *const u8; 
        
               /// The first address after the end of the allocated RAM for this process. 
        
               fn mem_end(&self) -> *const u8; 
        
               /// The start address of the flash region allocated for this process. 
        
               fn flash_start(&self) -> *const u8; 
        
               /// The first address after the end of the flash region allocated for this 
        
               /// process. 
        
               fn flash_end(&self) -> *const u8; 
        
               /// The lowest address of the grant region for the process. 
        
               fn kernel_memory_break(&self) -> *const u8; 
        
               /// How many writeable flash regions defined in the TBF header for this 
        
               /// process. 
        
               fn number_writeable_flash_regions(&self) -> usize; 
        
               /// Get the offset from the beginning of flash and the size of the defined 
        
               /// writeable flash region. 
        
               fn get_writeable_flash_region(&self, region_index: usize) -> (u32, u32); 
        
               /// Debug function to update the kernel on where the stack starts for this 
        
               /// process. Processes are not required to call this through the memop 
        
               /// system call, but it aids in debugging the process. 
        
               fn update_stack_start_pointer(&self, stack_pointer: *const u8); 
        
               /// Debug function to update the kernel on where the process heap starts. 
        
               /// Also optional. 
        
               fn update_heap_start_pointer(&self, heap_pointer: *const u8); 
        
               // additional memop like functions 
        
               /// Check if the buffer address and size is contained within the memory 
        
               /// owned by this process. This isn't quite the same as the memory allocated 
        
               /// to the process as this does not include the grant region which is owned 
        
               /// by the kernel. 
        
               fn in_app_owned_memory(&self, buf_start_addr: *const u8, size: usize) -> bool; 
        
               /// Get the first address of process's flash that isn't protected by the 
        
               /// kernel. The protected range of flash contains the TBF header and 
        
               /// potentially other state the kernel is storing on behalf of the process, 
        
               /// and cannot be edited by the process. 
        
               fn flash_non_protected_start(&self) -> *const u8; 
        
               // mpu 
        
               fn setup_mpu(&self, mpu: &mpu::MPU); 
        
               fn add_mpu_region(&self, base: *const u8, size: u32) -> bool; 
        
               // grants 
        
               /// Create new memory in the grant region. 
        
               unsafe fn alloc(&self, size: usize) -> Option<&mut [u8]>; 
        
               unsafe fn free(&self, _: *mut u8); 
        
               /// Get a pointer to the grant pointer for this grant number. 
        
               unsafe fn grant_ptr(&self, grant_num: usize) -> *mut *mut u8; 
        
               // functions for processes that are architecture specific 
        
               /// Get the syscall that the process called. 
        
               unsafe fn get_syscall(&self) -> Option<Syscall>; 
        
               /// Set the return value the process should see when it begins executing 
        
               /// again after the syscall. 
        
               unsafe fn set_syscall_return_value(&self, return_value: isize); 
        
               /// Remove the last stack frame from the process. 
        
               unsafe fn pop_syscall_stack_frame(&self); 
        
               /// Replace the last stack frame with the new function call. This function 
        
               /// is what should be executed when the process is resumed. 
        
               unsafe fn push_function_call(&self, callback: FunctionCall); 
        
               /// Context switch to a specific process. 
        
               unsafe fn switch_to(&self) -> Option<syscall::ContextSwitchReason>; 
        
               unsafe fn fault_str(&self, writer: &mut Write); 
        
               unsafe fn statistics_str(&self, writer: &mut Write); 
        
           }

dverhaert · 2018-08-06T20:29:40Z

I like these changes! Merging this soon would help out a lot for the MPU because we're blocking on the use of trait objects in the processes array.

bradjc · 2018-08-09T16:07:17Z

@tock/core-wg

alevy

I'm in favor of merging this ASAP. It basically doesn't add any new problems with how Process is structured. It uncovers a bunch of existing issues I was always unhappy with (I implemented it, so it's my own damn fault). But assuming this is a milestone for the next release, it seems simpler to merge this and iterate on the Process trait/struct/boundary.

Meanwhile this lets @cmcavity and @dverhaert get on with their MPU trait work.

bradjc · 2018-08-11T14:02:50Z

@niklasad1 @hudson-ayers @phil-levis

bradjc · 2018-08-13T14:30:00Z

@phil-levis @niklasad1

bradjc · 2018-08-13T18:05:53Z

bors r+

1113: Move architecture-dependent syscall code to arch/cortex-m r=bradjc a=bradjc ### Pull Request Overview This pull request moves all of the code that is cortex-m syscall specific out of process.rs and into the cortex-m crate. This is part of #985. It does this by: - Making a new `SyscallInterface` trait that is implemented in the cortex-m crate. Each process has a reference to the implementing struct. - Making a new `ProcessType` trait that all process types implement (right now we only have one, `Process` in process.rs). This allows the `Process` struct to be templated over the `SyscallInterface` type while the `processes` array in the `Kernel` struct keeps an array of `ProcessType` implementations: ```rust Kernel { processes: &'static [Option<&'static process::ProcessType>] } ``` which means the template parameter stays only in the process.rs file and does not spread to all of Tock. The panic! prints in process.rs are partially commented out because they relied on many architecture-specific fields. Also the `SCB_REGISTERS` global static variable still exists. Moving those to the cortex-m crate is forthcoming in a different PR. This is blocked on #1111. ### Testing Strategy Hail on Hail, but needs more. ### TODO or Help Wanted n/a ### Documentation Updated - [x] Updated the relevant files in `/docs`, or no updates are required. ### Formatting - [x] Ran `make formatall`. Co-authored-by: Brad Campbell <bradjc5@gmail.com> Co-authored-by: Pat Pannuto <pat.pannuto@gmail.com>

bors · 2018-08-13T18:15:31Z

Build succeeded

continuous-integration/travis-ci/push

1115: Move architecture-dependent debugging print code to arch/cortex-m r=bradjc a=bradjc ### Pull Request Overview This pull finishes up #1113 by moving the `SCB_REGISTERS` variable to the cortex-m crate and all of the printing code that is architecture specific to the cortex-m crate. I believe this is the last step to having process.rs be architecture agnostic. ~~Blocked on #1113.~~ ### Testing Strategy This pull request was tested by running crash dummy and hail on hail and seeing the panic output. ### TODO or Help Wanted n/a ### Documentation Updated - [x] Updated the relevant files in `/docs`, or no updates are required. ### Formatting - [x] Ran `make formatall`. Co-authored-by: Brad Campbell <bradjc5@gmail.com>

1150: kernel: remove TBF header v1 r=bradjc a=bradjc V1 of the TBF header has been deprecated for a while now, and there is very little chance that any boards still have apps with the old tbf header version. This also removes the PIC options field that is not supported by the kernel, not standardized, and not something we want the kernel to have to support in the future. It is also, as far as we know, unused. ~~Blocked because #1113 _needs_ to be merged.~~ Fixes #1147. ### Testing Strategy This pull request was tested by compiling. ### TODO or Help Wanted n/a ### Documentation Updated - [x] Updated the relevant files in `/docs`, or no updates are required. ### Formatting - [x] Ran `make formatall`. Co-authored-by: Brad Campbell <bradjc5@gmail.com>

bradjc added the P-Significant This is a substancial change that requires review from all core developers. label Jul 13, 2018

bradjc mentioned this pull request Jul 13, 2018

Tracking: Make Tock Architecture Agnostic #985

Closed

9 tasks

bradjc added a commit that referenced this pull request Jul 13, 2018

PR #1113

bfd3023

bradjc force-pushed the arch-agnostic5 branch from 8b22ec7 to 2e3cb15 Compare July 13, 2018 22:52

alevy requested changes Jul 13, 2018

View reviewed changes

alevy previously approved these changes Jul 14, 2018

View reviewed changes

bradjc added a commit that referenced this pull request Jul 14, 2018

PR #1113

bf29613

This was referenced Jul 14, 2018

Move architecture-dependent debugging print code to arch/cortex-m #1115

Merged

Kernel: Move PROCS array to Kernel struct #1111

Merged

ppannuto added the blocked Waiting on something, like a different PR or a dependency. label Jul 18, 2018

bradjc dismissed alevy’s stale review via 5002f59 July 20, 2018 18:54

bradjc force-pushed the arch-agnostic5 branch from 4e8f1c5 to 5002f59 Compare July 20, 2018 18:54

bradjc force-pushed the arch-agnostic5 branch from d73e3dc to d1f9cb9 Compare July 26, 2018 13:33

bradjc removed the blocked Waiting on something, like a different PR or a dependency. label Jul 26, 2018

alevy reviewed Jul 26, 2018

View reviewed changes

brghena mentioned this pull request Jul 30, 2018

Kernel: add comments #1121

Merged

2 tasks

brghena reviewed Jul 30, 2018

View reviewed changes

phil-levis requested changes Aug 1, 2018

View reviewed changes

bradjc added 6 commits August 1, 2018 21:35

boards: update to new Process type

7237506

doc: update docs about cortex-m specifics

3e024c5

boards: syscallinterface: remove static_init

237b574

It is not needed.

kernel: improve function names

4f57173

also add comments

kernel: improve names and return values

285543a

- update names and comments in UserlandKernelBoundary - Allow `push_function_call` to fail if there is no stack space left

kernel: remove unsafe from set_fault_state

1a4b3bc

bradjc mentioned this pull request Aug 7, 2018

Package name can potentially access all flash and ram #1147

Closed

brghena previously approved these changes Aug 9, 2018

View reviewed changes

arch: clarify APP_HARD_FAULT a bit

841d531

ppannuto mentioned this pull request Aug 9, 2018

Race condition in context switching #1149

Closed

ppannuto dismissed brghena’s stale review via 841d531 August 9, 2018 19:16

ppannuto approved these changes Aug 9, 2018

View reviewed changes

alevy approved these changes Aug 10, 2018

View reviewed changes

brghena approved these changes Aug 10, 2018

View reviewed changes

hudson-ayers self-assigned this Aug 11, 2018

hudson-ayers self-requested a review August 11, 2018 17:51

hudson-ayers approved these changes Aug 11, 2018

View reviewed changes

bradjc unassigned hudson-ayers Aug 11, 2018

bradjc mentioned this pull request Aug 12, 2018

kernel: remove TBF header v1 #1150

Merged

2 tasks

phil-levis approved these changes Aug 13, 2018

View reviewed changes

bors bot merged commit 841d531 into master Aug 13, 2018

bors bot deleted the arch-agnostic5 branch August 13, 2018 18:15

hudson-ayers mentioned this pull request Aug 22, 2018

IP Userland #1134

Merged

2 tasks

cmcavity mentioned this pull request Aug 22, 2018

Process faults #1160

Closed

Move architecture-dependent syscall code to arch/cortex-m #1113

Move architecture-dependent syscall code to arch/cortex-m #1113

Conversation

bradjc commented Jul 13, 2018 • edited Loading

Pull Request Overview

Testing Strategy

TODO or Help Wanted

Documentation Updated

Formatting

bradjc commented Jul 13, 2018

alevy left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

bradjc commented Jul 14, 2018

bradjc commented Jul 24, 2018

bradjc commented Jul 26, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

brghena left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

bradjc commented Aug 1, 2018

phil-levis left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

phil-levis Aug 1, 2018 • edited Loading

Choose a reason for hiding this comment

bradjc commented Aug 5, 2018

dverhaert commented Aug 6, 2018

bradjc commented Aug 9, 2018

alevy left a comment

Choose a reason for hiding this comment

bradjc commented Aug 11, 2018

bradjc commented Aug 13, 2018

bradjc commented Aug 13, 2018

bors bot commented Aug 13, 2018

Build succeeded

bradjc commented Jul 13, 2018 •

edited

Loading

phil-levis Aug 1, 2018 •

edited

Loading