/*

 * 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/vdo-releases/aluminum/src/c++/vdo/kernel/deviceRegistry.c#3 $

 */

#include "deviceRegistry.h"

#include <linux/list.h>

#include <linux/types.h>

#include <linux/spinlock.h>

#include "memoryAlloc.h"

/*

 * We don't expect this set to ever get really large, so a linked list

 * is adequate. We can use a PointerMap if we need to later.

 */

typedef struct {

  struct list_head links;

  rwlock_t         lock;

} DeviceRegistry;

typedef struct {

  struct list_head    links;

  KernelLayer        *layer;

} RegisteredDevice;

static DeviceRegistry registry;

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

void initializeDeviceRegistryOnce(void)

{

  INIT_LIST_HEAD(&registry.links);

  rwlock_init(&registry.lock);

}

/**

 * Implements LayerFilter.

 **/

static bool layerIsEqual(KernelLayer *layer, void *context)

{

  return ((void *) layer == context);

}

/**

 * Find a layer in the registry if it exists there. Must be called holding

 * the lock.

 *

 * @param filter   The filter function to apply to devices

 * @param context  A bit of context to provide the filter.

 *

 * @return the layer object found, if any

 **/

__attribute__((warn_unused_result))

static KernelLayer *filterLayersLocked(LayerFilter *filter, void *context)

{

  RegisteredDevice *device;

  list_for_each_entry(device, &registry.links, links) {

    if (filter(device->layer, context)) {

      return device->layer;

    }

  }

  return NULL;

}

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

int addLayerToDeviceRegistry(KernelLayer *layer)

{

  RegisteredDevice *newDevice;

  int result = ALLOCATE(1, RegisteredDevice, __func__, &newDevice);

  if (result != VDO_SUCCESS) {

    return result;

  }

  INIT_LIST_HEAD(&newDevice->links);

  newDevice->layer = layer;

  write_lock(&registry.lock);

  KernelLayer *oldLayer = filterLayersLocked(layerIsEqual, layer);

  result = ASSERT(oldLayer == NULL, "Layer not already registered");

  if (result == VDO_SUCCESS) {

    list_add_tail(&newDevice->links, &registry.links);

  }

  write_unlock(&registry.lock);

  return result;

}

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

void removeLayerFromDeviceRegistry(KernelLayer *layer)

{

  write_lock(&registry.lock);

  RegisteredDevice *device = NULL;

  list_for_each_entry(device, &registry.links, links) {

    if (device->layer == layer) {

      list_del_init(&device->links);

      FREE(device);

      break;

    }

  }

  write_unlock(&registry.lock);

}

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

KernelLayer *findLayerMatching(LayerFilter *filter, void *context)

{

  read_lock(&registry.lock);

  KernelLayer *layer = filterLayersLocked(filter, context);

  read_unlock(&registry.lock);

  return layer;

}