home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / blkdev.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  25.0 KB  |  852 lines
  1. #ifndef _LINUX_BLKDEV_H
  2. #define _LINUX_BLKDEV_H
  3.  
  4. #include <linux/major.h>
  5. #include <linux/genhd.h>
  6. #include <linux/list.h>
  7. #include <linux/timer.h>
  8. #include <linux/workqueue.h>
  9. #include <linux/pagemap.h>
  10. #include <linux/backing-dev.h>
  11. #include <linux/wait.h>
  12. #include <linux/mempool.h>
  13. #include <linux/bio.h>
  14. #include <linux/module.h>
  15. #include <linux/stringify.h>
  16.  
  17. #include <asm/scatterlist.h>
  18.  
  19. struct scsi_ioctl_command;
  20.  
  21. struct request_queue;
  22. typedef struct request_queue request_queue_t;
  23. struct elevator_queue;
  24. typedef struct elevator_queue elevator_t;
  25. struct request_pm_state;
  26. struct blk_trace;
  27.  
  28. #define BLKDEV_MIN_RQ    4
  29. #define BLKDEV_MAX_RQ    128    /* Default maximum */
  30.  
  31. /*
  32.  * This is the per-process anticipatory I/O scheduler state.
  33.  */
  34. struct as_io_context {
  35.     spinlock_t lock;
  36.  
  37.     void (*dtor)(struct as_io_context *aic); /* destructor */
  38.     void (*exit)(struct as_io_context *aic); /* called on task exit */
  39.  
  40.     unsigned long state;
  41.     atomic_t nr_queued; /* queued reads & sync writes */
  42.     atomic_t nr_dispatched; /* number of requests gone to the drivers */
  43.  
  44.     /* IO History tracking */
  45.     /* Thinktime */
  46.     unsigned long last_end_request;
  47.     unsigned long ttime_total;
  48.     unsigned long ttime_samples;
  49.     unsigned long ttime_mean;
  50.     /* Layout pattern */
  51.     unsigned int seek_samples;
  52.     sector_t last_request_pos;
  53.     u64 seek_total;
  54.     sector_t seek_mean;
  55. };
  56.  
  57. struct cfq_queue;
  58. struct cfq_io_context {
  59.     struct rb_node rb_node;
  60.     void *key;
  61.  
  62.     struct cfq_queue *cfqq[2];
  63.  
  64.     struct io_context *ioc;
  65.  
  66.     unsigned long last_end_request;
  67.     sector_t last_request_pos;
  68.      unsigned long last_queue;
  69.  
  70.     unsigned long ttime_total;
  71.     unsigned long ttime_samples;
  72.     unsigned long ttime_mean;
  73.  
  74.     unsigned int seek_samples;
  75.     u64 seek_total;
  76.     sector_t seek_mean;
  77.  
  78.     struct list_head queue_list;
  79.  
  80.     void (*dtor)(struct io_context *); /* destructor */
  81.     void (*exit)(struct io_context *); /* called on task exit */
  82. };
  83.  
  84. /*
  85.  * This is the per-process I/O subsystem state.  It is refcounted and
  86.  * kmalloc'ed. Currently all fields are modified in process io context
  87.  * (apart from the atomic refcount), so require no locking.
  88.  */
  89. struct io_context {
  90.     atomic_t refcount;
  91.     struct task_struct *task;
  92.  
  93.     int (*set_ioprio)(struct io_context *, unsigned int);
  94.  
  95.     /*
  96.      * For request batching
  97.      */
  98.     unsigned long last_waited; /* Time last woken after wait for request */
  99.     int nr_batch_requests;     /* Number of requests left in the batch */
  100.  
  101.     struct as_io_context *aic;
  102.     struct rb_root cic_root;
  103. };
  104.  
  105. void put_io_context(struct io_context *ioc);
  106. void exit_io_context(void);
  107. struct io_context *current_io_context(gfp_t gfp_flags);
  108. struct io_context *get_io_context(gfp_t gfp_flags);
  109. void copy_io_context(struct io_context **pdst, struct io_context **psrc);
  110. void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
  111.  
  112. struct request;
  113. typedef void (rq_end_io_fn)(struct request *, int);
  114.  
  115. struct request_list {
  116.     int count[2];
  117.     int starved[2];
  118.     int elvpriv;
  119.     mempool_t *rq_pool;
  120.     wait_queue_head_t wait[2];
  121. };
  122.  
  123. #define BLK_MAX_CDB    16
  124.  
  125. /*
  126.  * try to put the fields that are referenced together in the same cacheline
  127.  */
  128. struct request {
  129.     struct list_head queuelist;
  130.     struct list_head donelist;
  131.  
  132.     unsigned long flags;        /* see REQ_ bits below */
  133.  
  134.     /* Maintain bio traversal state for part by part I/O submission.
  135.      * hard_* are block layer internals, no driver should touch them!
  136.      */
  137.  
  138.     sector_t sector;        /* next sector to submit */
  139.     unsigned long nr_sectors;    /* no. of sectors left to submit */
  140.     /* no. of sectors left to submit in the current segment */
  141.     unsigned int current_nr_sectors;
  142.  
  143.     sector_t hard_sector;        /* next sector to complete */
  144.     unsigned long hard_nr_sectors;    /* no. of sectors left to complete */
  145.     /* no. of sectors left to complete in the current segment */
  146.     unsigned int hard_cur_sectors;
  147.  
  148.     struct bio *bio;
  149.     struct bio *biotail;
  150.  
  151.     void *elevator_private;
  152.     void *completion_data;
  153.  
  154.     unsigned short ioprio;
  155.  
  156.     int rq_status;    /* should split this into a few status bits */
  157.     struct gendisk *rq_disk;
  158.     int errors;
  159.     unsigned long start_time;
  160.  
  161.     /* Number of scatter-gather DMA addr+len pairs after
  162.      * physical address coalescing is performed.
  163.      */
  164.     unsigned short nr_phys_segments;
  165.  
  166.     /* Number of scatter-gather addr+len pairs after
  167.      * physical and DMA remapping hardware coalescing is performed.
  168.      * This is the number of scatter-gather entries the driver
  169.      * will actually have to deal with after DMA mapping is done.
  170.      */
  171.     unsigned short nr_hw_segments;
  172.  
  173.     int tag;
  174.     char *buffer;
  175.  
  176.     int ref_count;
  177.     request_queue_t *q;
  178.     struct request_list *rl;
  179.  
  180.     struct completion *waiting;
  181.     void *special;
  182.  
  183.     /*
  184.      * when request is used as a packet command carrier
  185.      */
  186.     unsigned int cmd_len;
  187.     unsigned char cmd[BLK_MAX_CDB];
  188.  
  189.     unsigned int data_len;
  190.     void *data;
  191.  
  192.     unsigned int sense_len;
  193.     void *sense;
  194.  
  195.     unsigned int timeout;
  196.     int retries;
  197.  
  198.     /*
  199.      * For Power Management requests
  200.      */
  201.     struct request_pm_state *pm;
  202.  
  203.     /*
  204.      * completion callback. end_io_data should be folded in with waiting
  205.      */
  206.     rq_end_io_fn *end_io;
  207.     void *end_io_data;
  208. };
  209.  
  210. /*
  211.  * first three bits match BIO_RW* bits, important
  212.  */
  213. enum rq_flag_bits {
  214.     __REQ_RW,        /* not set, read. set, write */
  215.     __REQ_FAILFAST,        /* no low level driver retries */
  216.     __REQ_SORTED,        /* elevator knows about this request */
  217.     __REQ_SOFTBARRIER,    /* may not be passed by ioscheduler */
  218.     __REQ_HARDBARRIER,    /* may not be passed by drive either */
  219.     __REQ_FUA,        /* forced unit access */
  220.     __REQ_CMD,        /* is a regular fs rw request */
  221.     __REQ_NOMERGE,        /* don't touch this for merging */
  222.     __REQ_STARTED,        /* drive already may have started this one */
  223.     __REQ_DONTPREP,        /* don't call prep for this one */
  224.     __REQ_QUEUED,        /* uses queueing */
  225.     __REQ_ELVPRIV,        /* elevator private data attached */
  226.     /*
  227.      * for ATA/ATAPI devices
  228.      */
  229.     __REQ_PC,        /* packet command (special) */
  230.     __REQ_BLOCK_PC,        /* queued down pc from block layer */
  231.     __REQ_SENSE,        /* sense retrival */
  232.  
  233.     __REQ_FAILED,        /* set if the request failed */
  234.     __REQ_QUIET,        /* don't worry about errors */
  235.     __REQ_SPECIAL,        /* driver suplied command */
  236.     __REQ_DRIVE_CMD,
  237.     __REQ_DRIVE_TASK,
  238.     __REQ_DRIVE_TASKFILE,
  239.     __REQ_PREEMPT,        /* set for "ide_preempt" requests */
  240.     __REQ_PM_SUSPEND,    /* suspend request */
  241.     __REQ_PM_RESUME,    /* resume request */
  242.     __REQ_PM_SHUTDOWN,    /* shutdown request */
  243.     __REQ_ORDERED_COLOR,    /* is before or after barrier */
  244.     __REQ_NR_BITS,        /* stops here */
  245. };
  246.  
  247. #define REQ_RW        (1 << __REQ_RW)
  248. #define REQ_FAILFAST    (1 << __REQ_FAILFAST)
  249. #define REQ_SORTED    (1 << __REQ_SORTED)
  250. #define REQ_SOFTBARRIER    (1 << __REQ_SOFTBARRIER)
  251. #define REQ_HARDBARRIER    (1 << __REQ_HARDBARRIER)
  252. #define REQ_FUA        (1 << __REQ_FUA)
  253. #define REQ_CMD        (1 << __REQ_CMD)
  254. #define REQ_NOMERGE    (1 << __REQ_NOMERGE)
  255. #define REQ_STARTED    (1 << __REQ_STARTED)
  256. #define REQ_DONTPREP    (1 << __REQ_DONTPREP)
  257. #define REQ_QUEUED    (1 << __REQ_QUEUED)
  258. #define REQ_ELVPRIV    (1 << __REQ_ELVPRIV)
  259. #define REQ_PC        (1 << __REQ_PC)
  260. #define REQ_BLOCK_PC    (1 << __REQ_BLOCK_PC)
  261. #define REQ_SENSE    (1 << __REQ_SENSE)
  262. #define REQ_FAILED    (1 << __REQ_FAILED)
  263. #define REQ_QUIET    (1 << __REQ_QUIET)
  264. #define REQ_SPECIAL    (1 << __REQ_SPECIAL)
  265. #define REQ_DRIVE_CMD    (1 << __REQ_DRIVE_CMD)
  266. #define REQ_DRIVE_TASK    (1 << __REQ_DRIVE_TASK)
  267. #define REQ_DRIVE_TASKFILE    (1 << __REQ_DRIVE_TASKFILE)
  268. #define REQ_PREEMPT    (1 << __REQ_PREEMPT)
  269. #define REQ_PM_SUSPEND    (1 << __REQ_PM_SUSPEND)
  270. #define REQ_PM_RESUME    (1 << __REQ_PM_RESUME)
  271. #define REQ_PM_SHUTDOWN    (1 << __REQ_PM_SHUTDOWN)
  272. #define REQ_ORDERED_COLOR    (1 << __REQ_ORDERED_COLOR)
  273.  
  274. /*
  275.  * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME
  276.  * requests. Some step values could eventually be made generic.
  277.  */
  278. struct request_pm_state
  279. {
  280.     /* PM state machine step value, currently driver specific */
  281.     int    pm_step;
  282.     /* requested PM state value (S1, S2, S3, S4, ...) */
  283.     u32    pm_state;
  284.     void*    data;        /* for driver use */
  285. };
  286.  
  287. #include <linux/elevator.h>
  288.  
  289. typedef int (merge_request_fn) (request_queue_t *, struct request *,
  290.                 struct bio *);
  291. typedef int (merge_requests_fn) (request_queue_t *, struct request *,
  292.                  struct request *);
  293. typedef void (request_fn_proc) (request_queue_t *q);
  294. typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);
  295. typedef int (prep_rq_fn) (request_queue_t *, struct request *);
  296. typedef void (unplug_fn) (request_queue_t *);
  297.  
  298. struct bio_vec;
  299. typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
  300. typedef void (activity_fn) (void *data, int rw);
  301. typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
  302. typedef void (prepare_flush_fn) (request_queue_t *, struct request *);
  303. typedef void (softirq_done_fn)(struct request *);
  304.  
  305. enum blk_queue_state {
  306.     Queue_down,
  307.     Queue_up,
  308. };
  309.  
  310. struct blk_queue_tag {
  311.     struct request **tag_index;    /* map of busy tags */
  312.     unsigned long *tag_map;        /* bit map of free/busy tags */
  313.     struct list_head busy_list;    /* fifo list of busy tags */
  314.     int busy;            /* current depth */
  315.     int max_depth;            /* what we will send to device */
  316.     int real_max_depth;        /* what the array can hold */
  317.     atomic_t refcnt;        /* map can be shared */
  318. };
  319.  
  320. struct request_queue
  321. {
  322.     /*
  323.      * Together with queue_head for cacheline sharing
  324.      */
  325.     struct list_head    queue_head;
  326.     struct request        *last_merge;
  327.     elevator_t        *elevator;
  328.  
  329.     /*
  330.      * the queue request freelist, one for reads and one for writes
  331.      */
  332.     struct request_list    rq;
  333.  
  334.     request_fn_proc        *request_fn;
  335.     merge_request_fn    *back_merge_fn;
  336.     merge_request_fn    *front_merge_fn;
  337.     merge_requests_fn    *merge_requests_fn;
  338.     make_request_fn        *make_request_fn;
  339.     prep_rq_fn        *prep_rq_fn;
  340.     unplug_fn        *unplug_fn;
  341.     merge_bvec_fn        *merge_bvec_fn;
  342.     activity_fn        *activity_fn;
  343.     issue_flush_fn        *issue_flush_fn;
  344.     prepare_flush_fn    *prepare_flush_fn;
  345.     softirq_done_fn        *softirq_done_fn;
  346.  
  347.     /*
  348.      * Dispatch queue sorting
  349.      */
  350.     sector_t        end_sector;
  351.     struct request        *boundary_rq;
  352.  
  353.     /*
  354.      * Auto-unplugging state
  355.      */
  356.     struct timer_list    unplug_timer;
  357.     int            unplug_thresh;    /* After this many requests */
  358.     unsigned long        unplug_delay;    /* After this many jiffies */
  359.     struct work_struct    unplug_work;
  360.  
  361.     struct backing_dev_info    backing_dev_info;
  362.  
  363.     /*
  364.      * The queue owner gets to use this for whatever they like.
  365.      * ll_rw_blk doesn't touch it.
  366.      */
  367.     void            *queuedata;
  368.  
  369.     void            *activity_data;
  370.  
  371.     /*
  372.      * queue needs bounce pages for pages above this limit
  373.      */
  374.     unsigned long        bounce_pfn;
  375.     gfp_t            bounce_gfp;
  376.  
  377.     /*
  378.      * various queue flags, see QUEUE_* below
  379.      */
  380.     unsigned long        queue_flags;
  381.  
  382.     /*
  383.      * protects queue structures from reentrancy. ->__queue_lock should
  384.      * _never_ be used directly, it is queue private. always use
  385.      * ->queue_lock.
  386.      */
  387.     spinlock_t        __queue_lock;
  388.     spinlock_t        *queue_lock;
  389.  
  390.     /*
  391.      * queue kobject
  392.      */
  393.     struct kobject kobj;
  394.  
  395.     /*
  396.      * queue settings
  397.      */
  398.     unsigned long        nr_requests;    /* Max # of requests */
  399.     unsigned int        nr_congestion_on;
  400.     unsigned int        nr_congestion_off;
  401.     unsigned int        nr_batching;
  402.  
  403.     unsigned int        max_sectors;
  404.     unsigned int        max_hw_sectors;
  405.     unsigned short        max_phys_segments;
  406.     unsigned short        max_hw_segments;
  407.     unsigned short        hardsect_size;
  408.     unsigned int        max_segment_size;
  409.  
  410.     unsigned long        seg_boundary_mask;
  411.     unsigned int        dma_alignment;
  412.  
  413.     struct blk_queue_tag    *queue_tags;
  414.  
  415.     unsigned int        nr_sorted;
  416.     unsigned int        in_flight;
  417.  
  418.     /*
  419.      * sg stuff
  420.      */
  421.     unsigned int        sg_timeout;
  422.     unsigned int        sg_reserved_size;
  423.     int            node;
  424.  
  425.     struct blk_trace    *blk_trace;
  426.  
  427.     /*
  428.      * reserved for flush operations
  429.      */
  430.     unsigned int        ordered, next_ordered, ordseq;
  431.     int            orderr, ordcolor;
  432.     struct request        pre_flush_rq, bar_rq, post_flush_rq;
  433.     struct request        *orig_bar_rq;
  434.     unsigned int        bi_size;
  435.  
  436.     struct mutex        sysfs_lock;
  437. };
  438.  
  439. #define RQ_INACTIVE        (-1)
  440. #define RQ_ACTIVE        1
  441. #define RQ_SCSI_BUSY        0xffff
  442. #define RQ_SCSI_DONE        0xfffe
  443. #define RQ_SCSI_DISCONNECTING    0xffe0
  444.  
  445. #define QUEUE_FLAG_CLUSTER    0    /* cluster several segments into 1 */
  446. #define QUEUE_FLAG_QUEUED    1    /* uses generic tag queueing */
  447. #define QUEUE_FLAG_STOPPED    2    /* queue is stopped */
  448. #define    QUEUE_FLAG_READFULL    3    /* write queue has been filled */
  449. #define QUEUE_FLAG_WRITEFULL    4    /* read queue has been filled */
  450. #define QUEUE_FLAG_DEAD        5    /* queue being torn down */
  451. #define QUEUE_FLAG_REENTER    6    /* Re-entrancy avoidance */
  452. #define QUEUE_FLAG_PLUGGED    7    /* queue is plugged */
  453. #define QUEUE_FLAG_ELVSWITCH    8    /* don't use elevator, just do FIFO */
  454.  
  455. enum {
  456.     /*
  457.      * Hardbarrier is supported with one of the following methods.
  458.      *
  459.      * NONE        : hardbarrier unsupported
  460.      * DRAIN    : ordering by draining is enough
  461.      * DRAIN_FLUSH    : ordering by draining w/ pre and post flushes
  462.      * DRAIN_FUA    : ordering by draining w/ pre flush and FUA write
  463.      * TAG        : ordering by tag is enough
  464.      * TAG_FLUSH    : ordering by tag w/ pre and post flushes
  465.      * TAG_FUA    : ordering by tag w/ pre flush and FUA write
  466.      */
  467.     QUEUE_ORDERED_NONE    = 0x00,
  468.     QUEUE_ORDERED_DRAIN    = 0x01,
  469.     QUEUE_ORDERED_TAG    = 0x02,
  470.  
  471.     QUEUE_ORDERED_PREFLUSH    = 0x10,
  472.     QUEUE_ORDERED_POSTFLUSH    = 0x20,
  473.     QUEUE_ORDERED_FUA    = 0x40,
  474.  
  475.     QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
  476.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
  477.     QUEUE_ORDERED_DRAIN_FUA    = QUEUE_ORDERED_DRAIN |
  478.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
  479.     QUEUE_ORDERED_TAG_FLUSH    = QUEUE_ORDERED_TAG |
  480.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH,
  481.     QUEUE_ORDERED_TAG_FUA    = QUEUE_ORDERED_TAG |
  482.             QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_FUA,
  483.  
  484.     /*
  485.      * Ordered operation sequence
  486.      */
  487.     QUEUE_ORDSEQ_STARTED    = 0x01,    /* flushing in progress */
  488.     QUEUE_ORDSEQ_DRAIN    = 0x02,    /* waiting for the queue to be drained */
  489.     QUEUE_ORDSEQ_PREFLUSH    = 0x04,    /* pre-flushing in progress */
  490.     QUEUE_ORDSEQ_BAR    = 0x08,    /* original barrier req in progress */
  491.     QUEUE_ORDSEQ_POSTFLUSH    = 0x10,    /* post-flushing in progress */
  492.     QUEUE_ORDSEQ_DONE    = 0x20,
  493. };
  494.  
  495. #define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
  496. #define blk_queue_tagged(q)    test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
  497. #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
  498. #define blk_queue_flushing(q)    ((q)->ordseq)
  499.  
  500. #define blk_fs_request(rq)    ((rq)->flags & REQ_CMD)
  501. #define blk_pc_request(rq)    ((rq)->flags & REQ_BLOCK_PC)
  502. #define blk_noretry_request(rq)    ((rq)->flags & REQ_FAILFAST)
  503. #define blk_rq_started(rq)    ((rq)->flags & REQ_STARTED)
  504.  
  505. #define blk_account_rq(rq)    (blk_rq_started(rq) && blk_fs_request(rq))
  506.  
  507. #define blk_pm_suspend_request(rq)    ((rq)->flags & REQ_PM_SUSPEND)
  508. #define blk_pm_resume_request(rq)    ((rq)->flags & REQ_PM_RESUME)
  509. #define blk_pm_request(rq)    \
  510.     ((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME))
  511.  
  512. #define blk_sorted_rq(rq)    ((rq)->flags & REQ_SORTED)
  513. #define blk_barrier_rq(rq)    ((rq)->flags & REQ_HARDBARRIER)
  514. #define blk_fua_rq(rq)        ((rq)->flags & REQ_FUA)
  515.  
  516. #define list_entry_rq(ptr)    list_entry((ptr), struct request, queuelist)
  517.  
  518. #define rq_data_dir(rq)        ((rq)->flags & 1)
  519.  
  520. static inline int blk_queue_full(struct request_queue *q, int rw)
  521. {
  522.     if (rw == READ)
  523.         return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  524.     return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  525. }
  526.  
  527. static inline void blk_set_queue_full(struct request_queue *q, int rw)
  528. {
  529.     if (rw == READ)
  530.         set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  531.     else
  532.         set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  533. }
  534.  
  535. static inline void blk_clear_queue_full(struct request_queue *q, int rw)
  536. {
  537.     if (rw == READ)
  538.         clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  539.     else
  540.         clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  541. }
  542.  
  543.  
  544. /*
  545.  * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
  546.  * it already be started by driver.
  547.  */
  548. #define RQ_NOMERGE_FLAGS    \
  549.     (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
  550. #define rq_mergeable(rq)    \
  551.     (!((rq)->flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
  552.  
  553. /*
  554.  * noop, requests are automagically marked as active/inactive by I/O
  555.  * scheduler -- see elv_next_request
  556.  */
  557. #define blk_queue_headactive(q, head_active)
  558.  
  559. /*
  560.  * q->prep_rq_fn return values
  561.  */
  562. #define BLKPREP_OK        0    /* serve it */
  563. #define BLKPREP_KILL        1    /* fatal error, kill */
  564. #define BLKPREP_DEFER        2    /* leave on queue */
  565.  
  566. extern unsigned long blk_max_low_pfn, blk_max_pfn;
  567.  
  568. /*
  569.  * standard bounce addresses:
  570.  *
  571.  * BLK_BOUNCE_HIGH    : bounce all highmem pages
  572.  * BLK_BOUNCE_ANY    : don't bounce anything
  573.  * BLK_BOUNCE_ISA    : bounce pages above ISA DMA boundary
  574.  */
  575. #define BLK_BOUNCE_HIGH        ((u64)blk_max_low_pfn << PAGE_SHIFT)
  576. #define BLK_BOUNCE_ANY        ((u64)blk_max_pfn << PAGE_SHIFT)
  577. #define BLK_BOUNCE_ISA        (ISA_DMA_THRESHOLD)
  578.  
  579. #ifdef CONFIG_MMU
  580. extern int init_emergency_isa_pool(void);
  581. extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
  582. #else
  583. static inline int init_emergency_isa_pool(void)
  584. {
  585.     return 0;
  586. }
  587. static inline void blk_queue_bounce(request_queue_t *q, struct bio **bio)
  588. {
  589. }
  590. #endif /* CONFIG_MMU */
  591.  
  592. #define rq_for_each_bio(_bio, rq)    \
  593.     if ((rq->bio))            \
  594.         for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
  595.  
  596. struct sec_size {
  597.     unsigned block_size;
  598.     unsigned block_size_bits;
  599. };
  600.  
  601. extern int blk_register_queue(struct gendisk *disk);
  602. extern void blk_unregister_queue(struct gendisk *disk);
  603. extern void register_disk(struct gendisk *dev);
  604. extern void generic_make_request(struct bio *bio);
  605. extern void blk_put_request(struct request *);
  606. extern void __blk_put_request(request_queue_t *, struct request *);
  607. extern void blk_end_sync_rq(struct request *rq, int error);
  608. extern struct request *blk_get_request(request_queue_t *, int, gfp_t);
  609. extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
  610. extern void blk_requeue_request(request_queue_t *, struct request *);
  611. extern void blk_plug_device(request_queue_t *);
  612. extern int blk_remove_plug(request_queue_t *);
  613. extern void blk_recount_segments(request_queue_t *, struct bio *);
  614. extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
  615. extern int sg_scsi_ioctl(struct file *, struct request_queue *,
  616.         struct gendisk *, struct scsi_ioctl_command __user *);
  617. extern void blk_start_queue(request_queue_t *q);
  618. extern void blk_stop_queue(request_queue_t *q);
  619. extern void blk_sync_queue(struct request_queue *q);
  620. extern void __blk_stop_queue(request_queue_t *q);
  621. extern void blk_run_queue(request_queue_t *);
  622. extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
  623. extern int blk_rq_map_user(request_queue_t *, struct request *, void __user *, unsigned int);
  624. extern int blk_rq_unmap_user(struct bio *, unsigned int);
  625. extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, gfp_t);
  626. extern int blk_rq_map_user_iov(request_queue_t *, struct request *, struct sg_iovec *, int);
  627. extern int blk_execute_rq(request_queue_t *, struct gendisk *,
  628.               struct request *, int);
  629. extern void blk_execute_rq_nowait(request_queue_t *, struct gendisk *,
  630.                   struct request *, int, rq_end_io_fn *);
  631.  
  632. static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
  633. {
  634.     return bdev->bd_disk->queue;
  635. }
  636.  
  637. static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
  638.                        struct page *page)
  639. {
  640.     if (bdi && bdi->unplug_io_fn)
  641.         bdi->unplug_io_fn(bdi, page);
  642. }
  643.  
  644. static inline void blk_run_address_space(struct address_space *mapping)
  645. {
  646.     if (mapping)
  647.         blk_run_backing_dev(mapping->backing_dev_info, NULL);
  648. }
  649.  
  650. /*
  651.  * end_request() and friends. Must be called with the request queue spinlock
  652.  * acquired. All functions called within end_request() _must_be_ atomic.
  653.  *
  654.  * Several drivers define their own end_request and call
  655.  * end_that_request_first() and end_that_request_last()
  656.  * for parts of the original function. This prevents
  657.  * code duplication in drivers.
  658.  */
  659. extern int end_that_request_first(struct request *, int, int);
  660. extern int end_that_request_chunk(struct request *, int, int);
  661. extern void end_that_request_last(struct request *, int);
  662. extern void end_request(struct request *req, int uptodate);
  663. extern void blk_complete_request(struct request *);
  664.  
  665. static inline int rq_all_done(struct request *rq, unsigned int nr_bytes)
  666. {
  667.     if (blk_fs_request(rq))
  668.         return (nr_bytes >= (rq->hard_nr_sectors << 9));
  669.     else if (blk_pc_request(rq))
  670.         return nr_bytes >= rq->data_len;
  671.  
  672.     return 0;
  673. }
  674.  
  675. /*
  676.  * end_that_request_first/chunk() takes an uptodate argument. we account
  677.  * any value <= as an io error. 0 means -EIO for compatability reasons,
  678.  * any other < 0 value is the direct error type. An uptodate value of
  679.  * 1 indicates successful io completion
  680.  */
  681. #define end_io_error(uptodate)    (unlikely((uptodate) <= 0))
  682.  
  683. static inline void blkdev_dequeue_request(struct request *req)
  684. {
  685.     elv_dequeue_request(req->q, req);
  686. }
  687.  
  688. /*
  689.  * This should be in elevator.h, but that requires pulling in rq and q
  690.  */
  691. static inline void elv_dispatch_add_tail(struct request_queue *q,
  692.                      struct request *rq)
  693. {
  694.     if (q->last_merge == rq)
  695.         q->last_merge = NULL;
  696.     q->nr_sorted--;
  697.  
  698.     q->end_sector = rq_end_sector(rq);
  699.     q->boundary_rq = rq;
  700.     list_add_tail(&rq->queuelist, &q->queue_head);
  701. }
  702.  
  703. /*
  704.  * Access functions for manipulating queue properties
  705.  */
  706. extern request_queue_t *blk_init_queue_node(request_fn_proc *rfn,
  707.                     spinlock_t *lock, int node_id);
  708. extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
  709. extern void blk_cleanup_queue(request_queue_t *);
  710. extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
  711. extern void blk_queue_bounce_limit(request_queue_t *, u64);
  712. extern void blk_queue_max_sectors(request_queue_t *, unsigned int);
  713. extern void blk_queue_max_phys_segments(request_queue_t *, unsigned short);
  714. extern void blk_queue_max_hw_segments(request_queue_t *, unsigned short);
  715. extern void blk_queue_max_segment_size(request_queue_t *, unsigned int);
  716. extern void blk_queue_hardsect_size(request_queue_t *, unsigned short);
  717. extern void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b);
  718. extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
  719. extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
  720. extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
  721. extern void blk_queue_dma_alignment(request_queue_t *, int);
  722. extern void blk_queue_softirq_done(request_queue_t *, softirq_done_fn *);
  723. extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
  724. extern int blk_queue_ordered(request_queue_t *, unsigned, prepare_flush_fn *);
  725. extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
  726. extern int blk_do_ordered(request_queue_t *, struct request **);
  727. extern unsigned blk_ordered_cur_seq(request_queue_t *);
  728. extern unsigned blk_ordered_req_seq(struct request *);
  729. extern void blk_ordered_complete_seq(request_queue_t *, unsigned, int);
  730.  
  731. extern int blk_rq_map_sg(request_queue_t *, struct request *, struct scatterlist *);
  732. extern void blk_dump_rq_flags(struct request *, char *);
  733. extern void generic_unplug_device(request_queue_t *);
  734. extern void __generic_unplug_device(request_queue_t *);
  735. extern long nr_blockdev_pages(void);
  736.  
  737. int blk_get_queue(request_queue_t *);
  738. request_queue_t *blk_alloc_queue(gfp_t);
  739. request_queue_t *blk_alloc_queue_node(gfp_t, int);
  740. extern void blk_put_queue(request_queue_t *);
  741.  
  742. /*
  743.  * tag stuff
  744.  */
  745. #define blk_queue_tag_depth(q)        ((q)->queue_tags->busy)
  746. #define blk_queue_tag_queue(q)        ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
  747. #define blk_rq_tagged(rq)        ((rq)->flags & REQ_QUEUED)
  748. extern int blk_queue_start_tag(request_queue_t *, struct request *);
  749. extern struct request *blk_queue_find_tag(request_queue_t *, int);
  750. extern void blk_queue_end_tag(request_queue_t *, struct request *);
  751. extern int blk_queue_init_tags(request_queue_t *, int, struct blk_queue_tag *);
  752. extern void blk_queue_free_tags(request_queue_t *);
  753. extern int blk_queue_resize_tags(request_queue_t *, int);
  754. extern void blk_queue_invalidate_tags(request_queue_t *);
  755. extern long blk_congestion_wait(int rw, long timeout);
  756.  
  757. extern void blk_rq_bio_prep(request_queue_t *, struct request *, struct bio *);
  758. extern int blkdev_issue_flush(struct block_device *, sector_t *);
  759.  
  760. #define MAX_PHYS_SEGMENTS 128
  761. #define MAX_HW_SEGMENTS 128
  762. #define SAFE_MAX_SECTORS 255
  763. #define BLK_DEF_MAX_SECTORS 1024
  764.  
  765. #define MAX_SEGMENT_SIZE    65536
  766.  
  767. #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
  768.  
  769. static inline int queue_hardsect_size(request_queue_t *q)
  770. {
  771.     int retval = 512;
  772.  
  773.     if (q && q->hardsect_size)
  774.         retval = q->hardsect_size;
  775.  
  776.     return retval;
  777. }
  778.  
  779. static inline int bdev_hardsect_size(struct block_device *bdev)
  780. {
  781.     return queue_hardsect_size(bdev_get_queue(bdev));
  782. }
  783.  
  784. static inline int queue_dma_alignment(request_queue_t *q)
  785. {
  786.     int retval = 511;
  787.  
  788.     if (q && q->dma_alignment)
  789.         retval = q->dma_alignment;
  790.  
  791.     return retval;
  792. }
  793.  
  794. static inline int bdev_dma_aligment(struct block_device *bdev)
  795. {
  796.     return queue_dma_alignment(bdev_get_queue(bdev));
  797. }
  798.  
  799. #define blk_finished_io(nsects)    do { } while (0)
  800. #define blk_started_io(nsects)    do { } while (0)
  801.  
  802. /* assumes size > 256 */
  803. static inline unsigned int blksize_bits(unsigned int size)
  804. {
  805.     unsigned int bits = 8;
  806.     do {
  807.         bits++;
  808.         size >>= 1;
  809.     } while (size > 256);
  810.     return bits;
  811. }
  812.  
  813. static inline unsigned int block_size(struct block_device *bdev)
  814. {
  815.     return bdev->bd_block_size;
  816. }
  817.  
  818. typedef struct {struct page *v;} Sector;
  819.  
  820. unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
  821.  
  822. static inline void put_dev_sector(Sector p)
  823. {
  824.     page_cache_release(p.v);
  825. }
  826.  
  827. struct work_struct;
  828. int kblockd_schedule_work(struct work_struct *work);
  829. void kblockd_flush(void);
  830.  
  831. #ifdef CONFIG_LBD
  832. # include <asm/div64.h>
  833. # define sector_div(a, b) do_div(a, b)
  834. #else
  835. # define sector_div(n, b)( \
  836. { \
  837.     int _res; \
  838.     _res = (n) % (b); \
  839.     (n) /= (b); \
  840.     _res; \
  841. } \
  842. )
  843. #endif 
  844.  
  845. #define MODULE_ALIAS_BLOCKDEV(major,minor) \
  846.     MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
  847. #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
  848.     MODULE_ALIAS("block-major-" __stringify(major) "-*")
  849.  
  850.  
  851. #endif
  852.