![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / dump / src|
Return to dump.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / dump / src |
1.1 root 1: /*
2: * The code in this file is taken from the example dump module listing in
3: * Appendix B of the STREAMS Programmer's Guide for System V, Release 4 Multi-
4: * Processor (Intel Edition). The overall structure of the code has been
5: * retained, with some editing to reflect local coding standards, additional
6: * commentary, and to bring the code up to SVR4MP DDI/DKI standards.
7: */
8:
9: #define _DDI_DKI 1
10: #define _SYSV4 1
11:
12: #include <common/ccompat.h>
13: #include <sys/inline.h>
14: #include <sys/file.h>
15: #include <sys/errno.h>
16: #include <stddef.h>
17:
18: /*
19: * DUMP Module. This module prints data and ioctls going to and from a device
20: * in real time. Printout is on the console. Usage is to push it on a stream
21: * between any other modules.
22: *
23: * It accepts two ioctls:
24: * DUMP_VERB Verbose printing of M_DATA (default)
25: * DUMP_TERSE Terse printing of data
26: *
27: * The messages it prints begin with "I:" for incoming, "O:" for outgoing
28: * data. "Ci" or "Co" are for non-data (control) messages. Data is printed in
29: * character or hexadecimal format delimited by {{ and }} at message
30: * boundaries.
31: */
32:
33: #include "sys/types.h"
34: #include "sys/stream.h"
35: #include "sys/cmn_err.h"
36: #include "dump.h"
37:
38: static struct module_info dumprinfo = {
39: 0x6475, "dump", 0, INFPSZ, 0, 0
40: };
41: static struct module_info dumpwinfo = {
42: 0x6475, "dump", 0, INFPSZ, 0, 0
43: };
44:
45:
46: static int dumpopen __PROTO ((queue_t * q, dev_t * devp, int flag,
47: int sflag, cred_t * credp));
48: static int dumpclose __PROTO ((queue_t * q, int flag,
49: cred_t * credp));
50: static void dumpwput __PROTO ((queue_t * q, mblk_t * mp));
51: static void dumprput __PROTO ((queue_t * q, mblk_t * mp));
52:
53: static struct qinit rinit = {
54: dumprput, NULL, dumpopen, dumpclose, NULL, & dumprinfo, NULL
55: };
56: static struct qinit winit = {
57: dumpwput, NULL, NULL, NULL, NULL, & dumpwinfo, NULL
58: };
59:
60: struct streamtab dumpinfo = {
61: & rinit, & winit, NULL, NULL
62: };
63:
64: int dumpdevflag = 0;
65:
66:
67: /*
68: * Gather information from this data message and print it. The caller deals
69: * with actually forwarding the data message.
70: */
71:
72: #if __USE_PROTO__
73: __LOCAL__ void (dumpgather) (queue_t * q, mblk_t * mp, dm_dir_t dir)
74: #else
75: __LOCAL__ void
76: dumpgather __ARGS ((q, mp, dir))
77: queue_t * q;
78: mblk_t * mp;
79: dm_dir_t dir;
80: #endif
81: {
82: struct dm_str * d = (struct dm_str *) q->q_ptr;
83: pl_t prev_pl;
84: mblk_t * tmp;
85: unsigned long counter;
86: char junk [2];
87:
88: /*
89: * Check state and print direction indication when it changes.
90: */
91:
92: if (d->dm_dir != dir) {
93:
94: d->dm_dir = dir;
95: cmn_err (CE_CONT, dir == D_IN ? "^\nIN:" : "^\nOUT:");
96: }
97:
98: if (mp->b_datap == NULL ||
99: (mp->b_rptr == mp->b_wptr && mp->b_cont == NULL)) {
100: /*
101: * Zero-length messages are treated specially in most streams,
102: * note them specially.
103: */
104:
105: cmn_err (CE_CONT, "^DUMP: Zero-length data message\n");
106: return;
107: }
108:
109: cmn_err (CE_CONT, "^ {{");
110:
111: tmp = mp;
112: counter = 0;
113: junk [1] = 0;
114:
115: prev_pl = splstr ();
116:
117: do {
118: unsigned char * readp;
119:
120: if ((d->dm_flags & D_VERB) == 0) {
121:
122: counter += tmp->b_wptr - tmp->b_rptr;
123: continue;
124: }
125:
126: for (readp = tmp->b_rptr ; readp < tmp->b_wptr ; readp ++)
127: if ((junk [0] = * readp) >= ' ' && junk [0] <= '~')
128: cmn_err (CE_CONT, "^ %s", junk);
129: else
130: cmn_err (CE_CONT, "^ 0x%x", junk [0]);
131:
132: } while ((tmp = tmp->b_cont) != NULL &&
133: tmp->b_datap->db_type == M_DATA);
134:
135:
136: if ((d->dm_flags & D_VERB) == 0)
137: cmn_err (CE_CONT, "^ %d", counter);
138:
139: cmn_err (CE_CONT, "^ }} ");
140:
141: if (tmp != NULL)
142: cmn_err (CE_CONT, "^\nDUMP: non-data b_cont\n");
143:
144: splx (prev_pl);
145: }
146:
147:
148: /*
149: * Completely handle one of our ioctl () calls, including the qreply () of the
150: * message.
151: */
152:
153: #if __USE_PROTO__
154: __LOCAL__ void (dumpioc) (queue_t * q, mblk_t * mp)
155: #else
156: __LOCAL__ void
157: dumpioc __ARGS ((q, mp))
158: queue_t * q;
159: mblk_t * mp;
160: #endif
161: {
162: struct iocblk * iocp = (struct iocblk *) mp->b_rptr;
163: struct dm_str * d = (struct dm_str *) q->q_ptr;
164:
165: cmn_err (CE_CONT, "^DUMP: own ioctl is ");
166:
167: switch (iocp->ioc_cmd) {
168:
169: case DUMP_VERB:
170: d->dm_flags |= D_VERB;
171: cmn_err (CE_CONT, "^DUMP_VERB\n");
172:
173: mp->b_datap->db_type = M_IOCACK;
174: break;
175:
176: case DUMP_TERSE:
177: d->dm_flags &= ~ D_VERB;
178: cmn_err (CE_CONT, "^DUMP_TERSE\n");
179:
180: mp->b_datap->db_type = M_IOCACK;
181: break;
182:
183: default:
184: cmn_err (CE_CONT, "^ unknown, %x\n", iocp->ioc_cmd);
185:
186: mp->b_datap->db_type = M_IOCNAK;
187: break;
188: }
189:
190: iocp->ioc_count = 0;
191: qreply (q, mp);
192: }
193:
194:
195: /*
196: * Display information about control messages.
197: */
198:
199: #if __USE_PROTO__
200: __LOCAL__ void (dumpctl) (queue_t * q, mblk_t * mp, dm_dir_t dir)
201: #else
202: __LOCAL__ void
203: dumpctl __ARGS ((q, mp, dir))
204: queue_t * q;
205: mblk_t * mp;
206: dm_dir_t dir;
207: #endif
208: {
209: __CONST__ char * tmp = NULL;
210:
211: cmn_err (CE_CONT, "^\nC%s: M_", dir == D_IN ? "i" : "o");
212:
213: switch (mp->b_datap->db_type) {
214:
215: /* just in case */
216: case M_DATA: tmp = "DATA"; break;
217:
218: case M_READ: tmp = "READ"; break;
219:
220: case M_IOCTL: tmp = "IOCTL"; break;
221:
222: case M_IOCACK: tmp = "IOCACK"; break;
223:
224: case M_IOCNAK: tmp = "IOCNAK"; break;
225:
226: case M_IOCDATA: tmp = "IOCDATA"; break;
227:
228: case M_CTL: tmp = "CTL"; break;
229:
230: case M_PROTO: tmp = "PROTO"; break;
231:
232: case M_PCPROTO: tmp = "PCPROTO"; break;
233:
234: case M_BREAK: tmp = "BREAK"; break;
235:
236: case M_DELAY: tmp = "DELAY"; break;
237:
238: case M_PASSFP: tmp = "PASSFP"; break;
239:
240: case M_SETOPTS: tmp = "SETOPTS"; break;
241:
242: case M_ERROR: tmp = "ERROR"; break;
243:
244: case M_HANGUP: tmp = "HANGUP"; break;
245:
246: case M_FLUSH: tmp = "FLUSH"; break;
247:
248: case M_COPYOUT: tmp = "COPYOUT"; break;
249:
250: case M_COPYIN: tmp = "COPYIN"; break;
251:
252: case M_START: tmp = "START"; break;
253:
254: case M_STOP: tmp = "STOP"; break;
255:
256: case M_STARTI: tmp = "STARTI"; break;
257:
258: case M_STOPI: tmp = "STOPI"; break;
259:
260: case M_SIG:
261: cmn_err (CE_CONT, "^SIG (%d) ", * mp->b_rptr);
262: break;
263:
264: case M_PCSIG:
265: cmn_err (CE_CONT, "^PCSIG (%d) ", * mp->b_rptr);
266: break;
267:
268: default:
269: cmn_err (CE_CONT, "^Unknown! (0x%x) ", mp->b_datap->db_type);
270: break;
271: }
272:
273: if (tmp != NULL)
274: cmn_err (CE_CONT, "^%s", tmp);
275:
276: /*
277: * Reset the direction indicator so the next data message will print
278: * the direction it is headed in.
279: */
280:
281: ((struct dm_str *) q->q_ptr)->dm_dir = D_NONE;
282: }
283:
284:
285: /*
286: * Display information about generally-known ioctl ()s. Feel free to add more
287: * knowledge to this to suit your application.
288: */
289:
290: #if __USE_PROTO__
291: __LOCAL__ void (dumpshow) (mblk_t * __NOTUSED (mp), int cmd)
292: #else
293: __LOCAL__ void
294: dumpshow __ARGS ((mp, cmd))
295: mblk_t * mp;
296: int cmd;
297: #endif
298: {
299: switch (cmd) {
300:
301: default:
302: return;
303: }
304: }
305:
306:
307: /*
308: * Open a dump filter.
309: */
310:
311: #if __USE_PROTO__
312: int dumpopen (queue_t * q, dev_t * __NOTUSED (devp), int flag,
313: int __NOTUSED (sflag), cred_t * __NOTUSED (credp))
314: #else
315: int dumpopen (q, devp, flag, sflag, credp)
316: queue_t * q;
317: dev_t * devp;
318: int flag;
319: int sflag;
320: cred_t * credp;
321: #endif
322: {
323: int i;
324:
325: if (q->q_ptr != NULL) {
326:
327: cmn_err (CE_CONT, "^DUMP: re-open slot %d\n",
328: (struct dm_str *) q->q_ptr - dm_users);
329:
330: if ((flag & FNDELAY) != 0)
331: cmn_err (CE_CONT, "^DUMP: reopen, NDELAY set\n");
332: if ((flag & FNONBLOCK) != 0)
333: cmn_err (CE_CONT, "^DUMP: reopen, NONBLOCK set\n");
334:
335: qprocson (q);
336: return 0;
337: }
338:
339: /*
340: * Search for a slot to use. We depend on the single-threading of
341: * driver open routines to protect this code, and the complementary
342: * code in dumpclose ()
343: */
344:
345: for (i = 0 ; i < dm_ucnt ; i ++) {
346:
347: if (dm_users [i].dm_use == D_FREE) {
348:
349: dm_users [i].dm_use = D_USED;
350: dm_users [i].dm_dir = D_NONE;
351: dm_users [i].dm_flags = D_VERB;
352:
353: WR (q)->q_ptr = q->q_ptr = (_VOID *) & dm_users [i];
354:
355: cmn_err (CE_CONT, "^DUMP: flag = %d\n", flag);
356:
357: if ((flag & FNDELAY) != 0)
358: cmn_err (CE_CONT, "^DUMP: open, NDELAY set\n");
359: if ((flag & FNONBLOCK) != 0)
360: cmn_err (CE_CONT, "^DUMP: open, NONBLOCK set\n");
361:
362: qprocson (q);
363: return 0;
364: }
365: }
366:
367: return EAGAIN;
368: }
369:
370:
371: /*
372: * Close an entry and deallocate the control slot.
373: */
374:
375: #if __USE_PROTO__
376: int (dumpclose) (queue_t * q, int __NOTUSED (flag),
377: cred_t * __NOTUSED (credp))
378: #else
379: int
380: dumpclose (q, flag, credp)
381: queue_t * q;
382: int flag;
383: cred_t * credp;
384: #endif
385: {
386: struct dm_str * d = (struct dm_str *) q->q_ptr;
387:
388: d->dm_use = D_FREE;
389: d->dm_flags = 0;
390:
391: WR (q)->q_ptr = q->q_ptr = NULL;
392:
393: cmn_err (CE_CONT, "^\nDUMP: end trace\n");
394: qprocsoff (q);
395: return 0;
396: }
397:
398:
399: /*
400: * Put procedure for write side of module. Gathers data from all passing
401: * M_DATA messages. Calls routine to handle ioctl calls.
402: */
403:
404: #if __USE_PROTO__
405: void dumpwput (queue_t * q, mblk_t * mp)
406: #else
407: void
408: dumpwput (q, mp)
409: queue_t * q;
410: mblk_t * mp;
411: #endif
412: {
413: if (mp->b_datap->db_type == M_IOCTL) {
414: struct iocblk * iocp = (struct iocblk *) mp->b_rptr;
415: struct dm_str * d = (struct dm_str *) q->q_ptr;
416:
417: if ((iocp->ioc_cmd & DUMPIOC) == DUMPIOC) {
418:
419: dumpioc (q, mp);
420: return;
421: }
422:
423: cmn_err (CE_CONT, "^Co: M_IOCTL %x, cnt %d ",
424: iocp->ioc_cmd, iocp->ioc_count);
425:
426: if ((d->dm_flags & D_VERB) != 0 && mp->b_cont)
427: dumpshow (mp->b_cont, iocp->ioc_count);
428:
429: d->dm_dir = D_NONE;
430:
431: } else if (mp->b_datap->db_type == M_DATA)
432: dumpgather (q, mp, D_OUT);
433: else
434: dumpctl (q, mp, D_OUT);
435:
436: putnext (q, mp);
437: }
438:
439:
440: /*
441: * Read side put procedure, simply discriminates between upwards-bound control
442: * and data.
443: */
444:
445: #if __USE_PROTO__
446: void dumprput (queue_t * q, mblk_t * mp)
447: #else
448: void
449: dumprput (q, mp)
450: queue_t * q;
451: mblk_t * mp;
452: #endif
453: {
454: if (mp->b_datap->db_type == M_DATA)
455: dumpgather (q, mp, D_IN);
456: else
457: dumpctl (q, mp, D_IN);
458:
459: putnext (q, mp);
460: }
461:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.