sbin/nvmecontrol/power.c

   1 /*-
   2  * Copyright (c) 2016 Netflix, Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 #include <sys/param.h>
  28 #include <sys/ioccom.h>
  29
  30 #include <ctype.h>
  31 #include <err.h>
  32 #include <fcntl.h>
  33 #include <stdbool.h>
  34 #include <stddef.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <sysexits.h>
  39 #include <unistd.h>
  40
  41 #include "nvmecontrol.h"
  42
  43 _Static_assert(sizeof(struct nvme_power_state) == 256 / NBBY,
  44                "nvme_power_state size wrong");
  45
  46 #define POWER_NONE 0xffffffffu
  47
  48 static struct options {
  49         bool            list;
  50         uint32_t        power;
  51         uint32_t        workload;
  52         const char      *dev;
  53 } opt = {
  54         .list = false,
  55         .power = POWER_NONE,
  56         .workload = 0,
  57         .dev = NULL,
  58 };
  59
  60 static void
  61 power_list_one(int i, struct nvme_power_state *nps)
  62 {
  63         int mpower, apower, ipower;
  64         uint8_t mps, nops, aps, apw;
  65
  66         mps = (nps->mps_nops >> NVME_PWR_ST_MPS_SHIFT) &
  67                 NVME_PWR_ST_MPS_MASK;
  68         nops = (nps->mps_nops >> NVME_PWR_ST_NOPS_SHIFT) &
  69                 NVME_PWR_ST_NOPS_MASK;
  70         apw = (nps->apw_aps >> NVME_PWR_ST_APW_SHIFT) &
  71                 NVME_PWR_ST_APW_MASK;
  72         aps = (nps->apw_aps >> NVME_PWR_ST_APS_SHIFT) &
  73                 NVME_PWR_ST_APS_MASK;
  74
  75         mpower = nps->mp;
  76         if (mps == 0)
  77                 mpower *= 100;
  78         ipower = nps->idlp;
  79         if (nps->ips == 1)
  80                 ipower *= 100;
  81         apower = nps->actp;
  82         if (aps == 1)
  83                 apower *= 100;
  84         printf("%2d: %2d.%04dW%c %3d.%03dms %3d.%03dms %2d %2d %2d %2d %2d.%04dW %2d.%04dW %d\n",
  85                i, mpower / 10000, mpower % 10000,
  86                nops ? '*' : ' ', nps->enlat / 1000, nps->enlat % 1000,
  87                nps->exlat / 1000, nps->exlat % 1000, nps->rrt, nps->rrl,
  88                nps->rwt, nps->rwl, ipower / 10000, ipower % 10000,
  89                apower / 10000, apower % 10000, apw);
  90 }
  91
  92 static void
  93 power_list(struct nvme_controller_data *cdata)
  94 {
  95         int i;
  96
  97         printf("\nPower States Supported: %d\n\n", cdata->npss + 1);
  98         printf(" #   Max pwr  Enter Lat  Exit Lat RT RL WT WL Idle Pwr  Act Pwr Workloadd\n");
  99         printf("--  --------  --------- --------- -- -- -- -- -------- -------- --\n");
 100         for (i = 0; i <= cdata->npss; i++)
 101                 power_list_one(i, &cdata->power_state[i]);
 102 }
 103
 104 static void
 105 power_set(int fd, int power_val, int workload, int perm)
 106 {
 107         struct nvme_pt_command  pt;
 108         uint32_t p;
 109
 110         p = perm ? (1u << 31) : 0;
 111         memset(&pt, 0, sizeof(pt));
 112         pt.cmd.opc = NVME_OPC_SET_FEATURES;
 113         pt.cmd.cdw10 = htole32(NVME_FEAT_POWER_MANAGEMENT | p);
 114         pt.cmd.cdw11 = htole32(power_val | (workload << 5));
 115
 116         if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
 117                 err(EX_IOERR, "set feature power mgmt request failed");
 118
 119         if (nvme_completion_is_error(&pt.cpl))
 120                 errx(EX_IOERR, "set feature power mgmt request returned error");
 121 }
 122
 123 static void
 124 power_show(int fd)
 125 {
 126         struct nvme_pt_command  pt;
 127
 128         memset(&pt, 0, sizeof(pt));
 129         pt.cmd.opc = NVME_OPC_GET_FEATURES;
 130         pt.cmd.cdw10 = htole32(NVME_FEAT_POWER_MANAGEMENT);
 131
 132         if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
 133                 err(EX_IOERR, "set feature power mgmt request failed");
 134
 135         if (nvme_completion_is_error(&pt.cpl))
 136                 errx(EX_IOERR, "set feature power mgmt request returned error");
 137
 138         printf("Current Power State is %d\n", pt.cpl.cdw0 & 0x1F);
 139         printf("Current Workload Hint is %d\n", pt.cpl.cdw0 >> 5);
 140 }
 141
 142 static void
 143 power(const struct cmd *f, int argc, char *argv[])
 144 {
 145         struct nvme_controller_data     cdata;
 146         int                             fd;
 147         char                            *path;
 148         uint32_t                        nsid;
 149
 150         if (arg_parse(argc, argv, f))
 151                 return;
 152
 153         if (opt.list && opt.power != POWER_NONE) {
 154                 fprintf(stderr, "Can't set power and list power states\n");
 155                 arg_help(argc, argv, f);
 156         }
 157
 158         open_dev(opt.dev, &fd, 1, 1);
 159         get_nsid(fd, &path, &nsid);
 160         if (nsid != 0) {
 161                 close(fd);
 162                 open_dev(path, &fd, 1, 1);
 163         }
 164         free(path);
 165
 166         if (opt.list) {
 167                 if (read_controller_data(fd, &cdata))
 168                         errx(EX_IOERR, "Identify request failed");
 169                 power_list(&cdata);
 170                 goto out;
 171         }
 172
 173         if (opt.power != POWER_NONE) {
 174                 power_set(fd, opt.power, opt.workload, 0);
 175                 goto out;
 176         }
 177         power_show(fd);
 178
 179 out:
 180         close(fd);
 181         exit(0);
 182 }
 183
 184 static const struct opts power_opts[] = {
 185 #define OPT(l, s, t, opt, addr, desc) { l, s, t, &opt.addr, desc }
 186         OPT("list", 'l', arg_none, opt, list,
 187             "List the valid power states"),
 188         OPT("power", 'p', arg_uint32, opt, power,
 189             "Set the power state"),
 190         OPT("workload", 'w', arg_uint32, opt, workload,
 191             "Set the workload hint"),
 192         { NULL, 0, arg_none, NULL, NULL }
 193 };
 194 #undef OPT
 195
 196 static const struct args power_args[] = {
 197         { arg_string, &opt.dev, "controller-id|namespace-id" },
 198         { arg_none, NULL, NULL },
 199 };
 200
 201 static struct cmd power_cmd = {
 202         .name = "power",
 203         .fn = power,
 204         .descr = "Manage power states for the drive",
 205         .ctx_size = sizeof(opt),
 206         .opts = power_opts,
 207         .args = power_args,
 208 };
 209
 210 CMD_COMMAND(power_cmd);