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
36DirectVolume::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
52DirectVolume::~DirectVolume() {
53    PathCollection::iterator it;
54
55    for (it = mPaths->begin(); it != mPaths->end(); ++it)
56        free(*it);
57    delete mPaths;
58}
59
60int DirectVolume::addPath(const char *path) {
61    mPaths->push_back(strdup(path));
62    return 0;
63}
64
65void DirectVolume::setFlags(int flags) {
66    mFlags = flags;
67}
68
69dev_t DirectVolume::getDiskDevice() {
70    return MKDEV(mDiskMajor, mDiskMinor);
71}
72
73dev_t DirectVolume::getShareDevice() {
74    if (mPartIdx != -1) {
75        return MKDEV(mDiskMajor, mPartIdx);
76    } else {
77        return MKDEV(mDiskMajor, mDiskMinor);
78    }
79}
80
81void DirectVolume::handleVolumeShared() {
82    setState(Volume::State_Shared);
83}
84
85void DirectVolume::handleVolumeUnshared() {
86    setState(Volume::State_Idle);
87}
88
89int 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
149void 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
182void 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
238void 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
271void 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
277void 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
295void 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 */
354int 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 */
379int 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 */
434void 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 */
451int 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