← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/avoid-disturbing-partitions.patch/libparted/arch/linux.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/avoid-disturbing-partitions.patch/libparted/arch/linux.c
1
1
/* libparted - a library for manipulating disk partitions
2
 
    Copyright (C) 1999-2010 Free Software Foundation, Inc.
 
2
    Copyright (C) 1999-2012 Free Software Foundation, Inc.
3
3
 
4
4
    This program is free software; you can redistribute it and/or modify
5
5
    it under the terms of the GNU General Public License as published by
48
48
 
49
49
#include "../architecture.h"
50
50
#include "dirname.h"
 
51
#include "xstrtol.h"
51
52
 
52
53
#if ENABLE_NLS
53
54
#  include <libintl.h>
56
57
#  define _(String) (String)
57
58
#endif /* ENABLE_NLS */
58
59
 
 
60
/* The __attribute__ feature is available in gcc versions 2.5 and later.
 
61
   The __-protected variants of the attributes 'format' and 'printf' are
 
62
   accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
 
63
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
 
64
# define _GL_ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))
 
65
#else
 
66
# define _GL_ATTRIBUTE_FORMAT(spec) /* empty */
 
67
#endif
 
68
 
59
69
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
60
70
 
61
71
#ifndef __NR__llseek
222
232
#define SCSI_DISK5_MAJOR        69
223
233
#define SCSI_DISK6_MAJOR        70
224
234
#define SCSI_DISK7_MAJOR        71
 
235
#define SCSI_DISK8_MAJOR        128
 
236
#define SCSI_DISK9_MAJOR        129
 
237
#define SCSI_DISK10_MAJOR       130
 
238
#define SCSI_DISK11_MAJOR       131
 
239
#define SCSI_DISK12_MAJOR       132
 
240
#define SCSI_DISK13_MAJOR       133
 
241
#define SCSI_DISK14_MAJOR       134
 
242
#define SCSI_DISK15_MAJOR       135
225
243
#define COMPAQ_SMART2_MAJOR     72
226
244
#define COMPAQ_SMART2_MAJOR1    73
227
245
#define COMPAQ_SMART2_MAJOR2    74
262
280
#define SCSI_BLK_MAJOR(M) (                                             \
263
281
                (M) == SCSI_DISK0_MAJOR                                 \
264
282
                || (M) == SCSI_CDROM_MAJOR                              \
265
 
                || ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR))
 
283
                || ((M) >= SCSI_DISK1_MAJOR && (M) <= SCSI_DISK7_MAJOR) \
 
284
                || ((M) >= SCSI_DISK8_MAJOR && (M) <= SCSI_DISK15_MAJOR))
266
285
 
267
286
/* Maximum number of partitions supported by linux. */
268
287
#define MAX_NUM_PARTS           64
550
569
static int
551
570
_device_stat (PedDevice* dev, struct stat * dev_stat)
552
571
{
553
 
        PED_ASSERT (dev != NULL, return 0);
554
 
        PED_ASSERT (!dev->external_mode, return 0);
 
572
        PED_ASSERT (dev != NULL);
 
573
        PED_ASSERT (!dev->external_mode);
555
574
 
556
575
        while (1) {
557
576
                if (!stat (dev->path, dev_stat)) {
644
663
        static int kver = -1;
645
664
 
646
665
        struct utsname uts;
647
 
        int major;
648
 
        int minor;
649
 
        int teeny;
 
666
        int major = 0;
 
667
        int minor = 0;
 
668
        int teeny = 0;
650
669
 
651
670
        if (kver != -1)
652
671
                return kver;
653
672
 
654
673
        if (uname (&uts))
655
674
                return kver = 0;
656
 
        if (sscanf (uts.release, "%u.%u.%u", &major, &minor, &teeny) == 3)
657
 
                ; /* ok */
658
 
        else if (sscanf (uts.release, "%u.%u", &major, &minor) == 2)
659
 
                teeny = 0;
660
 
        else
661
 
                return kver = 0;
662
 
 
 
675
        int n = sscanf (uts.release, "%u.%u.%u", &major, &minor, &teeny);
 
676
        assert (n == 2 || n == 3);
663
677
        return kver = KERNEL_VERSION (major, minor, teeny);
664
678
}
665
679
 
702
716
        dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
703
717
        dev->phys_sector_size = PED_SECTOR_SIZE_DEFAULT;
704
718
 
705
 
        PED_ASSERT (dev->open_count, return);
 
719
        PED_ASSERT (dev->open_count);
706
720
 
707
721
        if (_get_linux_version() < KERNEL_VERSION (2,3,0)) {
708
722
                dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
768
782
        unsigned long           size;
769
783
        LinuxSpecific*          arch_specific = LINUX_SPECIFIC (dev);
770
784
        uint64_t bytes=0;
771
 
 
772
 
 
773
 
        PED_ASSERT (dev->open_count > 0, return 0);
774
 
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
 
785
        const char*             test_str;
 
786
        PedSector               test_size;
 
787
 
 
788
 
 
789
        PED_ASSERT (dev->open_count > 0);
 
790
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
 
791
 
 
792
        test_str = getenv ("PARTED_TEST_DEVICE_LENGTH");
 
793
        if (test_str
 
794
            && xstrtoll (test_str, NULL, 10, &test_size, NULL) == LONGINT_OK)
 
795
                return test_size;
775
796
 
776
797
        if (_kernel_has_blkgetsize64()) {
777
798
                if (ioctl(arch_specific->fd, BLKGETSIZE64, &bytes) == 0) {
801
822
 
802
823
        if (!_device_stat (dev, &dev_stat))
803
824
                return 0;
804
 
        PED_ASSERT (S_ISBLK (dev_stat.st_mode), return 0);
 
825
        PED_ASSERT (S_ISBLK (dev_stat.st_mode));
805
826
 
806
827
        _device_set_sector_size (dev);
807
828
 
881
902
                                dev->model = strdup(_("Generic IDE"));
882
903
                                break;
883
904
                        default:
884
 
                                PED_ASSERT (0, (void) 0);
 
905
                                PED_ASSERT (0);
885
906
                                break;
886
907
                }
887
908
        } else {
917
938
                                case PED_EXCEPTION_IGNORE:
918
939
                                        break;
919
940
                                default:
920
 
                                        PED_ASSERT (0, (void) 0);
 
941
                                        PED_ASSERT (0);
921
942
                                        break;
922
943
                        }
923
944
                }
954
975
        if ((f = fopen (name_buf, "r")) == NULL)
955
976
                return NULL;
956
977
 
957
 
        if (fgets (buf, 255, f) == NULL)
 
978
        if (fgets (buf, 255, f) == NULL) {
 
979
                fclose (f);
958
980
                return NULL;
 
981
        }
959
982
 
960
983
        fclose (f);
961
984
        return strip_name (buf);
1138
1161
                ped_exception_throw (
1139
1162
                        PED_EXCEPTION_ERROR,
1140
1163
                        PED_EXCEPTION_CANCEL,
1141
 
                        _("The device %s has zero length, and can't possibly "
 
1164
                        _("The device %s is so small that it cannot possibly "
1142
1165
                          "store a file system or partition table.  Perhaps "
1143
1166
                          "you selected the wrong device?"),
1144
1167
                        dev->path);
1177
1200
 
1178
1201
        LinuxSpecific* arch_specific = LINUX_SPECIFIC (dev);
1179
1202
 
1180
 
        PED_ASSERT (S_ISBLK (dev_stat.st_mode), return 0);
 
1203
        PED_ASSERT (S_ISBLK (dev_stat.st_mode));
1181
1204
 
1182
1205
        _device_set_sector_size (dev);
1183
1206
        if (!dev->sector_size)
1238
1261
        if (_device_probe_geometry (dev)) {
1239
1262
                ped_exception_leave_all ();
1240
1263
        } else {
1241
 
                if (!_device_get_length (dev)) {
1242
 
                        ped_exception_catch ();
1243
 
                        ped_exception_leave_all ();
1244
 
                        goto error_close_dev;
1245
 
                }
 
1264
                if (!_device_get_length (dev)) {
 
1265
                        ped_exception_catch ();
 
1266
                        ped_exception_leave_all ();
 
1267
                        goto error_close_dev;
 
1268
                }
1246
1269
 
1247
1270
                /* hack to allow use of files, for testing */
1248
1271
                ped_exception_catch ();
1264
1287
                        case PED_EXCEPTION_IGNORE:
1265
1288
                                break;
1266
1289
                        default:
1267
 
                                PED_ASSERT (0, (void) 0);
 
1290
                                PED_ASSERT (0);
1268
1291
                                break;
1269
1292
                }
1270
1293
 
1322
1345
        PedDevice*      dev;
1323
1346
        LinuxSpecific*  arch_specific;
1324
1347
 
1325
 
        PED_ASSERT (path != NULL, return NULL);
 
1348
        PED_ASSERT (path != NULL);
1326
1349
 
1327
1350
        dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
1328
1351
        if (!dev)
1415
1438
                        goto error_free_arch_specific;
1416
1439
                break;
1417
1440
 
 
1441
        case PED_DEVICE_LOOP:
 
1442
                if (!init_generic (dev, _("Loopback device")))
 
1443
                        goto error_free_arch_specific;
 
1444
                break;
 
1445
 
1418
1446
        case PED_DEVICE_DM:
1419
1447
                {
1420
1448
                  char* type;
1453
1481
                        goto error_free_arch_specific;
1454
1482
                break;
1455
1483
 
1456
 
        case PED_DEVICE_LOOP:
1457
 
                if (!init_generic (dev, _("Loopback device")))
1458
 
                        goto error_free_arch_specific;
1459
 
                break;
1460
 
 
1461
1484
        default:
1462
1485
                ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
1463
1486
                                PED_EXCEPTION_CANCEL,
1675
1698
{
1676
1699
        LinuxSpecific*  arch_specific;
1677
1700
 
1678
 
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
1679
 
        PED_ASSERT (dev != NULL, return 0);
1680
 
        PED_ASSERT (!dev->external_mode, return 0);
 
1701
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
 
1702
        PED_ASSERT (dev != NULL);
 
1703
        PED_ASSERT (!dev->external_mode);
1681
1704
 
1682
1705
        arch_specific = LINUX_SPECIFIC (dev);
1683
1706
 
1699
1722
        LinuxSpecific*                  arch_specific;
1700
1723
        struct blkdev_ioctl_param       ioctl_param;
1701
1724
 
1702
 
        PED_ASSERT(dev != NULL, return 0);
1703
 
        PED_ASSERT(buffer != NULL, return 0);
 
1725
        PED_ASSERT(dev != NULL);
 
1726
        PED_ASSERT(buffer != NULL);
1704
1727
 
1705
1728
        arch_specific = LINUX_SPECIFIC (dev);
1706
1729
 
1734
1757
        PedExceptionOption      ex_status;
1735
1758
        void*                   diobuf = NULL;
1736
1759
 
1737
 
        PED_ASSERT (dev != NULL, return 0);
1738
 
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
 
1760
        PED_ASSERT (dev != NULL);
 
1761
        PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
1739
1762
 
1740
1763
        if (_get_linux_version() < KERNEL_VERSION (2,6,0)) {
1741
1764
                /* Kludge.  This is necessary to read/write the last
1769
1792
                        case PED_EXCEPTION_CANCEL:
1770
1793
                                return 0;
1771
1794
                        default:
1772
 
                                PED_ASSERT (0, (void) 0);
 
1795
                                PED_ASSERT (0);
1773
1796
                                break;
1774
1797
                }
1775
1798
        }
1794
1817
                        PED_EXCEPTION_ERROR,
1795
1818
                        PED_EXCEPTION_RETRY_IGNORE_CANCEL,
1796
1819
                        (status == 0
1797
 
                         ? _("end of file while reading %s")
 
1820
                         ? _("%0.0send of file while reading %s")
1798
1821
                         : _("%s during read on %s")),
1799
1822
                        strerror (errno),
1800
1823
                        dev->path);
1813
1836
                                free(diobuf);
1814
1837
                                return 0;
1815
1838
                        default:
1816
 
                                PED_ASSERT (0, (void) 0);
 
1839
                                PED_ASSERT (0);
1817
1840
                                break;
1818
1841
                }
1819
1842
        }
1829
1852
        LinuxSpecific*                  arch_specific;
1830
1853
        struct blkdev_ioctl_param       ioctl_param;
1831
1854
 
1832
 
        PED_ASSERT(dev != NULL, return 0);
1833
 
        PED_ASSERT(buffer != NULL, return 0);
 
1855
        PED_ASSERT(dev != NULL);
 
1856
        PED_ASSERT(buffer != NULL);
1834
1857
 
1835
1858
        arch_specific = LINUX_SPECIFIC (dev);
1836
1859
 
1865
1888
        void*                   diobuf;
1866
1889
        void*                   diobuf_start;
1867
1890
 
1868
 
        PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
 
1891
        PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
1869
1892
 
1870
1893
        if (dev->read_only) {
1871
1894
                if (ped_exception_throw (
1911
1934
                        case PED_EXCEPTION_CANCEL:
1912
1935
                                return 0;
1913
1936
                        default:
1914
 
                                PED_ASSERT (0, (void) 0);
 
1937
                                PED_ASSERT (0);
1915
1938
                                break;
1916
1939
                }
1917
1940
        }
1955
1978
                                free(diobuf_start);
1956
1979
                                return 0;
1957
1980
                        default:
1958
 
                                PED_ASSERT (0, (void) 0);
 
1981
                                PED_ASSERT (0);
1959
1982
                                break;
1960
1983
                }
1961
1984
        }
1974
1997
        int             status;
1975
1998
        void*           diobuf;
1976
1999
 
1977
 
        PED_ASSERT(dev != NULL, return 0);
 
2000
        PED_ASSERT(dev != NULL);
1978
2001
 
1979
2002
        if (!_device_seek (dev, start))
1980
2003
                return 0;
2025
2048
                        case PED_EXCEPTION_CANCEL:
2026
2049
                                return 0;
2027
2050
                        default:
2028
 
                                PED_ASSERT (0, (void) 0);
 
2051
                                PED_ASSERT (0);
2029
2052
                                break;
2030
2053
                }
2031
2054
        }
2035
2058
static int
2036
2059
linux_sync (PedDevice* dev)
2037
2060
{
2038
 
        PED_ASSERT (dev != NULL, return 0);
2039
 
        PED_ASSERT (!dev->external_mode, return 0);
 
2061
        PED_ASSERT (dev != NULL);
 
2062
        PED_ASSERT (!dev->external_mode);
2040
2063
 
2041
2064
        if (dev->read_only)
2042
2065
                return 1;
2049
2072
static int
2050
2073
linux_sync_fast (PedDevice* dev)
2051
2074
{
2052
 
        PED_ASSERT (dev != NULL, return 0);
2053
 
        PED_ASSERT (!dev->external_mode, return 0);
 
2075
        PED_ASSERT (dev != NULL);
 
2076
        PED_ASSERT (!dev->external_mode);
2054
2077
 
2055
2078
        if (dev->read_only)
2056
2079
                return 1;
2070
2093
 * Motivation: accept devices looking like /dev/rd/c0d0, but
2071
2094
 * not looking like /dev/hda1 and /dev/rd/c0d0p1
2072
2095
 */
2073
 
static int
 
2096
static int _GL_ATTRIBUTE_PURE
2074
2097
_match_rd_device (const char* name)
2075
2098
{
2076
2099
        const char* pos;
2107
2130
        char            buf [512];
2108
2131
        char            part_name [256];
2109
2132
        char            dev_name [256];
 
2133
        int ok = 0;
2110
2134
 
2111
2135
        proc_part_file = fopen ("/proc/partitions", "r");
2112
2136
        if (!proc_part_file)
2113
2137
                return 0;
2114
2138
 
2115
2139
        if (fgets (buf, 256, proc_part_file) == NULL)
2116
 
                return 0;
 
2140
                goto done;
2117
2141
 
2118
2142
        if (fgets (buf, 256, proc_part_file) == NULL)
2119
 
                return 0;
 
2143
                goto done;
2120
2144
 
2121
2145
        while (fgets (buf, 512, proc_part_file)
2122
2146
               && sscanf (buf, "%d %d %d %255s", &major, &minor, &size,
2133
2157
                _ped_device_probe (dev_name);
2134
2158
        }
2135
2159
 
 
2160
        ok = 1;
 
2161
 done:
2136
2162
        fclose (proc_part_file);
2137
 
        return 1;
 
2163
        return ok;
2138
2164
}
2139
2165
 
2140
2166
struct _entry {
2142
2168
        size_t len;
2143
2169
};
2144
2170
 
2145
 
static int
 
2171
static int _GL_ATTRIBUTE_PURE
2146
2172
_skip_entry (const char *name)
2147
2173
{
2148
2174
        struct _entry *i;
2241
2267
                _probe_proc_partitions ();
2242
2268
}
2243
2269
 
 
2270
static char * _GL_ATTRIBUTE_FORMAT ((__printf__, 1, 2))
 
2271
zasprintf (const char *format, ...)
 
2272
{
 
2273
  va_list args;
 
2274
  char *resultp;
 
2275
  va_start (args, format);
 
2276
  int r = vasprintf (&resultp, format, args);
 
2277
  va_end (args);
 
2278
  return r < 0 ? NULL : resultp;
 
2279
}
 
2280
 
2244
2281
static char *dm_canonical_path (PedDevice *dev)
2245
2282
{
2246
2283
        char*           dev_name = NULL;
2267
2304
}
2268
2305
 
2269
2306
static char*
2270
 
_device_get_part_path (PedDevice* dev, int num)
 
2307
_device_get_part_path (PedDevice *dev, int num)
2271
2308
{
2272
2309
        char*           devpath;
2273
2310
        if (dev->type == PED_DEVICE_DM)
2274
2311
                devpath = dm_canonical_path (dev);
2275
2312
        else devpath = dev->path;
2276
 
        int             path_len = strlen (devpath);
2277
 
        int             result_len = path_len + 16;
2278
 
        char*           result;
2279
 
 
2280
 
        result = (char*) ped_malloc (result_len);
2281
 
        if (!result)
2282
 
                return NULL;
2283
 
 
 
2313
        size_t path_len = strlen (devpath);
 
2314
 
 
2315
        char *result;
2284
2316
        /* Check for devfs-style /disc => /partN transformation
2285
2317
           unconditionally; the system might be using udev with devfs rules,
2286
2318
           and if not the test is harmless. */
2287
 
        if (!strcmp (devpath + path_len - 5, "/disc")) {
2288
 
                /* replace /disc with /path%d */
2289
 
                strcpy (result, devpath);
2290
 
                snprintf (result + path_len - 5, 16, "/part%d", num);
2291
 
        } else if (dev->type == PED_DEVICE_DAC960
2292
 
                        || dev->type == PED_DEVICE_CPQARRAY
2293
 
                        || dev->type == PED_DEVICE_ATARAID
2294
 
                        || isdigit (devpath[path_len - 1]))
2295
 
                snprintf (result, result_len, "%sp%d", devpath, num);
2296
 
        else
2297
 
                snprintf (result, result_len, "%s%d", devpath, num);
2298
 
        if (dev->type == PED_DEVICE_DM)
2299
 
                free (devpath);
 
2319
        if (5 < path_len && !strcmp (devpath + path_len - 5, "/disc")) {
 
2320
                /* replace /disc with /part%d */
 
2321
                result = zasprintf ("%.*s/part%d",
 
2322
                                    (int) (path_len - 5), devpath, num);
 
2323
        } else {
 
2324
                char const *p = (dev->type == PED_DEVICE_DAC960
 
2325
                                 || dev->type == PED_DEVICE_CPQARRAY
 
2326
                                 || dev->type == PED_DEVICE_ATARAID
 
2327
                                 || isdigit (devpath[path_len - 1])
 
2328
                                 ? "p" : "");
 
2329
                result = zasprintf ("%s%s%d", devpath, p, num);
 
2330
        }
 
2331
 
2300
2332
        return result;
2301
2333
}
2302
2334
 
2349
2381
        return _partition_is_mounted_by_dev (part_stat.st_rdev);
2350
2382
}
2351
2383
 
 
2384
/* If partition PART is mounted, or if we encounter an out-of-memory error
 
2385
   while trying to determine its status, return 1.  Otherwise, return 0.  */
2352
2386
static int
2353
2387
_partition_is_mounted (const PedPartition *part)
2354
2388
{
2355
 
        char *part_name;
2356
 
        int status;
2357
 
        if (!ped_partition_is_active (part))
2358
 
                return 0;
2359
 
        part_name = _device_get_part_path (part->disk->dev, part->num);
 
2389
        if (!ped_partition_is_active (part))
 
2390
                return 0;
 
2391
        char *part_name = _device_get_part_path (part->disk->dev, part->num);
2360
2392
        if (!part_name)
2361
2393
                return 1;
2362
 
        status = _partition_is_mounted_by_path (part_name);
 
2394
        int status = _partition_is_mounted_by_path (part_name);
2363
2395
        free (part_name);
2364
 
        if (status)
2365
 
                return 1;
2366
 
        return 0;
2367
 
}
2368
 
 
2369
 
static int
2370
 
_has_partitions (const PedDisk* disk)
2371
 
{
2372
 
        PED_ASSERT(disk != NULL, return 0);
2373
 
 
2374
 
        /* Some devices can't be partitioned. */
2375
 
        if (!strcmp (disk->type->name, "loop"))
2376
 
                return 0;
2377
 
 
2378
 
        return 1;
 
2396
        return !!status;
2379
2397
}
2380
2398
 
2381
2399
static int
2383
2401
{
2384
2402
        PedPartition*   walk;
2385
2403
 
2386
 
        PED_ASSERT (part != NULL, return 0);
 
2404
        PED_ASSERT (part != NULL);
2387
2405
 
2388
2406
        if (_partition_is_mounted (part))
2389
2407
                return 1;
2417
2435
        const char*             vol_name;
2418
2436
        char*                   dev_name;
2419
2437
 
2420
 
        PED_ASSERT(disk != NULL, return 0);
2421
 
        PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
2422
 
                   return 0);
2423
 
 
2424
 
        if (!_has_partitions (disk))
2425
 
                return 0;
 
2438
        PED_ASSERT(disk != NULL);
 
2439
        PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
2426
2440
 
2427
2441
        if (ped_disk_type_check_feature (disk->type,
2428
2442
                                         PED_DISK_TYPE_PARTITION_NAME))
2472
2486
{
2473
2487
        struct blkpg_partition  linux_part;
2474
2488
 
2475
 
        if (!_has_partitions (disk))
2476
 
                return 0;
2477
 
 
2478
2489
        memset (&linux_part, 0, sizeof (linux_part));
2479
2490
        linux_part.pno = n;
2480
2491
        return _blkpg_part_command (disk->dev, &linux_part,
2488
2499
        const char*             vol_name;
2489
2500
        char*                   dev_name;
2490
2501
 
2491
 
        PED_ASSERT(disk != NULL, return 0);
2492
 
        PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
 
2502
        PED_ASSERT (disk != NULL);
 
2503
        PED_ASSERT (disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
2493
2504
 
2494
2505
        dev_name = _device_get_part_path (disk->dev, part->num);
2495
2506
        if (!dev_name)
2528
2539
}
2529
2540
#endif
2530
2541
 
 
2542
/* Read the integer from /sys/block/DEV_BASE/ENTRY and set *VAL
 
2543
   to that value, where DEV_BASE is the last component of DEV->path.
 
2544
   Upon success, return true.  Otherwise, return false. */
 
2545
static bool
 
2546
_sysfs_int_entry_from_dev(PedDevice const* dev, const char *entry, int *val)
 
2547
{
 
2548
        char        path[128];
 
2549
        int r = snprintf(path, sizeof(path), "/sys/block/%s/%s",
 
2550
                         last_component(dev->path), entry);
 
2551
        if (r < 0 || r >= sizeof(path))
 
2552
                return false;
 
2553
 
 
2554
        FILE *fp = fopen(path, "r");
 
2555
        if (!fp)
 
2556
                return false;
 
2557
 
 
2558
        bool ok = fscanf(fp, "%d", val) == 1;
 
2559
        fclose(fp);
 
2560
 
 
2561
        return ok;
 
2562
}
 
2563
 
2531
2564
/* Read the unsigned long long from /sys/block/DEV_BASE/PART_BASE/ENTRY
2532
2565
   and set *VAL to that value, where DEV_BASE is the last component of path to
2533
2566
   block device corresponding to PART and PART_BASE is the sysfs name of PART.
2568
2601
                                       unsigned long long *start,
2569
2602
                                       unsigned long long *length)
2570
2603
{
2571
 
        PED_ASSERT(part, return false);
2572
 
        PED_ASSERT(start, return false);
2573
 
        PED_ASSERT(length, return false);
 
2604
        PED_ASSERT(part);
 
2605
        PED_ASSERT(start);
 
2606
        PED_ASSERT(length);
2574
2607
 
2575
2608
        char *dev_name = linux_partition_get_path (part);
2576
2609
        if (!dev_name)
2623
2656
 * value.
2624
2657
 */
2625
2658
static unsigned int
2626
 
_device_get_partition_range(PedDevice* dev)
 
2659
_device_get_partition_range(PedDevice const* dev)
2627
2660
{
2628
 
        int         range, r;
2629
 
        char        path[128];
2630
 
        FILE*       fp;
2631
 
        bool        ok;
 
2661
        int range;
 
2662
        bool ok = _sysfs_int_entry_from_dev(dev, "ext_range", &range);
2632
2663
 
2633
2664
        if (dev->type == PED_DEVICE_DM)
2634
2665
                return MAX_NUM_PARTS;
2635
2666
 
2636
 
        r = snprintf(path, sizeof(path), "/sys/block/%s/ext_range",
2637
 
                     last_component(dev->path));
2638
 
        if (r < 0 || r >= sizeof(path))
2639
 
                return MAX_NUM_PARTS;
2640
 
 
2641
 
        fp = fopen(path, "r");
2642
 
        if (!fp)
2643
 
                return MAX_NUM_PARTS;
2644
 
 
2645
 
        ok = fscanf(fp, "%d", &range) == 1;
2646
 
        fclose(fp);
2647
 
 
2648
 
        /* (range <= 0) is none sense.*/
2649
 
        return ok && range > 0 ? range : MAX_NUM_PARTS;
 
2667
        if (!ok)
 
2668
                return MAX_NUM_PARTS;
 
2669
        /* both 0 and 1 mean no partitions */
 
2670
        return range > 1 ? range : 0;
2650
2671
}
2651
2672
 
2652
2673
/*
2666
2687
static int
2667
2688
_disk_sync_part_table (PedDisk* disk)
2668
2689
{
2669
 
        PED_ASSERT(disk != NULL, return 0);
2670
 
        PED_ASSERT(disk->dev != NULL, return 0);
 
2690
        PED_ASSERT(disk != NULL);
 
2691
        PED_ASSERT(disk->dev != NULL);
2671
2692
        int lpn;
2672
2693
 
 
2694
        unsigned int part_range = _device_get_partition_range(disk->dev);
 
2695
 
2673
2696
        int (*add_partition)(PedDisk* disk, const PedPartition *part);
2674
2697
        int (*remove_partition)(PedDisk* disk, int partno);
2675
2698
        bool (*get_partition_start_and_length)(PedPartition const *part,
2689
2712
 
2690
2713
        /* lpn = largest partition number. */
2691
2714
        if (ped_disk_get_max_supported_partition_count(disk, &lpn))
2692
 
                lpn = PED_MIN(lpn, _device_get_partition_range(disk->dev));
 
2715
                lpn = PED_MIN(lpn, part_range);
2693
2716
        else
2694
 
                lpn = _device_get_partition_range(disk->dev);
 
2717
                lpn = part_range;
2695
2718
 
2696
2719
        /* Its not possible to support largest_partnum < 0.
2697
2720
         * largest_partnum == 0 would mean does not support partitions.
2698
2721
         * */
2699
 
        if (lpn < 0)
 
2722
        if (lpn < 1)
2700
2723
                return 0;
2701
2724
        int ret = 0;
2702
2725
        int *ok = calloc (lpn, sizeof *ok);
2904
2927
        if (!(task = dm_task_create(DM_DEVICE_TABLE)))
2905
2928
                return 0;
2906
2929
        path = _device_get_part_path (part->disk->dev, part->num);
2907
 
        PED_ASSERT(path, return false);
 
2930
        if (!path)
 
2931
                return 0;
2908
2932
        dm_task_set_name(task, path);
2909
2933
        if (!dm_task_run(task))
2910
2934
                goto err;
2927
2951
        char*           params = NULL;
2928
2952
        LinuxSpecific*  arch_specific = LINUX_SPECIFIC (disk->dev);
2929
2953
 
2930
 
        if (!_has_partitions(disk))
2931
 
                return 0;
2932
 
 
2933
2954
        /* Get map name from devicemapper */
2934
2955
        struct dm_task *task = dm_task_create (DM_DEVICE_INFO);
2935
2956
        if (!task)
2945
2966
        dev_name = dm_task_get_name (task);
2946
2967
 
2947
2968
        if (isdigit (dev_name[strlen (dev_name) - 1])) {
2948
 
                if (asprintf (&vol_name, "%sp%d", dev_name, part->num) == -1)
 
2969
                if ( ! (vol_name = zasprintf ("%sp%d", dev_name, part->num)))
2949
2970
                        goto err;
2950
 
        } else if (asprintf (&vol_name, "%s%d", dev_name, part->num) == -1)
 
2971
        } else if ( ! (vol_name = zasprintf ("%s%d", dev_name, part->num)))
2951
2972
                goto err;
2952
2973
 
2953
2974
        /* Caution: dm_task_destroy frees dev_name.  */
2954
2975
        dm_task_destroy (task);
2955
2976
        task = NULL;
2956
2977
 
2957
 
        if (asprintf (&params, "%d:%d %lld", arch_specific->major,
2958
 
                      arch_specific->minor, part->geom.start) == -1)
 
2978
        if ( ! (params = zasprintf ("%d:%d %lld", arch_specific->major,
 
2979
                                    arch_specific->minor, part->geom.start)))
2959
2980
                goto err;
2960
2981
 
2961
2982
        task = dm_task_create (DM_DEVICE_CREATE);
3031
3052
{
3032
3053
        int ret = 1;
3033
3054
 
3034
 
        if (!_has_partitions (disk))
3035
 
                return 1;
3036
 
 
3037
3055
        /* Modern versions of udev may notice the write activity on
3038
3056
         * partition devices caused by _flush_cache, and may decide to
3039
3057
         * synthesise some change events as a result. These may in turn run
3098
3116
        if (!tp)
3099
3117
                return NULL;
3100
3118
 
3101
 
        /* If optimal_io_size is 0 _and_ alignment_offset is 0 _and_
3102
 
           minimum_io_size is a power of 2 then go with the device.c default */
3103
 
        unsigned long minimum_io_size = blkid_topology_get_minimum_io_size(tp);
3104
 
        if (blkid_topology_get_optimal_io_size(tp) == 0 &&
3105
 
            blkid_topology_get_alignment_offset(tp) == 0 &&
3106
 
            (minimum_io_size & (minimum_io_size - 1)) == 0)
3107
 
                return NULL;
 
3119
        /* When PED_DEFAULT_ALIGNMENT is divisible by the *_io_size or
 
3120
           there are no *_io_size values, use the PED_DEFAULT_ALIGNMENT
 
3121
           If one or the other will not divide evenly, fall through to
 
3122
           previous logic. */
 
3123
        unsigned long optimal_io = blkid_topology_get_optimal_io_size(tp);
 
3124
        unsigned long minimum_io = blkid_topology_get_minimum_io_size(tp);
 
3125
        if (
 
3126
            (!optimal_io && !minimum_io)
 
3127
            || (optimal_io && PED_DEFAULT_ALIGNMENT % optimal_io == 0
 
3128
                && minimum_io && PED_DEFAULT_ALIGNMENT % minimum_io == 0)
 
3129
            || (!minimum_io && optimal_io
 
3130
                && PED_DEFAULT_ALIGNMENT % optimal_io == 0)
 
3131
            || (!optimal_io && minimum_io
 
3132
                && PED_DEFAULT_ALIGNMENT % minimum_io == 0)
 
3133
           ) {
 
3134
            /* DASD needs to use minimum alignment */
 
3135
            if (dev->type == PED_DEVICE_DASD)
 
3136
                return linux_get_minimum_alignment(dev);
 
3137
 
 
3138
            return ped_alignment_new(
 
3139
                    blkid_topology_get_alignment_offset(tp) / dev->sector_size,
 
3140
                    PED_DEFAULT_ALIGNMENT / dev->sector_size);
 
3141
        }
3108
3142
 
3109
3143
        /* If optimal_io_size is 0 and we don't meet the other criteria
3110
3144
           for using the device.c default, return the minimum alignment. */