unwritten_sync: convert XFS_IOC_FREESP64 to ftruncate
[xfstests-dev.git] / src / unwritten_sync.c
1 #include <stdlib.h>
2 #include <string.h>
3 #include <sys/types.h>
4 #include <fcntl.h>
5 #include <errno.h>
6 #include <malloc.h>
7 #include <unistd.h>
8 #include <xfs/xfs.h>
9
10 /* test thanks to judith@sgi.com */
11
12 #define IO_SIZE 1048576
13
14 void
15 print_getbmapx(
16         const char      *pathname,
17         int             fd,
18         int64_t         start,
19         int64_t         limit);
20
21 int
22 main(int argc, char *argv[])
23 {
24         int i;
25         int fd;
26         char *buf;
27         struct dioattr dio;
28         xfs_flock64_t flock;
29         off_t offset;
30         char    *file;
31         int     loops;
32         char    *dio_env;
33
34         if(argc != 3) {
35                 fprintf(stderr, "%s <loops> <file>\n", argv[0]);
36                 exit(1);
37         }
38
39         errno = 0;
40         loops = strtoull(argv[1], NULL, 0);
41         if (errno) {
42                 perror("strtoull");
43                 exit(errno);
44         }
45         file = argv[2];
46
47         while (loops-- > 0) {
48                 sleep(1);
49                 fd = open(file, O_RDWR|O_CREAT|O_DIRECT, 0666);
50                 if (fd < 0) {
51                         perror("open");
52                         exit(1);
53                 }
54                 if (xfsctl(file, fd, XFS_IOC_DIOINFO, &dio) < 0) {
55                         perror("dioinfo");
56                         exit(1);
57                 }
58
59                 dio_env = getenv("XFS_DIO_MIN");
60                 if (dio_env)
61                         dio.d_mem = dio.d_miniosz = atoi(dio_env);
62
63                 if ((dio.d_miniosz > IO_SIZE) || (dio.d_maxiosz < IO_SIZE)) {
64                         fprintf(stderr, "Test won't work - iosize out of range"
65                                 " (dio.d_miniosz=%d, dio.d_maxiosz=%d)\n",
66                                 dio.d_miniosz, dio.d_maxiosz);
67
68                         exit(1);
69                 }
70                 buf = (char *)memalign(dio.d_mem , IO_SIZE);
71                 if (buf == NULL) {
72                         fprintf(stderr,"Can't get memory\n");
73                         exit(1);
74                 }
75                 memset(buf,'Z',IO_SIZE);
76                 offset = 0;
77
78                 flock.l_whence = 0;
79                 flock.l_start= 0;
80                 flock.l_len = IO_SIZE*21;
81                 if (xfsctl(file, fd, XFS_IOC_RESVSP64, &flock) < 0) {
82                         perror("xfsctl ");
83                         exit(1);
84                 }
85                 for (i = 0; i < 21; i++) {
86                         if (pwrite(fd, buf, IO_SIZE, offset) != IO_SIZE) {
87                                 perror("pwrite");
88                                 exit(1);
89                         }
90                         offset += IO_SIZE;
91                 }
92
93                 print_getbmapx(file, fd, 0, 0);
94
95                 if (ftruncate(fd, 0)) {
96                         perror("ftruncate");
97                         exit(1);
98                 }
99
100                 print_getbmapx(file, fd, 0, 0);
101                 close(fd);
102         }
103         exit(0);
104 }
105
106 void
107 print_getbmapx(
108 const   char    *pathname,
109         int     fd,
110         int64_t start,
111         int64_t limit)
112 {
113         struct getbmapx bmapx[50];
114         int array_size = sizeof(bmapx) / sizeof(bmapx[0]);
115         int x;
116         int foundone = 0;
117         int foundany = 0;
118
119 again:
120         foundone = 0;
121         memset(bmapx, '\0', sizeof(bmapx));
122
123         bmapx[0].bmv_offset = start;
124         bmapx[0].bmv_length = -1; /* limit - start; */
125         bmapx[0].bmv_count = array_size;
126         bmapx[0].bmv_entries = 0;       /* no entries filled in yet */
127
128         bmapx[0].bmv_iflags = BMV_IF_PREALLOC;
129
130         x = array_size;
131         for (;;) {
132                 if (x > bmapx[0].bmv_entries) {
133                         if (x != array_size) {
134                                 break;  /* end of file */
135                         }
136                         if (xfsctl(pathname, fd, XFS_IOC_GETBMAPX, bmapx) < 0) {
137                                 fprintf(stderr, "XFS_IOC_GETBMAPX failed\n");
138                                 exit(1);
139                         }
140                         if (bmapx[0].bmv_entries == 0) {
141                                 break;
142                         }
143                         x = 1;  /* back at first extent in buffer */
144                 }
145                 if (bmapx[x].bmv_oflags & 1) {
146                         fprintf(stderr, "FOUND ONE %lld %lld %x\n",
147                                 (long long) bmapx[x].bmv_offset,
148                                 (long long) bmapx[x].bmv_length,
149                                 bmapx[x].bmv_oflags);
150                         foundone = 1;
151                         foundany = 1;
152                 }
153                 x++;
154         }
155         if (foundone) {
156                 sleep(1);
157                 fprintf(stderr,"Repeat\n");
158                 goto again;
159         }
160         if (foundany) {
161                 exit(1);
162         }
163 }
164