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