lib/sysfs.c

   1 /*
   2  *      The PCI Library -- Configuration Access via /sys/bus/pci
   3  *
   4  *      Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
   5  *      Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
   6  *
   7  *      Can be freely distributed and used under the terms of the GNU GPL.
   8  */
   9
  10 #define _GNU_SOURCE
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <stdarg.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18 #include <dirent.h>
  19 #include <fcntl.h>
  20 #include <sys/types.h>
  21
  22 #include "internal.h"
  23 #include "pread.h"
  24
  25 static void
  26 sysfs_config(struct pci_access *a)
  27 {
  28   pci_define_param(a, "sysfs.path", PCI_PATH_SYS_BUS_PCI, "Path to the sysfs device tree");
  29 }
  30
  31 static inline char *
  32 sysfs_name(struct pci_access *a)
  33 {
  34   return pci_get_param(a, "sysfs.path");
  35 }
  36
  37 static int
  38 sysfs_detect(struct pci_access *a)
  39 {
  40   if (access(sysfs_name(a), R_OK))
  41     {
  42       a->debug("...cannot open %s", sysfs_name(a));
  43       return 0;
  44     }
  45   a->debug("...using %s", sysfs_name(a));
  46   return 1;
  47 }
  48
  49 static void
  50 sysfs_init(struct pci_access *a)
  51 {
  52   a->fd = -1;
  53 }
  54
  55 static void
  56 sysfs_cleanup(struct pci_access *a)
  57 {
  58   if (a->fd >= 0)
  59     {
  60       close(a->fd);
  61       a->fd = -1;
  62     }
  63 }
  64
  65 #define OBJNAMELEN 1024
  66 static void
  67 sysfs_obj_name(struct pci_dev *d, char *object, char *buf)
  68 {
  69   int n = snprintf(buf, OBJNAMELEN, "%s/devices/%04x:%02x:%02x.%d/%s",
  70                    sysfs_name(d->access), d->domain, d->bus, d->dev, d->func, object);
  71   if (n < 0 || n >= OBJNAMELEN)
  72     d->access->error("File name too long");
  73 }
  74
  75 static int
  76 sysfs_get_value(struct pci_dev *d, char *object)
  77 {
  78   struct pci_access *a = d->access;
  79   int fd, n;
  80   char namebuf[OBJNAMELEN], buf[256];
  81
  82   sysfs_obj_name(d, object, namebuf);
  83   fd = open(namebuf, O_RDONLY);
  84   if (fd < 0)
  85     a->error("Cannot open %s: %s", namebuf, strerror(errno));
  86   n = read(fd, buf, sizeof(buf));
  87   close(fd);
  88   if (n < 0)
  89     a->error("Error reading %s: %s", namebuf, strerror(errno));
  90   if (n >= (int) sizeof(buf))
  91     a->error("Value in %s too long", namebuf);
  92   buf[n] = 0;
  93   return strtol(buf, NULL, 0);
  94 }
  95
  96 static void
  97 sysfs_get_resources(struct pci_dev *d)
  98 {
  99   struct pci_access *a = d->access;
 100   char namebuf[OBJNAMELEN], buf[256];
 101   FILE *file;
 102   int i;
 103
 104   sysfs_obj_name(d, "resource", namebuf);
 105   file = fopen(namebuf, "r");
 106   if (!file)
 107     a->error("Cannot open %s: %s", namebuf, strerror(errno));
 108   for (i = 0; i < 7; i++)
 109     {
 110       unsigned long long start, end, size;
 111       if (!fgets(buf, sizeof(buf), file))
 112         break;
 113       if (sscanf(buf, "%llx %llx", &start, &end) != 2)
 114         a->error("Syntax error in %s", namebuf);
 115       if (start)
 116         size = end - start + 1;
 117       else
 118         size = 0;
 119       if (i < 6)
 120         {
 121           d->base_addr[i] = start;
 122           d->size[i] = size;
 123         }
 124       else
 125         {
 126           d->rom_base_addr = start;
 127           d->rom_size = size;
 128         }
 129     }
 130   fclose(file);
 131 }
 132
 133 static void sysfs_scan(struct pci_access *a)
 134 {
 135   char dirname[1024];
 136   DIR *dir;
 137   struct dirent *entry;
 138   int n;
 139
 140   n = snprintf(dirname, sizeof(dirname), "%s/devices", sysfs_name(a));
 141   if (n < 0 || n >= (int) sizeof(dirname))
 142     a->error("Directory name too long");
 143   dir = opendir(dirname);
 144   if (!dir)
 145     a->error("Cannot open %s", dirname);
 146   while ((entry = readdir(dir)))
 147     {
 148       struct pci_dev *d;
 149       unsigned int dom, bus, dev, func;
 150
 151       /* ".", ".." or a special non-device perhaps */
 152       if (entry->d_name[0] == '.')
 153         continue;
 154
 155       d = pci_alloc_dev(a);
 156       if (sscanf(entry->d_name, "%x:%x:%x.%d", &dom, &bus, &dev, &func) < 4)
 157         a->error("sysfs_scan: Couldn't parse entry name %s", entry->d_name);
 158       d->domain = dom;
 159       d->bus = bus;
 160       d->dev = dev;
 161       d->func = func;
 162       if (!a->buscentric)
 163         {
 164           sysfs_get_resources(d);
 165           d->irq = sysfs_get_value(d, "irq");
 166           /*
 167            *  We could read these faster from the config registers, but we want to give
 168            *  the kernel a chance to fix up ID's and especially classes of broken devices.
 169            */
 170           d->vendor_id = sysfs_get_value(d, "vendor");
 171           d->device_id = sysfs_get_value(d, "device");
 172           d->device_class = sysfs_get_value(d, "class") >> 8;
 173           d->known_fields = PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES;
 174         }
 175       pci_link_dev(a, d);
 176     }
 177   closedir(dir);
 178 }
 179
 180 static void
 181 sysfs_fill_slots(struct pci_access *a)
 182 {
 183   char dirname[1024];
 184   DIR *dir;
 185   struct dirent *entry;
 186   int n;
 187
 188   n = snprintf(dirname, sizeof(dirname), "%s/slots", sysfs_name(a));
 189   if (n < 0 || n >= (int) sizeof(dirname))
 190     a->error("Directory name too long");
 191   dir = opendir(dirname);
 192   if (!dir)
 193     return;
 194
 195   while (entry = readdir(dir))
 196     {
 197       char namebuf[OBJNAMELEN], buf[16];
 198       FILE *file;
 199       unsigned int dom, bus, dev;
 200       struct pci_dev *d;
 201
 202       /* ".", ".." or a special non-device perhaps */
 203       if (entry->d_name[0] == '.')
 204         continue;
 205
 206       n = snprintf(namebuf, OBJNAMELEN, "%s/%s/%s", dirname, entry->d_name, "address");
 207       if (n < 0 || n >= OBJNAMELEN)
 208         a->error("File name too long");
 209       file = fopen(namebuf, "r");
 210       if (!file)
 211         {
 212           a->warning("sysfs_fill_slots: Cannot open %s: %s", namebuf, strerror(errno));
 213           continue;
 214         }
 215
 216       if (!fgets(buf, sizeof(buf), file) || sscanf(buf, "%x:%x:%x", &dom, &bus, &dev) < 3)
 217         a->warning("sysfs_fill_slots: Couldn't parse entry address %s", buf);
 218       else
 219         {
 220           for (d = a->devices; d; d = d->next)
 221             if (dom == d->domain && bus == d->bus && dev == d->dev && !d->phy_slot)
 222               {
 223                 d->phy_slot = pci_malloc(a, strlen(entry->d_name) + 1);
 224                 strcpy(d->phy_slot, entry->d_name);
 225                 break;
 226               }
 227         }
 228       fclose(file);
 229     }
 230   closedir(dir);
 231 }
 232
 233 static int
 234 sysfs_fill_info(struct pci_dev *d, int flags)
 235 {
 236   if ((flags & PCI_FILL_PHYS_SLOT) && !(d->known_fields & PCI_FILL_PHYS_SLOT))
 237     {
 238       struct pci_dev *pd;
 239       sysfs_fill_slots(d->access);
 240       for (pd = d->access->devices; pd; pd = pd->next)
 241         pd->known_fields |= PCI_FILL_PHYS_SLOT;
 242     }
 243   return pci_generic_fill_info(d, flags);
 244 }
 245
 246 /* Intent of the sysfs_setup() caller */
 247 enum
 248   {
 249     SETUP_READ_CONFIG = 0,
 250     SETUP_WRITE_CONFIG = 1,
 251     SETUP_READ_VPD = 2
 252   };
 253
 254 static int
 255 sysfs_setup(struct pci_dev *d, int intent)
 256 {
 257   struct pci_access *a = d->access;
 258   char namebuf[OBJNAMELEN];
 259
 260   if (a->cached_dev != d || intent == SETUP_WRITE_CONFIG && !a->fd_rw)
 261     {
 262       if (a->fd >= 0)
 263         close(a->fd);
 264       sysfs_obj_name(d, "config", namebuf);
 265       a->fd_rw = a->writeable || intent == SETUP_WRITE_CONFIG;
 266       a->fd = open(namebuf, a->fd_rw ? O_RDWR : O_RDONLY);
 267       if (a->fd < 0)
 268         a->warning("Cannot open %s", namebuf);
 269       a->fd_pos = 0;
 270     }
 271
 272   if (a->cached_dev != d)
 273     {
 274       if (a->fd_vpd >= 0)
 275         close(a->fd_vpd);
 276       sysfs_obj_name(d, "vpd", namebuf);
 277       a->fd_vpd = open(namebuf, O_RDONLY);
 278       /* No warning on error; vpd may be absent or accessible only to root */
 279     }
 280
 281   a->cached_dev = d;
 282   return intent == SETUP_READ_VPD ? a->fd_vpd : a->fd;
 283 }
 284
 285 static int sysfs_read(struct pci_dev *d, int pos, byte *buf, int len)
 286 {
 287   int fd = sysfs_setup(d, SETUP_READ_CONFIG);
 288   int res;
 289
 290   if (fd < 0)
 291     return 0;
 292   res = do_read(d, fd, buf, len, pos);
 293   if (res < 0)
 294     {
 295       d->access->warning("sysfs_read: read failed: %s", strerror(errno));
 296       return 0;
 297     }
 298   else if (res != len)
 299     return 0;
 300   return 1;
 301 }
 302
 303 static int sysfs_write(struct pci_dev *d, int pos, byte *buf, int len)
 304 {
 305   int fd = sysfs_setup(d, SETUP_WRITE_CONFIG);
 306   int res;
 307
 308   if (fd < 0)
 309     return 0;
 310   res = do_write(d, fd, buf, len, pos);
 311   if (res < 0)
 312     {
 313       d->access->warning("sysfs_write: write failed: %s", strerror(errno));
 314       return 0;
 315     }
 316   else if (res != len)
 317     {
 318       d->access->warning("sysfs_write: tried to write %d bytes at %d, but only %d succeeded", len, pos, res);
 319       return 0;
 320     }
 321   return 1;
 322 }
 323
 324 #ifdef PCI_HAVE_DO_READ
 325
 326 /* pread() is not available and do_read() only works for a single fd, so we
 327  * cannot implement read_vpd properly. */
 328 static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len)
 329 {
 330   return 0;
 331 }
 332
 333 #else /* !PCI_HAVE_DO_READ */
 334
 335 static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len)
 336 {
 337   int fd = sysfs_setup(d, SETUP_READ_VPD);
 338   int res;
 339
 340   if (fd < 0)
 341     return 0;
 342   res = pread(fd, buf, len, pos);
 343   if (res < 0)
 344     {
 345       d->access->warning("sysfs_read_vpd: read failed: %s", strerror(errno));
 346       return 0;
 347     }
 348   else if (res != len)
 349     return 0;
 350   return 1;
 351 }
 352
 353 #endif /* PCI_HAVE_DO_READ */
 354
 355 static void sysfs_cleanup_dev(struct pci_dev *d)
 356 {
 357   struct pci_access *a = d->access;
 358
 359   if (a->cached_dev == d)
 360     {
 361       a->cached_dev = NULL;
 362       close(a->fd);
 363       a->fd = -1;
 364     }
 365 }
 366
 367 struct pci_methods pm_linux_sysfs = {
 368   "linux-sysfs",
 369   "The sys filesystem on Linux",
 370   sysfs_config,
 371   sysfs_detect,
 372   sysfs_init,
 373   sysfs_cleanup,
 374   sysfs_scan,
 375   sysfs_fill_info,
 376   sysfs_read,
 377   sysfs_write,
 378   sysfs_read_vpd,
 379   NULL,                                 /* init_dev */
 380   sysfs_cleanup_dev
 381 };