91cde561c7452e218b8d8fc80cce4073bcbe86d6
[platform/upstream/cryptsetup.git] / lib / utils_loop.c
1 /*
2  * loopback block device utilities
3  *
4  * Copyright (C) 2011, Red Hat, Inc. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * version 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19
20 #include <string.h>
21 #include <stdio.h>
22 #include <unistd.h>
23 #include <fcntl.h>
24 #include <errno.h>
25 #include <limits.h>
26 #include <sys/ioctl.h>
27 #include <sys/stat.h>
28 #include <linux/loop.h>
29
30 #include "utils_loop.h"
31
32 static char *crypt_loop_get_device_old(void)
33 {
34         char dev[20];
35         int i, loop_fd;
36         struct stat st;
37         struct loop_info64 lo64 = {0};
38
39         for (i = 0; i < 256; i++) {
40                 sprintf(dev, "/dev/loop%d", i);
41                 if (stat(dev, &st) || !S_ISBLK(st.st_mode))
42                         return NULL;
43
44                 loop_fd = open(dev, O_RDONLY);
45                 if (loop_fd < 0)
46                         return NULL;
47
48                 if (ioctl(loop_fd, LOOP_GET_STATUS64, &lo64) &&
49                     errno == ENXIO) {
50                         close(loop_fd);
51                         return strdup(dev);
52                 }
53                 close(loop_fd);
54         }
55
56         return NULL;
57 }
58
59 char *crypt_loop_get_device(void)
60 {
61         char dev[64];
62         int i, loop_fd;
63         struct stat st;
64
65         loop_fd = open("/dev/loop-control", O_RDONLY);
66         if (loop_fd < 0)
67                 return crypt_loop_get_device_old();
68
69         i = ioctl(loop_fd, LOOP_CTL_GET_FREE);
70         if (i < 0) {
71                 close(loop_fd);
72                 return NULL;
73         }
74         close(loop_fd);
75
76         if (sprintf(dev, "/dev/loop%d", i) < 0)
77                 return NULL;
78
79         if (stat(dev, &st) || !S_ISBLK(st.st_mode))
80                 return NULL;
81
82         return strdup(dev);
83 }
84
85 int crypt_loop_attach(const char *loop, const char *file, int offset,
86                       int autoclear, int *readonly)
87 {
88         struct loop_info64 lo64 = {0};
89         int loop_fd = -1, file_fd = -1, r = 1;
90
91         file_fd = open(file, (*readonly ? O_RDONLY : O_RDWR) | O_EXCL);
92         if (file_fd < 0 && errno == EROFS && !*readonly) {
93                 *readonly = 1;
94                 file_fd = open(file, O_RDONLY | O_EXCL);
95         }
96         if (file_fd < 0)
97                 goto out;
98
99         loop_fd = open(loop, *readonly ? O_RDONLY : O_RDWR);
100         if (loop_fd < 0)
101                 goto out;
102
103         strncpy((char*)lo64.lo_file_name, file, LO_NAME_SIZE);
104         lo64.lo_offset = offset;
105         if (autoclear)
106                 lo64.lo_flags |= LO_FLAGS_AUTOCLEAR;
107
108         if (ioctl(loop_fd, LOOP_SET_FD, file_fd) < 0)
109                 goto out;
110
111         if (ioctl(loop_fd, LOOP_SET_STATUS64, &lo64) < 0) {
112                 (void)ioctl(loop_fd, LOOP_CLR_FD, 0);
113                 goto out;
114         }
115
116         /* Verify that autoclear is really set */
117         if (autoclear) {
118                 memset(&lo64, 0, sizeof(lo64));
119                 if (ioctl(loop_fd, LOOP_GET_STATUS64, &lo64) < 0 ||
120                    !(lo64.lo_flags & LO_FLAGS_AUTOCLEAR)) {
121                 (void)ioctl(loop_fd, LOOP_CLR_FD, 0);
122                         goto out;
123                 }
124         }
125
126         r = 0;
127 out:
128         if (r && loop_fd >= 0)
129                 close(loop_fd);
130         if (file_fd >= 0)
131                 close(file_fd);
132         return r ? -1 : loop_fd;
133 }
134
135 int crypt_loop_detach(const char *loop)
136 {
137         int loop_fd = -1, r = 1;
138
139         loop_fd = open(loop, O_RDONLY);
140         if (loop_fd < 0)
141                 return 1;
142
143         if (!ioctl(loop_fd, LOOP_CLR_FD, 0))
144                 r = 0;
145
146         close(loop_fd);
147         return r;
148 }
149
150 static char *_ioctl_backing_file(const char *loop)
151 {
152         struct loop_info64 lo64 = {0};
153         int loop_fd;
154
155         loop_fd = open(loop, O_RDONLY);
156         if (loop_fd < 0)
157                 return NULL;
158
159         if (ioctl(loop_fd, LOOP_GET_STATUS64, &lo64) < 0) {
160                 close(loop_fd);
161                 return NULL;
162         }
163
164         lo64.lo_file_name[LO_NAME_SIZE-2] = '*';
165         lo64.lo_file_name[LO_NAME_SIZE-1] = 0;
166
167         close(loop_fd);
168
169         return strdup((char*)lo64.lo_file_name);
170 }
171
172 static char *_sysfs_backing_file(const char *loop)
173 {
174         struct stat st;
175         char buf[PATH_MAX];
176         size_t len;
177         int fd;
178
179         if (stat(loop, &st) || !S_ISBLK(st.st_mode))
180                 return NULL;
181
182         snprintf(buf, sizeof(buf), "/sys/dev/block/%d:%d/loop/backing_file",
183                  major(st.st_rdev), minor(st.st_rdev));
184
185         fd = open(buf, O_RDONLY);
186         if (fd < 0)
187                 return NULL;
188
189         len = read(fd, buf, PATH_MAX);
190         close(fd);
191         if (len < 2)
192                 return NULL;
193
194         buf[len - 1] = '\0';
195         return strdup(buf);
196 }
197
198 char *crypt_loop_backing_file(const char *loop)
199 {
200         char *bf = _sysfs_backing_file(loop);
201         return bf ?: _ioctl_backing_file(loop);
202 }
203
204 int crypt_loop_device(const char *loop)
205 {
206         struct stat st;
207
208         if (!loop)
209                 return 0;
210
211         if (stat(loop, &st) || !S_ISBLK(st.st_mode) ||
212             major(st.st_rdev) != LOOP_DEV_MAJOR)
213                 return 0;
214
215         return 1;
216 }