Ok, I just did a trial of this, using the
Finnix Live CD finnix-111-ppc.iso (155MB)
https://ftp.osuosl.org/pub/finnix/111/finnix-ppc-111.iso
EDIT: I made a remastered version of finnix which includes pv, socat, and lzop:
https://forums.macrumors.com/threads/remastered-finnix-live-cd-with-pv-socat-lzop.2384155/
Finnix doesn't have socat, but it does have nc (netcat), which will also work, but doesn't automatically terminate the connection when the file transfer is complete (you'll have to wait until the transfer rate drops to zero and then use CTRL+c to kill it).
It also doesn't have lzop, which means we'll probably be limited to about 11MB/s by 100mbit ethernet.
On the receiving machine (an M1 Mac Mini), I run:
Code:
socat tcp4-listen:9999 - | pv | gzip -1 > /tmp/ibookg3.sda.dd.gz
Note: this receiving machine is a modern Mac, so I installed socat with `brew install socat` and pv with `brew install pv`.
On the sending machine (the Mac being backed up, an iBook G3 in this case), boot Finnix, then use mac-fdisk to print the partition of the disk, just to be sure you have the right device name:
Then to send the backup, run:
Code:
dd if=/dev/sda bs=64k | nc 192.168.1.98 9999
A note on compression:
I used gzip to compress the disk image to save storage space, because a raw disk image of a 40GB disk will take up 40GB, even if you've only have 30GB of files on that disk.
However, note that when you delete a file, the filesystem doesn't actually overwrite the file with zero's, it just marks that area as free space. So in our "30GB of files" scenario, it is entirely possible that the 10GB of free space might be full of junk which doesn't compress very well (e.g. binary files, mp3's, videos, etc).
To get the smallest disk image, you can zero-out the free space before booting into Finnix. Then the 10GB of free space will compress to basically zero, even when using `gzip -1` (gzip's fastest setting).
On the Mac being backed up, before booting into Finnix (i.e. while still booted into Tiger / Leopard), open a terminal and run:
Code:
dd if=/dev/zero of=/tmp/zeros bs=64k ; rm -f /tmp/zeros
If you are curious about the progress, in another terminal you can run:
Code:
while true ; do du -sh /tmp/zeros ; sleep 1 ; done
(Note: this is where lzop would really shine -- transferring that 10GB of zeros would be waaaay faster if compressed by lzop on the sending side)
Also note that if the receiving machine is fast enough, you don't need to bother with gzip's `-1` flag. For example, my receiving machine is an M1 Mac Mini, which is fast enough that gzip's default setting exceeds the limits of 100mbit ethernet, so compression isn't the bottleneck (and I could just use `gzip` rather than `gzip -1`):
and just for comparison, here's how much faster lzop is!!!:
(It is likely that even a G3 Mac could sustain more than 11MB/s of lzop compression, meaning that you could use it on the sending side and speed up the transfer)
EDIT: indeed, even a 400MHz G3 can sustain 22MB/s of lzop compression:
UPDATE: Ok, the transfer finished, and the behavior is that `nc` is still running (doing nothing), but `socat` exits successfully:
So when socat exits on the receiving Mac, just hit CTRL+c on the sending Mac to kill nc and then reboot.