mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-16 23:18:51 +09:00
![Charles Manning](/assets/img/avatar_default.png)
This patch updates the yaffs2 in u-boot to correspond to git://www.aleph1.co.uk/yaffs2 commit id 9ee5d0643e559568dbe62215f76e0a7bd5a63d93 Signed-off-by: Charles Manning <cdhmanning@gmail.com>
209 lines
4.4 KiB
C
209 lines
4.4 KiB
C
/*
|
|
* YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
|
|
*
|
|
* Copyright (C) 2002-2011 Aleph One Ltd.
|
|
* for Toby Churchill Ltd and Brightstar Engineering
|
|
*
|
|
* Created by Charles Manning <charles@aleph1.co.uk>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
/*
|
|
* This simple implementation of a name-value store assumes a small number of
|
|
* values and fits into a small finite buffer.
|
|
*
|
|
* Each attribute is stored as a record:
|
|
* sizeof(int) bytes record size.
|
|
* yaffs_strnlen+1 bytes name null terminated.
|
|
* nbytes value.
|
|
* ----------
|
|
* total size stored in record size
|
|
*
|
|
* This code has not been tested with unicode yet.
|
|
*/
|
|
|
|
#include "yaffs_nameval.h"
|
|
|
|
#include "yportenv.h"
|
|
|
|
static int nval_find(const char *xb, int xb_size, const YCHAR *name,
|
|
int *exist_size)
|
|
{
|
|
int pos = 0;
|
|
int size;
|
|
|
|
memcpy(&size, xb, sizeof(int));
|
|
while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
|
|
if (!yaffs_strncmp((YCHAR *) (xb + pos + sizeof(int)),
|
|
name, size)) {
|
|
if (exist_size)
|
|
*exist_size = size;
|
|
return pos;
|
|
}
|
|
pos += size;
|
|
if (pos < xb_size - sizeof(int))
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
else
|
|
size = 0;
|
|
}
|
|
if (exist_size)
|
|
*exist_size = 0;
|
|
return -ENODATA;
|
|
}
|
|
|
|
static int nval_used(const char *xb, int xb_size)
|
|
{
|
|
int pos = 0;
|
|
int size;
|
|
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
|
|
pos += size;
|
|
if (pos < xb_size - sizeof(int))
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
else
|
|
size = 0;
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
int nval_del(char *xb, int xb_size, const YCHAR *name)
|
|
{
|
|
int pos = nval_find(xb, xb_size, name, NULL);
|
|
int size;
|
|
|
|
if (pos < 0 || pos >= xb_size)
|
|
return -ENODATA;
|
|
|
|
/* Find size, shift rest over this record,
|
|
* then zero out the rest of buffer */
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
memcpy(xb + pos, xb + pos + size, xb_size - (pos + size));
|
|
memset(xb + (xb_size - size), 0, size);
|
|
return 0;
|
|
}
|
|
|
|
int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf,
|
|
int bsize, int flags)
|
|
{
|
|
int pos;
|
|
int namelen = yaffs_strnlen(name, xb_size);
|
|
int reclen;
|
|
int size_exist = 0;
|
|
int space;
|
|
int start;
|
|
|
|
pos = nval_find(xb, xb_size, name, &size_exist);
|
|
|
|
if (flags & XATTR_CREATE && pos >= 0)
|
|
return -EEXIST;
|
|
if (flags & XATTR_REPLACE && pos < 0)
|
|
return -ENODATA;
|
|
|
|
start = nval_used(xb, xb_size);
|
|
space = xb_size - start + size_exist;
|
|
|
|
reclen = (sizeof(int) + namelen + 1 + bsize);
|
|
|
|
if (reclen > space)
|
|
return -ENOSPC;
|
|
|
|
if (pos >= 0) {
|
|
nval_del(xb, xb_size, name);
|
|
start = nval_used(xb, xb_size);
|
|
}
|
|
|
|
pos = start;
|
|
|
|
memcpy(xb + pos, &reclen, sizeof(int));
|
|
pos += sizeof(int);
|
|
yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
|
|
pos += (namelen + 1);
|
|
memcpy(xb + pos, buf, bsize);
|
|
return 0;
|
|
}
|
|
|
|
int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf,
|
|
int bsize)
|
|
{
|
|
int pos = nval_find(xb, xb_size, name, NULL);
|
|
int size;
|
|
|
|
if (pos >= 0 && pos < xb_size) {
|
|
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
pos += sizeof(int); /* advance past record length */
|
|
size -= sizeof(int);
|
|
|
|
/* Advance over name string */
|
|
while (xb[pos] && size > 0 && pos < xb_size) {
|
|
pos++;
|
|
size--;
|
|
}
|
|
/*Advance over NUL */
|
|
pos++;
|
|
size--;
|
|
|
|
/* If bsize is zero then this is a size query.
|
|
* Return the size, but don't copy.
|
|
*/
|
|
if (!bsize)
|
|
return size;
|
|
|
|
if (size <= bsize) {
|
|
memcpy(buf, xb + pos, size);
|
|
return size;
|
|
}
|
|
}
|
|
if (pos >= 0)
|
|
return -ERANGE;
|
|
|
|
return -ENODATA;
|
|
}
|
|
|
|
int nval_list(const char *xb, int xb_size, char *buf, int bsize)
|
|
{
|
|
int pos = 0;
|
|
int size;
|
|
int name_len;
|
|
int ncopied = 0;
|
|
int filled = 0;
|
|
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
while (size > sizeof(int) &&
|
|
size <= xb_size &&
|
|
(pos + size) < xb_size &&
|
|
!filled) {
|
|
pos += sizeof(int);
|
|
size -= sizeof(int);
|
|
name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
|
|
if (ncopied + name_len + 1 < bsize) {
|
|
memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
|
|
buf += name_len;
|
|
*buf = '\0';
|
|
buf++;
|
|
if (sizeof(YCHAR) > 1) {
|
|
*buf = '\0';
|
|
buf++;
|
|
}
|
|
ncopied += (name_len + 1);
|
|
} else {
|
|
filled = 1;
|
|
}
|
|
pos += size;
|
|
if (pos < xb_size - sizeof(int))
|
|
memcpy(&size, xb + pos, sizeof(int));
|
|
else
|
|
size = 0;
|
|
}
|
|
return ncopied;
|
|
}
|
|
|
|
int nval_hasvalues(const char *xb, int xb_size)
|
|
{
|
|
return nval_used(xb, xb_size) > 0;
|
|
}
|