zfcp_fc.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * zfcp device driver
  4. *
  5. * Fibre Channel related functions for the zfcp device driver.
  6. *
  7. * Copyright IBM Corp. 2008, 2017
  8. */
  9. #define KMSG_COMPONENT "zfcp"
  10. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11. #include <linux/types.h>
  12. #include <linux/slab.h>
  13. #include <linux/utsname.h>
  14. #include <linux/random.h>
  15. #include <linux/bsg-lib.h>
  16. #include <scsi/fc/fc_els.h>
  17. #include <scsi/libfc.h>
  18. #include "zfcp_ext.h"
  19. #include "zfcp_fc.h"
  20. struct kmem_cache *zfcp_fc_req_cache;
  21. static u32 zfcp_fc_rscn_range_mask[] = {
  22. [ELS_ADDR_FMT_PORT] = 0xFFFFFF,
  23. [ELS_ADDR_FMT_AREA] = 0xFFFF00,
  24. [ELS_ADDR_FMT_DOM] = 0xFF0000,
  25. [ELS_ADDR_FMT_FAB] = 0x000000,
  26. };
  27. static bool no_auto_port_rescan;
  28. module_param(no_auto_port_rescan, bool, 0600);
  29. MODULE_PARM_DESC(no_auto_port_rescan,
  30. "no automatic port_rescan (default off)");
  31. static unsigned int port_scan_backoff = 500;
  32. module_param(port_scan_backoff, uint, 0600);
  33. MODULE_PARM_DESC(port_scan_backoff,
  34. "upper limit of port scan random backoff in msecs (default 500)");
  35. static unsigned int port_scan_ratelimit = 60000;
  36. module_param(port_scan_ratelimit, uint, 0600);
  37. MODULE_PARM_DESC(port_scan_ratelimit,
  38. "minimum interval between port scans in msecs (default 60000)");
  39. unsigned int zfcp_fc_port_scan_backoff(void)
  40. {
  41. if (!port_scan_backoff)
  42. return 0;
  43. return prandom_u32_max(port_scan_backoff);
  44. }
  45. static void zfcp_fc_port_scan_time(struct zfcp_adapter *adapter)
  46. {
  47. unsigned long interval = msecs_to_jiffies(port_scan_ratelimit);
  48. unsigned long backoff = msecs_to_jiffies(zfcp_fc_port_scan_backoff());
  49. adapter->next_port_scan = jiffies + interval + backoff;
  50. }
  51. static void zfcp_fc_port_scan(struct zfcp_adapter *adapter)
  52. {
  53. unsigned long now = jiffies;
  54. unsigned long next = adapter->next_port_scan;
  55. unsigned long delay = 0, max;
  56. /* delay only needed within waiting period */
  57. if (time_before(now, next)) {
  58. delay = next - now;
  59. /* paranoia: never ever delay scans longer than specified */
  60. max = msecs_to_jiffies(port_scan_ratelimit + port_scan_backoff);
  61. delay = min(delay, max);
  62. }
  63. queue_delayed_work(adapter->work_queue, &adapter->scan_work, delay);
  64. }
  65. void zfcp_fc_conditional_port_scan(struct zfcp_adapter *adapter)
  66. {
  67. if (no_auto_port_rescan)
  68. return;
  69. zfcp_fc_port_scan(adapter);
  70. }
  71. void zfcp_fc_inverse_conditional_port_scan(struct zfcp_adapter *adapter)
  72. {
  73. if (!no_auto_port_rescan)
  74. return;
  75. zfcp_fc_port_scan(adapter);
  76. }
  77. /**
  78. * zfcp_fc_post_event - post event to userspace via fc_transport
  79. * @work: work struct with enqueued events
  80. */
  81. void zfcp_fc_post_event(struct work_struct *work)
  82. {
  83. struct zfcp_fc_event *event = NULL, *tmp = NULL;
  84. LIST_HEAD(tmp_lh);
  85. struct zfcp_fc_events *events = container_of(work,
  86. struct zfcp_fc_events, work);
  87. struct zfcp_adapter *adapter = container_of(events, struct zfcp_adapter,
  88. events);
  89. spin_lock_bh(&events->list_lock);
  90. list_splice_init(&events->list, &tmp_lh);
  91. spin_unlock_bh(&events->list_lock);
  92. list_for_each_entry_safe(event, tmp, &tmp_lh, list) {
  93. fc_host_post_event(adapter->scsi_host, fc_get_event_number(),
  94. event->code, event->data);
  95. list_del(&event->list);
  96. kfree(event);
  97. }
  98. }
  99. /**
  100. * zfcp_fc_enqueue_event - safely enqueue FC HBA API event from irq context
  101. * @adapter: The adapter where to enqueue the event
  102. * @event_code: The event code (as defined in fc_host_event_code in
  103. * scsi_transport_fc.h)
  104. * @event_data: The event data (e.g. n_port page in case of els)
  105. */
  106. void zfcp_fc_enqueue_event(struct zfcp_adapter *adapter,
  107. enum fc_host_event_code event_code, u32 event_data)
  108. {
  109. struct zfcp_fc_event *event;
  110. event = kmalloc(sizeof(struct zfcp_fc_event), GFP_ATOMIC);
  111. if (!event)
  112. return;
  113. event->code = event_code;
  114. event->data = event_data;
  115. spin_lock(&adapter->events.list_lock);
  116. list_add_tail(&event->list, &adapter->events.list);
  117. spin_unlock(&adapter->events.list_lock);
  118. queue_work(adapter->work_queue, &adapter->events.work);
  119. }
  120. static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port *wka_port)
  121. {
  122. if (mutex_lock_interruptible(&wka_port->mutex))
  123. return -ERESTARTSYS;
  124. if (wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE ||
  125. wka_port->status == ZFCP_FC_WKA_PORT_CLOSING) {
  126. wka_port->status = ZFCP_FC_WKA_PORT_OPENING;
  127. if (zfcp_fsf_open_wka_port(wka_port))
  128. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  129. }
  130. mutex_unlock(&wka_port->mutex);
  131. wait_event(wka_port->completion_wq,
  132. wka_port->status == ZFCP_FC_WKA_PORT_ONLINE ||
  133. wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE);
  134. if (wka_port->status == ZFCP_FC_WKA_PORT_ONLINE) {
  135. atomic_inc(&wka_port->refcount);
  136. return 0;
  137. }
  138. return -EIO;
  139. }
  140. static void zfcp_fc_wka_port_offline(struct work_struct *work)
  141. {
  142. struct delayed_work *dw = to_delayed_work(work);
  143. struct zfcp_fc_wka_port *wka_port =
  144. container_of(dw, struct zfcp_fc_wka_port, work);
  145. mutex_lock(&wka_port->mutex);
  146. if ((atomic_read(&wka_port->refcount) != 0) ||
  147. (wka_port->status != ZFCP_FC_WKA_PORT_ONLINE))
  148. goto out;
  149. wka_port->status = ZFCP_FC_WKA_PORT_CLOSING;
  150. if (zfcp_fsf_close_wka_port(wka_port)) {
  151. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  152. wake_up(&wka_port->completion_wq);
  153. }
  154. out:
  155. mutex_unlock(&wka_port->mutex);
  156. }
  157. static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port *wka_port)
  158. {
  159. if (atomic_dec_return(&wka_port->refcount) != 0)
  160. return;
  161. /* wait 10 milliseconds, other reqs might pop in */
  162. schedule_delayed_work(&wka_port->work, HZ / 100);
  163. }
  164. static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port *wka_port, u32 d_id,
  165. struct zfcp_adapter *adapter)
  166. {
  167. init_waitqueue_head(&wka_port->completion_wq);
  168. wka_port->adapter = adapter;
  169. wka_port->d_id = d_id;
  170. wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  171. atomic_set(&wka_port->refcount, 0);
  172. mutex_init(&wka_port->mutex);
  173. INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline);
  174. }
  175. static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port *wka)
  176. {
  177. cancel_delayed_work_sync(&wka->work);
  178. mutex_lock(&wka->mutex);
  179. wka->status = ZFCP_FC_WKA_PORT_OFFLINE;
  180. mutex_unlock(&wka->mutex);
  181. }
  182. void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *gs)
  183. {
  184. if (!gs)
  185. return;
  186. zfcp_fc_wka_port_force_offline(&gs->ms);
  187. zfcp_fc_wka_port_force_offline(&gs->ts);
  188. zfcp_fc_wka_port_force_offline(&gs->ds);
  189. zfcp_fc_wka_port_force_offline(&gs->as);
  190. }
  191. static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
  192. struct fc_els_rscn_page *page)
  193. {
  194. unsigned long flags;
  195. struct zfcp_adapter *adapter = fsf_req->adapter;
  196. struct zfcp_port *port;
  197. read_lock_irqsave(&adapter->port_list_lock, flags);
  198. list_for_each_entry(port, &adapter->port_list, list) {
  199. if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range))
  200. zfcp_fc_test_link(port);
  201. }
  202. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  203. }
  204. static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req)
  205. {
  206. struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data;
  207. struct zfcp_adapter *adapter = fsf_req->adapter;
  208. struct fc_els_rscn *head;
  209. struct fc_els_rscn_page *page;
  210. u16 i;
  211. u16 no_entries;
  212. unsigned int afmt;
  213. head = (struct fc_els_rscn *) status_buffer->payload.data;
  214. page = (struct fc_els_rscn_page *) head;
  215. /* see FC-FS */
  216. no_entries = be16_to_cpu(head->rscn_plen) /
  217. sizeof(struct fc_els_rscn_page);
  218. if (no_entries > 1) {
  219. /* handle failed ports */
  220. unsigned long flags;
  221. struct zfcp_port *port;
  222. read_lock_irqsave(&adapter->port_list_lock, flags);
  223. list_for_each_entry(port, &adapter->port_list, list) {
  224. if (port->d_id)
  225. continue;
  226. zfcp_erp_port_reopen(port,
  227. ZFCP_STATUS_COMMON_ERP_FAILED,
  228. "fcrscn1");
  229. }
  230. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  231. }
  232. for (i = 1; i < no_entries; i++) {
  233. /* skip head and start with 1st element */
  234. page++;
  235. afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK;
  236. _zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt],
  237. page);
  238. zfcp_fc_enqueue_event(fsf_req->adapter, FCH_EVT_RSCN,
  239. *(u32 *)page);
  240. }
  241. zfcp_fc_conditional_port_scan(fsf_req->adapter);
  242. }
  243. static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
  244. {
  245. unsigned long flags;
  246. struct zfcp_adapter *adapter = req->adapter;
  247. struct zfcp_port *port;
  248. read_lock_irqsave(&adapter->port_list_lock, flags);
  249. list_for_each_entry(port, &adapter->port_list, list)
  250. if (port->wwpn == wwpn) {
  251. zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
  252. break;
  253. }
  254. read_unlock_irqrestore(&adapter->port_list_lock, flags);
  255. }
  256. static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req)
  257. {
  258. struct fsf_status_read_buffer *status_buffer;
  259. struct fc_els_flogi *plogi;
  260. status_buffer = (struct fsf_status_read_buffer *) req->data;
  261. plogi = (struct fc_els_flogi *) status_buffer->payload.data;
  262. zfcp_fc_incoming_wwpn(req, be64_to_cpu(plogi->fl_wwpn));
  263. }
  264. static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req)
  265. {
  266. struct fsf_status_read_buffer *status_buffer =
  267. (struct fsf_status_read_buffer *)req->data;
  268. struct fc_els_logo *logo =
  269. (struct fc_els_logo *) status_buffer->payload.data;
  270. zfcp_fc_incoming_wwpn(req, be64_to_cpu(logo->fl_n_port_wwn));
  271. }
  272. /**
  273. * zfcp_fc_incoming_els - handle incoming ELS
  274. * @fsf_req: request which contains incoming ELS
  275. */
  276. void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
  277. {
  278. struct fsf_status_read_buffer *status_buffer =
  279. (struct fsf_status_read_buffer *) fsf_req->data;
  280. unsigned int els_type = status_buffer->payload.data[0];
  281. zfcp_dbf_san_in_els("fciels1", fsf_req);
  282. if (els_type == ELS_PLOGI)
  283. zfcp_fc_incoming_plogi(fsf_req);
  284. else if (els_type == ELS_LOGO)
  285. zfcp_fc_incoming_logo(fsf_req);
  286. else if (els_type == ELS_RSCN)
  287. zfcp_fc_incoming_rscn(fsf_req);
  288. }
  289. static void zfcp_fc_ns_gid_pn_eval(struct zfcp_fc_req *fc_req)
  290. {
  291. struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
  292. struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
  293. if (ct_els->status)
  294. return;
  295. if (gid_pn_rsp->ct_hdr.ct_cmd != cpu_to_be16(FC_FS_ACC))
  296. return;
  297. /* looks like a valid d_id */
  298. ct_els->port->d_id = ntoh24(gid_pn_rsp->gid_pn.fp_fid);
  299. }
  300. static void zfcp_fc_complete(void *data)
  301. {
  302. complete(data);
  303. }
  304. static void zfcp_fc_ct_ns_init(struct fc_ct_hdr *ct_hdr, u16 cmd, u16 mr_size)
  305. {
  306. ct_hdr->ct_rev = FC_CT_REV;
  307. ct_hdr->ct_fs_type = FC_FST_DIR;
  308. ct_hdr->ct_fs_subtype = FC_NS_SUBTYPE;
  309. ct_hdr->ct_cmd = cpu_to_be16(cmd);
  310. ct_hdr->ct_mr_size = cpu_to_be16(mr_size / 4);
  311. }
  312. static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
  313. struct zfcp_fc_req *fc_req)
  314. {
  315. struct zfcp_adapter *adapter = port->adapter;
  316. DECLARE_COMPLETION_ONSTACK(completion);
  317. struct zfcp_fc_gid_pn_req *gid_pn_req = &fc_req->u.gid_pn.req;
  318. struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
  319. int ret;
  320. /* setup parameters for send generic command */
  321. fc_req->ct_els.port = port;
  322. fc_req->ct_els.handler = zfcp_fc_complete;
  323. fc_req->ct_els.handler_data = &completion;
  324. fc_req->ct_els.req = &fc_req->sg_req;
  325. fc_req->ct_els.resp = &fc_req->sg_rsp;
  326. sg_init_one(&fc_req->sg_req, gid_pn_req, sizeof(*gid_pn_req));
  327. sg_init_one(&fc_req->sg_rsp, gid_pn_rsp, sizeof(*gid_pn_rsp));
  328. zfcp_fc_ct_ns_init(&gid_pn_req->ct_hdr,
  329. FC_NS_GID_PN, ZFCP_FC_CT_SIZE_PAGE);
  330. gid_pn_req->gid_pn.fn_wwpn = cpu_to_be64(port->wwpn);
  331. ret = zfcp_fsf_send_ct(&adapter->gs->ds, &fc_req->ct_els,
  332. adapter->pool.gid_pn_req,
  333. ZFCP_FC_CTELS_TMO);
  334. if (!ret) {
  335. wait_for_completion(&completion);
  336. zfcp_fc_ns_gid_pn_eval(fc_req);
  337. }
  338. return ret;
  339. }
  340. /**
  341. * zfcp_fc_ns_gid_pn - initiate GID_PN nameserver request
  342. * @port: port where GID_PN request is needed
  343. * return: -ENOMEM on error, 0 otherwise
  344. */
  345. static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
  346. {
  347. int ret;
  348. struct zfcp_fc_req *fc_req;
  349. struct zfcp_adapter *adapter = port->adapter;
  350. fc_req = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
  351. if (!fc_req)
  352. return -ENOMEM;
  353. memset(fc_req, 0, sizeof(*fc_req));
  354. ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
  355. if (ret)
  356. goto out;
  357. ret = zfcp_fc_ns_gid_pn_request(port, fc_req);
  358. zfcp_fc_wka_port_put(&adapter->gs->ds);
  359. out:
  360. mempool_free(fc_req, adapter->pool.gid_pn);
  361. return ret;
  362. }
  363. void zfcp_fc_port_did_lookup(struct work_struct *work)
  364. {
  365. int ret;
  366. struct zfcp_port *port = container_of(work, struct zfcp_port,
  367. gid_pn_work);
  368. set_worker_desc("zgidpn%16llx", port->wwpn); /* < WORKER_DESC_LEN=24 */
  369. ret = zfcp_fc_ns_gid_pn(port);
  370. if (ret) {
  371. /* could not issue gid_pn for some reason */
  372. zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
  373. goto out;
  374. }
  375. if (!port->d_id) {
  376. zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
  377. goto out;
  378. }
  379. zfcp_erp_port_reopen(port, 0, "fcgpn_3");
  380. out:
  381. put_device(&port->dev);
  382. }
  383. /**
  384. * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request
  385. * @port: The zfcp_port to lookup the d_id for.
  386. */
  387. void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
  388. {
  389. get_device(&port->dev);
  390. if (!queue_work(port->adapter->work_queue, &port->gid_pn_work))
  391. put_device(&port->dev);
  392. }
  393. /**
  394. * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
  395. * @port: zfcp_port structure
  396. * @plogi: plogi payload
  397. *
  398. * Evaluate PLOGI playload and copy important fields into zfcp_port structure
  399. */
  400. void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
  401. {
  402. if (be64_to_cpu(plogi->fl_wwpn) != port->wwpn) {
  403. port->d_id = 0;
  404. dev_warn(&port->adapter->ccw_device->dev,
  405. "A port opened with WWPN 0x%016Lx returned data that "
  406. "identifies it as WWPN 0x%016Lx\n",
  407. (unsigned long long) port->wwpn,
  408. (unsigned long long) be64_to_cpu(plogi->fl_wwpn));
  409. return;
  410. }
  411. port->wwnn = be64_to_cpu(plogi->fl_wwnn);
  412. port->maxframe_size = be16_to_cpu(plogi->fl_csp.sp_bb_data);
  413. if (plogi->fl_cssp[0].cp_class & cpu_to_be16(FC_CPC_VALID))
  414. port->supported_classes |= FC_COS_CLASS1;
  415. if (plogi->fl_cssp[1].cp_class & cpu_to_be16(FC_CPC_VALID))
  416. port->supported_classes |= FC_COS_CLASS2;
  417. if (plogi->fl_cssp[2].cp_class & cpu_to_be16(FC_CPC_VALID))
  418. port->supported_classes |= FC_COS_CLASS3;
  419. if (plogi->fl_cssp[3].cp_class & cpu_to_be16(FC_CPC_VALID))
  420. port->supported_classes |= FC_COS_CLASS4;
  421. }
  422. static void zfcp_fc_adisc_handler(void *data)
  423. {
  424. struct zfcp_fc_req *fc_req = data;
  425. struct zfcp_port *port = fc_req->ct_els.port;
  426. struct fc_els_adisc *adisc_resp = &fc_req->u.adisc.rsp;
  427. if (fc_req->ct_els.status) {
  428. /* request rejected or timed out */
  429. zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
  430. "fcadh_1");
  431. goto out;
  432. }
  433. if (!port->wwnn)
  434. port->wwnn = be64_to_cpu(adisc_resp->adisc_wwnn);
  435. if ((port->wwpn != be64_to_cpu(adisc_resp->adisc_wwpn)) ||
  436. !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
  437. zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
  438. "fcadh_2");
  439. goto out;
  440. }
  441. /* re-init to undo drop from zfcp_fc_adisc() */
  442. port->d_id = ntoh24(adisc_resp->adisc_port_id);
  443. /* port is good, unblock rport without going through erp */
  444. zfcp_scsi_schedule_rport_register(port);
  445. out:
  446. atomic_andnot(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
  447. put_device(&port->dev);
  448. kmem_cache_free(zfcp_fc_req_cache, fc_req);
  449. }
  450. static int zfcp_fc_adisc(struct zfcp_port *port)
  451. {
  452. struct zfcp_fc_req *fc_req;
  453. struct zfcp_adapter *adapter = port->adapter;
  454. struct Scsi_Host *shost = adapter->scsi_host;
  455. u32 d_id;
  456. int ret;
  457. fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_ATOMIC);
  458. if (!fc_req)
  459. return -ENOMEM;
  460. fc_req->ct_els.port = port;
  461. fc_req->ct_els.req = &fc_req->sg_req;
  462. fc_req->ct_els.resp = &fc_req->sg_rsp;
  463. sg_init_one(&fc_req->sg_req, &fc_req->u.adisc.req,
  464. sizeof(struct fc_els_adisc));
  465. sg_init_one(&fc_req->sg_rsp, &fc_req->u.adisc.rsp,
  466. sizeof(struct fc_els_adisc));
  467. fc_req->ct_els.handler = zfcp_fc_adisc_handler;
  468. fc_req->ct_els.handler_data = fc_req;
  469. /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
  470. without FC-AL-2 capability, so we don't set it */
  471. fc_req->u.adisc.req.adisc_wwpn = cpu_to_be64(fc_host_port_name(shost));
  472. fc_req->u.adisc.req.adisc_wwnn = cpu_to_be64(fc_host_node_name(shost));
  473. fc_req->u.adisc.req.adisc_cmd = ELS_ADISC;
  474. hton24(fc_req->u.adisc.req.adisc_port_id, fc_host_port_id(shost));
  475. d_id = port->d_id; /* remember as destination for send els below */
  476. /*
  477. * Force fresh GID_PN lookup on next port recovery.
  478. * Must happen after request setup and before sending request,
  479. * to prevent race with port->d_id re-init in zfcp_fc_adisc_handler().
  480. */
  481. port->d_id = 0;
  482. ret = zfcp_fsf_send_els(adapter, d_id, &fc_req->ct_els,
  483. ZFCP_FC_CTELS_TMO);
  484. if (ret)
  485. kmem_cache_free(zfcp_fc_req_cache, fc_req);
  486. return ret;
  487. }
  488. void zfcp_fc_link_test_work(struct work_struct *work)
  489. {
  490. struct zfcp_port *port =
  491. container_of(work, struct zfcp_port, test_link_work);
  492. int retval;
  493. set_worker_desc("zadisc%16llx", port->wwpn); /* < WORKER_DESC_LEN=24 */
  494. get_device(&port->dev);
  495. port->rport_task = RPORT_DEL;
  496. zfcp_scsi_rport_work(&port->rport_work);
  497. /* only issue one test command at one time per port */
  498. if (atomic_read(&port->status) & ZFCP_STATUS_PORT_LINK_TEST)
  499. goto out;
  500. atomic_or(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
  501. retval = zfcp_fc_adisc(port);
  502. if (retval == 0)
  503. return;
  504. /* send of ADISC was not possible */
  505. atomic_andnot(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
  506. zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
  507. out:
  508. put_device(&port->dev);
  509. }
  510. /**
  511. * zfcp_fc_test_link - lightweight link test procedure
  512. * @port: port to be tested
  513. *
  514. * Test status of a link to a remote port using the ELS command ADISC.
  515. * If there is a problem with the remote port, error recovery steps
  516. * will be triggered.
  517. */
  518. void zfcp_fc_test_link(struct zfcp_port *port)
  519. {
  520. get_device(&port->dev);
  521. if (!queue_work(port->adapter->work_queue, &port->test_link_work))
  522. put_device(&port->dev);
  523. }
  524. /**
  525. * zfcp_fc_sg_free_table - free memory used by scatterlists
  526. * @sg: pointer to scatterlist
  527. * @count: number of scatterlist which are to be free'ed
  528. * the scatterlist are expected to reference pages always
  529. */
  530. static void zfcp_fc_sg_free_table(struct scatterlist *sg, int count)
  531. {
  532. int i;
  533. for (i = 0; i < count; i++, sg = sg_next(sg))
  534. if (sg)
  535. free_page((unsigned long) sg_virt(sg));
  536. else
  537. break;
  538. }
  539. /**
  540. * zfcp_fc_sg_setup_table - init scatterlist and allocate, assign buffers
  541. * @sg: pointer to struct scatterlist
  542. * @count: number of scatterlists which should be assigned with buffers
  543. * of size page
  544. *
  545. * Returns: 0 on success, -ENOMEM otherwise
  546. */
  547. static int zfcp_fc_sg_setup_table(struct scatterlist *sg, int count)
  548. {
  549. void *addr;
  550. int i;
  551. sg_init_table(sg, count);
  552. for (i = 0; i < count; i++, sg = sg_next(sg)) {
  553. addr = (void *) get_zeroed_page(GFP_KERNEL);
  554. if (!addr) {
  555. zfcp_fc_sg_free_table(sg, i);
  556. return -ENOMEM;
  557. }
  558. sg_set_buf(sg, addr, PAGE_SIZE);
  559. }
  560. return 0;
  561. }
  562. static struct zfcp_fc_req *zfcp_fc_alloc_sg_env(int buf_num)
  563. {
  564. struct zfcp_fc_req *fc_req;
  565. fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
  566. if (!fc_req)
  567. return NULL;
  568. if (zfcp_fc_sg_setup_table(&fc_req->sg_rsp, buf_num)) {
  569. kmem_cache_free(zfcp_fc_req_cache, fc_req);
  570. return NULL;
  571. }
  572. sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req,
  573. sizeof(struct zfcp_fc_gpn_ft_req));
  574. return fc_req;
  575. }
  576. static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req,
  577. struct zfcp_adapter *adapter, int max_bytes)
  578. {
  579. struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
  580. struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req;
  581. DECLARE_COMPLETION_ONSTACK(completion);
  582. int ret;
  583. zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes);
  584. req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
  585. ct_els->handler = zfcp_fc_complete;
  586. ct_els->handler_data = &completion;
  587. ct_els->req = &fc_req->sg_req;
  588. ct_els->resp = &fc_req->sg_rsp;
  589. ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
  590. ZFCP_FC_CTELS_TMO);
  591. if (!ret)
  592. wait_for_completion(&completion);
  593. return ret;
  594. }
  595. static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
  596. {
  597. if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC))
  598. return;
  599. atomic_andnot(ZFCP_STATUS_COMMON_NOESC, &port->status);
  600. if ((port->supported_classes != 0) ||
  601. !list_empty(&port->unit_list))
  602. return;
  603. list_move_tail(&port->list, lh);
  604. }
  605. static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
  606. struct zfcp_adapter *adapter, int max_entries)
  607. {
  608. struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
  609. struct scatterlist *sg = &fc_req->sg_rsp;
  610. struct fc_ct_hdr *hdr = sg_virt(sg);
  611. struct fc_gpn_ft_resp *acc = sg_virt(sg);
  612. struct zfcp_port *port, *tmp;
  613. unsigned long flags;
  614. LIST_HEAD(remove_lh);
  615. u32 d_id;
  616. int ret = 0, x, last = 0;
  617. if (ct_els->status)
  618. return -EIO;
  619. if (hdr->ct_cmd != cpu_to_be16(FC_FS_ACC)) {
  620. if (hdr->ct_reason == FC_FS_RJT_UNABL)
  621. return -EAGAIN; /* might be a temporary condition */
  622. return -EIO;
  623. }
  624. if (hdr->ct_mr_size) {
  625. dev_warn(&adapter->ccw_device->dev,
  626. "The name server reported %d words residual data\n",
  627. hdr->ct_mr_size);
  628. return -E2BIG;
  629. }
  630. /* first entry is the header */
  631. for (x = 1; x < max_entries && !last; x++) {
  632. if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
  633. acc++;
  634. else
  635. acc = sg_virt(++sg);
  636. last = acc->fp_flags & FC_NS_FID_LAST;
  637. d_id = ntoh24(acc->fp_fid);
  638. /* don't attach ports with a well known address */
  639. if (d_id >= FC_FID_WELL_KNOWN_BASE)
  640. continue;
  641. /* skip the adapter's port and known remote ports */
  642. if (be64_to_cpu(acc->fp_wwpn) ==
  643. fc_host_port_name(adapter->scsi_host))
  644. continue;
  645. port = zfcp_port_enqueue(adapter, be64_to_cpu(acc->fp_wwpn),
  646. ZFCP_STATUS_COMMON_NOESC, d_id);
  647. if (!IS_ERR(port))
  648. zfcp_erp_port_reopen(port, 0, "fcegpf1");
  649. else if (PTR_ERR(port) != -EEXIST)
  650. ret = PTR_ERR(port);
  651. }
  652. zfcp_erp_wait(adapter);
  653. write_lock_irqsave(&adapter->port_list_lock, flags);
  654. list_for_each_entry_safe(port, tmp, &adapter->port_list, list)
  655. zfcp_fc_validate_port(port, &remove_lh);
  656. write_unlock_irqrestore(&adapter->port_list_lock, flags);
  657. list_for_each_entry_safe(port, tmp, &remove_lh, list) {
  658. zfcp_erp_port_shutdown(port, 0, "fcegpf2");
  659. device_unregister(&port->dev);
  660. }
  661. return ret;
  662. }
  663. /**
  664. * zfcp_fc_scan_ports - scan remote ports and attach new ports
  665. * @work: reference to scheduled work
  666. */
  667. void zfcp_fc_scan_ports(struct work_struct *work)
  668. {
  669. struct delayed_work *dw = to_delayed_work(work);
  670. struct zfcp_adapter *adapter = container_of(dw, struct zfcp_adapter,
  671. scan_work);
  672. int ret, i;
  673. struct zfcp_fc_req *fc_req;
  674. int chain, max_entries, buf_num, max_bytes;
  675. zfcp_fc_port_scan_time(adapter);
  676. chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
  677. buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;
  678. max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;
  679. max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE;
  680. if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
  681. fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
  682. return;
  683. if (zfcp_fc_wka_port_get(&adapter->gs->ds))
  684. return;
  685. fc_req = zfcp_fc_alloc_sg_env(buf_num);
  686. if (!fc_req)
  687. goto out;
  688. for (i = 0; i < 3; i++) {
  689. ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes);
  690. if (!ret) {
  691. ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries);
  692. if (ret == -EAGAIN)
  693. ssleep(1);
  694. else
  695. break;
  696. }
  697. }
  698. zfcp_fc_sg_free_table(&fc_req->sg_rsp, buf_num);
  699. kmem_cache_free(zfcp_fc_req_cache, fc_req);
  700. out:
  701. zfcp_fc_wka_port_put(&adapter->gs->ds);
  702. }
  703. static int zfcp_fc_gspn(struct zfcp_adapter *adapter,
  704. struct zfcp_fc_req *fc_req)
  705. {
  706. DECLARE_COMPLETION_ONSTACK(completion);
  707. char devno[] = "DEVNO:";
  708. struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
  709. struct zfcp_fc_gspn_req *gspn_req = &fc_req->u.gspn.req;
  710. struct zfcp_fc_gspn_rsp *gspn_rsp = &fc_req->u.gspn.rsp;
  711. int ret;
  712. zfcp_fc_ct_ns_init(&gspn_req->ct_hdr, FC_NS_GSPN_ID,
  713. FC_SYMBOLIC_NAME_SIZE);
  714. hton24(gspn_req->gspn.fp_fid, fc_host_port_id(adapter->scsi_host));
  715. sg_init_one(&fc_req->sg_req, gspn_req, sizeof(*gspn_req));
  716. sg_init_one(&fc_req->sg_rsp, gspn_rsp, sizeof(*gspn_rsp));
  717. ct_els->handler = zfcp_fc_complete;
  718. ct_els->handler_data = &completion;
  719. ct_els->req = &fc_req->sg_req;
  720. ct_els->resp = &fc_req->sg_rsp;
  721. ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
  722. ZFCP_FC_CTELS_TMO);
  723. if (ret)
  724. return ret;
  725. wait_for_completion(&completion);
  726. if (ct_els->status)
  727. return ct_els->status;
  728. if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_NPIV &&
  729. !(strstr(gspn_rsp->gspn.fp_name, devno)))
  730. snprintf(fc_host_symbolic_name(adapter->scsi_host),
  731. FC_SYMBOLIC_NAME_SIZE, "%s%s %s NAME: %s",
  732. gspn_rsp->gspn.fp_name, devno,
  733. dev_name(&adapter->ccw_device->dev),
  734. init_utsname()->nodename);
  735. else
  736. strlcpy(fc_host_symbolic_name(adapter->scsi_host),
  737. gspn_rsp->gspn.fp_name, FC_SYMBOLIC_NAME_SIZE);
  738. return 0;
  739. }
  740. static void zfcp_fc_rspn(struct zfcp_adapter *adapter,
  741. struct zfcp_fc_req *fc_req)
  742. {
  743. DECLARE_COMPLETION_ONSTACK(completion);
  744. struct Scsi_Host *shost = adapter->scsi_host;
  745. struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
  746. struct zfcp_fc_rspn_req *rspn_req = &fc_req->u.rspn.req;
  747. struct fc_ct_hdr *rspn_rsp = &fc_req->u.rspn.rsp;
  748. int ret, len;
  749. zfcp_fc_ct_ns_init(&rspn_req->ct_hdr, FC_NS_RSPN_ID,
  750. FC_SYMBOLIC_NAME_SIZE);
  751. hton24(rspn_req->rspn.fr_fid.fp_fid, fc_host_port_id(shost));
  752. len = strlcpy(rspn_req->rspn.fr_name, fc_host_symbolic_name(shost),
  753. FC_SYMBOLIC_NAME_SIZE);
  754. rspn_req->rspn.fr_name_len = len;
  755. sg_init_one(&fc_req->sg_req, rspn_req, sizeof(*rspn_req));
  756. sg_init_one(&fc_req->sg_rsp, rspn_rsp, sizeof(*rspn_rsp));
  757. ct_els->handler = zfcp_fc_complete;
  758. ct_els->handler_data = &completion;
  759. ct_els->req = &fc_req->sg_req;
  760. ct_els->resp = &fc_req->sg_rsp;
  761. ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
  762. ZFCP_FC_CTELS_TMO);
  763. if (!ret)
  764. wait_for_completion(&completion);
  765. }
  766. /**
  767. * zfcp_fc_sym_name_update - Retrieve and update the symbolic port name
  768. * @work: ns_up_work of the adapter where to update the symbolic port name
  769. *
  770. * Retrieve the current symbolic port name that may have been set by
  771. * the hardware using the GSPN request and update the fc_host
  772. * symbolic_name sysfs attribute. When running in NPIV mode (and hence
  773. * the port name is unique for this system), update the symbolic port
  774. * name to add Linux specific information and update the FC nameserver
  775. * using the RSPN request.
  776. */
  777. void zfcp_fc_sym_name_update(struct work_struct *work)
  778. {
  779. struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
  780. ns_up_work);
  781. int ret;
  782. struct zfcp_fc_req *fc_req;
  783. if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
  784. fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
  785. return;
  786. fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
  787. if (!fc_req)
  788. return;
  789. ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
  790. if (ret)
  791. goto out_free;
  792. ret = zfcp_fc_gspn(adapter, fc_req);
  793. if (ret || fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
  794. goto out_ds_put;
  795. memset(fc_req, 0, sizeof(*fc_req));
  796. zfcp_fc_rspn(adapter, fc_req);
  797. out_ds_put:
  798. zfcp_fc_wka_port_put(&adapter->gs->ds);
  799. out_free:
  800. kmem_cache_free(zfcp_fc_req_cache, fc_req);
  801. }
  802. static void zfcp_fc_ct_els_job_handler(void *data)
  803. {
  804. struct bsg_job *job = data;
  805. struct zfcp_fsf_ct_els *zfcp_ct_els = job->dd_data;
  806. struct fc_bsg_reply *jr = job->reply;
  807. jr->reply_payload_rcv_len = job->reply_payload.payload_len;
  808. jr->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
  809. jr->result = zfcp_ct_els->status ? -EIO : 0;
  810. bsg_job_done(job, jr->result, jr->reply_payload_rcv_len);
  811. }
  812. static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct bsg_job *job)
  813. {
  814. u32 preamble_word1;
  815. u8 gs_type;
  816. struct zfcp_adapter *adapter;
  817. struct fc_bsg_request *bsg_request = job->request;
  818. struct fc_rport *rport = fc_bsg_to_rport(job);
  819. struct Scsi_Host *shost;
  820. preamble_word1 = bsg_request->rqst_data.r_ct.preamble_word1;
  821. gs_type = (preamble_word1 & 0xff000000) >> 24;
  822. shost = rport ? rport_to_shost(rport) : fc_bsg_to_shost(job);
  823. adapter = (struct zfcp_adapter *) shost->hostdata[0];
  824. switch (gs_type) {
  825. case FC_FST_ALIAS:
  826. return &adapter->gs->as;
  827. case FC_FST_MGMT:
  828. return &adapter->gs->ms;
  829. case FC_FST_TIME:
  830. return &adapter->gs->ts;
  831. break;
  832. case FC_FST_DIR:
  833. return &adapter->gs->ds;
  834. break;
  835. default:
  836. return NULL;
  837. }
  838. }
  839. static void zfcp_fc_ct_job_handler(void *data)
  840. {
  841. struct bsg_job *job = data;
  842. struct zfcp_fc_wka_port *wka_port;
  843. wka_port = zfcp_fc_job_wka_port(job);
  844. zfcp_fc_wka_port_put(wka_port);
  845. zfcp_fc_ct_els_job_handler(data);
  846. }
  847. static int zfcp_fc_exec_els_job(struct bsg_job *job,
  848. struct zfcp_adapter *adapter)
  849. {
  850. struct zfcp_fsf_ct_els *els = job->dd_data;
  851. struct fc_rport *rport = fc_bsg_to_rport(job);
  852. struct fc_bsg_request *bsg_request = job->request;
  853. struct zfcp_port *port;
  854. u32 d_id;
  855. if (rport) {
  856. port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
  857. if (!port)
  858. return -EINVAL;
  859. d_id = port->d_id;
  860. put_device(&port->dev);
  861. } else
  862. d_id = ntoh24(bsg_request->rqst_data.h_els.port_id);
  863. els->handler = zfcp_fc_ct_els_job_handler;
  864. return zfcp_fsf_send_els(adapter, d_id, els, job->timeout / HZ);
  865. }
  866. static int zfcp_fc_exec_ct_job(struct bsg_job *job,
  867. struct zfcp_adapter *adapter)
  868. {
  869. int ret;
  870. struct zfcp_fsf_ct_els *ct = job->dd_data;
  871. struct zfcp_fc_wka_port *wka_port;
  872. wka_port = zfcp_fc_job_wka_port(job);
  873. if (!wka_port)
  874. return -EINVAL;
  875. ret = zfcp_fc_wka_port_get(wka_port);
  876. if (ret)
  877. return ret;
  878. ct->handler = zfcp_fc_ct_job_handler;
  879. ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->timeout / HZ);
  880. if (ret)
  881. zfcp_fc_wka_port_put(wka_port);
  882. return ret;
  883. }
  884. int zfcp_fc_exec_bsg_job(struct bsg_job *job)
  885. {
  886. struct Scsi_Host *shost;
  887. struct zfcp_adapter *adapter;
  888. struct zfcp_fsf_ct_els *ct_els = job->dd_data;
  889. struct fc_bsg_request *bsg_request = job->request;
  890. struct fc_rport *rport = fc_bsg_to_rport(job);
  891. shost = rport ? rport_to_shost(rport) : fc_bsg_to_shost(job);
  892. adapter = (struct zfcp_adapter *)shost->hostdata[0];
  893. if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN))
  894. return -EINVAL;
  895. ct_els->req = job->request_payload.sg_list;
  896. ct_els->resp = job->reply_payload.sg_list;
  897. ct_els->handler_data = job;
  898. switch (bsg_request->msgcode) {
  899. case FC_BSG_RPT_ELS:
  900. case FC_BSG_HST_ELS_NOLOGIN:
  901. return zfcp_fc_exec_els_job(job, adapter);
  902. case FC_BSG_RPT_CT:
  903. case FC_BSG_HST_CT:
  904. return zfcp_fc_exec_ct_job(job, adapter);
  905. default:
  906. return -EINVAL;
  907. }
  908. }
  909. int zfcp_fc_timeout_bsg_job(struct bsg_job *job)
  910. {
  911. /* hardware tracks timeout, reset bsg timeout to not interfere */
  912. return -EAGAIN;
  913. }
  914. int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
  915. {
  916. struct zfcp_fc_wka_ports *wka_ports;
  917. wka_ports = kzalloc(sizeof(struct zfcp_fc_wka_ports), GFP_KERNEL);
  918. if (!wka_ports)
  919. return -ENOMEM;
  920. adapter->gs = wka_ports;
  921. zfcp_fc_wka_port_init(&wka_ports->ms, FC_FID_MGMT_SERV, adapter);
  922. zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter);
  923. zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter);
  924. zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter);
  925. return 0;
  926. }
  927. void zfcp_fc_gs_destroy(struct zfcp_adapter *adapter)
  928. {
  929. kfree(adapter->gs);
  930. adapter->gs = NULL;
  931. }