自学教程：C++ ALIGN_DOWN函数代码示例

SYSCALL vm_addr VirtualAllocPhys (vm_addr addr, ssize_t len, bits32_t flags, vm_addr paddr){    struct Segment *seg;    struct Process *current;    current = GetCurrentProcess();    addr = ALIGN_DOWN (addr, PAGE_SIZE);    paddr = ALIGN_DOWN (paddr, PAGE_SIZE);    len = ALIGN_UP (len, PAGE_SIZE);    flags = (flags & ~VM_SYSTEM_MASK) | MEM_PHYS;    if (!(current->flags & PROCF_ALLOW_IO))        return (vm_addr)NULL;    if (PmapSupportsCachePolicy (flags) == -1)        return (vm_addr)NULL;    DisablePreemption();    if (EnoughSegments() == FALSE)        ReclaimSegments();            if ((seg = SegmentAlloc (paddr, len, flags)) == NULL)        return (vm_addr)NULL;      return seg->base;}

/** Unmap a piece of virtual address space. * * @param vaddr		Virtual address to be unmapped. May be unaligned, but *			it must a value previously returned by km_map(). * @param size		Size of area starting at vaddr to be unmapped. */void km_unmap(uintptr_t vaddr, size_t size){	size_t offs; 	offs = vaddr - ALIGN_DOWN(vaddr, PAGE_SIZE); 	km_unmap_aligned(ALIGN_DOWN(vaddr, PAGE_SIZE),	    ALIGN_UP(size + offs, PAGE_SIZE));}

static int tegra_spi_dma_prepare(struct tegra_spi_channel *spi,		unsigned int bytes, enum spi_direction dir){	unsigned int todo, wcount;	/*	 * For DMA we need to think of things in terms of word count.	 * AHB width is fixed at 32-bits. To avoid overrunning	 * the in/out buffers we must align down. (Note: lowest 2-bits	 * in WCOUNT register are ignored, and WCOUNT seems to count	 * words starting at n-1)	 *	 * Example: If "bytes" is 7 and we are transferring 1-byte at a time,	 * WCOUNT should be 4. The remaining 3 bytes must be transferred	 * using PIO.	 */	todo = MIN(bytes, SPI_MAX_TRANSFER_BYTES_DMA - TEGRA_DMA_ALIGN_BYTES);	todo = ALIGN_DOWN(todo, TEGRA_DMA_ALIGN_BYTES);	wcount = ALIGN_DOWN(todo - TEGRA_DMA_ALIGN_BYTES, TEGRA_DMA_ALIGN_BYTES);	flush_fifos(spi);	if (dir == SPI_SEND) {		spi->dma_out = dma_claim();		if (!spi->dma_out)			return -1;		/* ensure bytes to send will be visible to DMA controller */		dcache_clean_by_mva(spi->out_buf, bytes);		write32(&spi->dma_out->regs->apb_ptr,			(uintptr_t) & spi->regs->tx_fifo);		write32(&spi->dma_out->regs->ahb_ptr, (uintptr_t)spi->out_buf);		setbits_le32(&spi->dma_out->regs->csr, APB_CSR_DIR);		setup_dma_params(spi, spi->dma_out);		write32(&spi->dma_out->regs->wcount, wcount);	} else {		spi->dma_in = dma_claim();		if (!spi->dma_in)			return -1;		/* avoid data collisions */		dcache_clean_invalidate_by_mva(spi->in_buf, bytes);		write32(&spi->dma_in->regs->apb_ptr,			(uintptr_t)&spi->regs->rx_fifo);		write32(&spi->dma_in->regs->ahb_ptr, (uintptr_t)spi->in_buf);		clrbits_le32(&spi->dma_in->regs->csr, APB_CSR_DIR);		setup_dma_params(spi, spi->dma_in);		write32(&spi->dma_in->regs->wcount, wcount);	}	/* BLOCK_SIZE starts at n-1 */	write32(&spi->regs->dma_blk, todo - 1);	return todo;}

/** Map a piece of physical address space into the virtual address space. * * @param paddr		Physical address to be mapped. May be unaligned. * @param size		Size of area starting at paddr to be mapped. * @param flags		Protection flags to be used for the mapping. * * @return New virtual address mapped to paddr. */uintptr_t km_map(uintptr_t paddr, size_t size, unsigned int flags){	uintptr_t page;	size_t offs; 	offs = paddr - ALIGN_DOWN(paddr, FRAME_SIZE); 	page = km_map_aligned(ALIGN_DOWN(paddr, FRAME_SIZE),	    ALIGN_UP(size + offs, FRAME_SIZE), flags);	return page + offs;}

void *write_thread(void *_ts) {	struct ts *ts = _ts;	struct packet *packet;	mode_t umask_val = umask(0);	dir_perm = (0777 & ~umask_val) | (S_IWUSR | S_IXUSR);	set_thread_name("tsdump-write");	while ((packet = queue_get(ts->packet_queue))) {		if (!packet->data_len)			continue;		p_dbg1(" - Got packet %d, size: %u, file_time:%lu packet_time:%lu depth:%d/n",			packet->num, packet->data_len, ALIGN_DOWN(packet->ts.tv_sec, ts->rotate_secs),			packet->ts.tv_sec, ts->packet_queue->items);		handle_files(ts, packet);		if (ts->output_fd > -1) {			p_dbg2(" - Writing into fd:%d size:%d file:%s/n", ts->output_fd, packet->data_len, ts->output_filename);			ssize_t written = write(ts->output_fd, packet->data, packet->data_len);			if (written != packet->data_len) {				p_err("Can not write data (fd:%d written %zd of %d file:%s)",					ts->output_fd, written, packet->data_len, ts->output_filename);			}		}		free_packet(packet);	}	close_output_file(ts, NO_UNLINK);	return NULL;}

static void handle_files(struct ts *ts, struct packet *packet) {	int file_time = ALIGN_DOWN(packet->ts.tv_sec, ts->rotate_secs);	// Is this file already created?	if (file_time <= ts->output_startts)		return;	close_output_file(ts, UNLINK_OLD);	format_output_filename(ts, file_time);	/*	 * When tsdumper2 is started, try to continue writing into "current" file.	 * This allows the program to be killed/restarted.	 *	 * If current file does not exist, create new file with the time of the start	 * (not aligned to rotate_secs).	 */	int append = 0;	if (ts->output_fd < 0) { // First file (or error).		append = file_exists(ts->output_filename);		if (!append) { // Create first file *NOT ALIGNED*			format_output_filename(ts, packet->ts.tv_sec);		}	}	ts->output_fd = append ? append_output_file(ts) : create_output_file(ts);}

/*!  * /brief メモリプ
C++ ALIGN_SIZE函数代码示例
C++ ALIGNED函数代码示例