req_op
if (req_op(req->req) == REQ_OP_READ) {
enum req_op op = req_op(req);
enum req_op op = req_op(req);
switch (req_op(req)) {
if (req_op(req->req) == REQ_OP_FLUSH) {
switch (req_op(req->req)) {
if (req_op(io_req->req) == REQ_OP_DISCARD)
else if (req_op(io_req->req) == REQ_OP_WRITE_ZEROES)
size_t len, enum req_op op)
unsigned long bdev_start_io_acct(struct block_device *bdev, enum req_op op,
void bdev_end_io_acct(struct block_device *bdev, enum req_op op,
inline const char *blk_op_str(enum req_op op)
switch (req_op(rq)) {
switch (req_op(rq)) {
enum req_op op = req_op(rq);
req_op(rq) == REQ_OP_DISCARD ||
req_op(rq) == REQ_OP_SECURE_ERASE)
if (req_op(req) == REQ_OP_DISCARD)
part_stat_inc(req->part, merges[op_stat_group(req_op(req))]);
in_flight[op_is_write(req_op(req))]);
if (req_op(req) != req_op(next))
if (req_op(rq) != bio_op(bio))
part_stat_inc(req->part, merges[op_stat_group(req_op(req))]);
const enum req_op op = req_op(rq);
const int sgrp = op_stat_group(req_op(req));
in_flight[op_is_write(req_op(req))]);
part_stat_local_inc(req->part, in_flight[op_is_write(req_op(req))]);
if (blk_integrity_rq(rq) && req_op(rq) == REQ_OP_WRITE)
} else if (req_op(rq) == REQ_OP_FLUSH) {
const int sgrp = op_stat_group(req_op(req));
blk_rq_pos(req), (__force u32)req_op(req),
blk_op_str(req_op(req)),
if (blk_integrity_rq(req) && req_op(req) == REQ_OP_READ)
if (blk_integrity_rq(req) && req_op(req) == REQ_OP_READ &&
const enum req_op op = req_op(rq);
int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
enum req_op op;
if (req_op(rq) == REQ_OP_FLUSH)
if (req_op(rq) == REQ_OP_WRITE_ZEROES)
if (req_op(rq) == REQ_OP_ZONE_APPEND)
if (req_op(req) == REQ_OP_DISCARD &&
if (req_op(rq) == REQ_OP_DISCARD)
enum req_op op = req_op(rq);
return req_op(rq) == REQ_OP_ZONE_APPEND ||
sector_t sector, enum req_op op)
sector_t sector, enum req_op op)
enum req_op op = ctx->flags & BM_AIO_READ ? REQ_OP_READ : REQ_OP_WRITE;
struct drbd_backing_dev *bdev, sector_t sector, enum req_op op);
static enum req_op wire_flags_to_bio_op(u32 dpf)
switch (req_op(rq)) {
const bool write = op_is_write(req_op(rq));
req_op(rq) != REQ_OP_READ) {
if (req_op(rq) == REQ_OP_WRITE)
switch (req_op(rq)) {
switch (req_op(req)) {
op_is_write(req_op(rq)), pos,
blk_status_t null_handle_memory_backed(struct nullb_cmd *cmd, enum req_op op,
if (!dev->memory_backed && req_op(rq) == REQ_OP_READ) {
blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
sector_t nr_sectors, enum req_op op)
cmd->error = null_process_cmd(cmd, req_op(req), blk_rq_pos(req),
null_handle_cmd(cmd, sector, nr_sectors, req_op(rq));
blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
blk_status_t null_handle_memory_backed(struct nullb_cmd *cmd, enum req_op op,
blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
enum req_op op, sector_t sector, sector_t nr_sectors)
__field_struct(enum req_op, op)
__entry->op = req_op(blk_mq_rq_from_pdu(cmd));
static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op,
blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
switch (req_op(req)) {
if (req_op(req) == REQ_OP_FLUSH) {
switch (req_op(bd->rq)) {
rbd_warn(rbd_dev, "unknown req_op %d", req_op(bd->rq));
if ((req_op(rq) != REQ_OP_DISCARD) && (req_op(rq) != REQ_OP_WRITE_ZEROES))
switch (req_op(rq)) {
(__force u32)req_op(rq),
return ublk_rq_has_data(req) && req_op(req) == REQ_OP_WRITE;
(req_op(req) == REQ_OP_READ || req_op(req) == REQ_OP_DRV_IN);
switch (req_op(req)) {
if (!io->res && req_op(req) == REQ_OP_READ)
if (req_op(req) != REQ_OP_READ && req_op(req) != REQ_OP_WRITE &&
req_op(req) != REQ_OP_DRV_IN)
req_op(req) == REQ_OP_READ))
} else if (req_op(req) != REQ_OP_ZONE_APPEND && buf_addr) {
if (req_op(req) == REQ_OP_ZONE_APPEND)
if (req_op(req) == REQ_OP_ZONE_APPEND)
if ((req_op(req) == REQ_OP_READ || req_op(req) == REQ_OP_DRV_IN) &&
if ((req_op(req) == REQ_OP_WRITE ||
req_op(req) == REQ_OP_ZONE_APPEND) &&
switch (req_op(req)) {
if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED) && op_is_zone_mgmt(req_op(req)))
switch (req_op(req)) {
if (req_op(req) == REQ_OP_ZONE_APPEND)
enum req_op operation;
enum req_op operation)
if (req_op(shadow[j].request) == REQ_OP_FLUSH ||
req_op(shadow[j].request) == REQ_OP_DISCARD ||
req_op(shadow[j].request) == REQ_OP_SECURE_ERASE ||
if (req_op(req) == REQ_OP_SECURE_ERASE && info->feature_secdiscard)
BUG_ON(req_op(req) == REQ_OP_FLUSH || req->cmd_flags & REQ_FUA);
if (req_op(req) == REQ_OP_FLUSH ||
(req_op(req) == REQ_OP_WRITE && (req->cmd_flags & REQ_FUA))) {
if (unlikely(req_op(req) == REQ_OP_DISCARD ||
req_op(req) == REQ_OP_SECURE_ERASE))
if (unlikely(req_op(qd->rq) == REQ_OP_FLUSH && !info->feature_flush))
bool is_append = req_op(rq) == REQ_OP_ZONE_APPEND;
bool is_write = req_op(rq) == REQ_OP_WRITE || is_append;
switch (req_op(rq)) {
pr_err("Unsupported operation %d\n", req_op(rq));
switch (req_op(rq)) {
req_op(rq) == REQ_OP_WRITE ? "" : "append ",
if (req_op(rq) == REQ_OP_ZONE_APPEND)
if (zlo->ordered_zone_append && req_op(rq) == REQ_OP_ZONE_APPEND) {
switch (req_op(bd->rq)) {
const struct sec_req_op *req_op;
ret = ctx->req_op->buf_map(ctx, req);
ctx->req_op->do_transfer(ctx, req);
ret = ctx->req_op->bd_fill(ctx, req);
ctx->req_op->buf_unmap(ctx, req);
ctx->req_op->buf_unmap(ctx, req);
ret = ctx->req_op->bd_send(ctx, req);
ctx->req_op = &sec_skcipher_req_ops;
ctx->req_op = &sec_skcipher_req_ops_v3;
ctx->req_op = &sec_aead_req_ops;
ctx->req_op = &sec_aead_req_ops_v3;
return ctx->req_op->process(ctx, req);
ctx->req_op->buf_unmap(ctx, req);
return ctx->req_op->process(ctx, req);
ctx->req_op->buf_unmap(ctx, req);
ctx->req_op->callback(ctx, req, err);
ctx->req_op->buf_unmap(ctx, req);
ctx->req_op->callback(ctx, req, err);
enum req_op op;
static void use_dmio(struct dm_buffer *b, enum req_op op, sector_t sector,
static void use_bio(struct dm_buffer *b, enum req_op op, sector_t sector,
static void submit_io(struct dm_buffer *b, enum req_op op, unsigned short ioprio,
static int __ebs_rw_bio(struct ebs_c *ec, enum req_op op, struct bio *bio)
static int __ebs_rw_bvec(struct ebs_c *ec, enum req_op op, struct bio_vec *bv,
enum req_op op;
const enum req_op op = opf & REQ_OP_MASK;
const enum req_op op = opf & REQ_OP_MASK;
enum req_op op;
static int rw_header(struct log_c *lc, enum req_op op)
if (req_op(clone) == REQ_OP_DISCARD &&
else if (req_op(clone) == REQ_OP_WRITE_ZEROES &&
unsigned int chunk, enum req_op op)
static int dmz_rdwr_block(struct dmz_dev *dev, enum req_op op,
unsigned int chunk, enum req_op op);
enum req_op op = bio_op(bio);
int sectors, struct page *page, enum req_op op)
enum req_op op;
switch (req_op(req)) {
switch (req_op(req)) {
switch (req_op(req)) {
if (req_op(req) == REQ_OP_READ || req_op(req) == REQ_OP_WRITE)
switch (req_op(req)) {
switch (req_op(bd->rq)) {
enum req_op op, sector_t sector)
switch (req_op(req)) {
req_op(req) == REQ_OP_ZONE_APPEND) {
nvme_req(rq)->start_time = bdev_start_io_acct(disk->part0, req_op(rq),
bdev_end_io_acct(ns->head->disk->part0, req_op(rq),
static inline enum req_op nvme_req_op(struct nvme_command *cmd)
nvmeq->qid, blk_op_str(req_op(req)), req_op(req),
if (req_op(req) == REQ_OP_ZONE_RESET_ALL)
ARRAY_SIZE(req->inline_bvec), req_op(rq));
bio = bio_alloc(NULL, bio_max_segs(req->sg_cnt), req_op(rq),
static inline enum req_op zsa_req_op(u8 zsa)
enum req_op op = zsa_req_op(req->cmd->zms.zsa);
if (req_op(req) == REQ_OP_DISCARD || req_op(req) == REQ_OP_WRITE_ZEROES)
void *buffer, unsigned int buflength, enum req_op op)
!op_is_write(req_op(rq)) &&
enum req_op op = data_direction == DMA_TO_DEVICE ? REQ_OP_DRV_OUT :
enum req_op op, void *buffer, unsigned int bufflen,
switch (req_op(rq)) {
switch (req_op(req)) {
if (op_is_zone_mgmt(req_op(rq)) &&
switch (req_op(rq)) {
unsigned int sector_nr, enum req_op op)
const enum req_op op = opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
const enum req_op dio_op = dio->opf & REQ_OP_MASK;
enum req_op op; /* contains REQ_OP_ */
do_add_page_to_bio(struct bio *bio, int npg, enum req_op op, sector_t isect,
enum req_op op)
enum req_op op)
char *data, enum req_op op);
enum req_op op;
struct zonefs_zone *z, enum req_op op)
int zonefs_inode_zone_mgmt(struct inode *inode, enum req_op op)
enum req_op op),
__field(enum req_op, op)
int zonefs_inode_zone_mgmt(struct inode *inode, enum req_op op);
size_t len, enum req_op op);
static inline enum req_op req_op(const struct request *req)
#define rq_data_dir(rq) (op_is_write(req_op(rq)) ? WRITE : READ)
(op_is_write(req_op(rq)) ? DMA_TO_DEVICE : DMA_FROM_DEVICE)
static inline enum req_op bio_op(const struct bio *bio)
static inline bool op_is_zone_mgmt(enum req_op op)
static inline int op_stat_group(enum req_op op)
extern const char *blk_op_str(enum req_op op);
unsigned long bdev_start_io_acct(struct block_device *bdev, enum req_op op,
void bdev_end_io_acct(struct block_device *bdev, enum req_op op,
int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
enum req_op op = bio_op(bio);
__field(enum req_op, op)
__field(enum req_op, op)
enum req_op mode),
__field_struct(enum req_op, mode)
const enum req_op op = opf & REQ_OP_MASK;