9a2d7d3b6a
The SharedMemObject class template contains a fair amount of inline code that does not depend on the template types T. To avoid duplicating it in every template specialization, split that code to a separate base SharedMem class. We don't define copy semantics for the classes (we don't need one at the moment) and we make them non-copyable since the default copy constructor would lead to use-after-unmap. Doxygen documentation by Dennis Bonke and Andrei Konovalov. Reviewed-by: Pavel Machek <pavel@ucw.cz> Reviewed-by: Milan Zamazal <mzamazal@redhat.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Co-developed-by: Dennis Bonke <admin@dennisbonke.com> Signed-off-by: Dennis Bonke <admin@dennisbonke.com> Signed-off-by: Andrei Konovalov <andrey.konovalov.ynk@gmail.com> Signed-off-by: Hans de Goede <hdegoede@redhat.com> Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
128 lines
2.0 KiB
C++
128 lines
2.0 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2023 Raspberry Pi Ltd
|
|
* Copyright (C) 2024 Andrei Konovalov
|
|
* Copyright (C) 2024 Dennis Bonke
|
|
*
|
|
* shared_mem_object.h - Helpers for shared memory allocations
|
|
*/
|
|
#pragma once
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <sys/mman.h>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include <libcamera/base/class.h>
|
|
#include <libcamera/base/shared_fd.h>
|
|
#include <libcamera/base/span.h>
|
|
|
|
namespace libcamera {
|
|
|
|
class SharedMem
|
|
{
|
|
public:
|
|
SharedMem();
|
|
|
|
SharedMem(const std::string &name, std::size_t size);
|
|
SharedMem(SharedMem &&rhs);
|
|
|
|
virtual ~SharedMem();
|
|
|
|
SharedMem &operator=(SharedMem &&rhs);
|
|
|
|
const SharedFD &fd() const
|
|
{
|
|
return fd_;
|
|
}
|
|
|
|
Span<uint8_t> mem() const
|
|
{
|
|
return mem_;
|
|
}
|
|
|
|
explicit operator bool() const
|
|
{
|
|
return !mem_.empty();
|
|
}
|
|
|
|
private:
|
|
LIBCAMERA_DISABLE_COPY(SharedMem)
|
|
|
|
SharedFD fd_;
|
|
|
|
Span<uint8_t> mem_;
|
|
};
|
|
|
|
template<class T, typename = std::enable_if_t<std::is_standard_layout<T>::value>>
|
|
class SharedMemObject : public SharedMem
|
|
{
|
|
public:
|
|
static constexpr std::size_t kSize = sizeof(T);
|
|
|
|
SharedMemObject()
|
|
: SharedMem(), obj_(nullptr)
|
|
{
|
|
}
|
|
|
|
template<class... Args>
|
|
SharedMemObject(const std::string &name, Args &&...args)
|
|
: SharedMem(name, kSize), obj_(nullptr)
|
|
{
|
|
if (mem().empty())
|
|
return;
|
|
|
|
obj_ = new (mem().data()) T(std::forward<Args>(args)...);
|
|
}
|
|
|
|
SharedMemObject(SharedMemObject<T> &&rhs)
|
|
: SharedMem(std::move(rhs))
|
|
{
|
|
this->obj_ = rhs.obj_;
|
|
rhs.obj_ = nullptr;
|
|
}
|
|
|
|
~SharedMemObject()
|
|
{
|
|
if (obj_)
|
|
obj_->~T();
|
|
}
|
|
|
|
SharedMemObject<T> &operator=(SharedMemObject<T> &&rhs)
|
|
{
|
|
SharedMem::operator=(std::move(rhs));
|
|
this->obj_ = rhs.obj_;
|
|
rhs.obj_ = nullptr;
|
|
return *this;
|
|
}
|
|
|
|
T *operator->()
|
|
{
|
|
return obj_;
|
|
}
|
|
|
|
const T *operator->() const
|
|
{
|
|
return obj_;
|
|
}
|
|
|
|
T &operator*()
|
|
{
|
|
return *obj_;
|
|
}
|
|
|
|
const T &operator*() const
|
|
{
|
|
return *obj_;
|
|
}
|
|
|
|
private:
|
|
LIBCAMERA_DISABLE_COPY(SharedMemObject)
|
|
|
|
T *obj_;
|
|
};
|
|
|
|
} /* namespace libcamera */
|