drivers/s390/char/zcore.c

   1 /*
   2  * zcore module to export memory content and register sets for creating system
   3  * dumps on SCSI disks (zfcpdump). The "zcore/mem" debugfs file shows the same
   4  * dump format as s390 standalone dumps.
   5  *
   6  * For more information please refer to Documentation/s390/zfcpdump.txt
   7  *
   8  * Copyright IBM Corp. 2003, 2008
   9  * Author(s): Michael Holzheu
  10  */
  11
  12 #define KMSG_COMPONENT "zdump"
  13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  14
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/miscdevice.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/module.h>
  20 #include <linux/memblock.h>
  21
  22 #include <asm/asm-offsets.h>
  23 #include <asm/ipl.h>
  24 #include <asm/sclp.h>
  25 #include <asm/setup.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/debug.h>
  28 #include <asm/processor.h>
  29 #include <asm/irqflags.h>
  30 #include <asm/checksum.h>
  31 #include <asm/os_info.h>
  32 #include <asm/switch_to.h>
  33 #include "sclp.h"
  34
  35 #define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)
  36
  37 #define CHUNK_INFO_SIZE 34 /* 2 16-byte char, each followed by blank */
  38
  39 enum arch_id {
  40         ARCH_S390       = 0,
  41         ARCH_S390X      = 1,
  42 };
  43
  44 struct ipib_info {
  45         unsigned long   ipib;
  46         u32             checksum;
  47 }  __attribute__((packed));
  48
  49 static struct debug_info *zcore_dbf;
  50 static int hsa_available;
  51 static struct dentry *zcore_dir;
  52 static struct dentry *zcore_memmap_file;
  53 static struct dentry *zcore_reipl_file;
  54 static struct dentry *zcore_hsa_file;
  55 static struct ipl_parameter_block *ipl_block;
  56
  57 static char hsa_buf[PAGE_SIZE] __aligned(PAGE_SIZE);
  58
  59 /*
  60  * Copy memory from HSA to user memory (not reentrant):
  61  *
  62  * @dest:  User buffer where memory should be copied to
  63  * @src:   Start address within HSA where data should be copied
  64  * @count: Size of buffer, which should be copied
  65  */
  66 int memcpy_hsa_user(void __user *dest, unsigned long src, size_t count)
  67 {
  68         unsigned long offset, bytes;
  69
  70         if (!hsa_available)
  71                 return -ENODATA;
  72
  73         while (count) {
  74                 if (sclp_sdias_copy(hsa_buf, src / PAGE_SIZE + 2, 1)) {
  75                         TRACE("sclp_sdias_copy() failed\n");
  76                         return -EIO;
  77                 }
  78                 offset = src % PAGE_SIZE;
  79                 bytes = min(PAGE_SIZE - offset, count);
  80                 if (copy_to_user(dest, hsa_buf + offset, bytes))
  81                         return -EFAULT;
  82                 src += bytes;
  83                 dest += bytes;
  84                 count -= bytes;
  85         }
  86         return 0;
  87 }
  88
  89 /*
  90  * Copy memory from HSA to kernel memory (not reentrant):
  91  *
  92  * @dest:  Kernel or user buffer where memory should be copied to
  93  * @src:   Start address within HSA where data should be copied
  94  * @count: Size of buffer, which should be copied
  95  */
  96 int memcpy_hsa_kernel(void *dest, unsigned long src, size_t count)
  97 {
  98         unsigned long offset, bytes;
  99
 100         if (!hsa_available)
 101                 return -ENODATA;
 102
 103         while (count) {
 104                 if (sclp_sdias_copy(hsa_buf, src / PAGE_SIZE + 2, 1)) {
 105                         TRACE("sclp_sdias_copy() failed\n");
 106                         return -EIO;
 107                 }
 108                 offset = src % PAGE_SIZE;
 109                 bytes = min(PAGE_SIZE - offset, count);
 110                 memcpy(dest, hsa_buf + offset, bytes);
 111                 src += bytes;
 112                 dest += bytes;
 113                 count -= bytes;
 114         }
 115         return 0;
 116 }
 117
 118 static int __init init_cpu_info(void)
 119 {
 120         struct save_area *sa;
 121
 122         /* get info for boot cpu from lowcore, stored in the HSA */
 123         sa = save_area_boot_cpu();
 124         if (!sa)
 125                 return -ENOMEM;
 126         if (memcpy_hsa_kernel(hsa_buf, __LC_FPREGS_SAVE_AREA, 512) < 0) {
 127                 TRACE("could not copy from HSA\n");
 128                 return -EIO;
 129         }
 130         save_area_add_regs(sa, hsa_buf); /* vx registers are saved in smp.c */
 131         return 0;
 132 }
 133
 134 /*
 135  * Release the HSA
 136  */
 137 static void release_hsa(void)
 138 {
 139         diag308(DIAG308_REL_HSA, NULL);
 140         hsa_available = 0;
 141 }
 142
 143 static ssize_t zcore_memmap_read(struct file *filp, char __user *buf,
 144                                  size_t count, loff_t *ppos)
 145 {
 146         return simple_read_from_buffer(buf, count, ppos, filp->private_data,
 147                                        memblock.memory.cnt * CHUNK_INFO_SIZE);
 148 }
 149
 150 static int zcore_memmap_open(struct inode *inode, struct file *filp)
 151 {
 152         struct memblock_region *reg;
 153         char *buf;
 154         int i = 0;
 155
 156         buf = kzalloc(memblock.memory.cnt * CHUNK_INFO_SIZE, GFP_KERNEL);
 157         if (!buf) {
 158                 return -ENOMEM;
 159         }
 160         for_each_memblock(memory, reg) {
 161                 sprintf(buf + (i++ * CHUNK_INFO_SIZE), "%016llx %016llx ",
 162                         (unsigned long long) reg->base,
 163                         (unsigned long long) reg->size);
 164         }
 165         filp->private_data = buf;
 166         return nonseekable_open(inode, filp);
 167 }
 168
 169 static int zcore_memmap_release(struct inode *inode, struct file *filp)
 170 {
 171         kfree(filp->private_data);
 172         return 0;
 173 }
 174
 175 static const struct file_operations zcore_memmap_fops = {
 176         .owner          = THIS_MODULE,
 177         .read           = zcore_memmap_read,
 178         .open           = zcore_memmap_open,
 179         .release        = zcore_memmap_release,
 180         .llseek         = no_llseek,
 181 };
 182
 183 static ssize_t zcore_reipl_write(struct file *filp, const char __user *buf,
 184                                  size_t count, loff_t *ppos)
 185 {
 186         if (ipl_block) {
 187                 diag308(DIAG308_SET, ipl_block);
 188                 diag308(DIAG308_IPL, NULL);
 189         }
 190         return count;
 191 }
 192
 193 static int zcore_reipl_open(struct inode *inode, struct file *filp)
 194 {
 195         return nonseekable_open(inode, filp);
 196 }
 197
 198 static int zcore_reipl_release(struct inode *inode, struct file *filp)
 199 {
 200         return 0;
 201 }
 202
 203 static const struct file_operations zcore_reipl_fops = {
 204         .owner          = THIS_MODULE,
 205         .write          = zcore_reipl_write,
 206         .open           = zcore_reipl_open,
 207         .release        = zcore_reipl_release,
 208         .llseek         = no_llseek,
 209 };
 210
 211 static ssize_t zcore_hsa_read(struct file *filp, char __user *buf,
 212                               size_t count, loff_t *ppos)
 213 {
 214         static char str[18];
 215
 216         if (hsa_available)
 217                 snprintf(str, sizeof(str), "%lx\n", sclp.hsa_size);
 218         else
 219                 snprintf(str, sizeof(str), "0\n");
 220         return simple_read_from_buffer(buf, count, ppos, str, strlen(str));
 221 }
 222
 223 static ssize_t zcore_hsa_write(struct file *filp, const char __user *buf,
 224                                size_t count, loff_t *ppos)
 225 {
 226         char value;
 227
 228         if (*ppos != 0)
 229                 return -EPIPE;
 230         if (copy_from_user(&value, buf, 1))
 231                 return -EFAULT;
 232         if (value != '0')
 233                 return -EINVAL;
 234         release_hsa();
 235         return count;
 236 }
 237
 238 static const struct file_operations zcore_hsa_fops = {
 239         .owner          = THIS_MODULE,
 240         .write          = zcore_hsa_write,
 241         .read           = zcore_hsa_read,
 242         .open           = nonseekable_open,
 243         .llseek         = no_llseek,
 244 };
 245
 246 static int __init check_sdias(void)
 247 {
 248         if (!sclp.hsa_size) {
 249                 TRACE("Could not determine HSA size\n");
 250                 return -ENODEV;
 251         }
 252         return 0;
 253 }
 254
 255 /*
 256  * Provide IPL parameter information block from either HSA or memory
 257  * for future reipl
 258  */
 259 static int __init zcore_reipl_init(void)
 260 {
 261         struct ipib_info ipib_info;
 262         int rc;
 263
 264         rc = memcpy_hsa_kernel(&ipib_info, __LC_DUMP_REIPL, sizeof(ipib_info));
 265         if (rc)
 266                 return rc;
 267         if (ipib_info.ipib == 0)
 268                 return 0;
 269         ipl_block = (void *) __get_free_page(GFP_KERNEL);
 270         if (!ipl_block)
 271                 return -ENOMEM;
 272         if (ipib_info.ipib < sclp.hsa_size)
 273                 rc = memcpy_hsa_kernel(ipl_block, ipib_info.ipib, PAGE_SIZE);
 274         else
 275                 rc = memcpy_real(ipl_block, (void *) ipib_info.ipib, PAGE_SIZE);
 276         if (rc || csum_partial(ipl_block, ipl_block->hdr.len, 0) !=
 277             ipib_info.checksum) {
 278                 TRACE("Checksum does not match\n");
 279                 free_page((unsigned long) ipl_block);
 280                 ipl_block = NULL;
 281         }
 282         return 0;
 283 }
 284
 285 static int __init zcore_init(void)
 286 {
 287         unsigned char arch;
 288         int rc;
 289
 290         if (ipl_info.type != IPL_TYPE_FCP_DUMP)
 291                 return -ENODATA;
 292         if (OLDMEM_BASE)
 293                 return -ENODATA;
 294
 295         zcore_dbf = debug_register("zcore", 4, 1, 4 * sizeof(long));
 296         debug_register_view(zcore_dbf, &debug_sprintf_view);
 297         debug_set_level(zcore_dbf, 6);
 298
 299         TRACE("devno:  %x\n", ipl_info.data.fcp.dev_id.devno);
 300         TRACE("wwpn:   %llx\n", (unsigned long long) ipl_info.data.fcp.wwpn);
 301         TRACE("lun:    %llx\n", (unsigned long long) ipl_info.data.fcp.lun);
 302
 303         rc = sclp_sdias_init();
 304         if (rc)
 305                 goto fail;
 306
 307         rc = check_sdias();
 308         if (rc)
 309                 goto fail;
 310         hsa_available = 1;
 311
 312         rc = memcpy_hsa_kernel(&arch, __LC_AR_MODE_ID, 1);
 313         if (rc)
 314                 goto fail;
 315
 316         if (arch == ARCH_S390) {
 317                 pr_alert("The 64-bit dump tool cannot be used for a "
 318                          "32-bit system\n");
 319                 rc = -EINVAL;
 320                 goto fail;
 321         }
 322
 323         pr_alert("DETECTED 'S390X (64 bit) OS'\n");
 324         rc = init_cpu_info();
 325         if (rc)
 326                 goto fail;
 327
 328         rc = zcore_reipl_init();
 329         if (rc)
 330                 goto fail;
 331
 332         zcore_dir = debugfs_create_dir("zcore" , NULL);
 333         if (!zcore_dir) {
 334                 rc = -ENOMEM;
 335                 goto fail;
 336         }
 337         zcore_memmap_file = debugfs_create_file("memmap", S_IRUSR, zcore_dir,
 338                                                 NULL, &zcore_memmap_fops);
 339         if (!zcore_memmap_file) {
 340                 rc = -ENOMEM;
 341                 goto fail_dir;
 342         }
 343         zcore_reipl_file = debugfs_create_file("reipl", S_IRUSR, zcore_dir,
 344                                                 NULL, &zcore_reipl_fops);
 345         if (!zcore_reipl_file) {
 346                 rc = -ENOMEM;
 347                 goto fail_memmap_file;
 348         }
 349         zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR|S_IWUSR, zcore_dir,
 350                                              NULL, &zcore_hsa_fops);
 351         if (!zcore_hsa_file) {
 352                 rc = -ENOMEM;
 353                 goto fail_reipl_file;
 354         }
 355         return 0;
 356
 357 fail_reipl_file:
 358         debugfs_remove(zcore_reipl_file);
 359 fail_memmap_file:
 360         debugfs_remove(zcore_memmap_file);
 361 fail_dir:
 362         debugfs_remove(zcore_dir);
 363 fail:
 364         diag308(DIAG308_REL_HSA, NULL);
 365         return rc;
 366 }
 367
 368 static void __exit zcore_exit(void)
 369 {
 370         debug_unregister(zcore_dbf);
 371         sclp_sdias_exit();
 372         free_page((unsigned long) ipl_block);
 373         debugfs_remove(zcore_hsa_file);
 374         debugfs_remove(zcore_reipl_file);
 375         debugfs_remove(zcore_memmap_file);
 376         debugfs_remove(zcore_dir);
 377         diag308(DIAG308_REL_HSA, NULL);
 378 }
 379
 380 MODULE_AUTHOR("Copyright IBM Corp. 2003,2008");
 381 MODULE_DESCRIPTION("zcore module for zfcpdump support");
 382 MODULE_LICENSE("GPL");
 383
 384 subsys_initcall(zcore_init);
 385 module_exit(zcore_exit);