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