summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ext4_utils/ext4_utils.c2
-rw-r--r--ext4_utils/ext4_utils.h1
-rw-r--r--ext4_utils/wipe.h2
-rw-r--r--kexec_tools/Android.mk23
-rw-r--r--kexec_tools/kexec.h24
-rw-r--r--kexec_tools/kexecload.c166
-rw-r--r--ksmutils/Android.mk30
-rw-r--r--ksmutils/MODULE_LICENSE_APACHE20
-rw-r--r--ksmutils/NOTICE190
-rw-r--r--ksmutils/ksminfo.c485
-rw-r--r--ksmutils/lookup3.c1002
-rw-r--r--libc_test/main.cpp420
-rw-r--r--memtrack/Android.mk55
-rw-r--r--memtrack/memtrack.cpp373
-rw-r--r--memtrack/memtrack.h123
-rw-r--r--tests/ext4/Android.mk2
-rwxr-xr-xtests/ext4/android_emmc_perf_tests.sh301
-rw-r--r--tests/ext4/rand_emmc_perf.c201
-rw-r--r--tests/mmc_tracepoints/README27
-rwxr-xr-xtests/mmc_tracepoints/mmc_trace_reduce152
-rw-r--r--tests/mmc_tracepoints/mmc_trace_sample_data1545
-rw-r--r--tests/uevents/Android.mk11
-rw-r--r--tests/uevents/uevents.c45
23 files changed, 4992 insertions, 188 deletions
diff --git a/ext4_utils/ext4_utils.c b/ext4_utils/ext4_utils.c
index c3bec965..d4fbc7c8 100644
--- a/ext4_utils/ext4_utils.c
+++ b/ext4_utils/ext4_utils.c
@@ -388,7 +388,7 @@ void ext4_update_free()
}
}
-static u64 get_block_device_size(int fd)
+u64 get_block_device_size(int fd)
{
u64 size = 0;
int ret;
diff --git a/ext4_utils/ext4_utils.h b/ext4_utils/ext4_utils.h
index 0a9bd564..adc7d9e5 100644
--- a/ext4_utils/ext4_utils.h
+++ b/ext4_utils/ext4_utils.h
@@ -174,6 +174,7 @@ void ext4_create_resize_inode(void);
void ext4_create_journal_inode(void);
void ext4_update_free(void);
void ext4_queue_sb(void);
+u64 get_block_device_size(int fd);
u64 get_file_size(int fd);
u64 parse_num(const char *arg);
void ext4_parse_sb(struct ext4_super_block *sb);
diff --git a/ext4_utils/wipe.h b/ext4_utils/wipe.h
index 814877d8..ecde9c14 100644
--- a/ext4_utils/wipe.h
+++ b/ext4_utils/wipe.h
@@ -17,6 +17,8 @@
#ifndef _WIPE_H_
#define _WIPE_H_
+#include "ext4_utils.h"
+
int wipe_block_device(int fd, s64 len);
#endif
diff --git a/kexec_tools/Android.mk b/kexec_tools/Android.mk
new file mode 100644
index 00000000..f6bf7dc2
--- /dev/null
+++ b/kexec_tools/Android.mk
@@ -0,0 +1,23 @@
+# Copyright (C) 2013 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Copyright The Android Open Source Project
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := kexecload
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := eng
+LOCAL_SRC_FILES := kexecload.c
+include $(BUILD_EXECUTABLE)
diff --git a/kexec_tools/kexec.h b/kexec_tools/kexec.h
new file mode 100644
index 00000000..2300ff56
--- /dev/null
+++ b/kexec_tools/kexec.h
@@ -0,0 +1,24 @@
+#ifndef _SYS_KEXEC_H
+#define _SYS_KEXEC_H
+
+#include <sys/cdefs.h>
+#include <uapi/linux/kexec.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include "kexec.h"
+
+#define KEXEC_SEGMENT_MAX 16
+
+#define KEXEC_TYPE_DEFAULT 0
+#define KEXEC_TYPE_CRASH 1
+
+/*
+ * Prototypes
+ */
+
+static inline long kexec_load(unsigned int entry, unsigned long nr_segments,
+ struct kexec_segment *segment, unsigned long flags) {
+ return syscall(__NR_kexec_load, entry, nr_segments, segment, flags);
+}
+
+#endif /* _SYS_KEXEC_H */
diff --git a/kexec_tools/kexecload.c b/kexec_tools/kexecload.c
new file mode 100644
index 00000000..2574e4a6
--- /dev/null
+++ b/kexec_tools/kexecload.c
@@ -0,0 +1,166 @@
+#include <errno.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "kexec.h"
+
+// Offsets same as in kernel asm/kexec.h
+#define KEXEC_ARM_ATAGS_OFFSET 0x1000
+#define KEXEC_ARM_ZIMAGE_OFFSET 0x8000
+
+#define MEMORY_SIZE 0x0800000
+// Physical buffer address cannot overlap with other regions
+#define START_ADDRESS 0x44000000
+
+#define ROUND_TO_PAGE(address,pagesize) ((address + pagesize - 1) & (~(pagesize - 1)))
+
+/*
+ * Gives file position and resets current position to begining of file
+ */
+int get_file_size(int f)
+{
+ struct stat st;
+ fstat(f, &st);
+ return st.st_size;
+}
+
+int test_kexeccall() {
+ int rv;
+
+ rv = kexec_load(0, 0, NULL, KEXEC_ARCH_DEFAULT);
+
+ if (rv != 0) {
+ printf("ERROR: kexec_load: %d \n", errno);
+ return 1;
+ }
+
+ printf("Kexec test: Success \n");
+
+ return 0;
+}
+
+void usage(void)
+{
+ fprintf(stderr,
+ "usage: kexecload [ <option> ] <atags path> <kernel path>\n"
+ "\n"
+ "options:\n"
+ " -t tests syscall\n"
+ " -s <start address> specify start address of kernel\n"
+ );
+}
+
+/*
+ * Loads kexec into the kernel and sets kexec on crash
+ */
+int main(int argc, char *argv[])
+{
+ int rv;
+ int atag_file,
+ zimage_file;
+ int atag_size,
+ zimage_size,
+ total_size;
+ void *atag_buffer;
+ void *zimage_buffer;
+ struct kexec_segment segment[2];
+ int page_size = getpagesize();
+ void *start_address = (void *)START_ADDRESS;
+ int c;
+
+ const struct option longopts[] = {
+ {"start_address", required_argument, 0, 's'},
+ {"test", 0, 0, 't'},
+ {"help", 0, 0, 'h'},
+ {0, 0, 0, 0}
+ };
+
+ while (1) {
+ int option_index = 0;
+ c = getopt_long(argc, argv, "s:th", longopts, NULL);
+ if (c < 0) {
+ break;
+ }
+ /* Alphabetical cases */
+ switch (c) {
+ case 's':
+ start_address = (void *) strtoul(optarg, 0, 16);
+ break;
+ case 'h':
+ usage();
+ return 1;
+ case 't':
+ test_kexeccall();
+ return 1;
+ case '?':
+ return 1;
+ default:
+ abort();
+ }
+ }
+
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 2) {
+ usage();
+ return 1;
+ }
+
+ atag_file = open(argv[0], O_RDONLY);
+ zimage_file = open(argv[1], O_RDONLY);
+
+ if (atag_file < 0 || zimage_file < 0) {
+ fprintf(stderr, "Error during opening of atag file or the zImage file %s\n", strerror(errno));
+ return 1;
+ }
+
+ atag_size = ROUND_TO_PAGE(get_file_size(atag_file), page_size);
+ zimage_size = ROUND_TO_PAGE(get_file_size(zimage_file), page_size);
+
+ if (atag_size >= KEXEC_ARM_ZIMAGE_OFFSET - KEXEC_ARM_ATAGS_OFFSET) {
+ fprintf(stderr, "Atag file is too large\n");
+ return 1;
+ }
+
+ atag_buffer = (char *) mmap(NULL, atag_size, PROT_READ, MAP_POPULATE | MAP_PRIVATE, atag_file, 0);
+ zimage_buffer = (char *) mmap(NULL, zimage_size, PROT_READ, MAP_POPULATE | MAP_PRIVATE, zimage_file, 0);
+
+ if(atag_buffer == MAP_FAILED || zimage_buffer == MAP_FAILED) {
+ fprintf(stderr, "Unable to map files into memory");
+ return 1;
+ }
+
+ segment[0].buf = zimage_buffer;
+ segment[0].bufsz = zimage_size;
+ segment[0].mem = (void *) ((unsigned) start_address + KEXEC_ARM_ZIMAGE_OFFSET);
+ segment[0].memsz = zimage_size;
+
+ segment[1].buf = atag_buffer;
+ segment[1].bufsz = atag_size;
+ segment[1].mem = (void *) ((unsigned) start_address + KEXEC_ARM_ATAGS_OFFSET);
+ segment[1].memsz = atag_size;
+
+ rv = kexec_load(((unsigned) start_address + KEXEC_ARM_ZIMAGE_OFFSET),
+ 2, (void *) segment, KEXEC_ARCH_DEFAULT | KEXEC_ON_CRASH);
+
+ if (rv != 0) {
+ fprintf(stderr, "Kexec_load returned non-zero exit code: %d with errno %d\n", rv, errno);
+ return 1;
+ }
+
+ printf("Done! Kexec loaded\n");
+ printf("New kernel should start at 0x%08x\n", START_ADDRESS + KEXEC_ARM_ZIMAGE_OFFSET);
+
+ return 0;
+
+}
+
diff --git a/ksmutils/Android.mk b/ksmutils/Android.mk
new file mode 100644
index 00000000..f34576d9
--- /dev/null
+++ b/ksmutils/Android.mk
@@ -0,0 +1,30 @@
+# Copyright (C) 2013 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := ksminfo.c lookup3.c
+
+LOCAL_C_INCLUDES := $(call include-path-for, libpagemap)
+
+LOCAL_SHARED_LIBRARIES := libpagemap
+
+LOCAL_MODULE := ksminfo
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+
+LOCAL_MODULE_TAGS := debug
+
+include $(BUILD_EXECUTABLE)
diff --git a/ksmutils/MODULE_LICENSE_APACHE2 b/ksmutils/MODULE_LICENSE_APACHE2
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/ksmutils/MODULE_LICENSE_APACHE2
diff --git a/ksmutils/NOTICE b/ksmutils/NOTICE
new file mode 100644
index 00000000..c5b1efa7
--- /dev/null
+++ b/ksmutils/NOTICE
@@ -0,0 +1,190 @@
+
+ Copyright (c) 2005-2008, The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
diff --git a/ksmutils/ksminfo.c b/ksmutils/ksminfo.c
new file mode 100644
index 00000000..eb3c024c
--- /dev/null
+++ b/ksmutils/ksminfo.c
@@ -0,0 +1,485 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <getopt.h>
+
+#include <pagemap/pagemap.h>
+
+#define MAX_FILENAME 64
+
+#define GROWTH_FACTOR 10
+
+#define NO_PATTERN 0x100
+
+#define PR_SORTED 1
+#define PR_VERBOSE 2
+#define PR_ALL 4
+
+struct vaddr {
+ unsigned long addr;
+ size_t num_pages;
+ pid_t pid;
+};
+
+struct ksm_page {
+ uint64_t count;
+ uint32_t hash;
+ struct vaddr *vaddr;
+ size_t vaddr_len, vaddr_size;
+ size_t vaddr_count;
+ uint16_t pattern;
+};
+
+struct ksm_pages {
+ struct ksm_page *pages;
+ size_t len, size;
+};
+
+static void usage(char *myname);
+static int getprocname(pid_t pid, char *buf, int len);
+static int read_pages(struct ksm_pages *kp, pm_map_t **maps, size_t num_maps, uint8_t pr_flags);
+static void print_pages(struct ksm_pages *kp, uint8_t pr_flags);
+static void free_pages(struct ksm_pages *kp, uint8_t pr_flags);
+static bool is_pattern(uint8_t *data, size_t len);
+static int cmp_pages(const void *a, const void *b);
+extern uint32_t hashword(const uint32_t *, size_t, int32_t);
+
+int main(int argc, char *argv[]) {
+ pm_kernel_t *ker;
+ pm_process_t *proc;
+ pid_t *pids;
+ size_t num_procs;
+ size_t i;
+ pm_map_t **maps;
+ size_t num_maps;
+ char cmdline[256]; // this must be within the range of int
+ int error;
+ int rc = EXIT_SUCCESS;
+ uint8_t pr_flags = 0;
+ struct ksm_pages kp;
+
+ memset(&kp, 0, sizeof(kp));
+
+ opterr = 0;
+ do {
+ int c = getopt(argc, argv, "hvsa");
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'a':
+ pr_flags |= PR_ALL;
+ break;
+ case 's':
+ pr_flags |= PR_SORTED;
+ break;
+ case 'v':
+ pr_flags |= PR_VERBOSE;
+ break;
+ case 'h':
+ usage(argv[0]);
+ exit(EXIT_SUCCESS);
+ case '?':
+ fprintf(stderr, "unknown option: %c\n", optopt);
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ } while (1);
+
+ error = pm_kernel_create(&ker);
+ if (error) {
+ fprintf(stderr, "Error creating kernel interface -- "
+ "does this kernel have pagemap?\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (pr_flags & PR_ALL) {
+ error = pm_kernel_pids(ker, &pids, &num_procs);
+ if (error) {
+ fprintf(stderr, "Error listing processes.\n");
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ if (optind != argc - 1) {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+
+ pids = malloc(sizeof(*pids));
+ if (pids == NULL) {
+ fprintf(stderr, "Error allocating pid memory\n");
+ exit(EXIT_FAILURE);
+ }
+
+ *pids = strtoul(argv[optind], NULL, 10);
+ if (*pids == 0) {
+ fprintf(stderr, "Invalid PID\n");
+ rc = EXIT_FAILURE;
+ goto exit;
+ }
+ num_procs = 1;
+ if (getprocname(*pids, cmdline, sizeof(cmdline)) < 0) {
+ cmdline[0] = '\0';
+ }
+ printf("%s (%u):\n", cmdline, *pids);
+ }
+
+ printf("Warning: this tool only compares the KSM CRCs of pages, there is a chance of "
+ "collisions\n");
+
+ for (i = 0; i < num_procs; i++) {
+ error = pm_process_create(ker, pids[i], &proc);
+ if (error) {
+ fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]);
+ rc = EXIT_FAILURE;
+ goto exit;
+ }
+
+ error = pm_process_maps(proc, &maps, &num_maps);
+ if (error) {
+ pm_process_destroy(proc);
+ fprintf(stderr, "warning: could not read process map for %d\n", pids[i]);
+ rc = EXIT_FAILURE;
+ goto exit;
+ }
+
+ if (read_pages(&kp, maps, num_maps, pr_flags) < 0) {
+ free(maps);
+ pm_process_destroy(proc);
+ rc = EXIT_FAILURE;
+ goto exit;
+ }
+
+ free(maps);
+ pm_process_destroy(proc);
+ }
+
+ if (pr_flags & PR_SORTED) {
+ qsort(kp.pages, kp.len, sizeof(*kp.pages), cmp_pages);
+ }
+ print_pages(&kp, pr_flags);
+
+exit:
+ free_pages(&kp, pr_flags);
+ free(pids);
+ return rc;
+}
+
+static int read_pages(struct ksm_pages *kp, pm_map_t **maps, size_t num_maps, uint8_t pr_flags) {
+ size_t i, j, k;
+ size_t len;
+ uint64_t *pagemap;
+ size_t map_len;
+ uint64_t flags;
+ pm_kernel_t *ker;
+ int error;
+ unsigned long vaddr;
+ int fd;
+ off_t off;
+ char filename[MAX_FILENAME];
+ uint32_t *data;
+ uint32_t hash;
+ int rc = 0;
+ struct ksm_page *cur_page;
+ pid_t pid;
+
+ if (num_maps == 0)
+ return 0;
+
+ pid = pm_process_pid(maps[0]->proc);
+ ker = maps[0]->proc->ker;
+ error = snprintf(filename, MAX_FILENAME, "/proc/%d/mem", pid);
+ if (error < 0 || error >= MAX_FILENAME) {
+ return -1;
+ }
+
+ data = malloc(pm_kernel_pagesize(ker));
+ if (data == NULL) {
+ fprintf(stderr, "warning: not enough memory to malloc data buffer\n");
+ return -1;
+ }
+
+ fd = open(filename, O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "warning: could not open %s\n", filename);
+ rc = -1;
+ goto err_open;
+ }
+
+ for (i = 0; i < num_maps; i++) {
+ error = pm_map_pagemap(maps[i], &pagemap, &map_len);
+ if (error) {
+ fprintf(stderr, "warning: could not read the pagemap of %d\n",
+ pm_process_pid(maps[i]->proc));
+ continue;
+ }
+ for (j = 0; j < map_len; j++) {
+ error = pm_kernel_flags(ker, pagemap[j], &flags);
+ if (error) {
+ fprintf(stderr, "warning: could not read flags for pfn at address 0x%016llx\n",
+ pagemap[i]);
+ continue;
+ }
+ if (!(flags & PM_PAGE_KSM)) {
+ continue;
+ }
+ vaddr = pm_map_start(maps[i]) + j * pm_kernel_pagesize(ker);
+ off = lseek(fd, vaddr, SEEK_SET);
+ if (off == (off_t)-1) {
+ fprintf(stderr, "warning: could not lseek to 0x%08lx\n", vaddr);
+ continue;
+ }
+ len = read(fd, data, pm_kernel_pagesize(ker));
+ if (len != pm_kernel_pagesize(ker)) {
+ fprintf(stderr, "warning: could not read page at 0x%08lx\n", vaddr);
+ continue;
+ }
+
+ hash = hashword(data, pm_kernel_pagesize(ker) / sizeof(*data), 17);
+
+ for (k = 0; k < kp->len; k++) {
+ if (kp->pages[k].hash == hash) break;
+ }
+
+ if (k == kp->len) {
+ if (kp->len == kp->size) {
+ struct ksm_page *tmp = realloc(kp->pages,
+ (kp->size + GROWTH_FACTOR) * sizeof(*kp->pages));
+ if (tmp == NULL) {
+ fprintf(stderr, "warning: not enough memory to realloc pages struct\n");
+ free(pagemap);
+ rc = -1;
+ goto err_realloc;
+ }
+ memset(&tmp[k], 0, sizeof(tmp[k]) * GROWTH_FACTOR);
+ kp->pages = tmp;
+ kp->size += GROWTH_FACTOR;
+ }
+ rc = pm_kernel_count(ker, pagemap[j], &kp->pages[kp->len].count);
+ if (rc) {
+ fprintf(stderr, "error reading page count\n");
+ free(pagemap);
+ goto err_count;
+ }
+ kp->pages[kp->len].hash = hash;
+ kp->pages[kp->len].pattern =
+ is_pattern((uint8_t *)data, pm_kernel_pagesize(ker)) ?
+ (data[0] & 0xFF) : NO_PATTERN;
+ kp->len++;
+ }
+
+ cur_page = &kp->pages[k];
+
+ if (pr_flags & PR_VERBOSE) {
+ if (cur_page->vaddr_len > 0 &&
+ cur_page->vaddr[cur_page->vaddr_len - 1].pid == pid &&
+ cur_page->vaddr[cur_page->vaddr_len - 1].addr ==
+ vaddr - (cur_page->vaddr[cur_page->vaddr_len - 1].num_pages *
+ pm_kernel_pagesize(ker))) {
+ cur_page->vaddr[cur_page->vaddr_len - 1].num_pages++;
+ } else {
+ if (cur_page->vaddr_len == cur_page->vaddr_size) {
+ struct vaddr *tmp = realloc(cur_page->vaddr,
+ (cur_page->vaddr_size + GROWTH_FACTOR) * sizeof(*(cur_page->vaddr)));
+ if (tmp == NULL) {
+ fprintf(stderr, "warning: not enough memory to realloc vaddr array\n");
+ free(pagemap);
+ rc = -1;
+ goto err_realloc;
+ }
+ memset(&tmp[cur_page->vaddr_len], 0, sizeof(tmp[cur_page->vaddr_len]) * GROWTH_FACTOR);
+ cur_page->vaddr = tmp;
+ cur_page->vaddr_size += GROWTH_FACTOR;
+ }
+ cur_page->vaddr[cur_page->vaddr_len].addr = vaddr;
+ cur_page->vaddr[cur_page->vaddr_len].num_pages = 1;
+ cur_page->vaddr[cur_page->vaddr_len].pid = pid;
+ cur_page->vaddr_len++;
+ }
+ }
+ cur_page->vaddr_count++;
+ }
+ free(pagemap);
+ }
+ goto no_err;
+
+err_realloc:
+err_count:
+ if (pr_flags & PR_VERBOSE) {
+ for (i = 0; i < kp->len; i++) {
+ free(kp->pages[i].vaddr);
+ }
+ }
+ free(kp->pages);
+
+no_err:
+ close(fd);
+err_open:
+ free(data);
+ return rc;
+}
+
+static void print_pages(struct ksm_pages *kp, uint8_t pr_flags) {
+ size_t i, j, k;
+ char suffix[13];
+ int index;
+
+ for (i = 0; i < kp->len; i++) {
+ if (kp->pages[i].pattern != NO_PATTERN) {
+ printf("0x%02x byte pattern: ", kp->pages[i].pattern);
+ } else {
+ printf("KSM CRC 0x%08x:", kp->pages[i].hash);
+ }
+ printf(" %4d page", kp->pages[i].vaddr_count);
+ if (kp->pages[i].vaddr_count > 1) {
+ printf("s");
+ }
+ if (!(pr_flags & PR_ALL)) {
+ printf(" (%llu reference", kp->pages[i].count);
+ if (kp->pages[i].count > 1) {
+ printf("s");
+ }
+ printf(")");
+ }
+ printf("\n");
+
+ if (pr_flags & PR_VERBOSE) {
+ j = 0;
+ while (j < kp->pages[i].vaddr_len) {
+ printf(" ");
+ for (k = 0; k < 8 && j < kp->pages[i].vaddr_len; k++, j++) {
+ printf(" 0x%08lx", kp->pages[i].vaddr[j].addr);
+
+ index = snprintf(suffix, sizeof(suffix), ":%d",
+ kp->pages[i].vaddr[j].num_pages);
+ if (pr_flags & PR_ALL) {
+ index += snprintf(suffix + index, sizeof(suffix) - index, "[%d]",
+ kp->pages[i].vaddr[j].pid);
+ }
+ printf("%-12s", suffix);
+ }
+ printf("\n");
+ }
+ }
+ }
+}
+
+static void free_pages(struct ksm_pages *kp, uint8_t pr_flags) {
+ size_t i;
+
+ if (pr_flags & PR_VERBOSE) {
+ for (i = 0; i < kp->len; i++) {
+ free(kp->pages[i].vaddr);
+ }
+ }
+ free(kp->pages);
+}
+
+static void usage(char *myname) {
+ fprintf(stderr, "Usage: %s [-s | -v | -a | -h ] <pid>\n"
+ " -s Sort pages by usage count.\n"
+ " -v Verbose: print virtual addresses.\n"
+ " -a Display all the KSM pages in the system. Ignore the pid argument.\n"
+ " -h Display this help screen.\n",
+ myname);
+}
+
+static int cmp_pages(const void *a, const void *b) {
+ const struct ksm_page *pg_a = a;
+ const struct ksm_page *pg_b = b;
+ int cmp = pg_b->vaddr_count - pg_a->vaddr_count;
+
+ return cmp ? cmp : pg_b->count - pg_a->count;
+}
+
+static bool is_pattern(uint8_t *data, size_t len) {
+ size_t i;
+ uint8_t first_byte = data[0];
+
+ for (i = 1; i < len; i++) {
+ if (first_byte != data[i]) return false;
+ }
+
+ return true;
+}
+
+/*
+ * Get the process name for a given PID. Inserts the process name into buffer
+ * buf of length len. The size of the buffer must be greater than zero to get
+ * any useful output.
+ *
+ * Note that fgets(3) only declares length as an int, so our buffer size is
+ * also declared as an int.
+ *
+ * Returns 0 on success, a positive value on partial success, and -1 on
+ * failure. Other interesting values:
+ * 1 on failure to create string to examine proc cmdline entry
+ * 2 on failure to open proc cmdline entry
+ * 3 on failure to read proc cmdline entry
+ */
+static int getprocname(pid_t pid, char *buf, int len) {
+ char *filename;
+ FILE *f;
+ int rc = 0;
+ static const char* unknown_cmdline = "<unknown>";
+
+ if (len <= 0) {
+ return -1;
+ }
+
+ if (asprintf(&filename, "/proc/%zd/cmdline", pid) < 0) {
+ rc = 1;
+ goto exit;
+ }
+
+ f = fopen(filename, "r");
+ if (f == NULL) {
+ rc = 2;
+ goto releasefilename;
+ }
+
+ if (fgets(buf, len, f) == NULL) {
+ rc = 3;
+ goto closefile;
+ }
+
+closefile:
+ (void) fclose(f);
+releasefilename:
+ free(filename);
+exit:
+ if (rc != 0) {
+ /*
+ * The process went away before we could read its process name. Try
+ * to give the user "<unknown>" here, but otherwise they get to look
+ * at a blank.
+ */
+ if (strlcpy(buf, unknown_cmdline, (size_t)len) >= (size_t)len) {
+ rc = 4;
+ }
+ }
+
+ return rc;
+}
+
diff --git a/ksmutils/lookup3.c b/ksmutils/lookup3.c
new file mode 100644
index 00000000..e6072958
--- /dev/null
+++ b/ksmutils/lookup3.c
@@ -0,0 +1,1002 @@
+/*
+-------------------------------------------------------------------------------
+lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+
+These are functions for producing 32-bit hashes for hash table lookup.
+hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final()
+are externally useful functions. Routines to test the hash are included
+if SELF_TEST is defined. You can use this free for any purpose. It's in
+the public domain. It has no warranty.
+
+You probably want to use hashlittle(). hashlittle() and hashbig()
+hash byte arrays. hashlittle() is is faster than hashbig() on
+little-endian machines. Intel and AMD are little-endian machines.
+On second thought, you probably want hashlittle2(), which is identical to
+hashlittle() except it returns two 32-bit hashes for the price of one.
+You could implement hashbig2() if you wanted but I haven't bothered here.
+
+If you want to find a hash of, say, exactly 7 integers, do
+ a = i1; b = i2; c = i3;
+ mix(a,b,c);
+ a += i4; b += i5; c += i6;
+ mix(a,b,c);
+ a += i7;
+ final(a,b,c);
+then use c as the hash value. If you have a variable length array of
+4-byte integers to hash, use hashword(). If you have a byte array (like
+a character string), use hashlittle(). If you have several byte arrays, or
+a mix of things, see the comments above hashlittle().
+
+Why is this so big? I read 12 bytes at a time into 3 4-byte integers,
+then mix those integers. This is fast (you can do a lot more thorough
+mixing with 12*3 instructions on 3 integers than you can with 3 instructions
+on 1 byte), but shoehorning those bytes into integers efficiently is messy.
+-------------------------------------------------------------------------------
+*/
+#define SELF_TEST 1
+#undef SELF_TEST
+
+#include <stdio.h> /* defines printf for tests */
+#include <time.h> /* defines time_t for timings in the test */
+#include <stdint.h> /* defines uint32_t etc */
+#include <sys/param.h> /* attempt to define endianness */
+#ifdef linux
+# include <endian.h> /* attempt to define endianness */
+#endif
+
+/*
+ * My best guess at if you are big-endian or little-endian. This may
+ * need adjustment.
+ */
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
+ __BYTE_ORDER == __LITTLE_ENDIAN) || \
+ (defined(i386) || defined(__i386__) || defined(__i486__) || \
+ defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
+# define HASH_LITTLE_ENDIAN 1
+# define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
+ __BYTE_ORDER == __BIG_ENDIAN) || \
+ (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 1
+#else
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 0
+#endif
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+/*
+-------------------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+
+This is reversible, so any information in (a,b,c) before mix() is
+still in (a,b,c) after mix().
+
+If four pairs of (a,b,c) inputs are run through mix(), or through
+mix() in reverse, there are at least 32 bits of the output that
+are sometimes the same for one pair and different for another pair.
+This was tested for:
+* pairs that differed by one bit, by two bits, in any combination
+ of top bits of (a,b,c), or in any combination of bottom bits of
+ (a,b,c).
+* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
+ the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ is commonly produced by subtraction) look like a single 1-bit
+ difference.
+* the base values were pseudorandom, all zero but one bit set, or
+ all zero plus a counter that starts at zero.
+
+Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
+satisfy this are
+ 4 6 8 16 19 4
+ 9 15 3 18 27 15
+ 14 9 3 7 17 3
+Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
+for "differ" defined as + with a one-bit base and a two-bit delta. I
+used http://burtleburtle.net/bob/hash/avalanche.html to choose
+the operations, constants, and arrangements of the variables.
+
+This does not achieve avalanche. There are input bits of (a,b,c)
+that fail to affect some output bits of (a,b,c), especially of a. The
+most thoroughly mixed value is c, but it doesn't really even achieve
+avalanche in c.
+
+This allows some parallelism. Read-after-writes are good at doubling
+the number of bits affected, so the goal of mixing pulls in the opposite
+direction as the goal of parallelism. I did what I could. Rotates
+seem to cost as much as shifts on every machine I could lay my hands
+on, and rotates are much kinder to the top and bottom bits, so I used
+rotates.
+-------------------------------------------------------------------------------
+*/
+#define mix(a,b,c) \
+{ \
+ a -= c; a ^= rot(c, 4); c += b; \
+ b -= a; b ^= rot(a, 6); a += c; \
+ c -= b; c ^= rot(b, 8); b += a; \
+ a -= c; a ^= rot(c,16); c += b; \
+ b -= a; b ^= rot(a,19); a += c; \
+ c -= b; c ^= rot(b, 4); b += a; \
+}
+
+/*
+-------------------------------------------------------------------------------
+final -- final mixing of 3 32-bit values (a,b,c) into c
+
+Pairs of (a,b,c) values differing in only a few bits will usually
+produce values of c that look totally different. This was tested for
+* pairs that differed by one bit, by two bits, in any combination
+ of top bits of (a,b,c), or in any combination of bottom bits of
+ (a,b,c).
+* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
+ the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ is commonly produced by subtraction) look like a single 1-bit
+ difference.
+* the base values were pseudorandom, all zero but one bit set, or
+ all zero plus a counter that starts at zero.
+
+These constants passed:
+ 14 11 25 16 4 14 24
+ 12 14 25 16 4 14 24
+and these came close:
+ 4 8 15 26 3 22 24
+ 10 8 15 26 3 22 24
+ 11 8 15 26 3 22 24
+-------------------------------------------------------------------------------
+*/
+#define final(a,b,c) \
+{ \
+ c ^= b; c -= rot(b,14); \
+ a ^= c; a -= rot(c,11); \
+ b ^= a; b -= rot(a,25); \
+ c ^= b; c -= rot(b,16); \
+ a ^= c; a -= rot(c,4); \
+ b ^= a; b -= rot(a,14); \
+ c ^= b; c -= rot(b,24); \
+}
+
+/*
+--------------------------------------------------------------------
+ This works on all machines. To be useful, it requires
+ -- that the key be an array of uint32_t's, and
+ -- that the length be the number of uint32_t's in the key
+
+ The function hashword() is identical to hashlittle() on little-endian
+ machines, and identical to hashbig() on big-endian machines,
+ except that the length has to be measured in uint32_ts rather than in
+ bytes. hashlittle() is more complicated than hashword() only because
+ hashlittle() has to dance around fitting the key bytes into registers.
+--------------------------------------------------------------------
+*/
+uint32_t hashword(
+const uint32_t *k, /* the key, an array of uint32_t values */
+size_t length, /* the length of the key, in uint32_ts */
+uint32_t initval) /* the previous hash, or an arbitrary value */
+{
+ uint32_t a,b,c;
+
+ /* Set up the internal state */
+ a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
+
+ /*------------------------------------------------- handle most of the key */
+ while (length > 3)
+ {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 3;
+ k += 3;
+ }
+
+ /*------------------------------------------- handle the last 3 uint32_t's */
+ switch(length) /* all the case statements fall through */
+ {
+ case 3 : c+=k[2];
+ case 2 : b+=k[1];
+ case 1 : a+=k[0];
+ final(a,b,c);
+ case 0: /* case 0: nothing left to add */
+ break;
+ }
+ /*------------------------------------------------------ report the result */
+ return c;
+}
+
+
+/*
+--------------------------------------------------------------------
+hashword2() -- same as hashword(), but take two seeds and return two
+32-bit values. pc and pb must both be nonnull, and *pc and *pb must
+both be initialized with seeds. If you pass in (*pb)==0, the output
+(*pc) will be the same as the return value from hashword().
+--------------------------------------------------------------------
+*/
+void hashword2 (
+const uint32_t *k, /* the key, an array of uint32_t values */
+size_t length, /* the length of the key, in uint32_ts */
+uint32_t *pc, /* IN: seed OUT: primary hash value */
+uint32_t *pb) /* IN: more seed OUT: secondary hash value */
+{
+ uint32_t a,b,c;
+
+ /* Set up the internal state */
+ a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + *pc;
+ c += *pb;
+
+ /*------------------------------------------------- handle most of the key */
+ while (length > 3)
+ {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 3;
+ k += 3;
+ }
+
+ /*------------------------------------------- handle the last 3 uint32_t's */
+ switch(length) /* all the case statements fall through */
+ {
+ case 3 : c+=k[2];
+ case 2 : b+=k[1];
+ case 1 : a+=k[0];
+ final(a,b,c);
+ case 0: /* case 0: nothing left to add */
+ break;
+ }
+ /*------------------------------------------------------ report the result */
+ *pc=c; *pb=b;
+}
+
+
+/*
+-------------------------------------------------------------------------------
+hashlittle() -- hash a variable-length key into a 32-bit value
+ k : the key (the unaligned variable-length array of bytes)
+ length : the length of the key, counting by bytes
+ initval : can be any 4-byte value
+Returns a 32-bit value. Every bit of the key affects every bit of
+the return value. Two keys differing by one or two bits will have
+totally different hash values.
+
+The best hash table sizes are powers of 2. There is no need to do
+mod a prime (mod is sooo slow!). If you need less than 32 bits,
+use a bitmask. For example, if you need only 10 bits, do
+ h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (uint8_t **)k, do it like this:
+ for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
+
+By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
+code any way you wish, private, educational, or commercial. It's free.
+
+Use for hash table lookup, or anything where one collision in 2^^32 is
+acceptable. Do NOT use for cryptographic purposes.
+-------------------------------------------------------------------------------
+*/
+
+uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
+{
+ uint32_t a,b,c; /* internal state */
+ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
+
+ /* Set up the internal state */
+ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+ u.ptr = key;
+ if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+ const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
+ const uint8_t *k8;
+
+ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 12;
+ k += 3;
+ }
+
+ /*----------------------------- handle the last (probably partial) block */
+ /*
+ * "k[2]&0xffffff" actually reads beyond the end of the string, but
+ * then masks off the part it's not allowed to read. Because the
+ * string is aligned, the masked-off tail is in the same word as the
+ * rest of the string. Every machine with memory protection I've seen
+ * does it on word boundaries, so is OK with this. But VALGRIND will
+ * still catch it and complain. The masking trick does make the hash
+ * noticably faster for short strings (like English words).
+ */
+#ifndef VALGRIND
+
+ switch(length)
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+ case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+ case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+ case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+ case 5 : b+=k[1]&0xff; a+=k[0]; break;
+ case 4 : a+=k[0]; break;
+ case 3 : a+=k[0]&0xffffff; break;
+ case 2 : a+=k[0]&0xffff; break;
+ case 1 : a+=k[0]&0xff; break;
+ case 0 : return c; /* zero length strings require no mixing */
+ }
+
+#else /* make valgrind happy */
+
+ k8 = (const uint8_t *)k;
+ switch(length)
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
+ case 10: c+=((uint32_t)k8[9])<<8; /* fall through */
+ case 9 : c+=k8[8]; /* fall through */
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
+ case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */
+ case 5 : b+=k8[4]; /* fall through */
+ case 4 : a+=k[0]; break;
+ case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
+ case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */
+ case 1 : a+=k8[0]; break;
+ case 0 : return c;
+ }
+
+#endif /* !valgrind */
+
+ } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+ const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
+ const uint8_t *k8;
+
+ /*--------------- all but last block: aligned reads and different mixing */
+ while (length > 12)
+ {
+ a += k[0] + (((uint32_t)k[1])<<16);
+ b += k[2] + (((uint32_t)k[3])<<16);
+ c += k[4] + (((uint32_t)k[5])<<16);
+ mix(a,b,c);
+ length -= 12;
+ k += 6;
+ }
+
+ /*----------------------------- handle the last (probably partial) block */
+ k8 = (const uint8_t *)k;
+ switch(length)
+ {
+ case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+ b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
+ case 10: c+=k[4];
+ b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 9 : c+=k8[8]; /* fall through */
+ case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
+ case 6 : b+=k[2];
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 5 : b+=k8[4]; /* fall through */
+ case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
+ case 2 : a+=k[0];
+ break;
+ case 1 : a+=k8[0];
+ break;
+ case 0 : return c; /* zero length requires no mixing */
+ }
+
+ } else { /* need to read the key one byte at a time */
+ const uint8_t *k = (const uint8_t *)key;
+
+ /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += k[0];
+ a += ((uint32_t)k[1])<<8;
+ a += ((uint32_t)k[2])<<16;
+ a += ((uint32_t)k[3])<<24;
+ b += k[4];
+ b += ((uint32_t)k[5])<<8;
+ b += ((uint32_t)k[6])<<16;
+ b += ((uint32_t)k[7])<<24;
+ c += k[8];
+ c += ((uint32_t)k[9])<<8;
+ c += ((uint32_t)k[10])<<16;
+ c += ((uint32_t)k[11])<<24;
+ mix(a,b,c);
+ length -= 12;
+ k += 12;
+ }
+
+ /*-------------------------------- last block: affect all 32 bits of (c) */
+ switch(length) /* all the case statements fall through */
+ {
+ case 12: c+=((uint32_t)k[11])<<24;
+ case 11: c+=((uint32_t)k[10])<<16;
+ case 10: c+=((uint32_t)k[9])<<8;
+ case 9 : c+=k[8];
+ case 8 : b+=((uint32_t)k[7])<<24;
+ case 7 : b+=((uint32_t)k[6])<<16;
+ case 6 : b+=((uint32_t)k[5])<<8;
+ case 5 : b+=k[4];
+ case 4 : a+=((uint32_t)k[3])<<24;
+ case 3 : a+=((uint32_t)k[2])<<16;
+ case 2 : a+=((uint32_t)k[1])<<8;
+ case 1 : a+=k[0];
+ break;
+ case 0 : return c;
+ }
+ }
+
+ final(a,b,c);
+ return c;
+}
+
+
+/*
+ * hashlittle2: return 2 32-bit hash values
+ *
+ * This is identical to hashlittle(), except it returns two 32-bit hash
+ * values instead of just one. This is good enough for hash table
+ * lookup with 2^^64 buckets, or if you want a second hash if you're not
+ * happy with the first, or if you want a probably-unique 64-bit ID for
+ * the key. *pc is better mixed than *pb, so use *pc first. If you want
+ * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)".
+ */
+void hashlittle2(
+ const void *key, /* the key to hash */
+ size_t length, /* length of the key */
+ uint32_t *pc, /* IN: primary initval, OUT: primary hash */
+ uint32_t *pb) /* IN: secondary initval, OUT: secondary hash */
+{
+ uint32_t a,b,c; /* internal state */
+ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
+
+ /* Set up the internal state */
+ a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc;
+ c += *pb;
+
+ u.ptr = key;
+ if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+ const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
+ const uint8_t *k8;
+
+ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 12;
+ k += 3;
+ }
+
+ /*----------------------------- handle the last (probably partial) block */
+ /*
+ * "k[2]&0xffffff" actually reads beyond the end of the string, but
+ * then masks off the part it's not allowed to read. Because the
+ * string is aligned, the masked-off tail is in the same word as the
+ * rest of the string. Every machine with memory protection I've seen
+ * does it on word boundaries, so is OK with this. But VALGRIND will
+ * still catch it and complain. The masking trick does make the hash
+ * noticably faster for short strings (like English words).
+ */
+#ifndef VALGRIND
+
+ switch(length)
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+ case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+ case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+ case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+ case 5 : b+=k[1]&0xff; a+=k[0]; break;
+ case 4 : a+=k[0]; break;
+ case 3 : a+=k[0]&0xffffff; break;
+ case 2 : a+=k[0]&0xffff; break;
+ case 1 : a+=k[0]&0xff; break;
+ case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */
+ }
+
+#else /* make valgrind happy */
+
+ k8 = (const uint8_t *)k;
+ switch(length)
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
+ case 10: c+=((uint32_t)k8[9])<<8; /* fall through */
+ case 9 : c+=k8[8]; /* fall through */
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
+ case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */
+ case 5 : b+=k8[4]; /* fall through */
+ case 4 : a+=k[0]; break;
+ case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
+ case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */
+ case 1 : a+=k8[0]; break;
+ case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */
+ }
+
+#endif /* !valgrind */
+
+ } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+ const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
+ const uint8_t *k8;
+
+ /*--------------- all but last block: aligned reads and different mixing */
+ while (length > 12)
+ {
+ a += k[0] + (((uint32_t)k[1])<<16);
+ b += k[2] + (((uint32_t)k[3])<<16);
+ c += k[4] + (((uint32_t)k[5])<<16);
+ mix(a,b,c);
+ length -= 12;
+ k += 6;
+ }
+
+ /*----------------------------- handle the last (probably partial) block */
+ k8 = (const uint8_t *)k;
+ switch(length)
+ {
+ case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+ b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
+ case 10: c+=k[4];
+ b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 9 : c+=k8[8]; /* fall through */
+ case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
+ case 6 : b+=k[2];
+ a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 5 : b+=k8[4]; /* fall through */
+ case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
+ case 2 : a+=k[0];
+ break;
+ case 1 : a+=k8[0];
+ break;
+ case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */
+ }
+
+ } else { /* need to read the key one byte at a time */
+ const uint8_t *k = (const uint8_t *)key;
+
+ /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += k[0];
+ a += ((uint32_t)k[1])<<8;
+ a += ((uint32_t)k[2])<<16;
+ a += ((uint32_t)k[3])<<24;
+ b += k[4];
+ b += ((uint32_t)k[5])<<8;
+ b += ((uint32_t)k[6])<<16;
+ b += ((uint32_t)k[7])<<24;
+ c += k[8];
+ c += ((uint32_t)k[9])<<8;
+ c += ((uint32_t)k[10])<<16;
+ c += ((uint32_t)k[11])<<24;
+ mix(a,b,c);
+ length -= 12;
+ k += 12;
+ }
+
+ /*-------------------------------- last block: affect all 32 bits of (c) */
+ switch(length) /* all the case statements fall through */
+ {
+ case 12: c+=((uint32_t)k[11])<<24;
+ case 11: c+=((uint32_t)k[10])<<16;
+ case 10: c+=((uint32_t)k[9])<<8;
+ case 9 : c+=k[8];
+ case 8 : b+=((uint32_t)k[7])<<24;
+ case 7 : b+=((uint32_t)k[6])<<16;
+ case 6 : b+=((uint32_t)k[5])<<8;
+ case 5 : b+=k[4];
+ case 4 : a+=((uint32_t)k[3])<<24;
+ case 3 : a+=((uint32_t)k[2])<<16;
+ case 2 : a+=((uint32_t)k[1])<<8;
+ case 1 : a+=k[0];
+ break;
+ case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */
+ }
+ }
+
+ final(a,b,c);
+ *pc=c; *pb=b;
+}
+
+
+
+/*
+ * hashbig():
+ * This is the same as hashword() on big-endian machines. It is different
+ * from hashlittle() on all machines. hashbig() takes advantage of
+ * big-endian byte ordering.
+ */
+uint32_t hashbig( const void *key, size_t length, uint32_t initval)
+{
+ uint32_t a,b,c;
+ union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
+
+ /* Set up the internal state */
+ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+ u.ptr = key;
+ if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
+ const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
+ const uint8_t *k8;
+
+ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ mix(a,b,c);
+ length -= 12;
+ k += 3;
+ }
+
+ /*----------------------------- handle the last (probably partial) block */
+ /*
+ * "k[2]<<8" actually reads beyond the end of the string, but
+ * then shifts out the part it's not allowed to read. Because the
+ * string is aligned, the illegal read is in the same word as the
+ * rest of the string. Every machine with memory protection I've seen
+ * does it on word boundaries, so is OK with this. But VALGRIND will
+ * still catch it and complain. The masking trick does make the hash
+ * noticably faster for short strings (like English words).
+ */
+#ifndef VALGRIND
+
+ switch(length)
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
+ case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
+ case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
+ case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
+ case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
+ case 4 : a+=k[0]; break;
+ case 3 : a+=k[0]&0xffffff00; break;
+ case 2 : a+=k[0]&0xffff0000; break;
+ case 1 : a+=k[0]&0xff000000; break;
+ case 0 : return c; /* zero length strings require no mixing */
+ }
+
+#else /* make valgrind happy */
+
+ k8 = (const uint8_t *)k;
+ switch(length) /* all the case statements fall through */
+ {
+ case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c+=((uint32_t)k8[10])<<8; /* fall through */
+ case 10: c+=((uint32_t)k8[9])<<16; /* fall through */
+ case 9 : c+=((uint32_t)k8[8])<<24; /* fall through */
+ case 8 : b+=k[1]; a+=k[0]; break;
+ case 7 : b+=((uint32_t)k8[6])<<8; /* fall through */
+ case 6 : b+=((uint32_t)k8[5])<<16; /* fall through */
+ case 5 : b+=((uint32_t)k8[4])<<24; /* fall through */
+ case 4 : a+=k[0]; break;
+ case 3 : a+=((uint32_t)k8[2])<<8; /* fall through */
+ case 2 : a+=((uint32_t)k8[1])<<16; /* fall through */
+ case 1 : a+=((uint32_t)k8[0])<<24; break;
+ case 0 : return c;
+ }
+
+#endif /* !VALGRIND */
+
+ } else { /* need to read the key one byte at a time */
+ const uint8_t *k = (const uint8_t *)key;
+
+ /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+ while (length > 12)
+ {
+ a += ((uint32_t)k[0])<<24;
+ a += ((uint32_t)k[1])<<16;
+ a += ((uint32_t)k[2])<<8;
+ a += ((uint32_t)k[3]);
+ b += ((uint32_t)k[4])<<24;
+ b += ((uint32_t)k[5])<<16;
+ b += ((uint32_t)k[6])<<8;
+ b += ((uint32_t)k[7]);
+ c += ((uint32_t)k[8])<<24;
+ c += ((uint32_t)k[9])<<16;
+ c += ((uint32_t)k[10])<<8;
+ c += ((uint32_t)k[11]);
+ mix(a,b,c);
+ length -= 12;
+ k += 12;
+ }
+
+ /*-------------------------------- last block: affect all 32 bits of (c) */
+ switch(length) /* all the case statements fall through */
+ {
+ case 12: c+=k[11];
+ case 11: c+=((uint32_t)k[10])<<8;
+ case 10: c+=((uint32_t)k[9])<<16;
+ case 9 : c+=((uint32_t)k[8])<<24;
+ case 8 : b+=k[7];
+ case 7 : b+=((uint32_t)k[6])<<8;
+ case 6 : b+=((uint32_t)k[5])<<16;
+ case 5 : b+=((uint32_t)k[4])<<24;
+ case 4 : a+=k[3];
+ case 3 : a+=((uint32_t)k[2])<<8;
+ case 2 : a+=((uint32_t)k[1])<<16;
+ case 1 : a+=((uint32_t)k[0])<<24;
+ break;
+ case 0 : return c;
+ }
+ }
+
+ final(a,b,c);
+ return c;
+}
+
+
+#ifdef SELF_TEST
+
+/* used for timings */
+void driver1()
+{
+ uint8_t buf[256];
+ uint32_t i;
+ uint32_t h=0;
+ time_t a,z;
+
+ time(&a);
+ for (i=0; i<256; ++i) buf[i] = 'x';
+ for (i=0; i<1; ++i)
+ {
+ h = hashlittle(&buf[0],1,h);
+ }
+ time(&z);
+ if (z-a > 0) printf("time %d %.8x\n", z-a, h);
+}
+
+/* check that every input bit changes every output bit half the time */
+#define HASHSTATE 1
+#define HASHLEN 1
+#define MAXPAIR 60
+#define MAXLEN 70
+void driver2()
+{
+ uint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
+ uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, k, l, m=0, z;
+ uint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
+ uint32_t x[HASHSTATE],y[HASHSTATE];
+ uint32_t hlen;
+
+ printf("No more than %d trials should ever be needed \n",MAXPAIR/2);
+ for (hlen=0; hlen < MAXLEN; ++hlen)
+ {
+ z=0;
+ for (i=0; i<hlen; ++i) /*----------------------- for each input byte, */
+ {
+ for (j=0; j<8; ++j) /*------------------------ for each input bit, */
+ {
+ for (m=1; m<8; ++m) /*------------ for serveral possible initvals, */
+ {
+ for (l=0; l<HASHSTATE; ++l)
+ e[l]=f[l]=g[l]=h[l]=x[l]=y[l]=~((uint32_t)0);
+
+ /*---- check that every output bit is affected by that input bit */
+ for (k=0; k<MAXPAIR; k+=2)
+ {
+ uint32_t finished=1;
+ /* keys have one bit different */
+ for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (uint8_t)0;}
+ /* have a and b be two keys differing in only one bit */
+ a[i] ^= (k<<j);
+ a[i] ^= (k>>(8-j));
+ c[0] = hashlittle(a, hlen, m);
+ b[i] ^= ((k+1)<<j);
+ b[i] ^= ((k+1)>>(8-j));
+ d[0] = hashlittle(b, hlen, m);
+ /* check every bit is 1, 0, set, and not set at least once */
+ for (l=0; l<HASHSTATE; ++l)
+ {
+ e[l] &= (c[l]^d[l]);
+ f[l] &= ~(c[l]^d[l]);
+ g[l] &= c[l];
+ h[l] &= ~c[l];
+ x[l] &= d[l];
+ y[l] &= ~d[l];
+ if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
+ }
+ if (finished) break;
+ }
+ if (k>z) z=k;
+ if (k==MAXPAIR)
+ {
+ printf("Some bit didn't change: ");
+ printf("%.8x %.8x %.8x %.8x %.8x %.8x ",
+ e[0],f[0],g[0],h[0],x[0],y[0]);
+ printf("i %d j %d m %d len %d\n", i, j, m, hlen);
+ }
+ if (z==MAXPAIR) goto done;
+ }
+ }
+ }
+ done:
+ if (z < MAXPAIR)
+ {
+ printf("Mix success %2d bytes %2d initvals ",i,m);
+ printf("required %d trials\n", z/2);
+ }
+ }
+ printf("\n");
+}
+
+/* Check for reading beyond the end of the buffer and alignment problems */
+void driver3()
+{
+ uint8_t buf[MAXLEN+20], *b;
+ uint32_t len;
+ uint8_t q[] = "This is the time for all good men to come to the aid of their country...";
+ uint32_t h;
+ uint8_t qq[] = "xThis is the time for all good men to come to the aid of their country...";
+ uint32_t i;
+ uint8_t qqq[] = "xxThis is the time for all good men to come to the aid of their country...";
+ uint32_t j;
+ uint8_t qqqq[] = "xxxThis is the time for all good men to come to the aid of their country...";
+ uint32_t ref,x,y;
+ uint8_t *p;
+
+ printf("Endianness. These lines should all be the same (for values filled in):\n");
+ printf("%.8x %.8x %.8x\n",
+ hashword((const uint32_t *)q, (sizeof(q)-1)/4, 13),
+ hashword((const uint32_t *)q, (sizeof(q)-5)/4, 13),
+ hashword((const uint32_t *)q, (sizeof(q)-9)/4, 13));
+ p = q;
+ printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+ hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+ hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+ hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+ hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+ hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+ hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+ p = &qq[1];
+ printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+ hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+ hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+ hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+ hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+ hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+ hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+ p = &qqq[2];
+ printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+ hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+ hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+ hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+ hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+ hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+ hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+ p = &qqqq[3];
+ printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
+ hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
+ hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
+ hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
+ hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
+ hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
+ hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
+ printf("\n");
+
+ /* check that hashlittle2 and hashlittle produce the same results */
+ i=47; j=0;
+ hashlittle2(q, sizeof(q), &i, &j);
+ if (hashlittle(q, sizeof(q), 47) != i)
+ printf("hashlittle2 and hashlittle mismatch\n");
+
+ /* check that hashword2 and hashword produce the same results */
+ len = 0xdeadbeef;
+ i=47, j=0;
+ hashword2(&len, 1, &i, &j);
+ if (hashword(&len, 1, 47) != i)
+ printf("hashword2 and hashword mismatch %x %x\n",
+ i, hashword(&len, 1, 47));
+
+ /* check hashlittle doesn't read before or after the ends of the string */
+ for (h=0, b=buf+1; h<8; ++h, ++b)
+ {
+ for (i=0; i<MAXLEN; ++i)
+ {
+ len = i;
+ for (j=0; j<i; ++j) *(b+j)=0;
+
+ /* these should all be equal */
+ ref = hashlittle(b, len, (uint32_t)1);
+ *(b+i)=(uint8_t)~0;
+ *(b-1)=(uint8_t)~0;
+ x = hashlittle(b, len, (uint32_t)1);
+ y = hashlittle(b, len, (uint32_t)1);
+ if ((ref != x) || (ref != y))
+ {
+ printf("alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y,
+ h, i);
+ }
+ }
+ }
+}
+
+/* check for problems with nulls */
+ void driver4()
+{
+ uint8_t buf[1];
+ uint32_t h,i,state[HASHSTATE];
+
+
+ buf[0] = ~0;
+ for (i=0; i<HASHSTATE; ++i) state[i] = 1;
+ printf("These should all be different\n");
+ for (i=0, h=0; i<8; ++i)
+ {
+ h = hashlittle(buf, 0, h);
+ printf("%2ld 0-byte strings, hash is %.8x\n", i, h);
+ }
+}
+
+void driver5()
+{
+ uint32_t b,c;
+ b=0, c=0, hashlittle2("", 0, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* deadbeef deadbeef */
+ b=0xdeadbeef, c=0, hashlittle2("", 0, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* bd5b7dde deadbeef */
+ b=0xdeadbeef, c=0xdeadbeef, hashlittle2("", 0, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* 9c093ccd bd5b7dde */
+ b=0, c=0, hashlittle2("Four score and seven years ago", 30, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* 17770551 ce7226e6 */
+ b=1, c=0, hashlittle2("Four score and seven years ago", 30, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* e3607cae bd371de4 */
+ b=0, c=1, hashlittle2("Four score and seven years ago", 30, &c, &b);
+ printf("hash is %.8lx %.8lx\n", c, b); /* cd628161 6cbea4b3 */
+ c = hashlittle("Four score and seven years ago", 30, 0);
+ printf("hash is %.8lx\n", c); /* 17770551 */
+ c = hashlittle("Four score and seven years ago", 30, 1);
+ printf("hash is %.8lx\n", c); /* cd628161 */
+}
+
+
+int main()
+{
+ driver1(); /* test that the key is hashed: used for timings */
+ driver2(); /* test that whole key is hashed thoroughly */
+ driver3(); /* test that nothing but the key is hashed */
+ driver4(); /* test hashing multiple buffers (all buffers are null) */
+ driver5(); /* test the hash against known vectors */
+ return 1;
+}
+
+#endif /* SELF_TEST */
diff --git a/libc_test/main.cpp b/libc_test/main.cpp
index 8b012b67..6e7b62f3 100644
--- a/libc_test/main.cpp
+++ b/libc_test/main.cpp
@@ -31,8 +31,39 @@ extern "C" {
#define MAX_MEMSET_TEST_SIZE 2048
#define MAX_MEMSET_BUFFER_SIZE (3 * MAX_MEMSET_TEST_SIZE)
-#define MAX_STRCMP_TEST_SIZE 1024
-#define MAX_STRCMP_BUFFER_SIZE (3 * MAX_STRCMP_TEST_SIZE)
+#define MAX_STRING_TEST_SIZE 1024
+#define MAX_STRING_BUFFER_SIZE (3 * MAX_STRING_TEST_SIZE)
+
+#define MAX_STRCAT_DST_SIZE 32
+
+const int kStringAligns[][4] = {
+ // All zeroes to use the values returned from malloc.
+ { 0, 0, 0, 0 },
+
+ { 1, 0, 1, 0 },
+ { 2, 0, 2, 0 },
+ { 4, 0, 4, 0 },
+ { 8, 0, 8, 0 },
+
+ { 8, 0, 4, 0 },
+ { 4, 0, 8, 0 },
+
+ { 8, 0, 8, 1 },
+ { 8, 0, 8, 2 },
+ { 8, 0, 8, 3 },
+ { 8, 1, 8, 0 },
+ { 8, 2, 8, 0 },
+ { 8, 3, 8, 0 },
+
+ { 4, 0, 4, 1 },
+ { 4, 0, 4, 2 },
+ { 4, 0, 4, 3 },
+ { 4, 1, 4, 0 },
+ { 4, 2, 4, 0 },
+ { 4, 3, 4, 0 },
+};
+
+#define STRING_ALIGN_LEN (sizeof(kStringAligns)/sizeof(int[4]))
// Return a pointer into the current string with the specified alignment.
void *getAlignedPtr(void *orig_ptr, int alignment, int or_mask) {
@@ -48,6 +79,24 @@ void *getAlignedPtr(void *orig_ptr, int alignment, int or_mask) {
return reinterpret_cast<void*>(ptr);
}
+char *setString(char *str, size_t size) {
+ for (size_t i = 0; i < size; i++) {
+ str[i] = (char)(32 + (i % 96));
+ }
+ str[size] = '\0';
+
+ return str;
+}
+
+char *allocateString() {
+ char *str = reinterpret_cast<char*>(malloc(MAX_STRING_BUFFER_SIZE+1));
+ if (!str) {
+ return NULL;
+ }
+
+ return setString(str, MAX_STRING_BUFFER_SIZE);
+}
+
void setFencepost(uint8_t *buffer) {
for (int i = 0; i < FENCEPOST_LENGTH; i += 2) {
buffer[i] = 0xde;
@@ -65,7 +114,7 @@ bool verifyFencepost(uint8_t *buffer) {
} else {
expected_value = 0xde;
}
- printf(" mismatch at fencepost[%d], expected %d found %d\n",
+ printf(" mismatch at fencepost[%d], expected %d found %d\n",
i, expected_value, buffer[i]);
return false;
}
@@ -73,13 +122,13 @@ bool verifyFencepost(uint8_t *buffer) {
return true;
}
-bool doStrcmpExpectEqual(char *string1, char *string2, int align[4],
+bool doStrcmpExpectEqual(char *string1, char *string2, const int align[4],
int (*test_strcmp)(const char *s1, const char *s2),
bool verbose) {
char *align_str1 = (char*)getAlignedPtr(string1, align[0], align[1]);
char *align_str2 = (char*)getAlignedPtr(string2, align[2], align[3]);
- for (size_t i = 0; i < MAX_STRCMP_TEST_SIZE; i++) {
+ for (size_t i = 0; i < MAX_STRING_TEST_SIZE; i++) {
for (size_t j = 0; j < i; j++) {
align_str1[j] = (char)(32 + (j % 96));
align_str2[j] = align_str1[j];
@@ -109,14 +158,14 @@ bool doStrcmpExpectEqual(char *string1, char *string2, int align[4],
return true;
}
-bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
- int align[4], char diff_char,
+bool doStrcmpExpectDiff(char *string1, char *string2, const int diff_align[2],
+ const int align[4], char diff_char,
int (*test_strcmp)(const char *s1, const char *s2),
bool verbose) {
char *align_str1 = (char*)getAlignedPtr(string1, align[0], align[1]);
char *align_str2 = (char*)getAlignedPtr(string2, align[2], align[3]);
- for (int i = 0; i < MAX_STRCMP_TEST_SIZE; i++) {
+ for (int i = 0; i < MAX_STRING_TEST_SIZE; i++) {
// Use valid ascii characters, no unprintables characters.
align_str1[i] = (char)(32 + (i % 96));
if (align_str1[i] == diff_char) {
@@ -126,8 +175,8 @@ bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
}
align_str2[i] = align_str1[i];
}
- align_str1[MAX_STRCMP_TEST_SIZE] = '\0';
- align_str2[MAX_STRCMP_TEST_SIZE] = '\0';
+ align_str1[MAX_STRING_TEST_SIZE] = '\0';
+ align_str2[MAX_STRING_TEST_SIZE] = '\0';
// Quick check to make sure that the strcmp knows that everything is
// equal. If it's so broken that it already thinks the strings are
@@ -138,7 +187,7 @@ bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
}
// Get a pointer into the string at the specified alignment.
- char *bad = (char*)getAlignedPtr(align_str1+MAX_STRCMP_TEST_SIZE/2,
+ char *bad = (char*)getAlignedPtr(align_str1+MAX_STRING_TEST_SIZE/2,
diff_align[0], diff_align[1]);
char saved_char = bad[0];
@@ -150,7 +199,7 @@ bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
}
if (test_strcmp(align_str1, align_str2) == 0) {
printf(" Did not miscompare at size %d, src1 %p, src2 %p, diff %p\n",
- MAX_STRCMP_TEST_SIZE, align_str1, align_str2, bad);
+ MAX_STRING_TEST_SIZE, align_str1, align_str2, bad);
return false;
}
bad[0] = saved_char;
@@ -161,7 +210,7 @@ bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
return false;
}
- bad = (char*)getAlignedPtr(align_str2+MAX_STRCMP_TEST_SIZE/2, diff_align[0],
+ bad = (char*)getAlignedPtr(align_str2+MAX_STRING_TEST_SIZE/2, diff_align[0],
diff_align[1]);
bad[0] = diff_char;
@@ -171,7 +220,7 @@ bool doStrcmpExpectDiff(char *string1, char *string2, int diff_align[2],
}
if (test_strcmp(align_str1, align_str2) == 0) {
printf(" Did not miscompare at size %d, src1 %p, src2 %p, diff %p\n",
- MAX_STRCMP_TEST_SIZE, align_str1, align_str2, bad);
+ MAX_STRING_TEST_SIZE, align_str1, align_str2, bad);
return false;
}
@@ -195,7 +244,7 @@ bool doStrcmpCheckRead(int (*test_strcmp)(const char *s1, const char *s2),
return false;
}
- size_t max_size = pagesize < MAX_STRCMP_TEST_SIZE ? pagesize-1 : MAX_STRCMP_TEST_SIZE;
+ size_t max_size = pagesize < MAX_STRING_TEST_SIZE ? pagesize-1 : MAX_STRING_TEST_SIZE;
// Allocate an extra byte beyond the string terminator to allow us to
// extend the string to be larger than our protected string.
char *other_string = (char *)malloc(max_size+2);
@@ -254,61 +303,23 @@ bool doStrcmpCheckRead(int (*test_strcmp)(const char *s1, const char *s2),
bool runStrcmpTest(int (*test_strcmp)(const char *s1, const char *s2),
bool verbose) {
- // Allocate two large buffers to hold the two strings.
- char *string1 = reinterpret_cast<char*>(malloc(MAX_STRCMP_BUFFER_SIZE+1));
- char *string2 = reinterpret_cast<char*>(malloc(MAX_STRCMP_BUFFER_SIZE+1));
+ char *string1 = allocateString();
+ char *string2 = allocateString();
if (string1 == NULL || string2 == NULL) {
perror("Unable to allocate memory.\n");
return false;
}
- // Initialize the strings to be exactly the same.
- for (int i = 0; i < MAX_STRCMP_BUFFER_SIZE; i++) {
- string1[i] = (char)(32 + (i % 96));
- string2[i] = string1[i];
- }
- string1[MAX_STRCMP_BUFFER_SIZE] = '\0';
- string2[MAX_STRCMP_BUFFER_SIZE] = '\0';
-
- // Check different string alignments. All zeroes indicates that the
- // unmodified malloc values should be used.
- int string_aligns[][4] = {
- // All zeroes to use the values returned from malloc.
- { 0, 0, 0, 0 },
-
- { 1, 0, 1, 0 },
- { 2, 0, 2, 0 },
- { 4, 0, 4, 0 },
- { 8, 0, 8, 0 },
-
- { 8, 0, 4, 0 },
- { 4, 0, 8, 0 },
-
- { 8, 0, 8, 1 },
- { 8, 0, 8, 2 },
- { 8, 0, 8, 3 },
- { 8, 1, 8, 0 },
- { 8, 2, 8, 0 },
- { 8, 3, 8, 0 },
-
- { 4, 0, 4, 1 },
- { 4, 0, 4, 2 },
- { 4, 0, 4, 3 },
- { 4, 1, 4, 0 },
- { 4, 2, 4, 0 },
- { 4, 3, 4, 0 },
- };
-
printf(" Verifying equal sized strings at different alignments.\n");
- for (size_t i = 0; i < sizeof(string_aligns)/sizeof(int[4]); i++) {
- if (!doStrcmpExpectEqual(string1, string2, string_aligns[i], test_strcmp,
+ for (size_t i = 0; i < STRING_ALIGN_LEN; i++) {
+ if (!doStrcmpExpectEqual(string1, string2, kStringAligns[i], test_strcmp,
verbose)) {
return false;
}
}
// Test the function finds strings with differences at specific locations.
- int diff_aligns[][2] = {
+ const int diff_aligns[][2] = {
{ 4, 0 },
{ 4, 1 },
{ 4, 2 },
@@ -321,17 +332,17 @@ bool runStrcmpTest(int (*test_strcmp)(const char *s1, const char *s2),
printf(" Verifying different strings at different alignments.\n");
for (size_t i = 0; i < sizeof(diff_aligns)/sizeof(int[2]); i++) {
// First loop put the string terminator at the chosen alignment.
- for (size_t j = 0; j < sizeof(string_aligns)/sizeof(int[4]); j++) {
+ for (size_t j = 0; j < STRING_ALIGN_LEN; j++) {
if (!doStrcmpExpectDiff(string1, string2, diff_aligns[i],
- string_aligns[j], '\0', test_strcmp, verbose)) {
+ kStringAligns[j], '\0', test_strcmp, verbose)) {
return false;
}
}
// Second loop put a different character at the chosen alignment.
// This character is guaranteed not to be in the original string.
- for (size_t j = 0; j < sizeof(string_aligns)/sizeof(int[4]); j++) {
+ for (size_t j = 0; j < STRING_ALIGN_LEN; j++) {
if (!doStrcmpExpectDiff(string1, string2, diff_aligns[i],
- string_aligns[j], '\0', test_strcmp, verbose)) {
+ kStringAligns[j], '\0', test_strcmp, verbose)) {
return false;
}
}
@@ -347,9 +358,277 @@ bool runStrcmpTest(int (*test_strcmp)(const char *s1, const char *s2),
return true;
}
+bool doStrlenCheck(size_t size, char *string, int align, int or_mask,
+ size_t (*test_strlen)(const char *), bool verbose) {
+ char *aligned_string = reinterpret_cast<char*>(getAlignedPtr(string, align, or_mask));
+ size_t len;
+ if (verbose) {
+ printf("Testing size %d, align=%p[%d,%d]\n", size, aligned_string, align, or_mask);
+ }
+
+ aligned_string[size] = '\0';
+ len = test_strlen(aligned_string);
+ if (len != size) {
+ printf("Failed at size %d, length returned %u, align=%p[%d,%d]\n",
+ size, len, aligned_string, align, or_mask);
+ return false;
+ }
+
+ if (verbose) {
+ printf("Testing size %d with extra zeros after string, align=%p[%d,%d]\n",
+ size, aligned_string, align, or_mask);
+ }
+
+ for (size_t j = size+1; j <= size+16; j++) {
+ aligned_string[j] = '\0';
+ }
+
+ len = test_strlen(aligned_string);
+ if (len != size) {
+ printf("Failed at size %d, length returned %u with zeroes after string, align=%p[%d,%d]\n",
+ size, len, aligned_string, align, or_mask);
+ return false;
+ }
+
+ for (size_t j = size; j <= size+16; j++) {
+ aligned_string[j] = (char)(32 + (j % 96));
+ }
+ return true;
+}
+
+bool runStrlenTest(size_t (*test_strlen)(const char *),
+ bool verbose) {
+ char *string = allocateString();
+ if (string == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+
+ // Check different string alignments. All zeroes indicates that the
+ // unmodified malloc values should be used.
+ const int aligns[][2] = {
+ // All zeroes to use the values returned from malloc.
+ { 0, 0 },
+
+ { 1, 0 },
+ { 2, 0 },
+ { 4, 0 },
+ { 8, 0 },
+ { 16, 0 },
+ { 32, 0 },
+
+ { 8, 1 },
+ { 8, 2 },
+ { 8, 3 },
+
+ { 4, 1 },
+ { 4, 2 },
+ { 4, 3 },
+ };
+
+ printf(" Verifying string lengths at different alignments.\n");
+ for (size_t i = 0; i < sizeof(aligns)/sizeof(int[2]); i++) {
+ for (size_t j = 0; j <= MAX_STRING_TEST_SIZE; j++) {
+ if (!doStrlenCheck(j, string, aligns[i][0], aligns[i][1], test_strlen, verbose)) {
+ return false;
+ }
+ }
+ }
+
+ printf(" Verifying strlen does not read past end of string.\n");
+
+ // In order to verify that strlen is not reading past the end of the
+ // string, create strings that end near unreadable memory.
+ long pagesize = sysconf(_SC_PAGE_SIZE);
+ char *memory = (char*)memalign(pagesize, 2 * pagesize);
+ if (memory == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+
+ // Make the second page unreadable and unwritable.
+ if (mprotect(&memory[pagesize], pagesize, PROT_NONE) != 0) {
+ perror("Unable to set protection of page.\n");
+ return false;
+ }
+
+ size_t max_size = pagesize < MAX_STRING_TEST_SIZE ? pagesize-1 : MAX_STRING_TEST_SIZE;
+ for (long i = 0; i < pagesize; i++) {
+ memory[i] = (char)(32 + (i % 96));
+ }
+
+ size_t len;
+ for (size_t i = 0; i < sizeof(aligns)/sizeof(int[2]); i++) {
+ for (size_t j = 0; j <= max_size; j++) {
+ string = &memory[pagesize-j-1];
+ string[j] = '\0';
+
+ if (verbose) {
+ printf("Testing size %d overread, align=%p[%d,%d]\n",
+ j, string, aligns[i][0], aligns[i][1]);
+ }
+ len = test_strlen(string);
+ if (len != j) {
+ printf(" Failed at size %u, returned %u, align=%p[%d,%d]\n",
+ j, len, string, aligns[i][0], aligns[i][1]);
+ return false;
+ }
+ string[j] = (char)(32 + (j % 96));
+ }
+ }
+
+ printf(" All tests pass.\n");
+
+ return true;
+}
+
+bool runStrcpyTest(char *(*test_strcpy)(char *, const char *),
+ bool verbose) {
+ char *src = allocateString();
+ if (src == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+ char *dst = allocateString();
+ if (dst == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+
+ printf(" Verifying string lengths at different alignments.\n");
+ char *src_align;
+ char *dst_align;
+ char *dst_ret;
+ for (size_t i = 0; i < STRING_ALIGN_LEN; i++) {
+ for (size_t copy_len = 0; copy_len <= MAX_STRING_TEST_SIZE; copy_len++) {
+ if (kStringAligns[i][0]) {
+ src_align = reinterpret_cast<char*>(getAlignedPtr(src+FENCEPOST_LENGTH, kStringAligns[i][0], kStringAligns[i][1]));
+ dst_align = reinterpret_cast<char*>(getAlignedPtr(dst+FENCEPOST_LENGTH, kStringAligns[i][2], kStringAligns[i][3]));
+ } else {
+ src_align = src;
+ dst_align = dst;
+ }
+ setString(src_align, copy_len);
+ memset(dst_align, 0, copy_len+1);
+
+ if (dst_align != dst) {
+ setFencepost(reinterpret_cast<uint8_t*>(&dst_align[-FENCEPOST_LENGTH]));
+ }
+ setFencepost(reinterpret_cast<uint8_t*>(&dst_align[copy_len+1]));
+
+ if (verbose) {
+ printf("Testing copy_len %u, src_align=%p[%d,%d], dst_align=%p[%d,%d]\n",
+ copy_len, src_align, kStringAligns[i][0], kStringAligns[i][1],
+ dst_align, kStringAligns[i][2], kStringAligns[i][3]);
+ }
+
+ dst_ret = test_strcpy(dst_align, src_align);
+ if (dst_ret != dst_align) {
+ printf("copy_len %u returned incorrect value: expected %p, got %p\n",
+ copy_len, dst_align, dst_ret);
+ return false;
+ }
+ if (memcmp(src_align, dst_align, copy_len) != 0) {
+ printf("copy_len %u failed to copy properly: src and dst aren't equal\n", copy_len);
+ return false;
+ }
+
+ if (dst_align != dst && !verifyFencepost(reinterpret_cast<uint8_t*>(&dst_align[-FENCEPOST_LENGTH]))) {
+ printf("copy_len %u fencepost before dst was overwritten\n", copy_len);
+ return false;
+ }
+
+ if (!verifyFencepost(reinterpret_cast<uint8_t*>(&dst_align[copy_len+1]))) {
+ printf("copy_len %u fencepost at end of dst was overwritten\n", copy_len);
+ return false;
+ }
+ }
+ }
+
+ printf(" All tests pass.\n");
+
+ return true;
+}
+
+bool runStrcatTest(char *(*test_strcat)(char *, const char *),
+ bool verbose) {
+ char *src = allocateString();
+ if (src == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+ char *dst = allocateString();
+ if (dst == NULL) {
+ perror("Unable to allocate memory.\n");
+ return false;
+ }
+
+ printf(" Verifying string lengths at different alignments.\n");
+ char *src_align;
+ char *dst_align;
+ char *dst_ret;
+ for (size_t i = 0; i < STRING_ALIGN_LEN; i++) {
+ for (size_t dst_len = 0; dst_len <= MAX_STRCAT_DST_SIZE; dst_len++) {
+ for (size_t copy_len = 0; copy_len <= MAX_STRING_TEST_SIZE; copy_len++) {
+ if (kStringAligns[i][0]) {
+ src_align = reinterpret_cast<char*>(getAlignedPtr(src+FENCEPOST_LENGTH, kStringAligns[i][0], kStringAligns[i][1]));
+ dst_align = reinterpret_cast<char*>(getAlignedPtr(dst+FENCEPOST_LENGTH, kStringAligns[i][2], kStringAligns[i][3]));
+ } else {
+ src_align = src;
+ dst_align = dst;
+ }
+ setString(src_align, copy_len);
+ memset(dst_align, 'd', dst_len);
+ memset(dst_align+dst_len, 0, copy_len+1);
+
+ if (dst_align != dst) {
+ setFencepost(reinterpret_cast<uint8_t*>(&dst_align[-FENCEPOST_LENGTH]));
+ }
+ setFencepost(reinterpret_cast<uint8_t*>(&dst_align[copy_len+dst_len+1]));
+
+ if (verbose) {
+ printf("Testing copy_len %u, dst_len %u, src_align=%p[%d,%d], dst_align=%p[%d,%d]\n",
+ copy_len, dst_len, src_align, kStringAligns[i][0], kStringAligns[i][1],
+ dst_align, kStringAligns[i][2], kStringAligns[i][3]);
+ }
+
+ dst_ret = test_strcat(dst_align, src_align);
+ if (dst_ret != dst_align) {
+ printf("dst_len %u, copy_len %u returned incorrect value: expected %p, got %p\n",
+ dst_len, copy_len, dst_align, dst_ret);
+ return false;
+ }
+ for (size_t j = 0; j < dst_len; j++) {
+ if (dst_align[j] != 'd') {
+ printf("dst_len %u, copy_len %u: strcat overwrote dst string\n",
+ dst_len, copy_len);
+ return false;
+ }
+ }
+ if (memcmp(src_align, dst_align+dst_len, copy_len+1) != 0) {
+ printf("dst_len %u, copy_len %u failed to copy properly: src and dst aren't equal\n",
+ dst_len, copy_len);
+ return false;
+ }
+
+ if (dst_align != dst && !verifyFencepost(reinterpret_cast<uint8_t*>(&dst_align[-FENCEPOST_LENGTH]))) {
+ return false;
+ }
+
+ if (!verifyFencepost(reinterpret_cast<uint8_t*>(&dst_align[dst_len+copy_len+1]))) {
+ return false;
+ }
+ }
+ }
+ }
+
+ printf(" All tests pass.\n");
+
+ return true;
+}
+
bool runMemcpyTest(void* (*test_memcpy)(void *dst, const void *src, size_t n),
bool verbose) {
- // Allocate two large buffers to hold the dst and src.
uint8_t *dst = reinterpret_cast<uint8_t*>(malloc(MAX_MEMCPY_BUFFER_SIZE));
uint8_t *src = reinterpret_cast<uint8_t*>(malloc(MAX_MEMCPY_BUFFER_SIZE));
if (dst == NULL || src == NULL) {
@@ -368,7 +647,7 @@ bool runMemcpyTest(void* (*test_memcpy)(void *dst, const void *src, size_t n),
}
}
- int aligns[][4] = {
+ const int aligns[][4] = {
// Src and dst use pointers returned by malloc.
{ 0, 0, 0, 0 },
@@ -491,14 +770,13 @@ bool runMemcpyTest(void* (*test_memcpy)(void *dst, const void *src, size_t n),
bool runMemsetTest(void* (*test_memset)(void *s, int c, size_t n),
bool verbose) {
- // Allocate one large buffer to hold the dst.
uint8_t *buf = reinterpret_cast<uint8_t*>(malloc(MAX_MEMSET_BUFFER_SIZE));
if (buf == NULL) {
perror("Unable to allocate memory.\n");
return false;
}
- int aligns[][2] = {
+ const int aligns[][2] = {
// Use malloc return values unaltered.
{ 0, 0 },
@@ -587,6 +865,7 @@ int main(int argc, char **argv) {
}
bool tests_passing = true;
+
printf("Testing strcmp...\n");
tests_passing = runStrcmpTest(strcmp, verbose) && tests_passing;
@@ -596,5 +875,14 @@ int main(int argc, char **argv) {
printf("Testing memset...\n");
tests_passing = runMemsetTest(memset, verbose) && tests_passing;
+ printf("Testing strlen...\n");
+ tests_passing = runStrlenTest(strlen, verbose) && tests_passing;
+
+ printf("Testing strcpy...\n");
+ tests_passing = runStrcpyTest(strcpy, verbose) && tests_passing;
+
+ printf("Testing strcat...\n");
+ tests_passing = runStrcatTest(strcat, verbose) && tests_passing;
+
return (tests_passing ? 0 : 1);
}
diff --git a/memtrack/Android.mk b/memtrack/Android.mk
new file mode 100644
index 00000000..66759bb5
--- /dev/null
+++ b/memtrack/Android.mk
@@ -0,0 +1,55 @@
+# Copyright (C) 2013 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+
+src_files := \
+ memtrack.cpp
+
+includes := \
+ bionic \
+ external/stlport/stlport \
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(src_files)
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE := memtrack_share
+
+LOCAL_C_INCLUDES += $(includes)
+LOCAL_SHARED_LIBRARIES := \
+ libc \
+ libstlport \
+ liblog \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(src_files)
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE := memtrack
+
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_C_INCLUDES += $(includes)
+LOCAL_STATIC_LIBRARIES := \
+ libc \
+ libstdc++ \
+ libstlport_static \
+ liblog \
+
+include $(BUILD_EXECUTABLE)
diff --git a/memtrack/memtrack.cpp b/memtrack/memtrack.cpp
new file mode 100644
index 00000000..ab45fd0c
--- /dev/null
+++ b/memtrack/memtrack.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <limits.h>
+#include <ctype.h>
+#include <unistd.h>
+
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include <cutils/log.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "memtrack.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "MemTracker"
+
+FileData::FileData(char *filename, char *buffer, size_t buffer_len)
+ : data_(buffer), max_(buffer_len), cur_idx_(0), len_(0),
+ read_complete_(false) {
+ fd_ = open(filename, O_RDONLY);
+ if (fd_ < 0) {
+ read_complete_ = true;
+ }
+}
+
+FileData::~FileData() {
+ if (fd_ >= 0) {
+ close(fd_);
+ }
+}
+
+bool FileData::isAvail(size_t bytes_needed) {
+ if (cur_idx_ + bytes_needed < len_) {
+ return true;
+ }
+
+ if (read_complete_) {
+ return false;
+ }
+
+ if (cur_idx_ != len_) {
+ // Copy the leftover to the front of the buffer.
+ len_ = len_ - cur_idx_;
+ memcpy(data_, data_ + cur_idx_, len_);
+ }
+
+ ssize_t bytes;
+ cur_idx_ = 0;
+ while (cur_idx_ + bytes_needed >= len_) {
+ bytes = read(fd_, data_ + len_, max_ - len_);
+ if (bytes == 0 || bytes == -1) {
+ read_complete_;
+ break;
+ }
+ len_ += bytes;
+ }
+
+ return cur_idx_ + bytes_needed < len_;
+}
+
+bool FileData::getPss(size_t *pss) {
+ size_t value;
+ while (true) {
+ if (!isAvail(4)) {
+ return false;
+ }
+
+ if (data_[cur_idx_] != 'P' || data_[cur_idx_+1] != 's' ||
+ data_[cur_idx_+2] != 's' || data_[cur_idx_+3] != ':') {
+ // Consume the rest of the line.
+ while (isAvail(1) && data_[cur_idx_++] != '\n');
+ } else {
+ cur_idx_ += 4;
+ while (isAvail(1) && isspace(data_[cur_idx_])) {
+ cur_idx_++;
+ }
+
+ value = 0;
+ while (isAvail(1) && isdigit(data_[cur_idx_])) {
+ value = value * 10 + data_[cur_idx_] - '0';
+ cur_idx_++;
+ }
+ *pss = value;
+
+ // Consume the rest of the line.
+ while (isAvail(1) && data_[cur_idx_++] != '\n');
+
+ return true;
+ }
+ }
+}
+
+const char *ProcessInfo::kProc = "/proc/";
+const char *ProcessInfo::kCmdline = "/cmdline";
+const char *ProcessInfo::kSmaps = "/smaps";
+
+ProcessInfo::ProcessInfo() {
+ memcpy(proc_file_, kProc, kProcLen);
+}
+
+ProcessInfo::~ProcessInfo() {
+}
+
+bool ProcessInfo::getInformation(int pid, char *pid_str, size_t pid_str_len) {
+ memcpy(proc_file_ + kProcLen, pid_str, pid_str_len);
+ memcpy(proc_file_ + kProcLen + pid_str_len, kCmdline, kCmdlineLen);
+
+ // Read the cmdline for the process.
+ int fd = open(proc_file_, O_RDONLY);
+ if (fd < 0) {
+ return false;
+ }
+
+ ssize_t bytes = read(fd, cmd_name_, sizeof(cmd_name_));
+ close(fd);
+ if (bytes == -1 || bytes == 0) {
+ return false;
+ }
+
+ memcpy(proc_file_ + kProcLen + pid_str_len, kSmaps, kSmapsLen);
+ FileData smaps(proc_file_, buffer_, sizeof(buffer_));
+
+ cur_process_info_t process_info;
+ size_t pss_kb;
+ process_info.pss_kb = 0;
+ while (smaps.getPss(&pss_kb)) {
+ process_info.pss_kb += pss_kb;
+ }
+
+ if (cur_.count(cmd_name_) == 0) {
+ cur_[cmd_name_] = process_info;
+ } else {
+ cur_[cmd_name_].pss_kb += process_info.pss_kb;
+ }
+ cur_[cmd_name_].pids.push_back(pid);
+
+ return true;
+}
+
+void ProcessInfo::scan() {
+ DIR *proc_dir = opendir(kProc);
+ if (proc_dir == NULL) {
+ perror("Cannot open directory.\n");
+ exit(1);
+ }
+
+ // Clear any current pids.
+ for (processes_t::iterator it = all_.begin(); it != all_.end(); ++it) {
+ it->second.pids.clear();
+ }
+
+ struct dirent *dir_data;
+ int len;
+ bool is_pid;
+ size_t pid;
+ cur_.clear();
+ while ((dir_data = readdir(proc_dir))) {
+ // Check if the directory entry represents a pid.
+ len = strlen(dir_data->d_name);
+ is_pid = true;
+ pid = 0;
+ for (int i = 0; i < len; i++) {
+ if (!isdigit(dir_data->d_name[i])) {
+ is_pid = false;
+ break;
+ }
+ pid = pid * 10 + dir_data->d_name[i] - '0';
+ }
+ if (is_pid) {
+ getInformation(pid, dir_data->d_name, len);
+ }
+ }
+ closedir(proc_dir);
+
+ // Loop through the current processes and add them into our real list.
+ for (cur_processes_t::const_iterator it = cur_.begin();
+ it != cur_.end(); ++it) {
+
+ if (all_.count(it->first) == 0) {
+ // Initialize all of the variables.
+ all_[it->first].num_samples = 0;
+ all_[it->first].name = it->first;
+ all_[it->first].avg_pss_kb = 0;
+ all_[it->first].min_pss_kb = 0;
+ all_[it->first].max_pss_kb = 0;
+ }
+
+ if (it->second.pids.size() > all_[it->first].max_num_pids) {
+ all_[it->first].max_num_pids = it->second.pids.size();
+ }
+
+ all_[it->first].pids = it->second.pids;
+
+ if (it->second.pss_kb > all_[it->first].max_pss_kb) {
+ all_[it->first].max_pss_kb = it->second.pss_kb;
+ }
+
+ if (all_[it->first].min_pss_kb == 0 ||
+ it->second.pss_kb < all_[it->first].min_pss_kb) {
+ all_[it->first].min_pss_kb = it->second.pss_kb;
+ }
+
+ all_[it->first].last_pss_kb = it->second.pss_kb;
+
+ computeAvg(&all_[it->first].avg_pss_kb, it->second.pss_kb,
+ all_[it->first].num_samples);
+ all_[it->first].num_samples++;
+ }
+}
+
+bool comparePss(const process_info_t *first, const process_info_t *second) {
+ return first->max_pss_kb > second->max_pss_kb;
+}
+
+void ProcessInfo::dumpToLog() {
+ list_.clear();
+ for (processes_t::const_iterator it = all_.begin(); it != all_.end(); ++it) {
+ list_.push_back(&it->second);
+ }
+
+ // Now sort the list.
+ std::sort(list_.begin(), list_.end(), comparePss);
+
+ ALOGI("Dumping process list");
+ for (std::vector<const process_info_t *>::const_iterator it = list_.begin();
+ it != list_.end(); ++it) {
+ ALOGI(" Name: %s", (*it)->name.c_str());
+ ALOGI(" Max running processes: %d", (*it)->max_num_pids);
+ if ((*it)->pids.size() > 0) {
+ ALOGI(" Currently running pids:");
+ for (std::vector<int>::const_iterator pid_it = (*it)->pids.begin();
+ pid_it != (*it)->pids.end(); ++pid_it) {
+ ALOGI(" %d", *pid_it);
+ }
+ }
+
+ ALOGI(" Min PSS %0.4fM", (*it)->min_pss_kb/1024.0);
+ ALOGI(" Avg PSS %0.4fM", (*it)->avg_pss_kb/1024.0);
+ ALOGI(" Max PSS %0.4fM", (*it)->max_pss_kb/1024.0);
+ ALOGI(" Last PSS %0.4fM", (*it)->last_pss_kb/1024.0);
+ }
+}
+
+void usage() {
+ printf("Usage: memtrack [--verbose | --quiet] [--scan_delay TIME_SECS]\n");
+ printf(" --scan_delay TIME_SECS\n");
+ printf(" The amount of delay in seconds between scans.\n");
+ printf(" --verbose\n");
+ printf(" Print information about the scans to stdout only.\n");
+ printf(" --quiet\n");
+ printf(" Nothing will be printed to stdout.\n");
+ printf(" All scan data is dumped to the android log using the tag %s\n",
+ LOG_TAG);
+}
+
+int SignalReceived = 0;
+
+int SignalsToHandle[] = {
+ SIGTSTP,
+ SIGINT,
+ SIGHUP,
+ SIGPIPE,
+ SIGUSR1,
+};
+
+void handleSignal(int signo) {
+ if (SignalReceived == 0) {
+ SignalReceived = signo;
+ }
+}
+
+int main(int argc, char **argv) {
+ if (geteuid() != 0) {
+ printf("Must be run as root.\n");
+ exit(1);
+ }
+
+ bool verbose = false;
+ bool quiet = false;
+ unsigned int scan_delay_sec = DEFAULT_SLEEP_DELAY_SECONDS;
+ for (int i = 1; i < argc; i++) {
+ if (strcmp(argv[i], "--verbose") == 0) {
+ verbose = true;
+ } else if (strcmp(argv[i], "--quiet") == 0) {
+ quiet = true;
+ } else if (strcmp(argv[i], "--scan_delay") == 0) {
+ if (i+1 == argc) {
+ printf("The %s options requires a single argument.\n", argv[i]);
+ usage();
+ exit(1);
+ }
+ scan_delay_sec = atoi(argv[++i]);
+ } else {
+ printf("Unknown option %s\n", argv[i]);
+ usage();
+ exit(1);
+ }
+ }
+ if (quiet && verbose) {
+ printf("Both --quiet and --verbose cannot be specified.\n");
+ usage();
+ exit(1);
+ }
+
+ // Set up the signal handlers.
+ for (size_t i = 0; i < sizeof(SignalsToHandle)/sizeof(int); i++) {
+ if (signal(SignalsToHandle[i], handleSignal) == SIG_ERR) {
+ printf("Unable to handle signal %d\n", SignalsToHandle[i]);
+ exit(1);
+ }
+ }
+
+ ProcessInfo proc_info;
+
+ if (!quiet) {
+ printf("Hit Ctrl-Z or send SIGUSR1 to pid %d to print the current list of\n",
+ getpid());
+ printf("processes.\n");
+ printf("Hit Ctrl-C to print the list of processes and terminate.\n");
+ }
+
+ struct timespec t;
+ unsigned long long nsecs;
+ while (true) {
+ if (verbose) {
+ memset(&t, 0, sizeof(t));
+ clock_gettime(CLOCK_MONOTONIC, &t);
+ nsecs = (unsigned long long)t.tv_sec*NS_PER_SEC + t.tv_nsec;
+ }
+ proc_info.scan();
+ if (verbose) {
+ memset(&t, 0, sizeof(t));
+ clock_gettime(CLOCK_MONOTONIC, &t);
+ nsecs = ((unsigned long long)t.tv_sec*NS_PER_SEC + t.tv_nsec) - nsecs;
+ printf("Scan Time %0.4f\n", ((double)nsecs)/NS_PER_SEC);
+ }
+
+ if (SignalReceived != 0) {
+ proc_info.dumpToLog();
+ if (SignalReceived != SIGUSR1 && SignalReceived != SIGTSTP) {
+ if (!quiet) {
+ printf("Terminating...\n");
+ }
+ exit(1);
+ }
+ SignalReceived = 0;
+ }
+ sleep(scan_delay_sec);
+ }
+}
diff --git a/memtrack/memtrack.h b/memtrack/memtrack.h
new file mode 100644
index 00000000..602fdb22
--- /dev/null
+++ b/memtrack/memtrack.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __MEMTRACK_H__
+#define __MEMTRACK_H__
+
+#include <sys/types.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#define DEFAULT_SLEEP_DELAY_SECONDS 5
+#define NS_PER_SEC 1000000000LL
+
+class FileData {
+public:
+ FileData(char *filename, char *buffer, size_t buffer_len);
+ ~FileData();
+
+ // Get the PSS information from the file data. If there are no more
+ // PSS values to be found, return false.
+ bool getPss(size_t *pss);
+
+ // Check if there is at least bytes available in the file data.
+ bool isAvail(size_t bytes);
+
+private:
+ int fd_;
+ char *data_;
+ size_t max_;
+ size_t cur_idx_;
+ size_t len_;
+ bool read_complete_;
+};
+
+typedef struct {
+ std::string name;
+
+ size_t max_num_pids;
+
+ size_t num_samples;
+ double avg_pss_kb;
+ size_t min_pss_kb;
+ size_t max_pss_kb;
+ size_t last_pss_kb;
+
+ std::vector<int> pids;
+} process_info_t;
+typedef std::map<std::string, process_info_t> processes_t;
+
+typedef struct {
+ size_t pss_kb;
+
+ std::vector<int> pids;
+} cur_process_info_t;
+typedef std::map<std::string, cur_process_info_t> cur_processes_t;
+
+class ProcessInfo {
+public:
+ ProcessInfo();
+ ~ProcessInfo();
+
+ // Get the information about a single process.
+ bool getInformation(int pid, char *pid_str, size_t pid_str_len);
+
+ // Scan all of the running processes.
+ void scan();
+
+ // Dump the information about all of the processes in the system to the log.
+ void dumpToLog();
+
+private:
+ static const size_t kBufferLen = 4096;
+ static const size_t kCmdNameLen = 1024;
+
+ static const char *kProc;
+ static const size_t kProcLen = 6;
+
+ static const char *kCmdline;
+ static const size_t kCmdlineLen = 9; // Includes \0 at end of string.
+
+ static const char *kSmaps;
+ static const size_t kSmapsLen = 7; // Includes \0 at end of string.
+
+ static const char *kStatus;
+ static const size_t kStatusLen = 8; // Includes \0 at end of string.
+
+ static const size_t kInitialEntries = 1000;
+
+ char proc_file_[PATH_MAX];
+ char buffer_[kBufferLen];
+
+ char cmd_name_[kCmdNameLen];
+
+ // Minimize a need for a lot of allocations by keeping our maps and
+ // lists in this object.
+ processes_t all_;
+ cur_processes_t cur_;
+ std::vector<const process_info_t *> list_;
+
+ // Compute a running average.
+ static inline void computeAvg(double *running_avg, size_t cur_avg,
+ size_t num_samples) {
+ *running_avg = (*running_avg/(num_samples+1))*num_samples
+ + (double)cur_avg/(num_samples+1);
+ }
+};
+
+#endif // __MEMTRACK_H__
diff --git a/tests/ext4/Android.mk b/tests/ext4/Android.mk
index 0c0cdd08..e76ccae6 100644
--- a/tests/ext4/Android.mk
+++ b/tests/ext4/Android.mk
@@ -26,7 +26,7 @@ LOCAL_SRC_FILES:= rand_emmc_perf.c
LOCAL_MODULE:= rand_emmc_perf
LOCAL_MODULE_TAGS := optional
LOCAL_FORCE_STATIC_EXECUTABLE := true
-LOCAL_STATIC_LIBRARIES := libc
+LOCAL_STATIC_LIBRARIES := libm libc
include $(BUILD_EXECUTABLE)
diff --git a/tests/ext4/android_emmc_perf_tests.sh b/tests/ext4/android_emmc_perf_tests.sh
index c7fc4a55..6464312f 100755
--- a/tests/ext4/android_emmc_perf_tests.sh
+++ b/tests/ext4/android_emmc_perf_tests.sh
@@ -1,6 +1,18 @@
#!/bin/bash
PERF="rand_emmc_perf"
+PERF_LOC=/dev
+STATS_FILE="/data/local/tmp/stats_test"
+STATS_MODE=0
+USERBUILD_MODE=0
+
+if [ "$1" = "-s" ]
+then
+ STATS_MODE=1
+elif [ "$1" = "-u" ]
+then
+ USERBUILD_MODE=1
+fi
if [ ! -r "$PERF" ]
then
@@ -54,102 +66,219 @@ case "$HARDWARE" in
MMCDEV="mmcblk0"
;;
+ flo)
+ CPUFREQ="/sys/devices/system/cpu/cpu0/cpufreq"
+ CACHE="dev/block/platform/msm_sdcc.1/by-name/cache"
+ MMCDEV="mmcblk0"
+ ;;
+
*)
echo "Unknown hardware $HARDWARE. Exiting."
exit 1
esac
-# prepare the device
-adb root
-adb wait-for-device
-adb push "$PERF" /dev
-adb shell stop
-adb shell stop sdcard
-adb shell stop ril-daemon
-adb shell stop media
-adb shell stop drm
-adb shell stop keystore
-adb shell stop tf_daemon
-adb shell stop bluetoothd
-adb shell stop hciattach
-adb shell stop p2p_supplicant
-adb shell stop wpa_supplicant
-adb shell stop mobicore
-adb shell umount /sdcard >/dev/null 2>&1
-adb shell umount /mnt/shell/sdcard0 >/dev/null 2>&1
-adb shell umount /data >/dev/null 2>&1
-adb shell umount /cache >/dev/null 2>&1
+# We cannot stop and unmount stuff in a user build, so don't even try.
+if [ "$USERBUILD_MODE" -eq 0 ]
+then
+ # prepare the device
+ adb root
+ adb wait-for-device
+ adb push "$PERF" /dev
+ adb shell stop
+ adb shell stop sdcard
+ adb shell stop ril-daemon
+ adb shell stop media
+ adb shell stop drm
+ adb shell stop keystore
+ adb shell stop tf_daemon
+ adb shell stop bluetoothd
+ adb shell stop hciattach
+ adb shell stop p2p_supplicant
+ adb shell stop wpa_supplicant
+ adb shell stop mobicore
+ adb shell umount /sdcard >/dev/null 2>&1
+ adb shell umount /mnt/sdcard >/dev/null 2>&1
+ adb shell umount /mnt/shell/sdcard0 >/dev/null 2>&1
+ adb shell umount /mnt/shell/emulated >/dev/null 2>&1
+ adb shell umount /cache >/dev/null 2>&1
+ if [ "$STATS_MODE" -ne 1 ]
+ then
+ adb shell umount /data >/dev/null 2>&1
+ fi
+else
+ # For user builds, put the $PERF binary in /data/local/tmp,
+ # and also setup CACHE to point to a file on /data/local/tmp,
+ # and create that file
+ PERF_LOC=/data/local/tmp
+ adb push "$PERF" "$PERF_LOC"
+ CACHE=/data/local/tmp/testfile
+ echo "Creating testfile for user builds (can take up to 60 seconds)"
+ adb shell dd if=/dev/zero of=$CACHE bs=1048576 count=512
+fi
+
# Add more services here that other devices need to stop.
# So far, this list is sufficient for:
# Prime
-# At this point, the device is quiescent, need to crank up the cpu speed,
-# then run tests
-adb shell "cat $CPUFREQ/cpuinfo_max_freq > $CPUFREQ/scaling_max_freq"
-adb shell "cat $CPUFREQ/cpuinfo_max_freq > $CPUFREQ/scaling_min_freq"
+if [ "$USERBUILD_MODE" -eq 0 ]
+then
+ # At this point, the device is quiescent, need to crank up the cpu speed,
+ # then run tests
+ adb shell "cat $CPUFREQ/cpuinfo_max_freq > $CPUFREQ/scaling_max_freq"
+ adb shell "cat $CPUFREQ/cpuinfo_max_freq > $CPUFREQ/scaling_min_freq"
+fi
# Start the tests
-# Sequential read test
-for I in 1 2 3
-do
- adb shell "echo 3 > /proc/sys/vm/drop_caches"
- echo "Sequential read test $I"
- adb shell dd if="$CACHE" of=/dev/null bs=1048576 count=200
-done
-
-# Sequential write test
-for I in 1 2 3
-do
- echo "Sequential write test $I"
- adb shell dd if=/dev/zero of="$CACHE" bs=1048576 count=200
-done
-
-# Random read tests require that we read from a much larger range of offsets
-# into the emmc chip than the write test. If we only read though 100 Megabytes
-# (and with a read-ahead of 128K), we quickly fill the buffer cache with 100
-# Megabytes of data, and subsequent reads are nearly instantaneous. Since
-# reading is non-destructive, and we've never shipped a device with less than
-# 8 Gbytes, for this test we read from the raw emmc device, and randomly seek
-# in the first 6 Gbytes. That is way more memory than any device we currently
-# have and it should keep the cache from being poluted with entries from
-# previous random reads.
-#
-# Also, test with the read-ahead set very low at 4K, and at the default
-
-# Random read test, 4K read-ahead
-ORIG_READAHEAD=`adb shell cat /sys/block/$MMCDEV/queue/read_ahead_kb | tr -d "\r"`
-adb shell "echo 4 > /sys/block/$MMCDEV/queue/read_ahead_kb"
-for I in 1 2 3
-do
- adb shell "echo 3 > /proc/sys/vm/drop_caches"
- echo "Random read (4K read-ahead) test $I"
- adb shell /dev/"$PERF" -r 6000 "/dev/block/$MMCDEV"
-done
-
-# Random read test, default read-ahead
-adb shell "echo $ORIG_READAHEAD > /sys/block/$MMCDEV/queue/read_ahead_kb"
-for I in 1 2 3
-do
- adb shell "echo 3 > /proc/sys/vm/drop_caches"
- echo "Random read (default read-ahead of ${ORIG_READAHEAD}K) test $I"
- adb shell /dev/"$PERF" -r 6000 "/dev/block/$MMCDEV"
-done
-
-# Random write test
-for I in 1 2 3
-do
- echo "Random write test $I"
- adb shell /dev/"$PERF" -w 100 "$CACHE"
-done
-
-# Random write test with O_SYNC
-for I in 1 2 3
-do
- echo "Random write with o_sync test $I"
- adb shell /dev/"$PERF" -w -o 100 "$CACHE"
-done
-
-# Make a new empty /cache filesystem
-adb shell make_ext4fs "$CACHE"
+if [ "$STATS_MODE" -eq 1 ]
+then
+ # This test looks for the average and max random write times for the emmc
+ # chip. It should be run with the emmc chip full for worst case numbers,
+ # and after fstrim for best case numbers. So first fill the chip, twice,
+ # then run the test, then remove the large file, run fstrim, and run the
+ # test again.
+
+ # Remove the test file if it exists, then make it anew.
+ echo "Filling userdata"
+ adb shell rm -f "$STATS_FILE"
+ adb shell dd if=/dev/zero of="$STATS_FILE" bs=1048576
+ adb shell sync
+
+ # Do it again to make sure to fill up all the reserved blocks used for
+ # wear levelling, plus any unused blocks in the other partitions. Yes,
+ # this is not precise, just a good heuristic.
+ echo "Filling userdata again"
+ adb shell rm "$STATS_FILE"
+ adb shell sync
+ adb shell dd if=/dev/zero of="$STATS_FILE" bs=1048576
+ adb shell sync
+
+ # Run the test
+ echo "Running stats test after filling emmc chip"
+ adb shell /dev/$PERF -w -o -s 20000 -f /dev/full_stats 400 "$CACHE"
+
+ # Remove the file, and have vold do fstrim
+ adb shell rm "$STATS_FILE"
+ adb shell sync
+ # Make sure fstrim knows there is work to do
+ sleep 10
+
+ # Get the current number of FSTRIM complete lines in thh logcat
+ ORIGCNT=`adb shell logcat -d | grep -c "Finished fstrim work"`
+
+ # Attempt to start fstrim
+ OUT=`adb shell vdc fstrim dotrim | grep "Command not recognized"`
+
+ if [ -z "$OUT" ]
+ then
+ # Wait till we see another fstrim finished line
+ sleep 10
+ let T=10
+ NEWCNT=`adb shell logcat -d |grep -c "Finished fstrim work"`
+ while [ "$NEWCNT" -eq "$ORIGCNT" ]
+ do
+ sleep 10
+ let T=T+10
+ if [ "$T" -ge 300 ]
+ then
+ echo "Error: FSTRIM did not complete in 300 seconds, continuing"
+ break
+ fi
+ NEWCNT=`adb shell logcat -d |grep -c "Finished fstrim work"`
+ done
+
+ echo "FSTRIM took "$T" seconds"
+
+ # Run the test again
+ echo "Running test after fstrim"
+ adb shell /dev/$PERF -w -o -s 20000 -f /dev/fstrimmed_stats 400 "$CACHE"
+
+ # Retrieve the full data logs
+ adb pull /dev/fstrimmed_stats $HARDWARE-fstrimmed_stats
+ adb pull /dev/full_stats $HARDWARE-full_stats
+ else
+ echo "Device doesn't support fstrim, not running test a second time"
+ fi
+
+else
+
+ # Sequential read test
+ if [ "$USERBUILD_MODE" -eq 0 ]
+ then
+ # There is no point in running this in USERBUILD mode, because
+ # we can't drop caches, and the numbers are ludicrously high
+ for I in 1 2 3
+ do
+ adb shell "echo 3 > /proc/sys/vm/drop_caches"
+ echo "Sequential read test $I"
+ adb shell dd if="$CACHE" of=/dev/null bs=1048576 count=200
+ done
+ fi
+
+ # Sequential write test
+ for I in 1 2 3
+ do
+ echo "Sequential write test $I"
+ # It's unclear if this test is useful on USERBUILDS, given the
+ # caching on the filesystem
+ adb shell dd if=/dev/zero conv=notrunc of="$CACHE" bs=1048576 count=200
+ done
+
+ if [ "$USERBUILD_MODE" -eq 0 ]
+ then
+ # Random read tests require that we read from a much larger range of offsets
+ # into the emmc chip than the write test. If we only read though 100 Megabytes
+ # (and with a read-ahead of 128K), we quickly fill the buffer cache with 100
+ # Megabytes of data, and subsequent reads are nearly instantaneous. Since
+ # reading is non-destructive, and we've never shipped a device with less than
+ # 8 Gbytes, for this test we read from the raw emmc device, and randomly seek
+ # in the first 6 Gbytes. That is way more memory than any device we currently
+ # have and it should keep the cache from being poluted with entries from
+ # previous random reads.
+ #
+ # Also, test with the read-ahead set very low at 4K, and at the default
+
+ # Random read test, 4K read-ahead
+ ORIG_READAHEAD=`adb shell cat /sys/block/$MMCDEV/queue/read_ahead_kb | tr -d "\r"`
+ adb shell "echo 4 > /sys/block/$MMCDEV/queue/read_ahead_kb"
+ for I in 1 2 3
+ do
+ adb shell "echo 3 > /proc/sys/vm/drop_caches"
+ echo "Random read (4K read-ahead) test $I"
+ adb shell "$PERF_LOC"/"$PERF" -r 6000 "/dev/block/$MMCDEV"
+ done
+
+ # Random read test, default read-ahead
+ adb shell "echo $ORIG_READAHEAD > /sys/block/$MMCDEV/queue/read_ahead_kb"
+ for I in 1 2 3
+ do
+ adb shell "echo 3 > /proc/sys/vm/drop_caches"
+ echo "Random read (default read-ahead of ${ORIG_READAHEAD}K) test $I"
+ adb shell "$PERF_LOC"/"$PERF" -r 6000 "/dev/block/$MMCDEV"
+ done
+ fi
+
+ # Random write test
+ for I in 1 2 3
+ do
+ echo "Random write test $I"
+ adb shell "$PERF_LOC"/"$PERF" -w 100 "$CACHE"
+ done
+
+ # Random write test with O_SYNC
+ for I in 1 2 3
+ do
+ echo "Random write with o_sync test $I"
+ adb shell "$PERF_LOC"/"$PERF" -w -o 100 "$CACHE"
+ done
+fi
+
+# cleanup
+if [ "$USERBUILD_MODE" -eq 0 ]
+then
+ # Make a new empty /cache filesystem
+ adb shell make_ext4fs -w "$CACHE"
+else
+ adb shell rm -f "$CACHE" "$PERF_LOC"/"$PERF"
+fi
diff --git a/tests/ext4/rand_emmc_perf.c b/tests/ext4/rand_emmc_perf.c
index 9c633369..ed6a05cc 100644
--- a/tests/ext4/rand_emmc_perf.c
+++ b/tests/ext4/rand_emmc_perf.c
@@ -29,27 +29,170 @@
#include <sys/time.h>
#include <stdlib.h>
#include <unistd.h>
+#include <math.h>
#define TST_BLK_SIZE 4096
/* Number of seconds to run the test */
#define TEST_LEN 10
+struct stats {
+ struct timeval start;
+ struct timeval end;
+ off64_t offset;
+};
+
static void usage(void) {
- fprintf(stderr, "Usage: rand_emmc_perf [ -r | -w ] [-o] <size_in_mb> <block_dev>\n");
+ fprintf(stderr, "Usage: rand_emmc_perf [ -r | -w ] [-o] [-s count] [-f full_stats_filename] <size_in_mb> <block_dev>\n");
exit(1);
}
-int main(int argc, char *argv[])
+static void print_stats(struct stats *stats_buf, int stats_count,
+ char * full_stats_file)
+{
+ int i;
+ struct timeval t;
+ struct timeval sum = { 0 };
+ struct timeval max = { 0 };
+ long long total_usecs;
+ long long avg_usecs;
+ long long max_usecs;
+ long long variance = 0;;
+ long long x;
+ double sdev;
+ FILE *full_stats = NULL;
+
+ if (full_stats_file) {
+ full_stats = fopen(full_stats_file, "w");
+ if (full_stats == NULL) {
+ fprintf(stderr, "Cannot open full stats output file %s, ignoring\n",
+ full_stats_file);
+ }
+ }
+
+ for (i = 0; i < stats_count; i++) {
+ timersub(&stats_buf[i].end, &stats_buf[i].start, &t);
+ if (timercmp(&t, &max, >)) {
+ max = t;
+ }
+ if (full_stats) {
+ fprintf(full_stats, "%lld\n", (t.tv_sec * 1000000LL) + t.tv_usec);
+ }
+ timeradd(&sum, &t, &sum);
+ }
+
+ if (full_stats) {
+ fclose(full_stats);
+ }
+
+ max_usecs = (max.tv_sec * 1000000LL) + max.tv_usec;
+ total_usecs = (sum.tv_sec * 1000000LL) + sum.tv_usec;
+ avg_usecs = total_usecs / stats_count;
+ printf("average random %d byte iop time = %lld usecs\n",
+ TST_BLK_SIZE, avg_usecs);
+ printf("maximum random %d byte iop time = %lld usecs\n",
+ TST_BLK_SIZE, max_usecs);
+
+ /* Now that we have the average (aka mean) go through the data
+ * again and compute the standard deviation.
+ * The formula is sqrt(sum_1_to_n((Xi - avg)^2)/n)
+ */
+ for (i = 0; i < stats_count; i++) {
+ timersub(&stats_buf[i].end, &stats_buf[i].start, &t); /* Xi */
+ x = (t.tv_sec * 1000000LL) + t.tv_usec; /* Convert to long long */
+ x = x - avg_usecs; /* Xi - avg */
+ x = x * x; /* (Xi - avg) ^ 2 */
+ variance += x; /* Summation */
+ }
+ sdev = sqrt((double)variance/(double)stats_count);
+ printf("standard deviation of iops is %.2f\n", sdev);
+}
+
+static void stats_test(int fd, int write_mode, off64_t max_blocks, int stats_count,
+ char *full_stats_file)
+{
+ struct stats *stats_buf;
+ char buf[TST_BLK_SIZE] = { 0 };
+ int i;
+
+ stats_buf = malloc(stats_count * sizeof(struct stats));
+ if (stats_buf == NULL) {
+ fprintf(stderr, "Cannot allocate stats_buf\n");
+ exit(1);
+ }
+
+ for (i = 0; i < stats_count; i++) {
+ gettimeofday(&stats_buf[i].start, NULL);
+
+ if (lseek64(fd, (rand() % max_blocks) * TST_BLK_SIZE, SEEK_SET) < 0) {
+ fprintf(stderr, "lseek64 failed\n");
+ }
+
+ if (write_mode) {
+ if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
+ fprintf(stderr, "Short write\n");
+ }
+ } else {
+ if (read(fd, buf, sizeof(buf)) != sizeof(buf)) {
+ fprintf(stderr, "Short read\n");
+ }
+ }
+
+ gettimeofday(&stats_buf[i].end, NULL);
+ }
+
+ print_stats(stats_buf, stats_count, full_stats_file);
+}
+
+static void perf_test(int fd, int write_mode, off64_t max_blocks)
{
- unsigned long long max_blocks;
- int fd, fd2, write_mode = 0, iops = 0;
struct timeval start, end, res;
- unsigned int seed;
char buf[TST_BLK_SIZE] = { 0 };
- int c;
+ int iops = 0;
+ int msecs;
+
+ res.tv_sec = 0;
+ gettimeofday(&start, NULL);
+ while (res.tv_sec < TEST_LEN) {
+ if (lseek64(fd, (rand() % max_blocks) * TST_BLK_SIZE, SEEK_SET) < 0) {
+ fprintf(stderr, "lseek64 failed\n");
+ }
+ if (write_mode) {
+ if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
+ fprintf(stderr, "Short write\n");
+ }
+ } else {
+ if (read(fd, buf, sizeof(buf)) != sizeof(buf)) {
+ fprintf(stderr, "Short read\n");
+ }
+ }
+ iops++;
+ gettimeofday(&end, NULL);
+ timersub(&end, &start, &res);
+ }
+ close(fd);
+
+ /* The close can take a while when in write_mode as buffers are flushed.
+ * So get the time again. */
+ gettimeofday(&end, NULL);
+ timersub(&end, &start, &res);
+
+ msecs = (res.tv_sec * 1000) + (res.tv_usec / 1000);
+ printf("%d %dbyte iops/sec\n", iops * 1000 / msecs, TST_BLK_SIZE);
+}
+
+int main(int argc, char *argv[])
+{
+ int fd, fd2;
+ int write_mode = 0;
int o_sync = 0;
+ int stats_mode = 0;
+ int stats_count;
+ char *full_stats_file = NULL;
+ off64_t max_blocks;
+ unsigned int seed;
+ int c;
- while ((c = getopt(argc, argv, "+rwo")) != -1) {
+ while ((c = getopt(argc, argv, "+rwos:f:")) != -1) {
switch (c) {
case '?':
default:
@@ -67,6 +210,18 @@ int main(int argc, char *argv[])
case 'o':
o_sync = O_SYNC;
break;
+
+ case 's':
+ stats_mode = 1;
+ stats_count = atoi(optarg);
+ break;
+
+ case 'f':
+ full_stats_file = strdup(optarg);
+ if (full_stats_file == NULL) {
+ fprintf(stderr, "Cannot get full stats filename\n");
+ }
+ break;
}
}
@@ -81,7 +236,7 @@ int main(int argc, char *argv[])
}
/* Size is given in megabytes, so compute the number of TST_BLK_SIZE blocks. */
- max_blocks = atol(argv[optind]) * ((1024*1024) / TST_BLK_SIZE);
+ max_blocks = atoll(argv[optind]) * ((1024*1024) / TST_BLK_SIZE);
if ((fd = open(argv[optind + 1], O_RDWR | o_sync)) < 0) {
fprintf(stderr, "Cannot open block device %s\n", argv[optind + 1]);
@@ -98,33 +253,11 @@ int main(int argc, char *argv[])
close(fd2);
srand(seed);
- res.tv_sec = 0;
- gettimeofday(&start, 0);
- while (res.tv_sec < TEST_LEN) {
- if (lseek64(fd, (rand() % max_blocks) * TST_BLK_SIZE, SEEK_SET) < 0) {
- fprintf(stderr, "lseek64 failed\n");
- }
- if (write_mode) {
- if (write(fd, buf, sizeof(buf)) != sizeof(buf)) {
- fprintf(stderr, "Short write\n");
- }
- } else {
- if (read(fd, buf, sizeof(buf)) != sizeof(buf)) {
- fprintf(stderr, "Short read\n");
- }
- }
- iops++;
- gettimeofday(&end, 0);
- timersub(&end, &start, &res);
+ if (stats_mode) {
+ stats_test(fd, write_mode, max_blocks, stats_count, full_stats_file);
+ } else {
+ perf_test(fd, write_mode, max_blocks);
}
- close(fd);
-
- /* The close can take a while when in write_mode as buffers are flushed.
- * So get the time again. */
- gettimeofday(&end, 0);
- timersub(&end, &start, &res);
-
- printf("%d iops/sec\n", iops / (int) res.tv_sec);
exit(0);
}
diff --git a/tests/mmc_tracepoints/README b/tests/mmc_tracepoints/README
new file mode 100644
index 00000000..37aba304
--- /dev/null
+++ b/tests/mmc_tracepoints/README
@@ -0,0 +1,27 @@
+The code in this directory is used to process data from the mmc tracepoints
+in the kernel. To turn on mmc tracing, do this:
+
+ adb shell echo 1 >/d/tracing/events/mmc/enable
+ adb shell echo 1 >/d/tracing/tracing_on
+
+To get the trace:
+
+ adb pull /d/tracing/trace
+
+To turn it back off, do:
+
+ adb shell echo 0 >/d/tracing/tracing_enabled
+
+The output is in a form of start/stop pairs. The ops with rw in the name are
+read or write ops, and the ones with erase in the name are the various erase
+opts.
+
+The mmc_trace_reduce script will take the output from the kernel, and convert it
+to a single line per event, which includes the duration of the event.
+
+This can then be fed into other tools for further analysis.
+
+The file mmc_trace_sample_data contains sample mmc trace data from a Nexus 10.
+It includes read, write and discard entries. The discard entries came from
+invoking fstrim in vold with "vdc fstrim dotrim".
+
diff --git a/tests/mmc_tracepoints/mmc_trace_reduce b/tests/mmc_tracepoints/mmc_trace_reduce
new file mode 100755
index 00000000..ef6683eb
--- /dev/null
+++ b/tests/mmc_tracepoints/mmc_trace_reduce
@@ -0,0 +1,152 @@
+#!/bin/bash
+
+# TO DO
+# This should be re-written in python.
+
+# Complain about dereferencing unset variables
+set -u
+typeset -i STARTTIME ENDTIME DURATION START_SEC START_USEC DUR_SEC DUR_USEC
+
+if [ "$#" -ne 1 ]
+then
+ echo "Usage: mmc_trace_reduce <trace_file>" >&2
+ exit 1
+fi
+
+exec < "$1"
+
+SAVED_START_LINE=""
+
+while read LINE
+do
+ # Skip comment lines
+ if [ -z "${LINE###*}" ]
+ then
+ continue
+ fi
+
+ # Fix up lines with nuisance spaces
+ LINE=${LINE/AsyncTask /AsyncTask-}
+
+ set $LINE
+
+ if [ "${5##*mmc_blk_*_}" = "start:" ]
+ then
+ if [ ! -z "$SAVED_START_LINE" ]
+ then
+ echo "Ignoring consecutive start line" >&2
+ continue
+ fi
+ SAVED_START_LINE="$LINE"
+
+ # Found a start line. Extract the interesting bits
+ TMP=${4%:}
+ START_SEC="10#${TMP%%.*}"
+ STARTTIME=START_SEC*1000000
+ START_USEC="10#${TMP##*.}"
+ STARTTIME=STARTTIME+START_USEC
+
+ STARTPARMS="$6"
+ STARTCMD=${STARTPARMS%%,addr=*}
+ STARTCMD=${STARTCMD##*cmd=}
+ STARTADDR=${STARTPARMS%%,size=*}
+ STARTADDR=${STARTADDR##*addr=}
+ STARTSIZE=${STARTPARMS##*size=}
+
+ elif [ "${5##*mmc_blk_*_}" = "end:" ]
+ then
+ # Found an end line. Extract the interesting bits,
+ # then make sure it matches with the saved start line,
+ # Finally, do the math and emit a single reduced line
+ TMP=${4%:}
+ ENDTIME="${TMP%%.*}"
+ ENDTIME=ENDTIME*1000000
+ ENDTIME=ENDTIME+10#${TMP##*.}
+
+ ENDPARMS="$6"
+ ENDCMD=${ENDPARMS%%,addr=*}
+ ENDCMD=${ENDCMD##*cmd=}
+ ENDADDR=${ENDPARMS%%,size=*}
+ ENDADDR=${ENDADDR##*addr=}
+ ENDSIZE=${ENDPARMS##*size=}
+
+ if [ "$ENDCMD" != "$STARTCMD" ]
+ then
+ echo "End cmd doesn't match start cmd, ignoring both" >&2
+ SAVED_START_LINE=""
+ continue
+ fi
+ if [ "$ENDADDR" != "$STARTADDR" ]
+ then
+ echo "End addr doesn't match start addr, ignoring both" >&2
+ SAVED_START_LINE=""
+ continue
+ fi
+ if [ "$ENDSIZE" != "$STARTSIZE" ]
+ then
+ echo "End size doesn't match start size, ignoring both" >&2
+ SAVED_START_LINE=""
+ continue
+ fi
+
+ # Turn the command number into a command the flash analysis tool
+ # understands. The tool doesn't differentiate between the different
+ # forms erase, so just emit "discard" for all of them. Also, ignore
+ # the secure_trim2 and sanitize commands as the tool doesn't know
+ # about them either.
+ if [ "$ENDCMD" -eq 18 ]
+ then
+ ENDCMD="read"
+ elif [ "$ENDCMD" -eq 25 ]
+ then
+ ENDCMD="write"
+ elif [ "$ENDCMD" -eq 32 ]
+ then
+ ENDCMD="flush"
+ continue
+ elif [ "$ENDCMD" -eq 0 ]
+ then
+ ENDCMD="discard"
+ elif [ "$ENDCMD" -eq 1 ]
+ then
+ ENDCMD="discard"
+ elif [ "$ENDCMD" -eq 3 ]
+ then
+ ENDCMD="discard"
+ elif [ "$ENDCMD" -eq 2147483648 ] # 0x80000000
+ then
+ ENDCMD="discard"
+ elif [ "$ENDCMD" -eq 2147483649 ] # 0x80000001
+ then
+ ENDCMD="discard"
+ elif [ "$ENDCMD" -eq 2147516416 ] # 0x80008000
+ then
+ # Ignore, as the analysis tool doesn't deal with this
+ # ENDCMD="secure_trim2"
+ SAVED_START_LINE=""
+ continue
+ elif [ "$ENDCMD" -eq 165 ]
+ then
+ # Ignore, as the analysis tool doesn't deal with this
+ # ENDCMD="sanitize"
+ SAVED_START_LINE=""
+ continue
+ else
+ echo "Unrecognized command $ENDCMD, ignoring" >&2
+ SAVED_START_LINE=""
+ continue
+ fi
+
+ DURATION=ENDTIME-STARTTIME
+ DUR_SEC=DURATION/1000000
+ DUR_USEC=DURATION%1000000
+
+ printf "$%s,%s,%s,%d.%06d,%d.%06d\n" "$ENDCMD" "$ENDADDR" "$ENDSIZE" "$START_SEC" "$START_USEC" "$DUR_SEC" "$DUR_USEC"
+
+ SAVED_START_LINE=""
+ fi
+
+ # Ignore unknown lines and continue
+
+done
+
diff --git a/tests/mmc_tracepoints/mmc_trace_sample_data b/tests/mmc_tracepoints/mmc_trace_sample_data
new file mode 100644
index 00000000..4e62dcb7
--- /dev/null
+++ b/tests/mmc_tracepoints/mmc_trace_sample_data
@@ -0,0 +1,1545 @@
+# tracer: nop
+#
+# entries-in-buffer/entries-written: 1534/1534 #P:2
+#
+# _-----=> irqs-off
+# / _----=> need-resched
+# | / _---=> hardirq/softirq
+# || / _--=> preempt-depth
+# ||| / delay
+# TASK-PID CPU# |||| TIMESTAMP FUNCTION
+# | | | |||| | |
+ mmcqd/0-82 [000] ...1 49.828932: mmc_blk_rw_start: cmd=25,addr=0x002c6518,size=0x00000010
+ <...>-1484 [000] ..s4 49.829171: mmc_blk_rw_end: cmd=25,addr=0x002c6518,size=0x00000010
+ mmcqd/0-82 [000] ...1 49.830095: mmc_blk_rw_start: cmd=25,addr=0x002c6528,size=0x00000008
+ kworker/0:2-48 [000] ..s4 49.830218: mmc_blk_rw_end: cmd=25,addr=0x002c6528,size=0x00000008
+ mmcqd/0-82 [000] ...1 52.465957: mmc_blk_rw_start: cmd=18,addr=0x001ad578,size=0x00000020
+ <idle>-0 [000] ..s3 52.466404: mmc_blk_rw_end: cmd=18,addr=0x001ad578,size=0x00000020
+ mmcqd/0-82 [000] ...1 52.492868: mmc_blk_rw_start: cmd=18,addr=0x001aecb8,size=0x00000020
+ <idle>-0 [000] ..s3 52.493157: mmc_blk_rw_end: cmd=18,addr=0x001aecb8,size=0x00000020
+ mmcqd/0-82 [000] ...1 54.834287: mmc_blk_rw_start: cmd=25,addr=0x005420a8,size=0x00000008
+ <idle>-0 [000] ..s3 54.834383: mmc_blk_rw_end: cmd=25,addr=0x005420a8,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.114476: mmc_blk_rw_start: cmd=18,addr=0x0013fb18,size=0x00000020
+ <idle>-0 [000] .Ns3 56.114862: mmc_blk_rw_end: cmd=18,addr=0x0013fb18,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.115150: mmc_blk_rw_start: cmd=18,addr=0x0013fb38,size=0x00000040
+ Binder_4-434 [000] ..s3 56.115539: mmc_blk_rw_end: cmd=18,addr=0x0013fb38,size=0x00000040
+ mmcqd/0-82 [000] ...1 56.115616: mmc_blk_rw_start: cmd=18,addr=0x0013faf0,size=0x00000020
+ Binder_4-434 [000] ..s2 56.115856: mmc_blk_rw_end: cmd=18,addr=0x0013faf0,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.118937: mmc_blk_rw_start: cmd=18,addr=0x0013fb78,size=0x00000200
+ <idle>-0 [000] ..s3 56.120836: mmc_blk_rw_end: cmd=18,addr=0x0013fb78,size=0x00000200
+ mmcqd/0-82 [000] ...1 56.123287: mmc_blk_rw_start: cmd=18,addr=0x0013faa8,size=0x00000020
+ <idle>-0 [000] .Ns3 56.123668: mmc_blk_rw_end: cmd=18,addr=0x0013faa8,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.125172: mmc_blk_rw_start: cmd=18,addr=0x0013fb10,size=0x00000008
+ Compiler-387 [000] ..s4 56.125356: mmc_blk_rw_end: cmd=18,addr=0x0013fb10,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.136772: mmc_blk_rw_start: cmd=18,addr=0x0013fd80,size=0x00000008
+ <idle>-0 [000] ..s3 56.136934: mmc_blk_rw_end: cmd=18,addr=0x0013fd80,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.138223: mmc_blk_rw_start: cmd=18,addr=0x0013fda0,size=0x00000008
+ <idle>-0 [000] ..s3 56.138395: mmc_blk_rw_end: cmd=18,addr=0x0013fda0,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.398796: mmc_blk_rw_start: cmd=18,addr=0x0035af18,size=0x00000020
+ WindowManager-396 [000] ..s2 56.399184: mmc_blk_rw_end: cmd=18,addr=0x0035af18,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.399205: mmc_blk_rw_start: cmd=18,addr=0x0035af40,size=0x000000c0
+ WindowManager-396 [000] ..s2 56.399992: mmc_blk_rw_end: cmd=18,addr=0x0035af40,size=0x000000c0
+ mmcqd/0-82 [000] ...1 56.400029: mmc_blk_rw_start: cmd=18,addr=0x00361000,size=0x00000018
+ WindowManager-396 [000] ..s2 56.400300: mmc_blk_rw_end: cmd=18,addr=0x00361000,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.400358: mmc_blk_rw_start: cmd=18,addr=0x003610e8,size=0x00000088
+ WindowManager-396 [000] ..s2 56.400993: mmc_blk_rw_end: cmd=18,addr=0x003610e8,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.402605: mmc_blk_rw_start: cmd=18,addr=0x0035aab8,size=0x00000100
+ WindowManager-396 [000] .Ns3 56.403653: mmc_blk_rw_end: cmd=18,addr=0x0035aab8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.404001: mmc_blk_rw_start: cmd=18,addr=0x0035a250,size=0x00000100
+ WindowManager-396 [000] ..s3 56.404986: mmc_blk_rw_end: cmd=18,addr=0x0035a250,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.405199: mmc_blk_rw_start: cmd=18,addr=0x0035ade0,size=0x00000100
+ WindowManager-396 [000] ..s3 56.406153: mmc_blk_rw_end: cmd=18,addr=0x0035ade0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.406346: mmc_blk_rw_start: cmd=18,addr=0x0035a020,size=0x000000e8
+ WindowManager-396 [000] ..s2 56.407260: mmc_blk_rw_end: cmd=18,addr=0x0035a020,size=0x000000e8
+ mmcqd/0-82 [000] ...1 56.407510: mmc_blk_rw_start: cmd=18,addr=0x0035a108,size=0x00000090
+ Compiler-387 [000] ..s2 56.408158: mmc_blk_rw_end: cmd=18,addr=0x0035a108,size=0x00000090
+ mmcqd/0-82 [000] ...1 56.408391: mmc_blk_rw_start: cmd=18,addr=0x0035ac10,size=0x00000100
+ WindowManager-396 [000] ..s2 56.409353: mmc_blk_rw_end: cmd=18,addr=0x0035ac10,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.409602: mmc_blk_rw_start: cmd=18,addr=0x0035abb8,size=0x00000058
+ WindowManager-396 [000] ..s2 56.410055: mmc_blk_rw_end: cmd=18,addr=0x0035abb8,size=0x00000058
+ mmcqd/0-82 [000] ...1 56.410338: mmc_blk_rw_start: cmd=18,addr=0x0035ad10,size=0x000000d0
+ UI-395 [000] ..s3 56.411151: mmc_blk_rw_end: cmd=18,addr=0x0035ad10,size=0x000000d0
+ mmcqd/0-82 [000] ...1 56.411364: mmc_blk_rw_start: cmd=18,addr=0x0035a198,size=0x000000b0
+ kworker/0:2-48 [000] ..s2 56.412130: mmc_blk_rw_end: cmd=18,addr=0x0035a198,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.412521: mmc_blk_rw_start: cmd=18,addr=0x0035a350,size=0x000000b8
+ <idle>-0 [000] ..s3 56.413278: mmc_blk_rw_end: cmd=18,addr=0x0035a350,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.415655: mmc_blk_rw_start: cmd=18,addr=0x00361018,size=0x000000b8
+ <idle>-0 [000] ..s3 56.416489: mmc_blk_rw_end: cmd=18,addr=0x00361018,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.416798: mmc_blk_rw_start: cmd=18,addr=0x0035a570,size=0x00000100
+ <idle>-0 [000] ..s3 56.417832: mmc_blk_rw_end: cmd=18,addr=0x0035a570,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.418187: mmc_blk_rw_start: cmd=18,addr=0x0035aa00,size=0x000000b8
+ <idle>-0 [000] ..s3 56.418901: mmc_blk_rw_end: cmd=18,addr=0x0035aa00,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.422006: mmc_blk_rw_start: cmd=18,addr=0x0035a670,size=0x000000c0
+ <idle>-0 [000] ..s3 56.422804: mmc_blk_rw_end: cmd=18,addr=0x0035a670,size=0x000000c0
+ mmcqd/0-82 [000] ...1 56.424176: mmc_blk_rw_start: cmd=18,addr=0x00b91498,size=0x00000008
+ <idle>-0 [000] ..s3 56.424325: mmc_blk_rw_end: cmd=18,addr=0x00b91498,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.432630: mmc_blk_rw_start: cmd=18,addr=0x0035a918,size=0x000000e8
+ <idle>-0 [000] ..s3 56.433782: mmc_blk_rw_end: cmd=18,addr=0x0035a918,size=0x000000e8
+ mmcqd/0-82 [000] ...1 56.434442: mmc_blk_rw_start: cmd=18,addr=0x0035aee0,size=0x00000038
+ <idle>-0 [000] ..s3 56.434774: mmc_blk_rw_end: cmd=18,addr=0x0035aee0,size=0x00000038
+ mmcqd/0-82 [000] ...1 56.435132: mmc_blk_rw_start: cmd=18,addr=0x0035a248,size=0x00000008
+ <idle>-0 [000] ..s3 56.435292: mmc_blk_rw_end: cmd=18,addr=0x0035a248,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.435774: mmc_blk_rw_start: cmd=18,addr=0x0035a408,size=0x00000100
+ <idle>-0 [000] ..s3 56.436777: mmc_blk_rw_end: cmd=18,addr=0x0035a408,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.436924: mmc_blk_rw_start: cmd=18,addr=0x0035a730,size=0x000000b0
+ <idle>-0 [000] ..s3 56.437682: mmc_blk_rw_end: cmd=18,addr=0x0035a730,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.443462: mmc_blk_rw_start: cmd=18,addr=0x0035a508,size=0x00000068
+ <idle>-0 [000] ..s3 56.443997: mmc_blk_rw_end: cmd=18,addr=0x0035a508,size=0x00000068
+ mmcqd/0-82 [000] ...1 56.446861: mmc_blk_rw_start: cmd=18,addr=0x003610d0,size=0x00000018
+ ion_chunk_heap-18 [000] ..s2 56.447095: mmc_blk_rw_end: cmd=18,addr=0x003610d0,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.457912: mmc_blk_rw_start: cmd=18,addr=0x0013ffd0,size=0x00000020
+ <idle>-0 [000] ..s3 56.458311: mmc_blk_rw_end: cmd=18,addr=0x0013ffd0,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.503358: mmc_blk_rw_start: cmd=18,addr=0x0013fdb8,size=0x00000008
+ <idle>-0 [000] ..s3 56.503531: mmc_blk_rw_end: cmd=18,addr=0x0013fdb8,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.599614: mmc_blk_rw_start: cmd=18,addr=0x001cae08,size=0x00000020
+ <...>-1488 [000] ..s2 56.599978: mmc_blk_rw_end: cmd=18,addr=0x001cae08,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.600278: mmc_blk_rw_start: cmd=18,addr=0x001dab70,size=0x00000088
+ <...>-1488 [000] .Ns2 56.600968: mmc_blk_rw_end: cmd=18,addr=0x001dab70,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.601458: mmc_blk_rw_start: cmd=18,addr=0x001da970,size=0x00000100
+ <...>-186 [000] ..s4 56.602466: mmc_blk_rw_end: cmd=18,addr=0x001da970,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.602892: mmc_blk_rw_start: cmd=18,addr=0x001cae28,size=0x000000e0
+ <...>-1488 [000] ..s2 56.603805: mmc_blk_rw_end: cmd=18,addr=0x001cae28,size=0x000000e0
+ mmcqd/0-82 [000] ...1 56.604302: mmc_blk_rw_start: cmd=18,addr=0x001f1980,size=0x00000010
+ <...>-1488 [000] ..s2 56.604534: mmc_blk_rw_end: cmd=18,addr=0x001f1980,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.605940: mmc_blk_rw_start: cmd=18,addr=0x001c7f48,size=0x00000018
+ <...>-1488 [000] ..s2 56.606185: mmc_blk_rw_end: cmd=18,addr=0x001c7f48,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.606682: mmc_blk_rw_start: cmd=18,addr=0x00207318,size=0x00000020
+ <...>-1488 [000] ..s2 56.607019: mmc_blk_rw_end: cmd=18,addr=0x00207318,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.607347: mmc_blk_rw_start: cmd=18,addr=0x002073d8,size=0x00000088
+ <...>-1488 [000] ..s2 56.607987: mmc_blk_rw_end: cmd=18,addr=0x002073d8,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.608403: mmc_blk_rw_start: cmd=18,addr=0x00207338,size=0x000000a0
+ <...>-1488 [000] ..s2 56.609126: mmc_blk_rw_end: cmd=18,addr=0x00207338,size=0x000000a0
+ mmcqd/0-82 [000] ...1 56.612141: mmc_blk_rw_start: cmd=18,addr=0x001cbcb0,size=0x00000100
+ <...>-1488 [000] ..s2 56.613209: mmc_blk_rw_end: cmd=18,addr=0x001cbcb0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.615745: mmc_blk_rw_start: cmd=18,addr=0x001caf08,size=0x00000100
+ SurfaceFlinger-150 [000] ..s2 56.616755: mmc_blk_rw_end: cmd=18,addr=0x001caf08,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.616885: mmc_blk_rw_start: cmd=18,addr=0x001d9ff0,size=0x00000100
+ Binder_7-622 [000] ..s4 56.618039: mmc_blk_rw_end: cmd=18,addr=0x001d9ff0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.619426: mmc_blk_rw_start: cmd=18,addr=0x001da0f0,size=0x00000100
+ Binder_7-622 [000] ..s2 56.620534: mmc_blk_rw_end: cmd=18,addr=0x001da0f0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.620701: mmc_blk_rw_start: cmd=18,addr=0x001da1f0,size=0x00000100
+ <idle>-0 [000] ..s3 56.621724: mmc_blk_rw_end: cmd=18,addr=0x001da1f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.621879: mmc_blk_rw_start: cmd=18,addr=0x001cb008,size=0x00000100
+ Binder_B-670 [000] ..s2 56.622887: mmc_blk_rw_end: cmd=18,addr=0x001cb008,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.627277: mmc_blk_rw_start: cmd=18,addr=0x001da2f0,size=0x00000100
+ <...>-1503 [000] ..s2 56.628332: mmc_blk_rw_end: cmd=18,addr=0x001da2f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.628525: mmc_blk_rw_start: cmd=18,addr=0x001cb108,size=0x00000100
+ <...>-1488 [000] ..s2 56.629524: mmc_blk_rw_end: cmd=18,addr=0x001cb108,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.629924: mmc_blk_rw_start: cmd=18,addr=0x001da3f0,size=0x00000100
+ <...>-1503 [000] ..s2 56.630942: mmc_blk_rw_end: cmd=18,addr=0x001da3f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.631074: mmc_blk_rw_start: cmd=18,addr=0x001cb208,size=0x00000100
+ SurfaceFlinger-150 [000] ..s2 56.632066: mmc_blk_rw_end: cmd=18,addr=0x001cb208,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.639698: mmc_blk_rw_start: cmd=18,addr=0x001cb308,size=0x00000100
+ <...>-1488 [000] ..s4 56.640734: mmc_blk_rw_end: cmd=18,addr=0x001cb308,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.640888: mmc_blk_rw_start: cmd=18,addr=0x001cb408,size=0x00000100
+ <...>-1488 [000] ..s2 56.641892: mmc_blk_rw_end: cmd=18,addr=0x001cb408,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.641926: mmc_blk_rw_start: cmd=18,addr=0x001da4f0,size=0x00000100
+ <...>-1488 [000] ..s2 56.642952: mmc_blk_rw_end: cmd=18,addr=0x001da4f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.642981: mmc_blk_rw_start: cmd=18,addr=0x001da5f0,size=0x00000100
+ <...>-1503 [000] ..s2 56.643995: mmc_blk_rw_end: cmd=18,addr=0x001da5f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.644277: mmc_blk_rw_start: cmd=18,addr=0x001cb508,size=0x00000100
+ kworker/0:1-23 [000] ..s2 56.645266: mmc_blk_rw_end: cmd=18,addr=0x001cb508,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.645946: mmc_blk_rw_start: cmd=18,addr=0x001cb608,size=0x00000100
+ <idle>-0 [000] ..s3 56.646933: mmc_blk_rw_end: cmd=18,addr=0x001cb608,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.647065: mmc_blk_rw_start: cmd=18,addr=0x001da6f0,size=0x00000100
+ <idle>-0 [000] .Ns3 56.648106: mmc_blk_rw_end: cmd=18,addr=0x001da6f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.651473: mmc_blk_rw_start: cmd=18,addr=0x001cb708,size=0x00000100
+ <idle>-0 [000] ..s3 56.652503: mmc_blk_rw_end: cmd=18,addr=0x001cb708,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.652660: mmc_blk_rw_start: cmd=18,addr=0x001cb808,size=0x00000100
+ <idle>-0 [000] ..s3 56.653650: mmc_blk_rw_end: cmd=18,addr=0x001cb808,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.654708: mmc_blk_rw_start: cmd=18,addr=0x001da7f0,size=0x00000100
+ <idle>-0 [000] ..s3 56.655755: mmc_blk_rw_end: cmd=18,addr=0x001da7f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.655961: mmc_blk_rw_start: cmd=18,addr=0x001da8f0,size=0x00000080
+ <...>-1488 [000] ..s2 56.656559: mmc_blk_rw_end: cmd=18,addr=0x001da8f0,size=0x00000080
+ mmcqd/0-82 [000] ...1 56.656590: mmc_blk_rw_start: cmd=18,addr=0x001cb908,size=0x00000100
+ <...>-1488 [000] ..s3 56.657590: mmc_blk_rw_end: cmd=18,addr=0x001cb908,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.661710: mmc_blk_rw_start: cmd=18,addr=0x001cba08,size=0x00000100
+ <...>-1488 [000] ..s2 56.662732: mmc_blk_rw_end: cmd=18,addr=0x001cba08,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.663283: mmc_blk_rw_start: cmd=18,addr=0x001cbb08,size=0x00000100
+ <...>-1488 [000] ..s2 56.664267: mmc_blk_rw_end: cmd=18,addr=0x001cbb08,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.664292: mmc_blk_rw_start: cmd=18,addr=0x001daa70,size=0x00000080
+ <...>-204 [000] ..s3 56.664948: mmc_blk_rw_end: cmd=18,addr=0x001daa70,size=0x00000080
+ mmcqd/0-82 [001] ...1 56.664969: mmc_blk_rw_start: cmd=18,addr=0x001cbc08,size=0x000000a8
+ SurfaceFlinger-150 [000] ..s2 56.665694: mmc_blk_rw_end: cmd=18,addr=0x001cbc08,size=0x000000a8
+ mmcqd/0-82 [001] ...1 56.665785: mmc_blk_rw_start: cmd=18,addr=0x001daaf0,size=0x00000080
+ SurfaceFlinger-150 [000] ..s3 56.666372: mmc_blk_rw_end: cmd=18,addr=0x001daaf0,size=0x00000080
+ mmcqd/0-82 [001] ...1 56.697351: mmc_blk_rw_start: cmd=18,addr=0x0013ffa0,size=0x00000008
+ <...>-1503 [000] ..s2 56.697583: mmc_blk_rw_end: cmd=18,addr=0x0013ffa0,size=0x00000008
+ mmcqd/0-82 [001] ...1 56.703729: mmc_blk_rw_start: cmd=18,addr=0x001cbdb0,size=0x000000d0
+ WindowManager-396 [000] ..s2 56.704708: mmc_blk_rw_end: cmd=18,addr=0x001cbdb0,size=0x000000d0
+ mmcqd/0-82 [001] ...1 56.707676: mmc_blk_rw_start: cmd=18,addr=0x001cc148,size=0x00000100
+ <idle>-0 [000] ..s3 56.708698: mmc_blk_rw_end: cmd=18,addr=0x001cc148,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.709038: mmc_blk_rw_start: cmd=18,addr=0x001d35d0,size=0x00000100
+ ion_chunk_heap-18 [000] ..s2 56.710085: mmc_blk_rw_end: cmd=18,addr=0x001d35d0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.710400: mmc_blk_rw_start: cmd=18,addr=0x001d4f18,size=0x00000010
+ ion_chunk_heap-18 [000] ..s3 56.710646: mmc_blk_rw_end: cmd=18,addr=0x001d4f18,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.710661: mmc_blk_rw_start: cmd=18,addr=0x001d4f28,size=0x00000038
+ ion_chunk_heap-18 [000] ..s2 56.711007: mmc_blk_rw_end: cmd=18,addr=0x001d4f28,size=0x00000038
+ mmcqd/0-82 [000] ...1 56.711022: mmc_blk_rw_start: cmd=18,addr=0x001d4f60,size=0x00000010
+ ion_chunk_heap-18 [000] ..s3 56.711188: mmc_blk_rw_end: cmd=18,addr=0x001d4f60,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.711202: mmc_blk_rw_start: cmd=18,addr=0x001d4f70,size=0x00000010
+ ion_chunk_heap-18 [000] ..s4 56.711365: mmc_blk_rw_end: cmd=18,addr=0x001d4f70,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.711385: mmc_blk_rw_start: cmd=18,addr=0x001d4f80,size=0x00000010
+ ion_chunk_heap-18 [000] ..s4 56.711571: mmc_blk_rw_end: cmd=18,addr=0x001d4f80,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.711588: mmc_blk_rw_start: cmd=18,addr=0x001d4f90,size=0x00000010
+ ion_chunk_heap-18 [000] ..s2 56.711769: mmc_blk_rw_end: cmd=18,addr=0x001d4f90,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.711785: mmc_blk_rw_start: cmd=18,addr=0x001d4fa0,size=0x00000010
+ <...>-1523 [000] ..s2 56.711965: mmc_blk_rw_end: cmd=18,addr=0x001d4fa0,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.712020: mmc_blk_rw_start: cmd=18,addr=0x001d4fb0,size=0x00000010
+ ion_chunk_heap-18 [000] ..s2 56.712220: mmc_blk_rw_end: cmd=18,addr=0x001d4fb0,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.712236: mmc_blk_rw_start: cmd=18,addr=0x001d4fc0,size=0x00000010
+ ion_chunk_heap-18 [000] ..s2 56.712423: mmc_blk_rw_end: cmd=18,addr=0x001d4fc0,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.712439: mmc_blk_rw_start: cmd=18,addr=0x001d4fd0,size=0x00000010
+ ion_chunk_heap-18 [000] ..s3 56.712617: mmc_blk_rw_end: cmd=18,addr=0x001d4fd0,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.712633: mmc_blk_rw_start: cmd=18,addr=0x001d4fe0,size=0x00000010
+ ion_chunk_heap-18 [000] ..s3 56.712812: mmc_blk_rw_end: cmd=18,addr=0x001d4fe0,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.712833: mmc_blk_rw_start: cmd=18,addr=0x001d4ff0,size=0x00000020
+ ion_chunk_heap-18 [000] ..s2 56.713092: mmc_blk_rw_end: cmd=18,addr=0x001d4ff0,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.713105: mmc_blk_rw_start: cmd=18,addr=0x001d5010,size=0x00000008
+ ion_chunk_heap-18 [000] ..s2 56.713221: mmc_blk_rw_end: cmd=18,addr=0x001d5010,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.713234: mmc_blk_rw_start: cmd=18,addr=0x001cdc68,size=0x00000100
+ ion_chunk_heap-18 [000] ..s2 56.714260: mmc_blk_rw_end: cmd=18,addr=0x001cdc68,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.714479: mmc_blk_rw_start: cmd=18,addr=0x001cc248,size=0x00000088
+ <...>-95 [000] ..s3 56.715077: mmc_blk_rw_end: cmd=18,addr=0x001cc248,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.716732: mmc_blk_rw_start: cmd=18,addr=0x0013fe68,size=0x00000008
+ ion_chunk_heap-18 [000] ..s3 56.717001: mmc_blk_rw_end: cmd=18,addr=0x0013fe68,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.717019: mmc_blk_rw_start: cmd=18,addr=0x001b9410,size=0x00000018
+ ion_chunk_heap-18 [000] ..s3 56.717306: mmc_blk_rw_end: cmd=18,addr=0x001b9410,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.717328: mmc_blk_rw_start: cmd=18,addr=0x001cd4f0,size=0x00000100
+ Binder_1-198 [000] ..s2 56.718333: mmc_blk_rw_end: cmd=18,addr=0x001cd4f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.719547: mmc_blk_rw_start: cmd=18,addr=0x001cd710,size=0x00000100
+ ion_chunk_heap-18 [000] ..s2 56.720525: mmc_blk_rw_end: cmd=18,addr=0x001cd710,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.720781: mmc_blk_rw_start: cmd=18,addr=0x001cd970,size=0x00000100
+ ion_chunk_heap-18 [000] ..s3 56.721794: mmc_blk_rw_end: cmd=18,addr=0x001cd970,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.722013: mmc_blk_rw_start: cmd=18,addr=0x001cf240,size=0x00000100
+ <...>-204 [000] ..s3 56.722961: mmc_blk_rw_end: cmd=18,addr=0x001cf240,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.723195: mmc_blk_rw_start: cmd=18,addr=0x001d12b8,size=0x00000100
+ ion_chunk_heap-18 [000] ..s3 56.724218: mmc_blk_rw_end: cmd=18,addr=0x001d12b8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.724309: mmc_blk_rw_start: cmd=18,addr=0x0013fda8,size=0x00000010
+ ion_chunk_heap-18 [000] ..s2 56.724519: mmc_blk_rw_end: cmd=18,addr=0x0013fda8,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.724532: mmc_blk_rw_start: cmd=18,addr=0x0013fdc0,size=0x00000048
+ ion_chunk_heap-18 [000] ..s2 56.724938: mmc_blk_rw_end: cmd=18,addr=0x0013fdc0,size=0x00000048
+ mmcqd/0-82 [000] ...1 56.726292: mmc_blk_rw_start: cmd=18,addr=0x0013ff90,size=0x00000008
+ <idle>-0 [000] ..s3 56.726465: mmc_blk_rw_end: cmd=18,addr=0x0013ff90,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.728492: mmc_blk_rw_start: cmd=18,addr=0x0013ff30,size=0x00000008
+ <idle>-0 [000] ..s3 56.728670: mmc_blk_rw_end: cmd=18,addr=0x0013ff30,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.729188: mmc_blk_rw_start: cmd=18,addr=0x0013ff38,size=0x00000058
+ <idle>-0 [000] ..s3 56.729717: mmc_blk_rw_end: cmd=18,addr=0x0013ff38,size=0x00000058
+ mmcqd/0-82 [000] ...1 56.729769: mmc_blk_rw_start: cmd=18,addr=0x0013ff98,size=0x00000008
+ <idle>-0 [000] ..s3 56.729932: mmc_blk_rw_end: cmd=18,addr=0x0013ff98,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.729978: mmc_blk_rw_start: cmd=18,addr=0x0013ffa8,size=0x00000010
+ <idle>-0 [000] ..s3 56.730221: mmc_blk_rw_end: cmd=18,addr=0x0013ffa8,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.730269: mmc_blk_rw_start: cmd=18,addr=0x0013feb8,size=0x00000078
+ <idle>-0 [000] ..s3 56.730903: mmc_blk_rw_end: cmd=18,addr=0x0013feb8,size=0x00000078
+ mmcqd/0-82 [000] ...1 56.733814: mmc_blk_rw_start: cmd=18,addr=0x0013fe78,size=0x00000020
+ <idle>-0 [000] ..s3 56.734174: mmc_blk_rw_end: cmd=18,addr=0x0013fe78,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.736291: mmc_blk_rw_start: cmd=18,addr=0x0013fd88,size=0x00000018
+ <idle>-0 [000] ..s3 56.736551: mmc_blk_rw_end: cmd=18,addr=0x0013fd88,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.736604: mmc_blk_rw_start: cmd=18,addr=0x0013fd78,size=0x00000008
+ <...>-1488 [000] ..s2 56.736753: mmc_blk_rw_end: cmd=18,addr=0x0013fd78,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.739250: mmc_blk_rw_start: cmd=18,addr=0x001d8ec0,size=0x00000100
+ <...>-406 [000] .Ns2 56.740339: mmc_blk_rw_end: cmd=18,addr=0x001d8ec0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.740691: mmc_blk_rw_start: cmd=18,addr=0x001d1738,size=0x00000100
+ <idle>-0 [000] ..s3 56.741682: mmc_blk_rw_end: cmd=18,addr=0x001d1738,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.741965: mmc_blk_rw_start: cmd=18,addr=0x001d1b90,size=0x00000100
+ <idle>-0 [000] ..s3 56.742953: mmc_blk_rw_end: cmd=18,addr=0x001d1b90,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.743297: mmc_blk_rw_start: cmd=18,addr=0x001d2a98,size=0x00000100
+ <...>-1496 [000] ..s2 56.744359: mmc_blk_rw_end: cmd=18,addr=0x001d2a98,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.744585: mmc_blk_rw_start: cmd=18,addr=0x001d3478,size=0x00000100
+ <idle>-0 [000] ..s3 56.745592: mmc_blk_rw_end: cmd=18,addr=0x001d3478,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.745846: mmc_blk_rw_start: cmd=18,addr=0x001d3b30,size=0x00000100
+ <idle>-0 [000] ..s3 56.746829: mmc_blk_rw_end: cmd=18,addr=0x001d3b30,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.747117: mmc_blk_rw_start: cmd=18,addr=0x001d9ba8,size=0x00000100
+ <idle>-0 [000] ..s3 56.748190: mmc_blk_rw_end: cmd=18,addr=0x001d9ba8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.748465: mmc_blk_rw_start: cmd=18,addr=0x001d2df0,size=0x00000100
+ <idle>-0 [000] ..s3 56.749470: mmc_blk_rw_end: cmd=18,addr=0x001d2df0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.749865: mmc_blk_rw_start: cmd=18,addr=0x001ce280,size=0x00000100
+ SurfaceFlinger-150 [000] ..s4 56.750866: mmc_blk_rw_end: cmd=18,addr=0x001ce280,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.751289: mmc_blk_rw_start: cmd=18,addr=0x001d3578,size=0x00000058
+ <idle>-0 [000] ..s3 56.751761: mmc_blk_rw_end: cmd=18,addr=0x001d3578,size=0x00000058
+ mmcqd/0-82 [000] ...1 56.751845: mmc_blk_rw_start: cmd=18,addr=0x001d58c8,size=0x00000100
+ <idle>-0 [000] ..s3 56.752893: mmc_blk_rw_end: cmd=18,addr=0x001d58c8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.754212: mmc_blk_rw_start: cmd=18,addr=0x0013fe70,size=0x00000008
+ <idle>-0 [000] ..s3 56.754450: mmc_blk_rw_end: cmd=18,addr=0x0013fe70,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.754496: mmc_blk_rw_start: cmd=18,addr=0x0013fe98,size=0x00000020
+ <...>-1497 [000] ..s2 56.754842: mmc_blk_rw_end: cmd=18,addr=0x0013fe98,size=0x00000020
+ mmcqd/0-82 [000] ...1 56.754860: mmc_blk_rw_start: cmd=18,addr=0x001d0740,size=0x00000100
+ <...>-1488 [000] ..s3 56.755885: mmc_blk_rw_end: cmd=18,addr=0x001d0740,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.759274: mmc_blk_rw_start: cmd=18,addr=0x001d5028,size=0x00000100
+ <...>-1488 [000] .Ns4 56.760368: mmc_blk_rw_end: cmd=18,addr=0x001d5028,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.764203: mmc_blk_rw_start: cmd=18,addr=0x001cce38,size=0x00000100
+ <...>-95 [000] ..s3 56.765272: mmc_blk_rw_end: cmd=18,addr=0x001cce38,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.765725: mmc_blk_rw_start: cmd=18,addr=0x001d0650,size=0x000000f0
+ <...>-1488 [000] ..s2 56.766713: mmc_blk_rw_end: cmd=18,addr=0x001d0650,size=0x000000f0
+ mmcqd/0-82 [001] ...1 56.767749: mmc_blk_rw_start: cmd=18,addr=0x001d3d60,size=0x00000070
+ <...>-1488 [000] ..s2 56.768374: mmc_blk_rw_end: cmd=18,addr=0x001d3d60,size=0x00000070
+ mmcqd/0-82 [001] ...1 56.769290: mmc_blk_rw_start: cmd=18,addr=0x001d3dd0,size=0x00000090
+ <...>-1488 [000] ..s2 56.769942: mmc_blk_rw_end: cmd=18,addr=0x001d3dd0,size=0x00000090
+ mmcqd/0-82 [001] ...1 56.774342: mmc_blk_rw_start: cmd=18,addr=0x001cd8d0,size=0x000000a0
+ <...>-406 [000] ..s4 56.775119: mmc_blk_rw_end: cmd=18,addr=0x001cd8d0,size=0x000000a0
+ mmcqd/0-82 [001] ...1 56.775689: mmc_blk_rw_start: cmd=18,addr=0x001d6330,size=0x00000100
+ Compiler-1495 [000] ..s2 56.776705: mmc_blk_rw_end: cmd=18,addr=0x001d6330,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.777034: mmc_blk_rw_start: cmd=18,addr=0x001d36d0,size=0x00000080
+ Compiler-1495 [000] ..s2 56.777586: mmc_blk_rw_end: cmd=18,addr=0x001d36d0,size=0x00000080
+ mmcqd/0-82 [001] ...1 56.777901: mmc_blk_rw_start: cmd=18,addr=0x001d92d0,size=0x00000100
+ Compiler-1495 [000] ..s2 56.778879: mmc_blk_rw_end: cmd=18,addr=0x001d92d0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.779219: mmc_blk_rw_start: cmd=18,addr=0x001d5838,size=0x00000090
+ Compiler-1495 [000] ..s2 56.779826: mmc_blk_rw_end: cmd=18,addr=0x001d5838,size=0x00000090
+ mmcqd/0-82 [001] ...1 56.780091: mmc_blk_rw_start: cmd=18,addr=0x001cbe80,size=0x00000100
+ <...>-1488 [000] ..s2 56.781135: mmc_blk_rw_end: cmd=18,addr=0x001cbe80,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.781221: mmc_blk_rw_start: cmd=18,addr=0x001d5128,size=0x00000080
+ <...>-1488 [000] ..s2 56.781804: mmc_blk_rw_end: cmd=18,addr=0x001d5128,size=0x00000080
+ mmcqd/0-82 [001] ...1 56.782053: mmc_blk_rw_start: cmd=18,addr=0x001d91c0,size=0x00000100
+ <...>-1488 [000] ..s2 56.783031: mmc_blk_rw_end: cmd=18,addr=0x001d91c0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.784197: mmc_blk_rw_start: cmd=18,addr=0x001d51a8,size=0x00000100
+ <idle>-0 [000] ..s3 56.785337: mmc_blk_rw_end: cmd=18,addr=0x001d51a8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.785476: mmc_blk_rw_start: cmd=18,addr=0x001d5018,size=0x00000010
+ <idle>-0 [000] ..s3 56.785673: mmc_blk_rw_end: cmd=18,addr=0x001d5018,size=0x00000010
+ mmcqd/0-82 [000] ...1 56.786668: mmc_blk_rw_start: cmd=18,addr=0x001d1ab0,size=0x000000e0
+ <idle>-0 [000] ..s3 56.787689: mmc_blk_rw_end: cmd=18,addr=0x001d1ab0,size=0x000000e0
+ mmcqd/0-82 [000] ...1 56.788047: mmc_blk_rw_start: cmd=18,addr=0x001d93d0,size=0x00000098
+ <idle>-0 [000] ..s3 56.788712: mmc_blk_rw_end: cmd=18,addr=0x001d93d0,size=0x00000098
+ mmcqd/0-82 [000] ...1 56.789370: mmc_blk_rw_start: cmd=18,addr=0x001d55c8,size=0x00000100
+ <idle>-0 [000] ..s3 56.790423: mmc_blk_rw_end: cmd=18,addr=0x001d55c8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.790915: mmc_blk_rw_start: cmd=18,addr=0x001d9578,size=0x00000100
+ <idle>-0 [000] ..s3 56.791962: mmc_blk_rw_end: cmd=18,addr=0x001d9578,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.792834: mmc_blk_rw_start: cmd=18,addr=0x001d56c8,size=0x000000d0
+ <idle>-0 [000] ..s3 56.793714: mmc_blk_rw_end: cmd=18,addr=0x001d56c8,size=0x000000d0
+ mmcqd/0-82 [000] ...1 56.793982: mmc_blk_rw_start: cmd=18,addr=0x001ce0a0,size=0x00000100
+ <idle>-0 [000] ..s3 56.794987: mmc_blk_rw_end: cmd=18,addr=0x001ce0a0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.795529: mmc_blk_rw_start: cmd=18,addr=0x001ce950,size=0x00000100
+ <idle>-0 [000] ..s3 56.796486: mmc_blk_rw_end: cmd=18,addr=0x001ce950,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.796968: mmc_blk_rw_start: cmd=18,addr=0x001d54a8,size=0x00000100
+ <idle>-0 [000] ..s3 56.798042: mmc_blk_rw_end: cmd=18,addr=0x001d54a8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.799026: mmc_blk_rw_start: cmd=18,addr=0x001d10c8,size=0x00000100
+ <...>-1488 [000] ..s2 56.800076: mmc_blk_rw_end: cmd=18,addr=0x001d10c8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.800814: mmc_blk_rw_start: cmd=18,addr=0x001cdf48,size=0x00000100
+ <...>-1488 [000] ..s2 56.801860: mmc_blk_rw_end: cmd=18,addr=0x001cdf48,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.807747: mmc_blk_rw_start: cmd=18,addr=0x001cc628,size=0x00000100
+ <idle>-0 [000] ..s3 56.808883: mmc_blk_rw_end: cmd=18,addr=0x001cc628,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.810313: mmc_blk_rw_start: cmd=18,addr=0x001cc728,size=0x00000100
+ <idle>-0 [000] ..s3 56.811414: mmc_blk_rw_end: cmd=18,addr=0x001cc728,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.838043: mmc_blk_rw_start: cmd=18,addr=0x001d52a8,size=0x00000098
+ <...>-1509 [000] ..s2 56.838880: mmc_blk_rw_end: cmd=18,addr=0x001d52a8,size=0x00000098
+ mmcqd/0-82 [000] ...1 56.839823: mmc_blk_rw_start: cmd=18,addr=0x001cee08,size=0x00000100
+ <idle>-0 [000] ..s3 56.840907: mmc_blk_rw_end: cmd=18,addr=0x001cee08,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.841309: mmc_blk_rw_start: cmd=18,addr=0x001cc980,size=0x00000100
+ <idle>-0 [000] ..s3 56.842316: mmc_blk_rw_end: cmd=18,addr=0x001cc980,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.842635: mmc_blk_rw_start: cmd=18,addr=0x001d6430,size=0x00000100
+ <idle>-0 [000] ..s3 56.843647: mmc_blk_rw_end: cmd=18,addr=0x001d6430,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.843694: mmc_blk_rw_start: cmd=18,addr=0x001d5420,size=0x00000088
+ <idle>-0 [000] ..s3 56.844291: mmc_blk_rw_end: cmd=18,addr=0x001d5420,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.844588: mmc_blk_rw_start: cmd=18,addr=0x001d3750,size=0x00000100
+ <idle>-0 [000] ..s3 56.845580: mmc_blk_rw_end: cmd=18,addr=0x001d3750,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.845630: mmc_blk_rw_start: cmd=18,addr=0x001d15d0,size=0x00000100
+ <idle>-0 [000] ..s3 56.846655: mmc_blk_rw_end: cmd=18,addr=0x001d15d0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.847372: mmc_blk_rw_start: cmd=18,addr=0x001cf120,size=0x00000100
+ <idle>-0 [000] ..s3 56.848387: mmc_blk_rw_end: cmd=18,addr=0x001cf120,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.848652: mmc_blk_rw_start: cmd=18,addr=0x001cc498,size=0x00000100
+ UI-395 [000] ..s2 56.849701: mmc_blk_rw_end: cmd=18,addr=0x001cc498,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.853069: mmc_blk_rw_start: cmd=18,addr=0x001cef08,size=0x000000b0
+ <idle>-0 [000] ..s3 56.853834: mmc_blk_rw_end: cmd=18,addr=0x001cef08,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.854772: mmc_blk_rw_start: cmd=18,addr=0x001cf340,size=0x000000b0
+ <idle>-0 [000] ..s3 56.855503: mmc_blk_rw_end: cmd=18,addr=0x001cf340,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.855902: mmc_blk_rw_start: cmd=18,addr=0x001cf560,size=0x00000100
+ <idle>-0 [000] ..s3 56.856920: mmc_blk_rw_end: cmd=18,addr=0x001cf560,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.857426: mmc_blk_rw_start: cmd=18,addr=0x001d5340,size=0x000000b8
+ <idle>-0 [000] ..s3 56.858165: mmc_blk_rw_end: cmd=18,addr=0x001d5340,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.858818: mmc_blk_rw_start: cmd=18,addr=0x001cf3f0,size=0x000000b8
+ kworker/0:1-23 [000] ..s2 56.859605: mmc_blk_rw_end: cmd=18,addr=0x001cf3f0,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.864629: mmc_blk_rw_start: cmd=18,addr=0x001d3908,size=0x00000100
+ <...>-95 [000] ..s3 56.865633: mmc_blk_rw_end: cmd=18,addr=0x001d3908,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.866118: mmc_blk_rw_start: cmd=18,addr=0x001cc3f0,size=0x000000a8
+ Binder_2-130 [000] ..s2 56.866844: mmc_blk_rw_end: cmd=18,addr=0x001cc3f0,size=0x000000a8
+ mmcqd/0-82 [000] ...1 56.868586: mmc_blk_rw_start: cmd=18,addr=0x001d3aa8,size=0x00000088
+ <idle>-0 [000] ..s3 56.869318: mmc_blk_rw_end: cmd=18,addr=0x001d3aa8,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.869655: mmc_blk_rw_start: cmd=18,addr=0x001ccf38,size=0x000000d0
+ <idle>-0 [000] ..s3 56.870499: mmc_blk_rw_end: cmd=18,addr=0x001ccf38,size=0x000000d0
+ mmcqd/0-82 [000] ...1 56.870776: mmc_blk_rw_start: cmd=18,addr=0x001cea50,size=0x00000080
+ <idle>-0 [000] ..s3 56.871323: mmc_blk_rw_end: cmd=18,addr=0x001cea50,size=0x00000080
+ mmcqd/0-82 [000] ...1 56.871650: mmc_blk_rw_start: cmd=18,addr=0x001cc2d0,size=0x00000100
+ <idle>-0 [000] ..s3 56.872658: mmc_blk_rw_end: cmd=18,addr=0x001cc2d0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.872765: mmc_blk_rw_start: cmd=18,addr=0x001d3850,size=0x000000b8
+ <idle>-0 [000] ..s3 56.873509: mmc_blk_rw_end: cmd=18,addr=0x001d3850,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.874190: mmc_blk_rw_start: cmd=18,addr=0x001d3a08,size=0x00000088
+ <idle>-0 [000] ..s3 56.874798: mmc_blk_rw_end: cmd=18,addr=0x001d3a08,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.879190: mmc_blk_rw_start: cmd=18,addr=0x001cec48,size=0x00000100
+ <idle>-0 [000] ..s3 56.880192: mmc_blk_rw_end: cmd=18,addr=0x001cec48,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.880782: mmc_blk_rw_start: cmd=18,addr=0x001d11c8,size=0x000000f0
+ <idle>-0 [000] ..s3 56.881750: mmc_blk_rw_end: cmd=18,addr=0x001d11c8,size=0x000000f0
+ mmcqd/0-82 [000] ...1 56.882143: mmc_blk_rw_start: cmd=18,addr=0x001ccb30,size=0x00000100
+ Compiler-387 [000] ..s2 56.883123: mmc_blk_rw_end: cmd=18,addr=0x001ccb30,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.884709: mmc_blk_rw_start: cmd=18,addr=0x001cefb8,size=0x000000d0
+ <idle>-0 [000] ..s3 56.885617: mmc_blk_rw_end: cmd=18,addr=0x001cefb8,size=0x000000d0
+ mmcqd/0-82 [000] ...1 56.885963: mmc_blk_rw_start: cmd=18,addr=0x001cc598,size=0x00000090
+ <idle>-0 [000] ..s3 56.886669: mmc_blk_rw_end: cmd=18,addr=0x001cc598,size=0x00000090
+ mmcqd/0-82 [000] ...1 56.886972: mmc_blk_rw_start: cmd=18,addr=0x001cf088,size=0x00000098
+ <...>-1488 [000] ..s3 56.887678: mmc_blk_rw_end: cmd=18,addr=0x001cf088,size=0x00000098
+ mmcqd/0-82 [000] ...1 56.887794: mmc_blk_rw_start: cmd=18,addr=0x001cf660,size=0x00000100
+ <idle>-0 [000] ..s3 56.888813: mmc_blk_rw_end: cmd=18,addr=0x001cf660,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.888906: mmc_blk_rw_start: cmd=18,addr=0x00b88260,size=0x00000008
+ <idle>-0 [000] ..s3 56.889033: mmc_blk_rw_end: cmd=18,addr=0x00b88260,size=0x00000008
+ mmcqd/0-82 [000] ...1 56.889423: mmc_blk_rw_start: cmd=18,addr=0x001d45e8,size=0x00000100
+ <idle>-0 [000] ..s3 56.890499: mmc_blk_rw_end: cmd=18,addr=0x001d45e8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.891533: mmc_blk_rw_start: cmd=18,addr=0x001ce380,size=0x000000d0
+ <idle>-0 [000] ..s3 56.892387: mmc_blk_rw_end: cmd=18,addr=0x001ce380,size=0x000000d0
+ mmcqd/0-82 [000] ...1 56.893152: mmc_blk_rw_start: cmd=18,addr=0x001d8e10,size=0x000000b0
+ <idle>-0 [000] ..s3 56.893861: mmc_blk_rw_end: cmd=18,addr=0x001d8e10,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.894806: mmc_blk_rw_start: cmd=18,addr=0x00544c90,size=0x00000100
+ <idle>-0 [000] ..s3 56.895846: mmc_blk_rw_end: cmd=18,addr=0x00544c90,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.896175: mmc_blk_rw_start: cmd=18,addr=0x005441a8,size=0x00000100
+ <idle>-0 [000] ..s3 56.897158: mmc_blk_rw_end: cmd=18,addr=0x005441a8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.897495: mmc_blk_rw_start: cmd=18,addr=0x001d9dc8,size=0x00000100
+ <idle>-0 [000] ..s3 56.898518: mmc_blk_rw_end: cmd=18,addr=0x001d9dc8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.898781: mmc_blk_rw_start: cmd=18,addr=0x001d5798,size=0x000000a0
+ WindowManager-396 [000] ..s2 56.899508: mmc_blk_rw_end: cmd=18,addr=0x001d5798,size=0x000000a0
+ mmcqd/0-82 [000] ...1 56.900612: mmc_blk_rw_start: cmd=18,addr=0x001d3140,size=0x00000100
+ WindowManager-396 [000] ..s2 56.901656: mmc_blk_rw_end: cmd=18,addr=0x001d3140,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.901925: mmc_blk_rw_start: cmd=18,addr=0x001d6530,size=0x00000100
+ <...>-204 [000] ..s2 56.902901: mmc_blk_rw_end: cmd=18,addr=0x001d6530,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.903030: mmc_blk_rw_start: cmd=18,addr=0x001d8320,size=0x00000100
+ <idle>-0 [000] ..s3 56.903994: mmc_blk_rw_end: cmd=18,addr=0x001d8320,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.904278: mmc_blk_rw_start: cmd=18,addr=0x001d9d20,size=0x000000a8
+ <idle>-0 [000] ..s3 56.904943: mmc_blk_rw_end: cmd=18,addr=0x001d9d20,size=0x000000a8
+ mmcqd/0-82 [000] ...1 56.906275: mmc_blk_rw_start: cmd=18,addr=0x005449e0,size=0x00000100
+ <idle>-0 [000] ..s3 56.907247: mmc_blk_rw_end: cmd=18,addr=0x005449e0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.907674: mmc_blk_rw_start: cmd=18,addr=0x005437c0,size=0x00000100
+ <idle>-0 [000] ..s3 56.908631: mmc_blk_rw_end: cmd=18,addr=0x005437c0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.910838: mmc_blk_rw_start: cmd=18,addr=0x001ccd78,size=0x000000c0
+ <idle>-0 [000] ..s3 56.911723: mmc_blk_rw_end: cmd=18,addr=0x001ccd78,size=0x000000c0
+ mmcqd/0-82 [000] ...1 56.912234: mmc_blk_rw_start: cmd=18,addr=0x001d6278,size=0x000000b8
+ <idle>-0 [000] ..s3 56.912999: mmc_blk_rw_end: cmd=18,addr=0x001d6278,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.935470: mmc_blk_rw_start: cmd=18,addr=0x001cd370,size=0x00000100
+ <idle>-0 [000] ..s3 56.936581: mmc_blk_rw_end: cmd=18,addr=0x001cd370,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.937169: mmc_blk_rw_start: cmd=18,addr=0x001d3c70,size=0x000000f0
+ <idle>-0 [000] ..s3 56.938142: mmc_blk_rw_end: cmd=18,addr=0x001d3c70,size=0x000000f0
+ mmcqd/0-82 [000] ...1 56.939187: mmc_blk_rw_start: cmd=18,addr=0x001ceb98,size=0x000000b0
+ <idle>-0 [000] ..s3 56.940006: mmc_blk_rw_end: cmd=18,addr=0x001ceb98,size=0x000000b0
+ mmcqd/0-82 [000] ...1 56.940382: mmc_blk_rw_start: cmd=18,addr=0x001cdad8,size=0x00000100
+ <idle>-0 [000] ..s3 56.941418: mmc_blk_rw_end: cmd=18,addr=0x001cdad8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.941715: mmc_blk_rw_start: cmd=18,addr=0x001d3a90,size=0x00000018
+ <idle>-0 [000] ..s3 56.941974: mmc_blk_rw_end: cmd=18,addr=0x001d3a90,size=0x00000018
+ mmcqd/0-82 [000] ...1 56.942388: mmc_blk_rw_start: cmd=18,addr=0x001cf850,size=0x00000100
+ <idle>-0 [000] ..s3 56.943362: mmc_blk_rw_end: cmd=18,addr=0x001cf850,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.943778: mmc_blk_rw_start: cmd=18,addr=0x001cc828,size=0x000000c8
+ <idle>-0 [000] ..s3 56.944676: mmc_blk_rw_end: cmd=18,addr=0x001cc828,size=0x000000c8
+ mmcqd/0-82 [000] ...1 56.945026: mmc_blk_rw_start: cmd=18,addr=0x001d0358,size=0x00000100
+ <idle>-0 [000] ..s3 56.946053: mmc_blk_rw_end: cmd=18,addr=0x001d0358,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.946416: mmc_blk_rw_start: cmd=18,addr=0x001d3e60,size=0x000000a8
+ <idle>-0 [000] ..s3 56.947118: mmc_blk_rw_end: cmd=18,addr=0x001d3e60,size=0x000000a8
+ mmcqd/0-82 [000] ...1 56.947455: mmc_blk_rw_start: cmd=18,addr=0x001d40c8,size=0x00000100
+ <idle>-0 [000] ..s3 56.948489: mmc_blk_rw_end: cmd=18,addr=0x001d40c8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.948831: mmc_blk_rw_start: cmd=18,addr=0x001d41f0,size=0x00000100
+ <idle>-0 [000] ..s3 56.949854: mmc_blk_rw_end: cmd=18,addr=0x001d41f0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.950189: mmc_blk_rw_start: cmd=18,addr=0x001d3f08,size=0x00000088
+ <idle>-0 [000] ..s3 56.950786: mmc_blk_rw_end: cmd=18,addr=0x001d3f08,size=0x00000088
+ mmcqd/0-82 [000] ...1 56.951156: mmc_blk_rw_start: cmd=18,addr=0x001d4460,size=0x00000100
+ <idle>-0 [000] ..s3 56.952161: mmc_blk_rw_end: cmd=18,addr=0x001d4460,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.954210: mmc_blk_rw_start: cmd=18,addr=0x001d1c90,size=0x000000e0
+ <idle>-0 [000] .Ns3 56.955120: mmc_blk_rw_end: cmd=18,addr=0x001d1c90,size=0x000000e0
+ mmcqd/0-82 [000] ...1 56.956111: mmc_blk_rw_start: cmd=18,addr=0x001d1db8,size=0x00000100
+ Compiler-1495 [000] ..s2 56.957170: mmc_blk_rw_end: cmd=18,addr=0x001d1db8,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.958861: mmc_blk_rw_start: cmd=18,addr=0x001ccc30,size=0x00000100
+ Compiler-1495 [000] ..s2 56.959885: mmc_blk_rw_end: cmd=18,addr=0x001ccc30,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.960795: mmc_blk_rw_start: cmd=18,addr=0x001cd0a0,size=0x00000100
+ <idle>-0 [000] ..s3 56.961838: mmc_blk_rw_end: cmd=18,addr=0x001cd0a0,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.965080: mmc_blk_rw_start: cmd=18,addr=0x001cfc08,size=0x00000100
+ <...>-1534 [000] ..s3 56.966104: mmc_blk_rw_end: cmd=18,addr=0x001cfc08,size=0x00000100
+ mmcqd/0-82 [000] ...1 56.969245: mmc_blk_rw_start: cmd=18,addr=0x001d1d70,size=0x00000048
+ <...>-1534 [000] ..s2 56.969681: mmc_blk_rw_end: cmd=18,addr=0x001d1d70,size=0x00000048
+ mmcqd/0-82 [000] ...1 56.978217: mmc_blk_rw_start: cmd=18,addr=0x001d19f8,size=0x000000b8
+ <...>-1534 [000] ..s4 56.979048: mmc_blk_rw_end: cmd=18,addr=0x001d19f8,size=0x000000b8
+ mmcqd/0-82 [000] ...1 56.989267: mmc_blk_rw_start: cmd=18,addr=0x00545fd0,size=0x00000100
+ <idle>-0 [000] ..s3 56.990384: mmc_blk_rw_end: cmd=18,addr=0x00545fd0,size=0x00000100
+ mmcqd/0-82 [001] ...1 56.990930: mmc_blk_rw_start: cmd=18,addr=0x001ceb00,size=0x00000098
+ <idle>-0 [000] ..s3 56.991576: mmc_blk_rw_end: cmd=18,addr=0x001ceb00,size=0x00000098
+ mmcqd/0-82 [000] ...1 56.997991: mmc_blk_rw_start: cmd=18,addr=0x001cf760,size=0x00000080
+ <idle>-0 [000] ..s3 56.998591: mmc_blk_rw_end: cmd=18,addr=0x001cf760,size=0x00000080
+ mmcqd/0-82 [000] ...1 56.999603: mmc_blk_rw_start: cmd=18,addr=0x001d0458,size=0x000000c8
+ <idle>-0 [000] ..s3 57.000459: mmc_blk_rw_end: cmd=18,addr=0x001d0458,size=0x000000c8
+ mmcqd/0-82 [000] ...1 57.000920: mmc_blk_rw_start: cmd=18,addr=0x001d2680,size=0x00000100
+ <idle>-0 [000] ..s3 57.001914: mmc_blk_rw_end: cmd=18,addr=0x001d2680,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.002233: mmc_blk_rw_start: cmd=18,addr=0x001cf4a8,size=0x00000088
+ <idle>-0 [000] ..s3 57.002917: mmc_blk_rw_end: cmd=18,addr=0x001cf4a8,size=0x00000088
+ mmcqd/0-82 [000] ...1 57.003455: mmc_blk_rw_start: cmd=18,addr=0x001cf220,size=0x00000020
+ <idle>-0 [000] ..s3 57.003677: mmc_blk_rw_end: cmd=18,addr=0x001cf220,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.004798: mmc_blk_rw_start: cmd=18,addr=0x001d7ae8,size=0x00000100
+ <idle>-0 [000] ..s3 57.005940: mmc_blk_rw_end: cmd=18,addr=0x001d7ae8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.006242: mmc_blk_rw_start: cmd=18,addr=0x001d8420,size=0x00000088
+ <idle>-0 [000] ..s3 57.006811: mmc_blk_rw_end: cmd=18,addr=0x001d8420,size=0x00000088
+ mmcqd/0-82 [000] ...1 57.014360: mmc_blk_rw_start: cmd=18,addr=0x00b88258,size=0x00000008
+ <idle>-0 [000] ..s3 57.014509: mmc_blk_rw_end: cmd=18,addr=0x00b88258,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.015519: mmc_blk_rw_start: cmd=18,addr=0x001d41c8,size=0x00000028
+ <idle>-0 [000] ..s3 57.015851: mmc_blk_rw_end: cmd=18,addr=0x001d41c8,size=0x00000028
+ mmcqd/0-82 [000] ...1 57.016743: mmc_blk_rw_start: cmd=18,addr=0x001d22d8,size=0x00000100
+ <idle>-0 [000] ..s3 57.017853: mmc_blk_rw_end: cmd=18,addr=0x001d22d8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.018187: mmc_blk_rw_start: cmd=18,addr=0x001d3c30,size=0x00000040
+ <idle>-0 [000] ..s3 57.018535: mmc_blk_rw_end: cmd=18,addr=0x001d3c30,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.019173: mmc_blk_rw_start: cmd=18,addr=0x001cdbd8,size=0x00000080
+ <idle>-0 [000] ..s3 57.019773: mmc_blk_rw_end: cmd=18,addr=0x001cdbd8,size=0x00000080
+ mmcqd/0-82 [000] ...1 57.020398: mmc_blk_rw_start: cmd=18,addr=0x001d4560,size=0x00000088
+ <idle>-0 [000] ..s3 57.020992: mmc_blk_rw_end: cmd=18,addr=0x001d4560,size=0x00000088
+ mmcqd/0-82 [000] ...1 57.022153: mmc_blk_rw_start: cmd=18,addr=0x001ced68,size=0x000000a0
+ <idle>-0 [000] ..s3 57.022895: mmc_blk_rw_end: cmd=18,addr=0x001ced68,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.023353: mmc_blk_rw_start: cmd=18,addr=0x001cca90,size=0x000000a0
+ <idle>-0 [000] ..s3 57.024100: mmc_blk_rw_end: cmd=18,addr=0x001cca90,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.025959: mmc_blk_rw_start: cmd=18,addr=0x00544ae0,size=0x00000098
+ <idle>-0 [000] ..s3 57.026594: mmc_blk_rw_end: cmd=18,addr=0x00544ae0,size=0x00000098
+ mmcqd/0-82 [000] ...1 57.027610: mmc_blk_rw_start: cmd=18,addr=0x001ce810,size=0x00000100
+ <idle>-0 [000] ..s3 57.028584: mmc_blk_rw_end: cmd=18,addr=0x001ce810,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.028628: mmc_blk_rw_start: cmd=18,addr=0x001cd008,size=0x00000098
+ <...>-1488 [000] ..s2 57.029283: mmc_blk_rw_end: cmd=18,addr=0x001cd008,size=0x00000098
+ mmcqd/0-82 [000] ...1 57.029304: mmc_blk_rw_start: cmd=18,addr=0x001cca80,size=0x00000010
+ <...>-1531 [000] ..s2 57.029488: mmc_blk_rw_end: cmd=18,addr=0x001cca80,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.034193: mmc_blk_rw_start: cmd=18,addr=0x001ccd30,size=0x00000048
+ <idle>-0 [000] ..s3 57.034599: mmc_blk_rw_end: cmd=18,addr=0x001ccd30,size=0x00000048
+ mmcqd/0-82 [000] ...1 57.034644: mmc_blk_rw_start: cmd=18,addr=0x001d13b8,size=0x00000100
+ <idle>-0 [000] ..s3 57.035681: mmc_blk_rw_end: cmd=18,addr=0x001d13b8,size=0x00000100
+ mmcqd/0-82 [001] ...1 57.039204: mmc_blk_rw_start: cmd=18,addr=0x001cd680,size=0x00000090
+ <idle>-0 [000] ..s3 57.039835: mmc_blk_rw_end: cmd=18,addr=0x001cd680,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.040145: mmc_blk_rw_start: cmd=18,addr=0x001d33a0,size=0x000000d8
+ <idle>-0 [000] ..s3 57.041015: mmc_blk_rw_end: cmd=18,addr=0x001d33a0,size=0x000000d8
+ mmcqd/0-82 [000] ...1 57.044216: mmc_blk_rw_start: cmd=25,addr=0x002c6530,size=0x00000048
+ <idle>-0 [000] ..s3 57.045285: mmc_blk_rw_end: cmd=25,addr=0x002c6530,size=0x00000048
+ mmcqd/0-82 [000] ...1 57.046053: mmc_blk_rw_start: cmd=25,addr=0x002c6578,size=0x00000008
+ <idle>-0 [000] ..s3 57.046113: mmc_blk_rw_end: cmd=25,addr=0x002c6578,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.046937: mmc_blk_rw_start: cmd=25,addr=0x002c6580,size=0x00000008
+ <idle>-0 [000] ..s3 57.046997: mmc_blk_rw_end: cmd=25,addr=0x002c6580,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.047945: mmc_blk_rw_start: cmd=25,addr=0x002c6588,size=0x00000030
+ <idle>-0 [000] ..s3 57.048141: mmc_blk_rw_end: cmd=25,addr=0x002c6588,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.048855: mmc_blk_rw_start: cmd=25,addr=0x002c65b8,size=0x00000008
+ <idle>-0 [000] ..s3 57.048913: mmc_blk_rw_end: cmd=25,addr=0x002c65b8,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.049547: mmc_blk_rw_start: cmd=18,addr=0x001cead0,size=0x00000030
+ <idle>-0 [000] ..s3 57.049858: mmc_blk_rw_end: cmd=18,addr=0x001cead0,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.050791: mmc_blk_rw_start: cmd=18,addr=0x001cd470,size=0x00000080
+ <idle>-0 [000] ..s3 57.051398: mmc_blk_rw_end: cmd=18,addr=0x001cd470,size=0x00000080
+ mmcqd/0-82 [000] ...1 57.054193: mmc_blk_rw_start: cmd=18,addr=0x00b88248,size=0x00000008
+ <...>-1488 [000] ..s2 57.054408: mmc_blk_rw_end: cmd=18,addr=0x00b88248,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.054487: mmc_blk_rw_start: cmd=18,addr=0x001ce1a0,size=0x00000090
+ <...>-1488 [000] ..s2 57.055128: mmc_blk_rw_end: cmd=18,addr=0x001ce1a0,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.055512: mmc_blk_rw_start: cmd=18,addr=0x00b87298,size=0x00000008
+ <idle>-0 [000] ..s3 57.055640: mmc_blk_rw_end: cmd=18,addr=0x00b87298,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.055658: mmc_blk_rw_start: cmd=18,addr=0x00b91248,size=0x00000008
+ <idle>-0 [000] ..s3 57.055845: mmc_blk_rw_end: cmd=18,addr=0x00b91248,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.055894: mmc_blk_rw_start: cmd=18,addr=0x00b93138,size=0x00000008
+ <idle>-0 [000] ..s3 57.056031: mmc_blk_rw_end: cmd=18,addr=0x00b93138,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.056073: mmc_blk_rw_start: cmd=18,addr=0x001ce230,size=0x00000050
+ <...>-1488 [000] ..s2 57.056486: mmc_blk_rw_end: cmd=18,addr=0x001ce230,size=0x00000050
+ mmcqd/0-82 [000] ...1 57.056730: mmc_blk_rw_start: cmd=18,addr=0x00b93120,size=0x00000008
+ <idle>-0 [000] ..s3 57.056857: mmc_blk_rw_end: cmd=18,addr=0x00b93120,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.056946: mmc_blk_rw_start: cmd=18,addr=0x00b87290,size=0x00000008
+ <...>-1488 [000] ..s2 57.057066: mmc_blk_rw_end: cmd=18,addr=0x00b87290,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.057083: mmc_blk_rw_start: cmd=18,addr=0x00b88240,size=0x00000008
+ <...>-1488 [000] ..s3 57.057204: mmc_blk_rw_end: cmd=18,addr=0x00b88240,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.059204: mmc_blk_rw_start: cmd=18,addr=0x00544448,size=0x00000100
+ <idle>-0 [000] ..s3 57.060309: mmc_blk_rw_end: cmd=18,addr=0x00544448,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.060443: mmc_blk_rw_start: cmd=18,addr=0x001d53f8,size=0x00000028
+ <...>-1488 [000] ..s4 57.060791: mmc_blk_rw_end: cmd=18,addr=0x001d53f8,size=0x00000028
+ mmcqd/0-82 [000] ...1 57.061081: mmc_blk_rw_start: cmd=18,addr=0x001ced48,size=0x00000020
+ <idle>-0 [000] ..s3 57.061342: mmc_blk_rw_end: cmd=18,addr=0x001ced48,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.061580: mmc_blk_rw_start: cmd=18,addr=0x001ce668,size=0x00000100
+ <idle>-0 [000] ..s3 57.062605: mmc_blk_rw_end: cmd=18,addr=0x001ce668,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.062882: mmc_blk_rw_start: cmd=18,addr=0x001ce520,size=0x00000100
+ <idle>-0 [000] ..s3 57.063843: mmc_blk_rw_end: cmd=18,addr=0x001ce520,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.064177: mmc_blk_rw_start: cmd=25,addr=0x002c65c0,size=0x00000030
+ <...>-1488 [000] ..s2 57.064365: mmc_blk_rw_end: cmd=25,addr=0x002c65c0,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.065042: mmc_blk_rw_start: cmd=25,addr=0x002c65f0,size=0x00000008
+ <...>-1488 [000] ..s3 57.065098: mmc_blk_rw_end: cmd=25,addr=0x002c65f0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.066113: mmc_blk_rw_start: cmd=25,addr=0x002c65f8,size=0x00000030
+ <idle>-0 [000] .Ns3 57.066320: mmc_blk_rw_end: cmd=25,addr=0x002c65f8,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.067085: mmc_blk_rw_start: cmd=25,addr=0x002c6628,size=0x00000008
+ <idle>-0 [000] ..s3 57.067144: mmc_blk_rw_end: cmd=25,addr=0x002c6628,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.067995: mmc_blk_rw_start: cmd=25,addr=0x00b98110,size=0x00000008
+ <idle>-0 [000] ..s3 57.068056: mmc_blk_rw_end: cmd=25,addr=0x00b98110,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.068894: mmc_blk_rw_start: cmd=25,addr=0x002c6630,size=0x00000020
+ <idle>-0 [000] ..s3 57.069029: mmc_blk_rw_end: cmd=25,addr=0x002c6630,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.069653: mmc_blk_rw_start: cmd=25,addr=0x002c6650,size=0x00000008
+ <idle>-0 [000] ..s3 57.069712: mmc_blk_rw_end: cmd=25,addr=0x002c6650,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.070613: mmc_blk_rw_start: cmd=25,addr=0x002c6658,size=0x00000030
+ <idle>-0 [000] ..s3 57.070798: mmc_blk_rw_end: cmd=25,addr=0x002c6658,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.071612: mmc_blk_rw_start: cmd=25,addr=0x002c6688,size=0x00000008
+ <idle>-0 [000] ..s3 57.071670: mmc_blk_rw_end: cmd=25,addr=0x002c6688,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.072584: mmc_blk_rw_start: cmd=25,addr=0x00b98118,size=0x00000008
+ <idle>-0 [000] ..s3 57.072660: mmc_blk_rw_end: cmd=25,addr=0x00b98118,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.073492: mmc_blk_rw_start: cmd=25,addr=0x002c6690,size=0x00000020
+ <idle>-0 [000] ..s3 57.073643: mmc_blk_rw_end: cmd=25,addr=0x002c6690,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.074337: mmc_blk_rw_start: cmd=25,addr=0x002c66b0,size=0x00000008
+ <idle>-0 [000] ..s3 57.074413: mmc_blk_rw_end: cmd=25,addr=0x002c66b0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.075439: mmc_blk_rw_start: cmd=25,addr=0x002c66b8,size=0x00000040
+ <idle>-0 [000] ..s3 57.075814: mmc_blk_rw_end: cmd=25,addr=0x002c66b8,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.077220: mmc_blk_rw_start: cmd=25,addr=0x002c66f8,size=0x00000008
+ <idle>-0 [000] ..s3 57.077296: mmc_blk_rw_end: cmd=25,addr=0x002c66f8,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.078134: mmc_blk_rw_start: cmd=25,addr=0x002c6700,size=0x00000008
+ <idle>-0 [000] ..s3 57.078210: mmc_blk_rw_end: cmd=25,addr=0x002c6700,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.079207: mmc_blk_rw_start: cmd=18,addr=0x001cd810,size=0x000000b0
+ <idle>-0 [000] ..s3 57.079920: mmc_blk_rw_end: cmd=18,addr=0x001cd810,size=0x000000b0
+ mmcqd/0-82 [000] ...1 57.102577: mmc_blk_rw_start: cmd=18,addr=0x001d55a8,size=0x00000020
+ <idle>-0 [000] ..s3 57.102988: mmc_blk_rw_end: cmd=18,addr=0x001d55a8,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.105262: mmc_blk_rw_start: cmd=18,addr=0x00343b00,size=0x00000020
+ <...>-1488 [000] ..s2 57.105606: mmc_blk_rw_end: cmd=18,addr=0x00343b00,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.106150: mmc_blk_rw_start: cmd=18,addr=0x00b872a0,size=0x00000008
+ <...>-1488 [000] ..s2 57.106340: mmc_blk_rw_end: cmd=18,addr=0x00b872a0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.106360: mmc_blk_rw_start: cmd=18,addr=0x00b912a0,size=0x00000008
+ <...>-1525 [000] ..s2 57.106549: mmc_blk_rw_end: cmd=18,addr=0x00b912a0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.106745: mmc_blk_rw_start: cmd=18,addr=0x00343b78,size=0x00000008
+ <...>-1488 [000] ..s2 57.106876: mmc_blk_rw_end: cmd=18,addr=0x00343b78,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.107430: mmc_blk_rw_start: cmd=18,addr=0x00343b80,size=0x00000008
+ <...>-1488 [000] ..s2 57.107559: mmc_blk_rw_end: cmd=18,addr=0x00343b80,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.108843: mmc_blk_rw_start: cmd=18,addr=0x00343b20,size=0x00000040
+ <...>-1525 [000] ..s2 57.109237: mmc_blk_rw_end: cmd=18,addr=0x00343b20,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.110414: mmc_blk_rw_start: cmd=18,addr=0x001cf530,size=0x00000030
+ <idle>-0 [000] ..s3 57.110809: mmc_blk_rw_end: cmd=18,addr=0x001cf530,size=0x00000030
+ mmcqd/0-82 [000] ...1 57.110880: mmc_blk_rw_start: cmd=18,addr=0x001cc028,size=0x00000100
+ <idle>-0 [000] ..s3 57.111960: mmc_blk_rw_end: cmd=18,addr=0x001cc028,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.112794: mmc_blk_rw_start: cmd=18,addr=0x001d14b8,size=0x00000100
+ <...>-1488 [000] ..s2 57.113838: mmc_blk_rw_end: cmd=18,addr=0x001d14b8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.114825: mmc_blk_rw_start: cmd=18,addr=0x001d46e8,size=0x00000100
+ <...>-1488 [000] ..s2 57.115915: mmc_blk_rw_end: cmd=18,addr=0x001d46e8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.115997: mmc_blk_rw_start: cmd=18,addr=0x001cd8c0,size=0x00000010
+ <...>-1488 [000] ..s3 57.116180: mmc_blk_rw_end: cmd=18,addr=0x001cd8c0,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.119197: mmc_blk_rw_start: cmd=18,addr=0x00b91258,size=0x00000020
+ <...>-1529 [000] ..s2 57.119555: mmc_blk_rw_end: cmd=18,addr=0x00b91258,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.120544: mmc_blk_rw_start: cmd=18,addr=0x00b91250,size=0x00000008
+ <idle>-0 [000] .Ns4 57.120694: mmc_blk_rw_end: cmd=18,addr=0x00b91250,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.120710: mmc_blk_rw_start: cmd=18,addr=0x00b91360,size=0x00000018
+ <...>-1525 [000] ..s2 57.120911: mmc_blk_rw_end: cmd=18,addr=0x00b91360,size=0x00000018
+ mmcqd/0-82 [000] ...1 57.124398: mmc_blk_rw_start: cmd=18,addr=0x00b91278,size=0x00000010
+ <idle>-0 [000] ..s3 57.124605: mmc_blk_rw_end: cmd=18,addr=0x00b91278,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.134837: mmc_blk_rw_start: cmd=18,addr=0x001d2840,size=0x00000100
+ <...>-1488 [000] ..s2 57.135881: mmc_blk_rw_end: cmd=18,addr=0x001d2840,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.138549: mmc_blk_rw_start: cmd=18,addr=0x001ce048,size=0x00000058
+ <...>-1523 [000] ..s2 57.139016: mmc_blk_rw_end: cmd=18,addr=0x001ce048,size=0x00000058
+ mmcqd/0-82 [000] ...1 57.139371: mmc_blk_rw_start: cmd=18,addr=0x001ce620,size=0x00000048
+ Binder_9-663 [000] ..s2 57.139720: mmc_blk_rw_end: cmd=18,addr=0x001ce620,size=0x00000048
+ mmcqd/0-82 [000] ...1 57.144191: mmc_blk_rw_start: cmd=18,addr=0x001d9468,size=0x000000d0
+ <idle>-0 [000] ..s3 57.145085: mmc_blk_rw_end: cmd=18,addr=0x001d9468,size=0x000000d0
+ mmcqd/0-82 [000] ...1 57.145455: mmc_blk_rw_start: cmd=18,addr=0x001d3f90,size=0x00000100
+ <idle>-0 [000] ..s3 57.146436: mmc_blk_rw_end: cmd=18,addr=0x001d3f90,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.146515: mmc_blk_rw_start: cmd=18,addr=0x001cdea0,size=0x000000a8
+ <idle>-0 [000] ..s3 57.147224: mmc_blk_rw_end: cmd=18,addr=0x001cdea0,size=0x000000a8
+ mmcqd/0-82 [000] ...1 57.152107: mmc_blk_rw_start: cmd=18,addr=0x005449a0,size=0x00000008
+ <...>-1488 [000] ..s2 57.152257: mmc_blk_rw_end: cmd=18,addr=0x005449a0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.154192: mmc_blk_rw_start: cmd=18,addr=0x001d3040,size=0x00000100
+ <idle>-0 [000] ..s3 57.155162: mmc_blk_rw_end: cmd=18,addr=0x001d3040,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.162409: mmc_blk_rw_start: cmd=18,addr=0x0035a7e0,size=0x00000100
+ <...>-1488 [000] ..s2 57.163463: mmc_blk_rw_end: cmd=18,addr=0x0035a7e0,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.177438: mmc_blk_rw_start: cmd=18,addr=0x0013faa0,size=0x00000008
+ <idle>-0 [000] ..s3 57.177673: mmc_blk_rw_end: cmd=18,addr=0x0013faa0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.204547: mmc_blk_rw_start: cmd=18,addr=0x001d9a88,size=0x00000100
+ <...>-1488 [000] ..s2 57.205593: mmc_blk_rw_end: cmd=18,addr=0x001d9a88,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.205939: mmc_blk_rw_start: cmd=18,addr=0x001d97d0,size=0x00000100
+ <...>-85 [000] ..s3 57.206922: mmc_blk_rw_end: cmd=18,addr=0x001d97d0,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.207744: mmc_blk_rw_start: cmd=18,addr=0x001d2780,size=0x000000a8
+ <idle>-0 [000] ..s3 57.208525: mmc_blk_rw_end: cmd=18,addr=0x001d2780,size=0x000000a8
+ mmcqd/0-82 [000] ...1 57.208869: mmc_blk_rw_start: cmd=18,addr=0x001d2940,size=0x00000100
+ <idle>-0 [000] ..s3 57.209819: mmc_blk_rw_end: cmd=18,addr=0x001d2940,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.209871: mmc_blk_rw_start: cmd=18,addr=0x001d2c78,size=0x00000100
+ <idle>-0 [000] ..s3 57.210890: mmc_blk_rw_end: cmd=18,addr=0x001d2c78,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.211390: mmc_blk_rw_start: cmd=18,addr=0x001d9ca8,size=0x00000078
+ <idle>-0 [000] ..s3 57.212014: mmc_blk_rw_end: cmd=18,addr=0x001d9ca8,size=0x00000078
+ mmcqd/0-82 [000] ...1 57.212429: mmc_blk_rw_start: cmd=18,addr=0x001d2a40,size=0x00000058
+ <idle>-0 [000] ..s3 57.212840: mmc_blk_rw_end: cmd=18,addr=0x001d2a40,size=0x00000058
+ mmcqd/0-82 [000] ...1 57.212887: mmc_blk_rw_start: cmd=18,addr=0x001d2b98,size=0x000000a0
+ <idle>-0 [000] ..s3 57.213629: mmc_blk_rw_end: cmd=18,addr=0x001d2b98,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.214172: mmc_blk_rw_start: cmd=18,addr=0x0013fe48,size=0x00000008
+ <idle>-0 [000] ..s3 57.214305: mmc_blk_rw_end: cmd=18,addr=0x0013fe48,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.214405: mmc_blk_rw_start: cmd=18,addr=0x001d2828,size=0x00000018
+ <...>-1488 [000] ..s2 57.214626: mmc_blk_rw_end: cmd=18,addr=0x001d2828,size=0x00000018
+ mmcqd/0-82 [000] ...1 57.214992: mmc_blk_rw_start: cmd=18,addr=0x001d98d0,size=0x00000100
+ <idle>-0 [000] ..s3 57.215970: mmc_blk_rw_end: cmd=18,addr=0x001d98d0,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.216111: mmc_blk_rw_start: cmd=18,addr=0x001d99d0,size=0x000000b8
+ <idle>-0 [000] .Ns3 57.216876: mmc_blk_rw_end: cmd=18,addr=0x001d99d0,size=0x000000b8
+ mmcqd/0-82 [001] ...1 57.217019: mmc_blk_rw_start: cmd=18,addr=0x001d9b88,size=0x00000020
+ <idle>-0 [000] ..s3 57.217344: mmc_blk_rw_end: cmd=18,addr=0x001d9b88,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.218411: mmc_blk_rw_start: cmd=18,addr=0x001d42f0,size=0x00000090
+ <idle>-0 [000] ..s3 57.219073: mmc_blk_rw_end: cmd=18,addr=0x001d42f0,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.219314: mmc_blk_rw_start: cmd=18,addr=0x001d2ef0,size=0x000000b0
+ <idle>-0 [000] ..s3 57.220056: mmc_blk_rw_end: cmd=18,addr=0x001d2ef0,size=0x000000b0
+ mmcqd/0-82 [000] ...1 57.220313: mmc_blk_rw_start: cmd=18,addr=0x001d4380,size=0x000000e0
+ <idle>-0 [000] ..s3 57.221180: mmc_blk_rw_end: cmd=18,addr=0x001d4380,size=0x000000e0
+ mmcqd/0-82 [000] ...1 57.221384: mmc_blk_rw_start: cmd=18,addr=0x001d2fa0,size=0x000000a0
+ <idle>-0 [000] ..s3 57.222072: mmc_blk_rw_end: cmd=18,addr=0x001d2fa0,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.223422: mmc_blk_rw_start: cmd=18,addr=0x001cbf80,size=0x000000a8
+ <idle>-0 [000] ..s3 57.224200: mmc_blk_rw_end: cmd=18,addr=0x001cbf80,size=0x000000a8
+ mmcqd/0-82 [000] ...1 57.224509: mmc_blk_rw_start: cmd=18,addr=0x001d0098,size=0x00000100
+ <idle>-0 [000] ..s3 57.225557: mmc_blk_rw_end: cmd=18,addr=0x001d0098,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.225794: mmc_blk_rw_start: cmd=18,addr=0x001cff78,size=0x00000100
+ <idle>-0 [000] ..s3 57.226801: mmc_blk_rw_end: cmd=18,addr=0x001cff78,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.227092: mmc_blk_rw_start: cmd=18,addr=0x001d0078,size=0x00000020
+ <idle>-0 [000] ..s3 57.227402: mmc_blk_rw_end: cmd=18,addr=0x001d0078,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.227628: mmc_blk_rw_start: cmd=18,addr=0x001d9130,size=0x00000090
+ <idle>-0 [000] ..s3 57.228243: mmc_blk_rw_end: cmd=18,addr=0x001d9130,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.228522: mmc_blk_rw_start: cmd=18,addr=0x001cf958,size=0x00000100
+ <idle>-0 [000] ..s3 57.229530: mmc_blk_rw_end: cmd=18,addr=0x001cf958,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.229794: mmc_blk_rw_start: cmd=18,addr=0x001d0288,size=0x000000d0
+ <idle>-0 [000] ..s3 57.230655: mmc_blk_rw_end: cmd=18,addr=0x001d0288,size=0x000000d0
+ mmcqd/0-82 [000] ...1 57.230854: mmc_blk_rw_start: cmd=18,addr=0x001cf7e0,size=0x00000070
+ <idle>-0 [000] ..s3 57.231357: mmc_blk_rw_end: cmd=18,addr=0x001cf7e0,size=0x00000070
+ mmcqd/0-82 [000] ...1 57.232991: mmc_blk_rw_start: cmd=18,addr=0x001d16d0,size=0x00000068
+ <idle>-0 [000] ..s3 57.233489: mmc_blk_rw_end: cmd=18,addr=0x001d16d0,size=0x00000068
+ mmcqd/0-82 [000] ...1 57.233879: mmc_blk_rw_start: cmd=18,addr=0x001cdc58,size=0x00000010
+ <idle>-0 [000] ..s3 57.234057: mmc_blk_rw_end: cmd=18,addr=0x001cdc58,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.234417: mmc_blk_rw_start: cmd=18,addr=0x001d01a0,size=0x000000e8
+ <idle>-0 [000] ..s3 57.235343: mmc_blk_rw_end: cmd=18,addr=0x001d01a0,size=0x000000e8
+ mmcqd/0-82 [000] ...1 57.235572: mmc_blk_rw_start: cmd=18,addr=0x001d0578,size=0x000000d8
+ <idle>-0 [000] ..s3 57.236437: mmc_blk_rw_end: cmd=18,addr=0x001d0578,size=0x000000d8
+ mmcqd/0-82 [000] ...1 57.238214: mmc_blk_rw_start: cmd=18,addr=0x001cd1a0,size=0x000000c8
+ <idle>-0 [000] ..s3 57.239060: mmc_blk_rw_end: cmd=18,addr=0x001cd1a0,size=0x000000c8
+ mmcqd/0-82 [001] ...1 57.239429: mmc_blk_rw_start: cmd=18,addr=0x001cc8f0,size=0x00000090
+ <idle>-0 [000] ..s3 57.240094: mmc_blk_rw_end: cmd=18,addr=0x001cc8f0,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.240493: mmc_blk_rw_start: cmd=18,addr=0x001d9008,size=0x00000100
+ <idle>-0 [000] ..s3 57.241469: mmc_blk_rw_end: cmd=18,addr=0x001d9008,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.243860: mmc_blk_rw_start: cmd=18,addr=0x001d1838,size=0x000000a0
+ <idle>-0 [000] ..s3 57.244560: mmc_blk_rw_end: cmd=18,addr=0x001d1838,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.245037: mmc_blk_rw_start: cmd=18,addr=0x001cd268,size=0x000000e0
+ <idle>-0 [000] ..s3 57.245971: mmc_blk_rw_end: cmd=18,addr=0x001cd268,size=0x000000e0
+ mmcqd/0-82 [000] ...1 57.246252: mmc_blk_rw_start: cmd=18,addr=0x001cddc8,size=0x000000d8
+ <idle>-0 [000] ..s3 57.247134: mmc_blk_rw_end: cmd=18,addr=0x001cddc8,size=0x000000d8
+ mmcqd/0-82 [000] ...1 57.247428: mmc_blk_rw_start: cmd=18,addr=0x001d4090,size=0x00000038
+ <idle>-0 [000] ..s3 57.247754: mmc_blk_rw_end: cmd=18,addr=0x001d4090,size=0x00000038
+ mmcqd/0-82 [000] ...1 57.247854: mmc_blk_rw_start: cmd=18,addr=0x001d0520,size=0x00000058
+ <idle>-0 [000] ..s3 57.248258: mmc_blk_rw_end: cmd=18,addr=0x001d0520,size=0x00000058
+ mmcqd/0-82 [000] ...1 57.248574: mmc_blk_rw_start: cmd=18,addr=0x001cfd08,size=0x000000e8
+ <idle>-0 [000] ..s3 57.249475: mmc_blk_rw_end: cmd=18,addr=0x001cfd08,size=0x000000e8
+ mmcqd/0-82 [000] ...1 57.249726: mmc_blk_rw_start: cmd=18,addr=0x001cfaa8,size=0x00000100
+ <idle>-0 [000] ..s3 57.250796: mmc_blk_rw_end: cmd=18,addr=0x001cfaa8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.251114: mmc_blk_rw_start: cmd=18,addr=0x001cfba8,size=0x00000060
+ <idle>-0 [000] ..s3 57.251695: mmc_blk_rw_end: cmd=18,addr=0x001cfba8,size=0x00000060
+ mmcqd/0-82 [000] ...1 57.252516: mmc_blk_rw_start: cmd=18,addr=0x001cfdf0,size=0x00000100
+ <idle>-0 [000] ..s3 57.253564: mmc_blk_rw_end: cmd=18,addr=0x001cfdf0,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.253905: mmc_blk_rw_start: cmd=18,addr=0x001ce450,size=0x000000b0
+ <idle>-0 [000] ..s3 57.254612: mmc_blk_rw_end: cmd=18,addr=0x001ce450,size=0x000000b0
+ mmcqd/0-82 [000] ...1 57.255259: mmc_blk_rw_start: cmd=18,addr=0x001d0198,size=0x00000008
+ <idle>-0 [000] ..s3 57.255413: mmc_blk_rw_end: cmd=18,addr=0x001d0198,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.256613: mmc_blk_rw_start: cmd=18,addr=0x001d1f28,size=0x00000100
+ <idle>-0 [000] ..s3 57.257654: mmc_blk_rw_end: cmd=18,addr=0x001d1f28,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.259196: mmc_blk_rw_start: cmd=18,addr=0x0013fe08,size=0x00000040
+ <idle>-0 [000] ..s3 57.259737: mmc_blk_rw_end: cmd=18,addr=0x0013fe08,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.259779: mmc_blk_rw_start: cmd=18,addr=0x0013fe50,size=0x00000018
+ <idle>-0 [000] ..s3 57.260033: mmc_blk_rw_end: cmd=18,addr=0x0013fe50,size=0x00000018
+ mmcqd/0-82 [000] ...1 57.260076: mmc_blk_rw_start: cmd=18,addr=0x001d0b78,size=0x00000100
+ <...>-1488 [000] ..s2 57.261095: mmc_blk_rw_end: cmd=18,addr=0x001d0b78,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.261370: mmc_blk_rw_start: cmd=18,addr=0x001d2c38,size=0x00000040
+ <...>-1488 [000] ..s2 57.261739: mmc_blk_rw_end: cmd=18,addr=0x001d2c38,size=0x00000040
+ mmcqd/0-82 [001] ...1 57.262839: mmc_blk_rw_start: cmd=18,addr=0x001d96c0,size=0x00000100
+ <...>-1488 [000] ..s2 57.263907: mmc_blk_rw_end: cmd=18,addr=0x001d96c0,size=0x00000100
+ mmcqd/0-82 [001] ...1 57.264945: mmc_blk_rw_start: cmd=18,addr=0x001d2440,size=0x00000100
+ <...>-1488 [000] ..s2 57.265992: mmc_blk_rw_end: cmd=18,addr=0x001d2440,size=0x00000100
+ mmcqd/0-82 [001] ...1 57.290040: mmc_blk_rw_start: cmd=18,addr=0x001d9678,size=0x00000048
+ <...>-1488 [000] ..s2 57.290472: mmc_blk_rw_end: cmd=18,addr=0x001d9678,size=0x00000048
+ mmcqd/0-82 [001] ...1 57.302592: mmc_blk_rw_start: cmd=18,addr=0x001cda70,size=0x00000068
+ <idle>-0 [000] ..s3 57.303140: mmc_blk_rw_end: cmd=18,addr=0x001cda70,size=0x00000068
+ mmcqd/0-82 [000] ...1 57.309317: mmc_blk_rw_start: cmd=18,addr=0x001d0a80,size=0x000000f8
+ <idle>-0 [000] ..s3 57.310291: mmc_blk_rw_end: cmd=18,addr=0x001d0a80,size=0x000000f8
+ mmcqd/0-82 [000] ...1 57.310613: mmc_blk_rw_start: cmd=18,addr=0x001d0df0,size=0x00000100
+ <idle>-0 [000] ..s3 57.311611: mmc_blk_rw_end: cmd=18,addr=0x001d0df0,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.311878: mmc_blk_rw_start: cmd=18,addr=0x001d0ef0,size=0x00000098
+ <idle>-0 [000] ..s3 57.312534: mmc_blk_rw_end: cmd=18,addr=0x001d0ef0,size=0x00000098
+ mmcqd/0-82 [000] ...1 57.315086: mmc_blk_rw_start: cmd=18,addr=0x001cfa58,size=0x00000050
+ <idle>-0 [000] ..s3 57.315561: mmc_blk_rw_end: cmd=18,addr=0x001cfa58,size=0x00000050
+ mmcqd/0-82 [000] ...1 57.316185: mmc_blk_rw_start: cmd=18,addr=0x001ce910,size=0x00000040
+ <...>-1523 [000] ..s2 57.316510: mmc_blk_rw_end: cmd=18,addr=0x001ce910,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.319192: mmc_blk_rw_start: cmd=18,addr=0x001d0978,size=0x00000100
+ <idle>-0 [000] ..s3 57.320214: mmc_blk_rw_end: cmd=18,addr=0x001d0978,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.320264: mmc_blk_rw_start: cmd=18,addr=0x001d0c78,size=0x00000100
+ <...>-1523 [000] ..s2 57.321292: mmc_blk_rw_end: cmd=18,addr=0x001d0c78,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.323769: mmc_blk_rw_start: cmd=18,addr=0x001d2d78,size=0x00000078
+ <idle>-0 [000] ..s3 57.324361: mmc_blk_rw_end: cmd=18,addr=0x001d2d78,size=0x00000078
+ mmcqd/0-82 [000] ...1 57.327321: mmc_blk_rw_start: cmd=18,addr=0x001cc3d0,size=0x00000020
+ <...>-1523 [000] ..s2 57.327591: mmc_blk_rw_end: cmd=18,addr=0x001cc3d0,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.327617: mmc_blk_rw_start: cmd=18,addr=0x001cd5f0,size=0x00000090
+ <idle>-0 [000] ..s3 57.328264: mmc_blk_rw_end: cmd=18,addr=0x001cd5f0,size=0x00000090
+ mmcqd/0-82 [000] ...1 57.328300: mmc_blk_rw_start: cmd=18,addr=0x001ce500,size=0x00000020
+ <idle>-0 [000] ..s3 57.328518: mmc_blk_rw_end: cmd=18,addr=0x001ce500,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.371192: mmc_blk_rw_start: cmd=18,addr=0x001d2178,size=0x00000100
+ <...>-1488 [000] ..s2 57.372229: mmc_blk_rw_end: cmd=18,addr=0x001d2178,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.372428: mmc_blk_rw_start: cmd=18,addr=0x001d2278,size=0x00000060
+ <...>-1488 [000] ..s2 57.372913: mmc_blk_rw_end: cmd=18,addr=0x001d2278,size=0x00000060
+ mmcqd/0-82 [000] ...1 57.382172: mmc_blk_rw_start: cmd=18,addr=0x001d18d8,size=0x00000100
+ <...>-1547 [000] ..s2 57.383225: mmc_blk_rw_end: cmd=18,addr=0x001d18d8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.391840: mmc_blk_rw_start: cmd=18,addr=0x001d1eb8,size=0x00000070
+ <...>-1488 [000] ..s2 57.392423: mmc_blk_rw_end: cmd=18,addr=0x001d1eb8,size=0x00000070
+ mmcqd/0-82 [000] ...1 57.394518: mmc_blk_rw_start: cmd=18,addr=0x00545750,size=0x00000100
+ <...>-1488 [000] ..s2 57.395564: mmc_blk_rw_end: cmd=18,addr=0x00545750,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.396101: mmc_blk_rw_start: cmd=18,addr=0x00545850,size=0x00000100
+ <...>-1545 [000] ..s2 57.397066: mmc_blk_rw_end: cmd=18,addr=0x00545850,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.397915: mmc_blk_rw_start: cmd=18,addr=0x00545950,size=0x00000100
+ Binder_A-669 [000] ..s2 57.398901: mmc_blk_rw_end: cmd=18,addr=0x00545950,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.429423: mmc_blk_rw_start: cmd=18,addr=0x00344700,size=0x00000020
+ <...>-1559 [000] ..s4 57.429771: mmc_blk_rw_end: cmd=18,addr=0x00344700,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.430206: mmc_blk_rw_start: cmd=18,addr=0x00344720,size=0x00000040
+ <...>-1559 [000] ..s4 57.430606: mmc_blk_rw_end: cmd=18,addr=0x00344720,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.430705: mmc_blk_rw_start: cmd=18,addr=0x00344760,size=0x00000080
+ <...>-1559 [000] ..s3 57.431313: mmc_blk_rw_end: cmd=18,addr=0x00344760,size=0x00000080
+ mmcqd/0-82 [000] ...1 57.431392: mmc_blk_rw_start: cmd=18,addr=0x003447e0,size=0x00000020
+ <...>-1488 [000] ..s3 57.431645: mmc_blk_rw_end: cmd=18,addr=0x003447e0,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.434201: mmc_blk_rw_start: cmd=18,addr=0x00343f00,size=0x00000020
+ <...>-1488 [000] ..s2 57.434457: mmc_blk_rw_end: cmd=18,addr=0x00343f00,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.434904: mmc_blk_rw_start: cmd=18,addr=0x00b91298,size=0x00000008
+ <...>-1488 [000] ..s2 57.435094: mmc_blk_rw_end: cmd=18,addr=0x00b91298,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.435116: mmc_blk_rw_start: cmd=18,addr=0x00b914b0,size=0x00000010
+ <...>-1488 [000] ..s2 57.435277: mmc_blk_rw_end: cmd=18,addr=0x00b914b0,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.436381: mmc_blk_rw_start: cmd=18,addr=0x00343f20,size=0x00000040
+ <...>-1488 [000] ..s2 57.436784: mmc_blk_rw_end: cmd=18,addr=0x00343f20,size=0x00000040
+ mmcqd/0-82 [000] ...1 57.436813: mmc_blk_rw_start: cmd=18,addr=0x00343f60,size=0x00000060
+ <...>-1488 [000] ..s2 57.437329: mmc_blk_rw_end: cmd=18,addr=0x00343f60,size=0x00000060
+ mmcqd/0-82 [000] ...1 57.439210: mmc_blk_rw_start: cmd=18,addr=0x001d0f88,size=0x00000098
+ <...>-1488 [000] ..s2 57.439983: mmc_blk_rw_end: cmd=18,addr=0x001d0f88,size=0x00000098
+ mmcqd/0-82 [000] ...1 57.458813: mmc_blk_rw_start: cmd=18,addr=0x00b912b0,size=0x00000020
+ <...>-1523 [000] ..s2 57.459127: mmc_blk_rw_end: cmd=18,addr=0x00b912b0,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.459557: mmc_blk_rw_start: cmd=18,addr=0x00b912a8,size=0x00000008
+ <...>-1557 [000] ..s2 57.459684: mmc_blk_rw_end: cmd=18,addr=0x00b912a8,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.459704: mmc_blk_rw_start: cmd=18,addr=0x001d6630,size=0x000000a0
+ <...>-1557 [000] ..s3 57.460432: mmc_blk_rw_end: cmd=18,addr=0x001d6630,size=0x000000a0
+ mmcqd/0-82 [000] ...1 57.460733: mmc_blk_rw_start: cmd=18,addr=0x001d3240,size=0x00000080
+ <...>-1557 [000] ..s2 57.461264: mmc_blk_rw_end: cmd=18,addr=0x001d3240,size=0x00000080
+ mmcqd/0-82 [000] ...1 57.464247: mmc_blk_rw_start: cmd=18,addr=0x00b912d0,size=0x00000010
+ <...>-1523 [000] ..s2 57.464441: mmc_blk_rw_end: cmd=18,addr=0x00b912d0,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.464469: mmc_blk_rw_start: cmd=18,addr=0x00b912e8,size=0x00000020
+ <...>-1523 [000] ..s2 57.464789: mmc_blk_rw_end: cmd=18,addr=0x00b912e8,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.466611: mmc_blk_rw_start: cmd=18,addr=0x00b912e0,size=0x00000008
+ <...>-1523 [000] ..s2 57.466763: mmc_blk_rw_end: cmd=18,addr=0x00b912e0,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.485203: mmc_blk_rw_start: cmd=18,addr=0x00543ab8,size=0x00000100
+ <...>-1557 [000] ..s3 57.486350: mmc_blk_rw_end: cmd=18,addr=0x00543ab8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.487748: mmc_blk_rw_start: cmd=18,addr=0x00543da8,size=0x00000100
+ <...>-1523 [000] ..s2 57.488841: mmc_blk_rw_end: cmd=18,addr=0x00543da8,size=0x00000100
+ mmcqd/0-82 [000] ...1 57.498275: mmc_blk_rw_start: cmd=18,addr=0x00543a20,size=0x00000098
+ Binder_2-130 [000] ..s2 57.499041: mmc_blk_rw_end: cmd=18,addr=0x00543a20,size=0x00000098
+ mmcqd/0-82 [000] ...1 57.515152: mmc_blk_rw_start: cmd=18,addr=0x001cd348,size=0x00000028
+ <...>-1559 [000] ..s2 57.515467: mmc_blk_rw_end: cmd=18,addr=0x001cd348,size=0x00000028
+ mmcqd/0-82 [000] ...1 57.516495: mmc_blk_rw_start: cmd=18,addr=0x001d92c0,size=0x00000010
+ <...>-1559 [000] ..s3 57.516782: mmc_blk_rw_end: cmd=18,addr=0x001d92c0,size=0x00000010
+ mmcqd/0-82 [000] ...1 57.555361: mmc_blk_rw_start: cmd=18,addr=0x001d0d78,size=0x00000078
+ <...>-1488 [000] ..s2 57.555949: mmc_blk_rw_end: cmd=18,addr=0x001d0d78,size=0x00000078
+ mmcqd/0-82 [000] ...1 57.556157: mmc_blk_rw_start: cmd=18,addr=0x001cfef0,size=0x00000088
+ Compiler-1495 [000] ..s3 57.556774: mmc_blk_rw_end: cmd=18,addr=0x001cfef0,size=0x00000088
+ mmcqd/0-82 [000] ...1 57.565912: mmc_blk_rw_start: cmd=18,addr=0x001d32c0,size=0x000000c8
+ <...>-1557 [000] ..s3 57.566737: mmc_blk_rw_end: cmd=18,addr=0x001d32c0,size=0x000000c8
+ mmcqd/0-82 [000] ...1 57.614954: mmc_blk_rw_start: cmd=18,addr=0x001d0840,size=0x00000080
+ <...>-1559 [000] ..s3 57.615517: mmc_blk_rw_end: cmd=18,addr=0x001d0840,size=0x00000080
+ mmcqd/0-82 [000] ...1 57.648037: mmc_blk_rw_start: cmd=18,addr=0x001d19d8,size=0x00000020
+ <...>-1559 [000] ..s2 57.648383: mmc_blk_rw_end: cmd=18,addr=0x001d19d8,size=0x00000020
+ mmcqd/0-82 [000] ...1 57.693082: mmc_blk_rw_start: cmd=25,addr=0x00b98120,size=0x00000008
+ <idle>-0 [000] ..s3 57.693171: mmc_blk_rw_end: cmd=25,addr=0x00b98120,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.708695: mmc_blk_rw_start: cmd=25,addr=0x00b98128,size=0x00000008
+ <...>-1541 [000] ..s2 57.708790: mmc_blk_rw_end: cmd=25,addr=0x00b98128,size=0x00000008
+ mmcqd/0-82 [000] ...1 57.714395: mmc_blk_rw_start: cmd=25,addr=0x002c6708,size=0x00000068
+ <...>-1541 [000] ..s4 57.715838: mmc_blk_rw_end: cmd=25,addr=0x002c6708,size=0x00000068
+ mmcqd/0-82 [000] ...1 57.717987: mmc_blk_rw_start: cmd=25,addr=0x002c6770,size=0x00000008
+ <...>-1541 [000] ..s2 57.718057: mmc_blk_rw_end: cmd=25,addr=0x002c6770,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.084817: mmc_blk_rw_start: cmd=18,addr=0x001d81e8,size=0x00000100
+ Compiler-387 [000] ..s2 58.086066: mmc_blk_rw_end: cmd=18,addr=0x001d81e8,size=0x00000100
+ mmcqd/0-82 [000] ...1 58.088028: mmc_blk_rw_start: cmd=18,addr=0x001d59c8,size=0x00000100
+ <idle>-0 [000] ..s3 58.089180: mmc_blk_rw_end: cmd=18,addr=0x001d59c8,size=0x00000100
+ mmcqd/0-82 [000] ...1 58.090030: mmc_blk_rw_start: cmd=18,addr=0x001d5ae0,size=0x00000100
+ <idle>-0 [000] ..s3 58.091133: mmc_blk_rw_end: cmd=18,addr=0x001d5ae0,size=0x00000100
+ mmcqd/0-82 [000] ...1 58.092466: mmc_blk_rw_start: cmd=18,addr=0x001d61d8,size=0x000000a0
+ <idle>-0 [000] ..s3 58.093289: mmc_blk_rw_end: cmd=18,addr=0x001d61d8,size=0x000000a0
+ mmcqd/0-82 [000] ...1 58.094858: mmc_blk_rw_start: cmd=18,addr=0x001d5e20,size=0x00000100
+ <idle>-0 [000] ..s3 58.095933: mmc_blk_rw_end: cmd=18,addr=0x001d5e20,size=0x00000100
+ mmcqd/0-82 [000] ...1 58.097221: mmc_blk_rw_start: cmd=18,addr=0x001d5ac8,size=0x00000018
+ <idle>-0 [000] ..s3 58.097634: mmc_blk_rw_end: cmd=18,addr=0x001d5ac8,size=0x00000018
+ mmcqd/0-82 [000] ...1 58.575553: mmc_blk_rw_start: cmd=25,addr=0x002c6778,size=0x00000058
+ <idle>-0 [000] ..s3 58.576045: mmc_blk_rw_end: cmd=25,addr=0x002c6778,size=0x00000058
+ mmcqd/0-82 [000] ...1 58.578793: mmc_blk_rw_start: cmd=25,addr=0x002c67d0,size=0x00000008
+ mmcqd/0-82 [000] ..s3 58.578935: mmc_blk_rw_end: cmd=25,addr=0x002c67d0,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.580809: mmc_blk_rw_start: cmd=25,addr=0x002c67d8,size=0x00000008
+ mmcqd/0-82 [000] ..s2 58.580958: mmc_blk_rw_end: cmd=25,addr=0x002c67d8,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.583739: mmc_blk_rw_start: cmd=25,addr=0x002c67e0,size=0x00000030
+ <idle>-0 [000] ..s3 58.584041: mmc_blk_rw_end: cmd=25,addr=0x002c67e0,size=0x00000030
+ mmcqd/0-82 [000] ...1 58.585137: mmc_blk_rw_start: cmd=25,addr=0x002c6810,size=0x00000008
+ kworker/0:2-48 [000] ..s3 58.585311: mmc_blk_rw_end: cmd=25,addr=0x002c6810,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.588080: mmc_blk_rw_start: cmd=18,addr=0x00b93130,size=0x00000008
+ <idle>-0 [000] ..s3 58.588375: mmc_blk_rw_end: cmd=18,addr=0x00b93130,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.589839: mmc_blk_rw_start: cmd=18,addr=0x00b93128,size=0x00000008
+ <idle>-0 [000] ..s4 58.590078: mmc_blk_rw_end: cmd=18,addr=0x00b93128,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.594680: mmc_blk_rw_start: cmd=25,addr=0x002c6818,size=0x00000038
+ <idle>-0 [000] ..s3 58.595009: mmc_blk_rw_end: cmd=25,addr=0x002c6818,size=0x00000038
+ mmcqd/0-82 [000] ...1 58.596248: mmc_blk_rw_start: cmd=25,addr=0x002c6850,size=0x00000008
+ mmcqd/0-82 [000] ..s2 58.596389: mmc_blk_rw_end: cmd=25,addr=0x002c6850,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.599773: mmc_blk_rw_start: cmd=25,addr=0x002c6858,size=0x00000030
+ <idle>-0 [000] ..s3 58.600194: mmc_blk_rw_end: cmd=25,addr=0x002c6858,size=0x00000030
+ mmcqd/0-82 [000] ...1 58.601507: mmc_blk_rw_start: cmd=25,addr=0x002c6888,size=0x00000008
+ kworker/0:2-48 [000] ..s4 58.601625: mmc_blk_rw_end: cmd=25,addr=0x002c6888,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.604459: mmc_blk_rw_start: cmd=25,addr=0x00b991f0,size=0x00000008
+ kworker/0:2-48 [000] ..s4 58.604654: mmc_blk_rw_end: cmd=25,addr=0x00b991f0,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.609374: mmc_blk_rw_start: cmd=25,addr=0x002c6890,size=0x00000020
+ <idle>-0 [000] ..s3 58.609576: mmc_blk_rw_end: cmd=25,addr=0x002c6890,size=0x00000020
+ mmcqd/0-82 [000] ...1 58.610551: mmc_blk_rw_start: cmd=25,addr=0x002c68b0,size=0x00000008
+ kworker/0:2-48 [000] ..s4 58.610669: mmc_blk_rw_end: cmd=25,addr=0x002c68b0,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.612541: mmc_blk_rw_start: cmd=25,addr=0x002c68b8,size=0x00000030
+ <idle>-0 [000] ..s3 58.612794: mmc_blk_rw_end: cmd=25,addr=0x002c68b8,size=0x00000030
+ mmcqd/0-82 [000] ...1 58.613930: mmc_blk_rw_start: cmd=25,addr=0x002c68e8,size=0x00000008
+ kworker/0:2-48 [000] ..s4 58.614049: mmc_blk_rw_end: cmd=25,addr=0x002c68e8,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.615695: mmc_blk_rw_start: cmd=25,addr=0x00b991f8,size=0x00000008
+ kworker/0:2-48 [000] ..s4 58.615817: mmc_blk_rw_end: cmd=25,addr=0x00b991f8,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.617071: mmc_blk_rw_start: cmd=25,addr=0x002c68f0,size=0x00000020
+ <idle>-0 [000] ..s3 58.617275: mmc_blk_rw_end: cmd=25,addr=0x002c68f0,size=0x00000020
+ mmcqd/0-82 [000] ...1 58.618373: mmc_blk_rw_start: cmd=25,addr=0x002c6910,size=0x00000008
+ <idle>-0 [000] ..s3 58.618571: mmc_blk_rw_end: cmd=25,addr=0x002c6910,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.621280: mmc_blk_rw_start: cmd=25,addr=0x002c6918,size=0x00000048
+ <idle>-0 [000] ..s3 58.621673: mmc_blk_rw_end: cmd=25,addr=0x002c6918,size=0x00000048
+ mmcqd/0-82 [000] ...1 58.622708: mmc_blk_rw_start: cmd=25,addr=0x002c6960,size=0x00000008
+ <idle>-0 [000] ..s3 58.622821: mmc_blk_rw_end: cmd=25,addr=0x002c6960,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.624060: mmc_blk_rw_start: cmd=25,addr=0x002c6968,size=0x00000008
+ <idle>-0 [000] ..s4 58.624249: mmc_blk_rw_end: cmd=25,addr=0x002c6968,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.724886: mmc_blk_rw_start: cmd=18,addr=0x005439a0,size=0x00000010
+ Binder_1-391 [000] ..s2 58.725161: mmc_blk_rw_end: cmd=18,addr=0x005439a0,size=0x00000010
+ mmcqd/0-82 [000] ...1 58.741803: mmc_blk_rw_start: cmd=18,addr=0x005474b8,size=0x00000008
+ Compiler-1495 [000] ..s3 58.742041: mmc_blk_rw_end: cmd=18,addr=0x005474b8,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.774047: mmc_blk_rw_start: cmd=18,addr=0x00b91398,size=0x00000018
+ <idle>-0 [000] ..s3 58.774338: mmc_blk_rw_end: cmd=18,addr=0x00b91398,size=0x00000018
+ mmcqd/0-82 [000] ...1 58.774417: mmc_blk_rw_start: cmd=18,addr=0x00b913c0,size=0x00000008
+ <...>-1563 [000] ..s2 58.774583: mmc_blk_rw_end: cmd=18,addr=0x00b913c0,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.778354: mmc_blk_rw_start: cmd=18,addr=0x00b913b0,size=0x00000010
+ <idle>-0 [000] .Ns3 58.778590: mmc_blk_rw_end: cmd=18,addr=0x00b913b0,size=0x00000010
+ mmcqd/0-82 [000] ...1 58.778749: mmc_blk_rw_start: cmd=18,addr=0x00b91390,size=0x00000008
+ mmcqd/0-82 [000] ..s4 58.778956: mmc_blk_rw_end: cmd=18,addr=0x00b91390,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.818682: mmc_blk_rw_start: cmd=18,addr=0x00b91438,size=0x00000008
+ <idle>-0 [000] ..s3 58.818842: mmc_blk_rw_end: cmd=18,addr=0x00b91438,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.821591: mmc_blk_rw_start: cmd=18,addr=0x00b91440,size=0x00000008
+ <idle>-0 [000] ..s3 58.821747: mmc_blk_rw_end: cmd=18,addr=0x00b91440,size=0x00000008
+ mmcqd/0-82 [000] ...1 58.821801: mmc_blk_rw_start: cmd=18,addr=0x00b91410,size=0x00000018
+ <idle>-0 [000] ..s3 58.822033: mmc_blk_rw_end: cmd=18,addr=0x00b91410,size=0x00000018
+ mmcqd/0-82 [000] ...1 58.824678: mmc_blk_rw_start: cmd=18,addr=0x00b91428,size=0x00000010
+ <idle>-0 [000] ..s3 58.824889: mmc_blk_rw_end: cmd=18,addr=0x00b91428,size=0x00000010
+ mmcqd/0-82 [000] ...1 58.824943: mmc_blk_rw_start: cmd=18,addr=0x00b91408,size=0x00000008
+ <idle>-0 [000] ..s3 58.825089: mmc_blk_rw_end: cmd=18,addr=0x00b91408,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.707934: mmc_blk_rw_start: cmd=25,addr=0x00b99200,size=0x00000008
+ UI-395 [000] ..s2 59.708025: mmc_blk_rw_end: cmd=25,addr=0x00b99200,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.709282: mmc_blk_rw_start: cmd=25,addr=0x002c6970,size=0x00000070
+ <idle>-0 [000] .Ns3 59.709727: mmc_blk_rw_end: cmd=25,addr=0x002c6970,size=0x00000070
+ mmcqd/0-82 [000] ...1 59.710588: mmc_blk_rw_start: cmd=25,addr=0x002c69e0,size=0x00000008
+ Binder_4-434 [000] ..s2 59.710645: mmc_blk_rw_end: cmd=25,addr=0x002c69e0,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.714209: mmc_blk_rw_start: cmd=25,addr=0x00b99208,size=0x00000008
+ <...>-1541 [000] ..s2 59.714294: mmc_blk_rw_end: cmd=25,addr=0x00b99208,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.721000: mmc_blk_rw_start: cmd=25,addr=0x002c69e8,size=0x00000050
+ adbd-1470 [000] ..s2 59.722370: mmc_blk_rw_end: cmd=25,addr=0x002c69e8,size=0x00000050
+ mmcqd/0-82 [000] ...1 59.725148: mmc_blk_rw_start: cmd=25,addr=0x002c6a38,size=0x00000008
+ <...>-1541 [000] .Ns3 59.725219: mmc_blk_rw_end: cmd=25,addr=0x002c6a38,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.727335: mmc_blk_rw_start: cmd=25,addr=0x00b99210,size=0x00000008
+ UI-395 [000] ..s2 59.727424: mmc_blk_rw_end: cmd=25,addr=0x00b99210,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.729033: mmc_blk_rw_start: cmd=25,addr=0x002c6a40,size=0x00000050
+ <...>-607 [000] ..s2 59.729377: mmc_blk_rw_end: cmd=25,addr=0x002c6a40,size=0x00000050
+ mmcqd/0-82 [000] ...1 59.731558: mmc_blk_rw_start: cmd=25,addr=0x002c6a90,size=0x00000008
+ <...>-1541 [000] ..s4 59.731617: mmc_blk_rw_end: cmd=25,addr=0x002c6a90,size=0x00000008
+ mmcqd/0-82 [000] ...1 59.792023: mmc_blk_rw_start: cmd=18,addr=0x001b9460,size=0x00000008
+ Binder_3-566 [000] ..s2 59.792250: mmc_blk_rw_end: cmd=18,addr=0x001b9460,size=0x00000008
+ mmcqd/0-82 [000] ...1 60.715097: mmc_blk_rw_start: cmd=18,addr=0x001cdd68,size=0x00000060
+ <idle>-0 [000] ..s3 60.715744: mmc_blk_rw_end: cmd=18,addr=0x001cdd68,size=0x00000060
+ mmcqd/0-82 [000] ...1 62.025279: mmc_blk_rw_start: cmd=18,addr=0x00346400,size=0x00000008
+ <idle>-0 [000] ..s4 62.025583: mmc_blk_rw_end: cmd=18,addr=0x00346400,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.037473: mmc_blk_rw_start: cmd=18,addr=0x00b91460,size=0x00000010
+ <idle>-0 [000] ..s3 62.037922: mmc_blk_rw_end: cmd=18,addr=0x00b91460,size=0x00000010
+ mmcqd/0-82 [000] ...1 62.039874: mmc_blk_rw_start: cmd=18,addr=0x00347c00,size=0x00000018
+ <idle>-0 [000] ..s3 62.040414: mmc_blk_rw_end: cmd=18,addr=0x00347c00,size=0x00000018
+ mmcqd/0-82 [000] ...1 62.040972: mmc_blk_rw_start: cmd=18,addr=0x00b91470,size=0x00000010
+ <idle>-0 [000] ..s3 62.041143: mmc_blk_rw_end: cmd=18,addr=0x00b91470,size=0x00000010
+ mmcqd/0-82 [000] ...1 62.041491: mmc_blk_rw_start: cmd=18,addr=0x00b91480,size=0x00000010
+ <idle>-0 [000] ..s3 62.041660: mmc_blk_rw_end: cmd=18,addr=0x00b91480,size=0x00000010
+ mmcqd/0-82 [000] ...1 62.054430: mmc_blk_rw_start: cmd=25,addr=0x00542080,size=0x00000008
+ <idle>-0 [000] ..s3 62.054527: mmc_blk_rw_end: cmd=25,addr=0x00542080,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.055112: mmc_blk_rw_start: cmd=25,addr=0x005420d0,size=0x00000010
+ <idle>-0 [000] ..s3 62.055225: mmc_blk_rw_end: cmd=25,addr=0x005420d0,size=0x00000010
+ mmcqd/0-82 [000] ...1 62.055726: mmc_blk_rw_start: cmd=25,addr=0x005420e8,size=0x00000008
+ mmcqd/0-82 [000] ..s3 62.055809: mmc_blk_rw_end: cmd=25,addr=0x005420e8,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.056385: mmc_blk_rw_start: cmd=25,addr=0x00542108,size=0x00000020
+ <idle>-0 [000] .Ns3 62.056544: mmc_blk_rw_end: cmd=25,addr=0x00542108,size=0x00000020
+ mmcqd/0-82 [000] ...1 62.057231: mmc_blk_rw_start: cmd=25,addr=0x00542130,size=0x00000010
+ <idle>-0 [000] ..s3 62.057342: mmc_blk_rw_end: cmd=25,addr=0x00542130,size=0x00000010
+ mmcqd/0-82 [000] ...1 62.057850: mmc_blk_rw_start: cmd=25,addr=0x00543740,size=0x00000008
+ mmcqd/0-82 [000] ..s2 62.057929: mmc_blk_rw_end: cmd=25,addr=0x00543740,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.058526: mmc_blk_rw_start: cmd=25,addr=0x00543760,size=0x00000008
+ <idle>-0 [000] ..s4 62.058609: mmc_blk_rw_end: cmd=25,addr=0x00543760,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.059193: mmc_blk_rw_start: cmd=25,addr=0x005437b8,size=0x00000008
+ mmcqd/0-82 [000] ..s3 62.059274: mmc_blk_rw_end: cmd=25,addr=0x005437b8,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.059876: mmc_blk_rw_start: cmd=25,addr=0x00544180,size=0x00000008
+ <idle>-0 [000] ..s4 62.059960: mmc_blk_rw_end: cmd=25,addr=0x00544180,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.060559: mmc_blk_rw_start: cmd=25,addr=0x00544920,size=0x00000008
+ mmcqd/0-82 [000] ..s3 62.060638: mmc_blk_rw_end: cmd=25,addr=0x00544920,size=0x00000008
+ mmcqd/0-82 [000] ...1 62.061313: mmc_blk_rw_start: cmd=25,addr=0x00b98130,size=0x00000010
+ <idle>-0 [000] ..s3 62.061423: mmc_blk_rw_end: cmd=25,addr=0x00b98130,size=0x00000010
+ mmcqd/0-82 [000] ...1 64.790558: mmc_blk_rw_start: cmd=18,addr=0x001ae238,size=0x00000010
+ <idle>-0 [000] ..s3 64.790938: mmc_blk_rw_end: cmd=18,addr=0x001ae238,size=0x00000010
+ mmcqd/0-82 [000] ...1 64.839610: mmc_blk_rw_start: cmd=18,addr=0x0002a148,size=0x00000008
+ <idle>-0 [000] .Ns4 64.839860: mmc_blk_rw_end: cmd=18,addr=0x0002a148,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.844165: mmc_blk_erase_start: cmd=3,addr=0x0002f0a8,size=0x0003af58
+ mmcqd/0-82 [000] ...1 64.855674: mmc_blk_erase_end: cmd=3,addr=0x0002f0a8,size=0x0003af58
+ mmcqd/0-82 [001] ...1 64.860452: mmc_blk_rw_start: cmd=18,addr=0x0006a148,size=0x00000008
+ <idle>-0 [000] ..s3 64.860624: mmc_blk_rw_end: cmd=18,addr=0x0006a148,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.860873: mmc_blk_erase_start: cmd=3,addr=0x0006ae98,size=0x0003f168
+ mmcqd/0-82 [000] ...1 64.872976: mmc_blk_erase_end: cmd=3,addr=0x0006ae98,size=0x0003f168
+ mmcqd/0-82 [001] ...1 64.877698: mmc_blk_rw_start: cmd=18,addr=0x000aa000,size=0x00000008
+ <idle>-0 [000] ..s3 64.877871: mmc_blk_rw_end: cmd=18,addr=0x000aa000,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.878114: mmc_blk_erase_start: cmd=3,addr=0x000ab010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 64.890188: mmc_blk_erase_end: cmd=3,addr=0x000ab010,size=0x0003eff0
+ mmcqd/0-82 [001] ...1 64.895271: mmc_blk_rw_start: cmd=18,addr=0x000ea148,size=0x00000008
+ <idle>-0 [000] ..s3 64.895441: mmc_blk_rw_end: cmd=18,addr=0x000ea148,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.895691: mmc_blk_erase_start: cmd=3,addr=0x000eae90,size=0x0003f170
+ mmcqd/0-82 [000] ...1 64.907802: mmc_blk_erase_end: cmd=3,addr=0x000eae90,size=0x0003f170
+ mmcqd/0-82 [001] ...1 64.912733: mmc_blk_rw_start: cmd=18,addr=0x0012a000,size=0x00000008
+ <idle>-0 [000] ..s3 64.912903: mmc_blk_rw_end: cmd=18,addr=0x0012a000,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.913123: mmc_blk_erase_start: cmd=3,addr=0x0012ad48,size=0x000072b8
+ mmcqd/0-82 [000] ...1 64.916366: mmc_blk_erase_end: cmd=3,addr=0x0012ad48,size=0x000072b8
+ mmcqd/0-82 [000] ...1 64.917057: mmc_blk_erase_start: cmd=3,addr=0x00308958,size=0x000006a8
+ mmcqd/0-82 [000] ...1 64.918223: mmc_blk_erase_end: cmd=3,addr=0x00308958,size=0x000006a8
+ mmcqd/0-82 [000] ...1 64.918307: mmc_blk_erase_start: cmd=3,addr=0x0030a1f0,size=0x00000610
+ mmcqd/0-82 [000] ...1 64.919345: mmc_blk_erase_end: cmd=3,addr=0x0030a1f0,size=0x00000610
+ mmcqd/0-82 [000] ...1 64.919426: mmc_blk_erase_start: cmd=3,addr=0x0030cb28,size=0x000004d8
+ mmcqd/0-82 [000] ...1 64.920372: mmc_blk_erase_end: cmd=3,addr=0x0030cb28,size=0x000004d8
+ mmcqd/0-82 [000] ...1 64.920445: mmc_blk_erase_start: cmd=3,addr=0x0030eb88,size=0x00000478
+ mmcqd/0-82 [000] ...1 64.921343: mmc_blk_erase_end: cmd=3,addr=0x0030eb88,size=0x00000478
+ mmcqd/0-82 [000] ...1 64.921414: mmc_blk_erase_start: cmd=3,addr=0x00310790,size=0x00000870
+ mmcqd/0-82 [000] ...1 64.922467: mmc_blk_erase_end: cmd=3,addr=0x00310790,size=0x00000870
+ mmcqd/0-82 [000] ...1 64.922556: mmc_blk_erase_start: cmd=3,addr=0x00311a88,size=0x00000578
+ mmcqd/0-82 [000] ...1 64.923503: mmc_blk_erase_end: cmd=3,addr=0x00311a88,size=0x00000578
+ mmcqd/0-82 [000] ...1 64.923581: mmc_blk_erase_start: cmd=3,addr=0x00317048,size=0x00002fb8
+ mmcqd/0-82 [000] ...1 64.925475: mmc_blk_erase_end: cmd=3,addr=0x00317048,size=0x00002fb8
+ mmcqd/0-82 [000] ...1 64.925765: mmc_blk_erase_start: cmd=3,addr=0x00347c18,size=0x00001108
+ mmcqd/0-82 [000] ...1 64.927235: mmc_blk_erase_end: cmd=3,addr=0x00347c18,size=0x00001108
+ mmcqd/0-82 [000] ...1 64.927364: mmc_blk_erase_start: cmd=3,addr=0x00349720,size=0x000005d0
+ mmcqd/0-82 [000] ...1 64.928362: mmc_blk_erase_end: cmd=3,addr=0x00349720,size=0x000005d0
+ mmcqd/0-82 [000] ...1 64.928439: mmc_blk_erase_start: cmd=3,addr=0x00349da0,size=0x000008b8
+ mmcqd/0-82 [000] ...1 64.930094: mmc_blk_erase_end: cmd=3,addr=0x00349da0,size=0x000008b8
+ mmcqd/0-82 [000] ...1 64.930184: mmc_blk_erase_start: cmd=3,addr=0x0034b000,size=0x00000b38
+ mmcqd/0-82 [000] ...1 64.931858: mmc_blk_erase_end: cmd=3,addr=0x0034b000,size=0x00000b38
+ mmcqd/0-82 [000] ...1 64.931961: mmc_blk_erase_start: cmd=3,addr=0x0034f000,size=0x00000c00
+ mmcqd/0-82 [000] ...1 64.933171: mmc_blk_erase_end: cmd=3,addr=0x0034f000,size=0x00000c00
+ mmcqd/0-82 [000] ...1 64.933280: mmc_blk_erase_start: cmd=3,addr=0x003510f8,size=0x00001dc0
+ mmcqd/0-82 [000] ...1 64.935361: mmc_blk_erase_end: cmd=3,addr=0x003510f8,size=0x00001dc0
+ mmcqd/0-82 [000] ...1 64.935545: mmc_blk_erase_start: cmd=3,addr=0x00352f78,size=0x00000690
+ mmcqd/0-82 [000] ...1 64.937124: mmc_blk_erase_end: cmd=3,addr=0x00352f78,size=0x00000690
+ mmcqd/0-82 [000] ...1 64.937204: mmc_blk_erase_start: cmd=3,addr=0x00357000,size=0x00001008
+ mmcqd/0-82 [000] ...1 64.938986: mmc_blk_erase_end: cmd=3,addr=0x00357000,size=0x00001008
+ mmcqd/0-82 [000] ...1 64.939146: mmc_blk_erase_start: cmd=3,addr=0x00358800,size=0x00001400
+ mmcqd/0-82 [000] ...1 64.940462: mmc_blk_erase_end: cmd=3,addr=0x00358800,size=0x00001400
+ mmcqd/0-82 [000] ...1 64.940608: mmc_blk_erase_start: cmd=3,addr=0x0035d000,size=0x00000a00
+ mmcqd/0-82 [000] ...1 64.941711: mmc_blk_erase_end: cmd=3,addr=0x0035d000,size=0x00000a00
+ mmcqd/0-82 [000] ...1 64.941808: mmc_blk_erase_start: cmd=3,addr=0x0035e528,size=0x00000ad8
+ mmcqd/0-82 [000] ...1 64.942915: mmc_blk_erase_end: cmd=3,addr=0x0035e528,size=0x00000ad8
+ mmcqd/0-82 [000] ...1 64.943014: mmc_blk_erase_start: cmd=3,addr=0x00360000,size=0x00000800
+ mmcqd/0-82 [000] ...1 64.944178: mmc_blk_erase_end: cmd=3,addr=0x00360000,size=0x00000800
+ mmcqd/0-82 [000] ...1 64.944265: mmc_blk_erase_start: cmd=3,addr=0x00360a70,size=0x00000590
+ mmcqd/0-82 [000] ...1 64.945257: mmc_blk_erase_end: cmd=3,addr=0x00360a70,size=0x00000590
+ mmcqd/0-82 [000] ...1 64.945337: mmc_blk_erase_start: cmd=3,addr=0x00361170,size=0x00008e90
+ mmcqd/0-82 [000] ...1 64.949162: mmc_blk_erase_end: cmd=3,addr=0x00361170,size=0x00008e90
+ mmcqd/0-82 [000] ...1 64.949868: mmc_blk_erase_start: cmd=3,addr=0x0036d448,size=0x00002bb8
+ mmcqd/0-82 [000] ...1 64.951650: mmc_blk_erase_end: cmd=3,addr=0x0036d448,size=0x00002bb8
+ mmcqd/0-82 [000] ...1 64.951901: mmc_blk_erase_start: cmd=3,addr=0x00372320,size=0x00000ce0
+ mmcqd/0-82 [000] ...1 64.953019: mmc_blk_erase_end: cmd=3,addr=0x00372320,size=0x00000ce0
+ mmcqd/0-82 [000] ...1 64.953130: mmc_blk_erase_start: cmd=3,addr=0x00374118,size=0x00000ee8
+ mmcqd/0-82 [000] ...1 64.954322: mmc_blk_erase_end: cmd=3,addr=0x00374118,size=0x00000ee8
+ mmcqd/0-82 [000] ...1 64.954446: mmc_blk_erase_start: cmd=3,addr=0x00375bd0,size=0x0000c430
+ mmcqd/0-82 [000] ...1 64.960104: mmc_blk_erase_end: cmd=3,addr=0x00375bd0,size=0x0000c430
+ mmcqd/0-82 [000] ...1 64.960996: mmc_blk_rw_start: cmd=18,addr=0x00383ac8,size=0x00000008
+ <idle>-0 [000] ..s3 64.961164: mmc_blk_rw_end: cmd=18,addr=0x00383ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.961360: mmc_blk_erase_start: cmd=3,addr=0x00384ae8,size=0x00000520
+ mmcqd/0-82 [000] ...1 64.962923: mmc_blk_erase_end: cmd=3,addr=0x00384ae8,size=0x00000520
+ mmcqd/0-82 [000] ...1 64.962990: mmc_blk_erase_start: cmd=3,addr=0x00385190,size=0x00006778
+ mmcqd/0-82 [000] ...1 64.966548: mmc_blk_erase_end: cmd=3,addr=0x00385190,size=0x00006778
+ mmcqd/0-82 [000] ...1 64.966996: mmc_blk_erase_start: cmd=3,addr=0x0038bec0,size=0x00022140
+ mmcqd/0-82 [000] ...1 64.979761: mmc_blk_erase_end: cmd=3,addr=0x0038bec0,size=0x00022140
+ mmcqd/0-82 [000] ...1 64.981889: mmc_blk_erase_start: cmd=3,addr=0x003b1808,size=0x000107f8
+ mmcqd/0-82 [000] ...1 64.988880: mmc_blk_erase_end: cmd=3,addr=0x003b1808,size=0x000107f8
+ mmcqd/0-82 [000] ...1 64.990030: mmc_blk_rw_start: cmd=18,addr=0x003c2000,size=0x00000008
+ <idle>-0 [000] ..s3 64.990196: mmc_blk_rw_end: cmd=18,addr=0x003c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 64.990399: mmc_blk_erase_start: cmd=3,addr=0x003c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.002436: mmc_blk_erase_end: cmd=3,addr=0x003c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.006530: mmc_blk_rw_start: cmd=18,addr=0x00403ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.006696: mmc_blk_rw_end: cmd=18,addr=0x00403ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.006904: mmc_blk_erase_start: cmd=3,addr=0x00404ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.018401: mmc_blk_erase_end: cmd=3,addr=0x00404ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.022323: mmc_blk_rw_start: cmd=18,addr=0x00442000,size=0x00000008
+ <idle>-0 [000] ..s3 65.022490: mmc_blk_rw_end: cmd=18,addr=0x00442000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.022695: mmc_blk_erase_start: cmd=3,addr=0x00443000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.034731: mmc_blk_erase_end: cmd=3,addr=0x00443000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.038992: mmc_blk_rw_start: cmd=18,addr=0x00483ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.039163: mmc_blk_rw_end: cmd=18,addr=0x00483ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.039441: mmc_blk_erase_start: cmd=3,addr=0x00484ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.051022: mmc_blk_erase_end: cmd=3,addr=0x00484ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.054504: mmc_blk_rw_start: cmd=18,addr=0x004c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.054666: mmc_blk_rw_end: cmd=18,addr=0x004c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.054850: mmc_blk_erase_start: cmd=3,addr=0x004c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.066849: mmc_blk_erase_end: cmd=3,addr=0x004c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.070240: mmc_blk_rw_start: cmd=18,addr=0x00503ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.070402: mmc_blk_rw_end: cmd=18,addr=0x00503ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.070586: mmc_blk_erase_start: cmd=3,addr=0x00504ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.082108: mmc_blk_erase_end: cmd=3,addr=0x00504ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.085540: mmc_blk_rw_start: cmd=18,addr=0x00542000,size=0x00000008
+ <idle>-0 [000] ..s3 65.085704: mmc_blk_rw_end: cmd=18,addr=0x00542000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.085878: mmc_blk_erase_start: cmd=3,addr=0x00546158,size=0x00001360
+ mmcqd/0-82 [000] ...1 65.087692: mmc_blk_erase_end: cmd=3,addr=0x00546158,size=0x00001360
+ mmcqd/0-82 [000] ...1 65.087792: mmc_blk_erase_start: cmd=3,addr=0x005477b0,size=0x00000950
+ mmcqd/0-82 [000] ...1 65.088834: mmc_blk_erase_end: cmd=3,addr=0x005477b0,size=0x00000950
+ mmcqd/0-82 [000] ...1 65.088915: mmc_blk_erase_start: cmd=3,addr=0x00548268,size=0x00039d98
+ mmcqd/0-82 [000] ...1 65.099331: mmc_blk_erase_end: cmd=3,addr=0x00548268,size=0x00039d98
+ mmcqd/0-82 [000] ...1 65.102484: mmc_blk_rw_start: cmd=18,addr=0x00582000,size=0x00000008
+ <idle>-0 [000] ..s3 65.102697: mmc_blk_rw_end: cmd=18,addr=0x00582000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.102950: mmc_blk_erase_start: cmd=3,addr=0x00584008,size=0x00000ff8
+ mmcqd/0-82 [000] ...1 65.104144: mmc_blk_erase_end: cmd=3,addr=0x00584008,size=0x00000ff8
+ mmcqd/0-82 [000] ...1 65.104234: mmc_blk_erase_start: cmd=3,addr=0x005856b8,size=0x00000948
+ mmcqd/0-82 [000] ...1 65.105273: mmc_blk_erase_end: cmd=3,addr=0x005856b8,size=0x00000948
+ mmcqd/0-82 [000] ...1 65.105341: mmc_blk_erase_start: cmd=3,addr=0x005866c0,size=0x00000e30
+ mmcqd/0-82 [000] ...1 65.106438: mmc_blk_erase_end: cmd=3,addr=0x005866c0,size=0x00000e30
+ mmcqd/0-82 [000] ...1 65.106524: mmc_blk_erase_start: cmd=3,addr=0x00587508,size=0x00000800
+ mmcqd/0-82 [000] ...1 65.108103: mmc_blk_erase_end: cmd=3,addr=0x00587508,size=0x00000800
+ mmcqd/0-82 [000] ...1 65.108179: mmc_blk_erase_start: cmd=3,addr=0x00587d68,size=0x0003a298
+ mmcqd/0-82 [000] ...1 65.118631: mmc_blk_erase_end: cmd=3,addr=0x00587d68,size=0x0003a298
+ mmcqd/0-82 [000] ...1 65.121820: mmc_blk_rw_start: cmd=18,addr=0x005c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.121982: mmc_blk_rw_end: cmd=18,addr=0x005c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.122166: mmc_blk_erase_start: cmd=3,addr=0x005c3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.134174: mmc_blk_erase_end: cmd=3,addr=0x005c3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.137513: mmc_blk_rw_start: cmd=18,addr=0x00602000,size=0x00000008
+ <idle>-0 [000] ..s3 65.137675: mmc_blk_rw_end: cmd=18,addr=0x00602000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.137858: mmc_blk_erase_start: cmd=3,addr=0x00602ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.149874: mmc_blk_erase_end: cmd=3,addr=0x00602ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.153212: mmc_blk_rw_start: cmd=18,addr=0x00642000,size=0x00000008
+ <idle>-0 [000] ..s3 65.153374: mmc_blk_rw_end: cmd=18,addr=0x00642000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.153556: mmc_blk_erase_start: cmd=3,addr=0x00642ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.165578: mmc_blk_erase_end: cmd=3,addr=0x00642ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.169139: mmc_blk_rw_start: cmd=18,addr=0x00682000,size=0x00000008
+ <idle>-0 [000] ..s3 65.169302: mmc_blk_rw_end: cmd=18,addr=0x00682000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.169483: mmc_blk_erase_start: cmd=3,addr=0x00682ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.181507: mmc_blk_erase_end: cmd=3,addr=0x00682ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.185105: mmc_blk_rw_start: cmd=18,addr=0x006c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.185267: mmc_blk_rw_end: cmd=18,addr=0x006c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.185450: mmc_blk_erase_start: cmd=3,addr=0x006c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.204743: mmc_blk_erase_end: cmd=3,addr=0x006c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.208326: mmc_blk_rw_start: cmd=18,addr=0x00702000,size=0x00000008
+ <idle>-0 [000] ..s3 65.208489: mmc_blk_rw_end: cmd=18,addr=0x00702000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.208671: mmc_blk_erase_start: cmd=3,addr=0x00703180,size=0x0003ee80
+ mmcqd/0-82 [000] ...1 65.220673: mmc_blk_erase_end: cmd=3,addr=0x00703180,size=0x0003ee80
+ mmcqd/0-82 [000] ...1 65.224277: mmc_blk_rw_start: cmd=18,addr=0x00742000,size=0x00000008
+ <idle>-0 [000] ..s3 65.224440: mmc_blk_rw_end: cmd=18,addr=0x00742000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.224623: mmc_blk_erase_start: cmd=3,addr=0x00743098,size=0x0003ef68
+ mmcqd/0-82 [000] ...1 65.236666: mmc_blk_erase_end: cmd=3,addr=0x00743098,size=0x0003ef68
+ mmcqd/0-82 [000] ...1 65.240177: mmc_blk_rw_start: cmd=18,addr=0x00782000,size=0x00000008
+ <idle>-0 [000] ..s3 65.240340: mmc_blk_rw_end: cmd=18,addr=0x00782000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.240521: mmc_blk_erase_start: cmd=3,addr=0x00783000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.252559: mmc_blk_erase_end: cmd=3,addr=0x00783000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.256080: mmc_blk_rw_start: cmd=18,addr=0x007c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.256241: mmc_blk_rw_end: cmd=18,addr=0x007c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.256423: mmc_blk_erase_start: cmd=3,addr=0x007c30d0,size=0x0003ef30
+ mmcqd/0-82 [000] ...1 65.268445: mmc_blk_erase_end: cmd=3,addr=0x007c30d0,size=0x0003ef30
+ mmcqd/0-82 [000] ...1 65.271804: mmc_blk_rw_start: cmd=18,addr=0x00802000,size=0x00000008
+ <idle>-0 [000] ..s3 65.271968: mmc_blk_rw_end: cmd=18,addr=0x00802000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.272151: mmc_blk_erase_start: cmd=3,addr=0x00803010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.284198: mmc_blk_erase_end: cmd=3,addr=0x00803010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.287616: mmc_blk_rw_start: cmd=18,addr=0x00842000,size=0x00000008
+ <idle>-0 [000] ..s3 65.287778: mmc_blk_rw_end: cmd=18,addr=0x00842000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.287959: mmc_blk_erase_start: cmd=3,addr=0x00842ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.299984: mmc_blk_erase_end: cmd=3,addr=0x00842ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.303613: mmc_blk_rw_start: cmd=18,addr=0x00882000,size=0x00000008
+ <idle>-0 [000] ..s3 65.303775: mmc_blk_rw_end: cmd=18,addr=0x00882000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.303957: mmc_blk_erase_start: cmd=3,addr=0x00882ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.316036: mmc_blk_erase_end: cmd=3,addr=0x00882ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.319544: mmc_blk_rw_start: cmd=18,addr=0x008c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.319756: mmc_blk_rw_end: cmd=18,addr=0x008c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.320008: mmc_blk_erase_start: cmd=3,addr=0x008c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.332066: mmc_blk_erase_end: cmd=3,addr=0x008c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.335494: mmc_blk_rw_start: cmd=18,addr=0x00903ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.335656: mmc_blk_rw_end: cmd=18,addr=0x00903ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.335841: mmc_blk_erase_start: cmd=3,addr=0x00904ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.347297: mmc_blk_erase_end: cmd=3,addr=0x00904ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.350772: mmc_blk_rw_start: cmd=18,addr=0x00942000,size=0x00000008
+ <idle>-0 [000] ..s3 65.350934: mmc_blk_rw_end: cmd=18,addr=0x00942000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.351115: mmc_blk_erase_start: cmd=3,addr=0x00942ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.363095: mmc_blk_erase_end: cmd=3,addr=0x00942ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.366656: mmc_blk_rw_start: cmd=18,addr=0x00983ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.366818: mmc_blk_rw_end: cmd=18,addr=0x00983ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.366999: mmc_blk_erase_start: cmd=3,addr=0x00984ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.378413: mmc_blk_erase_end: cmd=3,addr=0x00984ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.381966: mmc_blk_rw_start: cmd=18,addr=0x009c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.382127: mmc_blk_rw_end: cmd=18,addr=0x009c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.382310: mmc_blk_erase_start: cmd=3,addr=0x009c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.394379: mmc_blk_erase_end: cmd=3,addr=0x009c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.397815: mmc_blk_rw_start: cmd=18,addr=0x00a02000,size=0x00000008
+ <idle>-0 [000] ..s3 65.397978: mmc_blk_rw_end: cmd=18,addr=0x00a02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.398162: mmc_blk_erase_start: cmd=3,addr=0x00a02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.410211: mmc_blk_erase_end: cmd=3,addr=0x00a02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.413546: mmc_blk_rw_start: cmd=18,addr=0x00a42000,size=0x00000008
+ <idle>-0 [000] ..s3 65.413708: mmc_blk_rw_end: cmd=18,addr=0x00a42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.413888: mmc_blk_erase_start: cmd=3,addr=0x00a42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.425781: mmc_blk_erase_end: cmd=3,addr=0x00a42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.429337: mmc_blk_rw_start: cmd=18,addr=0x00a82000,size=0x00000008
+ <idle>-0 [000] ..s3 65.429499: mmc_blk_rw_end: cmd=18,addr=0x00a82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.429680: mmc_blk_erase_start: cmd=3,addr=0x00a82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.441736: mmc_blk_erase_end: cmd=3,addr=0x00a82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.445303: mmc_blk_rw_start: cmd=18,addr=0x00ac2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.445465: mmc_blk_rw_end: cmd=18,addr=0x00ac2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.445648: mmc_blk_erase_start: cmd=3,addr=0x00ac2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.457715: mmc_blk_erase_end: cmd=3,addr=0x00ac2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.461193: mmc_blk_rw_start: cmd=18,addr=0x00b02000,size=0x00000008
+ <idle>-0 [000] ..s3 65.461405: mmc_blk_rw_end: cmd=18,addr=0x00b02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.461664: mmc_blk_erase_start: cmd=3,addr=0x00b02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.473758: mmc_blk_erase_end: cmd=3,addr=0x00b02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.477284: mmc_blk_erase_start: cmd=3,addr=0x00b43010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.489346: mmc_blk_erase_end: cmd=3,addr=0x00b43010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.492611: mmc_blk_erase_start: cmd=3,addr=0x00b83100,size=0x00000f00
+ mmcqd/0-82 [000] ...1 65.493769: mmc_blk_erase_end: cmd=3,addr=0x00b83100,size=0x00000f00
+ mmcqd/0-82 [000] ...1 65.493857: mmc_blk_erase_start: cmd=3,addr=0x00b85c30,size=0x00000480
+ mmcqd/0-82 [000] ...1 65.494702: mmc_blk_erase_end: cmd=3,addr=0x00b85c30,size=0x00000480
+ mmcqd/0-82 [000] ...1 65.494754: mmc_blk_erase_start: cmd=3,addr=0x00b86160,size=0x00000fa0
+ mmcqd/0-82 [000] ...1 65.495904: mmc_blk_erase_end: cmd=3,addr=0x00b86160,size=0x00000fa0
+ mmcqd/0-82 [000] ...1 65.495991: mmc_blk_erase_start: cmd=3,addr=0x00b872a8,size=0x00000e00
+ mmcqd/0-82 [000] ...1 65.497626: mmc_blk_erase_end: cmd=3,addr=0x00b872a8,size=0x00000e00
+ mmcqd/0-82 [000] ...1 65.497708: mmc_blk_erase_start: cmd=3,addr=0x00b88278,size=0x00001078
+ mmcqd/0-82 [000] ...1 65.498870: mmc_blk_erase_end: cmd=3,addr=0x00b88278,size=0x00001078
+ mmcqd/0-82 [000] ...1 65.498961: mmc_blk_erase_start: cmd=3,addr=0x00b89320,size=0x000016e8
+ mmcqd/0-82 [000] ...1 65.500863: mmc_blk_erase_end: cmd=3,addr=0x00b89320,size=0x000016e8
+ mmcqd/0-82 [000] ...1 65.500975: mmc_blk_erase_start: cmd=3,addr=0x00b8aa28,size=0x00000660
+ mmcqd/0-82 [000] ...1 65.502494: mmc_blk_erase_end: cmd=3,addr=0x00b8aa28,size=0x00000660
+ mmcqd/0-82 [000] ...1 65.502552: mmc_blk_erase_start: cmd=3,addr=0x00b8b108,size=0x00000f60
+ mmcqd/0-82 [000] ...1 65.504262: mmc_blk_erase_end: cmd=3,addr=0x00b8b108,size=0x00000f60
+ mmcqd/0-82 [000] ...1 65.504350: mmc_blk_erase_start: cmd=3,addr=0x00b8c138,size=0x00000f88
+ mmcqd/0-82 [000] ...1 65.505501: mmc_blk_erase_end: cmd=3,addr=0x00b8c138,size=0x00000f88
+ mmcqd/0-82 [000] ...1 65.505588: mmc_blk_erase_start: cmd=3,addr=0x00b8d0e0,size=0x00000fd0
+ mmcqd/0-82 [000] ...1 65.506685: mmc_blk_erase_end: cmd=3,addr=0x00b8d0e0,size=0x00000fd0
+ mmcqd/0-82 [000] ...1 65.506776: mmc_blk_erase_start: cmd=3,addr=0x00b8e0f8,size=0x00000f70
+ mmcqd/0-82 [000] ...1 65.508408: mmc_blk_erase_end: cmd=3,addr=0x00b8e0f8,size=0x00000f70
+ mmcqd/0-82 [000] ...1 65.508496: mmc_blk_erase_start: cmd=3,addr=0x00b8f070,size=0x00001770
+ mmcqd/0-82 [000] ...1 65.509835: mmc_blk_erase_end: cmd=3,addr=0x00b8f070,size=0x00001770
+ mmcqd/0-82 [000] ...1 65.509946: mmc_blk_erase_start: cmd=3,addr=0x00b907f0,size=0x00000870
+ mmcqd/0-82 [000] ...1 65.510983: mmc_blk_erase_end: cmd=3,addr=0x00b907f0,size=0x00000870
+ mmcqd/0-82 [000] ...1 65.511048: mmc_blk_erase_start: cmd=3,addr=0x00b914c0,size=0x00000d28
+ mmcqd/0-82 [000] ...1 65.512622: mmc_blk_erase_end: cmd=3,addr=0x00b914c0,size=0x00000d28
+ mmcqd/0-82 [000] ...1 65.512701: mmc_blk_erase_start: cmd=3,addr=0x00b921f0,size=0x00000e88
+ mmcqd/0-82 [000] ...1 65.514392: mmc_blk_erase_end: cmd=3,addr=0x00b921f0,size=0x00000e88
+ mmcqd/0-82 [000] ...1 65.514482: mmc_blk_erase_start: cmd=3,addr=0x00b930d0,size=0x00000fd8
+ mmcqd/0-82 [000] ...1 65.516232: mmc_blk_erase_end: cmd=3,addr=0x00b930d0,size=0x00000fd8
+ mmcqd/0-82 [000] ...1 65.516320: mmc_blk_erase_start: cmd=3,addr=0x00b940e0,size=0x00001048
+ mmcqd/0-82 [000] ...1 65.518068: mmc_blk_erase_end: cmd=3,addr=0x00b940e0,size=0x00001048
+ mmcqd/0-82 [000] ...1 65.518158: mmc_blk_erase_start: cmd=3,addr=0x00b95130,size=0x00000fa8
+ mmcqd/0-82 [000] ...1 65.519867: mmc_blk_erase_end: cmd=3,addr=0x00b95130,size=0x00000fa8
+ mmcqd/0-82 [000] ...1 65.519954: mmc_blk_erase_start: cmd=3,addr=0x00b962e0,size=0x000004b8
+ mmcqd/0-82 [000] ...1 65.521465: mmc_blk_erase_end: cmd=3,addr=0x00b962e0,size=0x000004b8
+ mmcqd/0-82 [000] ...1 65.521517: mmc_blk_erase_start: cmd=3,addr=0x00b96840,size=0x000008f0
+ mmcqd/0-82 [000] ...1 65.522552: mmc_blk_erase_end: cmd=3,addr=0x00b96840,size=0x000008f0
+ mmcqd/0-82 [000] ...1 65.522618: mmc_blk_erase_start: cmd=3,addr=0x00b97458,size=0x00000ba8
+ mmcqd/0-82 [000] ...1 65.523659: mmc_blk_erase_end: cmd=3,addr=0x00b97458,size=0x00000ba8
+ mmcqd/0-82 [000] ...1 65.523745: mmc_blk_erase_start: cmd=3,addr=0x00b9a000,size=0x00028000
+ mmcqd/0-82 [000] ...1 65.528268: mmc_blk_erase_end: cmd=3,addr=0x00b9a000,size=0x00028000
+ mmcqd/0-82 [000] ...1 65.530508: mmc_blk_rw_start: cmd=18,addr=0x00bc2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.530669: mmc_blk_rw_end: cmd=18,addr=0x00bc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.530852: mmc_blk_erase_start: cmd=3,addr=0x00bc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.542925: mmc_blk_erase_end: cmd=3,addr=0x00bc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.546510: mmc_blk_rw_start: cmd=18,addr=0x00c02000,size=0x00000008
+ <idle>-0 [000] ..s3 65.546673: mmc_blk_rw_end: cmd=18,addr=0x00c02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.546729: mmc_blk_rw_start: cmd=25,addr=0x002c6a98,size=0x00000058
+ <idle>-0 [000] ..s3 65.547168: mmc_blk_rw_end: cmd=25,addr=0x002c6a98,size=0x00000058
+ mmcqd/0-82 [000] ...1 65.547855: mmc_blk_rw_start: cmd=25,addr=0x002c6af0,size=0x00000008
+ <idle>-0 [000] ..s3 65.547938: mmc_blk_rw_end: cmd=25,addr=0x002c6af0,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.548643: mmc_blk_erase_start: cmd=3,addr=0x00c02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.560697: mmc_blk_erase_end: cmd=3,addr=0x00c02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.564290: mmc_blk_rw_start: cmd=18,addr=0x00c42000,size=0x00000008
+ <idle>-0 [000] ..s3 65.564452: mmc_blk_rw_end: cmd=18,addr=0x00c42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.564635: mmc_blk_erase_start: cmd=3,addr=0x00c42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.576689: mmc_blk_erase_end: cmd=3,addr=0x00c42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.580050: mmc_blk_rw_start: cmd=18,addr=0x00c82000,size=0x00000008
+ <idle>-0 [000] ..s3 65.580211: mmc_blk_rw_end: cmd=18,addr=0x00c82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.580392: mmc_blk_erase_start: cmd=3,addr=0x00c82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.593009: mmc_blk_erase_end: cmd=3,addr=0x00c82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.596373: mmc_blk_rw_start: cmd=18,addr=0x00cc2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.596537: mmc_blk_rw_end: cmd=18,addr=0x00cc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.596719: mmc_blk_erase_start: cmd=3,addr=0x00cc3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.609463: mmc_blk_erase_end: cmd=3,addr=0x00cc3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 65.612802: mmc_blk_rw_start: cmd=18,addr=0x00d02000,size=0x00000008
+ <idle>-0 [000] ..s3 65.612963: mmc_blk_rw_end: cmd=18,addr=0x00d02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.613147: mmc_blk_erase_start: cmd=3,addr=0x00d02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.625991: mmc_blk_erase_end: cmd=3,addr=0x00d02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.629539: mmc_blk_rw_start: cmd=18,addr=0x00d42000,size=0x00000008
+ <idle>-0 [000] ..s3 65.629700: mmc_blk_rw_end: cmd=18,addr=0x00d42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.629879: mmc_blk_erase_start: cmd=3,addr=0x00d42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.642728: mmc_blk_erase_end: cmd=3,addr=0x00d42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.646085: mmc_blk_rw_start: cmd=18,addr=0x00d82000,size=0x00000008
+ <idle>-0 [000] ..s3 65.646246: mmc_blk_rw_end: cmd=18,addr=0x00d82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.646428: mmc_blk_erase_start: cmd=3,addr=0x00d82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.659272: mmc_blk_erase_end: cmd=3,addr=0x00d82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.662916: mmc_blk_rw_start: cmd=18,addr=0x00dc2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.663083: mmc_blk_rw_end: cmd=18,addr=0x00dc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.663297: mmc_blk_erase_start: cmd=3,addr=0x00dc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.676145: mmc_blk_erase_end: cmd=3,addr=0x00dc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.679765: mmc_blk_rw_start: cmd=18,addr=0x00e02000,size=0x00000008
+ <idle>-0 [000] ..s3 65.679928: mmc_blk_rw_end: cmd=18,addr=0x00e02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.680119: mmc_blk_erase_start: cmd=3,addr=0x00e02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.692956: mmc_blk_erase_end: cmd=3,addr=0x00e02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.696314: mmc_blk_rw_start: cmd=18,addr=0x00e42000,size=0x00000008
+ <idle>-0 [000] ..s3 65.696476: mmc_blk_rw_end: cmd=18,addr=0x00e42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.696658: mmc_blk_erase_start: cmd=3,addr=0x00e42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.709458: mmc_blk_erase_end: cmd=3,addr=0x00e42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.712997: mmc_blk_rw_start: cmd=18,addr=0x00e82000,size=0x00000008
+ <idle>-0 [000] ..s3 65.713159: mmc_blk_rw_end: cmd=18,addr=0x00e82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.713339: mmc_blk_erase_start: cmd=3,addr=0x00e82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.726167: mmc_blk_erase_end: cmd=3,addr=0x00e82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.729808: mmc_blk_rw_start: cmd=18,addr=0x00ec2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.729969: mmc_blk_rw_end: cmd=18,addr=0x00ec2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.730151: mmc_blk_erase_start: cmd=3,addr=0x00ec2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.742962: mmc_blk_erase_end: cmd=3,addr=0x00ec2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.746523: mmc_blk_rw_start: cmd=18,addr=0x00f03ac8,size=0x00000008
+ <idle>-0 [000] ..s3 65.746736: mmc_blk_rw_end: cmd=18,addr=0x00f03ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.746997: mmc_blk_erase_start: cmd=3,addr=0x00f04ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.759333: mmc_blk_erase_end: cmd=3,addr=0x00f04ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 65.762585: mmc_blk_rw_start: cmd=18,addr=0x00f42000,size=0x00000008
+ <idle>-0 [000] ..s3 65.762746: mmc_blk_rw_end: cmd=18,addr=0x00f42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.762928: mmc_blk_erase_start: cmd=3,addr=0x00f42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.775775: mmc_blk_erase_end: cmd=3,addr=0x00f42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.779190: mmc_blk_rw_start: cmd=18,addr=0x00f82000,size=0x00000008
+ <idle>-0 [000] ..s3 65.779354: mmc_blk_rw_end: cmd=18,addr=0x00f82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.779536: mmc_blk_erase_start: cmd=3,addr=0x00f83008,size=0x0003eff8
+ mmcqd/0-82 [000] ...1 65.792334: mmc_blk_erase_end: cmd=3,addr=0x00f83008,size=0x0003eff8
+ mmcqd/0-82 [000] ...1 65.795718: mmc_blk_rw_start: cmd=18,addr=0x00fc2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.795880: mmc_blk_rw_end: cmd=18,addr=0x00fc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.796061: mmc_blk_erase_start: cmd=3,addr=0x00fc3010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.808910: mmc_blk_erase_end: cmd=3,addr=0x00fc3010,size=0x0003eff0
+ mmcqd/0-82 [000] ...1 65.812397: mmc_blk_rw_start: cmd=18,addr=0x01002000,size=0x00000008
+ <idle>-0 [000] ..s3 65.812559: mmc_blk_rw_end: cmd=18,addr=0x01002000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.812741: mmc_blk_erase_start: cmd=3,addr=0x01002ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.825541: mmc_blk_erase_end: cmd=3,addr=0x01002ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.828878: mmc_blk_rw_start: cmd=18,addr=0x01042000,size=0x00000008
+ <idle>-0 [000] ..s3 65.829040: mmc_blk_rw_end: cmd=18,addr=0x01042000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.829243: mmc_blk_erase_start: cmd=3,addr=0x01042ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.848483: mmc_blk_erase_end: cmd=3,addr=0x01042ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.852064: mmc_blk_rw_start: cmd=18,addr=0x01082000,size=0x00000008
+ <idle>-0 [000] ..s3 65.852225: mmc_blk_rw_end: cmd=18,addr=0x01082000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.852405: mmc_blk_erase_start: cmd=3,addr=0x01082ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.865241: mmc_blk_erase_end: cmd=3,addr=0x01082ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.868741: mmc_blk_rw_start: cmd=18,addr=0x010c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.868903: mmc_blk_rw_end: cmd=18,addr=0x010c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.869104: mmc_blk_erase_start: cmd=3,addr=0x010c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.881967: mmc_blk_erase_end: cmd=3,addr=0x010c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.885518: mmc_blk_rw_start: cmd=18,addr=0x01102000,size=0x00000008
+ <idle>-0 [000] ..s3 65.885679: mmc_blk_rw_end: cmd=18,addr=0x01102000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.885861: mmc_blk_erase_start: cmd=3,addr=0x01102ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.898719: mmc_blk_erase_end: cmd=3,addr=0x01102ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.902088: mmc_blk_rw_start: cmd=18,addr=0x01142000,size=0x00000008
+ <idle>-0 [000] ..s3 65.902250: mmc_blk_rw_end: cmd=18,addr=0x01142000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.902431: mmc_blk_erase_start: cmd=3,addr=0x01142ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.915275: mmc_blk_erase_end: cmd=3,addr=0x01142ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.918619: mmc_blk_rw_start: cmd=18,addr=0x01182000,size=0x00000008
+ <idle>-0 [000] ..s3 65.918781: mmc_blk_rw_end: cmd=18,addr=0x01182000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.918963: mmc_blk_erase_start: cmd=3,addr=0x01182ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.931861: mmc_blk_erase_end: cmd=3,addr=0x01182ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.935374: mmc_blk_rw_start: cmd=18,addr=0x011c2000,size=0x00000008
+ <idle>-0 [000] ..s3 65.935536: mmc_blk_rw_end: cmd=18,addr=0x011c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.935718: mmc_blk_erase_start: cmd=3,addr=0x011c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.948584: mmc_blk_erase_end: cmd=3,addr=0x011c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.952113: mmc_blk_rw_start: cmd=18,addr=0x01202000,size=0x00000008
+ <idle>-0 [000] ..s3 65.952275: mmc_blk_rw_end: cmd=18,addr=0x01202000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.952457: mmc_blk_erase_start: cmd=3,addr=0x01202ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.965256: mmc_blk_erase_end: cmd=3,addr=0x01202ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.968807: mmc_blk_rw_start: cmd=18,addr=0x01242000,size=0x00000008
+ <idle>-0 [000] ..s3 65.968969: mmc_blk_rw_end: cmd=18,addr=0x01242000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.969174: mmc_blk_erase_start: cmd=3,addr=0x01242ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.982055: mmc_blk_erase_end: cmd=3,addr=0x01242ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.985654: mmc_blk_rw_start: cmd=18,addr=0x01282000,size=0x00000008
+ <idle>-0 [000] ..s3 65.985816: mmc_blk_rw_end: cmd=18,addr=0x01282000,size=0x00000008
+ mmcqd/0-82 [000] ...1 65.985994: mmc_blk_erase_start: cmd=3,addr=0x01282ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 65.998829: mmc_blk_erase_end: cmd=3,addr=0x01282ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.002211: mmc_blk_rw_start: cmd=18,addr=0x012c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.002372: mmc_blk_rw_end: cmd=18,addr=0x012c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.002549: mmc_blk_erase_start: cmd=3,addr=0x012c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.015395: mmc_blk_erase_end: cmd=3,addr=0x012c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.018738: mmc_blk_rw_start: cmd=18,addr=0x01302000,size=0x00000008
+ <idle>-0 [000] ..s3 66.018899: mmc_blk_rw_end: cmd=18,addr=0x01302000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.019109: mmc_blk_erase_start: cmd=3,addr=0x01302ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.031822: mmc_blk_erase_end: cmd=3,addr=0x01302ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.035182: mmc_blk_rw_start: cmd=18,addr=0x01342000,size=0x00000008
+ <idle>-0 [000] ..s3 66.035344: mmc_blk_rw_end: cmd=18,addr=0x01342000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.035526: mmc_blk_erase_start: cmd=3,addr=0x01342ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.048386: mmc_blk_erase_end: cmd=3,addr=0x01342ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.051777: mmc_blk_rw_start: cmd=18,addr=0x01382000,size=0x00000008
+ <idle>-0 [000] ..s3 66.051938: mmc_blk_rw_end: cmd=18,addr=0x01382000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.052119: mmc_blk_erase_start: cmd=3,addr=0x01382ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.064933: mmc_blk_erase_end: cmd=3,addr=0x01382ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.068266: mmc_blk_rw_start: cmd=18,addr=0x013c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.068428: mmc_blk_rw_end: cmd=18,addr=0x013c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.068610: mmc_blk_erase_start: cmd=3,addr=0x013c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.081409: mmc_blk_erase_end: cmd=3,addr=0x013c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.084838: mmc_blk_rw_start: cmd=18,addr=0x01402000,size=0x00000008
+ <idle>-0 [000] ..s3 66.085004: mmc_blk_rw_end: cmd=18,addr=0x01402000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.085192: mmc_blk_erase_start: cmd=3,addr=0x01403000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.097986: mmc_blk_erase_end: cmd=3,addr=0x01403000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.101443: mmc_blk_rw_start: cmd=18,addr=0x01442000,size=0x00000008
+ <idle>-0 [000] ..s3 66.101605: mmc_blk_rw_end: cmd=18,addr=0x01442000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.101787: mmc_blk_erase_start: cmd=3,addr=0x01442ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.114633: mmc_blk_erase_end: cmd=3,addr=0x01442ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.118042: mmc_blk_rw_start: cmd=18,addr=0x01482000,size=0x00000008
+ <idle>-0 [000] ..s3 66.118204: mmc_blk_rw_end: cmd=18,addr=0x01482000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.118386: mmc_blk_erase_start: cmd=3,addr=0x01482ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.131232: mmc_blk_erase_end: cmd=3,addr=0x01482ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.134684: mmc_blk_rw_start: cmd=18,addr=0x014c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.134845: mmc_blk_rw_end: cmd=18,addr=0x014c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.135026: mmc_blk_erase_start: cmd=3,addr=0x014c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.147837: mmc_blk_erase_end: cmd=3,addr=0x014c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.151424: mmc_blk_rw_start: cmd=18,addr=0x01502000,size=0x00000008
+ <idle>-0 [000] ..s3 66.151586: mmc_blk_rw_end: cmd=18,addr=0x01502000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.151768: mmc_blk_erase_start: cmd=3,addr=0x01502ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.164628: mmc_blk_erase_end: cmd=3,addr=0x01502ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.167964: mmc_blk_rw_start: cmd=18,addr=0x01542000,size=0x00000008
+ <idle>-0 [000] ..s3 66.168125: mmc_blk_rw_end: cmd=18,addr=0x01542000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.168300: mmc_blk_erase_start: cmd=3,addr=0x01542ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.181084: mmc_blk_erase_end: cmd=3,addr=0x01542ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.184504: mmc_blk_rw_start: cmd=18,addr=0x01582000,size=0x00000008
+ <idle>-0 [000] ..s3 66.184666: mmc_blk_rw_end: cmd=18,addr=0x01582000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.184837: mmc_blk_erase_start: cmd=3,addr=0x01582ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.197739: mmc_blk_erase_end: cmd=3,addr=0x01582ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.201126: mmc_blk_erase_start: cmd=3,addr=0x015c3008,size=0x0003eff8
+ mmcqd/0-82 [000] ...1 66.213978: mmc_blk_erase_end: cmd=3,addr=0x015c3008,size=0x0003eff8
+ mmcqd/0-82 [000] ...1 66.217400: mmc_blk_rw_start: cmd=18,addr=0x01602000,size=0x00000008
+ <idle>-0 [000] ..s3 66.217565: mmc_blk_rw_end: cmd=18,addr=0x01602000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.217746: mmc_blk_erase_start: cmd=3,addr=0x01603000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.230570: mmc_blk_erase_end: cmd=3,addr=0x01603000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.233942: mmc_blk_rw_start: cmd=18,addr=0x01642000,size=0x00000008
+ <idle>-0 [000] ..s3 66.234107: mmc_blk_rw_end: cmd=18,addr=0x01642000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.234290: mmc_blk_erase_start: cmd=3,addr=0x01642ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.247107: mmc_blk_erase_end: cmd=3,addr=0x01642ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.250616: mmc_blk_rw_start: cmd=18,addr=0x01682000,size=0x00000008
+ <idle>-0 [000] ..s3 66.250778: mmc_blk_rw_end: cmd=18,addr=0x01682000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.250962: mmc_blk_erase_start: cmd=3,addr=0x01682ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.263787: mmc_blk_erase_end: cmd=3,addr=0x01682ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.267219: mmc_blk_rw_start: cmd=18,addr=0x016c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.267380: mmc_blk_rw_end: cmd=18,addr=0x016c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.267561: mmc_blk_erase_start: cmd=3,addr=0x016c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.280363: mmc_blk_erase_end: cmd=3,addr=0x016c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.283772: mmc_blk_rw_start: cmd=18,addr=0x01703ac8,size=0x00000008
+ <idle>-0 [000] ..s3 66.283934: mmc_blk_rw_end: cmd=18,addr=0x01703ac8,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.284146: mmc_blk_erase_start: cmd=3,addr=0x01704ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 66.296455: mmc_blk_erase_end: cmd=3,addr=0x01704ac0,size=0x0003d540
+ mmcqd/0-82 [000] ...1 66.299826: mmc_blk_rw_start: cmd=18,addr=0x01742000,size=0x00000008
+ <idle>-0 [000] ..s3 66.299991: mmc_blk_rw_end: cmd=18,addr=0x01742000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.300172: mmc_blk_erase_start: cmd=3,addr=0x01743000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.313018: mmc_blk_erase_end: cmd=3,addr=0x01743000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.316476: mmc_blk_rw_start: cmd=18,addr=0x01782000,size=0x00000008
+ <idle>-0 [000] ..s3 66.316641: mmc_blk_rw_end: cmd=18,addr=0x01782000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.316869: mmc_blk_erase_start: cmd=3,addr=0x01783000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.329795: mmc_blk_erase_end: cmd=3,addr=0x01783000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.333305: mmc_blk_rw_start: cmd=18,addr=0x017c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.333470: mmc_blk_rw_end: cmd=18,addr=0x017c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.333653: mmc_blk_erase_start: cmd=3,addr=0x017c3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.346485: mmc_blk_erase_end: cmd=3,addr=0x017c3000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.349946: mmc_blk_rw_start: cmd=18,addr=0x01802000,size=0x00000008
+ <idle>-0 [000] ..s3 66.350111: mmc_blk_rw_end: cmd=18,addr=0x01802000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.350294: mmc_blk_erase_start: cmd=3,addr=0x01803020,size=0x0003efe0
+ mmcqd/0-82 [000] ...1 66.363089: mmc_blk_erase_end: cmd=3,addr=0x01803020,size=0x0003efe0
+ mmcqd/0-82 [000] ...1 66.366450: mmc_blk_rw_start: cmd=18,addr=0x01842000,size=0x00000008
+ <idle>-0 [000] ..s3 66.366611: mmc_blk_rw_end: cmd=18,addr=0x01842000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.366793: mmc_blk_erase_start: cmd=3,addr=0x01842ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.379653: mmc_blk_erase_end: cmd=3,addr=0x01842ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.382987: mmc_blk_rw_start: cmd=18,addr=0x01882000,size=0x00000008
+ <idle>-0 [000] ..s3 66.383152: mmc_blk_rw_end: cmd=18,addr=0x01882000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.383334: mmc_blk_erase_start: cmd=3,addr=0x01883000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.396156: mmc_blk_erase_end: cmd=3,addr=0x01883000,size=0x0003f000
+ mmcqd/0-82 [000] ...1 66.399533: mmc_blk_rw_start: cmd=18,addr=0x018c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.399695: mmc_blk_rw_end: cmd=18,addr=0x018c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.399877: mmc_blk_erase_start: cmd=3,addr=0x018c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.412722: mmc_blk_erase_end: cmd=3,addr=0x018c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.416159: mmc_blk_rw_start: cmd=18,addr=0x01902000,size=0x00000008
+ <idle>-0 [000] ..s3 66.416321: mmc_blk_rw_end: cmd=18,addr=0x01902000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.416501: mmc_blk_erase_start: cmd=3,addr=0x01902ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.429352: mmc_blk_erase_end: cmd=3,addr=0x01902ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.432979: mmc_blk_rw_start: cmd=18,addr=0x01942000,size=0x00000008
+ <idle>-0 [000] ..s3 66.433141: mmc_blk_rw_end: cmd=18,addr=0x01942000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.433322: mmc_blk_erase_start: cmd=3,addr=0x01942ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.446157: mmc_blk_erase_end: cmd=3,addr=0x01942ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.449711: mmc_blk_rw_start: cmd=18,addr=0x01982000,size=0x00000008
+ <idle>-0 [000] ..s3 66.449872: mmc_blk_rw_end: cmd=18,addr=0x01982000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.450054: mmc_blk_erase_start: cmd=3,addr=0x01982ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.462903: mmc_blk_erase_end: cmd=3,addr=0x01982ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.466393: mmc_blk_rw_start: cmd=18,addr=0x019c2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.466555: mmc_blk_rw_end: cmd=18,addr=0x019c2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.466732: mmc_blk_erase_start: cmd=3,addr=0x019c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.479551: mmc_blk_erase_end: cmd=3,addr=0x019c2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.482884: mmc_blk_rw_start: cmd=18,addr=0x01a02000,size=0x00000008
+ <idle>-0 [000] ..s3 66.483045: mmc_blk_rw_end: cmd=18,addr=0x01a02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.483223: mmc_blk_erase_start: cmd=3,addr=0x01a02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.496041: mmc_blk_erase_end: cmd=3,addr=0x01a02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.499568: mmc_blk_rw_start: cmd=18,addr=0x01a42000,size=0x00000008
+ <idle>-0 [000] ..s3 66.499730: mmc_blk_rw_end: cmd=18,addr=0x01a42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.499915: mmc_blk_erase_start: cmd=3,addr=0x01a42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.512739: mmc_blk_erase_end: cmd=3,addr=0x01a42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.516246: mmc_blk_rw_start: cmd=18,addr=0x01a82000,size=0x00000008
+ <idle>-0 [000] ..s3 66.516408: mmc_blk_rw_end: cmd=18,addr=0x01a82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.516590: mmc_blk_erase_start: cmd=3,addr=0x01a82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.529394: mmc_blk_erase_end: cmd=3,addr=0x01a82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.532936: mmc_blk_rw_start: cmd=18,addr=0x01ac2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.533103: mmc_blk_rw_end: cmd=18,addr=0x01ac2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.533366: mmc_blk_erase_start: cmd=3,addr=0x01ac2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.551932: mmc_blk_erase_end: cmd=3,addr=0x01ac2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.555518: mmc_blk_rw_start: cmd=18,addr=0x01b02000,size=0x00000008
+ <idle>-0 [000] ..s3 66.555680: mmc_blk_rw_end: cmd=18,addr=0x01b02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.555864: mmc_blk_erase_start: cmd=3,addr=0x01b02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.568720: mmc_blk_erase_end: cmd=3,addr=0x01b02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.572289: mmc_blk_rw_start: cmd=18,addr=0x01b42000,size=0x00000008
+ <idle>-0 [000] ..s3 66.572452: mmc_blk_rw_end: cmd=18,addr=0x01b42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.572640: mmc_blk_erase_start: cmd=3,addr=0x01b42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.585472: mmc_blk_erase_end: cmd=3,addr=0x01b42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.589013: mmc_blk_rw_start: cmd=18,addr=0x01b82000,size=0x00000008
+ <idle>-0 [000] ..s3 66.589177: mmc_blk_rw_end: cmd=18,addr=0x01b82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.589361: mmc_blk_erase_start: cmd=3,addr=0x01b82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.602230: mmc_blk_erase_end: cmd=3,addr=0x01b82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.605811: mmc_blk_rw_start: cmd=18,addr=0x01bc2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.605978: mmc_blk_rw_end: cmd=18,addr=0x01bc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.606237: mmc_blk_erase_start: cmd=3,addr=0x01bc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.619123: mmc_blk_erase_end: cmd=3,addr=0x01bc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.622525: mmc_blk_rw_start: cmd=18,addr=0x01c02000,size=0x00000008
+ <idle>-0 [000] ..s3 66.622686: mmc_blk_rw_end: cmd=18,addr=0x01c02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.622869: mmc_blk_erase_start: cmd=3,addr=0x01c02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.635750: mmc_blk_erase_end: cmd=3,addr=0x01c02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.639180: mmc_blk_rw_start: cmd=18,addr=0x01c42000,size=0x00000008
+ <idle>-0 [000] ..s3 66.639341: mmc_blk_rw_end: cmd=18,addr=0x01c42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.639524: mmc_blk_erase_start: cmd=3,addr=0x01c42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.652365: mmc_blk_erase_end: cmd=3,addr=0x01c42ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.655886: mmc_blk_rw_start: cmd=18,addr=0x01c82000,size=0x00000008
+ <idle>-0 [000] ..s3 66.656047: mmc_blk_rw_end: cmd=18,addr=0x01c82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.656229: mmc_blk_erase_start: cmd=3,addr=0x01c82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.669069: mmc_blk_erase_end: cmd=3,addr=0x01c82ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.672492: mmc_blk_rw_start: cmd=18,addr=0x01cc2000,size=0x00000008
+ <idle>-0 [000] ..s3 66.672653: mmc_blk_rw_end: cmd=18,addr=0x01cc2000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.672835: mmc_blk_erase_start: cmd=3,addr=0x01cc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.685704: mmc_blk_erase_end: cmd=3,addr=0x01cc2ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.689362: mmc_blk_rw_start: cmd=18,addr=0x01d02000,size=0x00000008
+ <idle>-0 [000] ..s3 66.689523: mmc_blk_rw_end: cmd=18,addr=0x01d02000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.689706: mmc_blk_erase_start: cmd=3,addr=0x01d02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.702548: mmc_blk_erase_end: cmd=3,addr=0x01d02ff8,size=0x0003f008
+ mmcqd/0-82 [000] ...1 66.705996: mmc_blk_rw_start: cmd=18,addr=0x01d42000,size=0x00000008
+ <idle>-0 [000] ..s3 66.706158: mmc_blk_rw_end: cmd=18,addr=0x01d42000,size=0x00000008
+ mmcqd/0-82 [000] ...1 66.706330: mmc_blk_erase_start: cmd=3,addr=0x01d42ff8,size=0x00015008
+ mmcqd/0-82 [000] ...1 66.714103: mmc_blk_erase_end: cmd=3,addr=0x01d42ff8,size=0x00015008
+ mmcqd/0-82 [000] ...1 67.055083: mmc_blk_rw_start: cmd=25,addr=0x00346400,size=0x00000008
+ mmcqd/0-82 [000] ..s3 67.055305: mmc_blk_rw_end: cmd=25,addr=0x00346400,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.055236: mmc_blk_rw_start: cmd=25,addr=0x00542008,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.055404: mmc_blk_rw_end: cmd=25,addr=0x00542008,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.056094: mmc_blk_rw_start: cmd=25,addr=0x005420c0,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.056225: mmc_blk_rw_end: cmd=25,addr=0x005420c0,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.056859: mmc_blk_rw_start: cmd=25,addr=0x005420d0,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.056987: mmc_blk_rw_end: cmd=25,addr=0x005420d0,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.057657: mmc_blk_rw_start: cmd=25,addr=0x00542118,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.057785: mmc_blk_rw_end: cmd=25,addr=0x00542118,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.058561: mmc_blk_rw_start: cmd=25,addr=0x00542128,size=0x00000008
+ mmcqd/0-82 [000] ..s2 72.058755: mmc_blk_rw_end: cmd=25,addr=0x00542128,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.059645: mmc_blk_rw_start: cmd=25,addr=0x00542140,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.059835: mmc_blk_rw_end: cmd=25,addr=0x00542140,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.060601: mmc_blk_rw_start: cmd=25,addr=0x00544198,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.060792: mmc_blk_rw_end: cmd=25,addr=0x00544198,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.061673: mmc_blk_rw_start: cmd=25,addr=0x00b82000,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.061865: mmc_blk_rw_end: cmd=25,addr=0x00b82000,size=0x00000008
+ mmcqd/0-82 [000] ...1 72.062756: mmc_blk_rw_start: cmd=25,addr=0x002c2000,size=0x00000010
+ mmcqd/0-82 [000] ..s3 72.063006: mmc_blk_rw_end: cmd=25,addr=0x002c2000,size=0x00000010
+ mmcqd/0-82 [000] ...1 72.525587: mmc_blk_rw_start: cmd=25,addr=0x002c6af8,size=0x00000008
+ mmcqd/0-82 [000] ..s3 72.525813: mmc_blk_rw_end: cmd=25,addr=0x002c6af8,size=0x00000008
+ mmcqd/0-82 [000] ...1 120.323646: mmc_blk_rw_start: cmd=25,addr=0x00b98140,size=0x00000008
+ Compiler-1337 [000] ..s4 120.323786: mmc_blk_rw_end: cmd=25,addr=0x00b98140,size=0x00000008
+ mmcqd/0-82 [000] ...1 120.326162: mmc_blk_rw_start: cmd=25,addr=0x002c6b00,size=0x00000048
+ <idle>-0 [000] ..s3 120.326635: mmc_blk_rw_end: cmd=25,addr=0x002c6b00,size=0x00000048
+ mmcqd/0-82 [000] ...1 120.327595: mmc_blk_rw_start: cmd=25,addr=0x002c6b48,size=0x00000008
+ AsyncTask #1-777 [000] ..s3 120.327691: mmc_blk_rw_end: cmd=25,addr=0x002c6b48,size=0x00000008
+ mmcqd/0-82 [000] ...1 122.485441: mmc_blk_rw_start: cmd=25,addr=0x00b91298,size=0x00000008
+ mmcqd/0-82 [000] ..s2 122.485746: mmc_blk_rw_end: cmd=25,addr=0x00b91298,size=0x00000008
+ mmcqd/0-82 [000] ...1 122.486369: mmc_blk_rw_start: cmd=25,addr=0x00b914b0,size=0x00000010
+ mmcqd/0-82 [000] ..s2 122.486656: mmc_blk_rw_end: cmd=25,addr=0x00b914b0,size=0x00000010
+ mmcqd/0-82 [000] ...1 122.487231: mmc_blk_rw_start: cmd=25,addr=0x00542120,size=0x00000008
+ mmcqd/0-82 [000] ..s3 122.487473: mmc_blk_rw_end: cmd=25,addr=0x00542120,size=0x00000008
+ mmcqd/0-82 [000] ...1 125.545654: mmc_blk_rw_start: cmd=25,addr=0x002c6b50,size=0x00000048
+ <idle>-0 [000] ..s3 125.547111: mmc_blk_rw_end: cmd=25,addr=0x002c6b50,size=0x00000048
+ mmcqd/0-82 [000] ...1 125.550617: mmc_blk_rw_start: cmd=25,addr=0x002c6b98,size=0x00000008
+ <idle>-0 [000] ..s4 125.550855: mmc_blk_rw_end: cmd=25,addr=0x002c6b98,size=0x00000008
diff --git a/tests/uevents/Android.mk b/tests/uevents/Android.mk
new file mode 100644
index 00000000..f04b211c
--- /dev/null
+++ b/tests/uevents/Android.mk
@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := uevents.c
+
+LOCAL_SHARED_LIBRARIES += libcutils
+LOCAL_MODULE:= uevents
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_EXECUTABLE)
diff --git a/tests/uevents/uevents.c b/tests/uevents/uevents.c
new file mode 100644
index 00000000..1ca4cfee
--- /dev/null
+++ b/tests/uevents/uevents.c
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cutils/uevent.h>
+#include <stdio.h>
+
+#define UEVENT_MSG_LEN 1024
+
+int main(int argc, char *argv[])
+{
+ int device_fd;
+ char msg[UEVENT_MSG_LEN+2];
+ int n;
+ int i;
+
+ device_fd = uevent_open_socket(64*1024, true);
+ if(device_fd < 0)
+ return -1;
+
+ while ((n = uevent_kernel_multicast_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {
+ msg[n] = '\0';
+ msg[n+1] = '\0';
+
+ for (i = 0; i < n; i++)
+ if (msg[i] == '\0')
+ msg[i] = ' ';
+
+ printf("%s\n", msg);
+ }
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-23 20:40:03 +0000