Tag: USB Flash Drive

There are many ways to create a live USB drive carrying an operating system like Ubuntu, but the method I will describe further is mainly based on using SUN’s VirtualBox. While the method described on the Ubuntu documentations implies installing a Live CD image on a USB flash drive, which would then need to extract and load the operating system in the RAM, the method that I will describe on this page implies installing a fresh operating system on a bootable flash drive that will work the same way as from a real HDD (except the speed, of course). Thus, you should have a good bootable USB 2.0, with decent I/O data processing speeds, with at least 4GB (considering that the operating system itself weighs ~2GB, Karmic Koala).
Divide your USB flash drive into two partitions

In order to separate the operating system from the documents you would like to save on the flash drive, it is advisable that you divide your USB flash drive into two partitions. Only do this if your USB flash drive has more than 2GB of space and you do not need to save changes you make inside the operating system. In order to achieve this, you need to have GParted installed (or at least this is what i prefer). If you are not following this tutorial on a Linux machine, then you’ll have to use whatever software you best know that works with your operating system (on Windows I recommend Acronis Disk Director and Partition Magic). To get GParted type the following command in a terminal:

sudo apt-get install gparted

Now backup all data you have on your USB flash drive, because we will need to format it and create two partitions. Haven’t backed up your data? You’re playing with fire!

http://mintarticles.com/read/operating-systems-articles/how-to-install-portable-linux-ubuntu-on-a-bootable-usb-flash-drive-from-sun-virtualbox,13641/

---

Advanced Topics And Tools
Grub4DOS
Super Grub Disk
Guide for MultiBoot USB-stick with boot.ini Menu

UNetbootin (Universal Netboot Installer) is a cross-platform utility that can create live USB systems and can load a variety of system utilities or install various Linux distributions and other operating systems without a CD.

This installation mode creates bootable USB flash drives and bootable USB Hard Disk Drives; it is a Live USB creator.

• Cross-platform (available for Windows, Linux and Mac OS X)
• Non-destructive install (does not format the device) using Syslinux.
• Supports mainstream Linux distributions, such as Ubuntu, Fedora, openSUSE, CentOS, Debian, Gentoo, Linux Mint, Arch Linux, Mandriva, MEPIS, Slackware as well as FreeDOS, FreeBSD and NetBSD.
• Can load a variety of system utilities, such as Ophcrack, BackTrack.
• Other operating systems can be loaded via pre-downloaded ISO image or floppy/hard drive disk image files.
• Automatically detects all removable devices.
• Supports LiveUSB persistence (preserving files across reboots; this feature is for Ubuntu only)

Multiple installs on the same device are not supported.

It is worth noting that UNetbootin’s meta-data is very out of date. For example, the latest version of Linux Mint offered in the drop-down menu is version 10, whilst the latest official release is version 14 (at time of writing, February 2013). However, UNetbootin can still be used to write a bootable Mint 14 ISO file onto a USB device, if the user first downloads the ISO file manually.

---

---

Yumi (Pendrivelinux.com) offers to be the successor of the MultibootISOs program.

I also found Sardu (sarducd.it), it is MORE GUI then the GUI of Yumi, and also offers more implicit support for Windows-based ISO’s.

Both programs come with download link and a list of confirmed distributions that work.

Placing all ISO’s in Yumi’s executable folder should add them all in once, but I got adding multiple iso’s only working with Sardu.

---

Best 20 Methods To Create a Bootable USB Flash Drive [Windows, Linux]

A search led to a recommendation that I try XBOOT. Another source suggested that SARDU and XBOOT both might be more robust than YUMI.

Were there other possibilities? An AlternativeTo webpage listed Universal USB Installer (of which UNetbootin was apparently a clone) and WinToFlash as much more popular than SARDU, XBOOT, or YUMI, but these did not appear to be multiboot solutions. That is, they would load only one program onto the USB drive. At this point, Wikipedia’s list of tools to create live USB systems did not distinguish multiboot from single-boot tools — but it did make clear that there were many single- or multiboot tools out there. One source offered a way to use UNetbootin to create a multiboot flash drive, but it, too, sounded complicated. A search suggested that EasyBCD was another possibility, but it appeared that it was a boot manager that would let you decide whether to boot from, say, a hard drive partition containing Windows 7 rather than another partition containing Linux.

So I took it as a choice among YUMI, SARDU, or XBOOT. A search led to a thread with several user reports that tended to favor YUMI. As I had also found, one comment recommended formatting within YUMI rather than formatting the USB drive via Windows Explorer. One blogpage, written in spring 2011, seemed to find little difference in capabilities, between SARDU and YUMI, except that SARDU had the advantage of allowing the user to burn a CD or DVD containing one (or possibly more) installer. Two other webpages praised SARDU, but without offering specific comparisons against alternatives like YUMI. The XBOOT webpage seemed to indicate, as others had done, that XBOOT was preprogrammed to accept far fewer programs and distributions than YUMI; the same had also seemed to be true of SARDU.

---

YUMI (Your Universal Multiboot Installer), is the successor to MultibootISOs. It can be used to create a Multiboot USB Flash Drive containing multiple operating systems, antivirus utilities, disc cloning, diagnostic tools, and more. Contrary to MultiBootISO’s which used grub to boot ISO files directly from USB, YUMI uses syslinux to boot extracted distributions stored on the USB device, and reverts to using grub to Boot Multiple ISO files from USB, if necessary.

Aside from a few distributions, all files are stored within the Multiboot folder, making for a nicely organized Multiboot Drive that can still be used for other storage purposes.

Creating a YUMI Multiboot MultiSystem Bootable USB Flash Drive
YUMI works much like Universal USB Installer, except it can be used to install more than one distribution to run from your USB. Distributions can also be uninstalled using the same tool!

---

XBOOT is yet another neat little Multiboot ISO USB Creator. It is a Windows based application that can be used to create a Live Multiboot USB or even a Multiboot ISO file that can then be burnt to a CD/DVD. XBOOT supports many Linux Distributions and Utilities, and allows you to use your choice of a Grub or Syslinux bootloader. Also included is a built in QEMU emulator (enabling you to boot an ISO from within Windows).

 

XBOOT – Multiboot ISO/USB Creator

Authors Website: http://sites.google.com/site/shamurxboot/

---

Gujin is a GPLed bootloader for the PC.

This software boots your PC and analyse your filesystems. It displays a graphical menu for you to select which system to boot. Intended to replace LILO and Loadlin, written in C with GCC, fully real mode.

Users

Download gujin boot/system loader files

 

Project detail and discuss

Get support

What can Gujin do?

It can read FAT12, FAT16, FAT32, ext2, ext3, ext4 (with constant inode size) and ISO 9660 filesystems.

It has a graphical user interface with mouse support, and can be installed on any media: floppy, hard/USB disk partitions, hard/USB disk MBR, CD/DVDROM, DVD-ram (i.e. FAT with 2048 bytes/sectors). It can also use a serial port as input/ouput instead of the screen and keyboard.

Gujin can chain-load other bootloader, load Linux kernel, has an unfinished loader of multiboot specification, but more importantly for our current interest it can load standard ELF files (more exactly GZIP compressed ELF files).

There is two major ELF variant on the PC: ELF32 (with 32 bits load address, sizes and entry point) and ELF64 (with 64 bits fields), gujin loads any of them and switch the processor in protected mode to jump to the ELF entry point.

Gujin will not try to set-up memory paging at all, that is the job of the kernel to select which kind of paging it wants – so even the 64 bits ELF files will have to handle the transition from 32 bits to 64 bits themselves (because you need paging to go to 64 bits mode).

Same for interrupts, Gujin switches to protected mode but does not re-enable interrupts, that is the job of the kernel being booted to set-up the Interrupt Decriptor Table and handle each interrupts, because BIOS will not help the kernel any more.

Gujin can also relocate the ELF file if it contains relocation information, see option –emit-relocs of the “ld” linker of the “binutils” toolchain.

Because most applications will want to collect BIOS informations before the switch to protected mode, Gujin can call in real-mode a function of the ELF file, and if this function returns zero – continue the loading process – else display an error message (for instance: “trying to execute a 64 bits application on a processor without this feature!”).

Moreover, in most cases the kernel can decide to return to the Gujin bootloader (if it did not erased it from memory), without forcing a reboot.

The Gujin bootloader is built using standard Linux tools, it does not need Linux to run (only a not-too-buggy BIOS) – but we have to assume you are running Linux to use the GNU toolchain: GCC, binutils, GZIP… to produce the ELF file for the kernel. Also, Gujin installer needs either Linux 32 bits or Linux 64 bits to run and install the Gujin bootloader on a device.

Because Windows uses another executable format, you cannot install cygwin/MinGW on windows and use the compilation toolchain directly, in this case you would have to generate a cross compiler toolchain to produce ELF files, and that is out of scope for this description (but not that difficult).

---

So enough text description, let’s try it!

The floppies being out-dated, let’s say we want to use a USB stick as our test media. In some cases, we may want to use a SD card, basically the process is the same.

We first need to check that the target PC will be able to boot that USB stick or SD card, when Gujin is installed on it.

To have increased chances of success, we will ask the Gujin installer to reformat completely this USB disk or SD card, so first backup any interresting file you have in some other place.

Then, download this gujin executable if you are using a 32 bits Linux, and that gujin64 executable if you are using a 64 bits Linux:

If you do not trust anybody, download the source file gujin-*.tar.gz, extract it in a directory and type “make” – that will produce an executable named “gujin” (even on a 64 bits Linux).

Remember to visit http://gujin.org to check if there is a newer version of Gujin, and to increase Gujin author counters and keep him happy.

Then, we reformat that dedicated USB stick as a bootable FAT filesystem, erasing all its content: first go in “root” by typing “su” or “sudo” (distribution dependant), then get the device name of you USB stick (let’s say it is /dev/sdg) (sometimes /dev/mmcblk0 for SD cards), and type:

 ./gujin /dev/sdg --disk=BIOS:0x00,auto

Depending on the size of the USB stick, that will have created either a FAT16 or a FAT32 (or even a FAT12) filesystem, but that point is not really important.

You then unplug this device, and replug it: most distribution will automatically mount the filesystem and display a window of its content: only a single file which is the bootloader itself.

To check that this filesystem is correctly created, you can type:

 /sbin/fsck.vfat /dev/sdg

With the Gujin installer parameters we used, that would have created a “superfloppy” format on our USB stick, that is currently the format most PC will be able to understand and boot from.

That does not mean your own PC will 100% boot it, due to BIOS bugs – so you need to test now that this USB stick is bootable by your PC or not: umount the USB stick, plug it in the test PC and power it on, see if Gujin is started (you will notice easily).

If it is not started try to check:

 - that the boot order in the BIOS is set to boot USB devices first
 - try the different USB devices if your BIOS has switchable items.
 - try to tell the Gujin installer to use the Extended BIOS instead by typing (--disk=EBIOS:0x00,auto is the default):
 ./gujin /dev/sdg
 - try to tell the Gujin installer to generate a real disk and not a superfloppy by:
 ./gujin --mbr /dev/sdg --disk=BIOS:0x00,auto
 - try the two previous options together:
 ./gujin --mbr /dev/sdg --disk=EBIOS:0x00,auto
 - try to use another (smaller) USB stick, some BIOS will only accept to boot from a FAT16 superfloppy

By now you should know a lot more about your BIOS, and have a bootable USB stick.

---

Then, we want to generate this ELF kernel – let’s try to generate a “hello world”: Create a file with that content:

 const char msg1[] = "Hello protected-mode text world! please reboot ..."; 
 #define STACKSIZE 64 * 1024 
 static unsigned stack[STACKSIZE / 4] __attribute__ ((aligned(32))); 

 void _start (void) 
 { 
 	/* We are flat non-paged memory and interrupt disabled */ 
 	asm (" mov %0,%%esp " : : "i" (&stack[STACKSIZE / 4])); 
 	volatile unsigned short *video_array = (volatile unsigned short *)0xB8000; 
 	unsigned cpt1; 

 	video_array += 10 * 80; /* few empty lines */ 
 	/* We want blue background color and lightgray foreground, so 0x1700: */ 
 	for (cpt1 = 0; cpt1 < sizeof(msg1) - 1; cpt1++) 
 		video_array[cpt1] = 0x1700 + msg1[cpt1]; 

 	while (1) 
 		continue; 
 }

Then compile it like (you may need to add “-fno-stack-protector” too, distribution dependant):

 $ gcc -m32 -Wall -O2 -s -static -nostartfiles -nodefaultlibs -Wl,-Ttext=0x110000 hello.c -o hello.elf

and compress it by:

 $ gzip -9 hello.elf -c > hello.kgz

You just need to copy that hello.kgz file into the USB stick, and reboot with this USB stick, you will get a menu with “hello.kgz” displayed.

If you click on this filename, you will have “Hello protected-mode text world! please reboot …” displayed (Because this hello-world do not manage graphic modes, you have to “force start kernel in text mode” in Gujin configuration).

If you want a bit more complex “hello world” applications, you should download Gujin install*.tar.gz pack .

you will find there few KGZ files, like previous example but with some addresses displayed to show the exact position of the application in memory.

You will see hello_32bits.kgz and hello_32bits_r.kgz to show the effect of relocation, and hello_64bits.kgz and hello_64bits_r.kgz to show 64 bits applications.

To get the source code, just download the file gujin*.tar.gz, and extract the corresponding c files.

To see the command used to compile them, just search the string “hello_32bits.kgz:” (with semicolon) in the file Makefile.

If you just want a real mode “hello world”, you can do that too with an ELF file where the load address is null for the code segment.

There is a limit of 64 Kbytes for real mode ELF file.

Just create a file which contains:

 /* hello_bios.c - public domain - no support whatsoever */

 /* Constant entry block, max 64 KB code+data+stack, do not touch: */
 asm (
 "	.code16gcc				n"
 "	.section .init,"ax",@progbits		n"
 "	.global _start				n"
 "_start:					n"
 //  "int $3 # if debugging with borland td.exe, started by tiny.exe	n"
 "	pushw	%ds				n"
 "	pushw	%es				n"
 "	pushw	%fs				n"
 "	pushw	%gs				n"
 "	pushfl					n"
 "	pushal					n"
 "	movw	%ss,%cs:1f+1			n"
 "	movw	%sp,%cs:2f+2			n"
 "	movw	%cs,%ax				n"
 "	movw	%ax,%ds				n"
 "	movw	%ax,%es				n"
 "	movw	%ax,%fs				n"
 "	movw	%ax,%gs				n"
 "	movw	%ax,%ss				n"
 "	movl	$0,%esp				n"
 "	cld					n"
 "	calll	main				n"
 "	movl	%eax,%cs:3f+2			n"
 "1:	movw	$0,%ax				n"
 "	movw	%ax,%ss				n"
 "2:	movl	$0,%esp				n"
 "	popal					n"
 "	popfl					n"
 "	popw	%gs				n"
 "	popw	%fs				n"
 "	popw	%es				n"
 "	popw	%ds				n"
 "3:	movl	$0,%eax				n"
 "	lretw					n"
 "	.previous				n"
 );

 /* For information about asm() construct, see GCC manual:
 http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Extended-Asm.html
   For information about BIOS services, see
 http://stanislavs.org/helppc/
 */
 enum standard_color {
 	black,		blue,		green,		cyan,
 	red,		magenta,	brown,		lightgray,
 	darkgray,	lightblue,	lightgreen,	lightcyan,
 	lightred,	lightmagenta,	yellow,		white
 	};

 /* This assumes 16 colors modes, text or graphic - i.e. not 256 colors: */
 static inline void
 VGA_writestring (const char *string, unsigned char row, unsigned char col)
 {
 	unsigned short page_attribute = 16 * blue + lightgray, strlen_string;
 	const char *endstring = string;

 	/* We cannot rely on libc to provide strlen(): */
 	while (*endstring)
 		endstring++;
 	strlen_string = endstring - string;

 	asm (
 "	xchgl	%%ebp,%4		n"
 "	int	$0x10 # writestring	n"
 "	xchgl	%%ebp,%4		n"
 		: : "a" (0x1301), "b" (page_attribute),
 		"c" (strlen_string), "d" (((unsigned short)row << 8) | col),
 		"r" (string)	/* in fact %es:%bp, but "B" (string) doesn't work */
 		);
 }

 static inline void BIOS_wait (unsigned nb_microsecond)
 {
 	unsigned short status;

 	/* Use volatile when there is at least one result, but even if the result
 		is not used, the code has to be inserted (status is the result): */
 	asm volatile ("	int	$0x15	"
 		: "=a" (status)
 		:  "a" (0x8600), "d" (nb_microsecond & 0xFFFF), "c" (nb_microsecond >> 16)
 		);
 }

 int main (void)
 {
 	VGA_writestring ("Hello BIOS world! Please wait...rn", 0, 0);
 	BIOS_wait (3 * 1000 * 1000); /* 3 seconds before returning to Gujin*/
 //	return 0x80000000; /* to return to Gujin menu */
 	return 0xA0000000; /* to return to Gujin menu, do not display "press a key to continue" */
 }

And then compile it by:

 $ gcc -m32 -Wall -Os -s -static -nostartfiles -nodefaultlibs -Wa,-R -Wl,--section-start,.init=0 hello_bios.c -o hello_bios.elf

and compress it:

 $ gzip -9 hello_bios.elf -c > hello_bios.kgz

you can copy this hello_bios.kgz to the USB stick and run it, I hope the different functions of the source file are obvious.

The Gujin bootloader is willing to let the real mode and protected mode kernel to access the bootloader internal data (like what is the current video mode, how to display strings…) as long as the kernel is licensed under the GPL license – i.e. when the GZIP kernel contains a GZIP comment describing its license. That is illustrated by cleandisk.kgz compiled form this cleandisk.c source code and linked with this linker file.

The main point about the GPL license is that it is not possible to draw a line in between Gujin possible bug and a closed source application: it is no allowed to modify Gujin data while in real mode – but there isn’t any enforcement by hardware.

Obviously, Gujin will enable you to run an ELF file with a real mode part AND a protected mode part, just have a look at the example hello_gpl.kgz and its source code hello_gpl.c.

See Also

Articles

• Bootloader

Threads

External Links

• Gujin at sourceforge.net