[qemu.git] / include / qemu / rfifolock.h

/*
 * Recursive FIFO lock
 *
 * Copyright Red Hat, Inc. 2013
 *
 * Authors:
 *  Stefan Hajnoczi   <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 */

#ifndef QEMU_RFIFOLOCK_H
#define QEMU_RFIFOLOCK_H

#include "qemu/thread.h"

/* Recursive FIFO lock
 *
 * This lock provides more features than a plain mutex:
 *
 * 1. Fairness - enforces FIFO order.
 * 2. Nesting - can be taken recursively.
 * 3. Contention callback - optional, called when thread must wait.
 *
 * The recursive FIFO lock is heavyweight so prefer other synchronization
 * primitives if you do not need its features.
 */
typedef struct {
    QemuMutex lock;             /* protects all fields */

    /* FIFO order */
    unsigned int head;          /* active ticket number */
    unsigned int tail;          /* waiting ticket number */
    QemuCond cond;              /* used to wait for our ticket number */

    /* Nesting */
    QemuThread owner_thread;    /* thread that currently has ownership */
    unsigned int nesting;       /* amount of nesting levels */

    /* Contention callback */
    void (*cb)(void *);         /* called when thread must wait, with ->lock
                                 * held so it may not recursively lock/unlock
                                 */
    void *cb_opaque;
} RFifoLock;

void rfifolock_init(RFifoLock *r, void (*cb)(void *), void *opaque);
void rfifolock_destroy(RFifoLock *r);
void rfifolock_lock(RFifoLock *r);
void rfifolock_unlock(RFifoLock *r);

#endif /* QEMU_RFIFOLOCK_H */
Commit	Line	Data
2da61b67 SH	1	/*
	2	* Recursive FIFO lock
	3	*
	4	* Copyright Red Hat, Inc. 2013
	5	*
	6	* Authors:
	7	* Stefan Hajnoczi <[email protected]>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*
	12	*/
	13
	14	#ifndef QEMU_RFIFOLOCK_H
	15	#define QEMU_RFIFOLOCK_H
	16
	17	#include "qemu/thread.h"
	18
	19	/* Recursive FIFO lock
	20	*
	21	* This lock provides more features than a plain mutex:
	22	*
	23	* 1. Fairness - enforces FIFO order.
	24	* 2. Nesting - can be taken recursively.
	25	* 3. Contention callback - optional, called when thread must wait.
	26	*
	27	* The recursive FIFO lock is heavyweight so prefer other synchronization
	28	* primitives if you do not need its features.
	29	*/
	30	typedef struct {
	31	QemuMutex lock; /* protects all fields */
	32
	33	/* FIFO order */
	34	unsigned int head; /* active ticket number */
	35	unsigned int tail; /* waiting ticket number */
	36	QemuCond cond; /* used to wait for our ticket number */
	37
	38	/* Nesting */
	39	QemuThread owner_thread; /* thread that currently has ownership */
	40	unsigned int nesting; /* amount of nesting levels */
	41
	42	/* Contention callback */
	43	void (cb)(void ); /* called when thread must wait, with ->lock
	44	* held so it may not recursively lock/unlock
	45	*/
	46	void *cb_opaque;
	47	} RFifoLock;
	48
	49	void rfifolock_init(RFifoLock r, void (cb)(void ), void opaque);
	50	void rfifolock_destroy(RFifoLock *r);
	51	void rfifolock_lock(RFifoLock *r);
	52	void rfifolock_unlock(RFifoLock *r);
	53
	54	#endif /* QEMU_RFIFOLOCK_H */