Program to create bootcache area
Changes to bootcache program to match changes that have been
made to the bootcache device mapper.
BUG=chromium-os:25441
TEST=created bootcache and booted system.
Change-Id: Idc62d4cea72d69f4c202460400219184916231ee
Reviewed-on: https://gerrit.chromium.org/gerrit/31761
Reviewed-by: Luigi Semenzato <semenzato@chromium.org>
Commit-Ready: Paul Taysom <taysom@chromium.org>
Tested-by: Paul Taysom <taysom@chromium.org>
diff --git a/bootcache.c b/bootcache.c
index 515bde2..5fa9a8f 100644
--- a/bootcache.c
+++ b/bootcache.c
@@ -12,7 +12,10 @@
* conjunction with dm-bootcache device mapper to coalesce
* the blocks used during boot.
*
- * bootcache [-t] <device-name>
+ * Sizes and offsets are measured in 512 byte sectors.
+ * Space is allocated in CHUNK_SIZE chunks.
+ *
+ * bootcache [-t] <device-name> <raw-partition>
*
* -t - for testing - looks in a different place for
* information files.
@@ -21,14 +24,14 @@
* prefix.
*
* Files:
- * 1. Device - /dev/dm-0 - Where the blocks to be cached
- * are stored. Both the original and cached
- * copy.
+ * 1. Device - <raw-partition> - Where the blocks to be
+ * cached are stored. Both the original and
+ * cached copy.
* 2. Header - /sys/kernel/debug/dm-bootcache/dm-0/header
* Header for the boot cache. It contains the
* information the bootcache utility will need
* to create the bootcache.
- * 3. Trace - /sys/kernel/debug/dm-bootcache/dm-0/trace
+ * 3. Trace - /sys/kernel/debug/dm-bootcache/dm-0/blocktrace
* Trace of files read during boot
* 4. Valid - /sys/kernel/debug/dm-bootcache/dm-0/valid
* Returns "1" if cache is valid
@@ -41,14 +44,16 @@
#include <sys/types.h>
#include <sys/stat.h>
+#include <sys/user.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdbool.h>
-#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
+#include <syslog.h>
#include <unistd.h>
#include "dm-bootcache.h"
@@ -56,30 +61,41 @@
typedef uint64_t u64;
typedef uint32_t u32;
-#define MAX_BLOCKS 128
+#define CHUNK_SIZE 4096 /* todo(taysom) should get from bootcache_hdr */
+#define SECTOR_SHIFT 9
+#define MAX_CHUNKS 128
#define MAX_FILE_NAME 256
+#define SECTORS_PER_CHUNK (CHUNK_SIZE >> SECTOR_SHIFT)
+#define MAX_MSG 1024
-static struct Bootcache_hdr Header;
+static struct bootcache_hdr Header;
static struct {
- struct Trace *tr;
+ struct bootcache_trace *tr;
int num;
} Trace;
static const char Progname[] = "bootcache";
-static char Device_file[MAX_FILE_NAME];
static char Valid_file[MAX_FILE_NAME];
static char Free_file[MAX_FILE_NAME];
static char Header_file[MAX_FILE_NAME];
-static char Trace_file[MAX_FILE_NAME];
+static char Blocktrace_file[MAX_FILE_NAME];
-static u64 Header_block;
static u64 Trace_start;
static u64 Cache_start;
#define fatal(fmt, ...) pr_fatal(__FILE__, __FUNCTION__, __LINE__, \
fmt, ## __VA_ARGS__)
+#define PRs(_x) printf("|%s<%d> %s %s\n", __FUNCTION__, __LINE__, \
+ # _x, _x);
+
+#define PRd(_x) printf("|%s<%d> %s %lld\n", __FUNCTION__, __LINE__, \
+ # _x, (unsigned long long)(_x));
+
+#define PRx(_x) printf("|%s<%d> %s %llx\n", __FUNCTION__, __LINE__, \
+ # _x, (unsigned long long)(_x));
+
/* pr_fatal: print error message and exit */
static void pr_fatal(
const char *file,
@@ -87,20 +103,28 @@
int line,
const char *fmt, ...)
{
+ char msg[MAX_MSG];
va_list args;
+ int n = MAX_MSG;
+ int i = 0;
+ int r;
fflush(stdout);
- fprintf(stderr, "Fatal %s %s:%s<%d> ", Progname, file, func, line);
- if (fmt) {
+ r = snprintf(msg, n, "Fatal %s %s:%s<%d> ", Progname, file, func, line);
+ n -= r;
+ i += r;
+ if (n && fmt) {
va_start(args, fmt);
- vfprintf(stderr, fmt, args);
+ r = vsnprintf(&msg[i], n, fmt, args);
+ n -= r;
+ i += r;
va_end(args);
- if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':') {
- fprintf(stderr, " %s<%d>", strerror(errno), errno);
+ if (n && fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':') {
+ snprintf(&msg[i], n, " %s<%d>", strerror(errno), errno);
}
}
- fprintf(stderr, "\n");
+ syslog(LOG_ERR, "%s\n", msg);
exit(2); /* conventional value for failed execution */
}
@@ -153,14 +177,14 @@
void *buf;
int rc;
- rc = posix_memalign(&buf, BLK_SIZE, npages * BLK_SIZE);
+ rc = posix_memalign(&buf, CHUNK_SIZE, npages * CHUNK_SIZE);
if (rc) {
fatal("posix_memalign rc=%d", rc);
}
return buf;
}
-static u64 num_blocks_in_cache(void)
+static u64 num_sectors_in_cache(void)
{
int i;
u64 sum = 0;
@@ -171,33 +195,41 @@
return sum;
}
-static void compute_sections(void)
+static u64 num_meta_sectors(void)
{
- Header.num_blks_meta = BLK_ALIGN(Trace.num * sizeof(*Trace.tr));
- Header.num_blks_data = num_blocks_in_cache();
- Header_block = Header.blkno;
- Trace_start = Header_block + 1;
- Cache_start = Trace_start + Header.num_blks_meta;
+ u64 num_bytes = Trace.num * sizeof(*Trace.tr);
+
+ /* Align to page boundary then convert to sectors */
+ return ((num_bytes + CHUNK_SIZE - 1) / CHUNK_SIZE) * SECTORS_PER_CHUNK;
}
-static void copy_trace(int dst, int src, struct Trace tr, void *buf)
+static void compute_sections(void)
+{
+ Header.num_trace_recs = Trace.num;
+ Header.sectors_meta = num_meta_sectors();
+ Header.sectors_data = num_sectors_in_cache();
+ Trace_start = Header.sector + SECTORS_PER_CHUNK;
+ Cache_start = Trace_start + Header.sectors_meta;
+}
+
+static void copy_trace(int dst, int src, struct bootcache_trace tr, void *buf)
{
u64 n;
u64 remainder;
u64 offset;
int rc;
- offset = tr.blkno << BLK_SHIFT;
- remainder = tr.count << BLK_SHIFT;
- n = BLK_SIZE * MAX_BLOCKS;
+ offset = tr.sector << SECTOR_SHIFT;
+ remainder = tr.count << SECTOR_SHIFT;
+ n = MAX_CHUNKS * CHUNK_SIZE;
while (remainder) {
if (n > remainder) {
n = remainder;
}
rc = pread(src, buf, n, offset);
if (rc < 0) {
- fatal("pread trace offset=%llu num blocks=%llu",
- offset >> BLK_SHIFT, n >> BLK_SHIFT);
+ fatal("pread trace offset=%llu num sectors=%llu:",
+ offset >> SECTOR_SHIFT, n >> SECTOR_SHIFT);
}
if (rc != n) {
fatal("pread read only %u bytes expected %llu",
@@ -205,8 +237,8 @@
}
rc = write(dst, buf, n);
if (rc < 0) {
- fatal("write trace offset=%llu num blocks=%llu",
- offset >> BLK_SHIFT, n >> BLK_SHIFT);
+ fatal("write trace offset=%llu num sectors=%llu:",
+ offset >> SECTOR_SHIFT, n >> SECTOR_SHIFT);
}
if (rc != n) {
fatal("write wrote only %u bytes expected %llu",
@@ -224,8 +256,9 @@
int src = open(device, O_RDONLY);
int dst = open(device, O_WRONLY);
- void *buf = malloc_buf(MAX_BLOCKS);
- rc = lseek(dst, Cache_start << BLK_SHIFT, SEEK_SET);
+ void *buf = malloc_buf(MAX_CHUNKS);
+
+ rc = lseek(dst, Cache_start << SECTOR_SHIFT, SEEK_SET);
if (rc == -1) {
fatal("lseek for cache start:");
}
@@ -238,28 +271,31 @@
eclose(src);
}
-static void dump_trace(struct Trace *tr, int num_recs)
+static void dump_trace()
{
+ struct bootcache_trace *tr = Trace.tr;
int i;
- for (i = 0; i < num_recs; i++, tr++) {
- printf("%llu %llu %llu\n", tr->blkno, tr->count, tr->ino);
+ if (0) {
+ for (i = 0; i < Trace.num; i++, tr++) {
+ printf("%llu %llu %llu\n", tr->sector, tr->count, tr->ino);
+ }
}
}
/*
- * Because we are reading a pseudo file, we scan it to
- * see how big it is.
+ * Because we are reading a pseudo file in sysfs,
+ * we scan it to see how big it is.
*/
-static u64 num_traces(const char *file)
+static u64 num_bytes(const char *file)
{
- struct Trace trace[1024];
+ char buf[CHUNK_SIZE];
ssize_t rc;
u64 sum = 0;
int fd = eopen(file, O_RDONLY);
for (;;) {
- rc = read(fd, trace, sizeof(trace));
+ rc = read(fd, buf, sizeof(buf));
if (rc == -1)
fatal("read %s:", file);
if (rc == 0)
@@ -267,23 +303,39 @@
sum += rc;
}
eclose(fd);
- return sum / sizeof(struct Trace);
+ return sum;
}
static void read_trace(const char *file)
{
- u64 n = num_traces(file);
+ /*
+ * Because this is a sysfs file, we have to read it to get
+ * its size. Even if more data is appended to the file, we
+ * don't care, we just want the data up to this point in
+ * time.
+ */
+ u64 n = num_bytes(file);
ssize_t rc;
int fd;
+ char *b;
- Trace.tr = emalloc(n * sizeof(struct Trace));
- Trace.num = n;
+ Trace.tr = emalloc(n);
+ Trace.num = n / sizeof(struct bootcache_trace);
fd = eopen(file, O_RDONLY);
- rc = read(fd, Trace.tr, n * sizeof(struct Trace));
- if (rc == -1) {
- fatal("read %s:", file);
+ /*
+ * Because sysfs only returns a page at a time,
+ * will need to do the read in a loop.
+ */
+ for (b = (char *)Trace.tr; n; n -= rc, b += rc) {
+ rc = read(fd, b, n);
+ if (rc == -1) {
+ fatal("read %s:", file);
+ }
+ if (rc == 0) {
+ fatal("trying to read %lld bytes", n);
+ }
}
- dump_trace(Trace.tr, n);
+ dump_trace();
eclose(fd);
}
@@ -319,7 +371,7 @@
int rc;
fd = eopen(file, O_WRONLY);
- rc = pwrite(fd, &Header, sizeof(Header), Header_block << BLK_SHIFT);
+ rc = pwrite(fd, &Header, sizeof(Header), Header.sector << SECTOR_SHIFT);
if (rc != sizeof(Header)) {
fatal("pwrite %s rc=%d:", file, rc);
}
@@ -334,7 +386,7 @@
ssize_t size = Trace.num * sizeof(*Trace.tr);
fd = eopen(file, O_WRONLY);
- rc = pwrite(fd, Trace.tr, size, Trace_start);
+ rc = pwrite(fd, Trace.tr, size, Trace_start << SECTOR_SHIFT);
if (rc != size) {
fatal("pwrite %s rc=%ld size=%ld:", file, rc, size);
}
@@ -380,96 +432,77 @@
return buf[0] == '1';
}
-static void gen_file_name(char *file_name, int size,
- const char *fmt, const char *name)
+static void gen_file_name(char *file_name, int size, const char *fmt,
+ const char *prefix, const char *name)
{
int rc;
- rc = snprintf(file_name, size, fmt, name);
+ rc = snprintf(file_name, size, fmt, prefix, name);
if (rc >= size) {
fatal("Name too long %s", name);
}
}
-static void gen_file_names(const char *name)
+static void gen_file_names(const char *fmt, const char *device_mapper)
{
- gen_file_name(Device_file, sizeof(Device_file), "/dev/%s", name);
gen_file_name(Valid_file, sizeof(Valid_file),
- "/sys/kernel/debug/dm-bootcache/%s/valid", name);
+ fmt, device_mapper, "valid");
gen_file_name(Free_file, sizeof(Free_file),
- "/sys/kernel/debug/dm-bootcache/%s/free", name);
+ fmt, device_mapper, "free");
gen_file_name(Header_file, sizeof(Header_file),
- "/sys/kernel/debug/dm-bootcache/%s/header", name);
- gen_file_name(Trace_file, sizeof(Trace_file),
- "/sys/kernel/debug/dm-bootcache/%s/trace", name);
-}
-
-static void test_file_names(const char *name)
-{
- gen_file_name(Device_file, sizeof(Device_file),
- "/tmp/%s/dev", name);
- gen_file_name(Valid_file, sizeof(Valid_file),
- "/tmp/%s/valid", name);
- gen_file_name(Free_file, sizeof(Free_file),
- "/tmp/%s/free", name);
- gen_file_name(Header_file, sizeof(Header_file),
- "/tmp/%s/header", name);
- gen_file_name(Trace_file, sizeof(Trace_file),
- "/tmp/%s/trace", name);
+ fmt, device_mapper, "header");
+ gen_file_name(Blocktrace_file, sizeof(Blocktrace_file),
+ fmt, device_mapper, "blocktrace");
}
static void usage(void)
{
- fprintf(stderr, "Usage: %s [-t] <name>\n"
- " e.g %s dm-0\n",
+ fprintf(stderr, "Usage: %s [-t]"
+ " <device mapper> <raw partition>\n"
+ " e.g %s dm-0 /dev/sda3\n",
Progname, Progname);
exit(2);
}
int main(int argc, char *argv[])
{
- bool test = false;
- char *name = NULL;
+ char *device_mapper = NULL;
+ char *raw_partition = NULL;
+ openlog(Progname, LOG_PERROR | LOG_CONS | LOG_PID, 0);
+ syslog(LOG_ERR, "started\n");
for (;;) {
int c;
- c = getopt(argc, argv, "t?");
+ c = getopt(argc, argv, "?");
if (c == -1)
break;
switch (c) {
- case 't':
- test = true;
- break;
case '?':
default:
usage();
break;
}
}
- if (optind >= argc) {
+ if (optind+2 != argc) {
usage();
}
- name = argv[optind];
- if (test) {
- test_file_names(name);
- } else {
- gen_file_names(name);
- }
- if (is_valid(Valid_file)) {
- /* Because the boot cache is valid, the block
- * traces are not kept so the boot cache can't
- * be rebuilt. To force a rebuild of the cache,
- * zero the header.
+ device_mapper = argv[optind];
+ raw_partition = argv[optind + 1];
+ gen_file_names("/sys/devices/virtual/block/%s/dm/%s",
+ device_mapper);
+ if (!is_valid(Valid_file)) {
+ /*
+ * Rebuild the bootcache
*/
- return 0;
+ read_header(Header_file);
+ read_trace(Blocktrace_file);
+ compute_sections();
+ copy_blocks(raw_partition);
+ write_trace(raw_partition);
+ write_header(raw_partition);
}
- read_header(Header_file);
- read_trace(Trace_file);
- compute_sections();
- copy_blocks(Device_file);
- write_trace(Device_file);
- write_header(Device_file);
free_bootcache(Free_file);
+ syslog(LOG_ERR, "done\n");
return 0;
}
diff --git a/bootcache.conf b/bootcache.conf
new file mode 100644
index 0000000..27d00db
--- /dev/null
+++ b/bootcache.conf
@@ -0,0 +1,19 @@
+# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+description "Start the bootcache process"
+author "chromium-os-dev@chromium.org"
+
+# Starts the bootcache deamon that either creates the bootcache
+# or cleans it up after it is used.
+start on started system-services
+
+pre-start script
+ sleep 5 # Give a little extra time for chrome
+end script
+
+script
+ device=$(rootdev -s)
+ exec ionice -c3 bootcache dm-0 $device
+end script
diff --git a/dm-bootcache.h b/dm-bootcache.h
index af12df8..536911f 100644
--- a/dm-bootcache.h
+++ b/dm-bootcache.h
@@ -1,42 +1,44 @@
-/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
+/*
+ * Copyright 2012 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
*/
-#ifndef _BOOTCACHE_H
-#define _BOOTCACHE_H
+#ifndef DM_BOOTCACHE_H
+#define DM_BOOTCACHE_H
#include <linux/types.h>
-enum { BLK_SHIFT = 12,
- BLK_SIZE = 1<<BLK_SHIFT,
- BLK_MASK = BLK_SIZE - 1,
- SECTOR_BLOCK_SHIFT = 3,
- BOOTCACHE_MAGIC = 1651470196,
+enum { BOOTCACHE_MAGIC = 1651470196,
BOOTCACHE_VERSION = 2,
MAX_SIGNATURE = 256
};
-
-#define BLK_ALIGN(_x) (((_x) + BLK_MASK) >> BLK_SHIFT)
-
-struct Trace {
- __u64 blkno; /* Block number for data */
- __u64 count; /* Number of blocks in request */
- __u64 ino; /* Used for anaysis of traces */
+struct bootcache_trace {
+ __u64 sector; /* Sector offset */
+ __u64 count; /* Number of blocks traced */
+ __u64 ino; /* Inode number of file */
};
-struct Bootcache_hdr {
- __u64 blkno; /* Block number for where header is stored */
+struct bootcache_hdr {
+ __u64 sector; /* Sector offset where header is stored */
__u32 magic; /* Magic number */
__u32 version; /* Verion of boot cache */
__u32 state; /* Curent state */
- __u32 num_blks_meta; /* Size of trace data on disk */
- __u32 num_blks_data; /* Size of the data area */
- char date[12]; /* Date and time bootcache was compiled */
- char time[12];
+ __u32 num_trace_recs; /* Number of trace reords */
+ __u32 sectors_meta; /* Size of trace data on disk in sectors*/
+ __u32 sectors_data; /* Size of the data area in sectors*/
__u32 max_sectors; /* Max sectors that can to read */
__u32 max_hw_sectors; /* Max hardware sectore that can be read */
+ char date[12]; /* Date and time dm-bootcache was compiled */
+ char time[12];
char signature[MAX_SIGNATURE];
};
