1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Hypervisor filesystem for Linux on s390. Diag 204 and 224
4 * implementation.
5 *
6 * Copyright IBM Corp. 2006, 2008
7 * Author(s): Michael Holzheu <holzheu@de.ibm.com>
8 */
9
10 #define KMSG_COMPONENT "hypfs"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13 #include <linux/types.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/string.h>
17 #include <linux/vmalloc.h>
18 #include <linux/mm.h>
19 #include <asm/diag.h>
20 #include <asm/ebcdic.h>
21 #include "hypfs.h"
22
23 #define TMP_SIZE 64 /* size of temporary buffers */
24
25 #define DBFS_D204_HDR_VERSION 0
26
27 static char *diag224_cpu_names; /* diag 224 name table */
28 static enum diag204_sc diag204_store_sc; /* used subcode for store */
29 static enum diag204_format diag204_info_type; /* used diag 204 data format */
30
31 static void *diag204_buf; /* 4K aligned buffer for diag204 data */
32 static void *diag204_buf_vmalloc; /* vmalloc pointer for diag204 data */
33 static int diag204_buf_pages; /* number of pages for diag204 data */
34
35 static struct dentry *dbfs_d204_file;
36
37 /*
38 * DIAG 204 member access functions.
39 *
40 * Since we have two different diag 204 data formats for old and new s390
41 * machines, we do not access the structs directly, but use getter functions for
42 * each struct member instead. This should make the code more readable.
43 */
44
45 /* Time information block */
46
info_blk_hdr__size(enum diag204_format type)47 static inline int info_blk_hdr__size(enum diag204_format type)
48 {
49 if (type == DIAG204_INFO_SIMPLE)
50 return sizeof(struct diag204_info_blk_hdr);
51 else /* DIAG204_INFO_EXT */
52 return sizeof(struct diag204_x_info_blk_hdr);
53 }
54
info_blk_hdr__npar(enum diag204_format type,void * hdr)55 static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
56 {
57 if (type == DIAG204_INFO_SIMPLE)
58 return ((struct diag204_info_blk_hdr *)hdr)->npar;
59 else /* DIAG204_INFO_EXT */
60 return ((struct diag204_x_info_blk_hdr *)hdr)->npar;
61 }
62
info_blk_hdr__flags(enum diag204_format type,void * hdr)63 static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
64 {
65 if (type == DIAG204_INFO_SIMPLE)
66 return ((struct diag204_info_blk_hdr *)hdr)->flags;
67 else /* DIAG204_INFO_EXT */
68 return ((struct diag204_x_info_blk_hdr *)hdr)->flags;
69 }
70
71 /* Partition header */
72
part_hdr__size(enum diag204_format type)73 static inline int part_hdr__size(enum diag204_format type)
74 {
75 if (type == DIAG204_INFO_SIMPLE)
76 return sizeof(struct diag204_part_hdr);
77 else /* DIAG204_INFO_EXT */
78 return sizeof(struct diag204_x_part_hdr);
79 }
80
part_hdr__rcpus(enum diag204_format type,void * hdr)81 static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
82 {
83 if (type == DIAG204_INFO_SIMPLE)
84 return ((struct diag204_part_hdr *)hdr)->cpus;
85 else /* DIAG204_INFO_EXT */
86 return ((struct diag204_x_part_hdr *)hdr)->rcpus;
87 }
88
part_hdr__part_name(enum diag204_format type,void * hdr,char * name)89 static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
90 char *name)
91 {
92 if (type == DIAG204_INFO_SIMPLE)
93 memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name,
94 DIAG204_LPAR_NAME_LEN);
95 else /* DIAG204_INFO_EXT */
96 memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name,
97 DIAG204_LPAR_NAME_LEN);
98 EBCASC(name, DIAG204_LPAR_NAME_LEN);
99 name[DIAG204_LPAR_NAME_LEN] = 0;
100 strim(name);
101 }
102
103 /* CPU info block */
104
cpu_info__size(enum diag204_format type)105 static inline int cpu_info__size(enum diag204_format type)
106 {
107 if (type == DIAG204_INFO_SIMPLE)
108 return sizeof(struct diag204_cpu_info);
109 else /* DIAG204_INFO_EXT */
110 return sizeof(struct diag204_x_cpu_info);
111 }
112
cpu_info__ctidx(enum diag204_format type,void * hdr)113 static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
114 {
115 if (type == DIAG204_INFO_SIMPLE)
116 return ((struct diag204_cpu_info *)hdr)->ctidx;
117 else /* DIAG204_INFO_EXT */
118 return ((struct diag204_x_cpu_info *)hdr)->ctidx;
119 }
120
cpu_info__cpu_addr(enum diag204_format type,void * hdr)121 static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
122 {
123 if (type == DIAG204_INFO_SIMPLE)
124 return ((struct diag204_cpu_info *)hdr)->cpu_addr;
125 else /* DIAG204_INFO_EXT */
126 return ((struct diag204_x_cpu_info *)hdr)->cpu_addr;
127 }
128
cpu_info__acc_time(enum diag204_format type,void * hdr)129 static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
130 {
131 if (type == DIAG204_INFO_SIMPLE)
132 return ((struct diag204_cpu_info *)hdr)->acc_time;
133 else /* DIAG204_INFO_EXT */
134 return ((struct diag204_x_cpu_info *)hdr)->acc_time;
135 }
136
cpu_info__lp_time(enum diag204_format type,void * hdr)137 static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
138 {
139 if (type == DIAG204_INFO_SIMPLE)
140 return ((struct diag204_cpu_info *)hdr)->lp_time;
141 else /* DIAG204_INFO_EXT */
142 return ((struct diag204_x_cpu_info *)hdr)->lp_time;
143 }
144
cpu_info__online_time(enum diag204_format type,void * hdr)145 static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
146 {
147 if (type == DIAG204_INFO_SIMPLE)
148 return 0; /* online_time not available in simple info */
149 else /* DIAG204_INFO_EXT */
150 return ((struct diag204_x_cpu_info *)hdr)->online_time;
151 }
152
153 /* Physical header */
154
phys_hdr__size(enum diag204_format type)155 static inline int phys_hdr__size(enum diag204_format type)
156 {
157 if (type == DIAG204_INFO_SIMPLE)
158 return sizeof(struct diag204_phys_hdr);
159 else /* DIAG204_INFO_EXT */
160 return sizeof(struct diag204_x_phys_hdr);
161 }
162
phys_hdr__cpus(enum diag204_format type,void * hdr)163 static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
164 {
165 if (type == DIAG204_INFO_SIMPLE)
166 return ((struct diag204_phys_hdr *)hdr)->cpus;
167 else /* DIAG204_INFO_EXT */
168 return ((struct diag204_x_phys_hdr *)hdr)->cpus;
169 }
170
171 /* Physical CPU info block */
172
phys_cpu__size(enum diag204_format type)173 static inline int phys_cpu__size(enum diag204_format type)
174 {
175 if (type == DIAG204_INFO_SIMPLE)
176 return sizeof(struct diag204_phys_cpu);
177 else /* DIAG204_INFO_EXT */
178 return sizeof(struct diag204_x_phys_cpu);
179 }
180
phys_cpu__cpu_addr(enum diag204_format type,void * hdr)181 static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
182 {
183 if (type == DIAG204_INFO_SIMPLE)
184 return ((struct diag204_phys_cpu *)hdr)->cpu_addr;
185 else /* DIAG204_INFO_EXT */
186 return ((struct diag204_x_phys_cpu *)hdr)->cpu_addr;
187 }
188
phys_cpu__mgm_time(enum diag204_format type,void * hdr)189 static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
190 {
191 if (type == DIAG204_INFO_SIMPLE)
192 return ((struct diag204_phys_cpu *)hdr)->mgm_time;
193 else /* DIAG204_INFO_EXT */
194 return ((struct diag204_x_phys_cpu *)hdr)->mgm_time;
195 }
196
phys_cpu__ctidx(enum diag204_format type,void * hdr)197 static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
198 {
199 if (type == DIAG204_INFO_SIMPLE)
200 return ((struct diag204_phys_cpu *)hdr)->ctidx;
201 else /* DIAG204_INFO_EXT */
202 return ((struct diag204_x_phys_cpu *)hdr)->ctidx;
203 }
204
205 /* Diagnose 204 functions */
206 /*
207 * For the old diag subcode 4 with simple data format we have to use real
208 * memory. If we use subcode 6 or 7 with extended data format, we can (and
209 * should) use vmalloc, since we need a lot of memory in that case. Currently
210 * up to 93 pages!
211 */
212
diag204_free_buffer(void)213 static void diag204_free_buffer(void)
214 {
215 if (!diag204_buf)
216 return;
217 if (diag204_buf_vmalloc) {
218 vfree(diag204_buf_vmalloc);
219 diag204_buf_vmalloc = NULL;
220 } else {
221 free_pages((unsigned long) diag204_buf, 0);
222 }
223 diag204_buf = NULL;
224 }
225
page_align_ptr(void * ptr)226 static void *page_align_ptr(void *ptr)
227 {
228 return (void *) PAGE_ALIGN((unsigned long) ptr);
229 }
230
diag204_alloc_vbuf(int pages)231 static void *diag204_alloc_vbuf(int pages)
232 {
233 /* The buffer has to be page aligned! */
234 diag204_buf_vmalloc = vmalloc(array_size(PAGE_SIZE, (pages + 1)));
235 if (!diag204_buf_vmalloc)
236 return ERR_PTR(-ENOMEM);
237 diag204_buf = page_align_ptr(diag204_buf_vmalloc);
238 diag204_buf_pages = pages;
239 return diag204_buf;
240 }
241
diag204_alloc_rbuf(void)242 static void *diag204_alloc_rbuf(void)
243 {
244 diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
245 if (!diag204_buf)
246 return ERR_PTR(-ENOMEM);
247 diag204_buf_pages = 1;
248 return diag204_buf;
249 }
250
diag204_get_buffer(enum diag204_format fmt,int * pages)251 static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
252 {
253 if (diag204_buf) {
254 *pages = diag204_buf_pages;
255 return diag204_buf;
256 }
257 if (fmt == DIAG204_INFO_SIMPLE) {
258 *pages = 1;
259 return diag204_alloc_rbuf();
260 } else {/* DIAG204_INFO_EXT */
261 *pages = diag204((unsigned long)DIAG204_SUBC_RSI |
262 (unsigned long)DIAG204_INFO_EXT, 0, NULL);
263 if (*pages <= 0)
264 return ERR_PTR(-ENOSYS);
265 else
266 return diag204_alloc_vbuf(*pages);
267 }
268 }
269
270 /*
271 * diag204_probe() has to find out, which type of diagnose 204 implementation
272 * we have on our machine. Currently there are three possible scanarios:
273 * - subcode 4 + simple data format (only one page)
274 * - subcode 4-6 + extended data format
275 * - subcode 4-7 + extended data format
276 *
277 * Subcode 5 is used to retrieve the size of the data, provided by subcodes
278 * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
279 * to subcode 6 it provides also information about secondary cpus.
280 * In order to get as much information as possible, we first try
281 * subcode 7, then 6 and if both fail, we use subcode 4.
282 */
283
diag204_probe(void)284 static int diag204_probe(void)
285 {
286 void *buf;
287 int pages, rc;
288
289 buf = diag204_get_buffer(DIAG204_INFO_EXT, &pages);
290 if (!IS_ERR(buf)) {
291 if (diag204((unsigned long)DIAG204_SUBC_STIB7 |
292 (unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
293 diag204_store_sc = DIAG204_SUBC_STIB7;
294 diag204_info_type = DIAG204_INFO_EXT;
295 goto out;
296 }
297 if (diag204((unsigned long)DIAG204_SUBC_STIB6 |
298 (unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
299 diag204_store_sc = DIAG204_SUBC_STIB6;
300 diag204_info_type = DIAG204_INFO_EXT;
301 goto out;
302 }
303 diag204_free_buffer();
304 }
305
306 /* subcodes 6 and 7 failed, now try subcode 4 */
307
308 buf = diag204_get_buffer(DIAG204_INFO_SIMPLE, &pages);
309 if (IS_ERR(buf)) {
310 rc = PTR_ERR(buf);
311 goto fail_alloc;
312 }
313 if (diag204((unsigned long)DIAG204_SUBC_STIB4 |
314 (unsigned long)DIAG204_INFO_SIMPLE, pages, buf) >= 0) {
315 diag204_store_sc = DIAG204_SUBC_STIB4;
316 diag204_info_type = DIAG204_INFO_SIMPLE;
317 goto out;
318 } else {
319 rc = -ENOSYS;
320 goto fail_store;
321 }
322 out:
323 rc = 0;
324 fail_store:
325 diag204_free_buffer();
326 fail_alloc:
327 return rc;
328 }
329
diag204_do_store(void * buf,int pages)330 static int diag204_do_store(void *buf, int pages)
331 {
332 int rc;
333
334 rc = diag204((unsigned long) diag204_store_sc |
335 (unsigned long) diag204_info_type, pages, buf);
336 return rc < 0 ? -ENOSYS : 0;
337 }
338
diag204_store(void)339 static void *diag204_store(void)
340 {
341 void *buf;
342 int pages, rc;
343
344 buf = diag204_get_buffer(diag204_info_type, &pages);
345 if (IS_ERR(buf))
346 goto out;
347 rc = diag204_do_store(buf, pages);
348 if (rc)
349 return ERR_PTR(rc);
350 out:
351 return buf;
352 }
353
354 /* Diagnose 224 functions */
355
diag224_get_name_table(void)356 static int diag224_get_name_table(void)
357 {
358 /* memory must be below 2GB */
359 diag224_cpu_names = (char *) __get_free_page(GFP_KERNEL | GFP_DMA);
360 if (!diag224_cpu_names)
361 return -ENOMEM;
362 if (diag224(diag224_cpu_names)) {
363 free_page((unsigned long) diag224_cpu_names);
364 return -EOPNOTSUPP;
365 }
366 EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
367 return 0;
368 }
369
diag224_delete_name_table(void)370 static void diag224_delete_name_table(void)
371 {
372 free_page((unsigned long) diag224_cpu_names);
373 }
374
diag224_idx2name(int index,char * name)375 static int diag224_idx2name(int index, char *name)
376 {
377 memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN),
378 DIAG204_CPU_NAME_LEN);
379 name[DIAG204_CPU_NAME_LEN] = 0;
380 strim(name);
381 return 0;
382 }
383
384 struct dbfs_d204_hdr {
385 u64 len; /* Length of d204 buffer without header */
386 u16 version; /* Version of header */
387 u8 sc; /* Used subcode */
388 char reserved[53];
389 } __attribute__ ((packed));
390
391 struct dbfs_d204 {
392 struct dbfs_d204_hdr hdr; /* 64 byte header */
393 char buf[]; /* d204 buffer */
394 } __attribute__ ((packed));
395
dbfs_d204_create(void ** data,void ** data_free_ptr,size_t * size)396 static int dbfs_d204_create(void **data, void **data_free_ptr, size_t *size)
397 {
398 struct dbfs_d204 *d204;
399 int rc, buf_size;
400 void *base;
401
402 buf_size = PAGE_SIZE * (diag204_buf_pages + 1) + sizeof(d204->hdr);
403 base = vzalloc(buf_size);
404 if (!base)
405 return -ENOMEM;
406 d204 = page_align_ptr(base + sizeof(d204->hdr)) - sizeof(d204->hdr);
407 rc = diag204_do_store(d204->buf, diag204_buf_pages);
408 if (rc) {
409 vfree(base);
410 return rc;
411 }
412 d204->hdr.version = DBFS_D204_HDR_VERSION;
413 d204->hdr.len = PAGE_SIZE * diag204_buf_pages;
414 d204->hdr.sc = diag204_store_sc;
415 *data = d204;
416 *data_free_ptr = base;
417 *size = d204->hdr.len + sizeof(struct dbfs_d204_hdr);
418 return 0;
419 }
420
421 static struct hypfs_dbfs_file dbfs_file_d204 = {
422 .name = "diag_204",
423 .data_create = dbfs_d204_create,
424 .data_free = vfree,
425 };
426
hypfs_diag_init(void)427 __init int hypfs_diag_init(void)
428 {
429 int rc;
430
431 if (diag204_probe()) {
432 pr_info("The hardware system does not support hypfs\n");
433 return -ENODATA;
434 }
435
436 if (diag204_info_type == DIAG204_INFO_EXT)
437 hypfs_dbfs_create_file(&dbfs_file_d204);
438
439 if (MACHINE_IS_LPAR) {
440 rc = diag224_get_name_table();
441 if (rc) {
442 pr_err("The hardware system does not provide all "
443 "functions required by hypfs\n");
444 debugfs_remove(dbfs_d204_file);
445 return rc;
446 }
447 }
448 return 0;
449 }
450
hypfs_diag_exit(void)451 void hypfs_diag_exit(void)
452 {
453 debugfs_remove(dbfs_d204_file);
454 diag224_delete_name_table();
455 diag204_free_buffer();
456 hypfs_dbfs_remove_file(&dbfs_file_d204);
457 }
458
459 /*
460 * Functions to create the directory structure
461 * *******************************************
462 */
463
hypfs_create_cpu_files(struct dentry * cpus_dir,void * cpu_info)464 static int hypfs_create_cpu_files(struct dentry *cpus_dir, void *cpu_info)
465 {
466 struct dentry *cpu_dir;
467 char buffer[TMP_SIZE];
468 void *rc;
469
470 snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
471 cpu_info));
472 cpu_dir = hypfs_mkdir(cpus_dir, buffer);
473 rc = hypfs_create_u64(cpu_dir, "mgmtime",
474 cpu_info__acc_time(diag204_info_type, cpu_info) -
475 cpu_info__lp_time(diag204_info_type, cpu_info));
476 if (IS_ERR(rc))
477 return PTR_ERR(rc);
478 rc = hypfs_create_u64(cpu_dir, "cputime",
479 cpu_info__lp_time(diag204_info_type, cpu_info));
480 if (IS_ERR(rc))
481 return PTR_ERR(rc);
482 if (diag204_info_type == DIAG204_INFO_EXT) {
483 rc = hypfs_create_u64(cpu_dir, "onlinetime",
484 cpu_info__online_time(diag204_info_type,
485 cpu_info));
486 if (IS_ERR(rc))
487 return PTR_ERR(rc);
488 }
489 diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
490 rc = hypfs_create_str(cpu_dir, "type", buffer);
491 return PTR_ERR_OR_ZERO(rc);
492 }
493
hypfs_create_lpar_files(struct dentry * systems_dir,void * part_hdr)494 static void *hypfs_create_lpar_files(struct dentry *systems_dir, void *part_hdr)
495 {
496 struct dentry *cpus_dir;
497 struct dentry *lpar_dir;
498 char lpar_name[DIAG204_LPAR_NAME_LEN + 1];
499 void *cpu_info;
500 int i;
501
502 part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
503 lpar_name[DIAG204_LPAR_NAME_LEN] = 0;
504 lpar_dir = hypfs_mkdir(systems_dir, lpar_name);
505 if (IS_ERR(lpar_dir))
506 return lpar_dir;
507 cpus_dir = hypfs_mkdir(lpar_dir, "cpus");
508 if (IS_ERR(cpus_dir))
509 return cpus_dir;
510 cpu_info = part_hdr + part_hdr__size(diag204_info_type);
511 for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
512 int rc;
513 rc = hypfs_create_cpu_files(cpus_dir, cpu_info);
514 if (rc)
515 return ERR_PTR(rc);
516 cpu_info += cpu_info__size(diag204_info_type);
517 }
518 return cpu_info;
519 }
520
hypfs_create_phys_cpu_files(struct dentry * cpus_dir,void * cpu_info)521 static int hypfs_create_phys_cpu_files(struct dentry *cpus_dir, void *cpu_info)
522 {
523 struct dentry *cpu_dir;
524 char buffer[TMP_SIZE];
525 void *rc;
526
527 snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
528 cpu_info));
529 cpu_dir = hypfs_mkdir(cpus_dir, buffer);
530 if (IS_ERR(cpu_dir))
531 return PTR_ERR(cpu_dir);
532 rc = hypfs_create_u64(cpu_dir, "mgmtime",
533 phys_cpu__mgm_time(diag204_info_type, cpu_info));
534 if (IS_ERR(rc))
535 return PTR_ERR(rc);
536 diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
537 rc = hypfs_create_str(cpu_dir, "type", buffer);
538 return PTR_ERR_OR_ZERO(rc);
539 }
540
hypfs_create_phys_files(struct dentry * parent_dir,void * phys_hdr)541 static void *hypfs_create_phys_files(struct dentry *parent_dir, void *phys_hdr)
542 {
543 int i;
544 void *cpu_info;
545 struct dentry *cpus_dir;
546
547 cpus_dir = hypfs_mkdir(parent_dir, "cpus");
548 if (IS_ERR(cpus_dir))
549 return cpus_dir;
550 cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
551 for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
552 int rc;
553 rc = hypfs_create_phys_cpu_files(cpus_dir, cpu_info);
554 if (rc)
555 return ERR_PTR(rc);
556 cpu_info += phys_cpu__size(diag204_info_type);
557 }
558 return cpu_info;
559 }
560
hypfs_diag_create_files(struct dentry * root)561 int hypfs_diag_create_files(struct dentry *root)
562 {
563 struct dentry *systems_dir, *hyp_dir;
564 void *time_hdr, *part_hdr;
565 int i, rc;
566 void *buffer, *ptr;
567
568 buffer = diag204_store();
569 if (IS_ERR(buffer))
570 return PTR_ERR(buffer);
571
572 systems_dir = hypfs_mkdir(root, "systems");
573 if (IS_ERR(systems_dir)) {
574 rc = PTR_ERR(systems_dir);
575 goto err_out;
576 }
577 time_hdr = (struct x_info_blk_hdr *)buffer;
578 part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
579 for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
580 part_hdr = hypfs_create_lpar_files(systems_dir, part_hdr);
581 if (IS_ERR(part_hdr)) {
582 rc = PTR_ERR(part_hdr);
583 goto err_out;
584 }
585 }
586 if (info_blk_hdr__flags(diag204_info_type, time_hdr) &
587 DIAG204_LPAR_PHYS_FLG) {
588 ptr = hypfs_create_phys_files(root, part_hdr);
589 if (IS_ERR(ptr)) {
590 rc = PTR_ERR(ptr);
591 goto err_out;
592 }
593 }
594 hyp_dir = hypfs_mkdir(root, "hyp");
595 if (IS_ERR(hyp_dir)) {
596 rc = PTR_ERR(hyp_dir);
597 goto err_out;
598 }
599 ptr = hypfs_create_str(hyp_dir, "type", "LPAR Hypervisor");
600 if (IS_ERR(ptr)) {
601 rc = PTR_ERR(ptr);
602 goto err_out;
603 }
604 rc = 0;
605
606 err_out:
607 return rc;
608 }
609