mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 03:27:44 -04:00
Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block
* 'for-linus' of git://git.kernel.dk/linux-2.6-block: (34 commits) cfq-iosched: Fix the incorrect timeslice accounting with forced_dispatch loop: Update mtime when writing using aops block: expose the statistics in blkio.time and blkio.sectors for the root cgroup backing-dev: Handle class_create() failure Block: Fix block/elevator.c elevator_get() off-by-one error drbd: lc_element_by_index() never returns NULL cciss: unlock on error path cfq-iosched: Do not merge queues of BE and IDLE classes cfq-iosched: Add additional blktrace log messages in CFQ for easier debugging i2o: Remove the dangerous kobj_to_i2o_device macro block: remove 16 bytes of padding from struct request on 64bits cfq-iosched: fix a kbuild regression block: make CONFIG_BLK_CGROUP visible Remove GENHD_FL_DRIVERFS block: Export max number of segments and max segment size in sysfs block: Finalize conversion of block limits functions block: Fix overrun in lcm() and move it to lib vfs: improve writeback_inodes_wb() paride: fix off-by-one test drbd: fix al-to-on-disk-bitmap for 4k logical_block_size ...
This commit is contained in:
Linus Torvalds
commit
2f4084209a
34 changed files with 475 additions and 178 deletions
|
|
@ -2533,7 +2533,6 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
|
|||
Controller->RequestQueue[n] = RequestQueue;
|
||||
blk_queue_bounce_limit(RequestQueue, Controller->BounceBufferLimit);
|
||||
RequestQueue->queuedata = Controller;
|
||||
blk_queue_max_hw_segments(RequestQueue, Controller->DriverScatterGatherLimit);
|
||||
blk_queue_max_segments(RequestQueue, Controller->DriverScatterGatherLimit);
|
||||
blk_queue_max_hw_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
|
||||
disk->queue = RequestQueue;
|
||||
|
|
|
|||
|
|
@ -536,7 +536,9 @@ static void atodb_endio(struct bio *bio, int error)
|
|||
put_ldev(mdev);
|
||||
}
|
||||
|
||||
/* sector to word */
|
||||
#define S2W(s) ((s)<<(BM_EXT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL))
|
||||
|
||||
/* activity log to on disk bitmap -- prepare bio unless that sector
|
||||
* is already covered by previously prepared bios */
|
||||
static int atodb_prepare_unless_covered(struct drbd_conf *mdev,
|
||||
|
|
@ -546,13 +548,20 @@ static int atodb_prepare_unless_covered(struct drbd_conf *mdev,
|
|||
{
|
||||
struct bio *bio;
|
||||
struct page *page;
|
||||
sector_t on_disk_sector = enr + mdev->ldev->md.md_offset
|
||||
+ mdev->ldev->md.bm_offset;
|
||||
sector_t on_disk_sector;
|
||||
unsigned int page_offset = PAGE_SIZE;
|
||||
int offset;
|
||||
int i = 0;
|
||||
int err = -ENOMEM;
|
||||
|
||||
/* We always write aligned, full 4k blocks,
|
||||
* so we can ignore the logical_block_size (for now) */
|
||||
enr &= ~7U;
|
||||
on_disk_sector = enr + mdev->ldev->md.md_offset
|
||||
+ mdev->ldev->md.bm_offset;
|
||||
|
||||
D_ASSERT(!(on_disk_sector & 7U));
|
||||
|
||||
/* Check if that enr is already covered by an already created bio.
|
||||
* Caution, bios[] is not NULL terminated,
|
||||
* but only initialized to all NULL.
|
||||
|
|
@ -588,7 +597,7 @@ static int atodb_prepare_unless_covered(struct drbd_conf *mdev,
|
|||
|
||||
offset = S2W(enr);
|
||||
drbd_bm_get_lel(mdev, offset,
|
||||
min_t(size_t, S2W(1), drbd_bm_words(mdev) - offset),
|
||||
min_t(size_t, S2W(8), drbd_bm_words(mdev) - offset),
|
||||
kmap(page) + page_offset);
|
||||
kunmap(page);
|
||||
|
||||
|
|
@ -597,7 +606,7 @@ static int atodb_prepare_unless_covered(struct drbd_conf *mdev,
|
|||
bio->bi_bdev = mdev->ldev->md_bdev;
|
||||
bio->bi_sector = on_disk_sector;
|
||||
|
||||
if (bio_add_page(bio, page, MD_SECTOR_SIZE, page_offset) != MD_SECTOR_SIZE)
|
||||
if (bio_add_page(bio, page, 4096, page_offset) != 4096)
|
||||
goto out_put_page;
|
||||
|
||||
atomic_inc(&wc->count);
|
||||
|
|
@ -1327,7 +1336,7 @@ int drbd_rs_del_all(struct drbd_conf *mdev)
|
|||
/* ok, ->resync is there. */
|
||||
for (i = 0; i < mdev->resync->nr_elements; i++) {
|
||||
e = lc_element_by_index(mdev->resync, i);
|
||||
bm_ext = e ? lc_entry(e, struct bm_extent, lce) : NULL;
|
||||
bm_ext = lc_entry(e, struct bm_extent, lce);
|
||||
if (bm_ext->lce.lc_number == LC_FREE)
|
||||
continue;
|
||||
if (bm_ext->lce.lc_number == mdev->resync_wenr) {
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ struct drbd_bitmap {
|
|||
size_t bm_words;
|
||||
size_t bm_number_of_pages;
|
||||
sector_t bm_dev_capacity;
|
||||
struct semaphore bm_change; /* serializes resize operations */
|
||||
struct mutex bm_change; /* serializes resize operations */
|
||||
|
||||
atomic_t bm_async_io;
|
||||
wait_queue_head_t bm_io_wait;
|
||||
|
|
@ -115,7 +115,7 @@ void drbd_bm_lock(struct drbd_conf *mdev, char *why)
|
|||
return;
|
||||
}
|
||||
|
||||
trylock_failed = down_trylock(&b->bm_change);
|
||||
trylock_failed = !mutex_trylock(&b->bm_change);
|
||||
|
||||
if (trylock_failed) {
|
||||
dev_warn(DEV, "%s going to '%s' but bitmap already locked for '%s' by %s\n",
|
||||
|
|
@ -126,7 +126,7 @@ void drbd_bm_lock(struct drbd_conf *mdev, char *why)
|
|||
b->bm_task == mdev->receiver.task ? "receiver" :
|
||||
b->bm_task == mdev->asender.task ? "asender" :
|
||||
b->bm_task == mdev->worker.task ? "worker" : "?");
|
||||
down(&b->bm_change);
|
||||
mutex_lock(&b->bm_change);
|
||||
}
|
||||
if (__test_and_set_bit(BM_LOCKED, &b->bm_flags))
|
||||
dev_err(DEV, "FIXME bitmap already locked in bm_lock\n");
|
||||
|
|
@ -148,7 +148,7 @@ void drbd_bm_unlock(struct drbd_conf *mdev)
|
|||
|
||||
b->bm_why = NULL;
|
||||
b->bm_task = NULL;
|
||||
up(&b->bm_change);
|
||||
mutex_unlock(&b->bm_change);
|
||||
}
|
||||
|
||||
/* word offset to long pointer */
|
||||
|
|
@ -296,7 +296,7 @@ int drbd_bm_init(struct drbd_conf *mdev)
|
|||
if (!b)
|
||||
return -ENOMEM;
|
||||
spin_lock_init(&b->bm_lock);
|
||||
init_MUTEX(&b->bm_change);
|
||||
mutex_init(&b->bm_change);
|
||||
init_waitqueue_head(&b->bm_io_wait);
|
||||
|
||||
mdev->bitmap = b;
|
||||
|
|
|
|||
|
|
@ -261,6 +261,9 @@ static inline const char *cmdname(enum drbd_packets cmd)
|
|||
[P_OV_REQUEST] = "OVRequest",
|
||||
[P_OV_REPLY] = "OVReply",
|
||||
[P_OV_RESULT] = "OVResult",
|
||||
[P_CSUM_RS_REQUEST] = "CsumRSRequest",
|
||||
[P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
|
||||
[P_COMPRESSED_BITMAP] = "CBitmap",
|
||||
[P_MAX_CMD] = NULL,
|
||||
};
|
||||
|
||||
|
|
@ -443,13 +446,18 @@ struct p_rs_param_89 {
|
|||
char csums_alg[SHARED_SECRET_MAX];
|
||||
} __packed;
|
||||
|
||||
enum drbd_conn_flags {
|
||||
CF_WANT_LOSE = 1,
|
||||
CF_DRY_RUN = 2,
|
||||
};
|
||||
|
||||
struct p_protocol {
|
||||
struct p_header head;
|
||||
u32 protocol;
|
||||
u32 after_sb_0p;
|
||||
u32 after_sb_1p;
|
||||
u32 after_sb_2p;
|
||||
u32 want_lose;
|
||||
u32 conn_flags;
|
||||
u32 two_primaries;
|
||||
|
||||
/* Since protocol version 87 and higher. */
|
||||
|
|
@ -791,6 +799,8 @@ enum {
|
|||
* while this is set. */
|
||||
RESIZE_PENDING, /* Size change detected locally, waiting for the response from
|
||||
* the peer, if it changed there as well. */
|
||||
CONN_DRY_RUN, /* Expect disconnect after resync handshake. */
|
||||
GOT_PING_ACK, /* set when we receive a ping_ack packet, misc wait gets woken */
|
||||
};
|
||||
|
||||
struct drbd_bitmap; /* opaque for drbd_conf */
|
||||
|
|
|
|||
|
|
@ -1668,7 +1668,7 @@ int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc)
|
|||
int drbd_send_protocol(struct drbd_conf *mdev)
|
||||
{
|
||||
struct p_protocol *p;
|
||||
int size, rv;
|
||||
int size, cf, rv;
|
||||
|
||||
size = sizeof(struct p_protocol);
|
||||
|
||||
|
|
@ -1685,9 +1685,21 @@ int drbd_send_protocol(struct drbd_conf *mdev)
|
|||
p->after_sb_0p = cpu_to_be32(mdev->net_conf->after_sb_0p);
|
||||
p->after_sb_1p = cpu_to_be32(mdev->net_conf->after_sb_1p);
|
||||
p->after_sb_2p = cpu_to_be32(mdev->net_conf->after_sb_2p);
|
||||
p->want_lose = cpu_to_be32(mdev->net_conf->want_lose);
|
||||
p->two_primaries = cpu_to_be32(mdev->net_conf->two_primaries);
|
||||
|
||||
cf = 0;
|
||||
if (mdev->net_conf->want_lose)
|
||||
cf |= CF_WANT_LOSE;
|
||||
if (mdev->net_conf->dry_run) {
|
||||
if (mdev->agreed_pro_version >= 92)
|
||||
cf |= CF_DRY_RUN;
|
||||
else {
|
||||
dev_err(DEV, "--dry-run is not supported by peer");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
p->conn_flags = cpu_to_be32(cf);
|
||||
|
||||
if (mdev->agreed_pro_version >= 87)
|
||||
strcpy(p->integrity_alg, mdev->net_conf->integrity_alg);
|
||||
|
||||
|
|
@ -3161,14 +3173,18 @@ void drbd_free_bc(struct drbd_backing_dev *ldev)
|
|||
void drbd_free_sock(struct drbd_conf *mdev)
|
||||
{
|
||||
if (mdev->data.socket) {
|
||||
mutex_lock(&mdev->data.mutex);
|
||||
kernel_sock_shutdown(mdev->data.socket, SHUT_RDWR);
|
||||
sock_release(mdev->data.socket);
|
||||
mdev->data.socket = NULL;
|
||||
mutex_unlock(&mdev->data.mutex);
|
||||
}
|
||||
if (mdev->meta.socket) {
|
||||
mutex_lock(&mdev->meta.mutex);
|
||||
kernel_sock_shutdown(mdev->meta.socket, SHUT_RDWR);
|
||||
sock_release(mdev->meta.socket);
|
||||
mdev->meta.socket = NULL;
|
||||
mutex_unlock(&mdev->meta.mutex);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -285,8 +285,8 @@ int drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
|
|||
}
|
||||
|
||||
if (r == SS_NO_UP_TO_DATE_DISK && force &&
|
||||
(mdev->state.disk == D_INCONSISTENT ||
|
||||
mdev->state.disk == D_OUTDATED)) {
|
||||
(mdev->state.disk < D_UP_TO_DATE &&
|
||||
mdev->state.disk >= D_INCONSISTENT)) {
|
||||
mask.disk = D_MASK;
|
||||
val.disk = D_UP_TO_DATE;
|
||||
forced = 1;
|
||||
|
|
@ -407,7 +407,7 @@ static int drbd_nl_primary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
|
|||
}
|
||||
|
||||
reply->ret_code =
|
||||
drbd_set_role(mdev, R_PRIMARY, primary_args.overwrite_peer);
|
||||
drbd_set_role(mdev, R_PRIMARY, primary_args.primary_force);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -941,6 +941,25 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
|
|||
|
||||
drbd_md_set_sector_offsets(mdev, nbc);
|
||||
|
||||
/* allocate a second IO page if logical_block_size != 512 */
|
||||
logical_block_size = bdev_logical_block_size(nbc->md_bdev);
|
||||
if (logical_block_size == 0)
|
||||
logical_block_size = MD_SECTOR_SIZE;
|
||||
|
||||
if (logical_block_size != MD_SECTOR_SIZE) {
|
||||
if (!mdev->md_io_tmpp) {
|
||||
struct page *page = alloc_page(GFP_NOIO);
|
||||
if (!page)
|
||||
goto force_diskless_dec;
|
||||
|
||||
dev_warn(DEV, "Meta data's bdev logical_block_size = %d != %d\n",
|
||||
logical_block_size, MD_SECTOR_SIZE);
|
||||
dev_warn(DEV, "Workaround engaged (has performance impact).\n");
|
||||
|
||||
mdev->md_io_tmpp = page;
|
||||
}
|
||||
}
|
||||
|
||||
if (!mdev->bitmap) {
|
||||
if (drbd_bm_init(mdev)) {
|
||||
retcode = ERR_NOMEM;
|
||||
|
|
@ -980,25 +999,6 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
|
|||
goto force_diskless_dec;
|
||||
}
|
||||
|
||||
/* allocate a second IO page if logical_block_size != 512 */
|
||||
logical_block_size = bdev_logical_block_size(nbc->md_bdev);
|
||||
if (logical_block_size == 0)
|
||||
logical_block_size = MD_SECTOR_SIZE;
|
||||
|
||||
if (logical_block_size != MD_SECTOR_SIZE) {
|
||||
if (!mdev->md_io_tmpp) {
|
||||
struct page *page = alloc_page(GFP_NOIO);
|
||||
if (!page)
|
||||
goto force_diskless_dec;
|
||||
|
||||
dev_warn(DEV, "Meta data's bdev logical_block_size = %d != %d\n",
|
||||
logical_block_size, MD_SECTOR_SIZE);
|
||||
dev_warn(DEV, "Workaround engaged (has performance impact).\n");
|
||||
|
||||
mdev->md_io_tmpp = page;
|
||||
}
|
||||
}
|
||||
|
||||
/* Reset the "barriers don't work" bits here, then force meta data to
|
||||
* be written, to ensure we determine if barriers are supported. */
|
||||
if (nbc->dc.no_md_flush)
|
||||
|
|
|
|||
|
|
@ -2513,6 +2513,10 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_rol
|
|||
}
|
||||
|
||||
if (hg == -100) {
|
||||
/* FIXME this log message is not correct if we end up here
|
||||
* after an attempted attach on a diskless node.
|
||||
* We just refuse to attach -- well, we drop the "connection"
|
||||
* to that disk, in a way... */
|
||||
dev_alert(DEV, "Split-Brain detected, dropping connection!\n");
|
||||
drbd_khelper(mdev, "split-brain");
|
||||
return C_MASK;
|
||||
|
|
@ -2538,6 +2542,16 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_rol
|
|||
}
|
||||
}
|
||||
|
||||
if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) {
|
||||
if (hg == 0)
|
||||
dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n");
|
||||
else
|
||||
dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.",
|
||||
drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
|
||||
abs(hg) >= 2 ? "full" : "bit-map based");
|
||||
return C_MASK;
|
||||
}
|
||||
|
||||
if (abs(hg) >= 2) {
|
||||
dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
|
||||
if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake"))
|
||||
|
|
@ -2585,7 +2599,7 @@ static int receive_protocol(struct drbd_conf *mdev, struct p_header *h)
|
|||
struct p_protocol *p = (struct p_protocol *)h;
|
||||
int header_size, data_size;
|
||||
int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
|
||||
int p_want_lose, p_two_primaries;
|
||||
int p_want_lose, p_two_primaries, cf;
|
||||
char p_integrity_alg[SHARED_SECRET_MAX] = "";
|
||||
|
||||
header_size = sizeof(*p) - sizeof(*h);
|
||||
|
|
@ -2598,8 +2612,14 @@ static int receive_protocol(struct drbd_conf *mdev, struct p_header *h)
|
|||
p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
|
||||
p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
|
||||
p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
|
||||
p_want_lose = be32_to_cpu(p->want_lose);
|
||||
p_two_primaries = be32_to_cpu(p->two_primaries);
|
||||
cf = be32_to_cpu(p->conn_flags);
|
||||
p_want_lose = cf & CF_WANT_LOSE;
|
||||
|
||||
clear_bit(CONN_DRY_RUN, &mdev->flags);
|
||||
|
||||
if (cf & CF_DRY_RUN)
|
||||
set_bit(CONN_DRY_RUN, &mdev->flags);
|
||||
|
||||
if (p_proto != mdev->net_conf->wire_protocol) {
|
||||
dev_err(DEV, "incompatible communication protocols\n");
|
||||
|
|
@ -3118,13 +3138,16 @@ static int receive_state(struct drbd_conf *mdev, struct p_header *h)
|
|||
|
||||
put_ldev(mdev);
|
||||
if (nconn == C_MASK) {
|
||||
nconn = C_CONNECTED;
|
||||
if (mdev->state.disk == D_NEGOTIATING) {
|
||||
drbd_force_state(mdev, NS(disk, D_DISKLESS));
|
||||
nconn = C_CONNECTED;
|
||||
} else if (peer_state.disk == D_NEGOTIATING) {
|
||||
dev_err(DEV, "Disk attach process on the peer node was aborted.\n");
|
||||
peer_state.disk = D_DISKLESS;
|
||||
real_peer_disk = D_DISKLESS;
|
||||
} else {
|
||||
if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags))
|
||||
return FALSE;
|
||||
D_ASSERT(oconn == C_WF_REPORT_PARAMS);
|
||||
drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
|
||||
return FALSE;
|
||||
|
|
@ -3594,10 +3617,7 @@ static void drbd_disconnect(struct drbd_conf *mdev)
|
|||
|
||||
/* asender does not clean up anything. it must not interfere, either */
|
||||
drbd_thread_stop(&mdev->asender);
|
||||
|
||||
mutex_lock(&mdev->data.mutex);
|
||||
drbd_free_sock(mdev);
|
||||
mutex_unlock(&mdev->data.mutex);
|
||||
|
||||
spin_lock_irq(&mdev->req_lock);
|
||||
_drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
|
||||
|
|
@ -4054,6 +4074,8 @@ static int got_PingAck(struct drbd_conf *mdev, struct p_header *h)
|
|||
{
|
||||
/* restore idle timeout */
|
||||
mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ;
|
||||
if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags))
|
||||
wake_up(&mdev->misc_wait);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -938,7 +938,8 @@ int w_e_end_csum_rs_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel)
|
|||
|
||||
if (eq) {
|
||||
drbd_set_in_sync(mdev, e->sector, e->size);
|
||||
mdev->rs_same_csum++;
|
||||
/* rs_same_csums unit is BM_BLOCK_SIZE */
|
||||
mdev->rs_same_csum += e->size >> BM_BLOCK_SHIFT;
|
||||
ok = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, e);
|
||||
} else {
|
||||
inc_rs_pending(mdev);
|
||||
|
|
@ -1288,6 +1289,14 @@ int drbd_alter_sa(struct drbd_conf *mdev, int na)
|
|||
return retcode;
|
||||
}
|
||||
|
||||
static void ping_peer(struct drbd_conf *mdev)
|
||||
{
|
||||
clear_bit(GOT_PING_ACK, &mdev->flags);
|
||||
request_ping(mdev);
|
||||
wait_event(mdev->misc_wait,
|
||||
test_bit(GOT_PING_ACK, &mdev->flags) || mdev->state.conn < C_CONNECTED);
|
||||
}
|
||||
|
||||
/**
|
||||
* drbd_start_resync() - Start the resync process
|
||||
* @mdev: DRBD device.
|
||||
|
|
@ -1371,7 +1380,6 @@ void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side)
|
|||
_drbd_pause_after(mdev);
|
||||
}
|
||||
write_unlock_irq(&global_state_lock);
|
||||
drbd_state_unlock(mdev);
|
||||
put_ldev(mdev);
|
||||
|
||||
if (r == SS_SUCCESS) {
|
||||
|
|
@ -1382,11 +1390,8 @@ void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side)
|
|||
|
||||
if (mdev->rs_total == 0) {
|
||||
/* Peer still reachable? Beware of failing before-resync-target handlers! */
|
||||
request_ping(mdev);
|
||||
__set_current_state(TASK_INTERRUPTIBLE);
|
||||
schedule_timeout(mdev->net_conf->ping_timeo*HZ/9); /* 9 instead 10 */
|
||||
ping_peer(mdev);
|
||||
drbd_resync_finished(mdev);
|
||||
return;
|
||||
}
|
||||
|
||||
/* ns.conn may already be != mdev->state.conn,
|
||||
|
|
@ -1398,6 +1403,7 @@ void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side)
|
|||
|
||||
drbd_md_sync(mdev);
|
||||
}
|
||||
drbd_state_unlock(mdev);
|
||||
}
|
||||
|
||||
int drbd_worker(struct drbd_thread *thi)
|
||||
|
|
|
|||
|
|
@ -237,6 +237,8 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
|
|||
if (ret)
|
||||
goto fail;
|
||||
|
||||
file_update_time(file);
|
||||
|
||||
transfer_result = lo_do_transfer(lo, WRITE, page, offset,
|
||||
bvec->bv_page, bv_offs, size, IV);
|
||||
copied = size;
|
||||
|
|
|
|||
|
|
@ -341,11 +341,11 @@ static int pcd_wait(struct pcd_unit *cd, int go, int stop, char *fun, char *msg)
|
|||
&& (j++ < PCD_SPIN))
|
||||
udelay(PCD_DELAY);
|
||||
|
||||
if ((r & (IDE_ERR & stop)) || (j >= PCD_SPIN)) {
|
||||
if ((r & (IDE_ERR & stop)) || (j > PCD_SPIN)) {
|
||||
s = read_reg(cd, 7);
|
||||
e = read_reg(cd, 1);
|
||||
p = read_reg(cd, 2);
|
||||
if (j >= PCD_SPIN)
|
||||
if (j > PCD_SPIN)
|
||||
e |= 0x100;
|
||||
if (fun)
|
||||
printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
|
||||
|
|
|
|||
|
|
@ -391,11 +391,11 @@ static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
|
|||
&& (j++ < PF_SPIN))
|
||||
udelay(PF_SPIN_DEL);
|
||||
|
||||
if ((r & (STAT_ERR & stop)) || (j >= PF_SPIN)) {
|
||||
if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
|
||||
s = read_reg(pf, 7);
|
||||
e = read_reg(pf, 1);
|
||||
p = read_reg(pf, 2);
|
||||
if (j >= PF_SPIN)
|
||||
if (j > PF_SPIN)
|
||||
e |= 0x100;
|
||||
if (fun)
|
||||
printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
|
||||
|
|
|
|||
|
|
@ -274,11 +274,11 @@ static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
|
|||
&& (j++ < PT_SPIN))
|
||||
udelay(PT_SPIN_DEL);
|
||||
|
||||
if ((r & (STAT_ERR & stop)) || (j >= PT_SPIN)) {
|
||||
if ((r & (STAT_ERR & stop)) || (j > PT_SPIN)) {
|
||||
s = read_reg(pi, 7);
|
||||
e = read_reg(pi, 1);
|
||||
p = read_reg(pi, 2);
|
||||
if (j >= PT_SPIN)
|
||||
if (j > PT_SPIN)
|
||||
e |= 0x100;
|
||||
if (fun)
|
||||
printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
|
||||
|
|
|
|||
|
|
@ -348,14 +348,13 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
|
|||
set_capacity(vblk->disk, cap);
|
||||
|
||||
/* We can handle whatever the host told us to handle. */
|
||||
blk_queue_max_phys_segments(q, vblk->sg_elems-2);
|
||||
blk_queue_max_hw_segments(q, vblk->sg_elems-2);
|
||||
blk_queue_max_segments(q, vblk->sg_elems-2);
|
||||
|
||||
/* No need to bounce any requests */
|
||||
blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
|
||||
|
||||
/* No real sector limit. */
|
||||
blk_queue_max_sectors(q, -1U);
|
||||
blk_queue_max_hw_sectors(q, -1U);
|
||||
|
||||
/* Host can optionally specify maximum segment size and number of
|
||||
* segments. */
|
||||
|
|
|
|||
Loading…
Reference in a new issue