/*
* 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(®istry.links);
rwlock_init(®istry.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, ®istry.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(®istry.lock);
KernelLayer *oldLayer = filterLayersLocked(layerIsEqual, layer);
result = ASSERT(oldLayer == NULL, "Layer not already registered");
if (result == VDO_SUCCESS) {
list_add_tail(&newDevice->links, ®istry.links);
}
write_unlock(®istry.lock);
return result;
}
/**********************************************************************/
void removeLayerFromDeviceRegistry(KernelLayer *layer)
{
write_lock(®istry.lock);
RegisteredDevice *device = NULL;
list_for_each_entry(device, ®istry.links, links) {
if (device->layer == layer) {
list_del_init(&device->links);
FREE(device);
break;
}
}
write_unlock(®istry.lock);
}
/**********************************************************************/
KernelLayer *findLayerMatching(LayerFilter *filter, void *context)
{
read_lock(®istry.lock);
KernelLayer *layer = filterLayersLocked(filter, context);
read_unlock(®istry.lock);
return layer;
}