List Detailed File System Information

Examples

#pragma linkage(BPX1PCT, OS)
#pragma LANGLVL(EXTENDED)

extern void BPX1PCT(char *, int, int, char *, int *, int *, int *);

#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>

#define ZFSCALL_FSINFO       0x40000013
#define ZFS_MAX_AGGRNAME     44
#define AGOP_FSINFO_PARMDATA 153 /* Get status on aggr & fs */
#define BUFFER_SIZE          1024 * 64

#define FSINFO_XCF_ERR       0x1
#define FSINFO_IO_ERR        0x2
#define FSINFO_SPC_ERR       0x4

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[1]-parms[6] are currently unused*/
} syscall_parmlist;

struct timeval64 {
  uint64_t tv_sec;
  int32_t  tv_usec_pad;
  uint32_t tv_usec;
};

typedef struct FSINFO_REQUEST_t {
  char  fr_eye[4];
#define FR_EYE  "FIRQ"
  short fr_length;
  char  fr_sversion;             /* Structure version. must be 1 */
  char  fr_reqtype;              /*request type. BulkList=0, OffsetCursor=1*/
#define FR_REQTYPE_SINGLEQUERY 0
#define FR_REQTYPE_NAMECURSOR  1
  char  fr_version;              /* Version of input/output buffer; must be 1*/
  char  fr_output;               /* Type of output */
#define FR_OUT_LOCAL_STAT      0 /* Local stats from local system */
#define FR_OUT_FULL_STAT       1 /* Full stats from all systems*/
#define FR_OUT_RESET           2 /* reset statistics */
  char  fr_nameSelection;        /* Selection of aggregates desired, one of: */
#define FR_NM_ALLAGGR          1 /* All aggregates */
#define FR_NM_LOCAL            2 /* Local aggregates */
#define FR_NM_PATTERN          3 /* All aggregates matching pattern */
  char  fr_eol;                  /* Indicates if a multi-aggregate
                                    read has completed */
  int   fr_selection;            /* Selection criteria of aggregates desired */
  unsigned int   fr_entries;     /* Number of entries returned
                                    by zFS (for OffsetCusor) */
  int   fr_nonFatalRc;           /* Non-fatal error code */
  int   fr_nonFatalRsn;          /* Reason code if fr_nonFatalRc is non-0 */
  char  fr_resumeName[45];  /* Dataset name to resume with for NameCursor or */
                            /* the name for the single-aggregate query.*/
  char  fr_patternName[45]; /* The pattern name to be used. */
  char  fr_future2[2];
} FSINFO_REQUEST;

typedef struct FSINFO_NAME_t
{
  char  fn_eye[4];
#define FN_EYE "FINA"
  short fn_slength;           /* Structure length */
  short fn_sversion;
  char  fn_name[44];          /* aggregate name */
  unsigned int  fn_connected; /* number of conneceted systems if owner
                                 output is included; 0 otherwise*/
  char  fn_owner[8];          /* system name of the owner */
  unsigned int fn_length;     /* Total length of all information for this
                                 aggregate, so programs can quickly find the
                                 beginning of the next record
                                 in the output buffer. */
  char  fn_future[4];
  char  fn_sysnames[8];       /* Names of connected systems (32 at most).Actual
                                 number is defined fn_connected.*/
} FSINFO_NAME;

typedef struct FSINFO_OWNER_t {
  char           fo_eye[4];
#define          FSO_EYE "FIOW"
  short          fo_length;
  short          fo_sversion;
  unsigned int   fo_size;          /* Num of 8K blocks in the aggregate */
  unsigned int   fo_free;          /* Number of unused 8K blocks
                                      in the aggregate.*/
  unsigned long long int fo_frags; /* Num of free 1K fragments
                                      available in the aggregate.*/
  unsigned int   fo_logsize;       /* Num of 8K blocks allocated
                                      to the log file for
                                      transaction logging,
                                      including indirect blocks.*/
  unsigned int   fo_bitmapsize;    /* Number of 8K blocks allocated to the
                                      bitmap file including indirect blocks.*/
  unsigned int   fo_anodesize;     /* Number of 8K blocks allocated
                                      to the anode table.*/
  unsigned int   fo_objects;       /* Number of objects in the file system. */
  char           fo_version;       /* Aggregate version number */
  char           fo_threshold;     /* Space monitoring threshold */
  char           fo_increment;     /* Space monitoring increment*/
  char           reserved1;
  int            fo_flags;
#define FO_OWNER_MNTRW       0x1   /* Mounted in RW mode */
#define FO_OWNER_DISABLED    0x2   /* Disabled for access */
#define FO_OWNER_GROWFAIL    0x4   /* Grow failure since last reset */
#define FO_OWNER_LOW_ONSPC   0x8   /* Low on space (zfs definition)*/
#define FO_OWNER_DAMAGED     0x10  /* Aggregate is damaged by salvage
                                      verification & not repaired yet */
#define FO_OWNER_RWSHARE     0x20  /* Aggregate using zFS sysplex
                                      sharing (RWSHARE) */
#define FO_OWNER_GROWSET     0x40  /* Dynamic grow set at mount time */
#define FO_OWNER_GROWING     0x80  /* Aggregate is in the process
                                      of growing at the time of query */
#define FO_CONVERTOV5        0x100 /* CONVERTTOV5 parm is set on mount. */
#define FO_NOTMOUNT          0x200 /* Aggregate is not mounted */
#define FO_NO_OWNER          0x400 /* Aggregate is un-owned */
#define FO_OWNER_ALLOWGROW   0x800 /* Dynamic grow allowed , no
                                      grow failures or since a grow
                                      failure an admin grow was done. */
#define FO_OWNER_CHGOWNER    0x1000     /* The quiesce is done for a
                                           chgowner instead of a backup */
#define FO_CONVERTTOV5_DISABLED 0x2000  /* CONVERTTOV5 is disabled
                                           due to quiesce or failed convert */
#define FO_V4                0x4000     /* Aggregate with version 1.4 */
#define FO_V5                0x8000     /* Aggregate with version 1.5 */

  unsigned int fo_overflow; /* Num of overflow pages used for v5 directories */
  unsigned int fo_overflowhiwater; /* Hiwater mark of fo_overflow
                                      for life of file system.*/
  unsigned int fo_thrashing;       /* Current number of objects using
                                      the thrash-resolution protocol*/
  char         reserved2[4];
  unsigned long long int fo_thrash_resolution; /* Number of thrash resolutions
                                                  performed since last
                                                  statistics reset.*/
  unsigned long long int fo_revocations; /* Number of token revocations
                                            performed since last
                                            statistics reset*/
  unsigned long long int fo_revwait;     /* Average revocation wait time
                                            in microseconds.*/
  char                   fo_qsysname[8]; /* Name of system requesting quiesce,
                                            if the aggregate is quiesced,
                                            0 otherwise.*/
  char                   fo_jobname[8];  /* Name of job requesting quiesce,
                                            if the aggregate is quiesced,
                                            0 otherwise.*/
  unsigned long long int fo_createtime;  /* Creation time in
                                            seconds since epoch*/
  unsigned long long int fo_ownership;   /* Owership time in
                                            seconds since epoch*/
  unsigned long long int fo_reset;       /* Time statistic counters reset in
                                            seconds since last epoch*/
  unsigned long long int fo_quiesce;     /* Quiesce time in seconds since
                                            epoch, 0 if file system
                                            not quiesced.*/
  unsigned int           fo_devno;       /* Devno for the mount*/
  char                   fo_auditfid[10]; /* Audit fid for file system*/
  unsigned short         fo_qasid;       /* ASID which issued the quiesce */
  unsigned int           fo_growcount;   /* Number of grows since mount. */
  char                   reserved3[4];
  unsigned long long int fo_growtime;    /* Time of the last grow 
                                            as known by owner */
} FSINFO_OWNER;

typedef struct FSINFO_LOCAL_t {
  char                   fl_eye[4];
#define                  FL_EYE  "FILO"
  short                  fl_length;
  short                  fl_sversion;     /* Structure version */
  unsigned long long int fl_vnodes;       /* Number of vnodes cached in memory
                                             on the local system */
  unsigned long long int fl_ussheld;      /* Number of USS held vnodes*/
  char                   fl_sysname[8];   /* System name these stats are for */
  unsigned long long int fl_open;         /* Number of open objects in
                                             the file system */
  unsigned long long int fl_tokens;       /* Number of tokens held from
                                             the token manager */
  unsigned int           fl_usercache;    /* Number of 4K pages held in the
                                             user cache for the file system */
  unsigned int           fl_metacache;    /* Number of 8k pages held in
                                             the metadata cache */
  unsigned long long int fl_appreads;     /* Number of application reads made
                                             since last reset */
  unsigned long long int fl_appreadresp;  /* Average read response
                                             time in microseconds*/
  unsigned long long int fl_appwrites;    /* Number of application writes
                                             made since last reset */
  unsigned long long int fl_appwriteresp; /* Average write response
                                             time in microseconds*/
  unsigned long long int fl_xcfreads;     /* Number of xcf read calls made
                                             to the owner since last reset */
  unsigned long long int fl_xcfreadresp;  /* Average xcf read call response
                                             time in microseconds*/
  unsigned long long int fl_xcfwrites;    /* Number of xcf write calls made to
                                             the server since last reset */
  unsigned long long int fl_xcfwriteresp; /* Average xcf write call response
                                             time in microseconds*/
  unsigned long long int fl_enospc;       /* Number of ENOSPC errors returned
                                             to apps since last reset */
  unsigned long long int fl_ioerrs;       /* Number of disk IO errors 
                                             since last reset*/
  unsigned long long int fl_commerrs;     /* Number of XCF communication timeouts
                                             or failures since last reset*/
  unsigned long long int fl_cancels;      /* Number of cancelled operations
                                             since last reset by asynchronus
                                             abends, cancel, forces and EOMs */
  char                   fl_ddname[8];    /* DDNAME of allocation of dataset */
  struct timeval64       fl_mounttime;    /* Mount time, seconds since epoch */
  unsigned int           fl_numdasd;      /* Number of DASD volumes listed for
                                             aggregate in FSINFO_DASD array */
  unsigned int           fl_flags;        /* 1 indicates if this system has
                                             tasks waiting on a quiesced FS.*/
} FSINFO_LOCAL;

typedef struct FSINFO_DASD_t
{
  char  fd_eye[4];
#define FSD_EYE  "FIDA"
  short fd_length;
  short fd_sversion;
#define FSD_VER_INITIAL 1
  char  fd_volser[6];
  short fd_pavios;
  unsigned long long int fd_reads;
  unsigned long long int fd_readbytes;
  unsigned long long int fd_writes;
  unsigned long long int fd_writebytes;
  unsigned long long int fd_waits;
  unsigned long long int fd_waitTime;
  unsigned long long int fd_resptime;
} FSINFO_DASD;

void check_local_error(char *buffp, FSINFO_REQUEST *fs_req, int *lerr_stat);

int main(int argc, char **argv)
{
  char*             buffp          = NULL;
  syscall_parmlist* parmp          = NULL;
  FSINFO_REQUEST*   fs_req         = NULL;
  char              owner_sys[9];

  int               buff_fill_len  = 0;
  int               fs_ownerlen    = 0;
  int               fs_locallen    = 0;
  int               unowned        = 0;
  int               fr_nonFatalRc  = 0;
  int               fr_nonFatalRsn = 0;
  int               sperr          = 0;
  int               ioerr          = 0;
  int               xcferr         = 0;
  int               lerr_stat      = 0;
  int               bpxrv, bpxrc, bpxrs;
  int               i, j, k;
  unsigned long long int most_writes = 0;
  char              busiest_volume[7];
  int               locals         = 0;

  /* aggrname for fsinfo */
  char              aggrname[ZFS_MAX_AGGRNAME+1] = "PLEX.DCEIMGQY.FS";

  /* Output structure pointers */
  FSINFO_NAME*      fs_namep      = NULL;
  FSINFO_OWNER*     fs_ownerp     = NULL;
  FSINFO_LOCAL*     fs_localp     = NULL;
  FSINFO_DASD *     fs_dasdp      = NULL;
  char*             outputp       = NULL;

  /* Allocate buffer */
  buffp = (char*) malloc(BUFFER_SIZE);
  if( buffp == NULL )
  {
    printf("Malloc Error\n");
    return 0;
  }

  /* Set the parmdata */
  parmp = (syscall_parmlist*) &buffp[0];
  parmp->opcode   = AGOP_FSINFO_PARMDATA;
  parmp->parms[0] = buff_fill_len = sizeof(syscall_parmlist);
  parmp->parms[1] = 0;
  parmp->parms[2] = 0;
  parmp->parms[3] = 0;
  parmp->parms[4] = 0;
  parmp->parms[5] = 0;
  parmp->parms[6] = 0;

  fs_req = (FSINFO_REQUEST*) &buffp[buff_fill_len];
  memset( fs_req, 0x00, sizeof(FSINFO_REQUEST) );

  /* First obtain the statistics for all file systems. We will look       */
  /* through them to find the DASD volume with the most write operations. */
  memcpy( fs_req->fr_eye, FR_EYE, sizeof(fs_req->fr_eye) );
  fs_req->fr_length        = sizeof(FSINFO_REQUEST);
  fs_req->fr_sversion      = 1;
  fs_req->fr_version       = 1;
  fs_req->fr_reqtype       = FR_REQTYPE_NAMECURSOR;
  fs_req->fr_output        = FR_OUT_FULL_STAT;
  fs_req->fr_nameSelection = FR_NM_ALLAGGR;

  buff_fill_len += sizeof(FSINFO_REQUEST);

  /* Loop getting file system information from zFS until we have it all. */
  do
  {
      /* Call zFS. */
      printf("call zfs\n");
      BPX1PCT("ZFS     ",
              ZFSCALL_FSINFO,             /* Aggregate operation */
              BUFFER_SIZE,                /* Length of Argument */
              (char*) buffp,              /* Pointer to Argument */
              &bpxrv,                     /* Pointer to Return_value */
              &bpxrc,                     /* Pointer to Return_code */
              &bpxrs);                    /* Pointer to Reason_code */

      if( bpxrv )
      {
        printf("Error getting fsinfo for aggregate %s\n", aggrname);
        printf("Return Value: %d Return Code: %d Reason Code: %x\n",
               bpxrv, bpxrc, bpxrs);
        goto done;
      }
      if( fs_req->fr_nonFatalRc )
      {
        fr_nonFatalRc  = fs_req->fr_nonFatalRc;
        fr_nonFatalRsn = fs_req->fr_nonFatalRsn;
        goto print_non_fatals;
      }

      /* The first structure pointed by output buffer is FSINFO_NAME.*/
      fs_namep = (FSINFO_NAME *) &buffp[buff_fill_len];
      for (i=0; i<fs_req->fr_entries; i++)
      {
        fs_ownerp = (FSINFO_OWNER *)((char *)fs_namep+fs_namep->fn_slength);
        locals = fs_namep->fn_connected;

        /* If file system has an owner, there will be one more */
        /* FSINFO_LOCAL structure returned than this count.    */
        if (memcmp(fs_namep->fn_owner, "*UNOWNED") != 0)
          locals++;

        /* Determine if there is an FSINFO_OWNER or not.         */
        /* If not, then the structure should be an FSINFO_LOCAL. */
        if (memcmp(fs_ownerp->fo_eye, FSO_EYE, 4) == 0)
        { /* FSINFO_OWNER returned */
          fs_localp = (FSINFO_LOCAL *)((char *)fs_ownerp+fs_ownerp->fo_length);
        }
        else if (memcmp(fs_ownerp->fo_eye, FL_EYE, 4) == 0)
        {
          /* No FSINFO_OWNER returned. It's FSINFO_LOCAL */
          fs_localp = (FSINFO_LOCAL *)fs_ownerp;
          fs_ownerp = NULL;
        }
        else
        {
          /* Should not get here!! */
          printf("Error exit: Incorrect structure sequence!!\n");
          goto done;
        }

        /* Loop through each FSINFO_LOCAL structure returned. */
        for (j=0; j<locals; j++)
        {
          fs_dasdp = (FSINFO_DASD *)((char *)fs_localp + fs_localp->fl_length);
          for (k=0; k<fs_localp->fl_numdasd; k++)
          {
            /* Determine if this DASD volume has more writes than the  */
            /* previously higher one.  Yes, remember DASD volume name. */
            if (fs_dasdp->fd_writes > most_writes)
            {
              strncpy(busiest_volume, fs_dasdp->fd_volser, 6);
              busiest_volume[6] = 0;
              most_writes = fs_dasdp->fd_writes;
            }
            /* Set up for next iteration. */
            fs_dasdp = (FSINFO_DASD *)((char *)fs_dasdp + fs_dasdp->fd_length);
          }
          /* After looping through all FSINFO_DASD structures, fs_dasdp */
          /* should be pointing at the next FSINFO_LOCAL structure.     */
          fs_localp = (FSINFO_LOCAL *)fs_dasdp;
        }

        /* Get ready for next loop iteration. */
        fs_namep = (FSINFO_NAME *)((char *)fs_namep+fs_namep->fn_length);
      }
  }
  while (!fs_req->fr_eol);

  printf("DASD volume %s has the most writes (%llu)\n",
         busiest_volume, most_writes);

  /* Now do a single aggregate query for a specific file system. */
  memset( fs_req, 0x00, sizeof(FSINFO_REQUEST));
  memcpy( fs_req->fr_eye, FR_EYE, sizeof(fs_req->fr_eye) );
  fs_req->fr_length        = sizeof(FSINFO_REQUEST);
  fs_req->fr_sversion      = 1;
  fs_req->fr_version       = 1;
  fs_req->fr_output        = FR_OUT_FULL_STAT;
  fs_req->fr_reqtype       = FR_REQTYPE_SINGLEQUERY;
  memcpy( fs_req->fr_resumeName, aggrname, ZFS_MAX_AGGRNAME+1 );

  BPX1PCT("ZFS     ",
          ZFSCALL_FSINFO,             /* Aggregate operation */
          BUFFER_SIZE,                /* Length of Argument */
          (char*) buffp,              /* Pointer to Argument */
          &bpxrv,                     /* Pointer to Return_value */
          &bpxrc,                     /* Pointer to Return_code */
          &bpxrs);                    /* Pointer to Reason_code */

  if( bpxrv )
  {
    printf("Error getting fsinfo for aggregate %s\n", aggrname);
    printf("Return Value: %d Return Code: %d Reason Code: %x\n",
           bpxrv, bpxrc, bpxrs);
    goto done;
  }
  if( fs_req->fr_nonFatalRc )
  {
    fr_nonFatalRc  = fs_req->fr_nonFatalRc;
    fr_nonFatalRsn = fs_req->fr_nonFatalRsn;
    goto print_non_fatals;
  }

  buff_fill_len = sizeof(syscall_parmlist) + sizeof(FSINFO_REQUEST);
  outputp = buffp + buff_fill_len;
  check_local_error(outputp, fs_req, &lerr_stat);

  /* The first structure pointed by output buffer would be FSINFO_NAME. */
  fs_namep = (FSINFO_NAME *) &buffp[buff_fill_len];
  fs_ownerp = (FSINFO_OWNER *) ((char*) fs_namep + fs_namep->fn_slength);
  memcpy(owner_sys, fs_namep->fn_owner, 8);
  owner_sys[8] = '\0';

  if (memcmp(&owner_sys[0], "*UNOWNED", 8) == 0)
  {
     unowned = 1;
     if (memcmp(fs_ownerp->fo_eye, FSO_EYE, 4) == 0)
     {  /* FSINFO_OWNER returned */
        fs_localp = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);
     }
     else if (memcmp(fs_ownerp->fo_eye, FL_EYE, 4) == 0)
     {
        /* No FSINFO_OWNER returned. It's FSINFO_LOCAL */
        fs_localp = (FSINFO_LOCAL *)fs_ownerp;
        fs_ownerp = NULL;
     }
  } 
  else if (fs_ownerp->fo_flags & FO_NO_OWNER)
  {
     unowned = 1;
     fs_localp = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);
  }
  else
     fs_localp = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);

  if ((lerr_stat & FSINFO_SPC_ERR) == FSINFO_SPC_ERR)
  {
    fs_localp->fl_enospc = 1;
    sperr = 1;
  }
  if ((lerr_stat & FSINFO_IO_ERR) == FSINFO_IO_ERR)
  {
    fs_localp->fl_ioerrs = 1;
    ioerr = 1;
  }
  if ((lerr_stat & FSINFO_XCF_ERR) == FSINFO_XCF_ERR)
  {
    fs_localp->fl_commerrs = 1;
    xcferr = 1;
  }

  if( unowned && !fs_ownerp )
  {
    if (!xcferr && !ioerr && !sperr)
      printf("%-44.44s %-8.8s n/a \n\n",
             aggrname, "*UNOWNED");
    else
    {
      printf("%-44.44s %-8.8s %s%s%s \n\n",
             aggrname, "*UNOWNED",
             (sperr)? "SE" :"",
             (ioerr)?((sperr)?",IE":"IE"):"",
             (xcferr)?((sperr || ioerr)?",CE":"CE"):"");
      /* Define the flags in a legend */
      printf("Legend: %s%s%s\n\n",
             (sperr)? "SE = Space errors reported":"",
             (ioerr)?
               ((sperr)? ",IE = IO errors reported":
                         "IE = IO errors reported") : "",
             (xcferr)?
               ((sperr || ioerr)?
                         ",CE = Communication errors reported":
                         "CE = Communication errors reported") : "");
    }
  }
  else
  {
    /* Print the aggregate info with flags */
    printf("%-44.44s %-8.8s %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s \n\n",
           aggrname, fs_namep->fn_owner,
           (fs_ownerp->fo_flags & FO_NOTMOUNT)         ? "NM" : "",
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) &&
            (fs_ownerp->fo_flags & FO_OWNER_MNTRW))    ? "RW" :
           ((fs_ownerp->fo_flags & FO_NOTMOUNT)        ? ""   : "RO"),
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) && 
            (fs_ownerp->fo_flags & FO_OWNER_RWSHARE))  ? ",RS" :
           ((fs_ownerp->fo_flags & FO_NOTMOUNT)        ? ""    : ",NS"),

           (fs_ownerp->fo_thrashing)                   ? ",TH" : "",
           (fs_ownerp->fo_qsysname[0] != '\0')         ? ",Q"  : "",
           (fs_ownerp->fo_flags & FO_OWNER_DISABLED)   ? ",DI" : "",
           (fs_ownerp->fo_flags & FO_OWNER_GROWING)    ? ",GR" : "",
           (fs_ownerp->fo_flags & FO_OWNER_GROWFAIL)   ? ",GF" : "",
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) &&
            !(fs_ownerp->fo_flags & FO_OWNER_ALLOWGROW)) ? ",GD" : "",

           (fs_ownerp->fo_flags & FO_OWNER_DAMAGED)    ? ",DA" : "",
           (fs_ownerp->fo_flags & FO_OWNER_LOW_ONSPC)  ? ",L"  : "",
           (sperr)                                     ? ",SE" : "",
           (fs_ownerp->fo_flags & FO_OWNER_DISABLED)   ? ",DI" : "",
           (ioerr)                                     ? ",IE" : "",
           (xcferr)                                    ? ",CE" : "");


    /* Define the flags in a legend */
    printf("Legend: %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s \n\n",
           (fs_ownerp->fo_flags & FO_NOTMOUNT)    ? "NM = Not mounted" : "",
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) && 
            (fs_ownerp->fo_flags & FO_OWNER_MNTRW)) ? "RW = Read-write"  :
           ((fs_ownerp->fo_flags & FO_NOTMOUNT)     ? "" : "RO = Read-only"),
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) &&
            (fs_ownerp->fo_flags & FO_OWNER_RWSHARE)) ?
            ",RS = Mounted RWSHARE" : ((fs_ownerp->fo_flags & FO_NOTMOUNT) ?
            "" : ",NS = Mounted NORWSHARE"),
           (fs_ownerp->fo_thrashing)               ? ",TH = Thrashing"  : "",
           (fs_ownerp->fo_qsysname[0] != '\0')     ? ",Q = Queisced"    : "",
           (fs_ownerp->fo_flags & FO_OWNER_DISABLED) ?
            ",DI = Disabled"   : "",
           (fs_ownerp->fo_flags & FO_OWNER_GROWING)  ?
            ",GR = Growing"    : "",
           (fs_ownerp->fo_flags & FO_OWNER_GROWFAIL) ?
            ",GF = Grow Failed": "",
           /* Multiple Conditions */
           (!(fs_ownerp->fo_flags & FO_NOTMOUNT) &&
            !(fs_ownerp->fo_flags & FO_OWNER_ALLOWGROW)) ?
              ",GD = AGGRGROW disabled" : "",
           (fs_ownerp->fo_flags & FO_OWNER_DAMAGED)  ?
            ",DA = Damaged"    : "",
           (fs_ownerp->fo_flags & FO_OWNER_LOW_ONSPC)  ?
            ",L = Low on space": "",
           (sperr)   ? ",SE = Space errors reported":"",
           (fs_ownerp->fo_flags & FO_OWNER_DISABLED)   ?
            ",DI = Disabled"   : "",
           (ioerr)   ? ",IE = IO errors reported"  : "",
           (xcferr)  ? ",CE = Communication errors reported":"");
  }
  goto done;

print_non_fatals:
  if( fr_nonFatalRc )
  {
    printf("Non-Fatal errors:\n");
    printf("Return Code: %d Reason Code: %x\n\n",
           fr_nonFatalRc, fr_nonFatalRsn);
  }
done:
  free(buffp);
  return 0;
}

void check_local_error(char *buffptr, FSINFO_REQUEST *fs_req, int *lerr_stat)
{
  FSINFO_NAME * fs_namep;
  FSINFO_OWNER * fs_ownerp = NULL;
  FSINFO_LOCAL * fs_local;
  FSINFO_DASD  * dasdp;
  int dasd_space;
  int i, j;
  int total_sys = 0;
  int unowned = 0;  

  if ((*lerr_stat) == (FSINFO_XCF_ERR | FSINFO_IO_ERR | FSINFO_SPC_ERR))
  {
    printf("FSINFO_CheckLocalErr: all 3 bits are set in *lerr_stat=%X\n",
           *lerr_stat);
    return ;
  }

  /* The first structure pointed by output buffer would be FSINFO_NAME. */
  fs_namep = (FSINFO_NAME *)((char *)buffptr);
  fs_ownerp = (FSINFO_OWNER *)((char *)fs_namep + fs_namep->fn_slength);

  /* if UNOWNED, make sure we are processing the right stats. */
  if (memcmp(&fs_namep->fn_owner, "*UNOWNED", 8) == 0)
  {
    unowned = 1;
    if (memcmp(fs_ownerp->fo_eye, FSO_EYE, 4) == 0)
    { /* FSINFO_OWNER block */
      fs_local = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);
    }
    else if (memcmp(fs_ownerp->fo_eye, FL_EYE, 4) == 0)
    { /* FSINFO_LOCAL block */
      fs_local = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);
      fs_ownerp = NULL;
    }
    else
    {  /* We should not get here!! */
      return;
    }
  } 
  else
    fs_local = (FSINFO_LOCAL *)((char *)fs_ownerp + fs_ownerp->fo_length);

  /* If FSINFO_OWNER is not returned, we have 1 less FSINFO_LOCAL to process */
  if (unowned && (fs_ownerp == NULL))
    total_sys = fs_namep->fn_connected;
  else
    total_sys = fs_namep->fn_connected+1;

  for (i=0; i < total_sys; i++)
  {
    if (fs_local->fl_commerrs)
      (*lerr_stat) |= FSINFO_XCF_ERR;

    if (fs_local->fl_enospc)
      (*lerr_stat) |= FSINFO_SPC_ERR;

    if (fs_local->fl_ioerrs)
      (*lerr_stat) |= FSINFO_IO_ERR;

    if ((*lerr_stat) == (FSINFO_XCF_ERR | FSINFO_IO_ERR | FSINFO_SPC_ERR))
      return ;

    /* Find the next FSINFO_LOCAL structure, which is after any FSINFO_DASD */
    /* structures that might be present.                                    */
    if (fs_local->fl_numdasd > 0)
    {
        dasdp = (FSINFO_DASD *)((char *)fs_local + fs_local->fl_length);
        dasd_space = fs_local->fl_numdasd * dasdp->fd_length;
    }
    else
        dasd_space = 0;
    fs_local = (FSINFO_LOCAL *)((char *)fs_local + fs_local->fl_length +
                                dasd_space);
  }

  return;
}