Examples
#pragma linkage(BPX1PCT, OS)
extern void BPX1PCT(char *, int, int, char *, int *, int *, int *);
/* #include <stdlib.h> */
#include <stdio.h>
#define ZFSCALL_STATS 0x40000007
#define STATOP_LOCKING 240 /* Performance API queries */
#define u_long unsigned long
typedef struct syscall_parmlist_t
{
int opcode; /* Operation code to perform */
int parms[7]; /* Specific to type of operation, */
/* provides access to the parms */
/* parms[4]-parms[6] are currently unused*/
} syscall_parmlist;
typedef struct Lock_line_t
{
int count; /* Number of thread waits for this lock */
int async; /* Asynchronous disposition*/
int spins; /* Number of attempts to get lock that did not resolve immediately*/
int pad1;
double percentage; /**/
int percentage_whole; /* percentage >= 1*/
int percentage_decimal;/* percentage < 1*/
/* in thousanths.*/
/* For example, 3 means .003 and 300 means .3 */
char description[84]; /* Description of the lock */
int pad2;
} LOCK_LINE;
typedef struct Sleep_line_t
{
unsigned long sleepcount; /* Time spent sleeping */
int pad1;
double percentage; /* Percentage of time spent sleeping*/
int percentage_whole; /* Percentage >=1 */
int percentage_decimal; /* Percentage < 1 */
/* in thousanths.*/
/* For example, 3 means .003 and 300 means .3 */
char description[84]; /*Description of the thread*/
int pad2;
} SLEEP_LINE;
/* reset timestamp */
typedef struct reset_time {
u_long posix_time_high; /* high order 32 bits since epoc */
u_long posix_time_low; /* low order 32 bits since epoch */
u_long posix_usecs; /* microseconds */
int pad1;
} RESET_TIME;
/*********************************************************************/
/* The following structure is the api query control block */
/* It is used for all api query commands */
/*********************************************************************/
typedef struct stat_api_t
{
#define SA_EYE "STAP"
char sa_eye[4]; /* 4 byte identifier must be */
int sa_len; /* length of the buffer to put data into*/
/* this buffer area follows this struct*/
int sa_ver; /* the version number currently always 1*/
#define SA_VER_INITIAL 0x01
char sa_flags; /* flags field must be x00 or x80, x80 means reset statistics*/
#define SA_RESET 0x80
char sa_fill[3]; /* spare bytes */
int sa_reserve[4]; /* Reserved */
struct reset_time reset_time_info;
} STAT_API;
typedef struct stat_locking_t
{
int reserved1;
unsigned long stlk_untimed_sleeps; /* Number of untimed sleeps */
unsigned long stlk_timed_sleeps; /* Number of timed sleeps */
unsigned long stlk_wakeups; /* Number of wake ups */
unsigned long stlk_total_wait_for_locks; /* Total waits for locks */
int pad1;
double stlk_average_lock_wait_time; /*Average lock wait time */
int stlk_avg_lock_wait_time_whole; /*Average lock wait time in msecs */
/*left of the decimal part */
int stlk_avg_lock_wait_time_decimal; /*Average lock wait time in msecs */
/*decimal portion */
/* in thousanths */
/* for example, 3 means .003 and 300 means .3 */
unsigned long stlk_total_monitored_sleeps; /*Total monitored sleeps */
int pad2;
double stlk_average_monitored_sleep_time;/* Average monitored sleep time */
int stlk_avg_mon_sleep_time_whole; /*Average monitored sleep time in msecs */
/* left of the decimal part*/
int stlk_avg_mon_sleep_time_decimal; /*Average monitored sleep time in msecs */
/* decimal portion */
/* in thousanths */
/* for example, 3 means .003 and 300 means .3 */
unsigned long stlk_total_contentions; /*Total lock contention of all kinds*/
char stlk_reserved_space[48]; /* reserved for future use */
int pad3;
#define MAX_LOCKS 15 /* Maximum number of locks in this release*/
#define MAX_SLEEPS 5 /* Maximum number of sleeps in this release*/
LOCK_LINE stlk_locks[MAX_LOCKS]; /* Storage for the lock data */
SLEEP_LINE stlk_sleeps[MAX_SLEEPS]; /* Storage for the top 5 most common sleep threads*/
} STAT_LOCKING;
/*********************************************************************/
/* The following structures are used to represent cfgop queries */
/* for locking stats */
/*********************************************************************/
struct parmstruct
{
syscall_parmlist myparms;
STAT_API myapi;
STAT_LOCKING mystats;
char systemname[9];
} myparmstruct;
int main(int argc, char **argv)
{
int bpxrv;
int bpxrc;
int bpxrs;
int i;
STAT_API *stapptr = &(myparmstruct.myapi);
STAT_LOCKING *stlkptr = &(myparmstruct.mystats);
char buf[33];
myparmstruct.myparms.opcode = STATOP_LOCKING;
myparmstruct.myparms.parms[0] = sizeof(syscall_parmlist);
myparmstruct.myparms.parms[1] = sizeof(syscall_parmlist) + sizeof(STAT_API);
myparmstruct.myparms.parms[2] = 0;
/* Only specify a non-zero offset for the next field (parms[2]) if */
/* you are running z/OS 1.7 and above, and */
/* you want to query the locking statistics of a different system than this one */
/* myparmstruct.myparms.parms[2] = sizeof(syscall_parmlist) + sizeof(STAT_API) + sizeof(STAT_LOCKING); */
myparmstruct.myparms.parms[3] = 0;
myparmstruct.myparms.parms[4] = 0;
myparmstruct.myparms.parms[5] = 0;
myparmstruct.myparms.parms[6] = 0;
memset(stapptr,0,sizeof(STAT_API));
memcpy(stapptr->sa_eye,SA_EYE,4);
stapptr->sa_ver=SA_VER_INITIAL;
stapptr->sa_len=(int) sizeof(STAT_LOCKING);
/* This next field should only be set if parms[2] is non-zero */
/* strcpy(myparmstruct.systemname,"DCEIMGVQ"); */
BPX1PCT("ZFS ",
ZFSCALL_STATS, /* Perf statistics operation */
sizeof(myparmstruct), /* Length of Argument */
(char *) &myparmstruct, /* Pointer to Argument */
&bpxrv, /* Pointer to Return_value */
&bpxrc, /* Pointer to Return_code */
&bpxrs); /* Pointer to Reason_code */
if( bpxrv < 0 )
{
printf("Error querying locking stats, BPXRV = %d BPXRC = %d BPXRS = %x\n",bpxrv,bpxrc,bpxrs);
return bpxrc;
}
else
{
printf("%55s\n","Locking Statistics");
printf("\n");
printf("\n");
printf("Untimed sleeps: %10u Timed Sleeps: %10u Wakeups: %10u\n",
myparmstruct.mystats.stlk_untimed_sleeps,
myparmstruct.mystats.stlk_timed_sleeps,
myparmstruct.mystats.stlk_wakeups);
printf("\n");
printf("Total waits for locks: %10u\n",
myparmstruct.mystats.stlk_total_wait_for_locks);
printf("Average lock wait time: %9u.%3.3u (msecs)\n",
myparmstruct.mystats.stlk_avg_lock_wait_time_whole,
myparmstruct.mystats.stlk_avg_lock_wait_time_decimal);
printf("\n");
printf("Total monitored sleeps: %10u\n",
myparmstruct.mystats.stlk_total_monitored_sleeps);
printf("Average monitored sleep time: %9u.%3.3u (msecs)\n",
myparmstruct.mystats.stlk_avg_mon_sleep_time_whole,
myparmstruct.mystats.stlk_avg_mon_sleep_time_decimal);
printf("\n");
printf(" Top %u Most Highly Contended Locks\n",
MAX_LOCKS);
printf(" Thread Async Spin \n");
printf(" Wait Disp. Resol. Pct. Description\n");
printf("---------- ---------- ---------- ----- --------------\n");
for( i = 0; i < MAX_LOCKS;i++ )
{
printf("%10u %10u %10u %3u.%1.1u%% %.80s\n",
myparmstruct.mystats.stlk_locks[i].count,
myparmstruct.mystats.stlk_locks[i].async,
myparmstruct.mystats.stlk_locks[i].spins,
myparmstruct.mystats.stlk_locks[i].percentage_whole,
myparmstruct.mystats.stlk_locks[i].percentage_decimal,
myparmstruct.mystats.stlk_locks[i].description);
}
printf("\n");
printf("Total lock contention of all kinds: %10u\n",
myparmstruct.mystats.stlk_total_contentions);
printf("\n");
printf(" Top %u Most Common Thread Sleeps\n",
MAX_SLEEPS);
printf("Thread Wait Pct. Description\n");
printf("----------- ----- -----------\n");
for( i = 0; i < MAX_SLEEPS;i++ )
{
printf(" %10u %3u.%1.1u%% %.80s\n",
myparmstruct.mystats.stlk_sleeps[i].sleepcount,
myparmstruct.mystats.stlk_sleeps[i].percentage_whole,
myparmstruct.mystats.stlk_sleeps[i].percentage_decimal,
myparmstruct.mystats.stlk_sleeps[i].description);
printf("\n");
}
if (0==ctime_r((time_t *) &stapptr->reset_time_info.posix_time_low, buf))
{
printf("Could not get timestamp.\n");
}
else
{ /* Insert the microseconds into the displayable time value */
strncpy(&(buf[27]),&(buf[20]),6);
sprintf(&(buf[20]),"%06d",stapptr->reset_time_info.posix_usecs);
buf[26]=' ';
buf[19]='.';
printf("Last Reset Time: %s",buf);
}
}
return 0;
}
z/OS Distributed File Service zFS Administration
Copyright IBM Corporation 1990, 2014