ReactOS 0.4.16-dev-1993-gbf8741d
Macros | Functions
list.c File Reference
#include "diskpart.h"
#include <debug.h>
Include dependency graph for list.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

static ULONGLONG GetFreeDiskSize (_In_ PDISKENTRY DiskEntry)
 
VOID PrintDisk (_In_ PDISKENTRY DiskEntry)
 
BOOL ListDisk (INT argc, PWSTR *argv)
 
BOOL ListPartition (INT argc, PWSTR *argv)
 
VOID PrintVolume (_In_ PVOLENTRY VolumeEntry)
 
BOOL ListVolume (INT argc, PWSTR *argv)
 
BOOL ListVirtualDisk (INT argc, PWSTR *argv)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 11 of file list.c.

Function Documentation

◆ GetFreeDiskSize()

static ULONGLONG GetFreeDiskSize ( _In_ PDISKENTRY  DiskEntry)
static

Definition at line 18 of file list.c.

20{
21 ULONGLONG SectorCount;
22 PLIST_ENTRY Entry;
23 PPARTENTRY PartEntry;
24
25 if (DiskEntry->PartitionStyle == PARTITION_STYLE_MBR)
26 {
27 SectorCount = DiskEntry->EndSector.QuadPart - DiskEntry->StartSector.QuadPart + 1;
28
29 Entry = DiskEntry->PrimaryPartListHead.Flink;
30 while (Entry != &DiskEntry->PrimaryPartListHead)
31 {
32 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
33
34 if ((PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED) &&
35 !IsContainerPartition(PartEntry->Mbr.PartitionType))
36 {
37 SectorCount -= PartEntry->SectorCount.QuadPart;
38 }
39
40 Entry = Entry->Flink;
41 }
42
43 Entry = DiskEntry->LogicalPartListHead.Flink;
44 while (Entry != &DiskEntry->LogicalPartListHead)
45 {
46 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
47
48 if (PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED)
49 {
50 SectorCount -= PartEntry->SectorCount.QuadPart;
51 }
52
53 Entry = Entry->Flink;
54 }
55 }
56 else if (DiskEntry->PartitionStyle == PARTITION_STYLE_GPT)
57 {
58 SectorCount = DiskEntry->EndSector.QuadPart - DiskEntry->StartSector.QuadPart + 1;
59
60 Entry = DiskEntry->PrimaryPartListHead.Flink;
61 while (Entry != &DiskEntry->PrimaryPartListHead)
62 {
63 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
64
65 if (!IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID))
66 {
67 SectorCount -= PartEntry->SectorCount.QuadPart;
68 }
69
70 Entry = Entry->Flink;
71 }
72 }
73 else
74 {
75 SectorCount = DiskEntry->SectorCount.QuadPart;
76 }
77
78 return SectorCount * DiskEntry->BytesPerSector;
79}
PARTITION_ENTRY_UNUSED
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:71
PARTITION_STYLE_GPT
@ PARTITION_STYLE_GPT
Definition: imports.h:202
PARTITION_STYLE_MBR
@ PARTITION_STYLE_MBR
Definition: imports.h:201
IsContainerPartition
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:321
SectorCount
ULONG SectorCount
Definition: part_xbox.c:31
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
Entry
base of all file and directory entries
Definition: entries.h:83
_GPT_PARTITION_DATA::PartitionType
GUID PartitionType
Definition: diskpart.h:112
_LIST_ENTRY
Definition: typedefs.h:120
_MBR_PARTITION_DATA::PartitionType
UCHAR PartitionType
Definition: diskpart.h:107
_PARTENTRY
Definition: partlist.h:62
_PARTENTRY::SectorCount
ULARGE_INTEGER SectorCount
Definition: partlist.h:70
_PARTENTRY::Mbr
MBR_PARTITION_DATA Mbr
Definition: diskpart.h:128
_PARTENTRY::Gpt
GPT_PARTITION_DATA Gpt
Definition: diskpart.h:129
_ULARGE_INTEGER::QuadPart
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by PrintDisk().

◆ ListDisk()

BOOL ListDisk ( INT  argc,
PWSTR *  argv 
)

Definition at line 152 of file list.c.

155{
156 PLIST_ENTRY Entry;
157 PDISKENTRY DiskEntry;
158
159 /* Header labels */
160 ConPuts(StdOut, L"\n");
161 ConResPuts(StdOut, IDS_LIST_DISK_HEAD);
162 ConResPuts(StdOut, IDS_LIST_DISK_LINE);
163
164 Entry = DiskListHead.Flink;
165 while (Entry != &DiskListHead)
166 {
167 DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
168
169 PrintDisk(DiskEntry);
170
171 Entry = Entry->Flink;
172 }
173
174 ConPuts(StdOut, L"\n\n");
175
176 return TRUE;
177}
ConPuts
void ConPuts(FILE *fp, LPCWSTR psz)
Definition: fc.c:16
StdOut
#define StdOut
Definition: fc.c:14
ConResPuts
void ConResPuts(FILE *fp, UINT nID)
Definition: fc.c:27
PrintDisk
VOID PrintDisk(_In_ PDISKENTRY DiskEntry)
Definition: list.c:83
IDS_LIST_DISK_LINE
#define IDS_LIST_DISK_LINE
Definition: resource.h:82
IDS_LIST_DISK_HEAD
#define IDS_LIST_DISK_HEAD
Definition: resource.h:81
DiskListHead
LIST_ENTRY DiskListHead
Definition: partlist.c:73
TRUE
#define TRUE
Definition: types.h:120
L
#define L(x)
Definition: resources.c:13
_DISKENTRY
Definition: partlist.h:100
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121

◆ ListPartition()

BOOL ListPartition ( INT  argc,
PWSTR *  argv 
)

Definition at line 181 of file list.c.

184{
185 PLIST_ENTRY Entry;
186 PPARTENTRY PartEntry;
187 ULONGLONG PartSize;
188 ULONGLONG PartOffset;
189 LPWSTR lpSizeUnit;
190 LPWSTR lpOffsetUnit;
191 ULONG PartNumber = 1;
192
193 if (CurrentDisk == NULL)
194 {
195 ConResPuts(StdOut, IDS_LIST_PARTITION_NO_DISK);
196 return TRUE;
197 }
198
199 /* Header labels */
200 ConPuts(StdOut, L"\n");
201 ConResPuts(StdOut, IDS_LIST_PARTITION_HEAD);
202 ConResPuts(StdOut, IDS_LIST_PARTITION_LINE);
203
204 if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
205 {
206 Entry = CurrentDisk->PrimaryPartListHead.Flink;
207 while (Entry != &CurrentDisk->PrimaryPartListHead)
208 {
209 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
210
211 if (PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED)
212 {
213 PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;
214
215 if (PartSize >= SIZE_10TB) /* 10 TB */
216 {
217 PartSize = RoundingDivide(PartSize, SIZE_1TB);
218 lpSizeUnit = L"TB";
219 }
220 else if (PartSize >= SIZE_10GB) /* 10 GB */
221 {
222 PartSize = RoundingDivide(PartSize, SIZE_1GB);
223 lpSizeUnit = L"GB";
224 }
225 else if (PartSize >= SIZE_10MB) /* 10 MB */
226 {
227 PartSize = RoundingDivide(PartSize, SIZE_1MB);
228 lpSizeUnit = L"MB";
229 }
230 else
231 {
232 PartSize = RoundingDivide(PartSize, SIZE_1KB);
233 lpSizeUnit = L"KB";
234 }
235
236 PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;
237
238 if (PartOffset >= SIZE_10TB) /* 10 TB */
239 {
240 PartOffset = RoundingDivide(PartOffset, SIZE_1TB);
241 lpOffsetUnit = L"TB";
242 }
243 else if (PartOffset >= SIZE_10GB) /* 10 GB */
244 {
245 PartOffset = RoundingDivide(PartOffset, SIZE_1GB);
246 lpOffsetUnit = L"GB";
247 }
248 else if (PartOffset >= SIZE_10MB) /* 10 MB */
249 {
250 PartOffset = RoundingDivide(PartOffset, SIZE_1MB);
251 lpOffsetUnit = L"MB";
252 }
253 else
254 {
255 PartOffset = RoundingDivide(PartOffset, SIZE_1KB);
256 lpOffsetUnit = L"KB";
257 }
258
259 ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
260 (CurrentPartition == PartEntry) ? L'*' : L' ',
261 PartNumber++,
262 IsContainerPartition(PartEntry->Mbr.PartitionType) ? L"Extended" : L"Primary",
263 PartSize,
264 lpSizeUnit,
265 PartOffset,
266 lpOffsetUnit);
267 }
268
269 Entry = Entry->Flink;
270 }
271
272 Entry = CurrentDisk->LogicalPartListHead.Flink;
273 while (Entry != &CurrentDisk->LogicalPartListHead)
274 {
275 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
276
277 if (PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED)
278 {
279 PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;
280
281 if (PartSize >= SIZE_10TB) /* 10 TB */
282 {
283 PartSize = RoundingDivide(PartSize, SIZE_1TB);
284 lpSizeUnit = L"TB";
285 }
286 else if (PartSize >= SIZE_10GB) /* 10 GB */
287 {
288 PartSize = RoundingDivide(PartSize, SIZE_1GB);
289 lpSizeUnit = L"GB";
290 }
291 else if (PartSize >= SIZE_10MB) /* 10 MB */
292 {
293 PartSize = RoundingDivide(PartSize, SIZE_1MB);
294 lpSizeUnit = L"MB";
295 }
296 else
297 {
298 PartSize = RoundingDivide(PartSize, SIZE_1KB);
299 lpSizeUnit = L"KB";
300 }
301
302 PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;
303
304 if (PartOffset >= SIZE_10TB) /* 10 TB */
305 {
306 PartOffset = RoundingDivide(PartOffset, SIZE_1TB);
307 lpOffsetUnit = L"TB";
308 }
309 else if (PartOffset >= SIZE_10GB) /* 10 GB */
310 {
311 PartOffset = RoundingDivide(PartOffset, SIZE_1GB);
312 lpOffsetUnit = L"GB";
313 }
314 else if (PartOffset >= SIZE_10MB) /* 10 MB */
315 {
316 PartOffset = RoundingDivide(PartOffset, SIZE_1MB);
317 lpOffsetUnit = L"MB";
318 }
319 else
320 {
321 PartOffset = RoundingDivide(PartOffset, SIZE_1KB);
322 lpOffsetUnit = L"KB";
323 }
324
325 ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
326 (CurrentPartition == PartEntry) ? L'*' : L' ',
327 PartNumber++,
328 L"Logical",
329 PartSize,
330 lpSizeUnit,
331 PartOffset,
332 lpOffsetUnit);
333 }
334
335 Entry = Entry->Flink;
336 }
337 }
338 else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
339 {
340 LPWSTR lpPartitionType;
341
342 Entry = CurrentDisk->PrimaryPartListHead.Flink;
343 while (Entry != &CurrentDisk->PrimaryPartListHead)
344 {
345 PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
346
347 if (!IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID))
348 {
349 PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;
350
351 if (PartSize >= SIZE_10TB) /* 10 TB */
352 {
353 PartSize = RoundingDivide(PartSize, SIZE_1TB);
354 lpSizeUnit = L"TB";
355 }
356 else if (PartSize >= SIZE_10GB) /* 10 GB */
357 {
358 PartSize = RoundingDivide(PartSize, SIZE_1GB);
359 lpSizeUnit = L"GB";
360 }
361 else if (PartSize >= SIZE_10MB) /* 10 MB */
362 {
363 PartSize = RoundingDivide(PartSize, SIZE_1MB);
364 lpSizeUnit = L"MB";
365 }
366 else
367 {
368 PartSize = RoundingDivide(PartSize, SIZE_1KB);
369 lpSizeUnit = L"KB";
370 }
371
372 PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;
373
374 if (PartOffset >= SIZE_10TB) /* 10 TB */
375 {
376 PartOffset = RoundingDivide(PartOffset, SIZE_1TB);
377 lpOffsetUnit = L"TB";
378 }
379 else if (PartOffset >= SIZE_10GB) /* 10 GB */
380 {
381 PartOffset = RoundingDivide(PartOffset, SIZE_1GB);
382 lpOffsetUnit = L"GB";
383 }
384 else if (PartOffset >= SIZE_10MB) /* 10 MB */
385 {
386 PartOffset = RoundingDivide(PartOffset, SIZE_1MB);
387 lpOffsetUnit = L"MB";
388 }
389 else
390 {
391 PartOffset = RoundingDivide(PartOffset, SIZE_1KB);
392 lpOffsetUnit = L"KB";
393 }
394
395 if (IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID))
396 {
397 lpPartitionType = L"Unused";
398 }
399 else if (IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_BASIC_DATA_GUID))
400 {
401 lpPartitionType = L"Primary";
402 }
403 else if (IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_SYSTEM_GUID))
404 {
405 lpPartitionType = L"System";
406 }
407 else if (IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_MSFT_RESERVED_GUID))
408 {
409 lpPartitionType = L"Reserved";
410 }
411 else
412 {
413 lpPartitionType = L"Other"; /* ??? */
414 }
415
416 ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
417 (CurrentPartition == PartEntry) ? L'*' : L' ',
418 PartNumber++,
419 lpPartitionType,
420 PartSize,
421 lpSizeUnit,
422 PartOffset,
423 lpOffsetUnit);
424 }
425
426 Entry = Entry->Flink;
427 }
428 }
429
430 ConPuts(StdOut, L"\n");
431
432 return TRUE;
433}
ConResPrintf
void ConResPrintf(FILE *fp, UINT nID,...)
Definition: fc.c:33
IDS_LIST_PARTITION_NO_DISK
#define IDS_LIST_PARTITION_NO_DISK
Definition: resource.h:87
IDS_LIST_PARTITION_HEAD
#define IDS_LIST_PARTITION_HEAD
Definition: resource.h:84
IDS_LIST_PARTITION_LINE
#define IDS_LIST_PARTITION_LINE
Definition: resource.h:85
IDS_LIST_PARTITION_FORMAT
#define IDS_LIST_PARTITION_FORMAT
Definition: resource.h:86
SIZE_10TB
#define SIZE_10TB
Definition: diskpart.h:241
SIZE_1TB
#define SIZE_1TB
Definition: diskpart.h:240
CurrentDisk
PDISKENTRY CurrentDisk
Definition: partlist.c:77
SIZE_10GB
#define SIZE_10GB
Definition: diskpart.h:239
SIZE_1KB
#define SIZE_1KB
Definition: diskpart.h:234
SIZE_1MB
#define SIZE_1MB
Definition: diskpart.h:236
SIZE_10MB
#define SIZE_10MB
Definition: diskpart.h:237
SIZE_1GB
#define SIZE_1GB
Definition: diskpart.h:238
NULL
#define NULL
Definition: types.h:112
RoundingDivide
ULONGLONG RoundingDivide(IN ULONGLONG Dividend, IN ULONGLONG Divisor)
Definition: partlist.c:95
_DISKENTRY::LogicalPartListHead
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:150
_DISKENTRY::BytesPerSector
ULONG BytesPerSector
Definition: partlist.h:113
_DISKENTRY::PartitionStyle
DWORD PartitionStyle
Definition: diskpart.h:202
_DISKENTRY::PrimaryPartListHead
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:149
_PARTENTRY::StartSector
ULARGE_INTEGER StartSector
Definition: partlist.h:69
ULONG
uint32_t ULONG
Definition: typedefs.h:59
CurrentPartition
static PPARTENTRY CurrentPartition
Definition: usetup.c:78
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ ListVirtualDisk()

BOOL ListVirtualDisk ( INT  argc,
PWSTR *  argv 
)

Definition at line 523 of file list.c.

526{
527 ConPuts(StdOut, L"ListVirtualDisk()!\n");
528 return TRUE;
529}

◆ ListVolume()

BOOL ListVolume ( INT  argc,
PWSTR *  argv 
)

Definition at line 495 of file list.c.

498{
499 PLIST_ENTRY Entry;
500 PVOLENTRY VolumeEntry;
501
502 ConPuts(StdOut, L"\n");
503 ConResPuts(StdOut, IDS_LIST_VOLUME_HEAD);
504 ConResPuts(StdOut, IDS_LIST_VOLUME_LINE);
505
506 Entry = VolumeListHead.Flink;
507 while (Entry != &VolumeListHead)
508 {
509 VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);
510
511 PrintVolume(VolumeEntry);
512
513 Entry = Entry->Flink;
514 }
515
516 ConPuts(StdOut, L"\n");
517
518 return TRUE;
519}
PrintVolume
VOID PrintVolume(_In_ PVOLENTRY VolumeEntry)
Definition: list.c:437
IDS_LIST_VOLUME_LINE
#define IDS_LIST_VOLUME_LINE
Definition: resource.h:89
IDS_LIST_VOLUME_HEAD
#define IDS_LIST_VOLUME_HEAD
Definition: resource.h:88
VolumeListHead
LIST_ENTRY VolumeListHead
Definition: partlist.c:75
_VOLENTRY
Definition: partlist.h:44

◆ PrintDisk()

VOID PrintDisk ( _In_ PDISKENTRY  DiskEntry)

Definition at line 83 of file list.c.

85{
86 ULONGLONG DiskSize;
87 ULONGLONG FreeSize;
88 LPWSTR lpSizeUnit;
89 LPWSTR lpFreeUnit;
90
91 DiskSize = DiskEntry->SectorCount.QuadPart *
92 (ULONGLONG)DiskEntry->BytesPerSector;
93
94 if (DiskSize >= SIZE_10TB) /* 10 TB */
95 {
96 DiskSize = RoundingDivide(DiskSize, SIZE_1TB);
97 lpSizeUnit = L"TB";
98 }
99 else if (DiskSize >= SIZE_10GB) /* 10 GB */
100 {
101 DiskSize = RoundingDivide(DiskSize, SIZE_1GB);
102 lpSizeUnit = L"GB";
103 }
104 else
105 {
106 DiskSize = RoundingDivide(DiskSize, SIZE_1MB);
107 if (DiskSize == 0)
108 DiskSize = 1;
109 lpSizeUnit = L"MB";
110 }
111
112 FreeSize = GetFreeDiskSize(DiskEntry);
113 if (FreeSize >= SIZE_10TB) /* 10 TB */
114 {
115 FreeSize = RoundingDivide(FreeSize, SIZE_1TB);
116 lpFreeUnit = L"TB";
117 }
118 else if (FreeSize >= SIZE_10GB) /* 10 GB */
119 {
120 FreeSize = RoundingDivide(FreeSize, SIZE_1GB);
121 lpFreeUnit = L"GB";
122 }
123 else if (FreeSize >= SIZE_10MB) /* 10 MB */
124 {
125 FreeSize = RoundingDivide(FreeSize, SIZE_1MB);
126 lpFreeUnit = L"MB";
127 }
128 else if (FreeSize >= SIZE_10KB) /* 10 KB */
129 {
130 FreeSize = RoundingDivide(FreeSize, SIZE_1KB);
131 lpFreeUnit = L"KB";
132 }
133 else
134 {
135 lpFreeUnit = L"B";
136 }
137
138 ConResPrintf(StdOut, IDS_LIST_DISK_FORMAT,
139 (CurrentDisk == DiskEntry) ? L'*' : L' ',
140 DiskEntry->DiskNumber,
141 L"Online",
142 DiskSize,
143 lpSizeUnit,
144 FreeSize,
145 lpFreeUnit,
146 L" ",
147 (DiskEntry->PartitionStyle == PARTITION_STYLE_GPT) ? L"*" : L" ");
148}
GetFreeDiskSize
static ULONGLONG GetFreeDiskSize(_In_ PDISKENTRY DiskEntry)
Definition: list.c:18
IDS_LIST_DISK_FORMAT
#define IDS_LIST_DISK_FORMAT
Definition: resource.h:83
SIZE_10KB
#define SIZE_10KB
Definition: diskpart.h:235
if
if(dx< 0)
Definition: linetemp.h:194

Referenced by DetailVolume(), and ListDisk().

◆ PrintVolume()

VOID PrintVolume ( _In_ PVOLENTRY  VolumeEntry)

Definition at line 437 of file list.c.

439{
440 ULONGLONG VolumeSize;
441 PWSTR pszSizeUnit;
442 PWSTR pszVolumeType;
443
444 VolumeSize = VolumeEntry->Size.QuadPart;
445 if (VolumeSize >= SIZE_10TB) /* 10 TB */
446 {
447 VolumeSize = RoundingDivide(VolumeSize, SIZE_1TB);
448 pszSizeUnit = L"TB";
449 }
450 else if (VolumeSize >= SIZE_10GB) /* 10 GB */
451 {
452 VolumeSize = RoundingDivide(VolumeSize, SIZE_1GB);
453 pszSizeUnit = L"GB";
454 }
455 else if (VolumeSize >= SIZE_10MB) /* 10 MB */
456 {
457 VolumeSize = RoundingDivide(VolumeSize, SIZE_1MB);
458 pszSizeUnit = L"MB";
459 }
460 else
461 {
462 VolumeSize = RoundingDivide(VolumeSize, SIZE_1KB);
463 pszSizeUnit = L"KB";
464 }
465
466 switch (VolumeEntry->VolumeType)
467 {
468 case VOLUME_TYPE_CDROM:
469 pszVolumeType = L"DVD";
470 break;
471 case VOLUME_TYPE_PARTITION:
472 pszVolumeType = L"Partition";
473 break;
474 case VOLUME_TYPE_REMOVABLE:
475 pszVolumeType = L"Removable";
476 break;
477 case VOLUME_TYPE_UNKNOWN:
478 default:
479 pszVolumeType = L"Unknown";
480 break;
481 }
482
483 ConResPrintf(StdOut, IDS_LIST_VOLUME_FORMAT,
484 (CurrentVolume == VolumeEntry) ? L'*' : L' ',
485 VolumeEntry->VolumeNumber,
486 VolumeEntry->DriveLetter,
487 (VolumeEntry->pszLabel) ? VolumeEntry->pszLabel : L"",
488 (VolumeEntry->pszFilesystem) ? VolumeEntry->pszFilesystem : L"",
489 pszVolumeType,
490 VolumeSize, pszSizeUnit);
491}
IDS_LIST_VOLUME_FORMAT
#define IDS_LIST_VOLUME_FORMAT
Definition: resource.h:90
VOLUME_TYPE_UNKNOWN
@ VOLUME_TYPE_UNKNOWN
Definition: diskpart.h:101
VOLUME_TYPE_REMOVABLE
@ VOLUME_TYPE_REMOVABLE
Definition: diskpart.h:100
VOLUME_TYPE_CDROM
@ VOLUME_TYPE_CDROM
Definition: diskpart.h:98
VOLUME_TYPE_PARTITION
@ VOLUME_TYPE_PARTITION
Definition: diskpart.h:99
CurrentVolume
PVOLENTRY CurrentVolume
Definition: partlist.c:79
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56

Referenced by DetailDisk(), DetailPartition(), and ListVolume().