2 * Dynamic devices support
4 * Copyright 2006 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
35 #include "wine/library.h"
36 #include "wine/list.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(mountmgr
);
42 #define MAX_DOS_DRIVES 26
44 static const WCHAR drive_types
[][8] =
46 { 0 }, /* DEVICE_UNKNOWN */
47 { 0 }, /* DEVICE_HARDDISK */
48 {'h','d',0}, /* DEVICE_HARDDISK_VOL */
49 {'f','l','o','p','p','y',0}, /* DEVICE_FLOPPY */
50 {'c','d','r','o','m',0}, /* DEVICE_CDROM */
51 {'n','e','t','w','o','r','k',0}, /* DEVICE_NETWORK */
52 {'r','a','m','d','i','s','k',0} /* DEVICE_RAMDISK */
55 static const WCHAR drives_keyW
[] = {'S','o','f','t','w','a','r','e','\\',
56 'W','i','n','e','\\','D','r','i','v','e','s',0};
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 */
71 struct list entry
; /* entry in volumes list */
72 struct disk_device
*device
; /* disk device */
73 char *udi
; /* unique identifier for dynamic volumes */
74 unsigned int ref
; /* ref count */
75 GUID guid
; /* volume uuid */
76 struct mount_point
*mount
; /* Volume{xxx} mount point */
81 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 */
87 static struct list drives_list
= LIST_INIT(drives_list
);
88 static struct list volumes_list
= LIST_INIT(volumes_list
);
90 static DRIVER_OBJECT
*harddisk_driver
;
92 static CRITICAL_SECTION device_section
;
93 static CRITICAL_SECTION_DEBUG critsect_debug
=
95 0, 0, &device_section
,
96 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
97 0, 0, { (DWORD_PTR
)(__FILE__
": device_section") }
99 static CRITICAL_SECTION device_section
= { &critsect_debug
, -1, 0, 0, 0, 0 };
101 static char *get_dosdevices_path( char **drive
)
103 const char *config_dir
= wine_get_config_dir();
104 size_t len
= strlen(config_dir
) + sizeof("/dosdevices/a::");
105 char *path
= HeapAlloc( GetProcessHeap(), 0, len
);
108 strcpy( path
, config_dir
);
109 strcat( path
, "/dosdevices/a::" );
110 *drive
= path
+ len
- 4;
115 static char *strdupA( const char *str
)
119 if (!str
) return NULL
;
120 if ((ret
= RtlAllocateHeap( GetProcessHeap(), 0, strlen(str
) + 1 ))) strcpy( ret
, str
);
124 static const GUID
*get_default_uuid( int letter
)
128 guid
.Data4
[7] = 'A' + letter
;
132 /* read a Unix symlink; returned buffer must be freed by caller */
133 static char *read_symlink( const char *path
)
140 if (!(buffer
= RtlAllocateHeap( GetProcessHeap(), 0, size
)))
142 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
145 ret
= readlink( path
, buffer
, size
);
148 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
156 RtlFreeHeap( GetProcessHeap(), 0, buffer
);
161 /* update a symlink if it changed; return TRUE if updated */
162 static void update_symlink( const char *path
, const char *dest
, const char *orig_dest
)
166 if (!orig_dest
|| strcmp( orig_dest
, dest
))
169 symlink( dest
, path
);
175 /* send notification about a change to a given drive */
176 static void send_notify( int drive
, int code
)
178 DEV_BROADCAST_VOLUME info
;
180 info
.dbcv_size
= sizeof(info
);
181 info
.dbcv_devicetype
= DBT_DEVTYP_VOLUME
;
182 info
.dbcv_reserved
= 0;
183 info
.dbcv_unitmask
= 1 << drive
;
184 info
.dbcv_flags
= DBTF_MEDIA
;
185 BroadcastSystemMessageW( BSF_FORCEIFHUNG
|BSF_QUERY
, NULL
,
186 WM_DEVICECHANGE
, code
, (LPARAM
)&info
);
189 /* create the disk device for a given volume */
190 static NTSTATUS
create_disk_device( enum device_type type
, struct disk_device
**device_ret
)
192 static const WCHAR harddiskvolW
[] = {'\\','D','e','v','i','c','e',
193 '\\','H','a','r','d','d','i','s','k','V','o','l','u','m','e','%','u',0};
194 static const WCHAR harddiskW
[] = {'\\','D','e','v','i','c','e','\\','H','a','r','d','d','i','s','k','%','u',0};
195 static const WCHAR cdromW
[] = {'\\','D','e','v','i','c','e','\\','C','d','R','o','m','%','u',0};
196 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};
202 const WCHAR
*format
= NULL
;
204 DEVICE_OBJECT
*dev_obj
;
205 struct disk_device
*device
;
210 case DEVICE_HARDDISK
:
211 case DEVICE_NETWORK
: /* FIXME */
214 case DEVICE_HARDDISK_VOL
:
215 format
= harddiskvolW
;
216 first
= 1; /* harddisk volumes start counting from 1 */
230 name
.MaximumLength
= (strlenW(format
) + 10) * sizeof(WCHAR
);
231 name
.Buffer
= RtlAllocateHeap( GetProcessHeap(), 0, name
.MaximumLength
);
232 for (i
= first
; i
< 32; i
++)
234 sprintfW( name
.Buffer
, format
, i
);
235 name
.Length
= strlenW(name
.Buffer
) * sizeof(WCHAR
);
236 status
= IoCreateDevice( harddisk_driver
, sizeof(*device
), &name
, 0, 0, FALSE
, &dev_obj
);
237 if (status
!= STATUS_OBJECT_NAME_COLLISION
) break;
241 device
= dev_obj
->DeviceExtension
;
242 device
->dev_obj
= dev_obj
;
245 device
->unix_device
= NULL
;
246 device
->unix_mount
= NULL
;
247 device
->symlink
.Buffer
= NULL
;
253 device
->devnum
.DeviceType
= FILE_DEVICE_DISK
;
254 device
->devnum
.DeviceNumber
= i
;
255 device
->devnum
.PartitionNumber
= ~0u;
258 device
->devnum
.DeviceType
= FILE_DEVICE_CD_ROM
;
259 device
->devnum
.DeviceNumber
= i
;
260 device
->devnum
.PartitionNumber
= ~0u;
263 device
->devnum
.DeviceType
= FILE_DEVICE_DVD
;
264 device
->devnum
.DeviceNumber
= i
;
265 device
->devnum
.PartitionNumber
= ~0u;
268 case DEVICE_HARDDISK
:
269 case DEVICE_NETWORK
: /* FIXME */
271 UNICODE_STRING symlink
;
273 symlink
.MaximumLength
= sizeof(physdriveW
) + 10 * sizeof(WCHAR
);
274 if ((symlink
.Buffer
= RtlAllocateHeap( GetProcessHeap(), 0, symlink
.MaximumLength
)))
276 sprintfW( symlink
.Buffer
, physdriveW
, i
);
277 symlink
.Length
= strlenW(symlink
.Buffer
) * sizeof(WCHAR
);
278 if (!IoCreateSymbolicLink( &symlink
, &name
)) device
->symlink
= symlink
;
280 device
->devnum
.DeviceType
= FILE_DEVICE_DISK
;
281 device
->devnum
.DeviceNumber
= i
;
282 device
->devnum
.PartitionNumber
= 0;
285 case DEVICE_HARDDISK_VOL
:
286 device
->devnum
.DeviceType
= FILE_DEVICE_DISK
;
287 device
->devnum
.DeviceNumber
= 0;
288 device
->devnum
.PartitionNumber
= i
;
291 *device_ret
= device
;
292 TRACE( "created device %s\n", debugstr_w(name
.Buffer
) );
296 FIXME( "IoCreateDevice %s got %x\n", debugstr_w(name
.Buffer
), status
);
297 RtlFreeUnicodeString( &name
);
302 /* delete the disk device for a given drive */
303 static void delete_disk_device( struct disk_device
*device
)
305 TRACE( "deleting device %s\n", debugstr_w(device
->name
.Buffer
) );
306 if (device
->symlink
.Buffer
)
308 IoDeleteSymbolicLink( &device
->symlink
);
309 RtlFreeUnicodeString( &device
->symlink
);
311 RtlFreeHeap( GetProcessHeap(), 0, device
->unix_device
);
312 RtlFreeHeap( GetProcessHeap(), 0, device
->unix_mount
);
313 RtlFreeUnicodeString( &device
->name
);
314 IoDeleteDevice( device
->dev_obj
);
317 /* grab another reference to a volume */
318 static struct volume
*grab_volume( struct volume
*volume
)
324 /* release a volume and delete the corresponding disk device when refcount is 0 */
325 static unsigned int release_volume( struct volume
*volume
)
327 unsigned int ret
= --volume
->ref
;
331 TRACE( "%s udi %s\n", debugstr_guid(&volume
->guid
), debugstr_a(volume
->udi
) );
332 assert( !volume
->udi
);
333 list_remove( &volume
->entry
);
334 if (volume
->mount
) delete_mount_point( volume
->mount
);
335 delete_disk_device( volume
->device
);
336 RtlFreeHeap( GetProcessHeap(), 0, volume
);
341 /* set the volume udi */
342 static void set_volume_udi( struct volume
*volume
, const char *udi
)
346 assert( !volume
->udi
);
347 /* having a udi means the HAL side holds an extra reference */
348 if ((volume
->udi
= strdupA( udi
))) grab_volume( volume
);
350 else if (volume
->udi
)
352 RtlFreeHeap( GetProcessHeap(), 0, volume
->udi
);
354 release_volume( volume
);
358 /* create a disk volume */
359 static NTSTATUS
create_volume( const char *udi
, enum device_type type
, struct volume
**volume_ret
)
361 struct volume
*volume
;
364 if (!(volume
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*volume
) )))
365 return STATUS_NO_MEMORY
;
367 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
);
373 else RtlFreeHeap( GetProcessHeap(), 0, volume
);
378 /* create the disk device for a given volume */
379 static NTSTATUS
create_dos_device( struct volume
*volume
, const char *udi
, int letter
,
380 enum device_type type
, struct dos_drive
**drive_ret
)
382 struct dos_drive
*drive
;
385 if (!(drive
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*drive
) ))) return STATUS_NO_MEMORY
;
386 drive
->drive
= letter
;
391 if (udi
) set_volume_udi( volume
, udi
);
392 drive
->volume
= grab_volume( volume
);
393 status
= STATUS_SUCCESS
;
395 else status
= create_volume( udi
, type
, &drive
->volume
);
397 if (status
== STATUS_SUCCESS
)
399 list_add_tail( &drives_list
, &drive
->entry
);
402 else RtlFreeHeap( GetProcessHeap(), 0, drive
);
407 /* delete the disk device for a given drive */
408 static void delete_dos_device( struct dos_drive
*drive
)
410 list_remove( &drive
->entry
);
411 if (drive
->mount
) delete_mount_point( drive
->mount
);
412 release_volume( drive
->volume
);
413 RtlFreeHeap( GetProcessHeap(), 0, drive
);
416 /* find a volume that matches the parameters */
417 static struct volume
*find_matching_volume( const char *udi
, const char *device
,
418 const char *mount_point
, enum device_type type
)
420 struct volume
*volume
;
421 struct disk_device
*disk_device
;
423 LIST_FOR_EACH_ENTRY( volume
, &volumes_list
, struct volume
, entry
)
425 /* when we have a udi we only match drives added manually */
426 if (udi
&& volume
->udi
) continue;
427 /* and when we don't have a udi we only match dynamic drives */
428 if (!udi
&& !volume
->udi
) continue;
430 disk_device
= volume
->device
;
431 if (disk_device
->type
!= type
) continue;
432 if (device
&& disk_device
->unix_device
&& strcmp( device
, disk_device
->unix_device
)) continue;
433 if (mount_point
&& disk_device
->unix_mount
&& strcmp( mount_point
, disk_device
->unix_mount
)) continue;
434 TRACE( "found matching volume %s for device %s mount %s type %u\n",
435 debugstr_guid(&volume
->guid
), debugstr_a(device
), debugstr_a(mount_point
), type
);
436 return grab_volume( volume
);
441 /* change the information for an existing volume */
442 static NTSTATUS
set_volume_info( struct volume
*volume
, struct dos_drive
*drive
, const char *device
,
443 const char *mount_point
, enum device_type type
, const GUID
*guid
)
446 unsigned int id_len
= 0;
447 struct disk_device
*disk_device
= volume
->device
;
450 if (type
!= disk_device
->type
)
452 if ((status
= create_disk_device( type
, &disk_device
))) return status
;
455 delete_mount_point( volume
->mount
);
456 volume
->mount
= NULL
;
458 if (drive
&& drive
->mount
)
460 delete_mount_point( drive
->mount
);
463 delete_disk_device( volume
->device
);
464 volume
->device
= disk_device
;
468 RtlFreeHeap( GetProcessHeap(), 0, disk_device
->unix_device
);
469 RtlFreeHeap( GetProcessHeap(), 0, disk_device
->unix_mount
);
471 disk_device
->unix_device
= strdupA( device
);
472 disk_device
->unix_mount
= strdupA( mount_point
);
474 if (guid
&& memcmp( &volume
->guid
, guid
, sizeof(volume
->guid
) ))
476 volume
->guid
= *guid
;
479 delete_mount_point( volume
->mount
);
480 volume
->mount
= NULL
;
485 volume
->mount
= add_volume_mount_point( disk_device
->dev_obj
, &disk_device
->name
, &volume
->guid
);
486 if (drive
&& !drive
->mount
)
487 drive
->mount
= add_dosdev_mount_point( disk_device
->dev_obj
, &disk_device
->name
, drive
->drive
);
489 if (disk_device
->unix_mount
)
491 id
= disk_device
->unix_mount
;
492 id_len
= strlen( disk_device
->unix_mount
) + 1;
494 if (volume
->mount
) set_mount_point_id( volume
->mount
, id
, id_len
);
495 if (drive
&& drive
->mount
) set_mount_point_id( drive
->mount
, id
, id_len
);
497 return STATUS_SUCCESS
;
500 /* change the drive letter or volume for an existing drive */
501 static void set_drive_info( struct dos_drive
*drive
, int letter
, struct volume
*volume
)
503 if (drive
->drive
!= letter
)
505 if (drive
->mount
) delete_mount_point( drive
->mount
);
507 drive
->drive
= letter
;
509 if (drive
->volume
!= volume
)
511 if (drive
->mount
) delete_mount_point( drive
->mount
);
513 grab_volume( volume
);
514 release_volume( drive
->volume
);
515 drive
->volume
= volume
;
519 static inline int is_valid_device( struct stat
*st
)
521 #if defined(linux) || defined(__sun__)
522 return S_ISBLK( st
->st_mode
);
524 /* disks are char devices on *BSD */
525 return S_ISCHR( st
->st_mode
);
529 /* find or create a DOS drive for the corresponding device */
530 static int add_drive( const char *device
, enum device_type type
)
534 struct stat dev_st
, drive_st
;
535 int drive
, first
, last
, avail
= 0;
537 if (stat( device
, &dev_st
) == -1 || !is_valid_device( &dev_st
)) return -1;
539 if (!(path
= get_dosdevices_path( &p
))) return -1;
541 memset( in_use
, 0, sizeof(in_use
) );
563 for (drive
= first
; drive
< last
; drive
++)
565 if (in_use
[drive
]) continue; /* already checked */
567 if (stat( path
, &drive_st
) == -1)
569 if (lstat( path
, &drive_st
) == -1 && errno
== ENOENT
) /* this is a candidate */
574 /* if mount point symlink doesn't exist either, it's available */
575 if (lstat( path
, &drive_st
) == -1 && errno
== ENOENT
) avail
= drive
;
579 else in_use
[drive
] = 1;
584 if (!is_valid_device( &drive_st
)) continue;
585 if (dev_st
.st_rdev
== drive_st
.st_rdev
) goto done
;
590 /* try to use the one we found */
593 if (symlink( device
, path
) != -1) goto done
;
594 /* failed, retry the search */
600 HeapFree( GetProcessHeap(), 0, path
);
604 /* create devices for mapped drives */
605 static void create_drive_devices(void)
607 char *path
, *p
, *link
, *device
;
608 struct dos_drive
*drive
;
609 struct volume
*volume
;
612 enum device_type drive_type
;
613 WCHAR driveW
[] = {'a',':',0};
615 if (!(path
= get_dosdevices_path( &p
))) return;
616 if (RegOpenKeyW( HKEY_LOCAL_MACHINE
, drives_keyW
, &drives_key
)) drives_key
= 0;
618 for (i
= 0; i
< MAX_DOS_DRIVES
; i
++)
622 if (!(link
= read_symlink( path
))) continue;
624 device
= read_symlink( path
);
626 drive_type
= i
< 2 ? DEVICE_FLOPPY
: DEVICE_HARDDISK_VOL
;
630 DWORD j
, type
, size
= sizeof(buffer
);
633 if (!RegQueryValueExW( drives_key
, driveW
, NULL
, &type
, (BYTE
*)buffer
, &size
) &&
636 for (j
= 0; j
< sizeof(drive_types
)/sizeof(drive_types
[0]); j
++)
637 if (drive_types
[j
][0] && !strcmpiW( buffer
, drive_types
[j
] ))
642 if (drive_type
== DEVICE_FLOPPY
&& i
>= 2) drive_type
= DEVICE_HARDDISK
;
646 volume
= find_matching_volume( NULL
, device
, link
, drive_type
);
647 if (!create_dos_device( volume
, NULL
, i
, drive_type
, &drive
))
649 /* don't reset uuid if we used an existing volume */
650 const GUID
*guid
= volume
? NULL
: get_default_uuid(i
);
651 set_volume_info( drive
->volume
, drive
, device
, link
, drive_type
, guid
);
655 RtlFreeHeap( GetProcessHeap(), 0, link
);
656 RtlFreeHeap( GetProcessHeap(), 0, device
);
658 if (volume
) release_volume( volume
);
660 RegCloseKey( drives_key
);
661 RtlFreeHeap( GetProcessHeap(), 0, path
);
664 /* create a new disk volume */
665 NTSTATUS
add_volume( const char *udi
, const char *device
, const char *mount_point
,
666 enum device_type type
, const GUID
*guid
)
668 struct volume
*volume
;
669 NTSTATUS status
= STATUS_SUCCESS
;
671 TRACE( "adding %s device %s mount %s type %u uuid %s\n", debugstr_a(udi
),
672 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 if (volume
->udi
&& !strcmp( udi
, volume
->udi
))
678 grab_volume( volume
);
682 /* udi not found, search for a non-dynamic volume */
683 if ((volume
= find_matching_volume( udi
, device
, mount_point
, type
))) set_volume_udi( volume
, udi
);
684 else status
= create_volume( udi
, type
, &volume
);
687 if (!status
) status
= set_volume_info( volume
, NULL
, device
, mount_point
, type
, guid
);
688 if (volume
) release_volume( volume
);
689 LeaveCriticalSection( &device_section
);
693 /* create a new disk volume */
694 NTSTATUS
remove_volume( const char *udi
)
696 NTSTATUS status
= STATUS_NO_SUCH_DEVICE
;
697 struct volume
*volume
;
699 EnterCriticalSection( &device_section
);
700 LIST_FOR_EACH_ENTRY( volume
, &volumes_list
, struct volume
, entry
)
702 if (!volume
->udi
|| strcmp( udi
, volume
->udi
)) continue;
703 set_volume_udi( volume
, NULL
);
704 status
= STATUS_SUCCESS
;
707 LeaveCriticalSection( &device_section
);
712 /* create a new dos drive */
713 NTSTATUS
add_dos_device( int letter
, const char *udi
, const char *device
,
714 const char *mount_point
, enum device_type type
, const GUID
*guid
)
718 NTSTATUS status
= STATUS_SUCCESS
;
719 struct dos_drive
*drive
, *next
;
720 struct volume
*volume
;
723 if (!(path
= get_dosdevices_path( &p
))) return STATUS_NO_MEMORY
;
725 EnterCriticalSection( &device_section
);
726 volume
= find_matching_volume( udi
, device
, mount_point
, type
);
728 if (letter
== -1) /* auto-assign a letter */
730 letter
= add_drive( device
, type
);
733 status
= STATUS_OBJECT_NAME_COLLISION
;
737 LIST_FOR_EACH_ENTRY_SAFE( drive
, next
, &drives_list
, struct dos_drive
, entry
)
739 if (drive
->volume
->udi
&& !strcmp( udi
, drive
->volume
->udi
)) goto found
;
740 if (drive
->drive
== letter
) delete_dos_device( drive
);
743 else /* simply reset the device symlink */
745 LIST_FOR_EACH_ENTRY( drive
, &drives_list
, struct dos_drive
, entry
)
746 if (drive
->drive
== letter
) break;
749 if (&drive
->entry
== &drives_list
) update_symlink( path
, device
, NULL
);
752 update_symlink( path
, device
, drive
->volume
->device
->unix_device
);
753 delete_dos_device( drive
);
757 if ((status
= create_dos_device( volume
, udi
, letter
, type
, &drive
))) goto done
;
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 p
[0] = 'a' + drive
->drive
;
765 update_symlink( path
, mount_point
, volume
->device
->unix_mount
);
766 set_volume_info( volume
, drive
, device
, mount_point
, type
, guid
);
768 TRACE( "added device %c: udi %s for %s on %s type %u\n",
769 'a' + drive
->drive
, wine_dbgstr_a(udi
), wine_dbgstr_a(device
),
770 wine_dbgstr_a(mount_point
), type
);
772 /* hack: force the drive type in the registry */
773 if (!RegCreateKeyW( HKEY_LOCAL_MACHINE
, drives_keyW
, &hkey
))
775 const WCHAR
*type_name
= drive_types
[type
];
776 WCHAR name
[3] = {'a',':',0};
778 name
[0] += drive
->drive
;
779 if (!type_name
[0] && type
== DEVICE_HARDDISK
) type_name
= drive_types
[DEVICE_FLOPPY
];
781 RegSetValueExW( hkey
, name
, 0, REG_SZ
, (const BYTE
*)type_name
,
782 (strlenW(type_name
) + 1) * sizeof(WCHAR
) );
784 RegDeleteValueW( hkey
, name
);
788 if (udi
) notify
= drive
->drive
;
791 if (volume
) release_volume( volume
);
792 LeaveCriticalSection( &device_section
);
793 RtlFreeHeap( GetProcessHeap(), 0, path
);
794 if (notify
!= -1) send_notify( notify
, DBT_DEVICEARRIVAL
);
798 /* remove an existing dos drive, by letter or udi */
799 NTSTATUS
remove_dos_device( int letter
, const char *udi
)
801 NTSTATUS status
= STATUS_NO_SUCH_DEVICE
;
803 struct dos_drive
*drive
;
807 EnterCriticalSection( &device_section
);
808 LIST_FOR_EACH_ENTRY( drive
, &drives_list
, struct dos_drive
, entry
)
812 if (!drive
->volume
->udi
) continue;
813 if (strcmp( udi
, drive
->volume
->udi
)) continue;
814 set_volume_udi( drive
->volume
, NULL
);
816 else if (drive
->drive
!= letter
) continue;
818 if ((path
= get_dosdevices_path( &p
)))
820 p
[0] = 'a' + drive
->drive
;
823 RtlFreeHeap( GetProcessHeap(), 0, path
);
826 /* clear the registry key too */
827 if (!RegOpenKeyW( HKEY_LOCAL_MACHINE
, drives_keyW
, &hkey
))
829 WCHAR name
[3] = {'a',':',0};
830 name
[0] += drive
->drive
;
831 RegDeleteValueW( hkey
, name
);
835 if (udi
&& drive
->volume
->device
->unix_mount
) notify
= drive
->drive
;
837 delete_dos_device( drive
);
838 status
= STATUS_SUCCESS
;
841 LeaveCriticalSection( &device_section
);
842 if (notify
!= -1) send_notify( notify
, DBT_DEVICEREMOVECOMPLETE
);
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
)
849 NTSTATUS status
= STATUS_NO_SUCH_DEVICE
;
850 struct dos_drive
*drive
;
851 struct disk_device
*disk_device
;
853 EnterCriticalSection( &device_section
);
854 LIST_FOR_EACH_ENTRY( drive
, &drives_list
, struct dos_drive
, entry
)
856 if (drive
->drive
!= letter
) continue;
857 disk_device
= drive
->volume
->device
;
858 if (type
) *type
= disk_device
->type
;
859 if (device
) *device
= strdupA( disk_device
->unix_device
);
860 if (mount_point
) *mount_point
= strdupA( disk_device
->unix_mount
);
861 status
= STATUS_SUCCESS
;
864 LeaveCriticalSection( &device_section
);
868 /* handler for ioctls on the harddisk device */
869 static NTSTATUS WINAPI
harddisk_ioctl( DEVICE_OBJECT
*device
, IRP
*irp
)
871 IO_STACK_LOCATION
*irpsp
= IoGetCurrentIrpStackLocation( irp
);
872 struct disk_device
*dev
= device
->DeviceExtension
;
874 TRACE( "ioctl %x insize %u outsize %u\n",
875 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
,
876 irpsp
->Parameters
.DeviceIoControl
.InputBufferLength
,
877 irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
);
879 EnterCriticalSection( &device_section
);
881 switch(irpsp
->Parameters
.DeviceIoControl
.IoControlCode
)
883 case IOCTL_DISK_GET_DRIVE_GEOMETRY
:
886 DWORD len
= min( sizeof(info
), irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
);
888 info
.Cylinders
.QuadPart
= 10000;
889 info
.MediaType
= (dev
->devnum
.DeviceType
== FILE_DEVICE_DISK
) ? FixedMedia
: RemovableMedia
;
890 info
.TracksPerCylinder
= 255;
891 info
.SectorsPerTrack
= 63;
892 info
.BytesPerSector
= 512;
893 memcpy( irp
->MdlAddress
->StartVa
, &info
, len
);
894 irp
->IoStatus
.Information
= len
;
895 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
898 case IOCTL_STORAGE_GET_DEVICE_NUMBER
:
900 DWORD len
= min( sizeof(dev
->devnum
), irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
);
902 memcpy( irp
->MdlAddress
->StartVa
, &dev
->devnum
, len
);
903 irp
->IoStatus
.Information
= len
;
904 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
907 case IOCTL_CDROM_READ_TOC
:
908 irp
->IoStatus
.u
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
910 case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
:
912 DWORD len
= min( 32, irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
);
914 FIXME( "returning zero-filled buffer for IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS\n" );
915 memset( irp
->MdlAddress
->StartVa
, 0, len
);
916 irp
->IoStatus
.Information
= len
;
917 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
921 FIXME( "unsupported ioctl %x\n", irpsp
->Parameters
.DeviceIoControl
.IoControlCode
);
922 irp
->IoStatus
.u
.Status
= STATUS_NOT_SUPPORTED
;
926 LeaveCriticalSection( &device_section
);
927 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
928 return irp
->IoStatus
.u
.Status
;
931 /* driver entry point for the harddisk driver */
932 NTSTATUS WINAPI
harddisk_driver_entry( DRIVER_OBJECT
*driver
, UNICODE_STRING
*path
)
934 struct disk_device
*device
;
936 harddisk_driver
= driver
;
937 driver
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
] = harddisk_ioctl
;
939 /* create a harddisk0 device that isn't assigned to any drive */
940 create_disk_device( DEVICE_HARDDISK
, &device
);
942 create_drive_devices();
944 return STATUS_SUCCESS
;