mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 03:27:44 -04:00
Merge branch 'for-2.6.39/core' of git://git.kernel.dk/linux-2.6-block
* 'for-2.6.39/core' of git://git.kernel.dk/linux-2.6-block: (65 commits)
Documentation/iostats.txt: bit-size reference etc.
cfq-iosched: removing unnecessary think time checking
cfq-iosched: Don't clear queue stats when preempt.
blk-throttle: Reset group slice when limits are changed
blk-cgroup: Only give unaccounted_time under debug
cfq-iosched: Don't set active queue in preempt
block: fix non-atomic access to genhd inflight structures
block: attempt to merge with existing requests on plug flush
block: NULL dereference on error path in __blkdev_get()
cfq-iosched: Don't update group weights when on service tree
fs: assign sb->s_bdi to default_backing_dev_info if the bdi is going away
block: Require subsystems to explicitly allocate bio_set integrity mempool
jbd2: finish conversion from WRITE_SYNC_PLUG to WRITE_SYNC and explicit plugging
jbd: finish conversion from WRITE_SYNC_PLUG to WRITE_SYNC and explicit plugging
fs: make fsync_buffers_list() plug
mm: make generic_writepages() use plugging
blk-cgroup: Add unaccounted time to timeslice_used.
block: fixup plugging stubs for !CONFIG_BLOCK
block: remove obsolete comments for blkdev_issue_zeroout.
blktrace: Use rq->cmd_flags directly in blk_add_trace_rq.
...
Fix up conflicts in fs/{aio.c,super.c}
This commit is contained in:
Linus Torvalds
commit
6c51038900
172 changed files with 1520 additions and 2112 deletions
|
|
@ -140,13 +140,14 @@ static int DAC960_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int DAC960_media_changed(struct gendisk *disk)
|
||||
static unsigned int DAC960_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
DAC960_Controller_T *p = disk->queue->queuedata;
|
||||
int drive_nr = (long)disk->private_data;
|
||||
|
||||
if (!p->LogicalDriveInitiallyAccessible[drive_nr])
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -163,7 +164,7 @@ static const struct block_device_operations DAC960_BlockDeviceOperations = {
|
|||
.owner = THIS_MODULE,
|
||||
.open = DAC960_open,
|
||||
.getgeo = DAC960_getgeo,
|
||||
.media_changed = DAC960_media_changed,
|
||||
.check_events = DAC960_check_events,
|
||||
.revalidate_disk = DAC960_revalidate_disk,
|
||||
};
|
||||
|
||||
|
|
@ -2546,6 +2547,7 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
|
|||
disk->major = MajorNumber;
|
||||
disk->first_minor = n << DAC960_MaxPartitionsBits;
|
||||
disk->fops = &DAC960_BlockDeviceOperations;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
/*
|
||||
Indicate the Block Device Registration completed successfully,
|
||||
|
|
|
|||
|
|
@ -1658,12 +1658,12 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
|
|||
}
|
||||
|
||||
/*
|
||||
* floppy-change is never called from an interrupt, so we can relax a bit
|
||||
* check_events is never called from an interrupt, so we can relax a bit
|
||||
* here, sleep etc. Note that floppy-on tries to set current_DOR to point
|
||||
* to the desired drive, but it will probably not survive the sleep if
|
||||
* several floppies are used at the same time: thus the loop.
|
||||
*/
|
||||
static int amiga_floppy_change(struct gendisk *disk)
|
||||
static unsigned amiga_check_events(struct gendisk *disk, unsigned int clearing)
|
||||
{
|
||||
struct amiga_floppy_struct *p = disk->private_data;
|
||||
int drive = p - unit;
|
||||
|
|
@ -1686,7 +1686,7 @@ static int amiga_floppy_change(struct gendisk *disk)
|
|||
p->dirty = 0;
|
||||
writepending = 0; /* if this was true before, too bad! */
|
||||
writefromint = 0;
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1697,7 +1697,7 @@ static const struct block_device_operations floppy_fops = {
|
|||
.release = floppy_release,
|
||||
.ioctl = fd_ioctl,
|
||||
.getgeo = fd_getgeo,
|
||||
.media_changed = amiga_floppy_change,
|
||||
.check_events = amiga_check_events,
|
||||
};
|
||||
|
||||
static int __init fd_probe_drives(void)
|
||||
|
|
@ -1736,6 +1736,7 @@ static int __init fd_probe_drives(void)
|
|||
disk->major = FLOPPY_MAJOR;
|
||||
disk->first_minor = drive;
|
||||
disk->fops = &floppy_fops;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
sprintf(disk->disk_name, "fd%d", drive);
|
||||
disk->private_data = &unit[drive];
|
||||
set_capacity(disk, 880*2);
|
||||
|
|
|
|||
|
|
@ -1324,23 +1324,24 @@ static void finish_fdc_done( int dummy )
|
|||
* due to unrecognised disk changes.
|
||||
*/
|
||||
|
||||
static int check_floppy_change(struct gendisk *disk)
|
||||
static unsigned int floppy_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct atari_floppy_struct *p = disk->private_data;
|
||||
unsigned int drive = p - unit;
|
||||
if (test_bit (drive, &fake_change)) {
|
||||
/* simulated change (e.g. after formatting) */
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
if (test_bit (drive, &changed_floppies)) {
|
||||
/* surely changed (the WP signal changed at least once) */
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
if (UD.wpstat) {
|
||||
/* WP is on -> could be changed: to be sure, buffers should be
|
||||
* invalidated...
|
||||
*/
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -1570,7 +1571,7 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode,
|
|||
* or the next access will revalidate - and clear UDT :-(
|
||||
*/
|
||||
|
||||
if (check_floppy_change(disk))
|
||||
if (floppy_check_events(disk, 0))
|
||||
floppy_revalidate(disk);
|
||||
|
||||
if (UD.flags & FTD_MSG)
|
||||
|
|
@ -1904,7 +1905,7 @@ static const struct block_device_operations floppy_fops = {
|
|||
.open = floppy_unlocked_open,
|
||||
.release = floppy_release,
|
||||
.ioctl = fd_ioctl,
|
||||
.media_changed = check_floppy_change,
|
||||
.check_events = floppy_check_events,
|
||||
.revalidate_disk= floppy_revalidate,
|
||||
};
|
||||
|
||||
|
|
@ -1963,6 +1964,7 @@ static int __init atari_floppy_init (void)
|
|||
unit[i].disk->first_minor = i;
|
||||
sprintf(unit[i].disk->disk_name, "fd%d", i);
|
||||
unit[i].disk->fops = &floppy_fops;
|
||||
unit[i].disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
unit[i].disk->private_data = &unit[i];
|
||||
unit[i].disk->queue = blk_init_queue(do_fd_request,
|
||||
&ataflop_lock);
|
||||
|
|
|
|||
|
|
@ -3170,12 +3170,6 @@ static void do_cciss_request(struct request_queue *q)
|
|||
int sg_index = 0;
|
||||
int chained = 0;
|
||||
|
||||
/* We call start_io here in case there is a command waiting on the
|
||||
* queue that has not been sent.
|
||||
*/
|
||||
if (blk_queue_plugged(q))
|
||||
goto startio;
|
||||
|
||||
queue:
|
||||
creq = blk_peek_request(q);
|
||||
if (!creq)
|
||||
|
|
|
|||
|
|
@ -911,9 +911,6 @@ static void do_ida_request(struct request_queue *q)
|
|||
struct scatterlist tmp_sg[SG_MAX];
|
||||
int i, dir, seg;
|
||||
|
||||
if (blk_queue_plugged(q))
|
||||
goto startio;
|
||||
|
||||
queue_next:
|
||||
creq = blk_peek_request(q);
|
||||
if (!creq)
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ static int _drbd_md_sync_page_io(struct drbd_conf *mdev,
|
|||
|
||||
if ((rw & WRITE) && !test_bit(MD_NO_FUA, &mdev->flags))
|
||||
rw |= REQ_FUA;
|
||||
rw |= REQ_UNPLUG | REQ_SYNC;
|
||||
rw |= REQ_SYNC;
|
||||
|
||||
bio = bio_alloc(GFP_NOIO, 1);
|
||||
bio->bi_bdev = bdev->md_bdev;
|
||||
|
|
@ -689,8 +689,6 @@ void drbd_al_to_on_disk_bm(struct drbd_conf *mdev)
|
|||
}
|
||||
}
|
||||
|
||||
drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
|
||||
|
||||
/* always (try to) flush bitmap to stable storage */
|
||||
drbd_md_flush(mdev);
|
||||
|
||||
|
|
|
|||
|
|
@ -840,7 +840,6 @@ static int bm_rw(struct drbd_conf *mdev, int rw) __must_hold(local)
|
|||
for (i = 0; i < num_pages; i++)
|
||||
bm_page_io_async(mdev, b, i, rw);
|
||||
|
||||
drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
|
||||
wait_event(b->bm_io_wait, atomic_read(&b->bm_async_io) == 0);
|
||||
|
||||
if (test_bit(BM_MD_IO_ERROR, &b->bm_flags)) {
|
||||
|
|
|
|||
|
|
@ -377,7 +377,7 @@ union p_header {
|
|||
#define DP_HARDBARRIER 1 /* depricated */
|
||||
#define DP_RW_SYNC 2 /* equals REQ_SYNC */
|
||||
#define DP_MAY_SET_IN_SYNC 4
|
||||
#define DP_UNPLUG 8 /* equals REQ_UNPLUG */
|
||||
#define DP_UNPLUG 8 /* not used anymore */
|
||||
#define DP_FUA 16 /* equals REQ_FUA */
|
||||
#define DP_FLUSH 32 /* equals REQ_FLUSH */
|
||||
#define DP_DISCARD 64 /* equals REQ_DISCARD */
|
||||
|
|
@ -2382,20 +2382,6 @@ static inline int drbd_queue_order_type(struct drbd_conf *mdev)
|
|||
return QUEUE_ORDERED_NONE;
|
||||
}
|
||||
|
||||
static inline void drbd_blk_run_queue(struct request_queue *q)
|
||||
{
|
||||
if (q && q->unplug_fn)
|
||||
q->unplug_fn(q);
|
||||
}
|
||||
|
||||
static inline void drbd_kick_lo(struct drbd_conf *mdev)
|
||||
{
|
||||
if (get_ldev(mdev)) {
|
||||
drbd_blk_run_queue(bdev_get_queue(mdev->ldev->backing_bdev));
|
||||
put_ldev(mdev);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void drbd_md_flush(struct drbd_conf *mdev)
|
||||
{
|
||||
int r;
|
||||
|
|
|
|||
|
|
@ -2477,12 +2477,11 @@ static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
|
|||
{
|
||||
if (mdev->agreed_pro_version >= 95)
|
||||
return (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
|
||||
(bi_rw & REQ_UNPLUG ? DP_UNPLUG : 0) |
|
||||
(bi_rw & REQ_FUA ? DP_FUA : 0) |
|
||||
(bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
|
||||
(bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
|
||||
else
|
||||
return bi_rw & (REQ_SYNC | REQ_UNPLUG) ? DP_RW_SYNC : 0;
|
||||
return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
|
||||
}
|
||||
|
||||
/* Used to send write requests
|
||||
|
|
@ -2719,35 +2718,6 @@ static int drbd_release(struct gendisk *gd, fmode_t mode)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void drbd_unplug_fn(struct request_queue *q)
|
||||
{
|
||||
struct drbd_conf *mdev = q->queuedata;
|
||||
|
||||
/* unplug FIRST */
|
||||
spin_lock_irq(q->queue_lock);
|
||||
blk_remove_plug(q);
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
|
||||
/* only if connected */
|
||||
spin_lock_irq(&mdev->req_lock);
|
||||
if (mdev->state.pdsk >= D_INCONSISTENT && mdev->state.conn >= C_CONNECTED) {
|
||||
D_ASSERT(mdev->state.role == R_PRIMARY);
|
||||
if (test_and_clear_bit(UNPLUG_REMOTE, &mdev->flags)) {
|
||||
/* add to the data.work queue,
|
||||
* unless already queued.
|
||||
* XXX this might be a good addition to drbd_queue_work
|
||||
* anyways, to detect "double queuing" ... */
|
||||
if (list_empty(&mdev->unplug_work.list))
|
||||
drbd_queue_work(&mdev->data.work,
|
||||
&mdev->unplug_work);
|
||||
}
|
||||
}
|
||||
spin_unlock_irq(&mdev->req_lock);
|
||||
|
||||
if (mdev->state.disk >= D_INCONSISTENT)
|
||||
drbd_kick_lo(mdev);
|
||||
}
|
||||
|
||||
static void drbd_set_defaults(struct drbd_conf *mdev)
|
||||
{
|
||||
/* This way we get a compile error when sync_conf grows,
|
||||
|
|
@ -3222,9 +3192,7 @@ struct drbd_conf *drbd_new_device(unsigned int minor)
|
|||
blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
|
||||
blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
|
||||
blk_queue_merge_bvec(q, drbd_merge_bvec);
|
||||
q->queue_lock = &mdev->req_lock; /* needed since we use */
|
||||
/* plugging on a queue, that actually has no requests! */
|
||||
q->unplug_fn = drbd_unplug_fn;
|
||||
q->queue_lock = &mdev->req_lock;
|
||||
|
||||
mdev->md_io_page = alloc_page(GFP_KERNEL);
|
||||
if (!mdev->md_io_page)
|
||||
|
|
|
|||
|
|
@ -187,15 +187,6 @@ static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/* kick lower level device, if we have more than (arbitrary number)
|
||||
* reference counts on it, which typically are locally submitted io
|
||||
* requests. don't use unacked_cnt, so we speed up proto A and B, too. */
|
||||
static void maybe_kick_lo(struct drbd_conf *mdev)
|
||||
{
|
||||
if (atomic_read(&mdev->local_cnt) >= mdev->net_conf->unplug_watermark)
|
||||
drbd_kick_lo(mdev);
|
||||
}
|
||||
|
||||
static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed)
|
||||
{
|
||||
struct drbd_epoch_entry *e;
|
||||
|
|
@ -219,7 +210,6 @@ static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
|
|||
LIST_HEAD(reclaimed);
|
||||
struct drbd_epoch_entry *e, *t;
|
||||
|
||||
maybe_kick_lo(mdev);
|
||||
spin_lock_irq(&mdev->req_lock);
|
||||
reclaim_net_ee(mdev, &reclaimed);
|
||||
spin_unlock_irq(&mdev->req_lock);
|
||||
|
|
@ -436,8 +426,7 @@ void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
|
|||
while (!list_empty(head)) {
|
||||
prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
|
||||
spin_unlock_irq(&mdev->req_lock);
|
||||
drbd_kick_lo(mdev);
|
||||
schedule();
|
||||
io_schedule();
|
||||
finish_wait(&mdev->ee_wait, &wait);
|
||||
spin_lock_irq(&mdev->req_lock);
|
||||
}
|
||||
|
|
@ -1111,8 +1100,6 @@ next_bio:
|
|||
/* > e->sector, unless this is the first bio */
|
||||
bio->bi_sector = sector;
|
||||
bio->bi_bdev = mdev->ldev->backing_bdev;
|
||||
/* we special case some flags in the multi-bio case, see below
|
||||
* (REQ_UNPLUG) */
|
||||
bio->bi_rw = rw;
|
||||
bio->bi_private = e;
|
||||
bio->bi_end_io = drbd_endio_sec;
|
||||
|
|
@ -1141,13 +1128,8 @@ next_bio:
|
|||
bios = bios->bi_next;
|
||||
bio->bi_next = NULL;
|
||||
|
||||
/* strip off REQ_UNPLUG unless it is the last bio */
|
||||
if (bios)
|
||||
bio->bi_rw &= ~REQ_UNPLUG;
|
||||
|
||||
drbd_generic_make_request(mdev, fault_type, bio);
|
||||
} while (bios);
|
||||
maybe_kick_lo(mdev);
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
|
|
@ -1167,9 +1149,6 @@ static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsign
|
|||
|
||||
inc_unacked(mdev);
|
||||
|
||||
if (mdev->net_conf->wire_protocol != DRBD_PROT_C)
|
||||
drbd_kick_lo(mdev);
|
||||
|
||||
mdev->current_epoch->barrier_nr = p->barrier;
|
||||
rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
|
||||
|
||||
|
|
@ -1636,12 +1615,11 @@ static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
|
|||
{
|
||||
if (mdev->agreed_pro_version >= 95)
|
||||
return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
|
||||
(dpf & DP_UNPLUG ? REQ_UNPLUG : 0) |
|
||||
(dpf & DP_FUA ? REQ_FUA : 0) |
|
||||
(dpf & DP_FLUSH ? REQ_FUA : 0) |
|
||||
(dpf & DP_DISCARD ? REQ_DISCARD : 0);
|
||||
else
|
||||
return dpf & DP_RW_SYNC ? (REQ_SYNC | REQ_UNPLUG) : 0;
|
||||
return dpf & DP_RW_SYNC ? REQ_SYNC : 0;
|
||||
}
|
||||
|
||||
/* mirrored write */
|
||||
|
|
@ -3556,9 +3534,6 @@ static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned
|
|||
|
||||
static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
|
||||
{
|
||||
if (mdev->state.disk >= D_INCONSISTENT)
|
||||
drbd_kick_lo(mdev);
|
||||
|
||||
/* Make sure we've acked all the TCP data associated
|
||||
* with the data requests being unplugged */
|
||||
drbd_tcp_quickack(mdev->data.socket);
|
||||
|
|
|
|||
|
|
@ -960,10 +960,6 @@ allocate_barrier:
|
|||
bio_endio(req->private_bio, -EIO);
|
||||
}
|
||||
|
||||
/* we need to plug ALWAYS since we possibly need to kick lo_dev.
|
||||
* we plug after submit, so we won't miss an unplug event */
|
||||
drbd_plug_device(mdev);
|
||||
|
||||
return 0;
|
||||
|
||||
fail_conflicting:
|
||||
|
|
|
|||
|
|
@ -792,7 +792,6 @@ int drbd_resync_finished(struct drbd_conf *mdev)
|
|||
* queue (or even the read operations for those packets
|
||||
* is not finished by now). Retry in 100ms. */
|
||||
|
||||
drbd_kick_lo(mdev);
|
||||
__set_current_state(TASK_INTERRUPTIBLE);
|
||||
schedule_timeout(HZ / 10);
|
||||
w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC);
|
||||
|
|
|
|||
|
|
@ -45,24 +45,6 @@ static inline void drbd_generic_make_request(struct drbd_conf *mdev,
|
|||
generic_make_request(bio);
|
||||
}
|
||||
|
||||
static inline void drbd_plug_device(struct drbd_conf *mdev)
|
||||
{
|
||||
struct request_queue *q;
|
||||
q = bdev_get_queue(mdev->this_bdev);
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
|
||||
/* XXX the check on !blk_queue_plugged is redundant,
|
||||
* implicitly checked in blk_plug_device */
|
||||
|
||||
if (!blk_queue_plugged(q)) {
|
||||
blk_plug_device(q);
|
||||
del_timer(&q->unplug_timer);
|
||||
/* unplugging should not happen automatically... */
|
||||
}
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
}
|
||||
|
||||
static inline int drbd_crypto_is_hash(struct crypto_tfm *tfm)
|
||||
{
|
||||
return (crypto_tfm_alg_type(tfm) & CRYPTO_ALG_TYPE_HASH_MASK)
|
||||
|
|
|
|||
|
|
@ -3770,13 +3770,14 @@ out2:
|
|||
/*
|
||||
* Check if the disk has been changed or if a change has been faked.
|
||||
*/
|
||||
static int check_floppy_change(struct gendisk *disk)
|
||||
static unsigned int floppy_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
int drive = (long)disk->private_data;
|
||||
|
||||
if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
|
||||
test_bit(FD_VERIFY_BIT, &UDRS->flags))
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
|
||||
if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
|
||||
lock_fdc(drive, false);
|
||||
|
|
@ -3788,7 +3789,7 @@ static int check_floppy_change(struct gendisk *disk)
|
|||
test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
|
||||
test_bit(drive, &fake_change) ||
|
||||
drive_no_geom(drive))
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -3837,7 +3838,6 @@ static int __floppy_read_block_0(struct block_device *bdev)
|
|||
bio.bi_end_io = floppy_rb0_complete;
|
||||
|
||||
submit_bio(READ, &bio);
|
||||
generic_unplug_device(bdev_get_queue(bdev));
|
||||
process_fd_request();
|
||||
wait_for_completion(&complete);
|
||||
|
||||
|
|
@ -3898,7 +3898,7 @@ static const struct block_device_operations floppy_fops = {
|
|||
.release = floppy_release,
|
||||
.ioctl = fd_ioctl,
|
||||
.getgeo = fd_getgeo,
|
||||
.media_changed = check_floppy_change,
|
||||
.check_events = floppy_check_events,
|
||||
.revalidate_disk = floppy_revalidate,
|
||||
};
|
||||
|
||||
|
|
@ -4205,6 +4205,7 @@ static int __init floppy_init(void)
|
|||
disks[dr]->major = FLOPPY_MAJOR;
|
||||
disks[dr]->first_minor = TOMINOR(dr);
|
||||
disks[dr]->fops = &floppy_fops;
|
||||
disks[dr]->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
sprintf(disks[dr]->disk_name, "fd%d", dr);
|
||||
|
||||
init_timer(&motor_off_timer[dr]);
|
||||
|
|
|
|||
|
|
@ -540,17 +540,6 @@ out:
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* kick off io on the underlying address space
|
||||
*/
|
||||
static void loop_unplug(struct request_queue *q)
|
||||
{
|
||||
struct loop_device *lo = q->queuedata;
|
||||
|
||||
queue_flag_clear_unlocked(QUEUE_FLAG_PLUGGED, q);
|
||||
blk_run_address_space(lo->lo_backing_file->f_mapping);
|
||||
}
|
||||
|
||||
struct switch_request {
|
||||
struct file *file;
|
||||
struct completion wait;
|
||||
|
|
@ -917,7 +906,6 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
|
|||
*/
|
||||
blk_queue_make_request(lo->lo_queue, loop_make_request);
|
||||
lo->lo_queue->queuedata = lo;
|
||||
lo->lo_queue->unplug_fn = loop_unplug;
|
||||
|
||||
if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
|
||||
blk_queue_flush(lo->lo_queue, REQ_FLUSH);
|
||||
|
|
@ -1019,7 +1007,6 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
|
|||
|
||||
kthread_stop(lo->lo_thread);
|
||||
|
||||
lo->lo_queue->unplug_fn = NULL;
|
||||
lo->lo_backing_file = NULL;
|
||||
|
||||
loop_release_xfer(lo);
|
||||
|
|
@ -1636,9 +1623,6 @@ out:
|
|||
|
||||
static void loop_free(struct loop_device *lo)
|
||||
{
|
||||
if (!lo->lo_queue->queue_lock)
|
||||
lo->lo_queue->queue_lock = &lo->lo_queue->__queue_lock;
|
||||
|
||||
blk_cleanup_queue(lo->lo_queue);
|
||||
put_disk(lo->lo_disk);
|
||||
list_del(&lo->lo_list);
|
||||
|
|
|
|||
|
|
@ -172,7 +172,8 @@ module_param_array(drive3, int, NULL, 0);
|
|||
static int pcd_open(struct cdrom_device_info *cdi, int purpose);
|
||||
static void pcd_release(struct cdrom_device_info *cdi);
|
||||
static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
|
||||
static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr);
|
||||
static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
|
||||
unsigned int clearing, int slot_nr);
|
||||
static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
|
||||
static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
|
||||
static int pcd_drive_reset(struct cdrom_device_info *cdi);
|
||||
|
|
@ -257,10 +258,11 @@ static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int pcd_block_media_changed(struct gendisk *disk)
|
||||
static unsigned int pcd_block_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct pcd_unit *cd = disk->private_data;
|
||||
return cdrom_media_changed(&cd->info);
|
||||
return cdrom_check_events(&cd->info, clearing);
|
||||
}
|
||||
|
||||
static const struct block_device_operations pcd_bdops = {
|
||||
|
|
@ -268,14 +270,14 @@ static const struct block_device_operations pcd_bdops = {
|
|||
.open = pcd_block_open,
|
||||
.release = pcd_block_release,
|
||||
.ioctl = pcd_block_ioctl,
|
||||
.media_changed = pcd_block_media_changed,
|
||||
.check_events = pcd_block_check_events,
|
||||
};
|
||||
|
||||
static struct cdrom_device_ops pcd_dops = {
|
||||
.open = pcd_open,
|
||||
.release = pcd_release,
|
||||
.drive_status = pcd_drive_status,
|
||||
.media_changed = pcd_media_changed,
|
||||
.check_events = pcd_check_events,
|
||||
.tray_move = pcd_tray_move,
|
||||
.lock_door = pcd_lock_door,
|
||||
.get_mcn = pcd_get_mcn,
|
||||
|
|
@ -318,6 +320,7 @@ static void pcd_init_units(void)
|
|||
disk->first_minor = unit;
|
||||
strcpy(disk->disk_name, cd->name); /* umm... */
|
||||
disk->fops = &pcd_bdops;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -502,13 +505,14 @@ static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
|
|||
|
||||
#define DBMSG(msg) ((verbose>1)?(msg):NULL)
|
||||
|
||||
static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
|
||||
static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
|
||||
unsigned int clearing, int slot_nr)
|
||||
{
|
||||
struct pcd_unit *cd = cdi->handle;
|
||||
int res = cd->changed;
|
||||
if (res)
|
||||
cd->changed = 0;
|
||||
return res;
|
||||
return res ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
|
||||
|
|
|
|||
|
|
@ -794,7 +794,7 @@ static int pd_release(struct gendisk *p, fmode_t mode)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int pd_check_media(struct gendisk *p)
|
||||
static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
|
||||
{
|
||||
struct pd_unit *disk = p->private_data;
|
||||
int r;
|
||||
|
|
@ -803,7 +803,7 @@ static int pd_check_media(struct gendisk *p)
|
|||
pd_special_command(disk, pd_media_check);
|
||||
r = disk->changed;
|
||||
disk->changed = 0;
|
||||
return r;
|
||||
return r ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static int pd_revalidate(struct gendisk *p)
|
||||
|
|
@ -822,7 +822,7 @@ static const struct block_device_operations pd_fops = {
|
|||
.release = pd_release,
|
||||
.ioctl = pd_ioctl,
|
||||
.getgeo = pd_getgeo,
|
||||
.media_changed = pd_check_media,
|
||||
.check_events = pd_check_events,
|
||||
.revalidate_disk= pd_revalidate
|
||||
};
|
||||
|
||||
|
|
@ -837,6 +837,7 @@ static void pd_probe_drive(struct pd_unit *disk)
|
|||
p->fops = &pd_fops;
|
||||
p->major = major;
|
||||
p->first_minor = (disk - pd) << PD_BITS;
|
||||
p->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
disk->gd = p;
|
||||
p->private_data = disk;
|
||||
p->queue = pd_queue;
|
||||
|
|
|
|||
|
|
@ -243,7 +243,8 @@ static struct pf_unit units[PF_UNITS];
|
|||
static int pf_identify(struct pf_unit *pf);
|
||||
static void pf_lock(struct pf_unit *pf, int func);
|
||||
static void pf_eject(struct pf_unit *pf);
|
||||
static int pf_check_media(struct gendisk *disk);
|
||||
static unsigned int pf_check_events(struct gendisk *disk,
|
||||
unsigned int clearing);
|
||||
|
||||
static char pf_scratch[512]; /* scratch block buffer */
|
||||
|
||||
|
|
@ -270,7 +271,7 @@ static const struct block_device_operations pf_fops = {
|
|||
.release = pf_release,
|
||||
.ioctl = pf_ioctl,
|
||||
.getgeo = pf_getgeo,
|
||||
.media_changed = pf_check_media,
|
||||
.check_events = pf_check_events,
|
||||
};
|
||||
|
||||
static void __init pf_init_units(void)
|
||||
|
|
@ -293,6 +294,7 @@ static void __init pf_init_units(void)
|
|||
disk->first_minor = unit;
|
||||
strcpy(disk->disk_name, pf->name);
|
||||
disk->fops = &pf_fops;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
if (!(*drives[unit])[D_PRT])
|
||||
pf_drive_count++;
|
||||
}
|
||||
|
|
@ -377,9 +379,9 @@ static int pf_release(struct gendisk *disk, fmode_t mode)
|
|||
|
||||
}
|
||||
|
||||
static int pf_check_media(struct gendisk *disk)
|
||||
static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
|
||||
{
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
|
||||
static inline int status_reg(struct pf_unit *pf)
|
||||
|
|
|
|||
|
|
@ -1606,8 +1606,6 @@ static int kcdrwd(void *foobar)
|
|||
min_sleep_time = pkt->sleep_time;
|
||||
}
|
||||
|
||||
generic_unplug_device(bdev_get_queue(pd->bdev));
|
||||
|
||||
VPRINTK("kcdrwd: sleeping\n");
|
||||
residue = schedule_timeout(min_sleep_time);
|
||||
VPRINTK("kcdrwd: wake up\n");
|
||||
|
|
@ -2796,7 +2794,8 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int pkt_media_changed(struct gendisk *disk)
|
||||
static unsigned int pkt_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct pktcdvd_device *pd = disk->private_data;
|
||||
struct gendisk *attached_disk;
|
||||
|
|
@ -2806,9 +2805,9 @@ static int pkt_media_changed(struct gendisk *disk)
|
|||
if (!pd->bdev)
|
||||
return 0;
|
||||
attached_disk = pd->bdev->bd_disk;
|
||||
if (!attached_disk)
|
||||
if (!attached_disk || !attached_disk->fops->check_events)
|
||||
return 0;
|
||||
return attached_disk->fops->media_changed(attached_disk);
|
||||
return attached_disk->fops->check_events(attached_disk, clearing);
|
||||
}
|
||||
|
||||
static const struct block_device_operations pktcdvd_ops = {
|
||||
|
|
@ -2816,7 +2815,7 @@ static const struct block_device_operations pktcdvd_ops = {
|
|||
.open = pkt_open,
|
||||
.release = pkt_close,
|
||||
.ioctl = pkt_ioctl,
|
||||
.media_changed = pkt_media_changed,
|
||||
.check_events = pkt_check_events,
|
||||
};
|
||||
|
||||
static char *pktcdvd_devnode(struct gendisk *gd, mode_t *mode)
|
||||
|
|
@ -2889,6 +2888,10 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
|
|||
if (ret)
|
||||
goto out_new_dev;
|
||||
|
||||
/* inherit events of the host device */
|
||||
disk->events = pd->bdev->bd_disk->events;
|
||||
disk->async_events = pd->bdev->bd_disk->async_events;
|
||||
|
||||
add_disk(disk);
|
||||
|
||||
pkt_sysfs_dev_new(pd);
|
||||
|
|
|
|||
|
|
@ -741,11 +741,12 @@ static int floppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int floppy_check_change(struct gendisk *disk)
|
||||
static unsigned int floppy_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct floppy_state *fs = disk->private_data;
|
||||
|
||||
return fs->ejected;
|
||||
return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static int floppy_revalidate(struct gendisk *disk)
|
||||
|
|
@ -772,7 +773,7 @@ static const struct block_device_operations floppy_fops = {
|
|||
.release = floppy_release,
|
||||
.ioctl = floppy_ioctl,
|
||||
.getgeo = floppy_getgeo,
|
||||
.media_changed = floppy_check_change,
|
||||
.check_events = floppy_check_events,
|
||||
.revalidate_disk = floppy_revalidate,
|
||||
};
|
||||
|
||||
|
|
@ -857,6 +858,7 @@ static int __devinit swim_floppy_init(struct swim_priv *swd)
|
|||
swd->unit[drive].disk->first_minor = drive;
|
||||
sprintf(swd->unit[drive].disk->disk_name, "fd%d", drive);
|
||||
swd->unit[drive].disk->fops = &floppy_fops;
|
||||
swd->unit[drive].disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
swd->unit[drive].disk->private_data = &swd->unit[drive];
|
||||
swd->unit[drive].disk->queue = swd->queue;
|
||||
set_capacity(swd->unit[drive].disk, 2880);
|
||||
|
|
|
|||
|
|
@ -250,7 +250,8 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
|
|||
unsigned int cmd, unsigned long param);
|
||||
static int floppy_open(struct block_device *bdev, fmode_t mode);
|
||||
static int floppy_release(struct gendisk *disk, fmode_t mode);
|
||||
static int floppy_check_change(struct gendisk *disk);
|
||||
static unsigned int floppy_check_events(struct gendisk *disk,
|
||||
unsigned int clearing);
|
||||
static int floppy_revalidate(struct gendisk *disk);
|
||||
|
||||
static bool swim3_end_request(int err, unsigned int nr_bytes)
|
||||
|
|
@ -975,10 +976,11 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int floppy_check_change(struct gendisk *disk)
|
||||
static unsigned int floppy_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct floppy_state *fs = disk->private_data;
|
||||
return fs->ejected;
|
||||
return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static int floppy_revalidate(struct gendisk *disk)
|
||||
|
|
@ -1025,7 +1027,7 @@ static const struct block_device_operations floppy_fops = {
|
|||
.open = floppy_unlocked_open,
|
||||
.release = floppy_release,
|
||||
.ioctl = floppy_ioctl,
|
||||
.media_changed = floppy_check_change,
|
||||
.check_events = floppy_check_events,
|
||||
.revalidate_disk= floppy_revalidate,
|
||||
};
|
||||
|
||||
|
|
@ -1161,6 +1163,7 @@ static int __devinit swim3_attach(struct macio_dev *mdev, const struct of_device
|
|||
disk->major = FLOPPY_MAJOR;
|
||||
disk->first_minor = i;
|
||||
disk->fops = &floppy_fops;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
disk->private_data = &floppy_states[i];
|
||||
disk->queue = swim3_queue;
|
||||
disk->flags |= GENHD_FL_REMOVABLE;
|
||||
|
|
|
|||
|
|
@ -1788,7 +1788,8 @@ static int ub_bd_revalidate(struct gendisk *disk)
|
|||
*
|
||||
* The return code is bool!
|
||||
*/
|
||||
static int ub_bd_media_changed(struct gendisk *disk)
|
||||
static unsigned int ub_bd_check_events(struct gendisk *disk,
|
||||
unsigned int clearing)
|
||||
{
|
||||
struct ub_lun *lun = disk->private_data;
|
||||
|
||||
|
|
@ -1806,10 +1807,10 @@ static int ub_bd_media_changed(struct gendisk *disk)
|
|||
*/
|
||||
if (ub_sync_tur(lun->udev, lun) != 0) {
|
||||
lun->changed = 1;
|
||||
return 1;
|
||||
return DISK_EVENT_MEDIA_CHANGE;
|
||||
}
|
||||
|
||||
return lun->changed;
|
||||
return lun->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static const struct block_device_operations ub_bd_fops = {
|
||||
|
|
@ -1817,7 +1818,7 @@ static const struct block_device_operations ub_bd_fops = {
|
|||
.open = ub_bd_unlocked_open,
|
||||
.release = ub_bd_release,
|
||||
.ioctl = ub_bd_ioctl,
|
||||
.media_changed = ub_bd_media_changed,
|
||||
.check_events = ub_bd_check_events,
|
||||
.revalidate_disk = ub_bd_revalidate,
|
||||
};
|
||||
|
||||
|
|
@ -2333,6 +2334,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
|
|||
disk->major = UB_MAJOR;
|
||||
disk->first_minor = lun->id * UB_PARTS_PER_LUN;
|
||||
disk->fops = &ub_bd_fops;
|
||||
disk->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
disk->private_data = lun;
|
||||
disk->driverfs_dev = &sc->intf->dev;
|
||||
|
||||
|
|
|
|||
|
|
@ -241,8 +241,7 @@ static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
|
|||
*
|
||||
* Whenever IO on the active page completes, the Ready page is activated
|
||||
* and the ex-Active page is clean out and made Ready.
|
||||
* Otherwise the Ready page is only activated when it becomes full, or
|
||||
* when mm_unplug_device is called via the unplug_io_fn.
|
||||
* Otherwise the Ready page is only activated when it becomes full.
|
||||
*
|
||||
* If a request arrives while both pages a full, it is queued, and b_rdev is
|
||||
* overloaded to record whether it was a read or a write.
|
||||
|
|
@ -333,17 +332,6 @@ static inline void reset_page(struct mm_page *page)
|
|||
page->biotail = &page->bio;
|
||||
}
|
||||
|
||||
static void mm_unplug_device(struct request_queue *q)
|
||||
{
|
||||
struct cardinfo *card = q->queuedata;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&card->lock, flags);
|
||||
if (blk_remove_plug(q))
|
||||
activate(card);
|
||||
spin_unlock_irqrestore(&card->lock, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
* If there is room on Ready page, take
|
||||
* one bh off list and add it.
|
||||
|
|
@ -535,7 +523,6 @@ static int mm_make_request(struct request_queue *q, struct bio *bio)
|
|||
*card->biotail = bio;
|
||||
bio->bi_next = NULL;
|
||||
card->biotail = &bio->bi_next;
|
||||
blk_plug_device(q);
|
||||
spin_unlock_irq(&card->lock);
|
||||
|
||||
return 0;
|
||||
|
|
@ -779,20 +766,10 @@ static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Future support for removable devices
|
||||
*/
|
||||
static int mm_check_change(struct gendisk *disk)
|
||||
{
|
||||
/* struct cardinfo *dev = disk->private_data; */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct block_device_operations mm_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.getgeo = mm_getgeo,
|
||||
.revalidate_disk = mm_revalidate,
|
||||
.media_changed = mm_check_change,
|
||||
};
|
||||
|
||||
static int __devinit mm_pci_probe(struct pci_dev *dev,
|
||||
|
|
@ -907,7 +884,6 @@ static int __devinit mm_pci_probe(struct pci_dev *dev,
|
|||
blk_queue_make_request(card->queue, mm_make_request);
|
||||
card->queue->queue_lock = &card->lock;
|
||||
card->queue->queuedata = card;
|
||||
card->queue->unplug_fn = mm_unplug_device;
|
||||
|
||||
tasklet_init(&card->tasklet, process_page, (unsigned long)card);
|
||||
|
||||
|
|
|
|||
|
|
@ -867,12 +867,12 @@ static void ace_request(struct request_queue * q)
|
|||
}
|
||||
}
|
||||
|
||||
static int ace_media_changed(struct gendisk *gd)
|
||||
static unsigned int ace_check_events(struct gendisk *gd, unsigned int clearing)
|
||||
{
|
||||
struct ace_device *ace = gd->private_data;
|
||||
dev_dbg(ace->dev, "ace_media_changed(): %i\n", ace->media_change);
|
||||
dev_dbg(ace->dev, "ace_check_events(): %i\n", ace->media_change);
|
||||
|
||||
return ace->media_change;
|
||||
return ace->media_change ? DISK_EVENT_MEDIA_CHANGE : 0;
|
||||
}
|
||||
|
||||
static int ace_revalidate_disk(struct gendisk *gd)
|
||||
|
|
@ -953,7 +953,7 @@ static const struct block_device_operations ace_fops = {
|
|||
.owner = THIS_MODULE,
|
||||
.open = ace_open,
|
||||
.release = ace_release,
|
||||
.media_changed = ace_media_changed,
|
||||
.check_events = ace_check_events,
|
||||
.revalidate_disk = ace_revalidate_disk,
|
||||
.getgeo = ace_getgeo,
|
||||
};
|
||||
|
|
@ -1005,6 +1005,7 @@ static int __devinit ace_setup(struct ace_device *ace)
|
|||
ace->gd->major = ace_major;
|
||||
ace->gd->first_minor = ace->id * ACE_NUM_MINORS;
|
||||
ace->gd->fops = &ace_fops;
|
||||
ace->gd->events = DISK_EVENT_MEDIA_CHANGE;
|
||||
ace->gd->queue = ace->queue;
|
||||
ace->gd->private_data = ace;
|
||||
snprintf(ace->gd->disk_name, 32, "xs%c", ace->id + 'a');
|
||||
|
|
|
|||
Loading…
Reference in a new issue