/*====================================================================*/
/* This software is delivered "as-is", with no warranties             */
/* expressed or implied.  This software is not supported by IBM.      */
/*====================================================================*/
/* (C) COPYRIGHT International Business Machines Corp. 2001           */
/* All Rights Reserved                                                */
/*                                                                    */
/* US Government Users Restricted Rights - Use, duplication or        */
/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.  */
/*====================================================================*/

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/devinfo.h>
#include <sys/signal.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <ctype.h>
#include <sys/shm.h>

#define INFO 7
#define MAXBUF 4096   /* Maximum number of buffers allowed */
#define PAGESIZE 4096 /* Number of bytes in a page of virtual memory */

long *shr_memp[MAXBUF];     /* array of pointers to shared memory buffers */
int shmid[MAXBUF];          /* Array of shared memory ids */
int shmget_key[MAXBUF];     /* Array of shared memory keys */

struct rule_format {
 long  seg_size;        /* segment size in bytes                          */
 int   num_seg;         /* number of segments (default 1 segment)         */
 int   width;           /* 1, 4, or 8 bytes at a time                     */
} r;

 int pattern_des;
 int mode_flg;
 int result;
 long mem_size;
 char pattern_nm[50];

 extern char *sys_errlist[];
 extern int_sysnerr;

void getshrseg(long *reqsize,long *aa,long *lpage)
{
 /* r.seg_size = 128*1024*1024; */
 r.seg_size = *reqsize; 
 r.num_seg=1;
 r.width = 8;
 allocate_buffers(lpage);
 *aa = (long) shr_memp[0];
}

/************************************************************************
* allocate buffers                                                      *
************************************************************************/
allocate_buffers(long *lpage)
{
int i,key,memflg;
key=40000;

for (i=0; i<r.num_seg; i++)
{
 r.seg_size = r.seg_size * r.width;
  
 errno = 0;

 if (*lpage == (long) 1) {
 /* printf("Requesting Large Pages\n"); */
 memflg = (IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH | SHM_PIN | SHM_LGPAGE);
 } else {
 /* printf("Requesting Small Pages\n"); */
 memflg = (IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH );
 }


 shmget_key[i]= key+i;
 /* shmid[i] = shmget (key+i,r.seg_size, memflg); */
 shmid[i] = shmget (IPC_PRIVATE,r.seg_size, memflg);
 if (shmid[i] == -1)
  {
  printf("Error (%d) getting shared memory - shmget_key[%d] = 0x%x, (%ld bytes)"
  ,errno,i,shmget_key[i],r.seg_size);
  release_shm_segs();
  exit(1); 
  } /* endif */
 /*
 * The SHMAT system call attaches the shared memory segment associated
 * with the shared memory identifier mem_id (from the SHMGET system
 * call).
 */
 errno = 0;
 shr_memp[i] = (void *) shmat(shmid[i], (char *) 0, 0);
 /* printf("pointer to segment %u is %u\n",i,shr_memp[i]); */
 if (shr_memp[i] == (void *) 0)
   {
    printf("Error (%d) attaching shared memory - shmid[%d] = %d\n",
      errno,i, shmid[i]);
    /* hxfmsg (&stats, 0, 1, stats.msg_text); */
    release_shm_segs();
    exit(1);
   }

} /* endfor */

return(0);
} /* end allocate_buffers */

/*
 * Function Name: release_shm_segs()
 *
 * Description: It detaches and removes all shared memory segments
 *
 */
int release_shm_segs()
{
 int i, rc;
  for (i=0; i<r.num_seg; i++)
    {
     if (shr_memp[i] != 0)
       {
        errno = 0;
        rc = shmdt(shr_memp[i]);
        if (rc != 0)
         {
          printf("release_shm_segs: errno (%d) "
             "detaching shared memory segment %d rc=%d\n"
             "key = 0x%x, id = %d, shr_memp = 0x%x\n",
             errno, i,rc,shmget_key[i],shmid[i],shr_memp[i]);
          /* hxfmsg (&stats, 0, 1, stats.msg_text); */
         }
        errno = 0;
        rc = shmctl(shmid[i], IPC_RMID, (struct shmid_ds *) NULL);
        if (rc != 0)
           {
             printf("release_shm_segs: errno (%d) "
                "removing shared memory segment %d rc=%d\n"
                "key = 0x%x, id = %d, shr_memp = 0x%x\n",
                errno, i,rc,shmget_key[i],shmid[i],shr_memp[i]);
              /* hxfmsg (&stats, 0, 1, stats.msg_text); */
           }
        shr_memp[i] = (void *) NULL;
       } /* endif */
    } /* end for */
} /* end of release_shm_segs */


/***********************************************************************
* SIGTERM signal handler                                               *
************************************************************************/
fill_dword(double * buffer,double * pattern,int length)
{
  int i;
  for (i=0; i<length; i++)
   {
    buffer[i] = 2.0; 
   }
  
   
  printf("pattern is %d\n",pattern);
}
fill_word(int * buffer,int  *pattern,int length)
{
  printf("pattern is %d\n",* pattern);
}
fill_byte(char * buffer,char * pattern,int length)
{
  printf("pattern is %d\n",*pattern);
}
comp_dword(char * buffer,char * pattern,int length)
{
  printf("pattern is %d\n",* pattern);
}