--- zzzz-none-000/linux-2.4.17/fs/jffs2/write.c 2001-10-04 22:13:18.000000000 +0000 +++ sangam-fb-322/linux-2.4.17/fs/jffs2/write.c 2004-11-24 13:22:18.000000000 +0000 @@ -1,7 +1,7 @@ /* * JFFS2 -- Journalling Flash File System, Version 2. * - * Copyright (C) 2001 Red Hat, Inc. + * Copyright (C) 2001, 2002 Red Hat, Inc. * * Created by David Woodhouse * @@ -31,64 +31,74 @@ * provisions above, a recipient may use your version of this file * under either the RHEPL or the GPL. * - * $Id: write.c,v 1.28 2001/05/01 16:25:25 dwmw2 Exp $ + * $Id: write.c,v 1.1.1.1 2003/06/23 22:18:37 jharrell Exp $ * */ #include #include -#include +#include #include #include "nodelist.h" #include "crc32.h" + +int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri) +{ + struct jffs2_inode_cache *ic; + + ic = jffs2_alloc_inode_cache(); + if (!ic) { + return -ENOMEM; + } + memset(ic, 0, sizeof(*ic)); + + init_MUTEX_LOCKED(&f->sem); + f->inocache = ic; + f->inocache->nlink = 1; + f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; + f->inocache->ino = ri->ino = ++c->highest_ino; + D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", ri->ino)); + jffs2_add_ino_cache(c, f->inocache); + + ri->magic = JFFS2_MAGIC_BITMASK; + ri->nodetype = JFFS2_NODETYPE_INODE; + ri->totlen = PAD(sizeof(*ri)); + ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4); + ri->mode = mode; + f->highest_version = ri->version = 1; + + return 0; +} + /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, fill in the raw_inode while you're at it. */ struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri) { struct inode *inode; struct super_block *sb = dir_i->i_sb; - struct jffs2_inode_cache *ic; struct jffs2_sb_info *c; struct jffs2_inode_info *f; + int ret; D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); c = JFFS2_SB_INFO(sb); - memset(ri, 0, sizeof(*ri)); - - ic = jffs2_alloc_inode_cache(); - if (!ic) { - return ERR_PTR(-ENOMEM); - } - memset(ic, 0, sizeof(*ic)); inode = new_inode(sb); - if (!inode) { - jffs2_free_inode_cache(ic); + if (!inode) return ERR_PTR(-ENOMEM); - } /* Alloc jffs2_inode_info when that's split in 2.5 */ f = JFFS2_INODE_INFO(inode); memset(f, 0, sizeof(*f)); - init_MUTEX_LOCKED(&f->sem); - f->inocache = ic; - inode->i_nlink = f->inocache->nlink = 1; - f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; - f->inocache->ino = ri->ino = inode->i_ino = ++c->highest_ino; - D1(printk(KERN_DEBUG "jffs2_new_inode(): Assigned ino# %d\n", ri->ino)); - jffs2_add_ino_cache(c, f->inocache); - ri->magic = JFFS2_MAGIC_BITMASK; - ri->nodetype = JFFS2_NODETYPE_INODE; - ri->totlen = PAD(sizeof(*ri)); - ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4); - ri->mode = mode; - f->highest_version = ri->version = 1; + memset(ri, 0, sizeof(*ri)); + /* Set OS-specific defaults for new inodes */ ri->uid = current->fsuid; + if (dir_i->i_mode & S_ISGID) { ri->gid = dir_i->i_gid; if (S_ISDIR(mode)) @@ -96,6 +106,15 @@ } else { ri->gid = current->fsgid; } + ri->mode = mode; + ret = jffs2_do_new_inode (c, f, mode, ri); + if (ret) { + make_bad_inode(inode); + iput(inode); + return ERR_PTR(ret); + } + inode->i_nlink = 1; + inode->i_ino = ri->ino; inode->i_mode = ri->mode; inode->i_gid = ri->gid; inode->i_uid = ri->uid; @@ -131,21 +150,21 @@ } -static inline int mtd_writev(struct mtd_info *mtd, const struct iovec *vecs, unsigned long count, loff_t to, size_t *retlen) +static inline int jffs2_flash_writev(struct jffs2_sb_info *c, const struct iovec *vecs, unsigned long count, loff_t to, size_t *retlen) { - if (mtd->writev) - return mtd->writev(mtd,vecs,count,to,retlen); + if (c->mtd->writev) + return c->mtd->writev(c->mtd, vecs, count, to, retlen); else - return mtd_fake_writev(mtd, vecs, count, to, retlen); + return mtd_fake_writev(c->mtd, vecs, count, to, retlen); } -static void writecheck(struct mtd_info *mtd, __u32 ofs) +static void writecheck(struct jffs2_sb_info *c, uint32_t ofs) { unsigned char buf[16]; - ssize_t retlen; + size_t retlen; int ret, i; - ret = mtd->read(mtd, ofs, 16, &retlen, buf); + ret = jffs2_flash_read(c, ofs, 16, &retlen, buf); if (ret && retlen != 16) { D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %d\n", ret, retlen)); return; @@ -170,14 +189,12 @@ /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, write it to the flash, link it into the existing inode/fragment list */ -struct jffs2_full_dnode *jffs2_write_dnode(struct inode *inode, struct jffs2_raw_inode *ri, const unsigned char *data, __u32 datalen, __u32 flash_ofs, __u32 *writelen) +struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, uint32_t *writelen) { - struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); - struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); struct jffs2_raw_node_ref *raw; struct jffs2_full_dnode *fn; - ssize_t retlen; + size_t retlen; struct iovec vecs[2]; int ret; @@ -191,7 +208,7 @@ vecs[1].iov_base = (unsigned char *)data; vecs[1].iov_len = datalen; - writecheck(c->mtd, flash_ofs); + writecheck(c, flash_ofs); if (ri->totlen != sizeof(*ri) + datalen) { printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08x) + datalen (0x%08x)\n", ri->totlen, sizeof(*ri), datalen); @@ -207,8 +224,6 @@ } raw->flash_offset = flash_ofs; raw->totlen = PAD(ri->totlen); - raw->next_in_ino = f->inocache->nodes; - f->inocache->nodes = raw; raw->next_phys = NULL; fn->ofs = ri->offset; @@ -216,12 +231,20 @@ fn->frags = 0; fn->raw = raw; - ret = mtd_writev(c->mtd, vecs, 2, flash_ofs, &retlen); + ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen); if (ret || (retlen != sizeof(*ri) + datalen)) { printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %d\n", sizeof(*ri)+datalen, flash_ofs, ret, retlen); /* Mark the space as dirtied */ if (retlen) { + /* Doesn't belong to any inode */ + raw->next_in_ino = NULL; + + /* Don't change raw->size to match retlen. We may have + written the node header already, and only the data will + seem corrupted, in which case the scan would skip over + any node we write before the original intended end of + this node */ jffs2_add_physical_node_ref(c, raw, sizeof(*ri)+datalen, 1); jffs2_mark_node_obsolete(c, raw); } else { @@ -237,6 +260,11 @@ } /* Mark the space used */ jffs2_add_physical_node_ref(c, raw, retlen, 0); + + /* Link into per-inode list */ + raw->next_in_ino = f->inocache->nodes; + f->inocache->nodes = raw; + D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n", flash_ofs, ri->dsize, ri->csize, ri->node_crc, ri->data_crc, ri->totlen)); if (writelen) *writelen = retlen; @@ -245,18 +273,16 @@ return fn; } -struct jffs2_full_dirent *jffs2_write_dirent(struct inode *inode, struct jffs2_raw_dirent *rd, const unsigned char *name, __u32 namelen, __u32 flash_ofs, __u32 *writelen) +struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, uint32_t *writelen) { - struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); - struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); struct jffs2_raw_node_ref *raw; struct jffs2_full_dirent *fd; - ssize_t retlen; + size_t retlen; struct iovec vecs[2]; int ret; D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", rd->pino, name, name, rd->ino, rd->name_crc)); - writecheck(c->mtd, flash_ofs); + writecheck(c, flash_ofs); D1(if(rd->hdr_crc != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); @@ -293,7 +319,7 @@ fd->name[namelen]=0; fd->raw = raw; - ret = mtd_writev(c->mtd, vecs, 2, flash_ofs, &retlen); + ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen); if (ret || (retlen != sizeof(*rd) + namelen)) { printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %d\n", sizeof(*rd)+namelen, flash_ofs, ret, retlen); @@ -320,3 +346,107 @@ f->inocache->nodes = raw; return fd; } + +/* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that + we don't have to go digging in struct inode or its equivalent. It should set: + mode, uid, gid, (starting)isize, atime, ctime, mtime */ +int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, + struct jffs2_raw_inode *ri, unsigned char *buf, + uint32_t offset, uint32_t writelen, uint32_t *retlen) +{ + int ret = 0; + uint32_t writtenlen = 0; + + D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", + f->inocache->ino, offset, writelen)); + + while(writelen) { + struct jffs2_full_dnode *fn; + unsigned char *comprbuf = NULL; + unsigned char comprtype = JFFS2_COMPR_NONE; + uint32_t phys_ofs, alloclen; + uint32_t datalen, cdatalen; + + D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); + + ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL); + if (ret) { + D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); + break; + } + down(&f->sem); + datalen = writelen; + cdatalen = min(alloclen - sizeof(*ri), writelen); + + comprbuf = kmalloc(cdatalen, GFP_KERNEL); + if (comprbuf) { + comprtype = jffs2_compress(buf, comprbuf, &datalen, &cdatalen); + } + if (comprtype == JFFS2_COMPR_NONE) { + /* Either compression failed, or the allocation of comprbuf failed */ + if (comprbuf) + kfree(comprbuf); + comprbuf = buf; + datalen = cdatalen; + } + /* Now comprbuf points to the data to be written, be it compressed or not. + comprtype holds the compression type, and comprtype == JFFS2_COMPR_NONE means + that the comprbuf doesn't need to be kfree()d. + */ + + ri->magic = JFFS2_MAGIC_BITMASK; + ri->nodetype = JFFS2_NODETYPE_INODE; + ri->totlen = sizeof(*ri) + cdatalen; + ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4); + + ri->ino = f->inocache->ino; + ri->version = ++f->highest_version; + ri->isize = max(ri->isize, offset + datalen); + ri->offset = offset; + ri->csize = cdatalen; + ri->dsize = datalen; + ri->compr = comprtype; + ri->node_crc = crc32(0, ri, sizeof(*ri)-8); + ri->data_crc = crc32(0, comprbuf, cdatalen); + + fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, NULL); + + jffs2_complete_reservation(c); + + if (comprtype != JFFS2_COMPR_NONE) + kfree(comprbuf); + + if (IS_ERR(fn)) { + ret = PTR_ERR(fn); + up(&f->sem); + break; + } + ret = jffs2_add_full_dnode_to_inode(c, f, fn); + if (f->metadata) { + jffs2_mark_node_obsolete(c, f->metadata->raw); + jffs2_free_full_dnode(f->metadata); + f->metadata = NULL; + } + up(&f->sem); + if (ret) { + /* Eep */ + D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); + jffs2_mark_node_obsolete(c, fn->raw); + jffs2_free_full_dnode(fn); + break; + } + if (!datalen) { + printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); + ret = -EIO; + break; + } + D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); + writtenlen += datalen; + offset += datalen; + writelen -= datalen; + buf += datalen; + } + *retlen = writtenlen; + return ret; +} +