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