test_io.c revision a002e7e200308eb010f55f19b673a53775a7cccd
1/* 2 * test_io.c --- This is the Test I/O interface. 3 * 4 * Copyright (C) 1996 Theodore Ts'o. 5 * 6 * %Begin-Header% 7 * This file may be redistributed under the terms of the GNU Public 8 * License. 9 * %End-Header% 10 */ 11 12#include <stdio.h> 13#include <string.h> 14#if HAVE_UNISTD_H 15#include <unistd.h> 16#endif 17#include <fcntl.h> 18#include <time.h> 19#if HAVE_SYS_STAT_H 20#include <sys/stat.h> 21#endif 22#if HAVE_SYS_TYPES_H 23#include <sys/types.h> 24#endif 25 26#include "ext2_fs.h" 27#include "ext2fs.h" 28 29/* 30 * For checking structure magic numbers... 31 */ 32 33#define EXT2_CHECK_MAGIC(struct, code) \ 34 if ((struct)->magic != (code)) return (code) 35 36struct test_private_data { 37 int magic; 38 io_channel real; 39 int flags; 40 FILE *outfile; 41 unsigned long block; 42 int read_abort_count, write_abort_count; 43 void (*read_blk)(unsigned long block, int count, errcode_t err); 44 void (*write_blk)(unsigned long block, int count, errcode_t err); 45 void (*set_blksize)(int blksize, errcode_t err); 46 void (*write_byte)(unsigned long block, int count, errcode_t err); 47}; 48 49static errcode_t test_open(const char *name, int flags, io_channel *channel); 50static errcode_t test_close(io_channel channel); 51static errcode_t test_set_blksize(io_channel channel, int blksize); 52static errcode_t test_read_blk(io_channel channel, unsigned long block, 53 int count, void *data); 54static errcode_t test_write_blk(io_channel channel, unsigned long block, 55 int count, const void *data); 56static errcode_t test_flush(io_channel channel); 57static errcode_t test_write_byte(io_channel channel, unsigned long offset, 58 int count, const void *buf); 59 60static struct struct_io_manager struct_test_manager = { 61 EXT2_ET_MAGIC_IO_MANAGER, 62 "Test I/O Manager", 63 test_open, 64 test_close, 65 test_set_blksize, 66 test_read_blk, 67 test_write_blk, 68 test_flush, 69 test_write_byte 70 71}; 72 73io_manager test_io_manager = &struct_test_manager; 74 75/* 76 * These global variable can be set by the test program as 77 * necessary *before* calling test_open 78 */ 79io_manager test_io_backing_manager = 0; 80void (*test_io_cb_read_blk) 81 (unsigned long block, int count, errcode_t err) = 0; 82void (*test_io_cb_write_blk) 83 (unsigned long block, int count, errcode_t err) = 0; 84void (*test_io_cb_set_blksize) 85 (int blksize, errcode_t err) = 0; 86void (*test_io_cb_write_byte) 87 (unsigned long block, int count, errcode_t err) = 0; 88 89/* 90 * Test flags 91 */ 92#define TEST_FLAG_READ 0x01 93#define TEST_FLAG_WRITE 0x02 94#define TEST_FLAG_SET_BLKSIZE 0x04 95#define TEST_FLAG_FLUSH 0x08 96#define TEST_FLAG_DUMP 0x10 97 98static void test_dump_block(io_channel channel, 99 struct test_private_data *data, 100 unsigned long block, const void *buf) 101{ 102 const unsigned char *cp; 103 FILE *f = data->outfile; 104 int i; 105 unsigned long cksum = 0; 106 107 for (i=0, cp = buf; i < channel->block_size; i++, cp++) { 108 cksum += *cp; 109 } 110 fprintf(f, "Contents of block %lu, checksum %08lu: \n", block, cksum); 111 for (i=0, cp = buf; i < channel->block_size; i++, cp++) { 112 if ((i % 16) == 0) 113 fprintf(f, "%04x: ", i); 114 fprintf(f, "%02x%c", *cp, ((i % 16) == 15) ? '\n' : ' '); 115 } 116} 117 118static void test_abort(io_channel channel, unsigned long block) 119{ 120 struct test_private_data *data; 121 FILE *f; 122 123 data = (struct test_private_data *) channel->private_data; 124 f = data->outfile; 125 test_flush(channel); 126 127 fprintf(f, "Aborting due to I/O to block %lu\n", block); 128 fflush(f); 129 abort(); 130} 131 132static errcode_t test_open(const char *name, int flags, io_channel *channel) 133{ 134 io_channel io = NULL; 135 struct test_private_data *data = NULL; 136 errcode_t retval; 137 char *value; 138 139 if (name == 0) 140 return EXT2_ET_BAD_DEVICE_NAME; 141 retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); 142 if (retval) 143 return retval; 144 memset(io, 0, sizeof(struct struct_io_channel)); 145 io->magic = EXT2_ET_MAGIC_IO_CHANNEL; 146 retval = ext2fs_get_mem(sizeof(struct test_private_data), &data); 147 if (retval) { 148 retval = EXT2_ET_NO_MEMORY; 149 goto cleanup; 150 } 151 io->manager = test_io_manager; 152 retval = ext2fs_get_mem(strlen(name)+1, &io->name); 153 if (retval) 154 goto cleanup; 155 156 strcpy(io->name, name); 157 io->private_data = data; 158 io->block_size = 1024; 159 io->read_error = 0; 160 io->write_error = 0; 161 io->refcount = 1; 162 163 memset(data, 0, sizeof(struct test_private_data)); 164 data->magic = EXT2_ET_MAGIC_TEST_IO_CHANNEL; 165 if (test_io_backing_manager) { 166 retval = test_io_backing_manager->open(name, flags, 167 &data->real); 168 if (retval) 169 goto cleanup; 170 } else 171 data->real = 0; 172 data->read_blk = test_io_cb_read_blk; 173 data->write_blk = test_io_cb_write_blk; 174 data->set_blksize = test_io_cb_set_blksize; 175 data->write_byte = test_io_cb_write_byte; 176 177 data->outfile = NULL; 178 if ((value = getenv("TEST_IO_LOGFILE")) != NULL) 179 data->outfile = fopen(value, "w"); 180 if (!data->outfile) 181 data->outfile = stderr; 182 183 data->flags = 0; 184 if ((value = getenv("TEST_IO_FLAGS")) != NULL) 185 data->flags = strtoul(value, NULL, 0); 186 187 data->block = 0; 188 if ((value = getenv("TEST_IO_BLOCK")) != NULL) 189 data->block = strtoul(value, NULL, 0); 190 191 data->read_abort_count = 0; 192 if ((value = getenv("TEST_IO_READ_ABORT")) != NULL) 193 data->read_abort_count = strtoul(value, NULL, 0); 194 195 data->write_abort_count = 0; 196 if ((value = getenv("TEST_IO_WRITE_ABORT")) != NULL) 197 data->write_abort_count = strtoul(value, NULL, 0); 198 199 *channel = io; 200 return 0; 201 202cleanup: 203 if (io) 204 ext2fs_free_mem(&io); 205 if (data) 206 ext2fs_free_mem(&data); 207 return retval; 208} 209 210static errcode_t test_close(io_channel channel) 211{ 212 struct test_private_data *data; 213 errcode_t retval = 0; 214 215 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 216 data = (struct test_private_data *) channel->private_data; 217 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 218 219 if (--channel->refcount > 0) 220 return 0; 221 222 if (data->real) 223 retval = io_channel_close(data->real); 224 225 if (data->outfile && data->outfile != stderr) 226 fclose(data->outfile); 227 228 ext2fs_free_mem(&channel->private_data); 229 if (channel->name) 230 ext2fs_free_mem(&channel->name); 231 ext2fs_free_mem(&channel); 232 return retval; 233} 234 235static errcode_t test_set_blksize(io_channel channel, int blksize) 236{ 237 struct test_private_data *data; 238 errcode_t retval = 0; 239 240 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 241 data = (struct test_private_data *) channel->private_data; 242 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 243 244 if (data->real) 245 retval = io_channel_set_blksize(data->real, blksize); 246 if (data->set_blksize) 247 data->set_blksize(blksize, retval); 248 if (data->flags & TEST_FLAG_SET_BLKSIZE) 249 fprintf(data->outfile, 250 "Test_io: set_blksize(%d) returned %s\n", 251 blksize, retval ? error_message(retval) : "OK"); 252 channel->block_size = blksize; 253 return retval; 254} 255 256 257static errcode_t test_read_blk(io_channel channel, unsigned long block, 258 int count, void *buf) 259{ 260 struct test_private_data *data; 261 errcode_t retval = 0; 262 263 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 264 data = (struct test_private_data *) channel->private_data; 265 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 266 267 if (data->real) 268 retval = io_channel_read_blk(data->real, block, count, buf); 269 if (data->read_blk) 270 data->read_blk(block, count, retval); 271 if (data->flags & TEST_FLAG_READ) 272 fprintf(data->outfile, 273 "Test_io: read_blk(%lu, %d) returned %s\n", 274 block, count, retval ? error_message(retval) : "OK"); 275 if (data->block && data->block == block) { 276 if (data->flags & TEST_FLAG_DUMP) 277 test_dump_block(channel, data, block, buf); 278 if (--data->read_abort_count == 0) 279 test_abort(channel, block); 280 } 281 return retval; 282} 283 284static errcode_t test_write_blk(io_channel channel, unsigned long block, 285 int count, const void *buf) 286{ 287 struct test_private_data *data; 288 errcode_t retval = 0; 289 290 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 291 data = (struct test_private_data *) channel->private_data; 292 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 293 294 if (data->real) 295 retval = io_channel_write_blk(data->real, block, count, buf); 296 if (data->write_blk) 297 data->write_blk(block, count, retval); 298 if (data->flags & TEST_FLAG_WRITE) 299 fprintf(data->outfile, 300 "Test_io: write_blk(%lu, %d) returned %s\n", 301 block, count, retval ? error_message(retval) : "OK"); 302 if (data->block && data->block == block) { 303 if (data->flags & TEST_FLAG_DUMP) 304 test_dump_block(channel, data, block, buf); 305 if (--data->write_abort_count == 0) 306 test_abort(channel, block); 307 } 308 return retval; 309} 310 311static errcode_t test_write_byte(io_channel channel, unsigned long offset, 312 int count, const void *buf) 313{ 314 struct test_private_data *data; 315 errcode_t retval = 0; 316 317 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 318 data = (struct test_private_data *) channel->private_data; 319 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 320 321 if (data->real && data->real->manager->write_byte) 322 retval = io_channel_write_byte(data->real, offset, count, buf); 323 if (data->write_byte) 324 data->write_byte(offset, count, retval); 325 if (data->flags & TEST_FLAG_WRITE) 326 fprintf(data->outfile, 327 "Test_io: write_byte(%lu, %d) returned %s\n", 328 offset, count, retval ? error_message(retval) : "OK"); 329 return retval; 330} 331 332/* 333 * Flush data buffers to disk. 334 */ 335static errcode_t test_flush(io_channel channel) 336{ 337 struct test_private_data *data; 338 errcode_t retval = 0; 339 340 EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); 341 data = (struct test_private_data *) channel->private_data; 342 EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); 343 344 if (data->real) 345 retval = io_channel_flush(data->real); 346 347 if (data->flags & TEST_FLAG_FLUSH) 348 fprintf(data->outfile, "Test_io: flush() returned %s\n", 349 retval ? error_message(retval) : "OK"); 350 351 return retval; 352} 353 354