/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: sw=2 ts=8 et :

 */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//////////////////////////////////////////////////////////////////////////////

//

// Explanation: See bug 639842. Safely getting GL driver info on X11 is hard, because the only way to do

// that is to create a GL context and call glGetString(), but with bad drivers,

// just creating a GL context may crash.

//

// This file implements the idea to do that in a separate process.

//

// The only non-static function here is fire_glxtest_process(). It creates a pipe, publishes its 'read' end as the

// mozilla::widget::glxtest_pipe global variable, forks, and runs that GLX probe in the child process,

// which runs the glxtest() static function. This creates a X connection, a GLX context, calls glGetString, and writes that

// to the 'write' end of the pipe.

#include <cstdio>

#include <cstdlib>

#include <unistd.h>

#include <dlfcn.h>

#include "nscore.h"

#include <fcntl.h>

#include "stdint.h"

#ifdef __SUNPRO_CC

#include <stdio.h>

#endif

#include "X11/Xlib.h"

#include "X11/Xutil.h"

#include "mozilla/Unused.h"

// stuff from glx.h

typedef struct __GLXcontextRec *GLXContext;

typedef XID GLXPixmap;

typedef XID GLXDrawable;

/* GLX 1.3 and later */

typedef struct __GLXFBConfigRec *GLXFBConfig;

typedef XID GLXFBConfigID;

typedef XID GLXContextID;

typedef XID GLXWindow;

typedef XID GLXPbuffer;

#define GLX_RGBA        4

#define GLX_RED_SIZE    8

#define GLX_GREEN_SIZE  9

#define GLX_BLUE_SIZE   10

// stuff from gl.h

typedef uint8_t GLubyte;

typedef uint32_t GLenum;

#define GL_VENDOR       0x1F00

#define GL_RENDERER     0x1F01

#define GL_VERSION      0x1F02

namespace mozilla {

namespace widget {

// the read end of the pipe, which will be used by GfxInfo

extern int glxtest_pipe;

// the PID of the glxtest process, to pass to waitpid()

extern pid_t glxtest_pid;

}

}

// the write end of the pipe, which we're going to write to

static int write_end_of_the_pipe = -1;

// C++ standard collides with C standard in that it doesn't allow casting void* to function pointer types.

// So the work-around is to convert first to size_t.

// http://www.trilithium.com/johan/2004/12/problem-with-dlsym/

template<typename func_ptr_type>

static func_ptr_type cast(void *ptr)

{

  return reinterpret_cast<func_ptr_type>(

           reinterpret_cast<size_t>(ptr)

         );

}

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:void* (*cast<void* (*)(char const*)>(void*))(char const*)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:__GLXFBConfigRec** (*cast<__GLXFBConfigRec** (*)(_XDisplay*, int*, int*)>(void*))(_XDisplay*, int*, int*)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:XVisualInfo* (*cast<XVisualInfo* (*)(_XDisplay*, int, int*)>(void*))(_XDisplay*, int, int*)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:__GLXcontextRec* (*cast<__GLXcontextRec* (*)(_XDisplay*, XVisualInfo*, __GLXcontextRec*, int)>(void*))(_XDisplay*, XVisualInfo*, __GLXcontextRec*, int)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:int (*cast<int (*)(_XDisplay*, unsigned long, __GLXcontextRec*)>(void*))(_XDisplay*, unsigned long, __GLXcontextRec*)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:void (*cast<void (*)(_XDisplay*, __GLXcontextRec*)>(void*))(_XDisplay*, __GLXcontextRec*)

Unexecuted instantiation: Unified_cpp_toolkit_xre0.cpp:unsigned char* (*cast<unsigned char* (*)(unsigned int)>(void*))(unsigned int)

static void fatal_error(const char *str)

{

  mozilla::Unused << write(write_end_of_the_pipe, str, strlen(str));

  mozilla::Unused << write(write_end_of_the_pipe, "\n", 1);

  _exit(EXIT_FAILURE);

}

static int

x_error_handler(Display *, XErrorEvent *ev)

{

  enum { bufsize = 1024 };

  char buf[bufsize];

  int length = snprintf(buf, bufsize,

                        "X error occurred in GLX probe, error_code=%d, request_code=%d, minor_code=%d\n",

                        ev->error_code,

                        ev->request_code,

                        ev->minor_code);

  mozilla::Unused << write(write_end_of_the_pipe, buf, length);

  _exit(EXIT_FAILURE);

  return 0;

}

// glxtest is declared inside extern "C" so that the name is not mangled.

// The name is used in build/valgrind/x86_64-pc-linux-gnu.sup to suppress

// memory leak errors because we run it inside a short lived fork and we don't

// care about leaking memory

extern "C" {

void glxtest()

{

  // we want to redirect to /dev/null stdout, stderr, and while we're at it,

  // any PR logging file descriptors. To that effect, we redirect all positive

  // file descriptors up to what open() returns here. In particular, 1 is stdout and 2 is stderr.

  int fd = open("/dev/null", O_WRONLY);

  for (int i = 1; i < fd; i++)

    dup2(fd, i);

  close(fd);

  if (getenv("MOZ_AVOID_OPENGL_ALTOGETHER"))

    fatal_error("The MOZ_AVOID_OPENGL_ALTOGETHER environment variable is defined");

  ///// Open libGL and load needed symbols /////

#ifdef __OpenBSD__

  #define LIBGL_FILENAME "libGL.so"

#else

  #define LIBGL_FILENAME "libGL.so.1"

#endif

  void *libgl = dlopen(LIBGL_FILENAME, RTLD_LAZY);

  if (!libgl)

    fatal_error("Unable to load " LIBGL_FILENAME);

  typedef void* (* PFNGLXGETPROCADDRESS) (const char *);

  PFNGLXGETPROCADDRESS glXGetProcAddress = cast<PFNGLXGETPROCADDRESS>(dlsym(libgl, "glXGetProcAddress"));

  if (!glXGetProcAddress)

    fatal_error("Unable to find glXGetProcAddress in " LIBGL_FILENAME);

  typedef GLXFBConfig* (* PFNGLXQUERYEXTENSION) (Display *, int *, int *);

  PFNGLXQUERYEXTENSION glXQueryExtension = cast<PFNGLXQUERYEXTENSION>(glXGetProcAddress("glXQueryExtension"));

  typedef GLXFBConfig* (* PFNGLXQUERYVERSION) (Display *, int *, int *);

  PFNGLXQUERYVERSION glXQueryVersion = cast<PFNGLXQUERYVERSION>(dlsym(libgl, "glXQueryVersion"));

  typedef XVisualInfo* (* PFNGLXCHOOSEVISUAL) (Display *, int, int *);

  PFNGLXCHOOSEVISUAL glXChooseVisual = cast<PFNGLXCHOOSEVISUAL>(glXGetProcAddress("glXChooseVisual"));

  typedef GLXContext (* PFNGLXCREATECONTEXT) (Display *, XVisualInfo *, GLXContext, Bool);

  PFNGLXCREATECONTEXT glXCreateContext = cast<PFNGLXCREATECONTEXT>(glXGetProcAddress("glXCreateContext"));

  typedef Bool (* PFNGLXMAKECURRENT) (Display*, GLXDrawable, GLXContext);

  PFNGLXMAKECURRENT glXMakeCurrent = cast<PFNGLXMAKECURRENT>(glXGetProcAddress("glXMakeCurrent"));

  typedef void (* PFNGLXDESTROYCONTEXT) (Display*, GLXContext);

  PFNGLXDESTROYCONTEXT glXDestroyContext = cast<PFNGLXDESTROYCONTEXT>(glXGetProcAddress("glXDestroyContext"));

  typedef GLubyte* (* PFNGLGETSTRING) (GLenum);

  PFNGLGETSTRING glGetString = cast<PFNGLGETSTRING>(glXGetProcAddress("glGetString"));

  if (!glXQueryExtension ||

      !glXQueryVersion ||

      !glXChooseVisual ||

      !glXCreateContext ||

      !glXMakeCurrent ||

      !glXDestroyContext ||

      !glGetString)

  {

    fatal_error("glXGetProcAddress couldn't find required functions");

  }

  ///// Open a connection to the X server /////

  Display *dpy = XOpenDisplay(nullptr);

  if (!dpy)

    fatal_error("Unable to open a connection to the X server");

  ///// Check that the GLX extension is present /////

  if (!glXQueryExtension(dpy, nullptr, nullptr))

    fatal_error("GLX extension missing");

  XSetErrorHandler(x_error_handler);

  ///// Get a visual /////

   int attribs[] = {

      GLX_RGBA,

      GLX_RED_SIZE, 1,

      GLX_GREEN_SIZE, 1,

      GLX_BLUE_SIZE, 1,

      None };

  XVisualInfo *vInfo = glXChooseVisual(dpy, DefaultScreen(dpy), attribs);

  if (!vInfo)

    fatal_error("No visuals found");

  // using a X11 Window instead of a GLXPixmap does not crash

  // fglrx in indirect rendering. bug 680644

  Window window;

  XSetWindowAttributes swa;

  swa.colormap = XCreateColormap(dpy, RootWindow(dpy, vInfo->screen),

                                 vInfo->visual, AllocNone);

  swa.border_pixel = 0;

  window = XCreateWindow(dpy, RootWindow(dpy, vInfo->screen),

                       0, 0, 16, 16,

                       0, vInfo->depth, InputOutput, vInfo->visual,

                       CWBorderPixel | CWColormap, &swa);

  ///// Get a GL context and make it current //////

  GLXContext context = glXCreateContext(dpy, vInfo, nullptr, True);

  glXMakeCurrent(dpy, window, context);

  ///// Look for this symbol to determine texture_from_pixmap support /////

  void* glXBindTexImageEXT = glXGetProcAddress("glXBindTexImageEXT");

  ///// Get GL vendor/renderer/versions strings /////

  enum { bufsize = 1024 };

  char buf[bufsize];

  const GLubyte *vendorString = glGetString(GL_VENDOR);

  const GLubyte *rendererString = glGetString(GL_RENDERER);

  const GLubyte *versionString = glGetString(GL_VERSION);

  if (!vendorString || !rendererString || !versionString)

    fatal_error("glGetString returned null");

  int length = snprintf(buf, bufsize,

                        "VENDOR\n%s\nRENDERER\n%s\nVERSION\n%s\nTFP\n%s\n",

                        vendorString,

                        rendererString,

                        versionString,

                        glXBindTexImageEXT ? "TRUE" : "FALSE");

  if (length >= bufsize)

    fatal_error("GL strings length too large for buffer size");

  ///// Clean up. Indeed, the parent process might fail to kill us (e.g. if it doesn't need to check GL info)

  ///// so we might be staying alive for longer than expected, so it's important to consume as little memory as

  ///// possible. Also we want to check that we're able to do that too without generating X errors.

  glXMakeCurrent(dpy, None, nullptr); // must release the GL context before destroying it

  glXDestroyContext(dpy, context);

  XDestroyWindow(dpy, window);

  XFreeColormap(dpy, swa.colormap);

#ifdef NS_FREE_PERMANENT_DATA // conditionally defined in nscore.h, don't forget to #include it above

  XCloseDisplay(dpy);

#else

  // This XSync call wanted to be instead:

  //   XCloseDisplay(dpy);

  // but this can cause 1-minute stalls on certain setups using Nouveau, see bug 973192

  XSync(dpy, False);

#endif

  dlclose(libgl);

  ///// Finally write data to the pipe

  mozilla::Unused << write(write_end_of_the_pipe, buf, length);

}

}

/** \returns true in the child glxtest process, false in the parent process */

bool fire_glxtest_process()

{

  int pfd[2];

  if (pipe(pfd) == -1) {

      perror("pipe");

      return false;

  }

  pid_t pid = fork();

  if (pid < 0) {

      perror("fork");

      close(pfd[0]);

      close(pfd[1]);

      return false;

  }

  // The child exits early to avoid running the full shutdown sequence and avoid conflicting with threads

  // we have already spawned (like the profiler).

  if (pid == 0) {

      close(pfd[0]);

      write_end_of_the_pipe = pfd[1];

      glxtest();

      close(pfd[1]);

      _exit(0);

  }

  close(pfd[1]);

  mozilla::widget::glxtest_pipe = pfd[0];

  mozilla::widget::glxtest_pid = pid;

  return false;

}