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

hpfs_fn.h (13388B)


      1/* SPDX-License-Identifier: GPL-2.0 */
      2/*
      3 *  linux/fs/hpfs/hpfs_fn.h
      4 *
      5 *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
      6 *
      7 *  function headers
      8 */
      9
     10//#define DBG
     11//#define DEBUG_LOCKS
     12#ifdef pr_fmt
     13#undef pr_fmt
     14#endif
     15
     16#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
     17
     18#include <linux/mutex.h>
     19#include <linux/pagemap.h>
     20#include <linux/buffer_head.h>
     21#include <linux/slab.h>
     22#include <linux/sched/signal.h>
     23#include <linux/blkdev.h>
     24#include <asm/unaligned.h>
     25
     26#include "hpfs.h"
     27
     28#define EIOERROR  EIO
     29#define EFSERROR  EUCLEAN
     30
     31#define ANODE_ALLOC_FWD	512
     32#define FNODE_ALLOC_FWD	0
     33#define ALLOC_FWD_MIN	16
     34#define ALLOC_FWD_MAX	128
     35#define ALLOC_M		1
     36#define FNODE_RD_AHEAD	16
     37#define ANODE_RD_AHEAD	0
     38#define DNODE_RD_AHEAD	72
     39#define COUNT_RD_AHEAD	62
     40
     41#define FREE_DNODES_ADD	58
     42#define FREE_DNODES_DEL	29
     43
     44#define CHKCOND(x,y) if (!(x)) printk y
     45
     46struct hpfs_inode_info {
     47	loff_t mmu_private;
     48	ino_t i_parent_dir;	/* (directories) gives fnode of parent dir */
     49	unsigned i_dno;		/* (directories) root dnode */
     50	unsigned i_dpos;	/* (directories) temp for readdir */
     51	unsigned i_dsubdno;	/* (directories) temp for readdir */
     52	unsigned i_file_sec;	/* (files) minimalist cache of alloc info */
     53	unsigned i_disk_sec;	/* (files) minimalist cache of alloc info */
     54	unsigned i_n_secs;	/* (files) minimalist cache of alloc info */
     55	unsigned i_ea_size;	/* size of extended attributes */
     56	unsigned i_ea_mode : 1;	/* file's permission is stored in ea */
     57	unsigned i_ea_uid : 1;	/* file's uid is stored in ea */
     58	unsigned i_ea_gid : 1;	/* file's gid is stored in ea */
     59	unsigned i_dirty : 1;
     60	loff_t **i_rddir_off;
     61	struct inode vfs_inode;
     62};
     63
     64struct hpfs_sb_info {
     65	struct mutex hpfs_mutex;	/* global hpfs lock */
     66	ino_t sb_root;			/* inode number of root dir */
     67	unsigned sb_fs_size;		/* file system size, sectors */
     68	unsigned sb_bitmaps;		/* sector number of bitmap list */
     69	unsigned sb_dirband_start;	/* directory band start sector */
     70	unsigned sb_dirband_size;	/* directory band size, dnodes */
     71	unsigned sb_dmap;		/* sector number of dnode bit map */
     72	unsigned sb_n_free;		/* free blocks for statfs, or -1 */
     73	unsigned sb_n_free_dnodes;	/* free dnodes for statfs, or -1 */
     74	kuid_t sb_uid;			/* uid from mount options */
     75	kgid_t sb_gid;			/* gid from mount options */
     76	umode_t sb_mode;		/* mode from mount options */
     77	unsigned sb_eas : 2;		/* eas: 0-ignore, 1-ro, 2-rw */
     78	unsigned sb_err : 2;		/* on errs: 0-cont, 1-ro, 2-panic */
     79	unsigned sb_chk : 2;		/* checks: 0-no, 1-normal, 2-strict */
     80	unsigned sb_lowercase : 1;	/* downcase filenames hackery */
     81	unsigned sb_was_error : 1;	/* there was an error, set dirty flag */
     82	unsigned sb_chkdsk : 2;		/* chkdsk: 0-no, 1-on errs, 2-allways */
     83	unsigned char *sb_cp_table;	/* code page tables: */
     84					/* 	128 bytes uppercasing table & */
     85					/*	128 bytes lowercasing table */
     86	__le32 *sb_bmp_dir;		/* main bitmap directory */
     87	unsigned sb_c_bitmap;		/* current bitmap */
     88	unsigned sb_max_fwd_alloc;	/* max forwad allocation */
     89	int sb_timeshift;
     90	struct rcu_head rcu;
     91
     92	unsigned n_hotfixes;
     93	secno hotfix_from[256];
     94	secno hotfix_to[256];
     95};
     96
     97/* Four 512-byte buffers and the 2k block obtained by concatenating them */
     98
     99struct quad_buffer_head {
    100	struct buffer_head *bh[4];
    101	void *data;
    102};
    103
    104/* The b-tree down pointer from a dir entry */
    105
    106static inline dnode_secno de_down_pointer (struct hpfs_dirent *de)
    107{
    108  CHKCOND(de->down,("HPFS: de_down_pointer: !de->down\n"));
    109  return le32_to_cpu(*(__le32 *) ((void *) de + le16_to_cpu(de->length) - 4));
    110}
    111
    112/* The first dir entry in a dnode */
    113
    114static inline struct hpfs_dirent *dnode_first_de (struct dnode *dnode)
    115{
    116  return (void *) dnode->dirent;
    117}
    118
    119/* The end+1 of the dir entries */
    120
    121static inline struct hpfs_dirent *dnode_end_de (struct dnode *dnode)
    122{
    123  CHKCOND(le32_to_cpu(dnode->first_free)>=0x14 && le32_to_cpu(dnode->first_free)<=0xa00,("HPFS: dnode_end_de: dnode->first_free = %x\n",(unsigned)le32_to_cpu(dnode->first_free)));
    124  return (void *) dnode + le32_to_cpu(dnode->first_free);
    125}
    126
    127/* The dir entry after dir entry de */
    128
    129static inline struct hpfs_dirent *de_next_de (struct hpfs_dirent *de)
    130{
    131  CHKCOND(le16_to_cpu(de->length)>=0x20 && le16_to_cpu(de->length)<0x800,("HPFS: de_next_de: de->length = %x\n",(unsigned)le16_to_cpu(de->length)));
    132  return (void *) de + le16_to_cpu(de->length);
    133}
    134
    135static inline struct extended_attribute *fnode_ea(struct fnode *fnode)
    136{
    137	return (struct extended_attribute *)((char *)fnode + le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s));
    138}
    139
    140static inline struct extended_attribute *fnode_end_ea(struct fnode *fnode)
    141{
    142	return (struct extended_attribute *)((char *)fnode + le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s));
    143}
    144
    145static unsigned ea_valuelen(struct extended_attribute *ea)
    146{
    147	return ea->valuelen_lo + 256 * ea->valuelen_hi;
    148}
    149
    150static inline struct extended_attribute *next_ea(struct extended_attribute *ea)
    151{
    152	return (struct extended_attribute *)((char *)ea + 5 + ea->namelen + ea_valuelen(ea));
    153}
    154
    155static inline secno ea_sec(struct extended_attribute *ea)
    156{
    157	return le32_to_cpu(get_unaligned((__le32 *)((char *)ea + 9 + ea->namelen)));
    158}
    159
    160static inline secno ea_len(struct extended_attribute *ea)
    161{
    162	return le32_to_cpu(get_unaligned((__le32 *)((char *)ea + 5 + ea->namelen)));
    163}
    164
    165static inline char *ea_data(struct extended_attribute *ea)
    166{
    167	return (char *)((char *)ea + 5 + ea->namelen);
    168}
    169
    170static inline unsigned de_size(int namelen, secno down_ptr)
    171{
    172	return ((0x1f + namelen + 3) & ~3) + (down_ptr ? 4 : 0);
    173}
    174
    175static inline void copy_de(struct hpfs_dirent *dst, struct hpfs_dirent *src)
    176{
    177	int a;
    178	int n;
    179	if (!dst || !src) return;
    180	a = dst->down;
    181	n = dst->not_8x3;
    182	memcpy((char *)dst + 2, (char *)src + 2, 28);
    183	dst->down = a;
    184	dst->not_8x3 = n;
    185}
    186
    187static inline unsigned tstbits(__le32 *bmp, unsigned b, unsigned n)
    188{
    189	int i;
    190	if ((b >= 0x4000) || (b + n - 1 >= 0x4000)) return n;
    191	if (!((le32_to_cpu(bmp[(b & 0x3fff) >> 5]) >> (b & 0x1f)) & 1)) return 1;
    192	for (i = 1; i < n; i++)
    193		if (!((le32_to_cpu(bmp[((b+i) & 0x3fff) >> 5]) >> ((b+i) & 0x1f)) & 1))
    194			return i + 1;
    195	return 0;
    196}
    197
    198/* alloc.c */
    199
    200int hpfs_chk_sectors(struct super_block *, secno, int, char *);
    201secno hpfs_alloc_sector(struct super_block *, secno, unsigned, int);
    202int hpfs_alloc_if_possible(struct super_block *, secno);
    203void hpfs_free_sectors(struct super_block *, secno, unsigned);
    204int hpfs_check_free_dnodes(struct super_block *, int);
    205void hpfs_free_dnode(struct super_block *, secno);
    206struct dnode *hpfs_alloc_dnode(struct super_block *, secno, dnode_secno *, struct quad_buffer_head *);
    207struct fnode *hpfs_alloc_fnode(struct super_block *, secno, fnode_secno *, struct buffer_head **);
    208struct anode *hpfs_alloc_anode(struct super_block *, secno, anode_secno *, struct buffer_head **);
    209int hpfs_trim_fs(struct super_block *, u64, u64, u64, unsigned *);
    210
    211/* anode.c */
    212
    213secno hpfs_bplus_lookup(struct super_block *, struct inode *, struct bplus_header *, unsigned, struct buffer_head *);
    214secno hpfs_add_sector_to_btree(struct super_block *, secno, int, unsigned);
    215void hpfs_remove_btree(struct super_block *, struct bplus_header *);
    216int hpfs_ea_read(struct super_block *, secno, int, unsigned, unsigned, char *);
    217int hpfs_ea_write(struct super_block *, secno, int, unsigned, unsigned, const char *);
    218void hpfs_ea_remove(struct super_block *, secno, int, unsigned);
    219void hpfs_truncate_btree(struct super_block *, secno, int, unsigned);
    220void hpfs_remove_fnode(struct super_block *, fnode_secno fno);
    221
    222/* buffer.c */
    223
    224secno hpfs_search_hotfix_map(struct super_block *s, secno sec);
    225unsigned hpfs_search_hotfix_map_for_range(struct super_block *s, secno sec, unsigned n);
    226void hpfs_prefetch_sectors(struct super_block *, unsigned, int);
    227void *hpfs_map_sector(struct super_block *, unsigned, struct buffer_head **, int);
    228void *hpfs_get_sector(struct super_block *, unsigned, struct buffer_head **);
    229void *hpfs_map_4sectors(struct super_block *, unsigned, struct quad_buffer_head *, int);
    230void *hpfs_get_4sectors(struct super_block *, unsigned, struct quad_buffer_head *);
    231void hpfs_brelse4(struct quad_buffer_head *);
    232void hpfs_mark_4buffers_dirty(struct quad_buffer_head *);
    233
    234/* dentry.c */
    235
    236extern const struct dentry_operations hpfs_dentry_operations;
    237
    238/* dir.c */
    239
    240struct dentry *hpfs_lookup(struct inode *, struct dentry *, unsigned int);
    241extern const struct file_operations hpfs_dir_ops;
    242
    243/* dnode.c */
    244
    245int hpfs_add_pos(struct inode *, loff_t *);
    246void hpfs_del_pos(struct inode *, loff_t *);
    247struct hpfs_dirent *hpfs_add_de(struct super_block *, struct dnode *,
    248				const unsigned char *, unsigned, secno);
    249int hpfs_add_dirent(struct inode *, const unsigned char *, unsigned,
    250		    struct hpfs_dirent *);
    251int hpfs_remove_dirent(struct inode *, dnode_secno, struct hpfs_dirent *, struct quad_buffer_head *, int);
    252void hpfs_count_dnodes(struct super_block *, dnode_secno, int *, int *, int *);
    253dnode_secno hpfs_de_as_down_as_possible(struct super_block *, dnode_secno dno);
    254struct hpfs_dirent *map_pos_dirent(struct inode *, loff_t *, struct quad_buffer_head *);
    255struct hpfs_dirent *map_dirent(struct inode *, dnode_secno,
    256			       const unsigned char *, unsigned, dnode_secno *,
    257			       struct quad_buffer_head *);
    258void hpfs_remove_dtree(struct super_block *, dnode_secno);
    259struct hpfs_dirent *map_fnode_dirent(struct super_block *, fnode_secno, struct fnode *, struct quad_buffer_head *);
    260
    261/* ea.c */
    262
    263void hpfs_ea_ext_remove(struct super_block *, secno, int, unsigned);
    264int hpfs_read_ea(struct super_block *, struct fnode *, char *, char *, int);
    265char *hpfs_get_ea(struct super_block *, struct fnode *, char *, int *);
    266void hpfs_set_ea(struct inode *, struct fnode *, const char *,
    267		 const char *, int);
    268
    269/* file.c */
    270
    271int hpfs_file_fsync(struct file *, loff_t, loff_t, int);
    272void hpfs_truncate(struct inode *);
    273extern const struct file_operations hpfs_file_ops;
    274extern const struct inode_operations hpfs_file_iops;
    275extern const struct address_space_operations hpfs_aops;
    276
    277/* inode.c */
    278
    279void hpfs_init_inode(struct inode *);
    280void hpfs_read_inode(struct inode *);
    281void hpfs_write_inode(struct inode *);
    282void hpfs_write_inode_nolock(struct inode *);
    283int hpfs_setattr(struct user_namespace *, struct dentry *, struct iattr *);
    284void hpfs_write_if_changed(struct inode *);
    285void hpfs_evict_inode(struct inode *);
    286
    287/* map.c */
    288
    289__le32 *hpfs_map_dnode_bitmap(struct super_block *, struct quad_buffer_head *);
    290__le32 *hpfs_map_bitmap(struct super_block *, unsigned, struct quad_buffer_head *, char *);
    291void hpfs_prefetch_bitmap(struct super_block *, unsigned);
    292unsigned char *hpfs_load_code_page(struct super_block *, secno);
    293__le32 *hpfs_load_bitmap_directory(struct super_block *, secno bmp);
    294void hpfs_load_hotfix_map(struct super_block *s, struct hpfs_spare_block *spareblock);
    295struct fnode *hpfs_map_fnode(struct super_block *s, ino_t, struct buffer_head **);
    296struct anode *hpfs_map_anode(struct super_block *s, anode_secno, struct buffer_head **);
    297struct dnode *hpfs_map_dnode(struct super_block *s, dnode_secno, struct quad_buffer_head *);
    298dnode_secno hpfs_fnode_dno(struct super_block *s, ino_t ino);
    299
    300/* name.c */
    301
    302unsigned char hpfs_upcase(unsigned char *, unsigned char);
    303int hpfs_chk_name(const unsigned char *, unsigned *);
    304unsigned char *hpfs_translate_name(struct super_block *, unsigned char *, unsigned, int, int);
    305int hpfs_compare_names(struct super_block *, const unsigned char *, unsigned,
    306		       const unsigned char *, unsigned, int);
    307int hpfs_is_name_long(const unsigned char *, unsigned);
    308void hpfs_adjust_length(const unsigned char *, unsigned *);
    309
    310/* namei.c */
    311
    312extern const struct inode_operations hpfs_dir_iops;
    313extern const struct address_space_operations hpfs_symlink_aops;
    314
    315static inline struct hpfs_inode_info *hpfs_i(struct inode *inode)
    316{
    317	return container_of(inode, struct hpfs_inode_info, vfs_inode);
    318}
    319
    320static inline struct hpfs_sb_info *hpfs_sb(struct super_block *sb)
    321{
    322	return sb->s_fs_info;
    323}
    324
    325/* super.c */
    326
    327__printf(2, 3)
    328void hpfs_error(struct super_block *, const char *, ...);
    329int hpfs_stop_cycles(struct super_block *, int, int *, int *, char *);
    330unsigned hpfs_get_free_dnodes(struct super_block *);
    331long hpfs_ioctl(struct file *file, unsigned cmd, unsigned long arg);
    332
    333/*
    334 * local time (HPFS) to GMT (Unix)
    335 */
    336
    337static inline time64_t local_to_gmt(struct super_block *s, time64_t t)
    338{
    339	extern struct timezone sys_tz;
    340	return t + sys_tz.tz_minuteswest * 60 + hpfs_sb(s)->sb_timeshift;
    341}
    342
    343static inline time32_t gmt_to_local(struct super_block *s, time64_t t)
    344{
    345	extern struct timezone sys_tz;
    346	return t - sys_tz.tz_minuteswest * 60 - hpfs_sb(s)->sb_timeshift;
    347}
    348
    349static inline time32_t local_get_seconds(struct super_block *s)
    350{
    351	return gmt_to_local(s, ktime_get_real_seconds());
    352}
    353
    354/*
    355 * Locking:
    356 *
    357 * hpfs_lock() locks the whole filesystem. It must be taken
    358 * on any method called by the VFS.
    359 *
    360 * We don't do any per-file locking anymore, it is hard to
    361 * review and HPFS is not performance-sensitive anyway.
    362 */
    363static inline void hpfs_lock(struct super_block *s)
    364{
    365	struct hpfs_sb_info *sbi = hpfs_sb(s);
    366	mutex_lock(&sbi->hpfs_mutex);
    367}
    368
    369static inline void hpfs_unlock(struct super_block *s)
    370{
    371	struct hpfs_sb_info *sbi = hpfs_sb(s);
    372	mutex_unlock(&sbi->hpfs_mutex);
    373}
    374
    375static inline void hpfs_lock_assert(struct super_block *s)
    376{
    377	struct hpfs_sb_info *sbi = hpfs_sb(s);
    378	WARN_ON(!mutex_is_locked(&sbi->hpfs_mutex));
    379}