/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 *

 * $Id: //eng/uds-releases/jasper/kernelLinux/uds/threadsLinuxKernel.c#4 $

 */

#include <linux/completion.h>

#include <linux/kthread.h>

#include <linux/sched.h>

#include "memoryAlloc.h"

#include "logger.h"

#include "threads.h"

#include "uds-error.h"

static struct hlist_head kernelThreadList;

static struct mutex kernelThreadMutex;

static OnceState kernelThreadOnce;

typedef struct kernelThread {

  void (*threadFunc)(void *);

  void *threadData;

  struct hlist_node threadLinks;

  struct task_struct *threadTask;

  struct completion threadDone;

} KernelThread;

/**********************************************************************/

static void kernelThreadInit(void)

{

  mutex_init(&kernelThreadMutex);

}

/**********************************************************************/

static int threadStarter(void *arg)

{

  KernelThread *kt = arg;

  kt->threadTask = current;

  performOnce(&kernelThreadOnce, kernelThreadInit);

  mutex_lock(&kernelThreadMutex);

  hlist_add_head(&kt->threadLinks, &kernelThreadList);

  mutex_unlock(&kernelThreadMutex);

  RegisteredThread allocatingThread;

  registerAllocatingThread(&allocatingThread, NULL);

  kt->threadFunc(kt->threadData);

  unregisterAllocatingThread();

  complete(&kt->threadDone);

  return 0;

}

/**********************************************************************/

int createThread(void      (*threadFunc)(void *),

                 void       *threadData,

                 const char *name,

                 Thread     *newThread)

{

  char *nameColon = strchr(name, ':');

  char *myNameColon = strchr(current->comm, ':');

  KernelThread *kt;

  int result = ALLOCATE(1, KernelThread, __func__, &kt;;

  if (result != UDS_SUCCESS) {

    logWarning("Error allocating memory for %s", name);

    return result;

  }

  kt->threadFunc = threadFunc;

  kt->threadData = threadData;

  init_completion(&kt->threadDone);

  struct task_struct *thread;

  /*

   * Start the thread, with an appropriate thread name.

   *

   * If the name supplied contains a colon character, use that name.  This

   * causes uds module threads to have names like "uds:callbackW" and the main

   * test runner thread to be named "zub:runtest".

   *

   * Otherwise if the current thread has a name containing a colon character,

   * prefix the name supplied with the name of the current thread up to (and

   * including) the colon character.  Thus when the "kvdo0:dedupeQ" thread

   * opens an index session, all the threads associated with that index will

   * have names like "kvdo0:foo".

   *

   * Otherwise just use the name supplied.  This should be a rare occurrence.

   */

  if ((nameColon == NULL) && (myNameColon != NULL)) {

    thread = kthread_run(threadStarter, kt, "%.*s:%s",

                         (int) (myNameColon - current->comm), current->comm,

                         name);

  } else {

    thread = kthread_run(threadStarter, kt, "%s", name);

  }

  if (IS_ERR(thread)) {

    FREE(kt);

    return UDS_ENOTHREADS;

  }

  *newThread = kt;

  return UDS_SUCCESS;

}

/**********************************************************************/

int joinThreads(Thread kt)

{

  while (wait_for_completion_interruptible(&kt->threadDone) != 0) {

  }

  mutex_lock(&kernelThreadMutex);

  hlist_del(&kt->threadLinks);

  mutex_unlock(&kernelThreadMutex);

  FREE(kt);

  return UDS_SUCCESS;

}

/**********************************************************************/

void applyToThreads(void applyFunc(void *, struct task_struct *),

                    void *argument)

{

  KernelThread *kt;

  performOnce(&kernelThreadOnce, kernelThreadInit);

  mutex_lock(&kernelThreadMutex);

  hlist_for_each_entry(kt, &kernelThreadList, threadLinks) {

    applyFunc(argument, kt->threadTask);

  }

  mutex_unlock(&kernelThreadMutex);

}

/**********************************************************************/

void exitThread(void)

{

  KernelThread *kt;

  struct completion *completion = NULL;

  performOnce(&kernelThreadOnce, kernelThreadInit);

  mutex_lock(&kernelThreadMutex);

  hlist_for_each_entry(kt, &kernelThreadList, threadLinks) {

    if (kt->threadTask == current) {

      completion = &kt->threadDone;

      break;

    }

  }

  mutex_unlock(&kernelThreadMutex);

  unregisterAllocatingThread();

  complete_and_exit(completion, 1);

}

/**********************************************************************/

ThreadId getThreadId(void)

{

  return current->pid;

}

/**********************************************************************/

unsigned int getNumCores(void)

{

  return num_online_cpus();

}

/**********************************************************************/

int initializeBarrier(Barrier *barrier, unsigned int threadCount)

{

  barrier->arrived     = 0;

  barrier->threadCount = threadCount;

  int result = initializeSemaphore(&barrier->mutex, 1);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return initializeSemaphore(&barrier->wait, 0);

}

/**********************************************************************/

int destroyBarrier(Barrier *barrier)

{

  int result = destroySemaphore(&barrier->mutex);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return destroySemaphore(&barrier->wait);

}

/**********************************************************************/

int enterBarrier(Barrier *barrier, bool *winner)

{

  acquireSemaphore(&barrier->mutex);

  bool lastThread = ++barrier->arrived == barrier->threadCount;

  if (lastThread) {

    // This is the last thread to arrive, so wake up the others

    int i;

    for (i = 1; i < barrier->threadCount; i++) {

      releaseSemaphore(&barrier->wait);

    }

    // Then reinitialize for the next cycle

    barrier->arrived = 0;

    releaseSemaphore(&barrier->mutex);

  } else {

    // This is NOT the last thread to arrive, so just wait

    releaseSemaphore(&barrier->mutex);

    acquireSemaphore(&barrier->wait);

  }

  if (winner != NULL) {

    *winner = lastThread;

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int yieldScheduler(void)

{

  yield();

  return UDS_SUCCESS;

}