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