Change sendfile() to use the new m_ext callback scheme for cleaning up after
[dragonfly.git] / sys / sys / kobj.h
1 /*-
2  * Copyright (c) 2000 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/sys/kobj.h,v 1.8 2003/09/22 21:32:49 peter Exp $
27  * $DragonFly: src/sys/sys/kobj.h,v 1.7 2004/04/14 18:28:29 joerg Exp $
28  */
29
30 #ifndef _SYS_KOBJ_H_
31 #define _SYS_KOBJ_H_
32
33 /*
34  * Forward declarations
35  */
36 typedef struct kobj             *kobj_t;
37 typedef struct kobj_class       *kobj_class_t;
38 typedef struct kobj_method      kobj_method_t;
39 typedef int                     (*kobjop_t)(void);
40 typedef struct kobj_ops         *kobj_ops_t;
41 typedef struct kobjop_desc      *kobjop_desc_t;
42 struct malloc_type;
43
44 struct kobj_method {
45         kobjop_desc_t   desc;
46         kobjop_t        func;
47 };
48
49 /*
50  * A class is simply a method table and a sizeof value. When the first
51  * instance of the class is created, the method table will be compiled
52  * into a form more suited to efficient method dispatch. This compiled
53  * method table is always the first field of the object.
54  */
55 #define KOBJ_CLASS_FIELDS                                               \
56         const char      *name;          /* class name */                \
57         kobj_method_t   *methods;       /* method table */              \
58         size_t          size;           /* object size */               \
59         kobj_class_t    *baseclasses;   /* base classes */              \
60         u_int           refs;           /* reference count */           \
61         kobj_ops_t      ops             /* compiled method table */
62
63 struct kobj_class {
64         KOBJ_CLASS_FIELDS;
65 };
66
67 /*
68  * Implementation of kobj.
69  */
70 #define KOBJ_FIELDS                             \
71         kobj_ops_t      ops
72
73 struct kobj {
74         KOBJ_FIELDS;
75 };
76
77 /*
78  * The ops table is used as a cache of results from kobj_lookup_method().
79  */
80
81 #define KOBJ_CACHE_SIZE 256
82
83 struct kobj_ops {
84         kobj_method_t   *cache[KOBJ_CACHE_SIZE];
85         kobj_class_t    cls;
86 };
87
88 struct kobjop_desc {
89         unsigned int    id;     /* unique ID */
90         kobj_method_t   *deflt; /* default implementation */
91 };
92
93 /*
94  * Shorthand for constructing method tables.
95  */
96 #define KOBJMETHOD(NAME, FUNC) { &NAME##_desc, (kobjop_t) FUNC }
97
98 /*
99  * Declare a class (which should be defined in another file.
100  */
101 #define DECLARE_CLASS(name) extern struct kobj_class name
102
103 /*
104  * Define a class with no base classes (api backward-compatible. with
105  * FreeBSD-5.1 and earlier).
106  */
107 #define DEFINE_CLASS(name, methods, size)               \
108 DEFINE_CLASS_0(name, name ## _class, methods, size)
109
110 /*
111  * Define a class with no base classes. Use like this:
112  *
113  * DEFINE_CLASS_0(foo, foo_class, foo_methods, sizeof(foo_softc));
114  */
115 #define DEFINE_CLASS_0(name, classvar, methods, size)   \
116                                                         \
117 struct kobj_class classvar = {                          \
118         #name, methods, size, 0                         \
119 }
120
121 /*
122  * Define a class inheriting a single base class. Use like this:
123  *
124  * DEFINE_CLASS1(foo, foo_class, foo_methods, sizeof(foo_softc),
125  *                        bar);
126  */
127 #define DEFINE_CLASS_1(name, classvar, methods, size,   \
128                        base1)                           \
129                                                         \
130 static kobj_class_t name ## _baseclasses[] = {          \
131         &base1, 0                                       \
132 };                                                      \
133 struct kobj_class classvar = {                          \
134         #name, methods, size, name ## _baseclasses      \
135 }
136
137 /*
138  * Define a class inheriting two base classes. Use like this:
139  *
140  * DEFINE_CLASS2(foo, foo_class, foo_methods, sizeof(foo_softc),
141  *                        bar, baz);
142  */
143 #define DEFINE_CLASS_2(name, methods, size,             \
144                        base1, base2)                    \
145                                                         \
146 static kobj_class_t name ## _baseclasses[] = {          \
147         &base1,                                         \
148         &base2, 0                                       \
149 };                                                      \
150 struct kobj_class name ## _class = {                    \
151         #name, methods, size, name ## _baseclasses      \
152 }
153  
154 /*
155  * Define a class inheriting three base classes. Use like this:
156  *
157  * DEFINE_CLASS3(foo, foo_class, foo_methods, sizeof(foo_softc),
158  *                        bar, baz, foobar);
159  */
160 #define DEFINE_CLASS_3(name, methods, size,             \
161                        base1, base2, base3)             \
162                                                         \
163 static kobj_class_t name ## _baseclasses[] = {          \
164         &base1,                                         \
165         &base2,                                         \
166         &base3, 0                                       \
167 };                                                      \
168 struct kobj_class name ## _class = {                    \
169         #name, methods, size, name ## _baseclasses      \
170 }
171
172 /*
173  * Compile class for the first instance and add a reference.
174  */
175 void            kobj_class_instantiate(kobj_class_t cls);
176
177 /*
178  * Remove a reference and free method table with the last instance.
179  */
180 void            kobj_class_uninstantiate(kobj_class_t cls);
181
182 /*
183  * Allocate memory for and initialise a new object.
184  */
185 kobj_t          kobj_create(kobj_class_t cls,
186                             struct malloc_type *mtype,
187                             int mflags);
188
189 /*
190  * Initialise a pre-allocated object.
191  */
192 void            kobj_init(kobj_t obj, kobj_class_t cls);
193
194 /*
195  * Delete an object. If mtype is non-zero, free the memory.
196  */
197 void            kobj_delete(kobj_t obj, struct malloc_type *mtype);
198
199 /*
200  * Maintain stats on hits/misses in lookup caches.
201  */
202 #ifdef KOBJ_STATS
203 extern u_int kobj_lookup_hits;
204 extern u_int kobj_lookup_misses;
205 #endif
206
207 /*
208  * Lookup the method in the cache and if it isn't there look it up the
209  * slow way.
210  */
211 #ifdef KOBJ_STATS
212 #define KOBJOPLOOKUP(OPS,OP) do {                                       \
213         kobjop_desc_t _desc = &OP##_##desc;                             \
214         kobj_method_t **_cep =                                          \
215             &OPS->cache[_desc->id & (KOBJ_CACHE_SIZE-1)];               \
216         kobj_method_t *_ce = *_cep;                                     \
217         kobj_lookup_hits++; /* assume hit */                            \
218         if (_ce->desc != _desc)                                         \
219                 _ce = kobj_lookup_method(OPS->cls,                      \
220                                          _cep, _desc);                  \
221         _m = _ce->func;                                                 \
222 } while(0)
223 #else
224 #define KOBJOPLOOKUP(OPS,OP) do {                                       \
225         kobjop_desc_t _desc = &OP##_##desc;                             \
226         kobj_method_t **_cep =                                          \
227             &OPS->cache[_desc->id & (KOBJ_CACHE_SIZE-1)];               \
228         kobj_method_t *_ce = *_cep;                                     \
229         if (_ce->desc != _desc)                                         \
230                 _ce = kobj_lookup_method(OPS->cls,                      \
231                                          _cep, _desc);                  \
232         _m = _ce->func;                                                 \
233 } while(0)
234 #endif
235
236 kobj_method_t *kobj_lookup_method(kobj_class_t cls,
237                                   kobj_method_t **cep,
238                                   kobjop_desc_t desc);
239
240 /*
241  * Default method implementation. Returns ENXIO.
242  */
243 int kobj_error_method(void);
244
245 #endif /* !_SYS_KOBJ_H_ */