src/linux_sysfs.c

   1 /*
   2  * (C) Copyright IBM Corporation 2006
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file linux_sysfs.c
  27  * Access PCI subsystem using Linux's sysfs interface.  This interface is
  28  * available starting somewhere in the late 2.5.x kernel phase, and is the
  29  * prefered method on all 2.6.x kernels.
  30  *
  31  * \author Ian Romanick <idr@us.ibm.com>
  32  */
  33
  34 #define _GNU_SOURCE
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39 #include <unistd.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <fcntl.h>
  43 #include <sys/mman.h>
  44 #include <dirent.h>
  45 #include <errno.h>
  46
  47 #include "config.h"
  48
  49 #ifdef HAVE_MTRR
  50 #include <asm/mtrr.h>
  51 #include <sys/ioctl.h>
  52 #endif
  53
  54 #include "pciaccess.h"
  55 #include "pciaccess_private.h"
  56 #include "linux_devmem.h"
  57
  58 static int pci_device_linux_sysfs_read_rom( struct pci_device * dev,
  59     void * buffer );
  60
  61 static int pci_device_linux_sysfs_probe( struct pci_device * dev );
  62
  63 static int pci_device_linux_sysfs_map_range(struct pci_device *dev,
  64     struct pci_device_mapping *map);
  65
  66 static int pci_device_linux_sysfs_unmap_range(struct pci_device *dev,
  67     struct pci_device_mapping *map);
  68
  69 static int pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
  70     pciaddr_t offset, pciaddr_t size, pciaddr_t * bytes_read );
  71
  72 static int pci_device_linux_sysfs_write( struct pci_device * dev,
  73     const void * data, pciaddr_t offset, pciaddr_t size,
  74     pciaddr_t * bytes_wrtten );
  75
  76 static const struct pci_system_methods linux_sysfs_methods = {
  77     .destroy = NULL,
  78     .destroy_device = NULL,
  79     .read_rom = pci_device_linux_sysfs_read_rom,
  80     .probe = pci_device_linux_sysfs_probe,
  81     .map_range = pci_device_linux_sysfs_map_range,
  82     .unmap_range = pci_device_linux_sysfs_unmap_range,
  83
  84     .read = pci_device_linux_sysfs_read,
  85     .write = pci_device_linux_sysfs_write,
  86
  87     .fill_capabilities = pci_fill_capabilities_generic
  88 };
  89
  90 #define SYS_BUS_PCI "/sys/bus/pci/devices"
  91
  92
  93 static int populate_entries(struct pci_system * pci_sys);
  94
  95
  96 /**
  97  * Attempt to access PCI subsystem using Linux's sysfs interface.
  98  */
  99 _pci_hidden int
 100 pci_system_linux_sysfs_create( void )
 101 {
 102     int err = 0;
 103     struct stat st;
 104
 105
 106     /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem
 107      * can be accessed using this interface.
 108      */
 109
 110     if ( stat( SYS_BUS_PCI, & st ) == 0 ) {
 111         pci_sys = calloc( 1, sizeof( struct pci_system ) );
 112         if ( pci_sys != NULL ) {
 113             pci_sys->methods = & linux_sysfs_methods;
 114             err = populate_entries(pci_sys);
 115         }
 116         else {
 117             err = ENOMEM;
 118         }
 119     }
 120     else {
 121         err = errno;
 122     }
 123
 124 #ifdef HAVE_MTRR
 125     pci_sys->mtrr_fd = open("/proc/mtrr", O_WRONLY);
 126 #endif
 127
 128     return err;
 129 }
 130
 131
 132 /**
 133  * Filter out the names "." and ".." from the scanned sysfs entries.
 134  *
 135  * \param d  Directory entry being processed by \c scandir.
 136  *
 137  * \return
 138  * Zero if the entry name matches either "." or "..", non-zero otherwise.
 139  *
 140  * \sa scandir, populate_entries
 141  */
 142 static int
 143 scan_sys_pci_filter( const struct dirent * d )
 144 {
 145     return !((strcmp( d->d_name, "." ) == 0)
 146              || (strcmp( d->d_name, ".." ) == 0));
 147 }
 148
 149
 150 int
 151 populate_entries( struct pci_system * p )
 152 {
 153     struct dirent ** devices;
 154     int n;
 155     int i;
 156     int err = 0;
 157
 158
 159     n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort );
 160     if ( n > 0 ) {
 161         p->num_devices = n;
 162         p->devices = calloc( n, sizeof( struct pci_device_private ) );
 163
 164         if (p->devices != NULL) {
 165             for (i = 0 ; i < n ; i++) {
 166                 uint8_t config[48];
 167                 pciaddr_t bytes;
 168                 unsigned dom, bus, dev, func;
 169                 struct pci_device_private *device =
 170                         (struct pci_device_private *) &p->devices[i];
 171
 172
 173                 sscanf(devices[i]->d_name, "%04x:%02x:%02x.%1u",
 174                        & dom, & bus, & dev, & func);
 175
 176                 device->base.domain = dom;
 177                 device->base.bus = bus;
 178                 device->base.dev = dev;
 179                 device->base.func = func;
 180
 181
 182                 err = pci_device_linux_sysfs_read(& device->base, config, 0,
 183                                                   48, & bytes);
 184                 if ((bytes == 48) && !err) {
 185                     device->base.vendor_id = (uint16_t)config[0]
 186                         + ((uint16_t)config[1] << 8);
 187                     device->base.device_id = (uint16_t)config[2]
 188                         + ((uint16_t)config[3] << 8);
 189                     device->base.device_class = (uint32_t)config[9]
 190                         + ((uint32_t)config[10] << 8)
 191                         + ((uint32_t)config[11] << 16);
 192                     device->base.revision = config[8];
 193                     device->base.subvendor_id = (uint16_t)config[44]
 194                         + ((uint16_t)config[45] << 8);
 195                     device->base.subdevice_id = (uint16_t)config[46]
 196                         + ((uint16_t)config[47] << 8);
 197                 }
 198
 199                 if (err) {
 200                     break;
 201                 }
 202             }
 203         }
 204         else {
 205             err = ENOMEM;
 206         }
 207     }
 208
 209     if (err) {
 210         free(p->devices);
 211         p->devices = NULL;
 212     }
 213
 214     return err;
 215 }
 216
 217
 218 static int
 219 pci_device_linux_sysfs_probe( struct pci_device * dev )
 220 {
 221     char     name[256];
 222     uint8_t  config[256];
 223     char     resource[512];
 224     int fd;
 225     pciaddr_t bytes;
 226     unsigned i;
 227     int err;
 228
 229
 230     err = pci_device_linux_sysfs_read( dev, config, 0, 256, & bytes );
 231     if ( bytes >= 64 ) {
 232         struct pci_device_private *priv = (struct pci_device_private *) dev;
 233
 234         dev->irq = config[60];
 235         priv->header_type = config[14];
 236
 237
 238         /* The PCI config registers can be used to obtain information
 239          * about the memory and I/O regions for the device.  However,
 240          * doing so requires some tricky parsing (to correctly handle
 241          * 64-bit memory regions) and requires writing to the config
 242          * registers.  Since we'd like to avoid having to deal with the
 243          * parsing issues and non-root users can write to PCI config
 244          * registers, we use a different file in the device's sysfs
 245          * directory called "resource".
 246          *
 247          * The resource file contains all of the needed information in
 248          * a format that is consistent across all platforms.  Each BAR
 249          * and the expansion ROM have a single line of data containing
 250          * 3, 64-bit hex values:  the first address in the region,
 251          * the last address in the region, and the region's flags.
 252          */
 253         snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource",
 254                   SYS_BUS_PCI,
 255                   dev->domain,
 256                   dev->bus,
 257                   dev->dev,
 258                   dev->func );
 259         fd = open( name, O_RDONLY );
 260         if ( fd != -1 ) {
 261             char * next;
 262             pciaddr_t  low_addr;
 263             pciaddr_t  high_addr;
 264             pciaddr_t  flags;
 265
 266
 267             bytes = read( fd, resource, 512 );
 268             resource[511] = '\0';
 269
 270             close( fd );
 271
 272             next = resource;
 273             for ( i = 0 ; i < 6 ; i++ ) {
 274
 275                 dev->regions[i].base_addr = strtoull( next, & next, 16 );
 276                 high_addr = strtoull( next, & next, 16 );
 277                 flags = strtoull( next, & next, 16 );
 278
 279                 if ( dev->regions[i].base_addr != 0 ) {
 280                     dev->regions[i].size = (high_addr
 281                                             - dev->regions[i].base_addr) + 1;
 282
 283                     dev->regions[i].is_IO = (flags & 0x01);
 284                     dev->regions[i].is_64 = (flags & 0x04);
 285                     dev->regions[i].is_prefetchable = (flags & 0x08);
 286                 }
 287             }
 288
 289             low_addr = strtoull( next, & next, 16 );
 290             high_addr = strtoull( next, & next, 16 );
 291             flags = strtoull( next, & next, 16 );
 292             if ( low_addr != 0 ) {
 293                 priv->rom_base = low_addr;
 294                 dev->rom_size = (high_addr - low_addr) + 1;
 295             }
 296         }
 297     }
 298
 299     return err;
 300 }
 301
 302
 303 static int
 304 pci_device_linux_sysfs_read_rom( struct pci_device * dev, void * buffer )
 305 {
 306     char name[256];
 307     int fd;
 308     struct stat  st;
 309     int err = 0;
 310     size_t rom_size;
 311     size_t total_bytes;
 312
 313
 314     snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/rom",
 315               SYS_BUS_PCI,
 316               dev->domain,
 317               dev->bus,
 318               dev->dev,
 319               dev->func );
 320
 321     fd = open( name, O_RDWR );
 322     if ( fd == -1 ) {
 323         /* If reading the ROM using sysfs fails, fall back to the old
 324          * /dev/mem based interface.
 325          */
 326         return pci_device_linux_devmem_read_rom(dev, buffer);
 327     }
 328
 329
 330     if ( fstat( fd, & st ) == -1 ) {
 331         close( fd );
 332         return errno;
 333     }
 334
 335     rom_size = st.st_size;
 336     if ( rom_size == 0 )
 337         rom_size = 0x10000;
 338
 339     /* This is a quirky thing on Linux.  Even though the ROM and the file
 340      * for the ROM in sysfs are read-only, the string "1" must be written to
 341      * the file to enable the ROM.  After the data has been read, "0" must be
 342      * written to the file to disable the ROM.
 343      */
 344     write( fd, "1", 1 );
 345     lseek( fd, 0, SEEK_SET );
 346
 347     for ( total_bytes = 0 ; total_bytes < rom_size ; /* empty */ ) {
 348         const int bytes = read( fd, (char *) buffer + total_bytes,
 349                                 rom_size - total_bytes );
 350         if ( bytes == -1 ) {
 351             err = errno;
 352             break;
 353         }
 354         else if ( bytes == 0 ) {
 355             break;
 356         }
 357
 358         total_bytes += bytes;
 359     }
 360
 361
 362     lseek( fd, 0, SEEK_SET );
 363     write( fd, "0", 1 );
 364
 365     close( fd );
 366     return err;
 367 }
 368
 369
 370 static int
 371 pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
 372                              pciaddr_t offset, pciaddr_t size,
 373                              pciaddr_t * bytes_read )
 374 {
 375     char name[256];
 376     pciaddr_t temp_size = size;
 377     int err = 0;
 378     int fd;
 379     char *data_bytes = data;
 380
 381     if ( bytes_read != NULL ) {
 382         *bytes_read = 0;
 383     }
 384
 385     /* Each device has a directory under sysfs.  Within that directory there
 386      * is a file named "config".  This file used to access the PCI config
 387      * space.  It is used here to obtain most of the information about the
 388      * device.
 389      */
 390     snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
 391               SYS_BUS_PCI,
 392               dev->domain,
 393               dev->bus,
 394               dev->dev,
 395               dev->func );
 396
 397     fd = open( name, O_RDONLY );
 398     if ( fd == -1 ) {
 399         return errno;
 400     }
 401
 402
 403     while ( temp_size > 0 ) {
 404         const ssize_t bytes = pread64( fd, data_bytes, temp_size, offset );
 405
 406         /* If zero bytes were read, then we assume it's the end of the
 407          * config file.
 408          */
 409         if ( bytes <= 0 ) {
 410             err = errno;
 411             break;
 412         }
 413
 414         temp_size -= bytes;
 415         offset += bytes;
 416         data_bytes += bytes;
 417     }
 418
 419     if ( bytes_read != NULL ) {
 420         *bytes_read = size - temp_size;
 421     }
 422
 423     close( fd );
 424     return err;
 425 }
 426
 427
 428 static int
 429 pci_device_linux_sysfs_write( struct pci_device * dev, const void * data,
 430                              pciaddr_t offset, pciaddr_t size,
 431                              pciaddr_t * bytes_written )
 432 {
 433     char name[256];
 434     pciaddr_t temp_size = size;
 435     int err = 0;
 436     int fd;
 437     const char *data_bytes = data;
 438
 439     if ( bytes_written != NULL ) {
 440         *bytes_written = 0;
 441     }
 442
 443     /* Each device has a directory under sysfs.  Within that directory there
 444      * is a file named "config".  This file used to access the PCI config
 445      * space.  It is used here to obtain most of the information about the
 446      * device.
 447      */
 448     snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
 449               SYS_BUS_PCI,
 450               dev->domain,
 451               dev->bus,
 452               dev->dev,
 453               dev->func );
 454
 455     fd = open( name, O_WRONLY );
 456     if ( fd == -1 ) {
 457         return errno;
 458     }
 459
 460
 461     while ( temp_size > 0 ) {
 462         const ssize_t bytes = pwrite64( fd, data_bytes, temp_size, offset );
 463
 464         /* If zero bytes were written, then we assume it's the end of the
 465          * config file.
 466          */
 467         if ( bytes <= 0 ) {
 468             err = errno;
 469             break;
 470         }
 471
 472         temp_size -= bytes;
 473         offset += bytes;
 474         data_bytes += bytes;
 475     }
 476
 477     if ( bytes_written != NULL ) {
 478         *bytes_written = size - temp_size;
 479     }
 480
 481     close( fd );
 482     return err;
 483 }
 484
 485
 486 /**
 487  * Map a memory region for a device using the Linux sysfs interface.
 488  *
 489  * \param dev   Device whose memory region is to be mapped.
 490  * \param map   Parameters of the mapping that is to be created.
 491  *
 492  * \return
 493  * Zero on success or an \c errno value on failure.
 494  *
 495  * \sa pci_device_map_rrange, pci_device_linux_sysfs_unmap_range
 496  *
 497  * \todo
 498  * Some older 2.6.x kernels don't implement the resourceN files.  On those
 499  * systems /dev/mem must be used.  On these systems it is also possible that
 500  * \c mmap64 may need to be used.
 501  */
 502 static int
 503 pci_device_linux_sysfs_map_range(struct pci_device *dev,
 504                                  struct pci_device_mapping *map)
 505 {
 506     char name[256];
 507     int fd;
 508     int err = 0;
 509     const int prot = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
 510         ? (PROT_READ | PROT_WRITE) : PROT_READ;
 511     const int open_flags = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
 512         ? O_RDWR : O_RDONLY;
 513     const off_t offset = map->base - dev->regions[map->region].base_addr;
 514 #ifdef HAVE_MTRR
 515     struct mtrr_sentry sentry = {
 516         .base = map->base,
 517         .size = map->size,
 518         .type = MTRR_TYPE_UNCACHABLE
 519     };
 520 #endif
 521
 522     snprintf(name, 255, "%s/%04x:%02x:%02x.%1u/resource%u",
 523              SYS_BUS_PCI,
 524              dev->domain,
 525              dev->bus,
 526              dev->dev,
 527              dev->func,
 528              map->region);
 529
 530     fd = open(name, open_flags);
 531     if (fd == -1) {
 532         return errno;
 533     }
 534
 535
 536     map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset);
 537     if (map->memory == MAP_FAILED) {
 538         err = errno;
 539         map->memory = NULL;
 540     }
 541
 542     close(fd);
 543
 544 #ifdef HAVE_MTRR
 545     if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) {
 546         sentry.type = MTRR_TYPE_WRBACK;
 547     } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) {
 548         sentry.type = MTRR_TYPE_WRCOMB;
 549     }
 550
 551     if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) {
 552         if (ioctl(pci_sys->mtrr_fd, MTRRIOC_ADD_ENTRY, &sentry) < 0) {
 553             /* FIXME: Should we report an error in this case?
 554              */
 555             fprintf(stderr, "error setting MTRR "
 556                     "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n",
 557                     sentry.base, sentry.size, sentry.type,
 558                     strerror(errno), errno);
 559 /*            err = errno;*/
 560         }
 561         /* KLUDGE ALERT -- rewrite the PTEs to turn off the CD and WT bits */
 562         mprotect (map->memory, map->size, PROT_NONE);
 563         mprotect (map->memory, map->size, PROT_READ|PROT_WRITE);
 564     }
 565 #endif
 566
 567     return err;
 568 }
 569
 570 /**
 571  * Unmap a memory region for a device using the Linux sysfs interface.
 572  *
 573  * \param dev   Device whose memory region is to be unmapped.
 574  * \param map   Parameters of the mapping that is to be destroyed.
 575  *
 576  * \return
 577  * Zero on success or an \c errno value on failure.
 578  *
 579  * \sa pci_device_map_rrange, pci_device_linux_sysfs_map_range
 580  *
 581  * \todo
 582  * Some older 2.6.x kernels don't implement the resourceN files.  On those
 583  * systems /dev/mem must be used.  On these systems it is also possible that
 584  * \c mmap64 may need to be used.
 585  */
 586 static int
 587 pci_device_linux_sysfs_unmap_range(struct pci_device *dev,
 588                                    struct pci_device_mapping *map)
 589 {
 590     int err = 0;
 591 #ifdef HAVE_MTRR
 592     struct mtrr_sentry sentry = {
 593         .base = map->base,
 594         .size = map->size,
 595         .type = MTRR_TYPE_UNCACHABLE
 596     };
 597 #endif
 598
 599     err = pci_device_generic_unmap_range (dev, map);
 600     if (err)
 601         return err;
 602
 603 #ifdef HAVE_MTRR
 604     if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) {
 605         sentry.type = MTRR_TYPE_WRBACK;
 606     } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) {
 607         sentry.type = MTRR_TYPE_WRCOMB;
 608     }
 609
 610     if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) {
 611         if (ioctl(pci_sys->mtrr_fd, MTRRIOC_DEL_ENTRY, &sentry) < 0) {
 612             /* FIXME: Should we report an error in this case?
 613              */
 614             fprintf(stderr, "error setting MTRR "
 615                     "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n",
 616                     sentry.base, sentry.size, sentry.type,
 617                     strerror(errno), errno);
 618 /*            err = errno;*/
 619         }
 620     }
 621 #endif
 622
 623     return err;
 624 }