src/patches/suse-2.6.27.39/patches.arch/s390-17-perf-13-dasd-goodcase-perf.patch

   1 From: Gerald Schaefer <geraldsc@de.ibm.com>
   2 Subject: [PATCH] dasd: optimize cpu usage in goodcase
   3 References: bnc#532063,LTC#55526
   4
   5 From: Stefan Haberland <stefan.haberland@de.ibm.com>
   6
   7 remove unnecessary dbf call, remove string operations for magic
   8
   9 Signed-off-by: Stefan Haberland <stefan.haberland@de.ibm.com>
  10
  11 Acked-by: John Jolly <jjolly@suse.de>
  12
  13 ---
  14  drivers/s390/block/dasd.c       |   21 ++++++++-------------
  15  drivers/s390/block/dasd_alias.c |    3 +--
  16  drivers/s390/block/dasd_diag.c  |    3 +--
  17  drivers/s390/block/dasd_eckd.c  |   35 +++++++++++++++--------------------
  18  drivers/s390/block/dasd_eer.c   |    2 +-
  19  drivers/s390/block/dasd_fba.c   |    5 ++---
  20  drivers/s390/block/dasd_int.h   |   11 ++++++++---
  21  7 files changed, 36 insertions(+), 44 deletions(-)
  22
  23 Index: linux-sles11/drivers/s390/block/dasd.c
  24 ===================================================================
  25 --- linux-sles11.orig/drivers/s390/block/dasd.c
  26 +++ linux-sles11/drivers/s390/block/dasd.c
  27 @@ -645,14 +645,14 @@ static void dasd_profile_end(struct dasd
  28   * memory and 2) dasd_smalloc_request uses the static ccw memory
  29   * that gets allocated for each device.
  30   */
  31 -struct dasd_ccw_req *dasd_kmalloc_request(char *magic, int cplength,
  32 +struct dasd_ccw_req *dasd_kmalloc_request(int magic, int cplength,
  33                                           int datasize,
  34                                           struct dasd_device *device)
  35  {
  36         struct dasd_ccw_req *cqr;
  37
  38         /* Sanity checks */
  39 -       BUG_ON( magic == NULL || datasize > PAGE_SIZE ||
  40 +       BUG_ON(datasize > PAGE_SIZE ||
  41              (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
  42
  43         cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC);
  44 @@ -676,14 +676,13 @@ struct dasd_ccw_req *dasd_kmalloc_reques
  45                         return ERR_PTR(-ENOMEM);
  46                 }
  47         }
  48 -       strncpy((char *) &cqr->magic, magic, 4);
  49 -       ASCEBC((char *) &cqr->magic, 4);
  50 +       cqr->magic =  magic;
  51         set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  52         dasd_get_device(device);
  53         return cqr;
  54  }
  55
  56 -struct dasd_ccw_req *dasd_smalloc_request(char *magic, int cplength,
  57 +struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength,
  58                                           int datasize,
  59                                           struct dasd_device *device)
  60  {
  61 @@ -693,7 +692,7 @@ struct dasd_ccw_req *dasd_smalloc_reques
  62         int size;
  63
  64         /* Sanity checks */
  65 -       BUG_ON( magic == NULL || datasize > PAGE_SIZE ||
  66 +       BUG_ON(datasize > PAGE_SIZE ||
  67              (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
  68
  69         size = (sizeof(struct dasd_ccw_req) + 7L) & -8L;
  70 @@ -720,8 +719,7 @@ struct dasd_ccw_req *dasd_smalloc_reques
  71                 cqr->data = data;
  72                 memset(cqr->data, 0, datasize);
  73         }
  74 -       strncpy((char *) &cqr->magic, magic, 4);
  75 -       ASCEBC((char *) &cqr->magic, 4);
  76 +       cqr->magic = magic;
  77         set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
  78         dasd_get_device(device);
  79         return cqr;
  80 @@ -865,9 +863,6 @@ int dasd_start_IO(struct dasd_ccw_req *c
  81         switch (rc) {
  82         case 0:
  83                 cqr->status = DASD_CQR_IN_IO;
  84 -               DBF_DEV_EVENT(DBF_DEBUG, device,
  85 -                             "start_IO: request %p started successful",
  86 -                             cqr);
  87                 break;
  88         case -EBUSY:
  89                 DBF_DEV_EVENT(DBF_ERR, device, "%s",
  90 @@ -2393,7 +2388,7 @@ int dasd_generic_notify(struct ccw_devic
  91  static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
  92                                                    void *rdc_buffer,
  93                                                    int rdc_buffer_size,
  94 -                                                  char *magic)
  95 +                                                  int magic)
  96  {
  97         struct dasd_ccw_req *cqr;
  98         struct ccw1 *ccw;
  99 @@ -2422,7 +2417,7 @@ static struct dasd_ccw_req *dasd_generic
 100  }
 101
 102
 103 -int dasd_generic_read_dev_chars(struct dasd_device *device, char *magic,
 104 +int dasd_generic_read_dev_chars(struct dasd_device *device, int magic,
 105                                 void **rdc_buffer, int rdc_buffer_size)
 106  {
 107         int ret;
 108 Index: linux-sles11/drivers/s390/block/dasd_alias.c
 109 ===================================================================
 110 --- linux-sles11.orig/drivers/s390/block/dasd_alias.c
 111 +++ linux-sles11/drivers/s390/block/dasd_alias.c
 112 @@ -377,8 +377,7 @@ static int read_unit_address_configurati
 113         int rc;
 114         unsigned long flags;
 115
 116 -       cqr = dasd_kmalloc_request("ECKD",
 117 -                                  1 /* PSF */  + 1 /* RSSD */ ,
 118 +       cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
 119                                    (sizeof(struct dasd_psf_prssd_data)),
 120                                    device);
 121         if (IS_ERR(cqr))
 122 Index: linux-sles11/drivers/s390/block/dasd_diag.c
 123 ===================================================================
 124 --- linux-sles11.orig/drivers/s390/block/dasd_diag.c
 125 +++ linux-sles11/drivers/s390/block/dasd_diag.c
 126 @@ -521,8 +521,7 @@ static struct dasd_ccw_req *dasd_diag_bu
 127         /* Build the request */
 128         datasize = sizeof(struct dasd_diag_req) +
 129                 count*sizeof(struct dasd_diag_bio);
 130 -       cqr = dasd_smalloc_request(dasd_diag_discipline.name, 0,
 131 -                                  datasize, memdev);
 132 +       cqr = dasd_smalloc_request(DASD_DIAG_MAGIC, 0, datasize, memdev);
 133         if (IS_ERR(cqr))
 134                 return cqr;
 135
 136 Index: linux-sles11/drivers/s390/block/dasd_eckd.c
 137 ===================================================================
 138 --- linux-sles11.orig/drivers/s390/block/dasd_eckd.c
 139 +++ linux-sles11/drivers/s390/block/dasd_eckd.c
 140 @@ -582,7 +582,8 @@ static struct dasd_ccw_req *dasd_eckd_bu
 141         struct dasd_ccw_req *cqr;
 142         struct ccw1 *ccw;
 143
 144 -       cqr = dasd_smalloc_request("ECKD", 1 /* RCD */, ciw->count, device);
 145 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */, ciw->count,
 146 +                                  device);
 147
 148         if (IS_ERR(cqr)) {
 149                 DEV_MESSAGE(KERN_WARNING, device, "%s",
 150 @@ -784,8 +785,7 @@ static int dasd_eckd_read_features(struc
 151         struct dasd_eckd_private *private;
 152
 153         private = (struct dasd_eckd_private *) device->private;
 154 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 155 -                                  1 /* PSF */  + 1 /* RSSD */ ,
 156 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
 157                                    (sizeof(struct dasd_psf_prssd_data) +
 158                                     sizeof(struct dasd_rssd_features)),
 159                                    device);
 160 @@ -846,7 +846,7 @@ static struct dasd_ccw_req *dasd_eckd_bu
 161         struct dasd_psf_ssc_data *psf_ssc_data;
 162         struct ccw1 *ccw;
 163
 164 -       cqr = dasd_smalloc_request("ECKD", 1 /* PSF */ ,
 165 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ ,
 166                                   sizeof(struct dasd_psf_ssc_data),
 167                                   device);
 168
 169 @@ -995,7 +995,8 @@ dasd_eckd_check_characteristics(struct d
 170         /* Read Device Characteristics */
 171         rdc_data = (void *) &(private->rdc_data);
 172         memset(rdc_data, 0, sizeof(rdc_data));
 173 -       rc = dasd_generic_read_dev_chars(device, "ECKD", &rdc_data, 64);
 174 +       rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, &rdc_data,
 175 +                                        64);
 176         if (rc) {
 177                 DEV_MESSAGE(KERN_WARNING, device,
 178                             "Read device characteristics returned "
 179 @@ -1055,8 +1056,7 @@ dasd_eckd_analysis_ccw(struct dasd_devic
 180
 181         cplength = 8;
 182         datasize = sizeof(struct DE_eckd_data) + 2*sizeof(struct LO_eckd_data);
 183 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 184 -                                  cplength, datasize, device);
 185 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device);
 186         if (IS_ERR(cqr))
 187                 return cqr;
 188         ccw = cqr->cpaddr;
 189 @@ -1327,8 +1327,7 @@ dasd_eckd_format_device(struct dasd_devi
 190                 return ERR_PTR(-EINVAL);
 191         }
 192         /* Allocate the format ccw request. */
 193 -       fcp = dasd_smalloc_request(dasd_eckd_discipline.name,
 194 -                                  cplength, datasize, device);
 195 +       fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device);
 196         if (IS_ERR(fcp))
 197                 return fcp;
 198
 199 @@ -1607,8 +1606,8 @@ static struct dasd_ccw_req *dasd_eckd_bu
 200                 datasize += count*sizeof(struct LO_eckd_data);
 201         }
 202         /* Allocate the ccw request. */
 203 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 204 -                                  cplength, datasize, startdev);
 205 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize,
 206 +                                  startdev);
 207         if (IS_ERR(cqr))
 208                 return cqr;
 209         ccw = cqr->cpaddr;
 210 @@ -1865,8 +1864,7 @@ dasd_eckd_release(struct dasd_device *de
 211         if (!capable(CAP_SYS_ADMIN))
 212                 return -EACCES;
 213
 214 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 215 -                                  1, 32, device);
 216 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device);
 217         if (IS_ERR(cqr)) {
 218                 DEV_MESSAGE(KERN_WARNING, device, "%s",
 219                             "Could not allocate initialization request");
 220 @@ -1906,8 +1904,7 @@ dasd_eckd_reserve(struct dasd_device *de
 221         if (!capable(CAP_SYS_ADMIN))
 222                 return -EACCES;
 223
 224 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 225 -                                  1, 32, device);
 226 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device);
 227         if (IS_ERR(cqr)) {
 228                 DEV_MESSAGE(KERN_WARNING, device, "%s",
 229                             "Could not allocate initialization request");
 230 @@ -1946,8 +1943,7 @@ dasd_eckd_steal_lock(struct dasd_device
 231         if (!capable(CAP_SYS_ADMIN))
 232                 return -EACCES;
 233
 234 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 235 -                                  1, 32, device);
 236 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device);
 237         if (IS_ERR(cqr)) {
 238                 DEV_MESSAGE(KERN_WARNING, device, "%s",
 239                             "Could not allocate initialization request");
 240 @@ -1984,8 +1980,7 @@ dasd_eckd_performance(struct dasd_device
 241         struct ccw1 *ccw;
 242         int rc;
 243
 244 -       cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
 245 -                                  1 /* PSF */  + 1 /* RSSD */ ,
 246 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */  + 1 /* RSSD */,
 247                                    (sizeof(struct dasd_psf_prssd_data) +
 248                                     sizeof(struct dasd_rssd_perf_stats_t)),
 249                                    device);
 250 @@ -2131,7 +2126,7 @@ static int dasd_symm_io(struct dasd_devi
 251         }
 252
 253         /* setup CCWs for PSF + RSSD */
 254 -       cqr = dasd_smalloc_request("ECKD", 2 , 0, device);
 255 +       cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 , 0, device);
 256         if (IS_ERR(cqr)) {
 257                 DEV_MESSAGE(KERN_WARNING, device, "%s",
 258                         "Could not allocate initialization request");
 259 Index: linux-sles11/drivers/s390/block/dasd_eer.c
 260 ===================================================================
 261 --- linux-sles11.orig/drivers/s390/block/dasd_eer.c
 262 +++ linux-sles11/drivers/s390/block/dasd_eer.c
 263 @@ -456,7 +456,7 @@ int dasd_eer_enable(struct dasd_device *
 264         if (!device->discipline || strcmp(device->discipline->name, "ECKD"))
 265                 return -EPERM;  /* FIXME: -EMEDIUMTYPE ? */
 266
 267 -       cqr = dasd_kmalloc_request("ECKD", 1 /* SNSS */,
 268 +       cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* SNSS */,
 269                                    SNSS_DATA_SIZE, device);
 270         if (IS_ERR(cqr))
 271                 return -ENOMEM;
 272 Index: linux-sles11/drivers/s390/block/dasd_fba.c
 273 ===================================================================
 274 --- linux-sles11.orig/drivers/s390/block/dasd_fba.c
 275 +++ linux-sles11/drivers/s390/block/dasd_fba.c
 276 @@ -148,7 +148,7 @@ dasd_fba_check_characteristics(struct da
 277
 278         /* Read Device Characteristics */
 279         rdc_data = (void *) &(private->rdc_data);
 280 -       rc = dasd_generic_read_dev_chars(device, "FBA ", &rdc_data, 32);
 281 +       rc = dasd_generic_read_dev_chars(device, DASD_FBA_MAGIC, &rdc_data, 32);
 282         if (rc) {
 283                 DEV_MESSAGE(KERN_WARNING, device,
 284                             "Read device characteristics returned error %d",
 285 @@ -298,8 +298,7 @@ static struct dasd_ccw_req *dasd_fba_bui
 286                 datasize += (count - 1)*sizeof(struct LO_fba_data);
 287         }
 288         /* Allocate the ccw request. */
 289 -       cqr = dasd_smalloc_request(dasd_fba_discipline.name,
 290 -                                  cplength, datasize, memdev);
 291 +       cqr = dasd_smalloc_request(DASD_FBA_MAGIC, cplength, datasize, memdev);
 292         if (IS_ERR(cqr))
 293                 return cqr;
 294         ccw = cqr->cpaddr;
 295 Index: linux-sles11/drivers/s390/block/dasd_int.h
 296 ===================================================================
 297 --- linux-sles11.orig/drivers/s390/block/dasd_int.h
 298 +++ linux-sles11/drivers/s390/block/dasd_int.h
 299 @@ -60,6 +60,11 @@
 300  #include <asm/dasd.h>
 301  #include <asm/idals.h>
 302
 303 +/* DASD discipline magic */
 304 +#define DASD_ECKD_MAGIC 0xC5C3D2C4
 305 +#define DASD_DIAG_MAGIC 0xC4C9C1C7
 306 +#define DASD_FBA_MAGIC 0xC6C2C140
 307 +
 308  /*
 309   * SECTION: Type definitions
 310   */
 311 @@ -528,9 +533,9 @@ extern struct block_device_operations da
 312  extern struct kmem_cache *dasd_page_cache;
 313
 314  struct dasd_ccw_req *
 315 -dasd_kmalloc_request(char *, int, int, struct dasd_device *);
 316 +dasd_kmalloc_request(int , int, int, struct dasd_device *);
 317  struct dasd_ccw_req *
 318 -dasd_smalloc_request(char *, int, int, struct dasd_device *);
 319 +dasd_smalloc_request(int , int, int, struct dasd_device *);
 320  void dasd_kfree_request(struct dasd_ccw_req *, struct dasd_device *);
 321  void dasd_sfree_request(struct dasd_ccw_req *, struct dasd_device *);
 322
 323 @@ -572,7 +577,7 @@ int dasd_generic_set_offline (struct ccw
 324  int dasd_generic_notify(struct ccw_device *, int);
 325  void dasd_generic_handle_state_change(struct dasd_device *);
 326
 327 -int dasd_generic_read_dev_chars(struct dasd_device *, char *, void **, int);
 328 +int dasd_generic_read_dev_chars(struct dasd_device *, int, void **, int);
 329
 330  /* externals in dasd_devmap.c */
 331  extern int dasd_max_devindex;