Promoting affordable VPS

There was a time when I was developing Android roms, I longed to have my own VPS. Those initial two to three years found me hosting all my work and my personal sites on c0urier’s personal server. Make no mistake, I am extremely greateful to him and his company Kazi networks for providing free use of their space for my roms. But there comes a time when just having ftp space becomes unwieldy, especially when you have to move around huge files and need to write php scripts to make your site more interactive.

After nearly a year of languishing in the darkness, I found Low end box, better known in hosting circles as LEB. LEB is a site build on WordPress, dedicated to low end VPS hosting services. Their motto is to popularize VPS hosting solutions under $7 a month. A most just and exemplary concept. It gets tens of hundreds of VPS offers a month, and subscribers (free) of course get to see offers from a lot of mainstream VPS providers, all of which are below the $7 a month range.

I myself have gobbled up decent boxes from LEB. My most popular boxes are from MyRSK, Servermania, and Wills hosting. All three of these providers provide fairly decent boxes.

My MyRSK box provides 2GB RAM, 200GB HDD space, 100Mbit port and 1 ip at $7 a month. Servermania’s offering was a 1GB RAM + 1GB Vswap with 75 GB disk space, 100Mbit port. My present favorite box is a 512 MB RAM + 512 MB Vswap, 60GB hard disk space and 1Gbit port from Will’s hosting. I used to heavily use XDA and Goo build servers for hosting, but though they’re good for hosting, they had limitations. The XDA SSH buildbot had and still has issues with menuconfig.


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Making your ssh life paradise – Using a config file

The config file can automate many tedious processes.

Eg: You wish to scp a file from the current machine to a host like XDA, using a specific identity key. Of course you can use ssh-add to add the key, but it may not be recognized each reboot.

The usual command is like

scp -i ~/.ssh/path_to_keyfile sourcefilename [email protected]:~/targetpath

Once a .config file is set up, your new command becomes:

scp sourcefile xda:target

Really!

Create a text file in ~/.ssh/config:

[email protected]:~$ cat /home/droidzone/.ssh/config                                                                                                                    
Host bitbucket                                                                                                                                               
    IdentityFile ~/.ssh/bitbucket                                                                                                                                     
Host xda                                                                                                                                                              
     HostName build1.dev.xda-developers.com                                                                                                                           
     User droidzone                                                                                                                                                   
     IdentityFile ~/.ssh/xdamachine_key_openssh_pvt                                                                                                                   
     ServerAliveInterval 30                                                                                                                                           
     ServerAliveCountMax [email protected]:~$

Here, as you can see, I’ve added two hosts. One is my Bitbucket account, and I’ve specified a key file for authentication.

For XDA, I’ve given it a label “xda”, specified the build server username and hostname, specified an identity file, and a timeout interval.


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Compile svn for XDA

Download sources for subversion, apr, apr-util and sqlite3.

Extract them, compile each and install them

Compile svn with support for these packages.

 

 

cd ~/myapps
wget http://archive.apache.org/dist/subversion/subversion-1.7.7.tar.bz2
tar -jxvvf subversion-1.7.7.tar.bz2
wget http://archive.apache.org/dist/apr/apr-1.4.6.tar.gz
tar -xvvf apr-1.4.6.tar.gz
cd apr-1.4.6
./configure --prefix=/home/droidzone/myapps
make ; make install
cd ..
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/droidzone/myapps/lib
wget http://archive.apache.org/dist/apr/apr-util-1.5.1.tar.gz
tar -xvvf apr-util-1.5.1.tar.gz
cd apr-util-1.5.1
./configure --prefix=/home/droidzone/myapps --with-apr=/home/droidzone/myapps
make ; make install
cd ..
wget http://www.sqlite.org/sqlite-autoconf-3071401.tar.gz
tar -xvvf sqlite-autoconf-3071401.tar.gz
cd subversion-1.7.7
mkdir -p /home/droidzone/myapps/subversion-1.7.7/sqlite-amalgamation
cp ../sqlite-autoconf-3071401/sqlite3.c /home/droidzone/myapps/subversion-1.7.7/sqlite-amalgamation/sqlite3.c
./configure --prefix=/home/droidzone/myapps --with-apr=/home/droidzone/myapps --with-apr-util=/home/droidzone/myapps
make ; make install

[/code]


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.
Download from file sharing sites, remotely, with the linux command line

Download from file sharing sites, remotely, with the linux command line

Newer Update:
Downloading from file sharing sites can be done from the command line using a nifty program called plowshare.

Download it from here.

Now install it:

wget https://plowshare.googlecode.com/files/plowshare4_1~git20140112.7ad41c8-1_all.deb
dpkg -i plowshare4_1~git20140112.7ad41c8-1_all.deb
apt-get install -f

Older post:

Working on the XDA server, I needed to import Rom firmware to work on them. Having an extremely slow connection speed, I cursed the few XDA users who uploaded the firmware to file sharing sites like Hotfile, no doubt to encash on the revenue offered by these sites. I cant blame them, been there, done that. 😉

Anyway, I made a serrendipitious discovery of a program which runs on the bash command line, and downloads from file sharing sites, circumventing or working along their javascript based countdown tickers (which make piecemeal of web based browsers like links and elinks), and their captchas. In case of Recaptchas, the program downloads the captcha image and asks for user input to decipher the text in it.

It’s called plowdown and like all other awesome things, it’s an open source project, currently hosted on Google Project pages. Download it here.

I tried it while working on the xda system, and it worked wonders. It downloaded a 1GB Note 2 firmware in maximum speed, without any issues whatsoever. Problem solved. I could now work on the file remotely without having to download it to my PC first. And along with other tricks I’ve already mentioned, I could even remote copy it to Goo servers and share it. I also remote ftpd the file to my own host.

Here’s the program working along.

To install the program:

Download the latest source tarball from the Google Code repo

Extract it

tar -xvvf plowshare4-snapshot-git20121104.411fdec.tar.gz

Now install it to a local directory

make install PREFIX=/home/droidzone/myapps

Using the program:

In case of Samsung leaked Roms, most of the files seem to be hosted on Hotfile. Plowdown works very well on Hotfile. You can use the following command to download a typical file:

wget `plowdown http://www.hotfile.com/dl/187869240/8e5ac43/N7100XXDLL7_N7100ODDDLL2_INU.zip.html`

This leads to:

[[email protected]] ~ $wget `plowdown http://www.hotfile.com/dl/187869240/8e5ac43/N7100XXDLL7_N7100ODDDLL2_INU.zip.html`
Starting download (hotfile): http://www.hotfile.com/dl/187869240/8e5ac43/N7100XXDLL7_N7100ODDDLL2_INU.zip.html
Waiting 30 seconds... done         
No ascii viewer found to display captcha image
Local image: /tmp/plowdown.22419.27107.recaptcha.jpg
Leave this field blank and hit enter to get another captcha image
Enter captcha response (drop punctuation marks, case insensitive): TRADES edlePer
File URL: http://s177.hotfile.com/get/868a280af7edca209458390c8bc18da53af1ebb5/50ecebe8/320/c78ada7ded148d27/b32a838/N7100XXDLL7_N7100ODDDLL2_INU.zip
Filename: N7100XXDLL7_N7100ODDDLL2_INU.zip

Note the prompt for the captcha image. The image saved remotely can be scp-d to a local folder, viewed locally, and the captcha typed back in at the prompt. It’s all very easy!


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Pushing a file via ftp and the bash command line to an ftp server

Since I work with the XDA server, I often have to work on stuff in the XDA server, finish it and upload it to my host. Now Goo.im conveniently offers a sftp access, that makes everything very easy. A simple scp command can transfer the file (already descibed elsewhere on my blog). However when it comes to transferring the files via simple ftp, things are a bit different. You need a bash scrip to do it.

I’ve used this script from  Ubuntuforums to suit my needs perfectly:

# The next 9 lines are lifted from mickwombat's script
#!/bin/sh
USERNAME="[email protected]"
PASSWORD="myftppassword"
SERVER="ftp.droidzone.in"
# Directory where file is located
DIR=$2
#  Filename of backup file to be transfered
FILE=$1
# login to ftp server and transfer file

curl -T $FILE -u $USERNAME:$PASSWORD $SERVER/$DIR/

This very neatly takes the file specified in the first argument, and transfers it to ftp.droidzone.in/dir where dir is the specified directory.


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Using Smitna’s Build tool

Issues found while using it on XDA server:

No autoconf2.13 found:

Compile and install autoconf2.13 to a different folder, now create a symlink:

ln -s autoconf autoconf2.13

Add both versions of Autoconf (the latest, and 2.13 version)’s bin path to $PATH

Now it should work

Other package I needed to install was scons


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Bought a brand new Note 2

After a span of almost three years, I have bought a new Android device-The Samsung Galaxy Note II. My last one was my beloved die-hard HTC Desire, which has been the base of my popular Starburst and Supernova Roms, which incorporated Sibere’s scripts and a custom-tweaked HTC Official Rom. It was extremely popular with the Desire community, and the proof of its robustness is demonstrated by occasional queries in its XDA thread, even now when Jellybean is the new kid in town.

I’m looking forward  to getting my hands on the Note II. It was ordered from an Indian online retailer Shopclues.com, and should hopefully reach me the day after tomorrow.


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Using the XDA Build server (Transferring files from a remote server with scp)

XDA’s Build server for Recognized developers, in the works, does not have a public access section for the file system where files may be uploaded and may be downloaded. That may probably change in the future, as this is a beta thing kept under wraps, and open for only RDs.

For now, if you wish to transfer files from the server, you may use the scp service, either with a frontend like Filezilla, or from the command line. This is important for me because I’d like to remote upload my compiled files from the XDA build server to Goo.im, or Sourceforge and offer it to my users for download.

So on the second remote server (like Goo or Sourceforge) where you have ssh access, follow the following steps:

Login with ssh in the usual way with Putty or ssh to the second server (Goo or Sourceforge, will be called server2) where you have a public section of the file system (public_html or www).

Create a remote key on this server (server2), with:

ssh-keygen -t rsa

Now, you have to transfer the public key for this server2 to the server1. In other words, you are going to remote access server1 from server2. So you have to have a public/private key pair on server2, and transfer its public key to server1.

Once the key pair is set up, transfer the public key to server1. If server1 already has other keys setup, edit ~/.ssh/authorized_keys in a text editor (I prefer emacs), and add the new public key to the last line, and press enter (for a newline char). Save authorized_keys.

Now server1 will accept remote connections from server2.

Transfer from Remote to Local (Or two remotes, if one of them is logged into)

Now, use the following scp command to transfer the file remotely from the XDA filesystem, to the currently logged in server:

scp -i .ssh/goo_xda [email protected]:pathtofile targetonhost2

 

Eg:

 

scp -i .ssh/goo_xda [email protected]:~/myfiles/compiled.tar.bz2 ./myfolder/

 

This will use a ssh key at .ssh/goo_xda (Private key on the logged in server-Server2), to login to server 1 (devserver.xda.com) with username dz, and copy a file at ~/myfiles/compiled.tar.bz2 from server1 to  ./myfolder/compiled.tar.bz2 on server2. Server2 is where you have logged in currently using ssh/putty. Server1 is the XDA build server from which you want to transfer files.

Of course in some instances, you can omit the -i parameter to the private key by adding the key with ssh-add, to the agent. However I found that Goo, XDA and Sourceforge werent allowing this.

 

Transfer from Local to Remote (Or two remotes, if one of them is logged into)

In this example, I am logged into the XDA build server and am copying a file to my Sourceforge remote server.

 

scp download/phpfm_281012_064121.zip [email protected]:/home/users/d/dr/droidzone

Here, I’m copying a file download/phpfm_281012_064121.zip from the XDA server where I am logged in (or from my linux local machine) to the host web.sourceforge.net to the specified directory. I need to prefix my username. If I need a key, I would prefix it with -i option.

So, essentially, what you have to do is this:

Generate a key pair:

-bash-4.1$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/droidzone/.ssh/id_rsa): /home/droidzone/.ssh/id_rsa_xda
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/droidzone/.ssh/id_rsa_xda.
Your public key has been saved in /home/droidzone/.ssh/id_rsa_xda.pub.
The key fingerprint is:
2d:89:29:71:19:1d:bc:33:d0:cd:60:21:77:00:af:8f [email protected]
The key's randomart image is:
+--[ RSA 2048]----+
|      +=BB.      |
|      .B+.o      |
|    . o...       |
|     o ++o       |
|    . + So.      |
|     . o .       |
|      E .        |
|                 |
|                 |
+-----------------+

It doesnt matter where you generate the key files. It could be on your home PC too.

Next, let’s assume you’re going to build on XDA then transfer to Goo.

So. login into XDA (the local server).

Copy the key pair’s private key to XDA, into ~/.ssh/

Change the default permissions to a more secure permission.

chmod go= ~/.ssh/mynewkey

Now, add the public key for this pair to Goo (the remote server)

Edit ~/.ssh/authorized_keys

Go to the end of the last key line. Press enter and paste the new public key.

Save the file.

Now, you can copy the file with the following line:

scp -i ~/.ssh/goo_xda N7100XXALJ3_N7100ODDALJ2_INU.zip [email protected]:/home/droidzone/public_html/firmware/n7100/
N7100XXALJ3_N7100ODDALJ2_INU.zip

This uses the private key ~/.ssh/goo_xda and copies the file N7100XXALJ3_N7100ODDALJ2_INU.zip from the current directory on XDA (where you’re logged into-the local server), into the location /home/droidzone/public_html/firmware/n7100/ on the Goo server (remote). Piece of cake, isnt it?

As you can note, this is extremely useful as XDA does not provide a public_html folder where built files can be provided to users.

Working with Filezilla on XDA’s Build server

Due to the absence of password auth on XDA build server, one needs to setup key based authentication. For this, a third party program named Pageant is required. Another requirement is a key in PPK (Putty) format. The PPK conversion of OpenSSH keys may be done with Puttygen.

Download Pageant from Putty’s site (Choose the x86 version)

Run Pageant.exe (standalone exe)

An icon for pageant appears in the system tray.

Right click it and “Add key”

Choose the ppk key stored for XDA.

Choose Ok.

Start Filezilla, setup the following:

Host: Eg: buildserver.something.xda-developers.com (The actual hostname is provided to XDA RDs)

Port: 22

Protocol: SFTP

Logon type: Normal

Username: [your username]

Password: [leave empty]

Note that if Pageant is working, there is no need to setup key in Filezilla. We just leave an empty password. Pageant takes care of auth.

Transferring large files: rsync

rsync --partial --progress -avvvz -e "ssh -i /home/droidzone/.ssh/xdamachine_key_openssh_pvt" random [email protected]:~/

–partial: Continue interrupted downloads

–progress: Display progress

-a: archive with preserved permissions

-vvv: verbose mode

z: gzip mode transfer

 Rsync exit codes:

  • 0 Success
  • 1 Syntax or usage error
  • 2 Protocol incompatibility
  • 3 Errors selecting input/output files, dirs
  • 4 Requested action not supported: an attempt was made to manipulate 64-bit files on a platform that cannot support them; or an option was specified that is supported by the client and not by the server.
  • 5 Error starting client-server protocol
  • 10 Error in socket I/O
  • 11 Error in file I/O
  • 12 Error in rsync protocol data stream
  • 13 Errors with program diagnostics
  • 14 Error in IPC code
  • 20 Received SIGUSR1 or SIGINT
  • 21 Some error returned by waitpid()
  • 22 Error allocating core memory buffers
  • 23 Partial transfer due to error
  • 24 Partial transfer due to vanished source files
  • 30 Timeout in data send/receive

You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.

Building a toolchain for Android (Compiling an Android kernel) – crosstool-ng

Summary:

sudo apt-get install gawk bison flex texinfo automake libtool cvs curl aria2 patch lzma libncurses5-dev g++ openjdk-7-jre-headless build-essential libcloog-ppl-dev gettext help2man
cd ~/
git clone https://github.com/crosstool-ng/crosstool-ng.git
cd crosstool-ng/
./bootstrap
mkdir ../crosstoolactual
./configure --prefix=$HOME/crosstoolactual
make
make install
export PATH="${PATH}:$HOME/crosstoolactual/bin"
mkdir ~/work-dir
cd ~/work-dir
ct-ng help
ct-ng menuconfig
ct-ng build

Listing my .config here:

#
# Automatically generated file; DO NOT EDIT.
# Crosstool-NG Configuration
#
CT_CONFIGURE_has_static_link=y
CT_CONFIGURE_has_wget=y
CT_CONFIGURE_has_curl=y
CT_CONFIGURE_has_stat_flavor_GNU=y
CT_CONFIGURE_has_make_3_81_or_newer=y
CT_CONFIGURE_has_libtoolize_2_4_or_newer=y
CT_CONFIGURE_has_autoconf_2_63_or_newer=y
CT_CONFIGURE_has_autoreconf_2_63_or_newer=y
CT_CONFIGURE_has_gnu_m4_1_4_12_or_newer=y
CT_CONFIGURE_has_cvs=y
CT_CONFIGURE_has_svn=y
CT_CONFIGURE_has_git=y
CT_MODULES=y

#
# Paths and misc options
#

#
# crosstool-NG behavior
#
# CT_OBSOLETE is not set
CT_EXPERIMENTAL=y
# CT_ALLOW_BUILD_AS_ROOT is not set
# CT_DEBUG_CT is not set

#
# Paths
#
CT_LOCAL_TARBALLS_DIR="${HOME}/src"
CT_SAVE_TARBALLS=y
CT_WORK_DIR="${CT_TOP_DIR}/.build"
CT_BUILD_TOP_DIR="${CT_WORK_DIR}/${CT_HOST:+HOST-${CT_HOST}/}${CT_TARGET}"
CT_PREFIX_DIR="${CT_PREFIX:-${HOME}/x-tools}/${CT_HOST:+HOST-${CT_HOST}/}${CT_TARGET}"
CT_RM_RF_PREFIX_DIR=y
CT_REMOVE_DOCS=y
CT_PREFIX_DIR_RO=y
CT_STRIP_HOST_TOOLCHAIN_EXECUTABLES=y
# CT_STRIP_TARGET_TOOLCHAIN_EXECUTABLES is not set

#
# Downloading
#
CT_DOWNLOAD_AGENT_WGET=y
# CT_DOWNLOAD_AGENT_CURL is not set
# CT_DOWNLOAD_AGENT_NONE is not set
# CT_FORBID_DOWNLOAD is not set
# CT_FORCE_DOWNLOAD is not set
CT_CONNECT_TIMEOUT=10
CT_DOWNLOAD_WGET_OPTIONS="--passive-ftp --tries=3 -nc --progress=dot:binary"
# CT_ONLY_DOWNLOAD is not set
# CT_USE_MIRROR is not set

#
# Extracting
#
# CT_FORCE_EXTRACT is not set
CT_OVERRIDE_CONFIG_GUESS_SUB=y
# CT_ONLY_EXTRACT is not set
CT_PATCH_BUNDLED=y
# CT_PATCH_LOCAL is not set
# CT_PATCH_BUNDLED_LOCAL is not set
# CT_PATCH_LOCAL_BUNDLED is not set
# CT_PATCH_BUNDLED_FALLBACK_LOCAL is not set
# CT_PATCH_LOCAL_FALLBACK_BUNDLED is not set
# CT_PATCH_NONE is not set
CT_PATCH_ORDER="bundled"

#
# Build behavior
#
CT_PARALLEL_JOBS=0
CT_LOAD=""
CT_USE_PIPES=y
CT_EXTRA_CFLAGS_FOR_BUILD=""
CT_EXTRA_LDFLAGS_FOR_BUILD=""
CT_EXTRA_CFLAGS_FOR_HOST=""
CT_EXTRA_LDFLAGS_FOR_HOST=""
# CT_CONFIG_SHELL_SH is not set
# CT_CONFIG_SHELL_ASH is not set
CT_CONFIG_SHELL_BASH=y
# CT_CONFIG_SHELL_CUSTOM is not set
CT_CONFIG_SHELL="${bash}"

#
# Logging
#
# CT_LOG_ERROR is not set
# CT_LOG_WARN is not set
# CT_LOG_INFO is not set
CT_LOG_EXTRA=y
# CT_LOG_ALL is not set
# CT_LOG_DEBUG is not set
CT_LOG_LEVEL_MAX="EXTRA"
# CT_LOG_SEE_TOOLS_WARN is not set
CT_LOG_PROGRESS_BAR=y
CT_LOG_TO_FILE=y
CT_LOG_FILE_COMPRESS=y

#
# Target options
#
CT_ARCH="arm"
# CT_ARCH_alpha is not set
CT_ARCH_arm=y
# CT_ARCH_avr is not set
# CT_ARCH_m68k is not set
# CT_ARCH_microblaze is not set
# CT_ARCH_mips is not set
# CT_ARCH_nios2 is not set
# CT_ARCH_powerpc is not set
# CT_ARCH_s390 is not set
# CT_ARCH_sh is not set
# CT_ARCH_sparc is not set
# CT_ARCH_x86 is not set
# CT_ARCH_xtensa is not set
CT_ARCH_alpha_AVAILABLE=y
CT_ARCH_arm_AVAILABLE=y
CT_ARCH_avr_AVAILABLE=y
CT_ARCH_m68k_AVAILABLE=y
CT_ARCH_microblaze_AVAILABLE=y
CT_ARCH_mips_AVAILABLE=y
CT_ARCH_nios2_AVAILABLE=y
CT_ARCH_powerpc_AVAILABLE=y
CT_ARCH_s390_AVAILABLE=y
CT_ARCH_sh_AVAILABLE=y
CT_ARCH_sparc_AVAILABLE=y
CT_ARCH_x86_AVAILABLE=y
CT_ARCH_xtensa_AVAILABLE=y
CT_ARCH_SUFFIX=""

#
# Generic target options
#
# CT_MULTILIB is not set
CT_DEMULTILIB=y
CT_ARCH_SUPPORTS_BOTH_MMU=y
CT_ARCH_DEFAULT_HAS_MMU=y
CT_ARCH_USE_MMU=y
CT_ARCH_SUPPORTS_BOTH_ENDIAN=y
CT_ARCH_DEFAULT_LE=y
# CT_ARCH_BE is not set
CT_ARCH_LE=y
CT_ARCH_ENDIAN="little"
CT_ARCH_SUPPORTS_32=y
CT_ARCH_SUPPORTS_64=y
CT_ARCH_DEFAULT_32=y
CT_ARCH_BITNESS=64
# CT_ARCH_32 is not set
CT_ARCH_64=y

#
# Target optimisations
#
CT_ARCH_SUPPORTS_WITH_ARCH=y
CT_ARCH_SUPPORTS_WITH_CPU=y
CT_ARCH_SUPPORTS_WITH_TUNE=y
CT_ARCH_EXCLUSIVE_WITH_CPU=y
CT_ARCH_ARCH=""
CT_ARCH_CPU=""
CT_ARCH_TUNE=""
CT_TARGET_CFLAGS=""
CT_TARGET_LDFLAGS=""
CT_ARCH_FLOAT=""

#
# arm other options
#
CT_ARCH_ARM_MODE="arm"
CT_ARCH_ARM_MODE_ARM=y
# CT_ARCH_ARM_MODE_THUMB is not set
# CT_ARCH_ARM_INTERWORKING is not set
CT_ARCH_ARM_EABI_FORCE=y
CT_ARCH_ARM_EABI=y

#
# Toolchain options
#

#
# General toolchain options
#
CT_FORCE_SYSROOT=y
CT_USE_SYSROOT=y
CT_SYSROOT_NAME="sysroot"
CT_SYSROOT_DIR_PREFIX=""
CT_WANTS_STATIC_LINK=y
CT_WANTS_STATIC_LINK_CXX=y
# CT_STATIC_TOOLCHAIN is not set
CT_TOOLCHAIN_PKGVERSION=""
CT_TOOLCHAIN_BUGURL=""

#
# Tuple completion and aliasing
#
CT_TARGET_VENDOR=""
CT_TARGET_ALIAS_SED_EXPR=""
CT_TARGET_ALIAS="arm-one"

#
# Toolchain type
#
# CT_NATIVE is not set
CT_CROSS=y
# CT_CROSS_NATIVE is not set
# CT_CANADIAN is not set
CT_TOOLCHAIN_TYPE="cross"

#
# Build system
#
CT_BUILD=""
CT_BUILD_PREFIX=""
CT_BUILD_SUFFIX=""

#
# Misc options
#
# CT_TOOLCHAIN_ENABLE_NLS is not set

#
# Operating System
#
CT_KERNEL_SUPPORTS_SHARED_LIBS=y
CT_KERNEL="linux"
CT_KERNEL_VERSION="4.10.8"
# CT_KERNEL_bare_metal is not set
CT_KERNEL_linux=y
CT_KERNEL_bare_metal_AVAILABLE=y
CT_KERNEL_linux_AVAILABLE=y
# CT_KERNEL_LINUX_CUSTOM is not set
CT_KERNEL_V_4_10=y
# CT_KERNEL_V_4_9 is not set
# CT_KERNEL_V_4_4 is not set
# CT_KERNEL_V_4_1 is not set
# CT_KERNEL_V_3_16 is not set
# CT_KERNEL_V_3_12 is not set
# CT_KERNEL_V_3_10 is not set
# CT_KERNEL_V_3_4 is not set
# CT_KERNEL_V_3_2 is not set
CT_KERNEL_windows_AVAILABLE=y

#
# Common kernel options
#
CT_SHARED_LIBS=y

#
# linux other options
#
CT_KERNEL_LINUX_VERBOSITY_0=y
# CT_KERNEL_LINUX_VERBOSITY_1 is not set
# CT_KERNEL_LINUX_VERBOSITY_2 is not set
CT_KERNEL_LINUX_VERBOSE_LEVEL=0
# CT_KERNEL_LINUX_INSTALL_CHECK is not set

#
# Binary utilities
#
CT_ARCH_BINFMT_ELF=y
CT_BINUTILS="binutils"
CT_BINUTILS_binutils=y

#
# GNU binutils
#
# CT_BINUTILS_CUSTOM is not set
CT_BINUTILS_VERSION="2.28"
# CT_BINUTILS_SHOW_LINARO is not set
CT_BINUTILS_V_2_28=y
# CT_BINUTILS_V_2_27 is not set
# CT_BINUTILS_V_2_26 is not set
CT_BINUTILS_2_27_or_later=y
CT_BINUTILS_2_26_or_later=y
CT_BINUTILS_2_25_1_or_later=y
CT_BINUTILS_2_25_or_later=y
CT_BINUTILS_2_24_or_later=y
CT_BINUTILS_2_23_2_or_later=y
CT_BINUTILS_HAS_HASH_STYLE=y
CT_BINUTILS_HAS_GOLD=y
CT_BINUTILS_GOLD_SUPPORTS_ARCH=y
CT_BINUTILS_GOLD_SUPPORT=y
CT_BINUTILS_HAS_PLUGINS=y
CT_BINUTILS_HAS_PKGVERSION_BUGURL=y
CT_BINUTILS_FORCE_LD_BFD_DEFAULT=y
CT_BINUTILS_LINKER_LD=y
# CT_BINUTILS_LINKER_LD_GOLD is not set
# CT_BINUTILS_LINKER_GOLD_LD is not set
CT_BINUTILS_LINKERS_LIST="ld"
CT_BINUTILS_LINKER_DEFAULT="bfd"
# CT_BINUTILS_PLUGINS is not set
CT_BINUTILS_EXTRA_CONFIG_ARRAY=""
# CT_BINUTILS_FOR_TARGET is not set

#
# binutils other options
#

#
# C-library
#
CT_LIBC="glibc"
CT_LIBC_VERSION="2.25"
CT_LIBC_glibc=y
# CT_LIBC_musl is not set
# CT_LIBC_uClibc is not set
CT_LIBC_avr_libc_AVAILABLE=y
CT_LIBC_glibc_AVAILABLE=y
CT_THREADS="nptl"
# CT_LIBC_GLIBC_CUSTOM is not set
# CT_CC_GLIBC_SHOW_LINARO is not set
CT_LIBC_GLIBC_V_2_25=y
# CT_LIBC_GLIBC_V_2_24 is not set
# CT_LIBC_GLIBC_V_2_23 is not set
CT_LIBC_GLIBC_2_23_or_later=y
CT_LIBC_GLIBC_2_20_or_later=y
CT_LIBC_GLIBC_2_17_or_later=y
CT_LIBC_mingw_AVAILABLE=y
CT_LIBC_musl_AVAILABLE=y
CT_LIBC_newlib_AVAILABLE=y
CT_LIBC_none_AVAILABLE=y
CT_LIBC_uClibc_AVAILABLE=y
CT_LIBC_SUPPORT_THREADS_ANY=y
CT_LIBC_SUPPORT_THREADS_NATIVE=y

#
# Common C library options
#
CT_THREADS_NATIVE=y
# CT_CREATE_LDSO_CONF is not set
CT_LIBC_XLDD=y

#
# glibc other options
#
CT_LIBC_GLIBC_NEEDS_PORTS=y
CT_LIBC_glibc_family=y
CT_LIBC_GLIBC_EXTRA_CONFIG_ARRAY=""
CT_LIBC_GLIBC_CONFIGPARMS=""
CT_LIBC_GLIBC_EXTRA_CFLAGS=""
# CT_LIBC_ENABLE_FORTIFIED_BUILD is not set
# CT_LIBC_DISABLE_VERSIONING is not set
CT_LIBC_OLDEST_ABI=""
CT_LIBC_GLIBC_FORCE_UNWIND=y
CT_LIBC_ADDONS_LIST=""
# CT_LIBC_LOCALES is not set
# CT_LIBC_GLIBC_KERNEL_VERSION_NONE is not set
CT_LIBC_GLIBC_KERNEL_VERSION_AS_HEADERS=y
# CT_LIBC_GLIBC_KERNEL_VERSION_CHOSEN is not set
CT_LIBC_GLIBC_MIN_KERNEL="4.10.8"

#
# C compiler
#
CT_CC="gcc"
CT_CC_CORE_PASSES_NEEDED=y
CT_CC_CORE_PASS_1_NEEDED=y
CT_CC_CORE_PASS_2_NEEDED=y
CT_CC_gcc=y
# CT_CC_GCC_CUSTOM is not set
CT_CC_GCC_VERSION="6.3.0"
# CT_CC_GCC_SHOW_LINARO is not set
CT_CC_GCC_V_6_3_0=y
# CT_CC_GCC_V_5_4_0 is not set
# CT_CC_GCC_V_4_9_4 is not set
CT_CC_GCC_4_8_or_later=y
CT_CC_GCC_4_9_or_later=y
CT_CC_GCC_5_or_later=y
CT_CC_GCC_6=y
CT_CC_GCC_6_or_later=y
CT_CC_GCC_HAS_LIBMPX=y
CT_CC_GCC_ENABLE_CXX_FLAGS=""
CT_CC_GCC_CORE_EXTRA_CONFIG_ARRAY=""
CT_CC_GCC_EXTRA_CONFIG_ARRAY=""
CT_CC_GCC_STATIC_LIBSTDCXX=y
# CT_CC_GCC_SYSTEM_ZLIB is not set
CT_CC_GCC_CONFIG_TLS=m

#
# Optimisation features
#
CT_CC_GCC_USE_GRAPHITE=y
CT_CC_GCC_USE_LTO=y

#
# Settings for libraries running on target
#
CT_CC_GCC_ENABLE_TARGET_OPTSPACE=y
# CT_CC_GCC_LIBMUDFLAP is not set
# CT_CC_GCC_LIBGOMP is not set
# CT_CC_GCC_LIBSSP is not set
# CT_CC_GCC_LIBQUADMATH is not set
# CT_CC_GCC_LIBSANITIZER is not set

#
# Misc. obscure options.
#
CT_CC_CXA_ATEXIT=y
# CT_CC_GCC_DISABLE_PCH is not set
CT_CC_GCC_SJLJ_EXCEPTIONS=m
CT_CC_GCC_LDBL_128=m
# CT_CC_GCC_BUILD_ID is not set
CT_CC_GCC_LNK_HASH_STYLE_DEFAULT=y
# CT_CC_GCC_LNK_HASH_STYLE_SYSV is not set
# CT_CC_GCC_LNK_HASH_STYLE_GNU is not set
# CT_CC_GCC_LNK_HASH_STYLE_BOTH is not set
CT_CC_GCC_LNK_HASH_STYLE=""
CT_CC_GCC_DEC_FLOAT_AUTO=y
# CT_CC_GCC_DEC_FLOAT_BID is not set
# CT_CC_GCC_DEC_FLOAT_DPD is not set
# CT_CC_GCC_DEC_FLOATS_NO is not set
CT_CC_SUPPORT_CXX=y
CT_CC_SUPPORT_FORTRAN=y
CT_CC_SUPPORT_JAVA=y
CT_CC_SUPPORT_ADA=y
CT_CC_SUPPORT_OBJC=y
CT_CC_SUPPORT_OBJCXX=y
CT_CC_SUPPORT_GOLANG=y

#
# Additional supported languages:
#
CT_CC_LANG_CXX=y
# CT_CC_LANG_FORTRAN is not set
# CT_CC_LANG_JAVA is not set
# CT_CC_LANG_ADA is not set
# CT_CC_LANG_OBJC is not set
# CT_CC_LANG_OBJCXX is not set
# CT_CC_LANG_GOLANG is not set
CT_CC_LANG_OTHERS=""

#
# Debug facilities
#
# CT_DEBUG_duma is not set
# CT_DEBUG_gdb is not set
# CT_DEBUG_ltrace is not set
# CT_DEBUG_strace is not set

#
# Companion libraries
#
CT_COMPLIBS_NEEDED=y
CT_LIBICONV_NEEDED=y
CT_GETTEXT_NEEDED=y
CT_GMP_NEEDED=y
CT_MPFR_NEEDED=y
CT_ISL_NEEDED=y
CT_MPC_NEEDED=y
CT_NCURSES_NEEDED=y
CT_COMPLIBS=y
CT_LIBICONV=y
CT_GETTEXT=y
CT_GMP=y
CT_MPFR=y
CT_ISL=y
CT_MPC=y
CT_NCURSES=y
# CT_ZLIB is not set
CT_LIBICONV_V_1_15=y
# CT_LIBICONV_V_1_14 is not set
CT_LIBICONV_VERSION="1.15"
CT_GETTEXT_V_0_19_8_1=y
CT_GETTEXT_VERSION="0.19.8.1"
CT_GMP_V_6_1_2=y
CT_GMP_5_0_2_or_later=y
CT_GMP_VERSION="6.1.2"
CT_MPFR_V_3_1_5=y
CT_MPFR_VERSION="3.1.5"
CT_ISL_V_0_18=y
# CT_ISL_V_0_17_1 is not set
# CT_ISL_V_0_16_1 is not set
# CT_ISL_V_0_15 is not set
CT_ISL_V_0_16_or_later=y
CT_ISL_V_0_15_or_later=y
CT_ISL_V_0_14_or_later=y
CT_ISL_V_0_12_or_later=y
CT_ISL_VERSION="0.18"
CT_MPC_V_1_0_3=y
CT_MPC_VERSION="1.0.3"
CT_NCURSES_V_6_0=y
CT_NCURSES_VERSION="6.0"
# CT_NCURSES_NEW_ABI is not set
CT_NCURSES_HOST_CONFIG_ARGS=""
CT_NCURSES_HOST_DISABLE_DB=y
CT_NCURSES_HOST_FALLBACKS="linux,xterm,xterm-color,xterm-256color,vt100"
CT_NCURSES_TARGET_CONFIG_ARGS=""
# CT_NCURSES_TARGET_DISABLE_DB is not set
CT_NCURSES_TARGET_FALLBACKS=""

#
# Companion libraries common options
#
# CT_COMPLIBS_CHECK is not set

#
# Companion tools
#
# CT_COMP_TOOLS_FOR_HOST is not set
# CT_COMP_TOOLS_autoconf is not set
CT_COMP_TOOLS_automake=y
CT_AUTOMAKE_V_1_15=y
CT_AUTOMAKE_VERSION="1.15"
CT_COMP_TOOLS_libtool=y
CT_LIBTOOL_V_2_4_6=y
CT_LIBTOOL_VERSION="2.4.6"
# CT_COMP_TOOLS_m4 is not set
# CT_COMP_TOOLS_make is not set

#
# Test suite
#
# CT_TEST_SUITE_GCC is not set

For compiling anything on Android, you need a good toolchain to cross compile files. To just compile a kernel, you may try using the precompiled toolchain that comes with Android NDK (easy way out). However that one is not optimized for your machine. Neither does it have many prerequisites required if you want to compile other Linux binaries like dosfstools, Over the course of your Android development life, you’ll find yourself missing many linux utilities on Android and will not even find precompiled versions online. So you need to be able to build Linux utilites which can work on your phone too (cross compiling).

Thanks to Ahmet Ipkin (TheGanymedes on XDA), you now have a good guide to making a toolchain for Android. My post is based entirely on his original post, and I urge you to read his opening post completely to understand the details. If it helped you, please consider a paypal donation to him. I will be quoting his post on the actual guide to compile a toolchain, after I add some notes that I felt needed to be inserted to help newbies. 🙂

Prerequisites:

sudo apt-get install gawk bison flex texinfo automake libtool cvs curl aria2 patch lzma libncurses5-dev g++ openjdk-7-jre-headless build-essential libcloog-ppl-dev gettext

To debug issues, it is good to watch the build.log

 

tail -f /home/droidzone/x-tools/arm-msm-linux-gnueabi/build.log

 

Some Notes:

List of Toolchain Options: (Also includes Compatibility Table for different tool versions)

https://docs.google.com/spreadsheet/pub?hl=en_US&hl=en_US&key=0Amlyrhh3vKt7dF9COXVCdTc4VzJ1eGtWSWZueFB4MWc&output=html

Sources for tarballs:

I found that ct-ng allowed you to select only very old versions of included requirements like gcc. So I downloaded them from:

http://ftp.gnu.org/gnu/gcc/  for gcc

http://ftp.gnu.org/gnu/binutils/

http://ftp.gnu.org/gnu/gmp/

http://ftp.gnu.org/gnu/glibc/

http://ftp.gnu.org/gnu/gmp/

http://ftp.gnu.org/gnu/mpfr/

Libelf from http://www.mr511.de/software/

 

Note that once you add them, you have to go to the actual source dir of ct-ng from where you execute ./configure, and execute the following cmd lines:

Adding Latest Versions of Included software

./scripts/addToolVersion.sh --binutils -s -c 2.20.1a
./scripts/addToolVersion.sh --gcc -s -c 4.6.1
./scripts/addToolVersion.sh --glibc -s -c 2.1.3

Note that after you do this, you have to run

./configure --prefix="path to dir where you will be building ct-ng"
make install
cd [to dir where you will make ct-ng"
./ct-ng menuconfig
./ct-ng build

Then, moving to the tarballs dir, wget the latest packages…

wget http://ftp.gnu.org/gnu/glibc/glibc-2.1.3.tar.gz
wget http://ftp.gnu.org/gnu/gcc/gcc-4.6.1/gcc-4.6.1.tar.bz2
wget http://ftp.gnu.org/gnu/binutils/binutils-2.20.1a.tar.bz2
wget http://ftp.gnu.org/gnu/glibc/glibc-2.1.3.tar.gz
wget http://www.mr511.de/software/libelf-0.8.13.tar.gz

Errors I got while building:

Tip: The first time you build, it is good to check the following options:

Menuconfig>Paths and Misc options:

[x]Debug crosstool-ng
[x]Save intermediary steps

This will allow you to continue without redoing the steps which succeeded!

 

  • Error: Installing C library headers, Linux version is unavailable in installed headers files
Installing C library headers
[ERROR] Linux version is unavailable in installed headers files
[ERROR] Build failed in step 'Installing C library headers'
[ERROR] Error happened in '/home/droidzone/ct-ng/lib/ct-ng-1.9.3/scripts/build/libc/glibc.sh' in function 'do_libc_headers' (line unknown, sorry)
[ERROR] called from '/home/droidzone/ct-ng/lib/ct-ng-1.9.3/scripts/crosstool-NG.sh' at line # 597 in function 'main'

According to TheGanymedes, the solution is:

It shows that it couldn’t validate version of the linux kernel. Just open a terminal, go to the kernel directory and write “make ARCH=arm menuconfig”. After writing this, look through all options – you shall find one that allows you to pick your board model, cpu model etc. Pick board model as Qualcomm/msm and as cpu model pick qsd8x50. Sorry that I don’t know the exact names of the options.

After this, quit from that menu with esc-esc keys, and save config. The other options are unnecessary, just board and cpu type is all we need.

Now, write make ARCH=arm CROSS_COMPILE=arm-linux- . It’s going to fail, but will create the necessary version files and this was all we need. Now you can use crosstool-ng.

This is the location to find those options:

System type>ARM System type> Qualcomm MSM/QSD
Qualcomm MSM Soc tyoe: QSD8x50
  • Error: Errors with PPL/CLOOG. This was a tough one, since TheGanymedes forgot to mention that this would happen. ;). This is apparently (according to him) because ct-ng for some reason cannot build PPL/CLOOG. For this, you have to disable Graphite loop optimizations. Only then will ct-ng build
C compiler> Untick “Enable Graphite loop optimizations”
  • Error: Other errors with specific components. This may occur if your net connection is crappy and downloads files. In these cases, though the error message may be rather obscure, you can usually find out what step it failed at, by examining the file ~/x-tools/crosscompilername/.build/build.log. Note that .build is a hidden folder.
  • Error: [ERROR]  Build failed in step ‘Retrieving needed toolchain components’ tarballs’ called in step ‘(top-level)’
    • Now, this is a rather obscure issue which happened both on my local system and on the ssh at sourceforge. The reason was the compiler trying to create a symbolic link that already existed.
    • Solution: Go to ct-ng dir where you execute ./ct-ng build. Within it, do an rm -rf ./build/* ; rmdir ./build
  • Workarounds for getting crosstool itself to build under an ssh environment. The issue was that many dependencies of ct-ng, like autoconf, automake, lzma, texinfo (makeinfo) are not installed on the target system and we have no way of using aptitude. So the solution is to build all these utilities from source. A nice hint to do this to:
    • mkdir -p ~/bin
    • Add a path to your ~/.bashrc, and add the line: PATH=$PATH:~/bin:~/bin/bin
    • Now, configure each dependency while building with: ./configure –prefix=/absolutepath_to_$HOME/bin. Note that instead of building binaries in ~/bin, this builds them in ~/bin/bin. This is a good substitution when you dont have Write rights to /usr/bin (cant do a ‘sudo make install’).
    • Then, make
    • make install. Make install will install to $HOME/bin/bin 🙂

 

The following is a quote of TheGanymedes’s post at XDA. All credits to him.

NOTE
Before you start anything, don’t forget to install build-essentials package. Under ubuntu, the command necessary for it is:sudo apt-get install build-essential – I don’t know about other distros..

 

————————-

Well, as promised, now we should write the steps; right?… Now, before we begin, I should really warn that the process is really head spinning if you’re to do all by yourself; so take heed to the warnings I give you (I learned the hard way) 

Well, first thing is first, we need a Cross Compiler Toolchain, properly built that allows us to build applications, libraries etc. There is one toolchain that’s already given to you with Android Native Development Kit (called NDK) but that one is quite restricted because it’s built with support for Bionic (trimmed C library that is presented in Android), not Glibc or uGlibC. If you want to develop more native-like applications (especially linux programs) you need GlibC or uGlibC. You can try to build these libraries with that toolchain too, but don’t do that, because it’s going to fail as well. The reason is that some sort of Chicken-Egg problem is eminent in GlibC-GCC compilation 

Let’s put the steps to be followed first to build a nice toolchain. I assume you’re using Linux – because the tools are developed for this platform only. If you’re going to use them in Windows, you need Cygwin or such tools but I can’t supply help about that, for since I didn’t use them before at all. Google is your friend about this 

(Note, the packages I wrote at this list are available at GNU’s website www.gnu.org freely, open source)
1- We’re going to build “binutils” first. This package includes some important stuff like assembler, linker, archiver (for libraries) etc..
2- We’re going to build GCC’s prerequisites. These are GMP, MPRF and MPC packages.
3- We’re going to build a “bootstap” gcc (God, I hate that name. I like to call it “naked gcc” more  ). This GCC just converts source codes to pure assemblies: thus cannot generate linkages or such. We’re going to use it to build “actual” tools we’re going to use.
4- We’re going to extract Kernel source/headers – use Desire Kernel’s here. There is some copying, and such to be done tho.
5- We’re going to make GlibC headers installed, which will allow us to build more “complex” gcc, which can link applications with those libraries when the library binaries are given (so such thing is there yet, but we fool it  )
6- We’re going to build a very limited GlibC which will give us support for building more “complex” gcc.
7- We’re going to build GCC again. This is called “Pass 1 GCC” or “GCC Stage 1”. This GCC can link applications to libraries, with the information in Kernel headers and library headers (it’s why we give it the headers, so it can create applications suitable with the Kernel architecture).
8- We’re to build actual GlibC now. This glibC will be used for our compiled applications, statically or dynamically. You can, at the end of this step, copy the files to your devices and they would work, but picking files here is harder, so I’d recommend you to leave this alone for now 
9- We’re going to build “Pass 2 GCC” or “GCC Step 2” This is a full fledged GCC that can do anything we want 

Complex isn’t it? This is precisely why I recommend you to use Crostool-NG. The other tools (like Buildtools or Crosstool) (sadly) don’t create GlibC based toolchains, or use old versions of them, so using this one is recommended. This package automatically will download, setup and link your all toolchain without you worrying about something (believe me, this is what you need. I gave 8 days without this to create a working GCC and Crosstool-NG made another one to me in 50 minutes.  )

Well, however, Crosstool-NG won’t create “nice” applications (they’ll run allright, but they won’t be optimized) without some settings done, so, let’s go there. First, we need to install Crosstool-NG itself. To do that; go to http://crosstool-ng.org/website, download and extract it to some place. Even though the steps are written in Crosstool website, you don’t need all commands there (like setting PATH is unnecessary). The commands you should use is, after CD’ing to the Crosstool dir;

./configure –prefix=”</some/place>”
make
make install
cd “</some/place/bin>”
./ct-ng menuconfig

I used prefix as /home/ahmet/crosstool for instance. Note that this is not going to be where your toolchain is, this is where your “toolchain creator” is .
—- NECESSARY KERNEL HEADER CHANGES —-

OK now, before we start compiling; we need to make some folder moving, copying etc. in Kernel directory. This is needed, because tree structure changed a tad in 2.6 kernels and unless you compiled this kernel before, some directories won’t be in their correct place for our cross compiler. Switch to the directory which you extracted the kernel image. Now, from now on, I’m going to assume you’re an Qualcomm/MSM board (like Desire, Nexus One etc.) user; but if you’re not, change my descriptions accordingly:

1- Go to <kernel dir>/arch/arm/include folder. Copy “asm” directory and paste it into <kernel dir>/include directory.
2- Go to <kernel dir>/arch/arm/mach-msm/include folder. Copy “mach” directory and paste it to <kernel dir>/include/asm directory. It’s going to complain that there is another mach folder there and will ask if you want to merge/overwrite. Say yes to all questions.

Now our kernel headers folder is showing a Desire device. Note that if you’re not a Desire user, you should use your cpu folder instead of ARM and your board manufacturer in mach-xxxxx instead of mach-msm.

Note this kernel directory, we’re going to use it to configure crosstool..

— CONFIGURING CROSSTOOL —

After issuing the commands, the crosstool-ng will give you a configuration menu. Most of the setting here are unchanged, but the ones you should change are given below.

1- Paths and misc options
a) Try features marked as EXPERIMENTAL (this is needed to build a toolchain with the latest GlibC support) -> Enabled
b) Local Tarballs directory -> The folder address that you want downloaded stuff to be kept. You might use them again (like for compiling GlibC again for device, you will use them 
c) Save New Tarballs -> Enabled ( so that new downloaded files aren’t erased  )
d) Working Directory and Prefix directory -> Normally you don’t have to change them, but you can if you want to install your toolchain to some other location. CT_TARGET signifies your target name (like arm-msm-linux-gnueabi – arm is cpu model, msm is vendor (can be anything), linux is showing the binaries are for linux system (you can use android, but then you’ll get not GlibC but Bionic) and gnueabi shows you’re going to use open-source EABI structure for your executables. The other option is ELF but EABI is more flexible (because also supports ELF).
e) Strip all toolchain executables -> do it if you don’t want to debug GCC itself. this makes toolchain smaller of size, and a tad faster.

The other options can stay the way they are, or you can change them accordingly here. You can get help with ? key, and if you don’t understand anything, just leave them default – there are very complex things there that you don’t need to know if you’re not planning to be a expert on subject 

2- Target options
a) Target Architecture -> arm should be selected, cos Desire uses ARM. If you plan to make toolchain for, say, powerpc, pick that.
b) Endianness -> Should be little. ARM processors in Desire uses little endian system.
c) Architecture level -> “armv7-a” this is should be written. Desire uses ARMv7 based instructions and if you leave here empty, the applications will be built with armv5 support – they’re still going to run but not use advanced v7 features.
d) Use Specific FPU -> “neon” . Desire uses NEON structure for floating point arithmetic, and if you leave here empty, the applications will not use Desire’s FPU abilities (everything will be software based, which is slower)
e) Default instruction set mode -> arm . You can use thumb here for allegedly faster code but not every build system supports it. Leave it ARM.
f) Use EABI -> enabled. EABI is necessary for most flexible desing of binaries.

The other settings be as they were.

3- Toolchain options
a) Tuple’s vendor string -> You can leave here empty if you don’t want to; it’s not necessary to use a string here. I used “msm” but you can write anything. This string here is used in toolchain name as arm-xxxxx-linux-gnueabi, so make it short, I recommend 
b) Tuple’s alias -> make it something short like “arm-linux” This alias string is used to make calls to your toolchain easier. Instead of writing arm-msm-linux-gnueabi-gcc everytime, you can use arm-linux-gcc to compile your applications. Can write anything here (like toolchain if you want to use toolchain-gcc to compile your applications)

The other settings can stay as they are, for since default values are the best in our case. You can tweak them only if you know Desire cpu like the back of your hand 

4- Operating system
a) Target OS -> Use “linux” if you want the applications to run in Android and Linux; use “bare metal” if you’re to compile low level applications which won’t use linux headers. Default is linux.
b) Get Kernel headers from -> say “pre installed” because otherwise it’s going to download standard Linux headers from internet. We needed some changes, so this option is compulsory to be “pre installed”
c) Path to custom headers directory/tarball -> Path to your kernel source folder – which you made changes above.WARNING: I say specifically extracted, because standart tarball won’t work for us. We’re going to make some changes in kernel directories, which is non-standart (Instructions were above).
d) This is a tarball -> No . We’re going to use extracted folder.
e) Build shared libraries -> say “yes”; because we want dynamic linkage, not static one 
f) Check kernel headers -> say “no” otherwise some unnecessary check causes compilation to stop.

5- Binary utilities
a) Binutils version – pick the latest one, 2.20.1a. If you use older versions with newer GCC/GlibC, it’s not going to succeed.

Leave others as they are, they are not big deal..

6- C Compiler
a) GCC Version -> pick 4.6.1 for since it’s the latest and most bug free. Just stay away from 4.5 
b) Pick the languages you want support for. I’ve read online that Java is a tad troublesome in Android platform, for since Java in Android uses Dalvik, not Sun systems. You can try it at your second toolchain if you want  Definitely pick C++ tho
c) Link libstdc++ statically -> say yes; it really saves you from big configure scripts later  – apparently needed to avoid PPL problems as well 
d) Compile lidmudflap/libgomp/libssp -> say no. These libraries are not the most suitable libraries for ARM platform (at least at cross-compiler level. You can compile them later, if you want, with your cross-toolchain.)

You can leave others as default

7- C library
a) C library -> gLibC (recommended). You can use other libraries which are eGlibC (embedded Glibc, like Bionic) and uGlibC (micro-glibc) too, but GlibC is the most spanning solution above those. The libraries are bigger, but they support more.
b) glibC version -> Use 2.13 (experimental) it compiles just fine, and you get a new version of GlibC. Not the newest, but that’s ok 
c) Threading implementation -> nptl (recommended) . You can use linuxthreads too, but nptl is more advanced ( like giving support to Thread-Local-Storage and such)
d) Force Unwind Support -> Enabled . If you don’t use this option, for since we’re making this toolchain from scratch, it’s going to give you error during compiling that it couldn’t find necessary headers (we’re building them now, dumbass!)

Leave others default if you don’t know what they’re about

8- Companion Libraries
Well, go and pick the latest versions, even though when it says “Experimental”, otherwise your GCC compilation will give you error about these libraries being old.

After setting these settings, press ESC key twice till it goes way back and ask if you want to save configuration; say yes.

— STARTING COMPILATION —
Now to start compilation write
./ct-ng build.

This is going to take approx. 45 minutes, so go watch some episodes of Big Bang Theory or something. Normally, there should be no errors but if there is; most probably either you made a wrong configuration, or didn’t set your kernel folders well. Try again with other settings, google your problem etc.. 

After this process, you’re going to have a cross-compiler at your use at /home/<username>/x-tool/arm-<vendor>-linux-gnueabi/bin folder. Note that Crosstool-NG automatically makes this folder read only to make you prevent screwing your toolchain  You must edit your path variable to show “/home/<username>/x-tool/arm-<vendor>-linux-gnueabi/bin” folder as well for less headaches during compiling later 

Whilst compiling other application, most used configure options you’re going to use is “–host=arm-<vendor>-linux-gnueabi” and “–prefix=/some/folder/you/want/this/application/copied”. After compilation, you can send binaries to your phone from prefix folder.

More options about GCC and Configure is available at GCC and Autoconf man pages; check them as well 

Happy cross-compiling people 


You are reading this post on Joel G Mathew’s tech blog. Joel's personal blog is the Eyrie, hosted here.