summaryrefslogtreecommitdiff
path: root/include/linux/dma-buf.h
diff options
context:
space:
mode:
authorHirokazu Honda <hiroh@chromium.org>2021-04-03 22:57:34 +0900
committerLaurent Pinchart <laurent.pinchart@ideasonboard.com>2021-04-20 05:59:08 +0300
commitd40430116b1b65d8deeeeea106368e20d8534a03 (patch)
tree02e20a38f4307f7f701b7d6ead58fa168f238937 /include/linux/dma-buf.h
parent0b661d70ec62d69ffd4ea7bb0aeb92d7ad12b8d3 (diff)
android: CameraDevice: Fix Camera3RequestDescriptor leakage
CameraDevice creates Camera3RequestDescriptor in processCaptureRequest() and disallocates in requestComplete(). Camera3RequestDescriptor can never be destroyed if requestComplete() is never called. This avoid the memory leakage by storing them in map CameraRequestDescriptor. Signed-off-by: Hirokazu Honda <hiroh@chromium.org> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Diffstat (limited to 'include/linux/dma-buf.h')
0 files changed, 0 insertions, 0 deletions
d='n127' href='#n127'>127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * ipc_pipe.cpp - Image Processing Algorithm IPC module for IPA proxies
 */

#include "libcamera/internal/ipc_pipe.h"

#include <libcamera/base/log.h>

/**
 * \file ipc_pipe.h
 * \brief IPC mechanism for IPA isolation
 */

namespace libcamera {

LOG_DEFINE_CATEGORY(IPCPipe)

/**
 * \struct IPCMessage::Header
 * \brief Container for an IPCMessage header
 *
 * Holds a cmd code for the IPC message, and a cookie.
 */

/**
 * \var IPCMessage::Header::cmd
 * \brief Type of IPCMessage
 *
 * Typically used to carry a command code for an RPC.
 */

/**
 * \var IPCMessage::Header::cookie
 * \brief Cookie to identify the message and a corresponding reply.
 *
 * Populated and used by IPCPipe implementations for matching calls with
 * replies.
 */

/**
 * \class IPCMessage
 * \brief IPC message to be passed through IPC message pipe
 */

/**
 * \brief Construct an empty IPCMessage instance
 */
IPCMessage::IPCMessage()
	: header_(Header{ 0, 0 })
{
}

/**
 * \brief Construct an IPCMessage instance with a given command code
 * \param[in] cmd The command code
 */
IPCMessage::IPCMessage(uint32_t cmd)
	: header_(Header{ cmd, 0 })
{
}

/**
 * \brief Construct an IPCMessage instance with a given header
 * \param[in] header The header that the constructed IPCMessage will contain
 */
IPCMessage::IPCMessage(const Header &header)
	: header_(header)
{
}

/**
 * \brief Construct an IPCMessage instance from an IPC payload
 * \param[in] payload The IPCUnixSocket payload to construct from
 *
 * This essentially converts an IPCUnixSocket payload into an IPCMessage.
 * The header is extracted from the payload into the IPCMessage's header field.
 *
 * If the IPCUnixSocket payload had any valid file descriptors, then they will
 * all be invalidated.
 */
IPCMessage::IPCMessage(IPCUnixSocket::Payload &payload)
{
	memcpy(&header_, payload.data.data(), sizeof(header_));
	data_ = std::vector<uint8_t>(payload.data.begin() + sizeof(header_),
				     payload.data.end());
	for (int32_t &fd : payload.fds)
		fds_.push_back(SharedFD(std::move(fd)));
}

/**
 * \brief Create an IPCUnixSocket payload from the IPCMessage
 *
 * This essentially converts the IPCMessage into an IPCUnixSocket payload.
 *
 * \todo Resolve the layering violation (add other converters later?)
 */
IPCUnixSocket::Payload IPCMessage::payload() const
{
	IPCUnixSocket::Payload payload;

	payload.data.resize(sizeof(Header) + data_.size());
	payload.fds.reserve(fds_.size());

	memcpy(payload.data.data(), &header_, sizeof(Header));

	if (data_.size() > 0) {
		/* \todo Make this work without copy */
		memcpy(payload.data.data() + sizeof(Header),
		       data_.data(), data_.size());
	}

	for (const SharedFD &fd : fds_)
		payload.fds.push_back(fd.get());

	return payload;
}

/**
 * \fn IPCMessage::header()
 * \brief Returns a reference to the header
 */

/**
 * \fn IPCMessage::data()
 * \brief Returns a reference to the byte vector containing data
 */

/**
 * \fn IPCMessage::fds()
 * \brief Returns a reference to the vector containing file descriptors
 */

/**
 * \fn IPCMessage::header() const
 * \brief Returns a const reference to the header
 */

/**
 * \fn IPCMessage::data() const
 * \brief Returns a const reference to the byte vector containing data
 */

/**
 * \fn IPCMessage::fds() const
 * \brief Returns a const reference to the vector containing file descriptors
 */

/**
 * \class IPCPipe
 * \brief IPC message pipe for IPA isolation
 *
 * Virtual class to model an IPC message pipe for use by IPA proxies for IPA
 * isolation. sendSync() and sendAsync() must be implemented, and the recvMessage
 * signal must be emitted whenever new data is available.