Loop.cpp

   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
  41 int 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
  83 int 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
 129 int 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
 231 int 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
 250 int Loop::destroyByFile(const char * /*loopFile*/) {
 251     errno = ENOSYS;
 252     return -1;
 253 }
 254
 255 int 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
 272 int 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
 300 int 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 }