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
33 // #define PARTITION_DEBUG
34
DirectVolume(VolumeManager * vm,const char * label,const char * mount_point,int partIdx)35 DirectVolume::DirectVolume(VolumeManager *vm, const char *label,
36 const char *mount_point, int partIdx) :
37 Volume(vm, label, mount_point) {
38 mPartIdx = partIdx;
39
40 mPaths = new PathCollection();
41 for (int i = 0; i < MAX_PARTITIONS; i++)
42 mPartMinors[i] = -1;
43 mPendingPartMap = 0;
44 mDiskMajor = -1;
45 mDiskMinor = -1;
46 mDiskNumParts = 0;
47
48 setState(Volume::State_NoMedia);
49 }
50
~DirectVolume()51 DirectVolume::~DirectVolume() {
52 PathCollection::iterator it;
53
54 for (it = mPaths->begin(); it != mPaths->end(); ++it)
55 free(*it);
56 delete mPaths;
57 }
58
addPath(const char * path)59 int DirectVolume::addPath(const char *path) {
60 mPaths->push_back(strdup(path));
61 return 0;
62 }
63
getDiskDevice()64 dev_t DirectVolume::getDiskDevice() {
65 return MKDEV(mDiskMajor, mDiskMinor);
66 }
67
getShareDevice()68 dev_t DirectVolume::getShareDevice() {
69 if (mPartIdx != -1) {
70 return MKDEV(mDiskMajor, mPartIdx);
71 } else {
72 return MKDEV(mDiskMajor, mDiskMinor);
73 }
74 }
75
handleVolumeShared()76 void DirectVolume::handleVolumeShared() {
77 setState(Volume::State_Shared);
78 }
79
handleVolumeUnshared()80 void DirectVolume::handleVolumeUnshared() {
81 setState(Volume::State_Idle);
82 }
83
handleBlockEvent(NetlinkEvent * evt)84 int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
85 const char *dp = evt->findParam("DEVPATH");
86
87 PathCollection::iterator it;
88 for (it = mPaths->begin(); it != mPaths->end(); ++it) {
89 if (!strncmp(dp, *it, strlen(*it))) {
90 /* We can handle this disk */
91 int action = evt->getAction();
92 const char *devtype = evt->findParam("DEVTYPE");
93
94 if (action == NetlinkEvent::NlActionAdd) {
95 int major = atoi(evt->findParam("MAJOR"));
96 int minor = atoi(evt->findParam("MINOR"));
97 char nodepath[255];
98
99 snprintf(nodepath,
100 sizeof(nodepath), "/dev/block/vold/%d:%d",
101 major, minor);
102 if (createDeviceNode(nodepath, major, minor)) {
103 SLOGE("Error making device node '%s' (%s)", nodepath,
104 strerror(errno));
105 }
106 if (!strcmp(devtype, "disk")) {
107 handleDiskAdded(dp, evt);
108 } else {
109 handlePartitionAdded(dp, evt);
110 }
111 } else if (action == NetlinkEvent::NlActionRemove) {
112 if (!strcmp(devtype, "disk")) {
113 handleDiskRemoved(dp, evt);
114 } else {
115 handlePartitionRemoved(dp, evt);
116 }
117 } else if (action == NetlinkEvent::NlActionChange) {
118 if (!strcmp(devtype, "disk")) {
119 handleDiskChanged(dp, evt);
120 } else {
121 handlePartitionChanged(dp, evt);
122 }
123 } else {
124 SLOGW("Ignoring non add/remove/change event");
125 }
126
127 return 0;
128 }
129 }
130 errno = ENODEV;
131 return -1;
132 }
133
handleDiskAdded(const char * devpath,NetlinkEvent * evt)134 void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {
135 mDiskMajor = atoi(evt->findParam("MAJOR"));
136 mDiskMinor = atoi(evt->findParam("MINOR"));
137
138 const char *tmp = evt->findParam("NPARTS");
139 if (tmp) {
140 mDiskNumParts = atoi(tmp);
141 } else {
142 SLOGW("Kernel block uevent missing 'NPARTS'");
143 mDiskNumParts = 1;
144 }
145
146 char msg[255];
147
148 int partmask = 0;
149 int i;
150 for (i = 1; i <= mDiskNumParts; i++) {
151 partmask |= (1 << i);
152 }
153 mPendingPartMap = partmask;
154
155 if (mDiskNumParts == 0) {
156 #ifdef PARTITION_DEBUG
157 SLOGD("Dv::diskIns - No partitions - good to go son!");
158 #endif
159 setState(Volume::State_Idle);
160 } else {
161 #ifdef PARTITION_DEBUG
162 SLOGD("Dv::diskIns - waiting for %d partitions (mask 0x%x)",
163 mDiskNumParts, mPendingPartMap);
164 #endif
165 setState(Volume::State_Pending);
166 }
167
168 snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",
169 getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);
170 mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,
171 msg, false);
172 }
173
handlePartitionAdded(const char * devpath,NetlinkEvent * evt)174 void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) {
175 int major = atoi(evt->findParam("MAJOR"));
176 int minor = atoi(evt->findParam("MINOR"));
177
178 int part_num;
179
180 const char *tmp = evt->findParam("PARTN");
181
182 if (tmp) {
183 part_num = atoi(tmp);
184 } else {
185 SLOGW("Kernel block uevent missing 'PARTN'");
186 part_num = 1;
187 }
188
189 if (part_num > MAX_PARTITIONS || part_num < 1) {
190 SLOGW("Invalid 'PARTN' value");
191 part_num = 1;
192 }
193
194 if (part_num > mDiskNumParts) {
195 mDiskNumParts = part_num;
196 }
197
198 if (major != mDiskMajor) {
199 SLOGE("Partition '%s' has a different major than its disk!", devpath);
200 return;
201 }
202 #ifdef PARTITION_DEBUG
203 SLOGD("Dv:partAdd: part_num = %d, minor = %d\n", part_num, minor);
204 #endif
205 mPartMinors[part_num -1] = minor;
206
207 mPendingPartMap &= ~(1 << part_num);
208 if (!mPendingPartMap) {
209 #ifdef PARTITION_DEBUG
210 SLOGD("Dv:partAdd: Got all partitions - ready to rock!");
211 #endif
212 if (getState() != Volume::State_Formatting) {
213 setState(Volume::State_Idle);
214 }
215 } else {
216 #ifdef PARTITION_DEBUG
217 SLOGD("Dv:partAdd: pending mask now = 0x%x", mPendingPartMap);
218 #endif
219 }
220 }
221
handleDiskChanged(const char * devpath,NetlinkEvent * evt)222 void DirectVolume::handleDiskChanged(const char *devpath, NetlinkEvent *evt) {
223 int major = atoi(evt->findParam("MAJOR"));
224 int minor = atoi(evt->findParam("MINOR"));
225
226 if ((major != mDiskMajor) || (minor != mDiskMinor)) {
227 return;
228 }
229
230 SLOGI("Volume %s disk has changed", getLabel());
231 const char *tmp = evt->findParam("NPARTS");
232 if (tmp) {
233 mDiskNumParts = atoi(tmp);
234 } else {
235 SLOGW("Kernel block uevent missing 'NPARTS'");
236 mDiskNumParts = 1;
237 }
238
239 int partmask = 0;
240 int i;
241 for (i = 1; i <= mDiskNumParts; i++) {
242 partmask |= (1 << i);
243 }
244 mPendingPartMap = partmask;
245
246 if (getState() != Volume::State_Formatting) {
247 if (mDiskNumParts == 0) {
248 setState(Volume::State_Idle);
249 } else {
250 setState(Volume::State_Pending);
251 }
252 }
253 }
254
handlePartitionChanged(const char * devpath,NetlinkEvent * evt)255 void DirectVolume::handlePartitionChanged(const char *devpath, NetlinkEvent *evt) {
256 int major = atoi(evt->findParam("MAJOR"));
257 int minor = atoi(evt->findParam("MINOR"));
258 SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor);
259 }
260
handleDiskRemoved(const char * devpath,NetlinkEvent * evt)261 void DirectVolume::handleDiskRemoved(const char *devpath, NetlinkEvent *evt) {
262 int major = atoi(evt->findParam("MAJOR"));
263 int minor = atoi(evt->findParam("MINOR"));
264 char msg[255];
265
266 SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
267 snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)",
268 getLabel(), getMountpoint(), major, minor);
269 mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved,
270 msg, false);
271 setState(Volume::State_NoMedia);
272 }
273
handlePartitionRemoved(const char * devpath,NetlinkEvent * evt)274 void DirectVolume::handlePartitionRemoved(const char *devpath, NetlinkEvent *evt) {
275 int major = atoi(evt->findParam("MAJOR"));
276 int minor = atoi(evt->findParam("MINOR"));
277 char msg[255];
278
279 SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
280
281 /*
282 * The framework doesn't need to get notified of
283 * partition removal unless it's mounted. Otherwise
284 * the removal notification will be sent on the Disk
285 * itself
286 */
287 if (getState() != Volume::State_Mounted) {
288 return;
289 }
290
291 if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
292 /*
293 * Yikes, our mounted partition is going away!
294 */
295
296 snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
297 getLabel(), getMountpoint(), major, minor);
298 mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
299 msg, false);
300
301 if (mVm->cleanupAsec(this, true)) {
302 SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
303 }
304
305 if (Volume::unmountVol(true)) {
306 SLOGE("Failed to unmount volume on bad removal (%s)",
307 strerror(errno));
308 // XXX: At this point we're screwed for now
309 } else {
310 SLOGD("Crisis averted");
311 }
312 }
313 }
314
315 /*
316 * Called from base to get a list of devicenodes for mounting
317 */
getDeviceNodes(dev_t * devs,int max)318 int DirectVolume::getDeviceNodes(dev_t *devs, int max) {
319
320 if (mPartIdx == -1) {
321 // If the disk has no partitions, try the disk itself
322 if (!mDiskNumParts) {
323 devs[0] = MKDEV(mDiskMajor, mDiskMinor);
324 return 1;
325 }
326
327 int i;
328 for (i = 0; i < mDiskNumParts; i++) {
329 if (i == max)
330 break;
331 devs[i] = MKDEV(mDiskMajor, mPartMinors[i]);
332 }
333 return mDiskNumParts;
334 }
335 devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]);
336 return 1;
337 }
338