1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18#include <stdlib.h>
19#include <fcntl.h>
20#include <unistd.h>
21#include <errno.h>
22#include <string.h>
23
24#include <sys/mount.h>
25#include <sys/types.h>
26#include <sys/stat.h>
27#include <sys/ioctl.h>
28
29#include <linux/kdev_t.h>
30
31#define LOG_TAG "Vold"
32
33#include <cutils/log.h>
34
35#include <sysutils/SocketClient.h>
36#include "Loop.h"
37#include "Asec.h"
38#include "VoldUtil.h"
39#include "sehandle.h"
40
41int Loop::dumpState(SocketClient *c) {
42    int i;
43    int fd;
44    char filename[256];
45
46    for (i = 0; i < LOOP_MAX; i++) {
47        struct loop_info64 li;
48        int rc;
49
50        sprintf(filename, "/dev/block/loop%d", i);
51
52        if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
53            if (errno != ENOENT) {
54                SLOGE("Unable to open %s (%s)", filename, strerror(errno));
55            } else {
56                continue;
57            }
58            return -1;
59        }
60
61        rc = ioctl(fd, LOOP_GET_STATUS64, &li);
62        close(fd);
63        if (rc < 0 && errno == ENXIO) {
64            continue;
65        }
66
67        if (rc < 0) {
68            SLOGE("Unable to get loop status for %s (%s)", filename,
69                 strerror(errno));
70            return -1;
71        }
72        char *tmp = NULL;
73        asprintf(&tmp, "%s %d %lld:%lld %llu %lld:%lld %lld 0x%x {%s} {%s}", filename, li.lo_number,
74                MAJOR(li.lo_device), MINOR(li.lo_device), li.lo_inode, MAJOR(li.lo_rdevice),
75                        MINOR(li.lo_rdevice), li.lo_offset, li.lo_flags, li.lo_crypt_name,
76                        li.lo_file_name);
77        c->sendMsg(0, tmp, false);
78        free(tmp);
79    }
80    return 0;
81}
82
83int Loop::lookupActive(const char *id, char *buffer, size_t len) {
84    int i;
85    int fd;
86    char filename[256];
87
88    memset(buffer, 0, len);
89
90    for (i = 0; i < LOOP_MAX; i++) {
91        struct loop_info64 li;
92        int rc;
93
94        sprintf(filename, "/dev/block/loop%d", i);
95
96        if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
97            if (errno != ENOENT) {
98                SLOGE("Unable to open %s (%s)", filename, strerror(errno));
99            } else {
100                continue;
101            }
102            return -1;
103        }
104
105        rc = ioctl(fd, LOOP_GET_STATUS64, &li);
106        close(fd);
107        if (rc < 0 && errno == ENXIO) {
108            continue;
109        }
110
111        if (rc < 0) {
112            SLOGE("Unable to get loop status for %s (%s)", filename,
113                 strerror(errno));
114            return -1;
115        }
116        if (!strncmp((const char*) li.lo_crypt_name, id, LO_NAME_SIZE)) {
117            break;
118        }
119    }
120
121    if (i == LOOP_MAX) {
122        errno = ENOENT;
123        return -1;
124    }
125    strlcpy(buffer, filename, len);
126    return 0;
127}
128
129int Loop::create(const char *id, const char *loopFile, char *loopDeviceBuffer, size_t len) {
130    int i;
131    int fd;
132    char filename[256];
133
134    for (i = 0; i < LOOP_MAX; i++) {
135        struct loop_info64 li;
136        int rc;
137        char *secontext = NULL;
138
139        sprintf(filename, "/dev/block/loop%d", i);
140
141        /*
142         * The kernel starts us off with 8 loop nodes, but more
143         * are created on-demand if needed.
144         */
145        mode_t mode = 0660 | S_IFBLK;
146        unsigned int dev = (0xff & i) | ((i << 12) & 0xfff00000) | (7 << 8);
147
148        if (sehandle) {
149            rc = selabel_lookup(sehandle, &secontext, filename, S_IFBLK);
150            if (rc == 0)
151                setfscreatecon(secontext);
152        }
153
154        if (mknod(filename, mode, dev) < 0) {
155            if (errno != EEXIST) {
156                int sverrno = errno;
157                SLOGE("Error creating loop device node (%s)", strerror(errno));
158                if (secontext) {
159                    freecon(secontext);
160                    setfscreatecon(NULL);
161                }
162                errno = sverrno;
163                return -1;
164            }
165        }
166        if (secontext) {
167            freecon(secontext);
168            setfscreatecon(NULL);
169        }
170
171        if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
172            SLOGE("Unable to open %s (%s)", filename, strerror(errno));
173            return -1;
174        }
175
176        rc = ioctl(fd, LOOP_GET_STATUS64, &li);
177        if (rc < 0 && errno == ENXIO)
178            break;
179
180        close(fd);
181
182        if (rc < 0) {
183            SLOGE("Unable to get loop status for %s (%s)", filename,
184                 strerror(errno));
185            return -1;
186        }
187    }
188
189    if (i == LOOP_MAX) {
190        SLOGE("Exhausted all loop devices");
191        errno = ENOSPC;
192        return -1;
193    }
194
195    strlcpy(loopDeviceBuffer, filename, len);
196
197    int file_fd;
198
199    if ((file_fd = open(loopFile, O_RDWR | O_CLOEXEC)) < 0) {
200        SLOGE("Unable to open %s (%s)", loopFile, strerror(errno));
201        close(fd);
202        return -1;
203    }
204
205    if (ioctl(fd, LOOP_SET_FD, file_fd) < 0) {
206        SLOGE("Error setting up loopback interface (%s)", strerror(errno));
207        close(file_fd);
208        close(fd);
209        return -1;
210    }
211
212    struct loop_info64 li;
213
214    memset(&li, 0, sizeof(li));
215    strlcpy((char*) li.lo_crypt_name, id, LO_NAME_SIZE);
216    strlcpy((char*) li.lo_file_name, loopFile, LO_NAME_SIZE);
217
218    if (ioctl(fd, LOOP_SET_STATUS64, &li) < 0) {
219        SLOGE("Error setting loopback status (%s)", strerror(errno));
220        close(file_fd);
221        close(fd);
222        return -1;
223    }
224
225    close(fd);
226    close(file_fd);
227
228    return 0;
229}
230
231int Loop::destroyByDevice(const char *loopDevice) {
232    int device_fd;
233
234    device_fd = open(loopDevice, O_RDONLY | O_CLOEXEC);
235    if (device_fd < 0) {
236        SLOGE("Failed to open loop (%d)", errno);
237        return -1;
238    }
239
240    if (ioctl(device_fd, LOOP_CLR_FD, 0) < 0) {
241        SLOGE("Failed to destroy loop (%d)", errno);
242        close(device_fd);
243        return -1;
244    }
245
246    close(device_fd);
247    return 0;
248}
249
250int Loop::destroyByFile(const char * /*loopFile*/) {
251    errno = ENOSYS;
252    return -1;
253}
254
255int Loop::createImageFile(const char *file, unsigned int numSectors) {
256    int fd;
257
258    if ((fd = creat(file, 0600)) < 0) {
259        SLOGE("Error creating imagefile (%s)", strerror(errno));
260        return -1;
261    }
262
263    if (ftruncate(fd, numSectors * 512) < 0) {
264        SLOGE("Error truncating imagefile (%s)", strerror(errno));
265        close(fd);
266        return -1;
267    }
268    close(fd);
269    return 0;
270}
271
272int Loop::resizeImageFile(const char *file, unsigned int numSectors) {
273    int fd;
274
275    if ((fd = open(file, O_RDWR | O_CLOEXEC)) < 0) {
276        SLOGE("Error opening imagefile (%s)", strerror(errno));
277        return -1;
278    }
279
280    SLOGD("Attempting to increase size of %s to %d sectors.", file, numSectors);
281
282    if (fallocate(fd, 0, 0, numSectors * 512)) {
283        if (errno == ENOSYS || errno == ENOTSUP) {
284            SLOGW("fallocate not found. Falling back to ftruncate.");
285            if (ftruncate(fd, numSectors * 512) < 0) {
286                SLOGE("Error truncating imagefile (%s)", strerror(errno));
287                close(fd);
288                return -1;
289            }
290        } else {
291            SLOGE("Error allocating space (%s)", strerror(errno));
292            close(fd);
293            return -1;
294        }
295    }
296    close(fd);
297    return 0;
298}
299
300int Loop::lookupInfo(const char *loopDevice, struct asec_superblock *sb, unsigned long *nr_sec) {
301    int fd;
302    struct asec_superblock buffer;
303
304    if ((fd = open(loopDevice, O_RDONLY | O_CLOEXEC)) < 0) {
305        SLOGE("Failed to open loopdevice (%s)", strerror(errno));
306        destroyByDevice(loopDevice);
307        return -1;
308    }
309
310    get_blkdev_size(fd, nr_sec);
311    if (*nr_sec == 0) {
312        SLOGE("Failed to get loop size (%s)", strerror(errno));
313        destroyByDevice(loopDevice);
314        close(fd);
315        return -1;
316    }
317
318    /*
319     * Try to read superblock.
320     */
321    memset(&buffer, 0, sizeof(struct asec_superblock));
322    if (lseek(fd, ((*nr_sec - 1) * 512), SEEK_SET) < 0) {
323        SLOGE("lseek failed (%s)", strerror(errno));
324        close(fd);
325        destroyByDevice(loopDevice);
326        return -1;
327    }
328    if (read(fd, &buffer, sizeof(struct asec_superblock)) != sizeof(struct asec_superblock)) {
329        SLOGE("superblock read failed (%s)", strerror(errno));
330        close(fd);
331        destroyByDevice(loopDevice);
332        return -1;
333    }
334    close(fd);
335
336    /*
337     * Superblock successfully read. Copy to caller's struct.
338     */
339    memcpy(sb, &buffer, sizeof(struct asec_superblock));
340    return 0;
341}
342