cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

file.c (9641B)


      1/*
      2 * JFFS2 -- Journalling Flash File System, Version 2.
      3 *
      4 * Copyright © 2001-2007 Red Hat, Inc.
      5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
      6 *
      7 * Created by David Woodhouse <dwmw2@infradead.org>
      8 *
      9 * For licensing information, see the file 'LICENCE' in this directory.
     10 *
     11 */
     12
     13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
     14
     15#include <linux/kernel.h>
     16#include <linux/fs.h>
     17#include <linux/time.h>
     18#include <linux/pagemap.h>
     19#include <linux/highmem.h>
     20#include <linux/crc32.h>
     21#include <linux/jffs2.h>
     22#include "nodelist.h"
     23
     24static int jffs2_write_end(struct file *filp, struct address_space *mapping,
     25			loff_t pos, unsigned len, unsigned copied,
     26			struct page *pg, void *fsdata);
     27static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
     28			loff_t pos, unsigned len,
     29			struct page **pagep, void **fsdata);
     30static int jffs2_read_folio(struct file *filp, struct folio *folio);
     31
     32int jffs2_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
     33{
     34	struct inode *inode = filp->f_mapping->host;
     35	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
     36	int ret;
     37
     38	ret = file_write_and_wait_range(filp, start, end);
     39	if (ret)
     40		return ret;
     41
     42	inode_lock(inode);
     43	/* Trigger GC to flush any pending writes for this inode */
     44	jffs2_flush_wbuf_gc(c, inode->i_ino);
     45	inode_unlock(inode);
     46
     47	return 0;
     48}
     49
     50const struct file_operations jffs2_file_operations =
     51{
     52	.llseek =	generic_file_llseek,
     53	.open =		generic_file_open,
     54 	.read_iter =	generic_file_read_iter,
     55 	.write_iter =	generic_file_write_iter,
     56	.unlocked_ioctl=jffs2_ioctl,
     57	.mmap =		generic_file_readonly_mmap,
     58	.fsync =	jffs2_fsync,
     59	.splice_read =	generic_file_splice_read,
     60	.splice_write = iter_file_splice_write,
     61};
     62
     63/* jffs2_file_inode_operations */
     64
     65const struct inode_operations jffs2_file_inode_operations =
     66{
     67	.get_acl =	jffs2_get_acl,
     68	.set_acl =	jffs2_set_acl,
     69	.setattr =	jffs2_setattr,
     70	.listxattr =	jffs2_listxattr,
     71};
     72
     73const struct address_space_operations jffs2_file_address_operations =
     74{
     75	.read_folio =	jffs2_read_folio,
     76	.write_begin =	jffs2_write_begin,
     77	.write_end =	jffs2_write_end,
     78};
     79
     80static int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
     81{
     82	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
     83	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
     84	unsigned char *pg_buf;
     85	int ret;
     86
     87	jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n",
     88		  __func__, inode->i_ino, pg->index << PAGE_SHIFT);
     89
     90	BUG_ON(!PageLocked(pg));
     91
     92	pg_buf = kmap(pg);
     93	/* FIXME: Can kmap fail? */
     94
     95	ret = jffs2_read_inode_range(c, f, pg_buf, pg->index << PAGE_SHIFT,
     96				     PAGE_SIZE);
     97
     98	if (ret) {
     99		ClearPageUptodate(pg);
    100		SetPageError(pg);
    101	} else {
    102		SetPageUptodate(pg);
    103		ClearPageError(pg);
    104	}
    105
    106	flush_dcache_page(pg);
    107	kunmap(pg);
    108
    109	jffs2_dbg(2, "readpage finished\n");
    110	return ret;
    111}
    112
    113int __jffs2_read_folio(struct file *file, struct folio *folio)
    114{
    115	int ret = jffs2_do_readpage_nolock(folio->mapping->host, &folio->page);
    116	folio_unlock(folio);
    117	return ret;
    118}
    119
    120static int jffs2_read_folio(struct file *file, struct folio *folio)
    121{
    122	struct jffs2_inode_info *f = JFFS2_INODE_INFO(folio->mapping->host);
    123	int ret;
    124
    125	mutex_lock(&f->sem);
    126	ret = __jffs2_read_folio(file, folio);
    127	mutex_unlock(&f->sem);
    128	return ret;
    129}
    130
    131static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
    132			loff_t pos, unsigned len,
    133			struct page **pagep, void **fsdata)
    134{
    135	struct page *pg;
    136	struct inode *inode = mapping->host;
    137	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
    138	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
    139	pgoff_t index = pos >> PAGE_SHIFT;
    140	uint32_t pageofs = index << PAGE_SHIFT;
    141	int ret = 0;
    142
    143	jffs2_dbg(1, "%s()\n", __func__);
    144
    145	if (pageofs > inode->i_size) {
    146		/* Make new hole frag from old EOF to new page */
    147		struct jffs2_raw_inode ri;
    148		struct jffs2_full_dnode *fn;
    149		uint32_t alloc_len;
    150
    151		jffs2_dbg(1, "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
    152			  (unsigned int)inode->i_size, pageofs);
    153
    154		ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
    155					  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
    156		if (ret)
    157			goto out_err;
    158
    159		mutex_lock(&f->sem);
    160		memset(&ri, 0, sizeof(ri));
    161
    162		ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
    163		ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
    164		ri.totlen = cpu_to_je32(sizeof(ri));
    165		ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
    166
    167		ri.ino = cpu_to_je32(f->inocache->ino);
    168		ri.version = cpu_to_je32(++f->highest_version);
    169		ri.mode = cpu_to_jemode(inode->i_mode);
    170		ri.uid = cpu_to_je16(i_uid_read(inode));
    171		ri.gid = cpu_to_je16(i_gid_read(inode));
    172		ri.isize = cpu_to_je32(max((uint32_t)inode->i_size, pageofs));
    173		ri.atime = ri.ctime = ri.mtime = cpu_to_je32(JFFS2_NOW());
    174		ri.offset = cpu_to_je32(inode->i_size);
    175		ri.dsize = cpu_to_je32(pageofs - inode->i_size);
    176		ri.csize = cpu_to_je32(0);
    177		ri.compr = JFFS2_COMPR_ZERO;
    178		ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
    179		ri.data_crc = cpu_to_je32(0);
    180
    181		fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_NORMAL);
    182
    183		if (IS_ERR(fn)) {
    184			ret = PTR_ERR(fn);
    185			jffs2_complete_reservation(c);
    186			mutex_unlock(&f->sem);
    187			goto out_err;
    188		}
    189		ret = jffs2_add_full_dnode_to_inode(c, f, fn);
    190		if (f->metadata) {
    191			jffs2_mark_node_obsolete(c, f->metadata->raw);
    192			jffs2_free_full_dnode(f->metadata);
    193			f->metadata = NULL;
    194		}
    195		if (ret) {
    196			jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in write_begin, returned %d\n",
    197				  ret);
    198			jffs2_mark_node_obsolete(c, fn->raw);
    199			jffs2_free_full_dnode(fn);
    200			jffs2_complete_reservation(c);
    201			mutex_unlock(&f->sem);
    202			goto out_err;
    203		}
    204		jffs2_complete_reservation(c);
    205		inode->i_size = pageofs;
    206		mutex_unlock(&f->sem);
    207	}
    208
    209	/*
    210	 * While getting a page and reading data in, lock c->alloc_sem until
    211	 * the page is Uptodate. Otherwise GC task may attempt to read the same
    212	 * page in read_cache_page(), which causes a deadlock.
    213	 */
    214	mutex_lock(&c->alloc_sem);
    215	pg = grab_cache_page_write_begin(mapping, index);
    216	if (!pg) {
    217		ret = -ENOMEM;
    218		goto release_sem;
    219	}
    220	*pagep = pg;
    221
    222	/*
    223	 * Read in the page if it wasn't already present. Cannot optimize away
    224	 * the whole page write case until jffs2_write_end can handle the
    225	 * case of a short-copy.
    226	 */
    227	if (!PageUptodate(pg)) {
    228		mutex_lock(&f->sem);
    229		ret = jffs2_do_readpage_nolock(inode, pg);
    230		mutex_unlock(&f->sem);
    231		if (ret) {
    232			unlock_page(pg);
    233			put_page(pg);
    234			goto release_sem;
    235		}
    236	}
    237	jffs2_dbg(1, "end write_begin(). pg->flags %lx\n", pg->flags);
    238
    239release_sem:
    240	mutex_unlock(&c->alloc_sem);
    241out_err:
    242	return ret;
    243}
    244
    245static int jffs2_write_end(struct file *filp, struct address_space *mapping,
    246			loff_t pos, unsigned len, unsigned copied,
    247			struct page *pg, void *fsdata)
    248{
    249	/* Actually commit the write from the page cache page we're looking at.
    250	 * For now, we write the full page out each time. It sucks, but it's simple
    251	 */
    252	struct inode *inode = mapping->host;
    253	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
    254	struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
    255	struct jffs2_raw_inode *ri;
    256	unsigned start = pos & (PAGE_SIZE - 1);
    257	unsigned end = start + copied;
    258	unsigned aligned_start = start & ~3;
    259	int ret = 0;
    260	uint32_t writtenlen = 0;
    261
    262	jffs2_dbg(1, "%s(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
    263		  __func__, inode->i_ino, pg->index << PAGE_SHIFT,
    264		  start, end, pg->flags);
    265
    266	/* We need to avoid deadlock with page_cache_read() in
    267	   jffs2_garbage_collect_pass(). So the page must be
    268	   up to date to prevent page_cache_read() from trying
    269	   to re-lock it. */
    270	BUG_ON(!PageUptodate(pg));
    271
    272	if (end == PAGE_SIZE) {
    273		/* When writing out the end of a page, write out the
    274		   _whole_ page. This helps to reduce the number of
    275		   nodes in files which have many short writes, like
    276		   syslog files. */
    277		aligned_start = 0;
    278	}
    279
    280	ri = jffs2_alloc_raw_inode();
    281
    282	if (!ri) {
    283		jffs2_dbg(1, "%s(): Allocation of raw inode failed\n",
    284			  __func__);
    285		unlock_page(pg);
    286		put_page(pg);
    287		return -ENOMEM;
    288	}
    289
    290	/* Set the fields that the generic jffs2_write_inode_range() code can't find */
    291	ri->ino = cpu_to_je32(inode->i_ino);
    292	ri->mode = cpu_to_jemode(inode->i_mode);
    293	ri->uid = cpu_to_je16(i_uid_read(inode));
    294	ri->gid = cpu_to_je16(i_gid_read(inode));
    295	ri->isize = cpu_to_je32((uint32_t)inode->i_size);
    296	ri->atime = ri->ctime = ri->mtime = cpu_to_je32(JFFS2_NOW());
    297
    298	/* In 2.4, it was already kmapped by generic_file_write(). Doesn't
    299	   hurt to do it again. The alternative is ifdefs, which are ugly. */
    300	kmap(pg);
    301
    302	ret = jffs2_write_inode_range(c, f, ri, page_address(pg) + aligned_start,
    303				      (pg->index << PAGE_SHIFT) + aligned_start,
    304				      end - aligned_start, &writtenlen);
    305
    306	kunmap(pg);
    307
    308	if (ret) {
    309		/* There was an error writing. */
    310		SetPageError(pg);
    311	}
    312
    313	/* Adjust writtenlen for the padding we did, so we don't confuse our caller */
    314	writtenlen -= min(writtenlen, (start - aligned_start));
    315
    316	if (writtenlen) {
    317		if (inode->i_size < pos + writtenlen) {
    318			inode->i_size = pos + writtenlen;
    319			inode->i_blocks = (inode->i_size + 511) >> 9;
    320
    321			inode->i_ctime = inode->i_mtime = ITIME(je32_to_cpu(ri->ctime));
    322		}
    323	}
    324
    325	jffs2_free_raw_inode(ri);
    326
    327	if (start+writtenlen < end) {
    328		/* generic_file_write has written more to the page cache than we've
    329		   actually written to the medium. Mark the page !Uptodate so that
    330		   it gets reread */
    331		jffs2_dbg(1, "%s(): Not all bytes written. Marking page !uptodate\n",
    332			__func__);
    333		SetPageError(pg);
    334		ClearPageUptodate(pg);
    335	}
    336
    337	jffs2_dbg(1, "%s() returning %d\n",
    338		  __func__, writtenlen > 0 ? writtenlen : ret);
    339	unlock_page(pg);
    340	put_page(pg);
    341	return writtenlen > 0 ? writtenlen : ret;
    342}