[mk][migration] Add lk_|Lk prefix to avoid symbol clash during migration

Author: bherrera

mk/app/tests/thread_tests.c

@@ -601,14 +601,14 @@ static void spinlock_test(void) {
   printf("seems to work\n");
 
 #define COUNT (1024 * 1024)
-  arch_interrupt_save(&state, SPIN_LOCK_FLAG_INTERRUPTS);
+  lk_arch_interrupt_save(&state, SPIN_LOCK_FLAG_INTERRUPTS);
   uint32_t c = arch_cycle_count();
   for (uint i = 0; i < COUNT; i++) {
     spin_lock(&lock);
     spin_unlock(&lock);
   }
   c = arch_cycle_count() - c;
-  arch_interrupt_restore(state, SPIN_LOCK_FLAG_INTERRUPTS);
+  lk_arch_interrupt_restore(state, SPIN_LOCK_FLAG_INTERRUPTS);
 
   printf("%u cycles to acquire/release lock %u times (%u cycles per)\n", c, COUNT, c / COUNT);
 

mk/arch/x86/include/arch/arch_ops.h

@@ -52,11 +52,11 @@ static inline ulong arch_cycle_count(void) {
 /* use a global pointer to store the current_thread */
 extern struct thread *_current_thread;
 
-static inline struct thread *arch_get_current_thread(void) { return _current_thread; }
+static inline struct thread *lk_arch_get_current_thread(void) { return _current_thread; }
 
-static inline void arch_set_current_thread(struct thread *t) { _current_thread = t; }
+static inline void lk_arch_set_current_thread(struct thread *t) { _current_thread = t; }
 
-static inline uint arch_curr_cpu_num(void) { return 0; }
+static inline uint lk_arch_curr_cpu_num(void) { return 0; }
 
 #if ARCH_X86_64
 // relies on SSE2

mk/arch/x86/include/arch/spinlock.h

@@ -21,27 +21,27 @@ typedef x86_flags_t spin_lock_saved_state_t;
 typedef uint spin_lock_save_flags_t;
 
 /* simple implementation of spinlocks for no smp support */
-static inline void arch_spin_lock_init(spin_lock_t *lock) { *lock = SPIN_LOCK_INITIAL_VALUE; }
+static inline void lk_arch_spin_lock_init(spin_lock_t *lock) { *lock = SPIN_LOCK_INITIAL_VALUE; }
 
-static inline bool arch_spin_lock_held(spin_lock_t *lock) { return *lock != 0; }
+static inline bool lk_arch_spin_lock_held(spin_lock_t *lock) { return *lock != 0; }
 
-static inline void arch_spin_lock(spin_lock_t *lock) { *lock = 1; }
+static inline void lk_arch_spin_lock(spin_lock_t *lock) { *lock = 1; }
 
-static inline int arch_spin_trylock(spin_lock_t *lock) { return 0; }
+static inline int lk_arch_spin_trylock(spin_lock_t *lock) { return 0; }
 
-static inline void arch_spin_unlock(spin_lock_t *lock) { *lock = 0; }
+static inline void lk_arch_spin_unlock(spin_lock_t *lock) { *lock = 0; }
 
 /* flags are unused on x86 */
 #define ARCH_DEFAULT_SPIN_LOCK_FLAG_INTERRUPTS 0
 
-static inline void arch_interrupt_save(spin_lock_saved_state_t *statep,
-                                       spin_lock_save_flags_t flags) {
+static inline void lk_arch_interrupt_save(spin_lock_saved_state_t *statep,
+                                          spin_lock_save_flags_t flags) {
   *statep = x86_save_flags();
   arch_disable_ints();
 }
 
-static inline void arch_interrupt_restore(spin_lock_saved_state_t old_state,
-                                          spin_lock_save_flags_t flags) {
+static inline void lk_arch_interrupt_restore(spin_lock_saved_state_t old_state,
+                                             spin_lock_save_flags_t flags) {
   x86_restore_flags(old_state);
 }
 

mk/dev/bus/pci/pci.cc

@@ -23,7 +23,7 @@
 // Largely C level api for the PCI bus manager
 
 namespace {
-SpinLock lock;
+LkSpinLock lock;
 pci_backend *pcib = nullptr;
 }  // namespace
 
@@ -45,7 +45,7 @@ status_t pci_read_config_byte(const pci_location_t state, uint32_t reg, uint8_t
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->read_config_byte(state, reg, value);
 
@@ -55,7 +55,7 @@ status_t pci_read_config_half(const pci_location_t state, uint32_t reg, uint16_t
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->read_config_half(state, reg, value);
 
@@ -66,7 +66,7 @@ status_t pci_read_config_word(const pci_location_t state, uint32_t reg, uint32_t
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->read_config_word(state, reg, value);
 
@@ -77,7 +77,7 @@ status_t pci_write_config_byte(const pci_location_t state, uint32_t reg, uint8_t
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->write_config_byte(state, reg, value);
 
@@ -88,7 +88,7 @@ status_t pci_write_config_half(const pci_location_t state, uint32_t reg, uint16_
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->write_config_half(state, reg, value);
 
@@ -99,7 +99,7 @@ status_t pci_write_config_word(const pci_location_t state, uint32_t reg, uint32_
   if (!pcib)
     return ERR_NOT_CONFIGURED;
 
-  AutoSpinLock guard(&lock);
+  LkAutoSpinLock guard(&lock);
 
   int res = pcib->write_config_word(state, reg, value);
 

mk/dev/net/e1000/e1000.cc

@@ -166,7 +166,7 @@ handler_return e1000::irq_handler() {
 
   LTRACEF("icr %#x\n", icr);
 
-  AutoSpinLockNoIrqSave guard(&lock_);
+  LkAutoSpinLockNoIrqSave guard(&lock_);
 
   handler_return ret = INT_NO_RESCHEDULE;
 
@@ -237,7 +237,7 @@ int e1000::rx_worker_routine() {
       pktbuf_t *p;
 
       {
-        AutoSpinLock guard(&lock_);
+        LkAutoSpinLock guard(&lock_);
 
         p = list_remove_head_type(&rx_queue_, pktbuf_t, list);
       }
@@ -313,7 +313,7 @@ void e1000::add_pktbuf_to_rxring_locked(pktbuf_t *p) {
 }
 
 void e1000::add_pktbuf_to_rxring(pktbuf_t *pkt) {
-  AutoSpinLock guard(&lock_);
+  LkAutoSpinLock guard(&lock_);
 
   add_pktbuf_to_rxring_locked(pkt);
 }

mk/kernel/include/kernel/mutex.h

@@ -57,10 +57,10 @@ __END_CDECLS
 #include <fbl/macros.h>
 
 // C++ wrapper object
-class Mutex {
+class LkMutex {
  public:
-  constexpr Mutex() = default;
-  ~Mutex() { mutex_destroy(&lock_); }
+  constexpr LkMutex() = default;
+  ~LkMutex() { mutex_destroy(&lock_); }
 
   status_t acquire(lk_time_t timeout = INFINITE_TIME) {
     return mutex_acquire_timeout(&lock_, timeout);
@@ -69,25 +69,25 @@ class Mutex {
   bool is_held() { return is_mutex_held(&lock_); }
 
   // suppress default constructors
-  DISALLOW_COPY_ASSIGN_AND_MOVE(Mutex);
+  DISALLOW_COPY_ASSIGN_AND_MOVE(LkMutex);
 
  private:
   mutex_t lock_ = MUTEX_INITIAL_VALUE(lock_);
 
-  // AutoLock has access to the inner lock
-  friend class AutoLock;
+  // LkAutoLock has access to the inner lock
+  friend class LkAutoLock;
 };
 
 // RAII wrapper around the mutex
-class AutoLock {
+class LkAutoLock {
  public:
-  explicit AutoLock(mutex_t *mutex) : mutex_(mutex) { mutex_acquire(mutex_); }
-  AutoLock(mutex_t &mutex) : AutoLock(&mutex) {}
+  explicit LkAutoLock(mutex_t *mutex) : mutex_(mutex) { mutex_acquire(mutex_); }
+  LkAutoLock(mutex_t &mutex) : LkAutoLock(&mutex) {}
 
-  explicit AutoLock(Mutex *mutex) : AutoLock(&mutex->lock_) {}
-  AutoLock(Mutex &mutex) : AutoLock(&mutex) {}
+  explicit LkAutoLock(LkMutex *mutex) : LkAutoLock(&mutex->lock_) {}
+  LkAutoLock(LkMutex &mutex) : LkAutoLock(&mutex) {}
 
-  ~AutoLock() { release(); }
+  ~LkAutoLock() { release(); }
 
   // early release the mutex before the object goes out of scope
   void release() {
@@ -98,7 +98,7 @@ class AutoLock {
   }
 
   // suppress default constructors
-  DISALLOW_COPY_ASSIGN_AND_MOVE(AutoLock);
+  DISALLOW_COPY_ASSIGN_AND_MOVE(LkAutoLock);
 
  private:
   mutex_t *mutex_ = nullptr;

mk/kernel/include/kernel/spinlock.h

@@ -14,17 +14,17 @@
 __BEGIN_CDECLS
 
 /* interrupts should already be disabled */
-static inline void spin_lock(spin_lock_t *lock) { arch_spin_lock(lock); }
+static inline void spin_lock(spin_lock_t *lock) { lk_arch_spin_lock(lock); }
 
 /* Returns 0 on success, non-0 on failure */
-static inline int spin_trylock(spin_lock_t *lock) { return arch_spin_trylock(lock); }
+static inline int spin_trylock(spin_lock_t *lock) { return lk_arch_spin_trylock(lock); }
 
 /* interrupts should already be disabled */
-static inline void spin_unlock(spin_lock_t *lock) { arch_spin_unlock(lock); }
+static inline void spin_unlock(spin_lock_t *lock) { lk_arch_spin_unlock(lock); }
 
-static inline void spin_lock_init(spin_lock_t *lock) { arch_spin_lock_init(lock); }
+static inline void spin_lock_init(spin_lock_t *lock) { lk_arch_spin_lock_init(lock); }
 
-static inline bool spin_lock_held(spin_lock_t *lock) { return arch_spin_lock_held(lock); }
+static inline bool spin_lock_held(spin_lock_t *lock) { return lk_arch_spin_lock_held(lock); }
 
 /* spin lock irq save flags: */
 
@@ -40,15 +40,15 @@ static inline bool spin_lock_held(spin_lock_t *lock) { return arch_spin_lock_hel
 /* same as spin lock, but save disable and save interrupt state first */
 static inline void spin_lock_save(spin_lock_t *lock, spin_lock_saved_state_t *statep,
                                   spin_lock_save_flags_t flags) {
-  arch_interrupt_save(statep, flags);
+  lk_arch_interrupt_save(statep, flags);
   spin_lock(lock);
 }
 
 /* restore interrupt state before unlocking */
 static inline void spin_unlock_restore(spin_lock_t *lock, spin_lock_saved_state_t old_state,
                                        spin_lock_save_flags_t flags) {
   spin_unlock(lock);
-  arch_interrupt_restore(old_state, flags);
+  lk_arch_interrupt_restore(old_state, flags);
 }
 
 /* hand(ier) routines */
@@ -65,10 +65,10 @@ __END_CDECLS
 #include <fbl/macros.h>
 
 // C++ wrapper around a C spinlock_t
-class SpinLock {
+class LkSpinLock {
  public:
-  constexpr SpinLock() = default;
-  ~SpinLock() { DEBUG_ASSERT(!is_held()); }
+  constexpr LkSpinLock() = default;
+  ~LkSpinLock() { DEBUG_ASSERT(!is_held()); }
 
   void lock() { spin_lock(&lock_); }
   int trylock() { return spin_trylock(&lock_); }
@@ -84,22 +84,22 @@ class SpinLock {
   }
 
   // suppress default constructors
-  DISALLOW_COPY_ASSIGN_AND_MOVE(SpinLock);
+  DISALLOW_COPY_ASSIGN_AND_MOVE(LkSpinLock);
 
  private:
   spin_lock_t lock_ = SPIN_LOCK_INITIAL_VALUE;
 
   // friend classes to get to the inner lock
-  friend class AutoSpinLock;
-  friend class AutoSpinLockNoIrqSave;
+  friend class LkAutoSpinLock;
+  friend class LkAutoSpinLockNoIrqSave;
 };
 
 // RAII wrappers for a spinlock, with and without IRQ Save
-class AutoSpinLock {
+class LkAutoSpinLock {
  public:
-  explicit AutoSpinLock(spin_lock_t *lock) : lock_(lock) { spin_lock_irqsave(lock_, state_); }
-  explicit AutoSpinLock(SpinLock *lock) : AutoSpinLock(&lock->lock_) {}
-  ~AutoSpinLock() { release(); }
+  explicit LkAutoSpinLock(spin_lock_t *lock) : lock_(lock) { spin_lock_irqsave(lock_, state_); }
+  explicit LkAutoSpinLock(LkSpinLock *lock) : LkAutoSpinLock(&lock->lock_) {}
+  ~LkAutoSpinLock() { release(); }
 
   void release() {
     if (likely(lock_)) {
@@ -109,18 +109,18 @@ class AutoSpinLock {
   }
 
   // suppress default constructors
-  DISALLOW_COPY_ASSIGN_AND_MOVE(AutoSpinLock);
+  DISALLOW_COPY_ASSIGN_AND_MOVE(LkAutoSpinLock);
 
  private:
   spin_lock_t *lock_;
   spin_lock_saved_state_t state_;
 };
 
-class AutoSpinLockNoIrqSave {
+class LkAutoSpinLockNoIrqSave {
  public:
-  explicit AutoSpinLockNoIrqSave(spin_lock_t *lock) : lock_(lock) { spin_lock(lock_); }
-  explicit AutoSpinLockNoIrqSave(SpinLock *lock) : AutoSpinLockNoIrqSave(&lock->lock_) {}
-  ~AutoSpinLockNoIrqSave() { release(); }
+  explicit LkAutoSpinLockNoIrqSave(spin_lock_t *lock) : lock_(lock) { spin_lock(lock_); }
+  explicit LkAutoSpinLockNoIrqSave(LkSpinLock *lock) : LkAutoSpinLockNoIrqSave(&lock->lock_) {}
+  ~LkAutoSpinLockNoIrqSave() { release(); }
 
   void release() {
     if (likely(lock_)) {
@@ -130,7 +130,7 @@ class AutoSpinLockNoIrqSave {
   }
 
   // suppress default constructors
-  DISALLOW_COPY_ASSIGN_AND_MOVE(AutoSpinLockNoIrqSave);
+  DISALLOW_COPY_ASSIGN_AND_MOVE(LkAutoSpinLockNoIrqSave);
 
  private:
   spin_lock_t *lock_;

mk/kernel/include/kernel/thread.h

@@ -200,9 +200,9 @@ struct timer;
 enum handler_return thread_timer_tick(struct timer *, lk_time_t now, void *arg);
 
 /* the current thread */
-static inline thread_t *get_current_thread(void) { return arch_get_current_thread(); }
+static inline thread_t *get_current_thread(void) { return lk_arch_get_current_thread(); }
 
-static inline void set_current_thread(thread_t *t) { arch_set_current_thread(t); }
+static inline void set_current_thread(thread_t *t) { lk_arch_set_current_thread(t); }
 
 /* list of all threads, unsafe to traverse without holding thread_lock */
 extern struct list_node thread_list;
@@ -254,9 +254,9 @@ struct thread_stats {
 
 extern struct thread_stats thread_stats[SMP_MAX_CPUS];
 
-#define THREAD_STATS_INC(name)                \
-  do {                                        \
-    thread_stats[arch_curr_cpu_num()].name++; \
+#define THREAD_STATS_INC(name)                   \
+  do {                                           \
+    thread_stats[lk_arch_curr_cpu_num()].name++; \
   } while (0)
 
 #else