Print this page
NEX-13644 File access audit logging
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-16824 SMB client connection setup rework
NEX-17232 SMB client reconnect failures
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
and: (improve debug)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/ia32/ml/modstubs.s
+++ new/usr/src/uts/intel/ia32/ml/modstubs.s
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 * Copyright (c) 2017, Joyent, Inc. All rights reserved.
25 + * Copyright 2018 Nexenta Systems, Inc. All rights reserved.
25 26 */
26 27
27 28 #include <sys/asm_linkage.h>
28 29
29 30 #if defined(__lint)
30 31
31 32 char stubs_base[1], stubs_end[1];
32 33
33 34 #else /* __lint */
34 35
35 36 #include "assym.h"
36 37
37 38 /*
38 39 * !!!!!!!! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! !!!!!!!!
39 40 *
40 41 * For functions which are either STUBs or WSTUBs the actual function
41 42 * need to be called using 'call' instruction because of preamble and
42 43 * postamble (i.e mod_hold_stub and mod_release_stub) around the
43 44 * function call. Due to this we need to copy arguments for the
44 45 * real function. On Intel we can't tell how many arguments are there
45 46 * on the stack so we have to either copy everything between esp and
46 47 * ebp or copy only a fixed number (MAXNARG - defined here) for
47 48 * all the stub functions. Currently we are using MAXNARG (it is a kludge
48 49 * but worth it?!).
49 50 *
50 51 * NOTE: Use NO_UNLOAD_STUBs if the module is NOT unloadable once it is
51 52 * loaded.
52 53 */
53 54 #define MAXNARG 10
54 55
55 56 /*
56 57 * WARNING: there is no check for forgetting to write END_MODULE,
57 58 * and if you do, the kernel will most likely crash. Be careful
58 59 *
59 60 * This file assumes that all of the contributions to the data segment
60 61 * will be contiguous in the output file, even though they are separated
61 62 * by pieces of text. This is safe for all assemblers I know of now...
62 63 */
63 64
64 65 /*
65 66 * This file uses ansi preprocessor features:
66 67 *
67 68 * 1. #define mac(a) extra_ ## a --> mac(x) expands to extra_a
68 69 * The old version of this is
69 70 * #define mac(a) extra_/.*.*./a
70 71 * but this fails if the argument has spaces "mac ( x )"
71 72 * (Ignore the dots above, I had to put them in to keep this a comment.)
72 73 *
73 74 * 2. #define mac(a) #a --> mac(x) expands to "x"
74 75 * The old version is
75 76 * #define mac(a) "a"
76 77 *
77 78 * For some reason, the 5.0 preprocessor isn't happy with the above usage.
78 79 * For now, we're not using these ansi features.
79 80 *
80 81 * The reason is that "the 5.0 ANSI preprocessor" is built into the compiler
81 82 * and is a tokenizing preprocessor. This means, when confronted by something
82 83 * other than C token generation rules, strange things occur. In this case,
83 84 * when confronted by an assembly file, it would turn the token ".globl" into
84 85 * two tokens "." and "globl". For this reason, the traditional, non-ANSI
85 86 * preprocessor is used on assembly files.
86 87 *
87 88 * It would be desirable to have a non-tokenizing cpp (accp?) to use for this.
88 89 */
89 90
90 91 /*
91 92 * This file contains the stubs routines for modules which can be autoloaded.
92 93 */
93 94
94 95 #if defined(__amd64)
95 96
96 97 /*
97 98 * See the 'struct mod_modinfo' definition to see what this declaration
98 99 * is trying to achieve here.
99 100 */
100 101 #define MODULE(module,namespace) \
101 102 .data; \
102 103 module/**/_modname: \
103 104 .string "namespace/module"; \
104 105 SET_SIZE(module/**/_modname); \
105 106 .align CPTRSIZE; \
106 107 .globl module/**/_modinfo; \
107 108 .type module/**/_modinfo, @object; \
108 109 module/**/_modinfo: \
109 110 .quad module/**/_modname; \
110 111 .quad 0 /* storage for modctl pointer */
111 112
112 113 /* then mod_stub_info structures follow until a mods_func_adr is 0 */
113 114
114 115 /* this puts a 0 where the next mods_func_adr would be */
115 116 #define END_MODULE(module) \
116 117 .data; \
117 118 .align CPTRSIZE; \
118 119 .quad 0; \
119 120 SET_SIZE(module/**/_modinfo)
120 121
121 122 /*
122 123 * The data section in the stub_common macro is the
123 124 * mod_stub_info structure for the stub function
124 125 */
125 126
126 127 #define STUB_COMMON(module, fcnname, install_fcn, retfcn, weak) \
127 128 ENTRY(fcnname); \
128 129 leaq fcnname/**/_info(%rip), %rax; \
129 130 cmpl $0, MODS_FLAG(%rax); /* weak? */ \
130 131 je stubs_common_code; /* not weak */ \
131 132 testb $MODS_INSTALLED, MODS_FLAG(%rax); /* installed? */ \
132 133 jne stubs_common_code; /* yes, do the mod_hold */ \
133 134 jmp *MODS_RETFCN(%rax); /* no, jump to retfcn */ \
134 135 SET_SIZE(fcnname); \
135 136 .data; \
136 137 .align CPTRSIZE; \
137 138 .type fcnname/**/_info, @object; \
138 139 fcnname/**/_info: \
139 140 .quad install_fcn; /* 0 */ \
140 141 .quad module/**/_modinfo; /* 0x8 */ \
141 142 .quad fcnname; /* 0x10 */ \
142 143 .quad retfcn; /* 0x18 */ \
143 144 .long weak; /* 0x20 */ \
144 145 SET_SIZE(fcnname/**/_info)
145 146
146 147 #define STUB_UNLOADABLE(module, fcnname, install_fcn, retfcn, weak) \
147 148 ENTRY(fcnname); \
148 149 leaq fcnname/**/_info(%rip), %rax; \
149 150 testb $MODS_INSTALLED, MODS_FLAG(%rax); /* installed? */ \
150 151 je 5f; /* no */ \
151 152 jmp *(%rax); /* yes, jump to install_fcn */ \
152 153 5: testb $MODS_WEAK, MODS_FLAG(%rax); /* weak? */ \
153 154 je stubs_common_code; /* no, do mod load */ \
154 155 jmp *MODS_RETFCN(%rax); /* yes, jump to retfcn */ \
155 156 SET_SIZE(fcnname); \
156 157 .data; \
157 158 .align CPTRSIZE; \
158 159 .type fcnname/**/_info, @object; \
159 160 fcnname/**/_info: \
160 161 .quad install_fcn; /* 0 */ \
161 162 .quad module/**/_modinfo; /* 0x8 */ \
162 163 .quad fcnname; /* 0x10 */ \
163 164 .quad retfcn; /* 0x18 */ \
164 165 .long weak; /* 0x20 */ \
165 166 SET_SIZE(fcnname/**/_info)
166 167
167 168 /*
168 169 * We branch here with the fcnname_info pointer in %rax
169 170 */
170 171 ENTRY_NP(stubs_common_code)
171 172 .globl mod_hold_stub
172 173 .globl mod_release_stub
173 174 pushq %rbp
174 175 movq %rsp, %rbp
175 176 subq $0x10, %rsp
176 177 movq %r15, (%rsp) /* (caller saved) */
177 178 movq %rax, %r15 /* stash the fcnname_info pointer */
178 179 /*
179 180 * save incoming register arguments
180 181 */
181 182 pushq %rdi
182 183 pushq %rsi
183 184 pushq %rdx
184 185 pushq %rcx
185 186 pushq %r8
186 187 pushq %r9
187 188 /* (next 4 args, if any, are already on the stack above %rbp) */
188 189 movq %r15, %rdi
189 190 call mod_hold_stub /* mod_hold_stub(mod_stub_info *) */
190 191 cmpl $-1, %eax /* error? */
191 192 jne .L1
192 193 movq 0x18(%r15), %rax
193 194 call *%rax
194 195 addq $0x30, %rsp
195 196 jmp .L2
196 197 .L1:
197 198 /*
198 199 * copy MAXNARG == 10 incoming arguments
199 200 */
200 201 popq %r9
201 202 popq %r8
202 203 popq %rcx
203 204 popq %rdx
204 205 popq %rsi
205 206 popq %rdi
206 207 /*
207 208 * stack:
208 209 * arg9 0x38(%rsp)
209 210 * arg8 0x30(%rsp)
210 211 * arg7 0x28(%rsp)
211 212 * arg6 0x20(%rsp)
212 213 * saved %rip 0x18(%rsp)
213 214 * saved %rbp 0x10(%rsp)
214 215 * <pad> 0x8(%rsp)
215 216 * saved %r15 0x0(%rsp)
216 217 */
217 218 movl $MAXNARG - 6 + 3, %r11d
218 219 pushq (%rsp, %r11, 8)
219 220 pushq (%rsp, %r11, 8)
220 221 pushq (%rsp, %r11, 8)
221 222 pushq (%rsp, %r11, 8)
222 223 call *(%r15) /* call the stub fn(arg, ..) */
223 224 addq $0x20, %rsp /* pop off last 4 args */
224 225 pushq %rax /* save any return values */
225 226 pushq %rdx
226 227 movq %r15, %rdi
227 228 call mod_release_stub /* release hold on module */
228 229 popq %rdx /* restore return values */
229 230 popq %rax
230 231 .L2:
231 232 popq %r15
232 233 leave
233 234 ret
234 235 SET_SIZE(stubs_common_code)
235 236
236 237 #elif defined(__i386)
237 238
238 239 /*
239 240 * See the 'struct mod_modinfo' definition to see what this declaration
240 241 * is trying to achieve here.
241 242 */
242 243 #define MODULE(module,namespace) \
243 244 .data; \
244 245 module/**/_modname: \
245 246 .string "namespace/module"; \
246 247 SET_SIZE(module/**/_modname); \
247 248 .align CPTRSIZE; \
248 249 .globl module/**/_modinfo; \
249 250 .type module/**/_modinfo, @object; \
250 251 module/**/_modinfo: \
251 252 .long module/**/_modname; \
252 253 .long 0 /* storage for modctl pointer */
253 254
254 255 /* then mod_stub_info structures follow until a mods_func_adr is 0 */
255 256
256 257 /* this puts a 0 where the next mods_func_adr would be */
257 258 #define END_MODULE(module) \
258 259 .data; \
259 260 .align CPTRSIZE; \
260 261 .long 0; \
261 262 SET_SIZE(module/**/_modinfo)
262 263
263 264 /*
264 265 * The data section in the stub_common macro is the
265 266 * mod_stub_info structure for the stub function
266 267 */
267 268
268 269 /*
269 270 * The flag MODS_INSTALLED is stored in the stub data and is used to
270 271 * indicate if a module is installed and initialized. This flag is used
271 272 * instead of the mod_stub_info->mods_modinfo->mod_installed flag
272 273 * to minimize the number of pointer de-references for each function
273 274 * call (and also to avoid possible TLB misses which could be induced
274 275 * by dereferencing these pointers.)
275 276 */
276 277
277 278 #define STUB_COMMON(module, fcnname, install_fcn, retfcn, weak) \
278 279 ENTRY(fcnname); \
279 280 leal fcnname/**/_info, %eax; \
280 281 cmpl $0, MODS_FLAG(%eax); /* weak? */ \
281 282 je stubs_common_code; /* not weak */ \
282 283 testb $MODS_INSTALLED, MODS_FLAG(%eax); /* installed? */ \
283 284 jne stubs_common_code; /* yes, do the mod_hold */ \
284 285 jmp *MODS_RETFCN(%eax); /* no, just jump to retfcn */ \
285 286 SET_SIZE(fcnname); \
286 287 .data; \
287 288 .align CPTRSIZE; \
288 289 .type fcnname/**/_info, @object; \
289 290 fcnname/**/_info: \
290 291 .long install_fcn; \
291 292 .long module/**/_modinfo; \
292 293 .long fcnname; \
293 294 .long retfcn; \
294 295 .long weak; \
295 296 SET_SIZE(fcnname/**/_info)
296 297
297 298 #define STUB_UNLOADABLE(module, fcnname, install_fcn, retfcn, weak) \
298 299 ENTRY(fcnname); \
299 300 leal fcnname/**/_info, %eax; \
300 301 testb $MODS_INSTALLED, MODS_FLAG(%eax); /* installed? */ \
301 302 je 5f; /* no */ \
302 303 jmp *(%eax); /* yes, just jump to install_fcn */ \
303 304 5: testb $MODS_WEAK, MODS_FLAG(%eax); /* weak? */ \
304 305 je stubs_common_code; /* no, do mod load */ \
305 306 jmp *MODS_RETFCN(%eax); /* yes, just jump to retfcn */ \
306 307 SET_SIZE(fcnname); \
307 308 .data; \
308 309 .align CPTRSIZE; \
309 310 .type fcnname/**/_info, @object; \
310 311 fcnname/**/_info: \
311 312 .long install_fcn; /* 0 */ \
312 313 .long module/**/_modinfo; /* 0x4 */ \
313 314 .long fcnname; /* 0x8 */ \
314 315 .long retfcn; /* 0xc */ \
315 316 .long weak; /* 0x10 */ \
316 317 SET_SIZE(fcnname/**/_info)
317 318
318 319 /*
319 320 * We branch here with the fcnname_info pointer in %eax
320 321 */
321 322 ENTRY_NP(stubs_common_code)
322 323 .globl mod_hold_stub
323 324 .globl mod_release_stub
324 325 pushl %esi
325 326 movl %eax, %esi / save the info pointer
326 327 pushl %eax
327 328 call mod_hold_stub / mod_hold_stub(mod_stub_info *)
328 329 popl %ecx
329 330 cmpl $-1, %eax / error?
330 331 jne .L1
331 332 movl MODS_RETFCN(%esi), %eax
332 333 call *%eax
333 334 popl %esi / yes, return error (panic?)
334 335 ret
335 336 .L1:
336 337 movl $MAXNARG+1, %ecx
337 338 / copy incoming arguments
338 339 pushl (%esp, %ecx, 4) / push MAXNARG times
339 340 pushl (%esp, %ecx, 4)
340 341 pushl (%esp, %ecx, 4)
341 342 pushl (%esp, %ecx, 4)
342 343 pushl (%esp, %ecx, 4)
343 344 pushl (%esp, %ecx, 4)
344 345 pushl (%esp, %ecx, 4)
345 346 pushl (%esp, %ecx, 4)
346 347 pushl (%esp, %ecx, 4)
347 348 pushl (%esp, %ecx, 4)
348 349 call *(%esi) / call the stub function(arg1,arg2, ...)
349 350 add $_MUL(MAXNARG, 4), %esp / pop off MAXNARG arguments
350 351 pushl %eax / save any return values from the stub
351 352 pushl %edx
352 353 pushl %esi
353 354 call mod_release_stub / release hold on module
354 355 addl $4, %esp
355 356 popl %edx / restore return values
356 357 popl %eax
357 358 .L2:
358 359 popl %esi
359 360 ret
360 361 SET_SIZE(stubs_common_code)
361 362
362 363 #endif /* __i386 */
363 364
364 365 #define STUB(module, fcnname, retfcn) \
365 366 STUB_COMMON(module, fcnname, mod_hold_stub, retfcn, 0)
366 367
367 368 /*
368 369 * "weak stub", don't load on account of this call
369 370 */
370 371 #define WSTUB(module, fcnname, retfcn) \
371 372 STUB_COMMON(module, fcnname, retfcn, retfcn, MODS_WEAK)
372 373
373 374 /*
374 375 * "non-unloadable stub", don't bother 'holding' module if it's already loaded
375 376 * since the module cannot be unloaded.
376 377 *
377 378 * User *MUST* guarantee the module is not unloadable (no _fini routine).
378 379 */
379 380 #define NO_UNLOAD_STUB(module, fcnname, retfcn) \
380 381 STUB_UNLOADABLE(module, fcnname, retfcn, retfcn, MODS_NOUNLOAD)
381 382
382 383 /*
383 384 * "weak stub" for non-unloadable module, don't load on account of this call
384 385 */
385 386 #define NO_UNLOAD_WSTUB(module, fcnname, retfcn) \
386 387 STUB_UNLOADABLE(module, fcnname, retfcn, retfcn, MODS_NOUNLOAD|MODS_WEAK)
387 388
388 389 /*
389 390 * this is just a marker for the beginning area of text that contains stubs
390 391 */
391 392 ENTRY_NP(stubs_base)
392 393 nop
393 394
394 395 /*
395 396 * WARNING WARNING WARNING!!!!!!
396 397 *
397 398 * On the MODULE macro you MUST NOT use any spaces!!! They are
398 399 * significant to the preprocessor. With ansi c there is a way around this
399 400 * but for some reason (yet to be investigated) ansi didn't work for other
400 401 * reasons!
401 402 *
402 403 * When zero is used as the return function, the system will call
403 404 * panic if the stub can't be resolved.
404 405 */
405 406
406 407 /*
407 408 * Stubs for devfs. A non-unloadable module.
408 409 */
409 410
410 411 #ifndef DEVFS_MODULE
411 412 MODULE(devfs,fs);
412 413 NO_UNLOAD_STUB(devfs, devfs_clean, nomod_minus_one);
413 414 NO_UNLOAD_STUB(devfs, devfs_lookupname, nomod_minus_one);
414 415 NO_UNLOAD_STUB(devfs, devfs_walk, nomod_minus_one);
415 416 NO_UNLOAD_STUB(devfs, devfs_devpolicy, nomod_minus_one);
416 417 NO_UNLOAD_STUB(devfs, devfs_reset_perm, nomod_minus_one);
417 418 NO_UNLOAD_STUB(devfs, devfs_remdrv_cleanup, nomod_minus_one);
418 419 END_MODULE(devfs);
419 420 #endif
420 421
421 422 #ifndef DEV_MODULE
422 423 MODULE(dev,fs);
423 424 NO_UNLOAD_STUB(dev, sdev_modctl_readdir, nomod_minus_one);
424 425 NO_UNLOAD_STUB(dev, sdev_modctl_readdir_free, nomod_minus_one);
425 426 NO_UNLOAD_STUB(dev, devname_filename_register, nomod_minus_one);
426 427 NO_UNLOAD_STUB(dev, sdev_modctl_devexists, nomod_minus_one);
427 428 NO_UNLOAD_STUB(dev, devname_profile_update, nomod_minus_one);
428 429 NO_UNLOAD_STUB(dev, sdev_devstate_change, nomod_minus_one);
429 430 NO_UNLOAD_STUB(dev, devvt_getvnodeops, nomod_minus_one);
430 431 NO_UNLOAD_STUB(dev, devpts_getvnodeops, nomod_zero);
431 432 END_MODULE(dev);
432 433 #endif
433 434
434 435 /*
435 436 * Stubs for specfs. A non-unloadable module.
436 437 */
437 438
438 439 #ifndef SPEC_MODULE
439 440 MODULE(specfs,fs);
440 441 NO_UNLOAD_STUB(specfs, common_specvp, nomod_zero);
441 442 NO_UNLOAD_STUB(specfs, makectty, nomod_zero);
442 443 NO_UNLOAD_STUB(specfs, makespecvp, nomod_zero);
443 444 NO_UNLOAD_STUB(specfs, smark, nomod_zero);
444 445 NO_UNLOAD_STUB(specfs, spec_segmap, nomod_einval);
445 446 NO_UNLOAD_STUB(specfs, specfind, nomod_zero);
446 447 NO_UNLOAD_STUB(specfs, specvp, nomod_zero);
447 448 NO_UNLOAD_STUB(specfs, devi_stillreferenced, nomod_zero);
448 449 NO_UNLOAD_STUB(specfs, spec_getvnodeops, nomod_zero);
449 450 NO_UNLOAD_STUB(specfs, spec_char_map, nomod_zero);
450 451 NO_UNLOAD_STUB(specfs, specvp_devfs, nomod_zero);
451 452 NO_UNLOAD_STUB(specfs, spec_assoc_vp_with_devi, nomod_void);
452 453 NO_UNLOAD_STUB(specfs, spec_hold_devi_by_vp, nomod_zero);
453 454 NO_UNLOAD_STUB(specfs, spec_snode_walk, nomod_void);
454 455 NO_UNLOAD_STUB(specfs, spec_devi_open_count, nomod_minus_one);
455 456 NO_UNLOAD_STUB(specfs, spec_is_clone, nomod_zero);
456 457 NO_UNLOAD_STUB(specfs, spec_is_selfclone, nomod_zero);
457 458 NO_UNLOAD_STUB(specfs, spec_fence_snode, nomod_minus_one);
458 459 NO_UNLOAD_STUB(specfs, spec_unfence_snode, nomod_minus_one);
459 460 END_MODULE(specfs);
460 461 #endif
461 462
462 463
463 464 /*
464 465 * Stubs for sockfs. A non-unloadable module.
465 466 */
466 467 #ifndef SOCK_MODULE
467 468 MODULE(sockfs,fs);
468 469 NO_UNLOAD_STUB(sockfs, so_socket, nomod_zero);
469 470 NO_UNLOAD_STUB(sockfs, so_socketpair, nomod_zero);
470 471 NO_UNLOAD_STUB(sockfs, bind, nomod_zero);
471 472 NO_UNLOAD_STUB(sockfs, listen, nomod_zero);
472 473 NO_UNLOAD_STUB(sockfs, accept, nomod_zero);
473 474 NO_UNLOAD_STUB(sockfs, connect, nomod_zero);
474 475 NO_UNLOAD_STUB(sockfs, shutdown, nomod_zero);
475 476 NO_UNLOAD_STUB(sockfs, recv, nomod_zero);
476 477 NO_UNLOAD_STUB(sockfs, recvfrom, nomod_zero);
477 478 NO_UNLOAD_STUB(sockfs, recvmsg, nomod_zero);
478 479 NO_UNLOAD_STUB(sockfs, send, nomod_zero);
479 480 NO_UNLOAD_STUB(sockfs, sendmsg, nomod_zero);
480 481 NO_UNLOAD_STUB(sockfs, sendto, nomod_zero);
481 482 #ifdef _SYSCALL32_IMPL
482 483 NO_UNLOAD_STUB(sockfs, recv32, nomod_zero);
483 484 NO_UNLOAD_STUB(sockfs, recvfrom32, nomod_zero);
484 485 NO_UNLOAD_STUB(sockfs, send32, nomod_zero);
485 486 NO_UNLOAD_STUB(sockfs, sendto32, nomod_zero);
486 487 #endif /* _SYSCALL32_IMPL */
487 488 NO_UNLOAD_STUB(sockfs, getpeername, nomod_zero);
488 489 NO_UNLOAD_STUB(sockfs, getsockname, nomod_zero);
489 490 NO_UNLOAD_STUB(sockfs, getsockopt, nomod_zero);
490 491 NO_UNLOAD_STUB(sockfs, setsockopt, nomod_zero);
491 492 NO_UNLOAD_STUB(sockfs, sockconfig, nomod_zero);
492 493 NO_UNLOAD_STUB(sockfs, sock_getmsg, nomod_zero);
493 494 NO_UNLOAD_STUB(sockfs, sock_putmsg, nomod_zero);
494 495 NO_UNLOAD_STUB(sockfs, sosendfile64, nomod_zero);
495 496 NO_UNLOAD_STUB(sockfs, snf_segmap, nomod_einval);
496 497 NO_UNLOAD_STUB(sockfs, sock_getfasync, nomod_zero);
497 498 NO_UNLOAD_STUB(sockfs, nl7c_sendfilev, nomod_zero);
498 499 NO_UNLOAD_STUB(sockfs, sotpi_sototpi, nomod_zero);
499 500 NO_UNLOAD_STUB(sockfs, socket_sendmblk, nomod_zero);
500 501 NO_UNLOAD_STUB(sockfs, socket_setsockopt, nomod_zero);
501 502 END_MODULE(sockfs);
502 503 #endif
503 504
504 505 /*
505 506 * IPsec stubs.
506 507 */
507 508
508 509 #ifndef IPSECAH_MODULE
509 510 MODULE(ipsecah,drv);
510 511 WSTUB(ipsecah, ipsec_construct_inverse_acquire, nomod_zero);
511 512 WSTUB(ipsecah, sadb_acquire, nomod_zero);
512 513 WSTUB(ipsecah, ipsecah_algs_changed, nomod_zero);
513 514 WSTUB(ipsecah, sadb_alg_update, nomod_zero);
514 515 WSTUB(ipsecah, sadb_unlinkassoc, nomod_zero);
515 516 WSTUB(ipsecah, sadb_insertassoc, nomod_zero);
516 517 WSTUB(ipsecah, ipsecah_in_assocfailure, nomod_zero);
517 518 WSTUB(ipsecah, sadb_set_lpkt, nomod_zero);
518 519 WSTUB(ipsecah, ipsecah_icmp_error, nomod_zero);
519 520 END_MODULE(ipsecah);
520 521 #endif
521 522
522 523 #ifndef IPSECESP_MODULE
523 524 MODULE(ipsecesp,drv);
524 525 WSTUB(ipsecesp, ipsecesp_fill_defs, nomod_zero);
525 526 WSTUB(ipsecesp, ipsecesp_algs_changed, nomod_zero);
526 527 WSTUB(ipsecesp, ipsecesp_in_assocfailure, nomod_zero);
527 528 WSTUB(ipsecesp, ipsecesp_init_funcs, nomod_zero);
528 529 WSTUB(ipsecesp, ipsecesp_icmp_error, nomod_zero);
529 530 WSTUB(ipsecesp, ipsecesp_send_keepalive, nomod_zero);
530 531 END_MODULE(ipsecesp);
531 532 #endif
532 533
533 534 #ifndef KEYSOCK_MODULE
534 535 MODULE(keysock, drv);
535 536 WSTUB(keysock, keysock_spdsock_wput_iocdata, nomod_void);
536 537 WSTUB(keysock, keysock_plumb_ipsec, nomod_zero);
537 538 WSTUB(keysock, keysock_extended_reg, nomod_zero);
538 539 WSTUB(keysock, keysock_next_seq, nomod_zero);
539 540 END_MODULE(keysock);
540 541 #endif
541 542
542 543 #ifndef SPDSOCK_MODULE
543 544 MODULE(spdsock,drv);
544 545 WSTUB(spdsock, spdsock_update_pending_algs, nomod_zero);
545 546 END_MODULE(spdsock);
546 547 #endif
547 548
548 549 /*
549 550 * Stubs for nfs common code.
550 551 * XXX nfs_getvnodeops should go away with removal of kludge in vnode.c
551 552 */
552 553 #ifndef NFS_MODULE
553 554 MODULE(nfs,fs);
554 555 WSTUB(nfs, nfs_getvnodeops, nomod_zero);
555 556 WSTUB(nfs, nfs_perror, nomod_zero);
556 557 WSTUB(nfs, nfs_cmn_err, nomod_zero);
557 558 WSTUB(nfs, clcleanup_zone, nomod_zero);
558 559 WSTUB(nfs, clcleanup4_zone, nomod_zero);
559 560 END_MODULE(nfs);
560 561 #endif
561 562
562 563
563 564 /*
564 565 * Stubs for nfs_dlboot (diskless booting).
565 566 */
566 567 #ifndef NFS_DLBOOT_MODULE
567 568 MODULE(nfs_dlboot,misc);
568 569 STUB(nfs_dlboot, mount_root, nomod_minus_one);
569 570 STUB(nfs_dlboot, dhcpinit, nomod_minus_one);
570 571 END_MODULE(nfs_dlboot);
571 572 #endif
572 573
573 574 /*
574 575 * Stubs for nfs server-only code.
575 576 */
576 577 #ifndef NFSSRV_MODULE
577 578 MODULE(nfssrv,misc);
578 579 STUB(nfssrv, exportfs, nomod_minus_one);
579 580 STUB(nfssrv, nfs_getfh, nomod_minus_one);
580 581 STUB(nfssrv, nfsl_flush, nomod_minus_one);
581 582 STUB(nfssrv, rfs4_check_delegated, nomod_zero);
582 583 STUB(nfssrv, mountd_args, nomod_minus_one);
583 584 NO_UNLOAD_STUB(nfssrv, rdma_start, nomod_zero);
584 585 NO_UNLOAD_STUB(nfssrv, nfs_svc, nomod_zero);
585 586 END_MODULE(nfssrv);
586 587 #endif
587 588
588 589 /*
589 590 * Stubs for kernel lock manager.
590 591 */
591 592 #ifndef KLM_MODULE
592 593 MODULE(klmmod,misc);
593 594 NO_UNLOAD_STUB(klmmod, lm_svc, nomod_zero);
594 595 NO_UNLOAD_STUB(klmmod, lm_shutdown, nomod_zero);
595 596 NO_UNLOAD_STUB(klmmod, lm_unexport, nomod_zero);
596 597 NO_UNLOAD_STUB(klmmod, lm_cprresume, nomod_zero);
597 598 NO_UNLOAD_STUB(klmmod, lm_cprsuspend, nomod_zero);
598 599 NO_UNLOAD_STUB(klmmod, lm_safelock, nomod_zero);
599 600 NO_UNLOAD_STUB(klmmod, lm_safemap, nomod_zero);
600 601 NO_UNLOAD_STUB(klmmod, lm_has_sleep, nomod_zero);
601 602 NO_UNLOAD_STUB(klmmod, lm_free_config, nomod_zero);
602 603 NO_UNLOAD_STUB(klmmod, lm_vp_active, nomod_zero);
603 604 NO_UNLOAD_STUB(klmmod, lm_get_sysid, nomod_zero);
604 605 NO_UNLOAD_STUB(klmmod, lm_rel_sysid, nomod_zero);
605 606 NO_UNLOAD_STUB(klmmod, lm_alloc_sysidt, nomod_minus_one);
606 607 NO_UNLOAD_STUB(klmmod, lm_free_sysidt, nomod_zero);
607 608 NO_UNLOAD_STUB(klmmod, lm_sysidt, nomod_minus_one);
608 609 END_MODULE(klmmod);
609 610 #endif
610 611
611 612 #ifndef KLMOPS_MODULE
612 613 MODULE(klmops,misc);
613 614 NO_UNLOAD_STUB(klmops, lm_frlock, nomod_zero);
614 615 NO_UNLOAD_STUB(klmops, lm4_frlock, nomod_zero);
615 616 NO_UNLOAD_STUB(klmops, lm_shrlock, nomod_zero);
616 617 NO_UNLOAD_STUB(klmops, lm4_shrlock, nomod_zero);
617 618 NO_UNLOAD_STUB(klmops, lm_nlm_dispatch, nomod_zero);
618 619 NO_UNLOAD_STUB(klmops, lm_nlm4_dispatch, nomod_zero);
619 620 NO_UNLOAD_STUB(klmops, lm_nlm_reclaim, nomod_zero);
620 621 NO_UNLOAD_STUB(klmops, lm_nlm4_reclaim, nomod_zero);
621 622 NO_UNLOAD_STUB(klmops, lm_register_lock_locally, nomod_zero);
622 623 END_MODULE(klmops);
623 624 #endif
624 625
625 626 /*
626 627 * Stubs for kernel TLI module
627 628 * XXX currently we never allow this to unload
628 629 */
629 630 #ifndef TLI_MODULE
630 631 MODULE(tlimod,misc);
|
↓ open down ↓ |
596 lines elided |
↑ open up ↑ |
631 632 NO_UNLOAD_STUB(tlimod, t_kopen, nomod_minus_one);
632 633 NO_UNLOAD_STUB(tlimod, t_kunbind, nomod_zero);
633 634 NO_UNLOAD_STUB(tlimod, t_kadvise, nomod_zero);
634 635 NO_UNLOAD_STUB(tlimod, t_krcvudata, nomod_zero);
635 636 NO_UNLOAD_STUB(tlimod, t_ksndudata, nomod_zero);
636 637 NO_UNLOAD_STUB(tlimod, t_kalloc, nomod_zero);
637 638 NO_UNLOAD_STUB(tlimod, t_kbind, nomod_zero);
638 639 NO_UNLOAD_STUB(tlimod, t_kclose, nomod_zero);
639 640 NO_UNLOAD_STUB(tlimod, t_kspoll, nomod_zero);
640 641 NO_UNLOAD_STUB(tlimod, t_kfree, nomod_zero);
642 + NO_UNLOAD_STUB(tlimod, t_koptmgmt, nomod_zero);
641 643 END_MODULE(tlimod);
642 644 #endif
643 645
644 646 /*
645 647 * Stubs for kernel RPC module
646 648 * XXX currently we never allow this to unload
647 649 */
648 650 #ifndef RPC_MODULE
649 651 MODULE(rpcmod,strmod);
650 652 NO_UNLOAD_STUB(rpcmod, clnt_tli_kcreate, nomod_minus_one);
651 653 NO_UNLOAD_STUB(rpcmod, svc_tli_kcreate, nomod_minus_one);
652 654 NO_UNLOAD_STUB(rpcmod, bindresvport, nomod_minus_one);
653 655 NO_UNLOAD_STUB(rpcmod, rdma_register_mod, nomod_minus_one);
654 656 NO_UNLOAD_STUB(rpcmod, rdma_unregister_mod, nomod_minus_one);
655 657 NO_UNLOAD_STUB(rpcmod, svc_queuereq, nomod_minus_one);
656 658 NO_UNLOAD_STUB(rpcmod, clist_add, nomod_minus_one);
657 659 END_MODULE(rpcmod);
658 660 #endif
659 661
660 662 /*
661 663 * Stubs for des
662 664 */
663 665 #ifndef DES_MODULE
664 666 MODULE(des,misc);
665 667 STUB(des, cbc_crypt, nomod_zero);
666 668 STUB(des, ecb_crypt, nomod_zero);
667 669 STUB(des, _des_crypt, nomod_zero);
668 670 END_MODULE(des);
669 671 #endif
670 672
671 673 /*
672 674 * Stubs for procfs. A non-unloadable module.
673 675 */
674 676 #ifndef PROC_MODULE
675 677 MODULE(procfs,fs);
676 678 NO_UNLOAD_STUB(procfs, prfree, nomod_zero);
677 679 NO_UNLOAD_STUB(procfs, prexit, nomod_zero);
678 680 NO_UNLOAD_STUB(procfs, prlwpfree, nomod_zero);
679 681 NO_UNLOAD_STUB(procfs, prlwpexit, nomod_zero);
680 682 NO_UNLOAD_STUB(procfs, prinvalidate, nomod_zero);
681 683 NO_UNLOAD_STUB(procfs, prnsegs, nomod_zero);
682 684 NO_UNLOAD_STUB(procfs, prgetcred, nomod_zero);
683 685 NO_UNLOAD_STUB(procfs, prgetpriv, nomod_zero);
684 686 NO_UNLOAD_STUB(procfs, prgetprivsize, nomod_zero);
685 687 NO_UNLOAD_STUB(procfs, prgetsecflags, nomod_zero);
686 688 NO_UNLOAD_STUB(procfs, prgetstatus, nomod_zero);
687 689 NO_UNLOAD_STUB(procfs, prgetlwpstatus, nomod_zero);
688 690 NO_UNLOAD_STUB(procfs, prgetpsinfo, nomod_zero);
689 691 NO_UNLOAD_STUB(procfs, prgetlwpsinfo, nomod_zero);
690 692 NO_UNLOAD_STUB(procfs, oprgetstatus, nomod_zero);
691 693 NO_UNLOAD_STUB(procfs, oprgetpsinfo, nomod_zero);
692 694 #ifdef _SYSCALL32_IMPL
693 695 NO_UNLOAD_STUB(procfs, prgetstatus32, nomod_zero);
694 696 NO_UNLOAD_STUB(procfs, prgetlwpstatus32, nomod_zero);
695 697 NO_UNLOAD_STUB(procfs, prgetpsinfo32, nomod_zero);
696 698 NO_UNLOAD_STUB(procfs, prgetlwpsinfo32, nomod_zero);
697 699 NO_UNLOAD_STUB(procfs, oprgetstatus32, nomod_zero);
698 700 NO_UNLOAD_STUB(procfs, oprgetpsinfo32, nomod_zero);
699 701 NO_UNLOAD_STUB(procfs, psinfo_kto32, nomod_zero);
700 702 NO_UNLOAD_STUB(procfs, lwpsinfo_kto32, nomod_zero);
701 703 #endif /* _SYSCALL32_IMPL */
702 704 NO_UNLOAD_STUB(procfs, prnotify, nomod_zero);
703 705 NO_UNLOAD_STUB(procfs, prexecstart, nomod_zero);
704 706 NO_UNLOAD_STUB(procfs, prexecend, nomod_zero);
705 707 NO_UNLOAD_STUB(procfs, prrelvm, nomod_zero);
706 708 NO_UNLOAD_STUB(procfs, prbarrier, nomod_zero);
707 709 NO_UNLOAD_STUB(procfs, estimate_msacct, nomod_zero);
708 710 NO_UNLOAD_STUB(procfs, pr_getprot, nomod_zero);
709 711 NO_UNLOAD_STUB(procfs, pr_getprot_done, nomod_zero);
710 712 NO_UNLOAD_STUB(procfs, pr_getsegsize, nomod_zero);
711 713 NO_UNLOAD_STUB(procfs, pr_isobject, nomod_zero);
712 714 NO_UNLOAD_STUB(procfs, pr_isself, nomod_zero);
713 715 NO_UNLOAD_STUB(procfs, pr_allstopped, nomod_zero);
714 716 NO_UNLOAD_STUB(procfs, pr_free_watched_pages, nomod_zero);
715 717 END_MODULE(procfs);
716 718 #endif
717 719
718 720 /*
719 721 * Stubs for fifofs
720 722 */
721 723 #ifndef FIFO_MODULE
722 724 MODULE(fifofs,fs);
723 725 STUB(fifofs, fifovp, 0);
724 726 STUB(fifofs, fifo_getinfo, 0);
725 727 STUB(fifofs, fifo_vfastoff, 0);
726 728 END_MODULE(fifofs);
727 729 #endif
728 730
729 731 /*
730 732 * Stubs for ufs
731 733 *
732 734 * This is needed to support the old quotactl system call.
733 735 * When the old sysent stuff goes away, this will need to be revisited.
734 736 */
735 737 #ifndef UFS_MODULE
736 738 MODULE(ufs,fs);
737 739 STUB(ufs, quotactl, nomod_minus_one);
738 740 END_MODULE(ufs);
739 741 #endif
740 742
741 743 /*
742 744 * Stubs for zfs
743 745 */
744 746 #ifndef ZFS_MODULE
745 747 MODULE(zfs,fs);
746 748 STUB(zfs, dsl_prop_get, nomod_minus_one);
747 749 STUB(zfs, spa_boot_init, nomod_minus_one);
748 750 STUB(zfs, zfs_prop_to_name, nomod_zero);
749 751 END_MODULE(zfs);
750 752 #endif
751 753
752 754 /*
753 755 * Stubs for dcfs
754 756 */
755 757 #ifndef DCFS_MODULE
756 758 MODULE(dcfs,fs);
757 759 STUB(dcfs, decompvp, 0);
758 760 END_MODULE(dcfs);
759 761 #endif
760 762
761 763 /*
762 764 * Stubs for namefs
763 765 */
764 766 #ifndef NAMEFS_MODULE
765 767 MODULE(namefs,fs);
766 768 STUB(namefs, nm_unmountall, 0);
767 769 END_MODULE(namefs);
768 770 #endif
769 771
770 772 /*
771 773 * Stubs for sysdc
772 774 */
773 775 #ifndef SDC_MODULE
774 776 MODULE(SDC,sched);
775 777 NO_UNLOAD_STUB(SDC, sysdc_thread_enter, nomod_zero);
776 778 END_MODULE(SDC);
777 779 #endif
778 780
779 781 /*
780 782 * Stubs for ts_dptbl
781 783 */
782 784 #ifndef TS_DPTBL_MODULE
783 785 MODULE(TS_DPTBL,sched);
784 786 STUB(TS_DPTBL, ts_getdptbl, 0);
785 787 STUB(TS_DPTBL, ts_getkmdpris, 0);
786 788 STUB(TS_DPTBL, ts_getmaxumdpri, 0);
787 789 END_MODULE(TS_DPTBL);
788 790 #endif
789 791
790 792 /*
791 793 * Stubs for rt_dptbl
792 794 */
793 795 #ifndef RT_DPTBL_MODULE
794 796 MODULE(RT_DPTBL,sched);
795 797 STUB(RT_DPTBL, rt_getdptbl, 0);
796 798 END_MODULE(RT_DPTBL);
797 799 #endif
798 800
799 801 /*
800 802 * Stubs for ia_dptbl
801 803 */
802 804 #ifndef IA_DPTBL_MODULE
803 805 MODULE(IA_DPTBL,sched);
804 806 STUB(IA_DPTBL, ia_getdptbl, nomod_zero);
805 807 STUB(IA_DPTBL, ia_getkmdpris, nomod_zero);
806 808 STUB(IA_DPTBL, ia_getmaxumdpri, nomod_zero);
807 809 END_MODULE(IA_DPTBL);
808 810 #endif
809 811
810 812 /*
811 813 * Stubs for FSS scheduler
812 814 */
813 815 #ifndef FSS_MODULE
814 816 MODULE(FSS,sched);
815 817 WSTUB(FSS, fss_allocbuf, nomod_zero);
816 818 WSTUB(FSS, fss_freebuf, nomod_zero);
817 819 WSTUB(FSS, fss_changeproj, nomod_zero);
818 820 WSTUB(FSS, fss_changepset, nomod_zero);
819 821 END_MODULE(FSS);
820 822 #endif
821 823
822 824 /*
823 825 * Stubs for fx_dptbl
824 826 */
825 827 #ifndef FX_DPTBL_MODULE
826 828 MODULE(FX_DPTBL,sched);
827 829 STUB(FX_DPTBL, fx_getdptbl, 0);
828 830 STUB(FX_DPTBL, fx_getmaxumdpri, 0);
829 831 END_MODULE(FX_DPTBL);
830 832 #endif
831 833
832 834 /*
833 835 * Stubs for bootdev
834 836 */
835 837 #ifndef BOOTDEV_MODULE
836 838 MODULE(bootdev,misc);
837 839 STUB(bootdev, i_promname_to_devname, 0);
838 840 STUB(bootdev, i_convert_boot_device_name, 0);
839 841 END_MODULE(bootdev);
840 842 #endif
841 843
842 844 /*
843 845 * stubs for strplumb...
844 846 */
845 847 #ifndef STRPLUMB_MODULE
846 848 MODULE(strplumb,misc);
847 849 STUB(strplumb, strplumb, 0);
848 850 STUB(strplumb, strplumb_load, 0);
849 851 STUB(strplumb, strplumb_get_netdev_path, 0);
850 852 END_MODULE(strplumb);
851 853 #endif
852 854
853 855 /*
854 856 * Stubs for console configuration module
855 857 */
856 858 #ifndef CONSCONFIG_MODULE
857 859 MODULE(consconfig,misc);
858 860 STUB(consconfig, consconfig, 0);
859 861 STUB(consconfig, consconfig_get_usb_kb_path, 0);
860 862 STUB(consconfig, consconfig_get_usb_ms_path, 0);
861 863 STUB(consconfig, consconfig_get_plat_fbpath, 0);
862 864 STUB(consconfig, consconfig_console_is_ready, 0);
863 865 END_MODULE(consconfig);
864 866 #endif
865 867
866 868 /*
867 869 * Stubs for accounting.
868 870 */
869 871 #ifndef SYSACCT_MODULE
870 872 MODULE(sysacct,sys);
871 873 WSTUB(sysacct, acct, nomod_zero);
872 874 WSTUB(sysacct, acct_fs_in_use, nomod_zero);
873 875 END_MODULE(sysacct);
874 876 #endif
875 877
876 878 /*
877 879 * Stubs for semaphore routines. sem.c
878 880 */
879 881 #ifndef SEMSYS_MODULE
880 882 MODULE(semsys,sys);
881 883 WSTUB(semsys, semexit, nomod_zero);
882 884 END_MODULE(semsys);
883 885 #endif
884 886
885 887 /*
886 888 * Stubs for shmem routines. shm.c
887 889 */
888 890 #ifndef SHMSYS_MODULE
889 891 MODULE(shmsys,sys);
890 892 WSTUB(shmsys, shmexit, nomod_zero);
891 893 WSTUB(shmsys, shmfork, nomod_zero);
892 894 WSTUB(shmsys, shmgetid, nomod_minus_one);
893 895 END_MODULE(shmsys);
894 896 #endif
895 897
896 898 /*
897 899 * Stubs for doors
898 900 */
899 901 #ifndef DOOR_MODULE
900 902 MODULE(doorfs,sys);
901 903 WSTUB(doorfs, door_slam, nomod_zero);
902 904 WSTUB(doorfs, door_exit, nomod_zero);
903 905 WSTUB(doorfs, door_revoke_all, nomod_zero);
904 906 WSTUB(doorfs, door_fork, nomod_zero);
905 907 NO_UNLOAD_STUB(doorfs, door_upcall, nomod_einval);
906 908 NO_UNLOAD_STUB(doorfs, door_ki_create, nomod_einval);
907 909 NO_UNLOAD_STUB(doorfs, door_ki_open, nomod_einval);
908 910 NO_UNLOAD_STUB(doorfs, door_ki_lookup, nomod_zero);
909 911 WSTUB(doorfs, door_ki_upcall, nomod_einval);
910 912 WSTUB(doorfs, door_ki_upcall_limited, nomod_einval);
911 913 WSTUB(doorfs, door_ki_hold, nomod_zero);
912 914 WSTUB(doorfs, door_ki_rele, nomod_zero);
913 915 WSTUB(doorfs, door_ki_info, nomod_einval);
914 916 END_MODULE(doorfs);
915 917 #endif
916 918
917 919 /*
918 920 * Stubs for MD5
919 921 */
920 922 #ifndef MD5_MODULE
921 923 MODULE(md5,misc);
922 924 WSTUB(md5, MD5Init, nomod_zero);
923 925 WSTUB(md5, MD5Update, nomod_zero);
924 926 WSTUB(md5, MD5Final, nomod_zero);
925 927 END_MODULE(md5);
926 928 #endif
927 929
928 930 /*
929 931 * Stubs for idmap
930 932 */
931 933 #ifndef IDMAP_MODULE
932 934 MODULE(idmap,misc);
933 935 STUB(idmap, kidmap_batch_getgidbysid, nomod_zero);
934 936 STUB(idmap, kidmap_batch_getpidbysid, nomod_zero);
935 937 STUB(idmap, kidmap_batch_getsidbygid, nomod_zero);
936 938 STUB(idmap, kidmap_batch_getsidbyuid, nomod_zero);
937 939 STUB(idmap, kidmap_batch_getuidbysid, nomod_zero);
938 940 STUB(idmap, kidmap_get_create, nomod_zero);
939 941 STUB(idmap, kidmap_get_destroy, nomod_zero);
940 942 STUB(idmap, kidmap_get_mappings, nomod_zero);
941 943 STUB(idmap, kidmap_getgidbysid, nomod_zero);
942 944 STUB(idmap, kidmap_getpidbysid, nomod_zero);
943 945 STUB(idmap, kidmap_getsidbygid, nomod_zero);
944 946 STUB(idmap, kidmap_getsidbyuid, nomod_zero);
945 947 STUB(idmap, kidmap_getuidbysid, nomod_zero);
946 948 STUB(idmap, idmap_get_door, nomod_einval);
947 949 STUB(idmap, idmap_unreg_dh, nomod_einval);
948 950 STUB(idmap, idmap_reg_dh, nomod_einval);
949 951 STUB(idmap, idmap_purge_cache, nomod_einval);
950 952 END_MODULE(idmap);
951 953 #endif
|
↓ open down ↓ |
301 lines elided |
↑ open up ↑ |
952 954
953 955 /*
954 956 * Stubs for auditing.
955 957 */
956 958 #ifndef C2AUDIT_MODULE
957 959 MODULE(c2audit,sys);
958 960 NO_UNLOAD_STUB(c2audit, audit_init_module, nomod_zero);
959 961 NO_UNLOAD_STUB(c2audit, audit_start, nomod_zero);
960 962 NO_UNLOAD_STUB(c2audit, audit_finish, nomod_zero);
961 963 NO_UNLOAD_STUB(c2audit, audit, nomod_zero);
964 + NO_UNLOAD_STUB(c2audit, auditev, nomod_zero);
962 965 NO_UNLOAD_STUB(c2audit, auditdoor, nomod_zero);
963 966 NO_UNLOAD_STUB(c2audit, audit_closef, nomod_zero);
964 967 NO_UNLOAD_STUB(c2audit, audit_core_start, nomod_zero);
965 968 NO_UNLOAD_STUB(c2audit, audit_core_finish, nomod_zero);
969 + NO_UNLOAD_STUB(c2audit, audit_sacl, nomod_zero);
966 970 NO_UNLOAD_STUB(c2audit, audit_strputmsg, nomod_zero);
967 971 NO_UNLOAD_STUB(c2audit, audit_savepath, nomod_zero);
968 972 NO_UNLOAD_STUB(c2audit, audit_anchorpath, nomod_zero);
969 973 NO_UNLOAD_STUB(c2audit, audit_exit, nomod_zero);
970 974 NO_UNLOAD_STUB(c2audit, audit_exec, nomod_zero);
971 975 NO_UNLOAD_STUB(c2audit, audit_symlink, nomod_zero);
972 976 NO_UNLOAD_STUB(c2audit, audit_symlink_create, nomod_zero);
973 977 NO_UNLOAD_STUB(c2audit, audit_vncreate_start, nomod_zero);
974 978 NO_UNLOAD_STUB(c2audit, audit_vncreate_finish, nomod_zero);
975 979 NO_UNLOAD_STUB(c2audit, audit_enterprom, nomod_zero);
976 980 NO_UNLOAD_STUB(c2audit, audit_exitprom, nomod_zero);
977 981 NO_UNLOAD_STUB(c2audit, audit_chdirec, nomod_zero);
978 982 NO_UNLOAD_STUB(c2audit, audit_setf, nomod_zero);
979 983 NO_UNLOAD_STUB(c2audit, audit_sock, nomod_zero);
980 984 NO_UNLOAD_STUB(c2audit, audit_strgetmsg, nomod_zero);
981 985 NO_UNLOAD_STUB(c2audit, audit_ipc, nomod_zero);
982 986 NO_UNLOAD_STUB(c2audit, audit_ipcget, nomod_zero);
983 987 NO_UNLOAD_STUB(c2audit, audit_fdsend, nomod_zero);
984 988 NO_UNLOAD_STUB(c2audit, audit_fdrecv, nomod_zero);
985 989 NO_UNLOAD_STUB(c2audit, audit_priv, nomod_zero);
986 990 NO_UNLOAD_STUB(c2audit, audit_setppriv, nomod_zero);
987 991 NO_UNLOAD_STUB(c2audit, audit_psecflags, nomod_zero);
988 992 NO_UNLOAD_STUB(c2audit, audit_devpolicy, nomod_zero);
989 993 NO_UNLOAD_STUB(c2audit, audit_setfsat_path, nomod_zero);
990 994 NO_UNLOAD_STUB(c2audit, audit_cryptoadm, nomod_zero);
991 995 NO_UNLOAD_STUB(c2audit, audit_kssl, nomod_zero);
992 996 NO_UNLOAD_STUB(c2audit, audit_pf_policy, nomod_zero);
993 997 NO_UNLOAD_STUB(c2audit, au_doormsg, nomod_zero);
994 998 NO_UNLOAD_STUB(c2audit, au_uwrite, nomod_zero);
995 999 NO_UNLOAD_STUB(c2audit, au_to_arg32, nomod_zero);
996 1000 NO_UNLOAD_STUB(c2audit, au_free_rec, nomod_zero);
997 1001 END_MODULE(c2audit);
998 1002 #endif
999 1003
1000 1004 /*
1001 1005 * Stubs for kernel rpc security service module
1002 1006 */
1003 1007 #ifndef RPCSEC_MODULE
1004 1008 MODULE(rpcsec,misc);
1005 1009 NO_UNLOAD_STUB(rpcsec, sec_clnt_revoke, nomod_zero);
1006 1010 NO_UNLOAD_STUB(rpcsec, authkern_create, nomod_zero);
1007 1011 NO_UNLOAD_STUB(rpcsec, sec_svc_msg, nomod_zero);
1008 1012 NO_UNLOAD_STUB(rpcsec, sec_svc_control, nomod_zero);
1009 1013 END_MODULE(rpcsec);
1010 1014 #endif
1011 1015
1012 1016 /*
1013 1017 * Stubs for rpc RPCSEC_GSS security service module
1014 1018 */
1015 1019 #ifndef RPCSEC_GSS_MODULE
1016 1020 MODULE(rpcsec_gss,misc);
1017 1021 NO_UNLOAD_STUB(rpcsec_gss, __svcrpcsec_gss, nomod_zero);
1018 1022 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_getcred, nomod_zero);
1019 1023 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_set_callback, nomod_zero);
1020 1024 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_secget, nomod_zero);
1021 1025 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_secfree, nomod_zero);
1022 1026 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_seccreate, nomod_zero);
1023 1027 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_set_defaults, nomod_zero);
1024 1028 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_revauth, nomod_zero);
1025 1029 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_secpurge, nomod_zero);
1026 1030 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_cleanup, nomod_zero);
1027 1031 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_get_versions, nomod_zero);
1028 1032 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_max_data_length, nomod_zero);
1029 1033 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_svc_max_data_length, nomod_zero);
1030 1034 NO_UNLOAD_STUB(rpcsec_gss, rpc_gss_get_service_type, nomod_zero);
1031 1035 END_MODULE(rpcsec_gss);
1032 1036 #endif
1033 1037
1034 1038 /*
1035 1039 * Stubs for PCI configurator module (misc/pcicfg).
1036 1040 */
1037 1041 #ifndef PCICFG_MODULE
1038 1042 MODULE(pcicfg,misc);
1039 1043 STUB(pcicfg, pcicfg_configure, 0);
1040 1044 STUB(pcicfg, pcicfg_unconfigure, 0);
1041 1045 END_MODULE(pcicfg);
1042 1046 #endif
1043 1047
1044 1048 /*
1045 1049 * Stubs for pcieb nexus driver.
1046 1050 */
1047 1051 #ifndef PCIEB_MODULE
1048 1052 MODULE(pcieb,drv);
1049 1053 STUB(pcieb, pcieb_intel_error_workaround, 0);
1050 1054 END_MODULE(pcieb);
1051 1055 #endif
1052 1056
1053 1057 #ifndef IWSCN_MODULE
1054 1058 MODULE(iwscn,drv);
1055 1059 STUB(iwscn, srpop, 0);
1056 1060 END_MODULE(iwscn);
1057 1061 #endif
1058 1062
1059 1063 /*
1060 1064 * Stubs for checkpoint-resume module
1061 1065 */
1062 1066 #ifndef CPR_MODULE
1063 1067 MODULE(cpr,misc);
1064 1068 STUB(cpr, cpr, 0);
1065 1069 END_MODULE(cpr);
1066 1070 #endif
1067 1071
1068 1072 /*
1069 1073 * Stubs for kernel probes (tnf module). Not unloadable.
1070 1074 */
1071 1075 #ifndef TNF_MODULE
1072 1076 MODULE(tnf,drv);
1073 1077 NO_UNLOAD_STUB(tnf, tnf_ref32_1, nomod_zero);
1074 1078 NO_UNLOAD_STUB(tnf, tnf_string_1, nomod_zero);
1075 1079 NO_UNLOAD_STUB(tnf, tnf_opaque_array_1, nomod_zero);
1076 1080 NO_UNLOAD_STUB(tnf, tnf_struct_tag_1, nomod_zero);
1077 1081 NO_UNLOAD_STUB(tnf, tnf_allocate, nomod_zero);
1078 1082 END_MODULE(tnf);
1079 1083 #endif
1080 1084
1081 1085 /*
1082 1086 * Stubs for i86hvm bootstraping
1083 1087 */
1084 1088 #ifndef HVM_BOOTSTRAP
1085 1089 MODULE(hvm_bootstrap,misc);
1086 1090 NO_UNLOAD_STUB(hvm_bootstrap, hvmboot_rootconf, nomod_zero);
1087 1091 END_MODULE(hvm_bootstrap);
1088 1092 #endif
1089 1093
1090 1094 /*
1091 1095 * Clustering: stubs for bootstrapping.
1092 1096 */
1093 1097 #ifndef CL_BOOTSTRAP
1094 1098 MODULE(cl_bootstrap,misc);
1095 1099 NO_UNLOAD_WSTUB(cl_bootstrap, clboot_modload, nomod_minus_one);
1096 1100 NO_UNLOAD_WSTUB(cl_bootstrap, clboot_loadrootmodules, nomod_zero);
1097 1101 NO_UNLOAD_WSTUB(cl_bootstrap, clboot_rootconf, nomod_zero);
1098 1102 NO_UNLOAD_WSTUB(cl_bootstrap, clboot_mountroot, nomod_zero);
1099 1103 NO_UNLOAD_WSTUB(cl_bootstrap, clconf_init, nomod_zero);
1100 1104 NO_UNLOAD_WSTUB(cl_bootstrap, clconf_get_nodeid, nomod_zero);
1101 1105 NO_UNLOAD_WSTUB(cl_bootstrap, clconf_maximum_nodeid, nomod_zero);
1102 1106 NO_UNLOAD_WSTUB(cl_bootstrap, cluster, nomod_zero);
1103 1107 END_MODULE(cl_bootstrap);
1104 1108 #endif
1105 1109
1106 1110 /*
1107 1111 * Clustering: stubs for cluster infrastructure.
1108 1112 */
1109 1113 #ifndef CL_COMM_MODULE
1110 1114 MODULE(cl_comm,misc);
1111 1115 NO_UNLOAD_STUB(cl_comm, cladmin, nomod_minus_one);
1112 1116 END_MODULE(cl_comm);
1113 1117 #endif
1114 1118
1115 1119 /*
1116 1120 * Clustering: stubs for global file system operations.
1117 1121 */
1118 1122 #ifndef PXFS_MODULE
1119 1123 MODULE(pxfs,fs);
1120 1124 NO_UNLOAD_WSTUB(pxfs, clpxfs_aio_read, nomod_zero);
1121 1125 NO_UNLOAD_WSTUB(pxfs, clpxfs_aio_write, nomod_zero);
1122 1126 NO_UNLOAD_WSTUB(pxfs, cl_flk_state_transition_notify, nomod_zero);
1123 1127 END_MODULE(pxfs);
1124 1128 #endif
1125 1129
1126 1130 /*
1127 1131 * Stubs for kernel cryptographic framework module (misc/kcf).
1128 1132 */
1129 1133 #ifndef KCF_MODULE
1130 1134 MODULE(kcf,misc);
1131 1135 NO_UNLOAD_STUB(kcf, crypto_mech2id, nomod_minus_one);
1132 1136 NO_UNLOAD_STUB(kcf, crypto_register_provider, nomod_minus_one);
1133 1137 NO_UNLOAD_STUB(kcf, crypto_unregister_provider, nomod_minus_one);
1134 1138 NO_UNLOAD_STUB(kcf, crypto_provider_notification, nomod_minus_one);
1135 1139 NO_UNLOAD_STUB(kcf, crypto_op_notification, nomod_minus_one);
1136 1140 NO_UNLOAD_STUB(kcf, crypto_kmflag, nomod_minus_one);
1137 1141 NO_UNLOAD_STUB(kcf, crypto_digest, nomod_minus_one);
1138 1142 NO_UNLOAD_STUB(kcf, crypto_digest_prov, nomod_minus_one);
1139 1143 NO_UNLOAD_STUB(kcf, crypto_digest_init, nomod_minus_one);
1140 1144 NO_UNLOAD_STUB(kcf, crypto_digest_init_prov, nomod_minus_one);
1141 1145 NO_UNLOAD_STUB(kcf, crypto_digest_update, nomod_minus_one);
1142 1146 NO_UNLOAD_STUB(kcf, crypto_digest_final, nomod_minus_one);
1143 1147 NO_UNLOAD_STUB(kcf, crypto_digest_key_prov, nomod_minus_one);
1144 1148 NO_UNLOAD_STUB(kcf, crypto_encrypt, nomod_minus_one);
1145 1149 NO_UNLOAD_STUB(kcf, crypto_encrypt_prov, nomod_minus_one);
1146 1150 NO_UNLOAD_STUB(kcf, crypto_encrypt_init, nomod_minus_one);
1147 1151 NO_UNLOAD_STUB(kcf, crypto_encrypt_init_prov, nomod_minus_one);
1148 1152 NO_UNLOAD_STUB(kcf, crypto_encrypt_update, nomod_minus_one);
1149 1153 NO_UNLOAD_STUB(kcf, crypto_encrypt_final, nomod_minus_one);
1150 1154 NO_UNLOAD_STUB(kcf, crypto_decrypt, nomod_minus_one);
1151 1155 NO_UNLOAD_STUB(kcf, crypto_decrypt_prov, nomod_minus_one);
1152 1156 NO_UNLOAD_STUB(kcf, crypto_decrypt_init, nomod_minus_one);
1153 1157 NO_UNLOAD_STUB(kcf, crypto_decrypt_init_prov, nomod_minus_one);
1154 1158 NO_UNLOAD_STUB(kcf, crypto_decrypt_update, nomod_minus_one);
1155 1159 NO_UNLOAD_STUB(kcf, crypto_decrypt_final, nomod_minus_one);
1156 1160 NO_UNLOAD_STUB(kcf, crypto_get_all_mech_info, nomod_minus_one);
1157 1161 NO_UNLOAD_STUB(kcf, crypto_key_check, nomod_minus_one);
1158 1162 NO_UNLOAD_STUB(kcf, crypto_key_check_prov, nomod_minus_one);
1159 1163 NO_UNLOAD_STUB(kcf, crypto_key_derive, nomod_minus_one);
1160 1164 NO_UNLOAD_STUB(kcf, crypto_key_generate, nomod_minus_one);
1161 1165 NO_UNLOAD_STUB(kcf, crypto_key_generate_pair, nomod_minus_one);
1162 1166 NO_UNLOAD_STUB(kcf, crypto_key_unwrap, nomod_minus_one);
1163 1167 NO_UNLOAD_STUB(kcf, crypto_key_wrap, nomod_minus_one);
1164 1168 NO_UNLOAD_STUB(kcf, crypto_mac, nomod_minus_one);
1165 1169 NO_UNLOAD_STUB(kcf, crypto_mac_prov, nomod_minus_one);
1166 1170 NO_UNLOAD_STUB(kcf, crypto_mac_verify, nomod_minus_one);
1167 1171 NO_UNLOAD_STUB(kcf, crypto_mac_verify_prov, nomod_minus_one);
1168 1172 NO_UNLOAD_STUB(kcf, crypto_mac_init, nomod_minus_one);
1169 1173 NO_UNLOAD_STUB(kcf, crypto_mac_init_prov, nomod_minus_one);
1170 1174 NO_UNLOAD_STUB(kcf, crypto_mac_update, nomod_minus_one);
1171 1175 NO_UNLOAD_STUB(kcf, crypto_mac_final, nomod_minus_one);
1172 1176 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt, nomod_minus_one);
1173 1177 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt_prov, nomod_minus_one);
1174 1178 NO_UNLOAD_STUB(kcf, crypto_mac_verify_decrypt, nomod_minus_one);
1175 1179 NO_UNLOAD_STUB(kcf, crypto_mac_verify_decrypt_prov, nomod_minus_one);
1176 1180 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt_init, nomod_minus_one);
1177 1181 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt_init_prov, nomod_minus_one);
1178 1182 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt_update, nomod_minus_one);
1179 1183 NO_UNLOAD_STUB(kcf, crypto_mac_decrypt_final, nomod_minus_one);
1180 1184 NO_UNLOAD_STUB(kcf, crypto_object_copy, nomod_minus_one);
1181 1185 NO_UNLOAD_STUB(kcf, crypto_object_create, nomod_minus_one);
1182 1186 NO_UNLOAD_STUB(kcf, crypto_object_destroy, nomod_minus_one);
1183 1187 NO_UNLOAD_STUB(kcf, crypto_object_find_final, nomod_minus_one);
1184 1188 NO_UNLOAD_STUB(kcf, crypto_object_find_init, nomod_minus_one);
1185 1189 NO_UNLOAD_STUB(kcf, crypto_object_find, nomod_minus_one);
1186 1190 NO_UNLOAD_STUB(kcf, crypto_object_get_attribute_value, nomod_minus_one);
1187 1191 NO_UNLOAD_STUB(kcf, crypto_object_get_size, nomod_minus_one);
1188 1192 NO_UNLOAD_STUB(kcf, crypto_object_set_attribute_value, nomod_minus_one);
1189 1193 NO_UNLOAD_STUB(kcf, crypto_session_close, nomod_minus_one);
1190 1194 NO_UNLOAD_STUB(kcf, crypto_session_login, nomod_minus_one);
1191 1195 NO_UNLOAD_STUB(kcf, crypto_session_logout, nomod_minus_one);
1192 1196 NO_UNLOAD_STUB(kcf, crypto_session_open, nomod_minus_one);
1193 1197 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac, nomod_minus_one);
1194 1198 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac_prov, nomod_minus_one);
1195 1199 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac_init, nomod_minus_one);
1196 1200 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac_init_prov, nomod_minus_one);
1197 1201 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac_update, nomod_minus_one);
1198 1202 NO_UNLOAD_STUB(kcf, crypto_encrypt_mac_final, nomod_minus_one);
1199 1203 NO_UNLOAD_STUB(kcf, crypto_create_ctx_template, nomod_minus_one);
1200 1204 NO_UNLOAD_STUB(kcf, crypto_destroy_ctx_template, nomod_minus_one);
1201 1205 NO_UNLOAD_STUB(kcf, crypto_get_mech_list, nomod_minus_one);
1202 1206 NO_UNLOAD_STUB(kcf, crypto_free_mech_list, nomod_minus_one);
1203 1207 NO_UNLOAD_STUB(kcf, crypto_cancel_req, nomod_minus_one);
1204 1208 NO_UNLOAD_STUB(kcf, crypto_cancel_ctx, nomod_minus_one);
1205 1209 NO_UNLOAD_STUB(kcf, crypto_bufcall_alloc, nomod_minus_one);
1206 1210 NO_UNLOAD_STUB(kcf, crypto_bufcall_free, nomod_minus_one);
1207 1211 NO_UNLOAD_STUB(kcf, crypto_bufcall, nomod_minus_one);
1208 1212 NO_UNLOAD_STUB(kcf, crypto_unbufcall, nomod_minus_one);
1209 1213 NO_UNLOAD_STUB(kcf, crypto_notify_events, nomod_minus_one);
1210 1214 NO_UNLOAD_STUB(kcf, crypto_unnotify_events, nomod_minus_one);
1211 1215 NO_UNLOAD_STUB(kcf, crypto_get_provider, nomod_minus_one);
1212 1216 NO_UNLOAD_STUB(kcf, crypto_get_provinfo, nomod_minus_one);
1213 1217 NO_UNLOAD_STUB(kcf, crypto_release_provider, nomod_minus_one);
1214 1218 NO_UNLOAD_STUB(kcf, crypto_sign, nomod_minus_one);
1215 1219 NO_UNLOAD_STUB(kcf, crypto_sign_prov, nomod_minus_one);
1216 1220 NO_UNLOAD_STUB(kcf, crypto_sign_init, nomod_minus_one);
1217 1221 NO_UNLOAD_STUB(kcf, crypto_sign_init_prov, nomod_minus_one);
1218 1222 NO_UNLOAD_STUB(kcf, crypto_sign_update, nomod_minus_one);
1219 1223 NO_UNLOAD_STUB(kcf, crypto_sign_final, nomod_minus_one);
1220 1224 NO_UNLOAD_STUB(kcf, crypto_sign_recover, nomod_minus_one);
1221 1225 NO_UNLOAD_STUB(kcf, crypto_sign_recover_prov, nomod_minus_one);
1222 1226 NO_UNLOAD_STUB(kcf, crypto_sign_recover_init_prov, nomod_minus_one);
1223 1227 NO_UNLOAD_STUB(kcf, crypto_verify, nomod_minus_one);
1224 1228 NO_UNLOAD_STUB(kcf, crypto_verify_prov, nomod_minus_one);
1225 1229 NO_UNLOAD_STUB(kcf, crypto_verify_init, nomod_minus_one);
1226 1230 NO_UNLOAD_STUB(kcf, crypto_verify_init_prov, nomod_minus_one);
1227 1231 NO_UNLOAD_STUB(kcf, crypto_verify_update, nomod_minus_one);
1228 1232 NO_UNLOAD_STUB(kcf, crypto_verify_final, nomod_minus_one);
1229 1233 NO_UNLOAD_STUB(kcf, crypto_verify_recover, nomod_minus_one);
1230 1234 NO_UNLOAD_STUB(kcf, crypto_verify_recover_prov, nomod_minus_one);
1231 1235 NO_UNLOAD_STUB(kcf, crypto_verify_recover_init_prov, nomod_minus_one);
1232 1236 NO_UNLOAD_STUB(kcf, random_add_entropy, nomod_minus_one);
1233 1237 NO_UNLOAD_STUB(kcf, random_add_pseudo_entropy, nomod_minus_one);
1234 1238 NO_UNLOAD_STUB(kcf, random_get_blocking_bytes, nomod_minus_one);
1235 1239 NO_UNLOAD_STUB(kcf, random_get_bytes, nomod_minus_one);
1236 1240 NO_UNLOAD_STUB(kcf, random_get_pseudo_bytes, nomod_minus_one);
1237 1241 END_MODULE(kcf);
1238 1242 #endif
1239 1243
1240 1244 /*
1241 1245 * Stubs for sha1. A non-unloadable module.
1242 1246 */
1243 1247 #ifndef SHA1_MODULE
1244 1248 MODULE(sha1,crypto);
1245 1249 NO_UNLOAD_STUB(sha1, SHA1Init, nomod_void);
1246 1250 NO_UNLOAD_STUB(sha1, SHA1Update, nomod_void);
1247 1251 NO_UNLOAD_STUB(sha1, SHA1Final, nomod_void);
1248 1252 END_MODULE(sha1);
1249 1253 #endif
1250 1254
1251 1255 /*
1252 1256 * The following stubs are used by the mac module.
1253 1257 * Since dld already depends on mac, these
1254 1258 * stubs are needed to avoid circular dependencies.
1255 1259 */
1256 1260 #ifndef DLD_MODULE
1257 1261 MODULE(dld,drv);
1258 1262 STUB(dld, dld_init_ops, nomod_void);
1259 1263 STUB(dld, dld_fini_ops, nomod_void);
1260 1264 STUB(dld, dld_devt_to_instance, nomod_minus_one);
1261 1265 STUB(dld, dld_autopush, nomod_minus_one);
1262 1266 STUB(dld, dld_ioc_register, nomod_einval);
1263 1267 STUB(dld, dld_ioc_unregister, nomod_void);
1264 1268 END_MODULE(dld);
1265 1269 #endif
1266 1270
1267 1271 /*
1268 1272 * The following stubs are used by the mac module.
1269 1273 * Since dls already depends on mac, these
1270 1274 * stubs are needed to avoid circular dependencies.
1271 1275 */
1272 1276 #ifndef DLS_MODULE
1273 1277 MODULE(dls,misc);
1274 1278 STUB(dls, dls_devnet_mac, nomod_zero);
1275 1279 STUB(dls, dls_devnet_hold_tmp, nomod_einval);
1276 1280 STUB(dls, dls_devnet_rele_tmp, nomod_void);
1277 1281 STUB(dls, dls_devnet_hold_link, nomod_einval);
1278 1282 STUB(dls, dls_devnet_rele_link, nomod_void);
1279 1283 STUB(dls, dls_devnet_prop_task_wait, nomod_void);
1280 1284 STUB(dls, dls_mgmt_get_linkid, nomod_einval);
1281 1285 STUB(dls, dls_devnet_macname2linkid, nomod_einval);
1282 1286 STUB(dls, dls_mgmt_get_linkinfo, nomod_einval);
1283 1287 END_MODULE(dls);
1284 1288 #endif
1285 1289
1286 1290 #ifndef SOFTMAC_MODULE
1287 1291 MODULE(softmac,drv);
1288 1292 STUB(softmac, softmac_hold_device, nomod_einval);
1289 1293 STUB(softmac, softmac_rele_device, nomod_void);
1290 1294 STUB(softmac, softmac_recreate, nomod_void);
1291 1295 END_MODULE(softmac);
1292 1296 #endif
1293 1297
1294 1298 #ifndef IPTUN_MODULE
1295 1299 MODULE(iptun,drv);
1296 1300 STUB(iptun, iptun_create, nomod_einval);
1297 1301 STUB(iptun, iptun_delete, nomod_einval);
1298 1302 STUB(iptun, iptun_set_policy, nomod_void) ;
1299 1303 END_MODULE(iptun);
1300 1304 #endif
1301 1305
1302 1306 /*
1303 1307 * Stubs for dcopy, for Intel IOAT KAPIs
1304 1308 */
1305 1309 #ifndef DCOPY_MODULE
1306 1310 MODULE(dcopy,misc);
1307 1311 NO_UNLOAD_STUB(dcopy, dcopy_query, nomod_minus_one);
1308 1312 NO_UNLOAD_STUB(dcopy, dcopy_query_channel, nomod_minus_one);
1309 1313 NO_UNLOAD_STUB(dcopy, dcopy_alloc, nomod_minus_one);
1310 1314 NO_UNLOAD_STUB(dcopy, dcopy_free, nomod_minus_one);
1311 1315 NO_UNLOAD_STUB(dcopy, dcopy_cmd_alloc, nomod_minus_one);
1312 1316 NO_UNLOAD_STUB(dcopy, dcopy_cmd_free, nomod_void);
1313 1317 NO_UNLOAD_STUB(dcopy, dcopy_cmd_post, nomod_minus_one);
1314 1318 NO_UNLOAD_STUB(dcopy, dcopy_cmd_poll, nomod_minus_one);
1315 1319 END_MODULE(dcopy);
1316 1320 #endif
1317 1321
1318 1322 /*
1319 1323 * Stubs for acpica
1320 1324 */
1321 1325 #ifndef ACPICA_MODULE
1322 1326 MODULE(acpica,misc);
1323 1327 NO_UNLOAD_STUB(acpica, AcpiOsReadPort, nomod_minus_one) ;
1324 1328 NO_UNLOAD_STUB(acpica, AcpiOsWritePort, nomod_minus_one) ;
1325 1329 NO_UNLOAD_STUB(acpica, AcpiInstallNotifyHandler, nomod_minus_one) ;
1326 1330 NO_UNLOAD_STUB(acpica, AcpiRemoveNotifyHandler, nomod_minus_one) ;
1327 1331 NO_UNLOAD_STUB(acpica, AcpiEvaluateObject, nomod_minus_one) ;
1328 1332 NO_UNLOAD_STUB(acpica, AcpiEvaluateObjectTyped, nomod_minus_one) ;
1329 1333 NO_UNLOAD_STUB(acpica, AcpiWriteBitRegister, nomod_minus_one) ;
1330 1334 NO_UNLOAD_STUB(acpica, AcpiReadBitRegister, nomod_minus_one) ;
1331 1335 NO_UNLOAD_STUB(acpica, AcpiOsFree, nomod_minus_one) ;
1332 1336 NO_UNLOAD_STUB(acpica, acpica_get_handle_cpu, nomod_minus_one) ;
1333 1337 NO_UNLOAD_STUB(acpica, acpica_get_global_FADT, nomod_minus_one) ;
1334 1338 NO_UNLOAD_STUB(acpica, acpica_write_cpupm_capabilities,
1335 1339 nomod_minus_one) ;
1336 1340 NO_UNLOAD_STUB(acpica, __acpi_wbinvd, nomod_minus_one) ;
1337 1341 NO_UNLOAD_STUB(acpica, acpi_reset_system, nomod_minus_one) ;
1338 1342 END_MODULE(acpica);
1339 1343 #endif
1340 1344
1341 1345 /*
1342 1346 * Stubs for acpidev
1343 1347 */
1344 1348 #ifndef ACPIDEV_MODULE
1345 1349 MODULE(acpidev,misc);
1346 1350 NO_UNLOAD_STUB(acpidev, acpidev_dr_get_cpu_numa_info, nomod_minus_one) ;
1347 1351 NO_UNLOAD_STUB(acpidev, acpidev_dr_free_cpu_numa_info,
1348 1352 nomod_minus_one) ;
1349 1353 END_MODULE(acpidev);
1350 1354 #endif
1351 1355
1352 1356 #ifndef IPNET_MODULE
1353 1357 MODULE(ipnet,drv);
1354 1358 STUB(ipnet, ipnet_if_getdev, nomod_zero);
1355 1359 STUB(ipnet, ipnet_walk_if, nomod_zero);
1356 1360 END_MODULE(ipnet);
1357 1361 #endif
1358 1362
1359 1363 #ifndef IOMMULIB_MODULE
1360 1364 MODULE(iommulib,misc);
1361 1365 STUB(iommulib, iommulib_nex_close, nomod_void);
1362 1366 END_MODULE(iommulib);
1363 1367 #endif
1364 1368
1365 1369 /*
1366 1370 * Stubs for rootnex nexus driver.
1367 1371 */
1368 1372 #ifndef ROOTNEX_MODULE
1369 1373 MODULE(rootnex,drv);
1370 1374 STUB(rootnex, immu_init, 0);
1371 1375 STUB(rootnex, immu_startup, 0);
1372 1376 STUB(rootnex, immu_physmem_update, 0);
1373 1377 END_MODULE(rootnex);
1374 1378 #endif
1375 1379
1376 1380 /*
1377 1381 * Stubs for kernel socket, for iscsi
1378 1382 */
1379 1383 #ifndef KSOCKET_MODULE
1380 1384 MODULE(ksocket, misc);
1381 1385 NO_UNLOAD_STUB(ksocket, ksocket_setsockopt, nomod_minus_one);
1382 1386 NO_UNLOAD_STUB(ksocket, ksocket_getsockopt, nomod_minus_one);
1383 1387 NO_UNLOAD_STUB(ksocket, ksocket_getpeername, nomod_minus_one);
1384 1388 NO_UNLOAD_STUB(ksocket, ksocket_getsockname, nomod_minus_one);
1385 1389 NO_UNLOAD_STUB(ksocket, ksocket_socket, nomod_minus_one);
1386 1390 NO_UNLOAD_STUB(ksocket, ksocket_bind, nomod_minus_one);
1387 1391 NO_UNLOAD_STUB(ksocket, ksocket_listen, nomod_minus_one);
1388 1392 NO_UNLOAD_STUB(ksocket, ksocket_accept, nomod_minus_one);
1389 1393 NO_UNLOAD_STUB(ksocket, ksocket_connect, nomod_minus_one);
1390 1394 NO_UNLOAD_STUB(ksocket, ksocket_recv, nomod_minus_one);
1391 1395 NO_UNLOAD_STUB(ksocket, ksocket_recvfrom, nomod_minus_one);
1392 1396 NO_UNLOAD_STUB(ksocket, ksocket_recvmsg, nomod_minus_one);
1393 1397 NO_UNLOAD_STUB(ksocket, ksocket_send, nomod_minus_one);
1394 1398 NO_UNLOAD_STUB(ksocket, ksocket_sendto, nomod_minus_one);
1395 1399 NO_UNLOAD_STUB(ksocket, ksocket_sendmsg, nomod_minus_one);
1396 1400 NO_UNLOAD_STUB(ksocket, ksocket_ioctl, nomod_minus_one);
1397 1401 NO_UNLOAD_STUB(ksocket, ksocket_setcallbacks, nomod_minus_one);
1398 1402 NO_UNLOAD_STUB(ksocket, ksocket_hold, nomod_minus_one);
1399 1403 NO_UNLOAD_STUB(ksocket, ksocket_rele, nomod_minus_one);
1400 1404 NO_UNLOAD_STUB(ksocket, ksocket_shutdown, nomod_minus_one);
1401 1405 NO_UNLOAD_STUB(ksocket, ksocket_close, nomod_minus_one);
1402 1406 END_MODULE(ksocket);
1403 1407 #endif
1404 1408
1405 1409 /*
1406 1410 * Stubs for elfexec
1407 1411 */
1408 1412 #ifndef ELFEXEC_MODULE
1409 1413 MODULE(elfexec,exec);
1410 1414 STUB(elfexec, elfexec, nomod_einval);
1411 1415 STUB(elfexec, mapexec_brand, nomod_einval);
1412 1416 #if defined(__amd64)
1413 1417 STUB(elfexec, elf32exec, nomod_einval);
1414 1418 STUB(elfexec, mapexec32_brand, nomod_einval);
1415 1419 #endif
1416 1420 END_MODULE(elfexec);
1417 1421 #endif
1418 1422
1419 1423 /*
1420 1424 * Stub(s) for APIX module.
1421 1425 */
1422 1426 #ifndef APIX_MODULE
1423 1427 MODULE(apix,mach);
1424 1428 WSTUB(apix, apix_loaded, nomod_zero);
1425 1429 END_MODULE(apix);
1426 1430 #endif
1427 1431
1428 1432 / this is just a marker for the area of text that contains stubs
1429 1433
1430 1434 ENTRY_NP(stubs_end)
1431 1435 nop
1432 1436
1433 1437 #endif /* lint */
|
↓ open down ↓ |
458 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX