1 /* $NetBSD: t_etfs.c,v 1.12 2023/08/03 03:21:56 rin 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);
ATF_TC_HEAD(reregister_reg,tc)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"
ATF_TC_BODY(reregister_reg,tc)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 close(etcfd);
107 close(localfd);
108 }
109
110 ATF_TC(reregister_blk);
ATF_TC_HEAD(reregister_blk,tc)111 ATF_TC_HEAD(reregister_blk, tc)
112 {
113
114 atf_tc_set_md_var(tc, "descr", "Tests register/unregister/register "
115 "for a block device");
116 }
117
ATF_TC_BODY(reregister_blk,tc)118 ATF_TC_BODY(reregister_blk, tc)
119 {
120 char buf[512 * 128];
121 char cmpbuf[512 * 128];
122 int rv, tfd;
123
124 /* first, create some image files */
125 rv = system("dd if=/dev/zero bs=512 count=64 "
126 "| tr '\\0' '\\1' > disk1.img");
127 ATF_REQUIRE_EQ(rv, 0);
128
129 rv = system("dd if=/dev/zero bs=512 count=128 "
130 "| tr '\\0' '\\2' > disk2.img");
131 ATF_REQUIRE_EQ(rv, 0);
132
133 rump_init();
134
135 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "./disk1.img",
136 RUMP_ETFS_BLK), 0);
137 tfd = rump_sys_open(TESTPATH1, O_RDONLY);
138 ATF_REQUIRE(tfd != -1);
139 ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 64*512);
140 memset(cmpbuf, 1, sizeof(cmpbuf));
141 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 64*512), 0);
142 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
143 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0);
144
145 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./disk2.img",
146 RUMP_ETFS_BLK), 0);
147 tfd = rump_sys_open(TESTPATH2, O_RDONLY);
148 ATF_REQUIRE(tfd != -1);
149 ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 128*512);
150 memset(cmpbuf, 2, sizeof(cmpbuf));
151 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 128*512), 0);
152 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
153 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH2), 0);
154 }
155
156 ATF_TC_WITH_CLEANUP(large_blk);
ATF_TC_HEAD(large_blk,tc)157 ATF_TC_HEAD(large_blk, tc)
158 {
159
160 atf_tc_set_md_var(tc, "descr", "Check etfs block devices work for "
161 ">2TB images");
162 }
163
164 #define IMG_ON_MFS "mfsdir/disk.img"
ATF_TC_BODY(large_blk,tc)165 ATF_TC_BODY(large_blk, tc)
166 {
167 char buf[128];
168 char cmpbuf[128];
169 ssize_t n;
170 int rv, tfd;
171
172 if (sysconf(_SC_PAGESIZE) > 8192) {
173 atf_tc_skip(
174 "PR kern/55658: cause kernel freeze for page size > 8192");
175 }
176
177 /*
178 * mount mfs. it would be nice if this would not be required,
179 * but a) tmpfs doesn't "support" sparse files b) we don't really
180 * know what fs atf workdir is on anyway.
181 */
182 if (mkdir("mfsdir", 0777) == -1)
183 atf_tc_fail_errno("mkdir failed");
184 if (system("mount_mfs -s 64m -o nosuid,nodev mfs mfsdir") != 0)
185 atf_tc_skip("could not mount mfs");
186
187 /* create a 8TB sparse file */
188 rv = system("dd if=/dev/zero of=" IMG_ON_MFS " bs=1 count=1 seek=8t");
189 ATF_REQUIRE_EQ(rv, 0);
190
191 /*
192 * map it and issue write at 6TB, then unmap+remap and check
193 * we get the same stuff back
194 */
195
196 rump_init();
197 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, IMG_ON_MFS,
198 RUMP_ETFS_BLK), 0);
199 tfd = rump_sys_open(TESTPATH1, O_RDWR);
200 ATF_REQUIRE(tfd != -1);
201 memset(buf, 12, sizeof(buf));
202 n = rump_sys_pwrite(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL);
203 ATF_REQUIRE_EQ(n, sizeof(buf));
204 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
205 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0);
206
207 ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, IMG_ON_MFS,
208 RUMP_ETFS_BLK), 0);
209 tfd = rump_sys_open(TESTPATH2, O_RDWR);
210 ATF_REQUIRE(tfd != -1);
211 memset(buf, 0, sizeof(buf));
212 n = rump_sys_pread(tfd, buf, sizeof(buf), 6*1024*1024*1024ULL*1024ULL);
213 ATF_REQUIRE_EQ(n, sizeof(buf));
214
215 memset(cmpbuf, 12, sizeof(cmpbuf));
216 ATF_REQUIRE_EQ(memcmp(cmpbuf, buf, 128), 0);
217 }
218
ATF_TC_CLEANUP(large_blk,tc)219 ATF_TC_CLEANUP(large_blk, tc)
220 {
221
222 system("umount mfsdir");
223 }
224
225 ATF_TC(range_blk);
ATF_TC_HEAD(range_blk,tc)226 ATF_TC_HEAD(range_blk, tc)
227 {
228
229 atf_tc_set_md_var(tc, "descr", "Checks ranged (offset,size) mappings");
230 }
231
ATF_TC_BODY(range_blk,tc)232 ATF_TC_BODY(range_blk, tc)
233 {
234 char buf[32000];
235 char cmpbuf[32000];
236 ssize_t n;
237 int rv, tfd;
238
239 /* create a 64000 byte file with 16 1's at offset = 32000 */
240 rv = system("dd if=/dev/zero of=disk.img bs=1000 count=64");
241 ATF_REQUIRE_EQ(rv, 0);
242 rv = system("yes | tr '\\ny' '\\1' "
243 "| dd of=disk.img conv=notrunc bs=1 count=16 seek=32000");
244 ATF_REQUIRE_EQ(rv, 0);
245
246 /* map the file at [16000,48000]. this puts our 1's at offset 16000 */
247 rump_init();
248 ATF_REQUIRE_EQ(rump_pub_etfs_register_withsize(TESTPATH1, "disk.img",
249 RUMP_ETFS_BLK, 16000, 32000), 0);
250 tfd = rump_sys_open(TESTPATH1, O_RDWR);
251 ATF_REQUIRE(tfd != -1);
252 n = rump_sys_read(tfd, buf, sizeof(buf));
253 ATF_REQUIRE_EQ(n, sizeof(buf));
254 ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
255 ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0);
256
257 /* check that we got what is expected */
258 memset(cmpbuf, 0, sizeof(cmpbuf));
259 memset(cmpbuf+16000, 1, 16);
260 ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, sizeof(buf)), 0);
261 }
262
263 ATF_TC(key);
ATF_TC_HEAD(key,tc)264 ATF_TC_HEAD(key, tc)
265 {
266
267 atf_tc_set_md_var(tc, "descr", "Checks key format");
268 }
269
ATF_TC_BODY(key,tc)270 ATF_TC_BODY(key, tc)
271 {
272
273 RZ(rump_init());
274
275 RL(open("hostfile", O_RDWR | O_CREAT, 0777));
276
277 RZ(rump_pub_etfs_register("/key", "hostfile", RUMP_ETFS_REG));
278 ATF_REQUIRE_EQ(rump_pub_etfs_register("key", "hostfile", RUMP_ETFS_REG),
279 EINVAL);
280
281 RL(rump_sys_open("/key", O_RDONLY));
282 RL(rump_sys_open("////////key", O_RDONLY));
283
284 RZ(rump_pub_etfs_register("////key//with/slashes", "hostfile",
285 RUMP_ETFS_REG));
286
287 RL(rump_sys_open("/key//with/slashes", O_RDONLY));
288 RL(rump_sys_open("key//with/slashes", O_RDONLY));
289 ATF_REQUIRE_ERRNO(ENOENT,
290 rump_sys_open("/key/with/slashes", O_RDONLY) == -1);
291
292 RL(rump_sys_mkdir("/a", 0777));
293 ATF_REQUIRE_ERRNO(ENOENT,
294 rump_sys_open("/a/key//with/slashes", O_RDONLY) == -1);
295 }
296
ATF_TP_ADD_TCS(tp)297 ATF_TP_ADD_TCS(tp)
298 {
299
300 ATF_TP_ADD_TC(tp, reregister_reg);
301 ATF_TP_ADD_TC(tp, reregister_blk);
302 ATF_TP_ADD_TC(tp, large_blk);
303 ATF_TP_ADD_TC(tp, range_blk);
304 ATF_TP_ADD_TC(tp, key);
305
306 return atf_no_error();
307 }
308