Add libvts (Virtual Terminal Session) api

This adds a small library - libvts - to the cogl repo for safely
handling the privileged operations involved in opening a tty, opening a
pam session (optional), claiming drmMaster() mode for using KMS and
opening evdev input devices for the session-seat.

This was written to support the launching of Wayland based compositors
but there is nothing Wayland specific about the code so it can be used
to launch any kind of full screen application that wants to run on a
Linux virtual console via KMS.

The code has very minimal dependencies (no glib usage for example) and
could be factored out into a standalone project. This would enable
weston-launch to share the same code.

In the meantime we will maintain this code in Cogl so that applications
using the KMS backend can automatically take advantage of it.
Adds cogl udev api for discovering a drm device

This adds udev based probing of drm devices that can be used by the KMS
winsys and also support for monitoring hotplug events.
Adds CoglOutput support to KMS winsys
stash: Adds _USES_KMS constraint
stash: cogl-kms-hello example
stash: cogl-output don't guard config.h include
kms: set EGL_PLATFORM environment variable

Although EGL doesn't currently have a standard way of supporting
multiple platforms and being able explicitly select a platform, Mesa at
least lets you explicitly select a platform via the EGL_PLATFORM
environment variable. This makes the egl-kms winsys set EGL_PLATFORM to
"gbm".
drm: support authenticating a drm fd via X

This adds support for authenticating a DRM file descriptor via an X
server using the DRI2 protocol. This allows us to probe kms for
information without necessarily being drm master (which requires root
privileges)
stash: Expose api to configure outputs

Previously it was only possible to read the state of outputs. This patch
introduces apis for configuring outputs including setting new modes and
setting up hardware overlays.

This notably has a different style to the XRandR/KMS apis that expose
a model of components that can be assembled into a display pipeline. For
example the KMS api lets you make a pipeline like this:

  framebuffers -> crtc [+planes] -> encoder -> connector

This Cogl api instead exposes an object (CoglOutput) that represents a
full display/output pipeline and then lets you hook sources into that
pipeline via CoglOverlay objects whereby a source may be scaled and
positioned relative to the full output resolution and multiple overlays
may be stacked to be composed before display.

With this api all output changes are batched up until
cogl_renderer_commit_outputs() is called and on failure we will role
back to the previous state. This is also unlike the KMS api where errors
can be reported while you may only be part way through configuring the
outputs as desired and there is no role back mechanism.

With this api we also hope to cover more capabilities with a portable
api whereas the portable KMS api is very minimal and depends on device
specific ioctls for more complete control.
stash
stash
stash