1/*
2 * Copyright (C) 2014 Cyril Hrubis chrubis@suse.cz
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like.  Any license provided herein, whether implied or
15 * otherwise, applies only to this software file.  Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 */
23
24#include <sys/types.h>
25#include <sys/stat.h>
26#include <sys/ioctl.h>
27#include <sys/mount.h>
28#include <errno.h>
29#include <unistd.h>
30#include <stdlib.h>
31#include <linux/loop.h>
32#include <stdint.h>
33#include <inttypes.h>
34#include "test.h"
35#include "safe_macros.h"
36
37#ifndef LOOP_CTL_GET_FREE
38# define LOOP_CTL_GET_FREE 0x4C82
39#endif
40
41#define LOOP_CONTROL_FILE "/dev/loop-control"
42
43#define DEV_FILE "test_dev.img"
44#define DEV_SIZE_MB 256u
45
46static char dev_path[1024];
47static int device_acquired;
48
49static const char *dev_variants[] = {
50	"/dev/loop%i",
51	"/dev/loop/%i",
52	"/dev/block/loop%i"
53};
54
55static int set_dev_path(int dev)
56{
57	unsigned int i;
58	struct stat st;
59
60	for (i = 0; i < ARRAY_SIZE(dev_variants); i++) {
61		snprintf(dev_path, sizeof(dev_path), dev_variants[i], dev);
62
63		if (stat(dev_path, &st) == 0 && S_ISBLK(st.st_mode))
64			return 1;
65	}
66
67	return 0;
68}
69
70static int find_free_loopdev(void)
71{
72	int ctl_fd, dev_fd, rc, i;
73	struct loop_info loopinfo;
74
75	/* since Linux 3.1 */
76	ctl_fd = open(LOOP_CONTROL_FILE, O_RDWR);
77
78	if (ctl_fd > 0) {
79		rc = ioctl(ctl_fd, LOOP_CTL_GET_FREE);
80		close(ctl_fd);
81		if (rc >= 0) {
82			set_dev_path(rc);
83			tst_resm(TINFO, "Found free device '%s'", dev_path);
84			return 0;
85		}
86		tst_resm(TINFO, "Couldn't find free loop device");
87		return 1;
88	}
89
90	switch (errno) {
91	case ENOENT:
92	break;
93	case EACCES:
94		tst_resm(TINFO | TERRNO,
95		         "Not allowed to open " LOOP_CONTROL_FILE ". "
96			 "Are you root?");
97	break;
98	default:
99		tst_resm(TBROK | TERRNO, "Failed to open " LOOP_CONTROL_FILE);
100	}
101
102	/*
103	 * Older way is to iterate over /dev/loop%i and /dev/loop/%i and try
104	 * LOOP_GET_STATUS ioctl() which fails for free loop devices.
105	 */
106	for (i = 0; i < 256; i++) {
107
108		if (!set_dev_path(i))
109			continue;
110
111		dev_fd = open(dev_path, O_RDONLY);
112
113		if (dev_fd < 0)
114			continue;
115
116		if (ioctl(dev_fd, LOOP_GET_STATUS, &loopinfo) == 0) {
117			tst_resm(TINFO, "Device '%s' in use", dev_path);
118		} else {
119			if (errno != ENXIO)
120				continue;
121			tst_resm(TINFO, "Found free device '%s'", dev_path);
122			close(dev_fd);
123			return 0;
124		}
125
126		close(dev_fd);
127	}
128
129	tst_resm(TINFO, "No free devices found");
130
131	return 1;
132}
133
134static int attach_device(const char *dev, const char *file)
135{
136	int dev_fd, file_fd;
137	struct loop_info loopinfo;
138
139	dev_fd = open(dev, O_RDWR);
140	if (dev_fd < 0) {
141		tst_resm(TWARN | TERRNO, "open('%s', O_RDWR) failed", dev);
142		return 1;
143	}
144
145	file_fd = open(file, O_RDWR);
146	if (file_fd < 0) {
147		tst_resm(TWARN | TERRNO, "open('%s', O_RDWR) failed", file);
148		close(dev_fd);
149		return 1;
150	}
151
152	if (ioctl(dev_fd, LOOP_SET_FD, file_fd) < 0) {
153		close(dev_fd);
154		close(file_fd);
155		tst_resm(TWARN | TERRNO, "ioctl(%s, LOOP_SET_FD, %s) failed",
156			 dev, file);
157		return 1;
158	}
159
160	/* Old mkfs.btrfs use LOOP_GET_STATUS instead of backing_file to get
161	 * associated filename, so we need to set up the device by calling
162	 * LOOP_SET_FD and LOOP_SET_STATUS.
163	 */
164	memset(&loopinfo, 0, sizeof(loopinfo));
165	strcpy(loopinfo.lo_name, file);
166
167	if (ioctl(dev_fd, LOOP_SET_STATUS, &loopinfo)) {
168		close(dev_fd);
169		close(file_fd);
170		tst_resm(TWARN | TERRNO,
171			 "ioctl(%s, LOOP_SET_STATUS, %s) failed", dev, file);
172		return 1;
173	}
174
175	close(dev_fd);
176	close(file_fd);
177	return 0;
178}
179
180static int detach_device(const char *dev)
181{
182	int dev_fd, ret, i;
183
184	dev_fd = open(dev, O_RDONLY);
185	if (dev_fd < 0) {
186		tst_resm(TWARN | TERRNO, "open(%s) failed", dev);
187		return 1;
188	}
189
190	/* keep trying to clear LOOPDEV until we get ENXIO, a quick succession
191	 * of attach/detach might not give udev enough time to complete */
192	for (i = 0; i < 40; i++) {
193		ret = ioctl(dev_fd, LOOP_CLR_FD, 0);
194
195		if (ret && (errno == ENXIO)) {
196			close(dev_fd);
197			return 0;
198		}
199
200		if (ret && (errno != EBUSY)) {
201			tst_resm(TWARN,
202				 "ioctl(%s, LOOP_CLR_FD, 0) unexpectedly failed with: %s",
203				 dev, tst_strerrno(errno));
204			close(dev_fd);
205			return 1;
206		}
207
208		usleep(50000);
209	}
210
211	close(dev_fd);
212	tst_resm(TWARN,
213		"ioctl(%s, LOOP_CLR_FD, 0) no ENXIO for too long", dev);
214	return 1;
215}
216
217const char *tst_acquire_device__(unsigned int size)
218{
219	int fd;
220	char *dev;
221	struct stat st;
222	unsigned int acq_dev_size;
223	uint64_t ltp_dev_size;
224
225	acq_dev_size = MAX(size, DEV_SIZE_MB);
226
227	dev = getenv("LTP_DEV");
228
229	if (dev) {
230		tst_resm(TINFO, "Using test device LTP_DEV='%s'", dev);
231
232		if (stat(dev, &st)) {
233			tst_resm(TWARN | TERRNO, "stat() failed");
234			return NULL;
235		}
236
237		if (!S_ISBLK(st.st_mode)) {
238			tst_resm(TWARN, "%s is not a block device", dev);
239			return NULL;
240		}
241
242		fd = open(dev, O_RDONLY);
243		if (fd < 0) {
244			tst_resm(TWARN | TERRNO,
245				 "open(%s, O_RDONLY) failed", dev);
246			return NULL;
247		}
248
249		if (ioctl(fd, BLKGETSIZE64, &ltp_dev_size)) {
250			tst_resm(TWARN | TERRNO,
251				 "ioctl(fd, BLKGETSIZE64, ...) failed");
252			close(fd);
253			return NULL;
254		}
255
256		if (close(fd)) {
257			tst_resm(TWARN | TERRNO,
258				 "close(fd) failed");
259			return NULL;
260		}
261
262		ltp_dev_size = ltp_dev_size/1024/1024;
263
264		if (acq_dev_size <= ltp_dev_size)
265			return dev;
266
267		tst_resm(TINFO, "Skipping $LTP_DEV size %"PRIu64"MB, requested size %uMB",
268				ltp_dev_size, acq_dev_size);
269	}
270
271	if (tst_fill_file(DEV_FILE, 0, 1024, 1024 * acq_dev_size)) {
272		tst_resm(TWARN | TERRNO, "Failed to create " DEV_FILE);
273		return NULL;
274	}
275
276	if (find_free_loopdev())
277		return NULL;
278
279	if (attach_device(dev_path, DEV_FILE))
280		return NULL;
281
282	device_acquired = 1;
283
284	return dev_path;
285}
286
287const char *tst_acquire_device_(void (cleanup_fn)(void), unsigned int size)
288{
289	const char *device;
290
291	if (device_acquired) {
292		tst_brkm(TBROK, cleanup_fn, "Device already acquired");
293		return NULL;
294	}
295
296	if (!tst_tmpdir_created()) {
297		tst_brkm(TBROK, cleanup_fn,
298		         "Cannot acquire device without tmpdir() created");
299		return NULL;
300	}
301
302	device = tst_acquire_device__(size);
303
304	if (!device) {
305		tst_brkm(TBROK, cleanup_fn, "Failed to acquire device");
306		return NULL;
307	}
308
309	return device;
310}
311
312int tst_release_device(const char *dev)
313{
314	int ret;
315
316	if (getenv("LTP_DEV"))
317		return 0;
318
319	/*
320	 * Loop device was created -> we need to detach it.
321	 *
322	 * The file image is deleted in tst_rmdir();
323	 */
324	ret = detach_device(dev);
325
326	device_acquired = 0;
327
328	return ret;
329}
330
331int tst_clear_device(const char *dev)
332{
333	if (tst_fill_file(dev, 0, 1024, 512)) {
334		tst_resm(TWARN, "Failed to clear 512k block on %s", dev);
335		return 1;
336	}
337
338	return 0;
339}
340
341int tst_umount(const char *path)
342{
343	int err, ret, i;
344
345	for (i = 0; i < 50; i++) {
346		ret = umount(path);
347		err = errno;
348
349		if (!ret)
350			return 0;
351
352		tst_resm(TINFO, "umount('%s') failed with %s, try %2i...",
353		         path, tst_strerrno(err), i+1);
354
355		if (i == 0 && err == EBUSY) {
356			tst_resm(TINFO, "Likely gvfsd-trash is probing newly "
357			         "mounted fs, kill it to speed up tests.");
358		}
359
360		usleep(100000);
361	}
362
363	tst_resm(TWARN, "Failed to umount('%s') after 50 retries", path);
364	errno = err;
365	return -1;
366}
367