device.c 31.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Dynamic devices support
 *
 * Copyright 2006 Alexandre Julliard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "config.h"
#include "wine/port.h"

#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/time.h>

30
#include "mountmgr.h"
31 32 33 34 35 36
#include "winreg.h"
#include "winuser.h"
#include "dbt.h"

#include "wine/library.h"
#include "wine/list.h"
37
#include "wine/unicode.h"
38 39
#include "wine/debug.h"

40
WINE_DEFAULT_DEBUG_CHANNEL(mountmgr);
41

42 43
#define MAX_DOS_DRIVES 26

44 45
static const WCHAR drive_types[][8] =
{
46 47 48 49 50 51 52
    { 0 },                           /* DEVICE_UNKNOWN */
    { 0 },                           /* DEVICE_HARDDISK */
    {'h','d',0},                     /* DEVICE_HARDDISK_VOL */
    {'f','l','o','p','p','y',0},     /* DEVICE_FLOPPY */
    {'c','d','r','o','m',0},         /* DEVICE_CDROM */
    {'n','e','t','w','o','r','k',0}, /* DEVICE_NETWORK */
    {'r','a','m','d','i','s','k',0}  /* DEVICE_RAMDISK */
53 54
};

55 56 57
static const WCHAR drives_keyW[] = {'S','o','f','t','w','a','r','e','\\',
                                    'W','i','n','e','\\','D','r','i','v','e','s',0};

58
struct disk_device
59
{
60
    enum device_type      type;        /* drive type */
61
    DEVICE_OBJECT        *dev_obj;     /* disk device allocated for this volume */
62
    UNICODE_STRING        name;        /* device name */
63
    UNICODE_STRING        symlink;     /* device symlink if any */
64
    STORAGE_DEVICE_NUMBER devnum;      /* device number info */
65
    char                 *unix_device; /* unix device path */
66
    char                 *unix_mount;  /* unix mount point path */
67 68
};

69 70 71 72 73
struct volume
{
    struct list           entry;       /* entry in volumes list */
    struct disk_device   *device;      /* disk device */
    char                 *udi;         /* unique identifier for dynamic volumes */
74
    unsigned int          ref;         /* ref count */
75
    GUID                  guid;        /* volume uuid */
76 77 78
    struct mount_point   *mount;       /* Volume{xxx} mount point */
};

79 80 81
struct dos_drive
{
    struct list           entry;       /* entry in drives list */
82
    struct volume        *volume;      /* volume for this drive */
83
    int                   drive;       /* drive letter (0 = A: etc.) */
84
    struct mount_point   *mount;       /* DosDevices mount point */
85 86
};

87
static struct list drives_list = LIST_INIT(drives_list);
88
static struct list volumes_list = LIST_INIT(volumes_list);
89

90 91
static DRIVER_OBJECT *harddisk_driver;

92 93 94 95 96 97 98 99 100
static CRITICAL_SECTION device_section;
static CRITICAL_SECTION_DEBUG critsect_debug =
{
    0, 0, &device_section,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": device_section") }
};
static CRITICAL_SECTION device_section = { &critsect_debug, -1, 0, 0, 0, 0 };

101
static char *get_dosdevices_path( char **drive )
102 103 104 105 106 107 108 109
{
    const char *config_dir = wine_get_config_dir();
    size_t len = strlen(config_dir) + sizeof("/dosdevices/a::");
    char *path = HeapAlloc( GetProcessHeap(), 0, len );
    if (path)
    {
        strcpy( path, config_dir );
        strcat( path, "/dosdevices/a::" );
110
        *drive = path + len - 4;
111 112 113 114
    }
    return path;
}

115 116 117 118 119 120 121 122 123
static char *strdupA( const char *str )
{
    char *ret;

    if (!str) return NULL;
    if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, strlen(str) + 1 ))) strcpy( ret, str );
    return ret;
}

124 125 126 127 128 129 130 131
static const GUID *get_default_uuid( int letter )
{
    static GUID guid;

    guid.Data4[7] = 'A' + letter;
    return &guid;
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/* read a Unix symlink; returned buffer must be freed by caller */
static char *read_symlink( const char *path )
{
    char *buffer;
    int ret, size = 128;

    for (;;)
    {
        if (!(buffer = RtlAllocateHeap( GetProcessHeap(), 0, size )))
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            return 0;
        }
        ret = readlink( path, buffer, size );
        if (ret == -1)
        {
            RtlFreeHeap( GetProcessHeap(), 0, buffer );
            return 0;
        }
        if (ret != size)
        {
            buffer[ret] = 0;
            return buffer;
        }
        RtlFreeHeap( GetProcessHeap(), 0, buffer );
        size *= 2;
    }
}

161 162 163 164 165 166 167 168 169 170 171 172 173 174
/* update a symlink if it changed; return TRUE if updated */
static void update_symlink( const char *path, const char *dest, const char *orig_dest )
{
    if (dest && dest[0])
    {
        if (!orig_dest || strcmp( orig_dest, dest ))
        {
            unlink( path );
            symlink( dest, path );
        }
    }
    else unlink( path );
}

175 176 177 178 179 180 181 182 183 184
/* send notification about a change to a given drive */
static void send_notify( int drive, int code )
{
    DEV_BROADCAST_VOLUME info;

    info.dbcv_size       = sizeof(info);
    info.dbcv_devicetype = DBT_DEVTYP_VOLUME;
    info.dbcv_reserved   = 0;
    info.dbcv_unitmask   = 1 << drive;
    info.dbcv_flags      = DBTF_MEDIA;
185 186
    BroadcastSystemMessageW( BSF_FORCEIFHUNG|BSF_QUERY, NULL,
                             WM_DEVICECHANGE, code, (LPARAM)&info );
187 188
}

189 190
/* create the disk device for a given volume */
static NTSTATUS create_disk_device( enum device_type type, struct disk_device **device_ret )
191
{
192 193 194
    static const WCHAR harddiskvolW[] = {'\\','D','e','v','i','c','e',
                                         '\\','H','a','r','d','d','i','s','k','V','o','l','u','m','e','%','u',0};
    static const WCHAR harddiskW[] = {'\\','D','e','v','i','c','e','\\','H','a','r','d','d','i','s','k','%','u',0};
195 196
    static const WCHAR cdromW[] = {'\\','D','e','v','i','c','e','\\','C','d','R','o','m','%','u',0};
    static const WCHAR floppyW[] = {'\\','D','e','v','i','c','e','\\','F','l','o','p','p','y','%','u',0};
197
    static const WCHAR ramdiskW[] = {'\\','D','e','v','i','c','e','\\','R','a','m','d','i','s','k','%','u',0};
198
    static const WCHAR physdriveW[] = {'\\','?','?','\\','P','h','y','s','i','c','a','l','D','r','i','v','e','%','u',0};
199 200 201

    UINT i, first = 0;
    NTSTATUS status = 0;
202
    const WCHAR *format = NULL;
203
    UNICODE_STRING name;
204
    DEVICE_OBJECT *dev_obj;
205
    struct disk_device *device;
206 207 208

    switch(type)
    {
209 210 211 212 213 214 215 216 217 218
    case DEVICE_UNKNOWN:
    case DEVICE_HARDDISK:
    case DEVICE_NETWORK:  /* FIXME */
        format = harddiskW;
        break;
    case DEVICE_HARDDISK_VOL:
        format = harddiskvolW;
        first = 1;  /* harddisk volumes start counting from 1 */
        break;
    case DEVICE_FLOPPY:
219 220
        format = floppyW;
        break;
221
    case DEVICE_CDROM:
222
    case DEVICE_DVD:
223 224
        format = cdromW;
        break;
225 226
    case DEVICE_RAMDISK:
        format = ramdiskW;
227 228 229 230 231 232 233 234 235
        break;
    }

    name.MaximumLength = (strlenW(format) + 10) * sizeof(WCHAR);
    name.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, name.MaximumLength );
    for (i = first; i < 32; i++)
    {
        sprintfW( name.Buffer, format, i );
        name.Length = strlenW(name.Buffer) * sizeof(WCHAR);
236
        status = IoCreateDevice( harddisk_driver, sizeof(*device), &name, 0, 0, FALSE, &dev_obj );
237 238 239 240
        if (status != STATUS_OBJECT_NAME_COLLISION) break;
    }
    if (!status)
    {
241 242 243 244 245 246 247 248
        device = dev_obj->DeviceExtension;
        device->dev_obj        = dev_obj;
        device->name           = name;
        device->type           = type;
        device->unix_device    = NULL;
        device->unix_mount     = NULL;
        device->symlink.Buffer = NULL;

249
        switch (type)
250
        {
251 252
        case DEVICE_FLOPPY:
        case DEVICE_RAMDISK:
253 254 255
            device->devnum.DeviceType = FILE_DEVICE_DISK;
            device->devnum.DeviceNumber = i;
            device->devnum.PartitionNumber = ~0u;
256
            break;
257
        case DEVICE_CDROM:
258 259 260
            device->devnum.DeviceType = FILE_DEVICE_CD_ROM;
            device->devnum.DeviceNumber = i;
            device->devnum.PartitionNumber = ~0u;
261
            break;
262 263 264 265 266
        case DEVICE_DVD:
            device->devnum.DeviceType = FILE_DEVICE_DVD;
            device->devnum.DeviceNumber = i;
            device->devnum.PartitionNumber = ~0u;
            break;
267 268 269
        case DEVICE_UNKNOWN:
        case DEVICE_HARDDISK:
        case DEVICE_NETWORK:  /* FIXME */
270
            {
271 272 273 274 275 276 277
                UNICODE_STRING symlink;

                symlink.MaximumLength = sizeof(physdriveW) + 10 * sizeof(WCHAR);
                if ((symlink.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, symlink.MaximumLength)))
                {
                    sprintfW( symlink.Buffer, physdriveW, i );
                    symlink.Length = strlenW(symlink.Buffer) * sizeof(WCHAR);
278
                    if (!IoCreateSymbolicLink( &symlink, &name )) device->symlink = symlink;
279
                }
280 281 282
                device->devnum.DeviceType = FILE_DEVICE_DISK;
                device->devnum.DeviceNumber = i;
                device->devnum.PartitionNumber = 0;
283
            }
284 285
            break;
        case DEVICE_HARDDISK_VOL:
286 287 288
            device->devnum.DeviceType = FILE_DEVICE_DISK;
            device->devnum.DeviceNumber = 0;
            device->devnum.PartitionNumber = i;
289 290
            break;
        }
291
        *device_ret = device;
292
        TRACE( "created device %s\n", debugstr_w(name.Buffer) );
293 294 295 296 297 298 299 300 301
    }
    else
    {
        FIXME( "IoCreateDevice %s got %x\n", debugstr_w(name.Buffer), status );
        RtlFreeUnicodeString( &name );
    }
    return status;
}

302
/* delete the disk device for a given drive */
303 304 305 306 307 308 309 310 311 312 313 314 315 316
static void delete_disk_device( struct disk_device *device )
{
    TRACE( "deleting device %s\n", debugstr_w(device->name.Buffer) );
    if (device->symlink.Buffer)
    {
        IoDeleteSymbolicLink( &device->symlink );
        RtlFreeUnicodeString( &device->symlink );
    }
    RtlFreeHeap( GetProcessHeap(), 0, device->unix_device );
    RtlFreeHeap( GetProcessHeap(), 0, device->unix_mount );
    RtlFreeUnicodeString( &device->name );
    IoDeleteDevice( device->dev_obj );
}

317
/* grab another reference to a volume */
318
static struct volume *grab_volume( struct volume *volume )
319
{
320 321
    volume->ref++;
    return volume;
322 323 324 325 326 327 328 329 330
}

/* release a volume and delete the corresponding disk device when refcount is 0 */
static unsigned int release_volume( struct volume *volume )
{
    unsigned int ret = --volume->ref;

    if (!ret)
    {
331
        TRACE( "%s udi %s\n", debugstr_guid(&volume->guid), debugstr_a(volume->udi) );
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
        assert( !volume->udi );
        list_remove( &volume->entry );
        if (volume->mount) delete_mount_point( volume->mount );
        delete_disk_device( volume->device );
        RtlFreeHeap( GetProcessHeap(), 0, volume );
    }
    return ret;
}

/* set the volume udi */
static void set_volume_udi( struct volume *volume, const char *udi )
{
    if (udi)
    {
        assert( !volume->udi );
        /* having a udi means the HAL side holds an extra reference */
        if ((volume->udi = strdupA( udi ))) grab_volume( volume );
    }
    else if (volume->udi)
    {
        RtlFreeHeap( GetProcessHeap(), 0, volume->udi );
        volume->udi = NULL;
        release_volume( volume );
    }
}

358 359 360 361 362 363 364 365 366 367 368
/* create a disk volume */
static NTSTATUS create_volume( const char *udi, enum device_type type, struct volume **volume_ret )
{
    struct volume *volume;
    NTSTATUS status;

    if (!(volume = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*volume) )))
        return STATUS_NO_MEMORY;

    if (!(status = create_disk_device( type, &volume->device )))
    {
369
        if (udi) set_volume_udi( volume, udi );
370
        list_add_tail( &volumes_list, &volume->entry );
371
        *volume_ret = grab_volume( volume );
372
    }
373
    else RtlFreeHeap( GetProcessHeap(), 0, volume );
374

375
    return status;
376 377
}

378
/* create the disk device for a given volume */
379 380
static NTSTATUS create_dos_device( struct volume *volume, const char *udi, int letter,
                                   enum device_type type, struct dos_drive **drive_ret )
381 382 383 384 385
{
    struct dos_drive *drive;
    NTSTATUS status;

    if (!(drive = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*drive) ))) return STATUS_NO_MEMORY;
386
    drive->drive = letter;
387
    drive->mount = NULL;
388

389 390 391
    if (volume)
    {
        if (udi) set_volume_udi( volume, udi );
392
        drive->volume = grab_volume( volume );
393 394 395 396 397
        status = STATUS_SUCCESS;
    }
    else status = create_volume( udi, type, &drive->volume );

    if (status == STATUS_SUCCESS)
398 399 400 401
    {
        list_add_tail( &drives_list, &drive->entry );
        *drive_ret = drive;
    }
402 403
    else RtlFreeHeap( GetProcessHeap(), 0, drive );

404 405 406 407 408
    return status;
}

/* delete the disk device for a given drive */
static void delete_dos_device( struct dos_drive *drive )
409 410
{
    list_remove( &drive->entry );
411
    if (drive->mount) delete_mount_point( drive->mount );
412
    release_volume( drive->volume );
413
    RtlFreeHeap( GetProcessHeap(), 0, drive );
414 415
}

416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
/* find a volume that matches the parameters */
static struct volume *find_matching_volume( const char *udi, const char *device,
                                            const char *mount_point, enum device_type type )
{
    struct volume *volume;
    struct disk_device *disk_device;

    LIST_FOR_EACH_ENTRY( volume, &volumes_list, struct volume, entry )
    {
        /* when we have a udi we only match drives added manually */
        if (udi && volume->udi) continue;
        /* and when we don't have a udi we only match dynamic drives */
        if (!udi && !volume->udi) continue;

        disk_device = volume->device;
        if (disk_device->type != type) continue;
        if (device && disk_device->unix_device && strcmp( device, disk_device->unix_device )) continue;
        if (mount_point && disk_device->unix_mount && strcmp( mount_point, disk_device->unix_mount )) continue;
        TRACE( "found matching volume %s for device %s mount %s type %u\n",
               debugstr_guid(&volume->guid), debugstr_a(device), debugstr_a(mount_point), type );
436
        return grab_volume( volume );
437 438 439 440
    }
    return NULL;
}

441
/* change the information for an existing volume */
442 443
static NTSTATUS set_volume_info( struct volume *volume, struct dos_drive *drive, const char *device,
                                 const char *mount_point, enum device_type type, const GUID *guid )
444
{
445 446
    void *id = NULL;
    unsigned int id_len = 0;
447 448 449 450 451 452 453 454 455 456 457
    struct disk_device *disk_device = volume->device;
    NTSTATUS status;

    if (type != disk_device->type)
    {
        if ((status = create_disk_device( type, &disk_device ))) return status;
        if (volume->mount)
        {
            delete_mount_point( volume->mount );
            volume->mount = NULL;
        }
458 459 460 461 462
        if (drive && drive->mount)
        {
            delete_mount_point( drive->mount );
            drive->mount = NULL;
        }
463 464 465 466 467 468 469 470 471 472 473
        delete_disk_device( volume->device );
        volume->device = disk_device;
    }
    else
    {
        RtlFreeHeap( GetProcessHeap(), 0, disk_device->unix_device );
        RtlFreeHeap( GetProcessHeap(), 0, disk_device->unix_mount );
    }
    disk_device->unix_device = strdupA( device );
    disk_device->unix_mount = strdupA( mount_point );

474
    if (guid && memcmp( &volume->guid, guid, sizeof(volume->guid) ))
475 476 477 478 479 480 481 482 483 484 485
    {
        volume->guid = *guid;
        if (volume->mount)
        {
            delete_mount_point( volume->mount );
            volume->mount = NULL;
        }
    }

    if (!volume->mount)
        volume->mount = add_volume_mount_point( disk_device->dev_obj, &disk_device->name, &volume->guid );
486 487
    if (drive && !drive->mount)
        drive->mount = add_dosdev_mount_point( disk_device->dev_obj, &disk_device->name, drive->drive );
488

489
    if (disk_device->unix_mount)
490
    {
491 492
        id = disk_device->unix_mount;
        id_len = strlen( disk_device->unix_mount ) + 1;
493
    }
494 495 496
    if (volume->mount) set_mount_point_id( volume->mount, id, id_len );
    if (drive && drive->mount) set_mount_point_id( drive->mount, id, id_len );

497 498 499
    return STATUS_SUCCESS;
}

500 501
/* change the drive letter or volume for an existing drive */
static void set_drive_info( struct dos_drive *drive, int letter, struct volume *volume )
502
{
503 504 505 506 507 508 509 510 511 512 513 514 515 516
    if (drive->drive != letter)
    {
        if (drive->mount) delete_mount_point( drive->mount );
        drive->mount = NULL;
        drive->drive = letter;
    }
    if (drive->volume != volume)
    {
        if (drive->mount) delete_mount_point( drive->mount );
        drive->mount = NULL;
        grab_volume( volume );
        release_volume( drive->volume );
        drive->volume = volume;
    }
517
}
518

519 520 521 522 523 524 525 526 527 528
static inline int is_valid_device( struct stat *st )
{
#if defined(linux) || defined(__sun__)
    return S_ISBLK( st->st_mode );
#else
    /* disks are char devices on *BSD */
    return S_ISCHR( st->st_mode );
#endif
}

529
/* find or create a DOS drive for the corresponding device */
530
static int add_drive( const char *device, enum device_type type )
531 532 533 534 535 536
{
    char *path, *p;
    char in_use[26];
    struct stat dev_st, drive_st;
    int drive, first, last, avail = 0;

537
    if (stat( device, &dev_st ) == -1 || !is_valid_device( &dev_st )) return -1;
538

539
    if (!(path = get_dosdevices_path( &p ))) return -1;
540 541 542

    memset( in_use, 0, sizeof(in_use) );

543
    switch (type)
544
    {
545
    case DEVICE_FLOPPY:
546 547
        first = 0;
        last = 2;
548 549
        break;
    case DEVICE_CDROM:
550
    case DEVICE_DVD:
551 552 553 554 555 556 557
        first = 3;
        last = 26;
        break;
    default:
        first = 2;
        last = 26;
        break;
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
    }

    while (avail != -1)
    {
        avail = -1;
        for (drive = first; drive < last; drive++)
        {
            if (in_use[drive]) continue;  /* already checked */
            *p = 'a' + drive;
            if (stat( path, &drive_st ) == -1)
            {
                if (lstat( path, &drive_st ) == -1 && errno == ENOENT)  /* this is a candidate */
                {
                    if (avail == -1)
                    {
                        p[2] = 0;
                        /* if mount point symlink doesn't exist either, it's available */
                        if (lstat( path, &drive_st ) == -1 && errno == ENOENT) avail = drive;
                        p[2] = ':';
                    }
                }
                else in_use[drive] = 1;
            }
            else
            {
                in_use[drive] = 1;
584
                if (!is_valid_device( &drive_st )) continue;
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
                if (dev_st.st_rdev == drive_st.st_rdev) goto done;
            }
        }
        if (avail != -1)
        {
            /* try to use the one we found */
            drive = avail;
            *p = 'a' + drive;
            if (symlink( device, path ) != -1) goto done;
            /* failed, retry the search */
        }
    }
    drive = -1;

done:
    HeapFree( GetProcessHeap(), 0, path );
    return drive;
}

604 605
/* create devices for mapped drives */
static void create_drive_devices(void)
606
{
607
    char *path, *p, *link, *device;
608
    struct dos_drive *drive;
609
    struct volume *volume;
610
    unsigned int i;
611
    HKEY drives_key;
612
    enum device_type drive_type;
613
    WCHAR driveW[] = {'a',':',0};
614

615
    if (!(path = get_dosdevices_path( &p ))) return;
616
    if (RegOpenKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &drives_key )) drives_key = 0;
617

618 619 620 621 622
    for (i = 0; i < MAX_DOS_DRIVES; i++)
    {
        p[0] = 'a' + i;
        p[2] = 0;
        if (!(link = read_symlink( path ))) continue;
623 624
        p[2] = ':';
        device = read_symlink( path );
625

626
        drive_type = i < 2 ? DEVICE_FLOPPY : DEVICE_HARDDISK_VOL;
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
        if (drives_key)
        {
            WCHAR buffer[32];
            DWORD j, type, size = sizeof(buffer);

            driveW[0] = 'a' + i;
            if (!RegQueryValueExW( drives_key, driveW, NULL, &type, (BYTE *)buffer, &size ) &&
                type == REG_SZ)
            {
                for (j = 0; j < sizeof(drive_types)/sizeof(drive_types[0]); j++)
                    if (drive_types[j][0] && !strcmpiW( buffer, drive_types[j] ))
                    {
                        drive_type = j;
                        break;
                    }
642
                if (drive_type == DEVICE_FLOPPY && i >= 2) drive_type = DEVICE_HARDDISK;
643 644 645
            }
        }

646 647
        volume = find_matching_volume( NULL, device, link, drive_type );
        if (!create_dos_device( volume, NULL, i, drive_type, &drive ))
648
        {
649 650 651
            /* don't reset uuid if we used an existing volume */
            const GUID *guid = volume ? NULL : get_default_uuid(i);
            set_volume_info( drive->volume, drive, device, link, drive_type, guid );
652
        }
653 654 655 656 657
        else
        {
            RtlFreeHeap( GetProcessHeap(), 0, link );
            RtlFreeHeap( GetProcessHeap(), 0, device );
        }
658
        if (volume) release_volume( volume );
659
    }
660
    RegCloseKey( drives_key );
661
    RtlFreeHeap( GetProcessHeap(), 0, path );
662 663
}

664 665 666 667 668
/* create a new disk volume */
NTSTATUS add_volume( const char *udi, const char *device, const char *mount_point,
                     enum device_type type, const GUID *guid )
{
    struct volume *volume;
669
    NTSTATUS status = STATUS_SUCCESS;
670 671 672 673

    TRACE( "adding %s device %s mount %s type %u uuid %s\n", debugstr_a(udi),
           debugstr_a(device), debugstr_a(mount_point), type, debugstr_guid(guid) );

674
    EnterCriticalSection( &device_section );
675
    LIST_FOR_EACH_ENTRY( volume, &volumes_list, struct volume, entry )
676 677 678 679 680
        if (volume->udi && !strcmp( udi, volume->udi ))
        {
            grab_volume( volume );
            goto found;
        }
681

682
    /* udi not found, search for a non-dynamic volume */
683 684
    if ((volume = find_matching_volume( udi, device, mount_point, type ))) set_volume_udi( volume, udi );
    else status = create_volume( udi, type, &volume );
685 686

found:
687
    if (!status) status = set_volume_info( volume, NULL, device, mount_point, type, guid );
688
    if (volume) release_volume( volume );
689 690
    LeaveCriticalSection( &device_section );
    return status;
691 692 693 694 695
}

/* create a new disk volume */
NTSTATUS remove_volume( const char *udi )
{
696
    NTSTATUS status = STATUS_NO_SUCH_DEVICE;
697 698
    struct volume *volume;

699
    EnterCriticalSection( &device_section );
700 701 702
    LIST_FOR_EACH_ENTRY( volume, &volumes_list, struct volume, entry )
    {
        if (!volume->udi || strcmp( udi, volume->udi )) continue;
703
        set_volume_udi( volume, NULL );
704 705
        status = STATUS_SUCCESS;
        break;
706
    }
707 708
    LeaveCriticalSection( &device_section );
    return status;
709 710 711
}


712 713
/* create a new dos drive */
NTSTATUS add_dos_device( int letter, const char *udi, const char *device,
714
                         const char *mount_point, enum device_type type, const GUID *guid )
715
{
716
    char *path, *p;
717
    HKEY hkey;
718
    NTSTATUS status = STATUS_SUCCESS;
719
    struct dos_drive *drive, *next;
720 721
    struct volume *volume;
    int notify = -1;
722

723 724
    if (!(path = get_dosdevices_path( &p ))) return STATUS_NO_MEMORY;

725 726 727
    EnterCriticalSection( &device_section );
    volume = find_matching_volume( udi, device, mount_point, type );

728 729 730
    if (letter == -1)  /* auto-assign a letter */
    {
        letter = add_drive( device, type );
731 732 733 734 735
        if (letter == -1)
        {
            status = STATUS_OBJECT_NAME_COLLISION;
            goto done;
        }
736 737 738 739 740 741

        LIST_FOR_EACH_ENTRY_SAFE( drive, next, &drives_list, struct dos_drive, entry )
        {
            if (drive->volume->udi && !strcmp( udi, drive->volume->udi )) goto found;
            if (drive->drive == letter) delete_dos_device( drive );
        }
742 743 744
    }
    else  /* simply reset the device symlink */
    {
745
        LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
746 747 748 749 750
            if (drive->drive == letter) break;

        *p = 'a' + letter;
        if (&drive->entry == &drives_list) update_symlink( path, device, NULL );
        else
751
        {
752
            update_symlink( path, device, drive->volume->device->unix_device );
753
            delete_dos_device( drive );
754
        }
755
    }
756

757
    if ((status = create_dos_device( volume, udi, letter, type, &drive ))) goto done;
758 759

found:
760
    if (!guid && !volume) guid = get_default_uuid( letter );
761
    if (!volume) volume = grab_volume( drive->volume );
762
    set_drive_info( drive, letter, volume );
763 764
    p[0] = 'a' + drive->drive;
    p[2] = 0;
765 766
    update_symlink( path, mount_point, volume->device->unix_mount );
    set_volume_info( volume, drive, device, mount_point, type, guid );
767

768 769 770 771 772 773
    TRACE( "added device %c: udi %s for %s on %s type %u\n",
           'a' + drive->drive, wine_dbgstr_a(udi), wine_dbgstr_a(device),
           wine_dbgstr_a(mount_point), type );

    /* hack: force the drive type in the registry */
    if (!RegCreateKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey ))
774
    {
775 776 777 778 779 780 781 782 783 784 785 786
        const WCHAR *type_name = drive_types[type];
        WCHAR name[3] = {'a',':',0};

        name[0] += drive->drive;
        if (!type_name[0] && type == DEVICE_HARDDISK) type_name = drive_types[DEVICE_FLOPPY];
        if (type_name[0])
            RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)type_name,
                            (strlenW(type_name) + 1) * sizeof(WCHAR) );
        else
            RegDeleteValueW( hkey, name );
        RegCloseKey( hkey );
    }
787

788
    if (udi) notify = drive->drive;
789

790
done:
791
    if (volume) release_volume( volume );
792
    LeaveCriticalSection( &device_section );
793
    RtlFreeHeap( GetProcessHeap(), 0, path );
794
    if (notify != -1) send_notify( notify, DBT_DEVICEARRIVAL );
795
    return status;
796 797
}

798 799
/* remove an existing dos drive, by letter or udi */
NTSTATUS remove_dos_device( int letter, const char *udi )
800
{
801
    NTSTATUS status = STATUS_NO_SUCH_DEVICE;
802 803
    HKEY hkey;
    struct dos_drive *drive;
804
    char *path, *p;
805
    int notify = -1;
806

807
    EnterCriticalSection( &device_section );
808 809
    LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
    {
810 811
        if (udi)
        {
812 813
            if (!drive->volume->udi) continue;
            if (strcmp( udi, drive->volume->udi )) continue;
814
            set_volume_udi( drive->volume, NULL );
815
        }
816
        else if (drive->drive != letter) continue;
817

818
        if ((path = get_dosdevices_path( &p )))
819
        {
820 821 822 823 824
            p[0] = 'a' + drive->drive;
            p[2] = 0;
            unlink( path );
            RtlFreeHeap( GetProcessHeap(), 0, path );
        }
825

826 827 828 829 830 831 832
        /* clear the registry key too */
        if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, drives_keyW, &hkey ))
        {
            WCHAR name[3] = {'a',':',0};
            name[0] += drive->drive;
            RegDeleteValueW( hkey, name );
            RegCloseKey( hkey );
833
        }
834

835
        if (udi && drive->volume->device->unix_mount) notify = drive->drive;
836

837
        delete_dos_device( drive );
838 839
        status = STATUS_SUCCESS;
        break;
840
    }
841 842 843
    LeaveCriticalSection( &device_section );
    if (notify != -1) send_notify( notify, DBT_DEVICEREMOVECOMPLETE );
    return status;
844
}
845

846
/* query information about an existing dos drive, by letter or udi */
847
NTSTATUS query_dos_device( int letter, enum device_type *type, char **device, char **mount_point )
848
{
849
    NTSTATUS status = STATUS_NO_SUCH_DEVICE;
850
    struct dos_drive *drive;
851
    struct disk_device *disk_device;
852

853
    EnterCriticalSection( &device_section );
854 855 856
    LIST_FOR_EACH_ENTRY( drive, &drives_list, struct dos_drive, entry )
    {
        if (drive->drive != letter) continue;
857
        disk_device = drive->volume->device;
858
        if (type) *type = disk_device->type;
859 860
        if (device) *device = strdupA( disk_device->unix_device );
        if (mount_point) *mount_point = strdupA( disk_device->unix_mount );
861 862
        status = STATUS_SUCCESS;
        break;
863
    }
864 865
    LeaveCriticalSection( &device_section );
    return status;
866 867
}

868 869 870
/* handler for ioctls on the harddisk device */
static NTSTATUS WINAPI harddisk_ioctl( DEVICE_OBJECT *device, IRP *irp )
{
871
    IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
872
    struct disk_device *dev = device->DeviceExtension;
873 874 875 876 877 878

    TRACE( "ioctl %x insize %u outsize %u\n",
           irpsp->Parameters.DeviceIoControl.IoControlCode,
           irpsp->Parameters.DeviceIoControl.InputBufferLength,
           irpsp->Parameters.DeviceIoControl.OutputBufferLength );

879 880
    EnterCriticalSection( &device_section );

881 882 883 884 885 886 887 888
    switch(irpsp->Parameters.DeviceIoControl.IoControlCode)
    {
    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
    {
        DISK_GEOMETRY info;
        DWORD len = min( sizeof(info), irpsp->Parameters.DeviceIoControl.OutputBufferLength );

        info.Cylinders.QuadPart = 10000;
889
        info.MediaType = (dev->devnum.DeviceType == FILE_DEVICE_DISK) ? FixedMedia : RemovableMedia;
890 891 892 893 894 895 896 897
        info.TracksPerCylinder = 255;
        info.SectorsPerTrack = 63;
        info.BytesPerSector = 512;
        memcpy( irp->MdlAddress->StartVa, &info, len );
        irp->IoStatus.Information = len;
        irp->IoStatus.u.Status = STATUS_SUCCESS;
        break;
    }
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
    case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
    {
        DISK_GEOMETRY_EX info;
        DWORD len = min( sizeof(info), irpsp->Parameters.DeviceIoControl.OutputBufferLength );

        FIXME("The DISK_PARTITION_INFO and DISK_DETECTION_INFO structures will not be filled\n");

        info.Geometry.Cylinders.QuadPart = 10000;
        info.Geometry.MediaType = (dev->devnum.DeviceType == FILE_DEVICE_DISK) ? FixedMedia : RemovableMedia;
        info.Geometry.TracksPerCylinder = 255;
        info.Geometry.SectorsPerTrack = 63;
        info.Geometry.BytesPerSector = 512;
        info.DiskSize.QuadPart = info.Geometry.Cylinders.QuadPart * info.Geometry.TracksPerCylinder *
                                 info.Geometry.SectorsPerTrack * info.Geometry.BytesPerSector;
        info.Data[0]  = 0;
        memcpy( irp->MdlAddress->StartVa, &info, len );
        irp->IoStatus.Information = len;
        irp->IoStatus.u.Status = STATUS_SUCCESS;
        break;
    }
918 919
    case IOCTL_STORAGE_GET_DEVICE_NUMBER:
    {
920
        DWORD len = min( sizeof(dev->devnum), irpsp->Parameters.DeviceIoControl.OutputBufferLength );
921

922
        memcpy( irp->MdlAddress->StartVa, &dev->devnum, len );
923 924 925 926 927 928 929
        irp->IoStatus.Information = len;
        irp->IoStatus.u.Status = STATUS_SUCCESS;
        break;
    }
    case IOCTL_CDROM_READ_TOC:
        irp->IoStatus.u.Status = STATUS_INVALID_DEVICE_REQUEST;
        break;
930
    case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:
931 932 933
    {
        DWORD len = min( 32, irpsp->Parameters.DeviceIoControl.OutputBufferLength );

934
        FIXME( "returning zero-filled buffer for IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS\n" );
935 936 937 938 939
        memset( irp->MdlAddress->StartVa, 0, len );
        irp->IoStatus.Information = len;
        irp->IoStatus.u.Status = STATUS_SUCCESS;
        break;
    }
940 941 942 943 944
    default:
        FIXME( "unsupported ioctl %x\n", irpsp->Parameters.DeviceIoControl.IoControlCode );
        irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
        break;
    }
945 946

    LeaveCriticalSection( &device_section );
947
    IoCompleteRequest( irp, IO_NO_INCREMENT );
948 949 950 951 952 953
    return irp->IoStatus.u.Status;
}

/* driver entry point for the harddisk driver */
NTSTATUS WINAPI harddisk_driver_entry( DRIVER_OBJECT *driver, UNICODE_STRING *path )
{
954
    struct disk_device *device;
955

956
    harddisk_driver = driver;
957 958
    driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = harddisk_ioctl;

959
    /* create a harddisk0 device that isn't assigned to any drive */
960
    create_disk_device( DEVICE_HARDDISK, &device );
961 962

    create_drive_devices();
963

964
    return STATUS_SUCCESS;
965
}