
	Where results make sense

Topic: JFFS2

In the News (Tue 2 Dec 08)

Crimson Tide

Tommy Tuberville

Bill Clinton

Wayne Rooney

Vilasrao Deshmukh

Wake Forest

Grand Slam

Oklahoma State

Adelaide Oval

Civil War

	Flash Filesystems for Embedded Linux Systems \| Linux Journal
		The jffs2 filesystem is currently in development but is extremely useful; it should be stable by publication of this article.
		The jffs2 filesystem is new and in the process of being integrated into the kernel sources.
		By using the jffs2 filesystem, the Accelent system software solution allows units to be powered off at any time, yet allows the user to write data to the filesystem that is preserved between reboots.
	www.linuxjournal.com /article/4678 (1642 words)

	JFFS2 - Wikipedia, the free encyclopedia
		The Journalling Flash File System version 2 or JFFS2 is a log-structured file system for use in flash memory devices.
		JFFS2 has been included in the Linux kernel since the 2.4.10 release.
		Instead, JFFS2 deals in blocks, a unit the same size as the erase segment of the flash medium.
	en.wikipedia.org /wiki/JFFS2 (397 words)

	JFFS2: The Journalling Flash File System, version 2 (Site not responding. Last check: 2007-10-19)
		JFFS2 is a log-structured file system designed for use on flash devices in embedded systems.
		Rather than using a kind of translation layer on flash devices to emulate a normal hard drive, as is the case with older flash solutions, it places the filesystem directly on the flash chips.
		JFFS2 was developed by Red Hat, based on the work started in the original JFFS by Axis Communications, AB.
	sources.redhat.com /jffs2 (275 words)

	Using JFFS2
		JFFS2 has built-in tolerance of Flash errors when erasing and should adapt and work around bit errors that arise as Flash reaches the end of its working life.
		JFFS2 does not guarantee 100% optimal use of Flash space due to its journalling nature, and the granularity of Flash blocks.
		However, it may be more memory efficient to disable JFFS2 compression entirely in the CDL configuration, and instead ensure that images are stored compressed when they are downloaded, and use the standard RedBoot mechanism to decompress the files upon loading.
	www.ecoscentric.com /ecospro/doc/html/ecospro-ref/fs-jffs2-usage.html (815 words)

	Linux: LogFS, A New Flash Filesystem \| KernelTrap (Site not responding. Last check: 2007-10-19)
		Unlike most filesystems, there is no tree structure of any sorts on the medium, so the complete medium needs to be scanned at mount time and a tree structure kept in-memory while the filesystem is mounted.
		JFFS2 has recently gained summary support, which helps reduce mount time by a constant factor.
		OTOH, the days of jffs2 (jffs has recently been removed) are numbered, because of the inherent scalability problems arising from the need to read all metadata into RAM at mount time.
	kerneltrap.org /node/8159 (2181 words)

	JFFS2 NAND Flash support arrives in stable Linux tree
		According Red Hat's David Woodhouse, JFFS2 on NAND has received heavy testing under the 2.4 kernel, and is present in the handhelds.org kernel tree.
		JFFS2 is a journaling filesystem for flash devices that handles wear-leveling and other restrictions of Flash technology efficiently.
		JFFS2 for NOR Flash has been officially stable since the 2.4.12 Linux kernel release.
	www.linuxdevices.com /news/NS7386103729.html (565 words)

	JFFS2 Support — Flash Linux Portal (Site not responding. Last check: 2007-10-19)
		JFFS2 is a filesystem that was designed to run on flash memory (i.e.
		Because JFFS2 compresses on the fly (as opposed to requiring a static image currently used by cramfs in the current FlashLinux) it may be possible to make the entire FlashLinux filesystem read-write.
		One solution being looked at is to provide a complete QEMU environment on windows from which to install FlashLinux onto a key.
	flashlinux.org.uk /old_news/jffs (305 words)

	MAKING IT YOUR ADVANTAGE (Site not responding. Last check: 2007-10-19)
		The second version, JFFS2, is emerging as the de facto filesystem for raw flash chips for tiny embedded devices.
		JFFS2 performs flash erase/write/read on the sector level better than the Ext2 filesystem.
		JFFS2 can tend to slow down a great deal when the filesystem is full or nearly full.
	www.ciol.com /content/search/showarticle.asp?arid=33638&pageNo=5 (683 words)

	TechOnLine - Linux System Development on an Embedded Device
		To do this, it may be necessary to create a partition table to separate the flash device into a bootloader section, a kernel section, and a filesystem section.
		The main aim of the MTD subsystem in Linux is to provide a generic interface between the hardware drivers and the upper layers, or user modules, of the system.
		Once the JFFS2 filesystem is created, it is loaded into the appropriate location in flash (at the address where the bootloader tells the kernel to look for the filesystem) so that the kernel can mount it.
	www.techonline.com /community/tech_topic/linux/20704?csp_id=245 (0 words)

	OpenWrtDocs/Jffs2Root - OpenWrt
		Note: as of White Russian RC4, the jffs2 filesystem is always reinitialised when you replace the squashfs filesystem.
		It is important, when using the Jffs2 root, to use an image built for the correct Flash RAM size.
		This does not work very well with Jffs2 images because it ends up saving and restoring everything, including the files which are part of the system and which may have changed for good reasons.
	wiki.openwrt.org /OpenWrtDocs/Jffs2Root (1191 words)

	Linux system development on an embedded device
		To do this, it may be necessary to create a partition table to separate the flash device into a bootloader section, a kernel section, and a filesystem section.
		The main aim of the MTD subsystem in Linux is to provide a generic interface between the hardware drivers and the upper layers, or user modules, of the system.
		Once the JFFS2 filesystem is created, it is loaded into the appropriate location in flash (at the address where the bootloader tells the kernel to look for the filesystem) so that the kernel can mount it.
	www-128.ibm.com /developerworks/library/l-embdev.html (6583 words)

	RootFileSystemOnAJFFS2FileSystem < DULG < DENX
		JFFS2 (Journalling Flash File System version 2) was specifically designed for use on flash memory devices in embedded systems.
		The garbage collector thread may run at any time, consuming CPU cycles and blocking accesses to the file system.
		Despite the aforementioned disadvantages, systems using a JFFS2 based root file system are easy to build, make efficient use of the available resources and can run pretty reliably.
	www.denx.de /wiki/view/DULG/RootFileSystemOnAJFFS2FileSystem (0 words)

	OpenWrt
		The squashfs partition is moved from root to "/rom" and jffs2 takes over as the root filesystem in what can best be described as a "poor man's overlay filesystem"; each file on the jffs2 partition starts out as a symlink to the squashfs filesystem on /rom.
		As mentioned earlier in the flash section, the jffs2 partition can't be stored as part of the firmware or any changes to the filesystem would alter the firmware's CRC and it would be seen as a corrupt firmware.
		The answer to how the jffs2 layout works can only be described as the very definition of a hack -- the jffs2 filesystem is part of the firmware, but only up util the first bootup.
	downloads.openwrt.org /people/mbm/openwrt.html (0 words)

	[kaffe] Placing kaffe on embedded devices
		The jar-file compression is indeed more efficient than jffs2, because jffs2 compresses each page invidually (typically 4k chunks) specifically to allow easy decompression on limited resource devices.
		So while I wouldn't take position on whether jffs2 or jar compression is better, as that depends on the specific application, they should not be used at the same time.
		Note: Technically jffs2 compression could be turned off for pre-compressed files, on case-by-case basis, or the compression algorithm could be replaced with one more efficient on class/jar-files; but that's beyond the scope of the document ;) Ps.
	www.kaffe.org /pipermail/kaffe/2002-June/091661.html (0 words)

	JFFS2 mount on SuSE 9.3 fails - LinuxQuestions.org
		JFFS2 is a file system for flash memory storage.
		It's from IBM and has a good reputation as a general purpose file system with good overall read and write performance on large and small files alike.
		JFFS2 images need to be mounted through the MTD block device for it to work properly.
	www.linuxquestions.org /questions/showthread.php?t=336725 (0 words)

	gmane.linux.file-systems.jffs
		Hello, on doing some tests with JFFS2 (agreed not the latest version) I found a serious problem: a CRC error in the data part of a node never gets through to an application reading the file containing the erronous node.
		My test case was this: On a read-only filesystem I did a md5sum of the file, afterwards changed some bytes in the data part of one of the nodes belonging to that file through /dev/mtdblock1, and did the md5sum again.
		Exporting jffs2 by nfs with kernel 2.6 (6 Sep 17:38)
	blog.gmane.org /gmane.linux.file-systems.jffs (0 words)

	HOW TO use MTD/JFFS2 under µClinux. (c) pk/enseirb/2003
		By design, JFFS (and subsequently JFFS2) is designed to guarantee 1 (more on this in a minute) meta-data or "formatting" reliability of the file system layer.
		JFFS2 is the second version in the JFFS anthology.
		Then the older part can be marked for garbage collection and deleted during the erase of the sector in which it resides when all its neighbors have been either similarly marked or moved to another sector.
	www.enseirb.fr /~kadionik/embedded/uclinux/mtd/howto_mtd.html (2115 words)

	enabling_jffs2 [Blackfin Linux Docs]
		JFFS2 - is a file system designed for use on flash devices in embedded systems.
		) with a ramfs, and mount a secondary jffs2 filesystem.
		Sometimes it may be useful to mount the jffs2 image via loop on your development system.
	docs.blackfin.uclinux.org /doku.php?id=enabling_jffs2 (2220 words)

	Forensic Focus › Content › Papers › Forensic Image Analysis of Familiar-based iPAQ (Site not responding. Last check: 2007-10-19)
		JFFS2 used in certain Linux PDA further complicate the forensic process as compression is implemented in this file system.
		Unlike JFFS which treat the flash medium as a single circular log, JFFS2 deals in blocks, which is the same size as erase segment of the flash medium.
		JFFS2 always starts writing node from the beginning of an erase block and sequentially until the block is filled.
	www.forensicfocus.com /familiar-ipaq-forensic-analysis (6120 words)

	ARMLinux @ Simtec - ARM Linux FAQ
		JFFS2 has a limit on how much memory it will use for erase block tables, and thus reduces the number on devices that are too large.
		This warning is due to the JFFS2 image being created with a different eraseblock size to the one being used by JFFS2.
		This may be due to not specifying the eraseblock size to mkfs.jffs2, or due to JFFS2 enlarging the eraseblock size due to memory limits.
	armlinux.simtec.co.uk /faq.html (999 words)

	Announcing JFFS2 -- improved embedded Linux flash file system
		Well, it's been almost a week since the latest stupid bug was found in the JFFS2 code, so I suppose it's time to admit to the world that it exists.
		JFFS2, developed by Red Hat, is a complete reimplementation of a journaling filesystem for FLASH devices, based on the original JFFS from Axis Communications AB.
		JFFS2 filesystem images of the current Familiar distribution for the Compaq iPAQ, along with appropriate kernels, are available here.
	linuxdevices.com /news/NS7100197000.html (405 words)

	NSLU2-Linux - HowTo / AddJFFS2SupportUsingATrailerPartitionTable browse
		Then create a jffs2 partition in the "Rootdisk" area, and see if the kernel can mount it.
		jacques: can the start of the jffs2 paritition be read from the last block (before sercomm header) at boot, and then mtdblock4 created based on that, and then the ramdisk loads it - then we can have varying sizes of ramdisk and jfffs2
		partition table that only allows the boundary between ramdisk and jffs2 to be moved.
	www.nslu2-linux.org /wiki/HowTo/AddJFFS2SupportUsingATrailerPartitionTable (1178 words)

	Linux-MTD NAND FLASH
		YAFFS is faster than JFFS2 and consumes less RAM, JFFS2 provides on the fly file compression and decompression, which is very helpfull for small FLASHs.
		JFFS2 and YAFFS include bad block management, wear leveling, error correction and provide reliable filesystems for industrial use on top of NAND Flash.
		The latest changes to JFFS2 and the underlying NAND code are not in the kernel code at the moment.
	www.linux-mtd.infradead.org /archive/tech/nand.html (2043 words)

	Manpage of MKFS.JFFS2 (Site not responding. Last check: 2007-10-19)
		The program mkfs.jffs2 creates a JFFS2 (Second Journaling Flash Filesystem) filesystem image and writes the resulting image to the file specified by the option -o or to the standard output by default.
		It is unlikely that JFFS2 images are useful except in conjuction with the MTD (Memory Technology Device) drivers in the Linux kernel, since the JFFS2 filesystem driver in the kernel requires MTD devices.
		JFFS2 limits device major and minor numbers to 8 bits each.
	www.buserror.org /~ebrown/sshf2001/download/utils/mkfs.jffs2.1.html (327 words)

	JFFS2 alignment (Site not responding. Last check: 2007-10-19)
		JFFS2 in 2.6 (on my device) ain't handling small scattered writes very well.
		Normal files work all right though, but when it comes to making thousands of writes, all about 15 - 30 bytes each, the filesystem overhead simply gets huge and appear to leak (although it doesn't).
		To somewhat mitigate the situation here is a little test-library to minize the vast overhead.
	www.arbetsmyra.dyndns.org /jffs2align/?N=D (182 words)

	JFFS2 improvement project (Site not responding. Last check: 2007-10-19)
		At JFFS2 there is a compr field in the struct jffs2_raw_inode to identify the compression method used in that node.
		You should use the latest JFFS2 snaphot from MTD CVS.
		There will be two versions of mkfs.jffs2: an old one and a new one.
	www.inf.u-szeged.hu /jffs2/compression.php (310 words)

	Applied Data Support Forums - Debian JFFS2 2006-10-09 (Etch)
		Debian JFFS2 2006-10-09 is a root file system that is derived from the Debian (Etch) distribution and is trimmed down to fit (compressed) in a partition in on-board flash as small as 15MB.
		The JFFS2 filesystem is a persistent flash filesystem that keeps changes across reboots - it is not always the same on each boot (like the ramdisk).
		Although it is designed to be resilient in the case of power loss and unclean shutdown/dismount, you should shut down your JFFS2 system properly (using the 'shutdown' command) to cleanly unmount the root filesystem.
	www.applieddata.net /forums/topic.asp?TOPIC_ID=2246 (751 words)

	OpenWrt / RC6 filesystem ideas
		This would replace the current method of symlinking the jffs2 partition to squashfs, which currenly takes around 350k of space on the jffs2 partition.
		The squashfs images contain a "dirty flag" in the firmware images which trigger an automatic reformatting of the jffs2 filesystem; this is done to ensure filesystem integrity after an upgrade since the jffs2 filesystem resides immediately after squashfs and may become corrupted or otherwise invalidated by the upgrade process.
		The combination of squashfs and jffs2 is perfect for this and if mini_fo works well enough to use at some stage in the boot process with pivot_root or similar, to make the root filesystem appear read/write then I'm happy.
	forum.openwrt.org /viewtopic.php?id=5067 (1348 words)

	Embedded Linux - Managing Flash Memory
		JFFS2 is a journaling flash filesystem (hence the name) – the ‘2’ distinguishes JFFS2 from the JFFS filesystem, a largely defunct predecessor.
		JFFS2 bypasses the block device layer (with its associated buffer cache) and writes directly to the underlying flash device.
		If the cleanmarker or another node type is not present in the block, JFFS2 will redo the erase operation and write the cleanmarker at the beginning of the block.
	www.ssiembedded.com /embedded_linux_managing_memory.html (1806 words)

	Mounting a block device with JFFS2 - Gentoo Linux Wiki
		Makes a jffs2 image, the --eraseblock=256000000 is number of bytes, in later versions of mkfs.jffs2 you can use sci notation
		Uses a loop to make the jffs2 image file a block device.
		These were performed multiple times, the times represent the actual time of a typical run.
	gentoo-wiki.com /Mounting_a_block_device_with_JFFS2 (275 words)

Try your search on: Qwika (all wikis)