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 <android-base/logging.h>
  36 #include <android-base/stringprintf.h>
  37 #include <android-base/unique_fd.h>
  38
  39 #include <sysutils/SocketClient.h>
  40 #include "Loop.h"
  41 #include "Asec.h"
  42 #include "VoldUtil.h"
  43 #include "sehandle.h"
  44
  45 using android::base::StringPrintf;
  46 using android::base::unique_fd;
  47
  48 int Loop::dumpState(SocketClient *c) {
  49     int i;
  50     int fd;
  51     char filename[256];
  52
  53     for (i = 0; i < LOOP_MAX; i++) {
  54         struct loop_info64 li;
  55         int rc;
  56
  57         snprintf(filename, sizeof(filename), "/dev/block/loop%d", i);
  58
  59         if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
  60             if (errno != ENOENT) {
  61                 SLOGE("Unable to open %s (%s)", filename, strerror(errno));
  62             } else {
  63                 continue;
  64             }
  65             return -1;
  66         }
  67
  68         rc = ioctl(fd, LOOP_GET_STATUS64, &li);
  69         close(fd);
  70         if (rc < 0 && errno == ENXIO) {
  71             continue;
  72         }
  73
  74         if (rc < 0) {
  75             SLOGE("Unable to get loop status for %s (%s)", filename,
  76                  strerror(errno));
  77             return -1;
  78         }
  79         char *tmp = NULL;
  80         asprintf(&tmp, "%s %d %lld:%lld %llu %lld:%lld %lld 0x%x {%s} {%s}", filename, li.lo_number,
  81                 MAJOR(li.lo_device), MINOR(li.lo_device), li.lo_inode, MAJOR(li.lo_rdevice),
  82                         MINOR(li.lo_rdevice), li.lo_offset, li.lo_flags, li.lo_crypt_name,
  83                         li.lo_file_name);
  84         c->sendMsg(0, tmp, false);
  85         free(tmp);
  86     }
  87     return 0;
  88 }
  89
  90 int Loop::lookupActive(const char *id, char *buffer, size_t len) {
  91     int i;
  92     int fd;
  93     char filename[256];
  94
  95     memset(buffer, 0, len);
  96
  97     for (i = 0; i < LOOP_MAX; i++) {
  98         struct loop_info64 li;
  99         int rc;
 100
 101         snprintf(filename, sizeof(filename), "/dev/block/loop%d", i);
 102
 103         if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
 104             if (errno != ENOENT) {
 105                 SLOGE("Unable to open %s (%s)", filename, strerror(errno));
 106             } else {
 107                 continue;
 108             }
 109             return -1;
 110         }
 111
 112         rc = ioctl(fd, LOOP_GET_STATUS64, &li);
 113         if (rc < 0 && errno == ENXIO) {
 114             close(fd);
 115             continue;
 116         }
 117         close(fd);
 118
 119         if (rc < 0) {
 120             SLOGE("Unable to get loop status for %s (%s)", filename,
 121                  strerror(errno));
 122             return -1;
 123         }
 124         if (!strncmp((const char*) li.lo_crypt_name, id, LO_NAME_SIZE)) {
 125             break;
 126         }
 127     }
 128
 129     if (i == LOOP_MAX) {
 130         errno = ENOENT;
 131         return -1;
 132     }
 133     strlcpy(buffer, filename, len);
 134     return 0;
 135 }
 136
 137 int Loop::create(const char *id, const char *loopFile, char *loopDeviceBuffer, size_t len) {
 138     int i;
 139     int fd;
 140     char filename[256];
 141
 142     for (i = 0; i < LOOP_MAX; i++) {
 143         struct loop_info64 li;
 144         int rc;
 145         char *secontext = NULL;
 146
 147         snprintf(filename, sizeof(filename), "/dev/block/loop%d", i);
 148
 149         /*
 150          * The kernel starts us off with 8 loop nodes, but more
 151          * are created on-demand if needed.
 152          */
 153         mode_t mode = 0660 | S_IFBLK;
 154         unsigned int dev = (0xff & i) | ((i << 12) & 0xfff00000) | (7 << 8);
 155
 156         if (sehandle) {
 157             rc = selabel_lookup(sehandle, &secontext, filename, S_IFBLK);
 158             if (rc == 0)
 159                 setfscreatecon(secontext);
 160         }
 161
 162         if (mknod(filename, mode, dev) < 0) {
 163             if (errno != EEXIST) {
 164                 int sverrno = errno;
 165                 SLOGE("Error creating loop device node (%s)", strerror(errno));
 166                 if (secontext) {
 167                     freecon(secontext);
 168                     setfscreatecon(NULL);
 169                 }
 170                 errno = sverrno;
 171                 return -1;
 172             }
 173         }
 174         if (secontext) {
 175             freecon(secontext);
 176             setfscreatecon(NULL);
 177         }
 178
 179         if ((fd = open(filename, O_RDWR | O_CLOEXEC)) < 0) {
 180             SLOGE("Unable to open %s (%s)", filename, strerror(errno));
 181             return -1;
 182         }
 183
 184         rc = ioctl(fd, LOOP_GET_STATUS64, &li);
 185         if (rc < 0 && errno == ENXIO)
 186             break;
 187
 188         close(fd);
 189
 190         if (rc < 0) {
 191             SLOGE("Unable to get loop status for %s (%s)", filename,
 192                  strerror(errno));
 193             return -1;
 194         }
 195     }
 196
 197     if (i == LOOP_MAX) {
 198         SLOGE("Exhausted all loop devices");
 199         errno = ENOSPC;
 200         return -1;
 201     }
 202
 203     strlcpy(loopDeviceBuffer, filename, len);
 204
 205     int file_fd;
 206
 207     if ((file_fd = open(loopFile, O_RDWR | O_CLOEXEC)) < 0) {
 208         SLOGE("Unable to open %s (%s)", loopFile, strerror(errno));
 209         close(fd);
 210         return -1;
 211     }
 212
 213     if (ioctl(fd, LOOP_SET_FD, file_fd) < 0) {
 214         SLOGE("Error setting up loopback interface (%s)", strerror(errno));
 215         close(file_fd);
 216         close(fd);
 217         return -1;
 218     }
 219
 220     struct loop_info64 li;
 221
 222     memset(&li, 0, sizeof(li));
 223     strlcpy((char*) li.lo_crypt_name, id, LO_NAME_SIZE);
 224     strlcpy((char*) li.lo_file_name, loopFile, LO_NAME_SIZE);
 225
 226     if (ioctl(fd, LOOP_SET_STATUS64, &li) < 0) {
 227         SLOGE("Error setting loopback status (%s)", strerror(errno));
 228         close(file_fd);
 229         close(fd);
 230         return -1;
 231     }
 232
 233     close(fd);
 234     close(file_fd);
 235
 236     return 0;
 237 }
 238
 239 int Loop::create(const std::string& target, std::string& out_device) {
 240     unique_fd ctl_fd(open("/dev/loop-control", O_RDWR | O_CLOEXEC));
 241     if (ctl_fd.get() == -1) {
 242         PLOG(ERROR) << "Failed to open loop-control";
 243         return -errno;
 244     }
 245
 246     int num = ioctl(ctl_fd.get(), LOOP_CTL_GET_FREE);
 247     if (num == -1) {
 248         PLOG(ERROR) << "Failed LOOP_CTL_GET_FREE";
 249         return -errno;
 250     }
 251
 252     out_device = StringPrintf("/dev/block/loop%d", num);
 253
 254     unique_fd target_fd(open(target.c_str(), O_RDWR | O_CLOEXEC));
 255     if (target_fd.get() == -1) {
 256         PLOG(ERROR) << "Failed to open " << target;
 257         return -errno;
 258     }
 259     unique_fd device_fd(open(out_device.c_str(), O_RDWR | O_CLOEXEC));
 260     if (device_fd.get() == -1) {
 261         PLOG(ERROR) << "Failed to open " << out_device;
 262         return -errno;
 263     }
 264
 265     if (ioctl(device_fd.get(), LOOP_SET_FD, target_fd.get()) == -1) {
 266         PLOG(ERROR) << "Failed to LOOP_SET_FD";
 267         return -errno;
 268     }
 269
 270     return 0;
 271 }
 272
 273 int Loop::destroyByDevice(const char *loopDevice) {
 274     int device_fd;
 275
 276     device_fd = open(loopDevice, O_RDONLY | O_CLOEXEC);
 277     if (device_fd < 0) {
 278         SLOGE("Failed to open loop (%d)", errno);
 279         return -1;
 280     }
 281
 282     if (ioctl(device_fd, LOOP_CLR_FD, 0) < 0) {
 283         SLOGE("Failed to destroy loop (%d)", errno);
 284         close(device_fd);
 285         return -1;
 286     }
 287
 288     close(device_fd);
 289     return 0;
 290 }
 291
 292 int Loop::destroyByFile(const char * /*loopFile*/) {
 293     errno = ENOSYS;
 294     return -1;
 295 }
 296
 297 int Loop::createImageFile(const char *file, unsigned long numSectors) {
 298     unique_fd fd(open(file, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC, 0600));
 299     if (fd.get() == -1) {
 300         PLOG(ERROR) << "Failed to create image " << file;
 301         return -errno;
 302     }
 303     if (fallocate(fd.get(), 0, 0, numSectors * 512) == -1) {
 304         PLOG(WARNING) << "Failed to fallocate; falling back to ftruncate";
 305         if (ftruncate(fd, numSectors * 512) == -1) {
 306             PLOG(ERROR) << "Failed to ftruncate";
 307             return -errno;
 308         }
 309     }
 310     return 0;
 311 }
 312
 313 int Loop::resizeImageFile(const char *file, unsigned long numSectors) {
 314     int fd;
 315
 316     if ((fd = open(file, O_RDWR | O_CLOEXEC)) < 0) {
 317         SLOGE("Error opening imagefile (%s)", strerror(errno));
 318         return -1;
 319     }
 320
 321     SLOGD("Attempting to increase size of %s to %lu sectors.", file, numSectors);
 322
 323     if (fallocate(fd, 0, 0, numSectors * 512)) {
 324         if (errno == ENOSYS || errno == ENOTSUP) {
 325             SLOGW("fallocate not found. Falling back to ftruncate.");
 326             if (ftruncate(fd, numSectors * 512) < 0) {
 327                 SLOGE("Error truncating imagefile (%s)", strerror(errno));
 328                 close(fd);
 329                 return -1;
 330             }
 331         } else {
 332             SLOGE("Error allocating space (%s)", strerror(errno));
 333             close(fd);
 334             return -1;
 335         }
 336     }
 337     close(fd);
 338     return 0;
 339 }
 340
 341 int Loop::lookupInfo(const char *loopDevice, struct asec_superblock *sb, unsigned long *nr_sec) {
 342     int fd;
 343     struct asec_superblock buffer;
 344
 345     if ((fd = open(loopDevice, O_RDONLY | O_CLOEXEC)) < 0) {
 346         SLOGE("Failed to open loopdevice (%s)", strerror(errno));
 347         destroyByDevice(loopDevice);
 348         return -1;
 349     }
 350
 351     get_blkdev_size(fd, nr_sec);
 352     if (*nr_sec == 0) {
 353         SLOGE("Failed to get loop size (%s)", strerror(errno));
 354         destroyByDevice(loopDevice);
 355         close(fd);
 356         return -1;
 357     }
 358
 359     /*
 360      * Try to read superblock.
 361      */
 362     memset(&buffer, 0, sizeof(struct asec_superblock));
 363     if (lseek(fd, ((*nr_sec - 1) * 512), SEEK_SET) < 0) {
 364         SLOGE("lseek failed (%s)", strerror(errno));
 365         close(fd);
 366         destroyByDevice(loopDevice);
 367         return -1;
 368     }
 369     if (read(fd, &buffer, sizeof(struct asec_superblock)) != sizeof(struct asec_superblock)) {
 370         SLOGE("superblock read failed (%s)", strerror(errno));
 371         close(fd);
 372         destroyByDevice(loopDevice);
 373         return -1;
 374     }
 375     close(fd);
 376
 377     /*
 378      * Superblock successfully read. Copy to caller's struct.
 379      */
 380     memcpy(sb, &buffer, sizeof(struct asec_superblock));
 381     return 0;
 382 }