protect access to a task by the closure irqsave

Author: stlankes

src/scheduler/scheduler.rs

@@ -5,8 +5,8 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 
-use crate::arch::irq::{irq_nested_disable, irq_nested_enable};
 use crate::arch::switch;
+use crate::collections::irqsave;
 use crate::consts::*;
 use crate::errno::*;
 use crate::logging::*;
@@ -61,37 +61,45 @@ impl Scheduler {
 	}
 
 	pub fn spawn(&mut self, func: extern "C" fn(), prio: TaskPriority) -> Result<TaskId> {
-		let prio_number = prio.into() as usize;
+		let closure = || {
+			let prio_number = prio.into() as usize;
 
-		if prio_number >= NO_PRIORITIES {
-			return Err(Error::BadPriority);
-		}
+			if prio_number >= NO_PRIORITIES {
+				return Err(Error::BadPriority);
+			}
+
+			// Create the new task.
+			let tid = self.get_tid();
+			let task = Rc::new(RefCell::new(Task::new(tid, TaskStatus::TaskReady, prio)));
 
-		// Create the new task.
-		let tid = self.get_tid();
-		let task = Rc::new(RefCell::new(Task::new(tid, TaskStatus::TaskReady, prio)));
+			task.borrow_mut().create_stack_frame(func);
 
-		task.borrow_mut().create_stack_frame(func);
+			// Add it to the task lists.
+			self.ready_queue.lock().push(task.clone());
+			self.tasks.lock().insert(tid, task);
+			NO_TASKS.fetch_add(1, Ordering::SeqCst);
 
-		// Add it to the task lists.
-		self.ready_queue.lock().push(task.clone());
-		self.tasks.lock().insert(tid, task);
-		NO_TASKS.fetch_add(1, Ordering::SeqCst);
+			info!("Creating task {}", tid);
 
-		info!("Creating task {}", tid);
+			Ok(tid)
+		};
 
-		Ok(tid)
+		irqsave(closure)
 	}
 
 	pub fn exit(&mut self) -> ! {
-		if self.current_task.borrow().status != TaskStatus::TaskIdle {
-			info!("finish task with id {}", self.current_task.borrow().id);
-			self.current_task.borrow_mut().status = TaskStatus::TaskFinished;
-			// update the number of tasks
-			NO_TASKS.fetch_sub(1, Ordering::SeqCst);
-		} else {
-			panic!("unable to terminate idle task");
-		}
+		let closure = || {
+			if self.current_task.borrow().status != TaskStatus::TaskIdle {
+				info!("finish task with id {}", self.current_task.borrow().id);
+				self.current_task.borrow_mut().status = TaskStatus::TaskFinished;
+				// update the number of tasks
+				NO_TASKS.fetch_sub(1, Ordering::SeqCst);
+			} else {
+				panic!("unable to terminate idle task");
+			}
+		};
+
+		irqsave(closure);
 
 		self.reschedule();
 
@@ -100,14 +108,18 @@ impl Scheduler {
 	}
 
 	pub fn abort(&mut self) -> ! {
-		if self.current_task.borrow().status != TaskStatus::TaskIdle {
-			info!("abort task with id {}", self.current_task.borrow().id);
-			self.current_task.borrow_mut().status = TaskStatus::TaskFinished;
-			// update the number of tasks
-			NO_TASKS.fetch_sub(1, Ordering::SeqCst);
-		} else {
-			panic!("unable to terminate idle task");
-		}
+		let closure = || {
+			if self.current_task.borrow().status != TaskStatus::TaskIdle {
+				info!("abort task with id {}", self.current_task.borrow().id);
+				self.current_task.borrow_mut().status = TaskStatus::TaskFinished;
+				// update the number of tasks
+				NO_TASKS.fetch_sub(1, Ordering::SeqCst);
+			} else {
+				panic!("unable to terminate idle task");
+			}
+		};
+
+		irqsave(closure);
 
 		self.reschedule();
 
@@ -116,32 +128,40 @@ impl Scheduler {
 	}
 
 	pub fn block_current_task(&mut self) -> Rc<RefCell<Task>> {
-		if self.current_task.borrow().status == TaskStatus::TaskRunning {
-			debug!("block task {}", self.current_task.borrow().id);
+		let closure = || {
+			if self.current_task.borrow().status == TaskStatus::TaskRunning {
+				debug!("block task {}", self.current_task.borrow().id);
+
+				self.current_task.borrow_mut().status = TaskStatus::TaskBlocked;
+				self.current_task.clone()
+			} else {
+				panic!("unable to block task {}", self.current_task.borrow().id);
+			}
+		};
 
-			self.current_task.borrow_mut().status = TaskStatus::TaskBlocked;
-			self.current_task.clone()
-		} else {
-			panic!("unable to block task {}", self.current_task.borrow().id);
-		}
+		irqsave(closure)
 	}
 
 	pub fn wakeup_task(&mut self, task: Rc<RefCell<Task>>) {
-		if task.borrow().status == TaskStatus::TaskBlocked {
-			debug!("wakeup task {}", task.borrow().id);
+		let closure = || {
+			if task.borrow().status == TaskStatus::TaskBlocked {
+				debug!("wakeup task {}", task.borrow().id);
 
-			task.borrow_mut().status = TaskStatus::TaskReady;
-			self.ready_queue.lock().push(task.clone());
-		}
+				task.borrow_mut().status = TaskStatus::TaskReady;
+				self.ready_queue.lock().push(task.clone());
+			}
+		};
+
+		irqsave(closure);
 	}
 
 	pub fn get_current_taskid(&self) -> TaskId {
-		self.current_task.borrow().id
+		irqsave(|| self.current_task.borrow().id)
 	}
 
 	/// Determines the start address of the stack
 	pub fn get_current_stack(&self) -> usize {
-		unsafe { (*self.current_task.borrow().stack).bottom() }
+		irqsave(|| unsafe { (*self.current_task.borrow().stack).bottom() })
 	}
 
 	pub fn schedule(&mut self) {
@@ -221,8 +241,6 @@ impl Scheduler {
 	}
 
 	pub fn reschedule(&mut self) {
-		let flags = irq_nested_disable();
-		self.schedule();
-		irq_nested_enable(flags);
+		irqsave(|| self.schedule());
 	}
 }