Linux: add option to link libpci directly instead of using dlopen.

content/gpu/gpu_info_collector_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/gpu/gpu_info_collector.h"
 
 #include <dlfcn.h>
 #include <X11/Xlib.h>
 #include <vector>
 
+// TODO(phajdan.jr): Report problem upstream and make pci.h handle this.
+extern "C" {
+#include <pci/pci.h>
+}
+
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "third_party/libXNVCtrl/NVCtrl.h"
 #include "third_party/libXNVCtrl/NVCtrlLib.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
-// PciDevice and PciAccess are defined to access libpci functions.  Their
-// members match the corresponding structures defined by libpci in size up to
-// fields we may access.  For those members we don't use, their names are
-// defined as "fieldX", etc., or, left out if they are declared after the
-// members we care about in libpci.
-
-struct PciDevice {
-  PciDevice* next;
-
-  uint16 field0;
-  uint8 field1;
-  uint8 field2;
-  uint8 field3;
-  int field4;
-
-  uint16 vendor_id;
-  uint16 device_id;
-  uint16 device_class;
-};
-
-struct PciAccess {
-  unsigned int field0;
-  int field1;
-  int field2;
-  char* field3;
-  int field4;
-  int field5;
-  unsigned int field6;
-  int field7;
-
-  void (*function0)();
-  void (*function1)();
-  void (*function2)();
-
-  PciDevice* device_list;
-};
-
 // Define function types.
-typedef PciAccess* (*FT_pci_alloc)();
-typedef void (*FT_pci_init)(PciAccess*);
-typedef void (*FT_pci_cleanup)(PciAccess*);
-typedef void (*FT_pci_scan_bus)(PciAccess*);
-typedef void (*FT_pci_scan_bus)(PciAccess*);
-typedef int (*FT_pci_fill_info)(PciDevice*, int);
-typedef char* (*FT_pci_lookup_name)(PciAccess*, char*, int, int, ...);
+typedef pci_access* (*FT_pci_alloc)();
+typedef void (*FT_pci_init)(pci_access*);
+typedef void (*FT_pci_cleanup)(pci_access*);
+typedef void (*FT_pci_scan_bus)(pci_access*);
+typedef void (*FT_pci_scan_bus)(pci_access*);
+typedef int (*FT_pci_fill_info)(pci_dev*, int);
+typedef char* (*FT_pci_lookup_name)(pci_access*, char*, int, int, ...);
 
 // This includes dynamically linked library handle and functions pointers from
 // libpci.
 struct PciInterface {
   void* lib_handle;
 
   FT_pci_alloc pci_alloc;
   FT_pci_init pci_init;
   FT_pci_cleanup pci_cleanup;
   FT_pci_scan_bus pci_scan_bus;
   FT_pci_fill_info pci_fill_info;
   FT_pci_lookup_name pci_lookup_name;
 };
 
 // This checks if a system supports PCI bus.
 // We check the existence of /sys/bus/pci or /sys/bug/pci_express.
 bool IsPciSupported() {
   const FilePath pci_path("/sys/bus/pci/");
   const FilePath pcie_path("/sys/bus/pci_express/");
   return (file_util::PathExists(pci_path) ||
           file_util::PathExists(pcie_path));
 }
 
 // This dynamically opens libpci and get function pointers we need.  Return
 // NULL if library fails to open or any functions can not be located.
 // Returned interface (if not NULL) should be deleted in FinalizeLibPci.
 PciInterface* InitializeLibPci(const char* lib_name) {
+#if defined(DLOPEN_LIBPCI)
   void* handle = dlopen(lib_name, RTLD_LAZY);
   if (handle == NULL) {
     VLOG(1) << "Failed to dlopen " << lib_name;
     return NULL;
   }
   PciInterface* interface = new struct PciInterface;

[Zhenyao Mo, 2012/10/29 21:39:08]

Nit: this can be outside the #if branches.

[Paweł Hajdan Jr., 2012/10/29 23:06:44]

Done. Note I used scoped_ptr to avoid leaks.

   interface->lib_handle = handle;
   interface->pci_alloc = reinterpret_cast<FT_pci_alloc>(
       dlsym(handle, "pci_alloc"));
   interface->pci_init = reinterpret_cast<FT_pci_init>(
       dlsym(handle, "pci_init"));
   interface->pci_cleanup = reinterpret_cast<FT_pci_cleanup>(
       dlsym(handle, "pci_cleanup"));
   interface->pci_scan_bus = reinterpret_cast<FT_pci_scan_bus>(
       dlsym(handle, "pci_scan_bus"));
   interface->pci_fill_info = reinterpret_cast<FT_pci_fill_info>(
       dlsym(handle, "pci_fill_info"));
   interface->pci_lookup_name = reinterpret_cast<FT_pci_lookup_name>(
       dlsym(handle, "pci_lookup_name"));
   if (interface->pci_alloc == NULL ||
       interface->pci_init == NULL ||
       interface->pci_cleanup == NULL ||
       interface->pci_scan_bus == NULL ||
       interface->pci_fill_info == NULL ||
       interface->pci_lookup_name == NULL) {
     VLOG(1) << "Missing required function(s) from " << lib_name;
     dlclose(handle);
     delete interface;
     return NULL;
   }
+#else  // !defined(DLOPEN_LIBPCI)
+  PciInterface* interface = new struct PciInterface;
+  interface->lib_handle = NULL;
+  interface->pci_alloc = &pci_alloc;
+  interface->pci_init = &pci_init;
+  interface->pci_cleanup = &pci_cleanup;
+  interface->pci_scan_bus = &pci_scan_bus;
+  interface->pci_fill_info = &pci_fill_info;
+  interface->pci_lookup_name = &pci_lookup_name;
+#endif  // !defined(DLOPEN_LIBPCI)
   return interface;
 }
 
 // This close the dynamically opened libpci and delete the interface.
 void FinalizeLibPci(PciInterface** interface) {
+#if defined(DLOPEN_LIBPCI)
   DCHECK(interface && *interface && (*interface)->lib_handle);
   dlclose((*interface)->lib_handle);
+#endif  // defined(DLOPEN_LIBPCI)
   delete (*interface);
   *interface = NULL;
 }
 
 // Scan /etc/ati/amdpcsdb.default for "ReleaseVersion".
 // Return empty string on failing.
 std::string CollectDriverVersionATI() {
   const FilePath::CharType kATIFileName[] =
       FILE_PATH_LITERAL("/etc/ati/amdpcsdb.default");
   FilePath ati_file_path(kATIFileName);
@@ skipping 124 matching lines @@
 
   // TODO(zmo): be more flexible about library name.
   PciInterface* interface = InitializeLibPci("libpci.so.3");
   if (interface == NULL)
     interface = InitializeLibPci("libpci.so");
   if (interface == NULL) {
     VLOG(1) << "Failed to locate libpci";
     return false;
   }
 
-  PciAccess* access = (interface->pci_alloc)();
+  pci_access* access = (interface->pci_alloc)();
   DCHECK(access != NULL);
   (interface->pci_init)(access);
   (interface->pci_scan_bus)(access);
   bool primary_gpu_identified = false;
-  for (PciDevice* device = access->device_list;
+  for (pci_dev* device = access->devices;
        device != NULL; device = device->next) {
     (interface->pci_fill_info)(device, 33);  // Fill the IDs and class fields.
     // TODO(zmo): there might be other classes that qualify as display devices.
     if (device->device_class != 0x0300)  // Device class is DISPLAY_VGA.
       continue;
 
     content::GPUInfo::GPUDevice gpu;
     gpu.vendor_id = device->vendor_id;
     gpu.device_id = device->device_id;
 
@@ skipping 75 matching lines @@
     return false;
   if (pos != std::string::npos)
     driver_version = driver_version.substr(0, pos);
 
   gpu_info->driver_vendor = pieces[1];
   gpu_info->driver_version = driver_version;
   return true;
 }
 
 }  // namespace gpu_info_collector