secvar-sysfs.c 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2019 IBM Corporation <nayna@linux.ibm.com>
  4. *
  5. * This code exposes secure variables to user via sysfs
  6. */
  7. #define pr_fmt(fmt) "secvar-sysfs: "fmt
  8. #include <linux/slab.h>
  9. #include <linux/compat.h>
  10. #include <linux/string.h>
  11. #include <linux/of.h>
  12. #include <asm/secvar.h>
  13. #define NAME_MAX_SIZE 1024
  14. static struct kobject *secvar_kobj;
  15. static struct kset *secvar_kset;
  16. static ssize_t format_show(struct kobject *kobj, struct kobj_attribute *attr,
  17. char *buf)
  18. {
  19. ssize_t rc = 0;
  20. struct device_node *node;
  21. const char *format;
  22. node = of_find_compatible_node(NULL, NULL, "ibm,secvar-backend");
  23. if (!of_device_is_available(node)) {
  24. rc = -ENODEV;
  25. goto out;
  26. }
  27. rc = of_property_read_string(node, "format", &format);
  28. if (rc)
  29. goto out;
  30. rc = sprintf(buf, "%s\n", format);
  31. out:
  32. of_node_put(node);
  33. return rc;
  34. }
  35. static ssize_t size_show(struct kobject *kobj, struct kobj_attribute *attr,
  36. char *buf)
  37. {
  38. uint64_t dsize;
  39. int rc;
  40. rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
  41. if (rc) {
  42. pr_err("Error retrieving %s variable size %d\n", kobj->name,
  43. rc);
  44. return rc;
  45. }
  46. return sprintf(buf, "%llu\n", dsize);
  47. }
  48. static ssize_t data_read(struct file *filep, struct kobject *kobj,
  49. struct bin_attribute *attr, char *buf, loff_t off,
  50. size_t count)
  51. {
  52. uint64_t dsize;
  53. char *data;
  54. int rc;
  55. rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, NULL, &dsize);
  56. if (rc) {
  57. pr_err("Error getting %s variable size %d\n", kobj->name, rc);
  58. return rc;
  59. }
  60. pr_debug("dsize is %llu\n", dsize);
  61. data = kzalloc(dsize, GFP_KERNEL);
  62. if (!data)
  63. return -ENOMEM;
  64. rc = secvar_ops->get(kobj->name, strlen(kobj->name) + 1, data, &dsize);
  65. if (rc) {
  66. pr_err("Error getting %s variable %d\n", kobj->name, rc);
  67. goto data_fail;
  68. }
  69. rc = memory_read_from_buffer(buf, count, &off, data, dsize);
  70. data_fail:
  71. kfree(data);
  72. return rc;
  73. }
  74. static ssize_t update_write(struct file *filep, struct kobject *kobj,
  75. struct bin_attribute *attr, char *buf, loff_t off,
  76. size_t count)
  77. {
  78. int rc;
  79. pr_debug("count is %ld\n", count);
  80. rc = secvar_ops->set(kobj->name, strlen(kobj->name) + 1, buf, count);
  81. if (rc) {
  82. pr_err("Error setting the %s variable %d\n", kobj->name, rc);
  83. return rc;
  84. }
  85. return count;
  86. }
  87. static struct kobj_attribute format_attr = __ATTR_RO(format);
  88. static struct kobj_attribute size_attr = __ATTR_RO(size);
  89. static struct bin_attribute data_attr = __BIN_ATTR_RO(data, 0);
  90. static struct bin_attribute update_attr = __BIN_ATTR_WO(update, 0);
  91. static struct bin_attribute *secvar_bin_attrs[] = {
  92. &data_attr,
  93. &update_attr,
  94. NULL,
  95. };
  96. static struct attribute *secvar_attrs[] = {
  97. &size_attr.attr,
  98. NULL,
  99. };
  100. static const struct attribute_group secvar_attr_group = {
  101. .attrs = secvar_attrs,
  102. .bin_attrs = secvar_bin_attrs,
  103. };
  104. __ATTRIBUTE_GROUPS(secvar_attr);
  105. static struct kobj_type secvar_ktype = {
  106. .sysfs_ops = &kobj_sysfs_ops,
  107. .default_groups = secvar_attr_groups,
  108. };
  109. static int update_kobj_size(void)
  110. {
  111. struct device_node *node;
  112. u64 varsize;
  113. int rc = 0;
  114. node = of_find_compatible_node(NULL, NULL, "ibm,secvar-backend");
  115. if (!of_device_is_available(node)) {
  116. rc = -ENODEV;
  117. goto out;
  118. }
  119. rc = of_property_read_u64(node, "max-var-size", &varsize);
  120. if (rc)
  121. goto out;
  122. data_attr.size = varsize;
  123. update_attr.size = varsize;
  124. out:
  125. of_node_put(node);
  126. return rc;
  127. }
  128. static int secvar_sysfs_load(void)
  129. {
  130. char *name;
  131. uint64_t namesize = 0;
  132. struct kobject *kobj;
  133. int rc;
  134. name = kzalloc(NAME_MAX_SIZE, GFP_KERNEL);
  135. if (!name)
  136. return -ENOMEM;
  137. do {
  138. rc = secvar_ops->get_next(name, &namesize, NAME_MAX_SIZE);
  139. if (rc) {
  140. if (rc != -ENOENT)
  141. pr_err("error getting secvar from firmware %d\n",
  142. rc);
  143. break;
  144. }
  145. kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
  146. if (!kobj) {
  147. rc = -ENOMEM;
  148. break;
  149. }
  150. kobject_init(kobj, &secvar_ktype);
  151. rc = kobject_add(kobj, &secvar_kset->kobj, "%s", name);
  152. if (rc) {
  153. pr_warn("kobject_add error %d for attribute: %s\n", rc,
  154. name);
  155. kobject_put(kobj);
  156. kobj = NULL;
  157. }
  158. if (kobj)
  159. kobject_uevent(kobj, KOBJ_ADD);
  160. } while (!rc);
  161. kfree(name);
  162. return rc;
  163. }
  164. static int secvar_sysfs_init(void)
  165. {
  166. int rc;
  167. if (!secvar_ops) {
  168. pr_warn("secvar: failed to retrieve secvar operations.\n");
  169. return -ENODEV;
  170. }
  171. secvar_kobj = kobject_create_and_add("secvar", firmware_kobj);
  172. if (!secvar_kobj) {
  173. pr_err("secvar: Failed to create firmware kobj\n");
  174. return -ENOMEM;
  175. }
  176. rc = sysfs_create_file(secvar_kobj, &format_attr.attr);
  177. if (rc) {
  178. kobject_put(secvar_kobj);
  179. return -ENOMEM;
  180. }
  181. secvar_kset = kset_create_and_add("vars", NULL, secvar_kobj);
  182. if (!secvar_kset) {
  183. pr_err("secvar: sysfs kobject registration failed.\n");
  184. kobject_put(secvar_kobj);
  185. return -ENOMEM;
  186. }
  187. rc = update_kobj_size();
  188. if (rc) {
  189. pr_err("Cannot read the size of the attribute\n");
  190. return rc;
  191. }
  192. secvar_sysfs_load();
  193. return 0;
  194. }
  195. late_initcall(secvar_sysfs_init);