git.sesse.net Git - bcachefs-tools-debian/blob - bcache.c

   1 #define _GNU_SOURCE
   2
   3 #include <ctype.h>
   4 #include <errno.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <stdint.h>
   8 #include <fcntl.h>
   9 #include <inttypes.h>
  10 #include <getopt.h>
  11 #include <limits.h>
  12 #include <linux/fs.h>
  13 #include <stdbool.h>
  14 #include <string.h>
  15 #include <sys/ioctl.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <dirent.h>
  19 #include <unistd.h>
  20 #include <uuid/uuid.h>
  21 #include <blkid.h>
  22
  23 #include "bcache.h"
  24
  25 const char * const cache_state[] = {
  26         "active",
  27         "ro",
  28         "failed",
  29         "spare",
  30         NULL
  31 };
  32
  33 const char * const replacement_policies[] = {
  34         "lru",
  35         "fifo",
  36         "random",
  37         NULL
  38 };
  39
  40 const char * const csum_types[] = {
  41         "none",
  42         "crc32c",
  43         "crc64",
  44         NULL
  45 };
  46
  47 const char * const compression_types[] = {
  48         "none",
  49         "lzo1x",
  50         "gzip",
  51         "xz",
  52         NULL
  53 };
  54
  55 const char * const error_actions[] = {
  56         "continue",
  57         "readonly",
  58         "panic",
  59         NULL
  60 };
  61
  62 const char * const bdev_cache_mode[] = {
  63         "writethrough",
  64         "writeback",
  65         "writearound",
  66         "none",
  67         NULL
  68 };
  69
  70 const char * const bdev_state[] = {
  71         "detached",
  72         "clean",
  73         "dirty",
  74         "inconsistent",
  75         NULL
  76 };
  77
  78 const char * const set_attrs[] = {
  79         "btree_flush_delay",
  80         "btree_scan_ratelimit",
  81         "bucket_reserve_percent",
  82         "cache_reserve_percent",
  83         "checksum_type",
  84         "congested_read_threshold_us",
  85         "congested_write_threshold_us",
  86         "data_replicas",
  87         "errors",
  88         "foreground_target_percent",
  89         "gc_sector_percent",
  90         "journal_delay_ms",
  91         "meta_replicas",
  92         "sector_reserve_percent",
  93         "tiering_percent",
  94         NULL
  95 };
  96
  97 const char * const cache_attrs[] = {
  98         "cache_replacement_policy",
  99         "discard",
 100         "state",
 101         "tier",
 102         NULL
 103 };
 104
 105 const char * const internal_attrs[] = {
 106         "btree_shrinker_disabled",
 107         "copy_gc_enabled",
 108         "foreground_write_rate",
 109         "tiering_enabled",
 110         "tiering_rate",
 111         NULL
 112 };
 113
 114 char *skip_spaces(const char *str)
 115 {
 116         while (isspace(*str))
 117                 ++str;
 118         return (char *)str;
 119 }
 120
 121 char *strim(char *s)
 122 {
 123         size_t size;
 124         char *end;
 125
 126         s = skip_spaces(s);
 127         size = strlen(s);
 128         if (!size)
 129                 return s;
 130
 131         end = s + size - 1;
 132         while (end >= s && isspace(*end))
 133                 end--;
 134         *(end + 1) = '\0';
 135
 136         return s;
 137 }
 138
 139 ssize_t read_string_list(const char *buf, const char * const list[])
 140 {
 141         size_t i;
 142         char *s, *d = strdup(buf);
 143         if (!d)
 144                 return -ENOMEM;
 145
 146         s = strim(d);
 147
 148         for (i = 0; list[i]; i++)
 149                 if (!strcmp(list[i], s))
 150                         break;
 151
 152         free(d);
 153
 154         if (!list[i])
 155                 return -EINVAL;
 156
 157         return i;
 158 }
 159
 160 ssize_t read_string_list_or_die(const char *opt, const char * const list[],
 161                                 const char *msg)
 162 {
 163         ssize_t v = read_string_list(opt, list);
 164         if (v < 0)
 165                 die("Bad %s %s", msg, opt);
 166
 167         return v;
 168 }
 169
 170 void print_string_list(const char * const list[], size_t selected)
 171 {
 172         size_t i;
 173
 174         for (i = 0; list[i]; i++) {
 175                 if (i)
 176                         putchar(' ');
 177                 printf(i == selected ? "[%s] ": "%s", list[i]);
 178         }
 179 }
 180
 181 /*
 182  * This is the CRC-32C table
 183  * Generated with:
 184  * width = 32 bits
 185  * poly = 0x1EDC6F41
 186  * reflect input bytes = true
 187  * reflect output bytes = true
 188  */
 189
 190 static const u32 crc32c_table[256] = {
 191         0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
 192         0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
 193         0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
 194         0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L,
 195         0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL,
 196         0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L,
 197         0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L,
 198         0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL,
 199         0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL,
 200         0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L,
 201         0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L,
 202         0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL,
 203         0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L,
 204         0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL,
 205         0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL,
 206         0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L,
 207         0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L,
 208         0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L,
 209         0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L,
 210         0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L,
 211         0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L,
 212         0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L,
 213         0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L,
 214         0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L,
 215         0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L,
 216         0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L,
 217         0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L,
 218         0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L,
 219         0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L,
 220         0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L,
 221         0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L,
 222         0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L,
 223         0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL,
 224         0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L,
 225         0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L,
 226         0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL,
 227         0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L,
 228         0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL,
 229         0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL,
 230         0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L,
 231         0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L,
 232         0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL,
 233         0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL,
 234         0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L,
 235         0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL,
 236         0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L,
 237         0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L,
 238         0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL,
 239         0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L,
 240         0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL,
 241         0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL,
 242         0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L,
 243         0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL,
 244         0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L,
 245         0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L,
 246         0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL,
 247         0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL,
 248         0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L,
 249         0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L,
 250         0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL,
 251         0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L,
 252         0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL,
 253         0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL,
 254         0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L
 255 };
 256
 257 /*
 258  * Steps through buffer one byte at at time, calculates reflected
 259  * crc using table.
 260  */
 261
 262 static u32 crc32c(u32 crc, unsigned char const *data, size_t length)
 263 {
 264         while (length--)
 265                 crc =
 266                     crc32c_table[(crc ^ *data++) & 0xFFL] ^ (crc >> 8);
 267         return crc;
 268 }
 269
 270 /*
 271  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group (Any
 272  * use permitted, subject to terms of PostgreSQL license; see.)
 273
 274  * If we have a 64-bit integer type, then a 64-bit CRC looks just like the
 275  * usual sort of implementation. (See Ross Williams' excellent introduction
 276  * A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS, available from
 277  * ftp://ftp.rocksoft.com/papers/crc_v3.txt or several other net sites.)
 278  * If we have no working 64-bit type, then fake it with two 32-bit registers.
 279  *
 280  * The present implementation is a normal (not "reflected", in Williams'
 281  * terms) 64-bit CRC, using initial all-ones register contents and a final
 282  * bit inversion. The chosen polynomial is borrowed from the DLT1 spec
 283  * (ECMA-182, available from http://www.ecma.ch/ecma1/STAND/ECMA-182.HTM):
 284  *
 285  * x^64 + x^62 + x^57 + x^55 + x^54 + x^53 + x^52 + x^47 + x^46 + x^45 +
 286  * x^40 + x^39 + x^38 + x^37 + x^35 + x^33 + x^32 + x^31 + x^29 + x^27 +
 287  * x^24 + x^23 + x^22 + x^21 + x^19 + x^17 + x^13 + x^12 + x^10 + x^9 +
 288  * x^7 + x^4 + x + 1
 289 */
 290
 291 static const uint64_t crc_table[256] = {
 292         0x0000000000000000ULL, 0x42F0E1EBA9EA3693ULL, 0x85E1C3D753D46D26ULL,
 293         0xC711223CFA3E5BB5ULL, 0x493366450E42ECDFULL, 0x0BC387AEA7A8DA4CULL,
 294         0xCCD2A5925D9681F9ULL, 0x8E224479F47CB76AULL, 0x9266CC8A1C85D9BEULL,
 295         0xD0962D61B56FEF2DULL, 0x17870F5D4F51B498ULL, 0x5577EEB6E6BB820BULL,
 296         0xDB55AACF12C73561ULL, 0x99A54B24BB2D03F2ULL, 0x5EB4691841135847ULL,
 297         0x1C4488F3E8F96ED4ULL, 0x663D78FF90E185EFULL, 0x24CD9914390BB37CULL,
 298         0xE3DCBB28C335E8C9ULL, 0xA12C5AC36ADFDE5AULL, 0x2F0E1EBA9EA36930ULL,
 299         0x6DFEFF5137495FA3ULL, 0xAAEFDD6DCD770416ULL, 0xE81F3C86649D3285ULL,
 300         0xF45BB4758C645C51ULL, 0xB6AB559E258E6AC2ULL, 0x71BA77A2DFB03177ULL,
 301         0x334A9649765A07E4ULL, 0xBD68D2308226B08EULL, 0xFF9833DB2BCC861DULL,
 302         0x388911E7D1F2DDA8ULL, 0x7A79F00C7818EB3BULL, 0xCC7AF1FF21C30BDEULL,
 303         0x8E8A101488293D4DULL, 0x499B3228721766F8ULL, 0x0B6BD3C3DBFD506BULL,
 304         0x854997BA2F81E701ULL, 0xC7B97651866BD192ULL, 0x00A8546D7C558A27ULL,
 305         0x4258B586D5BFBCB4ULL, 0x5E1C3D753D46D260ULL, 0x1CECDC9E94ACE4F3ULL,
 306         0xDBFDFEA26E92BF46ULL, 0x990D1F49C77889D5ULL, 0x172F5B3033043EBFULL,
 307         0x55DFBADB9AEE082CULL, 0x92CE98E760D05399ULL, 0xD03E790CC93A650AULL,
 308         0xAA478900B1228E31ULL, 0xE8B768EB18C8B8A2ULL, 0x2FA64AD7E2F6E317ULL,
 309         0x6D56AB3C4B1CD584ULL, 0xE374EF45BF6062EEULL, 0xA1840EAE168A547DULL,
 310         0x66952C92ECB40FC8ULL, 0x2465CD79455E395BULL, 0x3821458AADA7578FULL,
 311         0x7AD1A461044D611CULL, 0xBDC0865DFE733AA9ULL, 0xFF3067B657990C3AULL,
 312         0x711223CFA3E5BB50ULL, 0x33E2C2240A0F8DC3ULL, 0xF4F3E018F031D676ULL,
 313         0xB60301F359DBE0E5ULL, 0xDA050215EA6C212FULL, 0x98F5E3FE438617BCULL,
 314         0x5FE4C1C2B9B84C09ULL, 0x1D14202910527A9AULL, 0x93366450E42ECDF0ULL,
 315         0xD1C685BB4DC4FB63ULL, 0x16D7A787B7FAA0D6ULL, 0x5427466C1E109645ULL,
 316         0x4863CE9FF6E9F891ULL, 0x0A932F745F03CE02ULL, 0xCD820D48A53D95B7ULL,
 317         0x8F72ECA30CD7A324ULL, 0x0150A8DAF8AB144EULL, 0x43A04931514122DDULL,
 318         0x84B16B0DAB7F7968ULL, 0xC6418AE602954FFBULL, 0xBC387AEA7A8DA4C0ULL,
 319         0xFEC89B01D3679253ULL, 0x39D9B93D2959C9E6ULL, 0x7B2958D680B3FF75ULL,
 320         0xF50B1CAF74CF481FULL, 0xB7FBFD44DD257E8CULL, 0x70EADF78271B2539ULL,
 321         0x321A3E938EF113AAULL, 0x2E5EB66066087D7EULL, 0x6CAE578BCFE24BEDULL,
 322         0xABBF75B735DC1058ULL, 0xE94F945C9C3626CBULL, 0x676DD025684A91A1ULL,
 323         0x259D31CEC1A0A732ULL, 0xE28C13F23B9EFC87ULL, 0xA07CF2199274CA14ULL,
 324         0x167FF3EACBAF2AF1ULL, 0x548F120162451C62ULL, 0x939E303D987B47D7ULL,
 325         0xD16ED1D631917144ULL, 0x5F4C95AFC5EDC62EULL, 0x1DBC74446C07F0BDULL,
 326         0xDAAD56789639AB08ULL, 0x985DB7933FD39D9BULL, 0x84193F60D72AF34FULL,
 327         0xC6E9DE8B7EC0C5DCULL, 0x01F8FCB784FE9E69ULL, 0x43081D5C2D14A8FAULL,
 328         0xCD2A5925D9681F90ULL, 0x8FDAB8CE70822903ULL, 0x48CB9AF28ABC72B6ULL,
 329         0x0A3B7B1923564425ULL, 0x70428B155B4EAF1EULL, 0x32B26AFEF2A4998DULL,
 330         0xF5A348C2089AC238ULL, 0xB753A929A170F4ABULL, 0x3971ED50550C43C1ULL,
 331         0x7B810CBBFCE67552ULL, 0xBC902E8706D82EE7ULL, 0xFE60CF6CAF321874ULL,
 332         0xE224479F47CB76A0ULL, 0xA0D4A674EE214033ULL, 0x67C58448141F1B86ULL,
 333         0x253565A3BDF52D15ULL, 0xAB1721DA49899A7FULL, 0xE9E7C031E063ACECULL,
 334         0x2EF6E20D1A5DF759ULL, 0x6C0603E6B3B7C1CAULL, 0xF6FAE5C07D3274CDULL,
 335         0xB40A042BD4D8425EULL, 0x731B26172EE619EBULL, 0x31EBC7FC870C2F78ULL,
 336         0xBFC9838573709812ULL, 0xFD39626EDA9AAE81ULL, 0x3A28405220A4F534ULL,
 337         0x78D8A1B9894EC3A7ULL, 0x649C294A61B7AD73ULL, 0x266CC8A1C85D9BE0ULL,
 338         0xE17DEA9D3263C055ULL, 0xA38D0B769B89F6C6ULL, 0x2DAF4F0F6FF541ACULL,
 339         0x6F5FAEE4C61F773FULL, 0xA84E8CD83C212C8AULL, 0xEABE6D3395CB1A19ULL,
 340         0x90C79D3FEDD3F122ULL, 0xD2377CD44439C7B1ULL, 0x15265EE8BE079C04ULL,
 341         0x57D6BF0317EDAA97ULL, 0xD9F4FB7AE3911DFDULL, 0x9B041A914A7B2B6EULL,
 342         0x5C1538ADB04570DBULL, 0x1EE5D94619AF4648ULL, 0x02A151B5F156289CULL,
 343         0x4051B05E58BC1E0FULL, 0x87409262A28245BAULL, 0xC5B073890B687329ULL,
 344         0x4B9237F0FF14C443ULL, 0x0962D61B56FEF2D0ULL, 0xCE73F427ACC0A965ULL,
 345         0x8C8315CC052A9FF6ULL, 0x3A80143F5CF17F13ULL, 0x7870F5D4F51B4980ULL,
 346         0xBF61D7E80F251235ULL, 0xFD913603A6CF24A6ULL, 0x73B3727A52B393CCULL,
 347         0x31439391FB59A55FULL, 0xF652B1AD0167FEEAULL, 0xB4A25046A88DC879ULL,
 348         0xA8E6D8B54074A6ADULL, 0xEA16395EE99E903EULL, 0x2D071B6213A0CB8BULL,
 349         0x6FF7FA89BA4AFD18ULL, 0xE1D5BEF04E364A72ULL, 0xA3255F1BE7DC7CE1ULL,
 350         0x64347D271DE22754ULL, 0x26C49CCCB40811C7ULL, 0x5CBD6CC0CC10FAFCULL,
 351         0x1E4D8D2B65FACC6FULL, 0xD95CAF179FC497DAULL, 0x9BAC4EFC362EA149ULL,
 352         0x158E0A85C2521623ULL, 0x577EEB6E6BB820B0ULL, 0x906FC95291867B05ULL,
 353         0xD29F28B9386C4D96ULL, 0xCEDBA04AD0952342ULL, 0x8C2B41A1797F15D1ULL,
 354         0x4B3A639D83414E64ULL, 0x09CA82762AAB78F7ULL, 0x87E8C60FDED7CF9DULL,
 355         0xC51827E4773DF90EULL, 0x020905D88D03A2BBULL, 0x40F9E43324E99428ULL,
 356         0x2CFFE7D5975E55E2ULL, 0x6E0F063E3EB46371ULL, 0xA91E2402C48A38C4ULL,
 357         0xEBEEC5E96D600E57ULL, 0x65CC8190991CB93DULL, 0x273C607B30F68FAEULL,
 358         0xE02D4247CAC8D41BULL, 0xA2DDA3AC6322E288ULL, 0xBE992B5F8BDB8C5CULL,
 359         0xFC69CAB42231BACFULL, 0x3B78E888D80FE17AULL, 0x7988096371E5D7E9ULL,
 360         0xF7AA4D1A85996083ULL, 0xB55AACF12C735610ULL, 0x724B8ECDD64D0DA5ULL,
 361         0x30BB6F267FA73B36ULL, 0x4AC29F2A07BFD00DULL, 0x08327EC1AE55E69EULL,
 362         0xCF235CFD546BBD2BULL, 0x8DD3BD16FD818BB8ULL, 0x03F1F96F09FD3CD2ULL,
 363         0x41011884A0170A41ULL, 0x86103AB85A2951F4ULL, 0xC4E0DB53F3C36767ULL,
 364         0xD8A453A01B3A09B3ULL, 0x9A54B24BB2D03F20ULL, 0x5D45907748EE6495ULL,
 365         0x1FB5719CE1045206ULL, 0x919735E51578E56CULL, 0xD367D40EBC92D3FFULL,
 366         0x1476F63246AC884AULL, 0x568617D9EF46BED9ULL, 0xE085162AB69D5E3CULL,
 367         0xA275F7C11F7768AFULL, 0x6564D5FDE549331AULL, 0x279434164CA30589ULL,
 368         0xA9B6706FB8DFB2E3ULL, 0xEB46918411358470ULL, 0x2C57B3B8EB0BDFC5ULL,
 369         0x6EA7525342E1E956ULL, 0x72E3DAA0AA188782ULL, 0x30133B4B03F2B111ULL,
 370         0xF7021977F9CCEAA4ULL, 0xB5F2F89C5026DC37ULL, 0x3BD0BCE5A45A6B5DULL,
 371         0x79205D0E0DB05DCEULL, 0xBE317F32F78E067BULL, 0xFCC19ED95E6430E8ULL,
 372         0x86B86ED5267CDBD3ULL, 0xC4488F3E8F96ED40ULL, 0x0359AD0275A8B6F5ULL,
 373         0x41A94CE9DC428066ULL, 0xCF8B0890283E370CULL, 0x8D7BE97B81D4019FULL,
 374         0x4A6ACB477BEA5A2AULL, 0x089A2AACD2006CB9ULL, 0x14DEA25F3AF9026DULL,
 375         0x562E43B4931334FEULL, 0x913F6188692D6F4BULL, 0xD3CF8063C0C759D8ULL,
 376         0x5DEDC41A34BBEEB2ULL, 0x1F1D25F19D51D821ULL, 0xD80C07CD676F8394ULL,
 377         0x9AFCE626CE85B507ULL
 378 };
 379
 380 static uint64_t bch_crc64_update(uint64_t crc, const void *_data, size_t len)
 381 {
 382         const unsigned char *data = _data;
 383
 384         while (len--) {
 385                 int i = ((int) (crc >> 56) ^ *data++) & 0xFF;
 386                 crc = crc_table[i] ^ (crc << 8);
 387         }
 388
 389         return crc;
 390 }
 391
 392 static uint64_t bch_checksum_update(unsigned type, uint64_t crc, const void *data, size_t len)
 393 {
 394         switch (type) {
 395         case BCH_CSUM_NONE:
 396                 return 0;
 397         case BCH_CSUM_CRC32C:
 398                 return crc32c(crc, data, len);
 399         case BCH_CSUM_CRC64:
 400                 return bch_crc64_update(crc, data, len);
 401         default:
 402                 die("Unknown checksum type %u", type);
 403         }
 404 }
 405
 406 uint64_t bch_checksum(unsigned type, const void *data, size_t len)
 407 {
 408         uint64_t crc = 0xffffffffffffffffULL;
 409
 410         crc = bch_checksum_update(type, crc, data, len);
 411
 412         return crc ^ 0xffffffffffffffffULL;
 413 }
 414
 415 uint64_t getblocks(int fd)
 416 {
 417         uint64_t ret;
 418         struct stat statbuf;
 419         if (fstat(fd, &statbuf)) {
 420                 perror("getblocks: stat error\n");
 421                 exit(EXIT_FAILURE);
 422         }
 423         ret = statbuf.st_size / 512;
 424         if (S_ISBLK(statbuf.st_mode))
 425                 if (ioctl(fd, BLKGETSIZE, &ret)) {
 426                         perror("ioctl error getting blksize");
 427                         exit(EXIT_FAILURE);
 428                 }
 429         return ret;
 430 }
 431
 432 uint64_t hatoi(const char *s)
 433 {
 434         char *e;
 435         long long i = strtoll(s, &e, 10);
 436         switch (*e) {
 437                 case 't':
 438                 case 'T':
 439                         i *= 1024;
 440                 case 'g':
 441                 case 'G':
 442                         i *= 1024;
 443                 case 'm':
 444                 case 'M':
 445                         i *= 1024;
 446                 case 'k':
 447                 case 'K':
 448                         i *= 1024;
 449         }
 450         return i;
 451 }
 452
 453 unsigned hatoi_validate(const char *s, const char *msg)
 454 {
 455         uint64_t v = hatoi(s);
 456
 457         if (v & (v - 1))
 458                 die("%s must be a power of two", msg);
 459
 460         v /= 512;
 461
 462         if (v > USHRT_MAX)
 463                 die("%s too large\n", msg);
 464
 465         if (!v)
 466                 die("%s too small\n", msg);
 467
 468         return v;
 469 }
 470
 471 int dev_open(const char *dev)
 472 {
 473         blkid_probe pr;
 474         int fd;
 475
 476         if ((fd = open(dev, O_RDWR|O_EXCL)) == -1)
 477                 die("Can't open dev %s: %s\n", dev, strerror(errno));
 478
 479         if (!(pr = blkid_new_probe()))
 480                 die("Failed to create a new probe");
 481         if (blkid_probe_set_device(pr, fd, 0, 0))
 482                 die("failed to set probe to device");
 483
 484         /* enable ptable probing; superblock probing is enabled by default */
 485         if (blkid_probe_enable_partitions(pr, true))
 486                 die("Failed to enable partitions on probe");
 487
 488         if (!blkid_do_probe(pr))
 489                 /* XXX wipefs doesn't know how to remove partition tables */
 490                 die("Device %s already has a non-bcache superblock, "
 491                     "remove it using wipefs and wipefs -a\n", dev);
 492
 493         return fd;
 494 }
 495
 496 unsigned get_blocksize(const char *path, int fd)
 497 {
 498         struct stat statbuf;
 499
 500         if (fstat(fd, &statbuf))
 501                 die("Error statting %s: %s", path, strerror(errno));
 502
 503         if (S_ISBLK(statbuf.st_mode)) {
 504                 /* check IO limits:
 505                  * BLKALIGNOFF: alignment_offset
 506                  * BLKPBSZGET: physical_block_size
 507                  * BLKSSZGET: logical_block_size
 508                  * BLKIOMIN: minimum_io_size
 509                  * BLKIOOPT: optimal_io_size
 510                  *
 511                  * It may be tempting to use physical_block_size,
 512                  * or even minimum_io_size.
 513                  * But to be as transparent as possible,
 514                  * we want to use logical_block_size.
 515                  */
 516                 unsigned int logical_block_size;
 517                 if (ioctl(fd, BLKSSZGET, &logical_block_size))
 518                         die("ioctl(%s, BLKSSZGET) failed: %m", path);
 519
 520                 return logical_block_size / 512;
 521
 522         }
 523         /* else: not a block device.
 524          * Why would we even want to write a bcache super block there? */
 525
 526         return statbuf.st_blksize / 512;
 527 }
 528
 529 long strtoul_or_die(const char *p, size_t max, const char *msg)
 530 {
 531         errno = 0;
 532         long v = strtol(p, NULL, 10);
 533         if (errno || v < 0 || v >= max)
 534                 die("Invalid %s %zi", msg, v);
 535
 536         return v;
 537 }
 538
 539 static void print_encode(char *in)
 540 {
 541     char *pos;
 542         for (pos = in; *pos; pos++)
 543                 if (isalnum(*pos) || strchr(".-_", *pos))
 544                         putchar(*pos);
 545                 else
 546                         printf("%%%x", *pos);
 547 }
 548
 549 static void show_uuid_only(struct cache_sb *sb, char *dev_uuid) {
 550         uuid_unparse(sb->disk_uuid.b, dev_uuid);
 551 }
 552
 553 static void show_super_common(struct cache_sb *sb, bool force_csum)
 554 {
 555         char uuid[40];
 556         char label[SB_LABEL_SIZE + 1];
 557         uint64_t expected_csum;
 558
 559         printf("sb.magic\t\t");
 560         if (!memcmp(&sb->magic, &BCACHE_MAGIC, sizeof(sb->magic))) {
 561                 printf("ok\n");
 562         } else {
 563                 printf("bad magic\n");
 564                 die("Invalid superblock (bad magic)");
 565         }
 566
 567         printf("sb.first_sector\t\t%ju", (uint64_t) sb->offset);
 568         if (sb->offset == SB_SECTOR) {
 569                 printf(" [match]\n");
 570         } else {
 571                 printf(" [expected %ds]\n", SB_SECTOR);
 572                 die("Invalid superblock (bad sector)");
 573         }
 574
 575         printf("sb.csum\t\t\t%ju", (uint64_t) sb->csum);
 576         expected_csum = csum_set(sb,
 577                                  sb->version < BCACHE_SB_VERSION_CDEV_V3
 578                                  ? BCH_CSUM_CRC64
 579                                  : CACHE_SB_CSUM_TYPE(sb));
 580         if (sb->csum == expected_csum) {
 581                 printf(" [match]\n");
 582         } else {
 583                 printf(" [expected %" PRIX64 "]\n", expected_csum);
 584                 if (force_csum)
 585                         die("Corrupt superblock (bad csum)");
 586         }
 587
 588         printf("sb.version\t\t%ju", (uint64_t) sb->version);
 589         switch (sb->version) {
 590                 // These are handled the same by the kernel
 591                 case BCACHE_SB_VERSION_CDEV:
 592                 case BCACHE_SB_VERSION_CDEV_WITH_UUID:
 593                         printf(" [cache device]\n");
 594                         break;
 595
 596                 // The second adds data offset support
 597                 case BCACHE_SB_VERSION_BDEV:
 598                 case BCACHE_SB_VERSION_BDEV_WITH_OFFSET:
 599                         printf(" [backing device]\n");
 600                         break;
 601
 602                 default:
 603                         printf(" [unknown]\n");
 604                         // exit code?
 605                         exit(EXIT_SUCCESS);
 606         }
 607
 608         putchar('\n');
 609
 610         strncpy(label, (char *) sb->label, SB_LABEL_SIZE);
 611         label[SB_LABEL_SIZE] = '\0';
 612         printf("dev.label\t\t");
 613         if (*label)
 614                 print_encode(label);
 615         else
 616                 printf("(empty)");
 617         putchar('\n');
 618
 619         uuid_unparse(sb->disk_uuid.b, uuid);
 620         printf("dev.uuid\t\t%s\n", uuid);
 621
 622         uuid_unparse(sb->user_uuid.b, uuid);
 623         printf("cset.uuid\t\t%s\n", uuid);
 624
 625         uuid_unparse(sb->set_uuid.b, uuid);
 626         printf("internal.uuid\t%s\n", uuid);
 627
 628 }
 629
 630 void show_super_backingdev(struct cache_sb *sb, bool force_csum)
 631 {
 632         uint64_t first_sector;
 633
 634         show_super_common(sb, force_csum);
 635
 636         if (sb->version == BCACHE_SB_VERSION_BDEV) {
 637                 first_sector = BDEV_DATA_START_DEFAULT;
 638         } else {
 639                 first_sector = sb->bdev_data_offset;
 640         }
 641
 642         printf("dev.data.first_sector\t%ju\n"
 643                "dev.data.cache_mode\t%s"
 644                "dev.data.cache_state\t%s\n",
 645                first_sector,
 646                bdev_cache_mode[BDEV_CACHE_MODE(sb)],
 647                bdev_state[BDEV_STATE(sb)]);
 648 }
 649
 650 void show_super_cache(struct cache_sb *sb, bool force_csum)
 651 {
 652         struct cache_member *m = sb->members + sb->nr_this_dev;
 653         char uuid[16];
 654
 655         show_super_common(sb, force_csum);
 656
 657         uuid_unparse(m->uuid.b, uuid);
 658         printf("dev.cache.uuid\t%s\n", uuid);
 659
 660         printf("dev.sectors_per_block\t%u\n"
 661                "dev.sectors_per_bucket\t%u\n",
 662                sb->block_size,
 663                m->bucket_size);
 664
 665         // total_sectors includes the superblock;
 666         printf("dev.cache.first_sector\t%u\n"
 667                "dev.cache.cache_sectors\t%llu\n"
 668                "dev.cache.total_sectors\t%llu\n"
 669                "dev.cache.ordered\t%s\n"
 670                "dev.cache.pos\t\t%u\n"
 671                "dev.cache.setsize\t\t%u\n",
 672                m->bucket_size * m->first_bucket,
 673                m->bucket_size * (m->nbuckets - m->first_bucket),
 674                m->bucket_size * m->nbuckets,
 675                CACHE_SYNC(sb) ? "yes" : "no",
 676                sb->nr_this_dev,
 677                sb->nr_in_set);
 678
 679         printf("cache.state\t%s\n",             cache_state[CACHE_STATE(m)]);
 680
 681         printf("cache.tier\t%llu\n",            CACHE_TIER(m));
 682
 683         printf("cache.replication_set\t%llu\n", CACHE_REPLICATION_SET(m));
 684
 685         printf("cache.has_metadata\t%llu\n",    CACHE_HAS_METADATA(m));
 686         printf("cache.has_data\t%llu\n",        CACHE_HAS_DATA(m));
 687
 688         printf("cache.replacement\t%s\n",       replacement_policies[CACHE_REPLACEMENT(m)]);
 689         printf("cache.discard\t%llu\n",         CACHE_DISCARD(m));
 690 }
 691
 692 static int __sysfs_attr_type(const char *attr, const char * const *attr_arr)
 693 {
 694         for (unsigned i = 0; attr_arr[i] != NULL; i++)
 695                 if(!strcmp(attr, attr_arr[i]))
 696                         return 1;
 697         return 0;
 698 }
 699
 700 enum sysfs_attr sysfs_attr_type(const char *attr)
 701 {
 702         if(__sysfs_attr_type(attr, set_attrs))
 703                 return SET_ATTR;
 704         if(__sysfs_attr_type(attr, cache_attrs))
 705                 return CACHE_ATTR;
 706         if(__sysfs_attr_type(attr, internal_attrs))
 707                 return INTERNAL_ATTR;
 708
 709         printf("No attribute called %s, try --list to see options\n", attr);
 710
 711         return -1;
 712 }
 713
 714 static void __sysfs_attr_list(const char * const *attr_arr)
 715 {
 716         for (unsigned i = 0; attr_arr[i] != NULL; i++)
 717                 printf("%s\n", attr_arr[i]);
 718 }
 719
 720 void sysfs_attr_list()
 721 {
 722         __sysfs_attr_list(set_attrs);
 723         __sysfs_attr_list(cache_attrs);
 724         __sysfs_attr_list(internal_attrs);
 725 }
 726
 727 struct cache_sb *query_dev(char *dev, bool force_csum,
 728                 bool print_sb, bool uuid_only, char *dev_uuid)
 729 {
 730         size_t bytes = 4096;
 731         struct cache_sb *sb = aligned_alloc(bytes, bytes);
 732
 733         int fd = open(dev, O_RDONLY|O_DIRECT);
 734         if (fd < 0) {
 735                 printf("Can't open dev %s: %s\n", dev, strerror(errno));
 736                 return NULL;
 737         }
 738
 739         while (true) {
 740                 int ret = pread(fd, sb, bytes, SB_START);
 741                 if (ret < 0) {
 742                         fprintf(stderr, "Couldn't read superblock: %s\n",
 743                                         strerror(errno));
 744                         close(fd);
 745                         free(sb);
 746                         return NULL;
 747                 } else if (bytes > sizeof(sb) + sb->u64s * sizeof(u64)) {
 748                         /* We read the whole superblock */
 749                         break;
 750                 }
 751
 752                 /*
 753                  * otherwise double the size of our dest
 754                  * and read again
 755                  */
 756                 free(sb);
 757                 bytes *= 2;
 758                 sb = aligned_alloc(4096, bytes);
 759         }
 760
 761         close(fd);
 762
 763         if(uuid_only) {
 764                 show_uuid_only(sb, dev_uuid);
 765                 return sb;
 766         }
 767
 768         if(print_sb) {
 769                 if (!SB_IS_BDEV(sb))
 770                         show_super_cache(sb, force_csum);
 771                 else
 772                         show_super_backingdev(sb, force_csum);
 773         }
 774
 775         return sb;
 776 }
 777
 778 char *dev_name(const char *ugly_path) {
 779         char buf[32];
 780         int i, end = strlen(ugly_path);
 781
 782         //Chop off "/bcache", then look for the next '/' from the end
 783         for (i = end - 8; ; i--)
 784                 if(ugly_path[i] == '/')
 785                         break;
 786
 787         strcpy(buf, ugly_path + i);
 788         buf[end - i - 7] = 0;
 789
 790         // Is the dev guaranteed to be in /dev?
 791         // This is needed for finding the superblock with a query-dev
 792         return strdup(buf);
 793 }
 794
 795 char *find_matching_uuid(char *stats_dir, char *subdir, const char *stats_dev_uuid)
 796 {
 797         /* Do a query-dev --uuid only to get the uuid
 798          * repeat on each dev until we find a matching one
 799          * append that cache# to subdir and return
 800          */
 801
 802         int i = 0;
 803         DIR *cachedir;
 804         struct stat cache_stat;
 805         char intbuf[4];
 806         char entry[MAX_PATH];
 807         char *err = NULL;
 808
 809         snprintf(entry, MAX_PATH, "%s%s", stats_dir, subdir);
 810         snprintf(intbuf, 4, "%d", i);
 811         strcat(entry, intbuf);
 812
 813         while(true) {
 814                 char buf[MAX_PATH];
 815                 int len;
 816
 817                 if((cachedir = opendir(entry)) == NULL)
 818                         break;
 819
 820                 if(stat(entry, &cache_stat))
 821                         break;
 822
 823                 if((len = readlink(entry, buf, sizeof(buf) - 1)) != -1) {
 824                         char dev_uuid[40];
 825                         buf[len] = '\0';
 826                         int i, end = strlen(buf);
 827                         char tmp[32], devname[32];
 828                         struct cache_sb *sb;
 829
 830                         /* Chop off "/bcache", then look for the
 831                          * next '/' from the end
 832                          */
 833                         for (i = end - 8; ; i--)
 834                                 if(buf[i] == '/')
 835                                         break;
 836
 837                         strcpy(tmp, buf + i);
 838                         tmp[end - i - 7] = 0;
 839                         strcpy(devname, "/dev");
 840                         strcat(devname, tmp);
 841
 842                         err = "Unable to open superblock";
 843                         sb = query_dev(devname, false, false, true, dev_uuid);
 844                         if(!sb)
 845                                 return err;
 846                         else
 847                                 free(sb);
 848
 849                         if(!strcmp(stats_dev_uuid, dev_uuid)) {
 850                                 strcat(subdir, intbuf);
 851                                 return NULL;
 852                         }
 853                 }
 854
 855                 /* remove i from end and append i++ */
 856                 entry[strlen(entry)-strlen(intbuf)] = 0;
 857                 i++;
 858                 snprintf(intbuf, 4, "%d", i);
 859                 strcat(entry, intbuf);
 860         }
 861
 862
 863         err = "dev uuid doesn't exist in cache_set";
 864         return err;
 865 }
 866
 867 int bcachectl_open(void)
 868 {
 869         int fd = open("/dev/bcache-ctl", O_RDWR);
 870         if (fd < 0)
 871                 die("Can't open bcache device: %s", strerror(errno));
 872
 873         return fd;
 874 }
 875
 876 unsigned nr_args(char *const *args)
 877 {
 878         unsigned i;
 879
 880         for (i = 0; args[i]; i++)
 881                 ;
 882
 883         return i;
 884 }