1 /* 2 * The PCI Library -- Configuration Access via /sys/bus/pci 3 * 4 * Copyright (c) 2003 Matthew Wilcox <[email protected]> 5 * Copyright (c) 1997--2008 Martin Mares <[email protected]> 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 a->fd_vpd = -1; 54 } 55 56 static void 57 sysfs_flush_cache(struct pci_access *a) 58 { 59 if (a->fd >= 0) 60 { 61 close(a->fd); 62 a->fd = -1; 63 } 64 if (a->fd_vpd >= 0) 65 { 66 close(a->fd_vpd); 67 a->fd_vpd = -1; 68 } 69 a->cached_dev = NULL; 70 } 71 72 static void 73 sysfs_cleanup(struct pci_access *a) 74 { 75 sysfs_flush_cache(a); 76 } 77 78 #define OBJNAMELEN 1024 79 static void 80 sysfs_obj_name(struct pci_dev *d, char *object, char *buf) 81 { 82 int n = snprintf(buf, OBJNAMELEN, "%s/devices/%04x:%02x:%02x.%d/%s", 83 sysfs_name(d->access), d->domain, d->bus, d->dev, d->func, object); 84 if (n < 0 || n >= OBJNAMELEN) 85 d->access->error("File name too long"); 86 } 87 88 #define OBJBUFSIZE 1024 89 90 static int 91 sysfs_get_string(struct pci_dev *d, char *object, char *buf, int mandatory) 92 { 93 struct pci_access *a = d->access; 94 int fd, n; 95 char namebuf[OBJNAMELEN]; 96 void (*warn)(char *msg, ...) = (mandatory ? a->error : a->warning); 97 98 sysfs_obj_name(d, object, namebuf); 99 fd = open(namebuf, O_RDONLY); 100 if (fd < 0) 101 { 102 if (mandatory || errno != ENOENT) 103 warn("Cannot open %s: %s", namebuf, strerror(errno)); 104 return 0; 105 } 106 n = read(fd, buf, OBJBUFSIZE); 107 close(fd); 108 if (n < 0) 109 { 110 warn("Error reading %s: %s", namebuf, strerror(errno)); 111 return 0; 112 } 113 if (n >= OBJBUFSIZE) 114 { 115 warn("Value in %s too long", namebuf); 116 return 0; 117 } 118 buf[n] = 0; 119 return 1; 120 } 121 122 static char * 123 sysfs_deref_link(struct pci_dev *d, char *link_name) 124 { 125 char path[2*OBJNAMELEN], rel_path[OBJNAMELEN]; 126 127 sysfs_obj_name(d, link_name, path); 128 memset(rel_path, 0, sizeof(rel_path)); 129 130 if (readlink(path, rel_path, sizeof(rel_path)) < 0) 131 return NULL; 132 133 sysfs_obj_name(d, "", path); 134 strcat(path, rel_path); 135 136 // Returns a pointer to malloc'ed memory 137 return realpath(path, NULL); 138 } 139 140 static int 141 sysfs_get_value(struct pci_dev *d, char *object, int mandatory) 142 { 143 char buf[OBJBUFSIZE]; 144 145 if (sysfs_get_string(d, object, buf, mandatory)) 146 return strtol(buf, NULL, 0); 147 else 148 return -1; 149 } 150 151 static void 152 sysfs_get_resources(struct pci_dev *d) 153 { 154 struct pci_access *a = d->access; 155 char namebuf[OBJNAMELEN], buf[256]; 156 FILE *file; 157 int i; 158 159 sysfs_obj_name(d, "resource", namebuf); 160 file = fopen(namebuf, "r"); 161 if (!file) 162 a->error("Cannot open %s: %s", namebuf, strerror(errno)); 163 for (i = 0; i < 7; i++) 164 { 165 unsigned long long start, end, size, flags; 166 if (!fgets(buf, sizeof(buf), file)) 167 break; 168 if (sscanf(buf, "%llx %llx %llx", &start, &end, &flags) != 3) 169 a->error("Syntax error in %s", namebuf); 170 if (end > start) 171 size = end - start + 1; 172 else 173 size = 0; 174 if (i < 6) 175 { 176 d->flags[i] = flags; 177 flags &= PCI_ADDR_FLAG_MASK; 178 d->base_addr[i] = start | flags; 179 d->size[i] = size; 180 } 181 else 182 { 183 d->rom_flags = flags; 184 flags &= PCI_ADDR_FLAG_MASK; 185 d->rom_base_addr = start | flags; 186 d->rom_size = size; 187 } 188 } 189 fclose(file); 190 } 191 192 static void sysfs_scan(struct pci_access *a) 193 { 194 char dirname[1024]; 195 DIR *dir; 196 struct dirent *entry; 197 int n; 198 199 n = snprintf(dirname, sizeof(dirname), "%s/devices", sysfs_name(a)); 200 if (n < 0 || n >= (int) sizeof(dirname)) 201 a->error("Directory name too long"); 202 dir = opendir(dirname); 203 if (!dir) 204 a->error("Cannot open %s", dirname); 205 while ((entry = readdir(dir))) 206 { 207 struct pci_dev *d; 208 unsigned int dom, bus, dev, func; 209 210 /* ".", ".." or a special non-device perhaps */ 211 if (entry->d_name[0] == '.') 212 continue; 213 214 d = pci_alloc_dev(a); 215 if (sscanf(entry->d_name, "%x:%x:%x.%d", &dom, &bus, &dev, &func) < 4) 216 a->error("sysfs_scan: Couldn't parse entry name %s", entry->d_name); 217 218 /* Ensure kernel provided domain that fits in a signed integer */ 219 if (dom > 0x7fffffff) 220 a->error("sysfs_scan: Invalid domain %x", dom); 221 222 d->domain = dom; 223 d->bus = bus; 224 d->dev = dev; 225 d->func = func; 226 if (!a->buscentric) 227 { 228 sysfs_get_resources(d); 229 d->irq = sysfs_get_value(d, "irq", 1); 230 /* 231 * We could read these faster from the config registers, but we want to give 232 * the kernel a chance to fix up ID's and especially classes of broken devices. 233 */ 234 d->vendor_id = sysfs_get_value(d, "vendor", 1); 235 d->device_id = sysfs_get_value(d, "device", 1); 236 d->device_class = sysfs_get_value(d, "class", 1) >> 8; 237 d->known_fields = PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES | PCI_FILL_IO_FLAGS; 238 } 239 pci_link_dev(a, d); 240 } 241 closedir(dir); 242 } 243 244 static void 245 sysfs_fill_slots(struct pci_access *a) 246 { 247 char dirname[1024]; 248 DIR *dir; 249 struct dirent *entry; 250 int n; 251 252 n = snprintf(dirname, sizeof(dirname), "%s/slots", sysfs_name(a)); 253 if (n < 0 || n >= (int) sizeof(dirname)) 254 a->error("Directory name too long"); 255 dir = opendir(dirname); 256 if (!dir) 257 return; 258 259 while (entry = readdir(dir)) 260 { 261 char namebuf[OBJNAMELEN], buf[16]; 262 FILE *file; 263 unsigned int dom, bus, dev; 264 int res = 0; 265 struct pci_dev *d; 266 267 /* ".", ".." or a special non-device perhaps */ 268 if (entry->d_name[0] == '.') 269 continue; 270 271 n = snprintf(namebuf, OBJNAMELEN, "%s/%s/%s", dirname, entry->d_name, "address"); 272 if (n < 0 || n >= OBJNAMELEN) 273 a->error("File name too long"); 274 file = fopen(namebuf, "r"); 275 /* 276 * Old versions of Linux had a fakephp which didn't have an 'address' 277 * file. There's no useful information to be gleaned from these 278 * devices, pretend they're not there. 279 */ 280 if (!file) 281 continue; 282 283 if (!fgets(buf, sizeof(buf), file) || (res = sscanf(buf, "%x:%x:%x", &dom, &bus, &dev)) < 3) 284 { 285 /* 286 * In some cases, the slot is not tied to a specific device before 287 * a card gets inserted. This happens for example on IBM pSeries 288 * and we need not warn about it. 289 */ 290 if (res != 2) 291 a->warning("sysfs_fill_slots: Couldn't parse entry address %s", buf); 292 } 293 else 294 { 295 for (d = a->devices; d; d = d->next) 296 if (dom == (unsigned)d->domain && bus == d->bus && dev == d->dev && !d->phy_slot) 297 d->phy_slot = pci_set_property(d, PCI_FILL_PHYS_SLOT, entry->d_name); 298 } 299 fclose(file); 300 } 301 closedir(dir); 302 } 303 304 static int 305 sysfs_fill_info(struct pci_dev *d, int flags) 306 { 307 if ((flags & PCI_FILL_PHYS_SLOT) && !(d->known_fields & PCI_FILL_PHYS_SLOT)) 308 { 309 struct pci_dev *pd; 310 sysfs_fill_slots(d->access); 311 for (pd = d->access->devices; pd; pd = pd->next) 312 pd->known_fields |= PCI_FILL_PHYS_SLOT; 313 } 314 315 if ((flags & PCI_FILL_MODULE_ALIAS) && !(d->known_fields & PCI_FILL_MODULE_ALIAS)) 316 { 317 char buf[OBJBUFSIZE]; 318 if (sysfs_get_string(d, "modalias", buf, 0)) 319 d->module_alias = pci_set_property(d, PCI_FILL_MODULE_ALIAS, buf); 320 } 321 322 if ((flags & PCI_FILL_LABEL) && !(d->known_fields & PCI_FILL_LABEL)) 323 { 324 char buf[OBJBUFSIZE]; 325 if (sysfs_get_string(d, "label", buf, 0)) 326 d->label = pci_set_property(d, PCI_FILL_LABEL, buf); 327 } 328 329 if ((flags & PCI_FILL_NUMA_NODE) && !(d->known_fields & PCI_FILL_NUMA_NODE)) 330 d->numa_node = sysfs_get_value(d, "numa_node", 0); 331 332 if ((flags & PCI_FILL_DT_NODE) && !(d->known_fields & PCI_FILL_DT_NODE)) 333 { 334 char *node = sysfs_deref_link(d, "of_node"); 335 if (node) 336 { 337 pci_set_property(d, PCI_FILL_DT_NODE, node); 338 free(node); 339 } 340 } 341 342 return pci_generic_fill_info(d, flags); 343 } 344 345 /* Intent of the sysfs_setup() caller */ 346 enum 347 { 348 SETUP_READ_CONFIG = 0, 349 SETUP_WRITE_CONFIG = 1, 350 SETUP_READ_VPD = 2 351 }; 352 353 static int 354 sysfs_setup(struct pci_dev *d, int intent) 355 { 356 struct pci_access *a = d->access; 357 char namebuf[OBJNAMELEN]; 358 359 if (a->cached_dev != d || (intent == SETUP_WRITE_CONFIG && !a->fd_rw)) 360 { 361 sysfs_flush_cache(a); 362 a->cached_dev = d; 363 } 364 365 if (intent == SETUP_READ_VPD) 366 { 367 if (a->fd_vpd < 0) 368 { 369 sysfs_obj_name(d, "vpd", namebuf); 370 a->fd_vpd = open(namebuf, O_RDONLY); 371 /* No warning on error; vpd may be absent or accessible only to root */ 372 } 373 return a->fd_vpd; 374 } 375 376 if (a->fd < 0) 377 { 378 sysfs_obj_name(d, "config", namebuf); 379 a->fd_rw = a->writeable || intent == SETUP_WRITE_CONFIG; 380 a->fd = open(namebuf, a->fd_rw ? O_RDWR : O_RDONLY); 381 if (a->fd < 0) 382 a->warning("Cannot open %s", namebuf); 383 a->fd_pos = 0; 384 } 385 return a->fd; 386 } 387 388 static int sysfs_read(struct pci_dev *d, int pos, byte *buf, int len) 389 { 390 int fd = sysfs_setup(d, SETUP_READ_CONFIG); 391 int res; 392 393 if (fd < 0) 394 return 0; 395 res = do_read(d, fd, buf, len, pos); 396 if (res < 0) 397 { 398 d->access->warning("sysfs_read: read failed: %s", strerror(errno)); 399 return 0; 400 } 401 else if (res != len) 402 return 0; 403 return 1; 404 } 405 406 static int sysfs_write(struct pci_dev *d, int pos, byte *buf, int len) 407 { 408 int fd = sysfs_setup(d, SETUP_WRITE_CONFIG); 409 int res; 410 411 if (fd < 0) 412 return 0; 413 res = do_write(d, fd, buf, len, pos); 414 if (res < 0) 415 { 416 d->access->warning("sysfs_write: write failed: %s", strerror(errno)); 417 return 0; 418 } 419 else if (res != len) 420 { 421 d->access->warning("sysfs_write: tried to write %d bytes at %d, but only %d succeeded", len, pos, res); 422 return 0; 423 } 424 return 1; 425 } 426 427 #ifdef PCI_HAVE_DO_READ 428 429 /* pread() is not available and do_read() only works for a single fd, so we 430 * cannot implement read_vpd properly. */ 431 static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len) 432 { 433 return 0; 434 } 435 436 #else /* !PCI_HAVE_DO_READ */ 437 438 static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len) 439 { 440 int fd = sysfs_setup(d, SETUP_READ_VPD); 441 int res; 442 443 if (fd < 0) 444 return 0; 445 res = pread(fd, buf, len, pos); 446 if (res < 0) 447 { 448 d->access->warning("sysfs_read_vpd: read failed: %s", strerror(errno)); 449 return 0; 450 } 451 else if (res != len) 452 return 0; 453 return 1; 454 } 455 456 #endif /* PCI_HAVE_DO_READ */ 457 458 static void sysfs_cleanup_dev(struct pci_dev *d) 459 { 460 struct pci_access *a = d->access; 461 462 if (a->cached_dev == d) 463 sysfs_flush_cache(a); 464 } 465 466 struct pci_methods pm_linux_sysfs = { 467 "linux-sysfs", 468 "The sys filesystem on Linux", 469 sysfs_config, 470 sysfs_detect, 471 sysfs_init, 472 sysfs_cleanup, 473 sysfs_scan, 474 sysfs_fill_info, 475 sysfs_read, 476 sysfs_write, 477 sysfs_read_vpd, 478 NULL, /* init_dev */ 479 sysfs_cleanup_dev 480 }; 481