← Back to branch summary

~ubuntu-branches/ubuntu/vivid/parted/vivid

« back to all changes in this revision

Viewing changes to libparted/device.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:
libparted/device.c
1
1
/*
2
2
    libparted - a library for manipulating disk partitions
3
 
    Copyright (C) 1999 - 2001, 2005, 2007-2009 Free Software Foundation, Inc.
 
3
    Copyright (C) 1999 - 2001, 2005, 2007-2010 Free Software Foundation, Inc.
4
4
 
5
5
    This program is free software; you can redistribute it and/or modify
6
6
    it under the terms of the GNU General Public License as published by
110
110
{
111
111
        PedDevice*      dev;
112
112
 
113
 
        PED_ASSERT (path != NULL, return);
 
113
        PED_ASSERT (path != NULL);
114
114
 
115
115
        ped_exception_fetch_all ();
116
116
        dev = ped_device_get (path);
151
151
        PedDevice*      walk;
152
152
        char*           normal_path = NULL;
153
153
 
154
 
        PED_ASSERT (path != NULL, return NULL);
 
154
        PED_ASSERT (path != NULL);
155
155
        /* Don't canonicalize /dev/mapper paths, see tests/symlink.c */
156
156
        if (strncmp (path, "/dev/mapper/", 12))
157
157
                normal_path = canonicalize_file_name (path);
225
225
{
226
226
        int     status;
227
227
 
228
 
        PED_ASSERT (dev != NULL, return 0);
229
 
        PED_ASSERT (!dev->external_mode, return 0);
 
228
        PED_ASSERT (dev != NULL);
 
229
        PED_ASSERT (!dev->external_mode);
230
230
 
231
231
        if (dev->open_count)
232
232
                status = ped_architecture->dev_ops->refresh_open (dev);
247
247
int
248
248
ped_device_close (PedDevice* dev)
249
249
{
250
 
        PED_ASSERT (dev != NULL, return 0);
251
 
        PED_ASSERT (!dev->external_mode, return 0);
252
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
250
        PED_ASSERT (dev != NULL);
 
251
        PED_ASSERT (!dev->external_mode);
 
252
        PED_ASSERT (dev->open_count > 0);
253
253
 
254
254
        if (--dev->open_count)
255
255
                return ped_architecture->dev_ops->refresh_close (dev);
284
284
int
285
285
ped_device_begin_external_access (PedDevice* dev)
286
286
{
287
 
        PED_ASSERT (dev != NULL, return 0);
288
 
        PED_ASSERT (!dev->external_mode, return 0);
 
287
        PED_ASSERT (dev != NULL);
 
288
        PED_ASSERT (!dev->external_mode);
289
289
 
290
290
        dev->external_mode = 1;
291
291
        if (dev->open_count)
304
304
int
305
305
ped_device_end_external_access (PedDevice* dev)
306
306
{
307
 
        PED_ASSERT (dev != NULL, return 0);
308
 
        PED_ASSERT (dev->external_mode, return 0);
 
307
        PED_ASSERT (dev != NULL);
 
308
        PED_ASSERT (dev->external_mode);
309
309
 
310
310
        dev->external_mode = 0;
311
311
        if (dev->open_count)
324
324
ped_device_read (const PedDevice* dev, void* buffer, PedSector start,
325
325
                 PedSector count)
326
326
{
327
 
        PED_ASSERT (dev != NULL, return 0);
328
 
        PED_ASSERT (buffer != NULL, return 0);
329
 
        PED_ASSERT (!dev->external_mode, return 0);
330
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
327
        PED_ASSERT (dev != NULL);
 
328
        PED_ASSERT (buffer != NULL);
 
329
        PED_ASSERT (!dev->external_mode);
 
330
        PED_ASSERT (dev->open_count > 0);
331
331
 
332
332
        return (ped_architecture->dev_ops->read) (dev, buffer, start, count);
333
333
}
345
345
ped_device_write (PedDevice* dev, const void* buffer, PedSector start,
346
346
                  PedSector count)
347
347
{
348
 
        PED_ASSERT (dev != NULL, return 0);
349
 
        PED_ASSERT (buffer != NULL, return 0);
350
 
        PED_ASSERT (!dev->external_mode, return 0);
351
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
348
        PED_ASSERT (dev != NULL);
 
349
        PED_ASSERT (buffer != NULL);
 
350
        PED_ASSERT (!dev->external_mode);
 
351
        PED_ASSERT (dev->open_count > 0);
352
352
 
353
353
        return (ped_architecture->dev_ops->write) (dev, buffer, start, count);
354
354
}
357
357
ped_device_check (PedDevice* dev, void* buffer, PedSector start,
358
358
                  PedSector count)
359
359
{
360
 
        PED_ASSERT (dev != NULL, return 0);
361
 
        PED_ASSERT (!dev->external_mode, return 0);
362
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
360
        PED_ASSERT (dev != NULL);
 
361
        PED_ASSERT (!dev->external_mode);
 
362
        PED_ASSERT (dev->open_count > 0);
363
363
 
364
364
        return (ped_architecture->dev_ops->check) (dev, buffer, start, count);
365
365
}
374
374
int
375
375
ped_device_sync (PedDevice* dev)
376
376
{
377
 
        PED_ASSERT (dev != NULL, return 0);
378
 
        PED_ASSERT (!dev->external_mode, return 0);
379
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
377
        PED_ASSERT (dev != NULL);
 
378
        PED_ASSERT (!dev->external_mode);
 
379
        PED_ASSERT (dev->open_count > 0);
380
380
 
381
381
        return ped_architecture->dev_ops->sync (dev);
382
382
}
391
391
int
392
392
ped_device_sync_fast (PedDevice* dev)
393
393
{
394
 
        PED_ASSERT (dev != NULL, return 0);
395
 
        PED_ASSERT (!dev->external_mode, return 0);
396
 
        PED_ASSERT (dev->open_count > 0, return 0);
 
394
        PED_ASSERT (dev != NULL);
 
395
        PED_ASSERT (!dev->external_mode);
 
396
        PED_ASSERT (dev->open_count > 0);
397
397
 
398
398
        return ped_architecture->dev_ops->sync_fast (dev);
399
399
}
555
555
                default:
556
556
                        /* Align to a grain of 1MiB (like vista / win7) */
557
557
                        align = ped_alignment_new(0,
558
 
                                                  1048576 / dev->sector_size);
 
558
                                                  (PED_DEFAULT_ALIGNMENT
 
559
                                                   / dev->sector_size));
559
560
                }
560
561
        }
561
562