static int loop_write (const PedDisk* disk) { size_t buflen = disk->dev->sector_size; char *buf = ped_malloc (buflen); if (buf == NULL) return 0; if (ped_disk_get_partition (disk, 1)) { if (!ped_device_read (disk->dev, buf, 0, 1)) { free (buf); return 0; } if (strncmp (buf, LOOP_SIGNATURE, strlen (LOOP_SIGNATURE)) != 0) { free (buf); return 1; } memset (buf, 0, strlen (LOOP_SIGNATURE)); return ped_device_write (disk->dev, buf, 0, 1); } memset (buf, 0, buflen); strcpy (buf, LOOP_SIGNATURE); int write_ok = ped_device_write (disk->dev, buf, 0, 1); free (buf); return write_ok; }
bool LibPartedDevice::writeSectors(void* buffer, qint64 offset, qint64 numSectors) { if (!isExclusive()) return false; return ped_device_write(pedDevice(), buffer, offset, numSectors); }
static struct AmigaBlock * _amiga_read_block (const PedDevice *dev, struct AmigaBlock *blk, PedSector block, struct AmigaIds *ids) { if (!ped_device_read (dev, blk, block, 1)) return NULL; if (ids && !_amiga_id_in_list(PED_BE32_TO_CPU(blk->amiga_ID), ids)) return NULL; if (_amiga_checksum (blk) != 0) { switch (ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_FIX | PED_EXCEPTION_IGNORE | PED_EXCEPTION_CANCEL, _("%s : Bad checksum on block %llu of type %s."), __func__, block, _amiga_block_id(PED_BE32_TO_CPU(blk->amiga_ID)))) { case PED_EXCEPTION_CANCEL : return NULL; case PED_EXCEPTION_FIX : _amiga_calculate_checksum(AMIGA(blk)); if (!ped_device_write ((PedDevice*)dev, blk, block, 1)) return NULL; case PED_EXCEPTION_IGNORE : case PED_EXCEPTION_UNHANDLED : default : return blk; } } return blk; }
PyObject *py_ped_device_write(PyObject *s, PyObject *args) { PyObject *in_buf = NULL; PedSector start, count, ret; PedDevice *device = NULL; void *out_buf = NULL; if (!PyArg_ParseTuple(args, "OLL", &in_buf, &start, &count)) { return NULL; } device = _ped_Device2PedDevice(s); if (device == NULL) { return NULL; } out_buf = PyCapsule_GetPointer(in_buf, 0); if (out_buf == NULL) { return NULL; } if (!device->open_count) { PyErr_Format(IOException, "Device %s is not open.", device->path); return NULL; } if (device->external_mode) { PyErr_Format(IOException, "Device %s is already open for external access.", device->path); return NULL; } ret = ped_device_write(device, out_buf, start, count); if (ret == 0) { if (partedExnRaised) { partedExnRaised = 0; if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) PyErr_SetString(IOException, partedExnMessage); } else PyErr_Format(IOException, "Could not write to device %s", device->path); return NULL; } return PyLong_FromLong(ret); }
static int pc98_write (const PedDisk* disk) { PedPartition* part; int i; PED_ASSERT (disk != NULL); PED_ASSERT (disk->dev != NULL); void *s0; if (!ptt_read_sectors (disk->dev, 0, 2, &s0)) return 0; PC98RawTable *table = s0; if (!pc98_check_ipl_signature (table)) { memset (table->boot_code, 0, sizeof(table->boot_code)); memcpy (table->boot_code, MBR_BOOT_CODE, sizeof(MBR_BOOT_CODE)); } memset (table->partitions, 0, sizeof (table->partitions)); table->magic = PED_CPU_TO_LE16(PC9800_EXTFMT_MAGIC); for (i = 1; i <= MAX_PART_COUNT; i++) { part = ped_disk_get_partition (disk, i); if (!part) continue; if (!fill_raw_part (&table->partitions [i - 1], part)) return 0; } int write_ok = ped_device_write (disk->dev, table, 0, 2); free (s0); if (!write_ok) return 0; return ped_device_sync (disk->dev); }
static int amiga_write (const PedDisk* disk) { struct RigidDiskBlock *rdb; struct LinkedBlock *block; struct PartitionBlock *partition; PedPartition *part, *next_part; PedSector cylblocks, first_hb, last_hb; uint32_t * table; uint32_t i; uint32_t rdb_num, part_num, block_num, next_num; PED_ASSERT (disk != NULL); PED_ASSERT (disk->dev != NULL); PED_ASSERT (disk->disk_specific != NULL); if (!(rdb = ped_malloc (disk->dev->sector_size))) return 0; /* Let's read the rdb */ if ((rdb_num = _amiga_find_rdb (disk->dev, rdb)) == AMIGA_RDB_NOT_FOUND) { rdb_num = 2; size_t pb_size = sizeof (struct PartitionBlock); /* Initialize only the part that won't be copied over with a partition block in amiga_read. */ memset ((char *)(RDSK(disk->disk_specific)) + pb_size, 0, PED_SECTOR_SIZE_DEFAULT - pb_size); } else { memcpy (RDSK(disk->disk_specific), rdb, disk->dev->sector_size); } free (rdb); rdb = RDSK(disk->disk_specific); cylblocks = (PedSector) PED_BE32_TO_CPU (rdb->rdb_Heads) * (PedSector) PED_BE32_TO_CPU (rdb->rdb_Sectors); first_hb = (PedSector) PED_BE32_TO_CPU (rdb->rdb_RDBBlocksLo); last_hb = (PedSector) PED_BE32_TO_CPU (rdb->rdb_RDBBlocksHi); /* Allocate a free block table and initialize it. There must be room for at least RDB_NUM + 2 entries, since the first RDB_NUM+1 entries get IDNAME_RIGIDDISK, and the following one must have LINK_END to serve as sentinel. */ size_t tab_size = 2 + MAX (last_hb - first_hb, rdb_num); if (!(table = ped_malloc (tab_size * sizeof *table))) return 0; for (i = 0; i <= rdb_num; i++) table[i] = IDNAME_RIGIDDISK; for ( ; i < tab_size; i++) table[i] = LINK_END; /* Let's allocate a partition block */ if (!(block = ped_malloc (disk->dev->sector_size))) { free (table); return 0; } /* And fill the free block table */ if (_amiga_find_free_blocks(disk, table, block, PED_BE32_TO_CPU (rdb->rdb_BadBlockList), IDNAME_BADBLOCK) == 0) { ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL, _("%s : Failed to list bad blocks."), __func__); goto error_free_table; } if (_amiga_find_free_blocks(disk, table, block, PED_BE32_TO_CPU (rdb->rdb_PartitionList), IDNAME_PARTITION) == 0) { ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL, _("%s : Failed to list partition blocks."), __func__); goto error_free_table; } if (_amiga_find_free_blocks(disk, table, block, PED_BE32_TO_CPU (rdb->rdb_FileSysHeaderList), IDNAME_FILESYSHEADER) == 0) { ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL, _("%s : Failed to list file system blocks."), __func__); goto error_free_table; } if (_amiga_find_free_blocks(disk, table, block, PED_BE32_TO_CPU (rdb->rdb_BootBlockList), IDNAME_BOOT) == 0) { ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL, _("%s : Failed to list boot blocks."), __func__); goto error_free_table; } block_num = part_num = _amiga_next_free_block(table, rdb_num+1, IDNAME_PARTITION); part = _amiga_next_real_partition(disk, NULL); rdb->rdb_PartitionList = PED_CPU_TO_BE32(part ? part_num : LINK_END); for (; part != NULL; part = next_part, block_num = next_num) { PED_ASSERT(part->disk_specific != NULL); PED_ASSERT(part->geom.start % cylblocks == 0); PED_ASSERT((part->geom.end + 1) % cylblocks == 0); next_part = _amiga_next_real_partition(disk, part); next_num = _amiga_next_free_block(table, block_num+1, IDNAME_PARTITION); partition = PART(part->disk_specific); if (next_part == NULL) partition->pb_Next = PED_CPU_TO_BE32(LINK_END); else partition->pb_Next = PED_CPU_TO_BE32(next_num); partition->de_LowCyl = PED_CPU_TO_BE32(part->geom.start/cylblocks); partition->de_HighCyl = PED_CPU_TO_BE32((part->geom.end+1)/cylblocks-1); _amiga_calculate_checksum(AMIGA(partition)); if (!ped_device_write (disk->dev, (void*) partition, block_num, 1)) { ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL, _("Failed to write partition block at %d."), block_num); goto error_free_table; /* WARNING : If we fail here, we stop everything, * and the partition table is lost. A better * solution should be found, using the second * half of the hardblocks to not overwrite the * old partition table. It becomes problematic * if we use more than half of the hardblocks. */ } } if (block_num > PED_BE32_TO_CPU (rdb->rdb_HighRDSKBlock)) rdb->rdb_HighRDSKBlock = PED_CPU_TO_BE32(block_num); _amiga_calculate_checksum(AMIGA(rdb)); if (!ped_device_write (disk->dev, (void*) disk->disk_specific, rdb_num, 1)) goto error_free_table; free (table); free (block); return ped_device_sync (disk->dev); error_free_table: free (table); free (block); return 0; }