linux/fs/hpfs/super.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  linux/fs/hpfs/super.c
 *
 *  Mikulas Patocka ([email protected]), 1998-1999
 *
 *  mounting, unmounting, error handling
 */

#include "hpfs_fn.h"
#include <linux/module.h>
#include <linux/parser.h>
#include <linux/init.h>
#include <linux/statfs.h>
#include <linux/magic.h>
#include <linux/sched.h>
#include <linux/bitmap.h>
#include <linux/slab.h>
#include <linux/seq_file.h>

/* Mark the filesystem dirty, so that chkdsk checks it when os/2 booted */

static void mark_dirty(struct super_block *s, int remount)
{ … }

/* Mark the filesystem clean (mark it dirty for chkdsk if chkdsk==2 or if there
   were errors) */

static void unmark_dirty(struct super_block *s)
{ … }

/* Filesystem error... */
void hpfs_error(struct super_block *s, const char *fmt, ...)
{ … }

/* 
 * A little trick to detect cycles in many hpfs structures and don't let the
 * kernel crash on corrupted filesystem. When first called, set c2 to 0.
 *
 * BTW. chkdsk doesn't detect cycles correctly. When I had 2 lost directories
 * nested each in other, chkdsk locked up happilly.
 */

int hpfs_stop_cycles(struct super_block *s, int key, int *c1, int *c2,
		char *msg)
{ … }

static void free_sbi(struct hpfs_sb_info *sbi)
{ … }

static void lazy_free_sbi(struct rcu_head *rcu)
{ … }

static void hpfs_put_super(struct super_block *s)
{ … }

static unsigned hpfs_count_one_bitmap(struct super_block *s, secno secno)
{ … }

static unsigned count_bitmaps(struct super_block *s)
{ … }

unsigned hpfs_get_free_dnodes(struct super_block *s)
{ … }

static int hpfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ … }


long hpfs_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{ … }


static struct kmem_cache * hpfs_inode_cachep;

static struct inode *hpfs_alloc_inode(struct super_block *sb)
{ … }

static void hpfs_free_inode(struct inode *inode)
{ … }

static void init_once(void *foo)
{ … }

static int init_inodecache(void)
{ … }

static void destroy_inodecache(void)
{ … }

/*
 * A tiny parser for option strings, stolen from dosfs.
 * Stolen again from read-only hpfs.
 * And updated for table-driven option parsing.
 */

enum { … };

static const match_table_t tokens = …;

static int parse_opts(char *opts, kuid_t *uid, kgid_t *gid, umode_t *umask,
		      int *lowercase, int *eas, int *chk, int *errs,
		      int *chkdsk, int *timeshift)
{ … }

static inline void hpfs_help(void)
{ … }

static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
{ … }

static int hpfs_show_options(struct seq_file *seq, struct dentry *root)
{ … }

/* Super operations */

static const struct super_operations hpfs_sops = …;

static int hpfs_fill_super(struct super_block *s, void *options, int silent)
{ … }

static struct dentry *hpfs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
{ … }

static struct file_system_type hpfs_fs_type = …;
MODULE_ALIAS_FS(…) …;

static int __init init_hpfs_fs(void)
{ … }

static void __exit exit_hpfs_fs(void)
{ … }

module_init(…) …
module_exit(…)
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;