QEventDispatcherUNIXPrivate Class Reference

#include <qeventdispatcher_unix_p.h>

Inheritance diagram for QEventDispatcherUNIXPrivate:

Public Functions
int	doSelect (QEventLoop::ProcessEventsFlags flags, timeval *timeout)
virtual int	initThreadWakeUp ()
virtual int	processThreadWakeUp (int nsel)
	QEventDispatcherUNIXPrivate ()
	~QEventDispatcherUNIXPrivate ()
Public Functions inherited from QAbstractEventDispatcherPrivate
void	init ()
	QAbstractEventDispatcherPrivate ()
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
bool	interrupt
bool	mainThread
int	sn_highest
QSockNotType::List	sn_pending_list
QSockNotType	sn_vec [3]
int	thread_pipe [2]
QTimerInfoList	timerList
QAtomicInt	wakeUps
Public Variables inherited from QAbstractEventDispatcherPrivate
QAbstractEventDispatcher::EventFilter	event_filter
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QAbstractEventDispatcherPrivate
static int	allocateTimerId ()
static void	releaseTimerId (int id)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 177 of file qeventdispatcher_unix_p.h.

Constructors and Destructors

QEventDispatcherUNIXPrivate()

QEventDispatcherUNIXPrivate::QEventDispatcherUNIXPrivate

(

)

Definition at line 108 of file qeventdispatcher_unix.cpp.

{
    extern Qt::HANDLE qt_application_thread_id;
    mainThread = (QThread::currentThreadId() == qt_application_thread_id);
    bool pipefail = false;

    // initialize the common parts of the event loop
#if defined(Q_OS_NACL) || defined (Q_OS_BLACKBERRY)
   // do nothing.
#elif defined(Q_OS_INTEGRITY)
    // INTEGRITY doesn't like a "select" on pipes, so use socketpair instead
    if (socketpair(AF_INET, SOCK_STREAM, 0, thread_pipe) == -1) {
        perror("QEventDispatcherUNIXPrivate(): Unable to create socket pair");
        pipefail = true;
    } else {
        initThreadPipeFD(thread_pipe[0]);
        initThreadPipeFD(thread_pipe[1]);
    }
#elif defined(Q_OS_VXWORKS)
    char name[20];
    qsnprintf(name, sizeof(name), "/pipe/qt_%08x", int(taskIdSelf()));

    // make sure there is no pipe with this name
    pipeDevDelete(name, true);
    // create the pipe
    if (pipeDevCreate(name, 128 /*maxMsg*/, 1 /*maxLength*/) != OK) {
        perror("QEventDispatcherUNIXPrivate(): Unable to create thread pipe device");
        pipefail = true;
    } else {
        if ((thread_pipe[0] = open(name, O_RDWR, 0)) < 0) {
            perror("QEventDispatcherUNIXPrivate(): Unable to create thread pipe");
            pipefail = true;
        } else {
            initThreadPipeFD(thread_pipe[0]);
            thread_pipe[1] = thread_pipe[0];
        }
    }
#else
    if (qt_safe_pipe(thread_pipe, O_NONBLOCK) == -1) {
        perror("QEventDispatcherUNIXPrivate(): Unable to create thread pipe");
        pipefail = true;
    }
#endif

    if (pipefail)
        qFatal("QEventDispatcherUNIXPrivate(): Can not continue without a thread pipe");

    sn_highest = -1;

    interrupt = false;
}

~QEventDispatcherUNIXPrivate()

QEventDispatcherUNIXPrivate::~QEventDispatcherUNIXPrivate

(

)

Definition at line 160 of file qeventdispatcher_unix.cpp.

{
#if defined(Q_OS_NACL) || defined (Q_OS_BLACKBERRY)
   // do nothing.
#elif defined(Q_OS_VXWORKS)
    close(thread_pipe[0]);

    char name[20];
    qsnprintf(name, sizeof(name), "/pipe/qt_%08x", int(taskIdSelf()));

    pipeDevDelete(name, true);
#else
    // cleanup the common parts of the event loop
    close(thread_pipe[0]);
    close(thread_pipe[1]);
#endif

    // cleanup timers
    qDeleteAll(timerList);
}

Functions

doSelect()

int QEventDispatcherUNIXPrivate::doSelect	(	QEventLoop::ProcessEventsFlags	flags,
		timeval *	timeout
	)

Definition at line 181 of file qeventdispatcher_unix.cpp.

{
    Q_Q(QEventDispatcherUNIX);

    // needed in QEventDispatcherUNIX::select()
    timerList.updateCurrentTime();

    int nsel;
    do {
        if (mainThread) {
            while (signal_received) {
                signal_received = 0;
                for (int i = 0; i < NSIG; ++i) {
                    if (signals_fired[i]) {
                        signals_fired[i] = 0;
                        emit QCoreApplication::instance()->unixSignal(i);
                    }
                }
            }
        }

        // Process timers and socket notifiers - the common UNIX stuff
        int highest = 0;
        if (! (flags & QEventLoop::ExcludeSocketNotifiers) && (sn_highest >= 0)) {
            // return the highest fd we can wait for input on
                sn_vec[0].select_fds = sn_vec[0].enabled_fds;
                sn_vec[1].select_fds = sn_vec[1].enabled_fds;
                sn_vec[2].select_fds = sn_vec[2].enabled_fds;
            highest = sn_highest;
        } else {
            FD_ZERO(&sn_vec[0].select_fds);
            FD_ZERO(&sn_vec[1].select_fds);
            FD_ZERO(&sn_vec[2].select_fds);
        }

        int wakeUpFd = initThreadWakeUp();
        highest = qMax(highest, wakeUpFd);

        nsel = q->select(highest + 1,
                         &sn_vec[0].select_fds,
                         &sn_vec[1].select_fds,
                         &sn_vec[2].select_fds,
                         timeout);
    } while (nsel == -1 && (errno == EINTR || errno == EAGAIN));

    if (nsel == -1) {
        if (errno == EBADF) {
            // it seems a socket notifier has a bad fd... find out
            // which one it is and disable it
            fd_set fdset;
            timeval tm;
            tm.tv_sec = tm.tv_usec = 0l;

            for (int type = 0; type < 3; ++type) {
                QSockNotType::List &list = sn_vec[type].list;
                if (list.size() == 0)
                    continue;

                for (int i = 0; i < list.size(); ++i) {
                    QSockNot *sn = list[i];

                    FD_ZERO(&fdset);
                    FD_SET(sn->fd, &fdset);

                    int ret = -1;
                    do {
                        switch (type) {
                        case 0: // read
                            ret = select(sn->fd + 1, &fdset, 0, 0, &tm);
                            break;
                        case 1: // write
                            ret = select(sn->fd + 1, 0, &fdset, 0, &tm);
                            break;
                        case 2: // except
                            ret = select(sn->fd + 1, 0, 0, &fdset, &tm);
                            break;
                        }
                    } while (ret == -1 && (errno == EINTR || errno == EAGAIN));

                    if (ret == -1 && errno == EBADF) {
                        // disable the invalid socket notifier
                        static const char *t[] = { "Read", "Write", "Exception" };
                        qWarning("QSocketNotifier: Invalid socket %d and type '%s', disabling...",
                                 sn->fd, t[type]);
                        sn->obj->setEnabled(false);
                    }
                }
            }
        } else {
            // EINVAL... shouldn't happen, so let's complain to stderr
            // and hope someone sends us a bug report
            perror("select");
        }
    }

    int nevents = processThreadWakeUp(nsel);

    // activate socket notifiers
    if (! (flags & QEventLoop::ExcludeSocketNotifiers) && nsel > 0 && sn_highest >= 0) {
        // if select says data is ready on any socket, then set the socket notifier
        // to pending
        for (int i=0; i<3; i++) {
            QSockNotType::List &list = sn_vec[i].list;
            for (int j = 0; j < list.size(); ++j) {
                QSockNot *sn = list[j];
                if (FD_ISSET(sn->fd, &sn_vec[i].select_fds))
                    q->setSocketNotifierPending(sn->obj);
            }
        }
    }
    return (nevents + q->activateSocketNotifiers());
}

initThreadWakeUp()

int QEventDispatcherUNIXPrivate::initThreadWakeUp ( )

virtual

Reimplemented in QEventDispatcherBlackberryPrivate.

Definition at line 294 of file qeventdispatcher_unix.cpp.

Referenced by doSelect().

{
    FD_SET(thread_pipe[0], &sn_vec[0].select_fds);
    return thread_pipe[0];
}

processThreadWakeUp()

int QEventDispatcherUNIXPrivate::processThreadWakeUp ( int  nsel )

virtual

Reimplemented in QEventDispatcherBlackberryPrivate.

Definition at line 300 of file qeventdispatcher_unix.cpp.

Referenced by doSelect().

{
    if (nsel > 0 && FD_ISSET(thread_pipe[0], &sn_vec[0].select_fds)) {
        // some other thread woke us up... consume the data on the thread pipe so that
        // select doesn't immediately return next time
#if defined(Q_OS_VXWORKS)
        char c[16];
        ::read(thread_pipe[0], c, sizeof(c));
        ::ioctl(thread_pipe[0], FIOFLUSH, 0);
#else
        char c[16];
        while (::read(thread_pipe[0], c, sizeof(c)) > 0)
            ;
#endif
        if (!wakeUps.testAndSetRelease(1, 0)) {
            // hopefully, this is dead code
            qWarning("QEventDispatcherUNIX: internal error, wakeUps.testAndSetRelease(1, 0) failed!");
        }
        return 1;
    }
    return 0;
}

Properties

interrupt

bool QEventDispatcherUNIXPrivate::interrupt

Definition at line 203 of file qeventdispatcher_unix_p.h.

Referenced by QEventDispatcherUNIXPrivate().

mainThread

bool QEventDispatcherUNIXPrivate::mainThread

Definition at line 189 of file qeventdispatcher_unix_p.h.

Referenced by doSelect(), and QEventDispatcherUNIXPrivate().

sn_highest

int QEventDispatcherUNIXPrivate::sn_highest

Definition at line 193 of file qeventdispatcher_unix_p.h.

Referenced by doSelect(), and QEventDispatcherUNIXPrivate().

sn_pending_list

QSockNotType::List QEventDispatcherUNIXPrivate::sn_pending_list

Definition at line 200 of file qeventdispatcher_unix_p.h.

sn_vec

QSockNotType QEventDispatcherUNIXPrivate::sn_vec[3]

Definition at line 195 of file qeventdispatcher_unix_p.h.

Referenced by doSelect(), initThreadWakeUp(), and processThreadWakeUp().

thread_pipe

int QEventDispatcherUNIXPrivate::thread_pipe[2]

Definition at line 190 of file qeventdispatcher_unix_p.h.

Referenced by initThreadWakeUp(), processThreadWakeUp(), QEventDispatcherUNIXPrivate(), and ~QEventDispatcherUNIXPrivate().

timerList

QTimerInfoList QEventDispatcherUNIXPrivate::timerList

Definition at line 197 of file qeventdispatcher_unix_p.h.

Referenced by doSelect(), and ~QEventDispatcherUNIXPrivate().

wakeUps

QAtomicInt QEventDispatcherUNIXPrivate::wakeUps

Definition at line 202 of file qeventdispatcher_unix_p.h.

Referenced by QEventDispatcherBlackberryPrivate::processThreadWakeUp(), and processThreadWakeUp().

---

The documentation for this class was generated from the following files:

• /src/corelib/kernel/qeventdispatcher_unix_p.h
• /src/corelib/kernel/qeventdispatcher_unix.cpp