Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#ifndef QOBJECT_P_P_H
#define QOBJECT_P_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of qobject.cpp. This header file may change from version to version
// without notice, or even be removed.
//
// We mean it.
//
// Even though this file is only used by qobject.cpp, the only reason this
// code lives here is that some special apps/libraries for e.g., QtJambi,
// Gammaray need access to the structs in this file.
#include <QtCore/qalloc.h>
#include <QtCore/qobject.h>
#include <QtCore/private/qobject_p.h>
QT_BEGIN_NAMESPACE
// ConnectionList is a singly-linked list
struct QObjectPrivate::ConnectionList
{
QAtomicPointer<Connection> first;
QAtomicPointer<Connection> last;
};
static_assert(std::is_trivially_destructible_v<QObjectPrivate::ConnectionList>);
Q_DECLARE_TYPEINFO(QObjectPrivate::ConnectionList, Q_RELOCATABLE_TYPE);
struct QObjectPrivate::TaggedSignalVector
{
quintptr c;
TaggedSignalVector() = default;
TaggedSignalVector(std::nullptr_t) noexcept : c(0) {}
TaggedSignalVector(Connection *v) noexcept : c(reinterpret_cast<quintptr>(v)) { Q_ASSERT(v && (reinterpret_cast<quintptr>(v) & 0x1) == 0); }
TaggedSignalVector(SignalVector *v) noexcept : c(reinterpret_cast<quintptr>(v) | quintptr(1u)) { Q_ASSERT(v); }
explicit operator SignalVector *() const noexcept
{
if (c & 0x1)
return reinterpret_cast<SignalVector *>(c & ~quintptr(1u));
return nullptr;
}
explicit operator Connection *() const noexcept
{
return reinterpret_cast<Connection *>(c);
}
operator uintptr_t() const noexcept { return c; }
};
struct QObjectPrivate::ConnectionOrSignalVector
{
union {
// linked list of orphaned connections that need cleaning up
TaggedSignalVector nextInOrphanList;
// linked list of connections connected to slots in this object
Connection *next;
};
};
static_assert(std::is_trivially_copyable_v<QObjectPrivate::ConnectionOrSignalVector>);
struct QObjectPrivate::Connection : public ConnectionOrSignalVector
{
// linked list of connections connected to slots in this object, next is in base class
Connection **prev;
// linked list of connections connected to signals in this object
QAtomicPointer<Connection> nextConnectionList;
Connection *prevConnectionList;
QObject *sender;
QAtomicPointer<QObject> receiver;
QAtomicPointer<QThreadData> receiverThreadData;
union {
StaticMetaCallFunction callFunction;
QtPrivate::QSlotObjectBase *slotObj;
};
QAtomicPointer<const int> argumentTypes;
QAtomicInt ref_{
2
}; // ref_ is 2 for the use in the internal lists, and for the use in QMetaObject::Connection
QAtomicInteger<uint> id{0};
ushort method_offset;
ushort method_relative;
signed int signal_index : 27; // In signal range (see QObjectPrivate::signalIndex())
ushort connectionType : 2; // 0 == auto, 1 == direct, 2 == queued, 3 == blocking
ushort isSlotObject : 1;
ushort ownArgumentTypes : 1;
ushort isSingleShot : 1;
Connection() : ownArgumentTypes(true) {
receiver.storeRelaxed(nullptr);
receiverThreadData.storeRelaxed(nullptr);
}
~Connection();
int method() const
{
Q_ASSERT(!isSlotObject);
return method_offset + method_relative;
}
void ref() { ref_.ref(); }
void freeSlotObject()
{
if (isSlotObject) {
slotObj->destroyIfLastRef();
isSlotObject = false;
}
}
void deref()
{
if (!ref_.deref()) {
Q_ASSERT(!receiver.loadRelaxed());
Q_ASSERT(!isSlotObject);
delete this;
}
}
};
Q_DECLARE_TYPEINFO(QObjectPrivate::Connection, Q_RELOCATABLE_TYPE);
struct QObjectPrivate::SignalVector : public ConnectionOrSignalVector
{
quintptr allocated;
// ConnectionList signals[]
ConnectionList &at(int i) { return reinterpret_cast<ConnectionList *>(this + 1)[i + 1]; }
const ConnectionList &at(int i) const
{
return reinterpret_cast<const ConnectionList *>(this + 1)[i + 1];
}
int count() const { return static_cast<int>(allocated); }
};
// it doesn't need to be, but it helps
static_assert(std::is_trivially_copyable_v<QObjectPrivate::SignalVector>);
struct QObjectPrivate::ConnectionData
{
// the id below is used to avoid activating new connections. When the object gets
// deleted it's set to 0, so that signal emission stops
QAtomicInteger<uint> currentConnectionId;
QAtomicInt ref;
QAtomicPointer<SignalVector> signalVector;
Connection *senders = nullptr;
Sender *currentSender = nullptr; // object currently activating the object
std::atomic<TaggedSignalVector> orphaned = {nullptr};
~ConnectionData()
{
Q_ASSERT(ref.loadRelaxed() == 0);
TaggedSignalVector c = orphaned.exchange(nullptr, std::memory_order_relaxed);
if (c)
deleteOrphaned(c);
SignalVector *v = signalVector.loadRelaxed();
if (v) {
const size_t allocSize = sizeof(SignalVector) + (v->allocated + 1) * sizeof(ConnectionList);
v->~SignalVector();
QtPrivate::sizedFree(v, allocSize);
}
}
// must be called on the senders connection data
// assumes the senders and receivers lock are held
void removeConnection(Connection *c);
enum LockPolicy {
NeedToLock,
// Beware that we need to temporarily release the lock
// and thus calling code must carefully consider whether
// invariants still hold.
AlreadyLockedAndTemporarilyReleasingLock
};
void cleanOrphanedConnections(QObject *sender, LockPolicy lockPolicy = NeedToLock)
{
if (orphaned.load(std::memory_order_relaxed) && ref.loadAcquire() == 1)
cleanOrphanedConnectionsImpl(sender, lockPolicy);
}
void cleanOrphanedConnectionsImpl(QObject *sender, LockPolicy lockPolicy);
ConnectionList &connectionsForSignal(int signal)
{
return signalVector.loadRelaxed()->at(signal);
}
void resizeSignalVector(size_t size)
{
SignalVector *vector = this->signalVector.loadRelaxed();
if (vector && vector->allocated > size)
return;
size = (size + 7) & ~7;
void *ptr = QtPrivate::fittedMalloc(sizeof(SignalVector), &size, sizeof(ConnectionList), 1);
auto newVector = new (ptr) SignalVector;
int start = -1;
if (vector) {
for (int i = -1; i < vector->count(); ++i) {
new (&newVector->at(i)) ConnectionList{vector->at(i).first.loadRelaxed(),
vector->at(i).last.loadRelaxed()};
}
start = vector->count();
}
for (int i = start; i < int(size); ++i)
new (&newVector->at(i)) ConnectionList();
newVector->next = nullptr;
newVector->allocated = size;
signalVector.storeRelease(newVector);
if (vector) {
TaggedSignalVector o = nullptr;
/* No ABA issue here: When adding a node, we only care about the list head, it doesn't
* matter if the tail changes.
*/
o = orphaned.load(std::memory_order_acquire);
do {
vector->nextInOrphanList = o;
} while (!orphaned.compare_exchange_strong(o, TaggedSignalVector(vector), std::memory_order_release));
}
}
int signalVectorCount() const
{
SignalVector *v = signalVector.loadAcquire();
return v ? v->count() : -1;
}
static void deleteOrphaned(TaggedSignalVector o);
};
struct QObjectPrivate::Sender
{
Sender(QObject *receiver, QObject *sender, int signal, ConnectionData *receiverConnections)
: receiver(receiver), sender(sender), signal(signal)
{
if (receiverConnections) {
previous = receiverConnections->currentSender;
receiverConnections->currentSender = this;
}
}
~Sender()
{
if (receiver)
receiver->d_func()->connections.loadAcquire()->currentSender = previous;
}
void receiverDeleted()
{
Sender *s = this;
while (s) {
s->receiver = nullptr;
s = s->previous;
}
}
Sender *previous = nullptr;
QObject *receiver;
QObject *sender;
int signal;
};
Q_DECLARE_TYPEINFO(QObjectPrivate::Sender, Q_RELOCATABLE_TYPE);
QT_END_NAMESPACE
#endif