Merge branch 'proc-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/adobriyan...
[linux-2.6] / arch / s390 / hypfs / hypfs_diag.c
1 /*
2  *  arch/s390/hypfs/hypfs_diag.c
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/string.h>
16 #include <linux/vmalloc.h>
17 #include <asm/ebcdic.h>
18 #include "hypfs.h"
19
20 #define LPAR_NAME_LEN 8         /* lpar name len in diag 204 data */
21 #define CPU_NAME_LEN 16         /* type name len of cpus in diag224 name table */
22 #define TMP_SIZE 64             /* size of temporary buffers */
23
24 /* diag 204 subcodes */
25 enum diag204_sc {
26         SUBC_STIB4 = 4,
27         SUBC_RSI = 5,
28         SUBC_STIB6 = 6,
29         SUBC_STIB7 = 7
30 };
31
32 /* The two available diag 204 data formats */
33 enum diag204_format {
34         INFO_SIMPLE = 0,
35         INFO_EXT = 0x00010000
36 };
37
38 /* bit is set in flags, when physical cpu info is included in diag 204 data */
39 #define LPAR_PHYS_FLG  0x80
40
41 static char *diag224_cpu_names;                 /* diag 224 name table */
42 static enum diag204_sc diag204_store_sc;        /* used subcode for store */
43 static enum diag204_format diag204_info_type;   /* used diag 204 data format */
44
45 static void *diag204_buf;               /* 4K aligned buffer for diag204 data */
46 static void *diag204_buf_vmalloc;       /* vmalloc pointer for diag204 data */
47 static int diag204_buf_pages;           /* number of pages for diag204 data */
48
49 /*
50  * DIAG 204 data structures and member access functions.
51  *
52  * Since we have two different diag 204 data formats for old and new s390
53  * machines, we do not access the structs directly, but use getter functions for
54  * each struct member instead. This should make the code more readable.
55  */
56
57 /* Time information block */
58
59 struct info_blk_hdr {
60         __u8  npar;
61         __u8  flags;
62         __u16 tslice;
63         __u16 phys_cpus;
64         __u16 this_part;
65         __u64 curtod;
66 } __attribute__ ((packed));
67
68 struct x_info_blk_hdr {
69         __u8  npar;
70         __u8  flags;
71         __u16 tslice;
72         __u16 phys_cpus;
73         __u16 this_part;
74         __u64 curtod1;
75         __u64 curtod2;
76         char reserved[40];
77 } __attribute__ ((packed));
78
79 static inline int info_blk_hdr__size(enum diag204_format type)
80 {
81         if (type == INFO_SIMPLE)
82                 return sizeof(struct info_blk_hdr);
83         else /* INFO_EXT */
84                 return sizeof(struct x_info_blk_hdr);
85 }
86
87 static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
88 {
89         if (type == INFO_SIMPLE)
90                 return ((struct info_blk_hdr *)hdr)->npar;
91         else /* INFO_EXT */
92                 return ((struct x_info_blk_hdr *)hdr)->npar;
93 }
94
95 static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
96 {
97         if (type == INFO_SIMPLE)
98                 return ((struct info_blk_hdr *)hdr)->flags;
99         else /* INFO_EXT */
100                 return ((struct x_info_blk_hdr *)hdr)->flags;
101 }
102
103 static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
104 {
105         if (type == INFO_SIMPLE)
106                 return ((struct info_blk_hdr *)hdr)->phys_cpus;
107         else /* INFO_EXT */
108                 return ((struct x_info_blk_hdr *)hdr)->phys_cpus;
109 }
110
111 /* Partition header */
112
113 struct part_hdr {
114         __u8 pn;
115         __u8 cpus;
116         char reserved[6];
117         char part_name[LPAR_NAME_LEN];
118 } __attribute__ ((packed));
119
120 struct x_part_hdr {
121         __u8  pn;
122         __u8  cpus;
123         __u8  rcpus;
124         __u8  pflag;
125         __u32 mlu;
126         char  part_name[LPAR_NAME_LEN];
127         char  lpc_name[8];
128         char  os_name[8];
129         __u64 online_cs;
130         __u64 online_es;
131         __u8  upid;
132         char  reserved1[3];
133         __u32 group_mlu;
134         char  group_name[8];
135         char  reserved2[32];
136 } __attribute__ ((packed));
137
138 static inline int part_hdr__size(enum diag204_format type)
139 {
140         if (type == INFO_SIMPLE)
141                 return sizeof(struct part_hdr);
142         else /* INFO_EXT */
143                 return sizeof(struct x_part_hdr);
144 }
145
146 static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
147 {
148         if (type == INFO_SIMPLE)
149                 return ((struct part_hdr *)hdr)->cpus;
150         else /* INFO_EXT */
151                 return ((struct x_part_hdr *)hdr)->rcpus;
152 }
153
154 static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
155                                        char *name)
156 {
157         if (type == INFO_SIMPLE)
158                 memcpy(name, ((struct part_hdr *)hdr)->part_name,
159                        LPAR_NAME_LEN);
160         else /* INFO_EXT */
161                 memcpy(name, ((struct x_part_hdr *)hdr)->part_name,
162                        LPAR_NAME_LEN);
163         EBCASC(name, LPAR_NAME_LEN);
164         name[LPAR_NAME_LEN] = 0;
165         strstrip(name);
166 }
167
168 struct cpu_info {
169         __u16 cpu_addr;
170         char  reserved1[2];
171         __u8  ctidx;
172         __u8  cflag;
173         __u16 weight;
174         __u64 acc_time;
175         __u64 lp_time;
176 } __attribute__ ((packed));
177
178 struct x_cpu_info {
179         __u16 cpu_addr;
180         char  reserved1[2];
181         __u8  ctidx;
182         __u8  cflag;
183         __u16 weight;
184         __u64 acc_time;
185         __u64 lp_time;
186         __u16 min_weight;
187         __u16 cur_weight;
188         __u16 max_weight;
189         char  reseved2[2];
190         __u64 online_time;
191         __u64 wait_time;
192         __u32 pma_weight;
193         __u32 polar_weight;
194         char  reserved3[40];
195 } __attribute__ ((packed));
196
197 /* CPU info block */
198
199 static inline int cpu_info__size(enum diag204_format type)
200 {
201         if (type == INFO_SIMPLE)
202                 return sizeof(struct cpu_info);
203         else /* INFO_EXT */
204                 return sizeof(struct x_cpu_info);
205 }
206
207 static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
208 {
209         if (type == INFO_SIMPLE)
210                 return ((struct cpu_info *)hdr)->ctidx;
211         else /* INFO_EXT */
212                 return ((struct x_cpu_info *)hdr)->ctidx;
213 }
214
215 static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
216 {
217         if (type == INFO_SIMPLE)
218                 return ((struct cpu_info *)hdr)->cpu_addr;
219         else /* INFO_EXT */
220                 return ((struct x_cpu_info *)hdr)->cpu_addr;
221 }
222
223 static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
224 {
225         if (type == INFO_SIMPLE)
226                 return ((struct cpu_info *)hdr)->acc_time;
227         else /* INFO_EXT */
228                 return ((struct x_cpu_info *)hdr)->acc_time;
229 }
230
231 static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
232 {
233         if (type == INFO_SIMPLE)
234                 return ((struct cpu_info *)hdr)->lp_time;
235         else /* INFO_EXT */
236                 return ((struct x_cpu_info *)hdr)->lp_time;
237 }
238
239 static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
240 {
241         if (type == INFO_SIMPLE)
242                 return 0;       /* online_time not available in simple info */
243         else /* INFO_EXT */
244                 return ((struct x_cpu_info *)hdr)->online_time;
245 }
246
247 /* Physical header */
248
249 struct phys_hdr {
250         char reserved1[1];
251         __u8 cpus;
252         char reserved2[6];
253         char mgm_name[8];
254 } __attribute__ ((packed));
255
256 struct x_phys_hdr {
257         char reserved1[1];
258         __u8 cpus;
259         char reserved2[6];
260         char mgm_name[8];
261         char reserved3[80];
262 } __attribute__ ((packed));
263
264 static inline int phys_hdr__size(enum diag204_format type)
265 {
266         if (type == INFO_SIMPLE)
267                 return sizeof(struct phys_hdr);
268         else /* INFO_EXT */
269                 return sizeof(struct x_phys_hdr);
270 }
271
272 static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
273 {
274         if (type == INFO_SIMPLE)
275                 return ((struct phys_hdr *)hdr)->cpus;
276         else /* INFO_EXT */
277                 return ((struct x_phys_hdr *)hdr)->cpus;
278 }
279
280 /* Physical CPU info block */
281
282 struct phys_cpu {
283         __u16 cpu_addr;
284         char  reserved1[2];
285         __u8  ctidx;
286         char  reserved2[3];
287         __u64 mgm_time;
288         char  reserved3[8];
289 } __attribute__ ((packed));
290
291 struct x_phys_cpu {
292         __u16 cpu_addr;
293         char  reserved1[2];
294         __u8  ctidx;
295         char  reserved2[3];
296         __u64 mgm_time;
297         char  reserved3[80];
298 } __attribute__ ((packed));
299
300 static inline int phys_cpu__size(enum diag204_format type)
301 {
302         if (type == INFO_SIMPLE)
303                 return sizeof(struct phys_cpu);
304         else /* INFO_EXT */
305                 return sizeof(struct x_phys_cpu);
306 }
307
308 static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
309 {
310         if (type == INFO_SIMPLE)
311                 return ((struct phys_cpu *)hdr)->cpu_addr;
312         else /* INFO_EXT */
313                 return ((struct x_phys_cpu *)hdr)->cpu_addr;
314 }
315
316 static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
317 {
318         if (type == INFO_SIMPLE)
319                 return ((struct phys_cpu *)hdr)->mgm_time;
320         else /* INFO_EXT */
321                 return ((struct x_phys_cpu *)hdr)->mgm_time;
322 }
323
324 static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
325 {
326         if (type == INFO_SIMPLE)
327                 return ((struct phys_cpu *)hdr)->ctidx;
328         else /* INFO_EXT */
329                 return ((struct x_phys_cpu *)hdr)->ctidx;
330 }
331
332 /* Diagnose 204 functions */
333
334 static int diag204(unsigned long subcode, unsigned long size, void *addr)
335 {
336         register unsigned long _subcode asm("0") = subcode;
337         register unsigned long _size asm("1") = size;
338
339         asm volatile(
340                 "       diag    %2,%0,0x204\n"
341                 "0:\n"
342                 EX_TABLE(0b,0b)
343                 : "+d" (_subcode), "+d" (_size) : "d" (addr) : "memory");
344         if (_subcode)
345                 return -1;
346         return _size;
347 }
348
349 /*
350  * For the old diag subcode 4 with simple data format we have to use real
351  * memory. If we use subcode 6 or 7 with extended data format, we can (and
352  * should) use vmalloc, since we need a lot of memory in that case. Currently
353  * up to 93 pages!
354  */
355
356 static void diag204_free_buffer(void)
357 {
358         if (!diag204_buf)
359                 return;
360         if (diag204_buf_vmalloc) {
361                 vfree(diag204_buf_vmalloc);
362                 diag204_buf_vmalloc = NULL;
363         } else {
364                 free_pages((unsigned long) diag204_buf, 0);
365         }
366         diag204_buf_pages = 0;
367         diag204_buf = NULL;
368 }
369
370 static void *diag204_alloc_vbuf(int pages)
371 {
372         /* The buffer has to be page aligned! */
373         diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1));
374         if (!diag204_buf_vmalloc)
375                 return ERR_PTR(-ENOMEM);
376         diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc
377                                 & ~0xfffUL) + 0x1000;
378         diag204_buf_pages = pages;
379         return diag204_buf;
380 }
381
382 static void *diag204_alloc_rbuf(void)
383 {
384         diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
385         if (!diag204_buf)
386                 return ERR_PTR(-ENOMEM);
387         diag204_buf_pages = 1;
388         return diag204_buf;
389 }
390
391 static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
392 {
393         if (diag204_buf) {
394                 *pages = diag204_buf_pages;
395                 return diag204_buf;
396         }
397         if (fmt == INFO_SIMPLE) {
398                 *pages = 1;
399                 return diag204_alloc_rbuf();
400         } else {/* INFO_EXT */
401                 *pages = diag204((unsigned long)SUBC_RSI |
402                                  (unsigned long)INFO_EXT, 0, NULL);
403                 if (*pages <= 0)
404                         return ERR_PTR(-ENOSYS);
405                 else
406                         return diag204_alloc_vbuf(*pages);
407         }
408 }
409
410 /*
411  * diag204_probe() has to find out, which type of diagnose 204 implementation
412  * we have on our machine. Currently there are three possible scanarios:
413  *   - subcode 4   + simple data format (only one page)
414  *   - subcode 4-6 + extended data format
415  *   - subcode 4-7 + extended data format
416  *
417  * Subcode 5 is used to retrieve the size of the data, provided by subcodes
418  * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
419  * to subcode 6 it provides also information about secondary cpus.
420  * In order to get as much information as possible, we first try
421  * subcode 7, then 6 and if both fail, we use subcode 4.
422  */
423
424 static int diag204_probe(void)
425 {
426         void *buf;
427         int pages, rc;
428
429         buf = diag204_get_buffer(INFO_EXT, &pages);
430         if (!IS_ERR(buf)) {
431                 if (diag204((unsigned long)SUBC_STIB7 |
432                             (unsigned long)INFO_EXT, pages, buf) >= 0) {
433                         diag204_store_sc = SUBC_STIB7;
434                         diag204_info_type = INFO_EXT;
435                         goto out;
436                 }
437                 if (diag204((unsigned long)SUBC_STIB6 |
438                             (unsigned long)INFO_EXT, pages, buf) >= 0) {
439                         diag204_store_sc = SUBC_STIB7;
440                         diag204_info_type = INFO_EXT;
441                         goto out;
442                 }
443                 diag204_free_buffer();
444         }
445
446         /* subcodes 6 and 7 failed, now try subcode 4 */
447
448         buf = diag204_get_buffer(INFO_SIMPLE, &pages);
449         if (IS_ERR(buf)) {
450                 rc = PTR_ERR(buf);
451                 goto fail_alloc;
452         }
453         if (diag204((unsigned long)SUBC_STIB4 |
454                     (unsigned long)INFO_SIMPLE, pages, buf) >= 0) {
455                 diag204_store_sc = SUBC_STIB4;
456                 diag204_info_type = INFO_SIMPLE;
457                 goto out;
458         } else {
459                 rc = -ENOSYS;
460                 goto fail_store;
461         }
462 out:
463         rc = 0;
464 fail_store:
465         diag204_free_buffer();
466 fail_alloc:
467         return rc;
468 }
469
470 static void *diag204_store(void)
471 {
472         void *buf;
473         int pages;
474
475         buf = diag204_get_buffer(diag204_info_type, &pages);
476         if (IS_ERR(buf))
477                 goto out;
478         if (diag204((unsigned long)diag204_store_sc |
479                     (unsigned long)diag204_info_type, pages, buf) < 0)
480                 return ERR_PTR(-ENOSYS);
481 out:
482         return buf;
483 }
484
485 /* Diagnose 224 functions */
486
487 static int diag224(void *ptr)
488 {
489         int rc = -ENOTSUPP;
490
491         asm volatile(
492                 "       diag    %1,%2,0x224\n"
493                 "0:     lhi     %0,0x0\n"
494                 "1:\n"
495                 EX_TABLE(0b,1b)
496                 : "+d" (rc) :"d" (0), "d" (ptr) : "memory");
497         return rc;
498 }
499
500 static int diag224_get_name_table(void)
501 {
502         /* memory must be below 2GB */
503         diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
504         if (!diag224_cpu_names)
505                 return -ENOMEM;
506         if (diag224(diag224_cpu_names)) {
507                 kfree(diag224_cpu_names);
508                 return -ENOTSUPP;
509         }
510         EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
511         return 0;
512 }
513
514 static void diag224_delete_name_table(void)
515 {
516         kfree(diag224_cpu_names);
517 }
518
519 static int diag224_idx2name(int index, char *name)
520 {
521         memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),
522                 CPU_NAME_LEN);
523         name[CPU_NAME_LEN] = 0;
524         strstrip(name);
525         return 0;
526 }
527
528 __init int hypfs_diag_init(void)
529 {
530         int rc;
531
532         if (diag204_probe()) {
533                 pr_err("The hardware system does not support hypfs\n");
534                 return -ENODATA;
535         }
536         rc = diag224_get_name_table();
537         if (rc) {
538                 diag204_free_buffer();
539                 pr_err("The hardware system does not provide all "
540                        "functions required by hypfs\n");
541         }
542         return rc;
543 }
544
545 void hypfs_diag_exit(void)
546 {
547         diag224_delete_name_table();
548         diag204_free_buffer();
549 }
550
551 /*
552  * Functions to create the directory structure
553  * *******************************************
554  */
555
556 static int hypfs_create_cpu_files(struct super_block *sb,
557                                   struct dentry *cpus_dir, void *cpu_info)
558 {
559         struct dentry *cpu_dir;
560         char buffer[TMP_SIZE];
561         void *rc;
562
563         snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
564                                                             cpu_info));
565         cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
566         rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
567                               cpu_info__acc_time(diag204_info_type, cpu_info) -
568                               cpu_info__lp_time(diag204_info_type, cpu_info));
569         if (IS_ERR(rc))
570                 return PTR_ERR(rc);
571         rc = hypfs_create_u64(sb, cpu_dir, "cputime",
572                               cpu_info__lp_time(diag204_info_type, cpu_info));
573         if (IS_ERR(rc))
574                 return PTR_ERR(rc);
575         if (diag204_info_type == INFO_EXT) {
576                 rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",
577                                       cpu_info__online_time(diag204_info_type,
578                                                             cpu_info));
579                 if (IS_ERR(rc))
580                         return PTR_ERR(rc);
581         }
582         diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
583         rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
584         if (IS_ERR(rc))
585                 return PTR_ERR(rc);
586         return 0;
587 }
588
589 static void *hypfs_create_lpar_files(struct super_block *sb,
590                                      struct dentry *systems_dir, void *part_hdr)
591 {
592         struct dentry *cpus_dir;
593         struct dentry *lpar_dir;
594         char lpar_name[LPAR_NAME_LEN + 1];
595         void *cpu_info;
596         int i;
597
598         part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
599         lpar_name[LPAR_NAME_LEN] = 0;
600         lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);
601         if (IS_ERR(lpar_dir))
602                 return lpar_dir;
603         cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");
604         if (IS_ERR(cpus_dir))
605                 return cpus_dir;
606         cpu_info = part_hdr + part_hdr__size(diag204_info_type);
607         for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
608                 int rc;
609                 rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);
610                 if (rc)
611                         return ERR_PTR(rc);
612                 cpu_info += cpu_info__size(diag204_info_type);
613         }
614         return cpu_info;
615 }
616
617 static int hypfs_create_phys_cpu_files(struct super_block *sb,
618                                        struct dentry *cpus_dir, void *cpu_info)
619 {
620         struct dentry *cpu_dir;
621         char buffer[TMP_SIZE];
622         void *rc;
623
624         snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
625                                                             cpu_info));
626         cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
627         if (IS_ERR(cpu_dir))
628                 return PTR_ERR(cpu_dir);
629         rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
630                               phys_cpu__mgm_time(diag204_info_type, cpu_info));
631         if (IS_ERR(rc))
632                 return PTR_ERR(rc);
633         diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
634         rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
635         if (IS_ERR(rc))
636                 return PTR_ERR(rc);
637         return 0;
638 }
639
640 static void *hypfs_create_phys_files(struct super_block *sb,
641                                      struct dentry *parent_dir, void *phys_hdr)
642 {
643         int i;
644         void *cpu_info;
645         struct dentry *cpus_dir;
646
647         cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");
648         if (IS_ERR(cpus_dir))
649                 return cpus_dir;
650         cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
651         for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
652                 int rc;
653                 rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);
654                 if (rc)
655                         return ERR_PTR(rc);
656                 cpu_info += phys_cpu__size(diag204_info_type);
657         }
658         return cpu_info;
659 }
660
661 int hypfs_diag_create_files(struct super_block *sb, struct dentry *root)
662 {
663         struct dentry *systems_dir, *hyp_dir;
664         void *time_hdr, *part_hdr;
665         int i, rc;
666         void *buffer, *ptr;
667
668         buffer = diag204_store();
669         if (IS_ERR(buffer))
670                 return PTR_ERR(buffer);
671
672         systems_dir = hypfs_mkdir(sb, root, "systems");
673         if (IS_ERR(systems_dir)) {
674                 rc = PTR_ERR(systems_dir);
675                 goto err_out;
676         }
677         time_hdr = (struct x_info_blk_hdr *)buffer;
678         part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
679         for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
680                 part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);
681                 if (IS_ERR(part_hdr)) {
682                         rc = PTR_ERR(part_hdr);
683                         goto err_out;
684                 }
685         }
686         if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {
687                 ptr = hypfs_create_phys_files(sb, root, part_hdr);
688                 if (IS_ERR(ptr)) {
689                         rc = PTR_ERR(ptr);
690                         goto err_out;
691                 }
692         }
693         hyp_dir = hypfs_mkdir(sb, root, "hyp");
694         if (IS_ERR(hyp_dir)) {
695                 rc = PTR_ERR(hyp_dir);
696                 goto err_out;
697         }
698         ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");
699         if (IS_ERR(ptr)) {
700                 rc = PTR_ERR(ptr);
701                 goto err_out;
702         }
703         rc = 0;
704
705 err_out:
706         return rc;
707 }