| /* Copyright (C) 2021-2024 Free Software Foundation, Inc. |
| Contributed by Oracle. |
| |
| This file is part of GNU Binutils. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <strings.h> |
| #include <errno.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <sys/mman.h> |
| #include <sys/time.h> |
| |
| #include "stopwatch.h" |
| |
| /* parameters defining various tasks */ |
| #define BUFSIZE 16384 |
| #define NBLKS 1024 |
| |
| #define SIZE ((int)(16*1024*1024)) |
| unsigned buffer[SIZE]; |
| extern FILE *fid2; |
| |
| /* ioerror - do some erroneous file IO operations */ |
| int |
| ioerror () |
| { |
| FILE *fp; /* FILE pointer for stdio */ |
| char *fname = NULL; |
| char *ptr = NULL; |
| int fd; /* file descriptor for raw IO */ |
| int fd2; /* file descriptor for raw IO */ |
| int stat; |
| char buf[BUFSIZE]; |
| unsigned long size = 0; |
| char sfn[23] = ""; |
| |
| /* Log the regular read */ |
| wlog ("start of ioerror", NULL); |
| |
| /* fname is set to NULL. |
| Use various calls to create |
| a file. |
| */ |
| |
| fd = creat (fname, 0666); |
| fd = open (fname, 0666); |
| fd2 = 0; |
| fd = openat (fd2, fname, 0666); |
| fp = fopen (fname, "w"); |
| fp = fopen ("/iotest", "w"); |
| fp = NULL; |
| stat = fflush (fp); |
| stat = chmod (fname, 755); |
| stat = access (fname, 755); |
| fname = "/tmp/synprogXXXXXX"; |
| strncpy (sfn, fname, sizeof (sfn)); |
| fd = mkstemp (sfn); |
| stat = unlink (sfn); |
| stat = rename (fname, NULL); |
| unlink (fname); |
| fp = fopen (fname, "w"); |
| stat = fclose (fp); |
| stat = fread (buf, 100, 2, fp); |
| stat = fwrite (buf, 100, 2, fp); |
| ptr = fgets (buf, size, fp); |
| read (10000, buf, 100); |
| write (10000, buf, 100); |
| stat = unlink (fname); |
| fname = NULL; |
| stat = mkdir (fname, 755); |
| stat = unlink (fname); |
| /* |
| These functions cannot be executed |
| if the File Pointer (fp) is set |
| to NULL. They generate segv failure |
| in actual call not inside of |
| the wrapper. |
| |
| stat = fread(buf, size, 2, fp); |
| stat = fwrite(buf, size, 2, fp); |
| ptr = fgets(buf, size, fp); |
| stat = fputs(buf, fp); |
| stat = fprintf(fp, "%d\n", size); |
| stat = fseek(fp, size, size); |
| rewind(fp); |
| ftell(fp); |
| fpos_t pos; |
| stat = fsetpos(fp, &pos); |
| stat = fgetpos(fp, &pos); |
| */ |
| return 0; |
| } |
| |
| /*=======================================================*/ |
| |
| /* iofile - do some file io operations */ |
| int |
| iofile () |
| { |
| FILE *fp; /* FILE pointer for stdio */ |
| int k; /* temp value for loop */ |
| int i; |
| char *buf; |
| hrtime_t start; |
| hrtime_t vstart; |
| char sfn[23] = ""; |
| char *fname = "/tmp/synprogXXXXXX"; |
| int ret; |
| int readCnt = 0; |
| int bRead = 0; |
| int writeCnt = 0; |
| int bWritten = 0; |
| int otherIOCnt = 0; |
| int bytes = 0; |
| |
| start = gethrtime (); |
| vstart = gethrvtime (); |
| |
| /* Log the event */ |
| bytes = wlog ("start of iofile -- stdio", NULL); |
| bWritten += bytes; |
| writeCnt++; |
| |
| strncpy (sfn, fname, sizeof (sfn)); |
| ret = mkstemp (sfn); |
| otherIOCnt++; |
| if (ret == -1) |
| { |
| fprintf (stderr, "Unable to make a temporary name\n"); |
| exit (1); |
| } |
| bytes = fprintf (stderr, "\tUsing %s as scratch file\n", sfn); |
| bWritten += bytes; |
| writeCnt++; |
| |
| /* allocate a buffer for the reading */ |
| /* note that this buffer is leaked! */ |
| buf = (char *) malloc (BUFSIZE); |
| |
| /* open the file */ |
| fp = fdopen (ret, "w"); |
| otherIOCnt++; |
| if (fp == NULL) |
| { |
| fprintf (stderr, "++ERROR opening %s, error %d\n", sfn, errno); |
| exit (1); |
| } |
| |
| /* loop, writing the buffer to the file... */ |
| for (i = 0; i < NBLKS; i++) |
| { |
| k = fwrite (buf, sizeof (char), BUFSIZE, fp); |
| writeCnt++; |
| if (k != BUFSIZE) |
| { |
| fprintf (stderr, "++ERROR writing %s, error %d\n", sfn, errno); |
| exit (1); |
| } |
| bWritten += k; |
| } |
| |
| fclose (fp); |
| fp = NULL; |
| otherIOCnt++; |
| |
| sprintf (buf, "fwrite: %d blocks of %d", i, BUFSIZE); |
| bytes = whrvlog (gethrtime () - start, gethrvtime () - vstart, buf, NULL); |
| bWritten += bytes; |
| writeCnt++; |
| |
| |
| /* now reopen the file, and read it */ |
| start = gethrtime (); |
| vstart = gethrvtime (); |
| |
| fp = fopen (sfn, "r"); |
| otherIOCnt++; |
| if (fp == NULL) |
| { |
| fprintf (stderr, "++ERROR opening %s, error %d\n", sfn, errno); |
| exit (1); |
| } |
| i = 0; |
| for (;;) |
| { |
| k = fread (buf, sizeof (char), BUFSIZE, fp); |
| readCnt++; |
| if (k < 0) |
| fprintf (stderr, "++ERROR reading %s, error %d\n", sfn, errno); |
| |
| |
| if (k == 0) |
| { |
| /* close the file */ |
| fclose (fp); |
| fp = NULL; |
| otherIOCnt++; |
| break; |
| |
| } |
| else if (k != BUFSIZE) |
| { |
| /* short read */ |
| sprintf (buf, "\tunexpecter short read %d on %s\n", k, sfn); |
| fprintf (stderr, buf); |
| bRead += k; |
| break; |
| } |
| else |
| { |
| /* bump the block counter */ |
| i++; |
| bRead += k; |
| } |
| } |
| |
| if (fp != NULL) |
| { |
| fclose (fp); |
| fp = NULL; |
| } |
| sprintf (buf, "fread: %d blocks of %d", i, BUFSIZE); |
| bytes = whrvlog (gethrtime () - start, gethrvtime () - vstart, buf, NULL); |
| bWritten += bytes; |
| writeCnt++; |
| |
| bWritten += 99; /* the number of bytes are written by the next fprintf */ |
| writeCnt++; |
| |
| unlink (sfn); |
| otherIOCnt++; |
| fprintf (fid2, "X %14d %14d %17d %15d %17d iofile\n", |
| bRead, readCnt, bWritten, writeCnt, otherIOCnt); |
| return 0; |
| } |
| |
| /* iotest - do various io syscalls */ |
| int |
| iotest () |
| { |
| char *fname = "/tmp/foobar"; |
| int fd; /* file descriptor for raw IO */ |
| int fd2; /* file descriptor for raw IO */ |
| int k; /* temp value for loop */ |
| char buf[BUFSIZE]; |
| unsigned long size = 0; |
| int readCnt = 0; |
| int bRead = 0; |
| int writeCnt = 0; |
| int bWritten = 0; |
| int otherIOCnt = 0; |
| int bytes = 0; |
| |
| /* Log the regular read */ |
| bytes = wlog ("start of iotest", NULL); |
| bWritten += bytes; |
| writeCnt++; |
| |
| /* create an empty file */ |
| fd = creat (fname, 0666); |
| otherIOCnt++; |
| |
| /* dup the file descriptor */ |
| fd2 = dup (fd); |
| otherIOCnt++; |
| close (fd2); |
| otherIOCnt++; |
| close (fd); |
| otherIOCnt++; |
| |
| /* now open the empty file */ |
| fd = open (fname, O_RDONLY); |
| otherIOCnt++; |
| |
| /* loop, reading into the buffer */ |
| size = 0; |
| for (;;) |
| { |
| k = read (fd, buf, BUFSIZE); |
| readCnt++; |
| if (k < 0) |
| fprintf (stderr, "++ERROR reading %s, error %d\n", fname, errno); |
| else |
| { |
| size = size + k; |
| bRead += k; |
| } |
| if (k != BUFSIZE) |
| { |
| /* close the file */ |
| close (fd); |
| fd = -1; |
| otherIOCnt++; |
| bRead += k; |
| |
| /* short eread = EOF */ |
| break; |
| } |
| } |
| if (fd != -1) |
| { |
| close (fd); |
| fd = -1; |
| } |
| bWritten += 99; /* the number of bytes are written by the next fprintf */ |
| writeCnt++; |
| |
| /* remove the file */ |
| unlink (fname); |
| otherIOCnt++; |
| fprintf (fid2, "X %14d %14d %17d %15d %17d iotest\n", |
| bRead, readCnt, bWritten, writeCnt, otherIOCnt); |
| |
| return 0; |
| } |
| |
| /* |
| * Memory mapping routines- |
| * |
| * Allocate and deallocate memory using mmap and malloc. |
| * |
| * There is one parameter--the total number of megabytes to write, |
| * written in as many 16 megabyte files as are needed |
| */ |
| |
| unsigned char *start = (unsigned char*) 0x80000000; |
| unsigned char *stop; |
| int nblocks; |
| |
| void |
| memorymap (int megabytes) |
| { |
| int readCnt = 0; |
| int bRead = 0; |
| int writeCnt = 0; |
| int bWritten = 0; |
| int otherIOCnt = 0; |
| int bytes; |
| |
| /* |
| * First, see how much time it takes to mmap all the files. |
| * |
| * Second, pull in just a few pages of information to see how much |
| * time the "How much IBM do I hold?" question would take. |
| * |
| * Next, compare updating the database shared with updating it private |
| * and then recopying the changed segments. |
| |
| * (We could catch the pages that we have altered by mapping the |
| * entire BIS read-only and then punching holes in it via an |
| * mprotect call as we catch segfaults. This gives us a list |
| * of the pages that we need to write, at the added expense of |
| * handling lots of interrupts.) |
| * (Notice that we don't test the case where we are adding to |
| * the BIS files. This is an interesting situation as we either |
| * have to open the last page past the last write point or reopen |
| * extendable in some way. We could do that by opening /dev/zero |
| * with MAP_ANON for addresses above our current usage point. |
| */ |
| |
| int i; |
| stop = start + 1024 * 1024 * (long long) megabytes; |
| |
| printf ("Creating %d random numbers\n", SIZE); |
| for (i = 0; i < SIZE; i++) |
| buffer[i] = random (); // set pseudo-bis to noise |
| printf ("Done creating random numbers\n"); |
| |
| |
| /* |
| * Write a database consisting of 16 megabyte files. |
| * Each filename contains the memory address into which |
| * the file should be reloaded. |
| */ |
| |
| printf ("Writing pseudo-bis files\n"); |
| unsigned char* base = start; |
| nblocks = 0; |
| for (i = 0; i < megabytes; i += 16) |
| { |
| nblocks++; |
| // write data in 16MB files |
| char filename[256]; |
| sprintf (filename, "bistest.%p.%d", base, i); |
| int fd = open (filename, O_CREAT | O_TRUNC | O_WRONLY, 0660); |
| otherIOCnt++; |
| if (fd == -1) |
| { |
| printf ("open of %s failed: %s\n", filename, strerror (errno)); |
| exit (0); |
| } |
| bytes = write (fd, buffer, SIZE); |
| bWritten += bytes; |
| writeCnt++; |
| close (fd); |
| otherIOCnt++; |
| printf ("\twrote %d megabytes\n", i + 16); |
| base += 16 * 1024 * 1024; |
| } |
| printf ("Done writing files from %p to %p\n", start, stop); |
| |
| int j; |
| |
| printf ("Memory map all the files (private)\n"); |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char* base = start; |
| base += i * 1024 * 1024; |
| char filename[256]; |
| sprintf (filename, "bistest.%p.%d", base, i); |
| int fd = open (filename, O_RDWR); |
| otherIOCnt++; |
| if (fd < 0) |
| printf ("open of %s failed: %s\n", filename, strerror (errno)); |
| unsigned char *mp = (unsigned char*) mmap ((char*) base, |
| SIZE, PROT_READ | PROT_WRITE, |
| MAP_PRIVATE | MAP_FIXED, fd, 0); |
| if (mp == MAP_FAILED || mp != base) |
| { |
| printf ("mmap of %s failed: %s\n", filename, strerror (errno)); |
| exit (1); |
| } |
| |
| printf ("mapped %d bytes at %p\n", SIZE, base); |
| close (fd); // mmap will hold the file open for us |
| otherIOCnt++; |
| } |
| |
| printf ("Mapping done\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| int ranlimit = 1000; |
| printf ("Access %d bytes at random\n", ranlimit); |
| int sum = 0; |
| for (i = 0; i < ranlimit; i++) |
| { |
| unsigned char *where = start + |
| (((unsigned long) random ()) % (stop - start)); |
| sum += (int) *where; |
| } |
| printf ("Random byte access done\n"); |
| |
| ranlimit = 1000; |
| int ranrange = 256; |
| printf ("Alter %d random locations, %d bytes each (private)\n", |
| ranlimit, ranrange); |
| |
| for (i = 0; i < ranlimit; i++) |
| { |
| unsigned char *where = start + |
| (((unsigned long) random ()) % (stop - start)); |
| for (j = 0; j < ranrange; j++) |
| *where++ = j; |
| } |
| |
| printf ("Memory alteration done\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| printf ("Copy all memory back to disk\n"); |
| |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char* base = start; |
| base += i * 1024 * 1024; |
| char filename[256]; |
| sprintf (filename, "bistest2.%p.%d", base, i); |
| int fd = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0660); |
| otherIOCnt++; |
| if ((bytes = write (fd, base, SIZE)) == -1) |
| { |
| printf ("write of %s failed: %s\n", filename, strerror (errno)); |
| exit (1); |
| } |
| bWritten += bytes; |
| writeCnt++; |
| close (fd); |
| otherIOCnt++; |
| } |
| |
| printf ("Disk copy complete\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| printf ("Unmap all segments\n"); |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char* base = start; |
| base += i * 1024 * 1024; |
| if (munmap ((char*) base, SIZE) == -1) |
| { |
| printf ("munmap failed: %s\n", strerror (errno)); |
| exit (1); |
| } |
| printf ("unmapped %d bytes at %p\n", SIZE, base); |
| } |
| printf ("Segment unmapping complete\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| printf ("Remap all segments as shared\n"); |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char* base = start; |
| base += i * 1024 * 1024; |
| char filename[256]; |
| sprintf (filename, "bistest.%p.%d", base, i); |
| int fd = open (filename, O_RDWR); |
| otherIOCnt++; |
| char* mp = mmap ((char*) base, SIZE, PROT_READ | PROT_WRITE, |
| MAP_SHARED | MAP_FIXED, fd, 0); |
| if (mp == MAP_FAILED || (unsigned char*) mp != base) |
| { |
| printf ("re mmap of %s failed: %s\n", filename, strerror (errno)); |
| exit (1); |
| } |
| printf ("remapped %d bytes at %p\n", SIZE, base); |
| close (fd); // mmap will hold the file open for us |
| otherIOCnt++; |
| } |
| printf ("Remapping complete\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| ranlimit = 1000; |
| ranrange = 256; |
| printf ("Alter %d random locations, %d bytes each (shared)\n", |
| ranlimit, ranrange); |
| for (i = 0; i < ranlimit; i++) |
| { |
| unsigned char* where = start + |
| (((unsigned long) random ()) % (stop - start)); |
| for (j = 0; j < ranrange; j++) |
| *where++ = j; |
| } |
| printf ("Memory alteration done\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| printf ("Unmap all segments\n"); |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char *base = start; |
| base += i * 1024 * 1024; |
| if (munmap ((char*) base, SIZE) == -1) |
| { |
| printf ("munmap failed: %s\n", strerror (errno)); |
| exit (1); |
| } |
| printf ("unmapped %d bytes at %p\n", SIZE, base); |
| } |
| printf ("Segment unmapping complete\n"); |
| fflush (stdout); |
| otherIOCnt++; |
| |
| base = start; |
| |
| for (i = 0; i < megabytes; i += 16) |
| { |
| // write data in 16MB files |
| char filename[256]; |
| sprintf (filename, "bistest.%p.%d", base, i); |
| if (unlink (filename) != 0) |
| { |
| printf ("unlink of %s failed: %s\n", filename, strerror (errno)); |
| } |
| base += 16 * 1024 * 1024; |
| otherIOCnt++; |
| } |
| |
| for (i = 0; i < megabytes; i += 16) |
| { |
| unsigned char* base = start; |
| base += i * 1024 * 1024; |
| char filename[256]; |
| sprintf (filename, "bistest2.%p.%d", base, i); |
| if (unlink (filename) != 0) |
| { |
| printf ("unlink of %s failed: %s\n", filename, strerror (errno)); |
| } |
| otherIOCnt++; |
| } |
| bWritten += 102; /* the number of bytes are written by the next fprintf */ |
| writeCnt++; |
| |
| fflush (fid2); |
| otherIOCnt++; |
| |
| /* Record accounting record */ |
| fprintf (fid2, "X %14d %14d %17d %15d %17d memorymap\n", |
| bRead, readCnt, bWritten, writeCnt, otherIOCnt); |
| printf ("Deleted scratch files\n"); |
| } |
