Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
debug.c
Go to the documentation of this file.
1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/pci.h>
4 #include <linux/i2o.h>
5 
6 static void i2o_report_util_cmd(u8 cmd);
7 static void i2o_report_exec_cmd(u8 cmd);
8 static void i2o_report_fail_status(u8 req_status, u32 * msg);
9 static void i2o_report_common_status(u8 req_status);
10 static void i2o_report_common_dsc(u16 detailed_status);
11 
12 /*
13  * Used for error reporting/debugging purposes.
14  * Report Cmd name, Request status, Detailed Status.
15  */
16 void i2o_report_status(const char *severity, const char *str,
17  struct i2o_message *m)
18 {
19  u32 *msg = (u32 *) m;
20  u8 cmd = (msg[1] >> 24) & 0xFF;
21  u8 req_status = (msg[4] >> 24) & 0xFF;
22  u16 detailed_status = msg[4] & 0xFFFF;
23 
24  if (cmd == I2O_CMD_UTIL_EVT_REGISTER)
25  return; // No status in this reply
26 
27  printk("%s%s: ", severity, str);
28 
29  if (cmd < 0x1F) // Utility cmd
30  i2o_report_util_cmd(cmd);
31 
32  else if (cmd >= 0xA0 && cmd <= 0xEF) // Executive cmd
33  i2o_report_exec_cmd(cmd);
34  else
35  printk("Cmd = %0#2x, ", cmd); // Other cmds
36 
37  if (msg[0] & MSG_FAIL) {
38  i2o_report_fail_status(req_status, msg);
39  return;
40  }
41 
42  i2o_report_common_status(req_status);
43 
44  if (cmd < 0x1F || (cmd >= 0xA0 && cmd <= 0xEF))
45  i2o_report_common_dsc(detailed_status);
46  else
47  printk(" / DetailedStatus = %0#4x.\n",
48  detailed_status);
49 }
50 
51 /* Used to dump a message to syslog during debugging */
52 void i2o_dump_message(struct i2o_message *m)
53 {
54 #ifdef DEBUG
55  u32 *msg = (u32 *) m;
56  int i;
57  printk(KERN_INFO "Dumping I2O message size %d @ %p\n",
58  msg[0] >> 16 & 0xffff, msg);
59  for (i = 0; i < ((msg[0] >> 16) & 0xffff); i++)
60  printk(KERN_INFO " msg[%d] = %0#10x\n", i, msg[i]);
61 #endif
62 }
63 
64 /*
65  * Used for error reporting/debugging purposes.
66  * Following fail status are common to all classes.
67  * The preserved message must be handled in the reply handler.
68  */
69 static void i2o_report_fail_status(u8 req_status, u32 * msg)
70 {
71  static char *FAIL_STATUS[] = {
72  "0x80", /* not used */
73  "SERVICE_SUSPENDED", /* 0x81 */
74  "SERVICE_TERMINATED", /* 0x82 */
75  "CONGESTION",
76  "FAILURE",
77  "STATE_ERROR",
78  "TIME_OUT",
79  "ROUTING_FAILURE",
80  "INVALID_VERSION",
81  "INVALID_OFFSET",
82  "INVALID_MSG_FLAGS",
83  "FRAME_TOO_SMALL",
84  "FRAME_TOO_LARGE",
85  "INVALID_TARGET_ID",
86  "INVALID_INITIATOR_ID",
87  "INVALID_INITIATOR_CONTEX", /* 0x8F */
88  "UNKNOWN_FAILURE" /* 0xFF */
89  };
90 
91  if (req_status == I2O_FSC_TRANSPORT_UNKNOWN_FAILURE)
92  printk("TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n",
93  req_status);
94  else
95  printk("TRANSPORT_%s.\n",
96  FAIL_STATUS[req_status & 0x0F]);
97 
98  /* Dump some details */
99 
100  printk(KERN_ERR " InitiatorId = %d, TargetId = %d\n",
101  (msg[1] >> 12) & 0xFFF, msg[1] & 0xFFF);
102  printk(KERN_ERR " LowestVersion = 0x%02X, HighestVersion = 0x%02X\n",
103  (msg[4] >> 8) & 0xFF, msg[4] & 0xFF);
104  printk(KERN_ERR " FailingHostUnit = 0x%04X, FailingIOP = 0x%03X\n",
105  msg[5] >> 16, msg[5] & 0xFFF);
106 
107  printk(KERN_ERR " Severity: 0x%02X\n", (msg[4] >> 16) & 0xFF);
108  if (msg[4] & (1 << 16))
109  printk(KERN_DEBUG "(FormatError), "
110  "this msg can never be delivered/processed.\n");
111  if (msg[4] & (1 << 17))
112  printk(KERN_DEBUG "(PathError), "
113  "this msg can no longer be delivered/processed.\n");
114  if (msg[4] & (1 << 18))
115  printk(KERN_DEBUG "(PathState), "
116  "the system state does not allow delivery.\n");
117  if (msg[4] & (1 << 19))
118  printk(KERN_DEBUG
119  "(Congestion), resources temporarily not available;"
120  "do not retry immediately.\n");
121 }
122 
123 /*
124  * Used for error reporting/debugging purposes.
125  * Following reply status are common to all classes.
126  */
127 static void i2o_report_common_status(u8 req_status)
128 {
129  static char *REPLY_STATUS[] = {
130  "SUCCESS",
131  "ABORT_DIRTY",
132  "ABORT_NO_DATA_TRANSFER",
133  "ABORT_PARTIAL_TRANSFER",
134  "ERROR_DIRTY",
135  "ERROR_NO_DATA_TRANSFER",
136  "ERROR_PARTIAL_TRANSFER",
137  "PROCESS_ABORT_DIRTY",
138  "PROCESS_ABORT_NO_DATA_TRANSFER",
139  "PROCESS_ABORT_PARTIAL_TRANSFER",
140  "TRANSACTION_ERROR",
141  "PROGRESS_REPORT"
142  };
143 
144  if (req_status >= ARRAY_SIZE(REPLY_STATUS))
145  printk("RequestStatus = %0#2x", req_status);
146  else
147  printk("%s", REPLY_STATUS[req_status]);
148 }
149 
150 /*
151  * Used for error reporting/debugging purposes.
152  * Following detailed status are valid for executive class,
153  * utility class, DDM class and for transaction error replies.
154  */
155 static void i2o_report_common_dsc(u16 detailed_status)
156 {
157  static char *COMMON_DSC[] = {
158  "SUCCESS",
159  "0x01", // not used
160  "BAD_KEY",
161  "TCL_ERROR",
162  "REPLY_BUFFER_FULL",
163  "NO_SUCH_PAGE",
164  "INSUFFICIENT_RESOURCE_SOFT",
165  "INSUFFICIENT_RESOURCE_HARD",
166  "0x08", // not used
167  "CHAIN_BUFFER_TOO_LARGE",
168  "UNSUPPORTED_FUNCTION",
169  "DEVICE_LOCKED",
170  "DEVICE_RESET",
171  "INAPPROPRIATE_FUNCTION",
172  "INVALID_INITIATOR_ADDRESS",
173  "INVALID_MESSAGE_FLAGS",
174  "INVALID_OFFSET",
175  "INVALID_PARAMETER",
176  "INVALID_REQUEST",
177  "INVALID_TARGET_ADDRESS",
178  "MESSAGE_TOO_LARGE",
179  "MESSAGE_TOO_SMALL",
180  "MISSING_PARAMETER",
181  "TIMEOUT",
182  "UNKNOWN_ERROR",
183  "UNKNOWN_FUNCTION",
184  "UNSUPPORTED_VERSION",
185  "DEVICE_BUSY",
186  "DEVICE_NOT_AVAILABLE"
187  };
188 
189  if (detailed_status > I2O_DSC_DEVICE_NOT_AVAILABLE)
190  printk(" / DetailedStatus = %0#4x.\n",
191  detailed_status);
192  else
193  printk(" / %s.\n", COMMON_DSC[detailed_status]);
194 }
195 
196 /*
197  * Used for error reporting/debugging purposes
198  */
199 static void i2o_report_util_cmd(u8 cmd)
200 {
201  switch (cmd) {
202  case I2O_CMD_UTIL_NOP:
203  printk("UTIL_NOP, ");
204  break;
205  case I2O_CMD_UTIL_ABORT:
206  printk("UTIL_ABORT, ");
207  break;
208  case I2O_CMD_UTIL_CLAIM:
209  printk("UTIL_CLAIM, ");
210  break;
211  case I2O_CMD_UTIL_RELEASE:
212  printk("UTIL_CLAIM_RELEASE, ");
213  break;
214  case I2O_CMD_UTIL_CONFIG_DIALOG:
215  printk("UTIL_CONFIG_DIALOG, ");
216  break;
217  case I2O_CMD_UTIL_DEVICE_RESERVE:
218  printk("UTIL_DEVICE_RESERVE, ");
219  break;
220  case I2O_CMD_UTIL_DEVICE_RELEASE:
221  printk("UTIL_DEVICE_RELEASE, ");
222  break;
223  case I2O_CMD_UTIL_EVT_ACK:
224  printk("UTIL_EVENT_ACKNOWLEDGE, ");
225  break;
226  case I2O_CMD_UTIL_EVT_REGISTER:
227  printk("UTIL_EVENT_REGISTER, ");
228  break;
229  case I2O_CMD_UTIL_LOCK:
230  printk("UTIL_LOCK, ");
231  break;
232  case I2O_CMD_UTIL_LOCK_RELEASE:
233  printk("UTIL_LOCK_RELEASE, ");
234  break;
235  case I2O_CMD_UTIL_PARAMS_GET:
236  printk("UTIL_PARAMS_GET, ");
237  break;
238  case I2O_CMD_UTIL_PARAMS_SET:
239  printk("UTIL_PARAMS_SET, ");
240  break;
241  case I2O_CMD_UTIL_REPLY_FAULT_NOTIFY:
242  printk("UTIL_REPLY_FAULT_NOTIFY, ");
243  break;
244  default:
245  printk("Cmd = %0#2x, ", cmd);
246  }
247 }
248 
249 /*
250  * Used for error reporting/debugging purposes
251  */
252 static void i2o_report_exec_cmd(u8 cmd)
253 {
254  switch (cmd) {
255  case I2O_CMD_ADAPTER_ASSIGN:
256  printk("EXEC_ADAPTER_ASSIGN, ");
257  break;
258  case I2O_CMD_ADAPTER_READ:
259  printk("EXEC_ADAPTER_READ, ");
260  break;
261  case I2O_CMD_ADAPTER_RELEASE:
262  printk("EXEC_ADAPTER_RELEASE, ");
263  break;
264  case I2O_CMD_BIOS_INFO_SET:
265  printk("EXEC_BIOS_INFO_SET, ");
266  break;
267  case I2O_CMD_BOOT_DEVICE_SET:
268  printk("EXEC_BOOT_DEVICE_SET, ");
269  break;
270  case I2O_CMD_CONFIG_VALIDATE:
271  printk("EXEC_CONFIG_VALIDATE, ");
272  break;
273  case I2O_CMD_CONN_SETUP:
274  printk("EXEC_CONN_SETUP, ");
275  break;
276  case I2O_CMD_DDM_DESTROY:
277  printk("EXEC_DDM_DESTROY, ");
278  break;
279  case I2O_CMD_DDM_ENABLE:
280  printk("EXEC_DDM_ENABLE, ");
281  break;
282  case I2O_CMD_DDM_QUIESCE:
283  printk("EXEC_DDM_QUIESCE, ");
284  break;
285  case I2O_CMD_DDM_RESET:
286  printk("EXEC_DDM_RESET, ");
287  break;
288  case I2O_CMD_DDM_SUSPEND:
289  printk("EXEC_DDM_SUSPEND, ");
290  break;
291  case I2O_CMD_DEVICE_ASSIGN:
292  printk("EXEC_DEVICE_ASSIGN, ");
293  break;
294  case I2O_CMD_DEVICE_RELEASE:
295  printk("EXEC_DEVICE_RELEASE, ");
296  break;
297  case I2O_CMD_HRT_GET:
298  printk("EXEC_HRT_GET, ");
299  break;
300  case I2O_CMD_ADAPTER_CLEAR:
301  printk("EXEC_IOP_CLEAR, ");
302  break;
303  case I2O_CMD_ADAPTER_CONNECT:
304  printk("EXEC_IOP_CONNECT, ");
305  break;
306  case I2O_CMD_ADAPTER_RESET:
307  printk("EXEC_IOP_RESET, ");
308  break;
309  case I2O_CMD_LCT_NOTIFY:
310  printk("EXEC_LCT_NOTIFY, ");
311  break;
312  case I2O_CMD_OUTBOUND_INIT:
313  printk("EXEC_OUTBOUND_INIT, ");
314  break;
315  case I2O_CMD_PATH_ENABLE:
316  printk("EXEC_PATH_ENABLE, ");
317  break;
318  case I2O_CMD_PATH_QUIESCE:
319  printk("EXEC_PATH_QUIESCE, ");
320  break;
321  case I2O_CMD_PATH_RESET:
322  printk("EXEC_PATH_RESET, ");
323  break;
324  case I2O_CMD_STATIC_MF_CREATE:
325  printk("EXEC_STATIC_MF_CREATE, ");
326  break;
327  case I2O_CMD_STATIC_MF_RELEASE:
328  printk("EXEC_STATIC_MF_RELEASE, ");
329  break;
330  case I2O_CMD_STATUS_GET:
331  printk("EXEC_STATUS_GET, ");
332  break;
333  case I2O_CMD_SW_DOWNLOAD:
334  printk("EXEC_SW_DOWNLOAD, ");
335  break;
336  case I2O_CMD_SW_UPLOAD:
337  printk("EXEC_SW_UPLOAD, ");
338  break;
339  case I2O_CMD_SW_REMOVE:
340  printk("EXEC_SW_REMOVE, ");
341  break;
342  case I2O_CMD_SYS_ENABLE:
343  printk("EXEC_SYS_ENABLE, ");
344  break;
345  case I2O_CMD_SYS_MODIFY:
346  printk("EXEC_SYS_MODIFY, ");
347  break;
348  case I2O_CMD_SYS_QUIESCE:
349  printk("EXEC_SYS_QUIESCE, ");
350  break;
351  case I2O_CMD_SYS_TAB_SET:
352  printk("EXEC_SYS_TAB_SET, ");
353  break;
354  default:
355  printk("Cmd = %#02x, ", cmd);
356  }
357 }
358 
359 void i2o_debug_state(struct i2o_controller *c)
360 {
361  printk(KERN_INFO "%s: State = ", c->name);
362  switch (((i2o_status_block *) c->status_block.virt)->iop_state) {
363  case 0x01:
364  printk("INIT\n");
365  break;
366  case 0x02:
367  printk("RESET\n");
368  break;
369  case 0x04:
370  printk("HOLD\n");
371  break;
372  case 0x05:
373  printk("READY\n");
374  break;
375  case 0x08:
376  printk("OPERATIONAL\n");
377  break;
378  case 0x10:
379  printk("FAILED\n");
380  break;
381  case 0x11:
382  printk("FAULTED\n");
383  break;
384  default:
385  printk("%x (unknown !!)\n",
386  ((i2o_status_block *) c->status_block.virt)->iop_state);
387  }
388 };
389 
390 void i2o_dump_hrt(struct i2o_controller *c)
391 {
392  u32 *rows = (u32 *) c->hrt.virt;
393  u8 *p = (u8 *) c->hrt.virt;
394  u8 *d;
395  int count;
396  int length;
397  int i;
398  int state;
399 
400  if (p[3] != 0) {
401  printk(KERN_ERR
402  "%s: HRT table for controller is too new a version.\n",
403  c->name);
404  return;
405  }
406 
407  count = p[0] | (p[1] << 8);
408  length = p[2];
409 
410  printk(KERN_INFO "%s: HRT has %d entries of %d bytes each.\n",
411  c->name, count, length << 2);
412 
413  rows += 2;
414 
415  for (i = 0; i < count; i++) {
416  printk(KERN_INFO "Adapter %08X: ", rows[0]);
417  p = (u8 *) (rows + 1);
418  d = (u8 *) (rows + 2);
419  state = p[1] << 8 | p[0];
420 
421  printk("TID %04X:[", state & 0xFFF);
422  state >>= 12;
423  if (state & (1 << 0))
424  printk("H"); /* Hidden */
425  if (state & (1 << 2)) {
426  printk("P"); /* Present */
427  if (state & (1 << 1))
428  printk("C"); /* Controlled */
429  }
430  if (state > 9)
431  printk("*"); /* Hard */
432 
433  printk("]:");
434 
435  switch (p[3] & 0xFFFF) {
436  case 0:
437  /* Adapter private bus - easy */
438  printk("Local bus %d: I/O at 0x%04X Mem 0x%08X", p[2],
439  d[1] << 8 | d[0], *(u32 *) (d + 4));
440  break;
441  case 1:
442  /* ISA bus */
443  printk("ISA %d: CSN %d I/O at 0x%04X Mem 0x%08X", p[2],
444  d[2], d[1] << 8 | d[0], *(u32 *) (d + 4));
445  break;
446 
447  case 2: /* EISA bus */
448  printk("EISA %d: Slot %d I/O at 0x%04X Mem 0x%08X",
449  p[2], d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
450  break;
451 
452  case 3: /* MCA bus */
453  printk("MCA %d: Slot %d I/O at 0x%04X Mem 0x%08X", p[2],
454  d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
455  break;
456 
457  case 4: /* PCI bus */
458  printk("PCI %d: Bus %d Device %d Function %d", p[2],
459  d[2], d[1], d[0]);
460  break;
461 
462  case 0x80: /* Other */
463  default:
464  printk("Unsupported bus type.");
465  break;
466  }
467  printk("\n");
468  rows += length;
469  }
470 }
471 
472 EXPORT_SYMBOL(i2o_dump_message);
Generated on Thu Jan 10 2013 13:07:47 for Linux Kernel by   doxygen 1.8.2