smmemshow.c

vxworks源码源码解读是学习vxworks的最佳途径

/* smMemShow.c - shared memory management show routines (VxMP Option) */

/* Copyright 1984-1993 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01i, 14jul97,dgp  doc: add windsh x-ref to smMemShow()
01h,14feb93,jdi  documentation cleanup for 5.1.
01g,29jan93,pme  added little endian support.
01f,21nov92,jdi  documentation cleanup.
01e,21nov92,jdi  documentation cleanup.
01d,02oct92,pme  documentation cleanup.
                 added SPARC support.
01c,29sep92,pme  fixed WARNING in printf call.
01b,29jul92,pme  Added partition type check.
01a,19jul92,pme  written.
*/

/*
DESCRIPTION
This library provides routines to show the statistics on a shared memory
system partition.

General shared memory management routines are provided by smMemLib.

CONFIGURATION
The routines in this library are included by default if INCLUDE_SM_OBJ is
defined in configAll.h.

AVAILABILITY
This module is distributed as a component of the unbundled shared memory
objects support option, VxMP.

INCLUDE FILES: smLib.h, smObjLib.h, smMemLib.h

SEE ALSO: smMemLib,
.pG "Shared Memory Objects"
*/

/* includes */

#include "vxWorks.h"
#include "errno.h"
#include "semLib.h"
#include "smObjLib.h"
#include "smLib.h"
#include "logLib.h"
#include "intLib.h"
#include "smMemLib.h"
#include "taskLib.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "netinet/in.h"

/******************************************************************************
*
* smMemShowInit - initialize shared memory manager show routine
*
* This routine links the shared memory objects show routine into the VxWorks
* system.  These routines are included automatically by defining
* \%INCLUDE_SHOW_ROUTINES in configAll.h.
*
* RETURNS: N/A
*
* NOMANUAL
*/

void smMemShowInit (void)
    {
    smMemPartShowRtn = (FUNCPTR) smMemPartShow;
    }

/*******************************************************************************
*
* smMemPartShow - show shared partition blocks and statistics
*
* For a specified shared partition, this routine displays the total 
* amount of free space in the partition, the number of blocks, the average 
* block size, and the maximum block size.  It also shows the number of 
* blocks currently allocated, and the average allocated block size.
*
* In addition, if <type> is 1, this routine displays a list of all the blocks
* in the free list of the specified shared partition.
*
* WARNING
* This routine locks access to the partition while displaying the information.
* This can compromise the access time to the partition from other CPU in 
* the system.  Generally this routine is used for debugging purposes only.
*
* RETURNS: OK or ERROR.
*
* ERRNO:
*  S_objLib_OBJ_ID_ERROR
*  S_smObjLib_LOCK_TIMEOUT
*
* SEE ALSO: smMemShow()
* 
* NOMANUAL
*/

STATUS smMemPartShow 
    (
    SM_PART_ID partId,     /* global partition id to use */
    int        type        /* 0 = statistics, 1 = statistics & list */
    )
    {
    SM_BLOCK_HDR * pHdr;
    SM_DL_NODE *   pNode;
    unsigned       totalBytes   = 0;
    unsigned       biggestWords = 0;
    int            numBlocks;
    int            ix = 1;

    if (partId == NULL)
	{
	printf ("No partId specified.\n");
	return (ERROR);
	}

    if (SM_OBJ_VERIFY (partId) != OK)			/* shared object? */
        return (ERROR);

    if (ntohl (partId->objType) != MEM_PART_TYPE_SM_STD)/* shared partition? */
	{
	errno = S_objLib_OBJ_ID_ERROR;
	return (ERROR);
	}

    /* print out list header if we are going to print list */

    if (type > 0)
	{
	printf ("\nFREE LIST:\n");
	printf ("  num     addr      size\n");
	printf ("  --- ---------- ----------\n");
	}

    if (smMemPartAccessGet(partId) != OK) return (ERROR);

    /* go through free list and find total free and largest free,
     * and print each block if specified */

    for (pNode = (SM_DL_NODE *) SM_DL_FIRST (&partId->freeList);
	 pNode != LOC_NULL;
	 pNode = (SM_DL_NODE *) SM_DL_NEXT (pNode))
	{
	pHdr = SM_NODE_TO_HDR (pNode);

        /* check consistency and delete if not */

        if (!smMemPartBlockIsValid (partId, pHdr, TRUE))
            {
            printf ("  invalid block at %#x deleted\n", (int) pHdr);
            smDllRemove (&partId->freeList, SM_HDR_TO_NODE (pHdr));
            }
        else
	    {
	    totalBytes += 2 * (ntohl (pHdr->nWords));

	    if (ntohl (pHdr->nWords) > biggestWords)
		biggestWords = ntohl (pHdr->nWords);

	    if (type >= 1)
		printf ("  %3d %#10x %10d\n", ix++, LOC_TO_GLOB_ADRS (pHdr), 
			2 * ntohl (pHdr->nWords));
	    }
	}

    if (type > 0)
	printf ("\n\n");


    numBlocks = smDllCount (&partId->freeList);

    if (type > 0)
	printf ("SUMMARY:\n");
    printf (" status   bytes    blocks   ave block  max block\n");
    printf (" ------ --------- -------- ---------- ----------\n");
    printf ("current\n");

    if (numBlocks != 0)
	printf ("   free  %8d  %7d  %9d %9d\n", totalBytes, numBlocks,
		totalBytes / numBlocks, 2 * biggestWords);
    else
	printf ("   no free blocks\n");

    if (ntohl (partId->curBlocksAllocated) != 0)
	printf ("  alloc  %8d  %7d  %9d        -\n",
		2 * ntohl (partId->curWordsAllocated), 
		ntohl (partId->curBlocksAllocated),
	        (2 * ntohl (partId->curWordsAllocated)) / 
		ntohl (partId->curBlocksAllocated));
    else
	printf ("   no allocated blocks\n");

    printf ("cumulative\n");

    if (ntohl (partId->cumBlocksAllocated) != 0)
	printf ("  alloc  %8d  %7d  %9d        -\n",
		2 * ntohl (partId->cumWordsAllocated), 
		ntohl (partId->cumBlocksAllocated),
		(2 * ntohl (partId->cumWordsAllocated)) / 
		ntohl (partId->cumBlocksAllocated));
    else
	printf ("   no allocated blocks\n");

    if (smMemPartAccessRelease (partId) != OK) return (NULL);

    return (OK);
    }
/*******************************************************************************
*
* smMemShow - show the shared memory system partition blocks and statistics (VxMP Option)
*
* This routine displays the total amount of free space in the shared memory
* system partition, including the number of blocks, the average block size,
* and the maximum block size.  It also shows the number of blocks currently
* allocated, and the average allocated block size.
*
* If <type> is 1, it displays a list of all the blocks in the free list of
* the shared memory system partition.
*
* WARNING
* This routine locks access to the shared memory system partition while
* displaying the information.  This can compromise the access time to
* the partition from other CPUs in the system.  Generally, this routine is
* used for debugging purposes only.
*
* .ne8
* EXAMPLE
* .CS
* .ne 7
*    -> smMemShow 1
* 
*    FREE LIST:
*      num    addr       size
*      --- ---------- ----------
*        1   0x4ffef0        264
*        2   0x4fef18       1700
*
* .ne 9
*    SUMMARY:
*        status        bytes    blocks   ave block  max block
*    --------------- --------- -------- ---------- ----------
*            current
*               free      1964        2        982       1700
*              alloc      2356        1       2356         -
*         cumulative
*              alloc      2620        2       1310         -
*    value = 0 = 0x0
* .CE
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled shared memory
* objects support option, VxMP.
* 
* RETURNS: N/A
*
* SEE ALSO
* windsh,
* .tG "Shell"
*/

void smMemShow 
    (
    int type 		/* 0 = statistics, 1 = statistics & list */
    )
    {
    smMemPartShow (smSystemPartId, type);
    }