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

Commit 80081ec3 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-3.16/drivers' of git://git.kernel.dk/linux-block into next 

Pull block driver changes from Jens Axboe:
 "Now that the core bits are in, here's the pull request for the driver
  related changes for 3.16.  Nothing out of the ordinary here, mostly
  business as usual.  There are a few pulls of for-3.16/core into this
  branch, which were done when the blk-mq was modified after the
  mtip32xx conversion was put in.

  The pull request contains:

   - skd and cciss converted to use pci_enable_msix_exact().  From
     Alexander Gordeev.

   - A few mtip32xx fixes from Asai @ Micron.

   - The conversion of mtip32xx from make_request_fn to blk-mq, and a
     later small fix for that conversion on quiescing for non-queued IO.
     From me.

   - A fix for bsg to use an exported function to check whether this
     driver is request based or not.  Needed updating for blk-mq, which
     is request based, but does not have a request_fn hook.  From me.

   - Small floppy bug fix from Jiri.

   - A series of cleanups for the cdrom uniform layer from Joe Perches.
     Gets rid of various old ugly macros, making the code conform more
     to the modern coding style.

   - A series of patches for drbd from the drbd crew (Lars Ellenberg and
     Philipp Reisner).

   - A use-after-free fix for null_blk from Ming Lei.

   - Also from Ming Lei is a performance patch for virtio-blk, which can
     net us a 3x win on kvm platforms where world notification is
     expensive.

   - Ming Lei also fixed a stall issue in virtio-blk, due to a race
     between queue start/stop and resource limits.

   - A small batch of fixes for xen-blk{back,front} from Olaf Hering and
     Valentin Priescu"

* 'for-3.16/drivers' of git://git.kernel.dk/linux-block: (54 commits)
  block: virtio_blk: don't hold spin lock during world switch
  xen-blkback: defer freeing blkif to avoid blocking xenwatch
  xen blkif.h: fix comment typo in discard-alignment
  xen/blkback: disable discard feature if requested by toolstack
  xen-blkfront: remove type check from blkfront_setup_discard
  floppy: do not corrupt bio.bi_flags when reading block 0
  mtip32xx: move error handling to service thread
  virtio_blk: fix race between start and stop queue
  mtip32xx: stop block hardware queues before quiescing IO
  mtip32xx: blk_mq_init_queue() returns an ERR_PTR
  mtip32xx: convert to use blk-mq
  cdrom: Remove unnecessary prototype for cdrom_get_disc_info
  cdrom: Remove unnecessary prototype for cdrom_mrw_exit
  cdrom: Remove cdrom_count_tracks prototype
  cdrom: Remove cdrom_get_next_writeable prototype
  cdrom: Remove cdrom_get_last_written prototype
  cdrom: Move mmc_ioctls above cdrom_ioctl to remove unnecessary prototype
  cdrom: Remove unnecessary sanitize_format prototype
  cdrom: Remove unnecessary check_for_audio_disc prototype
  cdrom: Remove prototype for open_for_data
  ...
parents 42555320 e8edca6f

block/bsg.c

+1 −1
Original line number Diff line number Diff line
@@ -1008,7 +1008,7 @@ int bsg_register_queue(struct request_queue *q, struct device *parent, 
	/*

	 * we need a proper transport to send commands, not a stacked device

	 */

	if (!q->request_fn)

	if (!queue_is_rq_based(q))

		return 0;



	bcd = &q->bsg_dev;

drivers/block/cciss.c

+1 −5
Original line number Diff line number Diff line
@@ -4080,7 +4080,7 @@ static void cciss_interrupt_mode(ctlr_info_t *h) 
		goto default_int_mode;



	if (pci_find_capability(h->pdev, PCI_CAP_ID_MSIX)) {

		err = pci_enable_msix(h->pdev, cciss_msix_entries, 4);

		err = pci_enable_msix_exact(h->pdev, cciss_msix_entries, 4);

		if (!err) {

			h->intr[0] = cciss_msix_entries[0].vector;

			h->intr[1] = cciss_msix_entries[1].vector;
@@ -4088,10 +4088,6 @@ static void cciss_interrupt_mode(ctlr_info_t *h) 
			h->intr[3] = cciss_msix_entries[3].vector;

			h->msix_vector = 1;

			return;

		}

		if (err > 0) {

			dev_warn(&h->pdev->dev,

				"only %d MSI-X vectors available\n", err);

		} else {

			dev_warn(&h->pdev->dev,

				"MSI-X init failed %d\n", err);

drivers/block/drbd/drbd_actlog.c

+10 −13
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ 
#include <linux/drbd_limits.h>

#include <linux/dynamic_debug.h>

#include "drbd_int.h"

#include "drbd_wrappers.h"





enum al_transaction_types {
@@ -204,7 +203,7 @@ int drbd_md_sync_page_io(struct drbd_device *device, struct drbd_backing_dev *bd 


	BUG_ON(!bdev->md_bdev);



	drbd_dbg(device, "meta_data io: %s [%d]:%s(,%llus,%s) %pS\n",

	dynamic_drbd_dbg(device, "meta_data io: %s [%d]:%s(,%llus,%s) %pS\n",

	     current->comm, current->pid, __func__,

	     (unsigned long long)sector, (rw & WRITE) ? "WRITE" : "READ",

	     (void*)_RET_IP_ );
@@ -276,7 +275,6 @@ bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval 
	return _al_get(device, first, true);

}



static

bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i)

{

	/* for bios crossing activity log extent boundaries,
@@ -846,7 +844,7 @@ void __drbd_set_in_sync(struct drbd_device *device, sector_t sector, int size, 
	int wake_up = 0;

	unsigned long flags;



	if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {

	if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_DISCARD_SIZE) {

		drbd_err(device, "drbd_set_in_sync: sector=%llus size=%d nonsense!\n",

				(unsigned long long)sector, size);

		return;
@@ -920,7 +918,7 @@ int __drbd_set_out_of_sync(struct drbd_device *device, sector_t sector, int size 
	if (size == 0)

		return 0;



	if (size < 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {

	if (size < 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_DISCARD_SIZE) {

		drbd_err(device, "sector: %llus, size: %d\n",

			(unsigned long long)sector, size);

		return 0;
@@ -1023,8 +1021,7 @@ int drbd_rs_begin_io(struct drbd_device *device, sector_t sector) 
	unsigned int enr = BM_SECT_TO_EXT(sector);

	struct bm_extent *bm_ext;

	int i, sig;

	int sa = 200; /* Step aside 200 times, then grab the extent and let app-IO wait.

			 200 times -> 20 seconds. */

	bool sa;



retry:

	sig = wait_event_interruptible(device->al_wait,
@@ -1035,12 +1032,15 @@ int drbd_rs_begin_io(struct drbd_device *device, sector_t sector) 
	if (test_bit(BME_LOCKED, &bm_ext->flags))

		return 0;



	/* step aside only while we are above c-min-rate; unless disabled. */

	sa = drbd_rs_c_min_rate_throttle(device);



	for (i = 0; i < AL_EXT_PER_BM_SECT; i++) {

		sig = wait_event_interruptible(device->al_wait,

					       !_is_in_al(device, enr * AL_EXT_PER_BM_SECT + i) ||

					       test_bit(BME_PRIORITY, &bm_ext->flags));

					       (sa && test_bit(BME_PRIORITY, &bm_ext->flags)));



		if (sig || (test_bit(BME_PRIORITY, &bm_ext->flags) && sa)) {

		if (sig || (sa && test_bit(BME_PRIORITY, &bm_ext->flags))) {

			spin_lock_irq(&device->al_lock);

			if (lc_put(device->resync, &bm_ext->lce) == 0) {

				bm_ext->flags = 0; /* clears BME_NO_WRITES and eventually BME_PRIORITY */
@@ -1052,9 +1052,6 @@ int drbd_rs_begin_io(struct drbd_device *device, sector_t sector) 
				return -EINTR;

			if (schedule_timeout_interruptible(HZ/10))

				return -EINTR;

			if (sa && --sa == 0)

				drbd_warn(device, "drbd_rs_begin_io() stepped aside for 20sec."

					 "Resync stalled?\n");

			goto retry;

		}

	}
@@ -1288,7 +1285,7 @@ void drbd_rs_failed_io(struct drbd_device *device, sector_t sector, int size) 
	sector_t esector, nr_sectors;

	int wake_up = 0;



	if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {

	if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_DISCARD_SIZE) {

		drbd_err(device, "drbd_rs_failed_io: sector=%llus size=%d nonsense!\n",

				(unsigned long long)sector, size);

		return;

drivers/block/drbd/drbd_int.h

+85 −7
Original line number Diff line number Diff line
@@ -382,6 +382,12 @@ enum { 
	__EE_CALL_AL_COMPLETE_IO,

	__EE_MAY_SET_IN_SYNC,



	/* is this a TRIM aka REQ_DISCARD? */

	__EE_IS_TRIM,

	/* our lower level cannot handle trim,

	 * and we want to fall back to zeroout instead */

	__EE_IS_TRIM_USE_ZEROOUT,



	/* In case a barrier failed,

	 * we need to resubmit without the barrier flag. */

	__EE_RESUBMITTED,
@@ -405,6 +411,8 @@ enum { 
};

#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)

#define EE_MAY_SET_IN_SYNC     (1<<__EE_MAY_SET_IN_SYNC)

#define EE_IS_TRIM             (1<<__EE_IS_TRIM)

#define EE_IS_TRIM_USE_ZEROOUT (1<<__EE_IS_TRIM_USE_ZEROOUT)

#define EE_RESUBMITTED         (1<<__EE_RESUBMITTED)

#define EE_WAS_ERROR           (1<<__EE_WAS_ERROR)

#define EE_HAS_DIGEST          (1<<__EE_HAS_DIGEST)
@@ -579,6 +587,7 @@ struct drbd_resource { 
	struct list_head resources;

	struct res_opts res_opts;

	struct mutex conf_update;	/* mutex for ready-copy-update of net_conf and disk_conf */

	struct mutex adm_mutex;		/* mutex to serialize administrative requests */

	spinlock_t req_lock;



	unsigned susp:1;		/* IO suspended by user */
@@ -609,6 +618,7 @@ struct drbd_connection { 
	struct drbd_socket data;	/* data/barrier/cstate/parameter packets */

	struct drbd_socket meta;	/* ping/ack (metadata) packets */

	int agreed_pro_version;		/* actually used protocol version */

	u32 agreed_features;

	unsigned long last_received;	/* in jiffies, either socket */

	unsigned int ko_count;
@@ -814,6 +824,28 @@ struct drbd_device { 
	struct submit_worker submit;

};



struct drbd_config_context {

	/* assigned from drbd_genlmsghdr */

	unsigned int minor;

	/* assigned from request attributes, if present */

	unsigned int volume;

#define VOLUME_UNSPECIFIED		(-1U)

	/* pointer into the request skb,

	 * limited lifetime! */

	char *resource_name;

	struct nlattr *my_addr;

	struct nlattr *peer_addr;



	/* reply buffer */

	struct sk_buff *reply_skb;

	/* pointer into reply buffer */

	struct drbd_genlmsghdr *reply_dh;

	/* resolved from attributes, if possible */

	struct drbd_device *device;

	struct drbd_resource *resource;

	struct drbd_connection *connection;

};



static inline struct drbd_device *minor_to_device(unsigned int minor)

{

	return (struct drbd_device *)idr_find(&drbd_devices, minor);
@@ -821,7 +853,7 @@ static inline struct drbd_device *minor_to_device(unsigned int minor) 


static inline struct drbd_peer_device *first_peer_device(struct drbd_device *device)

{

	return list_first_entry(&device->peer_devices, struct drbd_peer_device, peer_devices);

	return list_first_entry_or_null(&device->peer_devices, struct drbd_peer_device, peer_devices);

}



#define for_each_resource(resource, _resources) \
@@ -1139,6 +1171,12 @@ struct bm_extent { 
#define DRBD_MAX_SIZE_H80_PACKET (1U << 15) /* Header 80 only allows packets up to 32KiB data */

#define DRBD_MAX_BIO_SIZE_P95    (1U << 17) /* Protocol 95 to 99 allows bios up to 128KiB */



/* For now, don't allow more than one activity log extent worth of data

 * to be discarded in one go. We may need to rework drbd_al_begin_io()

 * to allow for even larger discard ranges */

#define DRBD_MAX_DISCARD_SIZE	AL_EXTENT_SIZE

#define DRBD_MAX_DISCARD_SECTORS (DRBD_MAX_DISCARD_SIZE >> 9)



extern int  drbd_bm_init(struct drbd_device *device);

extern int  drbd_bm_resize(struct drbd_device *device, sector_t sectors, int set_new_bits);

extern void drbd_bm_cleanup(struct drbd_device *device);
@@ -1229,9 +1267,9 @@ extern struct bio *bio_alloc_drbd(gfp_t gfp_mask); 
extern rwlock_t global_state_lock;



extern int conn_lowest_minor(struct drbd_connection *connection);

enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned int minor, int vnr);

extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor);

extern void drbd_destroy_device(struct kref *kref);

extern void drbd_delete_device(struct drbd_device *mdev);

extern void drbd_delete_device(struct drbd_device *device);



extern struct drbd_resource *drbd_create_resource(const char *name);

extern void drbd_free_resource(struct drbd_resource *resource);
@@ -1257,7 +1295,7 @@ extern int is_valid_ar_handle(struct drbd_request *, sector_t); 




/* drbd_nl.c */

extern int drbd_msg_put_info(const char *info);

extern int drbd_msg_put_info(struct sk_buff *skb, const char *info);

extern void drbd_suspend_io(struct drbd_device *device);

extern void drbd_resume_io(struct drbd_device *device);

extern char *ppsize(char *buf, unsigned long long size);
@@ -1283,6 +1321,10 @@ extern void conn_try_outdate_peer_async(struct drbd_connection *connection); 
extern int drbd_khelper(struct drbd_device *device, char *cmd);



/* drbd_worker.c */

/* bi_end_io handlers */

extern void drbd_md_io_complete(struct bio *bio, int error);

extern void drbd_peer_request_endio(struct bio *bio, int error);

extern void drbd_request_endio(struct bio *bio, int error);

extern int drbd_worker(struct drbd_thread *thi);

enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);

void drbd_resync_after_changed(struct drbd_device *device);
@@ -1332,16 +1374,20 @@ extern int w_start_resync(struct drbd_work *, int); 
extern void resync_timer_fn(unsigned long data);

extern void start_resync_timer_fn(unsigned long data);



extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req);



/* drbd_receiver.c */

extern int drbd_receiver(struct drbd_thread *thi);

extern int drbd_asender(struct drbd_thread *thi);

extern int drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector);

extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);

extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector);

extern int drbd_submit_peer_request(struct drbd_device *,

				    struct drbd_peer_request *, const unsigned,

				    const int);

extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *);

extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_peer_device *, u64,

						     sector_t, unsigned int,

						     bool,

						     gfp_t) __must_hold(local);

extern void __drbd_free_peer_req(struct drbd_device *, struct drbd_peer_request *,

				 int);
@@ -1401,6 +1447,37 @@ static inline void drbd_tcp_quickack(struct socket *sock) 
			(char*)&val, sizeof(val));

}



/* sets the number of 512 byte sectors of our virtual device */

static inline void drbd_set_my_capacity(struct drbd_device *device,

					sector_t size)

{

	/* set_capacity(device->this_bdev->bd_disk, size); */

	set_capacity(device->vdisk, size);

	device->this_bdev->bd_inode->i_size = (loff_t)size << 9;

}



/*

 * used to submit our private bio

 */

static inline void drbd_generic_make_request(struct drbd_device *device,

					     int fault_type, struct bio *bio)

{

	__release(local);

	if (!bio->bi_bdev) {

		printk(KERN_ERR "drbd%d: drbd_generic_make_request: "

				"bio->bi_bdev == NULL\n",

		       device_to_minor(device));

		dump_stack();

		bio_endio(bio, -ENODEV);

		return;

	}



	if (drbd_insert_fault(device, fault_type))

		bio_endio(bio, -EIO);

	else

		generic_make_request(bio);

}



void drbd_bump_write_ordering(struct drbd_connection *connection, enum write_ordering_e wo);



/* drbd_proc.c */
@@ -1410,6 +1487,7 @@ extern const char *drbd_conn_str(enum drbd_conns s); 
extern const char *drbd_role_str(enum drbd_role s);



/* drbd_actlog.c */

extern bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i);

extern int drbd_al_begin_io_nonblock(struct drbd_device *device, struct drbd_interval *i);

extern void drbd_al_begin_io_commit(struct drbd_device *device, bool delegate);

extern bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval *i);
@@ -2144,7 +2222,7 @@ static inline void drbd_md_flush(struct drbd_device *device) 


static inline struct drbd_connection *first_connection(struct drbd_resource *resource)

{

	return list_first_entry(&resource->connections,

	return list_first_entry_or_null(&resource->connections,

				struct drbd_connection, connections);

}

drivers/block/drbd/drbd_main.c

+21 −7
Original line number Diff line number Diff line
@@ -1607,8 +1607,8 @@ static u32 bio_flags_to_wire(struct drbd_connection *connection, unsigned long b 
		return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;

}



/* Used to send write requests

 * R_PRIMARY -> Peer	(P_DATA)

/* Used to send write or TRIM aka REQ_DISCARD requests

 * R_PRIMARY -> Peer	(P_DATA, P_TRIM)

 */

int drbd_send_dblock(struct drbd_peer_device *peer_device, struct drbd_request *req)

{
@@ -1640,6 +1640,16 @@ int drbd_send_dblock(struct drbd_peer_device *peer_device, struct drbd_request * 
			dp_flags |= DP_SEND_WRITE_ACK;

	}

	p->dp_flags = cpu_to_be32(dp_flags);



	if (dp_flags & DP_DISCARD) {

		struct p_trim *t = (struct p_trim*)p;

		t->size = cpu_to_be32(req->i.size);

		err = __send_command(peer_device->connection, device->vnr, sock, P_TRIM, sizeof(*t), NULL, 0);

		goto out;

	}



	/* our digest is still only over the payload.

	 * TRIM does not carry any payload. */

	if (dgs)

		drbd_csum_bio(peer_device->connection->integrity_tfm, req->master_bio, p + 1);

	err = __send_command(peer_device->connection, device->vnr, sock, P_DATA, sizeof(*p) + dgs, NULL, req->i.size);
@@ -1675,6 +1685,7 @@ int drbd_send_dblock(struct drbd_peer_device *peer_device, struct drbd_request * 
		     ... Be noisy about digest too large ...

		} */

	}

out:

	mutex_unlock(&sock->mutex);  /* locked by drbd_prepare_command() */



	return err;
@@ -2570,6 +2581,7 @@ struct drbd_resource *drbd_create_resource(const char *name) 
	INIT_LIST_HEAD(&resource->connections);

	list_add_tail_rcu(&resource->resources, &drbd_resources);

	mutex_init(&resource->conf_update);

	mutex_init(&resource->adm_mutex);

	spin_lock_init(&resource->req_lock);

	return resource;
@@ -2687,14 +2699,16 @@ static int init_submitter(struct drbd_device *device) 
	return 0;

}



enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned int minor, int vnr)

enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor)

{

	struct drbd_resource *resource = adm_ctx->resource;

	struct drbd_connection *connection;

	struct drbd_device *device;

	struct drbd_peer_device *peer_device, *tmp_peer_device;

	struct gendisk *disk;

	struct request_queue *q;

	int id;

	int vnr = adm_ctx->volume;

	enum drbd_ret_code err = ERR_NOMEM;



	device = minor_to_device(minor);
@@ -2763,7 +2777,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned i 
	if (id < 0) {

		if (id == -ENOSPC) {

			err = ERR_MINOR_EXISTS;

			drbd_msg_put_info("requested minor exists already");

			drbd_msg_put_info(adm_ctx->reply_skb, "requested minor exists already");

		}

		goto out_no_minor_idr;

	}
@@ -2773,7 +2787,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned i 
	if (id < 0) {

		if (id == -ENOSPC) {

			err = ERR_MINOR_EXISTS;

			drbd_msg_put_info("requested minor exists already");

			drbd_msg_put_info(adm_ctx->reply_skb, "requested minor exists already");

		}

		goto out_idr_remove_minor;

	}
@@ -2794,7 +2808,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned i 
		if (id < 0) {

			if (id == -ENOSPC) {

				err = ERR_INVALID_REQUEST;

				drbd_msg_put_info("requested volume exists already");

				drbd_msg_put_info(adm_ctx->reply_skb, "requested volume exists already");

			}

			goto out_idr_remove_from_resource;

		}
@@ -2803,7 +2817,7 @@ enum drbd_ret_code drbd_create_device(struct drbd_resource *resource, unsigned i 


	if (init_submitter(device)) {

		err = ERR_NOMEM;

		drbd_msg_put_info("unable to create submit workqueue");

		drbd_msg_put_info(adm_ctx->reply_skb, "unable to create submit workqueue");

		goto out_idr_remove_vol;

	}