Lines Matching defs:in
65 static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
72 static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name,
76 static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
78 static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
102 static int yaffs_CheckFileSanity(yaffs_Object * in);
104 #define yaffs_CheckFileSanity(in)
107 static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in);
160 /* Function to return the number of shifts to get a 1 in bit 0
234 (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
410 * Check the first page we try to write in a block.
457 * NB We do this at the end to prevent duplicates in the case of a write error.
589 * in the tnode.
610 /* Calculate the tnode size in bytes for variable width tnode support.
694 /* Hoosterman, this thing looks like it isn't in the list */
722 /* Hoosterman, this thing looks like it is already in the list */
823 * in the tree. 0 means only the level 0 tnode is in the tree.
877 * This happens in two steps:
964 /* Don't have one, none passed in */
1008 * chunks and tnodes in the file
1013 static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
1021 yaffs_Device *dev = in->myDev;
1035 yaffs_DeleteWorker(in,
1073 in->objectId,
1080 in->nDataChunks--;
1118 /* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file.
1124 static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
1130 yaffs_Device *dev = in->myDev;
1139 yaffs_SoftDeleteWorker(in,
1266 * We can do this if only the 0th element in the tnode is in use
1370 * NB Can't put root or lostNFound in lostNFound so
1540 /* If there is already one in the list */
1554 static void yaffs_HashObject(yaffs_Object * in)
1556 int bucket = yaffs_HashFunction(in->objectId);
1557 yaffs_Device *dev = in->myDev;
1559 list_add(&in->hashLink, &dev->objectBucket[bucket].list);
1568 yaffs_Object *in;
1571 /* Look if it is in the list */
1573 in = list_entry(i, yaffs_Object, hashLink);
1574 if (in->objectId == number) {
1577 if (in->deferedFree)
1581 return in;
1695 yaffs_Object *in;
1704 in = yaffs_CreateNewObject(dev, -1, type);
1706 if (in) {
1707 in->chunkId = -1;
1708 in->valid = 1;
1709 in->variantType = type;
1711 in->yst_mode = mode;
1714 yfsd_WinFileTimeNow(in->win_atime);
1715 in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
1716 in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
1719 in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME;
1721 in->yst_rdev = rdev;
1722 in->yst_uid = uid;
1723 in->yst_gid = gid;
1725 in->nDataChunks = 0;
1727 yaffs_SetObjectName(in, name);
1728 in->dirty = 1;
1730 yaffs_AddObjectToDirectory(parent, in);
1732 in->myDev = parent->myDev;
1736 in->variant.symLinkVariant.alias =
1740 in->variant.hardLinkVariant.equivalentObject =
1742 in->variant.hardLinkVariant.equivalentObjectId =
1744 list_add(&in->hardLinks, &equivalentObject->hardLinks);
1754 if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
1756 yaffs_DestroyObject(in);
1757 in = NULL;
1762 return in;
1798 /* Get the real object in case we were fed a hard link as an equivalent object */
1844 * then it is OK to just stuff it in since duplicate names are allowed.
2060 * block has only a few pages in use.
2346 (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
2364 ("Collecting block %d that has no chunks in use" TENDSTR),
2377 /* This page is in use and might need to be copied off */
2399 ("page %d in gc has no object "
2405 /* Data chunk in a deleted file, throw it away
2434 /* It's either a data chunk in a live file or
2435 * an ObjectHeader, so we're interested in it.
2447 * and if it is left in place it will mess up scanning.
2531 * The idea is to help clear out space in a more spread-out manner.
2563 /* We're in no hurry */
2608 static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
2617 yaffs_Device *dev = in->myDev;
2624 tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
2630 yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
2636 static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode,
2644 yaffs_Device *dev = in->myDev;
2652 tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
2659 yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
2662 /* Delete the entry in the filestructure (if found) */
2678 static int yaffs_CheckFileSanity(yaffs_Object * in)
2691 if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
2696 objId = in->objectId;
2697 fSize = in->variant.fileVariant.fileSize;
2699 (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
2702 tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant,
2713 yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk,
2717 (tags, in->objectId, chunk, chunkDeleted)) {
2736 static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
2745 yaffs_Device *dev = in->myDev;
2751 if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
2768 &in->variant.fileVariant,
2806 yaffs_FindChunkInFile(in, chunkInInode,
2815 ("yaffs tragedy: existing chunk < 0 in scan"
2828 (in->myDev->isYaffs2 ||
2851 in->nDataChunks++;
2859 static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
2862 int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL);
2865 return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
2872 memset(buffer, 0, in->myDev->nDataBytesPerChunk);
2936 static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode,
2951 yaffs_Device *dev = in->myDev;
2955 /* Get the previous chunk at this location in the file if it exists */
2956 prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
2962 newTags.objectId = in->objectId;
2972 yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0);
2979 yaffs_CheckFileSanity(in);
2988 int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
2994 yaffs_Device *dev = in->myDev;
3008 if (!in->fake || force) {
3012 buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
3015 prevChunkId = in->chunkId;
3025 oh->type = in->variantType;
3026 oh->yst_mode = in->yst_mode;
3030 oh->win_atime[0] = in->win_atime[0];
3031 oh->win_ctime[0] = in->win_ctime[0];
3032 oh->win_mtime[0] = in->win_mtime[0];
3033 oh->win_atime[1] = in->win_atime[1];
3034 oh->win_ctime[1] = in->win_ctime[1];
3035 oh->win_mtime[1] = in->win_mtime[1];
3037 oh->yst_uid = in->yst_uid;
3038 oh->yst_gid = in->yst_gid;
3039 oh->yst_atime = in->yst_atime;
3040 oh->yst_mtime = in->yst_mtime;
3041 oh->yst_ctime = in->yst_ctime;
3042 oh->yst_rdev = in->yst_rdev;
3044 if (in->parent) {
3045 oh->parentObjectId = in->parent->objectId;
3061 switch (in->variantType) {
3069 YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant.
3074 in->variant.hardLinkVariant.equivalentObjectId;
3084 in->variant.symLinkVariant.alias,
3092 in->serial++;
3094 newTags.objectId = in->objectId;
3095 newTags.serialNumber = in->serial;
3105 newTags.extraObjectType = in->variantType;
3107 /* Create new chunk in NAND */
3114 in->chunkId = newChunkId;
3121 if(!yaffs_ObjectHasCachedWriteData(in))
3122 in->dirty = 0;
3126 bi = yaffs_GetBlockInfo(in->myDev,
3127 newChunkId /in->myDev-> nChunksPerBlock);
3236 /* Find a dirty object in the cache and flush it...
3408 static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
3411 yaffs_Device *dev = in->myDev;
3416 if (dev->srCache[i].object == in) {
3608 static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
3612 yaffs_Device *dev = in->myDev;
3621 ok = yaffs_CheckpointTnodeWorker(in,
3704 /* Iterate through the objects in each hash entry,
3880 int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
3893 dev = in->myDev;
3901 /* OK now check for the curveball where the start and end are in
3910 cache = yaffs_FindChunkCache(in, chunk);
3912 /* If the chunk is already in the cache or it is less than a whole chunk
3919 /* If we can't find the data in the cache, then load it up. */
3922 cache = yaffs_GrabChunkCache(in->myDev);
3923 cache->object = in;
3927 yaffs_ReadChunkDataFromObject(in, chunk,
3951 yaffs_ReadChunkDataFromObject(in, chunk,
3972 yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
3986 yaffs_ReadChunkDataFromObject(in, chunk, buffer);
4000 int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
4016 dev = in->myDev;
4024 /* OK now check for the curveball where the start and end are in
4037 in->variant.fileVariant.fileSize -
4057 /* If we can't find the data in the cache, then load the cache */
4058 cache = yaffs_FindChunkCache(in, chunk);
4061 && yaffs_CheckSpaceForAllocation(in->
4063 cache = yaffs_GrabChunkCache(in->myDev);
4064 cache->object = in;
4068 yaffs_ReadChunkDataFromObject(in, chunk,
4074 !yaffs_CheckSpaceForAllocation(in->myDev)){
4118 yaffs_ReadChunkDataFromObject(in, chunk,
4131 yaffs_WriteChunkDataToObject(in, chunk,
4156 yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
4163 yaffs_WriteChunkDataToObject(in, chunk, buffer,
4168 yaffs_InvalidateChunkCache(in, chunk);
4182 if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) {
4183 in->variant.fileVariant.fileSize = (startOfWrite + nDone);
4186 in->dirty = 1;
4194 static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
4197 yaffs_Device *dev = in->myDev;
4198 int oldFileSize = in->variant.fileVariant.fileSize;
4216 chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL);
4227 in->nDataChunks--;
4235 int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
4238 int oldFileSize = in->variant.fileVariant.fileSize;
4242 yaffs_Device *dev = in->myDev;
4246 yaffs_FlushFilesChunkCache(in);
4247 yaffs_InvalidateWholeChunkCache(in);
4251 if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
4252 return yaffs_GetFileSize(in);
4261 yaffs_PruneResizedChunks(in, newSize);
4269 yaffs_ReadChunkDataFromObject(in, lastChunk,
4275 yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer,
4281 in->variant.fileVariant.fileSize = newSize;
4283 yaffs_PruneFileStructure(dev, &in->variant.fileVariant);
4287 * Do this only if the file is not in the deleted directories.
4289 if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
4290 in->parent->objectId != YAFFS_OBJECTID_DELETED) {
4291 yaffs_UpdateObjectHeader(in, NULL, 0,
4314 int yaffs_FlushFile(yaffs_Object * in, int updateTime)
4317 if (in->dirty) {
4318 yaffs_FlushFilesChunkCache(in);
4321 yfsd_WinFileTimeNow(in->win_mtime);
4324 in->yst_mtime = Y_CURRENT_TIME;
4330 (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
4340 static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
4343 /* First off, invalidate the file's data in the cache, without flushing. */
4344 yaffs_InvalidateWholeChunkCache(in);
4346 if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
4348 yaffs_ChangeObjectName(in, in->myDev->deletedDir, NULL, 0, 0);
4352 yaffs_RemoveObjectFromDirectory(in);
4353 yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
4354 in->chunkId = -1;
4356 yaffs_FreeObject(in);
4365 static int yaffs_UnlinkFile(yaffs_Object * in)
4373 if (!in->myInode) {
4378 if (in->inUse <= 0) {
4385 yaffs_ChangeObjectName(in, in->myDev->deletedDir,
4389 in->objectId));
4390 in->deleted = 1;
4391 in->myDev->nDeletedFiles++;
4392 if (0 && in->myDev->isYaffs2) {
4393 yaffs_ResizeFile(in, 0);
4395 yaffs_SoftDeleteFile(in);
4398 yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
4406 int yaffs_DeleteFile(yaffs_Object * in)
4410 if (in->nDataChunks > 0) {
4411 /* Use soft deletion if there is data in the file */
4412 if (!in->unlinked) {
4413 retVal = yaffs_UnlinkFile(in);
4415 if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
4416 in->deleted = 1;
4417 in->myDev->nDeletedFiles++;
4418 yaffs_SoftDeleteFile(in);
4420 return in->deleted ? YAFFS_OK : YAFFS_FAIL;
4423 yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
4424 in->variant.fileVariant.top = NULL;
4425 yaffs_DoGenericObjectDeletion(in);
4431 static int yaffs_DeleteDirectory(yaffs_Object * in)
4434 if (list_empty(&in->variant.directoryVariant.children)) {
4435 return yaffs_DoGenericObjectDeletion(in);
4442 static int yaffs_DeleteSymLink(yaffs_Object * in)
4444 YFREE(in->variant.symLinkVariant.alias);
4446 return yaffs_DoGenericObjectDeletion(in);
4449 static int yaffs_DeleteHardLink(yaffs_Object * in)
4454 list_del(&in->hardLinks);
4455 return yaffs_DoGenericObjectDeletion(in);
4582 * We put it in unlinked dir to be cleaned up after the scanning
4602 yaffs_Object *in;
4608 in = yaffs_FindObjectByNumber(dev,
4612 if (in) {
4614 hl->variant.hardLinkVariant.equivalentObject = in;
4615 list_add(&hl->hardLinks, &in->hardLinks);
4664 yaffs_Object *in;
4775 /* get the block to scan in the correct order */
4786 /* For each chunk in each block that needs scanning....*/
4805 /* An unassigned chunk in the block
4811 /* We're looking at the first chunk in the block so the block is unused */
4848 in = yaffs_FindOrCreateObjectByNumber(dev,
4855 yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,
4860 if (in->variantType == YAFFS_OBJECT_TYPE_FILE
4861 && in->variant.fileVariant.scannedFileSize <
4863 in->variant.fileVariant.
4866 in->variant.fileVariant.
4868 in->variant.fileVariant.
4876 * Thus, we read in the object header and make the object
4887 in = yaffs_FindObjectByNumber(dev,
4889 if (in && in->variantType != oh->type) {
4895 yaffs_DestroyObject(in);
4897 in = 0;
4900 in = yaffs_FindOrCreateObjectByNumber(dev,
4912 if (in->valid) {
4915 unsigned existingSerial = in->serial;
4923 in->chunkId,
4925 in->valid = 0;
4933 if (!in->valid &&
4937 in->valid = 1;
4938 in->variantType = oh->type;
4940 in->yst_mode = oh->yst_mode;
4942 in->win_atime[0] = oh->win_atime[0];
4943 in->win_ctime[0] = oh->win_ctime[0];
4944 in->win_mtime[0] = oh->win_mtime[0];
4945 in->win_atime[1] = oh->win_atime[1];
4946 in->win_ctime[1] = oh->win_ctime[1];
4947 in->win_mtime[1] = oh->win_mtime[1];
4949 in->yst_uid = oh->yst_uid;
4950 in->yst_gid = oh->yst_gid;
4951 in->yst_atime = oh->yst_atime;
4952 in->yst_mtime = oh->yst_mtime;
4953 in->yst_ctime = oh->yst_ctime;
4954 in->yst_rdev = oh->yst_rdev;
4956 in->chunkId = chunk;
4958 } else if (!in->valid) {
4961 in->valid = 1;
4962 in->variantType = oh->type;
4964 in->yst_mode = oh->yst_mode;
4966 in->win_atime[0] = oh->win_atime[0];
4967 in->win_ctime[0] = oh->win_ctime[0];
4968 in->win_mtime[0] = oh->win_mtime[0];
4969 in->win_atime[1] = oh->win_atime[1];
4970 in->win_ctime[1] = oh->win_ctime[1];
4971 in->win_mtime[1] = oh->win_mtime[1];
4973 in->yst_uid = oh->yst_uid;
4974 in->yst_gid = oh->yst_gid;
4975 in->yst_atime = oh->yst_atime;
4976 in->yst_mtime = oh->yst_mtime;
4977 in->yst_ctime = oh->yst_ctime;
4978 in->yst_rdev = oh->yst_rdev;
4980 in->chunkId = chunk;
4982 yaffs_SetObjectName(in, oh->name);
4983 in->dirty = 0;
5011 " a directory in scan. Put in lost+found."
5016 yaffs_AddObjectToDirectory(parent, in);
5020 in->deleted = 1; /* If it is unlinked at start up then it wants deleting */
5025 * we put them all in a list.
5030 switch (in->variantType) {
5039 (in, oh->fileSize);
5046 in->variant.fileVariant.
5052 in->variant.hardLinkVariant.
5055 in->hardLinks.next =
5058 hardList = in;
5067 in->variant.symLinkVariant.
5074 yaffs_DestroyObject(in);
5110 /* Handle the unlinked files. Since they were left in an unlinked state we should
5136 static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
5140 yaffs_Device *dev = in->myDev;
5144 if(in->lazyLoaded){
5145 in->lazyLoaded = 0;
5148 result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
5151 in->yst_mode = oh->yst_mode;
5153 in->win_atime[0] = oh->win_atime[0];
5154 in->win_ctime[0] = oh->win_ctime[0];
5155 in->win_mtime[0] = oh->win_mtime[0];
5156 in->win_atime[1] = oh->win_atime[1];
5157 in->win_ctime[1] = oh->win_ctime[1];
5158 in->win_mtime[1] = oh->win_mtime[1];
5160 in->yst_uid = oh->yst_uid;
5161 in->yst_gid = oh->yst_gid;
5162 in->yst_atime = oh->yst_atime;
5163 in->yst_mtime = oh->yst_mtime;
5164 in->yst_ctime = oh->yst_ctime;
5165 in->yst_rdev = oh->yst_rdev;
5168 yaffs_SetObjectName(in, oh->name);
5170 if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
5171 in->variant.symLinkVariant.alias =
5196 yaffs_Object *in;
5345 /* get the block to scan in the correct order */
5353 /* For each chunk in each block that needs scanning.... */
5369 /* An unassigned chunk in the block.
5383 /* We're looking at the first chunk in the block so the block is unused */
5432 in = yaffs_FindOrCreateObjectByNumber(dev,
5436 if (in->variantType == YAFFS_OBJECT_TYPE_FILE
5438 in->variant.fileVariant.shrinkSize) {
5440 yaffs_PutChunkIntoFile(in, tags.chunkId,
5451 if (!in->valid && /* have not got an object header yet */
5452 in->variant.fileVariant.
5454 in->variant.fileVariant.
5456 in->variant.fileVariant.
5458 in->variant.fileVariant.
5469 * Thus, we read in the object header and make the object
5477 in = NULL;
5480 in = yaffs_FindOrCreateObjectByNumber
5485 if (!in ||
5487 !in->valid ||
5490 (!in->valid &&
5507 if (!in)
5508 in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
5512 if (!in) {
5522 if (in->valid) {
5528 if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
5557 in->variant.fileVariant.
5559 in->variant.fileVariant.
5574 if (!in->valid &&
5579 in->valid = 1;
5582 in->variantType = oh->type;
5584 in->yst_mode = oh->yst_mode;
5586 in->win_atime[0] = oh->win_atime[0];
5587 in->win_ctime[0] = oh->win_ctime[0];
5588 in->win_mtime[0] = oh->win_mtime[0];
5589 in->win_atime[1] = oh->win_atime[1];
5590 in->win_ctime[1] = oh->win_ctime[1];
5591 in->win_mtime[1] = oh->win_mtime[1];
5593 in->yst_uid = oh->yst_uid;
5594 in->yst_gid = oh->yst_gid;
5595 in->yst_atime = oh->yst_atime;
5596 in->yst_mtime = oh->yst_mtime;
5597 in->yst_ctime = oh->yst_ctime;
5598 in->yst_rdev = oh->yst_rdev;
5602 in->variantType = tags.extraObjectType;
5603 in->lazyLoaded = 1;
5606 in->chunkId = chunk;
5608 } else if (!in->valid) {
5611 in->valid = 1;
5612 in->chunkId = chunk;
5615 in->variantType = oh->type;
5617 in->yst_mode = oh->yst_mode;
5619 in->win_atime[0] = oh->win_atime[0];
5620 in->win_ctime[0] = oh->win_ctime[0];
5621 in->win_mtime[0] = oh->win_mtime[0];
5622 in->win_atime[1] = oh->win_atime[1];
5623 in->win_ctime[1] = oh->win_ctime[1];
5624 in->win_mtime[1] = oh->win_mtime[1];
5626 in->yst_uid = oh->yst_uid;
5627 in->yst_gid = oh->yst_gid;
5628 in->yst_atime = oh->yst_atime;
5629 in->yst_mtime = oh->yst_mtime;
5630 in->yst_ctime = oh->yst_ctime;
5631 in->yst_rdev = oh->yst_rdev;
5641 yaffs_SetObjectName(in, oh->name);
5653 in->variantType = tags.extraObjectType;
5661 in->lazyLoaded = 1;
5664 in->dirty = 0;
5688 " a directory in scan. Put in lost+found."
5693 yaffs_AddObjectToDirectory(parent, in);
5705 * we put them all in a list.
5710 switch (in->variantType) {
5716 if (in->variant.fileVariant.
5723 in->variant.fileVariant.fileSize = fileSize;
5724 in->variant.fileVariant.scannedFileSize =
5725 in->variant.fileVariant.fileSize;
5729 in->variant.fileVariant.shrinkSize > fileSize) {
5730 in->variant.fileVariant.shrinkSize = fileSize;
5736 in->variant.hardLinkVariant.equivalentObjectId =
5738 in->hardLinks.next =
5740 hardList = in;
5751 in->variant.symLinkVariant.alias =
6419 dev->tempBuffer[i].line = 0; /* not in use */
6572 /* Now count the number of dirty chunks in the cache and subtract those */