← Back to branch summary

~ubuntu-branches/ubuntu/utopic/parted/utopic-proposed

« back to all changes in this revision

Viewing changes to .pc/preserve-hidden-parts.patch/libparted/labels/dos.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2014-07-21 10:23:16 UTC
  • mfrom: (7.2.32 sid)
  • Revision ID: package-import@ubuntu.com-20140721102316-jsyv3yzmbo8vlde5
Tags: 3.1-3
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/preserve-hidden-parts.patch/libparted/labels/dos.c
1
1
/*
2
2
    libparted - a library for manipulating disk partitions
3
 
    Copyright (C) 1999-2001, 2004-2005, 2007-2010 Free Software
4
 
    Foundation, Inc.
 
3
    Copyright (C) 1999-2001, 2004-2005, 2007-2012 Free Software Foundation,
 
4
    Inc.
5
5
 
6
6
    This program is free software; you can redistribute it and/or modify
7
7
    it under the terms of the GNU General Public License as published by
103
103
 * (i.e. 1022 is sometimes used to indicate "use LBA").
104
104
 */
105
105
#define MAX_CHS_CYLINDER        1021
106
 
#define MAX_TOTAL_PART          16
 
106
#define MAX_TOTAL_PART          64
107
107
 
108
108
typedef struct _DosRawPartition         DosRawPartition;
109
109
typedef struct _DosRawTable             DosRawTable;
164
164
 
165
165
static PedDiskType msdos_disk_type;
166
166
 
 
167
#if 0
 
168
From http://www.win.tue.nl/~aeb/linux/fs/fat/fat-1.html
 
169
 
 
170
The 2-byte numbers are stored little endian (low order byte first).
 
171
 
 
172
Here the FAT12 version, that is also the common part of the FAT12, FAT16 and FAT32 boot sectors. See further below.
 
173
 
 
174
Bytes   Content
 
175
0-2     Jump to bootstrap (E.g. eb 3c 90; on i86: JMP 003E NOP.
 
176
        One finds either eb xx 90, or e9 xx xx.
 
177
        The position of the bootstrap varies.)
 
178
3-10    OEM name/version (E.g. "IBM  3.3", "IBM 20.0", "MSDOS5.0", "MSWIN4.0".
 
179
        Various format utilities leave their own name, like "CH-FOR18".
 
180
        Sometimes just garbage. Microsoft recommends "MSWIN4.1".)
 
181
        /* BIOS Parameter Block starts here */
 
182
11-12   Number of bytes per sector (512)
 
183
        Must be one of 512, 1024, 2048, 4096.
 
184
13      Number of sectors per cluster (1)
 
185
        Must be one of 1, 2, 4, 8, 16, 32, 64, 128.
 
186
        A cluster should have at most 32768 bytes. In rare cases 65536 is OK.
 
187
14-15   Number of reserved sectors (1)
 
188
        FAT12 and FAT16 use 1. FAT32 uses 32.
 
189
16      Number of FAT copies (2)
 
190
17-18   Number of root directory entries (224)
 
191
        0 for FAT32. 512 is recommended for FAT16.
 
192
19-20   Total number of sectors in the filesystem (2880)
 
193
        (in case the partition is not FAT32 and smaller than 32 MB)
 
194
21      Media descriptor type (f0: 1.4 MB floppy, f8: hard disk; see below)
 
195
22-23   Number of sectors per FAT (9)
 
196
        0 for FAT32.
 
197
24-25   Number of sectors per track (12)
 
198
26-27   Number of heads (2, for a double-sided diskette)
 
199
28-29   Number of hidden sectors (0)
 
200
        Hidden sectors are sectors preceding the partition.
 
201
        /* BIOS Parameter Block ends here */
 
202
30-509  Bootstrap
 
203
510-511 Signature 55 aa
 
204
#endif
 
205
 
 
206
/* There is a significant risk of misclassifying (as msdos)
 
207
   a disk that is composed solely of a single FAT partition.
 
208
   Return false if sector S could not be a valid FAT boot sector.
 
209
   Otherwise, return true.  */
 
210
static bool
 
211
maybe_FAT (unsigned char const *s)
 
212
{
 
213
  if (! (s[0] == 0xeb || s[0] == 0xe9))
 
214
    return false;
 
215
 
 
216
  unsigned int sector_size = PED_LE16_TO_CPU (*(uint16_t *) (s + 11));
 
217
  switch (sector_size)
 
218
    {
 
219
    case 512:
 
220
    case 1024:
 
221
    case 2048:
 
222
    case 4096:
 
223
      break;
 
224
    default:
 
225
      return false;
 
226
    }
 
227
 
 
228
  if (! (s[21] == 0xf0 || s[21] == 0xf8))
 
229
    return false;
 
230
 
 
231
  return true;
 
232
}
 
233
 
167
234
static int
168
235
msdos_probe (const PedDevice *dev)
169
236
{
171
238
        DosRawTable*    part_table;
172
239
        int             i;
173
240
 
174
 
        PED_ASSERT (dev != NULL, return 0);
 
241
        PED_ASSERT (dev != NULL);
175
242
 
176
243
        if (dev->sector_size < sizeof *part_table)
177
244
                return 0;
191
258
         * and ensure that each partition has a boot indicator that is
192
259
         * either 0 or 0x80.
193
260
         */
 
261
        unsigned int n_active = 0;
194
262
        for (i = 0; i < DOS_N_PRI_PARTITIONS; i++) {
 
263
                if (part_table->partitions[i].boot_ind == 0x80)
 
264
                        ++n_active;
195
265
                if (part_table->partitions[i].boot_ind != 0
196
266
                    && part_table->partitions[i].boot_ind != 0x80)
197
267
                        goto probe_fail;
198
268
        }
199
269
 
 
270
        /* If there are no active partitions and this is probably
 
271
           a FAT file system, do not classify it as msdos.  */
 
272
        if (n_active == 0 && maybe_FAT (label))
 
273
          goto probe_fail;
 
274
 
200
275
        /* If this is a GPT disk, fail here */
201
276
        for (i = 0; i < DOS_N_PRI_PARTITIONS; i++) {
202
277
                if (part_table->partitions[i].type == PARTITION_GPT)
232
307
msdos_alloc (const PedDevice* dev)
233
308
{
234
309
        PedDisk* disk;
235
 
        PED_ASSERT (dev != NULL, return NULL);
 
310
        PED_ASSERT (dev != NULL);
236
311
 
237
312
        disk = _ped_disk_alloc ((PedDevice*)dev, &msdos_disk_type);
238
313
        if (disk) {
266
341
static void
267
342
msdos_free (PedDisk* disk)
268
343
{
269
 
        PED_ASSERT (disk != NULL, return);
 
344
        PED_ASSERT (disk != NULL);
270
345
 
271
346
        DosDiskData *disk_specific = disk->disk_specific;
272
347
        _ped_disk_free (disk);
328
403
        return (chs->sector & 0x3f) - 1;
329
404
}
330
405
 
331
 
static PedSector
 
406
static PedSector _GL_ATTRIBUTE_PURE
332
407
chs_to_sector (const PedDevice* dev, const PedCHSGeometry *bios_geom,
333
408
               const RawCHS* chs)
334
409
{
336
411
        PedSector       h;              /* lots of bits */
337
412
        PedSector       s;
338
413
 
339
 
        PED_ASSERT (bios_geom != NULL, return 0);
340
 
        PED_ASSERT (chs != NULL, return 0);
 
414
        PED_ASSERT (bios_geom != NULL);
 
415
        PED_ASSERT (chs != NULL);
341
416
 
342
417
        c = chs_get_cylinder (chs);
343
418
        h = chs_get_head (chs);
356
431
{
357
432
        PedSector       real_c, real_h, real_s;
358
433
 
359
 
        PED_ASSERT (dev != NULL, return);
360
 
        PED_ASSERT (chs != NULL, return);
 
434
        PED_ASSERT (dev != NULL);
 
435
        PED_ASSERT (chs != NULL);
361
436
 
362
437
        if (!bios_geom)
363
438
                bios_geom = &dev->bios_geom;
377
452
        chs->sector = real_s + 1 + (real_c >> 8 << 6);
378
453
}
379
454
 
380
 
static PedSector
 
455
static PedSector _GL_ATTRIBUTE_PURE
381
456
legacy_start (const PedDisk* disk, const PedCHSGeometry* bios_geom,
382
457
              const DosRawPartition* raw_part)
383
458
{
384
 
        PED_ASSERT (disk != NULL, return 0);
385
 
        PED_ASSERT (raw_part != NULL, return 0);
 
459
        PED_ASSERT (disk != NULL);
 
460
        PED_ASSERT (raw_part != NULL);
386
461
 
387
462
        return chs_to_sector (disk->dev, bios_geom, &raw_part->chs_start);
388
463
}
389
464
 
390
 
static PedSector
 
465
static PedSector _GL_ATTRIBUTE_PURE
391
466
legacy_end (const PedDisk* disk, const PedCHSGeometry* bios_geom,
392
467
            const DosRawPartition* raw_part)
393
468
{
394
 
        PED_ASSERT (disk != NULL, return 0);
395
 
        PED_ASSERT (raw_part != NULL, return 0);
 
469
        PED_ASSERT (disk != NULL);
 
470
        PED_ASSERT (raw_part != NULL);
396
471
 
397
472
        return chs_to_sector (disk->dev, bios_geom, &raw_part->chs_end);
398
473
}
399
474
 
400
 
static PedSector
 
475
static PedSector _GL_ATTRIBUTE_PURE
401
476
linear_start (const PedDisk* disk, const DosRawPartition* raw_part,
402
477
              PedSector offset)
403
478
{
404
 
        PED_ASSERT (disk != NULL, return 0);
405
 
        PED_ASSERT (raw_part != NULL, return 0);
 
479
        PED_ASSERT (disk != NULL);
 
480
        PED_ASSERT (raw_part != NULL);
406
481
 
407
482
        return offset + PED_LE32_TO_CPU (raw_part->start);
408
483
}
409
484
 
410
 
static PedSector
 
485
static PedSector _GL_ATTRIBUTE_PURE
411
486
linear_end (const PedDisk* disk, const DosRawPartition* raw_part,
412
487
            PedSector offset)
413
488
{
414
 
        PED_ASSERT (disk != NULL, return 0);
415
 
        PED_ASSERT (raw_part != NULL, return 0);
 
489
        PED_ASSERT (disk != NULL);
 
490
        PED_ASSERT (raw_part != NULL);
416
491
 
417
492
        return (linear_start (disk, raw_part, offset)
418
493
                + (PED_LE32_TO_CPU (raw_part->length) - 1));
419
494
}
420
495
 
421
496
#ifndef DISCOVER_ONLY
422
 
static int
 
497
static int _GL_ATTRIBUTE_PURE
423
498
partition_check_bios_geometry (PedPartition* part, PedCHSGeometry* bios_geom)
424
499
{
425
500
        PedSector               leg_start, leg_end;
426
501
        DosPartitionData*       dos_data;
427
502
        PedDisk*                disk;
428
503
 
429
 
        PED_ASSERT (part != NULL, return 0);
430
 
        PED_ASSERT (part->disk != NULL, return 0);
431
 
        PED_ASSERT (part->disk_specific != NULL, return 0);
 
504
        PED_ASSERT (part != NULL);
 
505
        PED_ASSERT (part->disk != NULL);
 
506
        PED_ASSERT (part->disk_specific != NULL);
432
507
        dos_data = part->disk_specific;
433
508
 
434
509
        if (!dos_data->orig)
445
520
        return 1;
446
521
}
447
522
 
448
 
static int
 
523
static int _GL_ATTRIBUTE_PURE
449
524
disk_check_bios_geometry (const PedDisk* disk, PedCHSGeometry* bios_geom)
450
525
{
451
526
        PedPartition* part = NULL;
452
527
 
453
 
        PED_ASSERT (disk != NULL, return 0);
 
528
        PED_ASSERT (disk != NULL);
454
529
 
455
530
        while ((part = ped_disk_next_partition (disk, part))) {
456
531
                if (ped_partition_is_active (part)) {
473
548
        int heads;
474
549
        int res = 0;
475
550
 
476
 
        PED_ASSERT (bios_geom        != NULL, return 0);
477
 
        PED_ASSERT (part             != NULL, return 0);
478
 
        PED_ASSERT (part->disk       != NULL, return 0);
479
 
        PED_ASSERT (part->disk->dev  != NULL, return 0);
480
 
        PED_ASSERT (part->disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
481
 
                    return 0);
 
551
        PED_ASSERT (bios_geom        != NULL);
 
552
        PED_ASSERT (part             != NULL);
 
553
        PED_ASSERT (part->disk       != NULL);
 
554
        PED_ASSERT (part->disk->dev  != NULL);
 
555
        PED_ASSERT (part->disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
482
556
 
483
557
        buf = ped_malloc (part->disk->dev->sector_size);
484
558
 
564
638
        PedSector cyl_size, head_size;
565
639
        PedSector cylinders, heads, sectors;
566
640
 
567
 
        PED_ASSERT (part != NULL, return 0);
568
 
        PED_ASSERT (part->disk_specific != NULL, return 0);
569
 
        PED_ASSERT (bios_geom != NULL, return 0);
 
641
        PED_ASSERT (part != NULL);
 
642
        PED_ASSERT (part->disk_specific != NULL);
 
643
        PED_ASSERT (bios_geom != NULL);
570
644
 
571
645
        dos_data = part->disk_specific;
572
646
 
645
719
        if (cyl_size * denum != a_*H - A_*h)
646
720
                return 0;
647
721
 
648
 
        PED_ASSERT (cyl_size > 0, return 0);
649
 
        PED_ASSERT (cyl_size <= 255 * 63, return 0);
 
722
        if (!(cyl_size > 0))
 
723
                return 0;
 
724
        if (!(cyl_size <= 255 * 63))
 
725
                return 0;
650
726
 
651
727
        if (h > 0)
652
728
                head_size = ( a_ - c * cyl_size ) / h;
654
730
                head_size = ( A_ - C * cyl_size ) / H;
655
731
        else {
656
732
                /* should not happen because denum != 0 */
657
 
                PED_ASSERT (0, return 0);
 
733
                PED_ASSERT (0);
658
734
        }
659
735
 
660
 
        PED_ASSERT (head_size > 0, return 0);
661
 
        PED_ASSERT (head_size <= 63, return 0);
 
736
        if (!(head_size > 0))
 
737
                return 0;
 
738
        if (!(head_size <= 63))
 
739
                return 0;
662
740
 
663
741
        cylinders = part->disk->dev->length / cyl_size;
664
742
        heads = cyl_size / head_size;
665
743
        sectors = head_size;
666
744
 
667
 
        PED_ASSERT (heads > 0, return 0);
668
 
        PED_ASSERT (heads < 256, return 0);
 
745
        if (!(heads > 0))
 
746
                return 0;
 
747
        if (!(heads < 256))
 
748
                return 0;
669
749
 
670
 
        PED_ASSERT (sectors > 0, return 0);
671
 
        PED_ASSERT (sectors <= 63, return 0);
 
750
        if (!(sectors > 0))
 
751
                return 0;
 
752
        if (!(sectors <= 63))
 
753
                return 0;
672
754
 
673
755
        /* Some broken OEM partitioning program(s) seem to have an out-by-one
674
756
         * error on the end of partitions.  We should offer to fix the
677
759
        if (((C + 1) * heads + H) * sectors + S == A)
678
760
                C++;
679
761
 
680
 
        PED_ASSERT ((c * heads + h) * sectors + s == a, return 0);
681
 
        PED_ASSERT ((C * heads + H) * sectors + S == A, return 0);
 
762
        if (!((c * heads + h) * sectors + s == a))
 
763
                return 0;
 
764
        if (!((C * heads + H) * sectors + S == A))
 
765
                return 0;
682
766
 
683
767
        bios_geom->cylinders = cylinders;
684
768
        bios_geom->heads = heads;
691
775
partition_probe_bios_geometry (const PedPartition* part,
692
776
                               PedCHSGeometry* bios_geom)
693
777
{
694
 
        PED_ASSERT (part != NULL, return);
695
 
        PED_ASSERT (part->disk != NULL, return);
696
 
        PED_ASSERT (bios_geom != NULL, return);
 
778
        PED_ASSERT (part != NULL);
 
779
        PED_ASSERT (part->disk != NULL);
 
780
        PED_ASSERT (bios_geom != NULL);
697
781
 
698
782
        if (ped_partition_is_active (part)) {
699
783
                if (probe_partition_for_geom (part, bios_geom))
706
790
        if (part->type & PED_PARTITION_LOGICAL) {
707
791
                PedPartition* ext_part;
708
792
                ext_part = ped_disk_extended_partition (part->disk);
709
 
                PED_ASSERT (ext_part != NULL, return);
 
793
                PED_ASSERT (ext_part != NULL);
710
794
                partition_probe_bios_geometry (ext_part, bios_geom);
711
795
        } else {
712
796
                *bios_geom = part->disk->dev->bios_geom;
751
835
}
752
836
#endif /* !DISCOVER_ONLY */
753
837
 
754
 
static int
 
838
static int _GL_ATTRIBUTE_PURE
755
839
raw_part_is_extended (const DosRawPartition* raw_part)
756
840
{
757
 
        PED_ASSERT (raw_part != NULL, return 0);
 
841
        PED_ASSERT (raw_part != NULL);
758
842
 
759
843
        switch (raw_part->type) {
760
844
        case PARTITION_DOS_EXT:
769
853
        return 0;
770
854
}
771
855
 
772
 
static int
 
856
static int _GL_ATTRIBUTE_PURE
773
857
raw_part_is_hidden (const DosRawPartition* raw_part)
774
858
{
775
 
        PED_ASSERT (raw_part != NULL, return 0);
 
859
        PED_ASSERT (raw_part != NULL);
776
860
 
777
861
        switch (raw_part->type) {
778
862
        case PARTITION_FAT12_H:
791
875
        return 0;
792
876
}
793
877
 
794
 
static int
 
878
static int _GL_ATTRIBUTE_PURE
795
879
raw_part_is_lba (const DosRawPartition* raw_part)
796
880
{
797
 
        PED_ASSERT (raw_part != NULL, return 0);
 
881
        PED_ASSERT (raw_part != NULL);
798
882
 
799
883
        switch (raw_part->type) {
800
884
        case PARTITION_FAT32_LBA:
818
902
        PedPartition* part;
819
903
        DosPartitionData* dos_data;
820
904
 
821
 
        PED_ASSERT (disk != NULL, return NULL);
822
 
        PED_ASSERT (raw_part != NULL, return NULL);
 
905
        PED_ASSERT (disk != NULL);
 
906
        PED_ASSERT (raw_part != NULL);
823
907
 
824
908
        part = ped_partition_new (
825
909
                disk, type, NULL,
861
945
        PedPartitionType        type;
862
946
        PedSector               lba_offset;
863
947
 
864
 
        PED_ASSERT (disk != NULL, return 0);
865
 
        PED_ASSERT (disk->dev != NULL, return 0);
 
948
        PED_ASSERT (disk != NULL);
 
949
        PED_ASSERT (disk->dev != NULL);
866
950
 
867
951
        void *label = NULL;
868
952
        if (!ptt_read_sector (disk->dev, sector, &label))
980
1064
static int
981
1065
msdos_read (PedDisk* disk)
982
1066
{
983
 
        PED_ASSERT (disk != NULL, return 0);
984
 
        PED_ASSERT (disk->dev != NULL, return 0);
 
1067
        PED_ASSERT (disk != NULL);
 
1068
        PED_ASSERT (disk->dev != NULL);
985
1069
 
986
1070
        ped_disk_delete_all (disk);
987
1071
        if (!read_table (disk, 0, 0))
1016
1100
        DosPartitionData*       dos_data;
1017
1101
        PedCHSGeometry          bios_geom;
1018
1102
 
1019
 
        PED_ASSERT (raw_part != NULL, return 0);
1020
 
        PED_ASSERT (part != NULL, return 0);
 
1103
        PED_ASSERT (raw_part != NULL);
 
1104
        PED_ASSERT (part != NULL);
1021
1105
 
1022
1106
        partition_probe_bios_geometry (part, &bios_geom);
1023
1107
 
1049
1133
                        const PedCHSGeometry* bios_geom,
1050
1134
                        const PedGeometry* geom, PedSector offset)
1051
1135
{
1052
 
        PED_ASSERT (raw_part != NULL, return 0);
1053
 
        PED_ASSERT (geom != NULL, return 0);
1054
 
        PED_ASSERT (geom->dev != NULL, return 0);
 
1136
        PED_ASSERT (raw_part != NULL);
 
1137
        PED_ASSERT (geom != NULL);
 
1138
        PED_ASSERT (geom->dev != NULL);
1055
1139
 
1056
1140
        raw_part->boot_ind = 0;
1057
1141
        raw_part->type = PARTITION_DOS_EXT;
1072
1156
        PedPartition*           part;
1073
1157
        PedSector               lba_offset;
1074
1158
 
1075
 
        PED_ASSERT (disk != NULL, return 0);
1076
 
        PED_ASSERT (ped_disk_extended_partition (disk) != NULL, return 0);
1077
 
        PED_ASSERT (logical != NULL, return 0);
 
1159
        PED_ASSERT (disk != NULL);
 
1160
        PED_ASSERT (ped_disk_extended_partition (disk) != NULL);
 
1161
        PED_ASSERT (logical != NULL);
1078
1162
 
1079
1163
        lba_offset = ped_disk_extended_partition (disk)->geom.start;
1080
1164
 
1120
1204
        DosRawTable             table;
1121
1205
        void*                   table_sector;
1122
1206
 
1123
 
        PED_ASSERT (disk != NULL, return 0);
 
1207
        PED_ASSERT (disk != NULL);
1124
1208
 
1125
1209
        if (ptt_read_sector (disk->dev, sector, &table_sector)) {
1126
1210
                memcpy (&table, table_sector, sizeof (table));
1141
1225
        PedPartition*           part;
1142
1226
        PedCHSGeometry          bios_geom;
1143
1227
 
1144
 
        PED_ASSERT (disk != NULL, return 0);
 
1228
        PED_ASSERT (disk != NULL);
1145
1229
 
1146
1230
        ext_part = ped_disk_extended_partition (disk);
1147
1231
        partition_probe_bios_geometry (ext_part, &bios_geom);
1168
1252
        PedPartition*           part;
1169
1253
        int                     i;
1170
1254
 
1171
 
        PED_ASSERT (disk != NULL, return 0);
1172
 
        PED_ASSERT (disk->dev != NULL, return 0);
 
1255
        PED_ASSERT (disk != NULL);
 
1256
        PED_ASSERT (disk->dev != NULL);
1173
1257
 
1174
1258
        void *s0;
1175
1259
        if (!ptt_read_sector (disk->dev, 0, &s0))
1294
1378
static void
1295
1379
msdos_partition_destroy (PedPartition* part)
1296
1380
{
1297
 
        PED_ASSERT (part != NULL, return);
 
1381
        PED_ASSERT (part != NULL);
1298
1382
 
1299
1383
        if (ped_partition_is_active (part)) {
1300
1384
                DosPartitionData* dos_data;
1404
1488
        PedPartition*                   walk;
1405
1489
        DosPartitionData*               dos_data;
1406
1490
 
1407
 
        PED_ASSERT (part != NULL, return 0);
1408
 
        PED_ASSERT (part->disk_specific != NULL, return 0);
1409
 
        PED_ASSERT (part->disk != NULL, return 0);
 
1491
        PED_ASSERT (part != NULL);
 
1492
        PED_ASSERT (part->disk_specific != NULL);
 
1493
        PED_ASSERT (part->disk != NULL);
1410
1494
 
1411
1495
        dos_data = part->disk_specific;
1412
1496
        disk = part->disk;
1476
1560
        }
1477
1561
}
1478
1562
 
1479
 
static int
 
1563
static int _GL_ATTRIBUTE_PURE
1480
1564
msdos_partition_get_flag (const PedPartition* part, PedPartitionFlag flag)
1481
1565
{
1482
1566
        DosPartitionData*       dos_data;
1483
1567
 
1484
 
        PED_ASSERT (part != NULL, return 0);
1485
 
        PED_ASSERT (part->disk_specific != NULL, return 0);
 
1568
        PED_ASSERT (part != NULL);
 
1569
        PED_ASSERT (part->disk_specific != NULL);
1486
1570
 
1487
1571
        dos_data = part->disk_specific;
1488
1572
        switch (flag) {
1638
1722
                                        dev->length - min_geom->end))
1639
1723
                        return NULL;
1640
1724
        } else {
1641
 
                /* Do not assume that length is larger than 1 cylinder's
1642
 
                   worth of sectors.  This is useful when testing with
1643
 
                   a memory-mapped "disk" (a la scsi_debug) that is say,
1644
 
                   2048 sectors long.  */
1645
 
                if (cylinder_size < dev->length
1646
 
                    && !ped_geometry_init (&start_geom, dev, cylinder_size,
1647
 
                                           dev->length - cylinder_size))
 
1725
                /* Use cylinder_size as the starting sector number
 
1726
                   when the device is large enough to accommodate that.
 
1727
                   Otherwise, use sector 1.  */
 
1728
                PedSector start = (cylinder_size < dev->length
 
1729
                                   ? cylinder_size : 1);
 
1730
                if (!ped_geometry_init (&start_geom, dev, start,
 
1731
                                        dev->length - start))
1648
1732
                        return NULL;
1649
1733
                if (!ped_geometry_init (&end_geom, dev, 0, dev->length))
1650
1734
                        return NULL;
1725
1809
        PedAlignment    end_align;
1726
1810
        PedGeometry     max_geom;
1727
1811
 
1728
 
        PED_ASSERT (ext_part != NULL, return NULL);
 
1812
        PED_ASSERT (ext_part != NULL);
1729
1813
 
1730
1814
        if (!ped_alignment_init (&start_align, start_offset, cylinder_size))
1731
1815
                return NULL;
1874
1958
        PedPartition*   walk;
1875
1959
        int             not_5 = (part->num != 5);
1876
1960
 
1877
 
        PED_ASSERT (ext_part != NULL, return NULL);
 
1961
        PED_ASSERT (ext_part != NULL);
1878
1962
 
1879
1963
        walk = ext_part->part_list;
1880
1964
 
1916
2000
        PedGeometry*    solution = NULL;
1917
2001
        PedConstraint   *intersect, *log_meta_overlap;
1918
2002
 
1919
 
        PED_ASSERT (ext_part != NULL, return 0);
 
2003
        PED_ASSERT (ext_part != NULL);
1920
2004
 
1921
2005
        log_meta_overlap = _log_meta_overlap_constraint(part, &part->geom);
1922
2006
        intersect = ped_constraint_intersect (constraint, log_meta_overlap);
2054
2138
        PedCHSGeometry  bios_geom;
2055
2139
        DosPartitionData* dos_data;
2056
2140
 
2057
 
        PED_ASSERT (part != NULL, return 0);
2058
 
        PED_ASSERT (part->disk_specific != NULL, return 0);
 
2141
        PED_ASSERT (part != NULL);
 
2142
        PED_ASSERT (part->disk_specific != NULL);
2059
2143
 
2060
2144
        dos_data = part->disk_specific;
2061
2145
 
2100
2184
{
2101
2185
        PedPartition*           new_part;
2102
2186
 
2103
 
        PED_ASSERT (disk != NULL, return 0);
 
2187
        PED_ASSERT (disk != NULL);
2104
2188
 
2105
2189
        new_part = ped_partition_new (disk, type | PED_PARTITION_METADATA, NULL,
2106
2190
                                      start, end);
2157
2241
        if (log_part->num == 5 && metadata_length < bios_geom.sectors)
2158
2242
                return 1;
2159
2243
 
2160
 
        PED_ASSERT (metadata_length > 0, return 0);
 
2244
        PED_ASSERT (metadata_length > 0);
2161
2245
 
2162
2246
        return add_metadata_part (disk, PED_PARTITION_LOGICAL,
2163
2247
                                  metadata_start, metadata_end);
2271
2355
{
2272
2356
        PedPartition*           ext_part;
2273
2357
 
2274
 
        PED_ASSERT (disk != NULL, return 0);
2275
 
        PED_ASSERT (disk->dev != NULL, return 0);
 
2358
        PED_ASSERT (disk != NULL);
 
2359
        PED_ASSERT (disk->dev != NULL);
2276
2360
 
2277
2361
        if (!add_startend_metadata (disk))
2278
2362
                return 0;
2314
2398
                if (!ped_disk_get_partition (disk, i))
2315
2399
                        return i;
2316
2400
        }
2317
 
        return 0;
 
2401
        return -1;
2318
2402
}
2319
2403
 
2320
 
static int
 
2404
static int _GL_ATTRIBUTE_PURE
2321
2405
next_logical (const PedDisk* disk)
2322
2406
{
2323
2407
        int     i;
2324
 
        for (i=5; 1; i++) {
 
2408
        for (i=5; i<=MAX_TOTAL_PART; i++) {
2325
2409
                if (!ped_disk_get_partition (disk, i))
2326
2410
                        return i;
2327
2411
        }
 
2412
        ped_exception_throw (
 
2413
                PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
 
2414
                _("cannot create any more partitions"),
 
2415
                disk->dev->path);
 
2416
        return -1;
2328
2417
}
2329
2418
 
2330
2419
static int
2331
2420
msdos_partition_enumerate (PedPartition* part)
2332
2421
{
2333
 
        PED_ASSERT (part != NULL, return 0);
2334
 
        PED_ASSERT (part->disk != NULL, return 0);
 
2422
        PED_ASSERT (part != NULL);
 
2423
        PED_ASSERT (part->disk != NULL);
2335
2424
 
2336
2425
        /* don't re-number a primary partition */
2337
2426
        if (part->num != -1 && part->num <= DOS_N_PRI_PARTITIONS)
2343
2432
                part->num = next_logical (part->disk);
2344
2433
        else
2345
2434
                part->num = next_primary (part->disk);
2346
 
 
 
2435
        if (part->num == -1)
 
2436
                return 0;
2347
2437
        return 1;
2348
2438
}
2349
2439
 
2387
2477
void
2388
2478
ped_disk_msdos_init ()
2389
2479
{
2390
 
        PED_ASSERT (sizeof (DosRawPartition) == 16, return);
2391
 
        PED_ASSERT (sizeof (DosRawTable) == 512, return);
 
2480
        PED_ASSERT (sizeof (DosRawPartition) == 16);
 
2481
        PED_ASSERT (sizeof (DosRawTable) == 512);
2392
2482
 
2393
2483
        ped_disk_type_register (&msdos_disk_type);
2394
2484
}