1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Thunderbolt XDomain property support 4 * 5 * Copyright (C) 2017, Intel Corporation 6 * Authors: Michael Jamet <michael.jamet@intel.com> 7 * Mika Westerberg <mika.westerberg@linux.intel.com> 8 */ 9 10 #include <linux/err.h> 11 #include <linux/slab.h> 12 #include <linux/string.h> 13 #include <linux/uuid.h> 14 #include <linux/thunderbolt.h> 15 16 struct tb_property_entry { 17 u32 key_hi; 18 u32 key_lo; 19 u16 length; 20 u8 reserved; 21 u8 type; 22 u32 value; 23 }; 24 25 struct tb_property_rootdir_entry { 26 u32 magic; 27 u32 length; 28 struct tb_property_entry entries[]; 29 }; 30 31 struct tb_property_dir_entry { 32 u32 uuid[4]; 33 struct tb_property_entry entries[]; 34 }; 35 36 #define TB_PROPERTY_ROOTDIR_MAGIC 0x55584401 37 38 static struct tb_property_dir *__tb_property_parse_dir(const u32 *block, 39 size_t block_len, unsigned int dir_offset, size_t dir_len, 40 bool is_root); 41 parse_dwdata(void * dst,const void * src,size_t dwords)42 static inline void parse_dwdata(void *dst, const void *src, size_t dwords) 43 { 44 be32_to_cpu_array(dst, src, dwords); 45 } 46 format_dwdata(void * dst,const void * src,size_t dwords)47 static inline void format_dwdata(void *dst, const void *src, size_t dwords) 48 { 49 cpu_to_be32_array(dst, src, dwords); 50 } 51 tb_property_entry_valid(const struct tb_property_entry * entry,size_t block_len)52 static bool tb_property_entry_valid(const struct tb_property_entry *entry, 53 size_t block_len) 54 { 55 switch (entry->type) { 56 case TB_PROPERTY_TYPE_DIRECTORY: 57 case TB_PROPERTY_TYPE_DATA: 58 case TB_PROPERTY_TYPE_TEXT: 59 if (entry->length > block_len) 60 return false; 61 if (entry->value + entry->length > block_len) 62 return false; 63 break; 64 65 case TB_PROPERTY_TYPE_VALUE: 66 if (entry->length != 1) 67 return false; 68 break; 69 } 70 71 return true; 72 } 73 tb_property_key_valid(const char * key)74 static bool tb_property_key_valid(const char *key) 75 { 76 return key && strlen(key) <= TB_PROPERTY_KEY_SIZE; 77 } 78 79 static struct tb_property * tb_property_alloc(const char * key,enum tb_property_type type)80 tb_property_alloc(const char *key, enum tb_property_type type) 81 { 82 struct tb_property *property; 83 84 property = kzalloc(sizeof(*property), GFP_KERNEL); 85 if (!property) 86 return NULL; 87 88 strcpy(property->key, key); 89 property->type = type; 90 INIT_LIST_HEAD(&property->list); 91 92 return property; 93 } 94 tb_property_parse(const u32 * block,size_t block_len,const struct tb_property_entry * entry)95 static struct tb_property *tb_property_parse(const u32 *block, size_t block_len, 96 const struct tb_property_entry *entry) 97 { 98 char key[TB_PROPERTY_KEY_SIZE + 1]; 99 struct tb_property *property; 100 struct tb_property_dir *dir; 101 102 if (!tb_property_entry_valid(entry, block_len)) 103 return NULL; 104 105 parse_dwdata(key, entry, 2); 106 key[TB_PROPERTY_KEY_SIZE] = '\0'; 107 108 property = tb_property_alloc(key, entry->type); 109 if (!property) 110 return NULL; 111 112 property->length = entry->length; 113 114 switch (property->type) { 115 case TB_PROPERTY_TYPE_DIRECTORY: 116 dir = __tb_property_parse_dir(block, block_len, entry->value, 117 entry->length, false); 118 if (!dir) { 119 kfree(property); 120 return NULL; 121 } 122 property->value.dir = dir; 123 break; 124 125 case TB_PROPERTY_TYPE_DATA: 126 property->value.data = kcalloc(property->length, sizeof(u32), 127 GFP_KERNEL); 128 if (!property->value.data) { 129 kfree(property); 130 return NULL; 131 } 132 parse_dwdata(property->value.data, block + entry->value, 133 entry->length); 134 break; 135 136 case TB_PROPERTY_TYPE_TEXT: 137 property->value.text = kcalloc(property->length, sizeof(u32), 138 GFP_KERNEL); 139 if (!property->value.text) { 140 kfree(property); 141 return NULL; 142 } 143 parse_dwdata(property->value.text, block + entry->value, 144 entry->length); 145 /* Force null termination */ 146 property->value.text[property->length * 4 - 1] = '\0'; 147 break; 148 149 case TB_PROPERTY_TYPE_VALUE: 150 property->value.immediate = entry->value; 151 break; 152 153 default: 154 property->type = TB_PROPERTY_TYPE_UNKNOWN; 155 break; 156 } 157 158 return property; 159 } 160 __tb_property_parse_dir(const u32 * block,size_t block_len,unsigned int dir_offset,size_t dir_len,bool is_root)161 static struct tb_property_dir *__tb_property_parse_dir(const u32 *block, 162 size_t block_len, unsigned int dir_offset, size_t dir_len, bool is_root) 163 { 164 const struct tb_property_entry *entries; 165 size_t i, content_len, nentries; 166 unsigned int content_offset; 167 struct tb_property_dir *dir; 168 169 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 170 if (!dir) 171 return NULL; 172 173 if (is_root) { 174 content_offset = dir_offset + 2; 175 content_len = dir_len; 176 } else { 177 dir->uuid = kmemdup(&block[dir_offset], sizeof(*dir->uuid), 178 GFP_KERNEL); 179 if (!dir->uuid) { 180 tb_property_free_dir(dir); 181 return NULL; 182 } 183 content_offset = dir_offset + 4; 184 content_len = dir_len - 4; /* Length includes UUID */ 185 } 186 187 entries = (const struct tb_property_entry *)&block[content_offset]; 188 nentries = content_len / (sizeof(*entries) / 4); 189 190 INIT_LIST_HEAD(&dir->properties); 191 192 for (i = 0; i < nentries; i++) { 193 struct tb_property *property; 194 195 property = tb_property_parse(block, block_len, &entries[i]); 196 if (!property) { 197 tb_property_free_dir(dir); 198 return NULL; 199 } 200 201 list_add_tail(&property->list, &dir->properties); 202 } 203 204 return dir; 205 } 206 207 /** 208 * tb_property_parse_dir() - Parses properties from given property block 209 * @block: Property block to parse 210 * @block_len: Number of dword elements in the property block 211 * 212 * This function parses the XDomain properties data block into format that 213 * can be traversed using the helper functions provided by this module. 214 * Upon success returns the parsed directory. In case of error returns 215 * %NULL. The resulting &struct tb_property_dir needs to be released by 216 * calling tb_property_free_dir() when not needed anymore. 217 * 218 * The @block is expected to be root directory. 219 */ tb_property_parse_dir(const u32 * block,size_t block_len)220 struct tb_property_dir *tb_property_parse_dir(const u32 *block, 221 size_t block_len) 222 { 223 const struct tb_property_rootdir_entry *rootdir = 224 (const struct tb_property_rootdir_entry *)block; 225 226 if (rootdir->magic != TB_PROPERTY_ROOTDIR_MAGIC) 227 return NULL; 228 if (rootdir->length > block_len) 229 return NULL; 230 231 return __tb_property_parse_dir(block, block_len, 0, rootdir->length, 232 true); 233 } 234 235 /** 236 * tb_property_create_dir() - Creates new property directory 237 * @uuid: UUID used to identify the particular directory 238 * 239 * Creates new, empty property directory. If @uuid is %NULL then the 240 * directory is assumed to be root directory. 241 */ tb_property_create_dir(const uuid_t * uuid)242 struct tb_property_dir *tb_property_create_dir(const uuid_t *uuid) 243 { 244 struct tb_property_dir *dir; 245 246 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 247 if (!dir) 248 return NULL; 249 250 INIT_LIST_HEAD(&dir->properties); 251 if (uuid) { 252 dir->uuid = kmemdup(uuid, sizeof(*dir->uuid), GFP_KERNEL); 253 if (!dir->uuid) { 254 kfree(dir); 255 return NULL; 256 } 257 } 258 259 return dir; 260 } 261 EXPORT_SYMBOL_GPL(tb_property_create_dir); 262 tb_property_free(struct tb_property * property)263 static void tb_property_free(struct tb_property *property) 264 { 265 switch (property->type) { 266 case TB_PROPERTY_TYPE_DIRECTORY: 267 tb_property_free_dir(property->value.dir); 268 break; 269 270 case TB_PROPERTY_TYPE_DATA: 271 kfree(property->value.data); 272 break; 273 274 case TB_PROPERTY_TYPE_TEXT: 275 kfree(property->value.text); 276 break; 277 278 default: 279 break; 280 } 281 282 kfree(property); 283 } 284 285 /** 286 * tb_property_free_dir() - Release memory allocated for property directory 287 * @dir: Directory to release 288 * 289 * This will release all the memory the directory occupies including all 290 * descendants. It is OK to pass %NULL @dir, then the function does 291 * nothing. 292 */ tb_property_free_dir(struct tb_property_dir * dir)293 void tb_property_free_dir(struct tb_property_dir *dir) 294 { 295 struct tb_property *property, *tmp; 296 297 if (!dir) 298 return; 299 300 list_for_each_entry_safe(property, tmp, &dir->properties, list) { 301 list_del(&property->list); 302 tb_property_free(property); 303 } 304 kfree(dir->uuid); 305 kfree(dir); 306 } 307 EXPORT_SYMBOL_GPL(tb_property_free_dir); 308 tb_property_dir_length(const struct tb_property_dir * dir,bool recurse,size_t * data_len)309 static size_t tb_property_dir_length(const struct tb_property_dir *dir, 310 bool recurse, size_t *data_len) 311 { 312 const struct tb_property *property; 313 size_t len = 0; 314 315 if (dir->uuid) 316 len += sizeof(*dir->uuid) / 4; 317 else 318 len += sizeof(struct tb_property_rootdir_entry) / 4; 319 320 list_for_each_entry(property, &dir->properties, list) { 321 len += sizeof(struct tb_property_entry) / 4; 322 323 switch (property->type) { 324 case TB_PROPERTY_TYPE_DIRECTORY: 325 if (recurse) { 326 len += tb_property_dir_length( 327 property->value.dir, recurse, data_len); 328 } 329 /* Reserve dword padding after each directory */ 330 if (data_len) 331 *data_len += 1; 332 break; 333 334 case TB_PROPERTY_TYPE_DATA: 335 case TB_PROPERTY_TYPE_TEXT: 336 if (data_len) 337 *data_len += property->length; 338 break; 339 340 default: 341 break; 342 } 343 } 344 345 return len; 346 } 347 __tb_property_format_dir(const struct tb_property_dir * dir,u32 * block,unsigned int start_offset,size_t block_len)348 static ssize_t __tb_property_format_dir(const struct tb_property_dir *dir, 349 u32 *block, unsigned int start_offset, size_t block_len) 350 { 351 unsigned int data_offset, dir_end; 352 const struct tb_property *property; 353 struct tb_property_entry *entry; 354 size_t dir_len, data_len = 0; 355 int ret; 356 357 /* 358 * The structure of property block looks like following. Leaf 359 * data/text is included right after the directory and each 360 * directory follows each other (even nested ones). 361 * 362 * +----------+ <-- start_offset 363 * | header | <-- root directory header 364 * +----------+ --- 365 * | entry 0 | -^--------------------. 366 * +----------+ | | 367 * | entry 1 | -|--------------------|--. 368 * +----------+ | | | 369 * | entry 2 | -|-----------------. | | 370 * +----------+ | | | | 371 * : : | dir_len | | | 372 * . . | | | | 373 * : : | | | | 374 * +----------+ | | | | 375 * | entry n | v | | | 376 * +----------+ <-- data_offset | | | 377 * | data 0 | <------------------|--' | 378 * +----------+ | | 379 * | data 1 | <------------------|-----' 380 * +----------+ | 381 * | 00000000 | padding | 382 * +----------+ <-- dir_end <------' 383 * | UUID | <-- directory UUID (child directory) 384 * +----------+ 385 * | entry 0 | 386 * +----------+ 387 * | entry 1 | 388 * +----------+ 389 * : : 390 * . . 391 * : : 392 * +----------+ 393 * | entry n | 394 * +----------+ 395 * | data 0 | 396 * +----------+ 397 * 398 * We use dir_end to hold pointer to the end of the directory. It 399 * will increase as we add directories and each directory should be 400 * added starting from previous dir_end. 401 */ 402 dir_len = tb_property_dir_length(dir, false, &data_len); 403 data_offset = start_offset + dir_len; 404 dir_end = start_offset + data_len + dir_len; 405 406 if (data_offset > dir_end) 407 return -EINVAL; 408 if (dir_end > block_len) 409 return -EINVAL; 410 411 /* Write headers first */ 412 if (dir->uuid) { 413 struct tb_property_dir_entry *pe; 414 415 pe = (struct tb_property_dir_entry *)&block[start_offset]; 416 memcpy(pe->uuid, dir->uuid, sizeof(pe->uuid)); 417 entry = pe->entries; 418 } else { 419 struct tb_property_rootdir_entry *re; 420 421 re = (struct tb_property_rootdir_entry *)&block[start_offset]; 422 re->magic = TB_PROPERTY_ROOTDIR_MAGIC; 423 re->length = dir_len - sizeof(*re) / 4; 424 entry = re->entries; 425 } 426 427 list_for_each_entry(property, &dir->properties, list) { 428 const struct tb_property_dir *child; 429 430 format_dwdata(entry, property->key, 2); 431 entry->type = property->type; 432 433 switch (property->type) { 434 case TB_PROPERTY_TYPE_DIRECTORY: 435 child = property->value.dir; 436 ret = __tb_property_format_dir(child, block, dir_end, 437 block_len); 438 if (ret < 0) 439 return ret; 440 entry->length = tb_property_dir_length(child, false, 441 NULL); 442 entry->value = dir_end; 443 dir_end = ret; 444 break; 445 446 case TB_PROPERTY_TYPE_DATA: 447 format_dwdata(&block[data_offset], property->value.data, 448 property->length); 449 entry->length = property->length; 450 entry->value = data_offset; 451 data_offset += entry->length; 452 break; 453 454 case TB_PROPERTY_TYPE_TEXT: 455 format_dwdata(&block[data_offset], property->value.text, 456 property->length); 457 entry->length = property->length; 458 entry->value = data_offset; 459 data_offset += entry->length; 460 break; 461 462 case TB_PROPERTY_TYPE_VALUE: 463 entry->length = property->length; 464 entry->value = property->value.immediate; 465 break; 466 467 default: 468 break; 469 } 470 471 entry++; 472 } 473 474 return dir_end; 475 } 476 477 /** 478 * tb_property_format_dir() - Formats directory to the packed XDomain format 479 * @dir: Directory to format 480 * @block: Property block where the packed data is placed 481 * @block_len: Length of the property block 482 * 483 * This function formats the directory to the packed format that can be 484 * then send over the thunderbolt fabric to receiving host. Returns %0 in 485 * case of success and negative errno on faulure. Passing %NULL in @block 486 * returns number of entries the block takes. 487 */ tb_property_format_dir(const struct tb_property_dir * dir,u32 * block,size_t block_len)488 ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block, 489 size_t block_len) 490 { 491 ssize_t ret; 492 493 if (!block) { 494 size_t dir_len, data_len = 0; 495 496 dir_len = tb_property_dir_length(dir, true, &data_len); 497 return dir_len + data_len; 498 } 499 500 ret = __tb_property_format_dir(dir, block, 0, block_len); 501 return ret < 0 ? ret : 0; 502 } 503 504 /** 505 * tb_property_copy_dir() - Take a deep copy of directory 506 * @dir: Directory to copy 507 * 508 * This function takes a deep copy of @dir and returns back the copy. In 509 * case of error returns %NULL. The resulting directory needs to be 510 * released by calling tb_property_free_dir(). 511 */ tb_property_copy_dir(const struct tb_property_dir * dir)512 struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir) 513 { 514 struct tb_property *property, *p = NULL; 515 struct tb_property_dir *d; 516 517 if (!dir) 518 return NULL; 519 520 d = tb_property_create_dir(dir->uuid); 521 if (!d) 522 return NULL; 523 524 list_for_each_entry(property, &dir->properties, list) { 525 struct tb_property *p; 526 527 p = tb_property_alloc(property->key, property->type); 528 if (!p) 529 goto err_free; 530 531 p->length = property->length; 532 533 switch (property->type) { 534 case TB_PROPERTY_TYPE_DIRECTORY: 535 p->value.dir = tb_property_copy_dir(property->value.dir); 536 if (!p->value.dir) 537 goto err_free; 538 break; 539 540 case TB_PROPERTY_TYPE_DATA: 541 p->value.data = kmemdup(property->value.data, 542 property->length * 4, 543 GFP_KERNEL); 544 if (!p->value.data) 545 goto err_free; 546 break; 547 548 case TB_PROPERTY_TYPE_TEXT: 549 p->value.text = kzalloc(p->length * 4, GFP_KERNEL); 550 if (!p->value.text) 551 goto err_free; 552 strcpy(p->value.text, property->value.text); 553 break; 554 555 case TB_PROPERTY_TYPE_VALUE: 556 p->value.immediate = property->value.immediate; 557 break; 558 559 default: 560 break; 561 } 562 563 list_add_tail(&p->list, &d->properties); 564 } 565 566 return d; 567 568 err_free: 569 kfree(p); 570 tb_property_free_dir(d); 571 572 return NULL; 573 } 574 575 /** 576 * tb_property_add_immediate() - Add immediate property to directory 577 * @parent: Directory to add the property 578 * @key: Key for the property 579 * @value: Immediate value to store with the property 580 */ tb_property_add_immediate(struct tb_property_dir * parent,const char * key,u32 value)581 int tb_property_add_immediate(struct tb_property_dir *parent, const char *key, 582 u32 value) 583 { 584 struct tb_property *property; 585 586 if (!tb_property_key_valid(key)) 587 return -EINVAL; 588 589 property = tb_property_alloc(key, TB_PROPERTY_TYPE_VALUE); 590 if (!property) 591 return -ENOMEM; 592 593 property->length = 1; 594 property->value.immediate = value; 595 596 list_add_tail(&property->list, &parent->properties); 597 return 0; 598 } 599 EXPORT_SYMBOL_GPL(tb_property_add_immediate); 600 601 /** 602 * tb_property_add_data() - Adds arbitrary data property to directory 603 * @parent: Directory to add the property 604 * @key: Key for the property 605 * @buf: Data buffer to add 606 * @buflen: Number of bytes in the data buffer 607 * 608 * Function takes a copy of @buf and adds it to the directory. 609 */ tb_property_add_data(struct tb_property_dir * parent,const char * key,const void * buf,size_t buflen)610 int tb_property_add_data(struct tb_property_dir *parent, const char *key, 611 const void *buf, size_t buflen) 612 { 613 /* Need to pad to dword boundary */ 614 size_t size = round_up(buflen, 4); 615 struct tb_property *property; 616 617 if (!tb_property_key_valid(key)) 618 return -EINVAL; 619 620 property = tb_property_alloc(key, TB_PROPERTY_TYPE_DATA); 621 if (!property) 622 return -ENOMEM; 623 624 property->length = size / 4; 625 property->value.data = kzalloc(size, GFP_KERNEL); 626 if (!property->value.data) { 627 kfree(property); 628 return -ENOMEM; 629 } 630 631 memcpy(property->value.data, buf, buflen); 632 633 list_add_tail(&property->list, &parent->properties); 634 return 0; 635 } 636 EXPORT_SYMBOL_GPL(tb_property_add_data); 637 638 /** 639 * tb_property_add_text() - Adds string property to directory 640 * @parent: Directory to add the property 641 * @key: Key for the property 642 * @text: String to add 643 * 644 * Function takes a copy of @text and adds it to the directory. 645 */ tb_property_add_text(struct tb_property_dir * parent,const char * key,const char * text)646 int tb_property_add_text(struct tb_property_dir *parent, const char *key, 647 const char *text) 648 { 649 /* Need to pad to dword boundary */ 650 size_t size = round_up(strlen(text) + 1, 4); 651 struct tb_property *property; 652 653 if (!tb_property_key_valid(key)) 654 return -EINVAL; 655 656 property = tb_property_alloc(key, TB_PROPERTY_TYPE_TEXT); 657 if (!property) 658 return -ENOMEM; 659 660 property->length = size / 4; 661 property->value.text = kzalloc(size, GFP_KERNEL); 662 if (!property->value.text) { 663 kfree(property); 664 return -ENOMEM; 665 } 666 667 strcpy(property->value.text, text); 668 669 list_add_tail(&property->list, &parent->properties); 670 return 0; 671 } 672 EXPORT_SYMBOL_GPL(tb_property_add_text); 673 674 /** 675 * tb_property_add_dir() - Adds a directory to the parent directory 676 * @parent: Directory to add the property 677 * @key: Key for the property 678 * @dir: Directory to add 679 */ tb_property_add_dir(struct tb_property_dir * parent,const char * key,struct tb_property_dir * dir)680 int tb_property_add_dir(struct tb_property_dir *parent, const char *key, 681 struct tb_property_dir *dir) 682 { 683 struct tb_property *property; 684 685 if (!tb_property_key_valid(key)) 686 return -EINVAL; 687 688 property = tb_property_alloc(key, TB_PROPERTY_TYPE_DIRECTORY); 689 if (!property) 690 return -ENOMEM; 691 692 property->value.dir = dir; 693 694 list_add_tail(&property->list, &parent->properties); 695 return 0; 696 } 697 EXPORT_SYMBOL_GPL(tb_property_add_dir); 698 699 /** 700 * tb_property_remove() - Removes property from a parent directory 701 * @property: Property to remove 702 * 703 * Note memory for @property is released as well so it is not allowed to 704 * touch the object after call to this function. 705 */ tb_property_remove(struct tb_property * property)706 void tb_property_remove(struct tb_property *property) 707 { 708 list_del(&property->list); 709 kfree(property); 710 } 711 EXPORT_SYMBOL_GPL(tb_property_remove); 712 713 /** 714 * tb_property_find() - Find a property from a directory 715 * @dir: Directory where the property is searched 716 * @key: Key to look for 717 * @type: Type of the property 718 * 719 * Finds and returns property from the given directory. Does not recurse 720 * into sub-directories. Returns %NULL if the property was not found. 721 */ tb_property_find(struct tb_property_dir * dir,const char * key,enum tb_property_type type)722 struct tb_property *tb_property_find(struct tb_property_dir *dir, 723 const char *key, enum tb_property_type type) 724 { 725 struct tb_property *property; 726 727 list_for_each_entry(property, &dir->properties, list) { 728 if (property->type == type && !strcmp(property->key, key)) 729 return property; 730 } 731 732 return NULL; 733 } 734 EXPORT_SYMBOL_GPL(tb_property_find); 735 736 /** 737 * tb_property_get_next() - Get next property from directory 738 * @dir: Directory holding properties 739 * @prev: Previous property in the directory (%NULL returns the first) 740 */ tb_property_get_next(struct tb_property_dir * dir,struct tb_property * prev)741 struct tb_property *tb_property_get_next(struct tb_property_dir *dir, 742 struct tb_property *prev) 743 { 744 if (prev) { 745 if (list_is_last(&prev->list, &dir->properties)) 746 return NULL; 747 return list_next_entry(prev, list); 748 } 749 return list_first_entry_or_null(&dir->properties, struct tb_property, 750 list); 751 } 752 EXPORT_SYMBOL_GPL(tb_property_get_next); 753