[deliverable/linux.git] / include / linux / slow-work.h

/* Worker thread pool for slow items, such as filesystem lookups or mkdirs
 *
 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 *
 * See Documentation/slow-work.txt
 */

#ifndef _LINUX_SLOW_WORK_H
#define _LINUX_SLOW_WORK_H

#ifdef CONFIG_SLOW_WORK

#include <linux/sysctl.h>

struct slow_work;

/*
 * The operations used to support slow work items
 */
struct slow_work_ops {
	/* get a ref on a work item
	 * - return 0 if successful, -ve if not
	 */
	int (*get_ref)(struct slow_work *work);

	/* discard a ref to a work item */
	void (*put_ref)(struct slow_work *work);

	/* execute a work item */
	void (*execute)(struct slow_work *work);
};

/*
 * A slow work item
 * - A reference is held on the parent object by the thread pool when it is
 *   queued
 */
struct slow_work {
	unsigned long		flags;
#define SLOW_WORK_PENDING	0	/* item pending (further) execution */
#define SLOW_WORK_EXECUTING	1	/* item currently executing */
#define SLOW_WORK_ENQ_DEFERRED	2	/* item enqueue deferred */
#define SLOW_WORK_VERY_SLOW	3	/* item is very slow */
	const struct slow_work_ops *ops; /* operations table for this item */
	struct list_head	link;	/* link in queue */
};

/**
 * slow_work_init - Initialise a slow work item
 * @work: The work item to initialise
 * @ops: The operations to use to handle the slow work item
 *
 * Initialise a slow work item.
 */
static inline void slow_work_init(struct slow_work *work,
				  const struct slow_work_ops *ops)
{
	work->flags = 0;
	work->ops = ops;
	INIT_LIST_HEAD(&work->link);
}

/**
 * vslow_work_init - Initialise a very slow work item
 * @work: The work item to initialise
 * @ops: The operations to use to handle the slow work item
 *
 * Initialise a very slow work item.  This item will be restricted such that
 * only a certain number of the pool threads will be able to execute items of
 * this type.
 */
static inline void vslow_work_init(struct slow_work *work,
				   const struct slow_work_ops *ops)
{
	work->flags = 1 << SLOW_WORK_VERY_SLOW;
	work->ops = ops;
	INIT_LIST_HEAD(&work->link);
}

extern int slow_work_enqueue(struct slow_work *work);
extern int slow_work_register_user(void);
extern void slow_work_unregister_user(void);

#ifdef CONFIG_SYSCTL
extern ctl_table slow_work_sysctls[];
#endif

#endif /* CONFIG_SLOW_WORK */
#endif /* _LINUX_SLOW_WORK_H */
Commit	Line	Data
07fe7cb7 DH	1	/* Worker thread pool for slow items, such as filesystem lookups or mkdirs
	2	*
	3	* Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
8f0aa2f2 DH	10	*
8f0aa2f2 DH	11	* See Documentation/slow-work.txt
07fe7cb7 DH	12	*/
	13
	14	#ifndef _LINUX_SLOW_WORK_H
	15	#define _LINUX_SLOW_WORK_H
	16
	17	#ifdef CONFIG_SLOW_WORK
	18
12e22c5e DH	19	#include <linux/sysctl.h>
12e22c5e DH	20
07fe7cb7 DH	21	struct slow_work;
	22
	23	/*
	24	* The operations used to support slow work items
	25	*/
	26	struct slow_work_ops {
	27	/* get a ref on a work item
	28	* - return 0 if successful, -ve if not
	29	*/
	30	int (get_ref)(struct slow_work work);
	31
	32	/* discard a ref to a work item */
	33	void (put_ref)(struct slow_work work);
	34
	35	/* execute a work item */
	36	void (execute)(struct slow_work work);
	37	};
	38
	39	/*
	40	* A slow work item
	41	* - A reference is held on the parent object by the thread pool when it is
	42	* queued
	43	*/
	44	struct slow_work {
	45	unsigned long flags;
	46	#define SLOW_WORK_PENDING 0 /* item pending (further) execution */
	47	#define SLOW_WORK_EXECUTING 1 /* item currently executing */
	48	#define SLOW_WORK_ENQ_DEFERRED 2 /* item enqueue deferred */
	49	#define SLOW_WORK_VERY_SLOW 3 /* item is very slow */
	50	const struct slow_work_ops ops; / operations table for this item */
	51	struct list_head link; /* link in queue */
	52	};
	53
	54	/**
	55	* slow_work_init - Initialise a slow work item
	56	* @work: The work item to initialise
	57	* @ops: The operations to use to handle the slow work item
	58	*
	59	* Initialise a slow work item.
	60	*/
	61	static inline void slow_work_init(struct slow_work *work,
	62	const struct slow_work_ops *ops)
	63	{
	64	work->flags = 0;
	65	work->ops = ops;
	66	INIT_LIST_HEAD(&work->link);
	67	}
	68
	69	/**
5dd559f0	70	* vslow_work_init - Initialise a very slow work item
07fe7cb7 DH	71	* @work: The work item to initialise
	72	* @ops: The operations to use to handle the slow work item
	73	*
	74	* Initialise a very slow work item. This item will be restricted such that
	75	* only a certain number of the pool threads will be able to execute items of
	76	* this type.
	77	*/
	78	static inline void vslow_work_init(struct slow_work *work,
	79	const struct slow_work_ops *ops)
	80	{
	81	work->flags = 1 << SLOW_WORK_VERY_SLOW;
	82	work->ops = ops;
	83	INIT_LIST_HEAD(&work->link);
	84	}
	85
	86	extern int slow_work_enqueue(struct slow_work *work);
	87	extern int slow_work_register_user(void);
	88	extern void slow_work_unregister_user(void);
	89
12e22c5e DH	90	#ifdef CONFIG_SYSCTL
	91	extern ctl_table slow_work_sysctls[];
	92	#endif
07fe7cb7 DH	93
	94	#endif /* CONFIG_SLOW_WORK */
	95	#endif /* _LINUX_SLOW_WORK_H */