s390/sclp: remove call home support
authorHeiko Carstens <heiko.carstens@de.ibm.com>
Mon, 17 Jun 2019 12:02:40 +0000 (14:02 +0200)
committerVasily Gorbik <gor@linux.ibm.com>
Wed, 19 Jun 2019 15:54:27 +0000 (17:54 +0200)
This feature has never been used, so remove it.

Acked-by: Vasily Gorbik <gor@linux.ibm.com>
Acked-by: Hendrik Brueckner <brueckner@linux.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Vasily Gorbik <gor@linux.ibm.com>
Documentation/sysctl/kernel.txt
drivers/s390/char/Kconfig
drivers/s390/char/Makefile
drivers/s390/char/sclp_async.c [deleted file]

index f0c86fbb3b48dbb8042ae72bbabd8225a2e370fd..5af8b131ccbc7a8522585cd6d51d65d632ffecf0 100644 (file)
@@ -23,7 +23,6 @@ show up in /proc/sys/kernel:
 - auto_msgmni
 - bootloader_type           [ X86 only ]
 - bootloader_version        [ X86 only ]
-- callhome                  [ S390 only ]
 - cap_last_cap
 - core_pattern
 - core_pipe_limit
@@ -171,21 +170,6 @@ Documentation/x86/boot.txt for additional information.
 
 ==============================================================
 
-callhome:
-
-Controls the kernel's callhome behavior in case of a kernel panic.
-
-The s390 hardware allows an operating system to send a notification
-to a service organization (callhome) in case of an operating system panic.
-
-When the value in this file is 0 (which is the default behavior)
-nothing happens in case of a kernel panic. If this value is set to "1"
-the complete kernel oops message is send to the IBM customer service
-organization in case the mainframe the Linux operating system is running
-on has a service contract with IBM.
-
-==============================================================
-
 cap_last_cap
 
 Highest valid capability of the running kernel.  Exports
index e2c0c60760b04090788d1fba68b11f34635e35a0..6cc4b19acf85c35e24ec99a76506040858c6dbe2 100644 (file)
@@ -79,27 +79,6 @@ config SCLP_VT220_CONSOLE
          Include support for using an IBM SCLP VT220-compatible terminal as a
          Linux system console.
 
-config SCLP_ASYNC
-       def_tristate m
-       prompt "Support for Call Home via Asynchronous SCLP Records"
-       depends on S390
-       help
-         This option enables the call home function, which is able to inform
-         the service element and connected organisations about a kernel panic.
-         You should only select this option if you know what you are doing,
-         want for inform other people about your kernel panics,
-         need this feature and intend to run your kernel in LPAR.
-
-config SCLP_ASYNC_ID
-       string "Component ID for Call Home"
-       depends on SCLP_ASYNC
-       default "000000000"
-       help
-         The Component ID for Call Home is used to identify the correct
-         problem reporting queue the call home records should be sent to.
-
-         If your are unsure, please use the default value "000000000".
-
 config HMC_DRV
        def_tristate m
        prompt "Support for file transfers from HMC drive CD/DVD-ROM"
index 3072b89785ddf7329165d6f2c8e678821f79e1a4..b8a8816d94e74f5df222f32bc2086454576e188f 100644 (file)
@@ -31,7 +31,6 @@ obj-$(CONFIG_TN3215) += con3215.o
 obj-$(CONFIG_SCLP_TTY) += sclp_tty.o
 obj-$(CONFIG_SCLP_CONSOLE) += sclp_con.o
 obj-$(CONFIG_SCLP_VT220_TTY) += sclp_vt220.o
-obj-$(CONFIG_SCLP_ASYNC) += sclp_async.o
 
 obj-$(CONFIG_PCI) += sclp_pci.o
 
diff --git a/drivers/s390/char/sclp_async.c b/drivers/s390/char/sclp_async.c
deleted file mode 100644 (file)
index e69b12a..0000000
+++ /dev/null
@@ -1,189 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Enable Asynchronous Notification via SCLP.
- *
- * Copyright IBM Corp. 2009
- * Author(s): Hans-Joachim Picht <hans@linux.vnet.ibm.com>
- *
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/device.h>
-#include <linux/stat.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/ctype.h>
-#include <linux/kmod.h>
-#include <linux/err.h>
-#include <linux/errno.h>
-#include <linux/proc_fs.h>
-#include <linux/sysctl.h>
-#include <linux/utsname.h>
-#include "sclp.h"
-
-static int callhome_enabled;
-static struct sclp_req *request;
-static struct sclp_async_sccb *sccb;
-static int sclp_async_send_wait(char *message);
-static struct ctl_table_header *callhome_sysctl_header;
-static DEFINE_SPINLOCK(sclp_async_lock);
-#define SCLP_NORMAL_WRITE      0x00
-
-struct async_evbuf {
-       struct evbuf_header header;
-       u64 reserved;
-       u8 rflags;
-       u8 empty;
-       u8 rtype;
-       u8 otype;
-       char comp_id[12];
-       char data[3000]; /* there is still some space left */
-} __attribute__((packed));
-
-struct sclp_async_sccb {
-       struct sccb_header header;
-       struct async_evbuf evbuf;
-} __attribute__((packed));
-
-static struct sclp_register sclp_async_register = {
-       .send_mask = EVTYP_ASYNC_MASK,
-};
-
-static int call_home_on_panic(struct notifier_block *self,
-                             unsigned long event, void *data)
-{
-       strncat(data, init_utsname()->nodename,
-               sizeof(init_utsname()->nodename));
-       sclp_async_send_wait(data);
-       return NOTIFY_DONE;
-}
-
-static struct notifier_block call_home_panic_nb = {
-       .notifier_call = call_home_on_panic,
-       .priority = INT_MAX,
-};
-
-static int zero;
-static int one = 1;
-
-static struct ctl_table callhome_table[] = {
-       {
-               .procname       = "callhome",
-               .data           = &callhome_enabled,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = proc_dointvec_minmax,
-               .extra1         = &zero,
-               .extra2         = &one,
-       },
-       {}
-};
-
-static struct ctl_table kern_dir_table[] = {
-       {
-               .procname       = "kernel",
-               .maxlen         = 0,
-               .mode           = 0555,
-               .child          = callhome_table,
-       },
-       {}
-};
-
-/*
- * Function used to transfer asynchronous notification
- * records which waits for send completion
- */
-static int sclp_async_send_wait(char *message)
-{
-       struct async_evbuf *evb;
-       int rc;
-       unsigned long flags;
-
-       if (!callhome_enabled)
-               return 0;
-       sccb->evbuf.header.type = EVTYP_ASYNC;
-       sccb->evbuf.rtype = 0xA5;
-       sccb->evbuf.otype = 0x00;
-       evb = &sccb->evbuf;
-       request->command = SCLP_CMDW_WRITE_EVENT_DATA;
-       request->sccb = sccb;
-       request->status = SCLP_REQ_FILLED;
-       strncpy(sccb->evbuf.data, message, sizeof(sccb->evbuf.data));
-       /*
-        * Retain Queue
-        * e.g. 5639CC140 500 Red Hat RHEL5 Linux for zSeries (RHEL AS)
-        */
-       strncpy(sccb->evbuf.comp_id, CONFIG_SCLP_ASYNC_ID,
-               sizeof(sccb->evbuf.comp_id));
-       sccb->evbuf.header.length = sizeof(sccb->evbuf);
-       sccb->header.length = sizeof(sccb->evbuf) + sizeof(sccb->header);
-       sccb->header.function_code = SCLP_NORMAL_WRITE;
-       rc = sclp_add_request(request);
-       if (rc)
-               return rc;
-       spin_lock_irqsave(&sclp_async_lock, flags);
-       while (request->status != SCLP_REQ_DONE &&
-               request->status != SCLP_REQ_FAILED) {
-                sclp_sync_wait();
-       }
-       spin_unlock_irqrestore(&sclp_async_lock, flags);
-       if (request->status != SCLP_REQ_DONE)
-               return -EIO;
-       rc = ((struct sclp_async_sccb *)
-              request->sccb)->header.response_code;
-       if (rc != 0x0020)
-               return -EIO;
-       if (evb->header.flags != 0x80)
-               return -EIO;
-       return rc;
-}
-
-static int __init sclp_async_init(void)
-{
-       int rc;
-
-       rc = sclp_register(&sclp_async_register);
-       if (rc)
-               return rc;
-       rc = -EOPNOTSUPP;
-       if (!(sclp_async_register.sclp_receive_mask & EVTYP_ASYNC_MASK))
-               goto out_sclp;
-       rc = -ENOMEM;
-       callhome_sysctl_header = register_sysctl_table(kern_dir_table);
-       if (!callhome_sysctl_header)
-               goto out_sclp;
-       request = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
-       sccb = (struct sclp_async_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
-       if (!request || !sccb)
-               goto out_mem;
-       rc = atomic_notifier_chain_register(&panic_notifier_list,
-                                           &call_home_panic_nb);
-       if (!rc)
-               goto out;
-out_mem:
-       kfree(request);
-       free_page((unsigned long) sccb);
-       unregister_sysctl_table(callhome_sysctl_header);
-out_sclp:
-       sclp_unregister(&sclp_async_register);
-out:
-       return rc;
-}
-module_init(sclp_async_init);
-
-static void __exit sclp_async_exit(void)
-{
-       atomic_notifier_chain_unregister(&panic_notifier_list,
-                                        &call_home_panic_nb);
-       unregister_sysctl_table(callhome_sysctl_header);
-       sclp_unregister(&sclp_async_register);
-       free_page((unsigned long) sccb);
-       kfree(request);
-}
-module_exit(sclp_async_exit);
-
-MODULE_AUTHOR("Copyright IBM Corp. 2009");
-MODULE_AUTHOR("Hans-Joachim Picht <hans@linux.vnet.ibm.com>");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("SCLP Asynchronous Notification Records");