1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
4 * Horst Hummel <Horst.Hummel@de.ibm.com>
5 * Martin Schwidefsky <schwidefsky@de.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
7 * Copyright IBM Corp. 1999, 2009
8 */
9
10 #ifndef DASD_INT_H
11 #define DASD_INT_H
12
13 /* we keep old device allocation scheme; IOW, minors are still in 0..255 */
14 #define DASD_PER_MAJOR (1U << (MINORBITS - DASD_PARTN_BITS))
15 #define DASD_PARTN_MASK ((1 << DASD_PARTN_BITS) - 1)
16
17 /*
18 * States a dasd device can have:
19 * new: the dasd_device structure is allocated.
20 * known: the discipline for the device is identified.
21 * basic: the device can do basic i/o.
22 * unfmt: the device could not be analyzed (format is unknown).
23 * ready: partition detection is done and the device is can do block io.
24 * online: the device accepts requests from the block device queue.
25 *
26 * Things to do for startup state transitions:
27 * new -> known: find discipline for the device and create devfs entries.
28 * known -> basic: request irq line for the device.
29 * basic -> ready: do the initial analysis, e.g. format detection,
30 * do block device setup and detect partitions.
31 * ready -> online: schedule the device tasklet.
32 * Things to do for shutdown state transitions:
33 * online -> ready: just set the new device state.
34 * ready -> basic: flush requests from the block device layer, clear
35 * partition information and reset format information.
36 * basic -> known: terminate all requests and free irq.
37 * known -> new: remove devfs entries and forget discipline.
38 */
39
40 #define DASD_STATE_NEW 0
41 #define DASD_STATE_KNOWN 1
42 #define DASD_STATE_BASIC 2
43 #define DASD_STATE_UNFMT 3
44 #define DASD_STATE_READY 4
45 #define DASD_STATE_ONLINE 5
46
47 #include <linux/module.h>
48 #include <linux/wait.h>
49 #include <linux/blkdev.h>
50 #include <linux/genhd.h>
51 #include <linux/hdreg.h>
52 #include <linux/interrupt.h>
53 #include <linux/log2.h>
54 #include <asm/ccwdev.h>
55 #include <linux/workqueue.h>
56 #include <asm/debug.h>
57 #include <asm/dasd.h>
58 #include <asm/idals.h>
59 #include <linux/bitops.h>
60 #include <linux/blk-mq.h>
61
62 /* DASD discipline magic */
63 #define DASD_ECKD_MAGIC 0xC5C3D2C4
64 #define DASD_DIAG_MAGIC 0xC4C9C1C7
65 #define DASD_FBA_MAGIC 0xC6C2C140
66
67 /*
68 * SECTION: Type definitions
69 */
70 struct dasd_device;
71 struct dasd_block;
72
73 /* BIT DEFINITIONS FOR SENSE DATA */
74 #define DASD_SENSE_BIT_0 0x80
75 #define DASD_SENSE_BIT_1 0x40
76 #define DASD_SENSE_BIT_2 0x20
77 #define DASD_SENSE_BIT_3 0x10
78
79 /* BIT DEFINITIONS FOR SIM SENSE */
80 #define DASD_SIM_SENSE 0x0F
81 #define DASD_SIM_MSG_TO_OP 0x03
82 #define DASD_SIM_LOG 0x0C
83
84 /* lock class for nested cdev lock */
85 #define CDEV_NESTED_FIRST 1
86 #define CDEV_NESTED_SECOND 2
87
88 /*
89 * SECTION: MACROs for klogd and s390 debug feature (dbf)
90 */
91 #define DBF_DEV_EVENT(d_level, d_device, d_str, d_data...) \
92 do { \
93 debug_sprintf_event(d_device->debug_area, \
94 d_level, \
95 d_str "\n", \
96 d_data); \
97 } while(0)
98
99 #define DBF_EVENT(d_level, d_str, d_data...)\
100 do { \
101 debug_sprintf_event(dasd_debug_area, \
102 d_level,\
103 d_str "\n", \
104 d_data); \
105 } while(0)
106
107 #define DBF_EVENT_DEVID(d_level, d_cdev, d_str, d_data...) \
108 do { \
109 struct ccw_dev_id __dev_id; \
110 ccw_device_get_id(d_cdev, &__dev_id); \
111 debug_sprintf_event(dasd_debug_area, \
112 d_level, \
113 "0.%x.%04x " d_str "\n", \
114 __dev_id.ssid, __dev_id.devno, d_data); \
115 } while (0)
116
117 /* limit size for an errorstring */
118 #define ERRORLENGTH 30
119
120 /* definition of dbf debug levels */
121 #define DBF_EMERG 0 /* system is unusable */
122 #define DBF_ALERT 1 /* action must be taken immediately */
123 #define DBF_CRIT 2 /* critical conditions */
124 #define DBF_ERR 3 /* error conditions */
125 #define DBF_WARNING 4 /* warning conditions */
126 #define DBF_NOTICE 5 /* normal but significant condition */
127 #define DBF_INFO 6 /* informational */
128 #define DBF_DEBUG 6 /* debug-level messages */
129
130 /* messages to be written via klogd and dbf */
131 #define DEV_MESSAGE(d_loglevel,d_device,d_string,d_args...)\
132 do { \
133 printk(d_loglevel PRINTK_HEADER " %s: " d_string "\n", \
134 dev_name(&d_device->cdev->dev), d_args); \
135 DBF_DEV_EVENT(DBF_ALERT, d_device, d_string, d_args); \
136 } while(0)
137
138 #define MESSAGE(d_loglevel,d_string,d_args...)\
139 do { \
140 printk(d_loglevel PRINTK_HEADER " " d_string "\n", d_args); \
141 DBF_EVENT(DBF_ALERT, d_string, d_args); \
142 } while(0)
143
144 /* messages to be written via klogd only */
145 #define DEV_MESSAGE_LOG(d_loglevel,d_device,d_string,d_args...)\
146 do { \
147 printk(d_loglevel PRINTK_HEADER " %s: " d_string "\n", \
148 dev_name(&d_device->cdev->dev), d_args); \
149 } while(0)
150
151 #define MESSAGE_LOG(d_loglevel,d_string,d_args...)\
152 do { \
153 printk(d_loglevel PRINTK_HEADER " " d_string "\n", d_args); \
154 } while(0)
155
156 /* Macro to calculate number of blocks per page */
157 #define BLOCKS_PER_PAGE(blksize) (PAGE_SIZE / blksize)
158
159 struct dasd_ccw_req {
160 unsigned int magic; /* Eye catcher */
161 int intrc; /* internal error, e.g. from start_IO */
162 struct list_head devlist; /* for dasd_device request queue */
163 struct list_head blocklist; /* for dasd_block request queue */
164 struct dasd_block *block; /* the originating block device */
165 struct dasd_device *memdev; /* the device used to allocate this */
166 struct dasd_device *startdev; /* device the request is started on */
167 struct dasd_device *basedev; /* base device if no block->base */
168 void *cpaddr; /* address of ccw or tcw */
169 short retries; /* A retry counter */
170 unsigned char cpmode; /* 0 = cmd mode, 1 = itcw */
171 char status; /* status of this request */
172 char lpm; /* logical path mask */
173 unsigned long flags; /* flags of this request */
174 struct dasd_queue *dq;
175 unsigned long starttime; /* jiffies time of request start */
176 unsigned long expires; /* expiration period in jiffies */
177 void *data; /* pointer to data area */
178 struct irb irb; /* device status in case of an error */
179 struct dasd_ccw_req *refers; /* ERP-chain queueing. */
180 void *function; /* originating ERP action */
181 void *mem_chunk;
182
183 unsigned long buildclk; /* TOD-clock of request generation */
184 unsigned long startclk; /* TOD-clock of request start */
185 unsigned long stopclk; /* TOD-clock of request interrupt */
186 unsigned long endclk; /* TOD-clock of request termination */
187
188 void (*callback)(struct dasd_ccw_req *, void *data);
189 void *callback_data;
190 unsigned int proc_bytes; /* bytes for partial completion */
191 unsigned int trkcount; /* count formatted tracks */
192 };
193
194 /*
195 * dasd_ccw_req -> status can be:
196 */
197 #define DASD_CQR_FILLED 0x00 /* request is ready to be processed */
198 #define DASD_CQR_DONE 0x01 /* request is completed successfully */
199 #define DASD_CQR_NEED_ERP 0x02 /* request needs recovery action */
200 #define DASD_CQR_IN_ERP 0x03 /* request is in recovery */
201 #define DASD_CQR_FAILED 0x04 /* request is finally failed */
202 #define DASD_CQR_TERMINATED 0x05 /* request was stopped by driver */
203
204 #define DASD_CQR_QUEUED 0x80 /* request is queued to be processed */
205 #define DASD_CQR_IN_IO 0x81 /* request is currently in IO */
206 #define DASD_CQR_ERROR 0x82 /* request is completed with error */
207 #define DASD_CQR_CLEAR_PENDING 0x83 /* request is clear pending */
208 #define DASD_CQR_CLEARED 0x84 /* request was cleared */
209 #define DASD_CQR_SUCCESS 0x85 /* request was successful */
210
211 /* default expiration time*/
212 #define DASD_EXPIRES 300
213 #define DASD_EXPIRES_MAX 40000000
214 #define DASD_RETRIES 256
215 #define DASD_RETRIES_MAX 32768
216
217 /* per dasd_ccw_req flags */
218 #define DASD_CQR_FLAGS_USE_ERP 0 /* use ERP for this request */
219 #define DASD_CQR_FLAGS_FAILFAST 1 /* FAILFAST */
220 #define DASD_CQR_VERIFY_PATH 2 /* path verification request */
221 #define DASD_CQR_ALLOW_SLOCK 3 /* Try this request even when lock was
222 * stolen. Should not be combined with
223 * DASD_CQR_FLAGS_USE_ERP
224 */
225 /*
226 * The following flags are used to suppress output of certain errors.
227 */
228 #define DASD_CQR_SUPPRESS_NRF 4 /* Suppress 'No Record Found' error */
229 #define DASD_CQR_SUPPRESS_FP 5 /* Suppress 'File Protected' error*/
230 #define DASD_CQR_SUPPRESS_IL 6 /* Suppress 'Incorrect Length' error */
231 #define DASD_CQR_SUPPRESS_CR 7 /* Suppress 'Command Reject' error */
232
233 #define DASD_REQ_PER_DEV 4
234
235 /* Signature for error recovery functions. */
236 typedef struct dasd_ccw_req *(*dasd_erp_fn_t) (struct dasd_ccw_req *);
237
238 /*
239 * A single CQR can only contain a maximum of 255 CCWs. It is limited by
240 * the locate record and locate record extended count value which can only hold
241 * 1 Byte max.
242 */
243 #define DASD_CQR_MAX_CCW 255
244
245 /*
246 * Unique identifier for dasd device.
247 */
248 #define UA_NOT_CONFIGURED 0x00
249 #define UA_BASE_DEVICE 0x01
250 #define UA_BASE_PAV_ALIAS 0x02
251 #define UA_HYPER_PAV_ALIAS 0x03
252
253 struct dasd_uid {
254 __u8 type;
255 char vendor[4];
256 char serial[15];
257 __u16 ssid;
258 __u8 real_unit_addr;
259 __u8 base_unit_addr;
260 char vduit[33];
261 };
262
263 /*
264 * the struct dasd_discipline is
265 * sth like a table of virtual functions, if you think of dasd_eckd
266 * inheriting dasd...
267 * no, currently we are not planning to reimplement the driver in C++
268 */
269 struct dasd_discipline {
270 struct module *owner;
271 char ebcname[8]; /* a name used for tagging and printks */
272 char name[8]; /* a name used for tagging and printks */
273
274 struct list_head list; /* used for list of disciplines */
275
276 /*
277 * Device recognition functions. check_device is used to verify
278 * the sense data and the information returned by read device
279 * characteristics. It returns 0 if the discipline can be used
280 * for the device in question. uncheck_device is called during
281 * device shutdown to deregister a device from its discipline.
282 */
283 int (*check_device) (struct dasd_device *);
284 void (*uncheck_device) (struct dasd_device *);
285
286 /*
287 * do_analysis is used in the step from device state "basic" to
288 * state "accept". It returns 0 if the device can be made ready,
289 * it returns -EMEDIUMTYPE if the device can't be made ready or
290 * -EAGAIN if do_analysis started a ccw that needs to complete
291 * before the analysis may be repeated.
292 */
293 int (*do_analysis) (struct dasd_block *);
294
295 /*
296 * This function is called, when new paths become available.
297 * Disciplins may use this callback to do necessary setup work,
298 * e.g. verify that new path is compatible with the current
299 * configuration.
300 */
301 int (*pe_handler)(struct dasd_device *, __u8, __u8);
302
303 /*
304 * Last things to do when a device is set online, and first things
305 * when it is set offline.
306 */
307 int (*basic_to_ready) (struct dasd_device *);
308 int (*online_to_ready) (struct dasd_device *);
309 int (*basic_to_known)(struct dasd_device *);
310
311 /*
312 * Initialize block layer request queue.
313 */
314 void (*setup_blk_queue)(struct dasd_block *);
315 /* (struct dasd_device *);
316 * Device operation functions. build_cp creates a ccw chain for
317 * a block device request, start_io starts the request and
318 * term_IO cancels it (e.g. in case of a timeout). format_device
319 * formats the device and check_device_format compares the format of
320 * a device with the expected format_data.
321 * handle_terminated_request allows to examine a cqr and prepare
322 * it for retry.
323 */
324 struct dasd_ccw_req *(*build_cp) (struct dasd_device *,
325 struct dasd_block *,
326 struct request *);
327 int (*start_IO) (struct dasd_ccw_req *);
328 int (*term_IO) (struct dasd_ccw_req *);
329 void (*handle_terminated_request) (struct dasd_ccw_req *);
330 int (*format_device) (struct dasd_device *,
331 struct format_data_t *, int);
332 int (*check_device_format)(struct dasd_device *,
333 struct format_check_t *, int);
334 int (*free_cp) (struct dasd_ccw_req *, struct request *);
335
336 /*
337 * Error recovery functions. examine_error() returns a value that
338 * indicates what to do for an error condition. If examine_error()
339 * returns 'dasd_era_recover' erp_action() is called to create a
340 * special error recovery ccw. erp_postaction() is called after
341 * an error recovery ccw has finished its execution. dump_sense
342 * is called for every error condition to print the sense data
343 * to the console.
344 */
345 dasd_erp_fn_t(*erp_action) (struct dasd_ccw_req *);
346 dasd_erp_fn_t(*erp_postaction) (struct dasd_ccw_req *);
347 void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *,
348 struct irb *);
349 void (*dump_sense_dbf) (struct dasd_device *, struct irb *, char *);
350 void (*check_for_device_change) (struct dasd_device *,
351 struct dasd_ccw_req *,
352 struct irb *);
353
354 /* i/o control functions. */
355 int (*fill_geometry) (struct dasd_block *, struct hd_geometry *);
356 int (*fill_info) (struct dasd_device *, struct dasd_information2_t *);
357 int (*ioctl) (struct dasd_block *, unsigned int, void __user *);
358
359 /* reload device after state change */
360 int (*reload) (struct dasd_device *);
361
362 int (*get_uid) (struct dasd_device *, struct dasd_uid *);
363 void (*kick_validate) (struct dasd_device *);
364 int (*check_attention)(struct dasd_device *, __u8);
365 int (*host_access_count)(struct dasd_device *);
366 int (*hosts_print)(struct dasd_device *, struct seq_file *);
367 void (*handle_hpf_error)(struct dasd_device *, struct irb *);
368 void (*disable_hpf)(struct dasd_device *);
369 int (*hpf_enabled)(struct dasd_device *);
370 void (*reset_path)(struct dasd_device *, __u8);
371
372 /*
373 * Extent Space Efficient (ESE) relevant functions
374 */
375 int (*is_ese)(struct dasd_device *);
376 /* Capacity */
377 int (*space_allocated)(struct dasd_device *);
378 int (*space_configured)(struct dasd_device *);
379 int (*logical_capacity)(struct dasd_device *);
380 int (*release_space)(struct dasd_device *, struct format_data_t *);
381 /* Extent Pool */
382 int (*ext_pool_id)(struct dasd_device *);
383 int (*ext_size)(struct dasd_device *);
384 int (*ext_pool_cap_at_warnlevel)(struct dasd_device *);
385 int (*ext_pool_warn_thrshld)(struct dasd_device *);
386 int (*ext_pool_oos)(struct dasd_device *);
387 int (*ext_pool_exhaust)(struct dasd_device *, struct dasd_ccw_req *);
388 struct dasd_ccw_req *(*ese_format)(struct dasd_device *,
389 struct dasd_ccw_req *, struct irb *);
390 int (*ese_read)(struct dasd_ccw_req *, struct irb *);
391 };
392
393 extern struct dasd_discipline *dasd_diag_discipline_pointer;
394
395 /*
396 * Notification numbers for extended error reporting notifications:
397 * The DASD_EER_DISABLE notification is sent before a dasd_device (and it's
398 * eer pointer) is freed. The error reporting module needs to do all necessary
399 * cleanup steps.
400 * The DASD_EER_TRIGGER notification sends the actual error reports (triggers).
401 */
402 #define DASD_EER_DISABLE 0
403 #define DASD_EER_TRIGGER 1
404
405 /* Trigger IDs for extended error reporting DASD_EER_TRIGGER notification */
406 #define DASD_EER_FATALERROR 1
407 #define DASD_EER_NOPATH 2
408 #define DASD_EER_STATECHANGE 3
409 #define DASD_EER_PPRCSUSPEND 4
410 #define DASD_EER_NOSPC 5
411
412 /* DASD path handling */
413
414 #define DASD_PATH_OPERATIONAL 1
415 #define DASD_PATH_TBV 2
416 #define DASD_PATH_PP 3
417 #define DASD_PATH_NPP 4
418 #define DASD_PATH_MISCABLED 5
419 #define DASD_PATH_NOHPF 6
420 #define DASD_PATH_CUIR 7
421 #define DASD_PATH_IFCC 8
422 #define DASD_PATH_FCSEC 9
423
424 #define DASD_THRHLD_MAX 4294967295U
425 #define DASD_INTERVAL_MAX 4294967295U
426
427 /* FC Endpoint Security Capabilities */
428 #define DASD_FC_SECURITY_UNSUP 0
429 #define DASD_FC_SECURITY_AUTH 1
430 #define DASD_FC_SECURITY_ENC_FCSP2 2
431 #define DASD_FC_SECURITY_ENC_ERAS 3
432
433 #define DASD_FC_SECURITY_ENC_STR "Encryption"
434 static const struct {
435 u8 value;
436 char *name;
437 } dasd_path_fcs_mnemonics[] = {
438 { DASD_FC_SECURITY_UNSUP, "Unsupported" },
439 { DASD_FC_SECURITY_AUTH, "Authentication" },
440 { DASD_FC_SECURITY_ENC_FCSP2, DASD_FC_SECURITY_ENC_STR },
441 { DASD_FC_SECURITY_ENC_ERAS, DASD_FC_SECURITY_ENC_STR },
442 };
443
dasd_path_get_fcs_str(int val)444 static inline char *dasd_path_get_fcs_str(int val)
445 {
446 int i;
447
448 for (i = 0; i < ARRAY_SIZE(dasd_path_fcs_mnemonics); i++) {
449 if (dasd_path_fcs_mnemonics[i].value == val)
450 return dasd_path_fcs_mnemonics[i].name;
451 }
452
453 return dasd_path_fcs_mnemonics[0].name;
454 }
455
456 struct dasd_path {
457 unsigned long flags;
458 u8 cssid;
459 u8 ssid;
460 u8 chpid;
461 struct dasd_conf_data *conf_data;
462 atomic_t error_count;
463 unsigned long errorclk;
464 u8 fc_security;
465 struct kobject kobj;
466 bool in_sysfs;
467 };
468
469 #define to_dasd_path(path) container_of(path, struct dasd_path, kobj)
470
dasd_path_release(struct kobject * kobj)471 static inline void dasd_path_release(struct kobject *kobj)
472 {
473 /* Memory for the dasd_path kobject is freed when dasd_free_device() is called */
474 }
475
476
477 struct dasd_profile_info {
478 /* legacy part of profile data, as in dasd_profile_info_t */
479 unsigned int dasd_io_reqs; /* number of requests processed */
480 unsigned int dasd_io_sects; /* number of sectors processed */
481 unsigned int dasd_io_secs[32]; /* histogram of request's sizes */
482 unsigned int dasd_io_times[32]; /* histogram of requests's times */
483 unsigned int dasd_io_timps[32]; /* h. of requests's times per sector */
484 unsigned int dasd_io_time1[32]; /* hist. of time from build to start */
485 unsigned int dasd_io_time2[32]; /* hist. of time from start to irq */
486 unsigned int dasd_io_time2ps[32]; /* hist. of time from start to irq */
487 unsigned int dasd_io_time3[32]; /* hist. of time from irq to end */
488 unsigned int dasd_io_nr_req[32]; /* hist. of # of requests in chanq */
489
490 /* new data */
491 struct timespec64 starttod; /* time of start or last reset */
492 unsigned int dasd_io_alias; /* requests using an alias */
493 unsigned int dasd_io_tpm; /* requests using transport mode */
494 unsigned int dasd_read_reqs; /* total number of read requests */
495 unsigned int dasd_read_sects; /* total number read sectors */
496 unsigned int dasd_read_alias; /* read request using an alias */
497 unsigned int dasd_read_tpm; /* read requests in transport mode */
498 unsigned int dasd_read_secs[32]; /* histogram of request's sizes */
499 unsigned int dasd_read_times[32]; /* histogram of requests's times */
500 unsigned int dasd_read_time1[32]; /* hist. time from build to start */
501 unsigned int dasd_read_time2[32]; /* hist. of time from start to irq */
502 unsigned int dasd_read_time3[32]; /* hist. of time from irq to end */
503 unsigned int dasd_read_nr_req[32]; /* hist. of # of requests in chanq */
504 unsigned long dasd_sum_times; /* sum of request times */
505 unsigned long dasd_sum_time_str; /* sum of time from build to start */
506 unsigned long dasd_sum_time_irq; /* sum of time from start to irq */
507 unsigned long dasd_sum_time_end; /* sum of time from irq to end */
508 };
509
510 struct dasd_profile {
511 struct dentry *dentry;
512 struct dasd_profile_info *data;
513 spinlock_t lock;
514 };
515
516 struct dasd_format_entry {
517 struct list_head list;
518 sector_t track;
519 };
520
521 struct dasd_device {
522 /* Block device stuff. */
523 struct dasd_block *block;
524
525 unsigned int devindex;
526 unsigned long flags; /* per device flags */
527 unsigned short features; /* copy of devmap-features (read-only!) */
528
529 /* extended error reporting stuff (eer) */
530 struct dasd_ccw_req *eer_cqr;
531
532 /* Device discipline stuff. */
533 struct dasd_discipline *discipline;
534 struct dasd_discipline *base_discipline;
535 void *private;
536 struct dasd_path path[8];
537 __u8 opm;
538
539 /* Device state and target state. */
540 int state, target;
541 struct mutex state_mutex;
542 int stopped; /* device (ccw_device_start) was stopped */
543
544 /* reference count. */
545 atomic_t ref_count;
546
547 /* ccw queue and memory for static ccw/erp buffers. */
548 struct list_head ccw_queue;
549 spinlock_t mem_lock;
550 void *ccw_mem;
551 void *erp_mem;
552 void *ese_mem;
553 struct list_head ccw_chunks;
554 struct list_head erp_chunks;
555 struct list_head ese_chunks;
556
557 atomic_t tasklet_scheduled;
558 struct tasklet_struct tasklet;
559 struct work_struct kick_work;
560 struct work_struct reload_device;
561 struct work_struct kick_validate;
562 struct work_struct suc_work;
563 struct work_struct requeue_requests;
564 struct timer_list timer;
565
566 debug_info_t *debug_area;
567
568 struct ccw_device *cdev;
569
570 /* hook for alias management */
571 struct list_head alias_list;
572
573 /* default expiration time in s */
574 unsigned long default_expires;
575 unsigned long default_retries;
576
577 unsigned long blk_timeout;
578
579 unsigned long path_thrhld;
580 unsigned long path_interval;
581
582 struct dentry *debugfs_dentry;
583 struct dentry *hosts_dentry;
584 struct dasd_profile profile;
585 struct dasd_format_entry format_entry;
586 struct kset *paths_info;
587 };
588
589 struct dasd_block {
590 /* Block device stuff. */
591 struct gendisk *gdp;
592 struct request_queue *request_queue;
593 spinlock_t request_queue_lock;
594 struct blk_mq_tag_set tag_set;
595 struct block_device *bdev;
596 atomic_t open_count;
597
598 unsigned long blocks; /* size of volume in blocks */
599 unsigned int bp_block; /* bytes per block */
600 unsigned int s2b_shift; /* log2 (bp_block/512) */
601
602 struct dasd_device *base;
603 struct list_head ccw_queue;
604 spinlock_t queue_lock;
605
606 atomic_t tasklet_scheduled;
607 struct tasklet_struct tasklet;
608 struct timer_list timer;
609
610 struct dentry *debugfs_dentry;
611 struct dasd_profile profile;
612
613 struct list_head format_list;
614 spinlock_t format_lock;
615 atomic_t trkcount;
616 };
617
618 struct dasd_attention_data {
619 struct dasd_device *device;
620 __u8 lpum;
621 };
622
623 struct dasd_queue {
624 spinlock_t lock;
625 };
626
627 /* reasons why device (ccw_device_start) was stopped */
628 #define DASD_STOPPED_NOT_ACC 1 /* not accessible */
629 #define DASD_STOPPED_QUIESCE 2 /* Quiesced */
630 #define DASD_STOPPED_PENDING 4 /* long busy */
631 #define DASD_STOPPED_DC_WAIT 8 /* disconnected, wait */
632 #define DASD_STOPPED_SU 16 /* summary unit check handling */
633 #define DASD_STOPPED_NOSPC 128 /* no space left */
634
635 /* per device flags */
636 #define DASD_FLAG_OFFLINE 3 /* device is in offline processing */
637 #define DASD_FLAG_EER_SNSS 4 /* A SNSS is required */
638 #define DASD_FLAG_EER_IN_USE 5 /* A SNSS request is running */
639 #define DASD_FLAG_DEVICE_RO 6 /* The device itself is read-only. Don't
640 * confuse this with the user specified
641 * read-only feature.
642 */
643 #define DASD_FLAG_IS_RESERVED 7 /* The device is reserved */
644 #define DASD_FLAG_LOCK_STOLEN 8 /* The device lock was stolen */
645 #define DASD_FLAG_SUSPENDED 9 /* The device was suspended */
646 #define DASD_FLAG_SAFE_OFFLINE 10 /* safe offline processing requested*/
647 #define DASD_FLAG_SAFE_OFFLINE_RUNNING 11 /* safe offline running */
648 #define DASD_FLAG_ABORTALL 12 /* Abort all noretry requests */
649 #define DASD_FLAG_PATH_VERIFY 13 /* Path verification worker running */
650 #define DASD_FLAG_SUC 14 /* unhandled summary unit check */
651
652 #define DASD_SLEEPON_START_TAG ((void *) 1)
653 #define DASD_SLEEPON_END_TAG ((void *) 2)
654
655 void dasd_put_device_wake(struct dasd_device *);
656
657 /*
658 * Reference count inliners
659 */
660 static inline void
dasd_get_device(struct dasd_device * device)661 dasd_get_device(struct dasd_device *device)
662 {
663 atomic_inc(&device->ref_count);
664 }
665
666 static inline void
dasd_put_device(struct dasd_device * device)667 dasd_put_device(struct dasd_device *device)
668 {
669 if (atomic_dec_return(&device->ref_count) == 0)
670 dasd_put_device_wake(device);
671 }
672
673 /*
674 * The static memory in ccw_mem and erp_mem is managed by a sorted
675 * list of free memory chunks.
676 */
677 struct dasd_mchunk
678 {
679 struct list_head list;
680 unsigned long size;
681 } __attribute__ ((aligned(8)));
682
683 static inline void
dasd_init_chunklist(struct list_head * chunk_list,void * mem,unsigned long size)684 dasd_init_chunklist(struct list_head *chunk_list, void *mem,
685 unsigned long size)
686 {
687 struct dasd_mchunk *chunk;
688
689 INIT_LIST_HEAD(chunk_list);
690 chunk = (struct dasd_mchunk *) mem;
691 chunk->size = size - sizeof(struct dasd_mchunk);
692 list_add(&chunk->list, chunk_list);
693 }
694
695 static inline void *
dasd_alloc_chunk(struct list_head * chunk_list,unsigned long size)696 dasd_alloc_chunk(struct list_head *chunk_list, unsigned long size)
697 {
698 struct dasd_mchunk *chunk, *tmp;
699
700 size = (size + 7L) & -8L;
701 list_for_each_entry(chunk, chunk_list, list) {
702 if (chunk->size < size)
703 continue;
704 if (chunk->size > size + sizeof(struct dasd_mchunk)) {
705 char *endaddr = (char *) (chunk + 1) + chunk->size;
706 tmp = (struct dasd_mchunk *) (endaddr - size) - 1;
707 tmp->size = size;
708 chunk->size -= size + sizeof(struct dasd_mchunk);
709 chunk = tmp;
710 } else
711 list_del(&chunk->list);
712 return (void *) (chunk + 1);
713 }
714 return NULL;
715 }
716
717 static inline void
dasd_free_chunk(struct list_head * chunk_list,void * mem)718 dasd_free_chunk(struct list_head *chunk_list, void *mem)
719 {
720 struct dasd_mchunk *chunk, *tmp;
721 struct list_head *p, *left;
722
723 chunk = (struct dasd_mchunk *)
724 ((char *) mem - sizeof(struct dasd_mchunk));
725 /* Find out the left neighbour in chunk_list. */
726 left = chunk_list;
727 list_for_each(p, chunk_list) {
728 if (list_entry(p, struct dasd_mchunk, list) > chunk)
729 break;
730 left = p;
731 }
732 /* Try to merge with right neighbour = next element from left. */
733 if (left->next != chunk_list) {
734 tmp = list_entry(left->next, struct dasd_mchunk, list);
735 if ((char *) (chunk + 1) + chunk->size == (char *) tmp) {
736 list_del(&tmp->list);
737 chunk->size += tmp->size + sizeof(struct dasd_mchunk);
738 }
739 }
740 /* Try to merge with left neighbour. */
741 if (left != chunk_list) {
742 tmp = list_entry(left, struct dasd_mchunk, list);
743 if ((char *) (tmp + 1) + tmp->size == (char *) chunk) {
744 tmp->size += chunk->size + sizeof(struct dasd_mchunk);
745 return;
746 }
747 }
748 __list_add(&chunk->list, left, left->next);
749 }
750
751 /*
752 * Check if bsize is in { 512, 1024, 2048, 4096 }
753 */
754 static inline int
dasd_check_blocksize(int bsize)755 dasd_check_blocksize(int bsize)
756 {
757 if (bsize < 512 || bsize > 4096 || !is_power_of_2(bsize))
758 return -EMEDIUMTYPE;
759 return 0;
760 }
761
762 /*
763 * return the callback data of the original request in case there are
764 * ERP requests build on top of it
765 */
dasd_get_callback_data(struct dasd_ccw_req * cqr)766 static inline void *dasd_get_callback_data(struct dasd_ccw_req *cqr)
767 {
768 while (cqr->refers)
769 cqr = cqr->refers;
770
771 return cqr->callback_data;
772 }
773
774 /* externals in dasd.c */
775 #define DASD_PROFILE_OFF 0
776 #define DASD_PROFILE_ON 1
777 #define DASD_PROFILE_GLOBAL_ONLY 2
778
779 extern debug_info_t *dasd_debug_area;
780 extern struct dasd_profile dasd_global_profile;
781 extern unsigned int dasd_global_profile_level;
782 extern const struct block_device_operations dasd_device_operations;
783
784 extern struct kmem_cache *dasd_page_cache;
785
786 struct dasd_ccw_req *
787 dasd_smalloc_request(int, int, int, struct dasd_device *, struct dasd_ccw_req *);
788 struct dasd_ccw_req *dasd_fmalloc_request(int, int, int, struct dasd_device *);
789 void dasd_sfree_request(struct dasd_ccw_req *, struct dasd_device *);
790 void dasd_ffree_request(struct dasd_ccw_req *, struct dasd_device *);
791 void dasd_wakeup_cb(struct dasd_ccw_req *, void *);
792
793 struct dasd_device *dasd_alloc_device(void);
794 void dasd_free_device(struct dasd_device *);
795
796 struct dasd_block *dasd_alloc_block(void);
797 void dasd_free_block(struct dasd_block *);
798
799 enum blk_eh_timer_return dasd_times_out(struct request *req, bool reserved);
800
801 void dasd_enable_device(struct dasd_device *);
802 void dasd_set_target_state(struct dasd_device *, int);
803 void dasd_kick_device(struct dasd_device *);
804 void dasd_reload_device(struct dasd_device *);
805 void dasd_schedule_requeue(struct dasd_device *);
806
807 void dasd_add_request_head(struct dasd_ccw_req *);
808 void dasd_add_request_tail(struct dasd_ccw_req *);
809 int dasd_start_IO(struct dasd_ccw_req *);
810 int dasd_term_IO(struct dasd_ccw_req *);
811 void dasd_schedule_device_bh(struct dasd_device *);
812 void dasd_schedule_block_bh(struct dasd_block *);
813 int dasd_sleep_on(struct dasd_ccw_req *);
814 int dasd_sleep_on_queue(struct list_head *);
815 int dasd_sleep_on_immediatly(struct dasd_ccw_req *);
816 int dasd_sleep_on_queue_interruptible(struct list_head *);
817 int dasd_sleep_on_interruptible(struct dasd_ccw_req *);
818 void dasd_device_set_timer(struct dasd_device *, int);
819 void dasd_device_clear_timer(struct dasd_device *);
820 void dasd_block_set_timer(struct dasd_block *, int);
821 void dasd_block_clear_timer(struct dasd_block *);
822 int dasd_cancel_req(struct dasd_ccw_req *);
823 int dasd_flush_device_queue(struct dasd_device *);
824 int dasd_generic_probe(struct ccw_device *);
825 void dasd_generic_free_discipline(struct dasd_device *);
826 void dasd_generic_remove (struct ccw_device *cdev);
827 int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
828 int dasd_generic_set_offline (struct ccw_device *cdev);
829 int dasd_generic_notify(struct ccw_device *, int);
830 int dasd_generic_last_path_gone(struct dasd_device *);
831 int dasd_generic_path_operational(struct dasd_device *);
832 void dasd_generic_shutdown(struct ccw_device *);
833
834 void dasd_generic_handle_state_change(struct dasd_device *);
835 enum uc_todo dasd_generic_uc_handler(struct ccw_device *, struct irb *);
836 void dasd_generic_path_event(struct ccw_device *, int *);
837 int dasd_generic_verify_path(struct dasd_device *, __u8);
838 void dasd_generic_space_exhaust(struct dasd_device *, struct dasd_ccw_req *);
839 void dasd_generic_space_avail(struct dasd_device *);
840
841 int dasd_generic_read_dev_chars(struct dasd_device *, int, void *, int);
842 char *dasd_get_sense(struct irb *);
843
844 void dasd_device_set_stop_bits(struct dasd_device *, int);
845 void dasd_device_remove_stop_bits(struct dasd_device *, int);
846
847 int dasd_device_is_ro(struct dasd_device *);
848
849 void dasd_profile_reset(struct dasd_profile *);
850 int dasd_profile_on(struct dasd_profile *);
851 void dasd_profile_off(struct dasd_profile *);
852 char *dasd_get_user_string(const char __user *, size_t);
853
854 /* externals in dasd_devmap.c */
855 extern int dasd_max_devindex;
856 extern int dasd_probeonly;
857 extern int dasd_autodetect;
858 extern int dasd_nopav;
859 extern int dasd_nofcx;
860
861 int dasd_devmap_init(void);
862 void dasd_devmap_exit(void);
863
864 struct dasd_device *dasd_create_device(struct ccw_device *);
865 void dasd_delete_device(struct dasd_device *);
866
867 int dasd_get_feature(struct ccw_device *, int);
868 int dasd_set_feature(struct ccw_device *, int, int);
869
870 extern const struct attribute_group *dasd_dev_groups[];
871 void dasd_path_create_kobj(struct dasd_device *, int);
872 void dasd_path_create_kobjects(struct dasd_device *);
873 void dasd_path_remove_kobjects(struct dasd_device *);
874
875 struct dasd_device *dasd_device_from_cdev(struct ccw_device *);
876 struct dasd_device *dasd_device_from_cdev_locked(struct ccw_device *);
877 struct dasd_device *dasd_device_from_devindex(int);
878
879 void dasd_add_link_to_gendisk(struct gendisk *, struct dasd_device *);
880 struct dasd_device *dasd_device_from_gendisk(struct gendisk *);
881
882 int dasd_parse(void) __init;
883 int dasd_busid_known(const char *);
884
885 /* externals in dasd_gendisk.c */
886 int dasd_gendisk_init(void);
887 void dasd_gendisk_exit(void);
888 int dasd_gendisk_alloc(struct dasd_block *);
889 void dasd_gendisk_free(struct dasd_block *);
890 int dasd_scan_partitions(struct dasd_block *);
891 void dasd_destroy_partitions(struct dasd_block *);
892
893 /* externals in dasd_ioctl.c */
894 int dasd_ioctl(struct block_device *, fmode_t, unsigned int, unsigned long);
895 int dasd_set_read_only(struct block_device *bdev, bool ro);
896
897 /* externals in dasd_proc.c */
898 int dasd_proc_init(void);
899 void dasd_proc_exit(void);
900
901 /* externals in dasd_erp.c */
902 struct dasd_ccw_req *dasd_default_erp_action(struct dasd_ccw_req *);
903 struct dasd_ccw_req *dasd_default_erp_postaction(struct dasd_ccw_req *);
904 struct dasd_ccw_req *dasd_alloc_erp_request(char *, int, int,
905 struct dasd_device *);
906 void dasd_free_erp_request(struct dasd_ccw_req *, struct dasd_device *);
907 void dasd_log_sense(struct dasd_ccw_req *, struct irb *);
908 void dasd_log_sense_dbf(struct dasd_ccw_req *cqr, struct irb *irb);
909
910 /* externals in dasd_3990_erp.c */
911 struct dasd_ccw_req *dasd_3990_erp_action(struct dasd_ccw_req *);
912 void dasd_3990_erp_handle_sim(struct dasd_device *, char *);
913
914 /* externals in dasd_eer.c */
915 #ifdef CONFIG_DASD_EER
916 int dasd_eer_init(void);
917 void dasd_eer_exit(void);
918 int dasd_eer_enable(struct dasd_device *);
919 void dasd_eer_disable(struct dasd_device *);
920 void dasd_eer_write(struct dasd_device *, struct dasd_ccw_req *cqr,
921 unsigned int id);
922 void dasd_eer_snss(struct dasd_device *);
923
dasd_eer_enabled(struct dasd_device * device)924 static inline int dasd_eer_enabled(struct dasd_device *device)
925 {
926 return device->eer_cqr != NULL;
927 }
928 #else
929 #define dasd_eer_init() (0)
930 #define dasd_eer_exit() do { } while (0)
931 #define dasd_eer_enable(d) (0)
932 #define dasd_eer_disable(d) do { } while (0)
933 #define dasd_eer_write(d,c,i) do { } while (0)
934 #define dasd_eer_snss(d) do { } while (0)
935 #define dasd_eer_enabled(d) (0)
936 #endif /* CONFIG_DASD_ERR */
937
938
939 /* DASD path handling functions */
940
941 /*
942 * helper functions to modify bit masks for a given channel path for a device
943 */
dasd_path_is_operational(struct dasd_device * device,int chp)944 static inline int dasd_path_is_operational(struct dasd_device *device, int chp)
945 {
946 return test_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
947 }
948
dasd_path_need_verify(struct dasd_device * device,int chp)949 static inline int dasd_path_need_verify(struct dasd_device *device, int chp)
950 {
951 return test_bit(DASD_PATH_TBV, &device->path[chp].flags);
952 }
953
dasd_path_verify(struct dasd_device * device,int chp)954 static inline void dasd_path_verify(struct dasd_device *device, int chp)
955 {
956 __set_bit(DASD_PATH_TBV, &device->path[chp].flags);
957 }
958
dasd_path_clear_verify(struct dasd_device * device,int chp)959 static inline void dasd_path_clear_verify(struct dasd_device *device, int chp)
960 {
961 __clear_bit(DASD_PATH_TBV, &device->path[chp].flags);
962 }
963
dasd_path_clear_all_verify(struct dasd_device * device)964 static inline void dasd_path_clear_all_verify(struct dasd_device *device)
965 {
966 int chp;
967
968 for (chp = 0; chp < 8; chp++)
969 dasd_path_clear_verify(device, chp);
970 }
971
dasd_path_fcsec(struct dasd_device * device,int chp)972 static inline void dasd_path_fcsec(struct dasd_device *device, int chp)
973 {
974 __set_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
975 }
976
dasd_path_clear_fcsec(struct dasd_device * device,int chp)977 static inline void dasd_path_clear_fcsec(struct dasd_device *device, int chp)
978 {
979 __clear_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
980 }
981
dasd_path_need_fcsec(struct dasd_device * device,int chp)982 static inline int dasd_path_need_fcsec(struct dasd_device *device, int chp)
983 {
984 return test_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
985 }
986
dasd_path_clear_all_fcsec(struct dasd_device * device)987 static inline void dasd_path_clear_all_fcsec(struct dasd_device *device)
988 {
989 int chp;
990
991 for (chp = 0; chp < 8; chp++)
992 dasd_path_clear_fcsec(device, chp);
993 }
994
dasd_path_operational(struct dasd_device * device,int chp)995 static inline void dasd_path_operational(struct dasd_device *device, int chp)
996 {
997 __set_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
998 device->opm |= (0x80 >> chp);
999 }
1000
dasd_path_nonpreferred(struct dasd_device * device,int chp)1001 static inline void dasd_path_nonpreferred(struct dasd_device *device, int chp)
1002 {
1003 __set_bit(DASD_PATH_NPP, &device->path[chp].flags);
1004 }
1005
dasd_path_is_nonpreferred(struct dasd_device * device,int chp)1006 static inline int dasd_path_is_nonpreferred(struct dasd_device *device, int chp)
1007 {
1008 return test_bit(DASD_PATH_NPP, &device->path[chp].flags);
1009 }
1010
dasd_path_clear_nonpreferred(struct dasd_device * device,int chp)1011 static inline void dasd_path_clear_nonpreferred(struct dasd_device *device,
1012 int chp)
1013 {
1014 __clear_bit(DASD_PATH_NPP, &device->path[chp].flags);
1015 }
1016
dasd_path_preferred(struct dasd_device * device,int chp)1017 static inline void dasd_path_preferred(struct dasd_device *device, int chp)
1018 {
1019 __set_bit(DASD_PATH_PP, &device->path[chp].flags);
1020 }
1021
dasd_path_is_preferred(struct dasd_device * device,int chp)1022 static inline int dasd_path_is_preferred(struct dasd_device *device, int chp)
1023 {
1024 return test_bit(DASD_PATH_PP, &device->path[chp].flags);
1025 }
1026
dasd_path_clear_preferred(struct dasd_device * device,int chp)1027 static inline void dasd_path_clear_preferred(struct dasd_device *device,
1028 int chp)
1029 {
1030 __clear_bit(DASD_PATH_PP, &device->path[chp].flags);
1031 }
1032
dasd_path_clear_oper(struct dasd_device * device,int chp)1033 static inline void dasd_path_clear_oper(struct dasd_device *device, int chp)
1034 {
1035 __clear_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
1036 device->opm &= ~(0x80 >> chp);
1037 }
1038
dasd_path_clear_cable(struct dasd_device * device,int chp)1039 static inline void dasd_path_clear_cable(struct dasd_device *device, int chp)
1040 {
1041 __clear_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1042 }
1043
dasd_path_cuir(struct dasd_device * device,int chp)1044 static inline void dasd_path_cuir(struct dasd_device *device, int chp)
1045 {
1046 __set_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1047 }
1048
dasd_path_is_cuir(struct dasd_device * device,int chp)1049 static inline int dasd_path_is_cuir(struct dasd_device *device, int chp)
1050 {
1051 return test_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1052 }
1053
dasd_path_clear_cuir(struct dasd_device * device,int chp)1054 static inline void dasd_path_clear_cuir(struct dasd_device *device, int chp)
1055 {
1056 __clear_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1057 }
1058
dasd_path_ifcc(struct dasd_device * device,int chp)1059 static inline void dasd_path_ifcc(struct dasd_device *device, int chp)
1060 {
1061 set_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1062 }
1063
dasd_path_is_ifcc(struct dasd_device * device,int chp)1064 static inline int dasd_path_is_ifcc(struct dasd_device *device, int chp)
1065 {
1066 return test_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1067 }
1068
dasd_path_clear_ifcc(struct dasd_device * device,int chp)1069 static inline void dasd_path_clear_ifcc(struct dasd_device *device, int chp)
1070 {
1071 clear_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1072 }
1073
dasd_path_clear_nohpf(struct dasd_device * device,int chp)1074 static inline void dasd_path_clear_nohpf(struct dasd_device *device, int chp)
1075 {
1076 __clear_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1077 }
1078
dasd_path_miscabled(struct dasd_device * device,int chp)1079 static inline void dasd_path_miscabled(struct dasd_device *device, int chp)
1080 {
1081 __set_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1082 }
1083
dasd_path_is_miscabled(struct dasd_device * device,int chp)1084 static inline int dasd_path_is_miscabled(struct dasd_device *device, int chp)
1085 {
1086 return test_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1087 }
1088
dasd_path_nohpf(struct dasd_device * device,int chp)1089 static inline void dasd_path_nohpf(struct dasd_device *device, int chp)
1090 {
1091 __set_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1092 }
1093
dasd_path_is_nohpf(struct dasd_device * device,int chp)1094 static inline int dasd_path_is_nohpf(struct dasd_device *device, int chp)
1095 {
1096 return test_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1097 }
1098
1099 /*
1100 * get functions for path masks
1101 * will return a path masks for the given device
1102 */
1103
dasd_path_get_opm(struct dasd_device * device)1104 static inline __u8 dasd_path_get_opm(struct dasd_device *device)
1105 {
1106 return device->opm;
1107 }
1108
dasd_path_get_tbvpm(struct dasd_device * device)1109 static inline __u8 dasd_path_get_tbvpm(struct dasd_device *device)
1110 {
1111 int chp;
1112 __u8 tbvpm = 0x00;
1113
1114 for (chp = 0; chp < 8; chp++)
1115 if (dasd_path_need_verify(device, chp))
1116 tbvpm |= 0x80 >> chp;
1117 return tbvpm;
1118 }
1119
dasd_path_get_fcsecpm(struct dasd_device * device)1120 static inline int dasd_path_get_fcsecpm(struct dasd_device *device)
1121 {
1122 int chp;
1123
1124 for (chp = 0; chp < 8; chp++)
1125 if (dasd_path_need_fcsec(device, chp))
1126 return 1;
1127
1128 return 0;
1129 }
1130
dasd_path_get_nppm(struct dasd_device * device)1131 static inline __u8 dasd_path_get_nppm(struct dasd_device *device)
1132 {
1133 int chp;
1134 __u8 npm = 0x00;
1135
1136 for (chp = 0; chp < 8; chp++) {
1137 if (dasd_path_is_nonpreferred(device, chp))
1138 npm |= 0x80 >> chp;
1139 }
1140 return npm;
1141 }
1142
dasd_path_get_ppm(struct dasd_device * device)1143 static inline __u8 dasd_path_get_ppm(struct dasd_device *device)
1144 {
1145 int chp;
1146 __u8 ppm = 0x00;
1147
1148 for (chp = 0; chp < 8; chp++)
1149 if (dasd_path_is_preferred(device, chp))
1150 ppm |= 0x80 >> chp;
1151 return ppm;
1152 }
1153
dasd_path_get_cablepm(struct dasd_device * device)1154 static inline __u8 dasd_path_get_cablepm(struct dasd_device *device)
1155 {
1156 int chp;
1157 __u8 cablepm = 0x00;
1158
1159 for (chp = 0; chp < 8; chp++)
1160 if (dasd_path_is_miscabled(device, chp))
1161 cablepm |= 0x80 >> chp;
1162 return cablepm;
1163 }
1164
dasd_path_get_cuirpm(struct dasd_device * device)1165 static inline __u8 dasd_path_get_cuirpm(struct dasd_device *device)
1166 {
1167 int chp;
1168 __u8 cuirpm = 0x00;
1169
1170 for (chp = 0; chp < 8; chp++)
1171 if (dasd_path_is_cuir(device, chp))
1172 cuirpm |= 0x80 >> chp;
1173 return cuirpm;
1174 }
1175
dasd_path_get_ifccpm(struct dasd_device * device)1176 static inline __u8 dasd_path_get_ifccpm(struct dasd_device *device)
1177 {
1178 int chp;
1179 __u8 ifccpm = 0x00;
1180
1181 for (chp = 0; chp < 8; chp++)
1182 if (dasd_path_is_ifcc(device, chp))
1183 ifccpm |= 0x80 >> chp;
1184 return ifccpm;
1185 }
1186
dasd_path_get_hpfpm(struct dasd_device * device)1187 static inline __u8 dasd_path_get_hpfpm(struct dasd_device *device)
1188 {
1189 int chp;
1190 __u8 hpfpm = 0x00;
1191
1192 for (chp = 0; chp < 8; chp++)
1193 if (dasd_path_is_nohpf(device, chp))
1194 hpfpm |= 0x80 >> chp;
1195 return hpfpm;
1196 }
1197
dasd_path_get_fcs_path(struct dasd_device * device,int chp)1198 static inline u8 dasd_path_get_fcs_path(struct dasd_device *device, int chp)
1199 {
1200 return device->path[chp].fc_security;
1201 }
1202
dasd_path_get_fcs_device(struct dasd_device * device)1203 static inline int dasd_path_get_fcs_device(struct dasd_device *device)
1204 {
1205 u8 fc_sec = 0;
1206 int chp;
1207
1208 for (chp = 0; chp < 8; chp++) {
1209 if (device->opm & (0x80 >> chp)) {
1210 fc_sec = device->path[chp].fc_security;
1211 break;
1212 }
1213 }
1214 for (; chp < 8; chp++) {
1215 if (device->opm & (0x80 >> chp))
1216 if (device->path[chp].fc_security != fc_sec)
1217 return -EINVAL;
1218 }
1219
1220 return fc_sec;
1221 }
1222
1223 /*
1224 * add functions for path masks
1225 * the existing path mask will be extended by the given path mask
1226 */
dasd_path_add_tbvpm(struct dasd_device * device,__u8 pm)1227 static inline void dasd_path_add_tbvpm(struct dasd_device *device, __u8 pm)
1228 {
1229 int chp;
1230
1231 for (chp = 0; chp < 8; chp++)
1232 if (pm & (0x80 >> chp))
1233 dasd_path_verify(device, chp);
1234 }
1235
dasd_path_get_notoperpm(struct dasd_device * device)1236 static inline __u8 dasd_path_get_notoperpm(struct dasd_device *device)
1237 {
1238 int chp;
1239 __u8 nopm = 0x00;
1240
1241 for (chp = 0; chp < 8; chp++)
1242 if (dasd_path_is_nohpf(device, chp) ||
1243 dasd_path_is_ifcc(device, chp) ||
1244 dasd_path_is_cuir(device, chp) ||
1245 dasd_path_is_miscabled(device, chp))
1246 nopm |= 0x80 >> chp;
1247 return nopm;
1248 }
1249
dasd_path_add_opm(struct dasd_device * device,__u8 pm)1250 static inline void dasd_path_add_opm(struct dasd_device *device, __u8 pm)
1251 {
1252 int chp;
1253
1254 for (chp = 0; chp < 8; chp++)
1255 if (pm & (0x80 >> chp)) {
1256 dasd_path_operational(device, chp);
1257 /*
1258 * if the path is used
1259 * it should not be in one of the negative lists
1260 */
1261 dasd_path_clear_nohpf(device, chp);
1262 dasd_path_clear_cuir(device, chp);
1263 dasd_path_clear_cable(device, chp);
1264 dasd_path_clear_ifcc(device, chp);
1265 }
1266 }
1267
dasd_path_add_cablepm(struct dasd_device * device,__u8 pm)1268 static inline void dasd_path_add_cablepm(struct dasd_device *device, __u8 pm)
1269 {
1270 int chp;
1271
1272 for (chp = 0; chp < 8; chp++)
1273 if (pm & (0x80 >> chp))
1274 dasd_path_miscabled(device, chp);
1275 }
1276
dasd_path_add_cuirpm(struct dasd_device * device,__u8 pm)1277 static inline void dasd_path_add_cuirpm(struct dasd_device *device, __u8 pm)
1278 {
1279 int chp;
1280
1281 for (chp = 0; chp < 8; chp++)
1282 if (pm & (0x80 >> chp))
1283 dasd_path_cuir(device, chp);
1284 }
1285
dasd_path_add_ifccpm(struct dasd_device * device,__u8 pm)1286 static inline void dasd_path_add_ifccpm(struct dasd_device *device, __u8 pm)
1287 {
1288 int chp;
1289
1290 for (chp = 0; chp < 8; chp++)
1291 if (pm & (0x80 >> chp))
1292 dasd_path_ifcc(device, chp);
1293 }
1294
dasd_path_add_nppm(struct dasd_device * device,__u8 pm)1295 static inline void dasd_path_add_nppm(struct dasd_device *device, __u8 pm)
1296 {
1297 int chp;
1298
1299 for (chp = 0; chp < 8; chp++)
1300 if (pm & (0x80 >> chp))
1301 dasd_path_nonpreferred(device, chp);
1302 }
1303
dasd_path_add_nohpfpm(struct dasd_device * device,__u8 pm)1304 static inline void dasd_path_add_nohpfpm(struct dasd_device *device, __u8 pm)
1305 {
1306 int chp;
1307
1308 for (chp = 0; chp < 8; chp++)
1309 if (pm & (0x80 >> chp))
1310 dasd_path_nohpf(device, chp);
1311 }
1312
dasd_path_add_ppm(struct dasd_device * device,__u8 pm)1313 static inline void dasd_path_add_ppm(struct dasd_device *device, __u8 pm)
1314 {
1315 int chp;
1316
1317 for (chp = 0; chp < 8; chp++)
1318 if (pm & (0x80 >> chp))
1319 dasd_path_preferred(device, chp);
1320 }
1321
1322 /*
1323 * set functions for path masks
1324 * the existing path mask will be replaced by the given path mask
1325 */
dasd_path_set_tbvpm(struct dasd_device * device,__u8 pm)1326 static inline void dasd_path_set_tbvpm(struct dasd_device *device, __u8 pm)
1327 {
1328 int chp;
1329
1330 for (chp = 0; chp < 8; chp++)
1331 if (pm & (0x80 >> chp))
1332 dasd_path_verify(device, chp);
1333 else
1334 dasd_path_clear_verify(device, chp);
1335 }
1336
dasd_path_set_opm(struct dasd_device * device,__u8 pm)1337 static inline void dasd_path_set_opm(struct dasd_device *device, __u8 pm)
1338 {
1339 int chp;
1340
1341 for (chp = 0; chp < 8; chp++) {
1342 dasd_path_clear_oper(device, chp);
1343 if (pm & (0x80 >> chp)) {
1344 dasd_path_operational(device, chp);
1345 /*
1346 * if the path is used
1347 * it should not be in one of the negative lists
1348 */
1349 dasd_path_clear_nohpf(device, chp);
1350 dasd_path_clear_cuir(device, chp);
1351 dasd_path_clear_cable(device, chp);
1352 dasd_path_clear_ifcc(device, chp);
1353 }
1354 }
1355 }
1356
1357 /*
1358 * remove functions for path masks
1359 * the existing path mask will be cleared with the given path mask
1360 */
dasd_path_remove_opm(struct dasd_device * device,__u8 pm)1361 static inline void dasd_path_remove_opm(struct dasd_device *device, __u8 pm)
1362 {
1363 int chp;
1364
1365 for (chp = 0; chp < 8; chp++) {
1366 if (pm & (0x80 >> chp))
1367 dasd_path_clear_oper(device, chp);
1368 }
1369 }
1370
1371 /*
1372 * add the newly available path to the to be verified pm and remove it from
1373 * normal operation until it is verified
1374 */
dasd_path_available(struct dasd_device * device,int chp)1375 static inline void dasd_path_available(struct dasd_device *device, int chp)
1376 {
1377 dasd_path_clear_oper(device, chp);
1378 dasd_path_verify(device, chp);
1379 }
1380
dasd_path_notoper(struct dasd_device * device,int chp)1381 static inline void dasd_path_notoper(struct dasd_device *device, int chp)
1382 {
1383 dasd_path_clear_oper(device, chp);
1384 dasd_path_clear_preferred(device, chp);
1385 dasd_path_clear_nonpreferred(device, chp);
1386 }
1387
dasd_path_fcsec_update(struct dasd_device * device,int chp)1388 static inline void dasd_path_fcsec_update(struct dasd_device *device, int chp)
1389 {
1390 dasd_path_fcsec(device, chp);
1391 }
1392
1393 /*
1394 * remove all paths from normal operation
1395 */
dasd_path_no_path(struct dasd_device * device)1396 static inline void dasd_path_no_path(struct dasd_device *device)
1397 {
1398 int chp;
1399
1400 for (chp = 0; chp < 8; chp++)
1401 dasd_path_notoper(device, chp);
1402
1403 dasd_path_clear_all_verify(device);
1404 }
1405
1406 /* end - path handling */
1407
1408 #endif /* DASD_H */
1409