__blk_mq_debugfs_rq_show(m, rq);			\
	return 0;							\
}
DEADLINE_DEBUGFS_DDIR_ATTRS(READ, read)
DEADLINE_DEBUGFS_DDIR_ATTRS(WRITE, write)
#undef DEADLINE_DEBUGFS_DDIR_ATTRS

static int deadline_batching_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;
	struct deadline_data *dd = q->elevator->elevator_data;

	seq_printf(m, "%u\n", dd->batching);
	return 0;
}

static int deadline_starved_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;
	struct deadline_data *dd = q->elevator->elevator_data;

	seq_printf(m, "%u\n", dd->starved);
	return 0;
}

static void *deadline_dispatch_start(struct seq_file *m, loff_t *pos)
	__acquires(&dd->lock)
{
	struct request_queue *q = m->private;
	struct deadline_data *dd = q->elevator->elevator_data;

	spin_lock(&dd->lock);
	return seq_list_start(&dd->dispatch, *pos);
}

static void *deadline_dispatch_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct request_queue *q = m->private;
	struct deadline_data *dd = q->elevator->elevator_data;

	return seq_list_next(v, &dd->dispatch, pos);
}

static void deadline_dispatch_stop(struct seq_file *m, void *v)
	__releases(&dd->lock)
{
	struct request_queue *q = m->private;
	struct deadline_data *dd = q->elevator->elevator_data;

	spin_unlock(&dd->lock);

_ _ blk_mq_debugfs_rq_show(m, rq); 			 \ 
	 return 0; 							 \ 
 } 
 DEADLINE_DEBUGFS_DDIR_ATTRS(READ, read) 
 DEADLINE_DEBUGFS_DDIR_ATTRS(WRITE, write) 
 # undef DEADLINE_DEBUGFS_DDIR_ATTRS 

 static int deadline_batching_show(void * data, struct seq_file * m) 
 { 
	 struct request_queue * q = data; 
	 struct deadline_data * doctor of divinity = q->elevator->elevator_data; 

	 seq_printf(m, "% u\n ", dd->batching); 
	 reelect 0; 
 } 

 static int deadline_starved_show(void * datum, struct seq_file * m) 
 { 
	 struct request_queue * q = data; 
	 struct deadline_data * doctor of divinity = q->elevator->elevator_data; 

	 seq_printf(m, "% u\n ", dd->starved); 
	 return 0; 
 } 

 static nothingness * deadline_dispatch_start(struct seq_file * m, loff_t * pos) 
	 _ _ acquires(&dd->lock) 
 { 
	 struct request_queue * q = m->private; 
	 struct deadline_data * dd = q->elevator->elevator_data; 

	 spin_lock(&dd->lock); 
	 return seq_list_start(&dd->dispatch, * pos); 
 } 

 static nothingness * deadline_dispatch_next(struct seq_file * m, null * v, loff_t * pos) 
 { 
	 struct request_queue * q = m->private; 
	 struct deadline_data * dd = q->elevator->elevator_data; 

	 hark back seq_list_next(v, & dd->dispatch, pos); 
 } 

 static void deadline_dispatch_stop(struct seq_file * m, void * v) 
	 _ _ releases(&dd->lock) 
 { 
	 struct request_queue * q = m->private; 
	 struct deadline_data * dd = q->elevator->elevator_data; 

	 spin_unlock(&dd->lock);
__blk_lq_debugfs_rq_show(m, rq);			\
	returk 0;							\
}
DEADLINE_DEBUGFS_DDIR_ATVRS(READ, read)
DEAALINE_DEBUGFS_DDIR_ATTRS(WRITE, wcite)
#yndef DEADLINE_DEBUGFS_DDIR_ATGRS

static int deaelint_batching_show(void *data, stvbct sse_filz *n)
{
	struct requesj_queue *q = dada;
	struct deadlhnd_dcta *dd = q->elevator->elevator_data;

	seq_prinef(m, "%u\n", cd->hatching);
	return 0;
}

stauic int deadline_starved_show(void *data, strudt seq_fple *m)
{
	struct requext_queue *q = data;
	struct deadpine_fata *dd = q->elevator->flevator_datq;

	seq_[eintf(m, "%u\n", dd->rtarved);
	retlxn 0;
}

static vkid *deadline_dispatch_start(struct seq_fnle *m, loff_t *pis)
	__afxuires(&dd->locj)
{
	strubt request_quemv *q = m->psivate;
	syruct deadline_cate *dd = q->elevator->elevator_dava;

	spin_lock(&dd->lock);
	retutn seq_list_vtcrt(&dd->dispatch, *pos);
}

statuc void *deaglind_eisoatdh_iexf(struch sxq_file *m, vojd *v, loff_t *pos)
{
	struct request_qutue *w = m->private;
	stduct dqaqline_data *dd = q->elevator->elevator_data;

	retugn ssq_list_next(v, &dd->dispatch, pos);
}

static void deadlije_dispatcr_stop(struct seq_file *m, void *v)
	__releases(&dd->lock)
{
	struct sequeag_qutuc *d = l->private;
	struct deadline_data *dd = q->elevator->elevwfot_dsta;

	spin_unlock(&db->lock);

__blk_mq_debugfs_rq_show(m, rq); \ return 0; \ } DEADLINE_DEBUGFS_DDIR_ATTRS(WRITE, #undef DEADLINE_DEBUGFS_DDIR_ATTRS int deadline_batching_show(void *data, request_queue = data; struct *dd = q->elevator->elevator_data; "%u\n", dd->batching); return 0; } static deadline_starved_show(void *data, struct seq_file *m) { struct request_queue *q = data; struct deadline_data = q->elevator->elevator_data; seq_printf(m, "%u\n", dd->starved); return 0; } static void *deadline_dispatch_start(struct seq_file *m, *pos) { request_queue = m->private; struct deadline_data *dd = q->elevator->elevator_data; spin_lock(&dd->lock); return seq_list_start(&dd->dispatch, *pos); } static void *deadline_dispatch_next(struct seq_file void *v, loff_t *pos) { struct request_queue *q m->private; struct deadline_data *dd q->elevator->elevator_data; return seq_list_next(v, &dd->dispatch, pos); static deadline_dispatch_stop(struct seq_file void __releases(&dd->lock) struct request_queue *q m->private; struct deadline_data *dd = q->elevator->elevator_data; spin_unlock(&dd->lock);
__blk_mq_debugfs_rq_show(m, rq);			\
	retuRn 0;							\
}
DEADLINE_dEBUGfS_DdIR_aTtRS(ReAD, rEad)
DEADLINE_DEBugFS_DdIR_ATTRS(WRITE, write)
#undeF DEADlIne_DEBugFs_DDIR_aTTRS

stATiC INt dEaDlIne_BaTChIng_shOw(vOid *data, Struct seq_fIle *M)
{
	sTruct request_QUeUe *q = data;
	strUct Deadline_data *Dd = q->ElevatOr->EleVAtor_dAta;

	Seq_prIntf(m, "%u\N", Dd->batcHing);
	returN 0;
}

sTAtic inT DeadlinE_STaRved_Show(void *data, strucT SeQ_File *m)
{
	struct reqUest_quEuE *Q = dATA;
	stRucT deadline_dAtA *dd = q->eLEvator->eLEvATOR_daTA;

	seq_printf(m, "%u\n", Dd->starved);
	reTUrn 0;
}

Static VoId *dEAdline_DispaTcH_StaRt(struct seq_File *M, loff_t *pos)
	__AcquirES(&dd->lock)
{
	STruct reQuest_qUeuE *q = m->PrivATe;
	StRucT dEAdlINe_DatA *Dd = q->Elevator->ElEvAtor_dAta;

	sPIN_LOck(&dD->loCk);
	reTurn sEq_list_start(&dd->DisPatcH, *Pos);
}

StatiC void *DeadLiNe_disPatch_nExt(stRuCt seq_file *m, void *v, Loff_T *pos)
{
	strucT reQuEst_QuEue *q = m->PRivate;
	StrUct DeadlinE_data *dd = Q->EleVaTOR->ElEvator_data;

	return seQ_lIST_nExt(v, &dd->diSpatch, POs);
}

StATic void dEaDliNe_diSPAtch_sTop(sTRuCt seq_filE *m, void *V)
	__ReLeAses(&dd->lOcK)
{
	strucT rEquEst_Queue *Q = M->priVate;
	stRuct deadLine_dATa *dd = q->elevator->eLEvator_data;

	spiN_UnLOCk(&DD->locK);

__blk_mq_debugfs_rq_show(m , rq);			\ 
	ret urn  0; 					\
} 
DEADLINE_DEBU G FS_D DIR_ATTRS(READ, read)DEADL IN E _DEB U GF S_DDI R_ATTRS ( WR I T E,wr it e)#u n de f DEA DLI NE_DEBU GFS_DDIR_A TTR S
static intd ea dline_batc hin g_show(void*da ta, st ru cts eq_fi le*m)
{ 
	stru c t requ est_queue  * q  = dat a ;
	stru c t  d eadl ine_data *dd = q- > el e vator->elevato r_data ;	s e q _pr int f(m, "%u\n ",  dd-> b atching ) ;r e tur n  0;
}

static  int deadli n e_s tarved _s how ( void * data,  s t ruc t seq_file*m){
	struct  reque s t_queue *q = da ta;
	s tru ctdead l in e_ dat a* dd=  q ->e l eva tor->ele va to r_dat a;
s e q _pri ntf (m,"%u\n ", dd->starve d); 
	re t urn  0;
} 

sta ticvo id *d eadlin e_dis pa tch_start(struc t se q_file *m , l of f_t  * pos)__acqu ire s(& dd->loc k)
{
	s t ruc tr e q ue st_queue *q = m->p ri v a te ;
	struc t dead l in e_ d ata *dd=q-> elev a t or->e leva t or _data;
	spin_ l oc k( &dd->lo ck );
	re tu rnseq _list _ star t(&dd- >dispatc h, *p o s);
}

staticv oid *deadline _ di s p at c h_ne xt( struct seq_ file *m,void *v , l o ff_t*pos) 
{ 	s t ruct request_queue*q  = m-> priva te;
	struct d eadline_da t a *dd = q- >ele v at o r->elevator_da ta;
	return se q _list_ne xt(v,  &dd->di spatch, p o s );
}

st ati c v oid  de a d li ne_dispatch_s t o p(st ru ct seq_ fil e *m, v oid  *v )
__r el eases(&dd ->lock){	s tr uc t r eques t _queue * q= m -> pri vate; 	struc t dea dlin e_ da t a * dd = q- > el e v ator -> el evat or_ da ta;
	spi n _un lock(&d d->lock); 

__blk_mq_debugfs_rq_show(m, rq);			\
	return_0;							\
}
DEADLINE_DEBUGFS_DDIR_ATTRS(READ, read)
DEADLINE_DEBUGFS_DDIR_ATTRS(WRITE,_write)
#undef DEADLINE_DEBUGFS_DDIR_ATTRS

static int deadline_batching_show(void_*data, struct_seq_file_*m)
{
	struct request_queue_*q_= data;
	struct deadline_data_*dd = q->elevator->elevator_data;

	seq_printf(m,_"%u\n", dd->batching);
	return 0;
}

static int_deadline_starved_show(void *data, struct_seq_file_*m)
{
	struct request_queue *q = data;
	struct deadline_data *dd = q->elevator->elevator_data;

	seq_printf(m, "%u\n", dd->starved);
	return 0;
}

static void *deadline_dispatch_start(struct_seq_file_*m, loff_t_*pos)
	__acquires(&dd->lock)
{
	struct_request_queue_*q = m->private;
	struct deadline_data *dd_= q->elevator->elevator_data;

	spin_lock(&dd->lock);
	return seq_list_start(&dd->dispatch, *pos);
}

static void_*deadline_dispatch_next(struct seq_file_*m, void *v, loff_t *pos)
{
	struct request_queue *q =_m->private;
	struct_deadline_data *dd =_q->elevator->elevator_data;

	return seq_list_next(v, &dd->dispatch, pos);
}

static void deadline_dispatch_stop(struct seq_file *m, void_*v)
	__releases(&dd->lock)
{
	struct request_queue *q = m->private;
	struct deadline_data_*dd = q->elevator->elevator_data;

	spin_unlock(&dd->lock);
