First, backup your image before you start anything![]

Warning: Make a Backup is before doing anything else! Be sure Linux is not running. This makes it safe to work on the Linux Virtual HD.

Since you use your Host Operating System (Windows XP) to perform the Linux commands and copy files, this method is faster than performing the same steps under coLinux.

Methods to expand the Root filesystem[]

This way seems more complicated, but it is faster and safer. A backup is inclusive by doing it this way. You will need the same free disk space as compared to a backup, increase filesize, and resize the new image. One advantage, you need less free disk space because you can create the new image as a sparse file.
This method is extremely dangerous and can damage an existing image. At first, it seems faster, but, we strongly recommend you make a backup, so it ends up not being faster as the first method. If you don't create a backup, then it is faster, and needs less free disk space as the method above. In some cases you have limits on the filesystem and the proces will fail.
This does not make the root filesystem bigger, but it adds more space at a mount point in the filesystem and gives the root filesystem some free space. For example, if you move the /home, /usr or /opt into additional image file. This is a good idea if you are creating your system. Or later, if you feel  your /home directory needs more space and the system can use the another 2 to 4GB. Splitting /home and the rest make an upgrade or system change easier.

The differences between the methods are: some need the complete Cygwin shell, others use only a subset of commands (e.g. fs2resize.exe) and others use only Windows tools and do the rest in Linux.

Copy all files into new created image[]

 If you made a backup of your current running system you won't need to do it again.

1) From windows, create a blank file 5*1024*1024*1024 bytes long.

  • 1 GB = 1073741824
  • 2 GB = 2147483648
  • 4 GB = 4294967296
  • 5 GB = 5368709120
  • 8 GB = 8589934592
  • x GB = x*1024^3

open a command prompt and run

fsutil file createnew "C:\New.img" 5368709120

(If you do not have fsutil, see HowtoCreateSwapFile.)

2) Edit the colinux configuration file to add the blank file as a new device,


and restart colinux.

3) Switch into single user mode. init s (or shutdown now)

4) Format filesystem. mkfs.ext3 /dev/cobd1

5) Create a mount point and mount the new filesystem from the cobd device:

      mkdir /tmp/mnt
      mount /dev/cobd1 /tmp/mnt (that's /dev/cobd/3 on GenToo)

(Do not mount it on mnt: the cp -x will not work there!)

6) Copy contents to new device. cp -ax / /tmp/mnt

7) Copy device nodes (only if you have a udev system, i.e. kernel 2.6+). if [ -d /dev/.udev ]; then cp -a /dev/* /tmp/mnt/dev/; fi  

8) Ensure the file /tmp/mnt/etc/fstab does not have 'labels'. Use only /dev/cobd... there.

9) Check the parition size with df -h

10) Unmount new device. umount /dev/cobd1

11) Shut down coLinux. shutdown -h now

12) From windows, edit your config file again. Change the entry of the old device to use the newly created file. Then remove the entry created above.

13) Restart coLinux. You should have a larger filesystem (use "df -h" to check).

Keep the old file until you're sure the new one works!


Resize an existing image[]

TopoResize - resize root file systems via GUI TopoResize will create new images or enlarge/shrink existing images using the ext2 or ext3 file system. It's still pretty new (and may have bugs), so use at your own risk. (There is in fact a bug where it won't work when your image filename has a space in it.) However, if you're squeezed for disk space, this program can be a real lifesaver! It uses a GUI, and is "newbie friendly.". The options are pretty straightforward.

This tool will increase the file size, resize the file system and check the file system integrity. The programs behind this tool are Linux file systems tools ported to Cygwin. TopoResize is also a good source for getting cygwin ports of e2fsprogs. It is just a tcl/tk front end for them, so advanced users can use them at the command line.

Before you start this tool, be sure you are not running other Cygwin shells. You can run only one Cygwin.dll at a time!

  • Ensure coLinux is not running, and your root file is an ext2 or ext3 file system.
  • NOW is a good time to make a Backup of the current image file. Copy the file into a separate directory.
  • Download the tool from Chris Semler
  • Unpack the zip
  • Run the batch file toporesize.bat
  • Click to find file and select your image file, for example Debian-3.0r0.ext3.1gb
  • The current size will be shown on the slider
  • Use the filesize slider to choose your new size
  • Click the button resize file

TopoResize can now be found at Chris Semler (the author's webpage) or from one of the following mirrors:

The fastest way to enlarge the root partition (live)[]

Using dd[]

WARNING: Data loss possible! This method has a limit on how much bigger the resulting image can be, see here.

Download dd for Windows:

Calculate size of root image in 16K blocks: Assuming root image size is 1 gigabyte / 16384 = 65472 blocks

Enlarge root image: (seek= argument specifies old image size, in blocks, count= specifies how much to add, in blocks)

    dd bs=16384 if=/dev/zero of=root.img seek=65472 count=100000

Resize partition online using ext2resize[]

On Ubuntu, you'll need to download the deb file first, as it's no longer in the repository: (ext2online installs in /usr/sbin, so you'll only see this as root)

dpkg -i ext2resize_1.1.19-9_i386.deb
ext2online /dev/cobd0

On Debian, kernel 2.6.17, coLinux 0.8.0 snapshot:

    apt-get install ext2resize
    ext2online /dev/cobd0


Resize partition online using resize2fs[]

Alternatively, you can use resize2fs, which is part of e2fsprogs. This may be preferable on an Ubuntu system as it is still in the repository.

apt-get install e2fsprogs
resize2fs /dev/cobd0


Toporesize - Command line tool[]

As an alternate to dd, you can use toporesize (from within windows) (see

Resize to a 10G image:

C:\Program Files\andLinux\ImageResizeTool\toporesize-0.7.1>tfile ..\..\Drives\base.vdi 10000

Duplicate raw data and resize[]

I started with a 1GB partition and tried to resize it with topresize. Despite making the size around 10GB, the resulting file only had another 1GB available and using topresize to change the file a second time resulted in a kernel panic when it tried to mount the resulting file system.

I used toprestore to create an empty 32GB file without any problems and mounted it on a second mount point, but I always want my filesystem inside a single file to make it simpler to back up.


  • NTFS file system.
  • fsutil.exe
  • Enough space on disk.

Back up your image file file now![]

In the last 36 years, I have told users "If you reach the point where you wouldn't want to do it all again, you should have already backed it up." Do they listen? Guess.

The simplest option is to create a folder and copy your original image file into it and then create a config file that points to the file in the new location.


In the following:

  • {old} = old image name
  • {new} = new image name
  • {size} = the number of bytes to add to the image

The size is in bytes (thanks MS) but you can always copy it out of Windoze calculator. A power of two is a very good plan, so multiply your required size by 1,024 * 1,024 for megs and by another 1,024 for gigs.

Open a command window, navigate to the folder that you want to use, then type:

fsutil file createnew bigfile {size}

This creates a sparse file of the required size. Never copy this file or it will magically shrink from umpteen gigs to a couple of K! Instead, type:

fsutil file setvaliddata bigfile {size}

This will make the file less sparse, type:

copy {old} /b + bigfile /b {new}

Note the /b option specifying binary format for both files - omitting this will make the copy very fast and the output file very small.

{new} should now contain an image file of the original size with {size} bytes free on the pseudo partition.

Start up CoLinux using the alternative config file that specifies {new} and log in as root.

Assuming {new} is mapped in as /dev/cobd0, type:

resize2fs /dev/cobd0

This will expand the image file to the maximum extent available in {new}.

All that remains is to delete bigfile and move the new file over to your preferred folder.

Enjoy :D

Several more complex ways to make a bigger root partition:[]

First, look at the very bottom of this page. There is a fairly easy way described how to resize root. You only need a very small program (mksparse) and no cygwin. Worked very well for me. Philipp

by Joe Wells ( on 2004-08-07

Here is a precise step-by-step guide, with error checking, to enlarge your coLinux root partition. These instructions were inspired by the earlier version which is appended below. These instructions make a copy of your current root partition, except larger.

These instructions improve on the earlier ones in that (1) they are more detailed, (2) they contain error checking steps to ensure nothing has gone wrong, (3) the invocation of dd is rearranged so that calculating the correct numbers to use is easier, and (4) they do not need you to install the ext2 file system tools under Cygwin (important because the standard Cygwin installer does not know where to find them).

Background and Requirements[]

This procedure is for ext3 file systems. It should also work for ext2 file systems, but I have not tried this. Only minor adaptations should be needed for reiserfs or XFS file systems. The earlier instructions appended below should have the necessary adaptations.

This procedure assumes your current coLinux root partition is 2 gigabytes (2 * 1024 * 1024 * 1024 = 2147483648 bytes) in size and that you want to expand it to 4 gigabytes (4 * 1024 * 1024 * 1024 = 4294967296 bytes). If your current and desired sizes are different, it should be easy for you to adapt the instructions. Your host version of Windows must support files of the desired size.

This procedure needs disk space for both your current and new coLinux root partitions, because you will be using them simultaneously. Your current coLinux root partition is not* enlarged, but rather a new partition is created that is a larger version of your current partition.

This procedure assumes you have the Cygwin environment installed on your Windows host machine, including at least these programs: bash, dd, cmp, ls, cp. If you don't have Cygwin installed, it should be easy to substitute equivalent Windows actions for everything but the instructions using dd. If you can't get dd, see the instructions for using dd for an understanding of how you might substitute some equivalent action.

This procedure assumes that your current coLinux root partition has at least these programs installed on it: resize2fs, e2fsck, shutdown, mkdir, bc, mount, umount, echo (or your shell has echo built in).

In the instructions below, the old root partition file is named gentoo-i586-ext3-2g-deluxe, the old coLinux configuration file is named default.colinux.conf, the new enlarged root partition file is named gentoo-i686-ext3-4g, and the new coLinux configuration file is named gentoo-i686-ext3-4g.colinux.conf. You *must* replace these names by the names you are actually using.

Each step is marked with "Linux", "Cygwin", or "Windows" depending on whether you need to do the step in your running coLinux, on Windows using the Cygwin tools, or just on Windows with any text editor.

The Steps[]

1. Linux: Shut down coLinux to insure sane state of root filesystem:

      shutdown -h now

2. Cygwin: Copy old root partition, adding 2g of empty blocks at end:

      dd if=/dev/zero bs=1k count=2M |
      cat gentoo-i586-ext3-2g-deluxe - > gentoo-i686-ext3-4g

(replace the 2 in 2M by the number of gigabytes you are adding. 2M does NOT mean "2 Megabytes" but 2 Million times a block of 1 kByte (bs=1k), so you get 2 Million * 1 kByte = 2 Gigabyte)

Please remember that copying from and to the same disk 'does' take some time.

It _might_ take an hour or more for a 10GB size file on a fast computer !

3. Cygwin: Verify new partition file has correct contents:

      cmp gentoo-i586-ext3-2g-deluxe gentoo-i686-ext3-4g

(should report binary files identical up to end of 1st file:

"cmp: EOF on gentoo-i586-ext3-2g-deluxe"

(seems to take at least as long as the initial copying)

4. Cygwin: Verify new partition file has correct size:

      ls -l gentoo-i686-ext3-4g
      echo '4 * 1024 * 1024 * 1024' | bc

(the number output from bc should be the size of gentoo-i686-ext3-4g in bytes)

5. Cygwin: Copy old coLinux configuration file:

      cp default.colinux.conf gentoo-i686-ext3-4g.colinux.conf

6. Windows: Edit the new configuration file to add the new partition:

      cobd2="c:\Program Files\coLinux\gentoo-i686-ext3-4g"

(the number 2 should actually be the next unused number in your configuration file)

7. Cygwin: Boot coLinux using the new configuration file which still uses the old root partition:

      colinux-daemon.exe @gentoo-i686-ext3-4g.colinux.conf

8. Linux: Check that the file system we are expanding is in fact in good shape:

      nice --adjustment=+19 e2fsck -fv /dev/cobd2

(WARNING: The number 2 in /dev/cobd2 must match the number 2 in index="2" above. Check also with the mount program that /dev/cobd2 is not already mounted. If you make a mistake in choosing the correct partition number here, you will probably destroy your existing partitions!)
(-f forces checking, -v means verbose)
(the nice command isn't really needed for a fast machine and a small filesystem)

9. Linux: Use resize2fs in Linux to resize copied file system on new partition:

      resize2fs -p /dev/cobd2

(-p for progress indication (optional)

10. Linux: Check that the new number of blocks reported by resize2fs (1048576 blocks) multiplied by the block size (1024 * 4 = 4096 bytes) is correct:

      echo '1048576 * 4 * 1024' | bc

11. Linux: Check that the expanded file system is still in good shape:

      nice --adjustment=+19 e2fsck -fv /dev/cobd2

(-f forces checking, -v means verbose)
(the nice command isn't really needed for a fast machine and a small filesystem)

12. Linux: Mount the resized file system and "exercise" it:

      mkdir /tmp/newfs
      mount -t ext3 /dev/cobd2 /tmp/newfs

... various commands to test things are okay ...

      umount /tmp/newfs

13. Linux: Shut down coLinux to allow coLinux to use the new larger file system as root:

      shutdown -h now

14. Windows: Edit the new configuration file to replace old root partition with the new enlarged partition:

      cobd0="c:\Program Files\coLinux\gentoo-i686-ext3-4g"

(you must comment out or remove the line pointing to of the old root partition and change the line pointing to the new partition per the instructions above)

15. Cygwin: Boot coLinux with the new configuration and the new root partition:

      colinux-daemon.exe @gentoo-i686-ext3-4g.colinux.conf

16. Linux: Test that it works!

The earlier (before 2004-08-07) instructions follow this point.

the SAFE way is the same way I create multiple gentoo images:

Requirements: 3 Images

  1. source image
  2. target image
  3. small, bootable image

A large chunk of spare disk space.

Boot image 3, when you get to a login, mount image 1 as /mnt/oldroot. mount image2 as /mnt/newroot (create the filesystem, if necessary).

Now, do ‘cp -ax /mnt/oldroot/* /mnt/newroot/’ and it'll copy all the files.

This is not, however, GROWING the filesystem, it's just making the file biger.

Actually growing a file system[]

This is VERY dangerous ground where ext3 is concerned.[]

For reiserfs and XFS it's not that big of a deal.

in cygwin, go to the directory the image is in.

# cd /colinux

find the image size:

# ls -al *img
* rw-r--r-- 1 root root 4294967296 Feb 27 03:32 test-img

What we want to do, is dd onto the end of that file, I'm assuming the block size is 16K, although most systems will perform better at 32K.

This means our file is:

  • filesize(bytes)/1024(bytes/K) K


  • 4192350KB

but we need blocks, not K, so we divide by blocksize now(16K)

  • 4192350/16=262021

this means our image is 262021 16K blocks long... now that we know that, we use dd.

Let me summarize what info we have so far:

  • filename=test-img
  • blocksize=16K
  • filesize =262021 BLOCKS

We need to figure out how much larger we want it (keep in mind, some file systems don't like files larger than 2gb, which may require a Raid solution). Lets assume we want to add 1GB. We need to find out how many 16K blocks that is. 1GB*(1024MB/GB)*(1024KB/MB)/(16KB/BLOCK} or 65536 this means we want the new image to be 65536 blocks larger than the original.


here's where we start the grow. I'll explain it as we go... We know so far:

our file is './test-img'
it is 262021 blocks long
but we want to make it 65536 blocks longer
where all those blocks are 16K
this translates to the following dd command:
dd if=/dev/zero of=./test-img bs=16K seek=262021 count=65536'
if=/dev/zero reads from /dev/zero
of=./test-img writes to ./test-img
bs=16K read/write 16K blocks
seek=262021 skip the first 26021 blocks
count=65536 write 65,536 blocks.
this should execute 'relatively' fast. 2-3 minutes.
another option is to do seek=262021+65536 count=1
this is considered 'safe' but I don't have experience with it.
We've now grown the IMAGE… we still need to grow the actual filesystem.

Growing the filesystem[]

I'll assume you know what filesystem the file is (probably ext3). it should be stated in the filename. To resize ext3, you need to install the filesystem tools for that filesystem in cygwin. For XFS, it's xfs_growfs, which needs to be run from within Colinux while the filesystem is mounted rw. For ext2, it's resize2fs which is in the e2fsprogs package, available from (does also build under Cygwin) for sanity's sake (the method I KNOW that works)

resize2fs test-img

and you should be done. If you resize the image under cygwin install the e2fsprogs package. The tools e2fsck and resize2fs.exe are located under /usr/sbin. On cygwin:

  c:\colinux> /usr/sbin/e2fsck -f test-img
  c:\colinux> /usr/sbin/resize2fs.exe test-img <new-size>
  c:\colinux> /usr/sbin/e2fsck -f test-img

(For the image size <new-size>, the units K, M, and G are valid. E.g 2400M, 3.4G)

<Gniarf>here is one small issue: under FAT32, you are not limited to 4 Gb but to 4 Gb minus 2 bytes (check it if you dont believe me). for some reasons I believe it is safer to use 4095 Mb than 4096 here, there may be some nasty issues when co Linux tries to write down there, resulting in possible corruption of the coLinux image.

<GarrettSerack> Using MkSparse to make larger growable root filesystem: I used this to create a 10 gig sparse file, and moved the root filesystem over to it. On Windows:

   c:\colinux> mksparse 10gigfs 10G

Alternatively you could also use fsutil as described in HowtoCreateSwapFile which is included in Windows XP and above:

   c:\colinux> fsutil file createnew 10gigfs 10 737 418 240

Add it to the colinux config:


Boot into colinux Login in as root, and perform the following:

   # dd if=/dev/cobd0 of=/dev/cobd3 bs=1k count=2M
   # e2fsck -fv /dev/cobd3
   # resize2fs -p /dev/cobd3
   # e2fsck -fv /dev/cobd3

(remark from Dennis De Winter: replace /dev/cobd0 and /dev/cobd3 by /dev/cobd/0 and /dev/cobd/3 when using Gentoo dedicated to kernel 2.6 !!!!) Shut down coLinux to allow coLinux to use the new larger file system as root:

      shutdown -h now

Remove the old root, and use the one you just made:


Change device 0 to:


Adding new mount point[]

Create more drivespace by making a new drive and mount it "/"[]

'Note: despite what it says below, this method is not faster, nor is there any reason to assume it is safer. 07:33, 9 December 2007 (UTC)

The (safest) fastest possible way to expand your coLinux drive's space is to create a new virtual drive file in your Window's c:\colinux directory and use coLinux's Linux commands (maybe Cygwin or QEmu too) to re-initialize it as an ext3 type drive.

You can start the "shutdown -h now" procedure in coLinux and ALT-TAB to Windows while what comes next is being done.

First get a file on your Windows system (could be ANY file, but it would be more sensible if it had a size that was 1024^x - EG: 100M or 2 gigabytes, not 123456789 bytes), I suggest you use your swap file but you will need to wait for coLinux to finish shutting down before you can use it.

If you want to make whatever file you use bigger, click [START], click "Run" and type "cmd" (hit return) - this shells you to DOS.

Type this:

cd c:\colinux
copy /b swap_2048Mb+swap_2048Mb drive_1.ext3.4GB

That will take two 2GB swap files and combine them to make one 4GB file. It will do so as quickly as your operating system can do it. That might take 20 minutes for some people. Add additional "+swap_2048"'s to increase the size further.

If you just want to use your swap file "as-is" (the size that it is) then copy it to a different directory (slow), rename it, then copy it back (instant) using Explorer and a few mouse clicks.

Now you should have a file called c:\colinux\drive_1.ext3.4GB .

Edit your configuration file (might be called c:\colinux\coLinux.conf) and add this after all your other drives (root / swap / cdrom etc.) :

# A second (virtual) HD - 4 GB in size

Save the file and start coLinux the usual way.

Type the following to initialize the file to a Linux ext3 type, double check that it is correctly sized, and check the file system for problems:

mke2fs -b 1024 -j -v /dev/cobd3
e2fsck -f /dev/cobd3
resize2fs -p /dev/cobd3
e2fsck -f /dev/cobd3

Remember to use the correct number above where it says "/dev/cobd3". You might need 2 or 4 - but NEVER 0. Don't use "0". That should only take 5 minutes for a 10 GB file.

If everything is OK, mount it. If something went wrong re-check your typing. At worst the file on your computer will not be any good, but what use was the file made from a couple of spare files copied together?

You might do something wrong and make the file "c:\colinux\drive_1.ext3.4GB") unusable as a coLinux directory when you type (for example) "ls -l /tmp/newfs" (or wherever it is mounted).

You can NOT wreck your Windows drives (in coLinux) with the above commands (or something close, but wrong). You can NOT wreck your coLinux drives (in coLinux) with the above commands (or something close, but wrong). Thus, this method is quite safe.

To use the new drive immediately:

mkdir /tmp/newfs
mount -t ext3 /dev/cobd3 /tmp/newfs

Type "df". You should see something like this:

Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/cobd0            14449712  12817036   1339076  91% /
/dev/cobd3            10318744      8472   9890842   1% /tmp/newfs

You can delete the "lost+found" directory if it exists, you don't want two of them.

rm -r /tmp/newfs/lost+found

If you want to move some files from the origonal drive to the new drive type:

cp -r --preserve=all /somedirectory/* /tmp/newfs/

Now you can erase "somedirectory" after checking that it copied OK. When you remove "somedirectory" you can make it re-appear by mounting the copied directory "/dev/cobd3" to "somedirectory" and then your coLinux drive will look exactly like it did before you started (and nothing will break). You will have extra space on your drive that you did not have before, that will be the only visible change.

Your coLinux directory (on Windows) (c:\colinux) will look slightly different since there will be a new file and the coLinux configuration file will have been edited. Other than that Windows will look the same as it did before. If this is not the case, you need to re-read these instructions.

For Debian (and some other systems) you can auto-mount the file by creating an fstab entry. Type "nano /etc/fstab" and add a line like this:

/dev/cobd3    /somedirectory     ext2    suid,dev,exec     0     2

When you re-boot and type "ls -l /" you should see a directory called "somedirectory" in your root directory. That directory is actually the file on your Windows system called "c:\colinux\drive_1.ext3.4GB". You can copy files from other directories (like /root/downloads) to the new /somedirectory/dowanlods directory and it will look like you made your root dirve bigger. The two seperate Windows files will operate as one big HD on your coLinux system. You can do this many times. Each time you do it you are creating a new drive so there is a disk limit to consider.

After you reboot you can test if it is OK and delete "/tmp/newfs".

If you mess up (a little) in coLinux you will only wreck your "/dev/cobd3" file. Make sure you use "/dev/cobd?" (whatever comes AFTER the other, existing cobdX files) and DON'T use "/dev/cobd0" in any of the above instructions (no matter what you think you are try to do). This guarantees that your system WILL boot when you re-start and you won't loose everything (as you might with some of the following methods - they warn about this in some of those methods below).

The resulting Linux file system will appear as it did before you started so all your scripts will still work and you won't need to edit any configuration files.