1 /* $NetBSD: t_etfs.c,v 1.9 2010/11/30 18:19:47 pooka Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <sys/types.h> 31 #include <sys/mount.h> 32 #include <sys/sysctl.h> 33 34 #include <rump/rump.h> 35 #include <rump/rump_syscalls.h> 36 37 #include <atf-c.h> 38 #include <fcntl.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <unistd.h> 42 43 #include "../../h_macros.h" 44 45 ATF_TC(reregister_reg); 46 ATF_TC_HEAD(reregister_reg, tc) 47 { 48 49 atf_tc_set_md_var(tc, "descr", "Tests register/unregister/register " 50 "for a regular file"); 51 } 52 53 #define TESTSTR1 "hi, it's me again!" 54 #define TESTSTR1SZ (sizeof(TESTSTR1)-1) 55 56 #define TESTSTR2 "what about the old vulcan proverb?" 57 #define TESTSTR2SZ (sizeof(TESTSTR2)-1) 58 59 #define TESTPATH1 "/trip/to/the/moon" 60 #define TESTPATH2 "/but/not/the/dark/size" 61 ATF_TC_BODY(reregister_reg, tc) 62 { 63 char buf[1024]; 64 int localfd, etcfd; 65 ssize_t n; 66 int tfd; 67 68 etcfd = open("/etc/passwd", O_RDONLY); 69 ATF_REQUIRE(etcfd != -1); 70 71 localfd = open("./testfile", O_RDWR | O_CREAT, 0666); 72 ATF_REQUIRE(localfd != -1); 73 74 ATF_REQUIRE_EQ(write(localfd, TESTSTR1, TESTSTR1SZ), TESTSTR1SZ); 75 /* testfile now contains test string */ 76 77 rump_init(); 78 79 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "/etc/passwd", 80 RUMP_ETFS_REG), 0); 81 tfd = rump_sys_open(TESTPATH1, O_RDONLY); 82 ATF_REQUIRE(tfd != -1); 83 ATF_REQUIRE(rump_sys_read(tfd, buf, sizeof(buf)) > 0); 84 rump_sys_close(tfd); 85 rump_pub_etfs_remove(TESTPATH1); 86 87 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./testfile", 88 RUMP_ETFS_REG), 0); 89 tfd = rump_sys_open(TESTPATH2, O_RDWR); 90 ATF_REQUIRE(tfd != -1); 91 memset(buf, 0, sizeof(buf)); 92 ATF_REQUIRE((n = rump_sys_read(tfd, buf, sizeof(buf))) > 0); 93 94 /* check that we have what we expected */ 95 ATF_REQUIRE_STREQ(buf, TESTSTR1); 96 97 /* ... while here, check that writing works too */ 98 ATF_REQUIRE_EQ(rump_sys_lseek(tfd, 0, SEEK_SET), 0); 99 ATF_REQUIRE(TESTSTR1SZ <= TESTSTR2SZ); 100 ATF_REQUIRE_EQ(rump_sys_write(tfd, TESTSTR2, TESTSTR2SZ), TESTSTR2SZ); 101 102 memset(buf, 0, sizeof(buf)); 103 ATF_REQUIRE_EQ(lseek(localfd, 0, SEEK_SET), 0); 104 ATF_REQUIRE(read(localfd, buf, sizeof(buf)) > 0); 105 ATF_REQUIRE_STREQ(buf, TESTSTR2); 106 } 107 108 ATF_TC(reregister_blk); 109 ATF_TC_HEAD(reregister_blk, tc) 110 { 111 112 atf_tc_set_md_var(tc, "descr", "Tests register/unregister/register " 113 "for a block device"); 114 } 115 116 ATF_TC_BODY(reregister_blk, tc) 117 { 118 char buf[512 * 128]; 119 char cmpbuf[512 * 128]; 120 int rv, tfd; 121 122 /* first, create some image files */ 123 rv = system("dd if=/dev/zero bs=512 count=64 " 124 "| tr '\\0' '\\1' > disk1.img"); 125 ATF_REQUIRE_EQ(rv, 0); 126 127 rv = system("dd if=/dev/zero bs=512 count=128 " 128 "| tr '\\0' '\\2' > disk2.img"); 129 ATF_REQUIRE_EQ(rv, 0); 130 131 rump_init(); 132 133 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "./disk1.img", 134 RUMP_ETFS_BLK), 0); 135 tfd = rump_sys_open(TESTPATH1, O_RDONLY); 136 ATF_REQUIRE(tfd != -1); 137 ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 64*512); 138 memset(cmpbuf, 1, sizeof(cmpbuf)); 139 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 64*512), 0); 140 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); 141 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); 142 143 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./disk2.img", 144 RUMP_ETFS_BLK), 0); 145 tfd = rump_sys_open(TESTPATH2, O_RDONLY); 146 ATF_REQUIRE(tfd != -1); 147 ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 128*512); 148 memset(cmpbuf, 2, sizeof(cmpbuf)); 149 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 128*512), 0); 150 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); 151 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH2), 0); 152 } 153 154 ATF_TC_WITH_CLEANUP(large_blk); 155 ATF_TC_HEAD(large_blk, tc) 156 { 157 158 atf_tc_set_md_var(tc, "descr", "Check etfs block devices work for " 159 ">2TB images"); 160 } 161 162 #define IMG_ON_MFS "mfsdir/disk.img" 163 ATF_TC_BODY(large_blk, tc) 164 { 165 char buf[128]; 166 char cmpbuf[128]; 167 ssize_t n; 168 int rv, tfd; 169 170 /* 171 * mount mfs. it would be nice if this would not be required, 172 * but a) tmpfs doesn't "support" sparse files b) we don't really 173 * know what fs atf workdir is on anyway. 174 */ 175 if (mkdir("mfsdir", 0777) == -1) 176 atf_tc_fail_errno("mkdir failed"); 177 if (system("mount_mfs -s 64m -o nosuid,nodev mfs mfsdir") != 0) 178 atf_tc_skip("could not mount mfs"); 179 180 /* create a 8TB sparse file */ 181 rv = system("dd if=/dev/zero of=" IMG_ON_MFS " bs=1 count=1 seek=8t"); 182 ATF_REQUIRE_EQ(rv, 0); 183 184 /* 185 * map it and issue write at 6TB, then unmap+remap and check 186 * we get the same stuff back 187 */ 188 189 rump_init(); 190 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, IMG_ON_MFS, 191 RUMP_ETFS_BLK), 0); 192 tfd = rump_sys_open(TESTPATH1, O_RDWR); 193 ATF_REQUIRE(tfd != -1); 194 memset(buf, 12, sizeof(buf)); 195 n = rump_sys_pwrite(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL); 196 ATF_REQUIRE_EQ(n, sizeof(buf)); 197 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); 198 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); 199 200 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, IMG_ON_MFS, 201 RUMP_ETFS_BLK), 0); 202 tfd = rump_sys_open(TESTPATH2, O_RDWR); 203 ATF_REQUIRE(tfd != -1); 204 memset(buf, 0, sizeof(buf)); 205 n = rump_sys_pread(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL); 206 ATF_REQUIRE_EQ(n, sizeof(buf)); 207 208 memset(cmpbuf, 12, sizeof(cmpbuf)); 209 ATF_REQUIRE_EQ(memcmp(cmpbuf, buf, 128), 0); 210 } 211 212 ATF_TC_CLEANUP(large_blk, tc) 213 { 214 215 system("umount mfsdir"); 216 } 217 218 ATF_TC(range_blk); 219 ATF_TC_HEAD(range_blk, tc) 220 { 221 222 atf_tc_set_md_var(tc, "descr", "Checks ranged (offset,size) mappings"); 223 } 224 225 ATF_TC_BODY(range_blk, tc) 226 { 227 char buf[32000]; 228 char cmpbuf[32000]; 229 ssize_t n; 230 int rv, tfd; 231 232 /* create a 64000 byte file with 16 1's at offset = 32000 */ 233 rv = system("dd if=/dev/zero of=disk.img bs=1000 count=64"); 234 ATF_REQUIRE_EQ(rv, 0); 235 rv = system("yes | tr '\\ny' '\\1' " 236 "| dd of=disk.img conv=notrunc bs=1 count=16 seek=32000"); 237 ATF_REQUIRE_EQ(rv, 0); 238 239 /* map the file at [16000,48000]. this puts our 1's at offset 16000 */ 240 rump_init(); 241 ATF_REQUIRE_EQ(rump_pub_etfs_register_withsize(TESTPATH1, "disk.img", 242 RUMP_ETFS_BLK, 16000, 32000), 0); 243 tfd = rump_sys_open(TESTPATH1, O_RDWR); 244 ATF_REQUIRE(tfd != -1); 245 n = rump_sys_read(tfd, buf, sizeof(buf)); 246 ATF_REQUIRE_EQ(n, sizeof(buf)); 247 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); 248 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); 249 250 /* check that we got what is expected */ 251 memset(cmpbuf, 0, sizeof(cmpbuf)); 252 memset(cmpbuf+16000, 1, 16); 253 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, sizeof(buf)), 0); 254 } 255 256 ATF_TC(key); 257 ATF_TC_HEAD(key, tc) 258 { 259 260 atf_tc_set_md_var(tc, "descr", "Checks key format"); 261 } 262 263 ATF_TC_BODY(key, tc) 264 { 265 266 RZ(rump_init()); 267 268 RL(open("hostfile", O_RDWR | O_CREAT, 0777)); 269 270 RZ(rump_pub_etfs_register("/key", "hostfile", RUMP_ETFS_REG)); 271 ATF_REQUIRE_EQ(rump_pub_etfs_register("key", "hostfile", RUMP_ETFS_REG), 272 EINVAL); 273 274 RL(rump_sys_open("/key", O_RDONLY)); 275 RL(rump_sys_open("////////key", O_RDONLY)); 276 277 RZ(rump_pub_etfs_register("////key//with/slashes", "hostfile", 278 RUMP_ETFS_REG)); 279 280 RL(rump_sys_open("/key//with/slashes", O_RDONLY)); 281 RL(rump_sys_open("key//with/slashes", O_RDONLY)); 282 ATF_REQUIRE_ERRNO(ENOENT, 283 rump_sys_open("/key/with/slashes", O_RDONLY) == -1); 284 285 RL(rump_sys_mkdir("/a", 0777)); 286 ATF_REQUIRE_ERRNO(ENOENT, 287 rump_sys_open("/a/key//with/slashes", O_RDONLY) == -1); 288 } 289 290 ATF_TP_ADD_TCS(tp) 291 { 292 293 ATF_TP_ADD_TC(tp, reregister_reg); 294 ATF_TP_ADD_TC(tp, reregister_blk); 295 ATF_TP_ADD_TC(tp, large_blk); 296 ATF_TP_ADD_TC(tp, range_blk); 297 ATF_TP_ADD_TC(tp, key); 298 299 return atf_no_error(); 300 } 301