Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1f0918d0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus 

* git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus:
  lguest: don't force VIRTIO_F_NOTIFY_ON_EMPTY
  lguest: cleanup for map_switcher()
  lguest: use PGDIR_SHIFT for PAE code to allow different PAGE_OFFSET
  lguest: use set_pte/set_pmd uniformly for real page table entries
  lguest: move panic notifier registration to its expected place.
  virtio_blk: add support for cache flush
  virtio: add virtio IDs file
  virtio: get rid of redundant VIRTIO_ID_9P definition
  virtio: make add_buf return capacity remaining
  virtio_pci: minor MSI-X cleanups
parents 4266c97a ca60a42c

Documentation/lguest/lguest.c

+22 −4
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 
#include <signal.h>

#include "linux/lguest_launcher.h"

#include "linux/virtio_config.h"

#include <linux/virtio_ids.h>

#include "linux/virtio_net.h"

#include "linux/virtio_blk.h"

#include "linux/virtio_console.h"
@@ -133,6 +134,9 @@ struct device { 
	/* Is it operational */

	bool running;



	/* Does Guest want an intrrupt on empty? */

	bool irq_on_empty;



	/* Device-specific data. */

	void *priv;

};
@@ -623,10 +627,13 @@ static void trigger_irq(struct virtqueue *vq) 
		return;

	vq->pending_used = 0;



	/* If they don't want an interrupt, don't send one, unless empty. */

	if ((vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)

	    && lg_last_avail(vq) != vq->vring.avail->idx)

	/* If they don't want an interrupt, don't send one... */

	if (vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT) {

		/* ... unless they've asked us to force one on empty. */

		if (!vq->dev->irq_on_empty

		    || lg_last_avail(vq) != vq->vring.avail->idx)

			return;

	}



	/* Send the Guest an interrupt tell them we used something up. */

	if (write(lguest_fd, buf, sizeof(buf)) != 0)
@@ -1042,6 +1049,15 @@ static void create_thread(struct virtqueue *vq) 
	close(vq->eventfd);

}



static bool accepted_feature(struct device *dev, unsigned int bit)

{

	const u8 *features = get_feature_bits(dev) + dev->feature_len;



	if (dev->feature_len < bit / CHAR_BIT)

		return false;

	return features[bit / CHAR_BIT] & (1 << (bit % CHAR_BIT));

}



static void start_device(struct device *dev)

{

	unsigned int i;
@@ -1055,6 +1071,8 @@ static void start_device(struct device *dev) 
		verbose(" %02x", get_feature_bits(dev)

			[dev->feature_len+i]);



	dev->irq_on_empty = accepted_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY);



	for (vq = dev->vq; vq; vq = vq->next) {

		if (vq->service)

			create_thread(vq);

arch/x86/lguest/boot.c

+4 −6
Original line number Diff line number Diff line
@@ -1135,11 +1135,6 @@ static struct notifier_block paniced = { 
/* Setting up memory is fairly easy. */

static __init char *lguest_memory_setup(void)

{

	/* We do this here and not earlier because lockcheck used to barf if we

	 * did it before start_kernel().  I think we fixed that, so it'd be

	 * nice to move it back to lguest_init.  Patch welcome... */

	atomic_notifier_chain_register(&panic_notifier_list, &paniced);



	/*

	 *The Linux bootloader header contains an "e820" memory map: the

	 * Launcher populated the first entry with our memory limit.
@@ -1364,10 +1359,13 @@ __init void lguest_init(void) 


	/*

	 * If we don't initialize the lock dependency checker now, it crashes

	 * paravirt_disable_iospace.

	 * atomic_notifier_chain_register, then paravirt_disable_iospace.

	 */

	lockdep_init();



	/* Hook in our special panic hypercall code. */

	atomic_notifier_chain_register(&panic_notifier_list, &paniced);



	/*

	 * The IDE code spends about 3 seconds probing for disks: if we reserve

	 * all the I/O ports up front it can't get them and so doesn't probe.

drivers/block/virtio_blk.c

+27 −6
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 
#include <linux/blkdev.h>

#include <linux/hdreg.h>

#include <linux/virtio.h>

#include <linux/virtio_ids.h>

#include <linux/virtio_blk.h>

#include <linux/scatterlist.h>
@@ -91,15 +92,26 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk, 
		return false;



	vbr->req = req;

	if (blk_fs_request(vbr->req)) {

	switch (req->cmd_type) {

	case REQ_TYPE_FS:

		vbr->out_hdr.type = 0;

		vbr->out_hdr.sector = blk_rq_pos(vbr->req);

		vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);

	} else if (blk_pc_request(vbr->req)) {

		break;

	case REQ_TYPE_BLOCK_PC:

		vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;

		vbr->out_hdr.sector = 0;

		vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);

	} else {

		break;

	case REQ_TYPE_LINUX_BLOCK:

		if (req->cmd[0] == REQ_LB_OP_FLUSH) {

			vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;

			vbr->out_hdr.sector = 0;

			vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);

			break;

		}

		/*FALLTHRU*/

	default:

		/* We don't put anything else in the queue. */

		BUG();

	}
@@ -139,7 +151,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk, 
		}

	}



	if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr)) {

	if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr) < 0) {

		mempool_free(vbr, vblk->pool);

		return false;

	}
@@ -199,6 +211,12 @@ static int virtblk_identify(struct gendisk *disk, void *argp) 
	return err;

}



static void virtblk_prepare_flush(struct request_queue *q, struct request *req)

{

	req->cmd_type = REQ_TYPE_LINUX_BLOCK;

	req->cmd[0] = REQ_LB_OP_FLUSH;

}



static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,

			 unsigned cmd, unsigned long data)

{
@@ -337,7 +355,10 @@ static int __devinit virtblk_probe(struct virtio_device *vdev) 
	index++;



	/* If barriers are supported, tell block layer that queue is ordered */

	if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))

	if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))

		blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_DRAIN_FLUSH,

				  virtblk_prepare_flush);

	else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))

		blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_TAG, NULL);



	/* If disk is read-only in the host, the guest should obey */
@@ -424,7 +445,7 @@ static struct virtio_device_id id_table[] = { 
static unsigned int features[] = {

	VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,

	VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,

	VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_IDENTIFY

	VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_IDENTIFY, VIRTIO_BLK_F_FLUSH

};



/*

drivers/char/hw_random/virtio-rng.c

+2 −1
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/scatterlist.h>

#include <linux/spinlock.h>

#include <linux/virtio.h>

#include <linux/virtio_ids.h>

#include <linux/virtio_rng.h>



/* The host will fill any buffer we give it with sweet, sweet randomness.  We
@@ -51,7 +52,7 @@ static void register_buffer(void) 


	sg_init_one(&sg, random_data+data_left, RANDOM_DATA_SIZE-data_left);

	/* There should always be room for one buffer. */

	if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) != 0)

	if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) < 0)

		BUG();

	vq->vq_ops->kick(vq);

}

drivers/char/virtio_console.c

+3 −2
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include <linux/err.h>

#include <linux/init.h>

#include <linux/virtio.h>

#include <linux/virtio_ids.h>

#include <linux/virtio_console.h>

#include "hvc_console.h"
@@ -65,7 +66,7 @@ static int put_chars(u32 vtermno, const char *buf, int count) 


	/* add_buf wants a token to identify this buffer: we hand it any

	 * non-NULL pointer, since there's only ever one buffer. */

	if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) == 0) {

	if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) >= 0) {

		/* Tell Host to go! */

		out_vq->vq_ops->kick(out_vq);

		/* Chill out until it's done with the buffer. */
@@ -85,7 +86,7 @@ static void add_inbuf(void) 
	sg_init_one(sg, inbuf, PAGE_SIZE);



	/* We should always be able to add one buffer to an empty queue. */

	if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) != 0)

	if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) < 0)

		BUG();

	in_vq->vq_ops->kick(in_vq);

}