]>
Commit | Line | Data |
---|---|---|
8f69975d BS |
1 | From: Robert Love <robert.w.love@intel.com> |
2 | Subject: use an operations structure for rport callbacks | |
3 | References: bnc #459142 | |
4 | ||
5 | This was called out for the disc callbacks in review | |
6 | comments when submitting to linux-scsi. It needed to be | |
7 | fixed for the rport callbacks too. | |
8 | ||
9 | This patch also fixes some spacing in the fc_rport | |
10 | structure definition as well as renaming the fc_lport_rport_event() | |
11 | function to fc_lport_rport_callback() to more clearly | |
12 | identify what it's doing. | |
13 | ||
14 | Signed-off-by: Robert Love <robert.w.love@intel.com> | |
15 | Acked-by: Bernhard Walle <bwalle@suse.de> | |
16 | --- | |
17 | ||
18 | drivers/scsi/libfc/fc_disc.c | 18 +++++++++----- | |
19 | drivers/scsi/libfc/fc_lport.c | 16 ++++++++----- | |
20 | drivers/scsi/libfc/fc_rport.c | 19 +++++++-------- | |
21 | include/scsi/libfc.h | 51 ++++++++++++++++++++++-------------------- | |
22 | 4 files changed, 57 insertions(+), 47 deletions(-) | |
23 | ||
24 | ||
25 | --- a/drivers/scsi/libfc/fc_disc.c | |
26 | +++ b/drivers/scsi/libfc/fc_disc.c | |
27 | @@ -154,7 +154,7 @@ void fc_disc_stop_rports(struct fc_disc | |
28 | } | |
29 | ||
30 | /** | |
31 | - * fc_disc_rport_event - Event handler for rport events | |
32 | + * fc_disc_rport_callback - Event handler for rport events | |
33 | * @lport: The lport which is receiving the event | |
34 | * @rport: The rport which the event has occured on | |
35 | * @event: The event that occured | |
36 | @@ -162,9 +162,9 @@ void fc_disc_stop_rports(struct fc_disc | |
37 | * Locking Note: The rport lock should not be held when calling | |
38 | * this function. | |
39 | */ | |
40 | -static void fc_disc_rport_event(struct fc_lport *lport, | |
41 | - struct fc_rport *rport, | |
42 | - enum fc_lport_event event) | |
43 | +static void fc_disc_rport_callback(struct fc_lport *lport, | |
44 | + struct fc_rport *rport, | |
45 | + enum fc_rport_event event) | |
46 | { | |
47 | struct fc_rport_libfc_priv *rdata = rport->dd_data; | |
48 | struct fc_disc *disc = lport->disc; | |
49 | @@ -420,6 +420,10 @@ static void fc_disc_start(void (*disc_ca | |
50 | mutex_unlock(&disc->disc_mutex); | |
51 | } | |
52 | ||
53 | +static struct fc_rport_operations fc_disc_rport_ops = { | |
54 | + .event_callback = fc_disc_rport_callback, | |
55 | +}; | |
56 | + | |
57 | /** | |
58 | * fc_disc_new_target - Handle new target found by discovery | |
59 | * @lport: FC local port | |
60 | @@ -475,7 +479,7 @@ static int fc_disc_new_target(struct fc_ | |
61 | } | |
62 | if (rport) { | |
63 | rp = rport->dd_data; | |
64 | - rp->event_callback = fc_disc_rport_event; | |
65 | + rp->ops = &fc_disc_rport_ops; | |
66 | rp->rp_state = RPORT_ST_INIT; | |
67 | lport->tt.rport_login(rport); | |
68 | } | |
69 | @@ -658,7 +662,7 @@ static int fc_disc_gpn_ft_parse(struct f | |
70 | rport = fc_rport_rogue_create(&dp); | |
71 | if (rport) { | |
72 | rdata = rport->dd_data; | |
73 | - rdata->event_callback = fc_disc_rport_event; | |
74 | + rdata->ops = &fc_disc_rport_ops; | |
75 | rdata->local_port = lport; | |
76 | lport->tt.rport_login(rport); | |
77 | } else | |
78 | @@ -812,7 +816,7 @@ static void fc_disc_single(struct fc_dis | |
79 | new_rport = fc_rport_rogue_create(dp); | |
80 | if (new_rport) { | |
81 | rdata = new_rport->dd_data; | |
82 | - rdata->event_callback = fc_disc_rport_event; | |
83 | + rdata->ops = &fc_disc_rport_ops; | |
84 | kfree(dp); | |
85 | lport->tt.rport_login(new_rport); | |
86 | } | |
87 | --- a/drivers/scsi/libfc/fc_lport.c | |
88 | +++ b/drivers/scsi/libfc/fc_lport.c | |
89 | @@ -38,7 +38,7 @@ | |
90 | * hold the rport's mutex, but not the other way around. | |
91 | * | |
92 | * The only complication to this rule is the callbacks from the rport to | |
93 | - * the lport's event_callback function. When rports become READY they make | |
94 | + * the lport's rport_callback function. When rports become READY they make | |
95 | * a callback to the lport so that it can track them. In the case of the | |
96 | * directory server that callback might cause the lport to change its | |
97 | * state, implying that the lport mutex would need to be held. This problem | |
98 | @@ -125,7 +125,7 @@ static int fc_frame_drop(struct fc_lport | |
99 | } | |
100 | ||
101 | /** | |
102 | - * fc_lport_rport_event - Event handler for rport events | |
103 | + * fc_lport_rport_callback - Event handler for rport events | |
104 | * @lport: The lport which is receiving the event | |
105 | * @rport: The rport which the event has occured on | |
106 | * @event: The event that occured | |
107 | @@ -133,9 +133,9 @@ static int fc_frame_drop(struct fc_lport | |
108 | * Locking Note: The rport lock should not be held when calling | |
109 | * this function. | |
110 | */ | |
111 | -static void fc_lport_rport_event(struct fc_lport *lport, | |
112 | - struct fc_rport *rport, | |
113 | - enum fc_lport_event event) | |
114 | +static void fc_lport_rport_callback(struct fc_lport *lport, | |
115 | + struct fc_rport *rport, | |
116 | + enum fc_rport_event event) | |
117 | { | |
118 | FC_DEBUG_LPORT("Received a %d event for port (%6x)\n", event, | |
119 | rport->port_id); | |
120 | @@ -1265,6 +1265,10 @@ static void fc_lport_enter_rpn_id(struct | |
121 | fc_lport_error(lport, fp); | |
122 | } | |
123 | ||
124 | +static struct fc_rport_operations fc_lport_rport_ops = { | |
125 | + .event_callback = fc_lport_rport_callback, | |
126 | +}; | |
127 | + | |
128 | /** | |
129 | * fc_rport_enter_dns - Create a rport to the name server | |
130 | * @lport: Fibre Channel local port requesting a rport for the name server | |
131 | @@ -1294,7 +1298,7 @@ static void fc_lport_enter_dns(struct fc | |
132 | goto err; | |
133 | ||
134 | rdata = rport->dd_data; | |
135 | - rdata->event_callback = fc_lport_rport_event; | |
136 | + rdata->ops = &fc_lport_rport_ops; | |
137 | lport->tt.rport_login(rport); | |
138 | return; | |
139 | ||
140 | --- a/drivers/scsi/libfc/fc_rport.c | |
141 | +++ b/drivers/scsi/libfc/fc_rport.c | |
142 | @@ -125,7 +125,7 @@ struct fc_rport *fc_rport_rogue_create(s | |
143 | rdata->rp_state = RPORT_ST_INIT; | |
144 | rdata->event = RPORT_EV_NONE; | |
145 | rdata->flags = FC_RP_FLAGS_REC_SUPPORTED; | |
146 | - rdata->event_callback = NULL; | |
147 | + rdata->ops = NULL; | |
148 | rdata->e_d_tov = dp->lp->e_d_tov; | |
149 | rdata->r_a_tov = dp->lp->r_a_tov; | |
150 | INIT_DELAYED_WORK(&rdata->retry_work, fc_rport_timeout); | |
151 | @@ -216,16 +216,15 @@ static void fc_rport_work(struct work_st | |
152 | { | |
153 | struct fc_rport_libfc_priv *rdata = | |
154 | container_of(work, struct fc_rport_libfc_priv, event_work); | |
155 | - enum fc_lport_event event; | |
156 | + enum fc_rport_event event; | |
157 | enum fc_rport_trans_state trans_state; | |
158 | struct fc_lport *lport = rdata->local_port; | |
159 | - void (*event_callback)(struct fc_lport *, struct fc_rport *, | |
160 | - enum fc_lport_event); | |
161 | + struct fc_rport_operations *rport_ops; | |
162 | struct fc_rport *rport = PRIV_TO_RPORT(rdata); | |
163 | ||
164 | mutex_lock(&rdata->rp_mutex); | |
165 | event = rdata->event; | |
166 | - event_callback = rdata->event_callback; | |
167 | + rport_ops = rdata->ops; | |
168 | ||
169 | if (event == RPORT_EV_CREATED) { | |
170 | struct fc_rport *new_rport; | |
171 | @@ -250,7 +249,7 @@ static void fc_rport_work(struct work_st | |
172 | new_rdata = new_rport->dd_data; | |
173 | new_rdata->e_d_tov = rdata->e_d_tov; | |
174 | new_rdata->r_a_tov = rdata->r_a_tov; | |
175 | - new_rdata->event_callback = rdata->event_callback; | |
176 | + new_rdata->ops = rdata->ops; | |
177 | new_rdata->local_port = rdata->local_port; | |
178 | new_rdata->flags = FC_RP_FLAGS_REC_SUPPORTED; | |
179 | new_rdata->trans_state = FC_PORTSTATE_REAL; | |
180 | @@ -269,15 +268,15 @@ static void fc_rport_work(struct work_st | |
181 | fc_rport_rogue_destroy(rport); | |
182 | rport = new_rport; | |
183 | rdata = new_rport->dd_data; | |
184 | - if (event_callback) | |
185 | - event_callback(lport, rport, event); | |
186 | + if (rport_ops->event_callback) | |
187 | + rport_ops->event_callback(lport, rport, event); | |
188 | } else if ((event == RPORT_EV_FAILED) || | |
189 | (event == RPORT_EV_LOGO) || | |
190 | (event == RPORT_EV_STOP)) { | |
191 | trans_state = rdata->trans_state; | |
192 | mutex_unlock(&rdata->rp_mutex); | |
193 | - if (event_callback) | |
194 | - event_callback(lport, rport, event); | |
195 | + if (rport_ops->event_callback) | |
196 | + rport_ops->event_callback(lport, rport, event); | |
197 | if (trans_state == FC_PORTSTATE_ROGUE) | |
198 | fc_rport_rogue_destroy(rport); | |
199 | else | |
200 | --- a/include/scsi/libfc.h | |
201 | +++ b/include/scsi/libfc.h | |
202 | @@ -89,14 +89,6 @@ enum fc_disc_event { | |
203 | DISC_EV_FAILED | |
204 | }; | |
205 | ||
206 | -enum fc_lport_event { | |
207 | - RPORT_EV_NONE = 0, | |
208 | - RPORT_EV_CREATED, | |
209 | - RPORT_EV_FAILED, | |
210 | - RPORT_EV_STOP, | |
211 | - RPORT_EV_LOGO | |
212 | -}; | |
213 | - | |
214 | enum fc_rport_state { | |
215 | RPORT_ST_NONE = 0, | |
216 | RPORT_ST_INIT, /* initialized */ | |
217 | @@ -126,6 +118,19 @@ struct fc_disc_port { | |
218 | struct work_struct rport_work; | |
219 | }; | |
220 | ||
221 | +enum fc_rport_event { | |
222 | + RPORT_EV_NONE = 0, | |
223 | + RPORT_EV_CREATED, | |
224 | + RPORT_EV_FAILED, | |
225 | + RPORT_EV_STOP, | |
226 | + RPORT_EV_LOGO | |
227 | +}; | |
228 | + | |
229 | +struct fc_rport_operations { | |
230 | + void (*event_callback)(struct fc_lport *, struct fc_rport *, | |
231 | + enum fc_rport_event); | |
232 | +}; | |
233 | + | |
234 | /** | |
235 | * struct fc_rport_libfc_priv - libfc internal information about a remote port | |
236 | * @local_port: Fibre Channel host port instance | |
237 | @@ -140,24 +145,22 @@ struct fc_disc_port { | |
238 | * @event_callback: Callback for rport READY, FAILED or LOGO | |
239 | */ | |
240 | struct fc_rport_libfc_priv { | |
241 | - struct fc_lport *local_port; | |
242 | - enum fc_rport_state rp_state; | |
243 | - u16 flags; | |
244 | + struct fc_lport *local_port; | |
245 | + enum fc_rport_state rp_state; | |
246 | + u16 flags; | |
247 | #define FC_RP_FLAGS_REC_SUPPORTED (1 << 0) | |
248 | #define FC_RP_FLAGS_RETRY (1 << 1) | |
249 | - u16 max_seq; | |
250 | - unsigned int retries; | |
251 | - unsigned int e_d_tov; | |
252 | - unsigned int r_a_tov; | |
253 | - enum fc_rport_trans_state trans_state; | |
254 | - struct mutex rp_mutex; | |
255 | - struct delayed_work retry_work; | |
256 | - enum fc_lport_event event; | |
257 | - void (*event_callback)(struct fc_lport *, | |
258 | - struct fc_rport *, | |
259 | - enum fc_lport_event); | |
260 | - struct list_head peers; | |
261 | - struct work_struct event_work; | |
262 | + u16 max_seq; | |
263 | + unsigned int retries; | |
264 | + unsigned int e_d_tov; | |
265 | + unsigned int r_a_tov; | |
266 | + enum fc_rport_trans_state trans_state; | |
267 | + struct mutex rp_mutex; | |
268 | + struct delayed_work retry_work; | |
269 | + enum fc_rport_event event; | |
270 | + struct fc_rport_operations *ops; | |
271 | + struct list_head peers; | |
272 | + struct work_struct event_work; | |
273 | }; | |
274 | ||
275 | #define PRIV_TO_RPORT(x) \ |