*/
const char *yaffs_guts_c_version =
- "$Id: yaffs_guts.c,v 1.56 2008-05-08 23:23:26 charles Exp $";
+ "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
#include "yportenv.h"
#include "yaffsinterface.h"
#include "yaffs_guts.h"
#include "yaffs_tagsvalidity.h"
-#include "yaffs_getblockinfo.h"
#include "yaffs_tagscompat.h"
#ifndef CONFIG_YAFFS_USE_OWN_SORT
static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
+static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
+static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
+ int lineNo);
static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
int chunkInNAND);
/* Function to calculate chunk and offset */
-static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, __u32 *offsetOut)
+static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
{
- int chunk;
- __u32 offset;
-
- chunk = (__u32)(addr >> dev->chunkShift);
-
- if(dev->chunkDiv == 1)
- {
- /* easy power of 2 case */
- offset = (__u32)(addr & dev->chunkMask);
+ if(dev->chunkShift){
+ /* Easy-peasy power of 2 case */
+ *chunk = (__u32)(addr >> dev->chunkShift);
+ *offset = (__u32)(addr & dev->chunkMask);
}
- else
+ else if(dev->crumbsPerChunk)
{
- /* Non power-of-2 case */
-
- loff_t chunkBase;
-
- chunk /= dev->chunkDiv;
-
- chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk;
- offset = (__u32)(addr - chunkBase);
+ /* Case where we're using "crumbs" */
+ *offset = (__u32)(addr & dev->crumbMask);
+ addr >>= dev->crumbShift;
+ *chunk = ((__u32)addr)/dev->crumbsPerChunk;
+ *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
}
-
- *chunkOut = chunk;
- *offsetOut = offset;
+ else
+ YBUG();
}
/* Function to return the number of shifts for a power of 2 greater than or equal
/* Function to return the number of shifts to get a 1 in bit 0
*/
-static __u32 Shifts(__u32 x)
+static __u32 ShiftDiv(__u32 x)
{
int nShifts;
for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
dev->tempBuffer[i].line = 0; /* not in use */
dev->tempBuffer[i].buffer = buf =
- YMALLOC_DMA(dev->totalBytesPerChunk);
+ YMALLOC_DMA(dev->nDataBytesPerChunk);
}
return buf ? YAFFS_OK : YAFFS_FAIL;
}
-__u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
+static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
{
int i, j;
-
- dev->tempInUse++;
- if(dev->tempInUse > dev->maxTemp)
- dev->maxTemp = dev->tempInUse;
-
for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
if (dev->tempBuffer[i].line == 0) {
dev->tempBuffer[i].line = lineNo;
}
-void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
+static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
int lineNo)
{
int i;
-
- dev->tempInUse--;
-
for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
if (dev->tempBuffer[i].buffer == buffer) {
dev->tempBuffer[i].line = 0;
return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
}
-#if 0
static int yaffs_SkipFullVerification(yaffs_Device *dev)
{
return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
}
-#endif
-
static int yaffs_SkipNANDVerification(yaffs_Device *dev)
{
return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
int i;
yaffs_Device *dev = obj->myDev;
int ok = 1;
+ int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
if (tn) {
if (level > 0) {
__u32 lastChunk;
__u32 x;
__u32 i;
+ int ok;
yaffs_Device *dev;
yaffs_ExtendedTags tags;
yaffs_Tnode *tn;
{
yaffs_Object *obj;
int i;
- struct ylist_head *lh;
+ struct list_head *lh;
if(yaffs_SkipVerification(dev))
return;
/* Iterate through the objects in each hash entry */
for(i = 0; i < YAFFS_NOBJECT_BUCKETS; i++){
- ylist_for_each(lh, &dev->objectBucket[i].list) {
+ list_for_each(lh, &dev->objectBucket[i].list) {
if (lh) {
- obj = ylist_entry(lh, yaffs_Object, hashLink);
+ obj = list_entry(lh, yaffs_Object, hashLink);
yaffs_VerifyObject(obj);
}
}
}
+
static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
const __u8 * data,
yaffs_ExtendedTags * tags,
/* Copy the data into the robustification buffer */
yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
- } while (writeOk != YAFFS_OK &&
- (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
-
- if(!writeOk)
- chunk = -1;
+ } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
if (attempts > 1) {
T(YAFFS_TRACE_ERROR,
* Must be a multiple of 32-bits */
tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
- if(tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
-
-
/* make these things */
newTnodes = YMALLOC(nTnodes * tnodeSize);
dev->nFreeTnodes--;
}
- dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
-
return tn;
}
static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
{
yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
- int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if(tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
if(tn)
- memset(tn, 0, tnodeSize);
+ memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
return tn;
}
dev->freeTnodes = tn;
dev->nFreeTnodes++;
}
- dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
-
}
static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
/* Hook them into the free list */
for (i = 0; i < nObjects - 1; i++) {
newObjects[i].siblings.next =
- (struct ylist_head *)(&newObjects[i + 1]);
+ (struct list_head *)(&newObjects[i + 1]);
}
newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
tn->myDev = dev;
tn->chunkId = -1;
tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
- YINIT_LIST_HEAD(&(tn->hardLinks));
- YINIT_LIST_HEAD(&(tn->hashLink));
- YINIT_LIST_HEAD(&tn->siblings);
+ INIT_LIST_HEAD(&(tn->hardLinks));
+ INIT_LIST_HEAD(&(tn->hashLink));
+ INIT_LIST_HEAD(&tn->siblings);
/* Add it to the lost and found directory.
* NB Can't put root or lostNFound in lostNFound so
}
}
- dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
-
return tn;
}
yaffs_Device *dev = tn->myDev;
/* If it is still linked into the bucket list, free from the list */
- if (!ylist_empty(&tn->hashLink)) {
- ylist_del_init(&tn->hashLink);
+ if (!list_empty(&tn->hashLink)) {
+ list_del_init(&tn->hashLink);
bucket = yaffs_HashFunction(tn->objectId);
dev->objectBucket[bucket].count--;
}
yaffs_UnhashObject(tn);
/* Link into the free list. */
- tn->siblings.next = (struct ylist_head *)(dev->freeObjects);
+ tn->siblings.next = (struct list_head *)(dev->freeObjects);
dev->freeObjects = tn;
dev->nFreeObjects++;
-
- dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
-
}
#ifdef __KERNEL__
dev->nFreeObjects = 0;
for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
- YINIT_LIST_HEAD(&dev->objectBucket[i].list);
+ INIT_LIST_HEAD(&dev->objectBucket[i].list);
dev->objectBucket[i].count = 0;
}
*/
int found = 0;
- struct ylist_head *i;
+ struct list_head *i;
__u32 n = (__u32) bucket;
found = 1;
n += YAFFS_NOBJECT_BUCKETS;
if (1 || dev->objectBucket[bucket].count > 0) {
- ylist_for_each(i, &dev->objectBucket[bucket].list) {
+ list_for_each(i, &dev->objectBucket[bucket].list) {
/* If there is already one in the list */
if (i
- && ylist_entry(i, yaffs_Object,
+ && list_entry(i, yaffs_Object,
hashLink)->objectId == n) {
found = 0;
}
int bucket = yaffs_HashFunction(in->objectId);
yaffs_Device *dev = in->myDev;
- ylist_add(&in->hashLink, &dev->objectBucket[bucket].list);
+ list_add(&in->hashLink, &dev->objectBucket[bucket].list);
dev->objectBucket[bucket].count++;
}
yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
{
int bucket = yaffs_HashFunction(number);
- struct ylist_head *i;
+ struct list_head *i;
yaffs_Object *in;
- ylist_for_each(i, &dev->objectBucket[bucket].list) {
+ list_for_each(i, &dev->objectBucket[bucket].list) {
/* Look if it is in the list */
if (i) {
- in = ylist_entry(i, yaffs_Object, hashLink);
+ in = list_entry(i, yaffs_Object, hashLink);
if (in->objectId == number) {
#ifdef __KERNEL__
/* Don't tell the VFS about this one if it is defered free */
{
yaffs_Object *theObject;
- yaffs_Tnode *tn = NULL;
+ yaffs_Tnode *tn;
if (number < 0) {
number = yaffs_CreateNewObjectNumber(dev);
theObject->variant.fileVariant.top = tn;
break;
case YAFFS_OBJECT_TYPE_DIRECTORY:
- YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
+ INIT_LIST_HEAD(&theObject->variant.directoryVariant.
children);
break;
case YAFFS_OBJECT_TYPE_SYMLINK:
const YCHAR * aliasString, __u32 rdev)
{
yaffs_Object *in;
- YCHAR *str = NULL;
+ YCHAR *str;
yaffs_Device *dev = parent->myDev;
equivalentObject;
in->variant.hardLinkVariant.equivalentObjectId =
equivalentObject->objectId;
- ylist_add(&in->hardLinks, &equivalentObject->hardLinks);
+ list_add(&in->hardLinks, &equivalentObject->hardLinks);
break;
case YAFFS_OBJECT_TYPE_FILE:
case YAFFS_OBJECT_TYPE_DIRECTORY:
existingTarget = yaffs_FindObjectByName(newDir, newName);
if (existingTarget &&
existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
- !ylist_empty(&existingTarget->variant.directoryVariant.children)) {
+ !list_empty(&existingTarget->variant.directoryVariant.children)) {
/* There is a target that is a non-empty directory, so we fail */
return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */
} else if (existingTarget && existingTarget != obj) {
}
-
-static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
-{
- if(!dev->nCheckpointBlocksRequired){
- /* Not a valid value so recalculate */
- int nBytes = 0;
- int nBlocks;
- int devBlocks = (dev->endBlock - dev->startBlock + 1);
- int tnodeSize;
-
- tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if(tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
-
- nBytes += sizeof(yaffs_CheckpointValidity);
- nBytes += sizeof(yaffs_CheckpointDevice);
- nBytes += devBlocks * sizeof(yaffs_BlockInfo);
- nBytes += devBlocks * dev->chunkBitmapStride;
- nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjectsCreated - dev->nFreeObjects);
- nBytes += (tnodeSize + sizeof(__u32)) * (dev->nTnodesCreated - dev->nFreeTnodes);
- nBytes += sizeof(yaffs_CheckpointValidity);
- nBytes += sizeof(__u32); /* checksum*/
-
- /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
-
- nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3;
-
- dev->nCheckpointBlocksRequired = nBlocks;
- }
-
- return dev->nCheckpointBlocksRequired;
-}
-
// Check if there's space to allocate...
// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
int reservedBlocks = dev->nReservedBlocks;
int checkpointBlocks;
- checkpointBlocks = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
+ checkpointBlocks = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
if(checkpointBlocks < 0)
checkpointBlocks = 0;
yaffs_ObjectHeader *oh;
oh = (yaffs_ObjectHeader *)buffer;
oh->isShrink = 0;
- oh->shadowsObject = oh->inbandShadowsObject = -1;
+ oh->shadowsObject = -1;
tags.extraShadows = 0;
tags.extraIsShrinkHeader = 0;
do {
maxTries++;
- checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
+ checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
if(checkpointBlockAdjust < 0)
checkpointBlockAdjust = 0;
oh->type = in->variantType;
oh->yst_mode = in->yst_mode;
- oh->shadowsObject = oh->inbandShadowsObject = shadows;
+ oh->shadowsObject = shadows;
#ifdef CONFIG_YAFFS_WINCE
oh->win_atime[0] = in->win_atime[0];
int i;
yaffs_Device *dev = in->myDev;
int ok = 1;
- int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if(tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
-
+ int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
if (tn) {
if (level > 0) {
/* printf("write tnode at %d\n",baseOffset); */
ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
if(ok)
- ok = (yaffs_CheckpointWrite(dev,tn,tnodeSize) == tnodeSize);
+ ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
}
}
yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
yaffs_Tnode *tn;
int nread = 0;
- int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
- if(tnodeSize < sizeof(yaffs_Tnode))
- tnodeSize = sizeof(yaffs_Tnode);
ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
/* printf("read tnode at %d\n",baseChunk); */
tn = yaffs_GetTnodeRaw(dev);
if(tn)
- ok = (yaffs_CheckpointRead(dev,tn,tnodeSize) == tnodeSize);
+ ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
+ (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
else
ok = 0;
yaffs_CheckpointObject cp;
int i;
int ok = 1;
- struct ylist_head *lh;
+ struct list_head *lh;
/* Iterate through the objects in each hash entry,
*/
for(i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++){
- ylist_for_each(lh, &dev->objectBucket[i].list) {
+ list_for_each(lh, &dev->objectBucket[i].list) {
if (lh) {
- obj = ylist_entry(lh, yaffs_Object, hashLink);
+ obj = list_entry(lh, yaffs_Object, hashLink);
if (!obj->deferedFree) {
yaffs_ObjectToCheckpointObject(&cp,obj);
cp.structType = sizeof(cp);
ok = yaffs_ReadCheckpointTnodes(obj);
} else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
obj->hardLinks.next =
- (struct ylist_head *)
+ (struct list_head *)
hardList;
hardList = obj;
}
{
int chunk;
- __u32 start;
+ int start;
int nToCopy;
int n = nBytes;
int nDone = 0;
cache = yaffs_FindChunkCache(in, chunk);
/* If the chunk is already in the cache or it is less than a whole chunk
- * or we're using inband tags then use the cache (if there is caching)
+ * then use the cache (if there is caching)
* else bypass the cache.
*/
- if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
+ if (cache || nToCopy != dev->nDataBytesPerChunk) {
if (dev->nShortOpCaches > 0) {
/* If we can't find the data in the cache, then load it up. */
{
int chunk;
- __u32 start;
+ int start;
int nToCopy;
int n = nBytes;
int nDone = 0;
nToWriteBack = dev->nDataBytesPerChunk;
}
- if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
- /* An incomplete start or end chunk (or maybe both start and end chunk),
- * or we're using inband tags, so we want to use the cache buffers.
- */
+ if (nToCopy != dev->nDataBytesPerChunk) {
+ /* An incomplete start or end chunk (or maybe both start and end chunk) */
if (dev->nShortOpCaches > 0) {
yaffs_ChunkCache *cache;
/* If we can't find the data in the cache, then load the cache */
}
} else {
- /* A full chunk. Write directly from the supplied buffer. */
-
+
#ifdef CONFIG_YAFFS_WINCE
/* Under WinCE can't do direct transfer. Need to use a local buffer.
* This is because we otherwise screw up WinCE's memory mapper
0);
yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
#else
-
+ /* A full chunk. Write directly from the supplied buffer. */
chunkWritten =
yaffs_WriteChunkDataToObject(in, chunk, buffer,
dev->nDataBytesPerChunk,
{
int oldFileSize = in->variant.fileVariant.fileSize;
- __u32 newSizeOfPartialChunk;
+ int newSizeOfPartialChunk;
int newFullChunks;
yaffs_Device *dev = in->myDev;
yaffs_CheckGarbageCollection(dev);
if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
- return YAFFS_FAIL;
+ return yaffs_GetFileSize(in);
}
if (newSize == oldFileSize) {
- return YAFFS_OK;
+ return oldFileSize;
}
if (newSize < oldFileSize) {
(newSize < oldFileSize) ? 1 : 0, 0);
}
- return YAFFS_OK;
+ return newSize;
}
loff_t yaffs_GetFileSize(yaffs_Object * obj)
if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
/* Move to the unlinked directory so we have a record that it was deleted. */
- yaffs_ChangeObjectName(in, in->myDev->deletedDir,_Y("deleted"), 0, 0);
+ yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
}
if (immediateDeletion) {
retVal =
yaffs_ChangeObjectName(in, in->myDev->deletedDir,
- _Y("deleted"), 0, 0);
+ "deleted", 0, 0);
T(YAFFS_TRACE_TRACING,
(TSTR("yaffs: immediate deletion of file %d" TENDSTR),
in->objectId));
} else {
retVal =
yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
- _Y("unlinked"), 0, 0);
+ "unlinked", 0, 0);
}
}
static int yaffs_DeleteDirectory(yaffs_Object * in)
{
/* First check that the directory is empty. */
- if (ylist_empty(&in->variant.directoryVariant.children)) {
+ if (list_empty(&in->variant.directoryVariant.children)) {
return yaffs_DoGenericObjectDeletion(in);
}
/* remove this hardlink from the list assocaited with the equivalent
* object
*/
- ylist_del(&in->hardLinks);
+ list_del(&in->hardLinks);
return yaffs_DoGenericObjectDeletion(in);
}
if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
return yaffs_DeleteHardLink(obj);
- } else if (!ylist_empty(&obj->hardLinks)) {
+ } else if (!list_empty(&obj->hardLinks)) {
/* Curve ball: We're unlinking an object that has a hardlink.
*
* This problem arises because we are not strictly following
int retVal;
YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
- hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
+ hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
- ylist_del_init(&hl->hardLinks);
- ylist_del_init(&hl->siblings);
+ list_del_init(&hl->hardLinks);
+ list_del_init(&hl->siblings);
yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
if (in) {
/* Add the hardlink pointers */
hl->variant.hardLinkVariant.equivalentObject = in;
- ylist_add(&hl->hardLinks, &in->hardLinks);
+ list_add(&hl->hardLinks, &in->hardLinks);
} else {
/* Todo Need to report/handle this better.
* Got a problem... hardlink to a non-existant object
*/
hl->variant.hardLinkVariant.equivalentObject = NULL;
- YINIT_LIST_HEAD(&hl->hardLinks);
+ INIT_LIST_HEAD(&hl->hardLinks);
}
yaffs_BlockState state;
yaffs_Object *hardList = NULL;
yaffs_BlockInfo *bi;
- __u32 sequenceNumber;
+ int sequenceNumber;
yaffs_ObjectHeader *oh;
yaffs_Object *in;
yaffs_Object *parent;
for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
blockIterator++) {
- YYIELD();
-
if (dev->isYaffs2) {
/* get the block to scan in the correct order */
blk = blockIndex[blockIterator].block;
bi->sequenceNumber)) {
T(YAFFS_TRACE_ALWAYS,
(TSTR
- ("yaffs: Allocation block %d was not highest sequence id: block seq = %d, dev seq = %d"
+ ("yaffs: Allocation block %d was not highest sequence id:"
+ " block seq = %d, dev seq = %d"
TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
}
}
/* Set up as a directory */
parent->variantType =
YAFFS_OBJECT_TYPE_DIRECTORY;
- YINIT_LIST_HEAD(&parent->variant.
+ INIT_LIST_HEAD(&parent->variant.
directoryVariant.
children);
} else if (parent->variantType !=
T(YAFFS_TRACE_ERROR,
(TSTR
- ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
+ ("yaffs tragedy: attempting to use non-directory as"
+ " a directory in scan. Put in lost+found."
TENDSTR)));
parent = dev->lostNFoundDir;
}
equivalentObjectId =
oh->equivalentObjectId;
in->hardLinks.next =
- (struct ylist_head *)
+ (struct list_head *)
hardList;
hardList = in;
break;
* just delete them.
*/
{
- struct ylist_head *i;
- struct ylist_head *n;
+ struct list_head *i;
+ struct list_head *n;
yaffs_Object *l;
/* Soft delete all the unlinked files */
- ylist_for_each_safe(i, n,
+ list_for_each_safe(i, n,
&dev->unlinkedDir->variant.directoryVariant.
children) {
if (i) {
- l = ylist_entry(i, yaffs_Object, siblings);
+ l = list_entry(i, yaffs_Object, siblings);
yaffs_DestroyObject(l);
}
}
yaffs_BlockState state;
yaffs_Object *hardList = NULL;
yaffs_BlockInfo *bi;
- __u32 sequenceNumber;
+ int sequenceNumber;
yaffs_ObjectHeader *oh;
yaffs_Object *in;
yaffs_Object *parent;
/* Sort the blocks */
#ifndef CONFIG_YAFFS_USE_OWN_SORT
- {
- /* Use qsort now. */
- yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
- }
+ yaffs_qsort(blockIndex, nBlocksToScan,
+ sizeof(yaffs_BlockIndex), ybicmp);
#else
{
/* Dungy old bubble sort... */
NULL);
oh = (yaffs_ObjectHeader *) chunkData;
-
- if(dev->inbandTags){
- /* Fix up the header if they got corrupted by inband tags */
- oh->shadowsObject = oh->inbandShadowsObject;
- oh->isShrink = oh->inbandIsShrink;
- }
if (!in)
in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
/* TODO Hoosterman we have a problem! */
T(YAFFS_TRACE_ERROR,
(TSTR
- ("yaffs tragedy: Could not make object for object %d at chunk %d during scan"
+ ("yaffs tragedy: Could not make object for object %d "
+ "at chunk %d during scan"
TENDSTR), tags.objectId, chunk));
}
/* Set up as a directory */
parent->variantType =
YAFFS_OBJECT_TYPE_DIRECTORY;
- YINIT_LIST_HEAD(&parent->variant.
+ INIT_LIST_HEAD(&parent->variant.
directoryVariant.
children);
} else if (parent->variantType !=
T(YAFFS_TRACE_ERROR,
(TSTR
- ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
+ ("yaffs tragedy: attempting to use non-directory as"
+ " a directory in scan. Put in lost+found."
TENDSTR)));
parent = dev->lostNFoundDir;
}
in->variant.hardLinkVariant.equivalentObjectId =
equivalentObjectId;
in->hardLinks.next =
- (struct ylist_head *) hardList;
+ (struct list_head *) hardList;
hardList = in;
}
break;
* Sort out state of unlinked and deleted objects.
*/
{
- struct ylist_head *i;
- struct ylist_head *n;
+ struct list_head *i;
+ struct list_head *n;
yaffs_Object *l;
/* Soft delete all the unlinked files */
- ylist_for_each_safe(i, n,
+ list_for_each_safe(i, n,
&dev->unlinkedDir->variant.directoryVariant.
children) {
if (i) {
- l = ylist_entry(i, yaffs_Object, siblings);
+ l = list_entry(i, yaffs_Object, siblings);
yaffs_DestroyObject(l);
}
}
/* Soft delete all the deletedDir files */
- ylist_for_each_safe(i, n,
+ list_for_each_safe(i, n,
&dev->deletedDir->variant.directoryVariant.
children) {
if (i) {
- l = ylist_entry(i, yaffs_Object, siblings);
+ l = list_entry(i, yaffs_Object, siblings);
yaffs_DestroyObject(l);
}
if(dev && dev->removeObjectCallback)
dev->removeObjectCallback(obj);
- ylist_del_init(&obj->siblings);
+ list_del_init(&obj->siblings);
obj->parent = NULL;
}
if (obj->siblings.prev == NULL) {
/* Not initialised */
- YINIT_LIST_HEAD(&obj->siblings);
+ INIT_LIST_HEAD(&obj->siblings);
- } else if (!ylist_empty(&obj->siblings)) {
+ } else if (!list_empty(&obj->siblings)) {
/* If it is holed up somewhere else, un hook it */
yaffs_RemoveObjectFromDirectory(obj);
}
/* Now add it */
- ylist_add(&obj->siblings, &directory->variant.directoryVariant.children);
+ list_add(&obj->siblings, &directory->variant.directoryVariant.children);
obj->parent = directory;
if (directory == obj->myDev->unlinkedDir
{
int sum;
- struct ylist_head *i;
+ struct list_head *i;
YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
yaffs_Object *l;
sum = yaffs_CalcNameSum(name);
- ylist_for_each(i, &directory->variant.directoryVariant.children) {
+ list_for_each(i, &directory->variant.directoryVariant.children) {
if (i) {
- l = ylist_entry(i, yaffs_Object, siblings);
+ l = list_entry(i, yaffs_Object, siblings);
yaffs_CheckObjectDetailsLoaded(l);
int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
int (*fn) (yaffs_Object *))
{
- struct ylist_head *i;
+ struct list_head *i;
yaffs_Object *l;
if (!theDir) {
YBUG();
}
- ylist_for_each(i, &theDir->variant.directoryVariant.children) {
+ list_for_each(i, &theDir->variant.directoryVariant.children) {
if (i) {
- l = ylist_entry(i, yaffs_Object, siblings);
+ l = list_entry(i, yaffs_Object, siblings);
if (l && !fn(l)) {
return YAFFS_FAIL;
}
int yaffs_GetObjectLinkCount(yaffs_Object * obj)
{
int count = 0;
- struct ylist_head *i;
+ struct list_head *i;
if (!obj->unlinked) {
count++; /* the object itself */
}
- ylist_for_each(i, &obj->hardLinks) {
+ list_for_each(i, &obj->hardLinks) {
count++; /* add the hard links; */
}
return count;
/* Check geometry parameters. */
- if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) ||
- (!dev->isYaffs2 && dev->totalBytesPerChunk != 512) ||
- (dev->inbandTags && !dev->isYaffs2 ) ||
+ if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+ (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
dev->nChunksPerBlock < 2 ||
dev->nReservedBlocks < 2 ||
dev->internalStartBlock <= 0 ||
) {
T(YAFFS_TRACE_ALWAYS,
(TSTR
- ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d "
- TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags));
+ ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
+ TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
return YAFFS_FAIL;
}
(TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
return YAFFS_FAIL;
}
-
- /* Sort out space for inband tags, if required */
- if(dev->inbandTags)
- dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart);
- else
- dev->nDataBytesPerChunk = dev->totalBytesPerChunk;
/* Got the right mix of functions? */
if (!yaffs_CheckDevFunctions(dev)) {
/*
* Calculate all the chunk size manipulation numbers:
*/
- {
- __u32 x = dev->nDataBytesPerChunk;
- /* We always use dev->chunkShift and dev->chunkDiv */
- dev->chunkShift = Shifts(x);
- x >>= dev->chunkShift;
- dev->chunkDiv = x;
- /* We only use chunk mask if chunkDiv is 1 */
- dev->chunkMask = (1<<dev->chunkShift) - 1;
+ /* Start off assuming it is a power of 2 */
+ dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
+ dev->chunkMask = (1<<dev->chunkShift) - 1;
+
+ if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
+ /* Yes it is a power of 2, disable crumbs */
+ dev->crumbMask = 0;
+ dev->crumbShift = 0;
+ dev->crumbsPerChunk = 0;
+ } else {
+ /* Not a power of 2, use crumbs instead */
+ dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
+ dev->crumbMask = (1<<dev->crumbShift)-1;
+ dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
+ dev->chunkShift = 0;
+ dev->chunkMask = 0;
}
if (!init_failed &&
dev->nShortOpCaches > 0) {
int i;
- void *buf;
+ __u8 *buf;
int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
dev->srCache[i].object = NULL;
dev->srCache[i].lastUse = 0;
dev->srCache[i].dirty = 0;
- dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk);
+ dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
}
if(!buf)
init_failed = 1;
YFREE(dev->tempBuffer[i].buffer);
}
-
dev->isMounted = 0;
}
nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
/* Now we figure out how much to reserve for the checkpoint and report that... */
- blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
+ blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
if(blocksForCheckpoint < 0)
blocksForCheckpoint = 0;
/*---------------------------------------- YAFFS test code ----------------------*/
#define yaffs_CheckStruct(structure,syze, name) \
- do { \
if(sizeof(structure) != syze) \
{ \
T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
name,syze,sizeof(structure))); \
return YAFFS_FAIL; \
- } \
- } while(0)
+ }
static int yaffs_CheckStructures(void)
{
-/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */
-/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
-/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
+/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
+/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
+/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
#ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
- yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode");
-#endif
-#ifndef CONFIG_YAFFS_WINCE
- yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
+ yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
#endif
+ yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
+
return YAFFS_OK;
}
projects / openwrt / openwrt.git / blobdiff