test/test72.c

   1 /* Test 72 - libminixfs unit test.
   2  *
   3  * Exercise the caching functionality of libminixfs in isolation.
   4  */
   5
   6 #include <minix/libminixfs.h>
   7 #include <minix/sysutil.h>
   8 #include <minix/syslib.h>
   9 #include <minix/vm.h>
  10 #include <minix/bdev.h>
  11 #include <sys/types.h>
  12 #include <sys/mman.h>
  13 #include <sys/ioc_memory.h>
  14 #include <stdio.h>
  15 #include <stdarg.h>
  16 #include <assert.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <math.h>
  22
  23 int max_error = 0;
  24
  25 #include "common.h"
  26 #include "testcache.h"
  27
  28 #define MYMAJOR 40      /* doesn't really matter, shouldn't be NO_DEV though */
  29
  30 #define MYDEV   makedev(MYMAJOR, 1)
  31
  32 static int curblocksize = -1;
  33
  34 static char *writtenblocks[MAXBLOCKS];
  35
  36 /* Some functions used by testcache.c */
  37
  38 int
  39 dowriteblock(int b, int blocksize, u32_t seed, char *data)
  40 {
  41         struct buf *bp;
  42
  43         assert(blocksize == curblocksize);
  44
  45         if(!(bp = lmfs_get_block(MYDEV, b, NORMAL))) {
  46                 e(30);
  47                 return 0;
  48         }
  49
  50         memcpy(bp->data, data, blocksize);
  51
  52         lmfs_markdirty(bp);
  53
  54         lmfs_put_block(bp, FULL_DATA_BLOCK);
  55
  56         return blocksize;
  57 }
  58
  59 int
  60 readblock(int b, int blocksize, u32_t seed, char *data)
  61 {
  62         struct buf *bp;
  63
  64         assert(blocksize == curblocksize);
  65
  66         if(!(bp = lmfs_get_block(MYDEV, b, NORMAL))) {
  67                 e(30);
  68                 return 0;
  69         }
  70
  71         memcpy(data, bp->data, blocksize);
  72
  73         lmfs_put_block(bp, FULL_DATA_BLOCK);
  74
  75         return blocksize;
  76 }
  77
  78 void testend(void)
  79 {
  80         int i;
  81         for(i = 0; i < MAXBLOCKS; i++) {
  82                 if(writtenblocks[i]) {
  83                         free(writtenblocks[i]);
  84                         writtenblocks[i] = NULL;
  85                 }
  86         }
  87 }
  88
  89 /* Fake some libminixfs client functions */
  90
  91 int
  92 fs_sync(void)
  93 {
  94         return 0;
  95 }
  96
  97 void
  98 fs_blockstats(u32_t *total, u32_t *free, u32_t *used)
  99 {
 100         *total = *free = *used = 0;
 101 }
 102
 103 static void allocate(int b)
 104 {
 105         assert(curblocksize > 0);
 106         assert(!writtenblocks[b]);
 107         if(!(writtenblocks[b] = calloc(1, curblocksize))) {
 108                 fprintf(stderr, "out of memory allocating block %d\n", b);
 109                 exit(1);
 110         }
 111 }
 112
 113 /* Fake some libblockdriver functions */
 114 ssize_t
 115 bdev_gather(dev_t dev, u64_t pos, iovec_t *vec, int count, int flags)
 116 {
 117         int i, block;
 118         ssize_t tot = 0;
 119         assert(dev == MYDEV);
 120         assert(curblocksize > 0);
 121         assert(!(pos % curblocksize));
 122         block = pos / curblocksize;
 123         for(i = 0; i < count; i++) {
 124                 int subblocks;
 125                 char *data = (char *) vec[i].iov_addr;
 126                 assert(vec[i].iov_size > 0);
 127                 assert(!(vec[i].iov_size % curblocksize));
 128                 subblocks = vec[i].iov_size / curblocksize;
 129                 while(subblocks > 0) {
 130                         assert(block > 0);
 131                         assert(block < MAXBLOCKS);
 132                         if(!writtenblocks[block]) {
 133                                 allocate(block);
 134                         }
 135                         memcpy(data, writtenblocks[block], curblocksize);
 136                         block++;
 137                         subblocks--;
 138                         data += curblocksize;
 139                         tot += curblocksize;
 140                 }
 141         }
 142
 143         return tot;
 144 }
 145
 146 ssize_t
 147 bdev_scatter(dev_t dev, u64_t pos, iovec_t *vec, int count, int flags)
 148 {
 149         int i, block;
 150         ssize_t tot = 0;
 151         assert(dev == MYDEV);
 152         assert(curblocksize > 0);
 153         assert(!(pos % curblocksize));
 154         block = pos / curblocksize;
 155         for(i = 0; i < count; i++) {
 156                 int subblocks;
 157                 char *data = (char *) vec[i].iov_addr;
 158                 assert(vec[i].iov_size > 0);
 159                 assert(!(vec[i].iov_size % curblocksize));
 160                 subblocks = vec[i].iov_size / curblocksize;
 161                 while(subblocks > 0) {
 162                         assert(block >= 0);
 163                         assert(block < MAXBLOCKS);
 164                         if(!writtenblocks[block]) {
 165                                 allocate(block);
 166                         }
 167                         memcpy(writtenblocks[block], data, curblocksize);
 168                         block++;
 169                         subblocks--;
 170                         data += curblocksize;
 171                         tot += curblocksize;
 172                 }
 173         }
 174
 175         return tot;
 176 }
 177
 178 ssize_t
 179 bdev_read(dev_t dev, u64_t pos, char *data, size_t count, int flags)
 180 {
 181         int block;
 182         ssize_t tot = 0;
 183         int subblocks;
 184
 185         assert(dev == MYDEV);
 186         assert(curblocksize > 0);
 187         assert(!(pos % curblocksize));
 188         assert(count > 0);
 189         assert(!(count % curblocksize));
 190
 191         block = pos / curblocksize;
 192         subblocks = count / curblocksize;
 193         while(subblocks > 0) {
 194                 assert(block >= 0);
 195                 assert(block < MAXBLOCKS);
 196                 if(!writtenblocks[block]) {
 197                         allocate(block);
 198                 }
 199                 memcpy(data, writtenblocks[block], curblocksize);
 200                 block++;
 201                 subblocks--;
 202                 data += curblocksize;
 203                 tot += curblocksize;
 204         }
 205
 206         return tot;
 207 }
 208
 209 /* Fake some libsys functions */
 210
 211 __dead void
 212 panic(const char *fmt, ...)
 213 {
 214         va_list va;
 215         va_start(va, fmt);
 216         vfprintf(stderr, fmt, va);
 217         va_end(va);
 218
 219         exit(1);
 220 }
 221
 222 int vm_forgetblock(u64_t id)
 223 {
 224         return ENOSYS;
 225 }
 226
 227 int vm_yield_block_get_block(u64_t yieldid, u64_t getid, void *mem,
 228         vir_bytes len)
 229 {
 230         return ENOSYS;
 231 }
 232
 233 void vm_forgetblocks(void)
 234 {
 235         return;
 236 }
 237
 238 int
 239 vm_info_stats(struct vm_stats_info *vsi)
 240 {
 241         return ENOSYS;
 242 }
 243
 244 void
 245 util_stacktrace(void)
 246 {
 247         fprintf(stderr, "fake stacktrace\n");
 248 }
 249
 250 void *alloc_contig(size_t len, int flags, phys_bytes *phys)
 251 {
 252         return malloc(len);
 253 }
 254
 255 int free_contig(void *addr, size_t len)
 256 {
 257         free(addr);
 258         return 0;
 259 }
 260
 261 u32_t sqrt_approx(u32_t v)
 262 {
 263         return (u32_t) sqrt(v);
 264 }
 265
 266 int
 267 main(int argc, char *argv[])
 268 {
 269         int wss, cs, n = 0, p;
 270
 271 #define ITER 3
 272 #define BLOCKS 200
 273
 274         start(72);
 275
 276         lmfs_setquiet(1);
 277
 278         /* Can the cache handle differently sized blocks? */
 279
 280         for(p = 1; p <= 3; p++) {
 281                 curblocksize = PAGE_SIZE*p;
 282                 lmfs_set_blocksize(curblocksize, MYMAJOR);
 283                 lmfs_buf_pool(BLOCKS);
 284                 if(dotest(curblocksize, BLOCKS, ITER)) e(n);
 285                 n++;
 286         }
 287
 288         /* Can the cache handle various combinations of the working set
 289          * being larger and smaller than the cache?
 290          */
 291         for(wss = 2; wss <= 3; wss++) {
 292                 int wsblocks = 10*wss*wss*wss*wss*wss;
 293                 for(cs = wsblocks/4; cs <= wsblocks*3; cs *= 1.5) {
 294                         curblocksize = PAGE_SIZE;
 295                         lmfs_set_blocksize(curblocksize, MYMAJOR);
 296                         lmfs_buf_pool(cs);
 297                         if(dotest(curblocksize, wsblocks, ITER)) e(n);
 298                         n++;
 299                 }
 300         }
 301
 302         quit();
 303
 304         return 0;
 305 }
 306