Change the functions to ANSI in those cases where it breaks promotion
to int rule. See ISO C Standard: SS6.7.5.3:15. Approved by: kib (mentor) Reviewed by: warner Tested by: silence on -current
This commit is contained in:
parent
dfb175c530
commit
af83f5d77c
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=189004
@ -258,10 +258,8 @@ ndis_getdone_func(adapter, status)
|
||||
}
|
||||
|
||||
static void
|
||||
ndis_resetdone_func(adapter, status, addressingreset)
|
||||
ndis_handle adapter;
|
||||
ndis_status status;
|
||||
uint8_t addressingreset;
|
||||
ndis_resetdone_func(ndis_handle adapter, ndis_status status,
|
||||
uint8_t addressingreset)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
struct ndis_softc *sc;
|
||||
|
@ -142,18 +142,14 @@ WRITE_PORT_ULONG(port, val)
|
||||
}
|
||||
|
||||
static void
|
||||
WRITE_PORT_USHORT(port, val)
|
||||
uint16_t *port;
|
||||
uint16_t val;
|
||||
WRITE_PORT_USHORT(uint16_t *port, uint16_t val)
|
||||
{
|
||||
bus_space_write_2(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port, val);
|
||||
return;
|
||||
}
|
||||
|
||||
static void
|
||||
WRITE_PORT_UCHAR(port, val)
|
||||
uint8_t *port;
|
||||
uint8_t val;
|
||||
WRITE_PORT_UCHAR(uint8_t *port, uint8_t val)
|
||||
{
|
||||
bus_space_write_1(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port, val);
|
||||
return;
|
||||
@ -378,9 +374,7 @@ KfAcquireSpinLock(lock)
|
||||
}
|
||||
|
||||
void
|
||||
KfReleaseSpinLock(lock, newirql)
|
||||
kspin_lock *lock;
|
||||
uint8_t newirql;
|
||||
KfReleaseSpinLock(kspin_lock *lock, uint8_t newirql)
|
||||
{
|
||||
KeReleaseSpinLockFromDpcLevel(lock);
|
||||
KeLowerIrql(newirql);
|
||||
@ -407,8 +401,7 @@ KeQueryPerformanceCounter(freq)
|
||||
}
|
||||
|
||||
uint8_t
|
||||
KfRaiseIrql(irql)
|
||||
uint8_t irql;
|
||||
KfRaiseIrql(uint8_t irql)
|
||||
{
|
||||
uint8_t oldirql;
|
||||
|
||||
@ -428,8 +421,7 @@ KfRaiseIrql(irql)
|
||||
}
|
||||
|
||||
void
|
||||
KfLowerIrql(oldirql)
|
||||
uint8_t oldirql;
|
||||
KfLowerIrql(uint8_t oldirql)
|
||||
{
|
||||
if (oldirql == DISPATCH_LEVEL)
|
||||
return;
|
||||
@ -453,8 +445,7 @@ KeRaiseIrqlToDpcLevel(void)
|
||||
}
|
||||
|
||||
static void
|
||||
_KeLowerIrql(oldirql)
|
||||
uint8_t oldirql;
|
||||
_KeLowerIrql(uint8_t oldirql)
|
||||
{
|
||||
KeLowerIrql(oldirql);
|
||||
return;
|
||||
|
@ -905,10 +905,8 @@ NdisInitializeReadWriteLock(lock)
|
||||
}
|
||||
|
||||
static void
|
||||
NdisAcquireReadWriteLock(lock, writeacc, state)
|
||||
ndis_rw_lock *lock;
|
||||
uint8_t writeacc;
|
||||
ndis_lock_state *state;
|
||||
NdisAcquireReadWriteLock(ndis_rw_lock *lock, uint8_t writeacc,
|
||||
ndis_lock_state *state)
|
||||
{
|
||||
if (writeacc == TRUE) {
|
||||
KeAcquireSpinLock(&lock->nrl_spinlock, &state->nls_oldirql);
|
||||
@ -1091,13 +1089,9 @@ ndis_map_cb(arg, segs, nseg, error)
|
||||
}
|
||||
|
||||
static void
|
||||
NdisMStartBufferPhysicalMapping(adapter, buf, mapreg, writedev, addrarray, arraysize)
|
||||
ndis_handle adapter;
|
||||
ndis_buffer *buf;
|
||||
uint32_t mapreg;
|
||||
uint8_t writedev;
|
||||
ndis_paddr_unit *addrarray;
|
||||
uint32_t *arraysize;
|
||||
NdisMStartBufferPhysicalMapping(ndis_handle adapter, ndis_buffer *buf,
|
||||
uint32_t mapreg, uint8_t writedev, ndis_paddr_unit *addrarray,
|
||||
uint32_t *arraysize)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
struct ndis_softc *sc;
|
||||
@ -1474,12 +1468,8 @@ NdisQueryMapRegisterCount(bustype, cnt)
|
||||
}
|
||||
|
||||
static ndis_status
|
||||
NdisMAllocateMapRegisters(adapter, dmachannel, dmasize, physmapneeded, maxmap)
|
||||
ndis_handle adapter;
|
||||
uint32_t dmachannel;
|
||||
uint8_t dmasize;
|
||||
uint32_t physmapneeded;
|
||||
uint32_t maxmap;
|
||||
NdisMAllocateMapRegisters(ndis_handle adapter, uint32_t dmachannel,
|
||||
uint8_t dmasize, uint32_t physmapneeded, uint32_t maxmap)
|
||||
{
|
||||
struct ndis_softc *sc;
|
||||
ndis_miniport_block *block;
|
||||
@ -1557,12 +1547,8 @@ ndis_mapshared_cb(arg, segs, nseg, error)
|
||||
*/
|
||||
|
||||
static void
|
||||
NdisMAllocateSharedMemory(adapter, len, cached, vaddr, paddr)
|
||||
ndis_handle adapter;
|
||||
uint32_t len;
|
||||
uint8_t cached;
|
||||
void **vaddr;
|
||||
ndis_physaddr *paddr;
|
||||
NdisMAllocateSharedMemory(ndis_handle adapter, uint32_t len, uint8_t cached,
|
||||
void **vaddr, ndis_physaddr *paddr)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
struct ndis_softc *sc;
|
||||
@ -1680,11 +1666,8 @@ ndis_asyncmem_complete(dobj, arg)
|
||||
}
|
||||
|
||||
static ndis_status
|
||||
NdisMAllocateSharedMemoryAsync(adapter, len, cached, ctx)
|
||||
ndis_handle adapter;
|
||||
uint32_t len;
|
||||
uint8_t cached;
|
||||
void *ctx;
|
||||
NdisMAllocateSharedMemoryAsync(ndis_handle adapter, uint32_t len,
|
||||
uint8_t cached, void *ctx)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
struct ndis_allocwork *w;
|
||||
@ -1717,12 +1700,8 @@ NdisMAllocateSharedMemoryAsync(adapter, len, cached, ctx)
|
||||
}
|
||||
|
||||
static void
|
||||
NdisMFreeSharedMemory(adapter, len, cached, vaddr, paddr)
|
||||
ndis_handle adapter;
|
||||
uint32_t len;
|
||||
uint8_t cached;
|
||||
void *vaddr;
|
||||
ndis_physaddr paddr;
|
||||
NdisMFreeSharedMemory(ndis_handle adapter, uint32_t len, uint8_t cached,
|
||||
void *vaddr, ndis_physaddr paddr)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
struct ndis_softc *sc;
|
||||
@ -1829,10 +1808,8 @@ NdisMGetDmaAlignment(handle)
|
||||
*/
|
||||
|
||||
static ndis_status
|
||||
NdisMInitializeScatterGatherDma(adapter, is64, maxphysmap)
|
||||
ndis_handle adapter;
|
||||
uint8_t is64;
|
||||
uint32_t maxphysmap;
|
||||
NdisMInitializeScatterGatherDma(ndis_handle adapter, uint8_t is64,
|
||||
uint32_t maxphysmap)
|
||||
{
|
||||
struct ndis_softc *sc;
|
||||
ndis_miniport_block *block;
|
||||
@ -2433,14 +2410,9 @@ ndis_intrhand(dpc, intr, sysarg1, sysarg2)
|
||||
}
|
||||
|
||||
static ndis_status
|
||||
NdisMRegisterInterrupt(intr, adapter, ivec, ilevel, reqisr, shared, imode)
|
||||
ndis_miniport_interrupt *intr;
|
||||
ndis_handle adapter;
|
||||
uint32_t ivec;
|
||||
uint32_t ilevel;
|
||||
uint8_t reqisr;
|
||||
uint8_t shared;
|
||||
ndis_interrupt_mode imode;
|
||||
NdisMRegisterInterrupt(ndis_miniport_interrupt *intr, ndis_handle adapter,
|
||||
uint32_t ivec, uint32_t ilevel, uint8_t reqisr, uint8_t shared,
|
||||
ndis_interrupt_mode imode)
|
||||
{
|
||||
ndis_miniport_block *block;
|
||||
ndis_miniport_characteristics *ch;
|
||||
|
@ -446,10 +446,7 @@ ntoskrnl_memmove(dst, src, size)
|
||||
}
|
||||
|
||||
static void *
|
||||
ntoskrnl_memchr(buf, ch, len)
|
||||
void *buf;
|
||||
unsigned char ch;
|
||||
size_t len;
|
||||
ntoskrnl_memchr(void *buf, unsigned char ch, size_t len)
|
||||
{
|
||||
if (len != 0) {
|
||||
unsigned char *p = buf;
|
||||
@ -520,10 +517,8 @@ ntoskrnl_tolower(c)
|
||||
}
|
||||
|
||||
static uint8_t
|
||||
RtlEqualUnicodeString(str1, str2, caseinsensitive)
|
||||
unicode_string *str1;
|
||||
unicode_string *str2;
|
||||
uint8_t caseinsensitive;
|
||||
RtlEqualUnicodeString(unicode_string *str1, unicode_string *str2,
|
||||
uint8_t caseinsensitive)
|
||||
{
|
||||
int i;
|
||||
|
||||
@ -595,10 +590,7 @@ ntoskrnl_unicode_to_ascii(unicode, ascii, len)
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RtlUnicodeStringToAnsiString(dest, src, allocate)
|
||||
ansi_string *dest;
|
||||
unicode_string *src;
|
||||
uint8_t allocate;
|
||||
RtlUnicodeStringToAnsiString(ansi_string *dest, unicode_string *src, uint8_t allocate)
|
||||
{
|
||||
if (dest == NULL || src == NULL)
|
||||
return(STATUS_INVALID_PARAMETER);
|
||||
@ -626,10 +618,8 @@ RtlUnicodeStringToAnsiString(dest, src, allocate)
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RtlAnsiStringToUnicodeString(dest, src, allocate)
|
||||
unicode_string *dest;
|
||||
ansi_string *src;
|
||||
uint8_t allocate;
|
||||
RtlAnsiStringToUnicodeString(unicode_string *dest, ansi_string *src,
|
||||
uint8_t allocate)
|
||||
{
|
||||
if (dest == NULL || src == NULL)
|
||||
return(STATUS_INVALID_PARAMETER);
|
||||
@ -727,14 +717,9 @@ IoGetDriverObjectExtension(drv, clid)
|
||||
|
||||
|
||||
uint32_t
|
||||
IoCreateDevice(drv, devextlen, devname, devtype, devchars, exclusive, newdev)
|
||||
driver_object *drv;
|
||||
uint32_t devextlen;
|
||||
unicode_string *devname;
|
||||
uint32_t devtype;
|
||||
uint32_t devchars;
|
||||
uint8_t exclusive;
|
||||
device_object **newdev;
|
||||
IoCreateDevice(driver_object *drv, uint32_t devextlen, unicode_string *devname,
|
||||
uint32_t devtype, uint32_t devchars, uint8_t exclusive,
|
||||
device_object **newdev)
|
||||
{
|
||||
device_object *dev;
|
||||
|
||||
@ -952,17 +937,9 @@ IoBuildAsynchronousFsdRequest(func, dobj, buf, len, off, status)
|
||||
}
|
||||
|
||||
static irp *
|
||||
IoBuildDeviceIoControlRequest(iocode, dobj, ibuf, ilen, obuf, olen,
|
||||
isinternal, event, status)
|
||||
uint32_t iocode;
|
||||
device_object *dobj;
|
||||
void *ibuf;
|
||||
uint32_t ilen;
|
||||
void *obuf;
|
||||
uint32_t olen;
|
||||
uint8_t isinternal;
|
||||
nt_kevent *event;
|
||||
io_status_block *status;
|
||||
IoBuildDeviceIoControlRequest(uint32_t iocode, device_object *dobj, void *ibuf,
|
||||
uint32_t ilen, void *obuf, uint32_t olen, uint8_t isinternal,
|
||||
nt_kevent *event, io_status_block *status)
|
||||
{
|
||||
irp *ip;
|
||||
io_stack_location *sl;
|
||||
@ -1048,9 +1025,7 @@ IoBuildDeviceIoControlRequest(iocode, dobj, ibuf, ilen, obuf, olen,
|
||||
}
|
||||
|
||||
static irp *
|
||||
IoAllocateIrp(stsize, chargequota)
|
||||
uint8_t stsize;
|
||||
uint8_t chargequota;
|
||||
IoAllocateIrp(uint8_t stsize, uint8_t chargequota)
|
||||
{
|
||||
irp *i;
|
||||
|
||||
@ -1064,9 +1039,7 @@ IoAllocateIrp(stsize, chargequota)
|
||||
}
|
||||
|
||||
static irp *
|
||||
IoMakeAssociatedIrp(ip, stsize)
|
||||
irp *ip;
|
||||
uint8_t stsize;
|
||||
IoMakeAssociatedIrp(irp *ip, uint8_t stsize)
|
||||
{
|
||||
irp *associrp;
|
||||
|
||||
@ -1093,10 +1066,7 @@ IoFreeIrp(ip)
|
||||
}
|
||||
|
||||
static void
|
||||
IoInitializeIrp(io, psize, ssize)
|
||||
irp *io;
|
||||
uint16_t psize;
|
||||
uint8_t ssize;
|
||||
IoInitializeIrp(irp *io, uint16_t psize, uint8_t ssize)
|
||||
{
|
||||
bzero((char *)io, IoSizeOfIrp(ssize));
|
||||
io->irp_size = psize;
|
||||
@ -1125,16 +1095,14 @@ IoReuseIrp(ip, status)
|
||||
}
|
||||
|
||||
void
|
||||
IoAcquireCancelSpinLock(irql)
|
||||
uint8_t *irql;
|
||||
IoAcquireCancelSpinLock(uint8_t *irql)
|
||||
{
|
||||
KeAcquireSpinLock(&ntoskrnl_cancellock, irql);
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
IoReleaseCancelSpinLock(irql)
|
||||
uint8_t irql;
|
||||
IoReleaseCancelSpinLock(uint8_t irql)
|
||||
{
|
||||
KeReleaseSpinLock(&ntoskrnl_cancellock, irql);
|
||||
return;
|
||||
@ -1185,9 +1153,7 @@ IofCallDriver(dobj, ip)
|
||||
}
|
||||
|
||||
void
|
||||
IofCompleteRequest(ip, prioboost)
|
||||
irp *ip;
|
||||
uint8_t prioboost;
|
||||
IofCompleteRequest(irp *ip, uint8_t prioboost)
|
||||
{
|
||||
uint32_t status;
|
||||
device_object *dobj;
|
||||
@ -1302,9 +1268,7 @@ KeAcquireInterruptSpinLock(iobj)
|
||||
}
|
||||
|
||||
void
|
||||
KeReleaseInterruptSpinLock(iobj, irql)
|
||||
kinterrupt *iobj;
|
||||
uint8_t irql;
|
||||
KeReleaseInterruptSpinLock(kinterrupt *iobj, uint8_t irql)
|
||||
{
|
||||
KeReleaseSpinLock(&ntoskrnl_intlock, irql);
|
||||
return;
|
||||
@ -1342,19 +1306,9 @@ KeSynchronizeExecution(iobj, syncfunc, syncctx)
|
||||
*/
|
||||
|
||||
uint32_t
|
||||
IoConnectInterrupt(iobj, svcfunc, svcctx, lock, vector, irql,
|
||||
syncirql, imode, shared, affinity, savefloat)
|
||||
kinterrupt **iobj;
|
||||
void *svcfunc;
|
||||
void *svcctx;
|
||||
uint32_t vector;
|
||||
kspin_lock *lock;
|
||||
uint8_t irql;
|
||||
uint8_t syncirql;
|
||||
uint8_t imode;
|
||||
uint8_t shared;
|
||||
uint32_t affinity;
|
||||
uint8_t savefloat;
|
||||
IoConnectInterrupt(kinterrupt **iobj, void *svcfunc, void *svcctx,
|
||||
kspin_lock *lock, uint32_t vector, uint8_t irql, uint8_t syncirql,
|
||||
uint8_t imode, uint8_t shared, uint32_t affinity, uint8_t savefloat)
|
||||
{
|
||||
uint8_t curirql;
|
||||
|
||||
@ -1699,12 +1653,8 @@ KeTickCount(void)
|
||||
*/
|
||||
|
||||
uint32_t
|
||||
KeWaitForSingleObject(arg, reason, mode, alertable, duetime)
|
||||
void *arg;
|
||||
uint32_t reason;
|
||||
uint32_t mode;
|
||||
uint8_t alertable;
|
||||
int64_t *duetime;
|
||||
KeWaitForSingleObject(void *arg, uint32_t reason, uint32_t mode,
|
||||
uint8_t alertable, int64_t *duetime)
|
||||
{
|
||||
wait_block w;
|
||||
struct thread *td = curthread;
|
||||
@ -1811,16 +1761,9 @@ KeWaitForSingleObject(arg, reason, mode, alertable, duetime)
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
KeWaitForMultipleObjects(cnt, obj, wtype, reason, mode,
|
||||
alertable, duetime, wb_array)
|
||||
uint32_t cnt;
|
||||
nt_dispatch_header *obj[];
|
||||
uint32_t wtype;
|
||||
uint32_t reason;
|
||||
uint32_t mode;
|
||||
uint8_t alertable;
|
||||
int64_t *duetime;
|
||||
wait_block *wb_array;
|
||||
KeWaitForMultipleObjects(uint32_t cnt, nt_dispatch_header *obj[], uint32_t wtype,
|
||||
uint32_t reason, uint32_t mode, uint8_t alertable, int64_t *duetime,
|
||||
wait_block *wb_array)
|
||||
{
|
||||
struct thread *td = curthread;
|
||||
wait_block *whead, *w;
|
||||
@ -2021,9 +1964,7 @@ KeWaitForMultipleObjects(cnt, obj, wtype, reason, mode,
|
||||
}
|
||||
|
||||
static void
|
||||
WRITE_REGISTER_USHORT(reg, val)
|
||||
uint16_t *reg;
|
||||
uint16_t val;
|
||||
WRITE_REGISTER_USHORT(uint16_t *reg, uint16_t val)
|
||||
{
|
||||
bus_space_write_2(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val);
|
||||
return;
|
||||
@ -2053,16 +1994,13 @@ READ_REGISTER_ULONG(reg)
|
||||
}
|
||||
|
||||
static uint8_t
|
||||
READ_REGISTER_UCHAR(reg)
|
||||
uint8_t *reg;
|
||||
READ_REGISTER_UCHAR(uint8_t *reg)
|
||||
{
|
||||
return(bus_space_read_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg));
|
||||
}
|
||||
|
||||
static void
|
||||
WRITE_REGISTER_UCHAR(reg, val)
|
||||
uint8_t *reg;
|
||||
uint8_t val;
|
||||
WRITE_REGISTER_UCHAR(uint8_t *reg, uint8_t val)
|
||||
{
|
||||
bus_space_write_1(NDIS_BUS_SPACE_MEM, 0x0, (bus_size_t)reg, val);
|
||||
return;
|
||||
@ -2117,33 +2055,25 @@ _aullrem(a, b)
|
||||
}
|
||||
|
||||
static int64_t
|
||||
_allshl(a, b)
|
||||
int64_t a;
|
||||
uint8_t b;
|
||||
_allshl(int64_t a, uint8_t b)
|
||||
{
|
||||
return (a << b);
|
||||
}
|
||||
|
||||
static uint64_t
|
||||
_aullshl(a, b)
|
||||
uint64_t a;
|
||||
uint8_t b;
|
||||
_aullshl(uint64_t a, uint8_t b)
|
||||
{
|
||||
return (a << b);
|
||||
}
|
||||
|
||||
static int64_t
|
||||
_allshr(a, b)
|
||||
int64_t a;
|
||||
uint8_t b;
|
||||
_allshr(int64_t a, uint8_t b)
|
||||
{
|
||||
return (a >> b);
|
||||
}
|
||||
|
||||
static uint64_t
|
||||
_aullshr(a, b)
|
||||
uint64_t a;
|
||||
uint8_t b;
|
||||
_aullshr(uint64_t a, uint8_t b)
|
||||
{
|
||||
return (a >> b);
|
||||
}
|
||||
@ -2208,15 +2138,9 @@ ntoskrnl_findwrap(func)
|
||||
}
|
||||
|
||||
static void
|
||||
ExInitializePagedLookasideList(lookaside, allocfunc, freefunc,
|
||||
flags, size, tag, depth)
|
||||
paged_lookaside_list *lookaside;
|
||||
lookaside_alloc_func *allocfunc;
|
||||
lookaside_free_func *freefunc;
|
||||
uint32_t flags;
|
||||
size_t size;
|
||||
uint32_t tag;
|
||||
uint16_t depth;
|
||||
ExInitializePagedLookasideList(paged_lookaside_list *lookaside,
|
||||
lookaside_alloc_func *allocfunc, lookaside_free_func *freefunc,
|
||||
uint32_t flags, size_t size, uint32_t tag, uint16_t depth)
|
||||
{
|
||||
bzero((char *)lookaside, sizeof(paged_lookaside_list));
|
||||
|
||||
@ -2263,15 +2187,9 @@ ExDeletePagedLookasideList(lookaside)
|
||||
}
|
||||
|
||||
static void
|
||||
ExInitializeNPagedLookasideList(lookaside, allocfunc, freefunc,
|
||||
flags, size, tag, depth)
|
||||
npaged_lookaside_list *lookaside;
|
||||
lookaside_alloc_func *allocfunc;
|
||||
lookaside_free_func *freefunc;
|
||||
uint32_t flags;
|
||||
size_t size;
|
||||
uint32_t tag;
|
||||
uint16_t depth;
|
||||
ExInitializeNPagedLookasideList(npaged_lookaside_list *lookaside,
|
||||
lookaside_alloc_func *allocfunc, lookaside_free_func *freefunc,
|
||||
uint32_t flags, size_t size, uint32_t tag, uint16_t depth)
|
||||
{
|
||||
bzero((char *)lookaside, sizeof(npaged_lookaside_list));
|
||||
|
||||
@ -2489,12 +2407,8 @@ ExInterlockedAddLargeStatistic(addend, inc)
|
||||
};
|
||||
|
||||
mdl *
|
||||
IoAllocateMdl(vaddr, len, secondarybuf, chargequota, iopkt)
|
||||
void *vaddr;
|
||||
uint32_t len;
|
||||
uint8_t secondarybuf;
|
||||
uint8_t chargequota;
|
||||
irp *iopkt;
|
||||
IoAllocateMdl(void *vaddr, uint32_t len, uint8_t secondarybuf,
|
||||
uint8_t chargequota, irp *iopkt)
|
||||
{
|
||||
mdl *m;
|
||||
int zone = 0;
|
||||
@ -2643,23 +2557,15 @@ MmBuildMdlForNonPagedPool(m)
|
||||
}
|
||||
|
||||
static void *
|
||||
MmMapLockedPages(buf, accessmode)
|
||||
mdl *buf;
|
||||
uint8_t accessmode;
|
||||
MmMapLockedPages(mdl *buf, uint8_t accessmode)
|
||||
{
|
||||
buf->mdl_flags |= MDL_MAPPED_TO_SYSTEM_VA;
|
||||
return(MmGetMdlVirtualAddress(buf));
|
||||
}
|
||||
|
||||
static void *
|
||||
MmMapLockedPagesSpecifyCache(buf, accessmode, cachetype, vaddr,
|
||||
bugcheck, prio)
|
||||
mdl *buf;
|
||||
uint8_t accessmode;
|
||||
uint32_t cachetype;
|
||||
void *vaddr;
|
||||
uint32_t bugcheck;
|
||||
uint32_t prio;
|
||||
MmMapLockedPagesSpecifyCache(mdl *buf, uint8_t accessmode, uint32_t cachetype,
|
||||
void *vaddr, uint32_t bugcheck, uint32_t prio)
|
||||
{
|
||||
return(MmMapLockedPages(buf, accessmode));
|
||||
}
|
||||
@ -3237,9 +3143,7 @@ srand(seed)
|
||||
}
|
||||
|
||||
static uint8_t
|
||||
IoIsWdmVersionAvailable(major, minor)
|
||||
uint8_t major;
|
||||
uint8_t minor;
|
||||
IoIsWdmVersionAvailable(uint8_t major, uint8_t minor)
|
||||
{
|
||||
if (major == WDM_MAJOR && minor == WDM_MINOR_WINXP)
|
||||
return(TRUE);
|
||||
@ -3299,9 +3203,7 @@ KeInitializeMutex(kmutex, level)
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
KeReleaseMutex(kmutex, kwait)
|
||||
kmutant *kmutex;
|
||||
uint8_t kwait;
|
||||
KeReleaseMutex(kmutant *kmutex, uint8_t kwait)
|
||||
{
|
||||
uint32_t prevstate;
|
||||
|
||||
@ -3333,10 +3235,7 @@ KeReadStateMutex(kmutex)
|
||||
}
|
||||
|
||||
void
|
||||
KeInitializeEvent(kevent, type, state)
|
||||
nt_kevent *kevent;
|
||||
uint32_t type;
|
||||
uint8_t state;
|
||||
KeInitializeEvent(nt_kevent *kevent, uint32_t type, uint8_t state)
|
||||
{
|
||||
InitializeListHead((&kevent->k_header.dh_waitlisthead));
|
||||
kevent->k_header.dh_sigstate = state;
|
||||
@ -3363,10 +3262,7 @@ KeResetEvent(kevent)
|
||||
}
|
||||
|
||||
uint32_t
|
||||
KeSetEvent(kevent, increment, kwait)
|
||||
nt_kevent *kevent;
|
||||
uint32_t increment;
|
||||
uint8_t kwait;
|
||||
KeSetEvent(nt_kevent *kevent, uint32_t increment, uint8_t kwait)
|
||||
{
|
||||
uint32_t prevstate;
|
||||
wait_block *w;
|
||||
@ -3468,14 +3364,8 @@ KeReadStateEvent(kevent)
|
||||
*/
|
||||
|
||||
static ndis_status
|
||||
ObReferenceObjectByHandle(handle, reqaccess, otype,
|
||||
accessmode, object, handleinfo)
|
||||
ndis_handle handle;
|
||||
uint32_t reqaccess;
|
||||
void *otype;
|
||||
uint8_t accessmode;
|
||||
void **object;
|
||||
void **handleinfo;
|
||||
ObReferenceObjectByHandle(ndis_handle handle, uint32_t reqaccess, void *otype,
|
||||
uint8_t accessmode, void **object, void **handleinfo)
|
||||
{
|
||||
nt_objref *nr;
|
||||
|
||||
@ -4122,9 +4012,7 @@ KeSetImportanceDpc(dpc, imp)
|
||||
}
|
||||
|
||||
void
|
||||
KeSetTargetProcessorDpc(dpc, cpu)
|
||||
kdpc *dpc;
|
||||
uint8_t cpu;
|
||||
KeSetTargetProcessorDpc(kdpc *dpc, uint8_t cpu)
|
||||
{
|
||||
if (cpu > mp_ncpus)
|
||||
return;
|
||||
@ -4269,10 +4157,7 @@ KeReadStateTimer(timer)
|
||||
}
|
||||
|
||||
static int32_t
|
||||
KeDelayExecutionThread(wait_mode, alertable, interval)
|
||||
uint8_t wait_mode;
|
||||
uint8_t alertable;
|
||||
int64_t *interval;
|
||||
KeDelayExecutionThread(uint8_t wait_mode, uint8_t alertable, int64_t *interval)
|
||||
{
|
||||
ktimer timer;
|
||||
|
||||
|
@ -1140,10 +1140,8 @@ USBD_GetUSBDIVersion(ui)
|
||||
}
|
||||
|
||||
static usb_interface_descriptor_t *
|
||||
USBD_ParseConfigurationDescriptor(conf, intfnum, altset)
|
||||
usb_config_descriptor_t *conf;
|
||||
uint8_t intfnum;
|
||||
uint8_t altset;
|
||||
USBD_ParseConfigurationDescriptor(usb_config_descriptor_t *conf,
|
||||
uint8_t intfnum, uint8_t altset)
|
||||
{
|
||||
return USBD_ParseConfigurationDescriptorEx(conf, conf, intfnum, altset,
|
||||
-1, -1, -1);
|
||||
|
@ -812,10 +812,7 @@ read_dsfield(m, pktattr)
|
||||
}
|
||||
|
||||
void
|
||||
write_dsfield(m, pktattr, dsfield)
|
||||
struct mbuf *m;
|
||||
struct altq_pktattr *pktattr;
|
||||
u_int8_t dsfield;
|
||||
write_dsfield(struct mbuf *m, struct altq_pktattr *pktattr, u_int8_t dsfield)
|
||||
{
|
||||
struct mbuf *m0;
|
||||
|
||||
|
@ -68,10 +68,7 @@ struct mca_device {
|
||||
|
||||
/* Not supposed to use this function! */
|
||||
void
|
||||
mca_pos_set (dev, reg, data)
|
||||
device_t dev;
|
||||
u_int8_t reg;
|
||||
u_int8_t data;
|
||||
mca_pos_set (device_t dev, u_int8_t reg, u_int8_t data)
|
||||
{
|
||||
struct mca_device * m_dev = device_get_ivars(dev);
|
||||
u_int8_t slot = mca_get_slot(dev);
|
||||
@ -98,9 +95,7 @@ mca_pos_set (dev, reg, data)
|
||||
}
|
||||
|
||||
u_int8_t
|
||||
mca_pos_get (dev, reg)
|
||||
device_t dev;
|
||||
u_int8_t reg;
|
||||
mca_pos_get (device_t dev, u_int8_t reg)
|
||||
{
|
||||
u_int8_t slot = mca_get_slot(dev);
|
||||
u_int8_t data = 0;
|
||||
@ -158,9 +153,7 @@ mca_pos_get (dev, reg)
|
||||
}
|
||||
|
||||
const char *
|
||||
mca_match_id (id, mca_devs)
|
||||
u_int16_t id;
|
||||
struct mca_ident * mca_devs;
|
||||
mca_match_id (u_int16_t id, struct mca_ident *mca_devs)
|
||||
{
|
||||
struct mca_ident * m = mca_devs;
|
||||
while(m->name != NULL) {
|
||||
@ -172,9 +165,7 @@ mca_match_id (id, mca_devs)
|
||||
}
|
||||
|
||||
u_int8_t
|
||||
mca_pos_read (dev, reg)
|
||||
device_t dev;
|
||||
u_int8_t reg;
|
||||
mca_pos_read (device_t dev, u_int8_t reg)
|
||||
{
|
||||
struct mca_device * m_dev = device_get_ivars(dev);
|
||||
|
||||
|
@ -218,11 +218,8 @@ nsp_cr_read_1(bst, bsh, ofs)
|
||||
}
|
||||
|
||||
static __inline void
|
||||
nsp_cr_write_1(bst, bsh, ofs, va)
|
||||
bus_space_tag_t bst;
|
||||
bus_space_handle_t bsh;
|
||||
bus_addr_t ofs;
|
||||
u_int8_t va;
|
||||
nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs,
|
||||
u_int8_t va)
|
||||
{
|
||||
|
||||
bus_space_write_1(bst, bsh, nsp_idxr, ofs);
|
||||
@ -230,9 +227,7 @@ nsp_cr_write_1(bst, bsh, ofs, va)
|
||||
}
|
||||
|
||||
static int
|
||||
nsp_expect_signal(sc, curphase, mask)
|
||||
struct nsp_softc *sc;
|
||||
u_int8_t curphase, mask;
|
||||
nsp_expect_signal(struct nsp_softc *sc, u_int8_t curphase, u_int8_t mask)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
bus_space_tag_t bst = sc->sc_iot;
|
||||
@ -1224,10 +1219,7 @@ nsp_pio_write(sc, suspendio)
|
||||
}
|
||||
|
||||
static int
|
||||
nsp_negate_signal(sc, mask, s)
|
||||
struct nsp_softc *sc;
|
||||
u_int8_t mask;
|
||||
u_char *s;
|
||||
nsp_negate_signal(struct nsp_softc *sc, u_int8_t mask, u_char *s)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
bus_space_tag_t bst = sc->sc_iot;
|
||||
@ -1354,10 +1346,8 @@ nsp_disconnected(sc, ti)
|
||||
static void nsp_error(struct nsp_softc *, u_char *, u_int8_t, u_int8_t, u_int8_t);
|
||||
|
||||
static void
|
||||
nsp_error(sc, s, isrc, ph, irqphs)
|
||||
struct nsp_softc *sc;
|
||||
u_char *s;
|
||||
u_int8_t isrc, ph, irqphs;
|
||||
nsp_error(struct nsp_softc * sc, u_char *s, u_int8_t isrc, u_int8_t ph,
|
||||
u_int8_t irqphs)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
|
||||
@ -1430,10 +1420,7 @@ nsp_ccb_nexus_establish(sc)
|
||||
}
|
||||
|
||||
static int
|
||||
nsp_phase_match(sc, phase, stat)
|
||||
struct nsp_softc *sc;
|
||||
u_int8_t phase;
|
||||
u_int8_t stat;
|
||||
nsp_phase_match(struct nsp_softc *sc, u_int8_t phase, u_int8_t stat)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
|
||||
|
@ -191,9 +191,7 @@ struct scsi_low_funcs stgfuncs = {
|
||||
* hwfuncs
|
||||
****************************************************/
|
||||
static __inline void
|
||||
stghw_bcr_write_1(sc, bcv)
|
||||
struct stg_softc *sc;
|
||||
u_int8_t bcv;
|
||||
stghw_bcr_write_1(struct stg_softc *sc, u_int8_t bcv)
|
||||
{
|
||||
|
||||
bus_space_write_1(sc->sc_iot, sc->sc_ioh, tmc_bctl, bcv);
|
||||
@ -722,10 +720,7 @@ stg_pio_write(sc, ti, thold)
|
||||
}
|
||||
|
||||
static int
|
||||
stg_negate_signal(sc, mask, s)
|
||||
struct stg_softc *sc;
|
||||
u_int8_t mask;
|
||||
u_char *s;
|
||||
stg_negate_signal(struct stg_softc *sc, u_int8_t mask, u_char *s)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
bus_space_tag_t bst = sc->sc_iot;
|
||||
@ -749,9 +744,7 @@ stg_negate_signal(sc, mask, s)
|
||||
}
|
||||
|
||||
static int
|
||||
stg_expect_signal(sc, phase, mask)
|
||||
struct stg_softc *sc;
|
||||
u_int8_t phase, mask;
|
||||
stg_expect_signal(struct stg_softc *sc, u_int8_t phase, u_int8_t mask)
|
||||
{
|
||||
struct scsi_low_softc *slp = &sc->sc_sclow;
|
||||
bus_space_tag_t bst = sc->sc_iot;
|
||||
|
@ -1376,11 +1376,8 @@ txp_start_locked(ifp)
|
||||
* Handle simple commands sent to the typhoon
|
||||
*/
|
||||
static int
|
||||
txp_command(sc, id, in1, in2, in3, out1, out2, out3, wait)
|
||||
struct txp_softc *sc;
|
||||
u_int16_t id, in1, *out1;
|
||||
u_int32_t in2, in3, *out2, *out3;
|
||||
int wait;
|
||||
txp_command(struct txp_softc *sc, u_int16_t id, u_int16_t in1, u_int32_t in2,
|
||||
u_int32_t in3, u_int16_t *out1, u_int32_t *out2, u_int32_t *out3, int wait)
|
||||
{
|
||||
struct txp_rsp_desc *rsp = NULL;
|
||||
|
||||
@ -1401,14 +1398,9 @@ txp_command(sc, id, in1, in2, in3, out1, out2, out3, wait)
|
||||
}
|
||||
|
||||
static int
|
||||
txp_command2(sc, id, in1, in2, in3, in_extp, in_extn, rspp, wait)
|
||||
struct txp_softc *sc;
|
||||
u_int16_t id, in1;
|
||||
u_int32_t in2, in3;
|
||||
struct txp_ext_desc *in_extp;
|
||||
u_int8_t in_extn;
|
||||
struct txp_rsp_desc **rspp;
|
||||
int wait;
|
||||
txp_command2(struct txp_softc *sc, u_int16_t id, u_int16_t in1, u_int32_t in2,
|
||||
u_int32_t in3, struct txp_ext_desc *in_extp, u_int8_t in_extn,
|
||||
struct txp_rsp_desc **rspp, int wait)
|
||||
{
|
||||
struct txp_hostvar *hv = sc->sc_hostvar;
|
||||
struct txp_cmd_desc *cmd;
|
||||
@ -1474,12 +1466,8 @@ txp_command2(sc, id, in1, in2, in3, in_extp, in_extn, rspp, wait)
|
||||
}
|
||||
|
||||
static int
|
||||
txp_response(sc, ridx, id, seq, rspp)
|
||||
struct txp_softc *sc;
|
||||
u_int32_t ridx;
|
||||
u_int16_t id;
|
||||
u_int16_t seq;
|
||||
struct txp_rsp_desc **rspp;
|
||||
txp_response(struct txp_softc *sc, u_int32_t ridx, u_int16_t id, u_int16_t seq,
|
||||
struct txp_rsp_desc **rspp)
|
||||
{
|
||||
struct txp_hostvar *hv = sc->sc_hostvar;
|
||||
struct txp_rsp_desc *rsp;
|
||||
|
@ -615,10 +615,7 @@ vm86_datacall(intnum, vmf, vmc)
|
||||
}
|
||||
|
||||
vm_offset_t
|
||||
vm86_getaddr(vmc, sel, off)
|
||||
struct vm86context *vmc;
|
||||
u_short sel;
|
||||
u_short off;
|
||||
vm86_getaddr(struct vm86context *vmc, u_short sel, u_short off)
|
||||
{
|
||||
int i, page;
|
||||
vm_offset_t addr;
|
||||
|
@ -460,8 +460,7 @@ npx_attach(dev)
|
||||
* Initialize floating point unit.
|
||||
*/
|
||||
void
|
||||
npxinit(control)
|
||||
u_short control;
|
||||
npxinit(u_short control)
|
||||
{
|
||||
static union savefpu dummy;
|
||||
register_t savecrit;
|
||||
|
@ -5628,10 +5628,7 @@ sctp_print_mbuf_chain(struct mbuf *m)
|
||||
#endif
|
||||
|
||||
void
|
||||
sctp_input_with_port(i_pak, off, port)
|
||||
struct mbuf *i_pak;
|
||||
int off;
|
||||
uint16_t port;
|
||||
sctp_input_with_port(struct mbuf *i_pak, int off, uint16_t port)
|
||||
{
|
||||
#ifdef SCTP_MBUF_LOGGING
|
||||
struct mbuf *mat;
|
||||
|
@ -2419,10 +2419,7 @@ key_spddump(so, m, mhp)
|
||||
}
|
||||
|
||||
static struct mbuf *
|
||||
key_setdumpsp(sp, type, seq, pid)
|
||||
struct secpolicy *sp;
|
||||
u_int8_t type;
|
||||
u_int32_t seq, pid;
|
||||
key_setdumpsp(struct secpolicy *sp, u_int8_t type, u_int32_t seq, u_int32_t pid)
|
||||
{
|
||||
struct mbuf *result = NULL, *m;
|
||||
struct seclifetime lt;
|
||||
@ -3323,10 +3320,8 @@ key_mature(struct secasvar *sav)
|
||||
* subroutine for SADB_GET and SADB_DUMP.
|
||||
*/
|
||||
static struct mbuf *
|
||||
key_setdumpsa(sav, type, satype, seq, pid)
|
||||
struct secasvar *sav;
|
||||
u_int8_t type, satype;
|
||||
u_int32_t seq, pid;
|
||||
key_setdumpsa(struct secasvar *sav, u_int8_t type, u_int8_t satype,
|
||||
u_int32_t seq, u_int32_t pid)
|
||||
{
|
||||
struct mbuf *result = NULL, *tres = NULL, *m;
|
||||
int i;
|
||||
@ -3464,12 +3459,8 @@ key_setdumpsa(sav, type, satype, seq, pid)
|
||||
* set data into sadb_msg.
|
||||
*/
|
||||
static struct mbuf *
|
||||
key_setsadbmsg(type, tlen, satype, seq, pid, reserved)
|
||||
u_int8_t type, satype;
|
||||
u_int16_t tlen;
|
||||
u_int32_t seq;
|
||||
pid_t pid;
|
||||
u_int16_t reserved;
|
||||
key_setsadbmsg(u_int8_t type, u_int16_t tlen, u_int8_t satype, u_int32_t seq,
|
||||
pid_t pid, u_int16_t reserved)
|
||||
{
|
||||
struct mbuf *m;
|
||||
struct sadb_msg *p;
|
||||
@ -3544,11 +3535,7 @@ key_setsadbsa(sav)
|
||||
* set data into sadb_address.
|
||||
*/
|
||||
static struct mbuf *
|
||||
key_setsadbaddr(exttype, saddr, prefixlen, ul_proto)
|
||||
u_int16_t exttype;
|
||||
const struct sockaddr *saddr;
|
||||
u_int8_t prefixlen;
|
||||
u_int16_t ul_proto;
|
||||
key_setsadbaddr(u_int16_t exttype, const struct sockaddr *saddr, u_int8_t prefixlen, u_int16_t ul_proto)
|
||||
{
|
||||
struct mbuf *m;
|
||||
struct sadb_address *p;
|
||||
@ -3595,9 +3582,7 @@ key_setsadbaddr(exttype, saddr, prefixlen, ul_proto)
|
||||
* set data into sadb_x_sa2.
|
||||
*/
|
||||
static struct mbuf *
|
||||
key_setsadbxsa2(mode, seq, reqid)
|
||||
u_int8_t mode;
|
||||
u_int32_t seq, reqid;
|
||||
key_setsadbxsa2(u_int8_t mode, u_int32_t seq, u_int32_t reqid)
|
||||
{
|
||||
struct mbuf *m;
|
||||
struct sadb_x_sa2 *p;
|
||||
@ -3629,10 +3614,7 @@ key_setsadbxsa2(mode, seq, reqid)
|
||||
* set data into sadb_x_policy
|
||||
*/
|
||||
static struct mbuf *
|
||||
key_setsadbxpolicy(type, dir, id)
|
||||
u_int16_t type;
|
||||
u_int8_t dir;
|
||||
u_int32_t id;
|
||||
key_setsadbxpolicy(u_int16_t type, u_int8_t dir, u_int32_t id)
|
||||
{
|
||||
struct mbuf *m;
|
||||
struct sadb_x_policy *p;
|
||||
@ -4379,8 +4361,7 @@ key_randomfill(p, l)
|
||||
* 0: invalid satype.
|
||||
*/
|
||||
static u_int16_t
|
||||
key_satype2proto(satype)
|
||||
u_int8_t satype;
|
||||
key_satype2proto(u_int8_t satype)
|
||||
{
|
||||
switch (satype) {
|
||||
case SADB_SATYPE_UNSPEC:
|
||||
@ -4405,8 +4386,7 @@ key_satype2proto(satype)
|
||||
* 0: invalid protocol type.
|
||||
*/
|
||||
static u_int8_t
|
||||
key_proto2satype(proto)
|
||||
u_int16_t proto;
|
||||
key_proto2satype(u_int16_t proto)
|
||||
{
|
||||
switch (proto) {
|
||||
case IPPROTO_AH:
|
||||
@ -5271,11 +5251,8 @@ key_delete(so, m, mhp)
|
||||
* delete all SAs for src/dst. Called from key_delete().
|
||||
*/
|
||||
static int
|
||||
key_delete_all(so, m, mhp, proto)
|
||||
struct socket *so;
|
||||
struct mbuf *m;
|
||||
const struct sadb_msghdr *mhp;
|
||||
u_int16_t proto;
|
||||
key_delete_all(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp,
|
||||
u_int16_t proto)
|
||||
{
|
||||
INIT_VNET_IPSEC(curvnet);
|
||||
struct sadb_address *src0, *dst0;
|
||||
@ -7310,9 +7287,7 @@ key_sa_routechange(dst)
|
||||
}
|
||||
|
||||
static void
|
||||
key_sa_chgstate(sav, state)
|
||||
struct secasvar *sav;
|
||||
u_int8_t state;
|
||||
key_sa_chgstate(struct secasvar *sav, u_int8_t state)
|
||||
{
|
||||
IPSEC_ASSERT(sav != NULL, ("NULL sav"));
|
||||
SAHTREE_LOCK_ASSERT();
|
||||
|
@ -104,11 +104,8 @@ dead_pager_getpages(obj, ma, count, req)
|
||||
}
|
||||
|
||||
static vm_object_t
|
||||
dead_pager_alloc(handle, size, prot, off)
|
||||
void *handle;
|
||||
vm_ooffset_t size;
|
||||
vm_prot_t prot;
|
||||
vm_ooffset_t off;
|
||||
dead_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot,
|
||||
vm_ooffset_t off)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user