SyntaxHighlighter

Freitag, 14. Dezember 2012

Stage 4 - Installation


Eine Stage 4  Archiv ist vergleichbar mit einem Backup des aktuellen Systemes  es wird fast genauso installiert wie ein Stage 3 Archiv.

Herunterladen und installieren

Als 1. müssen wir das Installationsverzeichnis erzeugen und betreten, falls dies noch nicht geschehen ist:
# mkdir -p ~/raspberry_files/rbp_root
# cd ~/raspberry_files/rpb_root
[OPTIONAL] Einhängen der SD-Karte (mounten):
# mount /dev/sda2 ~/raspberry_files/rbp_root
# mount /dev/sda1 ~/raspberry_files/rbp_root/boot


Danach müssen wir das aktuelle zRpi Stage4 Archiv herunterladen:
# wget http://www.simple-co.de/zRpi-stage4_20121214.tar.bz2
Nun müssen wir das heruntergeladene Archiv entpacken via:
# tar -xvjpf zRpi-stage4-20121214.tar.bz2
Als Letztes müssen noch wichtige device-nodes erstellt werden:
# mknod -m 660 /mnt/gentoo/dev/console c 5 1
# mknod -m 660 /mnt/gentoo/dev/null c 1 3
# mknod -m 600 /mnt/gentoo/dev/initctl p
# mknod -m 660 /mnt/gentoo/dev/tty1 c 4 1
Als nächstes geht es mit "Portage einrichten" weiter.

Donnerstag, 13. Dezember 2012

Mounten verschiedener Partitionen aus einem Image

Test von prettyprint... und nebenbei ein vielleicht nützliches Script zum Mounten verschiedener Partitionen aus ein und dem selben Abbild(image).

Code (auch auf  PasteBin: mm_loop.sh):
#!/bin/bash
# multi partition from one image-file mounter
# 2012 Armas Spann

I_FILE=$1
I_NAME=$(echo $I_FILE | sed -e 's/\./\n/g' | head -1)
B_SIZE=$(/sbin/fdisk -l $I_FILE | grep physical | sed -e 's/\/ /\n/g' | tail -n 1 | sed 's/ bytes//g')

TMP_FILE=$(mktemp)
P_CNT=$#
P_MNT=$2

#creating tempfile:
$(/sbin/fdisk -l $I_FILE | grep $I_NAME | grep -v "$I_FILE:" | sed -e 's/\*/\ /g' > $TMP_FILE)

#checking root privileges
if [[ ${EUID} == 0 ]] ; then
  ROOT=1
else
  ROOT=0
fi

function chkinput {
  if [ $P_CNT -ne 2 ]; then
    howuse
  else
    if [ ! -f $I_FILE ] && [ ! -d $P_MNT ]; then
      echo -e "File or mountpoint not found!"
      quit
    else
      selectpartition
    fi
  fi
}

function howuse {
  echo -e "Usage:"
  echo -e "$0  "
  quit
}

function quit {
  rm $TMP_FILE
  unset ROOT
  unset I_FILE
  unset I_NAME
  unset OFFSET
  unset LIMIT
  unset MNT_CMD
  unset what
  unset FS
  unset B_SIZE
  i=0; while [ $i -lt $idx ]; do
    unset P_TABLE[$i]
    i=$(($i+1))
  done
  unset i
  unset idx
  unset P_CNT
  unset P_MNT
  exit
}


#fetching partitions...
idx=0; while read partition; do idx=$(($idx+1));
  if [ "$(echo $partition | awk '{print $5}')" != "82" ]; then
    P_TABLE+=( [$idx-1]="$partition" )
  else
    idx=$(($idx-1))
  fi
done < $TMP_FILE


function selectpartition {
  #output...
  clear
  echo blocksize is: $B_SIZE bytes
  echo found $idx mountable Partitions:
  i=0; while [ $i -lt $idx ]; do
    echo $(($i+1))": ${P_TABLE[$i]}"
    i=$(($i+1))
  done

  #if not root
  if [ "$ROOT" != "1" ]; then
    echo -e "\nSorry u have to be \"root\" to do the mounting stuff..."
    echo -e "ERROR: NO ROOT-ACCESS!"
    quit
  fi

  # select partition
  while :
  do
  read -p "Please choose one of them to mount by number(or 'q' to quit): " -n1 what
  echo -e ""
  case $what in          
    "q") echo -e "Bye... ;-)"; quit
      ;;
    *) if [ $what -gt "0" ] && [ $(($what-1)) -lt $idx ]; then
        TMP_IDX=$(($what-1))
        echo -e "\nYour choice: \n${P_TABLE[TMP_IDX]}"
        read -p "Is this correct? (y/n): " -n1 what
        echo -e "\n"
        if [ $what == "y" ]; then
          OFFSET=$(($(echo ${P_TABLE[TMP_IDX]}|awk '{print $2}')*$B_SIZE))
          LIMIT=$(($(echo ${P_TABLE[TMP_IDX]}|awk '{print $4}')*$B_SIZE))
          read -p "Please enter filesystem (mount option -t): " FS
          MNT_CMD="mount -o loop,ro,offset=$OFFSET,sizelimit=$LIMIT $I_FILE -t $FS $P_MNT"
          mountit
        else
          selectpartition
        fi
      else
        echo -e "Wrong Choice, try again."
        selectpartition
      fi
      ;;
    esac
  done
}

function mountit {
  #should i mount it for you?
  while :
  do
    echo -e "Should i mount it for you? \nCommand: $MNT_CMD"
    read -p "(y/n):" -n1 what
    echo -e ""
    if [ $what == "y" ]; then
      $($MNT_CMD)
      echo -e "Done..."
      quit
    else
      selectpartition
    fi
  done
}

chkinput

Mittwoch, 12. Dezember 2012

Crossdev für den Host

Installation von "crossdev" um ARM Pakete zu kompilieren

Vorab, dieser Punkt wird euch eine Menge Zeit ersparen den Kernel des neuen Systems zum ersten mal zu erstellen. Mit meiner aktuellen Konfiguration braucht mein RaspberryPi (Model B 512) für einen clean-build des Kernels(ohne git pull/clone und ohne crossdev/distcc) ca. 8 Stunden in 2 Jobs.

Q: Gut, was ist "crossdev" eigentlich?
A: "Crossdev" ist eine Sammlung von Tools die das Erstellen(Kompilieren) für eine andere als die auf dem Host verwendete Architektur ermöglichen. In unserem Fall können wir also mit unserem x86/amd86/... Computer ARM-Pakete und Programme erstellen.

Wenn das HostOS nicht Gentoo Linux oder Arch Linux ist, benutzt bitte vorkompilierte Kernel Dateien und die dazugehörigen Module. Ihr braucht in dem Fall also nicht weiterlesen, sondern könnt direkt zu (comming soon) springen. 

Um "crossdev" unter Gentoo zu installieren, ist lediglich folgender Befehl nötig:
# emerge -a crossdev
Nun muss noch die "toolchain"(enthält u.A. gcc,glibc) für ARM erstellt werden:
# crossdev -S -v -t armv6j-hardfloat-linux-gnueabi

So, nun könnt ihr nen Kaffee trinken, oder ein neues Terminal Fenster öffnen.. ;) und mit (comming soon) fortfahren.

Portage einrichten

Die aktuelle "Portage" einrichten

Da nun das Stage- und somit auch das Basissystem unseres RaspberryPi's vorhanden ist, können wir nun mit der Einrichtung des aktuellen "Portage-Snapshots" (die Portage enthält alle Meta-Informationen zu den für Gentoo verfügbaren Installtionsquellen und Paketen, sie ist das Software Management Tool für Gentoo) beginnen.  

Als Erstes betreten wir wieder unser späteres SD-Karten Wurzelverzeichnis:
# cd ~/raspberry_files/rbp_root/

Danach laden wir den aktuellen Portage-Snapshop via "wget" herunter:
# wget http://distfiles.gentoo.org/snapshots/portage-latest.tar.bz2

Als Letztes müssen wir ihn noch in das richtige Verzeichnis extrahieren:
# tar xjvpf portage-latest.tar.bz2 -C /mnt/raspberrypiroot/usr

Als Nächstes können wir nun den Cross-Compiler installieren.

Stage 3 - Installation

Herunterladen und Installieren

Nachdem die SD-Karte partitioniert ist, und wir die aktuelle Firmware heruntergeladen haben können wir nun mit der Installation eines "Stage 3"-Tarballs fortfahren. (alternativ - Stage 4 zRpi build)

Bevor wir fortfahren müssen wir den SD-Karten Verzeichnisbaum unseres RaspberryPi erstellen, dies tun wir mit folgendem Befehl:
# mkdir -p ~/raspberry_files/rbp_root/boot
[OPTIONAL] Einhängen der SD-Karte (mounten):
# mount /dev/sda2 ~/raspberry_files/rbp_root
# mount /dev/sda1 ~/raspberry_files/rbp_root/boot

Nun müssen wir in das zukünftige Raspberry Wurzelverzeichnis wechseln:
# cd ~/raspberry_files/rbp_root/

Stage 3 - Archiv herunterladen:
(Eine Auflistung der aktuellen Stage 3 Tarrbals findet sich hier: http://distfiles.gentoo.org/)
# wget http://distfiles.gentoo.org/releases/arm/autobuilds/current-stage3-armv6j_hardfp/stage3-armv6j_hardfp-YYYYMMDD.tar.bz2

Stage 3 - Archiv entpacken:
# tar xfj stage3-armv6j_hardfp-YYYYMMDD.tar.bz2 -C ~/raspberry_files/rbp_root/


Als nächstes geht es mit "Portage einrichten" weiter.

SD-Karte für Installtion vorbereiten

Partitionierung der SD-Karte

Generell benötigt man für eine Gentoo-Instaltion auf dem RaspberryPi drei Partitionen. Die Erste und wichtigste Partition ist die "boot"-Partition diese muss vom Typ "FAT32 (LBA)" (hex-id: 0x0C) sein. Des Weiteren benötigt man eine wurzel Partition (/), diese enthält später das System, sie sollte ruhig großzügig gewählt werden. Als Letztes benötigt man noch eine Swap-Partition, diese sollte mind. 512 MB groß sein, falls der RAM, was beim Raspberry durchaus mal passieren kann, zu knapp wird.

nach der erfolgreichen Partitionierung sollte der Aufruf von "fdisk -l /dev/<device-node>" etwa folgendes liefern:
Disk /dev/sda: 7948 MB, 7948206080 bytes
81 heads, 10 sectors/track, 19165 cylinders, total 15523840 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *          10      250289      125140    c  W95 FAT32 (LBA)
/dev/sda2          250290    14524109     7136910   83  Linux
/dev/sda3        14524110    15523839      499865   82  Linux swap 

In diesem Fall habe ich 3 Partitionen angelegt:
  • /boot - 128 MB (Partition 1) !! "boot"-Flag nicht vergessen !!
  • / - 7 GB (Partition 2)
  • swap - 512 MB (Partition 3)
Nachdem die Partitionen angelegt sind sollte man sie Formatieren, bzw. das jeweilige Dateisystem erstellen. Dies machen wir mit folgenden Befehlen:

# mkfs.vfat /dev/sda1
# mkfs.ext4 /dev/sda2
# mkswap /dev/sda3

Bootloader/Firmware Vorbereitung

Firmware für den aktuellen Kernel (3.6.xx) vorbereiten

Um die Firmware für den Aktuellen Raspberry Kernel zu bekommen müssen wir diese zuerst aus dem RaspberryPi GIT Repositorium laden. Dies tun wir am besten mit Linux (Windows geht auch, hier werde ich aber ausschließlich die Installation mit der Benutzung eines Linux Computers erläutern).

Um die aktuelle "master" Branch der Firmware zu klonen müssen wir folgenden Befehl ausführen:
  1. Erstellung eines Ordners für sämtlich RaspberryPi Dateien:
    # mkdir ~/raspberry_files
  2. Betreten des "raspberry_files" Ordners im aktuellen $HOME des Users:
    # cd ~/raspberry_files
  3. Laden der Firmware Dateien:
     # git clone https://github.com/raspberrypi/firmware.git -b master /firmware-master
    Alternativ:
     # wget https://github.com/raspberrypi/firmware/archive/master.zip
     # unzip master.zip -d ./ && rm master.zip
Nun haben wir uns die aktuelle Firmware geladen und können mit der installation des aktuellen des "Stage-4"-Archives, alternativ mit der installation des "Stage-3"-Archives fortfahren.