int main(int argc, char* argv[]) { PedDevice* device; PedDisk* disk; if(argc != 2) error(EXIT_FAILURE, 0, "wrong number of argument"); device = ped_device_get(argv[1]); if(device == NULL) error(EXIT_FAILURE, 0, "error getting the device"); disk = ped_disk_new(device); if(disk == NULL) { ped_device_destroy(device); error(EXIT_FAILURE, 0, "error getting the disk"); } ped_disk_delete_all(disk); ped_disk_commit(disk); ped_disk_destroy(disk); ped_device_destroy(device); return 0; }
int main(int argc, char *argv[]) { PedDevice *dev; PedDisk *disk; PedPartition *part; PedConstraint *constraint; /* * argv [1] device * [2] udv_name * [3] start * [4] end */ dev = ped_device_get(argv[1]); if (!dev) { perror("get_device"); return -1; } //disk = _create_disk_label(dev, ped_disk_type_get("gpt")); disk = ped_disk_new(dev); if (!disk) { fprintf(stderr, "fail to create disk label gpt\n"); return -2; } constraint = ped_constraint_any(dev); // part1: 17.4Kb ~ 15MB /* part = ped_partition_new(disk, PED_PARTITION_NORMAL, NULL, 34, 29296); ped_disk_add_partition(disk, part, constraint); */ // part2: 15MB ~ 35MB part = ped_partition_new(disk, PED_PARTITION_NORMAL, NULL, (int)(atoll(argv[3])/512), (int)(atoll(argv[4])/512)); ped_partition_set_name(part, argv[2]); ped_disk_add_partition(disk, part, constraint); ped_disk_commit(disk); ped_constraint_destroy(constraint); ped_disk_destroy(disk); ped_device_destroy(dev); return 0; }
PedDisk* _create_disk_label (PedDevice *dev, PedDiskType *type) { PedDisk* disk = NULL; /* Create the label */ disk = ped_disk_new_fresh (dev, type); fail_if (!disk, "Failed to create a label of type: %s", type->name); fail_if (!ped_disk_commit(disk), "Failed to commit label to device"); return disk; }
int main(int argc, char* argv[]) { PedDevice* device; PedDisk* disk_old; PedDisk* disk; PedDiskType* type; if(argc != 3) error(EXIT_FAILURE, 0, "wrong number of arguments"); device = ped_device_get(argv[1]); if(device == NULL) return -1; type = ped_disk_type_get(argv[2]); if(type == NULL) { ped_device_destroy(device); error(EXIT_FAILURE, 0, "invalid type"); return -1; } disk_old = ped_disk_new(device); printf("disk type: %s \n",disk_old->type->name); disk = ped_disk_new_fresh(device, disk_old->type); if(disk == NULL) { ped_device_destroy(device); error(EXIT_FAILURE, 0, "error formating disk"); return -1; } if(!ped_disk_commit(disk)) { ped_disk_destroy(disk); error(EXIT_FAILURE, 0, "error writing a new partition table"); return -1; } ped_disk_destroy(disk); ped_device_destroy(device); return 0; }
// commit to dev and os. bool PartitionTable::commit() { return ped_disk_commit( disk_ ) ? true : false ; }
PartitionState do_test1(PedDevice *dev, label_type labelType) { PartitionState state; //PedGeometry geom; PedDisk *disk; PedPartition *part; PedPartition *grub_partition = 0, *boot_partition = 0, *root_partition = 0; PedDiskType *type = 0; PedFileSystemType *ext4 = ped_file_system_type_get("ext4"); bool dirty = false; PedSector start = 0, end = 0; /*if (!ped_geometry_init(&geom,dev,0,dev->length)) { qDebug() << "unable to init geom"; return; }*/ disk = ped_disk_new(dev); /*type = ped_disk_probe(dev); if (type) { qDebug() << "current partition type:" << type->name; disk = type->ops->alloc(dev); if (!type->ops->read(disk)) { qDebug() << "failed to read gpt tables"; return; } }*/ if (!disk) { qDebug() << "no tables detected"; if (labelType == label_type::gpt) { type = ped_disk_type_get("gpt"); } else if (labelType == label_type::mbr) { type = ped_disk_type_get("msdos"); } disk = ped_disk_new_fresh(dev,type); ped_disk_commit(disk); } if (disk) { for (part = ped_disk_next_partition(disk,NULL); part; part = ped_disk_next_partition(disk,part)) { if (!ped_partition_is_active(part)) continue; QString name(ped_partition_get_name(part)); qDebug() << "partition" << part->num << name; if (name == "boot") boot_partition = part; if (name == "root") root_partition = part; if (ped_partition_get_flag(part,PED_PARTITION_BIOS_GRUB)) grub_partition = part; for (int f = PED_PARTITION_FIRST_FLAG; f < PED_PARTITION_LAST_FLAG; f++) { if (ped_partition_get_flag(part,(PedPartitionFlag)f)) { QString flag_name(ped_partition_flag_get_name((PedPartitionFlag)f)); qDebug() << "flag" << flag_name << "is set"; } } } PedConstraint *constraint = ped_constraint_any(dev); if (!grub_partition) { start = (1024*1024) / dev->sector_size; end = ((1024*1024) / dev->sector_size) + start; qDebug() << "creating" << start << end; grub_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,ext4,start,end); if (labelType == label_type::gpt) { ped_partition_set_name(grub_partition,"bios boot"); ped_partition_set_flag(grub_partition,PED_PARTITION_BIOS_GRUB,1); } if (!ped_disk_add_partition(disk,grub_partition,constraint)) { qDebug() << "error adding partition"; } dirty = true; } if (!boot_partition) { start = (1024*1024*2) / dev->sector_size; end = ((1024*1024*128) / dev->sector_size) + start; qDebug() << "creating" << start << end; boot_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,NULL,start,end); if (labelType == label_type::gpt) { ped_partition_set_name(boot_partition,"boot"); } //ped_partition_set_flag(boot_partition,PED_PARTITION_BOOT,1); if (!ped_disk_add_partition(disk,boot_partition,constraint)) { qDebug() << "error adding partition"; } dirty = true; } if (!root_partition) { start = (1024*1024*129) / dev->sector_size; end = dev->length; qDebug() << "creating" << start << end; root_partition = ped_partition_new(disk,PED_PARTITION_NORMAL,ext4,start,end); if (labelType == label_type::gpt) { ped_partition_set_name(root_partition,"root"); //ped_partition_set_flag(root_partition,PED_PARTITION_ROOT,1); } if (!ped_disk_add_partition(disk,root_partition,constraint)) { qDebug() << "error adding partition"; } dirty = true; } ped_constraint_destroy(constraint); } if (dirty) ped_disk_commit(disk); state.boot_path = ped_partition_get_path(boot_partition); state.root_path = ped_partition_get_path(root_partition); return state; }
gboolean disk_resize_grow(const gchar* disk_path, GChildWatchFunc async_func_watcher, gpointer data) { char command[LINE_MAX] = { 0 }; int last_partition_num; const gchar* partition_path; PedDevice* dev = NULL; PedDisk* disk = NULL; gboolean result = false; PedPartition* partition; PedSector start; PedSector end; PedGeometry geometry_start; PedGeometry* geometry_end; PedConstraint* constraint; resize_fs = false; /* to handle exceptions, i.e Fix PMBR */ ped_exception_set_handler(disk_exception_handler); if (!disk_path) { LOG(MOD "Disk path is empty\n"); return false; } dev = ped_device_get(disk_path); if (!dev) { LOG(MOD "Cannot get device '%s'\n", disk_path); return false; } /* * verify disk, disk_exception_handler will called * if the disk has problems and it needs to be fixed * and resized */ disk = ped_disk_new(dev); if (!disk) { LOG(MOD "Cannot create a new disk '%s'\n", disk_path); return false; } if (!resize_fs) { /* do not resize filesystem, it is ok */ LOG(MOD "Nothing to do with '%s' disk\n", disk_path); return false; } LOG(MOD "Resizing filesystem disk '%s'\n", disk_path); last_partition_num = ped_disk_get_last_partition_num(disk); partition = ped_disk_get_partition(disk, last_partition_num); if (!partition) { LOG(MOD "Cannot get partition '%d' disk '%s'\n", last_partition_num, disk_path); return false; } start = partition->geom.start; end = (-PED_MEGABYTE_SIZE) / dev->sector_size + dev->length; geometry_start.dev = dev; geometry_start.start = start; geometry_start.end = end; geometry_start.length = 1; geometry_end = ped_geometry_new(dev, end, 1); if (!geometry_end) { LOG(MOD "Cannot get partition '%d' disk '%s'\n", last_partition_num, disk_path); return false; } constraint = ped_constraint_new(ped_alignment_any, ped_alignment_any, &geometry_start, geometry_end, 1, dev->length); if (!constraint) { LOG(MOD "Cannot create a new constraint disk '%s'\n", disk_path); goto fail1; } if (!ped_disk_set_partition_geom(disk, partition, constraint, start, end)) { LOG(MOD "Cannot set partition geometry disk '%s'\n", disk_path); goto fail2; } if (!ped_disk_commit(disk)) { LOG(MOD "Cannot write the partition table to disk '%s'\n", disk_path); goto fail2; } partition_path = ped_partition_get_path(partition); if (!partition_path) { LOG(MOD "Cannot get partition path disk '%s'\n", disk_path); goto fail2; } snprintf(command, LINE_MAX, RESIZEFS_PATH " %s", partition_path); exec_task_async(command, async_func_watcher, data); result = true; LOG(MOD "Resizing filesystem done\n"); fail2: ped_constraint_destroy (constraint); fail1: ped_geometry_destroy (geometry_end); return result; }
void SystemPartitioner::init() { #if NONDESTRUCTIVE emit done(); return; #endif // Check # of harddisks to see if RAID0-ing them makes any sense ped_device_probe_all(); PedDevice *tmp=NULL; int disks=0; QString installsource(getenv("INSTALLSOURCE")); MSG("Install source is " + installsource); while((tmp=ped_device_get_next(tmp))) { // FIXME workaround for parted breakage // Skip CD-ROMs parted accidentally marks as harddisk QString p(tmp->path); if(!p.startsWith("/dev/sd") && (p.contains("/dev/scd") || p.contains("/dev/sr") || access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK))) continue; // It's not a good idea to install on a USB stick we're installing from... if(installsource.startsWith(p)) continue; MSG(QString("Found disk: ") + QString(tmp->path) + ":" + "/proc/ide/" + p.section('/', 2, 2) + "/" + "cache" + ":" + QString::number(access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK))); #if 0 // Check if the drive is actually there -- some empty CF // readers misidentify themselves... int fd=open(tmp->path, O_RDONLY); if(fd < 0) continue; char test; if(read(fd, &test, 1) <= 0) { close(fd); continue; } close(fd); #endif disks++; } ped_device_free_all(); // Grab all disks ped_device_probe_all(); PedFileSystemType const *ext3=ped_file_system_type_get("ext2"); // parted doesn't support ext3 creation yet, so we need this hack PedFileSystemType const *bootext3=ped_file_system_type_get("ext2"); PedFileSystemType const *swap=ped_file_system_type_get("linux-swap"); Meminfo m; unsigned long long swapsize=m.suggested_swap(); QStringList raidPartitions; PedDevice *dev=NULL; PedPartition *fspart=NULL; PedGeometry *fsgeo=NULL; setHelp(tr("Removing other OSes...")); resizeEvent(0); uint32_t bootsize=0; #ifndef NO_RAID0 if(disks>1) bootsize=32*1024*2; /* size is in 512 kB blocks --> we use 32 MB */ #endif while((dev=ped_device_get_next(dev))) { // FIXME workaround for parted breakage QString p(dev->path); if(!p.startsWith("/dev/sd") && (p.contains("/dev/scd") || p.contains("/dev/sr") || access(QFile::encodeName("/proc/ide/" + p.section('/', 2, 2) + "/cache"), R_OK))) continue; // It's not a good idea to install on a USB stick we're installing from... if(installsource.startsWith(p)) continue; //unsigned long long disksize=dev->length*dev->sector_size; PedDiskType *type=ped_disk_type_get("msdos"); PedDisk *disk=ped_disk_new_fresh(dev, type); PedGeometry *part=ped_geometry_new(dev, 0, dev->length); if(swapsize && _swap.isEmpty() && ((unsigned long long)part->length > swapsize + bootsize)) { // Split disk in swap and fs partitions PedGeometry *swapgeo=ped_geometry_new(dev, 0, swapsize); PedGeometry *bootgeo=NULL; uint32_t fssize=part->end - swapsize; uint32_t fsstart=swapsize+1; if(bootsize) { bootgeo=ped_geometry_new(dev, swapsize+1, bootsize); fssize -= bootsize; fsstart += bootsize; } fsgeo=ped_geometry_new(dev, fsstart, fssize); PedPartition *swappart=ped_partition_new(disk, (PedPartitionType)0, swap, swapgeo->start, swapgeo->end); PedPartition *bootpart=NULL; if(bootsize) bootpart=ped_partition_new(disk, (PedPartitionType)0, bootext3, bootgeo->start, bootgeo->end); fspart=ped_partition_new(disk, (PedPartitionType)0, ext3, fsgeo->start, fsgeo->end); if(bootsize) ped_partition_set_flag(fspart, PED_PARTITION_RAID, 1); ped_disk_add_partition(disk, swappart, ped_constraint_any(dev)); ped_disk_commit(disk); ped_geometry_destroy(swapgeo); setHelp(tr("Creating swap filesystem")); PedFileSystem *swapfs=ped_file_system_create(&(swappart->geom), swap, NULL /*timer->timer()*/); ped_file_system_close(swapfs); _swap = dev->path + QString::number(swappart->num); // Parted's swap creator is buggy QProcess::execute("/sbin/mkswap " + _swap); if(bootpart) { setHelp(tr("Creating boot filesystem")); ped_disk_add_partition(disk, bootpart, ped_constraint_any(dev)); ped_disk_commit(disk); PedFileSystem *bootfs=ped_file_system_create(&(bootpart->geom), bootext3, timer->timer()); ped_file_system_close(bootfs); ped_partition_set_flag(bootpart, PED_PARTITION_BOOT, 1); ped_geometry_destroy(bootgeo); QString devname=dev->path + QString::number(bootpart->num); _size.insert(devname, bootpart->geom.length); if(_rootfs == "ext3") { Ext3FS e3(devname); e3.addJournal(0); e3.setCheckInterval(0); e3.setCheckMountcount(-1); e3.setDirIndex(); } else { QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " " + devname); } if(!_postmkfs.isEmpty()) QProcess::execute(_postmkfs + " " + devname); _partitions.insert(devname, FileSystem("/boot", _rootfs)); } } else { // Grab the whole disk for filesystem fsgeo=ped_constraint_solve_max(ped_constraint_any(dev)); fspart=ped_partition_new(disk, (PedPartitionType)0, ext3, part->start, part->end); if(bootsize) ped_partition_set_flag(fspart, PED_PARTITION_RAID, 1); } ped_disk_add_partition(disk, fspart, ped_constraint_any(dev)); if(!bootsize) ped_partition_set_flag(fspart, PED_PARTITION_BOOT, 1); ped_disk_commit(disk); if(!bootsize) { setHelp(tr("Creating Linux filesystem")); PedFileSystem *fs=ped_file_system_create(&(fspart->geom), ext3, timer->timer()); _totalSize += fspart->geom.length; ped_file_system_close(fs); } ped_geometry_destroy(fsgeo); // Convert to ext3 and turn off checking QString devname=dev->path + QString::number(fspart->num); if(bootsize) raidPartitions.append(devname); else if(!_partitions.hasMountpoint("/")) _partitions.insert(devname, FileSystem("/", _rootfs)); else { QString mp(devname); mp.replace("/dev", "/mnt"); _partitions.insert(devname, FileSystem(mp, _rootfs)); } _size.insert(devname, fspart->geom.length); if(!bootsize) { if(_rootfs == "ext3") { Ext3FS e3(devname); e3.addJournal(0); e3.setCheckInterval(0); e3.setCheckMountcount(-1); e3.setDirIndex(); } else { QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " " + devname); } if(!_postmkfs.isEmpty()) QProcess::execute(_postmkfs + " " + devname); ped_disk_destroy(disk); } } if(bootsize) { setHelp(tr("Combining disks...")); // Make sure we can read the array we're building first... Modules::instance()->loadWithDeps("md"); Modules::instance()->loadWithDeps("raid0"); // Now create it FILE *f=fopen("/tmp/mdadm.conf", "w"); if(!f) QMessageBox::information(0, "debug", QString("Failed to create mdadm.conf: ") + strerror(errno)); fprintf(f, "DEVICE partitions"); fprintf(f, "ARRAY /dev/md0 name=ArkLinux devices=%s level=0 num-devices=%u\n", qPrintable(raidPartitions.join(",")), raidPartitions.count()); fprintf(f, "MAILADDR root@localhost\n"); fclose(f); QString command="/sbin/mdadm --create -e 1.2 --chunk=32 --level=0 --raid-devices=" + QString::number(raidPartitions.count()) + " --name=ArkLinux --force /dev/md0 " + raidPartitions.join(" "); QProcess::execute(command); if(_rootfs == "ext3") { QProcess::execute("/sbin/mke2fs -j /dev/md0"); Ext3FS e3("/dev/md0"); e3.setCheckInterval(0); e3.setCheckMountcount(-1); e3.setDirIndex(); } else { QProcess::execute("/sbin/mkfs." + _rootfs + " " + _mkfsopts + " /dev/md0"); } if(!_postmkfs.isEmpty()) QProcess::execute(_postmkfs + " /dev/md0"); _partitions.insert("/dev/md0", FileSystem("/", _rootfs)); _size.clear(); _size.insert("/dev/md0", _totalSize); } // We don't need a UI to take the whole system - we're done. emit done(); }