src/system/kernel/disk_device_manager/KDiskDevice.cpp

   1 /*
   2  * Copyright 2006-2011, Axel Dörfler, axeld@pinc-software.de.
   3  * Copyright 2003-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7
   8 #include "KDiskDevice.h"
   9
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <stdio.h>
  13 #include <unistd.h>
  14
  15 #include <KernelExport.h>
  16 #include <Drivers.h>
  17
  18 #include "ddm_userland_interface.h"
  19 #include "KDiskDeviceUtils.h"
  20 #include "KPath.h"
  21 #include "UserDataWriter.h"
  22
  23
  24 // debugging
  25 //#define DBG(x)
  26 #define DBG(x) x
  27 #define OUT dprintf
  28
  29
  30 KDiskDevice::KDiskDevice(partition_id id)
  31         :
  32         KPartition(id),
  33         fDeviceData(),
  34         fFD(-1),
  35         fMediaStatus(B_ERROR)
  36 {
  37         rw_lock_init(&fLocker, "disk device");
  38
  39         Unset();
  40         fDevice = this;
  41         fPublishedName = (char*)"raw";
  42 }
  43
  44
  45 KDiskDevice::~KDiskDevice()
  46 {
  47         Unset();
  48 }
  49
  50
  51 status_t
  52 KDiskDevice::SetTo(const char* path)
  53 {
  54         // check initialization and parameter
  55         status_t error = InitCheck();
  56         if (error != B_OK)
  57                 return error;
  58         if (!path)
  59                 return B_BAD_VALUE;
  60         Unset();
  61         // set the path
  62         error = set_string(fDeviceData.path, path);
  63         if (error != B_OK)
  64                 return error;
  65         // open the device
  66         fFD = open(path, O_RDONLY);
  67         if (fFD < 0)
  68                 return errno;
  69         // get media status
  70         error = GetMediaStatus(&fMediaStatus);
  71         if (error != B_OK)
  72                 return error;
  73         if (fMediaStatus == B_DEV_MEDIA_CHANGED)
  74                 fMediaStatus = B_OK;
  75         // get device geometry
  76         if (fMediaStatus == B_OK) {
  77                 error = GetGeometry(&fDeviceData.geometry);
  78                 if (error != B_OK)
  79                         return error;
  80         } else {
  81                 // no media present: reset the geometry
  82                 _ResetGeometry();
  83         }
  84
  85         // set device flags
  86         _UpdateDeviceFlags();
  87         // update partition data
  88         _InitPartitionData();
  89         return B_OK;
  90 }
  91
  92
  93 void
  94 KDiskDevice::Unset()
  95 {
  96         if (fFD >= 0) {
  97                 close(fFD);
  98                 fFD = -1;
  99         }
 100         fMediaStatus = B_ERROR;
 101         fDeviceData.id = -1;
 102         fDeviceData.flags = 0;
 103         if (fDeviceData.path) {
 104                 free(fDeviceData.path);
 105                 fDeviceData.path = NULL;
 106         }
 107         _ResetGeometry();
 108 }
 109
 110
 111 status_t
 112 KDiskDevice::InitCheck() const
 113 {
 114         return B_OK;
 115 }
 116
 117
 118 bool
 119 KDiskDevice::ReadLock()
 120 {
 121         return rw_lock_read_lock(&fLocker) == B_OK;
 122 }
 123
 124
 125 void
 126 KDiskDevice::ReadUnlock()
 127 {
 128         rw_lock_read_unlock(&fLocker);
 129 }
 130
 131
 132 bool
 133 KDiskDevice::WriteLock()
 134 {
 135         return rw_lock_write_lock(&fLocker) == B_OK;
 136 }
 137
 138
 139 void
 140 KDiskDevice::WriteUnlock()
 141 {
 142         rw_lock_write_unlock(&fLocker);
 143 }
 144
 145
 146 void
 147 KDiskDevice::SetID(partition_id id)
 148 {
 149         KPartition::SetID(id);
 150         fDeviceData.id = id;
 151 }
 152
 153
 154 status_t
 155 KDiskDevice::PublishDevice()
 156 {
 157         // PublishDevice(), UnpublishDevice() and Republish are no-ops
 158         // for KDiskDevices, since they are always published.
 159         return B_OK;
 160 }
 161
 162
 163 status_t
 164 KDiskDevice::UnpublishDevice()
 165 {
 166         // PublishDevice(), UnpublishDevice() and Republish are no-ops
 167         // for KDiskDevices, since they are always published.
 168         return B_OK;
 169 }
 170
 171
 172 status_t
 173 KDiskDevice::RepublishDevice()
 174 {
 175         // PublishDevice(), UnpublishDevice() and Republish are no-ops
 176         // for KDiskDevices, since they are always published.
 177         return B_OK;
 178 }
 179
 180
 181 void
 182 KDiskDevice::SetDeviceFlags(uint32 flags)
 183 {
 184         fDeviceData.flags = flags;
 185 }
 186
 187
 188 uint32
 189 KDiskDevice::DeviceFlags() const
 190 {
 191         return fDeviceData.flags;
 192 }
 193
 194
 195 bool
 196 KDiskDevice::IsReadOnlyMedia() const
 197 {
 198         return fDeviceData.geometry.read_only;
 199 }
 200
 201
 202 bool
 203 KDiskDevice::IsWriteOnce() const
 204 {
 205         return fDeviceData.geometry.write_once;
 206 }
 207
 208
 209 bool
 210 KDiskDevice::IsRemovable() const
 211 {
 212         return fDeviceData.geometry.removable;
 213 }
 214
 215
 216 bool
 217 KDiskDevice::HasMedia() const
 218 {
 219         return fMediaStatus == B_OK || fMediaStatus == B_DEV_MEDIA_CHANGED;
 220 }
 221
 222
 223 bool
 224 KDiskDevice::MediaChanged() const
 225 {
 226         return fMediaStatus == B_DEV_MEDIA_CHANGED;
 227 }
 228
 229
 230 void
 231 KDiskDevice::UpdateMediaStatusIfNeeded()
 232 {
 233         // TODO: allow a device to notify us about its media status!
 234         // This will then also need to clear any B_DEV_MEDIA_CHANGED
 235         GetMediaStatus(&fMediaStatus);
 236 }
 237
 238
 239 void
 240 KDiskDevice::UninitializeMedia()
 241 {
 242         UninitializeContents();
 243         _ResetGeometry();
 244         _UpdateDeviceFlags();
 245         _InitPartitionData();
 246 }
 247
 248
 249 void
 250 KDiskDevice::UpdateGeometry()
 251 {
 252         if (GetGeometry(&fDeviceData.geometry) != B_OK)
 253                 return;
 254
 255         _UpdateDeviceFlags();
 256         _InitPartitionData();
 257 }
 258
 259
 260 status_t
 261 KDiskDevice::SetPath(const char* path)
 262 {
 263         return set_string(fDeviceData.path, path);
 264 }
 265
 266
 267 const char*
 268 KDiskDevice::Path() const
 269 {
 270         return fDeviceData.path;
 271 }
 272
 273
 274 status_t
 275 KDiskDevice::GetFileName(char* buffer, size_t size) const
 276 {
 277         if (strlcpy(buffer, "raw", size) >= size)
 278                 return B_NAME_TOO_LONG;
 279         return B_OK;
 280 }
 281
 282
 283 status_t
 284 KDiskDevice::GetPath(KPath* path) const
 285 {
 286         if (!path || path->InitCheck() != B_OK)
 287                 return B_BAD_VALUE;
 288         if (!fDeviceData.path)
 289                 return B_NO_INIT;
 290         return path->SetPath(fDeviceData.path);
 291 }
 292
 293
 294 void
 295 KDiskDevice::SetFD(int fd)
 296 {
 297         fFD = fd;
 298 }
 299
 300
 301 int
 302 KDiskDevice::FD() const
 303 {
 304         return fFD;
 305 }
 306
 307
 308 disk_device_data*
 309 KDiskDevice::DeviceData()
 310 {
 311         return &fDeviceData;
 312 }
 313
 314
 315 const disk_device_data*
 316 KDiskDevice::DeviceData() const
 317 {
 318         return &fDeviceData;
 319 }
 320
 321
 322 void
 323 KDiskDevice::WriteUserData(UserDataWriter& writer, user_partition_data* data)
 324 {
 325         return KPartition::WriteUserData(writer, data);
 326 }
 327
 328
 329 void
 330 KDiskDevice::WriteUserData(UserDataWriter& writer)
 331 {
 332         KPartition* partition = this;
 333         user_disk_device_data* data
 334                 = writer.AllocateDeviceData(partition->CountChildren());
 335         char* path = writer.PlaceString(Path());
 336         if (data != NULL) {
 337                 data->device_flags = DeviceFlags();
 338                 data->path = path;
 339                 writer.AddRelocationEntry(&data->path);
 340                 partition->WriteUserData(writer, &data->device_partition_data);
 341         } else
 342                 partition->WriteUserData(writer, NULL);
 343 }
 344
 345
 346 void
 347 KDiskDevice::Dump(bool deep, int32 level)
 348 {
 349         OUT("device %" B_PRId32 ": %s\n", ID(), Path());
 350         OUT("  media status:      %s\n", strerror(fMediaStatus));
 351         OUT("  device flags:      %" B_PRIx32 "\n", DeviceFlags());
 352         if (fMediaStatus == B_OK)
 353                 KPartition::Dump(deep, 0);
 354 }
 355
 356
 357 status_t
 358 KDiskDevice::GetMediaStatus(status_t* mediaStatus)
 359 {
 360         status_t error = B_OK;
 361         if (ioctl(fFD, B_GET_MEDIA_STATUS, mediaStatus) != 0)
 362                 error = errno;
 363         // maybe the device driver doesn't implement this ioctl -- see, if getting
 364         // the device geometry succeeds
 365         if (error != B_OK) {
 366                 device_geometry geometry;
 367                 if (GetGeometry(&geometry) == B_OK) {
 368                         // if the device is not removable, we can ignore the failed ioctl
 369                         // and return a media status of B_OK
 370                         if (!geometry.removable) {
 371                                 error = B_OK;
 372                                 *mediaStatus = B_OK;
 373                         }
 374                 }
 375         }
 376         return error;
 377 }
 378
 379
 380 status_t
 381 KDiskDevice::GetGeometry(device_geometry* geometry)
 382 {
 383         if (ioctl(fFD, B_GET_GEOMETRY, geometry) != 0)
 384                 return errno;
 385         return B_OK;
 386 }
 387
 388
 389 void
 390 KDiskDevice::_InitPartitionData()
 391 {
 392         fDeviceData.id = fPartitionData.id;
 393         fPartitionData.block_size = fDeviceData.geometry.bytes_per_sector;
 394         fPartitionData.offset = 0;
 395         fPartitionData.size = (off_t)fPartitionData.block_size
 396                 * fDeviceData.geometry.sectors_per_track
 397                 * fDeviceData.geometry.cylinder_count
 398                 * fDeviceData.geometry.head_count;
 399         fPartitionData.flags |= B_PARTITION_IS_DEVICE;
 400
 401         char name[B_FILE_NAME_LENGTH];
 402         if (ioctl(fFD, B_GET_DEVICE_NAME, name, sizeof(name)) == B_OK)
 403                 fPartitionData.name = strdup(name);
 404 }
 405
 406
 407 void
 408 KDiskDevice::_ResetGeometry()
 409 {
 410         fDeviceData.geometry.bytes_per_sector = 0;
 411         fDeviceData.geometry.sectors_per_track = 0;
 412         fDeviceData.geometry.cylinder_count = 0;
 413         fDeviceData.geometry.head_count = 0;
 414         fDeviceData.geometry.device_type = B_DISK;
 415         fDeviceData.geometry.removable = true;
 416         fDeviceData.geometry.read_only = true;
 417         fDeviceData.geometry.write_once = false;
 418 }
 419
 420
 421 void
 422 KDiskDevice::_UpdateDeviceFlags()
 423 {
 424         if (fDeviceData.geometry.removable)
 425                 SetDeviceFlags(DeviceFlags() | B_DISK_DEVICE_REMOVABLE);
 426         if (HasMedia())
 427                 SetDeviceFlags(DeviceFlags() | B_DISK_DEVICE_HAS_MEDIA);
 428         else
 429                 SetDeviceFlags(DeviceFlags() & ~B_DISK_DEVICE_HAS_MEDIA);
 430
 431         if (fDeviceData.geometry.read_only)
 432                 SetDeviceFlags(DeviceFlags() | B_DISK_DEVICE_READ_ONLY);
 433         if (fDeviceData.geometry.write_once)
 434                 SetDeviceFlags(DeviceFlags() | B_DISK_DEVICE_WRITE_ONCE);
 435 }