~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/hypfs/hypfs_diag.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp