PAGE_SIZE
#define DMA_PROG_ALLOC (8 * PAGE_SIZE)
m_pOsSupport->FreePhysPageBlock( PAGE_SIZE, m_pDuckPage);
Status = pOsSupport->AllocPhysPageBlock( PAGE_SIZE, pPageBlock);
#define COMM_PAGE_PHYS_BYTES ((sizeof(DspCommPage)+PAGE_SIZE-1)/PAGE_SIZE)*PAGE_SIZE
dwRoundedBytes = (dwBytes + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
#ifndef PAGE_SIZE
PAGE_SIZE);
#define NVME_MAX_XFER_SIZE NVME_MAX_PRP_LIST_ENTRIES * PAGE_SIZE
} __attribute__((aligned(PAGE_SIZE)));
modulo = req->payload_size & (PAGE_SIZE - 1);
unaligned = phys_addr & (PAGE_SIZE - 1);
seg_addr = payload + PAGE_SIZE - unaligned;
seg_addr = payload + cur_nseg * PAGE_SIZE - unaligned;
nvme_assert((length >= remaining_transfer_len) || ((phys_addr + length) % PAGE_SIZE) == 0,
nvme_assert((sge_count == 0) || (phys_addr % PAGE_SIZE) == 0,
modulo = data_transferred & (PAGE_SIZE - 1);
unaligned = phys_addr & (PAGE_SIZE - 1);
PAGE_SIZE - unaligned;
cur_nseg * PAGE_SIZE - unaligned;
cur_nseg * PAGE_SIZE - unaligned;
PAGE_SIZE,
PAGE_SIZE, NVME_NODE_ID_ANY,
PAGE_SIZE, NVME_NODE_ID_ANY,
#define BCM_PAGE_SIZE PAGE_SIZE
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_STD_RX_RING_SZ,
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_RX_RTN_RING_SZ(sc),
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_TX_RING_SZ,
error = bge_dma_ring_alloc(sc, PAGE_SIZE, sbsz,
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_STATS_SZ,
error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_JUMBO_RX_RING_SZ,
NULL, MJUM9BYTES, BGE_NSEG_JUMBO, PAGE_SIZE,
.isc_q_align = PAGE_SIZE,
.isc_tx_maxsegsize = PAGE_SIZE,
.isc_q_align = PAGE_SIZE,
.isc_tx_maxsegsize = PAGE_SIZE,
.isc_q_align = PAGE_SIZE,
.isc_tx_maxsegsize = PAGE_SIZE,
M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
PAGE_SIZE, 0, /* alignment, bounds */
htole64(sc->prph_info_dma.paddr + PAGE_SIZE / 2);
htole64(sc->prph_info_dma.paddr + 3 * PAGE_SIZE / 4);
KASSERT(sizeof(struct iwx_prph_info) < PAGE_SIZE / 2);
PAGE_SIZE, 0);
#define IWX_CMD_RESP_MAX PAGE_SIZE
#define IWM_CMD_RESP_MAX PAGE_SIZE
PAGE_SIZE, 0, /* alignment, bounds */
#define MALO_RXSIZE PAGE_SIZE
PAGE_SIZE, 0, /* alignment, bounds */
PAGE_SIZE, 0, /* alignment, bounds */
jumbosize = roundup(MWL_AGGR_SIZE, PAGE_SIZE);
PAGE_SIZE, 0, /* alignment, bounds */
PAGE_SIZE, 0, /* alignment, bounds */
error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), PAGE_SIZE, 0,
if ((hva % PAGE_SIZE) != 0 || (size % PAGE_SIZE) != 0) {
if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0 ||
(args->hva % PAGE_SIZE) != 0) {
if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0) {
size_t alloc_size = roundup(size, PAGE_SIZE);
npages * PAGE_SIZE, B_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
memset((void *)*va, 0, npages * PAGE_SIZE);
int32 numPages = size / PAGE_SIZE;
if (size % PAGE_SIZE != 0)
(roundup(sizeof(struct nvmm_comm_page), PAGE_SIZE))
CTASSERT(sizeof(struct vmcb) == PAGE_SIZE);
#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)
#define IOBM_SIZE (IOBM_NPAGES * PAGE_SIZE)
uint8_t data[PAGE_SIZE - 4];
CTASSERT(sizeof(struct vmxon) == PAGE_SIZE);
uint8_t data[PAGE_SIZE - 8];
CTASSERT(sizeof(struct vmcs) == PAGE_SIZE);
#define VMCS_SIZE (VMCS_NPAGES * PAGE_SIZE)
#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)
#ifndef PAGE_SIZE
size = PAGE_SIZE;
buf = ntfs_malloc(PAGE_SIZE);
for (; pass <= 2; size = PAGE_SIZE) {
#ifdef PAGE_SIZE
#define SBUF_MAXEXTENDSIZE PAGE_SIZE
#define SBUF_MAXEXTENDINCR PAGE_SIZE
if ((hva % PAGE_SIZE) != 0 || (size % PAGE_SIZE) != 0) {
if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0 ||
(args->hva % PAGE_SIZE) != 0) {
if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0) {
size_t alloc_size = roundup(size, PAGE_SIZE);
npages * PAGE_SIZE, B_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
memset((void *)*va, 0, npages * PAGE_SIZE);
int32 numPages = size / PAGE_SIZE;
if (size % PAGE_SIZE != 0)
(roundup(sizeof(struct nvmm_comm_page), PAGE_SIZE))
CTASSERT(sizeof(struct vmcb) == PAGE_SIZE);
#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)
#define IOBM_SIZE (IOBM_NPAGES * PAGE_SIZE)
uint8_t data[PAGE_SIZE - 4];
CTASSERT(sizeof(struct vmxon) == PAGE_SIZE);
uint8_t data[PAGE_SIZE - 8];
CTASSERT(sizeof(struct vmcs) == PAGE_SIZE);
#define VMCS_SIZE (VMCS_NPAGES * PAGE_SIZE)
#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)
#define PAGE_MASK (PAGE_SIZE - 1)
limit *= PAGE_SIZE;
if ((gva & PAGE_MASK) + size > PAGE_SIZE) {
remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);
if ((gva & PAGE_MASK) + size > PAGE_SIZE) {
remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);
instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
databuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)databuf, PAGE_SIZE) == -1)
ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)databuf, 0x1000, PAGE_SIZE,
L4 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L3 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L2 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L1 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
if (nvmm_hva_map(mach, (uintptr_t)L4, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L3, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L2, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L1, PAGE_SIZE) == -1)
ret = nvmm_gpa_map(mach, (uintptr_t)L4, 0x3000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L3, 0x4000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L2, 0x5000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L1, 0x6000, PAGE_SIZE,
memset(L4, 0, PAGE_SIZE);
memset(L3, 0, PAGE_SIZE);
memset(L2, 0, PAGE_SIZE);
memset(L1, 0, PAGE_SIZE);
L1[0x2000 / PAGE_SIZE] = PTE_P | PTE_W | 0x2000;
L1[0x1000 / PAGE_SIZE] = PTE_P | PTE_W | 0x1000;
memset(databuf, 0, PAGE_SIZE);
memset(mmiobuf, 0, PAGE_SIZE);
instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)
ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,
L4 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L3 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L2 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
L1 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
if (nvmm_hva_map(mach, (uintptr_t)L4, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L3, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L2, PAGE_SIZE) == -1)
if (nvmm_hva_map(mach, (uintptr_t)L1, PAGE_SIZE) == -1)
ret = nvmm_gpa_map(mach, (uintptr_t)L4, 0x3000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L3, 0x4000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L2, 0x5000, PAGE_SIZE,
ret = nvmm_gpa_map(mach, (uintptr_t)L1, 0x6000, PAGE_SIZE,
memset(L4, 0, PAGE_SIZE);
memset(L3, 0, PAGE_SIZE);
memset(L2, 0, PAGE_SIZE);
memset(L1, 0, PAGE_SIZE);
L1[0x2000 / PAGE_SIZE] = PTE_P | PTE_W | 0x2000;
L1[0x1000 / PAGE_SIZE] = PTE_P | PTE_W | 0x1000;
instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)
ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,
static uint8_t mmiobuf[PAGE_SIZE];
if (mem->gpa < 0x1000 || mem->gpa + mem->size > 0x1000 + PAGE_SIZE) {
#ifndef PAGE_SIZE
#define PAGE_ELEMENT_COUNT (PAGE_SIZE / 4)
#ifndef PAGE_SIZE
static const size_t kMapChunkSize = 4 * PAGE_SIZE;
static const size_t kTestSize = 256 * PAGE_SIZE;
if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE,
if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE, PROT_READ)
if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE, PROT_READ)
for (int i = 0; i < 256 * PAGE_SIZE; i++) {