sar.c

linux下查看系统工具原码,如IOSTAT等

			(long) pid_stats[curr][i]->nswap, itv));

	 if (!disp_avg)
	    printf("   %3d\n", pid_stats[curr][i]->processor);
	 else
	    printf("\n");
      }
   }

   /* Print statistics about children of a given process */
   if (GET_CPID(act)) {
      if (dis)
	 printf("\n%-11s      PPID cminflt/s cmajflt/s    %%cuser  %%csystem  cnswap/s\n",
		prev_string);

      for (i = 0; i < pid_nr; i++) {
	 if (!pid_stats[curr][i]->pid || !(pid_stats[curr][i]->flag & X_PPID_SET))
	    continue;
	 printf("%-11s %9ld", curr_string, pid_stats[curr][i]->pid);

	 printf(" %9.2f %9.2f    %6.2f    %6.2f %9.2f\n",
		S_VALUE(pid_stats[prev][i]->cminflt, pid_stats[curr][i]->cminflt, itv),
		S_VALUE(pid_stats[prev][i]->cmajflt, pid_stats[curr][i]->cmajflt, itv),
		SP_VALUE(pid_stats[prev][i]->cutime,  pid_stats[curr][i]->cutime,  itv),
		SP_VALUE(pid_stats[prev][i]->cstime,  pid_stats[curr][i]->cstime,  itv),
		S_VALUE((long) pid_stats[prev][i]->cnswap,
			(long) pid_stats[curr][i]->cnswap, itv));
      }
   }

   /* Print TTY statistics (serial lines) */
   if (GET_SERIAL(act)) {
      struct stats_serial
	 *ssi = st_serial[curr],
	 *ssj = st_serial[prev];

      if (dis)
	 printf("\n%-11s       TTY   rcvin/s   xmtin/s framerr/s prtyerr/s     "
		"brk/s   ovrun/s\n", prev_string);

      for (i = 0; i < file_hdr.sa_serial; i++, ssi++, ssj++) {

	 if (ssi->line == ~0)
	    continue;
	
	 printf("%-11s       %3d", curr_string, ssi->line);

	 if ((ssi->line == ssj->line) || want_since_boot) {
	    printf(" %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
		   S_VALUE(ssj->rx, ssi->rx, itv),
		   S_VALUE(ssj->tx, ssi->tx, itv),
		   S_VALUE(ssj->frame, ssi->frame, itv),
		   S_VALUE(ssj->parity, ssi->parity, itv),
		   S_VALUE(ssj->brk, ssi->brk, itv),
		   S_VALUE(ssj->overrun, ssi->overrun, itv));
	 }
	 else
	    printf("       N/A       N/A       N/A       N/A       N/A       N/A\n");
      }
   }

   if (GET_IRQ(act) && WANT_PER_PROC(flags) && file_hdr.sa_irqcpu) {
      int offset;
      struct stats_irq_cpu *p, *q, *p0, *q0;

      j = 0;
      /* Check if number of interrupts has changed */
      if (!dis && !want_since_boot && !disp_avg) {
	 do {
	    p0 = st_irq_cpu[curr] + j;
	    if (p0->irq != ~0) {
	       q0 = st_irq_cpu[prev] + j;
	       if (p0->irq != q0->irq)
		  j = -2;
	    }
	    j++;
	 }
	 while ((j > 0) && (j <= file_hdr.sa_irqcpu));
      }

      if (dis || (j < 0)) {
	 /* Print header */
	 printf("\n%-11s  CPU", prev_string);
	 for (j = 0; j < file_hdr.sa_irqcpu; j++) {
	    p0 = st_irq_cpu[curr] + j;
	    if (p0->irq != ~0)	/* Nb of irq per proc may have varied... */
	       printf("  i%03d/s", p0->irq);
	 }
	 printf("\n");
      }

      for (k = 0; k <= file_hdr.sa_proc; k++) {
	 if (cpu_bitmap[k >> 3] & (1 << (k & 0x07))) {

	    printf("%-11s  %3d", curr_string, k);

	    for (j = 0; j < file_hdr.sa_irqcpu; j++) {
	       p0 = st_irq_cpu[curr] + j;	/* irq field set only for proc #0 */
	       /*
		* A value of ~0 means it is a remaining interrupt
		* which is no longer used, for example because the
		* number of interrupts has decreased in /proc/interrupts
		* or because we are appending data to an old sa file
		* with more interrupts than are actually available now.
		*/
	       if (p0->irq != ~0) {	
		  q0 = st_irq_cpu[prev] + j;
		  offset = j;

		  /*
		   * If we want stats for the time since system startup,
		   * we have p0->irq != q0->irq, since q0 structure is
		   * completely set to zero.
		   */
		  if ((p0->irq != q0->irq) && !want_since_boot) {
		     if (j)
			offset = j - 1;
		     q0 = st_irq_cpu[prev] + offset;
		     if ((p0->irq != q0->irq) && (j + 1 < file_hdr.sa_irqcpu))
			offset = j + 1;
		     q0 = st_irq_cpu[prev] + offset;
		  }
		  if ((p0->irq == q0->irq) || want_since_boot) {
		     p = st_irq_cpu[curr] + k * file_hdr.sa_irqcpu + j;
		     q = st_irq_cpu[prev] + k * file_hdr.sa_irqcpu + offset;
		     printf(" %7.2f",
			    S_VALUE(q->interrupt, p->interrupt, itv));
		  }
		  else
		     printf("     N/A");
	       }
	    }
	    printf("\n");
	 }
      }
   }

   /* Print network interface statistics */
   if (GET_NET_DEV(act)) {
      struct stats_net_dev
	 *sndi = st_net_dev[curr],
	 *sndj;

      if (dis)
	 printf("\n%-11s     IFACE   rxpck/s   txpck/s   rxbyt/s   txbyt/s   "
		"rxcmp/s   txcmp/s  rxmcst/s\n",
		prev_string);

      for (i = 0; i < file_hdr.sa_iface; i++, sndi++) {

	 if (!strcmp(sndi->interface, "?"))
	    continue;
	 j = check_iface_reg(&file_hdr, st_net_dev, curr, prev, i);
	 sndj = st_net_dev[prev] + j;
	 printf("%-11s %9s", curr_string, sndi->interface);
	
	 printf(" %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
		S_VALUE(sndj->rx_packets, sndi->rx_packets, itv),
		S_VALUE(sndj->tx_packets, sndi->tx_packets, itv),
		S_VALUE(sndj->rx_bytes, sndi->rx_bytes, itv),
		S_VALUE(sndj->tx_bytes, sndi->tx_bytes, itv),
		S_VALUE(sndj->rx_compressed, sndi->rx_compressed, itv),
		S_VALUE(sndj->tx_compressed, sndi->tx_compressed, itv),
		S_VALUE(sndj->multicast, sndi->multicast, itv));
      }
   }

   /* Print network interface statistics (errors) */
   if (GET_NET_EDEV(act)) {
      struct stats_net_dev
	 *sndi = st_net_dev[curr],
	 *sndj;

      if (dis)
	 printf("\n%-11s     IFACE   rxerr/s   txerr/s    coll/s  rxdrop/s  "
		"txdrop/s  txcarr/s  rxfram/s  rxfifo/s  txfifo/s\n",
		prev_string);

      for (i = 0; i < file_hdr.sa_iface; i++, sndi++) {

	 if (!strcmp(sndi->interface, "?"))
	    continue;
	 j = check_iface_reg(&file_hdr, st_net_dev, curr, prev, i);
	 sndj = st_net_dev[prev] + j;
	
	 printf("%-11s %9s", curr_string, sndi->interface);

	 printf(" %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
		S_VALUE(sndj->rx_errors, sndi->rx_errors, itv),
		S_VALUE(sndj->tx_errors, sndi->tx_errors, itv),
		S_VALUE(sndj->collisions, sndi->collisions, itv),
		S_VALUE(sndj->rx_dropped, sndi->rx_dropped, itv),
		S_VALUE(sndj->tx_dropped, sndi->tx_dropped, itv),
		S_VALUE(sndj->tx_carrier_errors, sndi->tx_carrier_errors, itv),
		S_VALUE(sndj->rx_frame_errors, sndi->rx_frame_errors, itv),
		S_VALUE(sndj->rx_fifo_errors, sndi->rx_fifo_errors, itv),
		S_VALUE(sndj->tx_fifo_errors, sndi->tx_fifo_errors, itv));
      }
   }

   /* Print disk statistics */
   if (GET_DISK(act)) {
      double tput, util, await, svctm, arqsz;
      struct disk_stats
	 *sdi = st_disk[curr],
	 *sdj;

      if (dis)
	 printf("\n%-11s       DEV       tps  rd_sec/s  wr_sec/s  avgrq-sz  "
		"avgqu-sz     await     svctm     %%util\n",
		prev_string);

      for (i = 0; i < file_hdr.sa_nr_disk; i++, ++sdi) {
	
	 if (!(sdi->major + sdi->minor))
	    continue;

	 j = check_disk_reg(&file_hdr, st_disk, curr, prev, i);
	 sdj = st_disk[prev] + j;

	 tput = ((double) (sdi->nr_ios - sdj->nr_ios)) * HZ / itv;
	 util = S_VALUE(sdj->tot_ticks, sdi->tot_ticks, itv);
	 svctm = tput ? util / tput : 0.0;
	 await = (sdi->nr_ios - sdj->nr_ios) ?
	    ((sdi->rd_ticks - sdj->rd_ticks) + (sdi->wr_ticks - sdj->wr_ticks)) /
	    ((double) (sdi->nr_ios - sdj->nr_ios)) : 0.0;
	 arqsz  = (sdi->nr_ios - sdj->nr_ios) ?
	    ((sdi->rd_sect - sdj->rd_sect) + (sdi->wr_sect - sdj->wr_sect)) /
	    ((double) (sdi->nr_ios - sdj->nr_ios)) : 0.0;

	 printf("%-11s %9s %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
		curr_string,
		/* Confusion possible here between index and minor numbers */
		get_devname(sdi->major, sdi->minor, USE_PRETTY_OPTION(flags)),
		S_VALUE(sdj->nr_ios, sdi->nr_ios,  itv),
		ll_s_value(sdj->rd_sect, sdi->rd_sect, itv),
		ll_s_value(sdj->wr_sect, sdi->wr_sect, itv),
		/* See iostat for explanations */
		arqsz,
		S_VALUE(sdj->rq_ticks, sdi->rq_ticks, itv) / 1000.0,
		await,
		svctm,
		util / 10.0);
      }
   }

   /* Print NFS client stats */
   if (GET_NET_NFS(act)) {
      if (dis)
	 printf("\n%-11s    call/s retrans/s    read/s   write/s  access/s  getatt/s\n",
		prev_string);

      printf("%-11s %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n", curr_string,
	     S_VALUE(fsj->nfs_rpccnt, fsi->nfs_rpccnt, itv),
	     S_VALUE(fsj->nfs_rpcretrans, fsi->nfs_rpcretrans, itv),
	     S_VALUE(fsj->nfs_readcnt, fsi->nfs_readcnt, itv),
	     S_VALUE(fsj->nfs_writecnt, fsi->nfs_writecnt, itv),
	     S_VALUE(fsj->nfs_accesscnt, fsi->nfs_accesscnt, itv),
	     S_VALUE(fsj->nfs_getattcnt, fsi->nfs_getattcnt, itv));
   }

   /* Print NFS server stats */
   if (GET_NET_NFSD(act)) {
      if (dis)
	 printf("\n%-11s   scall/s badcall/s  packet/s     udp/s     tcp/s     "
		"hit/s    miss/s   sread/s  swrite/s saccess/s sgetatt/s\n",
		prev_string);

      printf("%-11s %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n",
	     curr_string,
	     S_VALUE(fsj->nfsd_rpccnt, fsi->nfsd_rpccnt, itv),
	     S_VALUE(fsj->nfsd_rpcbad, fsi->nfsd_rpcbad, itv),
	     S_VALUE(fsj->nfsd_netcnt, fsi->nfsd_netcnt, itv),
	     S_VALUE(fsj->nfsd_netudpcnt, fsi->nfsd_netudpcnt, itv),
	     S_VALUE(fsj->nfsd_nettcpcnt, fsi->nfsd_nettcpcnt, itv),
	     S_VALUE(fsj->nfsd_rchits, fsi->nfsd_rchits, itv),
	     S_VALUE(fsj->nfsd_rcmisses, fsi->nfsd_rcmisses, itv),
	     S_VALUE(fsj->nfsd_readcnt, fsi->nfsd_readcnt, itv),
	     S_VALUE(fsj->nfsd_writecnt, fsi->nfsd_writecnt, itv),
	     S_VALUE(fsj->nfsd_accesscnt, fsi->nfsd_accesscnt, itv),
	     S_VALUE(fsj->nfsd_getattcnt, fsi->nfsd_getattcnt, itv));
   }
}


/*
 ***************************************************************************
 * Print statistics average
 ***************************************************************************
 */
void write_stats_avg(int curr, short dis, unsigned int act, int read_from_file)
{
   unsigned long long itv, g_itv;
   char string[16];
   struct file_stats
     *fsi = &file_stats[curr];

   /* Interval value in jiffies */
   g_itv = (file_stats[curr].uptime - file_stats[2].uptime) & 0xffffffff;
   if (file_hdr.sa_proc)
      itv = (file_stats[curr].uptime0 - file_stats[2].uptime0) & 0xffffffff;
   else
      itv = g_itv;

   if (!itv || !g_itv) { /* Should no longer happen with recent versions */
      /*
       * Aiee: null interval... This should only happen when reading stats
       * from a system activity file with a far too big interval value...
       */
      fprintf(stderr, _("Please give a smaller interval value\n"));
      exit(1);
   }

   strcpy(string, _("Average:"));
   write_stats_core(2, curr, dis, string, string, act, itv, g_itv, TRUE, FALSE);

   if (GET_MEM_AMT(act)) {
      if (dis)
	 printf("\n%-11s kbmemfree kbmemused  %%memused kbbuffers  kbcached kbswpfree "
		"kbswpused  %%swpused  kbswpcad\n",
		string);

      printf("%-11s %9.0f %9.0f    %6.2f %9.0f %9.0f %9.0f %9.0f    %6.2f %9.0f\n",
	     string,
	     (double) asum.frmkb / asum.count,
	     (double) fsi->tlmkb - ((double) asum.frmkb / asum.count),
	     fsi->tlmkb ?
	     SP_VALUE(asum.frmkb / asum.count, fsi->tlmkb, fsi->tlmkb) : 0.0,
	     (double) asum.bufkb / asum.count,
	     (double) asum.camkb / asum.count,
	     (double) asum.frskb / asum.count,
	     ((double) asum.tlskb / asum.count) - ((double) asum.frskb / asum.count),
	     (asum.tlskb / asum.count) ?
	     SP_VALUE(asum.frskb / asum.count,
		      asum.tlskb / asum.count, asum.tlskb / asum.count)
	     : 0.0,
	     (double) asum.caskb / asum.count);
   }

   if (GET_KTABLES(act)) {
      if (dis)
	 printf("\n%-11s dentunusd   file-sz  inode-sz  super-sz %%super-sz  "
		"dquot-sz %%dquot-sz  rtsig-sz %%rtsig-sz\n",
		string);

      printf("%-11s %9.0f %9.0f %9.0f %9.0f    %6.2f %9.0f    %6.2f %9.0f    %6.2f\n",
	     string,
	     (double) asum.dentry_stat / asum.count,
	     (double) asum.file_used / asum.count,
	     (double) asum.inode_used / asum.count,
	     (double) asum.super_used / asum.count,
	     fsi->super_max ?
	     ((double) ((asum.super_used / asum.count) * 100)) / fsi->super_max
	     : 0.0,
	     (double) asum.dquot_used / asum.count,
	     fsi->dquot_max ?
	     ((double) ((asum.dquot_used / asum.count) * 100)) / fsi->dquot_max
	     : 0.0,
	     (double) asum.rtsig_queued / asum.count,
	     fsi->rtsig_max ?
	     ((double) ((asum.rtsig_queued / asum.count) * 100)) / fsi->rtsig_max
	     : 0.0);
   }

   if (GET_NET_SOCK(act)) {
      if (dis)
	 printf("\n%-11s    totsck    tcpsck    udpsck    rawsck   ip-frag\n",
		string);

      printf("%-11s %9.0f %9.0f %9.0f %9.0f %9.0f\n", string,
	     (double) asum.sock_inuse / asum.count,
	     (double) asum.tcp_inuse / asum.count,
	     (double) asum.udp_inuse / asum.count,
	     (double) asum.raw_inuse / asum.count,
	     (double) asum.frag_inuse / asum.count);
   }

   if (GET_QUEUE(act)) {
      if (dis)
	 printf("\n%-11s   runq-sz  plist-sz   ldavg-1   ldavg-5  ldavg-15\n",
		string);

      printf("%-11s %9.0f %9.0f %9.2f %9.2f %9.2f\n", string,
	     (double) asum.nr_running / asum.count,
	     (double) asum.nr_threads / asum.count,
	     (double) asum.load_avg_1 / (asum.count * 100),
	     (double) asum.load_avg_5 / (asum.count * 100),
	     (double) asum.load_avg_15 / (asum.count * 100));
   }

   if (read_from_file)
      /* Reset counters only if we read stats from a system activity file */
      memset(&asum, 0, STATS_SUM_SIZE);
}


/*
 ***************************************************************************
 * Print system statistics
 ***************************************************************************
 */
int write_stats(short curr, short dis, unsigned int act, int read_from_file,
		long *cnt, int use_tm_start, int use_tm_end, int reset,
		int want_since_boot)
{
   char cur_time[2][16];
   unsigned long long itv, g_itv;
   struct file_stats
      *fsi = &file_stats[curr];

   /* Check time (1) */
   if (read_from_file) {
      if (!next_slice(file_stats[2].uptime, file_stats[curr].uptime,
		      &file_hdr, reset, interval))
	 /* Not close enough to desired interval */
	 return 0;
   }

   /* Set previous timestamp */
   set_timestamp(!curr, cur_time[!curr], 16);
   /* Set current timestamp */
   set_timestamp(curr, cur_time[curr], 16);

   /* Check time (2) */
   if (use_tm_start && (datecmp(&loc_time, &tm_start) < 0))
     /* it's too soon... */
     return 0;

   /* Get interval values */
   get_itv_value(&file_stats[curr], &file_stats[!curr],
		 file_hdr.sa_proc, &itv, &g_itv);

   /* Check time (3) */
   if (use_tm_end && (datecmp(&loc_time, &tm_end) > 0)) {
      /* It's too late... */
      *cnt = 0;
      return 0;
   }

   (asum.count)++;	/* Nb of lines printed */

   write_stats_core(!curr, curr, dis, cur_time[!curr], cur_time[curr], act,
		    itv, g_itv, FALSE, want_since_boot);

   /* Print amount and usage of memory */
   if (GET_MEM_AMT(act)) {
      if (dis)
	 printf("\n%-11s kbmemfree kbmemused  %%memused kbbuffers  kbcached "
		"kbswpfree kbswpused  %%swpused  kbswpcad\n",
		cur_time[!curr]);

      printf("%-11s %9lu %9lu    %6.2f %9lu %9lu %9lu %9lu    %6.2f %9lu\n",
	     cur_time[curr],
	     fsi->frmkb,
	     fsi->tlmkb - fsi->frmkb,
	     fsi->tlmkb ?
	     SP_VALUE(fsi->frmkb, fsi->tlmkb, fsi->tlmkb) : 0.0,
	     fsi->bufkb,
	     fsi->camkb,
	     fsi->frskb,