Release Process for Linaro QEMU

This page describes the release process for the new qemu-linaro, which lives in the git archive at;a=summary

The old process for releasing a qemu-maemo package is described here.

This is a work in progress!

Taking over the release

WARNING : Since reconciling two stgit trees which have both been changed is not easy, before taking over the tree to make the release you need to get positive agreement from the previous 'owner' of the patchstack so that they can avoid making changes to it while you're doing the changes for the release. Then afterwards you need to formally hand it back again so they can resync with the post-release public tree before they start making more changes.

If this is the first time you're doing a release, you need to get an stgit tree which matches the current maintainer's state. The simplest way of doing this is as follows:

# Clone a fresh tree
git clone git://
# Set a publish-linaro remote, to push to
git remote add publish-linaro ssh://
# Create a local qemu-linaro branch.
stg branch --create qemu-linaro remotes/origin/rebasing
# Convert the changesets to stg patches.
stg uncommit -x -t remotes/origin/upstream

This will give you a qemu-linaro branch, with all the patches applied to it.

If you already had a qemu-linaro tree but need to resynchronise it with the publicly available version (for instance if you're taking back control of the patchstack after somebody else did a release) the best thing to do is to delete your local branches (eg with stg branch --delete --force qemu-linaro ; git branch -D qemu-linaro.public) and then recreate them from scratch as above. Obviously you may wish to check you don't have any accidental local changes first...

Update git tree

  1. First make sure that the git tree is actually something you want to release.

    This means that you work on the rebasing branch using stgit, and then use stg publish to copy your changes to master while keeping master mergeable (ie not rebased). Check that you can build it for all targets, and (at a minimum) that you can boot the last Linaro release and the latest snapshot. The Ubuntu netbook image is also a good heavyweight test.

  2. In particular, make sure Changelog.LINARO is up to date:

    • Look on Launchpad for fix-committed bugs in this release.
    • Checkout the master branch and do "git log 2012.01.. hw/arm* target-arm/" to note any upstream arm-related changes which are noteworthy.
  3. Push the changes to the git repository. Assuming you have a branch qemu-linaro which is the same as rebasing, and a branch qemu-linaro.public which is the same as qemu-linaro master, and that your local repository's master branch is the qemu upstream master, this will do:

    git push publish-linaro qemu-linaro.public:master
    git push --force publish-linaro qemu-linaro:rebasing
    git push publish-linaro master:upstream

Create tarball

  1. Check out a fresh source tree:
    git clone git://
    cd qemu-linaro
    echo qemu-linaro `date +%Y.%m` > VERSION.LINARO
    (This is actually a freeform string, but by convention the format here should be "linaro-qemu" giving year and month. For a respin it is "" givin the rev (-1, -2); by convention the initial version would be -0 but we don't put that in the version string.. Optionally you can add "RC1" or similar for a prerelease test.) If you edit the file in an editor make sure you don't leave any editor backups around because the tarball creation will not exclude them...
  3. Create the tarball, which will be placed in your home directory:
    TARFILE=qemu-linaro-$(head VERSION)-$(sed -ne 's/^qemu-linaro //p' VERSION.LINARO)
    rm -rf /tmp/$TARFILE
    cp -r . /tmp/$TARFILE
    cd /tmp/ && tar zcvf ~/$TARFILE.tar.gz $TARFILE --exclude CVS --exclude .git --exclude .svn
    rm -rf /tmp/$TARFILE

(The result of those substitutions should be a TARFILE string like "qemu-linaro-0.15.50-2011.08".) Note that we include the upstream qemu version here -- this causes it to appear in the tarball filename.

(We used to use 'make tar'; however upstream has changed its makefile and now uses a process which includes assumptions about tags for the version being already set and manipulation of submodules. We may move to using that in future, but for the moment, manually do the simple tarball creation the old 'make tar' target did.)

Test the tarball

  1. Untar the results and build them:
    cd /tmp/
    tar xvzf ~/qemu-linaro-0.13.50-2011.02-0.tar.gz
    cd /tmp/qemu-linaro-0.13.50-2011.02-0
  2. Do any further testing you want to do on the built qemu. See Google Docs for the template.

Update Launchpad bugs

  1. Check all the Launchpad bugs being fixed in this release are correctly marked as "Fix committed" and targeted at the milestone for this release. (It is a pain to target bugs to a milestone after you make the release, because you have to reactivate the milestone, target the bug, and then deactivate it.)

Upload tarball

  1. In launchpad create a release for qemu-linaro on trunk.

  2. You may need to create a milestone as part of the 'create release' dialog, if it wasn't created last time around -- this should be eg "2011.02".
  3. Don't tick 'Keep the trunk milestone active' -- you should already have checked that all the relevant bugs are targeted to it...
  4. Fill in the release notes similar to
    Linaro QEMU 2011.08 is the first release of qemu-linaro. Based off upstream qemu, it includes a number of ARM-focused bug fixes and enhancements.
    Interesting changes include:
     * Feature 1
     * Feature 2
  5. Fill in the changelog from Changelog.LINARO

  6. Now "Add a download file"; sign the tarball (as per the instructions there; gpg [-u keyid] --armor --sign --detach-sig ~/qemu-linaro-0.15.50-2011.09.tar.gz), and upload the tarball and signature.

  7. Verify the MD5 sum of the upload (check 'md5sum whatever.tar.gz' matches what launchpad gives the md5sum as)

Tag release in git

  1. Create tags for this release. We have one tag for the master branch and one for the rebasing branch; don't get them mixed up!
    git tag 2011.02 qemu-linaro.public
    git tag 2011.02.rebasing qemu-linaro
    git push publish-linaro 2011.02
    git push publish-linaro 2011.02.rebasing

Arrange for package creation

  1. Ubuntu packages are auto-generated from Linaro's CI. packages can be found in Linaro Tools PPA.

Update others

  1. Create a new milestone for the next release
  2. Change all Fix committed tickets against the milestone to Fix released

  3. Update the current release table on the WorkingGroups/ToolChain wiki page


Create a new project announcment similar to:

Subject: [ANNOUNCE] Linaro QEMU 20XX-XX released

The Linaro Toolchain Working Group is pleased to announce the release of Linaro QEMU 20XX-XX.

(quote the release notes here)

The source tarball is available at:

More information on Linaro QEMU is available at:

Email announcement to only (we no longer mail the -announce list!).

WorkingGroups/ToolChain/QemuReleaseProcess (last modified 2013-03-14 15:38:22)