fix compiler warnings
[xfstests-dev.git] / dmapi / src / suite2 / src / mmap.c
1 /*
2  * Copyright (c) 2000-2001 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 /*
19  *      This routine simulates
20  *      
21  *      cp      file1 file2
22  *
23  *
24  *      It is a demo program which does the copy by memory mapping each of the
25  *      files and then doing a byte at a time memory copy.
26  *
27  */
28 #ifdef linux
29 #ifndef _GNU_SOURCE
30 #define _GNU_SOURCE
31 #endif
32 #endif
33
34 #include <unistd.h>
35 #include <stddef.h>
36 #include <stdio.h>
37 #include <sys/types.h>
38 #include <sys/mman.h>
39 #include <sys/fcntl.h>
40 #include <sys/stat.h>
41 #include <string.h>
42 #include <errno.h>
43 #include <getopt.h>
44 #include <stdlib.h>
45
46
47 char * Progname;
48 off_t   len;                    /* length of file 1 */
49 off_t   offset = 0;
50 int     print_flags_set = 1;
51
52 typedef struct  fflag {
53         int     arg;            /* != 0 if ars specified */
54         int     value;          /* flags value */
55 } fflag_t;
56
57
58 typedef enum ftype {    /* flag bit types */
59         FL_MAP, FL_PROT, FL_OPEN, FL_MAX
60 } ftype_t;
61
62 typedef struct  mfile   {
63         fflag_t flags[FL_MAX];
64         char    *path;
65         int     fd;
66         struct  stat    st;
67 #ifdef linux
68         void *p;
69 #else
70         addr_t  p;
71 #endif
72 } mfile_t;
73
74
75 #define FLAG(symbol,type) { # symbol , symbol, type }
76 #define MAP_NONE        0
77
78 static  struct  {
79         char    *name;
80         int     value;
81         ftype_t type;
82 } Flags[] = {
83         FLAG(O_RDONLY, FL_OPEN),
84         FLAG(O_WRONLY, FL_OPEN),
85         FLAG(O_RDWR, FL_OPEN),
86         FLAG(O_NDELAY, FL_OPEN),
87         FLAG(O_NONBLOCK, FL_OPEN),
88         FLAG(O_APPEND, FL_OPEN),
89         FLAG(O_SYNC, FL_OPEN),
90         FLAG(O_TRUNC, FL_OPEN),
91         FLAG(O_CREAT, FL_OPEN),
92         FLAG(O_DIRECT, FL_OPEN),
93         FLAG(PROT_NONE, FL_PROT),
94         FLAG(PROT_READ, FL_PROT),
95         FLAG(PROT_WRITE, FL_PROT),
96         FLAG(PROT_EXEC, FL_PROT),
97 #ifdef __sgi
98         FLAG(PROT_EXECUTE, FL_PROT),
99 #endif
100         FLAG(MAP_SHARED, FL_MAP),
101         FLAG(MAP_PRIVATE, FL_MAP),
102         FLAG(MAP_FIXED, FL_MAP),
103 #ifdef __sgi
104         FLAG(MAP_RENAME, FL_MAP),
105         FLAG(MAP_AUTOGROW, FL_MAP),
106         FLAG(MAP_LOCAL, FL_MAP),
107         FLAG(MAP_AUTORESRV, FL_MAP),
108 #endif
109         FLAG(MAP_NONE, FL_MAP),
110 };
111
112 int     num_Flags = sizeof(Flags)/sizeof(Flags[0]);
113
114
115 mfile_t *ifile, *ofile;
116 mfile_t *hfile; /* Hack job */
117 static int      hack = 0;
118         
119 static  mfile_t *new_mfile(void);
120 static int mfile_opt(char * s, mfile_t * f);
121 static  void print_flags(char *s, mfile_t *f);
122 static void Usage(void);
123
124 main(int argc, char * argv[])
125 {
126         int     opt;
127
128         if ((Progname = strrchr(argv[0], '/')) == NULL)
129                 Progname = argv[0];
130         else
131                 Progname++;
132
133         ifile = new_mfile();
134         ofile = new_mfile();
135         hfile = new_mfile();
136         if (ifile == NULL || ofile == NULL || hfile == NULL) {
137                 fprintf(stderr,"%s: malloc failure.\n", Progname);
138                 exit (1);
139         }
140
141         /* Set default flags */
142         ifile->flags[FL_MAP].value = MAP_PRIVATE;
143         ifile->flags[FL_PROT].value = PROT_READ;
144         ifile->flags[FL_OPEN].value = O_RDONLY;
145         ofile->flags[FL_MAP].value = MAP_SHARED;
146 #ifdef __sgi
147         ofile->flags[FL_MAP].value = MAP_AUTOGROW;
148 #endif
149         ofile->flags[FL_PROT].value = PROT_WRITE;
150         ofile->flags[FL_OPEN].value = O_RDWR|O_CREAT;
151
152         while ((opt = getopt(argc, argv, "i:o:h:d")) != EOF) {
153                 switch(opt) {
154                 case 'i':
155                         if (mfile_opt(optarg, ifile) != 0) {
156                                 fprintf(stderr, "%s: Invalid -i option %s\n",
157                                         Progname, optarg);
158                                 Usage();
159                         }
160                         break;
161
162                 case 'o':
163                         if (mfile_opt(optarg, ofile) != 0) {
164                                 fprintf(stderr, "%s: Invalid -o option %s\n",
165                                         Progname, optarg);
166                                 Usage();
167                         }
168                         break;
169
170                 case 'h':
171                         if (mfile_opt(optarg, hfile) != 0) {
172                                 fprintf(stderr, "%s: Invalid -h option %s\n",
173                                         Progname, optarg);
174                                 Usage();
175                         }
176                         hack = 1;
177                         break;
178
179                 case 'd':
180                         print_flags_set ^= 1;
181                         break;
182                 case '?':
183                         Usage();
184                 }
185         }
186
187         if (optind+1 > argc)
188                 Usage();
189
190         ifile->path = argv[optind++];
191         ofile->path = argv[optind++];
192
193         if (optind != argc)     /* Extra args on command line */
194                 Usage();
195
196         if (stat(ifile->path, &(ifile->st)) < 0) {
197                 fprintf(stderr,"%s: stat of %s failed.\n",
198                                                 Progname, ifile->path);
199                 perror(ifile->path);
200                 exit(2);
201         }
202
203         len = ifile->st.st_size;
204
205         ifile->fd = open(ifile->path, ifile->flags[FL_OPEN].value);
206         if (ifile->fd < 0) {
207                 fprintf(stderr,"%s: cannot open %s\n", Progname, ifile->path);
208                 perror(ifile->path);
209                 exit(2);
210         }
211
212
213         ofile->fd = open(ofile->path, ofile->flags[FL_OPEN].value, 0644);
214         if (ofile->fd < 0) {
215                 fprintf(stderr,"%s: cannot open %s\n", Progname, ofile->path);
216                 perror(ofile->path);
217                 exit(3);
218         }
219
220         if (print_flags_set) {
221                 print_flags("Input ", ifile);
222                 print_flags("Output", ofile);
223                 if (hack)
224                         print_flags("Hack  ", hfile);
225         }
226
227
228         ifile->p = mmap(NULL, len, ifile->flags[FL_PROT].value,
229                                 ifile->flags[FL_MAP].value, ifile->fd, 0);
230         if (ifile->p == MAP_FAILED) {
231                 fprintf(stderr,"%s: cannot mmap %s\n", Progname, ifile->path);
232                 perror(ifile->path);
233                 exit(2);
234         }
235
236         ofile->p = mmap(NULL, len, ofile->flags[FL_PROT].value,
237                                 ofile->flags[FL_MAP].value , ofile->fd, 0);
238                 if (ofile->p == MAP_FAILED) {
239                 fprintf(stderr,"%s: cannot mmap %s\n", Progname, ofile->path);
240                 perror(ofile->path);
241                 exit(3);
242         }
243
244         if (hack) {
245                 int     error;
246
247                 error = mprotect(ofile->p, len, hfile->flags[FL_PROT].value);
248                 if (error) {
249                         fprintf(stderr,"%s: mprotect call failed.\n", Progname);
250                         perror("mprotect");
251                         exit(3);
252                 }
253         }
254         
255         bcopy(ifile->p, ofile->p, len);
256
257         printf("%s complete.\n", Progname);
258         return 0;
259 }
260
261 static mfile_t *
262 new_mfile(void)
263 {
264         mfile_t *ptr = (mfile_t *)malloc(sizeof(*ptr));
265         if (ptr)
266                 bzero(ptr, sizeof *ptr);
267
268         return  ptr;
269 }
270
271
272 static  int
273 mfile_opt(char * s, mfile_t *f)
274 {
275         int     i;
276         ftype_t type;
277
278         for (i = 0; i < num_Flags; i++) {
279                 if(!strcasecmp(Flags[i].name, s)) {
280
281                         /* Zero value if this is 1st arg of this type */
282
283                         type = Flags[i].type;
284                         if (f->flags[type].arg++ == 0) 
285                                 f->flags[type].value = 0;
286                         f->flags[type].value |= Flags[i].value;
287                         return 0;
288                 }
289         }
290         return -1;      /* error - string not found */
291 }
292
293 static void
294 Usage(void)
295 {
296         int     i;
297
298         fprintf(stderr, 
299                 "Usage: %s [-d] [-i flag] [-i flag] [-o flag] ... file1 file2\n",
300                 Progname);
301         fprintf(stderr, "Valid flag values are:\n");
302
303         for (i = 0; i < num_Flags; i++) {
304                 fprintf(stderr,"%15s",Flags[i].name);
305                 if ((i+1)%4 == 0 || i == num_Flags-1)
306                         fprintf(stderr,"\n");
307                 else
308                         fprintf(stderr,",");
309         }
310         exit(1);
311 }
312
313 static  void
314 print_flags(char *s, mfile_t *f)
315 {
316         int             i;
317         ftype_t         type;
318
319         printf("DEBUG - %s flags:\n", s);
320         for (i = 0; i < num_Flags; i++) {
321                 type = Flags[i].type;
322                 if (type == FL_OPEN && Flags[i].value == O_RDONLY && 
323                         ((f->flags[type].value) & 3) == 0) 
324                                 /* Hack to print out O_RDONLY */
325                                 printf("\t%s\n", Flags[i].name);
326                 else if ((Flags[i].value & (f->flags[type].value)) != 0)
327                         printf("\t%s\n", Flags[i].name);
328         }
329 }