Index: kernel/generic/include/synch/rcu.h
===================================================================
--- kernel/generic/include/synch/rcu.h	(revision 5b0cf635022b821f28f7a014ad5b39d005cd7666)
+++ kernel/generic/include/synch/rcu.h	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -41,7 +41,7 @@
 
 
-/** Use to assign a pointer to newly initialized data to a rcu reader 
+/** Use to assign a pointer to newly initialized data to a rcu reader
  * accessible pointer.
- * 
+ *
  * Example:
  * @code
@@ -50,8 +50,8 @@
  *     int grade;
  * } exam_t;
- * 
+ *
  * exam_t *exam_list;
  * // ..
- * 
+ *
  * // Insert at the beginning of the list.
  * exam_t *my_exam = malloc(sizeof(exam_t), 0);
@@ -59,5 +59,5 @@
  * my_exam->next = exam_list;
  * rcu_assign(exam_list, my_exam);
- * 
+ *
  * // Changes properly propagate. Every reader either sees
  * // the old version of exam_list or the new version with
@@ -65,5 +65,5 @@
  * rcu_synchronize();
  * // Now we can be sure every reader sees my_exam.
- * 
+ *
  * @endcode
  */
@@ -75,13 +75,13 @@
 
 /** Use to access RCU protected data in a reader section.
- * 
+ *
  * Example:
  * @code
  * exam_t *exam_list;
  * // ...
- * 
+ *
  * rcu_read_lock();
  * exam_t *first_exam = rcu_access(exam_list);
- * // We can now safely use first_exam, it won't change 
+ * // We can now safely use first_exam, it won't change
  * // under us while we're using it.
  *
@@ -131,6 +131,6 @@
 void _rcu_preempted_unlock(void);
 
-/** Delimits the start of an RCU reader critical section. 
- * 
+/** Delimits the start of an RCU reader critical section.
+ *
  * Reader sections may be nested and are preemptible. You must not
  * however block/sleep within reader sections.
@@ -165,12 +165,12 @@
 	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
-	/* 
-	 * A new GP was started since the last time we passed a QS. 
+	/*
+	 * A new GP was started since the last time we passed a QS.
 	 * Notify the detector we have reached a new QS.
 	 */
 	if (CPU->rcu.last_seen_gp != _rcu_cur_gp) {
 		rcu_gp_t cur_gp = ACCESS_ONCE(_rcu_cur_gp);
-		/* 
-		 * Contain memory accesses within a reader critical section. 
+		/*
+		 * Contain memory accesses within a reader critical section.
 		 * If we are in rcu_lock() it also makes changes prior to the
 		 * start of the GP visible in the reader section.
@@ -180,19 +180,19 @@
 		 * Acknowledge we passed a QS since the beginning of rcu.cur_gp.
 		 * Cache coherency will lazily transport the value to the
-		 * detector while it sleeps in gp_sleep(). 
-		 * 
+		 * detector while it sleeps in gp_sleep().
+		 *
 		 * Note that there is a theoretical possibility that we
-		 * overwrite a more recent/greater last_seen_gp here with 
+		 * overwrite a more recent/greater last_seen_gp here with
 		 * an older/smaller value. If this cpu is interrupted here
-		 * while in rcu_lock() reader sections in the interrupt handler 
-		 * will update last_seen_gp to the same value as is currently 
-		 * in local cur_gp. However, if the cpu continues processing 
-		 * interrupts and the detector starts a new GP immediately, 
-		 * local interrupt handlers may update last_seen_gp again (ie 
-		 * properly ack the new GP) with a value greater than local cur_gp. 
-		 * Resetting last_seen_gp to a previous value here is however 
-		 * benign and we only have to remember that this reader may end up 
+		 * while in rcu_lock() reader sections in the interrupt handler
+		 * will update last_seen_gp to the same value as is currently
+		 * in local cur_gp. However, if the cpu continues processing
+		 * interrupts and the detector starts a new GP immediately,
+		 * local interrupt handlers may update last_seen_gp again (ie
+		 * properly ack the new GP) with a value greater than local cur_gp.
+		 * Resetting last_seen_gp to a previous value here is however
+		 * benign and we only have to remember that this reader may end up
 		 * in cur_preempted even after the GP ends. That is why we
-		 * append next_preempted to cur_preempted rather than overwriting 
+		 * append next_preempted to cur_preempted rather than overwriting
 		 * it as if cur_preempted were empty.
 		 */
@@ -201,6 +201,6 @@
 }
 
-/** Delimits the start of an RCU reader critical section. 
- * 
+/** Delimits the start of an RCU reader critical section.
+ *
  * Reader sections may be nested and are preemptable. You must not
  * however block/sleep within reader sections.
@@ -229,7 +229,7 @@
 		_rcu_record_qs();
 		
-		/* 
-		 * The thread was preempted while in a critical section or 
-		 * the detector is eagerly waiting for this cpu's reader to finish. 
+		/*
+		 * The thread was preempted while in a critical section or
+		 * the detector is eagerly waiting for this cpu's reader to finish.
 		 */
 		if (CPU->rcu.signal_unlock) {
Index: kernel/generic/include/synch/rcu_types.h
===================================================================
--- kernel/generic/include/synch/rcu_types.h	(revision 5b0cf635022b821f28f7a014ad5b39d005cd7666)
+++ kernel/generic/include/synch/rcu_types.h	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -72,12 +72,12 @@
 	
 	/** True if we should signal the detector that we exited a reader section.
-	 * 
+	 *
 	 * Equal to (THREAD->rcu.was_preempted || CPU->rcu.is_delaying_gp).
 	 */
 	bool signal_unlock;
 
-	/** The number of times an RCU reader section is nested on this cpu. 
-	 * 
-	 * If positive, it is definitely executing reader code. If zero, 
+	/** The number of times an RCU reader section is nested on this cpu.
+	 *
+	 * If positive, it is definitely executing reader code. If zero,
 	 * the thread might already be executing reader code thanks to
 	 * cpu instruction reordering.
@@ -92,5 +92,5 @@
 	/** Number of callbacks in cur_cbs. */
 	size_t cur_cbs_cnt;
-	/** Callbacks to invoke once the next grace period ends, ie next_cbs_gp. 
+	/** Callbacks to invoke once the next grace period ends, ie next_cbs_gp.
 	 * Accessed by the local reclaimer only.
 	 */
@@ -102,5 +102,5 @@
 	/** Tail of arriving_cbs list. Disable interrupts to access. */
 	rcu_item_t **parriving_cbs_tail;
-	/** Number of callbacks currently in arriving_cbs. 
+	/** Number of callbacks currently in arriving_cbs.
 	 * Disable interrupts to access.
 	 */
@@ -110,9 +110,9 @@
 	rcu_gp_t cur_cbs_gp;
 	/** At the end of this grace period callbacks in next_cbs will be invoked.
-	 * 
-	 * Should be the next grace period but it allows the reclaimer to 
+	 *
+	 * Should be the next grace period but it allows the reclaimer to
 	 * notice if it missed a grace period end announcement. In that
 	 * case it can execute next_cbs without waiting for another GP.
-	 * 
+	 *
 	 * Invariant: next_cbs_gp >= cur_cbs_gp
 	 */
@@ -143,6 +143,6 @@
 /** RCU related per-thread data. */
 typedef struct rcu_thread_data {
-	/** 
-	 * Nesting count of the thread's RCU read sections when the thread 
+	/**
+	 * Nesting count of the thread's RCU read sections when the thread
 	 * is not running.
 	 */
@@ -151,9 +151,9 @@
 #ifdef RCU_PREEMPT_PODZIMEK
 	
-	/** True if the thread was preempted in a reader section. 
+	/** True if the thread was preempted in a reader section.
 	 *
 	 * The thread is placed into rcu.cur_preempted or rcu.next_preempted
-	 * and must remove itself in rcu_read_unlock(). 
-	 * 
+	 * and must remove itself in rcu_read_unlock().
+	 *
 	 * Access with interrupts disabled.
 	 */
Index: kernel/generic/include/synch/workqueue.h
===================================================================
--- kernel/generic/include/synch/workqueue.h	(revision 5b0cf635022b821f28f7a014ad5b39d005cd7666)
+++ kernel/generic/include/synch/workqueue.h	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -53,5 +53,5 @@
 	/* Magic number for integrity checks. */
 	uint32_t cookie;
-#endif 
+#endif
 } work_t;