/[gli]/trunk/src/templates/amd64ArchitectureTemplate.py
Gentoo

Contents of /trunk/src/templates/amd64ArchitectureTemplate.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 457 - (show annotations) (download) (as text)
Wed Mar 30 00:10:50 2005 UTC (15 years, 8 months ago) by agaffney
File MIME type: text/x-python
File size: 22224 byte(s)
Patch from zahna for extra arguments to the kernel.

1 """
2 Gentoo Linux Installer
3
4 $Id: amd64ArchitectureTemplate.py,v 1.2 2005/03/30 00:10:50 agaffney Exp $
5 Copyright 2004 Gentoo Technologies Inc.
6
7
8 This fills in amd64 specific functions.
9 """
10
11 import GLIUtility, string
12 from GLIArchitectureTemplate import ArchitectureTemplate
13 from GLIException import *
14 import parted
15
16 class amd64ArchitectureTemplate(ArchitectureTemplate):
17 def __init__(self,configuration=None, install_profile=None, client_controller=None):
18 ArchitectureTemplate.__init__(self, configuration, install_profile, client_controller)
19 self._architecture_name = 'amd64'
20 # self._kernel_bzimage = "arch/i386/boot/bzImage" I don't think this is used anywhere
21
22 def install_bootloader(self):
23 "Installs and configures bootloader"
24 #
25 # THIS IS ARCHITECTURE DEPENDANT!!!
26 # This is the amd64 way.. it uses grub but must do it staticly.
27
28 if self._install_profile.get_boot_loader_pkg():
29 exitstatus = self._emerge(self._install_profile.get_boot_loader_pkg())
30 if exitstatus != 0:
31 raise GLIException("BootLoaderEmergeError", 'fatal', 'install_bootloader', "Could not emerge bootloader!")
32 else:
33 pass
34
35 if self._install_profile.get_boot_loader_pkg() == "grub":
36 self._install_grub()
37 else:
38 raise Exception("BootLoaderError",'fatal','install_bootloader',"Invalid bootloader selected:"+self._install_profile.get_boot_loader_pkg())
39
40 def _sectors_to_megabytes(self, sectors, sector_bytes=512):
41 return float((float(sectors) * sector_bytes)/ float(1024*1024))
42
43 def _add_partition(self, disk, start, end, type, fs):
44 types = { 'primary': parted.PARTITION_PRIMARY, 'extended': parted.PARTITION_EXTENDED, 'logical': parted.PARTITION_LOGICAL }
45 fsTypes = {}
46 fs_type = parted.file_system_type_get_next ()
47 while fs_type:
48 fsTypes[fs_type.name] = fs_type
49 fs_type = parted.file_system_type_get_next (fs_type)
50 fstype = None
51 if fs: fstype = fsTypes[fs]
52 newpart = disk.partition_new(types[type], fstype, start, end)
53 constraint = disk.dev.constraint_any()
54 disk.add_partition(newpart, constraint)
55
56 def partition(self):
57 import GLIStorageDevice
58 import pprint
59
60 MEGABYTE = 1024 * 1024
61 devices_old = {}
62 parts_old = {}
63 parts_new = self._install_profile.get_partition_tables()
64 drives = GLIStorageDevice.detect_devices()
65 drives.sort()
66 for drive in drives:
67 devices_old[drive] = GLIStorageDevice.Device(drive)
68 devices_old[drive].set_partitions_from_disk()
69 for part in devices_old.keys(): parts_old[part] = devices_old[part].get_install_profile_structure()
70
71 # pp = pprint.PrettyPrinter(indent=4)
72 # pp.pprint(parts_old)
73 # pp.pprint(parts_new)
74
75 for dev in parts_old.keys():
76 parted_dev = parted.PedDevice.get(dev)
77 parted_disk = parted.PedDisk.new(parted_dev)
78 if not parts_new.has_key(dev) or not parts_new[dev]:
79 print "Partition table for " + dev + " does not exist in install profile"
80 continue
81 if parts_new[dev][parts_new[dev].keys()[0]]['mb']:
82 # Change MB/%/* into sectors
83 total_sectors = parted_dev.length
84 sector_size = parted_dev.sector_size
85 total_mb = float(total_sectors * sector_size) / MEGABYTE
86 start_sector = 63
87 mb_left = total_mb
88 for part in parts_new[dev]:
89 tmppart = parts_new[dev][part]
90 if tmppart['type'] == "extended": continue
91 if tmppart['mb'][-1] == "%":
92 tmppart['mb'] = float(tmppart['mb'][:-1]) / 100 * total_mb
93 mb_left = mb_left - float(tmppart['mb'])
94 partlist = parts_new.keys()
95 partlist.sort()
96 for part in partlist:
97 if part > 4: continue
98 tmppart = parts_new[dev][part]
99 if tmppart['type'] == "extended":
100 for part_log in partlist:
101 if part < 5: continue
102 tmppart_log = parts_new[dev][part_log]
103 if not tmppart['start']:
104 tmppart['start'] = start_sector
105 if tmppart_log['mb'] == "*":
106 tmppart_log['mb'] = mb_left
107 part_bytes = int(tmppart_log['mb'] * MEGABYTE)
108 part_sectors = round(part_bytes / sector_size)
109 tmppart_log['start'] = start_sector
110 tmppart_log['end'] = start_sector + part_sectors - 1
111 tmppart['end'] = tmppart_log['end']
112 start_sector = start_sector + part_sectors
113 continue
114 if tmppart['mb'] == "*":
115 tmppart['mb'] = mb_left
116 part_bytes = int(tmppart['mb'] * MEGABYTE)
117 part_sectors = round(part_bytes / sector_size)
118 tmppart['start'] = start_sector
119 tmppart['end'] = start_sector + part_sectors - 1
120 start_sector = start_sector + part_sectors
121 else:
122 table_changed = 1
123 for part in parts_old[dev]:
124 oldpart = parts_old[dev][part]
125 newpart = parts_new[dev][part]
126 if oldpart['type'] == newpart['type'] and oldpart['start'] == newpart['start'] and oldpart['end'] == newpart['end'] and newpart['format'] == False:
127 table_changed = 0
128 else:
129 table_changed = 1
130 break
131 if not table_changed:
132 print "Partition table for " + dev + " is unchanged"
133 continue
134 parts_active = []
135 parts_lba = []
136 print "\nProcessing " + dev + "..."
137 # First pass to delete old partitions that aren't resized
138 for part in parts_old[dev]:
139 if part > 4: continue
140 oldpart = parts_old[dev][part]
141 matchingminor = 0
142 delete = 0
143 if oldpart['type'] == "extended":
144 logical_to_resize = 0
145 for part_log in parts_old[dev]:
146 if part_log < 5: continue
147 matchingminor = 0
148 delete_log = 0
149 for new_part in parts_new[dev]:
150 if new_part < 5: continue
151 tmppart = parts_new[dev][new_part]
152 if int(tmppart['start']) == int(oldpart['start']) and tmppart['format'] == False and tmppart['type'] == oldpart['type'] and int(tmppart['end']) == int(oldpart['end']):
153 matchingminor = new_part
154 print " Deleting old minor " + str(part_log) + " to be recreated later"
155 delete_log = 1
156 break
157 if int(tmppart['start']) == int(oldpart['start']) and tmppart['format'] == False and tmppart['type'] == oldpart['type'] and int(tmppart['end']) != int(oldpart['end']):
158 matchingminor = new_part
159 print " Ignoring old minor " + str(part_log) + " to resize later"
160 logical_to_resize = 1
161 break
162 if not matchingminor:
163 print " No match found...deleting partition " + str(part_log)
164 parted_disk.delete_partition(parted_disk.get_partition(part_log))
165 else:
166 if parted_disk.get_partition(part_log).get_flag(1): # Active/boot
167 print " Partition " + str(part_log) + " was active...noted"
168 parts_active.append(int(matchingminor))
169 if parted_disk.get_partition(part_log).get_flag(7): # LBA
170 print " Partition " + str(part_log) + " was LBA...noted"
171 parts_lba.append(int(matchingminor))
172 if delete_log:
173 parted_disk.delete_partition(parted_disk.get_partition(part_log))
174 if not logical_to_resize:
175 print " Deleting old minor " + str(part)
176 parted_disk.delete_partition(parted_disk.get_partition(part))
177 continue
178 for new_part in parts_new[dev]:
179 tmppart = parts_new[dev][new_part]
180 if int(tmppart['start']) == int(oldpart['start']) and tmppart['format'] == False and tmppart['type'] == oldpart['type'] and int(tmppart['end']) == int(oldpart['end']):
181 matchingminor = new_part
182 print " Deleting old minor " + str(part) + " to be recreated later"
183 delete = 1
184 break
185 if int(tmppart['start']) == int(oldpart['start']) and tmppart['format'] == False and tmppart['type'] == oldpart['type'] and int(tmppart['end']) != int(oldpart['end']):
186 matchingminor = new_part
187 print " Ignoring old minor " + str(part) + " to resize later"
188 break
189 if not matchingminor:
190 print " No match found...deleting partition " + str(part)
191 parted_disk.delete_partition(parted_disk.get_partition(part))
192 else:
193 if parted_disk.get_partition(part).get_flag(1): # Active/boot
194 print " Partition " + str(part) + " was active...noted"
195 parts_active.append(int(matchingminor))
196 if parted_disk.get_partition(part).get_flag(7): # LBA
197 print " Partition " + str(part) + " was LBA...noted"
198 parts_lba.append(int(matchingminor))
199 if delete:
200 parted_disk.delete_partition(parted_disk.get_partition(part))
201 parted_disk.commit()
202 # Second pass to resize old partitions that need to be resized
203 print " Second pass..."
204 for part in parts_old[dev]:
205 oldpart = parts_old[dev][part]
206 for new_part in parts_new[dev]:
207 tmppart = parts_new[dev][new_part]
208 if int(tmppart['start']) == int(oldpart['start']) and tmppart['format'] == False and tmppart['type'] == oldpart['type'] and int(tmppart['end']) != int(oldpart['end']):
209 print " Resizing old minor " + str(part) + " from " + str(oldpart['start']) + "-" + str(oldpart['end'])+ " to " + str(tmppart['start']) + "-" + str(tmppart['end'])
210 type = tmppart['type']
211 device = dev
212 minor = part
213 start = tmppart['start']
214 end = tmppart['end']
215 if type == "ext2" or type == "ext3":
216 total_sectors = end - start + 1
217 ret = GLIUtility.spawn("resize2fs " + device + str(minor) + " " + str(total_sectors) + "s")
218 if ret: # Resize error
219 raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize " + dev + str(minor))
220 elif type == "ntfs":
221 total_sectors = end - start + 1
222 total_bytes = int(total_sectors) * 512
223 ret = GLIUtility.spawn("ntfsresize --size " + str(total_bytes) + " " + device + str(minor))
224 if ret: # Resize error
225 raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize " + dev + str(minor))
226 else:
227 parted_fs = parted_disk.get_partition(part).geom.file_system_open()
228 resize_constraint = parted_fs.get_resize_constraint()
229 if end < (start + resize_constraint.min_size) or start != resize_constraint.start_range.start:
230 raise GLIException("PartitionError", 'fatal', 'partition', "New size specified for " + dev + str(minor) + " is not within allowed boundaries")
231 new_geom = resize_constraint.start_range.duplicate()
232 new_geom.set_start(start)
233 new_geom.set_end(end)
234 try:
235 parted_fs.resize(new_geom)
236 except:
237 raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize " + dev + str(minor))
238 print " Deleting old minor " + str(part) + " to be recreated in 3rd pass"
239 parted_disk.delete_partition(parted_disk.get_partition(part))
240 break
241 parted_disk.delete_all()
242 parted_disk.commit()
243 # Third pass to create new partition table
244 print " Third pass..."
245 for part in parts_new[dev]:
246 newpart = parts_new[dev][part]
247 new_start, new_end = newpart['start'], newpart['end']
248 if newpart['type'] == "extended":
249 print " Adding extended partition from " + str(newpart['start']) + " to " + str(newpart['end'])
250 self._add_partition(parted_disk, new_start, new_end, "extended", "")
251 elif int(part) < 5:
252 print " Adding primary partition from " + str(newpart['start']) + " to " + str(newpart['end'])
253 self._add_partition(parted_disk, new_start, new_end, "primary", newpart['type'])
254 elif int(part) > 4:
255 print " Adding logical partition from " + str(newpart['start']) + " to " + str(newpart['end'])
256 self._add_partition(parted_disk, new_start, new_end, "logical", newpart['type'])
257 if int(part) in parts_active and not newpart['format']:
258 print " Partition was previously active...setting"
259 parted_disk.get_partition(part).set_flag(1)
260 if int(part) in parts_lba and not newpart['format']:
261 print " Partition was previously LBA...setting"
262 parted_disk.get_partition(part).set_flag(7)
263 parted_disk.commit()
264 if newpart['format']:
265 if newpart['type'] == "ext2":
266 if GLIUtility.spawn("mke2fs " + dev + str(part)):
267 raise GLIException("PartitionFormatError", 'fatal', 'partition', "could't create ext2 filesystem on " + dev + str(part))
268 elif newpart['type'] == "ext3":
269 if GLIUtility.spawn("mke2fs -j " + dev + str(part)):
270 raise GLIException("PartitionFormatError", 'fatal', 'partition', "could't create ext3 filesystem on " + dev + str(part))
271 elif newpart['type'] == "linux-swap":
272 if GLIUtility.spawn("mkswap " + dev + str(part)):
273 raise GLIException("PartitionFormatError", 'fatal', 'partition', "could't create swap on " + dev + str(part))
274 elif newpart['type'] == "fat32":
275 if GLIUtility.spawn("mkfs.vfat -F 32 " + dev + str(part)):
276 raise GLIException("PartitionFormatError", 'fatal', 'partition', "could't create fat32 filesystem on " + dev + str(part))
277 elif newpart['type'] == "ntfs":
278 if GLIUtility.spawn("mkntfs " + dev + str(part)):
279 raise GLIException("PartitionFormatError", 'fatal', 'partition', "could't create ntfs filesystem on " + dev + str(part))
280
281 def _install_grub(self):
282 boot_device = ""
283 boot_minor = ""
284 root_device = ""
285 root_minor = ""
286 grub_root_minor = ""
287 grub_boot_minor = ""
288 grub_boot_drive = ""
289 grub_root_drive = ""
290 minornum = 0
291 #Assign root to the root mount point to make lines more readable
292 root = self._chroot_dir
293 file_name2 = root + "/boot/grub/device.map"
294 file_name3 = root + "/boot/grub/kernel_name"
295 file_name4 = root + "/boot/grub/initrd_name"
296 foundboot = False
297 parts = self._install_profile.get_partition_tables()
298 for device in parts:
299 for partition in parts[device]:
300 mountpoint = parts[device][partition]['mountpoint']
301 if (mountpoint == "/boot"):
302 foundboot = True
303 if (( (mountpoint == "/") and (not foundboot) ) or (mountpoint == "/boot")):
304 boot_minor = str(parts[device][partition]['minor'])
305 grub_boot_minor = str(parts[device][partition]['minor'] - 1)
306 boot_device = device
307 if mountpoint == "/":
308 root_minor = str(parts[device][partition]['minor'])
309 grub_root_minor = str(parts[device][partition]['minor'] - 1)
310 root_device = device
311 if GLIUtility.is_file(root+file_name2):
312 exitstatus = GLIUtility.spawn("rm "+root+file_name2)
313 exitstatus1 = GLIUtility.spawn("echo quit | "+ root+"/sbin/grub --device-map="+file_name2)
314 exitstatus2 = GLIUtility.spawn("ls "+root+"/boot/kernel-* > "+file_name3)
315 exitstatus3 = GLIUtility.spawn("ls "+root+"/boot/initrd-* > "+file_name4)
316 if (exitstatus1 != 0) or (exitstatus2 != 0) or (exitstatus3 != 0):
317 raise GLIException("BootloaderError", 'fatal', '_install_grub', "Error in one of THE THREE run commands")
318
319 """
320 read the device map. sample looks like this:
321 (fd0) /dev/floppy/0
322 (hd0) /dev/ide/host2/bus0/target0/lun0/disc
323 (hd1) /dev/ide/host0/bus0/target0/lun0/disc
324 (hd2) /dev/ide/host0/bus0/target1/lun0/disc
325 """
326
327 # Search for the key
328 f = open(file_name2) #open the device map
329 file = f.readlines()
330 f.close()
331 for i in range(len(file)):
332 if file[i][6:-1] == boot_device:
333 #eurika we found the drivenum
334 grub_boot_drive = file[i][1:4]
335 if file[i][6:-1] == root_device:
336 grub_root_drive = file[i][1:4]
337 if (not grub_root_drive) or (not grub_boot_drive):
338 raise GLIException("BootloaderError", 'fatal', '_install_grub',"Couldn't find the drive num in the list from the device.map")
339
340 g = open(file_name3)
341 h = open(file_name4)
342 initrd_name = h.readlines()
343 kernel_name = g.readlines()
344 g.close()
345 h.close()
346 if not kernel_name[0]:
347 raise GLIException("BootloaderError", 'fatal', '_install_grub',"Error: We have no kernel in /boot to put in the grub.conf file!")
348 kernel_name = map(string.strip, kernel_name)
349 initrd_name = map(string.strip, initrd_name)
350 if self._install_profile.get_kernel_args(): kernel_args = self._install_profile.get_kernel_args()
351 else: kernel_args = ""
352 for i in range(len(kernel_name)):
353 grub_kernel_name = kernel_name[i].split(root)[1]
354 for i in range(len(initrd_name)):
355 grub_initrd_name = initrd_name[i].split(root)[1]
356 #-------------------------------------------------------------
357 #OK, now that we have all the info, let's build that grub.conf
358 newgrubconf = ""
359 newgrubconf += "default 0\ntimeout 30\n"
360 if foundboot: #we have a /boot
361 newgrubconf += "splashimage=(" + grub_boot_drive + "," + grub_boot_minor + ")/grub/splash.xpm.gz\n"
362 else: #we have / and /boot needs to be included
363 newgrubconf += "splashimage=(" + grub_boot_drive + "," + grub_boot_minor + ")/boot/grub/splash.xpm.gz\n"
364
365 newgrubconf += "title=Gentoo Linux\n"
366 newgrubconf += "root (" + grub_boot_drive + "," + grub_boot_minor + ")\n"
367 if self._install_profile.get_kernel_config_uri() != "": #using CUSTOM kernel
368 if foundboot:
369 newgrubconf += "kernel " + grub_kernel_name[5:] + " root="+root_device+root_minor+"\n"
370 else:
371 newgrubconf += "kernel /boot"+ grub_kernel_name[5:] + " root="+root_device+root_minor+"\n"
372 else:
373 if foundboot:
374 newgrubconf += "kernel " + grub_kernel_name[5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
375 newgrubconf += root_device + root_minor + " " + kernel_args + "\n"
376 newgrubconf += "initrd " + grub_initrd_name[5:] + "\n"
377 else:
378 newgrubconf += "kernel /boot" + grub_kernel_name[5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
379 newgrubconf += root_device + root_minor + " " + kernel_args + "\n"
380 newgrubconf += "initrd /boot" + grub_initrd_name[5:] + "\n"
381
382 #-------------------------------------------------------------
383 #OK, now that the file is built. Install grub.
384 #cp /proc/mounts /etc/mtab
385 #grub-install --root-directory=/boot /dev/hda
386 #shutil.copy("/proc/mounts",root +"/etc/mtab")
387 grubinstallstring = "echo -en 'root ("+grub_boot_drive + "," + grub_boot_minor + ")\n"
388 if not self._install_profile.get_boot_loader_mbr():
389 grubinstallstring +="setup ("+grub_boot_drive + "," + grub_boot_minor + ")\n"
390 else:
391 grubinstallstring +="setup ("+grub_boot_drive+")\n"
392 grubinstallstring += "quit\n' | "+root+"/sbin/grub"
393 #print grubinstallstring
394 exitstatus = GLIUtility.spawn(grubinstallstring,chroot=self._chroot_dir)
395 if exitstatus != 0:
396 raise GLIException("GrubInstallError", 'fatal', '_install_grub', "Could not install grub!")
397
398 #now make the grub.conf file
399 file_name = root + "/boot/grub/grub.conf"
400 try:
401 shutil.move(file_name, file_name + ".OLDdefault")
402 except:
403 pass
404 f = open(file_name, 'w')
405 f.writelines(newgrubconf)
406 f.close()
407 self._logger.log("Grub installed and configured.")
408
409 """
410 def _install_lilo(self):
411 boot_device = ""
412 boot_minor = ""
413 root_device = ""
414 root_minor = ""
415 minornum = 0
416 #Assign root to the root mount point to make lines more readable
417 root = self._chroot_dir
418 file_name3 = root + "/boot/grub/kernel_name"
419 foundboot = False
420 parts = self._install_profile.get_partition_tables()
421 for device in parts:
422 for partition in parts[device]:
423 mountpoint = parts[device][partition]['mountpoint']
424 if (mountpoint == "/boot"):
425 foundboot = True
426 if (( (mountpoint == "/") and (not foundboot) ) or (mountpoint == "/boot")):
427 boot_minor = str(parts[device][partition]['minor'])
428 boot_device = device
429 if mountpoint == "/":
430 root_minor = str(parts[device][partition]['minor'])
431 root_device = device
432 exitstatus0 = GLIUtility.spawn("ls "+root+"/boot/kernel-* > "+file_name3)
433 exitstatus1 = GLIUtility.spawn("ls "+root+"/boot/initrd-* >> "+file_name3)
434 if (exitstatus0 != 0) or (exitstatus1 != 0):
435 raise GLIException("BootloaderError", 'fatal', '_install_lilo', "Error in one of THE TWO run commands")
436 g = open(file_name3)
437 kernel_name = g.readlines()
438 g.close()
439 if not kernel_name[0]:
440 raise GLIException("BootloaderError", 'fatal', '_install_lilo',"Error: We have no kernel in /boot to put in the grub.conf file!")
441 kernel_name = map(string.strip, kernel_name)
442 kernel_name[0] = kernel_name[0].split(root)[1]
443 kernel_name[1] = kernel_name[1].split(root)[1]
444 if self._install_profile.get_kernel_args(): kernel_args = self._install_profile.get_kernel_args()
445 else: kernel_args = ""
446 #-------------------------------------------------------------
447 #time to build the lilo.conf
448 newliloconf = ""
449 if self._install_profile.get_boot_loader_mbr():
450 newliloconf += "boot="+boot_device+" # Install LILO in the MBR \n"
451 else:
452 newliloconf += "boot="+boot_device+boot_minor+" # Install LILO in the MBR \n"
453 newliloconf += "prompt # Give the user the chance to select another section\n"
454 newliloconf += "timeout=50 # Wait 5 (five) seconds before booting the default section\n"
455 newliloconf += "default=gentoo # When the timeout has passed, boot the \"gentoo\" section\n"
456 newliloconf += "# Only if you use framebuffer. Otherwise remove the following line:\n"
457 if not self._install_profile.get_kernel_bootsplash():
458 newliloconf += "#"
459 newliloconf += "vga=788 # Framebuffer setting. Adjust to your own will\n"
460 newliloconf += "image=/boot"+kernel_name[0][5:]+" \n"
461 newliloconf += " label=gentoo \n read-only \n root=/dev/ram0 \n"
462 newliloconf += " append=\"init=/linuxrc ramdisk=8192 real_root="+root_device+root_minor + " " + kernel_args + "\" \n"
463 newliloconf += " initrd=/boot"+kernel_name[1][5:] + "\n\n"
464 newliloconf = self._lilo_add_windows(newliloconf)
465 #now make the lilo.conf file
466 file_name = root + "/etc/lilo.conf"
467 try:
468 shutil.move(file_name, file_name + ".OLDdefault")
469 except:
470 pass
471 f = open(file_name, 'w')
472 f.writelines(newliloconf)
473 f.close()
474 #-------------------------------------------------------------
475 #OK, now that the file is built. Install lilo.
476 exitstatus = GLIUtility.spawn("/sbin/lilo",chroot=self._chroot_dir)
477 if exitstatus != 0:
478 raise GLIException("LiloInstallError", 'fatal', '_install_lilo', "Running lilo failed!")
479 self._logger.log("Lilo installed, configured, and run.")
480
481 def _lilo_add_windows(self, newliloconf):
482 parts = self._install_profile.get_partition_tables()
483 for device in parts:
484 for partition in parts[device]:
485 if (parts[device][partition]['type'] == "vfat") or (parts[device][partition]['type'] == "ntfs"):
486 newliloconf += "other="+device+str(parts[device][partition]['minor'])+"\n"
487 newliloconf += "label=Windows_P"+str(parts[device][partition]['minor'])+"\n\n"
488 return newliloconf
489 """

Properties

Name Value
svn:eol-style native

  ViewVC Help
Powered by ViewVC 1.1.20