shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-21 13:34:40 +03:00
Code Releases Activity

o get things compiling

Browse Source
This commit is contained in:
Joe Thornber 2001-10-08 09:45:16 +00:00
parent d81ec60d19
commit 812efa0f48
7 changed files with 150 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/.symlinks
View File

@ -1,12 +1,15 @@
../lib/config/config.h ../lib/config/config.h
../lib/device/device.h ../lib/datastruct/hash.h
../lib/datastruct/list.h
../lib/datastruct/lvm-types.h
../lib/device/dev-cache.h ../lib/device/dev-cache.h
../lib/device/device.h
../lib/display/display.h ../lib/display/display.h
../lib/filters/filter.h
../lib/format1/format1.h
../lib/log/log.h ../lib/log/log.h
../lib/metadata/metadata.h ../lib/metadata/metadata.h
../lib/metadata/metadata.h
../lib/mm/dbg_malloc.h ../lib/mm/dbg_malloc.h
../lib/mm/pool.h ../lib/mm/pool.h
../lib/datastruct/hash.h ../lib/mm/xlate.h
../lib/datastruct/list.h
../lib/filters/filter.h
../lib/datastruct/lvm-types.h

1
lib/Makefile.in
View File

@ -14,6 +14,7 @@ SOURCES=\
dev-mgr/dev-cache.c \ dev-mgr/dev-cache.c \
device/dev-cache.c \ device/dev-cache.c \
device/dev-io.c \ device/dev-io.c \
format1/disk-rep.c \
format1/format1.c \ format1/format1.c \
log/log.c \ log/log.c \
mm/dbg_malloc.c \ mm/dbg_malloc.c \

46
lib/format1/disk-rep.c
View File

@ -7,6 +7,8 @@
#include "disk-rep.h" #include "disk-rep.h"
#include "pool.h" #include "pool.h"
#include "xlate.h"
#include "log.h"
#define fail do {stack; return 0;} while(0) #define fail do {stack; return 0;} while(0)
#define xx16(v) disk->v = xlate16(disk->v) #define xx16(v) disk->v = xlate16(disk->v)
@ -24,7 +26,7 @@ static void _xlate_pv(struct pv_disk *disk)
xx32(pv_on_disk.base); xx32(pv_on_disk.size); xx32(pv_on_disk.base); xx32(pv_on_disk.size);
xx32(vg_on_disk.base); xx32(vg_on_disk.size); xx32(vg_on_disk.base); xx32(vg_on_disk.size);
xx32(pv_uuid_on_disk.base); xx32(pv_uuid_on_disk.size); xx32(pv_uuidlist_on_disk.base); xx32(pv_uuidlist_on_disk.size);
xx32(lv_on_disk.base); xx32(lv_on_disk.size); xx32(lv_on_disk.base); xx32(lv_on_disk.size);
xx32(pe_on_disk.base); xx32(pe_on_disk.size); xx32(pe_on_disk.base); xx32(pe_on_disk.size);
@ -94,16 +96,13 @@ static void _xlate_extents(struct pe_disk *extents, int count)
} }
} }
static int _read_pv(struct data_list *data) static int _read_pv(struct disk_list *data)
{ {
struct pv_disk *pvd = &data->pv; struct pv_disk *pvd = &data->pv;
if (dev_read(data->dev, 0, sizeof(*pvd), pvd) != sizeof(*pvd)) if (dev_read(data->dev, 0, sizeof(*pvd), pvd) != sizeof(*pvd))
fail; fail;
_xlate_pv(pvd); _xlate_pv(pvd);
memset(pvd->pv_name, 0, sizeof (pvd->pv_name));
strncpy(pvd->pv_name, data->dev->name, sizeof(pvd->pv_name) - 1);
pvd->pv_dev = pvd->dev;
return 1; return 1;
} }
@ -148,7 +147,7 @@ static int _read_uuids(struct disk_list *data)
memcpy(ul->uuid, buffer, NAME_LEN); memcpy(ul->uuid, buffer, NAME_LEN);
ul->uuid[NAME_LEN] = '\0'; ul->uuid[NAME_LEN] = '\0';
list_add(&ui->list, &data->uuids); list_add(&ul->list, &data->uuids);
pos += NAME_LEN; pos += NAME_LEN;
num_read++; num_read++;
@ -161,10 +160,11 @@ static int _read_lvs(struct disk_list *data)
{ {
int i; int i;
unsigned long pos; unsigned long pos;
struct lvd_list *ll;
for(i = 0; i < data->vg.lv_cur; i++) { for(i = 0; i < data->vg.lv_cur; i++) {
pos = data->pv.lv_on_disk.base + (i * sizeof(struct lv_disk)); pos = data->pv.lv_on_disk.base + (i * sizeof(struct lv_disk));
struct lv_list *ll = pool_alloc(sizeof(*ll)); ll = pool_alloc(data->mem, sizeof(*ll));
if (!ll) if (!ll)
fail; fail;
@ -180,7 +180,7 @@ static int _read_lvs(struct disk_list *data)
static int _read_extents(struct disk_list *data) static int _read_extents(struct disk_list *data)
{ {
size_t len = sizeof(struct pe_disk) * data->pv->pe_total; size_t len = sizeof(struct pe_disk) * data->pv.pe_total;
struct pe_disk *extents = pool_alloc(data->mem, len); struct pe_disk *extents = pool_alloc(data->mem, len);
unsigned long pos = data->pv.pe_on_disk.base; unsigned long pos = data->pv.pe_on_disk.base;
@ -203,7 +203,7 @@ struct disk_list *read_pv(struct device *dev, struct pool *mem,
data->dev = dev; data->dev = dev;
data->mem = mem; data->mem = mem;
if (!_read_pv(&data->pv)) { if (!_read_pv(data)) {
log_err("failed to read pv data from %s\n", dev->name); log_err("failed to read pv data from %s\n", dev->name);
goto bad; goto bad;
} }
@ -215,11 +215,12 @@ struct disk_list *read_pv(struct device *dev, struct pool *mem,
} }
if (vg_name && strcmp(vg_name, data->pv.vg_name)) { if (vg_name && strcmp(vg_name, data->pv.vg_name)) {
log_info("%s is not a member of the vg '%s'\n", vg_name); log_info("%s is not a member of the vg '%s'\n",
dev->name, vg_name);
goto bad; goto bad;
} }
if (!_read_vg(data->pv.pv_vg_on_disk.base, &data->vg)) { if (!_read_vg(data)) {
log_err("failed to read vg data from pv (%s)\n", dev->name); log_err("failed to read vg data from pv (%s)\n", dev->name);
goto bad; goto bad;
} }
@ -242,7 +243,7 @@ struct disk_list *read_pv(struct device *dev, struct pool *mem,
return data; return data;
bad: bad:
pool_free(data); pool_free(data->mem, data);
return NULL; return NULL;
} }
@ -252,20 +253,19 @@ struct disk_list *read_pv(struct device *dev, struct pool *mem,
* allocated form the pool so we can free off all * allocated form the pool so we can free off all
* the memory if something goes wrong. * the memory if something goes wrong.
*/ */
int read_pvs_in_vg(struct v1 *v, const char *vg_name, int read_pvs_in_vg(const char *vg_name, struct dev_filter *filter,
struct pool *mem, struct list_head *head) struct pool *mem, struct list_head *head)
{ {
struct dev_cache_iter *iter = dev_iter_create(v->filter); struct dev_iter *iter = dev_iter_create(filter);
struct device *dev; struct device *dev;
struct disk_list *data = NULL; struct disk_list *data = NULL;
for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) { for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) {
if ((data = read_pv(dev, mem, vg_name)))
if ((data = read_all_pv(dev, mem, vg_name)))
list_add(&data->list, head); list_add(&data->list, head);
else
pool_free(mem, pvd);
} }
dev_iter_destroy(iter);
return 1; return 1;
} }
@ -286,7 +286,6 @@ static int _write_vg(struct disk_list *data)
static int _write_uuids(struct disk_list *data) static int _write_uuids(struct disk_list *data)
{ {
int num_read = 0;
struct uuid_list *ul; struct uuid_list *ul;
struct list_head *tmp; struct list_head *tmp;
ulong pos = data->pv.pv_uuidlist_on_disk.base; ulong pos = data->pv.pv_uuidlist_on_disk.base;
@ -300,8 +299,8 @@ static int _write_uuids(struct disk_list *data)
} }
ul = list_entry(tmp, struct uuid_list, list); ul = list_entry(tmp, struct uuid_list, list);
if (dev_write(data->dev, pos, if (dev_write(data->dev, pos,
sizeof(NAME_LEN), NAME_LEN) != NAME_LEN) sizeof(NAME_LEN), ul->uuid) != NAME_LEN)
fail; fail;
pos += NAME_LEN; pos += NAME_LEN;
@ -324,9 +323,11 @@ static int _write_lv(struct device *dev, ulong pos, struct lv_disk *disk)
static int _write_lvs(struct disk_list *data) static int _write_lvs(struct disk_list *data)
{ {
struct list_head *tmp; struct list_head *tmp;
unsigned long pos;
list_for_each(tmp, &data->lvs) { list_for_each(tmp, &data->lvs) {
struct lv_list *ll = list_entry(tmp, struct lv_list, list); struct lvd_list *ll = list_entry(tmp, struct lvd_list, list);
pos = data->pv.lv_on_disk.base;
if (!_write_lv(data->dev, pos, &ll->lv)) if (!_write_lv(data->dev, pos, &ll->lv))
fail; fail;
@ -341,7 +342,6 @@ static int _write_extents(struct disk_list *data)
{ {
size_t len = sizeof(struct pe_disk) * data->pv.pe_total; size_t len = sizeof(struct pe_disk) * data->pv.pe_total;
struct pe_disk *extents = data->extents; struct pe_disk *extents = data->extents;
unsigned long pos = data->pv.pe_on_disk.base;
_xlate_extents(extents, data->pv.pe_total); _xlate_extents(extents, data->pv.pe_total);
if (dev_write(data->dev, 0, len, extents) != len) if (dev_write(data->dev, 0, len, extents) != len)

20
lib/format1/disk-rep.h
View File

@ -2,12 +2,21 @@
* Copyright (C) 2001 Sistina Software (UK) Limited. * Copyright (C) 2001 Sistina Software (UK) Limited.
* *
* This file is released under the GPL. * This file is released under the GPL.
*
*/ */
#ifndef DISK_REP_FORMAT1_H #ifndef DISK_REP_FORMAT1_H
#define DISK_REP_FORMAT1_H #define DISK_REP_FORMAT1_H
#include "lvm-types.h"
#include "metadata.h"
#include "pool.h"
#define MAX_PV 256
#define MAX_LV 256
#define MAX_VG 99
#define UNMAPPED_EXTENT ((uint16_t) -1)
struct data_area { struct data_area {
uint32_t base; uint32_t base;
uint32_t size; uint32_t size;
@ -63,8 +72,8 @@ struct lv_disk {
}; };
struct vg_disk { struct vg_disk {
uint8_t vg_uuid[UUID_LEN]; /* volume group UUID */ uint8_t vg_uuid[ID_LEN]; /* volume group UUID */
uint8_t vg_name_dummy[NAME_LEN-UUID_LEN]; /* rest of v1 VG name */ uint8_t vg_name_dummy[NAME_LEN - ID_LEN]; /* rest of v1 VG name */
uint32_t vg_number; /* volume group number */ uint32_t vg_number; /* volume group number */
uint32_t vg_access; /* read/write */ uint32_t vg_access; /* read/write */
uint32_t vg_status; /* active or not */ uint32_t vg_status; /* active or not */
@ -93,12 +102,13 @@ struct uuid_list {
char uuid[NAME_LEN + 1]; char uuid[NAME_LEN + 1];
}; };
struct lv_list { struct lvd_list {
struct list_head list; struct list_head list;
struct lv_disk lv; struct lv_disk lv;
} };
struct disk_list { struct disk_list {
struct pool *mem;
struct device *dev; struct device *dev;
struct list_head list; struct list_head list;

103
lib/format1/format1.c
View File

@ -9,13 +9,9 @@
#include "pool.h" #include "pool.h"
#include "hash.h" #include "hash.h"
#include "list.h" #include "list.h"
#include "log.h"
struct v1 {
struct pool *mem;
struct dev_filter *filter;
};
static int _import_vg(struct volume_group *vg, struct list_head *pvs) static int _import_vg(struct volume_group *vg, struct list_head *pvs)
{ {
struct list_head *tmp; struct list_head *tmp;
@ -31,8 +27,10 @@ static int _import_vg(struct volume_group *vg, struct list_head *pvs)
memcpy(vg->id, &first->vg_uuid, ID_LEN); memcpy(vg->id, &first->vg_uuid, ID_LEN);
vg->name = NULL; vg->name = NULL;
vg->status = first->vg_status;
vg->access = first->vg_access; // FIXME: encode flags
//vg->status = first->vg_status;
//vg->access = first->vg_access;
vg->extent_size = first->pe_size; vg->extent_size = first->pe_size;
vg->extent_count = first->pe_total; vg->extent_count = first->pe_total;
vg->free_count = first->pe_total - first->pe_allocated; vg->free_count = first->pe_total - first->pe_allocated;
@ -68,23 +66,25 @@ static int _import_pvs(struct pool *mem, struct volume_group *vg,
pv = &pvl->pv; pv = &pvl->pv;
memcpy(&pv->id, &dl->pv.pv_uuid, ID_LEN); memcpy(&pv->id, &dl->pv.pv_uuid, ID_LEN);
pv->dev = ??; // FIXME: finish
pv->vg_name = pool_strdup(dl->pv.vg_name); //pv->dev = ??;
pv->vg_name = pool_strdup(mem, dl->pv.vg_name);
if (!pv->vg_name) { if (!pv->vg_name) {
stack; stack;
return 0; return 0;
} }
pv->exported = ??; // FIXME: finish
//pv->exported = ??;
pv->status = dl->pv.pv_status; pv->status = dl->pv.pv_status;
pv->size = dl->pv.pv_size; pv->size = dl->pv.pv_size;
pv->pe_size = dl->pv.pv_size; pv->pe_size = dl->pv.pv_size;
pe_start = dl->pv.pe_start; pv->pe_start = dl->pv.pe_start;
pe_count = dl->pv.pe_count; pv->pe_count = dl->pv.pe_total;
pe_allocated = dl->pv.pe_allocated; pv->pe_allocated = dl->pv.pe_allocated;
list_add(&pvl->list, vg->pvs); list_add(&pvl->list, &vg->pvs);
vg->pv_count++; vg->pv_count++;
} }
@ -96,16 +96,35 @@ static struct logical_volume *_find_lv(struct volume_group *vg,
{ {
struct list_head *tmp; struct list_head *tmp;
struct logical_volume *lv; struct logical_volume *lv;
struct lv_list *ll;
list_for_each(tmp, &vg->lvs) { list_for_each(tmp, &vg->lvs) {
lv = list_entry(tmp, struct logical_volume, list); ll = list_entry(tmp, struct lv_list, list);
lv = &ll->lv;
if (!strcmp(name, lv->name)) if (!strcmp(name, lv->name))
return lv; return lv;
} }
return NULL; return NULL;
} }
static struct logical_volume *_add_lv(struct volume_group *vg, static struct physical_volume *_find_pv(struct volume_group *vg,
struct device *dev)
{
struct list_head *tmp;
struct physical_volume *pv;
struct pv_list *pl;
list_for_each(tmp, &vg->lvs) {
pl = list_entry(tmp, struct pv_list, list);
pv = &pl->pv;
if (dev == pv->dev)
return pv;
}
return NULL;
}
static struct logical_volume *_add_lv(struct pool *mem,
struct volume_group *vg,
struct lv_disk *lvd) struct lv_disk *lvd)
{ {
struct logical_volume *lv = pool_alloc(mem, sizeof(*lv)); struct logical_volume *lv = pool_alloc(mem, sizeof(*lv));
@ -116,16 +135,17 @@ static struct logical_volume *_add_lv(struct volume_group *vg,
} }
memset(lv->id, 0, sizeof(lv->id)); memset(lv->id, 0, sizeof(lv->id));
if (!(lv->name = pool_dupstr(lvd->lv_name))) { if (!(lv->name = pool_strdup(mem, lvd->lv_name))) {
stack; stack;
return 0; return 0;
} }
lv->access = lvd->lv_access; // FIXME: finish
lv->status = lvd->lv_status; //lv->access = lvd->lv_access;
//lv->status = lvd->lv_status;
lv->open = lvd->lv_open; lv->open = lvd->lv_open;
lv->size = lvd->lv_size; lv->size = lvd->lv_size;
lv->le_count = lvd->lv_allocated_lv; lv->le_count = lvd->lv_allocated_le;
lv->map = pool_alloc(mem, sizeof(struct pe_specifier) * lv->le_count); lv->map = pool_alloc(mem, sizeof(struct pe_specifier) * lv->le_count);
if (!lv->map) { if (!lv->map) {
@ -133,26 +153,25 @@ static struct logical_volume *_add_lv(struct volume_group *vg,
return 0; return 0;
} }
return 1; return lv;
} }
static int _import_lvs(struct pool *mem, struct volume_group *vg, static int _import_lvs(struct pool *mem, struct volume_group *vg,
struct list_head *pvs) struct list_head *pvs)
{ {
struct list_head *tmp, tmp2; struct list_head *tmp, *tmp2;
struct disk_list *dl; struct disk_list *dl;
struct lv_list *ll; struct lvd_list *ll;
struct lv_disk *lvd; struct lv_disk *lvd;
struct logical_volume *lv;
int i;
list_for_each(tmp, pvs) { list_for_each(tmp, pvs) {
dl = list_entry(tmp, struct disk_list, list); dl = list_entry(tmp, struct disk_list, list);
list_for_each(tmp2, &dl->lvs) { list_for_each(tmp2, &dl->lvs) {
ll = list_entry(tmp2, struct lv_list, list); ll = list_entry(tmp2, struct lvd_list, list);
lvd = &ll->lv; lvd = &ll->lv;
if (!_find_lv(vg, lvd->lvname) && !_add_lv(vg, lvd)) { if (!_find_lv(vg, lvd->lv_name) &&
!_add_lv(mem, vg, lvd)) {
stack; stack;
return 0; return 0;
} }
@ -162,18 +181,17 @@ static int _import_lvs(struct pool *mem, struct volume_group *vg,
return 1; return 1;
} }
static int _fill_lv_array(struct logical_volume *lvs, static int _fill_lv_array(struct logical_volume **lvs,
struct volume_group *vg, struct disk_list *dl) struct volume_group *vg, struct disk_list *dl)
{ {
struct list_head *tmp; struct list_head *tmp;
struct pv_disk *pvd = &dl->pv;
struct logical_volume *lv; struct logical_volume *lv;
int i = 0; int i = 0;
list_for_each(tmp, &dl->lvs) { list_for_each(tmp, &dl->lvs) {
struct lv_list *ll = list_entry(tmp, struct lv_disk, list); struct lvd_list *ll = list_entry(tmp, struct lvd_list, list);
if (!(lv = _find_lv(vg, ll->lv.name))) { if (!(lv = _find_lv(vg, ll->lv.lv_name))) {
stack; stack;
return 0; return 0;
} }
@ -190,7 +208,7 @@ static int _import_extents(struct pool *mem, struct volume_group *vg,
{ {
struct list_head *tmp; struct list_head *tmp;
struct disk_list *dl; struct disk_list *dl;
struct logical_volume *lv, lvs[MAX_LV]; struct logical_volume *lv, *lvs[MAX_LV];
struct physical_volume *pv; struct physical_volume *pv;
struct pe_disk *e; struct pe_disk *e;
int i; int i;
@ -198,7 +216,7 @@ static int _import_extents(struct pool *mem, struct volume_group *vg,
list_for_each(tmp, pvs) { list_for_each(tmp, pvs) {
dl = list_entry(tmp, struct disk_list, list); dl = list_entry(tmp, struct disk_list, list);
pv = _find_pv(vg, dl->pv.pv_name); pv = _find_pv(vg, dl->dev);
e = dl->extents; e = dl->extents;
/* build an array of lv's for this pv */ /* build an array of lv's for this pv */
@ -217,7 +235,7 @@ static int _import_extents(struct pool *mem, struct volume_group *vg,
log_err("invalid lv in extent map\n"); log_err("invalid lv in extent map\n");
return 0; return 0;
else { } else {
lv = lvs[lv_num]; lv = lvs[lv_num];
le = e[i].le_num; le = e[i].le_num;
@ -230,7 +248,7 @@ static int _import_extents(struct pool *mem, struct volume_group *vg,
return 1; return 1;
} }
static struct volume_group _build_vg(struct pool *mem, struct list_head *pvs) static struct volume_group *_build_vg(struct pool *mem, struct list_head *pvs)
{ {
struct volume_group *vg = pool_alloc(mem, sizeof(*vg)); struct volume_group *vg = pool_alloc(mem, sizeof(*vg));
@ -250,6 +268,9 @@ static struct volume_group _build_vg(struct pool *mem, struct list_head *pvs)
if (!_import_lvs(mem, vg, pvs)) if (!_import_lvs(mem, vg, pvs))
goto bad; goto bad;
if (!_import_extents(mem, vg, pvs))
goto bad;
return vg; return vg;
bad: bad:
@ -258,7 +279,7 @@ static struct volume_group _build_vg(struct pool *mem, struct list_head *pvs)
return NULL; return NULL;
} }
static struct volume_group _vg_read(struct io_space *is, const char *vg_name) static struct volume_group *_vg_read(struct io_space *is, const char *vg_name)
{ {
struct pool *mem = pool_create(1024 * 10); struct pool *mem = pool_create(1024 * 10);
struct list_head pvs; struct list_head pvs;
@ -282,8 +303,9 @@ static struct volume_group _vg_read(struct io_space *is, const char *vg_name)
return vg; return vg;
} }
static struct disk_list _flatten_pv(struct pool *mem, struct volume_group *vg, #if 0
struct physical_volume *pv) static struct disk_list *_flatten_pv(struct pool *mem, struct volume_group *vg,
struct physical_volume *pv)
{ {
} }
@ -323,10 +345,11 @@ static int _vg_write(struct io_space *is, struct volume_group *vg)
pool_destroy(mem); pool_destroy(mem);
return r; return r;
} }
#endif
struct io_space *create_lvm1_format(struct device_manager *mgr) struct io_space *create_lvm1_format(void)
{ {
return NULL;
} }

16
lib/metadata/metadata.h
View File

@ -98,11 +98,11 @@ struct volume_group {
/* physical volumes */ /* physical volumes */
uint32_t pv_count; uint32_t pv_count;
struct physical_volume **pv; struct list_head pvs;
/* logical volumes */ /* logical volumes */
uint32_t lv_count; uint32_t lv_count;
struct logical_volume **lv; struct list_head lvs;
}; };
struct name_list { struct name_list {
@ -115,6 +115,11 @@ struct pv_list {
struct physical_volume pv; struct physical_volume pv;
}; };
struct lv_list {
struct list_head list;
struct logical_volume lv;
};
/* ownership of returned objects passes */ /* ownership of returned objects passes */
struct io_space { struct io_space {
/* Returns list of names of all vgs - vg /* Returns list of names of all vgs - vg
@ -158,6 +163,7 @@ struct io_space {
/* Default to "/dev/" */ /* Default to "/dev/" */
char *prefix; char *prefix;
struct pool *mem;
struct dev_filter *filter; struct dev_filter *filter;
void *private; void *private;
}; };
@ -167,12 +173,6 @@ struct io_space *create_text_format(struct dev_filter *filter,
const char *text_file); const char *text_file);
struct io_space *create_lvm_v1_format(struct dev_filter *filter); struct io_space *create_lvm_v1_format(struct dev_filter *filter);
inline int write_backup(struct io_space *orig, struct io_space *text)
{
}
int id_eq(struct id *op1, struct id *op2); int id_eq(struct id *op1, struct id *op2);
/* Create consistent new empty structures, populated with defaults */ /* Create consistent new empty structures, populated with defaults */

32
lib/mm/xlate.h Normal file
View File

@ -0,0 +1,32 @@
/*
* Copyright (C) 2001 Sistina Software (UK) Limited.
*
* This file is released under the GPL.
*
*/
#ifndef _LVM_XLATE_H
#define _LVM_XLATE_H
/* FIXME: finish these as inlines */
uint16_t shuffle16(uint16_t n);
uint32_t shuffle32(uint32_t n);
uint64_t shuffle64(uint64_t n);
/* xlate functions move data between core and disk */
#if __BYTE_ORDER == __BIG_ENDIAN
# define xlate16(x) shuffle16(x)
# define xlate32(x) shuffle32(x)
# define xlate64(x) shuffle64(x)
#elif __BYTE_ORDER == __LITTLE_ENDIAN
# define xlate16(x) (x)
# define xlate32(x) (x)
# define xlate64(x) (x)
#else
# error "__BYTE_ORDER must be defined as __LITTLE_ENDIAN or __BIG_ENDIAN"
#endif
#endif