tree f081154c44f3836f25502d654ade6e011ea7125e
parent cd6dcc710541dd39504f47a5c258f14a762bb767
parent e84d5956cc6215d2f098e7b6090fc5ec4cba1be3
author Anthony Liguori <aliguori@us.ibm.com> 1347895302 -0500
committer Anthony Liguori <aliguori@us.ibm.com> 1347895302 -0500

Merge remote-tracking branch 'stefanha/trivial-patches' into staging

* stefanha/trivial-patches:
  configure: fix seccomp check
  arch_init.c: add missing '%' symbols before PRIu64 in debug printfs
  kvm: Fix warning from static code analysis
  qapi: Fix enumeration typo error
  console: Clean up bytes per pixel calculation
  Fix copy&paste typos in documentation comments
  linux-user: Remove #if 0'd cpu_get_real_ticks() definition
  ui: Fix spelling in comment (ressource -> resource)
  Spelling fixes in comments and macro names (ressource -> resource)
  Fix spelling (licenced -> licensed) in GPL
  Spelling fixes in comments and documentation
  srp: Don't use QEMU_PACKED for single elements of a structured type
