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 <string.h>
20 #include <errno.h>
21 #include <fnmatch.h>
22 
23 #include <linux/kdev_t.h>
24 
25 #define LOG_TAG "DirectVolume"
26 
27 #include <cutils/log.h>
28 #include <sysutils/NetlinkEvent.h>
29 
30 #include "DirectVolume.h"
31 #include "VolumeManager.h"
32 #include "ResponseCode.h"
33 #include "cryptfs.h"
34 
35 // #define PARTITION_DEBUG
36 
PathInfo(const char * p)37 PathInfo::PathInfo(const char *p)
38 {
39     warned = false;
40     pattern = strdup(p);
41 
42     if (!strchr(pattern, '*')) {
43         patternType = prefix;
44     } else {
45         patternType = wildcard;
46     }
47 }
48 
~PathInfo()49 PathInfo::~PathInfo()
50 {
51     free(pattern);
52 }
53 
match(const char * path)54 bool PathInfo::match(const char *path)
55 {
56     switch (patternType) {
57     case prefix:
58     {
59         bool ret = (strncmp(path, pattern, strlen(pattern)) == 0);
60         if (!warned && ret && (strlen(pattern) != strlen(path))) {
61             SLOGW("Deprecated implied prefix pattern detected, please use '%s*' instead", pattern);
62             warned = true;
63         }
64         return ret;
65     }
66     case wildcard:
67         return fnmatch(pattern, path, 0) == 0;
68     }
69     SLOGE("Bad matching type");
70     return false;
71 }
72 
DirectVolume(VolumeManager * vm,const fstab_rec * rec,int flags)73 DirectVolume::DirectVolume(VolumeManager *vm, const fstab_rec* rec, int flags) :
74         Volume(vm, rec, flags) {
75     mPaths = new PathCollection();
76     for (int i = 0; i < MAX_PARTITIONS; i++)
77         mPartMinors[i] = -1;
78     mPendingPartCount = 0;
79     mDiskMajor = -1;
80     mDiskMinor = -1;
81     mDiskNumParts = 0;
82     mIsDecrypted = 0;
83 
84     if (strcmp(rec->mount_point, "auto") != 0) {
85         ALOGE("Vold managed volumes must have auto mount point; ignoring %s",
86               rec->mount_point);
87     }
88 
89     char mount[PATH_MAX];
90 
91     snprintf(mount, PATH_MAX, "%s/%s", Volume::MEDIA_DIR, rec->label);
92     mMountpoint = strdup(mount);
93     snprintf(mount, PATH_MAX, "%s/%s", Volume::FUSE_DIR, rec->label);
94     mFuseMountpoint = strdup(mount);
95 
96     setState(Volume::State_NoMedia);
97 }
98 
~DirectVolume()99 DirectVolume::~DirectVolume() {
100     PathCollection::iterator it;
101 
102     for (it = mPaths->begin(); it != mPaths->end(); ++it)
103         delete *it;
104     delete mPaths;
105 }
106 
addPath(const char * path)107 int DirectVolume::addPath(const char *path) {
108     mPaths->push_back(new PathInfo(path));
109     return 0;
110 }
111 
getDiskDevice()112 dev_t DirectVolume::getDiskDevice() {
113     return MKDEV(mDiskMajor, mDiskMinor);
114 }
115 
getShareDevice()116 dev_t DirectVolume::getShareDevice() {
117     if (mPartIdx != -1) {
118         return MKDEV(mDiskMajor, mPartIdx);
119     } else {
120         return MKDEV(mDiskMajor, mDiskMinor);
121     }
122 }
123 
handleVolumeShared()124 void DirectVolume::handleVolumeShared() {
125     setState(Volume::State_Shared);
126 }
127 
handleVolumeUnshared()128 void DirectVolume::handleVolumeUnshared() {
129     setState(Volume::State_Idle);
130 }
131 
handleBlockEvent(NetlinkEvent * evt)132 int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
133     const char *dp = evt->findParam("DEVPATH");
134 
135     PathCollection::iterator  it;
136     for (it = mPaths->begin(); it != mPaths->end(); ++it) {
137         if ((*it)->match(dp)) {
138             /* We can handle this disk */
139             int action = evt->getAction();
140             const char *devtype = evt->findParam("DEVTYPE");
141 
142             if (action == NetlinkEvent::NlActionAdd) {
143                 int major = atoi(evt->findParam("MAJOR"));
144                 int minor = atoi(evt->findParam("MINOR"));
145                 char nodepath[255];
146 
147                 snprintf(nodepath,
148                          sizeof(nodepath), "/dev/block/vold/%d:%d",
149                          major, minor);
150                 if (createDeviceNode(nodepath, major, minor)) {
151                     SLOGE("Error making device node '%s' (%s)", nodepath,
152                                                                strerror(errno));
153                 }
154                 if (!strcmp(devtype, "disk")) {
155                     handleDiskAdded(dp, evt);
156                 } else {
157                     handlePartitionAdded(dp, evt);
158                 }
159                 /* Send notification iff disk is ready (ie all partitions found) */
160                 if (getState() == Volume::State_Idle) {
161                     char msg[255];
162 
163                     snprintf(msg, sizeof(msg),
164                              "Volume %s %s disk inserted (%d:%d)", getLabel(),
165                              getFuseMountpoint(), mDiskMajor, mDiskMinor);
166                     mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,
167                                                          msg, false);
168                 }
169             } else if (action == NetlinkEvent::NlActionRemove) {
170                 if (!strcmp(devtype, "disk")) {
171                     handleDiskRemoved(dp, evt);
172                 } else {
173                     handlePartitionRemoved(dp, evt);
174                 }
175             } else if (action == NetlinkEvent::NlActionChange) {
176                 if (!strcmp(devtype, "disk")) {
177                     handleDiskChanged(dp, evt);
178                 } else {
179                     handlePartitionChanged(dp, evt);
180                 }
181             } else {
182                     SLOGW("Ignoring non add/remove/change event");
183             }
184 
185             return 0;
186         }
187     }
188     errno = ENODEV;
189     return -1;
190 }
191 
handleDiskAdded(const char *,NetlinkEvent * evt)192 void DirectVolume::handleDiskAdded(const char * /*devpath*/,
193                                    NetlinkEvent *evt) {
194     mDiskMajor = atoi(evt->findParam("MAJOR"));
195     mDiskMinor = atoi(evt->findParam("MINOR"));
196 
197     const char *tmp = evt->findParam("NPARTS");
198     if (tmp) {
199         mDiskNumParts = atoi(tmp);
200     } else {
201         SLOGW("Kernel block uevent missing 'NPARTS'");
202         mDiskNumParts = 1;
203     }
204 
205     mPendingPartCount = mDiskNumParts;
206     for (int i = 0; i < MAX_PARTITIONS; i++)
207         mPartMinors[i] = -1;
208 
209     if (mDiskNumParts == 0) {
210 #ifdef PARTITION_DEBUG
211         SLOGD("Dv::diskIns - No partitions - good to go son!");
212 #endif
213         setState(Volume::State_Idle);
214     } else {
215 #ifdef PARTITION_DEBUG
216         SLOGD("Dv::diskIns - waiting for %d pending partitions", mPendingPartCount);
217 #endif
218         setState(Volume::State_Pending);
219     }
220 }
221 
handlePartitionAdded(const char * devpath,NetlinkEvent * evt)222 void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) {
223     int major = atoi(evt->findParam("MAJOR"));
224     int minor = atoi(evt->findParam("MINOR"));
225 
226     int part_num;
227 
228     const char *tmp = evt->findParam("PARTN");
229 
230     if (tmp) {
231         part_num = atoi(tmp);
232     } else {
233         SLOGW("Kernel block uevent missing 'PARTN'");
234         part_num = 1;
235     }
236 
237     if (part_num > MAX_PARTITIONS || part_num < 1) {
238         SLOGE("Invalid 'PARTN' value");
239         return;
240     }
241 
242     if (part_num > mDiskNumParts) {
243         mDiskNumParts = part_num;
244     }
245 
246     if (major != mDiskMajor) {
247         SLOGE("Partition '%s' has a different major than its disk!", devpath);
248         return;
249     }
250 #ifdef PARTITION_DEBUG
251     SLOGD("Dv:partAdd: part_num = %d, minor = %d\n", part_num, minor);
252 #endif
253     if (part_num >= MAX_PARTITIONS) {
254         SLOGE("Dv:partAdd: ignoring part_num = %d (max: %d)\n", part_num, MAX_PARTITIONS-1);
255     } else {
256         if ((mPartMinors[part_num - 1] == -1) && mPendingPartCount)
257             mPendingPartCount--;
258         mPartMinors[part_num -1] = minor;
259     }
260 
261     if (!mPendingPartCount) {
262 #ifdef PARTITION_DEBUG
263         SLOGD("Dv:partAdd: Got all partitions - ready to rock!");
264 #endif
265         if (getState() != Volume::State_Formatting) {
266             setState(Volume::State_Idle);
267             if (mRetryMount == true) {
268                 mRetryMount = false;
269                 mountVol();
270             }
271         }
272     } else {
273 #ifdef PARTITION_DEBUG
274         SLOGD("Dv:partAdd: pending %d disk", mPendingPartCount);
275 #endif
276     }
277 }
278 
handleDiskChanged(const char *,NetlinkEvent * evt)279 void DirectVolume::handleDiskChanged(const char * /*devpath*/,
280                                      NetlinkEvent *evt) {
281     int major = atoi(evt->findParam("MAJOR"));
282     int minor = atoi(evt->findParam("MINOR"));
283 
284     if ((major != mDiskMajor) || (minor != mDiskMinor)) {
285         return;
286     }
287 
288     SLOGI("Volume %s disk has changed", getLabel());
289     const char *tmp = evt->findParam("NPARTS");
290     if (tmp) {
291         mDiskNumParts = atoi(tmp);
292     } else {
293         SLOGW("Kernel block uevent missing 'NPARTS'");
294         mDiskNumParts = 1;
295     }
296 
297     mPendingPartCount = mDiskNumParts;
298     for (int i = 0; i < MAX_PARTITIONS; i++)
299         mPartMinors[i] = -1;
300 
301     if (getState() != Volume::State_Formatting) {
302         if (mDiskNumParts == 0) {
303             setState(Volume::State_Idle);
304         } else {
305             setState(Volume::State_Pending);
306         }
307     }
308 }
309 
handlePartitionChanged(const char *,NetlinkEvent * evt)310 void DirectVolume::handlePartitionChanged(const char * /*devpath*/,
311                                           NetlinkEvent *evt) {
312     int major = atoi(evt->findParam("MAJOR"));
313     int minor = atoi(evt->findParam("MINOR"));
314     SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor);
315 }
316 
handleDiskRemoved(const char *,NetlinkEvent * evt)317 void DirectVolume::handleDiskRemoved(const char * /*devpath*/,
318                                      NetlinkEvent *evt) {
319     int major = atoi(evt->findParam("MAJOR"));
320     int minor = atoi(evt->findParam("MINOR"));
321     char msg[255];
322     bool enabled;
323 
324     if (mVm->shareEnabled(getLabel(), "ums", &enabled) == 0 && enabled) {
325         mVm->unshareVolume(getLabel(), "ums");
326     }
327 
328     SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
329     snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)",
330              getLabel(), getFuseMountpoint(), major, minor);
331     mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved,
332                                              msg, false);
333     setState(Volume::State_NoMedia);
334 }
335 
handlePartitionRemoved(const char *,NetlinkEvent * evt)336 void DirectVolume::handlePartitionRemoved(const char * /*devpath*/,
337                                           NetlinkEvent *evt) {
338     int major = atoi(evt->findParam("MAJOR"));
339     int minor = atoi(evt->findParam("MINOR"));
340     char msg[255];
341     int state;
342 
343     SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
344 
345     /*
346      * The framework doesn't need to get notified of
347      * partition removal unless it's mounted. Otherwise
348      * the removal notification will be sent on the Disk
349      * itself
350      */
351     state = getState();
352     if (state != Volume::State_Mounted && state != Volume::State_Shared) {
353         return;
354     }
355 
356     if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
357         /*
358          * Yikes, our mounted partition is going away!
359          */
360 
361         bool providesAsec = (getFlags() & VOL_PROVIDES_ASEC) != 0;
362         if (providesAsec && mVm->cleanupAsec(this, true)) {
363             SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
364         }
365 
366         snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
367                  getLabel(), getFuseMountpoint(), major, minor);
368         mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
369                                              msg, false);
370 
371         if (Volume::unmountVol(true, false)) {
372             SLOGE("Failed to unmount volume on bad removal (%s)",
373                  strerror(errno));
374             // XXX: At this point we're screwed for now
375         } else {
376             SLOGD("Crisis averted");
377         }
378     } else if (state == Volume::State_Shared) {
379         /* removed during mass storage */
380         snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)",
381                  getLabel(), major, minor);
382         mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
383                                              msg, false);
384 
385         if (mVm->unshareVolume(getLabel(), "ums")) {
386             SLOGE("Failed to unshare volume on bad removal (%s)",
387                 strerror(errno));
388         } else {
389             SLOGD("Crisis averted");
390         }
391     }
392 }
393 
394 /*
395  * Called from base to get a list of devicenodes for mounting
396  */
getDeviceNodes(dev_t * devs,int max)397 int DirectVolume::getDeviceNodes(dev_t *devs, int max) {
398 
399     if (mPartIdx == -1) {
400         // If the disk has no partitions, try the disk itself
401         if (!mDiskNumParts) {
402             devs[0] = MKDEV(mDiskMajor, mDiskMinor);
403             return 1;
404         }
405 
406         int i;
407         for (i = 0; i < mDiskNumParts; i++) {
408             if (i == max)
409                 break;
410             devs[i] = MKDEV(mDiskMajor, mPartMinors[i]);
411         }
412         return mDiskNumParts;
413     }
414     devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]);
415     return 1;
416 }
417 
418 /*
419  * Called from base to update device info,
420  * e.g. When setting up an dm-crypt mapping for the sd card.
421  */
updateDeviceInfo(char * new_path,int new_major,int new_minor)422 int DirectVolume::updateDeviceInfo(char *new_path, int new_major, int new_minor)
423 {
424     PathCollection::iterator it;
425 
426     if (mPartIdx == -1) {
427         SLOGE("Can only change device info on a partition\n");
428         return -1;
429     }
430 
431     /*
432      * This is to change the sysfs path associated with a partition, in particular,
433      * for an internal SD card partition that is encrypted.  Thus, the list is
434      * expected to be only 1 entry long.  Check that and bail if not.
435      */
436     if (mPaths->size() != 1) {
437         SLOGE("Cannot change path if there are more than one for a volume\n");
438         return -1;
439     }
440 
441     it = mPaths->begin();
442     delete *it; /* Free the string storage */
443     mPaths->erase(it); /* Remove it from the list */
444     addPath(new_path); /* Put the new path on the list */
445 
446     /* Save away original info so we can restore it when doing factory reset.
447      * Then, when doing the format, it will format the original device in the
448      * clear, otherwise it just formats the encrypted device which is not
449      * readable when the device boots unencrypted after the reset.
450      */
451     mOrigDiskMajor = mDiskMajor;
452     mOrigDiskMinor = mDiskMinor;
453     mOrigPartIdx = mPartIdx;
454     memcpy(mOrigPartMinors, mPartMinors, sizeof(mPartMinors));
455 
456     mDiskMajor = new_major;
457     mDiskMinor = new_minor;
458     /* Ugh, virual block devices don't use minor 0 for whole disk and minor > 0 for
459      * partition number.  They don't have partitions, they are just virtual block
460      * devices, and minor number 0 is the first dm-crypt device.  Luckily the first
461      * dm-crypt device is for the userdata partition, which gets minor number 0, and
462      * it is not managed by vold.  So the next device is minor number one, which we
463      * will call partition one.
464      */
465     mPartIdx = new_minor;
466     mPartMinors[new_minor-1] = new_minor;
467 
468     mIsDecrypted = 1;
469 
470     return 0;
471 }
472 
473 /*
474  * Called from base to revert device info to the way it was before a
475  * crypto mapping was created for it.
476  */
revertDeviceInfo(void)477 void DirectVolume::revertDeviceInfo(void)
478 {
479     if (mIsDecrypted) {
480         mDiskMajor = mOrigDiskMajor;
481         mDiskMinor = mOrigDiskMinor;
482         mPartIdx = mOrigPartIdx;
483         memcpy(mPartMinors, mOrigPartMinors, sizeof(mPartMinors));
484 
485         mIsDecrypted = 0;
486     }
487 
488     return;
489 }
490 
491 /*
492  * Called from base to give cryptfs all the info it needs to encrypt eligible volumes
493  */
getVolInfo(struct volume_info * v)494 int DirectVolume::getVolInfo(struct volume_info *v)
495 {
496     strcpy(v->label, mLabel);
497     strcpy(v->mnt_point, mMountpoint);
498     v->flags = getFlags();
499     /* Other fields of struct volume_info are filled in by the caller or cryptfs.c */
500 
501     return 0;
502 }
503