NetworkStack.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef MACHINE_NETWORK_STACK_H
#define MACHINE_NETWORK_STACK_H
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Network.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/MemoryPool.h"
#include "pedigree/kernel/utilities/RequestQueue.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/Vector.h"
 
#include <config.h>
 
// lwIP network interface type
struct netif;
 
class EXPORTED_PUBLIC NetworkStack : public RequestQueue {
 public:
  class EXPORTED_PUBLIC DeviceLease {
   public:
    DeviceLease();
    DeviceLease(DeviceLease&& other);
    ~DeviceLease();
 
    DeviceLease& operator=(DeviceLease&& other);
 
    Network* device() const {
      return m_Device;
    }
 
    struct netif* interface() const {
      return m_Interface;
    }
 
    explicit operator bool() const {
      return m_Device != nullptr;
    }
 
   private:
    friend class NetworkStack;
 
    DeviceLease(Network* device, struct netif* interface, OperationBarrier::Lease&& lease);
 
    DeviceLease(const DeviceLease&) = delete;
    DeviceLease& operator=(const DeviceLease&) = delete;
 
    Network* m_Device;
    struct netif* m_Interface;
    OperationBarrier::Lease m_Lease;
  };
 
  NetworkStack();
  virtual ~NetworkStack();
 
  static NetworkStack& instance() {
    return *__atomic_load_n(&stack, __ATOMIC_ACQUIRE);
  }
 
  static NetworkStack* instanceIfAvailable() {
    return __atomic_load_n(&stack, __ATOMIC_ACQUIRE);
  }
 
  void receive(size_t nBytes, uintptr_t packet, Network* pCard, uint32_t offset);
 
  void registerDevice(Network* pDevice);
 
  MUST_USE_RESULT bool acquireDevice(size_t n, DeviceLease& lease);
 
  MUST_USE_RESULT bool acquireDevice(Network* pDevice, DeviceLease& lease);
 
  void deRegisterDevice(Network* pDevice);
 
  inline MemoryPool& getMemPool() {
    return m_MemPool;
  }
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  enum class HostedReceiveEvent {
    Queued,
    BeforeDispatch,
    Delivered,
    DiscardedStale,
    Cancelled,
  };
 
  using HostedReceiveHook = void (*)(HostedReceiveEvent event, uintptr_t buffer, Network* card,
                                     size_t generation);
 
  static void setHostedReceiveHook(HostedReceiveHook hook);
  static size_t getHostedRegistrationGeneration(Network* card);
  static size_t getHostedReceiveRequestCapacity();
#endif
 
 private:
  struct DeviceRegistration;
 
  static NetworkStack* stack;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static HostedReceiveHook m_HostedReceiveHook;
#endif
 
  virtual uint64_t executeRequest(uint64_t p1, uint64_t p2, uint64_t p3, uint64_t p4, uint64_t p5,
                                  uint64_t p6, uint64_t p7, uint64_t p8);
  virtual void cancelRequest(const Request& request);
 
  static void cancelReceive(uintptr_t buffer, Network* card, size_t generation);
 
  static constexpr size_t ReceiveRequestCapacity = 256;
 
  Vector<Network*> m_Children;
 
  MemoryPool m_MemPool;
 
#if THREADS || UTILITY_LINUX
  Mutex m_Lock;
#endif
 
  Tree<Network*, struct netif*> m_Interfaces;
 
  size_t m_NextInterfaceNumber;
 
  size_t m_NextDeviceGeneration;
 
  PreallocatedRequest m_ReceiveRequests[ReceiveRequestCapacity];
 
  Atomic<size_t> m_NextReceiveRequest;
 
  Tree<Network*, DeviceRegistration*> m_Registrations;
};
 
#endif