drivers/staging/greybus/manifest.c

   1 /*
   2  * Greybus manifest parsing
   3  *
   4  * Copyright 2014-2015 Google Inc.
   5  * Copyright 2014-2015 Linaro Ltd.
   6  *
   7  * Released under the GPLv2 only.
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include "greybus.h"
  13
  14 static const char *get_descriptor_type_string(u8 type)
  15 {
  16         switch(type) {
  17         case GREYBUS_TYPE_INVALID:
  18                 return "invalid";
  19         case GREYBUS_TYPE_STRING:
  20                 return "string";
  21         case GREYBUS_TYPE_INTERFACE:
  22                 return "interface";
  23         case GREYBUS_TYPE_CPORT:
  24                 return "cport";
  25         case GREYBUS_TYPE_BUNDLE:
  26                 return "bundle";
  27         default:
  28                 WARN_ON(1);
  29                 return "unknown";
  30         }
  31 }
  32
  33 /*
  34  * We scan the manifest once to identify where all the descriptors
  35  * are.  The result is a list of these manifest_desc structures.  We
  36  * then pick through them for what we're looking for (starting with
  37  * the interface descriptor).  As each is processed we remove it from
  38  * the list.  When we're done the list should (probably) be empty.
  39  */
  40 struct manifest_desc {
  41         struct list_head                links;
  42
  43         size_t                          size;
  44         void                            *data;
  45         enum greybus_descriptor_type    type;
  46 };
  47
  48 static void release_manifest_descriptor(struct manifest_desc *descriptor)
  49 {
  50         list_del(&descriptor->links);
  51         kfree(descriptor);
  52 }
  53
  54 static void release_manifest_descriptors(struct gb_interface *intf)
  55 {
  56         struct manifest_desc *descriptor;
  57         struct manifest_desc *next;
  58
  59         list_for_each_entry_safe(descriptor, next, &intf->manifest_descs, links)
  60                 release_manifest_descriptor(descriptor);
  61 }
  62
  63 static void release_cport_descriptors(struct list_head *head, u8 bundle_id)
  64 {
  65         struct manifest_desc *desc, *tmp;
  66         struct greybus_descriptor_cport *desc_cport;
  67
  68         list_for_each_entry_safe(desc, tmp, head, links) {
  69                 desc_cport = desc->data;
  70
  71                 if (desc->type != GREYBUS_TYPE_CPORT)
  72                         continue;
  73
  74                 if (desc_cport->bundle == bundle_id)
  75                         release_manifest_descriptor(desc);
  76         }
  77 }
  78
  79 static struct manifest_desc *get_next_bundle_desc(struct gb_interface *intf)
  80 {
  81         struct manifest_desc *descriptor;
  82         struct manifest_desc *next;
  83
  84         list_for_each_entry_safe(descriptor, next, &intf->manifest_descs, links)
  85                 if (descriptor->type == GREYBUS_TYPE_BUNDLE)
  86                         return descriptor;
  87
  88         return NULL;
  89 }
  90
  91 /*
  92  * Validate the given descriptor.  Its reported size must fit within
  93  * the number of bytes remaining, and it must have a recognized
  94  * type.  Check that the reported size is at least as big as what
  95  * we expect to see.  (It could be bigger, perhaps for a new version
  96  * of the format.)
  97  *
  98  * Returns the (non-zero) number of bytes consumed by the descriptor,
  99  * or a negative errno.
 100  */
 101 static int identify_descriptor(struct gb_interface *intf,
 102                                struct greybus_descriptor *desc, size_t size)
 103 {
 104         struct greybus_descriptor_header *desc_header = &desc->header;
 105         struct manifest_desc *descriptor;
 106         size_t desc_size;
 107         size_t expected_size;
 108
 109         if (size < sizeof(*desc_header)) {
 110                 pr_err("manifest too small (%zu < %zu)\n",
 111                                 size, sizeof(*desc_header));
 112                 return -EINVAL;         /* Must at least have header */
 113         }
 114
 115         desc_size = le16_to_cpu(desc_header->size);
 116         if (desc_size > size) {
 117                 pr_err("descriptor too big (%zu > %zu)\n", desc_size, size);
 118                 return -EINVAL;
 119         }
 120
 121         /* Descriptor needs to at least have a header */
 122         expected_size = sizeof(*desc_header);
 123
 124         switch (desc_header->type) {
 125         case GREYBUS_TYPE_STRING:
 126                 expected_size += sizeof(struct greybus_descriptor_string);
 127                 expected_size += desc->string.length;
 128
 129                 /* String descriptors are padded to 4 byte boundaries */
 130                 expected_size = ALIGN(expected_size, 4);
 131                 break;
 132         case GREYBUS_TYPE_INTERFACE:
 133                 expected_size += sizeof(struct greybus_descriptor_interface);
 134                 break;
 135         case GREYBUS_TYPE_BUNDLE:
 136                 expected_size += sizeof(struct greybus_descriptor_bundle);
 137                 break;
 138         case GREYBUS_TYPE_CPORT:
 139                 expected_size += sizeof(struct greybus_descriptor_cport);
 140                 break;
 141         case GREYBUS_TYPE_INVALID:
 142         default:
 143                 pr_err("invalid descriptor type (%hhu)\n", desc_header->type);
 144                 return -EINVAL;
 145         }
 146
 147         if (desc_size < expected_size) {
 148                 pr_err("%s descriptor too small (%zu < %zu)\n",
 149                        get_descriptor_type_string(desc_header->type),
 150                        desc_size, expected_size);
 151                 return -EINVAL;
 152         }
 153
 154         /* Descriptor bigger than what we expect */
 155         if (desc_size > expected_size) {
 156                 pr_warn("%s descriptor size mismatch (want %zu got %zu)\n",
 157                         get_descriptor_type_string(desc_header->type),
 158                         expected_size, desc_size);
 159         }
 160
 161         descriptor = kzalloc(sizeof(*descriptor), GFP_KERNEL);
 162         if (!descriptor)
 163                 return -ENOMEM;
 164
 165         descriptor->size = desc_size;
 166         descriptor->data = (char *)desc + sizeof(*desc_header);
 167         descriptor->type = desc_header->type;
 168         list_add_tail(&descriptor->links, &intf->manifest_descs);
 169
 170         /* desc_size is positive and is known to fit in a signed int */
 171
 172         return desc_size;
 173 }
 174
 175 /*
 176  * Find the string descriptor having the given id, validate it, and
 177  * allocate a duplicate copy of it.  The duplicate has an extra byte
 178  * which guarantees the returned string is NUL-terminated.
 179  *
 180  * String index 0 is valid (it represents "no string"), and for
 181  * that a null pointer is returned.
 182  *
 183  * Otherwise returns a pointer to a newly-allocated copy of the
 184  * descriptor string, or an error-coded pointer on failure.
 185  */
 186 static char *gb_string_get(struct gb_interface *intf, u8 string_id)
 187 {
 188         struct greybus_descriptor_string *desc_string;
 189         struct manifest_desc *descriptor;
 190         bool found = false;
 191         char *string;
 192
 193         /* A zero string id means no string (but no error) */
 194         if (!string_id)
 195                 return NULL;
 196
 197         list_for_each_entry(descriptor, &intf->manifest_descs, links) {
 198                 if (descriptor->type != GREYBUS_TYPE_STRING)
 199                         continue;
 200
 201                 desc_string = descriptor->data;
 202                 if (desc_string->id == string_id) {
 203                         found = true;
 204                         break;
 205                 }
 206         }
 207         if (!found)
 208                 return ERR_PTR(-ENOENT);
 209
 210         /* Allocate an extra byte so we can guarantee it's NUL-terminated */
 211         string = kmemdup(&desc_string->string, desc_string->length + 1,
 212                                 GFP_KERNEL);
 213         if (!string)
 214                 return ERR_PTR(-ENOMEM);
 215         string[desc_string->length] = '\0';
 216
 217         /* Ok we've used this string, so we're done with it */
 218         release_manifest_descriptor(descriptor);
 219
 220         return string;
 221 }
 222
 223 /*
 224  * Find cport descriptors in the manifest associated with the given
 225  * bundle, and set up data structures for the functions that use
 226  * them.  Returns the number of cports set up for the bundle, or 0
 227  * if there is an error.
 228  */
 229 static u32 gb_manifest_parse_cports(struct gb_bundle *bundle)
 230 {
 231         struct gb_interface *intf = bundle->intf;
 232         struct manifest_desc *desc;
 233         struct manifest_desc *next;
 234         u8 bundle_id = bundle->id;
 235         u8 protocol_id;
 236         u16 cport_id;
 237         u32 count = 0;
 238
 239         /* Set up all cport descriptors associated with this bundle */
 240         list_for_each_entry_safe(desc, next, &intf->manifest_descs, links) {
 241                 struct greybus_descriptor_cport *desc_cport;
 242
 243                 if (desc->type != GREYBUS_TYPE_CPORT)
 244                         continue;
 245
 246                 desc_cport = desc->data;
 247                 if (desc_cport->bundle != bundle_id)
 248                         continue;
 249
 250                 cport_id = le16_to_cpu(desc_cport->id);
 251                 if (cport_id > CPORT_ID_MAX)
 252                         goto exit;
 253
 254                 /* Found one.  Set up its function structure */
 255                 protocol_id = desc_cport->protocol_id;
 256
 257                 if (!gb_connection_create_dynamic(intf, bundle, cport_id,
 258                                                                 protocol_id))
 259                         goto exit;
 260
 261                 count++;
 262
 263                 /* Release the cport descriptor */
 264                 release_manifest_descriptor(desc);
 265         }
 266
 267         return count;
 268 exit:
 269
 270         /*
 271          * Free all cports for this bundle to avoid 'excess descriptors'
 272          * warnings.
 273          */
 274         release_cport_descriptors(&intf->manifest_descs, bundle_id);
 275
 276         return 0;       /* Error; count should also be 0 */
 277 }
 278
 279 /*
 280  * Find bundle descriptors in the manifest and set up their data
 281  * structures.  Returns the number of bundles set up for the
 282  * given interface.
 283  */
 284 static u32 gb_manifest_parse_bundles(struct gb_interface *intf)
 285 {
 286         struct manifest_desc *desc;
 287         struct gb_bundle *bundle;
 288         struct gb_bundle *bundle_next;
 289         u32 count = 0;
 290         u8 bundle_id;
 291         u8 class;
 292
 293         while ((desc = get_next_bundle_desc(intf))) {
 294                 struct greybus_descriptor_bundle *desc_bundle;
 295
 296                 /* Found one.  Set up its bundle structure*/
 297                 desc_bundle = desc->data;
 298                 bundle_id = desc_bundle->id;
 299                 class = desc_bundle->class;
 300
 301                 /* Done with this bundle descriptor */
 302                 release_manifest_descriptor(desc);
 303
 304                 /* Ignore any legacy control bundles */
 305                 if (bundle_id == GB_CONTROL_BUNDLE_ID) {
 306                         dev_dbg(&intf->dev, "%s - ignoring control bundle\n",
 307                                         __func__);
 308                         release_cport_descriptors(&intf->manifest_descs,
 309                                                                 bundle_id);
 310                         continue;
 311                 }
 312
 313                 /* Nothing else should have its class set to control class */
 314                 if (class == GREYBUS_CLASS_CONTROL) {
 315                         dev_err(&intf->dev,
 316                                 "bundle 0x%02x cannot use control class\n",
 317                                 bundle_id);
 318                         goto cleanup;
 319                 }
 320
 321                 bundle = gb_bundle_create(intf, bundle_id, class);
 322                 if (!bundle)
 323                         goto cleanup;
 324
 325                 /*
 326                  * Now go set up this bundle's functions and cports.
 327                  *
 328                  * A 'bundle' represents a device in greybus. It may require
 329                  * multiple cports for its functioning. If we fail to setup any
 330                  * cport of a bundle, we better reject the complete bundle as
 331                  * the device may not be able to function properly then.
 332                  *
 333                  * But, failing to setup a cport of bundle X doesn't mean that
 334                  * the device corresponding to bundle Y will not work properly.
 335                  * Bundles should be treated as separate independent devices.
 336                  *
 337                  * While parsing manifest for an interface, treat bundles as
 338                  * separate entities and don't reject entire interface and its
 339                  * bundles on failing to initialize a cport. But make sure the
 340                  * bundle which needs the cport, gets destroyed properly.
 341                  */
 342                 if (!gb_manifest_parse_cports(bundle)) {
 343                         gb_bundle_destroy(bundle);
 344                         continue;
 345                 }
 346
 347                 count++;
 348         }
 349
 350         return count;
 351 cleanup:
 352         /* An error occurred; undo any changes we've made */
 353         list_for_each_entry_safe(bundle, bundle_next, &intf->bundles, links) {
 354                 gb_bundle_destroy(bundle);
 355                 count--;
 356         }
 357         return 0;       /* Error; count should also be 0 */
 358 }
 359
 360 static bool gb_manifest_parse_interface(struct gb_interface *intf,
 361                                         struct manifest_desc *interface_desc)
 362 {
 363         struct greybus_descriptor_interface *desc_intf = interface_desc->data;
 364
 365         /* Handle the strings first--they can fail */
 366         intf->vendor_string = gb_string_get(intf, desc_intf->vendor_stringid);
 367         if (IS_ERR(intf->vendor_string))
 368                 return false;
 369
 370         intf->product_string = gb_string_get(intf, desc_intf->product_stringid);
 371         if (IS_ERR(intf->product_string))
 372                 goto out_free_vendor_string;
 373
 374         /* Release the interface descriptor, now that we're done with it */
 375         release_manifest_descriptor(interface_desc);
 376
 377         /* An interface must have at least one bundle descriptor */
 378         if (!gb_manifest_parse_bundles(intf)) {
 379                 dev_err(&intf->dev, "manifest bundle descriptors not valid\n");
 380                 goto out_err;
 381         }
 382
 383         return true;
 384 out_err:
 385         kfree(intf->product_string);
 386         intf->product_string = NULL;
 387 out_free_vendor_string:
 388         kfree(intf->vendor_string);
 389         intf->vendor_string = NULL;
 390
 391         return false;
 392 }
 393
 394 /*
 395  * Parse a buffer containing an interface manifest.
 396  *
 397  * If we find anything wrong with the content/format of the buffer
 398  * we reject it.
 399  *
 400  * The first requirement is that the manifest's version is
 401  * one we can parse.
 402  *
 403  * We make an initial pass through the buffer and identify all of
 404  * the descriptors it contains, keeping track for each its type
 405  * and the location size of its data in the buffer.
 406  *
 407  * Next we scan the descriptors, looking for an interface descriptor;
 408  * there must be exactly one of those.  When found, we record the
 409  * information it contains, and then remove that descriptor (and any
 410  * string descriptors it refers to) from further consideration.
 411  *
 412  * After that we look for the interface's bundles--there must be at
 413  * least one of those.
 414  *
 415  * Returns true if parsing was successful, false otherwise.
 416  */
 417 bool gb_manifest_parse(struct gb_interface *intf, void *data, size_t size)
 418 {
 419         struct greybus_manifest *manifest;
 420         struct greybus_manifest_header *header;
 421         struct greybus_descriptor *desc;
 422         struct manifest_desc *descriptor;
 423         struct manifest_desc *interface_desc = NULL;
 424         u16 manifest_size;
 425         u32 found = 0;
 426         bool result;
 427
 428         /* Manifest descriptor list should be empty here */
 429         if (WARN_ON(!list_empty(&intf->manifest_descs)))
 430                 return false;
 431
 432         /* we have to have at _least_ the manifest header */
 433         if (size < sizeof(*header)) {
 434                 pr_err("short manifest (%zu < %zu)\n", size, sizeof(*header));
 435                 return false;
 436         }
 437
 438         /* Make sure the size is right */
 439         manifest = data;
 440         header = &manifest->header;
 441         manifest_size = le16_to_cpu(header->size);
 442         if (manifest_size != size) {
 443                 pr_err("manifest size mismatch (%zu != %hu)\n",
 444                         size, manifest_size);
 445                 return false;
 446         }
 447
 448         /* Validate major/minor number */
 449         if (header->version_major > GREYBUS_VERSION_MAJOR) {
 450                 pr_err("manifest version too new (%hhu.%hhu > %hhu.%hhu)\n",
 451                        header->version_major, header->version_minor,
 452                        GREYBUS_VERSION_MAJOR, GREYBUS_VERSION_MINOR);
 453                 return false;
 454         }
 455
 456         /* OK, find all the descriptors */
 457         desc = manifest->descriptors;
 458         size -= sizeof(*header);
 459         while (size) {
 460                 int desc_size;
 461
 462                 desc_size = identify_descriptor(intf, desc, size);
 463                 if (desc_size < 0) {
 464                         result = false;
 465                         goto out;
 466                 }
 467                 desc = (struct greybus_descriptor *)((char *)desc + desc_size);
 468                 size -= desc_size;
 469         }
 470
 471         /* There must be a single interface descriptor */
 472         list_for_each_entry(descriptor, &intf->manifest_descs, links) {
 473                 if (descriptor->type == GREYBUS_TYPE_INTERFACE)
 474                         if (!found++)
 475                                 interface_desc = descriptor;
 476         }
 477         if (found != 1) {
 478                 pr_err("manifest must have 1 interface descriptor (%u found)\n",
 479                         found);
 480                 result = false;
 481                 goto out;
 482         }
 483
 484         /* Parse the manifest, starting with the interface descriptor */
 485         result = gb_manifest_parse_interface(intf, interface_desc);
 486
 487         /*
 488          * We really should have no remaining descriptors, but we
 489          * don't know what newer format manifests might leave.
 490          */
 491         if (result && !list_empty(&intf->manifest_descs))
 492                 pr_info("excess descriptors in interface manifest\n");
 493 out:
 494         release_manifest_descriptors(intf);
 495
 496         return result;
 497 }