am 49e5bca2: Merge "Remove fatblock and libublock."
* commit '49e5bca23f9759b9d75366a1f611249d6398a5e7':
Remove fatblock and libublock.
diff --git a/fatblock/Android.mk b/fatblock/Android.mk
deleted file mode 100644
index fb8d7bb..0000000
--- a/fatblock/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (C) 2010 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_MODULE := fatblock
-LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := fat.c fatblock.c fs.c import.c read.c utils.c fdpool.c
-LOCAL_C_INCLUDES := system/extras/libublock/include
-LOCAL_SHARED_LIBRARIES := libublock
-include $(BUILD_EXECUTABLE)
diff --git a/fatblock/MODULE_LICENSE_APACHE2 b/fatblock/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/fatblock/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/fatblock/fat.c b/fatblock/fat.c
deleted file mode 100644
index c549bc1..0000000
--- a/fatblock/fat.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <string.h>
-#include <endian.h>
-
-#include "fat.h"
-
-const char FAT_BOOT_SIG[] = { 0x55, 0xAA };
-const char FAT_INFO_SIG1[4] = { 'R', 'R', 'a', 'A' };
-const char FAT_INFO_SIG2[4] = { 'r', 'r', 'A', 'a' };
-
-void fat_dirent_set_first_cluster(struct fat_dirent *de, cluster_t cluster)
-{
- assert(de);
-
- de->first_cluster_hi = htole16((cluster >> 16) & 0xffff);
- de->first_cluster_lo = htole16((cluster >> 0) & 0xffff);
-}
-
-void fat_dirent_set(struct fat_dirent *de,
- char *name, uint8_t attr,
- cluster_t first_cluster, uint32_t size)
-{
- assert(de);
- assert(name);
-
- memset(de, 0, sizeof(*de));
-
- memcpy(de->name, name, 11);
- de->attr = attr;
- fat_dirent_set_first_cluster(de, first_cluster);
- de->size = htole32(size);
-}
diff --git a/fatblock/fat.h b/fatblock/fat.h
deleted file mode 100644
index 64c3a51..0000000
--- a/fatblock/fat.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2010 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 FAT_H
-#define FAT_H
-
-#include <stdint.h>
-
-#include "fatblock.h"
-
-typedef uint32_t cluster_t;
-typedef uint64_t sector_t;
-typedef cluster_t fat_entry_t;
-
-struct fat_boot_sector {
- uint8_t jump[3];
- char name[8];
- uint16_t sector_size;
- uint8_t sectors_per_cluster;
- uint16_t reserved_sectors;
- uint8_t fats;
- uint16_t rootdir_size;
- uint16_t sectors16;
- uint8_t media_desc;
- uint16_t fat_sectors16;
- uint16_t sectors_per_track;
- uint16_t heads;
- uint32_t hidden_sectors;
- uint32_t sectors32;
- uint32_t fat_sectors32;
- uint16_t fat_flags;
- uint16_t version;
- cluster_t rootdir_start;
- uint16_t fs_info_sector;
- uint16_t backup_boot_sector;
- uint8_t reserved1[12];
- uint8_t phys_drive;
- uint8_t reserved2;
- uint8_t ext_boot_sig;
- uint32_t serial;
- char vol_label[11];
- char type[8];
- char boot_code[420];
- uint8_t boot_sig[2];
-} __attribute__((__packed__));
-
-#define FAT_MEDIA_DESC_FIXED 0xF8
-
-#define FAT_PHYS_DRIVE_REMOVABLE 0x00
-#define FAT_PHYS_DRIVE_FIXED 0x80
-
-#define FAT_EXT_BOOT_SIG 0x29
-
-extern const char FAT_BOOT_SIG[2];
-
-extern const char FAT_INFO_SIG1[4];
-extern const char FAT_INFO_SIG2[4];
-#define FAT_INFO_SIG3 FAT_BOOT_SIG
-
-struct fat_info_sector {
- char info_sig1[4];
- char reserved1[480];
- char info_sig2[4];
- cluster_t free_clusters;
- cluster_t last_cluster;
- char reserved2[14];
- char info_sig3[2];
-} __attribute__((__packed__));
-
-struct fat_bootinfo {
- struct fat_boot_sector boot;
- struct fat_info_sector info;
-} __attribute__((__packed__));
-
-struct fat_dirent {
- char name[11];
- uint8_t attr;
- uint8_t reserved;
- uint8_t ctime_ms;
- uint16_t ctime;
- uint16_t cdate;
- uint16_t adate;
- uint16_t first_cluster_hi;
- uint16_t mtime;
- uint16_t mdate;
- uint16_t first_cluster_lo;
- uint32_t size;
-} __attribute__((__packed__));
-
-#define FAT_ATTR_READONLY 0x01
-#define FAT_ATTR_HIDDEN 0x02
-#define FAT_ATTR_SYSTEM 0x04
-#define FAT_ATTR_VOLLABEL 0x08
-#define FAT_ATTR_SUBDIR 0x10
-#define FAT_ATTR_ARCHIVE 0x20
-#define FAT_ATTR_DEVICE 0x40
-
-#define FAT_ENTRY_FREE 0x00000000
-#define FAT_ENTRY_BAD 0x0FFFFFF7
-#define FAT_ENTRY_EOC 0x0FFFFFF8
-
-#define FAT_SECTOR_SIZE 512
-#define FAT_CLUSTER_ZERO 2
-#define FAT_ENTRIES_PER_SECTOR ((SECTOR_SIZE) / (sizeof(fat_entry_t)))
-
-void fat_dirent_set_first_cluster(struct fat_dirent *de, cluster_t cluster);
-void fat_dirent_set(struct fat_dirent *de,
- char *name, uint8_t attr,
- cluster_t first_cluster, uint32_t size);
-
-#endif
diff --git a/fatblock/fatblock.c b/fatblock/fatblock.c
deleted file mode 100644
index 244eefa..0000000
--- a/fatblock/fatblock.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <errno.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <ublock/ublock.h>
-
-#include "fatblock.h"
-#include "fs.h"
-#include "utils.h"
-
-static struct fs fs;
-static struct ublock_ctx *ub;
-static int ums_lun = 0;
-
-static int fs_import(struct fs *fs,
- uint16_t cluster_size, offset_t data_size,
- offset_t *total_size_out)
-{
- int ret;
-
- ret = fs_init(fs, cluster_size, data_size, total_size_out);
- if (ret)
- return ret;
-
- ret = import_tree(fs, ".");
- if (ret)
- return ret;
-
- return 0;
-}
-
-
-
-static int read_callback(char *buf, uint64_t length, uint64_t offset)
-{
- int result;
- int i;
-
- result = fs_read(&fs, buf, offset, length);
- if (result == SKY_IS_FALLING) {
- WARN("underlying filesystem has been modified; stopping.\n");
- ublock_stop(ub);
- }
-
- return result ? -EINVAL : 0;
-}
-
-static int write_callback(const char *buf, uint64_t length, uint64_t offset)
-{
- DEBUG("writing to (%llu, %llu): we are read-only\n", offset, length);
-
- return -EINVAL;
-}
-
-static struct ublock_ops ops = {
- .read = &read_callback,
- .write = &write_callback
-};
-
-
-
-static int set_ums_file(int index)
-{
- char filename[PATH_MAX];
- FILE *file;
-
- sprintf(filename, "/sys/devices/platform/usb_mass_storage/lun%d/file",
- ums_lun);
- file = fopen(filename, "w");
- if (!file) {
- WARN("setting USB mass storage file: fopen(%s) failed: %s\n",
- filename, strerror(errno));
- return -1;
- }
-
- WARN("writing '/dev/block/ublock%d' to %s.\n", index, filename);
-
- fprintf(file, "/dev/block/ublock%d", index);
-
- fclose(file);
-
- return 0;
-}
-
-static int clear_ums_file(void)
-{
- char filename[PATH_MAX];
- FILE *file;
-
- sprintf(filename, "/sys/devices/platform/usb_mass_storage/lun%d/file",
- ums_lun);
- file = fopen(filename, "w");
- if (!file) {
- WARN("clearing USB mass storage file: fopen(%s) failed: %s\n",
- filename, strerror(errno));
- return -1;
- }
-
- fclose(file);
-
- return 0;
-}
-
-
-
-
-static void cleanup(void)
-{
- WARN("cleanup: clearing USB mass storage file\n");
- clear_ums_file();
- WARN("cleanup: destroying block device\n");
- ublock_destroy(ub);
-}
-
-static void signal_handler(int sig)
-{
- WARN("received signal %d\n", sig);
- cleanup();
- exit(0);
-}
-
-static int normal_exit = 0;
-
-static void atexit_handler(void)
-{
- if (normal_exit)
- return;
-
- cleanup();
-}
-
-int main(int argc, char *argv[]) {
- char *path;
- int mb;
- offset_t total_size;
- int index;
- int ret;
-
- signal(SIGINT, &signal_handler);
- signal(SIGTERM, &signal_handler);
- atexit(&atexit_handler);
-
- if (argc != 3)
- DIE("Usage: fatblock <path> <size in MB>\n");
-
- path = argv[1];
- mb = atoi(argv[2]);
-
- INFO("fatblock: importing filesystem from %s (%d MB)\n", path, mb);
-
- ret = chdir(path);
- if (ret < 0)
- DIE("fatblock: chdir(%s) failed: %s; aborting\n", path, strerror(errno));
-
- ret = fs_import(&fs, 32768, 1048576LL * mb, &total_size);
- if (ret)
- DIE("fatblock: couldn't import filesystem; aborting\n");
-
- INFO("fatblock: filesystem imported (%llu bytes)\n", total_size);
-
- ret = ublock_init(&ub, &ops, total_size);
- if (ret)
- DIE("fatblock: couldn't create block device; aborting\n");
- index = ublock_index(ub);
- if (index < 0)
- DIE("fatblock: invalid ublock index %d; aborting\n", index);
-
- INFO("fatblock: block device ublock%d created\n", index);
- set_ums_file(index);
-
- INFO("fatblock: entering main loop\n");
- ublock_run(ub);
-
- INFO("fatblock: destroying block device\n");
- clear_ums_file();
- ublock_destroy(ub);
-
- normal_exit = 1;
-
- INFO("fatblock: goodbye!\n");
- return 0;
-}
diff --git a/fatblock/fatblock.h b/fatblock/fatblock.h
deleted file mode 100644
index 8ee4c8d..0000000
--- a/fatblock/fatblock.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2010 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 FATBLOCK_H
-#define FATBLOCK_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "fdpool.h"
-
-typedef uint64_t offset_t;
-
-typedef enum {
- EXTENT_TYPE_BOOT,
- EXTENT_TYPE_INFO,
- EXTENT_TYPE_FAT,
- EXTENT_TYPE_FILE,
- EXTENT_TYPE_DIR
-} extent_type;
-
-struct extent {
- offset_t start;
- offset_t len;
- extent_type type;
-
- struct extent *next;
-};
-
-struct file {
- struct extent extent;
-
- char *path;
- uint32_t size;
-
- dev_t dev;
- ino_t ino;
- time_t mtime;
-
- struct pooled_fd pfd;
-};
-
-struct dir {
- struct extent extent;
-
- char *path;
- uint32_t size;
-
- struct fat_dirent *entries;
-};
-
-struct fs;
-
-int import_tree(struct fs *fs, char *path);
-int fs_read(struct fs *fs, char *buf, offset_t start, offset_t len);
-
-#define MALLOC_FAIL (-41) /* memory allocation failed somewhere. */
-#define SKY_IS_FALLING (-42) /* One of the files changed out from under us. */
-
-#endif
diff --git a/fatblock/fdpool.c b/fatblock/fdpool.c
deleted file mode 100644
index 92df4a1..0000000
--- a/fatblock/fdpool.c
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <utils.h>
-
-#include "fdpool.h"
-
-#define INVALID_FD (-1)
-#define FDPOOL_SIZE 4
-
-static struct pooled_fd fdpool_head = {
- .fd = INVALID_FD,
- .prev = &fdpool_head,
- .next = &fdpool_head
-};
-static int fdpool_count = 0;
-
-static void fdpool_insert_head(struct pooled_fd *node)
-{
- struct pooled_fd *prev = &fdpool_head;
- struct pooled_fd *next = prev->next;
-
- assert(node);
-
- prev->next = node;
- node->prev = prev;
- node->next = next;
- next->prev = node;
-
- fdpool_count++;
-}
-
-static void fdpool_remove(struct pooled_fd *node)
-{
- struct pooled_fd *prev = node->prev;
- struct pooled_fd *next = node->next;
-
- assert(prev);
- assert(next);
-
- prev->next = next;
- next->prev = prev;
-
- fdpool_count--;
-}
-
-static struct pooled_fd *fdpool_remove_tail(void)
-{
- struct pooled_fd *tail = fdpool_head.prev;
-
- assert(tail != &fdpool_head);
-
- fdpool_remove(tail);
-
- return tail;
-}
-
-static void fdpool_clear(struct pooled_fd *pfd)
-{
- assert(pfd);
-
- pfd->fd = INVALID_FD;
- pfd->prev = pfd->next = NULL;
-}
-
-static void fdpool_unpool(struct pooled_fd *pfd)
-{
- close(pfd->fd);
- fdpool_clear(pfd);
-}
-
-static void fdpool_evict(void)
-{
- struct pooled_fd *tail;
-
- tail = fdpool_remove_tail();
- fdpool_unpool(tail);
-}
-
-static void fdpool_pool(struct pooled_fd *pfd, int fd)
-{
- if (fdpool_count >= FDPOOL_SIZE)
- fdpool_evict();
-
- fdpool_insert_head(pfd);
- pfd->fd = fd;
-}
-
-static void fdpool_touch(struct pooled_fd *pfd)
-{
- fdpool_remove(pfd);
- fdpool_insert_head(pfd);
-}
-
-
-
-void fdpool_init(struct pooled_fd *pfd)
-{
- fdpool_clear(pfd);
-}
-
-int fdpool_open(struct pooled_fd *pfd, const char *pathname, int flags)
-{
- int open_errno;
- int fd;
-
- if (pfd->fd != INVALID_FD) {
- fdpool_touch(pfd);
- return pfd->fd;
- }
-
- fd = open(pathname, flags);
- open_errno = errno;
-
- if (fd >= 0) {
- fdpool_pool(pfd, fd);
- }
-
- errno = open_errno;
- return fd;
-}
-
-void fdpool_close(struct pooled_fd *pfd)
-{
- assert(pfd);
-
- fdpool_unpool(pfd);
-}
diff --git a/fatblock/fdpool.h b/fatblock/fdpool.h
deleted file mode 100644
index 85c7af3..0000000
--- a/fatblock/fdpool.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2010 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 FDPOOL_H
-#define FDPOOL_H
-
-struct pooled_fd {
- struct pooled_fd *prev;
- struct pooled_fd *next;
- int fd;
-};
-
-void fdpool_init(struct pooled_fd *pfd);
-int fdpool_open(struct pooled_fd *pfd, const char *pathname, int flags);
-void fdpool_close(struct pooled_fd *pfd);
-
-#endif
diff --git a/fatblock/fs.c b/fatblock/fs.c
deleted file mode 100644
index fb19a70..0000000
--- a/fatblock/fs.c
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <string.h>
-#include <endian.h>
-
-#include "fatblock.h"
-#include "fat.h"
-#include "fs.h"
-#include "utils.h"
-
-#define DEFAULT_SECTOR_SIZE 512
-
-static void fs_add_extent(struct fs *fs, struct extent *extent,
- offset_t start, offset_t len, int type)
-{
- assert(fs);
- assert(extent);
-
- extent->start = start;
- extent->len = len;
- extent->type = type;
-
- extent->next = fs->extents;
- fs->extents = extent;
-}
-
-struct extent *fs_find_extent(struct fs *fs, offset_t start, offset_t len,
- struct extent *last,
- offset_t *r_start_out,
- offset_t *e_start_out,
- offset_t *len_out)
-{
- struct extent *e;
- offset_t end;
- offset_t e_start, e_end, e_len, e_rel_start, r_rel_start, rel_len;
-
- assert(fs);
-
- end = start + len;
-
- e = last ? last->next : fs->extents;
- for (; e; e = e->next) {
- e_start = e->start;
- e_len = e->len;
- e_end = e_start + e_len;
-
- if (start >= e_end)
- continue;
-
- if (end <= e_start)
- continue;
-
- if (e_start <= start) {
- r_rel_start = 0;
- e_rel_start = start - e_start;
- if (end <= e_end)
- rel_len = len;
- else
- rel_len = e_end - start;
- } else {
- e_rel_start = 0;
- r_rel_start = e_start - start;
- if (e_end <= end)
- rel_len = e_len;
- else
- rel_len = end - e_start;
- }
-
- assert(e_rel_start < e_len);
- assert(e_rel_start + rel_len <= e_len);
- assert(r_rel_start < len);
- assert(r_rel_start + rel_len <= len);
-
- if (r_start_out)
- *r_start_out = r_rel_start;
- if (e_start_out)
- *e_start_out = e_rel_start;
- if (len_out)
- *len_out = rel_len;
-
- return e;
- }
-
- return NULL;
-}
-
-static void fs_set_fat(struct fs *fs, cluster_t cluster, fat_entry_t entry)
-{
- assert(fs);
-
- fs->fat[cluster] = htole32(entry);
-}
-
-int fs_alloc_extent(struct fs *fs, struct extent *extent,
- offset_t len, int type, cluster_t *first_cluster_out)
-{
- assert(fs);
- assert(extent);
-
- cluster_t clusters_needed, start;
- cluster_t i;
-
- if (len == 0) {
- extent->start = 0;
- extent->len = 0;
- extent->type = type;
- *first_cluster_out = 0;
- return 0;
- }
-
- clusters_needed = (len + fs->cluster_size - 1) / fs->cluster_size;
-
- /* Check for adequate space. */
- if (fs->next_cluster + clusters_needed > fs->num_clusters) {
- WARN("allocating extent: filesystem is full!\n");
- return -1;
- }
-
- /* Allocate clusters. */
- start = fs->next_cluster;
- fs->next_cluster += clusters_needed;
-
- /* Update FAT. */
- for (i = 0; i < clusters_needed - 1; i++) {
- fs_set_fat(fs, start + i, start + i + 1);
- }
- fs_set_fat(fs, start + clusters_needed - 1, FAT_ENTRY_EOC);
-
- *first_cluster_out = start;
-
- fs_add_extent(fs,
- extent,
- fs->data_offset + (offset_t)(start - FAT_CLUSTER_ZERO)
- * fs->cluster_size,
- (offset_t)clusters_needed * fs->cluster_size,
- type);
-
- return 0;
-}
-
-int fs_init(struct fs *fs, uint16_t cluster_size, offset_t data_size,
- offset_t *total_size_out)
-{
- uint16_t sector_size;
- cluster_t data_clusters;
- sector_t reserved_sectors, fat_sectors, data_sectors, total_sectors;
- sector_t sectors_per_cluster;
- int fat_entries_per_sector;
- fat_entry_t *fat;
- struct fat_boot_sector *bs;
- struct fat_info_sector *is;
-
- assert(fs);
-
- sector_size = DEFAULT_SECTOR_SIZE;
- fs->cluster_size = cluster_size;
-
- sectors_per_cluster = cluster_size / DEFAULT_SECTOR_SIZE;
- fat_entries_per_sector = sector_size / sizeof(fat_entry_t);
-
- data_clusters = (data_size + cluster_size - 1) / cluster_size;
- data_sectors = data_clusters * sectors_per_cluster;
- fat_sectors = ((data_clusters + 2) + fat_entries_per_sector - 1)
- / fat_entries_per_sector;
- reserved_sectors = 3;
- total_sectors = reserved_sectors + fat_sectors + data_sectors;
-
- memset(&fs->boot, 0, sizeof(fs->boot));
- bs = &fs->boot;
-
- strpadcpy(bs->name, "FATBLOCK", ' ', sizeof(bs->name));
- bs->sector_size = htole16(sector_size);
- bs->sectors_per_cluster = sectors_per_cluster;
- bs->reserved_sectors = htole16(reserved_sectors);
- bs->fats = 1;
- bs->media_desc = FAT_MEDIA_DESC_FIXED;
- /* TODO: Calculate geometry? */
- bs->sectors_per_track = htole16(42);
- bs->heads = htole16(42);
- bs->sectors32 = htole32(total_sectors);
- bs->fat_sectors32 = htole32(fat_sectors);
- /* bs->rootdir_start will be set later. */
- bs->fs_info_sector = htole16(1);
- bs->backup_boot_sector = htole16(2);
- bs->phys_drive = FAT_PHYS_DRIVE_REMOVABLE;
- bs->ext_boot_sig = FAT_EXT_BOOT_SIG;
- bs->serial = 0x42424242;
- strpadcpy(bs->vol_label, "FATBLOCK", ' ', sizeof(bs->vol_label));
- strpadcpy(bs->type, "FAT32", ' ', sizeof(bs->type));
- memcpy(bs->boot_sig, FAT_BOOT_SIG, sizeof(bs->boot_sig));
-
- memset(&fs->info, 0, sizeof(fs->info));
- is = &fs->info;
-
- memcpy(is->info_sig1, FAT_INFO_SIG1, sizeof(is->info_sig1));
- memcpy(is->info_sig2, FAT_INFO_SIG2, sizeof(is->info_sig2));
- is->free_clusters = htole32(-1);
- is->last_cluster = htole32(FAT_CLUSTER_ZERO);
- memcpy(is->info_sig3, FAT_INFO_SIG3, sizeof(is->info_sig3));
-
- fs->num_clusters = FAT_CLUSTER_ZERO + data_clusters;
- fs->next_cluster = FAT_CLUSTER_ZERO;
-
- fs->fat_size = fat_sectors * sector_size;
- fs->fat = malloc(fs->fat_size);
- if (!fs->fat) {
- WARN("initializing filesystem: couldn't allocate FAT extent: "
- "out of memory\n");
- return MALLOC_FAIL;
- }
- memset(fs->fat, 0, fs->fat_size);
-
- fs->data_offset = (reserved_sectors + fat_sectors) * sector_size;
-
- fs->extents = NULL;
- fs_add_extent(fs, &fs->boot_extent,
- 0, sector_size,
- EXTENT_TYPE_BOOT);
- fs_add_extent(fs, &fs->info_extent,
- sector_size, sector_size,
- EXTENT_TYPE_INFO);
- fs_add_extent(fs, &fs->backup_boot_extent,
- 2 * sector_size, sector_size,
- EXTENT_TYPE_BOOT);
- fs_add_extent(fs, &fs->fat_extent,
- reserved_sectors * sector_size, fs->fat_size,
- EXTENT_TYPE_FAT);
-
- *total_size_out = (offset_t)total_sectors * sector_size;
-
- return 0;
-}
-
-void fs_set_rootdir_start(struct fs *fs, cluster_t rootdir_start)
-{
- assert(fs);
-
- fs->boot.rootdir_start = htole32(rootdir_start);
-}
-
-void fs_update_free_clusters(struct fs *fs)
-{
- assert(fs);
-
- fs->info.free_clusters = htole32(fs->num_clusters - fs->next_cluster);
-}
diff --git a/fatblock/fs.h b/fatblock/fs.h
deleted file mode 100644
index 52f3383..0000000
--- a/fatblock/fs.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2010 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 FS_H
-#define FS_H
-
-#include "fatblock.h"
-#include "fat.h"
-
-struct fs {
- uint16_t cluster_size;
-
- cluster_t num_clusters;
- cluster_t next_cluster;
- struct extent *extents;
-
- struct fat_boot_sector boot;
- struct extent boot_extent;
- struct extent backup_boot_extent;
-
- struct fat_info_sector info;
- struct extent info_extent;
-
- struct extent fat_extent;
- fat_entry_t *fat;
- offset_t fat_size;
-
- offset_t data_offset;
-};
-
-int fs_alloc_extent(struct fs *fs, struct extent *extent,
- offset_t len, int type, cluster_t *first_cluster_out);
-struct extent *fs_find_extent(struct fs *fs, offset_t start, offset_t len, struct extent *last,
- offset_t *r_start_out, offset_t *e_start_out, offset_t *len_out);
-int fs_init(struct fs *fs, uint16_t cluster_size, offset_t data_size, offset_t *total_size_out);
-void fs_set_rootdir_start(struct fs *fs, cluster_t rootdir_start);
-void fs_update_free_clusters(struct fs *fs);
-
-#endif
diff --git a/fatblock/import.c b/fatblock/import.c
deleted file mode 100644
index 80ed5b8..0000000
--- a/fatblock/import.c
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-
-#include "fatblock.h"
-#include "fat.h"
-#include "fdpool.h"
-#include "fs.h"
-#include "utils.h"
-
-static inline int valid_char(int c)
-{
- return (isalnum(c) ||
- strchr("!#$%'()-@^_`{}~", c) ||
- ((c >= 128) && (c < 256)));
-}
-
-static int convert_name(char *short_name, const char *long_name)
-{
- int i;
-
- const char *s;
- const char *dot;
- int c;
-
- dot = NULL;
-
- for (s = long_name; *s; s++) {
- if (*s == '.') {
- if (dot) {
- goto short_fail;
- } else {
- dot = s;
- }
- } else if (!valid_char(*s)) {
- goto short_fail;
- }
- }
-
- if (dot - long_name > 8) {
- goto short_fail;
- }
-
- if (dot && (s - (dot + 1) > 3)) {
- goto short_fail;
- }
-
- memset(short_name, ' ', 11);
-
- if (!dot) {
- dot = s;
- }
-
- for (i = 0; i < dot - long_name; i++) {
- short_name[i] = toupper(long_name[i]);
- }
-
- for (i = 0; i < s - dot; i++) {
- short_name[8 + i] = toupper(dot[1 + i]);
- }
-
- return 0;
-
-short_fail:
- return 1;
-}
-
-struct imported {
- cluster_t first_cluster;
- uint32_t size;
- struct fat_dirent *dot_dot_dirent;
-};
-
-static int import_file(struct fs *fs, char *path, struct imported *out)
-{
- struct stat st;
- struct file *f = NULL;
- char *path_copy = NULL;
- int ret;
-
- ret = stat(path, &st);
- if (ret < 0) {
- WARN("importing %s: stat failed: %s\n", path, strerror(errno));
- goto fail;
- }
-
- f = malloc(sizeof(struct file));
- if (!f) {
- WARN("importing %s: couldn't allocate file struct: "
- "out of memory\n", path);
- ret = MALLOC_FAIL;
- goto fail;
- }
-
- path_copy = strdup(path);
- if (!path_copy) {
- WARN("importing %s: couldn't strdup path: out of memory\n",
- path);
- ret = MALLOC_FAIL;
- goto fail;
- }
-
- f->path = path_copy;
- f->size = st.st_size;
- f->dev = st.st_dev;
- f->ino = st.st_ino;
- f->mtime = st.st_mtime;
- fdpool_init(&f->pfd);
-
- ret = fs_alloc_extent(fs, &f->extent,
- f->size, EXTENT_TYPE_FILE, &out->first_cluster);
- if (ret) {
- WARN("importing %s: couldn't allocate data extent\n", path);
- goto fail;
- }
-
- out->size = f->size;
- out->dot_dot_dirent = NULL;
-
- return 0;
-
-fail:
- if (path_copy)
- free(path_copy);
- if (f)
- free(f);
- return ret;
-}
-
-struct item {
- char name[11];
- struct imported imp;
- struct item *next;
- int is_dir;
-};
-
-static struct item *free_items_head;
-
-static struct item *alloc_item(void)
-{
- struct item *item;
-
- if (free_items_head) {
- item = free_items_head;
- free_items_head = item->next;
- } else {
- item = malloc(sizeof(struct item));
- /* May return NULL if item couldn't be allocated. */
- }
-
- return item;
-}
-
-static void free_item(struct item *item)
-{
- item->next = free_items_head;
- free_items_head = item;
-}
-
-static void free_items(struct item *head)
-{
- struct item *tail;
-
- for (tail = head; tail->next; tail = tail->next);
-
- tail->next = free_items_head;
- free_items_head = head;
-}
-
-/* TODO: With some work, this can be rewritten so we don't recurse
- * until all memory is allocated. */
-static int import_dir(struct fs *fs, char *path, int is_root,
- struct imported *out)
-{
- struct dir *d;
- cluster_t my_first_cluster;
-
- DIR *dir;
- struct dirent *de;
-
- char ch_path[PATH_MAX];
- struct imported *ch_imp;
- cluster_t ch_first_cluster;
- struct fat_dirent *ch_dirent;
-
- int ret;
-
- struct item *items;
- struct item *item;
- int count;
-
- int i;
-
- dir = opendir(path);
- if (!dir) {
- WARN("importing %s: opendir failed: %s\n", path,
- strerror(errno));
- return -1;
- }
-
- d = malloc(sizeof(struct dir));
- if (!d) {
- WARN("importing %s: couldn't allocate dir struct: "
- "out of memory\n", path);
- closedir(dir);
- return MALLOC_FAIL;
- }
-
- d->path = strdup(path);
- if (!d->path) {
- WARN("importing %s: couldn't strdup path: out of memory\n",
- path);
- closedir(dir);
- free(d);
- return MALLOC_FAIL;
- }
-
- items = NULL;
- item = NULL;
- count = 0;
-
- while ((de = readdir(dir))) {
- if (de->d_name[0] == '.') {
- goto skip_item;
- }
-
- ret = snprintf(ch_path, PATH_MAX, "%s/%s", path, de->d_name);
- if (ret < 0 || ret >= PATH_MAX) {
- goto skip_item;
- }
-
- item = alloc_item();
- if (!item) {
- WARN("importing %s: couldn't allocate item struct: "
- "out of memory\n", path);
- ret = MALLOC_FAIL;
- goto free_items;
- }
-
- if (convert_name(item->name, de->d_name)) {
- goto skip_item;
- }
-
- switch (de->d_type) {
- case DT_REG:
- import_file(fs, ch_path, &item->imp);
- item->is_dir = 0;
- break;
- case DT_DIR:
- import_dir(fs, ch_path, 0, &item->imp);
- item->is_dir = 1;
- break;
- default:
- goto skip_item;
- }
-
- item->next = items;
- items = item;
-
- count++;
-
- item = NULL;
-
- continue;
-
-skip_item:
- if (item)
- free_item(item);
- }
-
- closedir(dir);
-
- d->size = sizeof(struct fat_dirent) * (count + (is_root ? 0 : 2));
- ret = fs_alloc_extent(fs, &d->extent, d->size, EXTENT_TYPE_DIR, &out->first_cluster);
- if (ret) {
- WARN("importing %s: couldn't allocate directory table extent: "
- "out of space\n", path);
- goto free_items;
- }
-
- if (is_root)
- out->first_cluster = 0;
-
- my_first_cluster = is_root ? 0 : out->first_cluster;
-
- d->entries = malloc(sizeof(struct fat_dirent) * (count + (is_root ? 0 : 2)));
- assert(d->entries);
- for (i = count - 1; i >= 0; i--) {
- item = items;
- items = item->next;
-
- ch_dirent = &d->entries[i + (is_root ? 0 : 2)];
-
- fat_dirent_set(ch_dirent,
- item->name, item->is_dir ? FAT_ATTR_SUBDIR : 0,
- item->imp.first_cluster, item->imp.size);
-
- if (item->imp.dot_dot_dirent) {
- fat_dirent_set_first_cluster(item->imp.dot_dot_dirent,
- my_first_cluster);
- }
-
- free_item(item);
- }
-
- if (!is_root) {
- fat_dirent_set(&d->entries[0],
- ".. ", FAT_ATTR_SUBDIR,
- (cluster_t)-1, 0);
- out->dot_dot_dirent = &d->entries[0]; /* will set first_cluster */
-
- fat_dirent_set(&d->entries[1],
- ". ", FAT_ATTR_SUBDIR,
- my_first_cluster, 0);
- } else {
- out->dot_dot_dirent = NULL;
- }
-
- out->size = 0;
-
- return 0;
-
-free_items:
- free_items(items);
- free(d->path);
- free(d);
-
- return ret;
-}
-
-int import_tree(struct fs *fs, char *path)
-{
- struct imported imp;
- int ret;
-
- ret = import_dir(fs, path, 0, &imp);
- if (ret)
- return ret;
-
- fs_set_rootdir_start(fs, imp.first_cluster);
- fs_update_free_clusters(fs);
-
- return 0;
-}
diff --git a/fatblock/read.c b/fatblock/read.c
deleted file mode 100644
index ffb1aec..0000000
--- a/fatblock/read.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/stat.h>
-
-#include "fatblock.h"
-#include "fs.h"
-#include "utils.h"
-
-static int buffer_read(char *buf, offset_t buf_len, char *out,
- offset_t off, offset_t len)
-{
- assert(buf);
- assert(out);
-
- if (off >= buf_len) {
- memset(out, 0, len);
- return 0;
- }
-
- if (off + len > buf_len) {
- memset(out + (buf_len - off), 0, len - (buf_len - off));
- len = buf_len - off;
- }
-
- assert(off < buf_len);
- assert(off + len <= buf_len);
-
- memcpy(out, buf + off, len);
-
- return 0;
-}
-
-static int file_check_metadata(struct file *f)
-{
- struct stat st;
- int ret;
-
- assert(f);
-
- ret = stat(f->path, &st);
- if (ret) {
- WARN("checking metadata of %s: stat failed: %s\n",
- f->path, strerror(errno));
- return -1;
- }
-
- if (f->mtime != st.st_mtime)
- return -1;
-
- return 0;
-}
-
-static int file_read(struct file *f, char *buf, offset_t off, offset_t len)
-{
- int fd;
- off_t sought;
- ssize_t ret;
-
- assert(f);
- assert(buf);
-
- if (off >= UINT32_MAX) {
- WARN("reading %s (%llu, %llu): "
- "ignoring read that starts past 2^32\n",
- f->path, off, len);
- return 0;
- }
-
- if (off + len > UINT32_MAX) {
- WARN("reading %s (%llu, %llu): "
- "truncating read that ends past 2^32\n",
- f->path, off, len);
- len = UINT32_MAX - off;
- }
-
- if (file_check_metadata(f)) {
- WARN("reading %s (%llu, %llu): metadata has changed\n",
- f->path, off, len);
- return SKY_IS_FALLING;
- }
-
- fd = fdpool_open(&f->pfd, f->path, O_RDONLY);
- if (fd < 0) {
- WARN("reading %s: open failed: %s\n", f->path, strerror(errno));
- return -1;
- }
-
- sought = lseek(fd, (off_t)len, SEEK_SET);
- if (sought != (off_t)len) {
- WARN("reading %s (%llu, %llu): seek failed: %s\n",
- f->path, off, len, strerror(errno));
- return -1;
- }
-
- ret = read(fd, buf, (size_t)len);
- if (ret != (ssize_t)len) {
- WARN("reading %s (%llu, %llu): read failed: %s\n",
- f->path, off, len, strerror(errno));
- return -1;
- }
-
- /* leave fd open; fdpool will close it if needed. */
-
- return 0;
-}
-
-static int dir_read(struct dir *d, char *buf, offset_t off, offset_t len)
-{
- assert(d);
- assert(buf);
-
- return buffer_read((char*)d->entries, d->size, buf, off, len);
-}
-
-static int extent_read(struct fs *fs, struct extent *e, char *buf,
- offset_t off, offset_t len)
-{
- assert(fs);
- assert(e);
- assert(buf);
-
- switch (e->type) {
- case EXTENT_TYPE_BOOT:
- return buffer_read((char*)&fs->boot, sizeof(fs->boot), buf,
- off, len);
- case EXTENT_TYPE_INFO:
- return buffer_read((char*)&fs->info, sizeof(fs->info), buf,
- off, len);
- case EXTENT_TYPE_FAT:
- return buffer_read((char*)fs->fat, fs->fat_size, buf,
- off, len);
- case EXTENT_TYPE_FILE:
- return file_read((struct file *)e, buf, off, len);
- case EXTENT_TYPE_DIR:
- return dir_read((struct dir *)e, buf, off, len);
- default:
- WARN("reading extent: unexpected type %d\n", e->type);
- return -1;
- }
-}
-
-int fs_read(struct fs *fs, char *buf, offset_t start, offset_t len)
-{
- struct extent *e = NULL;
- offset_t e_start, r_start, rel_len;
- int ret;
-
- memset(buf, 0, len);
-
- while ((e = fs_find_extent(fs, start, len, e,
- &r_start, &e_start, &rel_len))) {
- ret = extent_read(fs, e, buf + r_start, e_start, rel_len);
- if (ret == SKY_IS_FALLING)
- return SKY_IS_FALLING;
- if (ret)
- return ret;
- }
-
- return 0;
-}
diff --git a/fatblock/utils.c b/fatblock/utils.c
deleted file mode 100644
index 20fa83b..0000000
--- a/fatblock/utils.c
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2010 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 <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "utils.h"
-
-void strpadcpy(char *d, const char *s, char p, size_t l)
-{
- while (*s && l-- > 0)
- *d++ = *s++;
-
- while (l-- > 0)
- *d++ = ' ';
-}
-
-void warn(char *msg)
-{
- fprintf(stderr, "%s", msg);
-}
-
-void die(char *msg)
-{
- fprintf(stderr, "%s", msg);
- exit(EXIT_FAILURE);
-}
diff --git a/fatblock/utils.h b/fatblock/utils.h
deleted file mode 100644
index 7fe4b88..0000000
--- a/fatblock/utils.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2010 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 UTILS_H
-#define UTILS_H
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define EPRINT(...) fprintf(stderr, __VA_ARGS__)
-#define DIE(...) do { EPRINT(__VA_ARGS__); exit(EXIT_FAILURE); } while (0)
-#define WARN(...) EPRINT(__VA_ARGS__)
-#define INFO(...) EPRINT(__VA_ARGS__)
-#define DEBUG(...) EPRINT(__VA_ARGS__)
-
-void strpadcpy(char *d, const char *s, char p, size_t l);
-void warn(char *msg);
-void die(char *msg);
-
-#endif
diff --git a/libublock/Android.mk b/libublock/Android.mk
deleted file mode 100644
index 690c5e8..0000000
--- a/libublock/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright (C) 2010 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_MODULE := libublock
-LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := ublock.c
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/libublock/MODULE_LICENSE_APACHE2 b/libublock/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/libublock/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/libublock/NOTICE b/libublock/NOTICE
deleted file mode 100644
index c5b1efa..0000000
--- a/libublock/NOTICE
+++ /dev/null
@@ -1,190 +0,0 @@
-
- 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/libublock/include/ublock/ublock.h b/libublock/include/ublock/ublock.h
deleted file mode 100644
index 5b691b0..0000000
--- a/libublock/include/ublock/ublock.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2010 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 UBLOCK_UBLOCK_H
-#define UBLOCK_UBLOCK_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#define UBLOCK_VERSION 0
-
-struct ublock_ctx;
-
-struct ublock_ops {
- int (*read)(char *buf, uint64_t length, uint64_t offset);
- int (*write)(const char *buf, uint64_t length, uint64_t offset);
-};
-
-/*
- * Initializes a ublock block device.
- *
- * May call your read and write functions as the kernel scans partition
- * tables. Will return once the kernel has finished adding the block device.
- *
- * Returns 0 on success,
- * -ENOMEM if we ran out of memory,
- * -ENOENT if the kernel appears to lack ublock support, and
- * -EPROTO if the kernel did something unexpected.
- */
-int ublock_init(struct ublock_ctx **ub, struct ublock_ops *ops, uint64_t size);
-
-/*
- * Returns the index of a ublock block device.
- *
- * Returns -EFAULT if the context is NULL,
- * -EINVAL if the context is invalid.
- */
-int ublock_index(struct ublock_ctx *ub);
-
-/*
- * Runs a loop waiting for ublock requests and calling the ops callbacks.
- *
- * Returns 0 if the loop was stopped by ublock_stop,
- * -EPROTO if the loop was stopped by a protocol error,
- */
-int ublock_run(struct ublock_ctx *ub);
-
-/*
- * Stops ublock_run, if it is running. Should be called from one of the ops
- * callbacks.
- */
-void ublock_stop(struct ublock_ctx *ub);
-
-/*
- * Destroys a ublock block device.
- */
-void ublock_destroy(struct ublock_ctx *ub);
-
-#endif
diff --git a/libublock/ublock.c b/libublock/ublock.c
deleted file mode 100644
index c2627b1..0000000
--- a/libublock/ublock.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * Copyright (C) 2010 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 <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <linux/ublock.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <ublock/ublock.h>
-
-#define CONTROL_FILE "/dev/ublockctl"
-
-struct ublock_ctx {
- struct ublock_ops *ops;
-
- uint32_t index;
- uint64_t size;
- uint32_t max_buf;
-
- char *in_buf;
- char *out_buf;
-
- int flags;
- int fd;
- int fails;
-};
-
-#define CTX_INITED 0x1
-#define CTX_READY 0x2
-#define CTX_RUNNING 0x4
-
-#define MAX_BUF 65536
-
-#define MAX_FAILURES 10
-
-static inline void ublock_succeed(struct ublock_ctx *ub_ctx)
-{
- assert(ub_ctx);
-
- ub_ctx->fails = 0;
-}
-
-static void ublock_fail(struct ublock_ctx *ub_ctx)
-{
- assert(ub_ctx);
-
- ub_ctx->fails++;
- if (ub_ctx->fails > MAX_FAILURES)
- ublock_stop(ub_ctx);
-}
-
-static int ublock_handle_init(struct ublock_ctx *ub_ctx,
- const void *in, size_t in_len,
- void *out, size_t *out_len)
-{
- const struct ublock_init_in *in_h;
- struct ublock_init_out *out_h;
-
- assert(ub_ctx);
- assert(in);
- assert(out);
-
- if (in_len != sizeof(*in_h))
- return -EPROTO;
-
- in_h = (const struct ublock_init_in *)in;
-
- if (in_h->version != UBLOCK_VERSION)
- return -EPROTO;
-
- out_h = (struct ublock_init_out *)out;
- out_h->version = UBLOCK_VERSION;
- out_h->size = ub_ctx->size;
- if (in_h->max_buf < MAX_BUF)
- ub_ctx->max_buf = in_h->max_buf;
- else
- ub_ctx->max_buf = MAX_BUF;
- out_h->max_buf = ub_ctx->max_buf;
-
- *out_len = sizeof(*out_h);
-
- ub_ctx->index = in_h->index;
- ub_ctx->flags |= CTX_INITED;
-
- return 0;
-}
-
-static int ublock_handle_ready(struct ublock_ctx *ub_ctx,
- const void *in, size_t in_len,
- void *out, size_t *out_len)
-{
- struct ublock_ready_out *out_h;
-
- assert(ub_ctx);
- assert(in);
- assert(out);
-
- if (in_len != sizeof(struct ublock_ready_in))
- return -EPROTO;
-
- *out_len = sizeof(struct ublock_ready_out);
-
- ub_ctx->flags |= CTX_READY;
-
- return 0;
-}
-
-static int ublock_handle_read(struct ublock_ctx *ub_ctx,
- const void *in, size_t in_len,
- void *out, size_t *out_len)
-{
- const struct ublock_read_in *in_h;
- struct ublock_read_out *out_h;
- char *out_buf;
-
- assert(ub_ctx);
- assert(in);
- assert(out);
-
- if (in_len != sizeof(*in_h))
- return -EPROTO;
-
- in_h = (const struct ublock_read_in *)in;
-
- out_h = (struct ublock_read_out *)out;
- out_buf = (char *)(out_h + 1);
-
- out_h->status = (ub_ctx->ops->read)(out_buf, in_h->length, in_h->offset);
-
- if (out_h->status >= 0)
- *out_len = sizeof(*out_h) + in_h->length;
- else
- *out_len = sizeof(*out_h);
-
- return 0;
-}
-
-static int ublock_handle_write(struct ublock_ctx *ub_ctx,
- const void *in, size_t in_len,
- void *out, size_t *out_len)
-{
- const struct ublock_write_in *in_h;
- const char *in_buf;
- struct ublock_write_out *out_h;
-
- assert(ub_ctx);
- assert(in);
- assert(out);
-
- if (in_len < sizeof(*in_h))
- return -EPROTO;
-
- in_h = (const struct ublock_write_in *)in;
- in_buf = (const char*)(in_h + 1);
-
- out_h = (struct ublock_write_out *)out;
- *out_len = sizeof(*out_h);
-
- out_h->status = (ub_ctx->ops->write)(in_buf, in_h->length, in_h->offset);
-
- return 0;
-}
-
-static int ublock_handle_request(struct ublock_ctx *ub_ctx,
- const void *in, size_t in_len,
- void *out, size_t *out_len)
-{
- const struct ublock_in_header *in_h;
- const void *in_buf;
- size_t in_buf_len;
-
- struct ublock_out_header *out_h;
- void *out_buf;
- size_t out_buf_len;
-
- int result;
- int (*handle_fn)(struct ublock_ctx *, const void *, size_t, void *, size_t *);
-
- assert(ub_ctx);
- assert(in);
- assert(out);
-
- if (in_len < sizeof(*in_h))
- return -EPROTO;
-
- in_h = (const struct ublock_in_header *)in;
- in_buf = in_h + 1;
- in_buf_len = in_len - sizeof(*in_h);
-
- out_h = (struct ublock_out_header *)out;
- out_buf = out_h + 1;
-
- switch (in_h->opcode) {
- case UBLOCK_INIT_IN:
- out_h->opcode = UBLOCK_INIT_OUT;
- handle_fn = &ublock_handle_init;
- break;
- case UBLOCK_READY_IN:
- out_h->opcode = UBLOCK_READY_OUT;
- handle_fn = &ublock_handle_ready;
- break;
- case UBLOCK_READ_IN:
- out_h->opcode = UBLOCK_READ_OUT;
- handle_fn = &ublock_handle_read;
- break;
- case UBLOCK_WRITE_IN:
- out_h->opcode = UBLOCK_WRITE_OUT;
- handle_fn = &ublock_handle_write;
- break;
- default:
- return -EPROTO;
- }
-
- out_h->seq = in_h->seq;
- result = (handle_fn)(ub_ctx, in_buf, in_buf_len, out_buf, &out_buf_len);
- *out_len = sizeof(*out_h) + out_buf_len;
-
- return result;
-}
-
-static int ublock_do_request(struct ublock_ctx *ub_ctx,
- void *in_buf, size_t in_size,
- void *out_buf, size_t out_size)
-{
- size_t out_len;
- ssize_t in_len, out_wrote;
- int result;
-
- assert(ub_ctx);
- assert(in_buf);
- assert(out_buf);
-
- in_len = read(ub_ctx->fd, in_buf, in_size);
- if (in_len < 0)
- return -EPROTO;
-
- result = ublock_handle_request(ub_ctx, in_buf, in_len, out_buf, &out_len);
-
- assert(out_len <= out_size);
-
- out_wrote = write(ub_ctx->fd, out_buf, out_len);
-
- if (out_wrote < out_len)
- return -EPROTO;
-
- if (result)
- ublock_fail(ub_ctx);
- else
- ublock_succeed(ub_ctx);
-
- return result;
-}
-
-#define EXIT_READY 1
-#define EXIT_STOPPED 2
-#define EXIT_FAIL 4
-
-static int ublock_loop(struct ublock_ctx *ub_ctx, int exit_cond)
-{
- size_t in_len, out_len;
- int result;
-
- result = 0;
- while (((exit_cond & EXIT_READY) && (!(ub_ctx->flags & CTX_READY))) ||
- ((exit_cond & EXIT_STOPPED) && (ub_ctx->flags & CTX_RUNNING)) ||
- ((exit_cond & EXIT_FAIL) && (result))) {
- result = ublock_do_request(ub_ctx,
- ub_ctx->in_buf, ub_ctx->max_buf,
- ub_ctx->out_buf, ub_ctx->max_buf);
- if (result)
- return result;
- }
-
- return 0;
-}
-
-int ublock_run(struct ublock_ctx *ub_ctx)
-{
- if (!ub_ctx)
- return -EFAULT;
-
- if (!(ub_ctx->flags & CTX_INITED))
- return -EINVAL;
-
- ub_ctx->flags |= CTX_RUNNING;
- ublock_loop(ub_ctx, EXIT_STOPPED);
-
- return 0;
-}
-
-void ublock_stop(struct ublock_ctx *ub_ctx)
-{
- if (!ub_ctx)
- return;
-
- if (!(ub_ctx->flags & CTX_INITED))
- return;
-
- ub_ctx->flags &= ~CTX_RUNNING;
-}
-
-int ublock_index(struct ublock_ctx *ub_ctx)
-{
- if (!ub_ctx)
- return -EFAULT;
-
- if (!(ub_ctx->flags & CTX_INITED))
- return -EINVAL;
-
- return ub_ctx->index;
-}
-
-static inline size_t ublock_init_buf_size(void)
-{
- size_t in_size = sizeof(struct ublock_in_header) +
- sizeof(struct ublock_init_in);
- size_t out_size = sizeof(struct ublock_out_header) +
- sizeof(struct ublock_init_out);
-
- return (in_size > out_size) ? in_size : out_size;
-}
-
-int ublock_init(struct ublock_ctx **ub_ctx_out, struct ublock_ops *ops,
- uint64_t dev_size)
-{
- struct ublock_ctx *ub_ctx;
- char *in_buf, *out_buf;
- size_t size;
- int result;
-
- if (!ub_ctx_out || !ops)
- return -EFAULT;
-
- in_buf = out_buf = NULL;
-
- ub_ctx = malloc(sizeof(struct ublock_ctx));
- if (!ub_ctx) {
- result = -ENOMEM;
- goto error;
- }
-
- size = ublock_init_buf_size();
- in_buf = malloc(size);
- out_buf = malloc(size);
- if (!(in_buf && out_buf)) {
- result = -ENOMEM;
- goto error;
- }
-
- ub_ctx->ops = ops;
- ub_ctx->size = dev_size;
- ub_ctx->max_buf = 0;
- ub_ctx->flags = 0;
-
- ub_ctx->fd = open(CONTROL_FILE, O_RDWR);
- if (ub_ctx->fd < 0) {
- result = -ENOENT;
- goto error;
- }
-
- result = ublock_do_request(ub_ctx, in_buf, size, out_buf, size);
- if (result) {
- result = -EPROTO;
- goto error;
- }
- if (!ub_ctx->flags & CTX_INITED) {
- result = -EPROTO;
- goto error;
- }
-
- free(in_buf);
- in_buf = NULL;
- free(out_buf);
- out_buf = NULL;
-
- ub_ctx->in_buf = malloc(ub_ctx->max_buf);
- ub_ctx->out_buf = malloc(ub_ctx->max_buf);
- if (!(ub_ctx->in_buf && ub_ctx->out_buf)) {
- result = -ENOMEM;
- goto error;
- }
-
- ublock_loop(ub_ctx, EXIT_READY);
-
- *ub_ctx_out = ub_ctx;
-
- return 0;
-
-error:
- if (ub_ctx) {
- if (ub_ctx->in_buf)
- free(ub_ctx->in_buf);
- if (ub_ctx->out_buf)
- free(ub_ctx->out_buf);
- if (ub_ctx->fd)
- close(ub_ctx->fd);
- free(ub_ctx);
- }
- if (in_buf)
- free(in_buf);
- if (out_buf)
- free(out_buf);
-
- return result;
-}
-
-void ublock_destroy(struct ublock_ctx *ub_ctx)
-{
- if (!ub_ctx)
- return;
-
- close(ub_ctx->fd);
- free(ub_ctx);
-}