xref: /titanic_41/usr/src/cmd/sa/sadp.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 1994 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"
31 
32 /*	sadp.c 1.14.1.12 of 8/9/89	*/
33 /*	sadp.c - For VAX and PDP11 machines,
34 		disk profiler profiles rp06, rm05 and general disk drives.
35 		It reads system buffer header pool, physical buffer header
36 		pool and swap buffer header pool once every second,
37 		to examine disk drive's I/O queue.
38 		For 3b20s system, it profiles the regular disk drives,
39 		it reads the circular output queue for each drive
40 		once every second.
41 	usage : sadp [-th][-d device[-drive]] s [n]
42 */
43 
44 #include <stdio.h>
45 #include <sys/types.h>
46 #include <sys/param.h>
47 #include <sys/sysmacros.h>
48 #include <sys/buf.h>
49 #include <sys/elog.h>
50 #include <nlist.h>
51 
52 #include <string.h>
53 #include <fcntl.h>
54 #include <sys/dkio.h>
55 #ifdef FIXME
56 #include <sys/dk.h>
57 #endif
58 
59 #include <time.h>
60 #include <sys/utsname.h>
61 #include <sys/var.h>
62 #include <ctype.h>
63 #include <sys/sysinfo.h>
64 #include <kvm.h>
65 
66 /*
67  * These includes are for dealing with scsi targets.
68  */
69 #include <sys/dditypes.h>
70 #include <sys/scsi/scsi.h>
71 #include <sys/scsi/conf/device.h>
72 #include <sys/scsi/targets/sddef.h>
73 
74 
75 /* cylinder profiling */
76 #define	BLANK ' '
77 #define	BLOB '*'
78 #define	TRACE '.'
79 #define	BRK '='
80 #define	FOOT '-'
81 #define	CYLNO   1
82 #define	SEEKD   2
83 
84 struct dk_geom	dk_geom;
85 #define	CHUNK		16
86 #define	CHUNKSHIFT	4
87 #define	PHYS_CYL	dk_geom.dkg_pcyl
88 #define	CHPERCYL	(int)(PHYS_CYL/CHUNK)	/*
89 						 * the number of CHUNK cylinder
90 						 * chunks on a disk
91 						 */
92 #define	SECTPERTRK	(int)(dk_geom.dkg_nsect)	/* sectors per track */
93 #define	SECTPERCYL	(SECTPERTRK * (int)(dk_geom.dkg_nhead))
94 #define	ERR_BAD_DEV	"Device %s is not defined, valid devices are: "
95 #define	ERR_BAD_UNIT \
96 		"Invalid drive specified for device %s, valid drives are: "
97 #define	ERR_NO_DEV	"Please specify a device type, valid devices are: "
98 #define	DRVNUM(devname)	strpbrk(devname, "0123456789")
99 
100 #define	cylin b_resid
101 #define	NDRIVE  10
102 #define	SNDRIVE NDRIVE		/* Not used */
103 #define	MAX_HDISK_REP	NDRIVE
104 #define	MAXDRIVE	20	/* maximum number of configured disks */
105 #define	NAMESIZE	10	/* size of device names */
106 
107 
108 struct nlist setup[] = {
109 
110 #define	X1_V		0
111 	{"v"},
112 #define	X1_BUF		1
113 	{"buf"},
114 #define	X1_PBUF		2
115 	{"pbuf"},
116 #define	X1_SDUNITS	3
117 	{"sdunits"},
118 #ifdef FIXME
119 #define	X1_DK_NDRIVE	4
120 	{"dk_ndrive"},
121 #define	X1_DK_BUSY	5
122 	{"dk_busy"},
123 #define	X1_DK_TIME	6
124 	{"dk_time"},
125 #define	X1_DK_SEEK	7
126 	{"dk_seek"},
127 #define	X1_DK_XFER	8
128 	{"dk_xfer"},
129 #define	X1_DK_WDS	9
130 	{"dk_wds"},
131 #define	X1_DK_BPS	10
132 	{"dk_bps"},
133 #define	X1_DK_READ	11
134 	{"dk_read"},
135 #define	X1_DK_IVEC	12
136 	{"dk_ivec"},
137 #define	X1_NUMSYMBOLS	13
138 #else
139 #define	X1_NUMSYMBOLS	4
140 #endif
141 	{0}
142 };
143 
144 void	do_disk_stats ();
145 void	usage ();
146 void	prthist ();
147 void	pline ();
148 void	cylhdr ();
149 void	cylftr ();
150 void	cylhist ();
151 void	validate_device ();
152 void	validate_drive ();
153 void	init_geom ();
154 void	bad_device ();
155 void	read_devinfo_names ();
156 void	fail ();
157 void	init_disk ();
158 void	safe_kvm_read ();
159 
160 #undef n_name			/* to resolve conflict with <syms.h> */
161 #define	MAXINTSIZE	12	/* sizeof "-2147483648" + 1 */
162 
163 int debug = 1;
164 
165 #define	Debug		if (debug)
166 #define	dfprintf	if (debug) fprintf
167 
168 /*
169  * FETCH_XYZ naming convention:
170  * X = I for nlist index, A for actual address
171  * Y = V for regular variable, A for array variable
172  * Z = L if length explicitly specified
173  */
174 
175 #define	FETCH_AAL(addr, var, len, vname)\
176 	safe_kvm_read(kd, (unsigned long) addr, \
177 		(char *) var, len, vname)
178 
179 #define	FETCH_IV(index, var)\
180 	safe_kvm_read(kd, (unsigned long) setup[index].n_value, \
181 		(char *) &var, sizeof (var), setup[index].n_name)
182 
183 #define	FETCH_IAL(index, var, len)\
184 	safe_kvm_read(kd, (unsigned long)setup[index].n_value, \
185 		(char *) var, len, setup[index].n_name)
186 
187 int	dk_ndrive;
188 int	ndrives;
189 int	all = 0;	/*
190 			 * indicate whether all drives
191 			 * are implicitly specified
192 			 */
193 char    *cmdname = "sadp";
194 char	device[NAMESIZE];
195 char	dr_name[NDRIVE][NAMESIZE];
196 long	dk_bps[NDRIVE];
197 
198 struct {
199 	long	dk_busy[NDRIVE];
200 	long	dk_time[NDRIVE];
201 	long	dk_wds[NDRIVE];
202 	long	dk_seek[NDRIVE];
203 	long	dk_xfer[NDRIVE];
204 	long	dk_read[NDRIVE];
205 } dk;
206 
207 struct var 	tbl;
208 char 		*sbuf, *phybuf;
209 struct buf 	bp[2];		/*  for swap buffers  */
210 int 		nonblk;
211 int 		index;
212 int 		index1;
213 unsigned 	temp1;
214 #define devnm dr_name
215 
216 int fflg, dflg, tflg, hflg, errflg;
217 int s, n, ct;
218 static int ub = 8;
219 int sdist;
220 int m;
221 int dev;
222 int temp;
223 int f;
224 int i;
225 int n1, dleng, dashb, k, devlen;
226 int dashf;
227 int dn;
228 int drvlist[NDRIVE];
229 
230 int Sdrvlist[SNDRIVE];	/* SCSI */
231 
232 struct HISTDATA {
233 	long	hdata[1];
234 };
235 struct utsname name;
236 
237 char	*nopt;
238 char	empty[30];
239 char	drive[30];
240 char	*malloc();
241 
242 int	SCSI;	/* SCSI */
243 int	ALL;
244 
245 long	lseek();
246 long	**dkcyl;
247 long	**skcyl;
248 long	*iocnt;
249 static kvm_t	*kd = NULL;
250 struct scsi_device	*sdunits[SD_MAXUNIT];
251 struct scsi_device	sdunit[NDRIVE];
252 int			cyl_no, prev_cyl_no;
253 int			cyl_bk, prev_cyl_bk;
254 int			seek_dist, seek_bk;
255 int			max_cyl_no = 0;
256 int			max_seek_dist = 0;
257 
main(argc,argv)258 main(argc, argv)
259 int argc;
260 char **argv;
261 {
262 	unsigned sleep();
263 	extern int	optind;
264 	extern char	*optarg;
265 	int c, j;
266 	char *ctime(), *stime;
267 	long curt;
268 	extern time_t time();
269 	long *skdist;
270 	long *disk;
271 
272 	fail("sadp does not work yet -- no disk statistics in the kernel", 0);
273 
274 	while ((c = getopt(argc, argv, "thd:")) != EOF)
275 		switch (c) {
276 		case 't':
277 			tflg++;
278 			break;
279 		case 'h':
280 			hflg++;
281 			break;
282 		case 'd':
283 			dleng = strlen(optarg);
284 
285 			/*
286 			 * Controller types can be arbitrary length.
287 			 */
288 			devlen =  strchr(optarg, '-') ?
289 					strchr(optarg, '-') - optarg : dleng;
290 			SCSI = 0;
291 			strncpy(device, optarg, devlen);
292 
293 			if (dleng == (devlen+1)) {
294 				errflg++;
295 				break;
296 			}
297 			if (dleng > devlen) {
298 			for (i = (devlen+1), n1 = (devlen+1); i < dleng; i++){
299 
300 				if (optarg[i] == ','){
301 					if (n1 == i){
302 					errflg++;
303 					break;
304 					}
305 					if (getdrvn() != 0) {
306 						errflg++;
307 						break;
308 					}
309 					if (dashf != 0) {
310 						if (dashb >= dn){
311 							errflg++;
312 							break;
313 						}
314 						for (j = dashb; j < dn+1; j++){
315 							if (SCSI) /*  SCSI */
316 								Sdrvlist[j] = 1;
317 							else
318 								drvlist[j] = 1;
319 						}
320 						dashb = 0;
321 						dashf = 0;
322 					}
323 					else
324 					{
325 						if (SCSI)
326 							Sdrvlist[dn] = 1;
327 						else
328 							drvlist[dn] = 1;
329 					}
330 					n1 = i+1;
331 				} else {
332 				if (optarg[i] == '-'){
333 					if (dashf != 0) {
334 						errflg++;
335 						break;
336 					}
337 					if (getdrvn() != 0) {
338 						errflg++;
339 						break;
340 					}
341 					if (SCSI)
342 						Sdrvlist[dn] = 1;
343 					else
344 						drvlist[dn] = 1;
345 					dashb = dn;
346 					dashf = 1;
347 					n1 = i+1;
348 				} else {
349 					if (i == dleng-1){
350 					i++;
351 					if (getdrvn() != 0) {
352 						errflg++;
353 						break;
354 					}
355 					if (dashf != 0)
356 						for (j = dashb; j < dn+1; j++){
357 							if (SCSI)
358 								Sdrvlist[j] = 1;
359 							else
360 								drvlist[j] = 1;
361 						}
362 					else
363 					{
364 						if (SCSI)
365 							Sdrvlist[dn] = 1;
366 						else
367 							drvlist[dn] = 1;
368 					}
369 					}
370 				}
371 				}
372 			}
373 			} else {
374 				if (dleng != devlen){
375 					errflg++;
376 					break;
377 				}
378 				all++;
379 				if (SCSI)
380 					ALL++;
381 				else
382 					for (i = 0; i < MAX_HDISK_REP; i++)
383 						drvlist[i] = 1;
384 			}
385 			if (errflg)
386 				break;
387 			dflg++;
388 			break;
389 		case '?':
390 			errflg++;
391 			break;
392 		}
393 	if (errflg) {
394 		fprintf (stderr, "%s: errors in arguments\n", cmdname);
395 		usage();
396 	}
397 
398 	/*
399 	 * If no frequency arguments present, exit.
400 	 */
401 	if (optind == argc)
402 		usage();
403 	/*
404 	 * If a non-dash field is presented as an argument,
405 	 * check if it is a numerical arg.
406 	 */
407 	nopt = argv[optind];
408 	if (tstdigit(nopt) != 0)
409 		usage();
410 	/*
411 	 * For frequency arguments, if only s is presented , set n to 1
412 	 */
413 	if ((optind +1) == argc) {
414 		s = atoi(argv[optind]);
415 		n = 1;
416 	}
417 	/*
418 	 * If both s and n are specified, check if
419 	 * arg n is numeric.
420 	 */
421 	if ((optind +1) < argc) {
422 		nopt = argv[optind + 1];
423 		if (tstdigit(nopt) != 0)
424 			usage();
425 		s = atoi(argv[optind]);
426 		n = atoi(argv[optind+1]);
427 	}
428 	if (s <= 0)
429 		fail("bad value of s", 0);
430 	if (n <= 0)
431 		fail("bad value of n", 0);
432 	ct = s;
433 	/*
434 	 * Get entries defined in setup from /stand/unix
435 	 */
436 	if ((kd = kvm_open (NULL, NULL, NULL, O_RDONLY, "Bad kvm open"))
437 		== NULL)
438 		fail("kvm_open failed", 1);
439 
440 	dfprintf (stderr, "main: successful kvm_open\n");
441 	/*
442 	 * Search name list to get offsets.
443 	 */
444 	dfprintf (stderr, "main: about to kvm_nlist\n");
445 	if (kvm_nlist(kd, setup) == -1) {
446 		fail("kvm_nlist failed", 1);
447 	}
448 	dfprintf (stderr, "main: good nlist\n");
449 	Debug dump_nlist (setup, "main");
450 
451 	/*
452 	 * Initialize buffers and get disk info.
453 	 */
454 	init_disk();
455 	dfprintf (stderr, "init_disk\n");
456 	skdist = (long *)calloc(dk_ndrive, sizeof (long));
457 	disk = (long *)calloc(dk_ndrive, sizeof (long));
458 
459 	/*
460 	 * Make sure device and drive specified is legitimate.
461 	 */
462 	validate_device();
463 	dfprintf (stderr, "validate_device\n");
464 	validate_drive();
465 	dfprintf (stderr, "validate_drive\n");
466 
467 	/*
468 	 * Get storage from memory for sysbuf pool and physical buf pool
469 	 */
470 	FETCH_IV (X1_V, tbl);
471 	Debug dump_v_struct (&tbl);
472 	sbuf = malloc(sizeof (struct buf) * tbl.v_buf);
473 	if (sbuf == NULL)
474 		fail("malloc of sbuf failed", 1);
475 	phybuf = malloc(sizeof (struct buf) * tbl.v_pbuf);
476 	if (phybuf == NULL)
477 		fail("malloc of physbuf failed", 1);
478 
479 	/*
480 	 * Determine the number of CHUNK cylinder chunks on the disk.
481 	 * This will be referenced as CHPERCYL.
482 	 */
483 	init_geom();
484 	dfprintf (stderr, "init_geom\n");
485 
486 	ub = dk_ndrive;
487 #ifdef FIXME
488 	FETCH_IAL(X1_DK_XFER, dk.dk_xfer, dk_ndrive*sizeof (long));
489 	FETCH_IAL(X1_DK_READ, dk.dk_read, dk_ndrive*sizeof (long));
490 	FETCH_IAL(X1_DK_SEEK, dk.dk_seek, dk_ndrive*sizeof (long));
491 	FETCH_IAL(X1_DK_WDS, dk.dk_wds, dk_ndrive*sizeof (long));
492 	FETCH_IAL(X1_DK_TIME, dk.dk_time, dk_ndrive*sizeof (long));
493 #endif
494 	dfprintf (stderr, "%s: ub %d\n", cmdname, ub);
495 	/*
496 	 * Get the list of scsi device pointers from kernel space.
497 	 */
498 	FETCH_IAL(X1_SDUNITS, sdunits, SD_MAXUNIT);
499 	for (i = 0; i < SD_MAXUNIT; i++) {
500 		dfprintf (stderr, "sdunits[%d] 0x%x ", i, (int)sdunits[i]);
501 	}
502 	dfprintf (stderr, "\n");
503 	for (k = 0, i = 0; k < ub; k++) {
504 		if (drvlist[k] == 0)
505 			continue;
506 		/*
507 		 * Make sure that there is a scsi_device struct for
508 		 * the chosen device.
509 		 */
510 		if (!sdunits[k]) {
511 			fprintf (stderr, "%s: no valid scsi_device struct\n",
512 				cmdname);
513 		}
514 		dfprintf (stderr, "%s: read unit %d\n", cmdname, k);
515 		/*
516 		 * Read the scsi_device struct for the device.
517 		 */
518 		FETCH_AAL(sdunits[k], &sdunit[k],
519 			sizeof (struct scsi_device), "sdunits");
520 		dfprintf (stderr, "%s: sd_private 0x%x\n",
521 			cmdname, (int)sdunit[k].sd_private);
522 	}
523 
524 	/*
525 	 * Get current I/O count for each drive.
526 	 */
527 	for (;;) {
528 		s = ct;
529 		for (k = 0, i = 0; k < ub; k++) {
530 			if (drvlist[k] == 0)
531 				continue;
532 			for (j = 0; j < CHPERCYL; j++) {
533 				dkcyl[i][j] = 0;
534 				skcyl[i][j] = 0;
535 			}
536 			iocnt[i] = 0;
537 			disk[i] = 0;
538 			skdist[i] = 0;
539 			i++;
540 		}
541 		/*
542 		 * If no drives are selected or illegal drive number
543 		 * is specified, exit.
544 		 */
545 		if (i == 0)
546 			usage();
547 
548 		/*
549 		 * Get i/o count for each disk.
550 		 */
551 
552 		for (k = 0, i = 0; k < ub; k++) {
553 			if (drvlist[k] == 0)
554 				continue;
555 			iocnt[i] = dk.dk_xfer[k];
556 			i++;
557 		}
558 
559 	cyl_no = 0; prev_cyl_no = 0; cyl_bk = 0; prev_cyl_bk = 0; seek_dist = 0;
560 	for (;;) {
561 
562 		/*
563 		 * Take a snapshot of buffer header pool, swap
564 		 * buffer pool and physical buffer header.
565 		 */
566 
567 		/*
568 		 * read system buffer header pool.
569 		 */
570 		FETCH_IAL(X1_BUF, sbuf, tbl.v_buf*sizeof (struct buf));
571 
572 		/*
573 		 * Read physical buffer header pool.
574 		 */
575 		FETCH_IAL(X1_PBUF, phybuf, tbl.v_pbuf*sizeof (struct buf));
576 
577 		for (k = 0, i = 0; k < ub; k++) {
578 			if (drvlist[k] == 0)
579 				continue;
580 			do_disk_stats (i, k);
581 		i++;
582 		dfprintf (stderr, "%s: i %d\n", cmdname, i);
583 		}
584 
585 	/* TBD - get more samples */
586 
587 		if (--s)
588 			sleep(1);
589 		else {
590 
591 			/*
592 			 * At the end of sampling, get the present I/O
593 			 * count, and system name.
594 			 */
595 			uname(&name);
596 
597 			/*
598 			 * Print the report, there are two parts:
599 			 * cylinder profile, seeking distance profile.
600 			 */
601 			curt = time((long *) 0);
602 			stime = ctime (&curt);
603 			printf("\n\n%s\n", stime);
604 			printf("%s %s %s %s %s\n",
605 				name.sysname,
606 				name.nodename,
607 				name.release,
608 				name.version,
609 				name.machine);
610 			for (k = 0, i = 0; k < ub; k++) {
611 				if (drvlist[k] == 0)
612 					continue;
613 				for (j = 0; j < CHPERCYL; j++) {
614 					disk[i] = disk[i] +dkcyl[i][j];
615 					skdist[i] = skdist[i] + skcyl[i][j];
616 
617 				}
618 				i++;
619 			}
620 			if ((tflg == 0) && (hflg == 0))
621 				tflg = 1;
622 			if (tflg){
623 				printf("\nCYLINDER ACCESS PROFILE\n");
624 				for (k = 0, i = 0; k < ub; k++) {
625 					if (drvlist[k] == 0)
626 						continue;
627 					if (disk[i] != 0){
628 						iocnt[i] = dk.dk_xfer[k] - iocnt[i];
629 						printf("\n%s-%d:\n",
630 							device, k);
631 						printf("Cylinders\tTransfers\n");
632 						for (j = 0; j < CHPERCYL; j++) {
633 							if (dkcyl[i][j] > 0)
634 								printf("%3d - %3d\t%ld\n",
635 								j*8, j*8+7, dkcyl[i][j]);
636 						}
637 						printf("\nSampled I/O = %ld, Actual I/O = %ld\n",
638 						disk[i], iocnt[i]);
639 						if (iocnt[i] > 0)
640 						printf("Percentage of I/O sampled = %2.2f\n",
641 						((float)disk[i] /(float)iocnt[i]) * 100.0);
642 					}
643 					i++;
644 				}
645 
646 				printf("\n\n\nSEEK DISTANCE PROFILE\n");
647 				for (k = 0, i = 0; k < ub; k++) {
648 					if (drvlist[k] == 0)
649 						continue;
650 					if (skdist[i] != 0){
651 						printf("\n%s-%d:\n",
652 							device, k);
653 						printf("Seek Distance\tSeeks\n");
654 						for (j = 0; j < CHPERCYL; j++)
655 
656 							if (skcyl[i][j] > 0){
657 								if (j == 0)
658 									printf("        0\t%ld\n",
659 									skcyl[i][j]);
660 								else
661 									printf("%3d - %3d\t%ld\n",
662 								j*8-7, j*8, skcyl[i][j]);
663 							}
664 						printf("Total Seeks = %ld\n", skdist[i]);
665 					}
666 					i++;
667 				}
668 			}
669 			if (hflg){
670 				for (k = 0, i = 0; k < ub; k++) {
671 					if (drvlist[k] == 0)
672 						continue;
673 					if (disk[i] != 0) {
674 						cylhdr(CYLNO, disk[i]);
675 						cylhist(disk[i], dkcyl[i]);
676 						cylftr(CYLNO);
677 					}
678 					i++;
679 				}
680 				for (k = 0, i = 0; k < ub; k++) {
681 					if (drvlist[k] == 0)
682 						continue;
683 					if (skdist[i] != 0){
684 						cylhdr(SEEKD, skdist[i]);
685 						cylhist(skdist[i], skcyl[i]);
686 						cylftr(SEEKD);
687 					}
688 					i++;
689 				}
690 			}
691 
692 			break;
693 		}
694 	}
695 	if (--n)
696 		continue;
697 	exit(0);
698 	}
699 }
700 
701 void
do_disk_stats(i,k)702 do_disk_stats (i, k)
703 {
704 #ifdef	fixed
705 	struct scsi_disk	sddisk[NDRIVE];
706 	struct diskhd		*dp;
707 	struct buf		buffer, *bp;
708 	struct buf		*last_bp = 0;
709 
710 	dfprintf (stderr, "do_disk_stats (i %d, k %d)\n", i, k);
711 	/*
712 	 * In each scsi_device struct there is a sd_private
713 	 * pointer to a specialised scsi_disk struct which
714 	 * describes the disk.
715 	 */
716 	do {
717 		FETCH_AAL(sdunit[k].sd_private, &sddisk[k],
718 			sizeof (struct scsi_disk), "sdunit");
719 		/*
720 		 * The diskhd struct describing the active and waiting
721 		 * queues is embedded in the scsi_disk struct.
722 		 */
723 		dp = &sddisk[k].un_utab;
724 		Debug dump_diskhd (dp);
725 		/*
726 		 * The current SunOS sd.c driver uses the b_forw
727 		 * pointer for the currently active buffer, and the
728 		 * b_actf (av_forw) pointer for the waiting queue
729 		 * of buffers.
730 		 */
731 		dfprintf (stderr, "%s: b_forw 0x%x\n", cmdname, (int)dp->b_forw);
732 		/*
733 		 * Trace disk queue for I/O location, seek distance.
734 		 */
735 		if (dp->b_forw) {
736 			if (dp->b_forw == last_bp) {
737 				continue;
738 			} else {
739 				last_bp = dp->b_forw;
740 			}
741 			dfprintf (stderr, "%s: b_forw 0x%x\n",
742 				cmdname, (int)dp->b_forw);
743 			FETCH_AAL(dp->b_forw, &buffer, sizeof (struct buf),
744 				"b_forw");
745 			bp = &buffer;
746 			dfprintf (stderr, "%s: b_lblkno 0x%x b_blkno 0x%x\n",
747 				cmdname, bp->b_lblkno, bp->b_blkno);
748 			cyl_no = bp->b_blkno / SECTPERCYL;
749 			cyl_bk = cyl_no >> CHUNKSHIFT;
750 			seek_dist = prev_cyl_no - cyl_no;
751 			if (seek_dist < 0)
752 				seek_dist = -seek_dist;
753 			seek_bk = prev_cyl_bk - cyl_bk;
754 			if (seek_bk < 0)
755 				seek_bk = -seek_bk;
756 			prev_cyl_no = cyl_no;
757 			prev_cyl_bk = cyl_bk;
758 			if (cyl_no > max_cyl_no) {
759 				max_cyl_no = cyl_no;
760 			}
761 			if (seek_dist > max_seek_dist) {
762 				max_seek_dist = seek_dist;
763 			}
764 			skcyl[i][seek_bk]++;
765 			dkcyl[i][cyl_bk]++;
766 		}
767 	} while (dp->b_forw);
768 #endif
769 }
770 
771 
772 /*
773  * Determine if the I/O is from system buffer pool,
774  * or swap buffer pool or physical buffer.
775  */
776 
777 int
testbuf()778 testbuf()
779 {
780 	if ((temp1 < setup[X1_BUF].n_value) || (index > tbl.v_buf)){
781 		index = (int)(temp1 -setup[X1_PBUF].n_value)/
782 			(sizeof (struct buf));
783 		if (index < tbl.v_pbuf){
784 			nonblk = 1;
785 			return (0);
786 
787 		}
788 /* TBD - Is it possible to access swap buffers on Sun? */
789 #ifndef sun
790 		index = (int)(temp1 -setup[SWP].n_value)/
791 			(sizeof (struct buf));
792 		if (index < NSWP) {
793 			m = index;
794 			nonblk = 2;
795 			return (0);
796 		}
797 #endif
798 		return (-1);
799 	}
800 	return (0);
801 }
802 
803 /*
804  * Verify the I/O, get the cylinder number.
805  */
806 
ckbits(x)807 ckbits(x)
808 	register struct buf *x;
809 {
810 	register p;
811 	for (p = 0; p < index; p++, x++)
812 		continue;
813 	if ((x->b_flags & B_BUSY) &&
814 	    ((x->b_flags & B_DONE) == 0)){
815 		temp = x->cylin;
816 		temp1 = (unsigned)x->av_forw;
817 		return (0);
818 	}
819 	else
820 		return (-1);
821 
822 }
823 int
testdev()824 testdev()
825 {
826 	if ((nonblk == 0) && (ckbits((struct buf *)sbuf) != -1))
827 		goto endtest;
828 	else {
829 		if ((nonblk == 1) && (ckbits((struct buf *)phybuf) != -1))
830 			goto endtest;
831 
832 		else {
833 
834 			if ((nonblk == 2) &&
835 			    ((bp[m].b_flags & B_BUSY) &&
836 			    ((bp[m].b_flags & B_DONE) == 0))){
837 				temp = bp[m].cylin;
838 				temp1 = (unsigned)bp[m].av_forw;
839 			} else {
840 				dfprintf (stderr, "testdev -1\n");
841 				return (-1);
842 			}
843 		}
844 	}
845 endtest:
846 	dkcyl[i][temp >> 3]++;
847 	return (0);
848 }
849 
850 
851 
852 /*
853  * Get drive number routine.
854  */
getdrvn()855 getdrvn()
856 {
857 	extern char *optarg;
858 	char *strcpy();
859 	char *strncat();
860 
861 	strcpy(drive, empty);
862 	strncat(drive, &optarg[n1], i-n1);
863 	if (tstdigit(drive) != 0)
864 		return (-1);
865 	dn = atoi(drive);
866 	if (SCSI) {
867 		if (dn >= SNDRIVE)
868 			return (-1);
869 	} else {
870 		if (dn >= NDRIVE)
871 			return (-1);
872 	}
873 	return (0);
874 }
875 
876 void
usage()877 usage()
878 {
879 	fprintf(stderr, "usage:  sadp [-th][-d device[-drive]] s [n]\n");
880 	exit(1);
881 }
882 
tstdigit(ss)883 int tstdigit(ss)
884 char *ss;
885 {
886 	int kk, cc;
887 	kk = 0;
888 	while ((cc = ss[kk]) != '\0'){
889 		if (isdigit(cc) == 0)
890 			return (-1);
891 		kk++;
892 	}
893 	return (0);
894 }
895 
896 /*
897  * The following routines are obtained from iostat.
898  *
899  * Output Cylinder Histogram.
900  */
901 void
cylhist(at,dp)902 cylhist(at, dp)
903 long at;
904 register struct HISTDATA *dp;
905 {
906 	register ii;
907 	int maxrow;
908 	long *graph = (long *)calloc(CHPERCYL, sizeof (long));
909 	long    max, max2;
910 	long    data;
911 	long    scale;
912 
913 	for (ii = 0; ii < CHPERCYL; ii++) {
914 		dfprintf (stderr, "(%d %d) ", ii, (int)dp->hdata[ii]);
915 	}
916 	dfprintf (stderr, "\n");
917 	max = 0;
918 	for (ii = 0; ii < CHPERCYL; ii++) {
919 		if (data = dp->hdata[ii]) {
920 			maxrow = ii;
921 			if (data > max) {
922 				max2 = max;
923 				max = data;
924 			} else if (data > max2 && data != max)
925 				max2 = data;
926 		}
927 	}
928 	maxrow++;
929 
930 	/* determine scaling */
931 	scale = 1;
932 	if (max2) {
933 		scale = at / (max2 * 2);
934 		if (scale > 48)
935 			scale = 48;
936 		}
937 
938 	for (ii = 0; ii < maxrow; ii++) {
939 		if (dp->hdata[ii])
940 			graph[ii] = (scale * 100 * dp->hdata[ii]) / at;
941 		else
942 			graph[ii] = -1;
943 	}
944 
945 	prthist(graph, maxrow, scale, (long) (max*100*scale/at));
946 }
947 /*
948  * Print Histogram.
949  */
950 void
prthist(array,mrow,scale,gmax)951 prthist(array, mrow, scale, gmax)
952 	long array[], scale, gmax;
953 register mrow;
954 {
955 	long    line;
956 
957 	line = 50;
958 	/* handle overflow in scaling */
959 	if (gmax > 51) {
960 		line = 52;
961 		printf("\n%2ld%% -|", gmax/scale);
962 		pline(line--, array, mrow, BLOB);
963 		printf("\n     %c", BRK);
964 		pline(line--, array, mrow, BRK);
965 	} else if (gmax = 51)
966 		line = 51;
967 	while (line > 0) {
968 		if ((line & 07) == 0) {
969 			printf("\n%2ld%% -|", line/scale);
970 		} else {
971 			printf("\n     |");
972 		}
973 		pline(line--, array, mrow, BLOB);
974 	}
975 	printf("\n 0%% -+");
976 	line = -1;
977 	pline(line, array, mrow, FOOT);
978 }
979 
980 /*
981  * Print Histogram Line.
982  */
983 void
pline(line,array,mrow,dot)984 pline(line, array, mrow, dot)
985 	long line, array[];
986 int mrow;
987 char dot;
988 {
989 	register ii;
990 	register char *lp;
991 	char lbuff[132];
992 
993 	dfprintf (stderr,
994 		"pline(line 0x%x, array 0x%x, mrow 0x%x, dot 0x%x)\n",
995 		line, array, mrow, dot);
996 	lp = lbuff;
997 	for (ii = 0; ii < mrow; ii++)
998 		if (array[ii] < line)
999 			if (line == 1 && array[ii] == 0)
1000 				*lp++ = TRACE;
1001 			else
1002 				*lp++ = BLANK;
1003 		else
1004 			*lp++ = dot;
1005 	*lp++ = 0;
1006 	printf("%s", lbuff);
1007 }
1008 /*
1009  * Print Cylinder Profiling Headers.
1010  */
1011 void
cylhdr(flag,total)1012 cylhdr(flag, total)
1013 	long total;
1014 {
1015 
1016 	dfprintf (stderr, "cylhdr(flag 0x%x, total 0x%x)\n", flag, total);
1017 	if (fflg)
1018 		printf("\014\n");
1019 	if (flag == CYLNO)
1020 		printf("\nCYLINDER ACCESS HISTOGRAM\n");
1021 	if (flag == SEEKD)
1022 		printf("\nSEEK DISTANCE HISTOGRAM\n");
1023 	printf("\n%s-%d:\n",
1024 		device, k);
1025 	printf("Total %s = %ld\n",
1026 		flag == CYLNO ? "transfers" : "seeks", total);
1027 }
1028 
1029 #define	MAXCOL	80
1030 /* Print Histogram Footers */
1031 void
cylftr(flag)1032 cylftr(flag)
1033 {
1034 	int		i;
1035 	int		chunk_mult = 1;
1036 	int		col;
1037 	char		footer[4][MAXCOL];
1038 	char		digits[] = "0123456789";
1039 	int		significant = 0;
1040 
1041 	dfprintf (stderr, "cylftr(flag 0x%x)\n", flag);
1042 	if (flag == CYLNO)
1043 		printf("\n      \t\t\tCylinder number, granularity=%d", CHUNK);
1044 	else
1045 		printf("\n      =<< ");
1046 	for (i = 0; i < 4; i++) {
1047 		for (col = 0; col < MAXCOL - 1; col++) {
1048 			footer[i][col] = ' ';
1049 		}
1050 		footer[i][MAXCOL - 1] = '\0';
1051 	}
1052 	for (i = 0, col = 0; i < (int)PHYS_CYL;
1053 		i += (chunk_mult * CHUNK), col += chunk_mult, significant = 0) {
1054 		if ((i / 1000) > 0) {
1055 			footer[0][col] = digits[(i / 1000)];
1056 			significant = 1;
1057 		}
1058 		if ((significant) || (((i % 1000) / 100) > 0)) {
1059 			footer[1][col] = digits[((i % 1000) / 100)];
1060 			significant = 1;
1061 		}
1062 		if ((significant) || (((i % 100) / 10) > 0)) {
1063 			footer[2][col] = digits[((i % 100) / 10)];
1064 			significant = 1;
1065 		}
1066 		if ((i == 0) || (significant) || ((i % 10) > 0)) {
1067 			footer[3][col] = digits[(i % 10)];
1068 		}
1069 		if (i > CHUNK) {
1070 			chunk_mult = 2;
1071 		}
1072 		if (i > (3 * CHUNK)) {
1073 			chunk_mult = 4;
1074 			if (flag != CYLNO)
1075 				printf ("<   ");
1076 		}
1077 	}
1078 	for (i = 0; i < 4; i++) {
1079 		printf ("      %s\n", footer[i]);
1080 	}
1081 	printf ("\n");
1082 }
1083 
1084 void
validate_device()1085 validate_device()
1086 {
1087 	int	i;
1088 	char	tempdev[NAMESIZE];
1089 
1090 	if (dflg == 0) {
1091 
1092 		/*
1093 		 * No device specified, so default to the first
1094 		 * one if it is the only one, otherwise prompt
1095 		 * user to enter one.
1096 		 */
1097 		strcpy(device, devnm[0]);
1098 		*DRVNUM(device) = NULL;
1099 		devlen = strlen(device);
1100 		for (i = 0; i < dk_ndrive; i++)
1101 			drvlist[i] = 1;
1102 		if (dk_ndrive > 1)
1103 			bad_device(device, ERR_NO_DEV);
1104 		dev = 0;
1105 	} else {
1106 
1107 		/*
1108 		 * Device was specified.  Make sure it matches
1109 		 * one that is configured in the system.
1110 		 */
1111 		for (i = 0; i < dk_ndrive; i++) {
1112 			strncpy(tempdev, devnm[i], DRVNUM(devnm[i])-devnm[i]);
1113 			tempdev[DRVNUM(devnm[i])-devnm[i]] = NULL;
1114 			if (strcmp(device, tempdev) == 0)
1115 				break;
1116 		}
1117 		if (i == dk_ndrive)
1118 			bad_device(device, ERR_BAD_DEV);
1119 		dev = i;
1120 	}
1121 }
1122 
1123 void
validate_drive()1124 validate_drive()
1125 {
1126 	int	i, j, c;
1127 
1128 	/*
1129 	 * For each controller number specified, make sure it exists
1130 	 * in the configured device list.
1131 	 */
1132 	for (i = 0; i < dk_ndrive; i++) {
1133 		if (drvlist[i] == 0)
1134 			continue;
1135 
1136 		/*
1137 		 * Since this controller number (i) was specified,
1138 		 * find the corresponding entry (j) in the device list.
1139 		 * If found, save the device list index in drvlist[].
1140 		 */
1141 		for (j = 0; j < dk_ndrive; j++) {
1142 			if (strncmp(device, devnm[j], devlen) != 0)
1143 				continue;
1144 			c = atoi(DRVNUM(devnm[j]));
1145 			if (c == i) {
1146 				/*
1147 				 * NOTE: saved value actual index+1
1148 				 * as entries with 0 imply don't care.
1149 				 */
1150 				drvlist[i] = j+1;  /* not a flag anymore! */
1151 
1152 				break;
1153 			}
1154 		}
1155 
1156 		/*
1157 		 * If not found, output error, except if all drives
1158 		 * were implied by only specifying controller type.
1159 		 * In this case, flag it as don't care.
1160 		 */
1161 		if (j == dk_ndrive) {
1162 			if (all)
1163 				drvlist[i] = 0;
1164 			else
1165 				bad_device(device, ERR_BAD_UNIT);
1166 			}
1167 	}
1168 }
1169 
1170 void
init_geom()1171 init_geom()
1172 {
1173 	char	tempdev[NAMESIZE];
1174 	int	i, fd;
1175 /*
1176  * When the new device naming convention is in effect, switch to it
1177  */
1178 #ifdef NEW_DEVICE_NAMES
1179 #define	DEV_PREFIX	"/dev/rdsk/"
1180 #else
1181 #define	DEV_PREFIX	"/dev/r"
1182 #endif
1183 
1184 	for (i = 0; drvlist[i] == 0; i++);
1185 	sprintf(tempdev, "%s%s%da", DEV_PREFIX, device, i);
1186 	if ((fd = open(tempdev, O_RDONLY)) == -1)
1187 		fail("open failed", 1);
1188 	if (ioctl(fd, DKIOCGGEOM, &dk_geom) == -1) {
1189 		close(fd);
1190 		fail("ioctl failed", 1);
1191 	}
1192 	close(fd);
1193 
1194 	/*
1195 	 * dk_geom structure now has data, and the number
1196 	 * of 8 cylinder chunks on the disk can now be
1197 	 * referenced via the CHPERCYL macro.  So allocate
1198 	 * appropriate buffers based on this value.
1199 	 */
1200 	iocnt = (long *)calloc(dk_ndrive, sizeof (long));
1201 	dkcyl = (long **)calloc(dk_ndrive, sizeof (long *));
1202 	skcyl = (long **)calloc(dk_ndrive, sizeof (long *));
1203 	for (i = 0; i < dk_ndrive; i++) {
1204 		dkcyl[i] = (long *)calloc(CHPERCYL, sizeof (long));
1205 		skcyl[i] = (long *)calloc(CHPERCYL, sizeof (long));
1206 	}
1207 }
1208 
1209 /*
1210  * General routine for printing out an error message
1211  * when the specified device/drive is insufficient.
1212  */
1213 void
bad_device(device,errmsg)1214 bad_device(device, errmsg)
1215 	char	*device;
1216 	char	*errmsg;
1217 {
1218 	int	i, j;
1219 	int	unique = 0;
1220 	char	*p, *p1, **buf;
1221 	char	s[NAMESIZE];
1222 	char	*msg;
1223 
1224 
1225 	/*
1226 	 * Print usage statement if no device is specified.
1227 	 */
1228 	if (device[0] == NULL)
1229 		usage();
1230 
1231 	/*
1232 	 * Compose a list of unique device controller types, or
1233 	 * unit numbers for a specified controller type, from
1234 	 * the complete device list.
1235 	 */
1236 	buf = (char **)calloc(dk_ndrive, sizeof (char *));
1237 	for (i = 0; i < dk_ndrive; i++) {
1238 
1239 		/*
1240 		 * Get controller type or unit
1241 		 */
1242 		p = devnm[i];
1243 		p1 = DRVNUM(devnm[i]);
1244 		if (!strcmp(errmsg, ERR_BAD_UNIT)) {
1245 			if (strncmp(devnm[i], device, devlen))
1246 				continue;
1247 			p = p1;
1248 			p1++;
1249 		}
1250 		strncpy(s, p, p1-p);
1251 		s[p1-p] = NULL;
1252 
1253 		/*
1254 		 * Have we already logged this one as unique?
1255 		 * If not, then do so now.
1256 		 */
1257 		for (j = 0; j < unique; j++)
1258 			if (!strcmp(s, buf[j]))
1259 				break;
1260 		if (j == unique)
1261 			buf[unique++] = strdup(s);
1262 	}
1263 
1264 	/*
1265 	 * Invalid device was specified.  Compose message containing
1266 	 * list of valid devices.
1267 	 */
1268 	msg = (char *)malloc(strlen(errmsg) +
1269 			strlen(device) + unique*(NAMESIZE+1) + 1);
1270 	sprintf(msg, errmsg, device);
1271 	for (p = msg + strlen(msg), i = 0; i < unique; i++) {
1272 		sprintf(p, "%s ", buf[i]);
1273 		p += (strlen(buf[i])+ 1);
1274 	}
1275 
1276 	/*
1277 	 * Output the message and exit.
1278 	 */
1279 	fail(msg, 0);
1280 }
1281 
1282 /*
1283  * Code below here was taken from the SunOS 5.0 iostat command.
1284  */
1285 
1286 #ifdef FIXME
1287 
1288 void
read_devinfo_names()1289 read_devinfo_names()
1290 {
1291 	int i;
1292 	struct dk_ivec dkivec[NDRIVE];
1293 
1294 	safe_kvm_read (kd, nl_4c[X1_DK_IVEC].n_value, dkivec, sizeof dkivec,
1295 		"dk_ivec");
1296 	for (i = 0; i < NDRIVE; i++) {
1297 		if (dkivec[i].dk_name) {
1298 			safe_kvm_read (kd, dkivec[i].dk_name, dr_name[i], 2,
1299 				"dk_name");
1300 			sprintf(dr_name[i] + 2, "%d", dkivec[i].dk_unit);
1301 		}
1302 	}
1303 }
1304 
1305 #endif
1306 
1307 void
init_disk()1308 init_disk()
1309 {
1310 #ifdef FIXME
1311 	int i;
1312 
1313 	for (i = 0; i < NDRIVE; i++) {
1314 		dr_select[i] = 0;
1315 		dk_bps[i] = 0;
1316 	}
1317 
1318 	/*
1319 	 * The default device names: dk#
1320 	 */
1321 	for (i = 0; i < dk_ndrive; i++) {
1322 		dr_name[i] = buf;
1323 		(void) sprintf(buf, "dk%d", i);
1324 		buf += NAMESIZE;
1325 	}
1326 
1327 	/*
1328 	 * Device names must be discovered in this program, and output
1329 	 * with its io data via the "sa" structure.
1330 	 */
1331 
1332 	read_devinfo_names();
1333 #else
1334 	return;
1335 #endif
1336 }
1337 
1338 /*
1339  * issue failure message and exit
1340  */
1341 void
fail(message,doperror)1342 fail(message, doperror)
1343 char *message;
1344 int doperror;
1345 {
1346 	if (kd != NULL)
1347 		(void) kvm_close(kd);
1348 
1349 	if (doperror) {
1350 		fprintf(stderr, "%s: ", cmdname);
1351 		perror(message);
1352 	}
1353 	fprintf(stderr, "%s: %s\n", cmdname, message);
1354 	exit(2);
1355 }
1356 
1357 void
safe_kvm_read(kd,addr,buf,size,who)1358 safe_kvm_read(kd, addr, buf, size, who)
1359 kvm_t *kd;
1360 unsigned long addr;
1361 char *buf;
1362 unsigned size;
1363 {
1364 	int ret_code;
1365 	char errmsg[100];
1366 
1367 	if (addr == 0) {
1368 		sprintf(errmsg, "kvm_read of %s failed -- no address", who);
1369 		fail(errmsg, 0);
1370 	}
1371 
1372 	ret_code = kvm_read(kd, addr, buf, size);
1373 	if (ret_code != size) {
1374 		sprintf(errmsg, "kvm_read of %s failed with code %d",
1375 			who, ret_code);
1376 		fail(errmsg, 0);
1377 	}
1378 }
1379 
1380 /*
1381  * code for debugging dumps
1382  */
1383 
1384 #include <sys/tuneable.h>
1385 #include <sys/var.h>
1386 #include <sys/file.h>
1387 #include <sys/vnode.h>
1388 #include <sys/stat.h>
1389 #include <sys/buf.h>
1390 #include <sys/fs/rf_acct.h>
1391 
1392 int	dump_iodev ();
1393 
1394 dump_diskhd (dp)
1395 	struct diskhd	*dp;
1396 {
1397 
1398 	dfprintf (stderr, "dump_diskhd: dp 0x%x\n", (int)dp);
1399 	dfprintf (stderr, "flags\tb_forw\tb_back\tav_forw\tav_back\tb_bcount\n0x%x\t0x%x\t0x%x\t0x%x\t0x%x\t%d\n",
1400 		(int)dp->b_flags, (int)dp->b_forw, (int)dp->b_back,
1401 		(int)dp->av_forw, (int)dp->av_back, (int)dp->b_bcount);
1402 
1403 return (0);
1404 }
1405 
1406 dump_nlist (nlist, str)
1407 	struct nlist    nlist[];
1408 	char            *str;
1409 {
1410 	int             i;
1411 
1412 	for (i = 0; nlist[i].n_name; i++) {
1413 		dfprintf (stderr, "%s: i %d n_name '%s' n_value 0x%x\n",
1414 			str, i, nlist[i].n_name, (int)nlist[i].n_value);
1415 	}
1416 
1417 return (0);
1418 }
1419 
1420 dump_v_struct (tbl)
1421 	struct var *tbl;
1422 {
1423 	dfprintf (stderr, "dump_v_struct: tbl 0x%x\n", (int)tbl);
1424 	dfprintf (stderr, "v_buf\tv_call\tv_proc\tv_nglobpris\n%d\t%d\t%d\t%d\n",
1425 		tbl->v_buf, tbl->v_call, tbl->v_proc, tbl->v_nglobpris);
1426 	dfprintf (stderr, "v_maxsyspri\tv_clist\tv_maxup\tv_hbuf\n%d\t\t%d\t%d\t%d\n",
1427 		tbl->v_maxsyspri, tbl->v_clist, tbl->v_maxup, tbl->v_hbuf);
1428 	dfprintf (stderr, "v_hmask\tv_pbuf\tv_sptmap\tv_maxpmem\n0x%x\t%d\t%d\t\t%d\n",
1429 		tbl->v_hmask, tbl->v_pbuf, tbl->v_sptmap, tbl->v_maxpmem);
1430 	dfprintf (stderr, "v_autoup\tv_bufhwm\n%d\t\t%d\n",
1431 		tbl->v_autoup, tbl->v_bufhwm);
1432 
1433 return (0);
1434 }
1435 
dump_tblmap(tbl,size)1436 dump_tblmap (tbl, size)
1437 	int	*tbl;
1438 	int	size;
1439 {
1440 	int	i;
1441 
1442 	dfprintf (stderr, "tblmap size %d/4 = %d ", size, size/4);
1443 	for (i = 0; i < size/4; i++) {
1444 		dfprintf (stderr, "tblmap[%d] %d ", i, tbl[i]);
1445 	}
1446 	dfprintf (stderr, "\n");
1447 
1448 return (0);
1449 }
1450