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_diag.h" 22#include "hypfs.h" 23 24#define TMP_SIZE 64 /* size of temporary buffers */ 25 26static char *diag224_cpu_names; /* diag 224 name table */ 27static int diag224_idx2name(int index, char *name); 28 29/* 30 * DIAG 204 member access functions. 31 * 32 * Since we have two different diag 204 data formats for old and new s390 33 * machines, we do not access the structs directly, but use getter functions for 34 * each struct member instead. This should make the code more readable. 35 */ 36 37/* Time information block */ 38 39static inline int info_blk_hdr__size(enum diag204_format type) 40{ 41 if (type == DIAG204_INFO_SIMPLE) 42 return sizeof(struct diag204_info_blk_hdr); 43 else /* DIAG204_INFO_EXT */ 44 return sizeof(struct diag204_x_info_blk_hdr); 45} 46 47static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr) 48{ 49 if (type == DIAG204_INFO_SIMPLE) 50 return ((struct diag204_info_blk_hdr *)hdr)->npar; 51 else /* DIAG204_INFO_EXT */ 52 return ((struct diag204_x_info_blk_hdr *)hdr)->npar; 53} 54 55static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr) 56{ 57 if (type == DIAG204_INFO_SIMPLE) 58 return ((struct diag204_info_blk_hdr *)hdr)->flags; 59 else /* DIAG204_INFO_EXT */ 60 return ((struct diag204_x_info_blk_hdr *)hdr)->flags; 61} 62 63/* Partition header */ 64 65static inline int part_hdr__size(enum diag204_format type) 66{ 67 if (type == DIAG204_INFO_SIMPLE) 68 return sizeof(struct diag204_part_hdr); 69 else /* DIAG204_INFO_EXT */ 70 return sizeof(struct diag204_x_part_hdr); 71} 72 73static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr) 74{ 75 if (type == DIAG204_INFO_SIMPLE) 76 return ((struct diag204_part_hdr *)hdr)->cpus; 77 else /* DIAG204_INFO_EXT */ 78 return ((struct diag204_x_part_hdr *)hdr)->rcpus; 79} 80 81static inline void part_hdr__part_name(enum diag204_format type, void *hdr, 82 char *name) 83{ 84 if (type == DIAG204_INFO_SIMPLE) 85 memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name, 86 DIAG204_LPAR_NAME_LEN); 87 else /* DIAG204_INFO_EXT */ 88 memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name, 89 DIAG204_LPAR_NAME_LEN); 90 EBCASC(name, DIAG204_LPAR_NAME_LEN); 91 name[DIAG204_LPAR_NAME_LEN] = 0; 92 strim(name); 93} 94 95/* CPU info block */ 96 97static inline int cpu_info__size(enum diag204_format type) 98{ 99 if (type == DIAG204_INFO_SIMPLE) 100 return sizeof(struct diag204_cpu_info); 101 else /* DIAG204_INFO_EXT */ 102 return sizeof(struct diag204_x_cpu_info); 103} 104 105static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr) 106{ 107 if (type == DIAG204_INFO_SIMPLE) 108 return ((struct diag204_cpu_info *)hdr)->ctidx; 109 else /* DIAG204_INFO_EXT */ 110 return ((struct diag204_x_cpu_info *)hdr)->ctidx; 111} 112 113static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr) 114{ 115 if (type == DIAG204_INFO_SIMPLE) 116 return ((struct diag204_cpu_info *)hdr)->cpu_addr; 117 else /* DIAG204_INFO_EXT */ 118 return ((struct diag204_x_cpu_info *)hdr)->cpu_addr; 119} 120 121static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr) 122{ 123 if (type == DIAG204_INFO_SIMPLE) 124 return ((struct diag204_cpu_info *)hdr)->acc_time; 125 else /* DIAG204_INFO_EXT */ 126 return ((struct diag204_x_cpu_info *)hdr)->acc_time; 127} 128 129static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr) 130{ 131 if (type == DIAG204_INFO_SIMPLE) 132 return ((struct diag204_cpu_info *)hdr)->lp_time; 133 else /* DIAG204_INFO_EXT */ 134 return ((struct diag204_x_cpu_info *)hdr)->lp_time; 135} 136 137static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr) 138{ 139 if (type == DIAG204_INFO_SIMPLE) 140 return 0; /* online_time not available in simple info */ 141 else /* DIAG204_INFO_EXT */ 142 return ((struct diag204_x_cpu_info *)hdr)->online_time; 143} 144 145/* Physical header */ 146 147static inline int phys_hdr__size(enum diag204_format type) 148{ 149 if (type == DIAG204_INFO_SIMPLE) 150 return sizeof(struct diag204_phys_hdr); 151 else /* DIAG204_INFO_EXT */ 152 return sizeof(struct diag204_x_phys_hdr); 153} 154 155static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr) 156{ 157 if (type == DIAG204_INFO_SIMPLE) 158 return ((struct diag204_phys_hdr *)hdr)->cpus; 159 else /* DIAG204_INFO_EXT */ 160 return ((struct diag204_x_phys_hdr *)hdr)->cpus; 161} 162 163/* Physical CPU info block */ 164 165static inline int phys_cpu__size(enum diag204_format type) 166{ 167 if (type == DIAG204_INFO_SIMPLE) 168 return sizeof(struct diag204_phys_cpu); 169 else /* DIAG204_INFO_EXT */ 170 return sizeof(struct diag204_x_phys_cpu); 171} 172 173static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr) 174{ 175 if (type == DIAG204_INFO_SIMPLE) 176 return ((struct diag204_phys_cpu *)hdr)->cpu_addr; 177 else /* DIAG204_INFO_EXT */ 178 return ((struct diag204_x_phys_cpu *)hdr)->cpu_addr; 179} 180 181static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr) 182{ 183 if (type == DIAG204_INFO_SIMPLE) 184 return ((struct diag204_phys_cpu *)hdr)->mgm_time; 185 else /* DIAG204_INFO_EXT */ 186 return ((struct diag204_x_phys_cpu *)hdr)->mgm_time; 187} 188 189static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr) 190{ 191 if (type == DIAG204_INFO_SIMPLE) 192 return ((struct diag204_phys_cpu *)hdr)->ctidx; 193 else /* DIAG204_INFO_EXT */ 194 return ((struct diag204_x_phys_cpu *)hdr)->ctidx; 195} 196 197/* 198 * Functions to create the directory structure 199 * ******************************************* 200 */ 201 202static int hypfs_create_cpu_files(struct dentry *cpus_dir, void *cpu_info) 203{ 204 struct dentry *cpu_dir; 205 char buffer[TMP_SIZE]; 206 void *rc; 207 208 snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_get_info_type(), 209 cpu_info)); 210 cpu_dir = hypfs_mkdir(cpus_dir, buffer); 211 rc = hypfs_create_u64(cpu_dir, "mgmtime", 212 cpu_info__acc_time(diag204_get_info_type(), cpu_info) - 213 cpu_info__lp_time(diag204_get_info_type(), cpu_info)); 214 if (IS_ERR(rc)) 215 return PTR_ERR(rc); 216 rc = hypfs_create_u64(cpu_dir, "cputime", 217 cpu_info__lp_time(diag204_get_info_type(), cpu_info)); 218 if (IS_ERR(rc)) 219 return PTR_ERR(rc); 220 if (diag204_get_info_type() == DIAG204_INFO_EXT) { 221 rc = hypfs_create_u64(cpu_dir, "onlinetime", 222 cpu_info__online_time(diag204_get_info_type(), 223 cpu_info)); 224 if (IS_ERR(rc)) 225 return PTR_ERR(rc); 226 } 227 diag224_idx2name(cpu_info__ctidx(diag204_get_info_type(), cpu_info), buffer); 228 rc = hypfs_create_str(cpu_dir, "type", buffer); 229 return PTR_ERR_OR_ZERO(rc); 230} 231 232static void *hypfs_create_lpar_files(struct dentry *systems_dir, void *part_hdr) 233{ 234 struct dentry *cpus_dir; 235 struct dentry *lpar_dir; 236 char lpar_name[DIAG204_LPAR_NAME_LEN + 1]; 237 void *cpu_info; 238 int i; 239 240 part_hdr__part_name(diag204_get_info_type(), part_hdr, lpar_name); 241 lpar_name[DIAG204_LPAR_NAME_LEN] = 0; 242 lpar_dir = hypfs_mkdir(systems_dir, lpar_name); 243 if (IS_ERR(lpar_dir)) 244 return lpar_dir; 245 cpus_dir = hypfs_mkdir(lpar_dir, "cpus"); 246 if (IS_ERR(cpus_dir)) 247 return cpus_dir; 248 cpu_info = part_hdr + part_hdr__size(diag204_get_info_type()); 249 for (i = 0; i < part_hdr__rcpus(diag204_get_info_type(), part_hdr); i++) { 250 int rc; 251 252 rc = hypfs_create_cpu_files(cpus_dir, cpu_info); 253 if (rc) 254 return ERR_PTR(rc); 255 cpu_info += cpu_info__size(diag204_get_info_type()); 256 } 257 return cpu_info; 258} 259 260static int hypfs_create_phys_cpu_files(struct dentry *cpus_dir, void *cpu_info) 261{ 262 struct dentry *cpu_dir; 263 char buffer[TMP_SIZE]; 264 void *rc; 265 266 snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_get_info_type(), 267 cpu_info)); 268 cpu_dir = hypfs_mkdir(cpus_dir, buffer); 269 if (IS_ERR(cpu_dir)) 270 return PTR_ERR(cpu_dir); 271 rc = hypfs_create_u64(cpu_dir, "mgmtime", 272 phys_cpu__mgm_time(diag204_get_info_type(), cpu_info)); 273 if (IS_ERR(rc)) 274 return PTR_ERR(rc); 275 diag224_idx2name(phys_cpu__ctidx(diag204_get_info_type(), cpu_info), buffer); 276 rc = hypfs_create_str(cpu_dir, "type", buffer); 277 return PTR_ERR_OR_ZERO(rc); 278} 279 280static void *hypfs_create_phys_files(struct dentry *parent_dir, void *phys_hdr) 281{ 282 int i; 283 void *cpu_info; 284 struct dentry *cpus_dir; 285 286 cpus_dir = hypfs_mkdir(parent_dir, "cpus"); 287 if (IS_ERR(cpus_dir)) 288 return cpus_dir; 289 cpu_info = phys_hdr + phys_hdr__size(diag204_get_info_type()); 290 for (i = 0; i < phys_hdr__cpus(diag204_get_info_type(), phys_hdr); i++) { 291 int rc; 292 293 rc = hypfs_create_phys_cpu_files(cpus_dir, cpu_info); 294 if (rc) 295 return ERR_PTR(rc); 296 cpu_info += phys_cpu__size(diag204_get_info_type()); 297 } 298 return cpu_info; 299} 300 301int hypfs_diag_create_files(struct dentry *root) 302{ 303 struct dentry *systems_dir, *hyp_dir; 304 void *time_hdr, *part_hdr; 305 void *buffer, *ptr; 306 int i, rc, pages; 307 308 buffer = diag204_get_buffer(diag204_get_info_type(), &pages); 309 if (IS_ERR(buffer)) 310 return PTR_ERR(buffer); 311 rc = diag204_store(buffer, pages); 312 if (rc) 313 return rc; 314 315 systems_dir = hypfs_mkdir(root, "systems"); 316 if (IS_ERR(systems_dir)) { 317 rc = PTR_ERR(systems_dir); 318 goto err_out; 319 } 320 time_hdr = (struct x_info_blk_hdr *)buffer; 321 part_hdr = time_hdr + info_blk_hdr__size(diag204_get_info_type()); 322 for (i = 0; i < info_blk_hdr__npar(diag204_get_info_type(), time_hdr); i++) { 323 part_hdr = hypfs_create_lpar_files(systems_dir, part_hdr); 324 if (IS_ERR(part_hdr)) { 325 rc = PTR_ERR(part_hdr); 326 goto err_out; 327 } 328 } 329 if (info_blk_hdr__flags(diag204_get_info_type(), time_hdr) & 330 DIAG204_LPAR_PHYS_FLG) { 331 ptr = hypfs_create_phys_files(root, part_hdr); 332 if (IS_ERR(ptr)) { 333 rc = PTR_ERR(ptr); 334 goto err_out; 335 } 336 } 337 hyp_dir = hypfs_mkdir(root, "hyp"); 338 if (IS_ERR(hyp_dir)) { 339 rc = PTR_ERR(hyp_dir); 340 goto err_out; 341 } 342 ptr = hypfs_create_str(hyp_dir, "type", "LPAR Hypervisor"); 343 if (IS_ERR(ptr)) { 344 rc = PTR_ERR(ptr); 345 goto err_out; 346 } 347 rc = 0; 348 349err_out: 350 return rc; 351} 352 353/* Diagnose 224 functions */ 354 355static int diag224_idx2name(int index, char *name) 356{ 357 memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN), 358 DIAG204_CPU_NAME_LEN); 359 name[DIAG204_CPU_NAME_LEN] = 0; 360 strim(name); 361 return 0; 362} 363 364static int diag224_get_name_table(void) 365{ 366 /* memory must be below 2GB */ 367 diag224_cpu_names = (char *)__get_free_page(GFP_KERNEL | GFP_DMA); 368 if (!diag224_cpu_names) 369 return -ENOMEM; 370 if (diag224(diag224_cpu_names)) { 371 free_page((unsigned long)diag224_cpu_names); 372 return -EOPNOTSUPP; 373 } 374 EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16); 375 return 0; 376} 377 378static void diag224_delete_name_table(void) 379{ 380 free_page((unsigned long)diag224_cpu_names); 381} 382 383int __init __hypfs_diag_fs_init(void) 384{ 385 if (MACHINE_IS_LPAR) 386 return diag224_get_name_table(); 387 return 0; 388} 389 390void __hypfs_diag_fs_exit(void) 391{ 392 diag224_delete_name_table(); 393} 394