openwrt/upstream - upstream openwrt

	Commit message (Expand)	Author	Age	Files	Lines
*	.gitignore: Ignore Emacs editor generated files	Vasilis Tsiligiannis	2011-10-31	1	-0/+4
*	add vim temp files (*~) to .gitignore	Jo-Philipp Wich	2011-04-29	1	-0/+1
*	gitignore: add .rej and .orig to .gitignore	Florian Fainelli	2011-04-03	1	-0/+2
*	.gitignore: add *.o and .DS_Store by default - apparently some git versions d...	Felix Fietkau	2010-12-04	1	-0/+2
*	.gitignore: Undo accidental commit.	Daniel Dickinson	2010-05-10	1	-0/+3
*	brcm-2.4: Fixed preinit and failsafe switch configuration	Daniel Dickinson	2010-05-10	1	-3/+0
*	.gitignore: ignore vim swap files	Felix Fietkau	2009-12-16	1	-0/+1
*	add logs/ to .gitignore	Felix Fietkau	2009-04-24	1	-0/+1
*	add feeds.conf to .gitignore	Felix Fietkau	2008-09-23	1	-0/+1
*	add missing gitignore change for build environments	Felix Fietkau	2008-08-06	1	-0/+1
*	update svn:ignore and .gitignore	Felix Fietkau	2008-06-06	1	-6/+6
*	add package/openwrt-packages to .gitignore	Felix Fietkau	2008-02-09	1	-0/+1
*	add package/feeds to .gitignore	Felix Fietkau	2007-10-13	1	-0/+1
*	add feeds to .gitignore	Felix Fietkau	2007-10-09	1	-0/+1
*	update svn and git ignore settings	Felix Fietkau	2007-08-07	1	-1/+1
*	make top-level .gitignore only apply to top-level files/directories (#1960)	Felix Fietkau	2007-06-25	1	-8/+8
*	Add gitignore files	Felix Fietkau	2007-05-29	1	-0/+8

/****************************************************************************** * blkfront.c * * XenLinux virtual block-device driver. * * Copyright (c) 2003-2004, Keir Fraser & Steve Hand * Modifications by Mark A. Williamson are (c) Intel Research Cambridge * Copyright (c) 2004, Christian Limpach * Copyright (c) 2004, Andrew Warfield * Copyright (c) 2005, Christopher Clark * * This file may be distributed separately from the Linux kernel, or * incorporated into other software packages, subject to the following license: * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this source file (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #if 1 #define ASSERT(_p) \ if ( !(_p) ) { printk("Assertion '%s' failed, line %d, file %s", #_p , \ __LINE__, __FILE__); *(int*)0=0; } #else #define ASSERT(_p) #endif #include <linux/version.h> #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) #include "block.h" #else #include "common.h" #include <linux/blk.h> #include <linux/tqueue.h> #endif #include <linux/cdrom.h> #include <linux/sched.h> #include <linux/interrupt.h> #include <scsi/scsi.h> #include <asm-xen/ctrl_if.h> #include <asm-xen/evtchn.h> #ifdef CONFIG_XEN_BLKDEV_GRANT #include <asm-xen/xen-public/grant_table.h> #include <asm-xen/gnttab.h> #endif typedef unsigned char byte; /* from linux/ide.h */ /* Control whether runtime update of vbds is enabled. */ #define ENABLE_VBD_UPDATE 1 #if ENABLE_VBD_UPDATE static void vbd_update(void); #else static void vbd_update(void){}; #endif #define BLKIF_STATE_CLOSED 0 #define BLKIF_STATE_DISCONNECTED 1 #define BLKIF_STATE_CONNECTED 2 static int blkif_handle = 0; static unsigned int blkif_state = BLKIF_STATE_CLOSED; static unsigned int blkif_evtchn = 0; static unsigned int blkif_irq = 0; static int blkif_control_rsp_valid; static blkif_response_t blkif_control_rsp; static blkif_front_ring_t blk_ring; #define BLK_RING_SIZE __RING_SIZE((blkif_sring_t *)0, PAGE_SIZE) #ifdef CONFIG_XEN_BLKDEV_GRANT static domid_t rdomid = 0; static grant_ref_t gref_head, gref_terminal; #define MAXIMUM_OUTSTANDING_BLOCK_REQS \ (BLKIF_MAX_SEGMENTS_PER_REQUEST * BLKIF_RING_SIZE) #define GRANTREF_INVALID (1<<15) #endif static struct blk_shadow { blkif_request_t req; unsigned long request; unsigned long frame[BLKIF_MAX_SEGMENTS_PER_REQUEST]; } blk_shadow[BLK_RING_SIZE]; unsigned long blk_shadow_free; static int recovery = 0; /* Recovery in progress: protected by blkif_io_lock */ static void kick_pending_request_queues(void); int __init xlblk_init(void); static void blkif_completion(struct blk_shadow *s); static inline int GET_ID_FROM_FREELIST(void) { unsigned long free = blk_shadow_free; BUG_ON(free > BLK_RING_SIZE); blk_shadow_free = blk_shadow[free].req.id; blk_shadow[free].req.id = 0x0fffffee; /* debug */ return free; } static inline void ADD_ID_TO_FREELIST(unsigned long id) { blk_shadow[id].req.id = blk_shadow_free; blk_shadow[id].request = 0; blk_shadow_free = id; } /************************ COMMON CODE (inlined) ************************/ /* Kernel-specific definitions used in the common code */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) #define DISABLE_SCATTERGATHER() #else static int sg_operation = -1; #define DISABLE_SCATTERGATHER() (sg_operation = -1) #endif static inline void pickle_request(struct blk_shadow *s, blkif_request_t *r) { #ifndef CONFIG_XEN_BLKDEV_GRANT int i; #endif s->req = *r; #ifndef CONFIG_XEN_BLKDEV_GRANT for ( i = 0; i < r->nr_segments; i++ ) s->req.frame_and_sects[i] = machine_to_phys(r->frame_and_sects[i]); #endif } static inline void unpickle_request(blkif_request_t *r, struct blk_shadow *s) { #ifndef CONFIG_XEN_BLKDEV_GRANT int i; #endif *r = s->req; #ifndef CONFIG_XEN_BLKDEV_GRANT for ( i = 0; i < s->req.nr_segments; i++ ) r->frame_and_sects[i] = phys_to_machine(s->req.frame_and_sects[i]); #endif } static inline void flush_requests(void) { DISABLE_SCATTERGATHER(); RING_PUSH_REQUESTS(&blk_ring); notify_via_evtchn(blkif_evtchn); } /************************** KERNEL VERSION 2.6 **************************/ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_init(xlblk_init); #if ENABLE_VBD_UPDATE static void update_vbds_task(void *unused) { xlvbd_update_vbds(); } static void vbd_update(void) { static DECLARE_WORK(update_tq, update_vbds_task, NULL); schedule_work(&update_tq); } #endif /* ENABLE_VBD_UPDATE */ static void kick_pending_request_queues(void) { if ( (xlbd_blk_queue != NULL) && test_bit(QUEUE_FLAG_STOPPED, &xlbd_blk_queue->queue_flags) ) { blk_start_queue(xlbd_blk_queue); /* XXXcl call to request_fn should not be needed but * we get stuck without... needs investigating */ xlbd_blk_queue->request_fn(xlbd_blk_queue); } } int blkif_open(struct inode *inode, struct file *filep) { struct gendisk *gd = inode->i_bdev->bd_disk; struct xlbd_disk_info *di = (struct xlbd_disk_info *)gd->private_data; /* Update of usage count is protected by per-device semaphore. */ di->mi->usage++; return 0; } int blkif_release(struct inode *inode, struct file *filep) { struct gendisk *gd = inode->i_bdev->bd_disk; struct xlbd_disk_info *di = (struct xlbd_disk_info *)gd->private_data; /* * When usage drops to zero it may allow more VBD updates to occur. * Update of usage count is protected by a per-device semaphore. */ if ( --di->mi->usage == 0 ) vbd_update(); return 0; } int blkif_ioctl(struct inode *inode, struct file *filep, unsigned command, unsigned long argument) { int i; DPRINTK_IOCTL("command: 0x%x, argument: 0x%lx, dev: 0x%04x\n", command, (long)argument, inode->i_rdev); switch ( command ) { case HDIO_GETGEO: /* return ENOSYS to use defaults */ return -ENOSYS; case CDROMMULTISESSION: DPRINTK("FIXME: support multisession CDs later\n"); for ( i = 0; i < sizeof(struct cdrom_multisession); i++ ) if ( put_user(0, (byte *)(argument + i)) ) return -EFAULT; return 0; default: printk(KERN_ALERT "ioctl %08x not supported by Xen blkdev\n", command); return -ENOSYS; } return 0; } /* * blkif_queue_request * * request block io * * id: for guest use only. * operation: BLKIF_OP_{READ,WRITE,PROBE} * buffer: buffer to read/write into. this should be a * virtual address in the guest os. */ static int blkif_queue_request(struct request *req) { struct xlbd_disk_info *di = (struct xlbd_disk_info *)req->rq_disk->private_data; unsigned long buffer_ma; blkif_request_t *ring_req; struct bio *bio; struct bio_vec *bvec; int idx; unsigned long id; unsigned int fsect, lsect; #ifdef CONFIG_XEN_BLKDEV_GRANT int ref; #endif if ( unlikely(blkif_state != BLKIF_STATE_CONNECTED) ) return 1; /* Fill out a communications ring structure. */ ring_req = RING_GET_REQUEST(&blk_ring, blk_ring.req_prod_pvt); id = GET_ID_FROM_FREELIST(); blk_shadow[id].request = (unsigned long)req; ring_req->id = id; ring_req->operation = rq_data_dir(req) ? BLKIF_OP_WRITE : BLKIF_OP_READ; ring_req->sector_number = (blkif_sector_t)req->sector; ring_req->device = di->xd_device; ring_req->nr_segments = 0; rq_for_each_bio(bio, req) { bio_for_each_segment(bvec, bio, idx) { if ( ring_req->nr_segments == BLKIF_MAX_SEGMENTS_PER_REQUEST ) BUG(); buffer_ma = page_to_phys(bvec->bv_page); fsect = bvec->bv_offset >> 9; lsect = fsect + (bvec->bv_len >> 9) - 1; #ifdef CONFIG_XEN_BLKDEV_GRANT /* install a grant reference. */ ref = gnttab_claim_grant_reference(&gref_head, gref_terminal); ASSERT( ref != -ENOSPC ); gnttab_grant_foreign_access_ref( ref, rdomid, buffer_ma >> PAGE_SHIFT, rq_data_dir(req) ); blk_shadow[id].frame[ring_req->nr_segments] = buffer_ma >> PAGE_SHIFT; ring_req->frame_and_sects[ring_req->nr_segments++] = (((u32) ref) << 16) | (fsect << 3) | lsect; #else ring_req->frame_and_sects[ring_req->nr_segments++] = buffer_ma | (fsect << 3) | lsect; #endif } } blk_ring.req_prod_pvt++; /* Keep a private copy so we can reissue requests when recovering. */ pickle_request(&blk_shadow[id], ring_req); return 0; } /* * do_blkif_request * read a block; request is in a request queue */ void do_blkif_request(request_queue_t *rq) { struct request *req; int queued; DPRINTK("Entered do_blkif_request\n"); queued = 0; while ( (req = elv_next_request(rq)) != NULL ) { if ( !blk_fs_request(req) ) { end_request(req, 0); continue; } if ( RING_FULL(&blk_ring) ) { blk_stop_queue(rq); break; } DPRINTK("do_blk_req %p: cmd %p, sec %lx, (%u/%li) buffer:%p [%s]\n", req, req->cmd, req->sector, req->current_nr_sectors, req->nr_sectors, req->buffer, rq_data_dir(req) ? "write" : "read"); blkdev_dequeue_request(req); if ( blkif_queue_request(req) ) { blk_stop_queue(rq); break; } queued++; } if ( queued != 0 ) flush_requests(); } static irqreturn_t blkif_int(int irq, void *dev_id, struct pt_regs *ptregs) { struct request *req; blkif_response_t *bret; RING_IDX i, rp; unsigned long flags; spin_lock_irqsave(&blkif_io_lock, flags); if ( unlikely(blkif_state == BLKIF_STATE_CLOSED) || unlikely(recovery) ) { spin_unlock_irqrestore(&blkif_io_lock, flags); return IRQ_HANDLED; } rp = blk_ring.sring->rsp_prod; rmb(); /* Ensure we see queued responses up to 'rp'. */ for ( i = blk_ring.rsp_cons; i != rp; i++ ) { unsigned long id; bret = RING_GET_RESPONSE(&blk_ring, i); id = bret->id; req = (struct request *)blk_shadow[id].request; blkif_completion(&blk_shadow[id]); ADD_ID_TO_FREELIST(id); switch ( bret->operation ) { case BLKIF_OP_READ: case BLKIF_OP_WRITE: if ( unlikely(bret->status != BLKIF_RSP_OKAY) ) DPRINTK("Bad return from blkdev data request: %x\n", bret->status); if ( unlikely(end_that_request_first (req, (bret->status == BLKIF_RSP_OKAY), req->hard_nr_sectors)) ) BUG(); end_that_request_last(req); break; case BLKIF_OP_PROBE: memcpy(&blkif_control_rsp, bret, sizeof(*bret)); blkif_control_rsp_valid = 1; break; default: BUG(); } } blk_ring.rsp_cons = i; kick_pending_request_queues(); spin_unlock_irqrestore(&blkif_io_lock, flags); return IRQ_HANDLED; } #else /************************** KERNEL VERSION 2.4 **************************/ static kdev_t sg_dev; static unsigned long sg_next_sect; /* * Request queues with outstanding work, but ring is currently full. * We need no special lock here, as we always access this with the * blkif_io_lock held. We only need a small maximum list. */ #define MAX_PENDING 8 static request_queue_t *pending_queues[MAX_PENDING]; static int nr_pending; #define blkif_io_lock io_request_lock /*============================================================================*/ #if ENABLE_VBD_UPDATE /* * blkif_update_int/update-vbds_task - handle VBD update events. * Schedule a task for keventd to run, which will update the VBDs and perform * the corresponding updates to our view of VBD state. */ static void update_vbds_task(void *unused) { xlvbd_update_vbds(); } static void vbd_update(void) { static struct tq_struct update_tq; update_tq.routine = update_vbds_task; schedule_task(&update_tq); } #endif /* ENABLE_VBD_UPDATE */ /*============================================================================*/ static void kick_pending_request_queues(void) { /* We kick pending request queues if the ring is reasonably empty. */ if ( (nr_pending != 0) && (RING_PENDING_REQUESTS(&blk_ring) < (BLK_RING_SIZE >> 1)) ) { /* Attempt to drain the queue, but bail if the ring becomes full. */ while ( (nr_pending != 0) && !RING_FULL(&blk_ring) ) do_blkif_request(pending_queues[--nr_pending]); } } int blkif_open(struct inode *inode, struct file *filep) { short xldev = inode->i_rdev;