write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/block/blk-mq-sched.h
..
..
@@ -5,22 +5,20 @@
5
5
 #include "blk-mq.h"
6
6
 #include "blk-mq-tag.h"
7
7
 
8
-void blk_mq_sched_free_hctx_data(struct request_queue *q,
9
-				 void (*exit)(struct blk_mq_hw_ctx *));
10
-
11
-void blk_mq_sched_assign_ioc(struct request *rq, struct bio *bio);
8
+void blk_mq_sched_assign_ioc(struct request *rq);
12
9
 
13
10
 void blk_mq_sched_request_inserted(struct request *rq);
14
11
 bool blk_mq_sched_try_merge(struct request_queue *q, struct bio *bio,
15
-				struct request **merged_request);
16
-bool __blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio);
12
+		unsigned int nr_segs, struct request **merged_request);
13
+bool __blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio,
14
+		unsigned int nr_segs);
17
15
 bool blk_mq_sched_try_insert_merge(struct request_queue *q, struct request *rq);
18
16
 void blk_mq_sched_mark_restart_hctx(struct blk_mq_hw_ctx *hctx);
19
17
 void blk_mq_sched_restart(struct blk_mq_hw_ctx *hctx);
20
18
 
21
19
 void blk_mq_sched_insert_request(struct request *rq, bool at_head,
22
20
 				 bool run_queue, bool async);
23
-void blk_mq_sched_insert_requests(struct request_queue *q,
21
+void blk_mq_sched_insert_requests(struct blk_mq_hw_ctx *hctx,
24
22
 				  struct blk_mq_ctx *ctx,
25
23
 				  struct list_head *list, bool run_queue_async);
26
24
 
..
..
@@ -28,14 +26,16 @@
28
26
 
29
27
 int blk_mq_init_sched(struct request_queue *q, struct elevator_type *e);
30
28
 void blk_mq_exit_sched(struct request_queue *q, struct elevator_queue *e);
29
+void blk_mq_sched_free_requests(struct request_queue *q);
31
30
 
32
31
 static inline bool
33
-blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio)
32
+blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio,
33
+		unsigned int nr_segs)
34
34
 {
35
35
 	if (blk_queue_nomerges(q) || !bio_mergeable(bio))
36
36
 		return false;
37
37
 
38
-	return __blk_mq_sched_bio_merge(q, bio);
38
+	return __blk_mq_sched_bio_merge(q, bio, nr_segs);
39
39
 }
40
40
 
41
41
 static inline bool
..
..
@@ -44,27 +44,18 @@
44
44
 {
45
45
 	struct elevator_queue *e = q->elevator;
46
46
 
47
-	if (e && e->type->ops.mq.allow_merge)
48
-		return e->type->ops.mq.allow_merge(q, rq, bio);
47
+	if (e && e->type->ops.allow_merge)
48
+		return e->type->ops.allow_merge(q, rq, bio);
49
49
 
50
50
 	return true;
51
51
 }
52
52
 
53
-static inline void blk_mq_sched_completed_request(struct request *rq)
53
+static inline void blk_mq_sched_completed_request(struct request *rq, u64 now)
54
54
 {
55
55
 	struct elevator_queue *e = rq->q->elevator;
56
56
 
57
-	if (e && e->type->ops.mq.completed_request)
58
-		e->type->ops.mq.completed_request(rq);
59
-}
60
-
61
-static inline void blk_mq_sched_started_request(struct request *rq)
62
-{
63
-	struct request_queue *q = rq->q;
64
-	struct elevator_queue *e = q->elevator;
65
-
66
-	if (e && e->type->ops.mq.started_request)
67
-		e->type->ops.mq.started_request(rq);
57
+	if (e && e->type->ops.completed_request)
58
+		e->type->ops.completed_request(rq, now);
68
59
 }
69
60
 
70
61
 static inline void blk_mq_sched_requeue_request(struct request *rq)
..
..
@@ -72,16 +63,16 @@
72
63
 	struct request_queue *q = rq->q;
73
64
 	struct elevator_queue *e = q->elevator;
74
65
 
75
-	if (e && e->type->ops.mq.requeue_request)
76
-		e->type->ops.mq.requeue_request(rq);
66
+	if ((rq->rq_flags & RQF_ELVPRIV) && e && e->type->ops.requeue_request)
67
+		e->type->ops.requeue_request(rq);
77
68
 }
78
69
 
79
70
 static inline bool blk_mq_sched_has_work(struct blk_mq_hw_ctx *hctx)
80
71
 {
81
72
 	struct elevator_queue *e = hctx->queue->elevator;
82
73
 
83
-	if (e && e->type->ops.mq.has_work)
84
-		return e->type->ops.mq.has_work(hctx);
74
+	if (e && e->type->ops.has_work)
75
+		return e->type->ops.has_work(hctx);
85
76
 
86
77
 	return false;
87
78
 }