/*

 * Generic object event notification support.

 *

 * Copyright (C) 2021, 2022, 2023 Paul Boddie <paul@boddie.org.uk>

 *

 * 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

 */

#include <map>

#include <mutex>

#include <l4/sys/irq.h>

#include <ipc/cap_alloc.h>

#include <ipc/server.h>

#include <resource/resource_server.h>

#include "notification_client.h"

#include "notifier.h"

#include "notifier_server.h"

/* Null notification state. */

static ObjectNotificationState _null_state;

/* Lock protecting per-task notifier access. */

static std::mutex _lock;

/* Per-task storage for specific waiting operations. */

static SpecificObjectNotifier *_notifier = NULL;

/* Return the per-task notifier for object-specific waiting operations. */

SpecificObjectNotifier *notifier_get_task_notifier()

{

  std::lock_guard<std::mutex> guard(_lock);

  /* Start any new notifier. */

  if (_notifier == NULL)

  {

    _notifier = new SpecificObjectNotifier;

    _notifier->start();

  }

  return _notifier;

}

/* Return a local notifier for general object waiting operations. */

GeneralObjectNotifier *notifier_get_local_notifier()

{

  GeneralObjectNotifier *notifier = new GeneralObjectNotifier;

  notifier->start();

  return notifier;

}

/* Virtual destructor required for base class instance reference deletion. */

ObjectNotifier::~ObjectNotifier()

{

  stop();

  ServerConfigs::iterator it;

  for (it = _configs.begin(); it != _configs.end(); it++)

    delete *it;

  _configs.clear();

  /* Handle deletion of the special task notifier. */

  if (this == _notifier)

    _notifier = NULL;

}

/* Start listening for notifications. */

long ObjectNotifier::start()

{

  if (_started)

    return L4_EOK;

  /* Create a new thread to serve a "null" resource. This resource is not used

     for notifications but merely for control purposes. */

  NotifierResource *notifier = new NotifierResource;

  ResourceServer server(notifier);

  long err = server.start_thread(true, false);

  if (err)

    return err;

  _configs.push_back(server.config());

  _started = true;

  /* Retain the IRQ created for the server for control purposes. */

  _irq = server.config()->irq;

  return L4_EOK;

}

/* Stop the notifier. */

void ObjectNotifier::stop()

{

  if (l4_is_valid_cap(_irq))

  {

    l4_irq_trigger(_irq);

    _irq = L4_INVALID_CAP;

  }

}

/* Return notification state for the given object or null state if no record

   existed for the object. */

ObjectNotificationState &ObjectNotifier::object_state(notifiable_t *object, bool create)

{

  ObjectNotificationStates::iterator it = _state.find(object);

  if (it == _state.end())

  {

    if (create)

      return _state[object];

    else

      return _null_state;

  }

  return it->second;

}

/* Subscribe to notification events on an object. */

long ObjectNotifier::subscribe(notifiable_t *object, notify_flags_t flags)

{

  /* Acquire the lock for state lookup. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  /* Obtain potentially new state for the object. */

  ObjectNotificationState &state = object_state(object, true);

  if (state.is_null())

  {

    /* Serve the new object in the notifier thread. */

    NotifierResource *resource = new NotifierResource(this, object);

    ResourceServer server(resource);

    long err = server.start_in_thread(_configs.front()->thread);

    if (err)

      return err;

    _configs.push_back(server.config());

    state.endpoint = server.config()->server;

  }

  /* Forbid repeated subscription.

     NOTE: Could instead rely on being unsubscribed, releasing the existing

           endpoint. */

  else

    return -L4_EEXIST;

  /* Allow this object to be re-entered. This may occur because the subscribe

     operation can cause deferred notifications to be sent back to the

     subscribed notifier and to this object. */

  state_guard.unlock();

  /* Subscribe, sending the notification endpoint via the principal reference

     for the object. */

  client_Notification notify(object->base->ref);

  return notify.subscribe(state.endpoint, flags);

}

/* Unsubscribe from notification events on an object. */

long ObjectNotifier::unsubscribe(notifiable_t *object)

{

  /* Acquire the lock for state lookup. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  ObjectNotificationState &state = object_state(object, false);

  if (state.is_null())

    return -L4_ENOENT;

  /* Unsubscribe via the notification interface. */

  client_Notification notify(object->base->ref);

  notify.unsubscribe();

  return remove_endpoint(object, state.endpoint);

}

/* Remove a notification endpoint for an object. */

long ObjectNotifier::remove_endpoint(notifiable_t *object, l4_cap_idx_t endpoint)

{

  if (l4_is_invalid_cap(endpoint))

    return -L4_EINVAL;

  ipc_cap_free_um(endpoint);

  _state.erase(object);

  /* Remove the lock for updating object state. */

  _object_locks.erase(object);

  return L4_EOK;

}

/* Handle a notification event for an object. */

void GeneralObjectNotifier::notify(notifiable_t *object, notify_flags_t flags,

                                   notify_values_t values)

{

  /* Enter critical section for the notifier (affecting all objects). */

  std::unique_lock<std::mutex> general_guard(_general_lock);

  /* Acquire the lock for state lookup. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  ObjectNotificationState &state = object_state(object, false);

  if (state.is_null())

    return;

  /* Acquire the lock for the object state itself. */

  std::unique_lock<std::mutex> object_guard(state.lock);

  /* Record flags and note previous flags. */

  notify_flags_t recorded = state.pending_notifications;

  state.pending_notifications |= flags;

  state.pending_values = values;

  /* Add an object queue entry for any objects without previous notifications. */

  if (!recorded)

    _affected.push_back(object);

  /* Notify any waiting caller. */

  _general_condition.notify_one();

}

void SpecificObjectNotifier::notify(notifiable_t *object, notify_flags_t flags,

                                    notify_values_t values)

{

  /* Acquire the lock for state lookup. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  ObjectNotificationState &state = object_state(object, false);

  if (state.is_null())

    return;

  /* Acquire the lock for the object state itself. */

  std::unique_lock<std::mutex> object_guard(state.lock);

  state.pending_notifications |= flags;

  state.pending_values = values;

  /* Notify any waiting caller. */

  state.condition.notify_one();

}

/* Transfer pending notifications to the given object. This must be called with

   a lock acquired on the object notification state. */

bool ObjectNotifier::_transfer(ObjectNotificationState &state, notifiable_t *object)

{

  notify_flags_t recorded = state.pending_notifications;

  if (recorded)

  {

    object->notifications = recorded;

    object->values = state.pending_values;

    state.pending_notifications = 0;

    return true;

  }

  return false;

}

/* Obtain object state and transfer notifications. */

bool GeneralObjectNotifier::_retrieve_for_object(notifiable_t *object)

{

  /* Acquire the lock for state lookup. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  ObjectNotificationState &state = object_state(object, false);

  if (state.is_null())

    return false;

  /* Acquire the lock for the object state itself, then release the state lock. */

  std::unique_lock<std::mutex> object_guard(state.lock);

  state_guard.unlock();

  /* Call generic method to transfer notifications, if possible. */

  return _transfer(state, object);

}

/* Obtain queued objects until one is found that still has events recorded for

   it. This must be called with the notifier's general lock acquired. */

bool GeneralObjectNotifier::_retrieve(notifiable_t **object)

{

  while (!_affected.empty())

  {

    *object = _affected.front();

    _affected.pop_front();

    if (_retrieve_for_object(*object))

      return true;

  }

  return false;

}

/* Wait for notification events on objects. */

long GeneralObjectNotifier::wait(notifiable_t **object)

{

  std::unique_lock<std::mutex> general_guard(_general_lock);

  while (1)

  {

    /* With pending notifications, update the first object and exit. */

    if (_retrieve(object))

      break;

    /* Otherwise, wait for notifications. */

    _general_condition.wait(general_guard);

  }

  return L4_EOK;

}

/* Wait for notifications from a single object. */

long SpecificObjectNotifier::wait_object(notifiable_t *object)

{

  /* Acquire the lock for reading object state. */

  std::unique_lock<std::mutex> state_guard(_state_lock);

  ObjectNotificationState &state = object_state(object, false);

  if (state.is_null())

    return -L4_EINVAL;

  /* Acquire the lock for the object state itself, then release the state lock. */

  std::unique_lock<std::mutex> object_guard(state.lock);

  state_guard.unlock();

  while (1)

  {

    /* With pending notifications, update the object and exit. */

    if (_transfer(state, object))

      break;

    /* Otherwise, wait for notifications. */

    state.condition.wait(object_guard);

  }

  return L4_EOK;

}

/* Object-specific resource methods. */

ipc_server_default_config_type NotifierResource::config()

{

  return config_Notifier;

}

/* Register a notification received by an object-specific resource. */

long NotifierResource::notify(notify_flags_t flags, notify_values_t values)

{

  if (_notifier != NULL)

    _notifier->notify(_object, flags, values);

  return L4_EOK;

}

// vim: tabstop=2 expandtab shiftwidth=2