blkdev_issue_write_same – queue a write same operation Synopsis int blkdev_issue_write_same(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, struct page *page); Arguments bdev target blockdev sector start sector nr_sects number of sectors to write gfp_mask memory allocation flags (for bio_alloc) page page containing data to write Description Issue a write same request for the sectors…
blkdev_issue_flush – queue a flush Synopsis int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask, sector_t *error_sector); Arguments bdev blockdev to issue flush for gfp_mask memory allocation flags (for bio_alloc) error_sector error sector Description Issue a flush for the block device in question. Caller can supply room for storing the error offset in case of a flush error,…
blkdev_issue_discard – queue a discard Synopsis int blkdev_issue_discard(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, unsigned long flags); Arguments bdev blockdev to issue discard for sector start sector nr_sects number of sectors to discard gfp_mask memory allocation flags (for bio_alloc) flags BLKDEV_IFL_* flags to control behaviour Description Issue a discard request for the sectors…
blkdev_get_by_path – open a block device by name Synopsis struct block_device *blkdev_get_by_path(const char *path, fmode_t mode, void *holder); Arguments path path to the block device to open mode FMODE_* mask holder exclusive holder identifier Description Open the blockdevice described by the device file at path. mode and holder are identical to blkdev_get. On success, the…
blkdev_get_by_dev – open a block device by device number Synopsis struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder); Arguments dev device number of block device to open mode FMODE_* mask holder exclusive holder identifier Description Open the blockdevice described by device number dev. mode and holder are identical to blkdev_get. Use it ONLY if you…
blkdev_get – open a block device Synopsis int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder); Arguments bdev block_device to open mode FMODE_* mask holder exclusive holder identifier Description Open bdev with mode. If mode includes FMODE_EXCL, bdev is open with exclusive access. Specifying FMODE_EXCL with NULLholder is invalid. Exclusive opens may nest for the same…
blk_update_request – Special helper function for request stacking drivers Synopsis bool blk_update_request(struct request * req, int error, unsigned int nr_bytes); Arguments req the request being processed error 0 for success, < 0 for error nr_bytes number of bytes to complete req Description Ends I/O on a number of bytes attached to req, but doesn’t complete the request structure even…
blk_unprep_request – unprepare a request Synopsis void blk_unprep_request(struct request *req); Arguments req the request Description This function makes a request ready for complete resubmission (or completion). It happens only after all error handling is complete, so represents the appropriate moment to deallocate any resources that were allocated to the request in the prep_rq_fn. The queue…
blk_trace_shutdown – stop and cleanup trace structures Synopsis void blk_trace_shutdown(struct request_queue *q); Arguments q the request queue associated with the device Copyright
blk_trace_ioctl – handle the ioctls associated with tracing Synopsis int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg); Arguments bdev the block device cmd the ioctl cmd arg the argument data, if any Copyright
blk_sync_queue – cancel any pending callbacks on a queue Synopsis void blk_sync_queue(struct request_queue *q); Arguments q the queue Description The block layer may perform asynchronous callback activity on a queue, such as calling the unplug function after a timeout. A block device may call blk_sync_queue to ensure that any such activity is cancelled, thus allowing…
blk_stop_queue – stop a queue Synopsis void blk_stop_queue(struct request_queue *q); Arguments q The struct request_queue in question Description The Linux block layer assumes that a block driver will consume all entries on the request queue when the request_fn strategy is called. Often this will not happen, because of hardware limitations (queue depth settings). If a…
blk_start_request – start request processing on the driver Synopsis void blk_start_request(struct request *req); Arguments req request to dequeue Description Dequeue req and start timeout timer on it. This hands off the request to the driver. Block internal functions which don’t want to start timer should call blk_dequeue_request. Context queue_lock must be held. Copyright
blk_start_queue_async – asynchronously restart a previously stopped queue Synopsis void blk_start_queue_async(struct request_queue *q); Arguments q The struct request_queue in question Description blk_start_queue_async will clear the stop flag on the queue, and ensure that the request_fn for the queue is run from an async context. Copyright
blk_start_queue – restart a previously stopped queue Synopsis void blk_start_queue(struct request_queue *q); Arguments q The struct request_queue in question Description blk_start_queue will clear the stop flag on the queue, and call the request_fn for the queue if it was in a stopped state when entered. Also see blk_stop_queue. Queue lock must be held. Copyright
blk_start_plug – initialize blk_plug and track it inside the task_struct Synopsis void blk_start_plug(struct blk_plug *plug); Arguments plug The struct blk_plug that needs to be initialized Description Tracking blk_plug inside the task_struct will help with auto-flushing the pending I/O should the task end up blocking between blk_start_plug and blk_finish_plug. This is important from a performance perspective,…
blk_stack_limits – adjust queue_limits for stacked devices Synopsis int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, sector_t start); Arguments t the stacking driver limits (top device) b the underlying queue limits (bottom, component device) start first data sector within component device Description This function is used by stacking drivers like MD and DM to ensure that…
blk_set_stacking_limits – set default limits for stacking devices Synopsis void blk_set_stacking_limits(struct queue_limits *lim); Arguments lim the queue_limits structure to reset Description Returns a queue_limit struct to its default state. Should be used by stacking drivers like DM that have no internal limits. Copyright
blk_set_runtime_active – Force runtime status of the queue to be active Synopsis void blk_set_runtime_active(struct request_queue *q); Arguments q the queue of the device Description If the device is left runtime suspended during system suspend the resume hook typically resumes the device and corrects runtime status accordingly. However, that does not affect the queue runtime PM…
blk_set_default_limits – reset limits to default values Synopsis void blk_set_default_limits(struct queue_limits *lim); Arguments lim the queue_limits structure to reset Description Returns a queue_limit struct to its default state. Copyright