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

static void rx_complete(struct urb *req){	struct usbsvn_rx *svn_rx = req->context;	struct net_device *dev = svn_rx->netdev;	struct usbsvn *svn = netdev_priv(dev);	struct page *page = virt_to_page(req->transfer_buffer);	struct sipc4_rx_data rx_data;	int dev_id = svn_rx->dev_id;	int flags = 0;	int err;	usb_mark_last_busy(svn->usbdev);	switch (req->status) {	case -ENOENT:		if (req->actual_length == 0) {			req = NULL;			break;		}		printk(KERN_DEBUG "%s: Rx ENOENT", __func__);	case 0:		if (!svn->driver_info)			flags |= SIPC4_RX_HDLC;		if (req->actual_length < PAGE_SIZE)			flags |= SIPC4_RX_LAST;		rx_data.dev = dev;		rx_data.skb = svn->devdata[dev_id].rx_skb;		rx_data.page = page;		rx_data.size = req->actual_length;		rx_data.format = dev_id;		rx_data.flags = flags;		rx_data.rx_hdr = &svn->devdata[dev_id].rx_hdr;		page = NULL;		if (rx_debug) {			char *buf = req->transfer_buffer;			int i;			printk(KERN_DEBUG "[RX] dev_id: %d, size: %d/n", dev_id,					req->actual_length);			for (i = 0; i < req->actual_length; i++)				printk(KERN_DEBUG "%x ", *(buf + i));		}		if (dev_id == SIPC4_CMD)			err = usbsvn_cmd_rx(&rx_data, svn);		else			err = sipc4_rx(&rx_data);		if (err < 0) {			svn->devdata[dev_id].rx_skb = NULL;			break;		}		svn->devdata[dev_id].rx_skb = rx_data.skb;		if (dev_id == SIPC4_RAW)			wake_lock_timeout_data(svn);		goto resubmit;	case -ECONNRESET:	case -ESHUTDOWN:		if (!svn->suspended)			printk(KERN_DEBUG "%s: RX complete Status(%d)/n",				__func__, req->status);		req = NULL;		break;	case -EOVERFLOW:		dev->stats.rx_over_errors++;		dev_err(&dev->dev, "RX overflow/n");		break;	case -EILSEQ:		dev->stats.rx_crc_errors++;		break;	}	dev->stats.rx_errors++;resubmit:	kfree(svn_rx);	if (page)		netdev_free_page(dev, page);	if (req && req->status != -ENOENT) {		rx_submit(svn, dev_id, req, GFP_ATOMIC);	}}

static void account_kernel_stack(struct thread_info *ti, int account){	struct zone *zone = page_zone(virt_to_page(ti));	mod_zone_page_state(zone, NR_KERNEL_STACK, account);}

static struct page *dummy_pcm_page(struct snd_pcm_substream *substream,				   unsigned long offset){	return virt_to_page(dummy_page[substream->stream]); /* the same page */}

static void ati_free_page_map(struct ati_page_map *page_map){	unmap_page_from_agp(virt_to_page(page_map->real));	set_memory_wb((unsigned long)page_map->real, 1);	free_page((unsigned long) page_map->real);}

//.........这里部分代码省略.........					if (device->in_buff[count]) {						adr =						    device->						    in_buff[count]->offset;						if (adr)							prev_free_pages((unsigned long)									phys_to_virt									(adr),									device->									in_buff									[count]->									size);						kfree(device->in_buff[count]);						device->in_buff[count] = NULL;					}				}				device->in_numbuffers = 0;			}		}		/* allocate the buffer */		for (count = device->in_numbuffers; count < reqbufs->count;		     count++) {			/* Allocate memory for struct prev_buffer */			buffer =			    kmalloc(sizeof(struct prev_buffer), GFP_KERNEL);			/* if memory allocation fails then return error */			if (!buffer) {				/* free all the buffers */				while (--count >= device->in_numbuffers) {					adr = device->in_buff[count]->offset;					if (adr)						prev_free_pages((unsigned long)								phys_to_virt								(adr),								device->in_buff								[count]->size);					kfree(device->in_buff[count]);					device->in_buff[count] = NULL;				}				dev_err(prev_dev, "request_buffer:not /					enough memory/n");				return -ENOMEM;			}			/* assign buffer's address in configuration */			device->in_buff[count] = buffer;			/* set buffers index and buf_type,size parameters */			buffer->index = count;			buffer->buf_type = PREV_BUF_IN;			buffer->size = reqbufs->size;			/* allocate memory for buffer of size passed			   in reqbufs */			buffer->offset =			    (unsigned long)__get_free_pages(GFP_KERNEL |							    GFP_DMA,							    get_order							    (reqbufs->size));			/* if memory allocation fails, return error */			if (!(buffer->offset)) {				/* free all the buffer's space */				kfree(buffer);				device->in_buff[count] = NULL;				while (--count >= device->in_numbuffers) {					adr = device->in_buff[count]->offset;					if (adr)						prev_free_pages((unsigned long)								phys_to_virt								(adr),								device->in_buff								[count]->size);					kfree(device->in_buff[count]);					device->in_buff[count] = NULL;				}				dev_err(prev_dev, "request_buffer:not /					enough memory/n");				return -ENOMEM;			}			adr = (unsigned long)buffer->offset;			size = PAGE_SIZE << (get_order(reqbufs->size));			while (size > 0) {				/* make sure the frame buffers				   are never swapped out of memory */				SetPageReserved(virt_to_page(adr));				adr += PAGE_SIZE;				size -= PAGE_SIZE;			}			/* convert vertual address to physical */			buffer->offset = (unsigned long)			    virt_to_phys((void *)(buffer->offset));		}		device->in_numbuffers = reqbufs->count;	}

static int __initdev_nvram_init(void){	int order = 0, ret = 0;	struct page *page, *end;	unsigned int i;	/* Allocate and reserve memory to mmap() */	while ((PAGE_SIZE << order) < NVRAM_SPACE)		order++;	end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);	for (page = virt_to_page(nvram_buf); page <= end; page++)		mem_map_reserve(page);#ifdef CONFIG_MTD	/* Find associated MTD device */	for (i = 0; i < MAX_MTD_DEVICES; i++) {		nvram_mtd = get_mtd_device(NULL, i);		if (nvram_mtd) {			if (!strcmp(nvram_mtd->name, "nvram") &&			    nvram_mtd->size >= NVRAM_SPACE)				break;			put_mtd_device(nvram_mtd);		}	}	if (i >= MAX_MTD_DEVICES)		nvram_mtd = NULL;#endif	/* Initialize hash table lock */	spin_lock_init(&nvram_lock);	/* Initialize commit semaphore */	init_MUTEX(&nvram_sem);	/* Register char device */	if ((nvram_major = devfs_register_chrdev(0, "nvram", &dev_nvram_fops)) < 0) {		ret = nvram_major;		goto err;	}	/* Initialize hash table */	_nvram_init(sbh);	/* Create /dev/nvram handle */	nvram_handle = devfs_register(NULL, "nvram", DEVFS_FL_NONE, nvram_major, 0,				      S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, &dev_nvram_fops, NULL);	/* Set the SDRAM NCDL value into NVRAM if not already done */	if (getintvar(NULL, "sdram_ncdl") == 0) {		unsigned int ncdl;		char buf[] = "0x00000000";		if ((ncdl = sb_memc_get_ncdl(sbh))) {			sprintf(buf, "0x%08x", ncdl);			nvram_set("sdram_ncdl", buf);			nvram_commit();		}	}	return 0; err:	dev_nvram_exit();	return ret;}

//.........这里部分代码省略.........			tlen -= mem_len;			scst_put_buf(cmd, from);			mem_len = scst_get_buf_next(cmd, &from);			if (!mem_len)				return SCST_TGT_RES_SUCCESS;		}		mem_len -= tlen;		mem_off = tlen;	} else		fcmd->seq = lport->tt.seq_start_next(fcmd->seq);	/* no scatter/gather in skb for odd word length due to fc_seq_send() */	use_sg = !(remaining % 4) && lport->sg_supp;	while (remaining) {		if (!loop_limit) {			FT_ERR("hit loop limit.  remaining %zx mem_len %zx "			       "frame_len %zx tlen %zx/n",			       remaining, mem_len, frame_len, tlen);			break;		}		loop_limit--;		if (!mem_len) {			scst_put_buf(cmd, from);			mem_len = scst_get_buf_next(cmd, &from);			mem_off = 0;			if (!mem_len) {				FT_ERR("mem_len 0 from get_buf_next/n");				break;			}		}		if (!frame_len) {			frame_len = fcmd->max_lso_payload;			frame_len = min(frame_len, remaining);			fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len);			if (!fp) {				FT_IO_DBG("frame_alloc failed. "					  "use_sg %d frame_len %zd/n",					  use_sg, frame_len);				break;			}			fr_max_payload(fp) = fcmd->max_payload;			to = fc_frame_payload_get(fp, 0);			fh_off = frame_off;		}		tlen = min(mem_len, frame_len);		BUG_ON(!tlen);		BUG_ON(tlen > remaining);		BUG_ON(tlen > mem_len);		BUG_ON(tlen > frame_len);		if (use_sg) {			page = virt_to_page(from + mem_off);			get_page(page);			tlen = min_t(size_t, tlen,				     PAGE_SIZE - (mem_off & ~PAGE_MASK));			skb_fill_page_desc(fp_skb(fp),					   skb_shinfo(fp_skb(fp))->nr_frags,					   page, offset_in_page(from + mem_off),					   tlen);			fr_len(fp) += tlen;			fp_skb(fp)->data_len += tlen;			fp_skb(fp)->truesize +=					PAGE_SIZE << compound_order(page);			frame_len -= tlen;			if (skb_shinfo(fp_skb(fp))->nr_frags >= FC_FRAME_SG_LEN)				frame_len = 0;		} else {			memcpy(to, from + mem_off, tlen);			to += tlen;			frame_len -= tlen;		}		mem_len -= tlen;		mem_off += tlen;		remaining -= tlen;		frame_off += tlen;		if (frame_len)			continue;		fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,			       FC_TYPE_FCP,			       remaining ? (FC_FC_EX_CTX | FC_FC_REL_OFF) :			       (FC_FC_EX_CTX | FC_FC_REL_OFF | FC_FC_END_SEQ),			       fh_off);		error = lport->tt.seq_send(lport, fcmd->seq, fp);		if (error) {			WARN_ON(1);			/* XXX For now, initiator will retry */		} else			fcmd->read_data_len = frame_off;	}	if (mem_len)		scst_put_buf(cmd, from);	if (remaining) {		FT_IO_DBG("remaining read data %zd/n", remaining);		return SCST_TGT_RES_QUEUE_FULL;	}	return SCST_TGT_RES_SUCCESS;}

void * __ioremap(phys_t phys_addr, phys_t size, unsigned long flags){	struct vm_struct * area;	unsigned long offset;	phys_t last_addr;	void * addr;	phys_addr = fixup_bigphys_addr(phys_addr, size);	/* Don't allow wraparound or zero size */	last_addr = phys_addr + size - 1;	if (!size || last_addr < phys_addr)		return NULL;	/*	 * Map uncached objects in the low 512mb of address space using KSEG1,	 * otherwise map using page tables.	 */	if (IS_LOW512(phys_addr) && IS_LOW512(last_addr) &&	    flags == _CACHE_UNCACHED)		return (void *) CKSEG1ADDR(phys_addr);#ifdef CONFIG_DISCONTIGMEM#if defined ( CONFIG_MIPS_BCM97438 )       if (IS_PA_UPPER_RAM(phys_addr) && flags == _CACHE_UNCACHED) {               printk(KERN_ERR "Upper DDR at %08lx cannot be mapped uncached/n", phys_addr);               return NULL;       }#elif defined ( CONFIG_MIPS_BCM7440 )        if (IS_PA_UPPER_RAM(phys_addr) && (flags == _CACHE_UNCACHED)) {               printk(KERN_ERR "Upper/High DDR at %08lx cannot be mapped uncached/n", phys_addr);               return NULL;       }#endif#endif#ifndef CONFIG_DISCONTIGMEM  #ifdef CONFIG_MIPS_BRCM97XXX  #if defined( CONFIG_MIPS_BCM7038A0 )	if (((phys_addr >= 0xd0000000) && (phys_addr <= 0xe060000b)))		  #elif defined( CONFIG_MIPS_BCM7038B0 ) || defined( CONFIG_MIPS_BCM7038C0 ) /  	|| defined( CONFIG_MIPS_BCM7400 ) 	if (((phys_addr >= 0xd0000000) && (phys_addr <= 0xf060000b)))		  #elif defined( CONFIG_MIPS_BCM3560 ) /  	|| defined( CONFIG_MIPS_BCM7401 ) || defined( CONFIG_MIPS_BCM7402 ) /	|| defined( CONFIG_MIPS_BCM7118 ) || defined( CONFIG_MIPS_BCM7403 ) /	|| defined( CONFIG_MIPS_BCM7452 )  	if (((((unsigned long) (phys_addr)) >= 0xd0000000) && (((unsigned long) (phys_addr)) <= 0xf060000b)) ||		(((unsigned long) (phys_addr)) >= 0xff400000))		  #else	if (phys_addr >= 0xffe00000)  #endif      	return (void *) (phys_addr);  #endif#else  /* 97438 Discontiguous memory model */  #if defined ( CONFIG_MIPS_BCM97438 )        if (((phys_addr >= 0xd0000000) && (phys_addr < 0xe0000000)) ||               ((phys_addr >= 0xf0000000) && (phys_addr <= 0xf060000b)))                        return (void *) (phys_addr);       /* else upper ram area is handled just like lower ram, handled below */  #elif defined ( CONFIG_MIPS_BCM7440 )        if ((phys_addr >= 0xd0000000) && (phys_addr < 0xd8000000))                /* 128 MB of PCI-MEM */                return (void *) (phys_addr);        if ((phys_addr >= 0xf0000000) && (phys_addr < 0xf2000000))                /* 32 MB of PCI-IO */                return (void *) (0xf8000000 + (phys_addr - 0xf0000000));  #else       #error "Unsupported discontigmem platform"  #endif#endif	/*	 * Don't allow anybody to remap normal RAM that we're using..	 */	if (phys_addr < virt_to_phys(high_memory)) {		char *t_addr, *t_end;		struct page *page;		t_addr = __va(phys_addr);		t_end = t_addr + (size - 1);		for(page = virt_to_page(t_addr); page <= virt_to_page(t_end); page++)			if(!PageReserved(page))				return NULL;	}	/*	 * Mappings have to be page-aligned//.........这里部分代码省略.........

static intdev_nvram_init(void){	int order = 0, ret = 0;	struct page *page, *end;	osl_t *osh;#if defined(CONFIG_MTD) || defined(CONFIG_MTD_MODULE)	unsigned int i;#endif	/* Allocate and reserve memory to mmap() */	while ((PAGE_SIZE << order) < nvram_space)		order++;	end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);	for (page = virt_to_page(nvram_buf); page <= end; page++) {		SetPageReserved(page);	}#if defined(CONFIG_MTD) || defined(CONFIG_MTD_MODULE)	/* Find associated MTD device */	for (i = 0; i < MAX_MTD_DEVICES; i++) {		nvram_mtd = get_mtd_device(NULL, i);		if (!IS_ERR(nvram_mtd)) {			if (!strcmp(nvram_mtd->name, "nvram") &&			    nvram_mtd->size >= nvram_space) {				break;			}			put_mtd_device(nvram_mtd);		}	}	if (i >= MAX_MTD_DEVICES)		nvram_mtd = NULL;#endif	/* Initialize hash table lock */	spin_lock_init(&nvram_lock);	/* Initialize commit semaphore */	init_MUTEX(&nvram_sem);	/* Register char device */	if ((nvram_major = register_chrdev(0, "nvram", &dev_nvram_fops)) < 0) {		ret = nvram_major;		goto err;	}	if (si_osh(sih) == NULL) {		osh = osl_attach(NULL, SI_BUS, FALSE);		if (osh == NULL) {			printk("Error allocating osh/n");			unregister_chrdev(nvram_major, "nvram");			goto err;		}		si_setosh(sih, osh);	}	/* Initialize hash table */	_nvram_init(sih);	/* Create /dev/nvram handle */	nvram_class = class_create(THIS_MODULE, "nvram");	if (IS_ERR(nvram_class)) {		printk("Error creating nvram class/n");		goto err;	}	/* Add the device nvram0 */#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)	class_device_create(nvram_class, NULL, MKDEV(nvram_major, 0), NULL, "nvram");#else /* Linux 2.6.36 and above */	device_create(nvram_class, NULL, MKDEV(nvram_major, 0), NULL, "nvram");#endif	/* Linux 2.6.36 */	return 0;err:	dev_nvram_exit();	return ret;}

static struct page *mtk_i2s0_pcm_page(struct snd_pcm_substream *substream,                                      unsigned long offset){    printk("%s /n", __func__);    return virt_to_page(dummy_page[substream->stream]); /* the same page */}

static bool xen_page_pinned(void *ptr){	struct page *page = virt_to_page(ptr);	return PagePinned(page);}

/** * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit * capable IOCB types. * * @sp: SRB command to process * @cmd_pkt: Command type 3 IOCB * @tot_dsds: Total number of segments to transfer */void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,    uint16_t tot_dsds){	uint16_t	avail_dsds;	uint32_t	*cur_dsd;	scsi_qla_host_t	*ha;	struct scsi_cmnd *cmd;	cmd = sp->cmd;	/* Update entry type to indicate Command Type 3 IOCB */	*((uint32_t *)(&cmd_pkt->entry_type)) =	    __constant_cpu_to_le32(COMMAND_A64_TYPE);	/* No data transfer */	if (cmd->request_bufflen == 0 || cmd->sc_data_direction == DMA_NONE) {		cmd_pkt->byte_count = __constant_cpu_to_le32(0);		return;	}	ha = sp->ha;	cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(cmd));	/* Two DSDs are available in the Command Type 3 IOCB */	avail_dsds = 2;	cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;	/* Load data segments */	if (cmd->use_sg != 0) {		struct	scatterlist *cur_seg;		struct	scatterlist *end_seg;		cur_seg = (struct scatterlist *)cmd->request_buffer;		end_seg = cur_seg + tot_dsds;		while (cur_seg < end_seg) {			dma_addr_t	sle_dma;			cont_a64_entry_t *cont_pkt;			/* Allocate additional continuation packets? */			if (avail_dsds == 0) {				/*				 * Five DSDs are available in the Continuation				 * Type 1 IOCB.				 */				cont_pkt = qla2x00_prep_cont_type1_iocb(ha);				cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;				avail_dsds = 5;			}			sle_dma = sg_dma_address(cur_seg);			*cur_dsd++ = cpu_to_le32(LSD(sle_dma));			*cur_dsd++ = cpu_to_le32(MSD(sle_dma));			*cur_dsd++ = cpu_to_le32(sg_dma_len(cur_seg));			avail_dsds--;			cur_seg++;		}	} else {		dma_addr_t	req_dma;		struct page	*page;		unsigned long	offset;		page = virt_to_page(cmd->request_buffer);		offset = ((unsigned long)cmd->request_buffer & ~PAGE_MASK);		req_dma = pci_map_page(ha->pdev, page, offset,		    cmd->request_bufflen, cmd->sc_data_direction);		sp->dma_handle = req_dma;		*cur_dsd++ = cpu_to_le32(LSD(req_dma));		*cur_dsd++ = cpu_to_le32(MSD(req_dma));		*cur_dsd++ = cpu_to_le32(cmd->request_bufflen);	}}

/*============================================================================ * Do window creation here */static int __create_slave_window(vme_slave_handle_t handle,				 struct __vme_slave_window *window, int num,				 uint32_t ctl, uint32_t vme_addr, size_t size,				 void *phys_addr){	uint32_t base, bound, to, off;#ifndef ARCH	struct page *page;#endif	int resolution;	/* Windows 0 and 4 have a 4kb resolution, others have	   64kb resolution	 */	resolution = (num % 4) ? 0x10000 : 0x1000;	off = vme_addr % resolution;	vme_addr -= off;	size += off;	size += (size % resolution) ? resolution - (size % resolution) : 0;	/* If we're given the physical address, then use it,	   otherwise, let the kernel allocate the memory	   wherever it wants to.	 */	if (phys_addr) {		phys_addr -= off;		if ((uint32_t) phys_addr % resolution) {			write_unlock(&slave_rwlock);			printk(KERN_ERR "VME: Invalid physical address for "			       "slave window %d/n", num);			return -EINVAL;		}	} else {		window->vptr = pci_alloc_consistent(universe_pci_dev, size,						    &window->resource);		if (NULL == window->vptr) {			window->resource = 0;			window->vptr = NULL;			write_unlock(&slave_rwlock);			printk(KERN_ERR "VME: Failed to allocate memory for "			       "slave window %d/n", num);			return -ENOMEM;		}#ifdef ARCH	    memset(window->vptr, 0, size);	}#else		/* The memory manager wants to remove the		   allocated pages from main memory.  We don't		   want that because the user ends up seeing		   all zero's so we set the PG_RESERVED bit		   on each page.		 */		for (page = virt_to_page(window->vptr);		     page < virt_to_page(window->vptr + size); ++page)		{		     #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,68)			mem_map_reserve(page);#else						SetPageReserved(page);#endif					}		phys_addr = (void *) virt_to_phys(window->vptr);#endif		base = vme_addr;		bound = base + size;#ifdef ARCH	to = (uint32_t) window->resource - base;	window->phys_base = (uint32_t) window->vptr;#else		to = (uint32_t) phys_addr - base;	}

static struct sk_buff * ata(struct aoedev *d, struct sk_buff *skb){	struct aoe_hdr *aoe;	struct aoe_atahdr *ata;	struct aoereq *rq, *e;	struct bio *bio;	sector_t lba;	int len, rw;	struct page *page;	ulong bcnt, offset;	aoe = (struct aoe_hdr *) skb_mac_header(skb);	ata = (struct aoe_atahdr *) aoe->data;	lba = readlba(ata->lba);	len = sizeof *aoe + sizeof *ata;	switch (ata->cmdstat) {	do {	case ATA_CMD_PIO_READ:		lba &= ATA_LBA28MAX;	case ATA_CMD_PIO_READ_EXT:		lba &= 0x0000FFFFFFFFFFFFULL;		rw = READ;		break;	case ATA_CMD_PIO_WRITE:		lba &= ATA_LBA28MAX;	case ATA_CMD_PIO_WRITE_EXT:		lba &= 0x0000FFFFFFFFFFFFULL;		rw = WRITE;	} while (0);		if ((lba + ata->scnt) > d->scnt) {			printk(KERN_ERR "sector I/O is out of range: %Lu (%d), max %Lu/n",				(long long) lba, ata->scnt, d->scnt);			ata->cmdstat = ATA_ERR;			ata->errfeat = ATA_IDNF;			break;		}		rq = d->reqs;		e = rq + nelem(d->reqs);		for (; rq<e; rq++)			if (rq->skb == NULL)				break;		if (rq == e)			goto drop;				bio = bio_alloc(GFP_ATOMIC, 1);		if (bio == NULL) {			eprintk("can't alloc bio/n");			goto drop;		}		rq->bio = bio;		rq->d = d;		bio->bi_sector = lba;		bio->bi_bdev = d->blkdev;		bio->bi_end_io = ata_io_complete;		bio->bi_private = rq;		page = virt_to_page(ata->data);		bcnt = ata->scnt << 9;		offset = offset_in_page(ata->data);		if (bio_add_page(bio, page, bcnt, offset) < bcnt) {			printk(KERN_ERR "Can't bio_add_page for %d sectors/n", ata->scnt);			bio_put(bio);			goto drop;		}		rq->skb = skb;		atomic_inc(&d->busy);		submit_bio(rw, bio);		return NULL;	default:		printk(KERN_ERR "Unknown ATA command 0x%02X/n", ata->cmdstat);		ata->cmdstat = ATA_ERR;		ata->errfeat = ATA_ABORTED;		break;	case ATA_CMD_ID_ATA:		len += ata_identify(d, ata);	case ATA_CMD_FLUSH:		ata->cmdstat = ATA_DRDY;		ata->errfeat = 0;		break;	}	skb_trim(skb, len);	return skb;drop:	dev_kfree_skb(skb);	return NULL;}

/* Resets the struct page fields and frees the page */static void free_zbud_page(struct zbud_header *zhdr){	__free_page(virt_to_page(zhdr));}

static void rx_complete(struct urb *req){	struct net_device *dev = req->context;	struct usbpn_dev *pnd = netdev_priv(dev);	struct page *page = virt_to_page(req->transfer_buffer);	struct sk_buff *skb;	unsigned long flags;	switch (req->status) {	case 0:		spin_lock_irqsave(&pnd->rx_lock, flags);		skb = pnd->rx_skb;		if (!skb) {			skb = pnd->rx_skb = netdev_alloc_skb(dev, 12);			if (likely(skb)) {				/* Can't use pskb_pull() on page in IRQ */				memcpy(skb_put(skb, 1), page_address(page), 1);				skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,						page, 1, req->actual_length);				page = NULL;			}		} else {			skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,					page, 0, req->actual_length);			page = NULL;		}		if (req->actual_length < PAGE_SIZE)			pnd->rx_skb = NULL; /* Last fragment */		else			skb = NULL;		spin_unlock_irqrestore(&pnd->rx_lock, flags);		if (skb) {			skb->protocol = htons(ETH_P_PHONET);			skb_reset_mac_header(skb);			__skb_pull(skb, 1);			skb->dev = dev;			dev->stats.rx_packets++;			dev->stats.rx_bytes += skb->len;			netif_rx(skb);		}		goto resubmit;	case -ENOENT:	case -ECONNRESET:	case -ESHUTDOWN:		req = NULL;		break;	case -EOVERFLOW:		dev->stats.rx_over_errors++;		dev_dbg(&dev->dev, "RX overflow/n");		break;	case -EILSEQ:		dev->stats.rx_crc_errors++;		break;	}	dev->stats.rx_errors++;resubmit:	if (page)		netdev_free_page(dev, page);	if (req)		rx_submit(pnd, req, GFP_ATOMIC);}

int arch_domain_create(struct domain *d, unsigned int domcr_flags,                       struct xen_arch_domainconfig *config){    int rc;    d->arch.relmem = RELMEM_not_started;    /* Idle domains do not need this setup */    if ( is_idle_domain(d) )        return 0;    ASSERT(config != NULL);    if ( (rc = p2m_init(d)) != 0 )        goto fail;    rc = -ENOMEM;    if ( (d->shared_info = alloc_xenheap_pages(0, 0)) == NULL )        goto fail;    /* Default the virtual ID to match the physical */    d->arch.vpidr = boot_cpu_data.midr.bits;    clear_page(d->shared_info);    share_xen_page_with_guest(        virt_to_page(d->shared_info), d, XENSHARE_writable);    if ( (rc = domain_io_init(d)) != 0 )        goto fail;    if ( (rc = p2m_alloc_table(d)) != 0 )        goto fail;    switch ( config->gic_version )    {    case XEN_DOMCTL_CONFIG_GIC_NATIVE:        switch ( gic_hw_version () )        {        case GIC_V2:            config->gic_version = XEN_DOMCTL_CONFIG_GIC_V2;            d->arch.vgic.version = GIC_V2;            break;        case GIC_V3:            config->gic_version = XEN_DOMCTL_CONFIG_GIC_V3;            d->arch.vgic.version = GIC_V3;            break;        default:            BUG();        }        break;    case XEN_DOMCTL_CONFIG_GIC_V2:        d->arch.vgic.version = GIC_V2;        break;    case XEN_DOMCTL_CONFIG_GIC_V3:        d->arch.vgic.version = GIC_V3;        break;    default:        rc = -EOPNOTSUPP;        goto fail;    }    if ( (rc = domain_vgic_init(d, config->nr_spis)) != 0 )        goto fail;    if ( (rc = domain_vtimer_init(d, config)) != 0 )        goto fail;    /*     * The hardware domain will get a PPI later in     * arch/arm/domain_build.c  depending on the     * interrupt map of the hardware.     */    if ( !is_hardware_domain(d) )    {        d->arch.evtchn_irq = GUEST_EVTCHN_PPI;        /* At this stage vgic_reserve_virq should never fail */        if ( !vgic_reserve_virq(d, GUEST_EVTCHN_PPI) )            BUG();    }    /*     * Virtual UART is only used by linux early printk and decompress code.     * Only use it for the hardware domain because the linux kernel may not     * support multi-platform.     */    if ( is_hardware_domain(d) && (rc = domain_vuart_init(d)) )        goto fail;    if ( (rc = iommu_domain_init(d)) != 0 )        goto fail;    return 0;fail:    d->is_dying = DOMDYING_dead;    arch_domain_destroy(d);//.........这里部分代码省略.........

static bool page_empty(void *ptr){	struct page *ptr_page = virt_to_page(ptr);	return page_count(ptr_page) == 1;}

static struct page *mtk_bt_dai_capture_pcm_page(struct snd_pcm_substream *substream,                                                unsigned long offset){    printk("dummy_pcm_page /n");    return virt_to_page(dummy_page[substream->stream]); /* the same page */}

void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,			   dma_addr_t *dma_handle){	void *memory;	int gfp = GFP_ATOMIC;	int i;	unsigned long iommu_page;	if (hwdev == NULL || hwdev->dma_mask < 0xffffffff || (no_iommu && !swiotlb))		gfp |= GFP_DMA;	/* 	 * First try to allocate continuous and use directly if already 	 * in lowmem. 	 */ 	size = round_up(size, PAGE_SIZE); 	memory = (void *)__get_free_pages(gfp, get_order(size));	if (memory == NULL) {		return NULL; 	} else {		int high = 0, mmu;		if (((unsigned long)virt_to_bus(memory) + size) > 0xffffffffUL)			high = 1;		mmu = high;		if (force_mmu && !(gfp & GFP_DMA)) 			mmu = 1;		if (no_iommu) { #ifdef CONFIG_SWIOTLB			if (swiotlb && high && hwdev) {				unsigned long dma_mask = 0;				if (hwdev->dma_mask == ~0UL) {					hwdev->dma_mask = 0xffffffff;					dma_mask = ~0UL;				}				*dma_handle = swiotlb_map_single(hwdev, memory, size,						   		 PCI_DMA_FROMDEVICE);				if (dma_mask)					hwdev->dma_mask = dma_mask;				memset(phys_to_virt(*dma_handle), 0, size); 				free_pages((unsigned long)memory, get_order(size));				return phys_to_virt(*dma_handle);			}#endif			if (high) goto error;			mmu = 0; 		} 			memset(memory, 0, size); 		if (!mmu) { 			*dma_handle = virt_to_bus(memory);			return memory;		}	} 	size >>= PAGE_SHIFT;	iommu_page = alloc_iommu(size);	if (iommu_page == -1)		goto error;    	/* Fill in the GATT, allocating pages as needed. */	for (i = 0; i < size; i++) { 		unsigned long phys_mem; 		void *mem = memory + i*PAGE_SIZE;		if (i > 0) 			atomic_inc(&virt_to_page(mem)->count); 		phys_mem = virt_to_phys(mem); 		BUG_ON(phys_mem & ~PHYSICAL_PAGE_MASK); 		iommu_gatt_base[iommu_page + i] = GPTE_ENCODE(phys_mem); 	} 	flush_gart();	*dma_handle = iommu_bus_base + (iommu_page << PAGE_SHIFT);	return memory; 	 error:	free_pages((unsigned long)memory, get_order(size)); 	return NULL; }

unsigned long __init prom_free_prom_memory(void){    unsigned long freed = 0;    unsigned long addr;    int i;#ifdef	CONFIG_REALTEK_RECLAIM_BOOT_MEM    unsigned long dest;    struct page *page;    int count;#endif    for (i = 0; i < boot_mem_map.nr_map; i++) {        if (boot_mem_map.map[i].type != BOOT_MEM_ROM_DATA)            continue;        addr = boot_mem_map.map[i].addr;        while (addr < boot_mem_map.map[i].addr                + boot_mem_map.map[i].size) {            ClearPageReserved(virt_to_page(__va(addr)));            set_page_count(virt_to_page(__va(addr)), 1);            free_page((unsigned long)__va(addr));            addr += PAGE_SIZE;            freed += PAGE_SIZE;        }    }    printk("Freeing prom memory: %ldkb freed/n", freed >> 10);#ifdef	CONFIG_REALTEK_RECLAIM_BOOT_MEM    if (!is_mars_cpu()) {        // venus or neptune        addr = F_ADDR1;        if (debug_flag)            dest = T_ADDR1;        else            dest = T_ADDR2;    } else {        // mars        addr = F_ADDR2;        if (debug_flag)            dest = T_ADDR1;        else            dest = T_ADDR3;    }    printk("Reclaim bootloader memory from %x to %x/n", addr, dest);    count = 0;    while (addr < dest) {        page = virt_to_page(addr);        /*        		printk("mem_map: %x, page: %x, size: %d /n", (int)mem_map, (int)page, sizeof(struct page));        		if (PageReserved(page) != 1)        			BUG();        		if (page->_count.counter != -1)        			BUG();        */        count++;        __ClearPageReserved(page);        set_page_count(page, 1);        __free_page(page);        addr += 0x1000; // 4KB    }    totalram_pages += count;#endif    return freed;}

int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,		   struct mlx4_buf *buf){	dma_addr_t t;	if (size <= max_direct) {		buf->nbufs        = 1;		buf->npages       = 1;		buf->page_shift   = get_order(size) + PAGE_SHIFT;		buf->direct.buf   = dma_alloc_coherent(&dev->pdev->dev,						       size, &t, GFP_KERNEL);		if (!buf->direct.buf)			return -ENOMEM;		buf->direct.map = t;		while (t & ((1 << buf->page_shift) - 1)) {			--buf->page_shift;			buf->npages *= 2;		}		memset(buf->direct.buf, 0, size);	} else {		int i;		buf->direct.buf  = NULL;		buf->nbufs       = (size + PAGE_SIZE - 1) / PAGE_SIZE;		buf->npages      = buf->nbufs;		buf->page_shift  = PAGE_SHIFT;		buf->page_list   = kzalloc(buf->nbufs * sizeof *buf->page_list,					   GFP_KERNEL);		if (!buf->page_list)			return -ENOMEM;		for (i = 0; i < buf->nbufs; ++i) {			buf->page_list[i].buf =				dma_alloc_coherent(&dev->pdev->dev, PAGE_SIZE,						   &t, GFP_KERNEL);			if (!buf->page_list[i].buf)				goto err_free;			buf->page_list[i].map = t;			memset(buf->page_list[i].buf, 0, PAGE_SIZE);		}		if (BITS_PER_LONG == 64) {			struct page **pages;			pages = kmalloc(sizeof *pages * buf->nbufs, GFP_KERNEL);			if (!pages)				goto err_free;			for (i = 0; i < buf->nbufs; ++i)				pages[i] = virt_to_page(buf->page_list[i].buf);			buf->direct.buf = vmap(pages, buf->nbufs, VM_MAP, PAGE_KERNEL);			kfree(pages);			if (!buf->direct.buf)				goto err_free;		}	}	return 0;err_free:	mlx4_buf_free(dev, size, buf);	return -ENOMEM;}