Friday, 15 April 2016

Linux Commands Useful for Any Linux

LINUX COMMANDS

Here are some fundamental and common Linux commands with example usage:

FILESYSTEM

LS

Lists the content of the current directory (or one that is specified). Can be used with the -l flag to display additional information (permissions, owner, group, size, date and timestamp of last edit) about each file and directory in a list format. The-a flag allows you to view files beginning with . (i.e. dotfiles).

CD

Changes the current directory to the one specified. Can use relative (i.e.cd directoryA) or absolute (i.e. cd /home/pi/directoryA) paths.

PWD

Displays the name of the current working directory, i.e. pwd will output something like /home/pi.

MKDIR

Makes a new directory, e.g. mkdir newDir would create the directory newDirin the present working directory.

RMDIR

Remove empty directories, e.g. rmdir oldDir will remove the directoryoldDir only if it is empty.

RM

Removes the specified file (or recursively from a directory when used with -r). Be careful with this! Files deleted in this way are mostly gone for good!

CP

Makes a copy of a file and places it at the specified location (essentially doing a 'copy-paste'), for example - cp ~/fileA /home/otherUser/ would copy the filefileA from your home directory to that of the user otherUser (assuming you have permission to copy it there!). This command can either take FILE FILE(cp fileA fileB), FILE DIR (cp fileA /directoryB/) or -r DIR DIR(which recursively copies the contents of directories) as arguments.

MV

Moves a file and places it at the specified location (so where cp performs a 'copy-paste', mv performs a 'cut-paste'). The usage is similar to cp, somv ~/fileA /home/otherUser/ would move the file fileA from your home directory to that of the user otherUser. This command can either take FILE FILE(mv fileA fileB), FILE DIR (mv fileA /directoryB/) or DIR DIR(mv /directoryB /directoryC) as arguments. This command is also useful as a method to rename files and directories after they've been created.

TOUCH

Either sets the last modified time-stamp of the specified file(s) or creates it if it does not already exist.

CAT

Lists the contents of file(s), e.g. cat thisFile will display the contents ofthisFile. Can be used to list the contents of multiple files, i.e. cat *.txt will list the contents of all .txt files in the current directory.

HEAD

Displays the beginning of a file. Can be used with -n to specify the number of lines to show (by default 10), or with -c to specify the number of bytes.

TAIL

Displays the end of a file. The starting point in the file can be specified either through -b for 512 byte blocks, -c for bytes, or -n for number of lines.

CHMOD

Normally used to change the permissions for a file. The chmod command can use symbols u (user that owns the file), g (the files group) , o (other users) and the permissions r (read), w (write) and x (execute). Usingchmod u+x *filename* will add execute permission for the owner of the file.

CHOWN

Changes the user and/or group that owns a file. It normally needs to be run as root using sudo e.g. sudo chown pi:root *filename* will change the owner to pi and the group to root.

SSH

Secure shell. Connect to another computer using an encrypted network connection. For more details see SSH (secure shell)

SCP

Copies a file from one computer to another using ssh. For more details see SCP (secure copy)

SUDO

Run a command as a superuser, or another user. Use sudo -s for a superuser shell. For more details see Root user / sudo

DD

Copies a file converting the file as specified. It is often used to copy an entire disk to a single file or back again eg. dd if=/dev/sdd of=backup.img will create a backup image from an SD card or USB disk drive at /dev/sdd. Make sure to use the correct drive when copying an image to the SD card as it can overwrite the entire disk.

DF

Display the disk space available and used on the mounted filesystems. Usedf -h to see the output in a human readable format using M for MBs rather than showing number of bytes.

UNZIP

Extracts the files from a compressed zip file.

TAR

Store or extract files from a tape archive file. It can also reduce the space required by compressing the file similar to a zip file.
To create a compressed file usetar -cvzf *filename.tar.gz* *directory/* To extract the contents of a file use tar -xvzf *filename.tar.gz*

PIPES

A pipe allows the output from one command to be used as the input for another command. The pipe symbol is a vertical line |. For example to only show the first 10 entries of the ls command it can be piped through the head commandls | head

TREE

Show a directory and all subdirectories and files indented as a tree structure.

&

Run a command in the background freeing up the shell for future commands.

WGET

Download a file from the web directly to the computer e.g.wget http://www.raspberrypi.org/documentation/linux/usage/commands.mdwill download this file to your computer as commands.md

CURL

Download or upload a file to/from a server. By default it will output the file contents of the file to the screen.

MAN

Show the manual page for a file. To find out more run man man to view the manual page of the man command.

SEARCH

GREP

Search inside files for certain search patterns e.g. grep "search" *.txt will look in all the files in the current directory ending with .txt for the string search.
Supports regular expressions which allows special letter combinations to be included in the search.

AWK

Programming language useful for searching and manipulating text files.

FIND

Searches a directory and subdirectories for files matching certain patterns.

WHEREIS

Finds the location or a command. Looks through standard program locations until it finds the requested command.

NETWORKING

PING

Utility usually used to check if communication can be made with another host. Can be used with default settings by just specifying a hostname (e.g.ping raspberrypi.org) or an IP address (e.g. ping 8.8.8.8). Can specify the number of packets to send with the -c flag.

NMAP

Network exploration and scanning tool. Can return port and OS information about a host or a range of hosts. Running just nmap will display the options available as well as example usage.

HOSTNAME

Displays the current hostname of the system. A privileged (super) user can set the hostname to a new one by supplying it as an argument (e.g.hostname new-host).

IFCONFIG

Displays the network configuration details for the interfaces on the current system when run without any arguments (i.e. ifconfig). By supplying the command with the name of an interface (e.g. eth0 or lo) you can then alter the configuration (check the man-page for more details).
Posted by at No comments:

RC.LOCAL configuring on Linux

RC.LOCAL

In order to have a command or program run when the Pi boots, you can add commands to the rc.local file. This is especially useful if you want to be able to plug your Pi in to power headless, and have it run a program without configuration or a manual start.
An alternative for scheduled task management is cron.

EDITING RC.LOCAL

On your Pi, edit the file /etc/rc.local using the editor of your choice. You must edit with root, for example:
sudo nano /etc/rc.local
Add commands below the comment, but leave the line exit 0 at the end, then save the file and exit.

WARNING

If your command runs continuously (perhaps runs an infinite loop) or is likely not to exit, you must be sure to fork the process by adding an ampersand to the end of the command, like so:
python /home/pi/myscript.py &
Otherwise, the script will not end and the Pi will not boot. The ampersand allows the command to run in a separate process and continue booting with the process running.
Also, be sure to reference absolute filenames rather than relative to your home folder; for example, /home/pi/myscript.py rather than myscript.py.
Posted by at No comments:

TEXT EDITORS For LINUX

TEXT EDITORS

On Linux, you have a choice of text editors. Some are easy to use but have limited functionality, others require training to use and a long time to master but offer incredible functionality.

DESKTOP GRAPHICAL EDITORS

LEAFPAD

On Raspbian, you'll find an editor called Leafpad. This is a simple editor which opens in a window like a normal application. It allows use of the mouse and keyboard, and has tabs and syntax highlighting.
You can use keyboard shortcuts such as Ctrl + S to save a file andCtrl + X to exit.

IDLE

IDLE is a Python REPL and IDE, so you can write and edit Python code in a window and run it from there.
IDLE has independent windows and syntax highlighting. It's somewhat buggy but generally ok for basic use.
You can use keyboard shortcuts like Ctrl + S to save a file, or Alt + P(previous command) and Alt + N (next command) in the REPL.
Note that IDLE uses Python2 and IDLE 3 uses Python3.

GVIM

See Vim below

COMMAND LINE EDITORS

NANO

GNU Nano is at the easy-to-use end of command line editors. It's installed by default, so use nano somefile.txt to edit a file and keyboard shortcuts likeCtrl + O to save and Ctrl + X to exit.

VI

Vi is a very old (c. 1976) command line editor, which is available on most UNIX systems and is preinstalled on Raspbian. It is succeeded by Vim (Vi Improved), which requires installation.
Unlike most editors, Vi and Vim have a number of different modes. When you open Vi with vi somefile.txt, you start in command mode which does not (directly) permit entry of text. Press i to switch to insert mode in order to edit the file, and type away. To save the file you must return to command mode, so hit the Escapekey and enter :w (followed by Enter) which is the command to write the file to disk.
To search for the word 'raspberry' in a file, make sure you're in command mode (press Escape), then type /raspberry followed by n and N to flick forward/backward through the results.
To save and exit, enter the command :wq. To exit without saving, enter the command :q!.
Depending on your keyboard configuration you may find your cursor keys don't work. In this case, you can use the H-J-K-L keys to navigate the file (which move left, down, up, and right respectively) in command mode.

VIM

Vim is an extension of Vi and works in much the same way, with a number of improvements. Only Vi is installed by default so to get the full features of Vim, install it with APT:
sudo apt-get install vim
You can edit a file in vim with vim somefile.txt. Vim also has a graphical version which opens in a window and allows interaction with the mouse. This version is installable separately:
sudo apt-get install vim-gnome
To use the graphical version of vim, use gvim somefile.txt. You can save configuration in a .vimrc file in your user's home directory. To learn more about editing in Vi and Vim, you can run vimtutor and follow the tutorial.

EMACS

GNU Emacs is the GNU flavour of command line text editors; it is powerful, extensible, and customisable. You can install it with APT:
sudo apt-get install emacs
Use keyboard combination commands such as Ctrl + X Ctrl + S to save andCtrl + X Ctrl + C to close.
Posted by at No comments:

SCHEDULING TASKS WITH CRON on Linux

SCHEDULING TASKS WITH CRON

Cron is a tool for configuring scheduled tasks on Unix systems, used to schedule commands or scripts to run periodically and at fixed intervals. Tasks range from backing up the user's home folders every day at midnight, to logging CPU information every hour.
The command crontab (cron table) is used to edit the list of scheduled tasks in operation, and is done on a per-user basis; each user (including root) has their own crontab.

CRON GUI

A graphical application for Cron is available by installing the gnome-schedulepackage:
sudo apt-get install gnome-schedule
You can then launch the program Scheduled Tasks from the main menu.

EDITING CRONTAB

Run crontab with the -e flag to edit the cron table:
crontab -e

SELECT AN EDITOR

The first time you run crontab you'll be prompted to select an editor; if you are not sure which one to use, choose nano by pressing Enter.

ADD A SCHEDULED TASK

The layout for a cron entry is made up of six components: minute, hour, day of month, month of year, day of week, and the command to be executed.
# m h  dom mon dow   command
# * * * * *  command to execute
# ┬ ┬ ┬ ┬ ┬
# │ │ │ │ │
# │ │ │ │ │
# │ │ │ │ └───── day of week (0 - 7) (0 to 6 are Sunday to Saturday, or use names; 7 is Sunday, the same as 0)
# │ │ │ └────────── month (1 - 12)
# │ │ └─────────────── day of month (1 - 31)
# │ └──────────────────── hour (0 - 23)
# └───────────────────────── min (0 - 59)
For example:
0 0 * * *  /home/pi/backup.sh
This cron entry would run the backup.sh script every day at midnight.

VIEW SCHEDULED TASKS

View your currently saved scheduled tasks with:
crontab -l

RUN A TASK ON REBOOT

To run a command every time the Raspberry Pi starts up, write @reboot instead of the time and date. For example:
@reboot python /home/pi/myscript.py
This will run your Python script every time the Raspberry Pi reboots. If you want your command to be run in the background while the Raspberry Pi continues starting up, add a space and & at the end of the line, like this:
@reboot python /home/pi/myscript.py &
Posted by at No comments:

Raspberry Pi Kernel Compilation


Raspberry Pi Kernel Compilation

Software & Distributions:
Software - an overview.
Distributions - operating systems and development environments for the Raspberry Pi.
Kernel Compilation - advice on compiling a kernel.
Performance - measures of the Raspberry Pi's performance.
Programming - programming languages that might be used on the Raspberry Pi.

Important note

The instructions provided below appears to outdated, are inconsistent and fail for the current version of the reffered repositories. Considerhttp://www.raspberrypi.org/documentation/linux/kernel/building.md, for which the cross-compilation instructions is confirmed to work. (19 March 2015, tools: 783eb21c, linux: c4ba28133).

Overview

This page explains how to rebuild the kernel image for the Raspberry Pi. There are two possible routes available:
  1. Compile on the Raspberry Pi itself
  2. Cross compile on another Linux system
Both of these routes are covered below, however, you are strongly recommended to follow the cross-compilation route. The low processing power of the Raspberry Pi means that a local compile will take many hours. A compilation of the latest kernel and modules took about 752 minutes (12h30m)!
If you want to compile an upstream kernel, rather than the Raspberry Pi Foundation's downstream kernel, please see RPi_Upstream_Kernel_Compilation for a few tips.

Example Checklist/Roadmap

This section serves to hold a new user's hand just a bit more than some of the other more generic information below in the document. To get more information on the steps in the roadmap, search this page for additional details. It assumes you can navigate filesystems, move files across systems, and have a general understanding of compiling linux kernels, filesystems, partitions, and block devices.
This series of steps yielded a successful custom/updated hardfp kernel to a stock Raspbian installation, cross compiled from an AMD 64-bit Debian system without regression on any kernel configuration options or requiring modified boot parameters. Be aware that in the worst case, you may need to overlay a stock set of kernel/modules/firmware on the Raspberry Pi if something fails. If you do not know how to do this, then a reimage of the SD card may be necessary. Assuming this is not an issue for your configuration, continue onward:
  1. Get the latest Raspberry Pi kernel source (https://github.com/raspberrypi/linux)
  2. Set an environment variable KERNEL_SRC to point to the location of the source (for example, KERNEL_SRC=/home/me/linux/ )
  3. Get the latest Raspberry Pi compiler (git clone https://github.com/raspberrypi/tools)
  4. Set an environment variable CCPREFIX to point to the location of tools (for example, CCPREFIX=/home/me/tools/arm-bcm2708/arm-bcm2708-linux-gnueabi/bin/arm-bcm2708-linux-gnueabi- )
  5. From the kernel clone location, clean the kernel source with "make mrproper"
  6. Pull the /proc/config.gz from the running Raspbian installation
  7. Prime the kernel with the old configuration by running "ARCH=arm CROSS_COMPILE=${CCPREFIX} make oldconfig"
  8. Modify the kernel configuration by either modifying the .config file or using "ARCH=arm CROSS_COMPILE=${CCPREFIX} make menuconfig"
  9. Build the new kernel by using "ARCH=arm CROSS_COMPILE=${CCPREFIX} make"
  10. Set an environment variable, MODULES_TEMP, to point to the location of the source (for example, MODULES_TEMP=/home/me/modules/ )
  11. Set aside the new kernel modules by using "ARCH=arm CROSS_COMPILE=${CCPREFIX} INSTALL_MOD_PATH=${MODULES_TEMP} make modules_install"
  12. From the tools clone location, in the mkimage directory, run "./imagetool-uncompressed.py ${KERNEL_SRC}/arch/arm/boot/zImage"
  13. Move the resulting kernel.img to the Raspberry Pi's /boot/ directory
  14. Package up the modules into an archive such that at the top level, the structure looks like this:
    • ./firmware
    • ./firmware/brcm
    • ./firmware/edgeport
    • ./firmware/emi26
    • ...
    • ./modules
    • ./modules/3.6.11+
    • ./modules/3.6.11+/kernel
    • ./modules/3.6.11+/kernel/lib
    • ./modules/3.6.11+/kernel/fs
    • ...
  15. Move the modules archive to the Raspberry Pi and extract them such that the aforementioned firmware and modules directories overwrite /lib/firmware and /lib/modules
  16. Get the latest Raspberry Pi firmware (git://github.com/raspberrypi/firmware.git)
  17. Transfer the following files from the firmware/boot directory to the Raspberry Pi /boot directory:
    • bootcode.bin
    • fixup.dat
    • start.elf
  18. Transfer the firmware/hardfp/opt directory to the Raspberry Pi /opt directory
  19. Reboot the Raspberry Pi
The Raspberry Pi should now boot with the newly configured/recompiled kernel.

Get the kernel source

The kernel source should be downloaded from the Raspberry Pi Linux section on GitHub. Although you could just compile the vanilla kernel from Kernel.org, it will not have the necessary drivers and modules for the Broadcom SoC on the Raspberry Pi. You can however apply patches from the vanilla kernel to the Raspberry Pi one - be prepared for potential compiler grumbles though!
On Jan 2014, the current is rpi-3.10.y. You can check this and other available versions by browsing Raspberry Pi Linux section on GitHub
You can download the source directly using Git. For the 3.10 branch:
git init
git clone --depth 1 git://github.com/raspberrypi/linux.git
And for the other stable code branch, change the numbers in the following to suit:
git init
git fetch git://github.com/raspberrypi/linux.git rpi-3.6.y:refs/remotes/origin/rpi-3.6.y
git checkout rpi-3.6.y
Or you can download a tarball from the same website:

Get a compiler

Next, you will need to get a version of GCC in order to build the kernel.

1. On the Raspberry Pi

Arch Linux

pacman -Syu
pacman -S gcc make

Funtoo or Gentoo Linux

emerge make bc screen

openSUSE Linux

Detailed openSUSE Raspberry Pi 12.3 Image 20130407 + 3.8.8 kernel hack tutorial witten (2013-04-22 updated) see: http://www.raspberrypi.org/phpBB3/viewtopic.php?f=87&t=40664&p=331953#p331953 The kernel compile takes about 22 hours on Raspberry Pi Model B due massive module compiles. Include all IP_VS, ARPD, Fuse-zfs, Zram and more :-)
This works as well for Debian, Fedora Remix and others (just the package install command differs):
zypper install u-boot-tools sudo gcc automake autoconf bison gettext flex libncurses5 ncurses-devel

Raspbian and PiBang

apt-get update
apt-get -y dist-upgrade
apt-get -y install gcc make bc screen ncurses-dev git

cd /usr/src
mkdir GIT; cd GIT; git init; D=`date +"%m-%d-%Y"`
git fetch --depth=1 git://github.com/raspberrypi/linux.git rpi-3.8.y:refs/remotes/origin/rpi-3.8.y
git checkout rpi-3.8.y
tar cpf rpi-3.8.y.$D.tar   rpi-3.8.y

cd /usr/src
tar xpf  GIT/rpi-3.8.y.$D.tar
rm linux
ln -s linux-rpi-3.8.y linux

cd /usr/src/linux
kversion=$(make -s kernelrelease)
cp linux/.config .config_$kversion

cd /usr/src/
# Get config-3.8.7.ipvs+krb5+arpd.tar.bz2 from the tutorial:
wget http://www.raspberrypi.org/phpBB3/download/file.php?id=3174
# Copy the .config file to /usr/src/linux: 
tar xpfj config-3.8.7.ipvs+krb5+arpd.tar.bz2


#Make the kernel and go sleep :-)
cd linux
make oldconfig
nohup make zImage dep modules &

#The next day: Install it.
cd /usr/src/linux
kversion=$(make -s kernelrelease)
echo $kversion
mkdir -p  /boot/$kversion
make ARCH=arm INSTALL_PATH=/boot/ install
cp System.map /boot/System.map-$kversion
cp System.map-$kversion /boot/System.map
make ARCH=arm modules_install INSTALL_MOD_PATH=/
make ARCH=arm INSTALL_PATH=/boot/ zinstall
cp .config /boot/config-$kversion
cp ./Module.symvers  /boot/symvers-$kversion
cp arch/arm/boot/Image /boot/kernel.img

2. Cross compiling from Linux

Please note that when cross-compiling, your compiler may not target the correct ARM processor by default. This will at best reduce performance, or worse, compile for a much newer processor resulting in illegal instructions in your code. The pre-built compiler or a custom-built compiler are recommended because of this. (For example, the latest GCC Linaro binary targets armv7-a by default, whereas the Raspberry Pi requires armv6kz). It is possible to add extra compiler options to the HOSTCFLAGS line inMakefile. The correct flags are shown on the software page - note that you may also need to add -marm if your compiler produces Thumb code by default.

Use the provided compiler

Download the pre-built bmc2708 compiler from the Raspberry Pi tools section on GitHub.
git clone git://github.com/raspberrypi/tools.git --depth 1
Or you can download a tarball from the website using this link.

Custom-built Linaro GCC

Ubuntu

apt-get install gcc-arm-linux-gnueabi make ncurses-dev

Funtoo or Gentoo Linux

crossdev -S -v -t arm-unknown-linux-gnueabi
Crossdev should create a cross-toolchain using the latest stable versions of the required packages. If it fails, you can specify exact versions by removing the "-S" flag and adding the "--b", "--g", "--k" and "--l" flags. On 2012-05-06, cross -S -v -A gnueabi arm works just fine.

Arch Linux

yaourt -S arm-linux-gnueabi-gcc

Cross compiling from OS X

Macports

The kernel source requires a case-sensitive filesystem. If you do not have a HFS+ case-sensitive partition that can be used, create a disk image with the appropriate format. Ensure the latest versin of Xcode and command line tools are installed from Apple Developer Connection Install macports
port install arm-none-eabi-gcc
port install arm-none-eabi-binutils
If you get an error message that elf.h is missing
sudo port install libelf && sudo ln -s /opt/local/include/libelf /usr/include/libelf
From opensource.apple.com, download and copy elf.h and elftypes.h to /usr/include
Edit elf.h and add
#define EM_S390           22    
#define R_386_NONE        0
#define R_386_32          1
#define R_386_PC32        2
#define R_ARM_NONE        0
#define R_ARM_PC24        1
#define R_ARM_ABS32       2
#define R_MIPS_NONE       0
#define R_MIPS_16         1
#define R_MIPS_32         2
#define R_MIPS_REL32      3
#define R_MIPS_26         4
#define R_MIPS_HI16       5
#define R_MIPS_LO16       6
#define EM_S390           22
#define R_MIPS_64         18
#define R_390_64          22
#define R_X86_64_64       1
#define R_SPARC_64        32
#define R_SH_DIR32        1
#define R_PPC_ADDR32      1
#define R_PPC64_ADDR64    38
#define R_IA64_IMM64      0x23
If you get a "SEGMENT_SIZE is undeclared" error open the Makefile and change the line:
NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include)
to
NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include) -Dlinux
Complete script requires raspberrypi.config to be in the same folder that you execute from.
sudo port install arm-none-eabi-gcc
sudo port install arm-none-eabi-binutils
sudo port install libelf && sudo ln -s /opt/local/include/libelf /usr/include/libelf
sudo curl http://opensource.apple.com/source/dtrace/dtrace-48/sys/elftypes.h?txt -o  /usr/include/elftypes.h
sudo curl http://opensource.apple.com/source/dtrace/dtrace-48/sys/elf.h?txt -o /usr/include/elf.h
#code to append to elf.h
echo "
#define EM_S390 22    
#define R_386_NONE 0
#define R_386_32 1
#define R_386_PC32 2
#define R_ARM_NONE 0
#define R_ARM_PC24 1
#define R_ARM_ABS32 2
#define R_MIPS_NONE 0
#define R_MIPS_16 1
#define R_MIPS_32 2
#define R_MIPS_REL32 3
#define R_MIPS_26 4
#define R_MIPS_HI16 5
#define R_MIPS_LO16 6
#define EM_S390 22
#define R_MIPS_64 18
#define R_390_64 22
#define R_X86_64_64 1
#define R_SPARC_64 32
#define R_SH_DIR32 1
#define R_PPC_ADDR32 1
#define R_PPC64_ADDR64 38
#define R_IA64_IMM64 0x23" > elf-append.h
sudo -s 'cat elf-append.h >> /usr/include/elf.h'

#Make a case sensitive 3 GB disk image, raspberrypi-kernel, and attach it:
hdiutil create -size 10g -type SPARSEBUNDLE -nospotlight -volname raspberrypi-kernel -fs "Case-sensitive Journaled HFS+" -attach ./raspberrypi-kernel.dmg
cp raspberrypi.config /Volumes/raspberrypi-kernel/
mkdir /Volumes/raspberrypi-kernel/src
cd /Volumes/raspberrypi-kernel/src

#Get source, either 1. from a ZIP file (faster), or 2. from Git
#1. From a ZIP file
curl https://codeload.github.com/raspberrypi/linux/zip/rpi-3.6.y -o ./rpi-3.6.y.zip
unzip rpi-3.6.y.zip
#2. From Git (disabled)
#git init
#git fetch git://github.com/raspberrypi/linux.git rpi-3.6.y:refs/remotes/origin/rpi-3.6.y
#git checkout rpi-3.6.y

cpu=$(sysctl hw.ncpu | awk '{print $2}')
cpup1=$((cpu+1))

cd /Volumes/raspberrypi-kernel/src/linux-rpi-3.6.y/
export CCPREFIX=/opt/local/bin/arm-none-eabi-
make mrproper
cp /Volumes/raspberrypi-kernel/raspberrypi.config .config
#Answer yes to all config options
#yes "" | make ARCH=arm CROSS_COMPILE=${CCPREFIX} oldconfig
make ARCH=arm CROSS_COMPILE=${CCPREFIX} -j$cpup1
#make ARCH=arm CROSS_COMPILE=${CCPREFIX} modules -j$cpup1

Yagarto

Download and install from here.

Perform the compilation

Firstly, ensure your build directory is clean:
make mrproper
Next, in all cases, you will want to get a working kernel configuration to start from. You can get the one running on the Raspberry Pi by typing the following (on the Raspberry Pi):
zcat /proc/config.gz > .config
Then copy .config into your build directory.
Alternatively, the default configuration is available in the downloaded kernel source in arch/arm/configs/bcmrpi_defconfig. Just copy this to .config in the build directory.
From this point on, if you are cross-compiling, set an environment variable CCPREFIX that points to the prefix of your compiler binary as each compiler will be named slightly differently.
export CCPREFIX=/path/to/your/compiler/binary/prefix-of-binary-
If you are building on the Raspberry Pi, remove ARCH=arm CROSS_COMPILE=${CCPREFIX} from each command.
Ensure that your configuration file is up-to-date:
make ARCH=arm CROSS_COMPILE=${CCPREFIX} oldconfig
If any configuration options have been added, you will be asked what set each option to. If you don't know the answer, just press enter to accept the default.
Optionally, if you want to make changes to the configuration, run this next:
make ARCH=arm CROSS_COMPILE=${CCPREFIX} menuconfig
Now you are ready to build:
(On the Raspberry Pi, type 'screen' to open a virtual screen. If you use it you can disconnect from the Raspberry Pi and compile overnight...)
make ARCH=arm CROSS_COMPILE=${CCPREFIX}
If you are on a multi-core system, you can make the build faster by appending -j<N> where <N> is the number of cores on your system plus one (that is, -j3 for two cores).
Find something else to get on with while the compilation takes place. On an average PC with the default configuration, this should take about 15 minutes.
The modules will be build with the following command.
make ARCH=arm CROSS_COMPILE=${CCPREFIX} modules

Transfer the build

The fully built kernel will be arch/arm/boot/Image. Copy your new kernel file into the Raspberry Pi boot partition, though preferably as a new file (such askernel_new.img) just in case it doesn't work. If you're building on the Raspberry Pi, just copy the file to /boot. If you use a different filename, edit config.txt change the kernel line:
kernel=kernel_new.img
#kernel=kernel.img
Now you need to transfer the modules. Set an environment variable that points to a temporary module path.
export MODULES_TEMP=~/modules
In the build directory, run the following command:
make ARCH=arm CROSS_COMPILE=${CCPREFIX} INSTALL_MOD_PATH=${MODULES_TEMP} modules_install
The contents of this directory, a single
lib
directory, should then be copied into the Raspberry Pi root directory, merging or overwriting
/lib
NOTE: If you have rebuilt the new kernel with exactly the same version as the one that's running, you'll need to remove the old modules first. Ideally this should be done offline by mounting the SD card on another system.
NOTE: The lib directory will have symlinks back to the kernel sources (lib/modules/<kernel-version>/source and lib/modules/<kernel-version>/build). If you have limited space on the SD card and don't intend to compile modules on the Raspberry Pi itself, you will probably want to remove those links before you transfer the lib directory. The size difference can be many hundreds of MB.
Your Raspberry Pi should now be ready to boot the new kernel. However, at this point it's recommended that you update your GPU firmware and libraries. This is required if you've just moved from 3.2 to 3.6 as the firmware interface has changed.

Get the firmware

The firmware and boot files should be updated at the same time to ensure that your new kernel works properly. Again, two branches are available:
  • master - This is the version of firmware currently used in Raspbian (that is, it works with the 3.2 kernel).
  • next - This is a development branch which provides a newer GPU firmware to work with the updated drivers in the 3.6 kernel.
You can either download the source directly using Git: You can download the firmware directly using Git. For the master branch:
git clone git://github.com/raspberrypi/firmware.git
And for the next branch:
git fetch git://github.com/raspberrypi/firmware.git next:refs/remotes/origin/next
Or you can download a tarball from the website using these links: master next

Transfer the firmware

Firstly, update the required boot files in the Raspberry Pi boot directory with those you've downloaded. These are:
  • bootcode.bin
  • fixup.dat
  • start.elf
Next, you need to copy the VC libraries over. There are two copies of this: one for hard float and one for soft float. To find the correct one, run the following command:
${CCPREFIX}gcc -v 2>&1 | grep hard
If something prints out, and you can see --with-float=hard, you need the hard float ones. NOTE: The current version of Raspbian uses hard float.
Remove the /opt/vc directory from the Raspberry Pi root, then:
  • For hard float, copy vc from the hardfp/opt directory into /opt in the Raspberry Pi root directory
  • Otherwise copy vc from the top-level opt directory into /opt in the Raspberry Pi root directory.
Note: The hard float vs soft float here refers only to the kernel itself, not the functionality it provides. Your applications will still be able to use hard floats. The kernel doesn't use floats anyway, so it is not something to worry about as long as you select the correct vc directory to copy.

Test your build

Power cycle your Raspberry Pi and check the following:
  • If you have the serial port on the GPIO expander wired up, you should see the kernel booting.
  • The screen works - the kernel boots and you get a login prompt.
  • The VC interface is working - if the 'OK' LED flashes regularly eight or so times every few seconds once the OS has booted, it's not. You can also test this by runningvcgencmd measure_temp. If it prints "VCHI initialization failed", you have the a mismatch between the firmware, the VC libraries, and the kernel driver.
  • Run uname -a and check that your new kernel is the one that's running.
  • Make sure you don't have any odd error messages during boot that may indicate a module isn't working properly. If you see missed completion of cmd 18regarding DMA transfers to the SD card, you can safely ignore it.

Build modules for the running kernel

You need the kernel sources for the currently running kernel to successfully build kernel modules for the Raspberry Pi. More specifically, only parts of the complete source, the so called kernel headers are needed. There are two ways to arrive at a state from which you can build kernel modules on the Raspberry Pi.
1. is most suitable if you have been using Kernel sources from raspberrypi.org
2. is using only mainline kernel stuff

1. Using rpi-source

rpi-source downloads a matching source for the running kernel. It supports rpi-update kernels and Raspian kernels.

2. Manually

If you have used or want to stick with a vanilla (mainline) kernel, there is a different way
You have been following the RPi_Upstream_Kernel_Compilation guide, correct? Great, let's move on: That guide is not using modules, so enable modules in make menuconfig first. Then execute
$ ARCH=arm CROSS_COMPILE=${CCPREFIX} chrt -i 0 make -j 8
$ ARCH=arm CROSS_COMPILE=${CCPREFIX} INSTALL_MOD_PATH=${MODULES_TEMP} make modules_install
The second line will create the .ko files and it will create the necessary folder structure (/usr/src/linux/lib/modules/`uname -r`/[build|kernel|source]. build and source are symlinks to the kernel sources. kernel contains the module files (under some subdirectories).
Now you can continue with RPi_Upstream_Kernel_Compilation compiling the bootloader and so on. Finally also copy the used kernel sources onto the SD card, e.g. under /home/pi/linux
$ cp -av /usr/src/linux/ <sdcard-ext4-root>/home/pi/
Boot the Raspberry Pi, then execute
$ cd /home/pi
$ sudo chown -R pi:pi linux/
to change back ownership to you (this is necessary unless your username on your build machine is also "pi"...). Now copy /home/pi/linux/lib/modules/* to the correct
$ sudo cp -R /home/pi/linux/lib/modules/`uname -r`/ /lib/modules/
Correct the symlinks:
$ sudo cd /lib/modules/`uname -r`/
$ sudo rm build source
$ ln -s /home/pi/linux build
$ ln -s /home/pi/linux source
Now, we need to fix one more problem: During the cross-compilation build, a couple scripts were compiled for the host. We also need them for the Raspberry Pi. Still on the Pi, this can be checked with e.g.
$ file /home/pi/linux/scripts/recordmcount (returns something with x86-64)
$ cd /home/pi/linux/
$ make scripts
$ file /home/pi/linux/scripts/recordmcount (now returns something with 32-bit and ARM)
Posted by at No comments:
Subscribe to: Posts (Atom)