xref: /netbsd-src/tests/fs/common/fstest_nfs.c (revision 5b28f239895d55856221c590945769250e289f5f)
1 /*	$NetBSD: fstest_nfs.c,v 1.13 2024/09/08 09:36:52 rillig Exp $	*/
2 
3 /*
4  * Copyright (c) 2010 The NetBSD Foundation, Inc.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 #include <sys/types.h>
29 #include <sys/mount.h>
30 #include <sys/socket.h>
31 #include <sys/statvfs.h>
32 #include <sys/wait.h>
33 
34 #include <assert.h>
35 #include <atf-c.h>
36 #include <err.h>
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <libgen.h>
40 #include <pthread.h>
41 #include <puffs.h>
42 #include <puffsdump.h>
43 #include <stdio.h>
44 #include <unistd.h>
45 #include <string.h>
46 #include <stdlib.h>
47 
48 #include <rump/rump.h>
49 #include <rump/rump_syscallshotgun.h>
50 #include <rump/rump_syscalls.h>
51 
52 #include "h_fsmacros.h"
53 #include "mount_nfs.h"
54 #include "../../net/config/netconfig.c"
55 
56 #define SERVERADDR "10.3.2.1"
57 #define SERVERROADDR "10.4.2.1"
58 #define CLIENTADDR "10.3.2.2"
59 #define CLIENTROADDR "10.4.2.2"
60 #define NETNETMASK "255.255.255.0"
61 #define EXPORTPATH "/myexport"
62 
63 static void
64 childfail(int status)
65 {
66 
67 	atf_tc_fail("child died");
68 }
69 
70 /* fork rump nfsd, configure interface */
71 static int
72 donewfs(const atf_tc_t *tc, void **argp,
73 	const char *image, off_t size, void *fspriv)
74 {
75 	const char *srcdir;
76 	char *nfsdargv[16];
77 	char nfsdpath[MAXPATHLEN];
78 	char imagepath[MAXPATHLEN];
79 	char ethername[MAXPATHLEN], ethername_ro[MAXPATHLEN];
80 	char ifname[IFNAMSIZ], ifname_ro[IFNAMSIZ];
81 	char cwd[MAXPATHLEN];
82 	struct nfstestargs *args;
83 	pid_t childpid;
84 	int pipes[2];
85 	int devnull;
86 
87 	/*
88 	 * First, we start the nfs service.
89 	 */
90 	srcdir = atf_tc_get_config_var(tc, "srcdir");
91 	snprintf(nfsdpath, sizeof nfsdpath,
92 	    "%s/../nfs/nfsservice/rumpnfsd", srcdir);
93 	snprintf(ethername, sizeof ethername,
94 	    "/%s/%s.etherbus", getcwd(cwd, sizeof(cwd)), image);
95 	snprintf(ethername_ro, sizeof ethername_ro, "%s_ro", ethername);
96 	snprintf(imagepath, sizeof imagepath, "/%s/%s", cwd, image);
97 
98 	nfsdargv[0] = nfsdpath;
99 	nfsdargv[1] = ethername;
100 	nfsdargv[2] = ethername_ro;
101 	nfsdargv[3] = __UNCONST(SERVERADDR);
102 	nfsdargv[4] = __UNCONST(SERVERROADDR);
103 	nfsdargv[5] = __UNCONST(NETNETMASK);
104 	nfsdargv[6] = __UNCONST(EXPORTPATH);
105 	nfsdargv[7] = imagepath;
106 	nfsdargv[8] = NULL;
107 
108 	signal(SIGCHLD, childfail);
109 	if (pipe(pipes) == -1)
110 		return errno;
111 
112 	switch ((childpid = fork())) {
113 	case 0:
114 		if (chdir(dirname(nfsdpath)) == -1)
115 			err(1, "chdir");
116 		close(pipes[0]);
117 		if (dup2(pipes[1], 3) == -1)
118 			err(1, "dup2");
119 		execvp(nfsdargv[0], nfsdargv);
120 		err(1, "execvp");
121 	case -1:
122 		return errno;
123 	default:
124 		close(pipes[1]);
125 		break;
126 	}
127 
128 	/*
129 	 * Ok, nfsd has been run.  The following sleep helps with the
130 	 * theoretical problem that nfsd can't start fast enough to
131 	 * process our mount request and we end up doing a timeout
132 	 * before the mount.  This would take several seconds.  So
133 	 * try to make sure nfsd is up&running already at this stage.
134 	 */
135 	if (read(pipes[0], &devnull, 4) == -1)
136 		return errno;
137 
138 	/*
139 	 * Configure our networking interface.
140 	 */
141 	rump_init();
142 	netcfg_rump_makeshmif(ethername, ifname);
143 	netcfg_rump_if(ifname, CLIENTADDR, NETNETMASK);
144 	netcfg_rump_makeshmif(ethername_ro, ifname_ro);
145 	netcfg_rump_if(ifname_ro, CLIENTROADDR, NETNETMASK);
146 
147 	/*
148 	 * That's it.  The rest is done in mount, since we don't have
149 	 * the mountpath available here.
150 	 */
151 	args = malloc(sizeof(*args));
152 	if (args == NULL)
153 		return errno;
154 	memset(args, 0, sizeof(*args));
155 	args->ta_childpid = childpid;
156 	strcpy(args->ta_ethername, ethername);
157 
158 	*argp = args;
159 
160 	return 0;
161 }
162 
163 int
164 nfs_fstest_newfs(const atf_tc_t *tc, void **argp,
165 	const char *image, off_t size, void *fspriv)
166 {
167 
168 	return donewfs(tc, argp, image, size, fspriv);
169 }
170 
171 int
172 nfsro_fstest_newfs(const atf_tc_t *tc, void **argp,
173 	const char *image, off_t size, void *fspriv)
174 {
175 
176 	return donewfs(tc, argp, image, size, fspriv);
177 }
178 
179 /* mount the file system */
180 static int
181 domount(const atf_tc_t *tc, void *arg, const char *serverpath,
182 	const char *path, int flags)
183 {
184 	char canon_dev[MAXPATHLEN], canon_dir[MAXPATHLEN];
185 	const char *nfscliargs[] = {
186 		"nfsclient",
187 		serverpath,
188 		path,
189 		NULL,
190 	};
191 	struct nfs_args args;
192 	int mntflags;
193 
194 	if (rump_sys_mkdir(path, 0777) == -1)
195 		return errno;
196 
197 	/* XXX: atf does not reset values */
198 	optind = 1;
199 	opterr = 1;
200 
201 	/*
202 	 * We use nfs parseargs here, since as a side effect it
203 	 * takes care of the RPC hulabaloo.
204 	 */
205 	mount_nfs_parseargs(__arraycount(nfscliargs)-1, __UNCONST(nfscliargs),
206 	    &args, &mntflags, canon_dev, canon_dir);
207 
208 	if (rump_sys_mount(MOUNT_NFS, path, flags, &args, sizeof(args)) == -1) {
209 		return errno;
210 	}
211 
212 	return 0;
213 }
214 
215 int
216 nfs_fstest_mount(const atf_tc_t *tc, void *arg, const char *path, int flags)
217 {
218 
219 	return domount(tc, arg, SERVERADDR ":" EXPORTPATH, path, flags);
220 }
221 
222 /*
223  * This is where the magic happens!
224  *
225  * If we are mounting r/w, do the normal thing.  However, if we are
226  * doing a r/o mount, switch use the r/o server export address
227  * and do a r/w mount.  This way we end up testing the r/o export policy
228  * of the server! (yes, slightly questionable semantics, but at least
229  * we notice very quickly if our assumption is broken in the future ;)
230  */
231 int
232 nfsro_fstest_mount(const atf_tc_t *tc, void *arg, const char *path, int flags)
233 {
234 
235 	if (flags & MNT_RDONLY) {
236 		flags &= ~MNT_RDONLY;
237 		return domount(tc, arg, SERVERROADDR":"EXPORTPATH, path, flags);
238 	} else {
239 		return domount(tc, arg, SERVERADDR":"EXPORTPATH, path, flags);
240 	}
241 }
242 
243 static int
244 dodelfs(const atf_tc_t *tc, void *arg)
245 {
246 
247 	/*
248 	 * XXX: no access to "args" since we're called from "cleanup".
249 	 * Trust atf to kill nfsd process and remove etherfile.
250 	 */
251 #if 0
252 	/*
253 	 * It's highly expected that the child will die next, so we
254 	 * don't need that information anymore thank you very many.
255 	 */
256 	signal(SIGCHLD, SIG_IGN);
257 
258 	/*
259 	 * Just KILL it.  Sending it SIGTERM first causes it to try
260 	 * to send some unmount RPCs, leading to sticky situations.
261 	 */
262 	kill(args->ta_childpid, SIGKILL);
263 	wait(&status);
264 
265 	/* remove ethernet bus */
266 	if (unlink(args->ta_ethername) == -1)
267 		atf_tc_fail_errno("unlink ethername");
268 #endif
269 
270 	return 0;
271 }
272 
273 int
274 nfs_fstest_delfs(const atf_tc_t *tc, void *arg)
275 {
276 
277 	return dodelfs(tc, arg);
278 }
279 
280 int
281 nfsro_fstest_delfs(const atf_tc_t *tc, void *arg)
282 {
283 
284 	return dodelfs(tc, arg);
285 }
286 
287 static int
288 dounmount(const atf_tc_t *tc, const char *path, int flags)
289 {
290 	int status, i, sverrno;
291 
292 	/*
293 	 * NFS handles sillyrenames in a workqueue.  Some of them might
294 	 * be still in the queue even if all user activity has ceased.
295 	 * We try to unmount for 2 seconds to give them a chance
296 	 * to flush out.
297 	 *
298 	 * PR kern/43799
299 	 */
300 	for (i = 0; i < 20; i++) {
301 		if ((status = rump_sys_unmount(path, flags)) == 0)
302 			break;
303 		sverrno = errno;
304 		if (sverrno != EBUSY)
305 			break;
306 		usleep(100000);
307 	}
308 	if (status == -1)
309 		return sverrno;
310 
311 	if (rump_sys_rmdir(path) == -1)
312 		return errno;
313 
314 	return 0;
315 }
316 
317 int
318 nfs_fstest_unmount(const atf_tc_t *tc, const char *path, int flags)
319 {
320 
321 	return dounmount(tc, path, flags);
322 }
323 
324 int
325 nfsro_fstest_unmount(const atf_tc_t *tc, const char *path, int flags)
326 {
327 
328 	return dounmount(tc, path, flags);
329 }
330