Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
chp.c
Go to the documentation of this file.
1 /*
2  * Copyright IBM Corp. 1999, 2010
3  * Author(s): Cornelia Huck ([email protected])
4  * Arnd Bergmann ([email protected])
5  * Peter Oberparleiter <[email protected]>
6  */
7 
8 #include <linux/bug.h>
9 #include <linux/workqueue.h>
10 #include <linux/spinlock.h>
11 #include <linux/export.h>
12 #include <linux/sched.h>
13 #include <linux/init.h>
14 #include <linux/jiffies.h>
15 #include <linux/wait.h>
16 #include <linux/mutex.h>
17 #include <linux/errno.h>
18 #include <linux/slab.h>
19 #include <asm/chpid.h>
20 #include <asm/sclp.h>
21 #include <asm/crw.h>
22 
23 #include "cio.h"
24 #include "css.h"
25 #include "ioasm.h"
26 #include "cio_debug.h"
27 #include "chp.h"
28 
29 #define to_channelpath(device) container_of(device, struct channel_path, dev)
30 #define CHP_INFO_UPDATE_INTERVAL 1*HZ
31 
32 enum cfg_task_t {
36 };
37 
38 /* Map for pending configure tasks. */
39 static enum cfg_task_t chp_cfg_task[__MAX_CSSID + 1][__MAX_CHPID + 1];
40 static DEFINE_MUTEX(cfg_lock);
41 static int cfg_busy;
42 
43 /* Map for channel-path status. */
44 static struct sclp_chp_info chp_info;
45 static DEFINE_MUTEX(info_lock);
46 
47 /* Time after which channel-path status may be outdated. */
48 static unsigned long chp_info_expires;
49 
50 /* Workqueue to perform pending configure tasks. */
51 static struct workqueue_struct *chp_wq;
52 static struct work_struct cfg_work;
53 
54 /* Wait queue for configure completion events. */
55 static wait_queue_head_t cfg_wait_queue;
56 
57 /* Set vary state for given chpid. */
58 static void set_chp_logically_online(struct chp_id chpid, int onoff)
59 {
60  chpid_to_chp(chpid)->state = onoff;
61 }
62 
63 /* On success return 0 if channel-path is varied offline, 1 if it is varied
64  * online. Return -ENODEV if channel-path is not registered. */
66 {
67  return (chpid_to_chp(chpid) ? chpid_to_chp(chpid)->state : -ENODEV);
68 }
69 
78 {
79  struct chp_id chpid;
80  int opm;
81  int i;
82 
83  opm = 0;
84  chp_id_init(&chpid);
85  for (i = 0; i < 8; i++) {
86  opm <<= 1;
87  chpid.id = sch->schib.pmcw.chpid[i];
88  if (chp_get_status(chpid) != 0)
89  opm |= 1;
90  }
91  return opm;
92 }
94 
103 {
104  return chpid_to_chp(chpid) != NULL;
105 }
106 
107 /*
108  * Function: s390_vary_chpid
109  * Varies the specified chpid online or offline
110  */
111 static int s390_vary_chpid(struct chp_id chpid, int on)
112 {
113  char dbf_text[15];
114  int status;
115 
116  sprintf(dbf_text, on?"varyon%x.%02x":"varyoff%x.%02x", chpid.cssid,
117  chpid.id);
118  CIO_TRACE_EVENT(2, dbf_text);
119 
120  status = chp_get_status(chpid);
121  if (!on && !status)
122  return 0;
123 
124  set_chp_logically_online(chpid, on);
125  chsc_chp_vary(chpid, on);
126  return 0;
127 }
128 
129 /*
130  * Channel measurement related functions
131  */
132 static ssize_t chp_measurement_chars_read(struct file *filp,
133  struct kobject *kobj,
134  struct bin_attribute *bin_attr,
135  char *buf, loff_t off, size_t count)
136 {
137  struct channel_path *chp;
138  struct device *device;
139 
140  device = container_of(kobj, struct device, kobj);
141  chp = to_channelpath(device);
142  if (!chp->cmg_chars)
143  return 0;
144 
145  return memory_read_from_buffer(buf, count, &off,
146  chp->cmg_chars, sizeof(struct cmg_chars));
147 }
148 
149 static struct bin_attribute chp_measurement_chars_attr = {
150  .attr = {
151  .name = "measurement_chars",
152  .mode = S_IRUSR,
153  },
154  .size = sizeof(struct cmg_chars),
155  .read = chp_measurement_chars_read,
156 };
157 
158 static void chp_measurement_copy_block(struct cmg_entry *buf,
159  struct channel_subsystem *css,
160  struct chp_id chpid)
161 {
162  void *area;
163  struct cmg_entry *entry, reference_buf;
164  int idx;
165 
166  if (chpid.id < 128) {
167  area = css->cub_addr1;
168  idx = chpid.id;
169  } else {
170  area = css->cub_addr2;
171  idx = chpid.id - 128;
172  }
173  entry = area + (idx * sizeof(struct cmg_entry));
174  do {
175  memcpy(buf, entry, sizeof(*entry));
176  memcpy(&reference_buf, entry, sizeof(*entry));
177  } while (reference_buf.values[0] != buf->values[0]);
178 }
179 
180 static ssize_t chp_measurement_read(struct file *filp, struct kobject *kobj,
181  struct bin_attribute *bin_attr,
182  char *buf, loff_t off, size_t count)
183 {
184  struct channel_path *chp;
185  struct channel_subsystem *css;
186  struct device *device;
187  unsigned int size;
188 
189  device = container_of(kobj, struct device, kobj);
190  chp = to_channelpath(device);
191  css = to_css(chp->dev.parent);
192 
193  size = sizeof(struct cmg_entry);
194 
195  /* Only allow single reads. */
196  if (off || count < size)
197  return 0;
198  chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->chpid);
199  count = size;
200  return count;
201 }
202 
203 static struct bin_attribute chp_measurement_attr = {
204  .attr = {
205  .name = "measurement",
206  .mode = S_IRUSR,
207  },
208  .size = sizeof(struct cmg_entry),
209  .read = chp_measurement_read,
210 };
211 
213 {
214  device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
215  device_remove_bin_file(&chp->dev, &chp_measurement_attr);
216 }
217 
219 {
220  int ret;
221 
222  ret = device_create_bin_file(&chp->dev, &chp_measurement_chars_attr);
223  if (ret)
224  return ret;
225  ret = device_create_bin_file(&chp->dev, &chp_measurement_attr);
226  if (ret)
227  device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
228  return ret;
229 }
230 
231 /*
232  * Files for the channel path entries.
233  */
234 static ssize_t chp_status_show(struct device *dev,
235  struct device_attribute *attr, char *buf)
236 {
237  struct channel_path *chp = to_channelpath(dev);
238  int status;
239 
240  mutex_lock(&chp->lock);
241  status = chp->state;
242  mutex_unlock(&chp->lock);
243 
244  return status ? sprintf(buf, "online\n") : sprintf(buf, "offline\n");
245 }
246 
247 static ssize_t chp_status_write(struct device *dev,
248  struct device_attribute *attr,
249  const char *buf, size_t count)
250 {
251  struct channel_path *cp = to_channelpath(dev);
252  char cmd[10];
253  int num_args;
254  int error;
255 
256  num_args = sscanf(buf, "%5s", cmd);
257  if (!num_args)
258  return count;
259 
260  if (!strnicmp(cmd, "on", 2) || !strcmp(cmd, "1")) {
261  mutex_lock(&cp->lock);
262  error = s390_vary_chpid(cp->chpid, 1);
263  mutex_unlock(&cp->lock);
264  } else if (!strnicmp(cmd, "off", 3) || !strcmp(cmd, "0")) {
265  mutex_lock(&cp->lock);
266  error = s390_vary_chpid(cp->chpid, 0);
267  mutex_unlock(&cp->lock);
268  } else
269  error = -EINVAL;
270 
271  return error < 0 ? error : count;
272 }
273 
274 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
275 
276 static ssize_t chp_configure_show(struct device *dev,
277  struct device_attribute *attr, char *buf)
278 {
279  struct channel_path *cp;
280  int status;
281 
282  cp = to_channelpath(dev);
283  status = chp_info_get_status(cp->chpid);
284  if (status < 0)
285  return status;
286 
287  return snprintf(buf, PAGE_SIZE, "%d\n", status);
288 }
289 
290 static int cfg_wait_idle(void);
291 
292 static ssize_t chp_configure_write(struct device *dev,
293  struct device_attribute *attr,
294  const char *buf, size_t count)
295 {
296  struct channel_path *cp;
297  int val;
298  char delim;
299 
300  if (sscanf(buf, "%d %c", &val, &delim) != 1)
301  return -EINVAL;
302  if (val != 0 && val != 1)
303  return -EINVAL;
304  cp = to_channelpath(dev);
305  chp_cfg_schedule(cp->chpid, val);
306  cfg_wait_idle();
307 
308  return count;
309 }
310 
311 static DEVICE_ATTR(configure, 0644, chp_configure_show, chp_configure_write);
312 
313 static ssize_t chp_type_show(struct device *dev, struct device_attribute *attr,
314  char *buf)
315 {
316  struct channel_path *chp = to_channelpath(dev);
317  u8 type;
318 
319  mutex_lock(&chp->lock);
320  type = chp->desc.desc;
321  mutex_unlock(&chp->lock);
322  return sprintf(buf, "%x\n", type);
323 }
324 
325 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
326 
327 static ssize_t chp_cmg_show(struct device *dev, struct device_attribute *attr,
328  char *buf)
329 {
330  struct channel_path *chp = to_channelpath(dev);
331 
332  if (!chp)
333  return 0;
334  if (chp->cmg == -1) /* channel measurements not available */
335  return sprintf(buf, "unknown\n");
336  return sprintf(buf, "%x\n", chp->cmg);
337 }
338 
339 static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
340 
341 static ssize_t chp_shared_show(struct device *dev,
342  struct device_attribute *attr, char *buf)
343 {
344  struct channel_path *chp = to_channelpath(dev);
345 
346  if (!chp)
347  return 0;
348  if (chp->shared == -1) /* channel measurements not available */
349  return sprintf(buf, "unknown\n");
350  return sprintf(buf, "%x\n", chp->shared);
351 }
352 
353 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
354 
355 static struct attribute *chp_attrs[] = {
356  &dev_attr_status.attr,
357  &dev_attr_configure.attr,
358  &dev_attr_type.attr,
359  &dev_attr_cmg.attr,
360  &dev_attr_shared.attr,
361  NULL,
362 };
363 static struct attribute_group chp_attr_group = {
364  .attrs = chp_attrs,
365 };
366 static const struct attribute_group *chp_attr_groups[] = {
367  &chp_attr_group,
368  NULL,
369 };
370 
371 static void chp_release(struct device *dev)
372 {
373  struct channel_path *cp;
374 
375  cp = to_channelpath(dev);
376  kfree(cp);
377 }
378 
386 int chp_new(struct chp_id chpid)
387 {
388  struct channel_path *chp;
389  int ret;
390 
391  if (chp_is_registered(chpid))
392  return 0;
393  chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
394  if (!chp)
395  return -ENOMEM;
396 
397  /* fill in status, etc. */
398  chp->chpid = chpid;
399  chp->state = 1;
400  chp->dev.parent = &channel_subsystems[chpid.cssid]->device;
401  chp->dev.groups = chp_attr_groups;
402  chp->dev.release = chp_release;
403  mutex_init(&chp->lock);
404 
405  /* Obtain channel path description and fill it in. */
406  ret = chsc_determine_base_channel_path_desc(chpid, &chp->desc);
407  if (ret)
408  goto out_free;
409  if ((chp->desc.flags & 0x80) == 0) {
410  ret = -ENODEV;
411  goto out_free;
412  }
413  /* Get channel-measurement characteristics. */
416  if (ret)
417  goto out_free;
418  } else {
419  chp->cmg = -1;
420  }
421  dev_set_name(&chp->dev, "chp%x.%02x", chpid.cssid, chpid.id);
422 
423  /* make it known to the system */
424  ret = device_register(&chp->dev);
425  if (ret) {
426  CIO_MSG_EVENT(0, "Could not register chp%x.%02x: %d\n",
427  chpid.cssid, chpid.id, ret);
428  put_device(&chp->dev);
429  goto out;
430  }
431  mutex_lock(&channel_subsystems[chpid.cssid]->mutex);
432  if (channel_subsystems[chpid.cssid]->cm_enabled) {
433  ret = chp_add_cmg_attr(chp);
434  if (ret) {
435  device_unregister(&chp->dev);
436  mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
437  goto out;
438  }
439  }
440  channel_subsystems[chpid.cssid]->chps[chpid.id] = chp;
441  mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
442  goto out;
443 out_free:
444  kfree(chp);
445 out:
446  return ret;
447 }
448 
456 void *chp_get_chp_desc(struct chp_id chpid)
457 {
458  struct channel_path *chp;
459  struct channel_path_desc *desc;
460 
461  chp = chpid_to_chp(chpid);
462  if (!chp)
463  return NULL;
464  desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
465  if (!desc)
466  return NULL;
467 
468  mutex_lock(&chp->lock);
469  memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
470  mutex_unlock(&chp->lock);
471  return desc;
472 }
473 
483 static void chp_process_crw(struct crw *crw0, struct crw *crw1,
484  int overflow)
485 {
486  struct chp_id chpid;
487 
488  if (overflow) {
490  return;
491  }
492  CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "
493  "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
494  crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
495  crw0->erc, crw0->rsid);
496  /*
497  * Check for solicited machine checks. These are
498  * created by reset channel path and need not be
499  * handled here.
500  */
501  if (crw0->slct) {
502  CIO_CRW_EVENT(2, "solicited machine check for "
503  "channel path %02X\n", crw0->rsid);
504  return;
505  }
506  chp_id_init(&chpid);
507  chpid.id = crw0->rsid;
508  switch (crw0->erc) {
509  case CRW_ERC_IPARM: /* Path has come. */
510  if (!chp_is_registered(chpid))
511  chp_new(chpid);
512  chsc_chp_online(chpid);
513  break;
514  case CRW_ERC_PERRI: /* Path has gone. */
515  case CRW_ERC_PERRN:
516  chsc_chp_offline(chpid);
517  break;
518  default:
519  CIO_CRW_EVENT(2, "Don't know how to handle erc=%x\n",
520  crw0->erc);
521  }
522 }
523 
524 int chp_ssd_get_mask(struct chsc_ssd_info *ssd, struct chp_link *link)
525 {
526  int i;
527  int mask;
528 
529  for (i = 0; i < 8; i++) {
530  mask = 0x80 >> i;
531  if (!(ssd->path_mask & mask))
532  continue;
533  if (!chp_id_is_equal(&ssd->chpid[i], &link->chpid))
534  continue;
535  if ((ssd->fla_valid_mask & mask) &&
536  ((ssd->fla[i] & link->fla_mask) != link->fla))
537  continue;
538  return mask;
539  }
540  return 0;
541 }
543 
544 static inline int info_bit_num(struct chp_id id)
545 {
546  return id.id + id.cssid * (__MAX_CHPID + 1);
547 }
548 
549 /* Force chp_info refresh on next call to info_validate(). */
550 static void info_expire(void)
551 {
552  mutex_lock(&info_lock);
553  chp_info_expires = jiffies - 1;
554  mutex_unlock(&info_lock);
555 }
556 
557 /* Ensure that chp_info is up-to-date. */
558 static int info_update(void)
559 {
560  int rc;
561 
562  mutex_lock(&info_lock);
563  rc = 0;
564  if (time_after(jiffies, chp_info_expires)) {
565  /* Data is too old, update. */
566  rc = sclp_chp_read_info(&chp_info);
567  chp_info_expires = jiffies + CHP_INFO_UPDATE_INTERVAL ;
568  }
569  mutex_unlock(&info_lock);
570 
571  return rc;
572 }
573 
581 int chp_info_get_status(struct chp_id chpid)
582 {
583  int rc;
584  int bit;
585 
586  rc = info_update();
587  if (rc)
588  return rc;
589 
590  bit = info_bit_num(chpid);
591  mutex_lock(&info_lock);
592  if (!chp_test_bit(chp_info.recognized, bit))
594  else if (chp_test_bit(chp_info.configured, bit))
596  else if (chp_test_bit(chp_info.standby, bit))
597  rc = CHP_STATUS_STANDBY;
598  else
599  rc = CHP_STATUS_RESERVED;
600  mutex_unlock(&info_lock);
601 
602  return rc;
603 }
604 
605 /* Return configure task for chpid. */
606 static enum cfg_task_t cfg_get_task(struct chp_id chpid)
607 {
608  return chp_cfg_task[chpid.cssid][chpid.id];
609 }
610 
611 /* Set configure task for chpid. */
612 static void cfg_set_task(struct chp_id chpid, enum cfg_task_t cfg)
613 {
614  chp_cfg_task[chpid.cssid][chpid.id] = cfg;
615 }
616 
617 /* Perform one configure/deconfigure request. Reschedule work function until
618  * last request. */
619 static void cfg_func(struct work_struct *work)
620 {
621  struct chp_id chpid;
622  enum cfg_task_t t;
623  int rc;
624 
625  mutex_lock(&cfg_lock);
626  t = cfg_none;
627  chp_id_for_each(&chpid) {
628  t = cfg_get_task(chpid);
629  if (t != cfg_none) {
630  cfg_set_task(chpid, cfg_none);
631  break;
632  }
633  }
634  mutex_unlock(&cfg_lock);
635 
636  switch (t) {
637  case cfg_configure:
638  rc = sclp_chp_configure(chpid);
639  if (rc)
640  CIO_MSG_EVENT(2, "chp: sclp_chp_configure(%x.%02x)="
641  "%d\n", chpid.cssid, chpid.id, rc);
642  else {
643  info_expire();
644  chsc_chp_online(chpid);
645  }
646  break;
647  case cfg_deconfigure:
648  rc = sclp_chp_deconfigure(chpid);
649  if (rc)
650  CIO_MSG_EVENT(2, "chp: sclp_chp_deconfigure(%x.%02x)="
651  "%d\n", chpid.cssid, chpid.id, rc);
652  else {
653  info_expire();
654  chsc_chp_offline(chpid);
655  }
656  break;
657  case cfg_none:
658  /* Get updated information after last change. */
659  info_update();
660  mutex_lock(&cfg_lock);
661  cfg_busy = 0;
662  mutex_unlock(&cfg_lock);
663  wake_up_interruptible(&cfg_wait_queue);
664  return;
665  }
666  queue_work(chp_wq, &cfg_work);
667 }
668 
676 void chp_cfg_schedule(struct chp_id chpid, int configure)
677 {
678  CIO_MSG_EVENT(2, "chp_cfg_sched%x.%02x=%d\n", chpid.cssid, chpid.id,
679  configure);
680  mutex_lock(&cfg_lock);
681  cfg_set_task(chpid, configure ? cfg_configure : cfg_deconfigure);
682  cfg_busy = 1;
683  mutex_unlock(&cfg_lock);
684  queue_work(chp_wq, &cfg_work);
685 }
686 
695 {
696  CIO_MSG_EVENT(2, "chp_cfg_cancel:%x.%02x\n", chpid.cssid, chpid.id);
697  mutex_lock(&cfg_lock);
698  if (cfg_get_task(chpid) == cfg_deconfigure)
699  cfg_set_task(chpid, cfg_none);
700  mutex_unlock(&cfg_lock);
701 }
702 
703 static int cfg_wait_idle(void)
704 {
705  if (wait_event_interruptible(cfg_wait_queue, !cfg_busy))
706  return -ERESTARTSYS;
707  return 0;
708 }
709 
710 static int __init chp_init(void)
711 {
712  struct chp_id chpid;
713  int ret;
714 
715  ret = crw_register_handler(CRW_RSC_CPATH, chp_process_crw);
716  if (ret)
717  return ret;
718  chp_wq = create_singlethread_workqueue("cio_chp");
719  if (!chp_wq) {
721  return -ENOMEM;
722  }
723  INIT_WORK(&cfg_work, cfg_func);
724  init_waitqueue_head(&cfg_wait_queue);
725  if (info_update())
726  return 0;
727  /* Register available channel-paths. */
728  chp_id_for_each(&chpid) {
730  chp_new(chpid);
731  }
732 
733  return 0;
734 }
735 
736 subsys_initcall(chp_init);