Quelle  of.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

#include <linux/blkdev.h>
#include <linux/major.h>
#include <linux/of.h>
#include <linux/string.h>
#include "check.h"

static int validate_of_partition(struct device_node *np, int slot)
{
 u64 offset, size;
 int len;

 const __be32 *reg = of_get_property(np, "reg", &len);
 int a_cells = of_n_addr_cells(np);
 int s_cells = of_n_size_cells(np);

 /* Make sure reg len match the expected addr and size cells */
 if (len / sizeof(*reg) != a_cells + s_cells)
  return -EINVAL;

 /* Validate offset conversion from bytes to sectors */
 offset = of_read_number(reg, a_cells);
 if (offset % SECTOR_SIZE)
  return -EINVAL;

 /* Validate size conversion from bytes to sectors */
 size = of_read_number(reg + a_cells, s_cells);
 if (!size || size % SECTOR_SIZE)
  return -EINVAL;

 return 0;
}

static void add_of_partition(struct parsed_partitions *state, int slot,
        struct device_node *np)
{
 struct partition_meta_info *info;
 char tmp[sizeof(info->volname) + 4];
 const char *partname;
 int len;

 const __be32 *reg = of_get_property(np, "reg", &len);
 int a_cells = of_n_addr_cells(np);
 int s_cells = of_n_size_cells(np);

 /* Convert bytes to sector size */
 u64 offset = of_read_number(reg, a_cells) / SECTOR_SIZE;
 u64 size = of_read_number(reg + a_cells, s_cells) / SECTOR_SIZE;

 put_partition(state, slot, offset, size);

 if (of_property_read_bool(np, "read-only"))
  state->parts[slot].flags |= ADDPART_FLAG_READONLY;

 /*
 * Follow MTD label logic, search for label property,
 * fallback to node name if not found.
 */
 info = &state->parts[slot].info;
 partname = of_get_property(np, "label", &len);
 if (!partname)
  partname = of_get_property(np, "name", &len);
 strscpy(info->volname, partname, sizeof(info->volname));

 snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
 strlcat(state->pp_buf, tmp, PAGE_SIZE);
}

int of_partition(struct parsed_partitions *state)
{
 struct device *ddev = disk_to_dev(state->disk);
 struct device_node *np;
 int slot;

 struct device_node *partitions_np = of_node_get(ddev->of_node);

 if (!partitions_np ||
     !of_device_is_compatible(partitions_np, "fixed-partitions"))
  return 0;

 slot = 1;
 /* Validate parition offset and size */
 for_each_child_of_node(partitions_np, np) {
  if (validate_of_partition(np, slot)) {
   of_node_put(np);
   of_node_put(partitions_np);

   return -1;
  }

  slot++;
 }

 slot = 1;
 for_each_child_of_node(partitions_np, np) {
  if (slot >= state->limit) {
   of_node_put(np);
   break;
  }

  add_of_partition(state, slot, np);

  slot++;
 }

 strlcat(state->pp_buf, "\n", PAGE_SIZE);

 return 1;
}