Make most of kernel crate-visible only, rather than public.

kernel/src/callback.rs

@@ -14,11 +14,11 @@ pub struct AppId {
 const KERNEL_APPID_BOUNDARY: usize = 100;
 
 impl AppId {
-    pub(crate) fn new(idx: usize) -> AppId {
+    crate fn new(idx: usize) -> AppId {
         AppId { idx: idx }
     }
 
-    pub(crate) const fn kernel_new(idx: usize) -> AppId {
+    crate const fn kernel_new(idx: usize) -> AppId {
         AppId { idx: idx }
     }
 
@@ -40,7 +40,7 @@ impl AppId {
 }
 
 #[derive(Clone, Copy, Debug)]
-pub enum RustOrRawFnPtr {
+crate enum RustOrRawFnPtr {
     Raw {
         ptr: NonNull<*mut ()>,
     },
@@ -58,18 +58,15 @@ pub struct Callback {
 }
 
 impl Callback {
-    pub(crate) fn new(appid: AppId, appdata: usize, fn_ptr: NonNull<*mut ()>) -> Callback {
+    crate fn new(appid: AppId, appdata: usize, fn_ptr: NonNull<*mut ()>) -> Callback {
         Callback {
             app_id: appid,
             appdata: appdata,
             fn_ptr: RustOrRawFnPtr::Raw { ptr: fn_ptr },
         }
     }
 
-    pub(crate) const fn kernel_new(
-        appid: AppId,
-        fn_ptr: fn(usize, usize, usize, usize),
-    ) -> Callback {
+    crate const fn kernel_new(appid: AppId, fn_ptr: fn(usize, usize, usize, usize)) -> Callback {
         Callback {
             app_id: appid,
             appdata: 0,

kernel/src/common/deferred_call.rs

@@ -23,21 +23,21 @@ struct AtomicUsize {
 }
 
 impl AtomicUsize {
-    pub const fn new(v: usize) -> AtomicUsize {
+    crate const fn new(v: usize) -> AtomicUsize {
         AtomicUsize {
             v: UnsafeCell::new(v),
         }
     }
 
-    pub fn load_relaxed(&self) -> usize {
+    crate fn load_relaxed(&self) -> usize {
         unsafe { intrinsics::atomic_load_relaxed(self.v.get()) }
     }
 
-    pub fn store_relaxed(&self, val: usize) {
+    crate fn store_relaxed(&self, val: usize) {
         unsafe { intrinsics::atomic_store_relaxed(self.v.get(), val) }
     }
 
-    pub fn fetch_or_relaxed(&self, val: usize) {
+    crate fn fetch_or_relaxed(&self, val: usize) {
         unsafe { intrinsics::atomic_store_relaxed(self.v.get(), self.load_relaxed() | val) }
     }
 }

kernel/src/grant.rs

@@ -8,7 +8,7 @@ use core::ptr::{read_volatile, write_volatile, Unique};
 use debug;
 use process::{self, Error};
 
-pub static mut CONTAINER_COUNTER: usize = 0;
+crate static mut CONTAINER_COUNTER: usize = 0;
 
 pub struct Grant<T: Default> {
     grant_num: usize,
@@ -26,7 +26,7 @@ pub struct AppliedGrant<T> {
 /// stored in a processes array, and finding apps is a matter of iterating that
 /// array. Kernel "apps" currently (June 2018) have no such structure, so
 /// finding them is a bit more ad-hoc.
-pub unsafe fn kernel_grant_for<T>(app_id: usize) -> *mut T {
+crate unsafe fn kernel_grant_for<T>(app_id: usize) -> *mut T {
     match app_id {
         debug::APPID_IDX => debug::get_grant(),
         _ => panic!("lookup for invalid kernel grant {}", app_id),

kernel/src/lib.rs

@@ -8,7 +8,8 @@
 
 #![feature(asm, core_intrinsics, unique, ptr_internals, const_fn)]
 #![feature(use_extern_macros, try_from, used)]
-#![feature(in_band_lifetimes)]
+#![feature(in_band_lifetimes, crate_visibility_modifier)]
+#![warn(unreachable_pub)]
 #![no_std]
 
 extern crate tock_cells;

kernel/src/mem.rs

@@ -62,7 +62,7 @@ pub struct AppSlice<L, T> {
 }
 
 impl<L, T> AppSlice<L, T> {
-    pub(crate) fn new(ptr: *mut T, len: usize, appid: AppId) -> AppSlice<L, T> {
+    crate fn new(ptr: *mut T, len: usize, appid: AppId) -> AppSlice<L, T> {
         unsafe {
             AppSlice {
                 ptr: AppPtr::new(ptr, appid),
@@ -79,7 +79,7 @@ impl<L, T> AppSlice<L, T> {
         unsafe { self.ptr.ptr.as_ref() as *const T }
     }
 
-    pub unsafe fn expose_to(&self, appid: AppId) -> bool {
+    crate unsafe fn expose_to(&self, appid: AppId) -> bool {
         let ps = &mut process::PROCS;
         if appid.idx() != self.ptr.process.idx() && ps.len() > appid.idx() {
             ps[appid.idx()]

kernel/src/memop.rs

@@ -36,7 +36,7 @@ use returncode::ReturnCode;
 ///   where the app has put the start of its heap. This is not strictly
 ///   necessary for correct operation, but allows for better debugging if the
 ///   app crashes.
-pub fn memop(process: &mut Process) -> ReturnCode {
+crate fn memop(process: &mut Process) -> ReturnCode {
     let op_type = process.r0();
     let r1 = process.r1();
 

kernel/src/platform/mod.rs

@@ -3,7 +3,7 @@
 use driver::Driver;
 
 pub mod mpu;
-pub mod systick;
+crate mod systick;
 
 /// Interface for individual boards.
 pub trait Platform {