include/sys/cpr.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_CPR_H
  27 #define _SYS_CPR_H
  28
  29 #ifdef  __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #include <sys/obpdefs.h>
  34 #include <sys/param.h>
  35 #include <sys/mutex.h>
  36 #include <sys/uadmin.h>
  37 #include <sys/compress.h>
  38 #include <sys/archsystm.h>
  39
  40 /*
  41  * definitions for kernel, cprboot, pmconfig
  42  */
  43 #define CPR_VERSION             6
  44 #define CPR_CONFIG              "/etc/.cpr_config"
  45
  46
  47 /*
  48  * magic numbers for cpr files
  49  */
  50 #define CPR_CONFIG_MAGIC        0x436E4667      /* 'CnFg' */
  51 #define CPR_DEFAULT_MAGIC       0x44664C74      /* 'DfLt' */
  52
  53 /*
  54  * max(strlen("true"), strlen("false")) + 1
  55  */
  56 #define PROP_BOOL_LEN           6
  57 #define PROP_MOD                'Y'
  58 #define PROP_NOMOD              'N'
  59
  60 /*
  61  * max property name length used
  62  * max property count
  63  */
  64 #define CPR_MAXPLEN             15
  65 #define CPR_MAXPROP             5
  66
  67 /*
  68  * name/value of nvram properties
  69  */
  70 struct cpr_prop_info {
  71         char    mod;
  72         char    name[CPR_MAXPLEN];
  73         char    value[OBP_MAXPATHLEN];
  74 };
  75 typedef struct cpr_prop_info cprop_t;
  76
  77 struct cpr_default_mini {
  78         int     magic;                          /* magic word for booter */
  79         int     reusable;                       /* true if resuable statefile */
  80 };
  81 typedef struct cpr_default_mini cmini_t;
  82
  83 struct cpr_default_info {
  84         cmini_t mini;
  85         cprop_t props[CPR_MAXPROP];             /* nvram property info */
  86 };
  87 typedef struct cpr_default_info cdef_t;
  88
  89
  90 /*
  91  * Configuration info provided by user via pmconfig.
  92  *
  93  * The first part (cf_type, cf_path, cf_fs, cf_devfs, cf_dev_prom)
  94  * is used by both the cpr kernel module and cpr booter program
  95  * to locate the statefile.
  96  *
  97  * cf_type      CFT_UFS
  98  * cf_path      (path within file system) ".CPR"
  99  * cf_fs        (mount point for the statefile's filesystem) "/export/home"
 100  * cf_devfs     (devfs path of disk parition mounted there) "/dev/dsk/c0t0d0s7"
 101  * cf_dev_prom  (prom device path of the above disk partition)
 102  *                      "/sbus/espdma/dma/sd@0:h"
 103  *
 104  * If the statefile were on a character special device (/dev//rdsk/c0t1d0s7),
 105  * the fields would have the typical values shown below:
 106  *
 107  * cf_type      CFT_SPEC
 108  * cf_path      ignored
 109  * cf_fs        ignored
 110  * cf_devfs     /dev/rdsk/c1t0d0s7
 111  * cf_dev_prom  (prom device path of the above special file)
 112  *                      "/sbus/espdma/dma/sd@1:h"
 113  *
 114  * If the statefile is on a zvol, the fields would have these values:
 115  *
 116  * cf_type      CFT_ZVOL
 117  * cf_path      ignored
 118  * cf_fs        (the zvol name e.g. "dump" portion of rootpool/dump)
 119  * cf_devfs     (devfs path) "/dev/zvol/dsk/<pool>/<zvol>"
 120  * cf_dev_prom  (prom device path of the above special file)
 121  *              e.g. "/sbus/espdma/dma/sd@1:h"
 122  *
 123  * The rest of the fields are autoshutdown and autopm configuration related.
 124  * They are updated by pmconfig and consumed by both powerd and dtpower.
 125  */
 126
 127 struct cprconfig {
 128         int     cf_magic;                       /* magic word for       */
 129                                                 /* booter to verify     */
 130         int     cf_type;                        /* CFT_UFS or CFT_SPEC  */
 131         char    cf_path[MAXNAMELEN];            /* fs-relative path     */
 132                                                 /* for the state file   */
 133         char    cf_fs[MAXNAMELEN];              /* mount point for fs   */
 134                                                 /* holding state file   */
 135         char    cf_devfs[MAXNAMELEN];           /* path to device node  */
 136                                                 /* for above mount pt.  */
 137         char    cf_dev_prom[OBP_MAXPATHLEN];    /* full device path of  */
 138                                                 /* above filesystem     */
 139         /*
 140          * autoshutdown configuration fields
 141          */
 142         int     is_cpr_capable;                 /* 0 - False, 1 - True */
 143         int     is_cpr_default;                 /* 0 - False, 1 - True */
 144         int     is_autowakeup_capable;          /* 0 - False, 1 - True */
 145         int     as_idle;                        /* idle time in min */
 146         int     as_sh;                          /* Start_time hour */
 147         int     as_sm;                          /* Start_time minutes */
 148         int     as_fh;                          /* Finish_time hour */
 149         int     as_fm;                          /* Finish_time minute */
 150         char    as_behavior[64];                /* "default","unconfigured", */
 151                                                 /* "shutdown", "autowakeup" */
 152                                                 /*  or "noshutdown" */
 153         int     ttychars_thold;                 /* default = 0 */
 154         float   loadaverage_thold;              /* default = 0.04  */
 155         int     diskreads_thold;                /* default = 0 */
 156         int     nfsreqs_thold;                  /* default = 0 */
 157         char    idlecheck_path[MAXPATHLEN];     /* default = "" */
 158
 159         /*
 160          * autopm behavior field
 161          */
 162         int     is_autopm_default;              /* 0 - False, 1 - True */
 163         char    apm_behavior[64];               /* "enable","disable" or */
 164                                                 /* "default" */
 165 };
 166
 167
 168 /*
 169  * values for cf_type
 170  */
 171 #define CFT_UFS         1               /* statefile is ufs file        */
 172 #define CFT_SPEC        2               /* statefile is special file    */
 173 #define CFT_ZVOL        3               /* statefile is a zvol          */
 174
 175
 176 /*
 177  * definitions for kernel, cprboot
 178  */
 179 #ifdef _KERNEL
 180
 181 #include <sys/promif.h>
 182 #include <sys/sunddi.h>
 183 #include <sys/sysmacros.h>
 184 #include <sys/vnode.h>
 185 #include <sys/cpr_impl.h>
 186
 187 extern int      cpr_debug;
 188
 189 #define errp    prom_printf
 190 #define DPRINT
 191
 192 /*
 193  * CPR_DEBUG1 displays the main flow of CPR. Use it to identify which
 194  * sub-module of CPR causes problems.
 195  * CPR_DEBUG2 displays minor stuff that normally won't matter.
 196  * CPR_DEBUG3 displays some big loops (cpr_dump); requires much longer runtime.
 197  * CPR_DEBUG4 displays lots of cprboot output, cpr_read and page handling.
 198  * CPR_DEBUG5 various, mostly unique stuff
 199  * CPR_DEBUG9 displays statistical data for CPR on console (by using printf),
 200  *      such as num page invalidated, etc.
 201  */
 202 #define CPR_DEBUG1      0x1
 203 #define CPR_DEBUG2      0x2
 204 #define CPR_DEBUG3      0x4
 205 #define CPR_DEBUG4      0x8
 206 #define CPR_DEBUG5      0x10
 207 #define CPR_DEBUG6      0x20
 208 #define CPR_DEBUG7      0x40
 209 #define CPR_DEBUG8      0x80
 210 #define CPR_DEBUG9      CPR_DEBUG6
 211
 212 #define CPR_DEBUG(level, ...) if (cpr_debug & level) cpr_dprintf(__VA_ARGS__)
 213
 214 #define CPR_DEBUG_BIT(dval)     (1 << (dval - AD_CPR_DEBUG0 - 1))
 215 #define DBG_DONTSHOWRANGE       0
 216 #define DBG_SHOWRANGE           1
 217
 218 /*
 219  * CPR FILE FORMAT:
 220  *
 221  *      Dump Header: general dump data:
 222  *              cpr_dump_desc
 223  *
 224  *      Machdep descriptor: cpr_machdep_desc
 225  *      Machdep data: sun4m/sun4u machine dependent info:
 226  *              cpr_sun4m_machdep
 227  *              cpr_sun4u_machdep, var length prom words
 228  *
 229  *      Page Map: bitmap record consisting of a descriptor and data:
 230  *              cpr_bitmap_desc
 231  *              (char) bitmap[cpr_bitmap_desc.cbd_size]
 232  *
 233  *      Page data: Contains one or more physical page records,
 234  *              each record consists of a descriptor and data:
 235  *              cpr_page_desc
 236  *              (char) page_data[cpr_page_desc.cpd_offset]
 237  *
 238  *      Terminator: end marker
 239  *              cpr_terminator
 240  *
 241  *      NOTE: cprboot now supports both ILP32 and LP64 kernels;
 242  *      the size of these structures written to a cpr statefile
 243  *      must be the same for ILP32 and LP64.  For details, see
 244  *      sun4u/sys/cpr_impl.h
 245  */
 246
 247 #define CPR_DUMP_MAGIC          0x44754d70      /* 'DuMp' */
 248 #define CPR_BITMAP_MAGIC        0x42744d70      /* 'BtMp' */
 249 #define CPR_PAGE_MAGIC          0x50614765      /* 'PaGe' */
 250 #define CPR_MACHDEP_MAGIC       0x4d614470      /* 'MaDp' */
 251 #define CPR_TERM_MAGIC          0x5465526d      /* 'TeRm' */
 252
 253 /*
 254  * header at the begining of the dump data section
 255  */
 256 struct cpr_dump_desc {
 257         uint_t          cdd_magic;      /* paranoia check */
 258         ushort_t        cdd_version;    /* version number */
 259         ushort_t        cdd_machine;    /* sun4m, sun4u */
 260         int             cdd_bitmaprec;  /* number of bitmap records */
 261         int             cdd_dumppgsize; /* total # of frames dumped, in pages */
 262         int             cdd_test_mode;  /* true if called by uadmin test mode */
 263         int             cdd_debug;      /* turn on debug in cprboot */
 264         cpr_ext         cdd_filesize;   /* statefile size in bytes */
 265 };
 266 typedef struct cpr_dump_desc cdd_t;
 267
 268 /*
 269  * physical memory bitmap descriptor, preceeds the actual bitmap.
 270  */
 271 struct cpr_bitmap_desc {
 272         uint_t          cbd_magic;      /* so we can spot it better */
 273         pfn_t           cbd_spfn;       /* starting pfn */
 274         pfn_t           cbd_epfn;       /* ending pfn */
 275         size_t          cbd_size;       /* size of this bitmap, in bytes */
 276         cpr_ptr         cbd_reg_bitmap; /* regular bitmap */
 277         cpr_ptr         cbd_vlt_bitmap; /* volatile bitmap */
 278         cpr_ptr         cbd_auxmap;     /* aux bitmap used during thaw */
 279 };
 280 typedef struct cpr_bitmap_desc cbd_t;
 281
 282 /*
 283  * Maximum supported bitmap descriptors; 1-2 + null-terminator is common
 284  */
 285 #define CPR_MAX_BMDESC  (16 + 1)
 286
 287 /*
 288  * Describes the contiguous pages saved in the storage area.
 289  * To save space data will be compressed before saved.
 290  * However some data end up bigger after compression.
 291  * In that case, we save the raw data and make a note
 292  * of it in the csd_clean_compress field.
 293  */
 294 struct cpr_storage_desc {
 295         pfn_t           csd_dirty_spfn;         /* starting dirty pfn */
 296         pgcnt_t         csd_dirty_npages;
 297         cpr_ptr         csd_clean_sva;          /* starting clean va */
 298         size_t          csd_clean_sz;
 299         int             csd_clean_compressed;
 300 #ifdef DEBUG
 301         uint_t          csd_usum;
 302         uint_t          csd_csum;
 303 #endif
 304 };
 305 typedef struct cpr_storage_desc csd_t;
 306
 307 /*
 308  * Describes saved pages, preceeds page data;
 309  * cpd_lenth len is important when pages are compressed.
 310  */
 311 struct cpr_page_desc {
 312         uint_t  cpd_magic;      /* so we can spot it better */
 313         pfn_t   cpd_pfn;        /* kern physical address page # */
 314         pgcnt_t cpd_pages;      /* number of contiguous pages */
 315         size_t  cpd_length;     /* data segment size in bytes */
 316         uint_t  cpd_flag;       /* see below */
 317         uint_t  cpd_csum;       /* "after compression" checksum */
 318         uint_t  cpd_usum;       /* "before compression" checksum */
 319 };
 320 typedef struct cpr_page_desc cpd_t;
 321
 322 /*
 323  * cpd_flag values
 324  */
 325 #define CPD_COMPRESS    0x0001  /* set if compressed */
 326 #define CPD_CSUM        0x0002  /* set if "after compression" checsum valid */
 327 #define CPD_USUM        0x0004  /* set if "before compression" checsum valid */
 328
 329 /*
 330  * machdep header stores the length of the platform specific information
 331  * that are used by resume.
 332  *
 333  * Note: the md_size field is the total length of the machine dependent
 334  * information.  This always includes a fixed length section and may
 335  * include a variable length section following it on some platforms.
 336  */
 337 struct cpr_machdep_desc {
 338         uint_t md_magic;        /* paranoia check */
 339         uint_t md_size;         /* the size of the "opaque" data following */
 340 };
 341 typedef struct cpr_machdep_desc cmd_t;
 342
 343 typedef struct timespec32 cpr_time_t;
 344
 345 struct cpr_terminator {
 346         uint_t  magic;                  /* paranoia check */
 347         size_t  real_statef_size;       /* ...in bytes */
 348         cpr_ptr va;                     /* virtual addr of this struct */
 349         cpr_ext pfn;                    /* phys addr of this struct */
 350         cpr_time_t tm_shutdown;         /* time in milisec when shutdown */
 351         cpr_time_t tm_cprboot_start;    /* time when cprboot starts to run */
 352         cpr_time_t tm_cprboot_end;      /* time before jumping to kernel */
 353 };
 354 typedef struct cpr_terminator ctrm_t;
 355
 356
 357 #define REGULAR_BITMAP          1
 358 #define VOLATILE_BITMAP         0
 359
 360 /*
 361  * reference the right bitmap based on the arg descriptor and flag
 362  */
 363 #define DESC_TO_MAP(desc, flag) (flag == REGULAR_BITMAP) ? \
 364         (char *)desc->cbd_reg_bitmap : (char *)desc->cbd_vlt_bitmap
 365 /*
 366  * checks if a phys page is within the range covered by a bitmap
 367  */
 368 #define PPN_IN_RANGE(ppn, desc) \
 369         (ppn <= desc->cbd_epfn && ppn >= desc->cbd_spfn)
 370
 371 #define WRITE_TO_STATEFILE      0
 372 #define SAVE_TO_STORAGE         1
 373 #define STORAGE_DESC_ALLOC      2
 374
 375
 376 /*
 377  * prom_read() max is 32k
 378  * for sun4m, page size is 4k, CPR_MAXCONTIG is 8
 379  * for sun4u, page size is 8k, CPR_MAXCONTIG is 4
 380  */
 381 #define PROM_MAX_READ   0x8000
 382 #define CPR_MAX_BLOCK   0x8000
 383 #define CPR_MAXCONTIG   (CPR_MAX_BLOCK / MMU_PAGESIZE)
 384
 385 #define PAGE_ROUNDUP(val)       (((val) + MMU_PAGEOFFSET) & MMU_PAGEMASK)
 386
 387 /*
 388  * converts byte size to bitmap size; 1 bit represents one phys page
 389  */
 390 #define BITMAP_BYTES(size)      ((size) >> (MMU_PAGESHIFT + 3))
 391
 392
 393 /*
 394  * redefinitions of uadmin subcommands for A_FREEZE
 395  */
 396 #define AD_CPR_COMPRESS         AD_COMPRESS /* store state file compressed */
 397 #define AD_CPR_FORCE            AD_FORCE /* force to do AD_CPR_COMPRESS */
 398 #define AD_CPR_CHECK            AD_CHECK /* test if CPR module is there */
 399 #define AD_CPR_REUSEINIT        AD_REUSEINIT /* write cprinfo file */
 400 #define AD_CPR_REUSABLE         AD_REUSABLE /* create reusable statefile */
 401 #define AD_CPR_REUSEFINI        AD_REUSEFINI /* revert to non-reusable CPR */
 402 #define AD_CPR_TESTHALT         6       /* test mode, halt */
 403 #define AD_CPR_TESTNOZ          7       /* test mode, auto-restart uncompress */
 404 #define AD_CPR_TESTZ            8       /* test mode, auto-restart compress */
 405 #define AD_CPR_PRINT            9       /* print out stats */
 406 #define AD_CPR_NOCOMPRESS       10      /* store state file uncompressed */
 407 #define AD_CPR_SUSP_DEVICES     11      /* Only suspend resume devices */
 408 #define AD_CPR_DEBUG0           100     /* clear debug flag */
 409 #define AD_CPR_DEBUG1           101     /* display CPR main flow via prom */
 410 #define AD_CPR_DEBUG2           102     /* misc small/mid size loops */
 411 #define AD_CPR_DEBUG3           103     /* exhaustive big loops */
 412 #define AD_CPR_DEBUG4           104     /* debug cprboot */
 413 #define AD_CPR_DEBUG5           105     /* debug machdep part of resume */
 414 #define AD_CPR_DEBUG7           107     /* debug bitmap code */
 415 #define AD_CPR_DEBUG8           108
 416 #define AD_CPR_DEBUG9           109     /* display stat data on console */
 417
 418 /*
 419  * Suspend to RAM test points.
 420  * Probably belong above, but are placed here for now.
 421  */
 422 /* S3 leave hardware on and return success */
 423 #define AD_LOOPBACK_SUSPEND_TO_RAM_PASS 22
 424
 425 /* S3 leave hardware on and return failure */
 426 #define AD_LOOPBACK_SUSPEND_TO_RAM_FAIL 23
 427
 428 /* S3 ignored devices that fail to suspend */
 429 #define AD_FORCE_SUSPEND_TO_RAM         24
 430
 431 /* S3 on a specified device */
 432 #define AD_DEVICE_SUSPEND_TO_RAM        25
 433
 434
 435
 436 /*
 437  * Temporary definition of the Suspend to RAM development subcommands
 438  * so that non-ON apps will work after initial integration.
 439  */
 440 #define DEV_SUSPEND_TO_RAM      200
 441 #define DEV_CHECK_SUSPEND_TO_RAM        201
 442
 443 /*
 444  * cprboot related information and definitions.
 445  * The statefile names are hardcoded for now.
 446  */
 447 #define CPR_DEFAULT             "/.cpr_default"
 448 #define CPR_STATE_FILE          "/.CPR"
 449
 450
 451 /*
 452  * definitions for CPR statistics
 453  */
 454 #define CPR_E_NAMELEN           64
 455 #define CPR_E_MAX_EVENTNUM      64
 456
 457 struct cpr_tdata {
 458         time_t  mtime;          /* mean time on this event */
 459         time_t  stime;          /* start time on this event */
 460         time_t  etime;          /* end time on this event */
 461         time_t  ltime;          /* time duration of the last event */
 462 };
 463 typedef struct cpr_tdata ctd_t;
 464
 465 struct cpr_event {
 466         struct  cpr_event *ce_next;     /* next event in the list */
 467         long    ce_ntests;              /* num of the events since loaded */
 468         ctd_t   ce_sec;                 /* cpr time in sec on this event */
 469         ctd_t   ce_msec;                /* cpr time in 100*millisec */
 470         char    ce_name[CPR_E_NAMELEN];
 471 };
 472
 473 struct cpr_stat {
 474         int     cs_ntests;              /* num of cpr's since loaded */
 475         int     cs_mclustsz;            /* average cluster size: all in bytes */
 476         int     cs_upage2statef;        /* actual # of upages gone to statef */
 477         int     cs_min_comprate;        /* minimum compression ratio * 100 */
 478         pgcnt_t cs_nosw_pages;          /* # of pages of no backing store */
 479         size_t  cs_nocomp_statefsz;     /* statefile size without compression */
 480         size_t  cs_est_statefsz;        /* estimated statefile size */
 481         size_t  cs_real_statefsz;       /* real statefile size */
 482         size_t  cs_dumped_statefsz;     /* how much has been dumped out */
 483         struct cpr_event *cs_event_head; /* The 1st one in stat event list */
 484         struct cpr_event *cs_event_tail; /* The last one in stat event list */
 485 };
 486
 487 /*
 488  * macros for CPR statistics evaluation
 489  */
 490 #define CPR_STAT_EVENT_START(s)         cpr_stat_event_start(s, 0)
 491 #define CPR_STAT_EVENT_END(s)           cpr_stat_event_end(s, 0)
 492 /*
 493  * use the following is other time zone is required
 494  */
 495 #define CPR_STAT_EVENT_START_TMZ(s, t)  cpr_stat_event_start(s, t)
 496 #define CPR_STAT_EVENT_END_TMZ(s, t)    cpr_stat_event_end(s, t)
 497
 498 #define CPR_STAT_EVENT_PRINT            cpr_stat_event_print
 499
 500
 501 /*
 502  * State Structure for CPR
 503  */
 504 typedef struct cpr {
 505         uint_t          c_cprboot_magic;
 506         uint_t          c_flags;
 507         int             c_substate;     /* tracking suspend progress */
 508         int             c_fcn;          /* uadmin subcommand */
 509         vnode_t         *c_vp;          /* vnode for statefile */
 510         cbd_t           *c_bmda;        /* bitmap descriptor array */
 511         caddr_t         c_mapping_area; /* reserve for dumping kas phys pages */
 512         struct cpr_stat c_stat;
 513         char            c_alloc_cnt;    /* # of statefile alloc retries */
 514 } cpr_t;
 515
 516 /*
 517  * c_flags definitions
 518  */
 519 #define C_SUSPENDING            0x01
 520 #define C_RESUMING              0x02
 521 #define C_COMPRESSING           0x04
 522 #define C_REUSABLE              0x08
 523 #define C_ERROR                 0x10
 524
 525 extern cpr_t cpr_state;
 526 #define CPR     (&cpr_state)
 527 #define STAT    (&cpr_state.c_stat)
 528
 529 /*
 530  * definitions for c_substate. It works together w/ c_flags to determine which
 531  * stages the CPR is at.
 532  */
 533 #define C_ST_SUSPEND_BEGIN              0
 534 #define C_ST_MP_OFFLINE                 1
 535 #define C_ST_STOP_USER_THREADS          2
 536 #define C_ST_PM_REATTACH_NOINVOL        3
 537 #define C_ST_DISABLE_UFS_LOGGING        4
 538 #define C_ST_STATEF_ALLOC               5
 539 #define C_ST_SUSPEND_DEVICES            6
 540 #define C_ST_STOP_KERNEL_THREADS        7
 541 #define C_ST_SETPROPS_1                 8
 542 #define C_ST_DUMP                       9
 543 #define C_ST_SETPROPS_0                 10
 544 #define C_ST_DUMP_NOSPC                 11
 545 #define C_ST_REUSABLE                   12
 546 #define C_ST_NODUMP                     13
 547 #define C_ST_MP_PAUSED                  14
 548
 549 #define cpr_set_substate(a)     (CPR->c_substate = (a))
 550
 551 #define C_VP            (CPR->c_vp)
 552
 553 #define C_MAX_ALLOC_RETRY       4
 554
 555 #define CPR_PROM_SAVE           0
 556 #define CPR_PROM_RESTORE        1
 557 #define CPR_PROM_FREE           2
 558
 559 /*
 560  * default/historic size for cpr write buffer
 561  */
 562 #define CPRBUFSZ                0x20000
 563
 564 /*
 565  * cpr statefile I/O on a block device begins after the disk label
 566  * and bootblock (primarily for disk slices that start at cyl 0);
 567  * the offset should be at least (label size + bootblock size = 8k)
 568  */
 569 #define CPR_SPEC_OFFSET         16384
 570
 571 typedef int (*bitfunc_t)(pfn_t, int);
 572
 573 /*
 574  * arena scan info
 575  */
 576 struct cpr_walkinfo {
 577         int mapflag;
 578         bitfunc_t bitfunc;
 579         pgcnt_t pages;
 580         size_t size;
 581         int ranges;
 582 };
 583
 584 /*
 585  * Value used by cpr, found in devi_cpr_flags
 586  */
 587 #define DCF_CPR_SUSPENDED       0x1     /* device went through cpr_suspend */
 588
 589 /*
 590  * Values used to differentiate between suspend to disk and suspend to ram
 591  * in cpr_suspend and cpr_resume
 592  */
 593
 594 #define CPR_TORAM       3
 595 #define CPR_TODISK      4
 596
 597 #ifndef _ASM
 598
 599 extern char *cpr_build_statefile_path(void);
 600 extern char *cpr_enumerate_promprops(char **, size_t *);
 601 extern char *cpr_get_statefile_prom_path(void);
 602 extern int cpr_contig_pages(vnode_t *, int);
 603 extern int cpr_default_setup(int);
 604 extern int cpr_dump(vnode_t *);
 605 extern int cpr_get_reusable_mode(void);
 606 extern int cpr_isset(pfn_t, int);
 607 extern int cpr_main(int);
 608 extern int cpr_mp_offline(void);
 609 extern int cpr_mp_online(void);
 610 extern int cpr_nobit(pfn_t, int);
 611 extern int cpr_open_deffile(int, vnode_t **);
 612 extern int cpr_read_cdump(int, cdd_t *, ushort_t);
 613 extern int cpr_read_cprinfo(int, char *, char *);
 614 extern int cpr_read_machdep(int, caddr_t, size_t);
 615 extern int cpr_read_phys_page(int, uint_t, int *);
 616 extern int cpr_read_terminator(int, ctrm_t *, caddr_t);
 617 extern int cpr_resume_devices(dev_info_t *, int);
 618 extern int cpr_set_properties(int);
 619 extern int cpr_statefile_is_spec(void);
 620 extern int cpr_statefile_offset(void);
 621 extern int cpr_stop_kernel_threads(void);
 622 extern int cpr_threads_are_stopped(void);
 623 extern int cpr_stop_user_threads(void);
 624 extern int cpr_suspend_devices(dev_info_t *);
 625 extern int cpr_validate_definfo(int);
 626 extern int cpr_write(vnode_t *, caddr_t, size_t);
 627 extern int cpr_update_nvram(cprop_t *);
 628 extern int cpr_write_deffile(cdef_t *);
 629 extern int i_cpr_alloc_bitmaps(void);
 630 extern int i_cpr_dump_sensitive_kpages(vnode_t *);
 631 extern int i_cpr_save_sensitive_kpages(void);
 632 extern pgcnt_t cpr_count_kpages(int, bitfunc_t);
 633 extern pgcnt_t cpr_count_pages(caddr_t, size_t, int, bitfunc_t, int);
 634 extern pgcnt_t cpr_count_volatile_pages(int, bitfunc_t);
 635 extern pgcnt_t i_cpr_count_sensitive_kpages(int, bitfunc_t);
 636 extern pgcnt_t i_cpr_count_special_kpages(int, bitfunc_t);
 637 extern pgcnt_t i_cpr_count_storage_pages(int, bitfunc_t);
 638 extern ssize_t cpr_get_machdep_len(int);
 639 extern void cpr_clear_definfo(void);
 640 extern void cpr_restore_time(void);
 641 extern void cpr_save_time(void);
 642 extern void cpr_show_range(char *, size_t, int, bitfunc_t, pgcnt_t);
 643 extern void cpr_signal_user(int sig);
 644 extern void cpr_spinning_bar(void);
 645 extern void cpr_start_user_threads(void);
 646 extern void cpr_stat_cleanup(void);
 647 extern void cpr_stat_event_end(char *, cpr_time_t *);
 648 extern void cpr_stat_event_print(void);
 649 extern void cpr_stat_event_start(char *, cpr_time_t *);
 650 extern void cpr_stat_record_events(void);
 651 extern void cpr_tod_get(cpr_time_t *ctp);
 652 extern void cpr_tod_status_set(int);
 653 extern void i_cpr_bitmap_cleanup(void);
 654 extern void i_cpr_stop_other_cpus(void);
 655 extern void i_cpr_alloc_cpus(void);
 656 extern void i_cpr_free_cpus(void);
 657
 658 /*PRINTFLIKE2*/
 659 extern void cpr_err(int, const char *, ...) __KPRINTFLIKE(2);
 660
 661 extern cpr_time_t wholecycle_tv;
 662 extern int cpr_reusable_mode;
 663
 664 #endif  /* _ASM */
 665 #endif  /* _KERNEL */
 666
 667
 668 #ifdef  __cplusplus
 669 }
 670 #endif
 671
 672 #endif  /* _SYS_CPR_H */