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

super_mmi.c (3887B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * QNX6 file system, Linux implementation.
      4 *
      5 * Version : 1.0.0
      6 *
      7 * History :
      8 *
      9 * 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
     10 *
     11 */
     12
     13#include <linux/buffer_head.h>
     14#include <linux/slab.h>
     15#include <linux/crc32.h>
     16#include "qnx6.h"
     17
     18static void qnx6_mmi_copy_sb(struct qnx6_super_block *qsb,
     19		struct qnx6_mmi_super_block *sb)
     20{
     21	qsb->sb_magic = sb->sb_magic;
     22	qsb->sb_checksum = sb->sb_checksum;
     23	qsb->sb_serial = sb->sb_serial;
     24	qsb->sb_blocksize = sb->sb_blocksize;
     25	qsb->sb_num_inodes = sb->sb_num_inodes;
     26	qsb->sb_free_inodes = sb->sb_free_inodes;
     27	qsb->sb_num_blocks = sb->sb_num_blocks;
     28	qsb->sb_free_blocks = sb->sb_free_blocks;
     29
     30	/* the rest of the superblock is the same */
     31	memcpy(&qsb->Inode, &sb->Inode, sizeof(sb->Inode));
     32	memcpy(&qsb->Bitmap, &sb->Bitmap, sizeof(sb->Bitmap));
     33	memcpy(&qsb->Longfile, &sb->Longfile, sizeof(sb->Longfile));
     34}
     35
     36struct qnx6_super_block *qnx6_mmi_fill_super(struct super_block *s, int silent)
     37{
     38	struct buffer_head *bh1, *bh2 = NULL;
     39	struct qnx6_mmi_super_block *sb1, *sb2;
     40	struct qnx6_super_block *qsb = NULL;
     41	struct qnx6_sb_info *sbi;
     42	__u64 offset;
     43
     44	/* Check the superblock signatures
     45	   start with the first superblock */
     46	bh1 = sb_bread(s, 0);
     47	if (!bh1) {
     48		pr_err("Unable to read first mmi superblock\n");
     49		return NULL;
     50	}
     51	sb1 = (struct qnx6_mmi_super_block *)bh1->b_data;
     52	sbi = QNX6_SB(s);
     53	if (fs32_to_cpu(sbi, sb1->sb_magic) != QNX6_SUPER_MAGIC) {
     54		if (!silent) {
     55			pr_err("wrong signature (magic) in superblock #1.\n");
     56			goto out;
     57		}
     58	}
     59
     60	/* checksum check - start at byte 8 and end at byte 512 */
     61	if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
     62				crc32_be(0, (char *)(bh1->b_data + 8), 504)) {
     63		pr_err("superblock #1 checksum error\n");
     64		goto out;
     65	}
     66
     67	/* calculate second superblock blocknumber */
     68	offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) + QNX6_SUPERBLOCK_AREA /
     69					fs32_to_cpu(sbi, sb1->sb_blocksize);
     70
     71	/* set new blocksize */
     72	if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
     73		pr_err("unable to set blocksize\n");
     74		goto out;
     75	}
     76	/* blocksize invalidates bh - pull it back in */
     77	brelse(bh1);
     78	bh1 = sb_bread(s, 0);
     79	if (!bh1)
     80		goto out;
     81	sb1 = (struct qnx6_mmi_super_block *)bh1->b_data;
     82
     83	/* read second superblock */
     84	bh2 = sb_bread(s, offset);
     85	if (!bh2) {
     86		pr_err("unable to read the second superblock\n");
     87		goto out;
     88	}
     89	sb2 = (struct qnx6_mmi_super_block *)bh2->b_data;
     90	if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
     91		if (!silent)
     92			pr_err("wrong signature (magic) in superblock #2.\n");
     93		goto out;
     94	}
     95
     96	/* checksum check - start at byte 8 and end at byte 512 */
     97	if (fs32_to_cpu(sbi, sb2->sb_checksum)
     98			!= crc32_be(0, (char *)(bh2->b_data + 8), 504)) {
     99		pr_err("superblock #1 checksum error\n");
    100		goto out;
    101	}
    102
    103	qsb = kmalloc(sizeof(*qsb), GFP_KERNEL);
    104	if (!qsb) {
    105		pr_err("unable to allocate memory.\n");
    106		goto out;
    107	}
    108
    109	if (fs64_to_cpu(sbi, sb1->sb_serial) >
    110					fs64_to_cpu(sbi, sb2->sb_serial)) {
    111		/* superblock #1 active */
    112		qnx6_mmi_copy_sb(qsb, sb1);
    113#ifdef CONFIG_QNX6FS_DEBUG
    114		qnx6_superblock_debug(qsb, s);
    115#endif
    116		memcpy(bh1->b_data, qsb, sizeof(struct qnx6_super_block));
    117
    118		sbi->sb_buf = bh1;
    119		sbi->sb = (struct qnx6_super_block *)bh1->b_data;
    120		brelse(bh2);
    121		pr_info("superblock #1 active\n");
    122	} else {
    123		/* superblock #2 active */
    124		qnx6_mmi_copy_sb(qsb, sb2);
    125#ifdef CONFIG_QNX6FS_DEBUG
    126		qnx6_superblock_debug(qsb, s);
    127#endif
    128		memcpy(bh2->b_data, qsb, sizeof(struct qnx6_super_block));
    129
    130		sbi->sb_buf = bh2;
    131		sbi->sb = (struct qnx6_super_block *)bh2->b_data;
    132		brelse(bh1);
    133		pr_info("superblock #2 active\n");
    134	}
    135	kfree(qsb);
    136
    137	/* offset for mmi_fs is just SUPERBLOCK_AREA bytes */
    138	sbi->s_blks_off = QNX6_SUPERBLOCK_AREA / s->s_blocksize;
    139
    140	/* success */
    141	return sbi->sb;
    142
    143out:
    144	if (bh1 != NULL)
    145		brelse(bh1);
    146	if (bh2 != NULL)
    147		brelse(bh2);
    148	return NULL;
    149}