zfcp_dbf.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * zfcp device driver
  4. *
  5. * Debug traces for zfcp.
  6. *
  7. * Copyright IBM Corp. 2002, 2020
  8. */
  9. #define KMSG_COMPONENT "zfcp"
  10. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11. #include <linux/module.h>
  12. #include <linux/ctype.h>
  13. #include <linux/slab.h>
  14. #include <asm/debug.h>
  15. #include "zfcp_dbf.h"
  16. #include "zfcp_ext.h"
  17. #include "zfcp_fc.h"
  18. static u32 dbfsize = 4;
  19. module_param(dbfsize, uint, 0400);
  20. MODULE_PARM_DESC(dbfsize,
  21. "number of pages for each debug feature area (default 4)");
  22. static u32 dbflevel = 3;
  23. module_param(dbflevel, uint, 0400);
  24. MODULE_PARM_DESC(dbflevel,
  25. "log level for each debug feature area "
  26. "(default 3, range 0..6)");
  27. static inline unsigned int zfcp_dbf_plen(unsigned int offset)
  28. {
  29. return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC;
  30. }
  31. static inline
  32. void zfcp_dbf_pl_write(struct zfcp_dbf *dbf, void *data, u16 length, char *area,
  33. u64 req_id)
  34. {
  35. struct zfcp_dbf_pay *pl = &dbf->pay_buf;
  36. u16 offset = 0, rec_length;
  37. spin_lock(&dbf->pay_lock);
  38. memset(pl, 0, sizeof(*pl));
  39. pl->fsf_req_id = req_id;
  40. memcpy(pl->area, area, ZFCP_DBF_TAG_LEN);
  41. while (offset < length) {
  42. rec_length = min((u16) ZFCP_DBF_PAY_MAX_REC,
  43. (u16) (length - offset));
  44. memcpy(pl->data, data + offset, rec_length);
  45. debug_event(dbf->pay, 1, pl, zfcp_dbf_plen(rec_length));
  46. offset += rec_length;
  47. pl->counter++;
  48. }
  49. spin_unlock(&dbf->pay_lock);
  50. }
  51. /**
  52. * zfcp_dbf_hba_fsf_res - trace event for fsf responses
  53. * @tag: tag indicating which kind of FSF response has been received
  54. * @level: trace level to be used for event
  55. * @req: request for which a response was received
  56. */
  57. void zfcp_dbf_hba_fsf_res(char *tag, int level, struct zfcp_fsf_req *req)
  58. {
  59. struct zfcp_dbf *dbf = req->adapter->dbf;
  60. struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix;
  61. struct fsf_qtcb_header *q_head = &req->qtcb->header;
  62. struct zfcp_dbf_hba *rec = &dbf->hba_buf;
  63. unsigned long flags;
  64. spin_lock_irqsave(&dbf->hba_lock, flags);
  65. memset(rec, 0, sizeof(*rec));
  66. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  67. rec->id = ZFCP_DBF_HBA_RES;
  68. rec->fsf_req_id = req->req_id;
  69. rec->fsf_req_status = req->status;
  70. rec->fsf_cmd = q_head->fsf_command;
  71. rec->fsf_seq_no = q_pref->req_seq_no;
  72. rec->u.res.req_issued = req->issued;
  73. rec->u.res.prot_status = q_pref->prot_status;
  74. rec->u.res.fsf_status = q_head->fsf_status;
  75. rec->u.res.port_handle = q_head->port_handle;
  76. rec->u.res.lun_handle = q_head->lun_handle;
  77. memcpy(rec->u.res.prot_status_qual, &q_pref->prot_status_qual,
  78. FSF_PROT_STATUS_QUAL_SIZE);
  79. memcpy(rec->u.res.fsf_status_qual, &q_head->fsf_status_qual,
  80. FSF_STATUS_QUALIFIER_SIZE);
  81. rec->pl_len = q_head->log_length;
  82. zfcp_dbf_pl_write(dbf, (char *)q_pref + q_head->log_start,
  83. rec->pl_len, "fsf_res", req->req_id);
  84. debug_event(dbf->hba, level, rec, sizeof(*rec));
  85. spin_unlock_irqrestore(&dbf->hba_lock, flags);
  86. }
  87. /**
  88. * zfcp_dbf_hba_fsf_fces - trace event for fsf responses related to
  89. * FC Endpoint Security (FCES)
  90. * @tag: tag indicating which kind of FC Endpoint Security event has occurred
  91. * @req: request for which a response was received
  92. * @wwpn: remote port or ZFCP_DBF_INVALID_WWPN
  93. * @fc_security_old: old FC Endpoint Security of FCP device or connection
  94. * @fc_security_new: new FC Endpoint Security of FCP device or connection
  95. */
  96. void zfcp_dbf_hba_fsf_fces(char *tag, const struct zfcp_fsf_req *req, u64 wwpn,
  97. u32 fc_security_old, u32 fc_security_new)
  98. {
  99. struct zfcp_dbf *dbf = req->adapter->dbf;
  100. struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix;
  101. struct fsf_qtcb_header *q_head = &req->qtcb->header;
  102. struct zfcp_dbf_hba *rec = &dbf->hba_buf;
  103. static int const level = 3;
  104. unsigned long flags;
  105. if (unlikely(!debug_level_enabled(dbf->hba, level)))
  106. return;
  107. spin_lock_irqsave(&dbf->hba_lock, flags);
  108. memset(rec, 0, sizeof(*rec));
  109. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  110. rec->id = ZFCP_DBF_HBA_FCES;
  111. rec->fsf_req_id = req->req_id;
  112. rec->fsf_req_status = req->status;
  113. rec->fsf_cmd = q_head->fsf_command;
  114. rec->fsf_seq_no = q_pref->req_seq_no;
  115. rec->u.fces.req_issued = req->issued;
  116. rec->u.fces.fsf_status = q_head->fsf_status;
  117. rec->u.fces.port_handle = q_head->port_handle;
  118. rec->u.fces.wwpn = wwpn;
  119. rec->u.fces.fc_security_old = fc_security_old;
  120. rec->u.fces.fc_security_new = fc_security_new;
  121. debug_event(dbf->hba, level, rec, sizeof(*rec));
  122. spin_unlock_irqrestore(&dbf->hba_lock, flags);
  123. }
  124. /**
  125. * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer
  126. * @tag: tag indicating which kind of unsolicited status has been received
  127. * @req: request providing the unsolicited status
  128. */
  129. void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req)
  130. {
  131. struct zfcp_dbf *dbf = req->adapter->dbf;
  132. struct fsf_status_read_buffer *srb = req->data;
  133. struct zfcp_dbf_hba *rec = &dbf->hba_buf;
  134. static int const level = 2;
  135. unsigned long flags;
  136. if (unlikely(!debug_level_enabled(dbf->hba, level)))
  137. return;
  138. spin_lock_irqsave(&dbf->hba_lock, flags);
  139. memset(rec, 0, sizeof(*rec));
  140. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  141. rec->id = ZFCP_DBF_HBA_USS;
  142. rec->fsf_req_id = req->req_id;
  143. rec->fsf_req_status = req->status;
  144. rec->fsf_cmd = FSF_QTCB_UNSOLICITED_STATUS;
  145. if (!srb)
  146. goto log;
  147. rec->u.uss.status_type = srb->status_type;
  148. rec->u.uss.status_subtype = srb->status_subtype;
  149. rec->u.uss.d_id = ntoh24(srb->d_id);
  150. rec->u.uss.lun = srb->fcp_lun;
  151. memcpy(&rec->u.uss.queue_designator, &srb->queue_designator,
  152. sizeof(rec->u.uss.queue_designator));
  153. /* status read buffer payload length */
  154. rec->pl_len = (!srb->length) ? 0 : srb->length -
  155. offsetof(struct fsf_status_read_buffer, payload);
  156. if (rec->pl_len)
  157. zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len,
  158. "fsf_uss", req->req_id);
  159. log:
  160. debug_event(dbf->hba, level, rec, sizeof(*rec));
  161. spin_unlock_irqrestore(&dbf->hba_lock, flags);
  162. }
  163. /**
  164. * zfcp_dbf_hba_bit_err - trace event for bit error conditions
  165. * @tag: tag indicating which kind of bit error unsolicited status was received
  166. * @req: request which caused the bit_error condition
  167. */
  168. void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req)
  169. {
  170. struct zfcp_dbf *dbf = req->adapter->dbf;
  171. struct zfcp_dbf_hba *rec = &dbf->hba_buf;
  172. struct fsf_status_read_buffer *sr_buf = req->data;
  173. static int const level = 1;
  174. unsigned long flags;
  175. if (unlikely(!debug_level_enabled(dbf->hba, level)))
  176. return;
  177. spin_lock_irqsave(&dbf->hba_lock, flags);
  178. memset(rec, 0, sizeof(*rec));
  179. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  180. rec->id = ZFCP_DBF_HBA_BIT;
  181. rec->fsf_req_id = req->req_id;
  182. rec->fsf_req_status = req->status;
  183. rec->fsf_cmd = FSF_QTCB_UNSOLICITED_STATUS;
  184. memcpy(&rec->u.be, &sr_buf->payload.bit_error,
  185. sizeof(struct fsf_bit_error_payload));
  186. debug_event(dbf->hba, level, rec, sizeof(*rec));
  187. spin_unlock_irqrestore(&dbf->hba_lock, flags);
  188. }
  189. /**
  190. * zfcp_dbf_hba_def_err - trace event for deferred error messages
  191. * @adapter: pointer to struct zfcp_adapter
  192. * @req_id: request id which caused the deferred error message
  193. * @scount: number of sbals incl. the signaling sbal
  194. * @pl: array of all involved sbals
  195. */
  196. void zfcp_dbf_hba_def_err(struct zfcp_adapter *adapter, u64 req_id, u16 scount,
  197. void **pl)
  198. {
  199. struct zfcp_dbf *dbf = adapter->dbf;
  200. struct zfcp_dbf_pay *payload = &dbf->pay_buf;
  201. unsigned long flags;
  202. static int const level = 1;
  203. u16 length;
  204. if (unlikely(!debug_level_enabled(dbf->pay, level)))
  205. return;
  206. if (!pl)
  207. return;
  208. spin_lock_irqsave(&dbf->pay_lock, flags);
  209. memset(payload, 0, sizeof(*payload));
  210. memcpy(payload->area, "def_err", 7);
  211. payload->fsf_req_id = req_id;
  212. payload->counter = 0;
  213. length = min((u16)sizeof(struct qdio_buffer),
  214. (u16)ZFCP_DBF_PAY_MAX_REC);
  215. while (payload->counter < scount && (char *)pl[payload->counter]) {
  216. memcpy(payload->data, (char *)pl[payload->counter], length);
  217. debug_event(dbf->pay, level, payload, zfcp_dbf_plen(length));
  218. payload->counter++;
  219. }
  220. spin_unlock_irqrestore(&dbf->pay_lock, flags);
  221. }
  222. /**
  223. * zfcp_dbf_hba_basic - trace event for basic adapter events
  224. * @tag: identifier for event
  225. * @adapter: pointer to struct zfcp_adapter
  226. */
  227. void zfcp_dbf_hba_basic(char *tag, struct zfcp_adapter *adapter)
  228. {
  229. struct zfcp_dbf *dbf = adapter->dbf;
  230. struct zfcp_dbf_hba *rec = &dbf->hba_buf;
  231. static int const level = 1;
  232. unsigned long flags;
  233. if (unlikely(!debug_level_enabled(dbf->hba, level)))
  234. return;
  235. spin_lock_irqsave(&dbf->hba_lock, flags);
  236. memset(rec, 0, sizeof(*rec));
  237. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  238. rec->id = ZFCP_DBF_HBA_BASIC;
  239. debug_event(dbf->hba, level, rec, sizeof(*rec));
  240. spin_unlock_irqrestore(&dbf->hba_lock, flags);
  241. }
  242. static void zfcp_dbf_set_common(struct zfcp_dbf_rec *rec,
  243. struct zfcp_adapter *adapter,
  244. struct zfcp_port *port,
  245. struct scsi_device *sdev)
  246. {
  247. rec->adapter_status = atomic_read(&adapter->status);
  248. if (port) {
  249. rec->port_status = atomic_read(&port->status);
  250. rec->wwpn = port->wwpn;
  251. rec->d_id = port->d_id;
  252. }
  253. if (sdev) {
  254. rec->lun_status = atomic_read(&sdev_to_zfcp(sdev)->status);
  255. rec->lun = zfcp_scsi_dev_lun(sdev);
  256. } else
  257. rec->lun = ZFCP_DBF_INVALID_LUN;
  258. }
  259. /**
  260. * zfcp_dbf_rec_trig - trace event related to triggered recovery
  261. * @tag: identifier for event
  262. * @adapter: adapter on which the erp_action should run
  263. * @port: remote port involved in the erp_action
  264. * @sdev: scsi device involved in the erp_action
  265. * @want: wanted erp_action
  266. * @need: required erp_action
  267. *
  268. * The adapter->erp_lock has to be held.
  269. */
  270. void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter,
  271. struct zfcp_port *port, struct scsi_device *sdev,
  272. u8 want, u8 need)
  273. {
  274. struct zfcp_dbf *dbf = adapter->dbf;
  275. struct zfcp_dbf_rec *rec = &dbf->rec_buf;
  276. static int const level = 1;
  277. struct list_head *entry;
  278. unsigned long flags;
  279. lockdep_assert_held(&adapter->erp_lock);
  280. if (unlikely(!debug_level_enabled(dbf->rec, level)))
  281. return;
  282. spin_lock_irqsave(&dbf->rec_lock, flags);
  283. memset(rec, 0, sizeof(*rec));
  284. rec->id = ZFCP_DBF_REC_TRIG;
  285. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  286. zfcp_dbf_set_common(rec, adapter, port, sdev);
  287. list_for_each(entry, &adapter->erp_ready_head)
  288. rec->u.trig.ready++;
  289. list_for_each(entry, &adapter->erp_running_head)
  290. rec->u.trig.running++;
  291. rec->u.trig.want = want;
  292. rec->u.trig.need = need;
  293. debug_event(dbf->rec, level, rec, sizeof(*rec));
  294. spin_unlock_irqrestore(&dbf->rec_lock, flags);
  295. }
  296. /**
  297. * zfcp_dbf_rec_trig_lock - trace event related to triggered recovery with lock
  298. * @tag: identifier for event
  299. * @adapter: adapter on which the erp_action should run
  300. * @port: remote port involved in the erp_action
  301. * @sdev: scsi device involved in the erp_action
  302. * @want: wanted erp_action
  303. * @need: required erp_action
  304. *
  305. * The adapter->erp_lock must not be held.
  306. */
  307. void zfcp_dbf_rec_trig_lock(char *tag, struct zfcp_adapter *adapter,
  308. struct zfcp_port *port, struct scsi_device *sdev,
  309. u8 want, u8 need)
  310. {
  311. unsigned long flags;
  312. read_lock_irqsave(&adapter->erp_lock, flags);
  313. zfcp_dbf_rec_trig(tag, adapter, port, sdev, want, need);
  314. read_unlock_irqrestore(&adapter->erp_lock, flags);
  315. }
  316. /**
  317. * zfcp_dbf_rec_run_lvl - trace event related to running recovery
  318. * @level: trace level to be used for event
  319. * @tag: identifier for event
  320. * @erp: erp_action running
  321. */
  322. void zfcp_dbf_rec_run_lvl(int level, char *tag, struct zfcp_erp_action *erp)
  323. {
  324. struct zfcp_dbf *dbf = erp->adapter->dbf;
  325. struct zfcp_dbf_rec *rec = &dbf->rec_buf;
  326. unsigned long flags;
  327. if (!debug_level_enabled(dbf->rec, level))
  328. return;
  329. spin_lock_irqsave(&dbf->rec_lock, flags);
  330. memset(rec, 0, sizeof(*rec));
  331. rec->id = ZFCP_DBF_REC_RUN;
  332. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  333. zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev);
  334. rec->u.run.fsf_req_id = erp->fsf_req_id;
  335. rec->u.run.rec_status = erp->status;
  336. rec->u.run.rec_step = erp->step;
  337. rec->u.run.rec_action = erp->type;
  338. if (erp->sdev)
  339. rec->u.run.rec_count =
  340. atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter);
  341. else if (erp->port)
  342. rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);
  343. else
  344. rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);
  345. debug_event(dbf->rec, level, rec, sizeof(*rec));
  346. spin_unlock_irqrestore(&dbf->rec_lock, flags);
  347. }
  348. /**
  349. * zfcp_dbf_rec_run - trace event related to running recovery
  350. * @tag: identifier for event
  351. * @erp: erp_action running
  352. */
  353. void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp)
  354. {
  355. zfcp_dbf_rec_run_lvl(1, tag, erp);
  356. }
  357. /**
  358. * zfcp_dbf_rec_run_wka - trace wka port event with info like running recovery
  359. * @tag: identifier for event
  360. * @wka_port: well known address port
  361. * @req_id: request ID to correlate with potential HBA trace record
  362. */
  363. void zfcp_dbf_rec_run_wka(char *tag, struct zfcp_fc_wka_port *wka_port,
  364. u64 req_id)
  365. {
  366. struct zfcp_dbf *dbf = wka_port->adapter->dbf;
  367. struct zfcp_dbf_rec *rec = &dbf->rec_buf;
  368. static int const level = 1;
  369. unsigned long flags;
  370. if (unlikely(!debug_level_enabled(dbf->rec, level)))
  371. return;
  372. spin_lock_irqsave(&dbf->rec_lock, flags);
  373. memset(rec, 0, sizeof(*rec));
  374. rec->id = ZFCP_DBF_REC_RUN;
  375. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  376. rec->port_status = wka_port->status;
  377. rec->d_id = wka_port->d_id;
  378. rec->lun = ZFCP_DBF_INVALID_LUN;
  379. rec->u.run.fsf_req_id = req_id;
  380. rec->u.run.rec_status = ~0;
  381. rec->u.run.rec_step = ~0;
  382. rec->u.run.rec_action = ~0;
  383. rec->u.run.rec_count = ~0;
  384. debug_event(dbf->rec, level, rec, sizeof(*rec));
  385. spin_unlock_irqrestore(&dbf->rec_lock, flags);
  386. }
  387. #define ZFCP_DBF_SAN_LEVEL 1
  388. static inline
  389. void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf,
  390. char *paytag, struct scatterlist *sg, u8 id, u16 len,
  391. u64 req_id, u32 d_id, u16 cap_len)
  392. {
  393. struct zfcp_dbf_san *rec = &dbf->san_buf;
  394. u16 rec_len;
  395. unsigned long flags;
  396. struct zfcp_dbf_pay *payload = &dbf->pay_buf;
  397. u16 pay_sum = 0;
  398. spin_lock_irqsave(&dbf->san_lock, flags);
  399. memset(rec, 0, sizeof(*rec));
  400. rec->id = id;
  401. rec->fsf_req_id = req_id;
  402. rec->d_id = d_id;
  403. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  404. rec->pl_len = len; /* full length even if we cap pay below */
  405. if (!sg)
  406. goto out;
  407. rec_len = min_t(unsigned int, sg->length, ZFCP_DBF_SAN_MAX_PAYLOAD);
  408. memcpy(rec->payload, sg_virt(sg), rec_len); /* part of 1st sg entry */
  409. if (len <= rec_len)
  410. goto out; /* skip pay record if full content in rec->payload */
  411. /* if (len > rec_len):
  412. * dump data up to cap_len ignoring small duplicate in rec->payload
  413. */
  414. spin_lock(&dbf->pay_lock);
  415. memset(payload, 0, sizeof(*payload));
  416. memcpy(payload->area, paytag, ZFCP_DBF_TAG_LEN);
  417. payload->fsf_req_id = req_id;
  418. payload->counter = 0;
  419. for (; sg && pay_sum < cap_len; sg = sg_next(sg)) {
  420. u16 pay_len, offset = 0;
  421. while (offset < sg->length && pay_sum < cap_len) {
  422. pay_len = min((u16)ZFCP_DBF_PAY_MAX_REC,
  423. (u16)(sg->length - offset));
  424. /* cap_len <= pay_sum < cap_len+ZFCP_DBF_PAY_MAX_REC */
  425. memcpy(payload->data, sg_virt(sg) + offset, pay_len);
  426. debug_event(dbf->pay, ZFCP_DBF_SAN_LEVEL, payload,
  427. zfcp_dbf_plen(pay_len));
  428. payload->counter++;
  429. offset += pay_len;
  430. pay_sum += pay_len;
  431. }
  432. }
  433. spin_unlock(&dbf->pay_lock);
  434. out:
  435. debug_event(dbf->san, ZFCP_DBF_SAN_LEVEL, rec, sizeof(*rec));
  436. spin_unlock_irqrestore(&dbf->san_lock, flags);
  437. }
  438. /**
  439. * zfcp_dbf_san_req - trace event for issued SAN request
  440. * @tag: identifier for event
  441. * @fsf: request containing issued CT or ELS data
  442. * @d_id: N_Port_ID where SAN request is sent to
  443. * d_id: destination ID
  444. */
  445. void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id)
  446. {
  447. struct zfcp_dbf *dbf = fsf->adapter->dbf;
  448. struct zfcp_fsf_ct_els *ct_els = fsf->data;
  449. u16 length;
  450. if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
  451. return;
  452. length = (u16)zfcp_qdio_real_bytes(ct_els->req);
  453. zfcp_dbf_san(tag, dbf, "san_req", ct_els->req, ZFCP_DBF_SAN_REQ,
  454. length, fsf->req_id, d_id, length);
  455. }
  456. static u16 zfcp_dbf_san_res_cap_len_if_gpn_ft(char *tag,
  457. struct zfcp_fsf_req *fsf,
  458. u16 len)
  459. {
  460. struct zfcp_fsf_ct_els *ct_els = fsf->data;
  461. struct fc_ct_hdr *reqh = sg_virt(ct_els->req);
  462. struct fc_ns_gid_ft *reqn = (struct fc_ns_gid_ft *)(reqh + 1);
  463. struct scatterlist *resp_entry = ct_els->resp;
  464. struct fc_ct_hdr *resph;
  465. struct fc_gpn_ft_resp *acc;
  466. int max_entries, x, last = 0;
  467. if (!(memcmp(tag, "fsscth2", 7) == 0
  468. && ct_els->d_id == FC_FID_DIR_SERV
  469. && reqh->ct_rev == FC_CT_REV
  470. && reqh->ct_in_id[0] == 0
  471. && reqh->ct_in_id[1] == 0
  472. && reqh->ct_in_id[2] == 0
  473. && reqh->ct_fs_type == FC_FST_DIR
  474. && reqh->ct_fs_subtype == FC_NS_SUBTYPE
  475. && reqh->ct_options == 0
  476. && reqh->_ct_resvd1 == 0
  477. && reqh->ct_cmd == cpu_to_be16(FC_NS_GPN_FT)
  478. /* reqh->ct_mr_size can vary so do not match but read below */
  479. && reqh->_ct_resvd2 == 0
  480. && reqh->ct_reason == 0
  481. && reqh->ct_explan == 0
  482. && reqh->ct_vendor == 0
  483. && reqn->fn_resvd == 0
  484. && reqn->fn_domain_id_scope == 0
  485. && reqn->fn_area_id_scope == 0
  486. && reqn->fn_fc4_type == FC_TYPE_FCP))
  487. return len; /* not GPN_FT response so do not cap */
  488. acc = sg_virt(resp_entry);
  489. /* cap all but accept CT responses to at least the CT header */
  490. resph = (struct fc_ct_hdr *)acc;
  491. if ((ct_els->status) ||
  492. (resph->ct_cmd != cpu_to_be16(FC_FS_ACC)))
  493. return max(FC_CT_HDR_LEN, ZFCP_DBF_SAN_MAX_PAYLOAD);
  494. max_entries = (be16_to_cpu(reqh->ct_mr_size) * 4 /
  495. sizeof(struct fc_gpn_ft_resp))
  496. + 1 /* zfcp_fc_scan_ports: bytes correct, entries off-by-one
  497. * to account for header as 1st pseudo "entry" */;
  498. /* the basic CT_IU preamble is the same size as one entry in the GPN_FT
  499. * response, allowing us to skip special handling for it - just skip it
  500. */
  501. for (x = 1; x < max_entries && !last; x++) {
  502. if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
  503. acc++;
  504. else
  505. acc = sg_virt(++resp_entry);
  506. last = acc->fp_flags & FC_NS_FID_LAST;
  507. }
  508. len = min(len, (u16)(x * sizeof(struct fc_gpn_ft_resp)));
  509. return len; /* cap after last entry */
  510. }
  511. /**
  512. * zfcp_dbf_san_res - trace event for received SAN request
  513. * @tag: identifier for event
  514. * @fsf: request containing received CT or ELS data
  515. */
  516. void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf)
  517. {
  518. struct zfcp_dbf *dbf = fsf->adapter->dbf;
  519. struct zfcp_fsf_ct_els *ct_els = fsf->data;
  520. u16 length;
  521. if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
  522. return;
  523. length = (u16)zfcp_qdio_real_bytes(ct_els->resp);
  524. zfcp_dbf_san(tag, dbf, "san_res", ct_els->resp, ZFCP_DBF_SAN_RES,
  525. length, fsf->req_id, ct_els->d_id,
  526. zfcp_dbf_san_res_cap_len_if_gpn_ft(tag, fsf, length));
  527. }
  528. /**
  529. * zfcp_dbf_san_in_els - trace event for incoming ELS
  530. * @tag: identifier for event
  531. * @fsf: request containing received ELS data
  532. */
  533. void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf)
  534. {
  535. struct zfcp_dbf *dbf = fsf->adapter->dbf;
  536. struct fsf_status_read_buffer *srb =
  537. (struct fsf_status_read_buffer *) fsf->data;
  538. u16 length;
  539. struct scatterlist sg;
  540. if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
  541. return;
  542. length = (u16)(srb->length -
  543. offsetof(struct fsf_status_read_buffer, payload));
  544. sg_init_one(&sg, srb->payload.data, length);
  545. zfcp_dbf_san(tag, dbf, "san_els", &sg, ZFCP_DBF_SAN_ELS, length,
  546. fsf->req_id, ntoh24(srb->d_id), length);
  547. }
  548. /**
  549. * zfcp_dbf_scsi_common() - Common trace event helper for scsi.
  550. * @tag: Identifier for event.
  551. * @level: trace level of event.
  552. * @sdev: Pointer to SCSI device as context for this event.
  553. * @sc: Pointer to SCSI command, or NULL with task management function (TMF).
  554. * @fsf: Pointer to FSF request, or NULL.
  555. */
  556. void zfcp_dbf_scsi_common(char *tag, int level, struct scsi_device *sdev,
  557. struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf)
  558. {
  559. struct zfcp_adapter *adapter =
  560. (struct zfcp_adapter *) sdev->host->hostdata[0];
  561. struct zfcp_dbf *dbf = adapter->dbf;
  562. struct zfcp_dbf_scsi *rec = &dbf->scsi_buf;
  563. struct fcp_resp_with_ext *fcp_rsp;
  564. struct fcp_resp_rsp_info *fcp_rsp_info;
  565. unsigned long flags;
  566. spin_lock_irqsave(&dbf->scsi_lock, flags);
  567. memset(rec, 0, sizeof(*rec));
  568. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  569. rec->id = ZFCP_DBF_SCSI_CMND;
  570. if (sc) {
  571. rec->scsi_result = sc->result;
  572. rec->scsi_retries = sc->retries;
  573. rec->scsi_allowed = sc->allowed;
  574. rec->scsi_id = sc->device->id;
  575. rec->scsi_lun = (u32)sc->device->lun;
  576. rec->scsi_lun_64_hi = (u32)(sc->device->lun >> 32);
  577. rec->host_scribble = (unsigned long)sc->host_scribble;
  578. memcpy(rec->scsi_opcode, sc->cmnd,
  579. min_t(int, sc->cmd_len, ZFCP_DBF_SCSI_OPCODE));
  580. } else {
  581. rec->scsi_result = ~0;
  582. rec->scsi_retries = ~0;
  583. rec->scsi_allowed = ~0;
  584. rec->scsi_id = sdev->id;
  585. rec->scsi_lun = (u32)sdev->lun;
  586. rec->scsi_lun_64_hi = (u32)(sdev->lun >> 32);
  587. rec->host_scribble = ~0;
  588. memset(rec->scsi_opcode, 0xff, ZFCP_DBF_SCSI_OPCODE);
  589. }
  590. if (fsf) {
  591. rec->fsf_req_id = fsf->req_id;
  592. rec->pl_len = FCP_RESP_WITH_EXT;
  593. fcp_rsp = &(fsf->qtcb->bottom.io.fcp_rsp.iu);
  594. /* mandatory parts of FCP_RSP IU in this SCSI record */
  595. memcpy(&rec->fcp_rsp, fcp_rsp, FCP_RESP_WITH_EXT);
  596. if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) {
  597. fcp_rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
  598. rec->fcp_rsp_info = fcp_rsp_info->rsp_code;
  599. rec->pl_len += be32_to_cpu(fcp_rsp->ext.fr_rsp_len);
  600. }
  601. if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
  602. rec->pl_len += be32_to_cpu(fcp_rsp->ext.fr_sns_len);
  603. }
  604. /* complete FCP_RSP IU in associated PAYload record
  605. * but only if there are optional parts
  606. */
  607. if (fcp_rsp->resp.fr_flags != 0)
  608. zfcp_dbf_pl_write(
  609. dbf, fcp_rsp,
  610. /* at least one full PAY record
  611. * but not beyond hardware response field
  612. */
  613. min_t(u16, max_t(u16, rec->pl_len,
  614. ZFCP_DBF_PAY_MAX_REC),
  615. FSF_FCP_RSP_SIZE),
  616. "fcp_riu", fsf->req_id);
  617. }
  618. debug_event(dbf->scsi, level, rec, sizeof(*rec));
  619. spin_unlock_irqrestore(&dbf->scsi_lock, flags);
  620. }
  621. /**
  622. * zfcp_dbf_scsi_eh() - Trace event for special cases of scsi_eh callbacks.
  623. * @tag: Identifier for event.
  624. * @adapter: Pointer to zfcp adapter as context for this event.
  625. * @scsi_id: SCSI ID/target to indicate scope of task management function (TMF).
  626. * @ret: Return value of calling function.
  627. *
  628. * This SCSI trace variant does not depend on any of:
  629. * scsi_cmnd, zfcp_fsf_req, scsi_device.
  630. */
  631. void zfcp_dbf_scsi_eh(char *tag, struct zfcp_adapter *adapter,
  632. unsigned int scsi_id, int ret)
  633. {
  634. struct zfcp_dbf *dbf = adapter->dbf;
  635. struct zfcp_dbf_scsi *rec = &dbf->scsi_buf;
  636. unsigned long flags;
  637. static int const level = 1;
  638. if (unlikely(!debug_level_enabled(adapter->dbf->scsi, level)))
  639. return;
  640. spin_lock_irqsave(&dbf->scsi_lock, flags);
  641. memset(rec, 0, sizeof(*rec));
  642. memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
  643. rec->id = ZFCP_DBF_SCSI_CMND;
  644. rec->scsi_result = ret; /* re-use field, int is 4 bytes and fits */
  645. rec->scsi_retries = ~0;
  646. rec->scsi_allowed = ~0;
  647. rec->fcp_rsp_info = ~0;
  648. rec->scsi_id = scsi_id;
  649. rec->scsi_lun = (u32)ZFCP_DBF_INVALID_LUN;
  650. rec->scsi_lun_64_hi = (u32)(ZFCP_DBF_INVALID_LUN >> 32);
  651. rec->host_scribble = ~0;
  652. memset(rec->scsi_opcode, 0xff, ZFCP_DBF_SCSI_OPCODE);
  653. debug_event(dbf->scsi, level, rec, sizeof(*rec));
  654. spin_unlock_irqrestore(&dbf->scsi_lock, flags);
  655. }
  656. static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size)
  657. {
  658. struct debug_info *d;
  659. d = debug_register(name, size, 1, rec_size);
  660. if (!d)
  661. return NULL;
  662. debug_register_view(d, &debug_hex_ascii_view);
  663. debug_set_level(d, dbflevel);
  664. return d;
  665. }
  666. static void zfcp_dbf_unregister(struct zfcp_dbf *dbf)
  667. {
  668. if (!dbf)
  669. return;
  670. debug_unregister(dbf->scsi);
  671. debug_unregister(dbf->san);
  672. debug_unregister(dbf->hba);
  673. debug_unregister(dbf->pay);
  674. debug_unregister(dbf->rec);
  675. kfree(dbf);
  676. }
  677. /**
  678. * zfcp_adapter_debug_register - registers debug feature for an adapter
  679. * @adapter: pointer to adapter for which debug features should be registered
  680. * return: -ENOMEM on error, 0 otherwise
  681. */
  682. int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter)
  683. {
  684. char name[DEBUG_MAX_NAME_LEN];
  685. struct zfcp_dbf *dbf;
  686. dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL);
  687. if (!dbf)
  688. return -ENOMEM;
  689. spin_lock_init(&dbf->pay_lock);
  690. spin_lock_init(&dbf->hba_lock);
  691. spin_lock_init(&dbf->san_lock);
  692. spin_lock_init(&dbf->scsi_lock);
  693. spin_lock_init(&dbf->rec_lock);
  694. /* debug feature area which records recovery activity */
  695. sprintf(name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
  696. dbf->rec = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_rec));
  697. if (!dbf->rec)
  698. goto err_out;
  699. /* debug feature area which records HBA (FSF and QDIO) conditions */
  700. sprintf(name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
  701. dbf->hba = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_hba));
  702. if (!dbf->hba)
  703. goto err_out;
  704. /* debug feature area which records payload info */
  705. sprintf(name, "zfcp_%s_pay", dev_name(&adapter->ccw_device->dev));
  706. dbf->pay = zfcp_dbf_reg(name, dbfsize * 2, sizeof(struct zfcp_dbf_pay));
  707. if (!dbf->pay)
  708. goto err_out;
  709. /* debug feature area which records SAN command failures and recovery */
  710. sprintf(name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
  711. dbf->san = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_san));
  712. if (!dbf->san)
  713. goto err_out;
  714. /* debug feature area which records SCSI command failures and recovery */
  715. sprintf(name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
  716. dbf->scsi = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_scsi));
  717. if (!dbf->scsi)
  718. goto err_out;
  719. adapter->dbf = dbf;
  720. return 0;
  721. err_out:
  722. zfcp_dbf_unregister(dbf);
  723. return -ENOMEM;
  724. }
  725. /**
  726. * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
  727. * @adapter: pointer to adapter for which debug features should be unregistered
  728. */
  729. void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter)
  730. {
  731. struct zfcp_dbf *dbf = adapter->dbf;
  732. adapter->dbf = NULL;
  733. zfcp_dbf_unregister(dbf);
  734. }