Unquiesce Aggregate

Purpose

An aggregate operation that unquiesces a zFS compatibility mode aggregate on a system. This subcommand call allows activity on the aggregate and its file system to resume.

Format

syscall_parmlist
   opcode           int                  133       AGOP_UNQUIESCE_PARMDATA
   parms[0]         int                  offset to AGGR_ID
   parms[1]         int                  quiesce handle
   parms[2]         int                  0
   parms[3]         int                  0
   parms[4]         int                  0
   parms[5]         int                  0
   parms[6]         int                  0
AGGR_ID
   aid_eye          char[4]              "AGID"
   aid_len          char                 sizeof(AGGR_ID)
   aid_ver          char                 1
   aid_name         char[45]             "OMVS.PRV.AGGR001.LDS0001"
   aid_reserved     char[33]             0

Return_value    0 if request is successful, -1 if it is not successful

Return_code
  EINTR         ZFS is shutting down
  EMVSERR       Internal error using an osi service
  ENOENT        Aggregate is not attached
  EPERM         Permission denied to perform request

Reason_code
  0xEFnnxxxx    See z/OS Distributed File Service Messages and Codes

Usage notes

The unquiesce call must supply the quiesce handle that was returned by the quiesce call. The aggregate is typically quiesced before backing up the aggregate. After the backup is complete, the aggregate can be unquiesced.
Reserved fields and undefined flags must be set to binary zeros.

Privilege required

The issuer must be logged in as root or must have READ authority to the SUPERUSER.FILESYS.PFSCTL resource in the z/OS® UNIXPRIV class.

Related services

Quiesce Aggregate

Restrictions

None.

Examples

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

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

#include <stdio.h>
#include <stdlib.h>

#define  ZFSCALL_AGGR 0x40000005
#define  AGOP_UNQUIESCE_PARMDATA 133

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;

#define  ZFS_MAX_AGGRNAME 44

typedef struct aggr_id_t {
  char   aid_eye[4];                    /* Eye catcher */
#define  AID_EYE "AGID"
  char   aid_len;                       /* Length of this structure */
  char   aid_ver;                       /* Version */
#define  AID_VER_INITIAL 1              /* Initial version */
  char   aid_name[ZFS_MAX_AGGRNAME+1];  /* Name, null terminated */
  char   aid_reserved[33];              /* Reserved for the future */
} AGGR_ID;

struct parmstruct {
  syscall_parmlist myparms;
  AGGR_ID          aggr_id;
};

int main(int argc, char **argv) 
{
  int               bpxrv;
  int               bpxrc;
  int               bpxrs;
  char              aggrname[45] = "PLEX.DCEIMGQX.FS";
  int               save_quiesce_handle;
  struct parmstruct myparmstruct;

  if (argc != 2)
  {
    printf("This unquiesce program requires a quiesce handle" 
           "from the quiesce program as a parameter\n");
    return 1;
  }
    
  save_quiesce_handle = atoi(argv[1]);

  myparmstruct.myparms.opcode = AGOP_UNQUIESCE_PARMDATA;
  myparmstruct.myparms.parms[0] = sizeof(syscall_parmlist);
  myparmstruct.myparms.parms[1] = save_quiesce_handle;
  myparmstruct.myparms.parms[2] = 0;
  myparmstruct.myparms.parms[3] = 0;
  myparmstruct.myparms.parms[4] = 0;
  myparmstruct.myparms.parms[5] = 0;
  myparmstruct.myparms.parms[6] = 0;

  /* Ensure reserved fields are 0 */
  memset(&myparmstruct.aggr_id, 0, sizeof(AGGR_ID));
  memcpy(&myparmstruct.aggr_id.aid_eye, AID_EYE, 4);
  myparmstruct.aggr_id.aid_len = sizeof(AGGR_ID);
  myparmstruct.aggr_id.aid_ver = AID_VER_INITIAL;
  strcpy(myparmstruct.aggr_id.aid_name, aggrname);

  BPX1PCT("ZFS     ",
          ZFSCALL_AGGR,               /* Aggregate 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 unquiescing aggregate %s\n", aggrname);
    printf("BPXRV = %d BPXRC = %d BPXRS = %x\n", bpxrv, bpxrc, bpxrs);
    return bpxrc;
  } 
  else 
  { /* Return from unquiesce was successful */
    printf("Aggregate %s unquiesced successfully\n", aggrname);
  }
  return 0;
}