linux/fs/jffs2/wbuf.c

/*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
 * Copyright © 2001-2007 Red Hat, Inc.
 * Copyright © 2004 Thomas Gleixner <[email protected]>
 *
 * Created by David Woodhouse <[email protected]>
 * Modified debugged and enhanced by Thomas Gleixner <[email protected]>
 *
 * For licensing information, see the file 'LICENCE' in this directory.
 *
 */

#define pr_fmt(fmt) …

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mtd/mtd.h>
#include <linux/crc32.h>
#include <linux/mtd/rawnand.h>
#include <linux/jiffies.h>
#include <linux/sched.h>
#include <linux/writeback.h>

#include "nodelist.h"

/* For testing write failures */
#undef BREAKME
#undef BREAKMEHEADER

#ifdef BREAKME
static unsigned char *brokenbuf;
#endif

#define PAGE_DIV(x) …
#define PAGE_MOD(x) …

/* max. erase failures before we mark a block bad */
#define MAX_ERASE_FAILURES …

struct jffs2_inodirty { … };

static struct jffs2_inodirty inodirty_nomem;

static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
{ … }

static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
{ … }

static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
{ … }

static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
{ … }

#define REFILE_NOTEMPTY …
#define REFILE_ANYWAY …

static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
{ … }

static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
							    struct jffs2_inode_info *f,
							    struct jffs2_raw_node_ref *raw,
							    union jffs2_node_union *node)
{ … }

#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
			      uint32_t ofs)
{ … }
#else
#define jffs2_verify_write …
#endif

/* Recover from failure to write wbuf. Recover the nodes up to the
 * wbuf, not the one which we were starting to try to write. */

static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
{ … }

/* Meaning of pad argument:
   0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
   1: Pad, do not adjust nextblock free_size
   2: Pad, adjust nextblock free_size
*/
#define NOPAD …
#define PAD_NOACCOUNT …
#define PAD_ACCOUNTING …

static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
{ … }

/* Trigger garbage collection to flush the write-buffer.
   If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
   outstanding. If ino arg non-zero, do it only if a write for the
   given inode is outstanding. */
int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
{ … }

/* Pad write-buffer to end and write it, wasting space. */
int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
{ … }

static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
			      size_t len)
{ … }

int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
		       unsigned long count, loff_t to, size_t *retlen,
		       uint32_t ino)
{ … }

/*
 *	This is the entry for flash write.
 *	Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
*/
int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
		      size_t *retlen, const u_char *buf)
{ … }

/*
	Handle readback from writebuffer and ECC failure return
*/
int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
{ … }

#define NR_OOB_SCAN_PAGES …

/* For historical reasons we use only 8 bytes for OOB clean marker */
#define OOB_CM_SIZE …

static const struct jffs2_unknown_node oob_cleanmarker = …;

/*
 * Check, if the out of band area is empty. This function knows about the clean
 * marker and if it is present in OOB, treats the OOB as empty anyway.
 */
int jffs2_check_oob_empty(struct jffs2_sb_info *c,
			  struct jffs2_eraseblock *jeb, int mode)
{ … }

/*
 * Check for a valid cleanmarker.
 * Returns: 0 if a valid cleanmarker was found
 *	    1 if no cleanmarker was found
 *	    negative error code if an error occurred
 */
int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
				 struct jffs2_eraseblock *jeb)
{ … }

int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
				 struct jffs2_eraseblock *jeb)
{ … }

/*
 * On NAND we try to mark this block bad. If the block was erased more
 * than MAX_ERASE_FAILURES we mark it finally bad.
 * Don't care about failures. This block remains on the erase-pending
 * or badblock list as long as nobody manipulates the flash with
 * a bootloader or something like that.
 */

int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
{ … }

static struct jffs2_sb_info *work_to_sb(struct work_struct *work)
{ … }

static void delayed_wbuf_sync(struct work_struct *work)
{ … }

void jffs2_dirty_trigger(struct jffs2_sb_info *c)
{ … }

int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
{ … }

void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
{ … }

int jffs2_dataflash_setup(struct jffs2_sb_info *c) { … }

void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) { … }

int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) { … }

void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) { … }

int jffs2_ubivol_setup(struct jffs2_sb_info *c) { … }

void jffs2_ubivol_cleanup(struct jffs2_sb_info *c) { … }