1/*
  2 * Resizable simple ram filesystem for Linux.
  3 *
  4 * Copyright (C) 2000 Linus Torvalds.
  5 *               2000 Transmeta Corp.
  6 *
  7 * Usage limits added by David Gibson, Linuxcare Australia.
  8 * This file is released under the GPL.
  9 */
 10
 11/*
 12 * NOTE! This filesystem is probably most useful
 13 * not as a real filesystem, but as an example of
 14 * how virtual filesystems can be written.
 15 *
 16 * It doesn't get much simpler than this. Consider
 17 * that this file implements the full semantics of
 18 * a POSIX-compliant read-write filesystem.
 19 *
 20 * Note in particular how the filesystem does not
 21 * need to implement any data structures of its own
 22 * to keep track of the virtual data: using the VFS
 23 * caches is sufficient.
 24 */
 25
 26#include <linux/fs.h>
 27#include <linux/pagemap.h>
 28#include <linux/highmem.h>
 29#include <linux/time.h>
 30#include <linux/init.h>
 31#include <linux/string.h>
 32#include <linux/backing-dev.h>
 33#include <linux/ramfs.h>
 34#include <linux/sched.h>
 35#include <linux/parser.h>
 36#include <linux/magic.h>
 37#include <linux/slab.h>
 38#include <linux/uaccess.h>
 39#include <linux/fs_context.h>
 40#include <linux/fs_parser.h>
 41#include "internal.h"
 42
 43struct ramfs_mount_opts {
 44	umode_t mode;
 45};
 46
 47struct ramfs_fs_info {
 48	struct ramfs_mount_opts mount_opts;
 49};
 50
 51#define RAMFS_DEFAULT_MODE	0755
 52
 53static const struct super_operations ramfs_ops;
 54static const struct inode_operations ramfs_dir_inode_operations;
 55
 56static const struct address_space_operations ramfs_aops = {
 57	.readpage	= simple_readpage,
 58	.write_begin	= simple_write_begin,
 59	.write_end	= simple_write_end,
 60	.set_page_dirty	= __set_page_dirty_no_writeback,
 61};
 62
 63struct inode *ramfs_get_inode(struct super_block *sb,
 64				const struct inode *dir, umode_t mode, dev_t dev)
 65{
 66	struct inode * inode = new_inode(sb);
 67
 68	if (inode) {
 69		inode->i_ino = get_next_ino();
 70		inode_init_owner(inode, dir, mode);
 71		inode->i_mapping->a_ops = &ramfs_aops;
 72		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
 73		mapping_set_unevictable(inode->i_mapping);
 74		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 75		switch (mode & S_IFMT) {
 76		default:
 77			init_special_inode(inode, mode, dev);
 78			break;
 79		case S_IFREG:
 80			inode->i_op = &ramfs_file_inode_operations;
 81			inode->i_fop = &ramfs_file_operations;
 82			break;
 83		case S_IFDIR:
 84			inode->i_op = &ramfs_dir_inode_operations;
 85			inode->i_fop = &simple_dir_operations;
 86
 87			/* directory inodes start off with i_nlink == 2 (for "." entry) */
 88			inc_nlink(inode);
 89			break;
 90		case S_IFLNK:
 91			inode->i_op = &page_symlink_inode_operations;
 92			inode_nohighmem(inode);
 93			break;
 94		}
 95	}
 96	return inode;
 97}
 98
 99/*
100 * File creation. Allocate an inode, and we're done..
101 */
102/* SMP-safe */
103static int
104ramfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
105{
106	struct inode * inode = ramfs_get_inode(dir->i_sb, dir, mode, dev);
107	int error = -ENOSPC;
108
109	if (inode) {
110		d_instantiate(dentry, inode);
111		dget(dentry);	/* Extra count - pin the dentry in core */
112		error = 0;
113		dir->i_mtime = dir->i_ctime = current_time(dir);
114	}
115	return error;
116}
117
118static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
119{
120	int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
121	if (!retval)
122		inc_nlink(dir);
123	return retval;
124}
125
126static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
127{
128	return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
129}
130
131static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
132{
133	struct inode *inode;
134	int error = -ENOSPC;
135
136	inode = ramfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
137	if (inode) {
138		int l = strlen(symname)+1;
139		error = page_symlink(inode, symname, l);
140		if (!error) {
141			d_instantiate(dentry, inode);
142			dget(dentry);
143			dir->i_mtime = dir->i_ctime = current_time(dir);
144		} else
145			iput(inode);
146	}
147	return error;
148}
149
150static const struct inode_operations ramfs_dir_inode_operations = {
151	.create		= ramfs_create,
152	.lookup		= simple_lookup,
153	.link		= simple_link,
154	.unlink		= simple_unlink,
155	.symlink	= ramfs_symlink,
156	.mkdir		= ramfs_mkdir,
157	.rmdir		= simple_rmdir,
158	.mknod		= ramfs_mknod,
159	.rename		= simple_rename,
160};
161
162/*
163 * Display the mount options in /proc/mounts.
164 */
165static int ramfs_show_options(struct seq_file *m, struct dentry *root)
166{
167	struct ramfs_fs_info *fsi = root->d_sb->s_fs_info;
168
169	if (fsi->mount_opts.mode != RAMFS_DEFAULT_MODE)
170		seq_printf(m, ",mode=%o", fsi->mount_opts.mode);
171	return 0;
172}
173
174static const struct super_operations ramfs_ops = {
175	.statfs		= simple_statfs,
176	.drop_inode	= generic_delete_inode,
177	.show_options	= ramfs_show_options,
178};
179
180enum ramfs_param {
181	Opt_mode,
182};
183
184static const struct fs_parameter_spec ramfs_param_specs[] = {
185	fsparam_u32oct("mode",	Opt_mode),
186	{}
187};
188
189const struct fs_parameter_description ramfs_fs_parameters = {
190	.name		= "ramfs",
191	.specs		= ramfs_param_specs,
192};
193
194static int ramfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
195{
196	struct fs_parse_result result;
197	struct ramfs_fs_info *fsi = fc->s_fs_info;
198	int opt;
199
200	opt = fs_parse(fc, &ramfs_fs_parameters, param, &result);
201	if (opt < 0) {
202		/*
203		 * We might like to report bad mount options here;
204		 * but traditionally ramfs has ignored all mount options,
205		 * and as it is used as a !CONFIG_SHMEM simple substitute
206		 * for tmpfs, better continue to ignore other mount options.
207		 */
208		if (opt == -ENOPARAM)
209			opt = 0;
210		return opt;
211	}
212
213	switch (opt) {
214	case Opt_mode:
215		fsi->mount_opts.mode = result.uint_32 & S_IALLUGO;
216		break;
217	}
218
219	return 0;
220}
221
222static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
223{
224	struct ramfs_fs_info *fsi = sb->s_fs_info;
225	struct inode *inode;
226
227	sb->s_maxbytes		= MAX_LFS_FILESIZE;
228	sb->s_blocksize		= PAGE_SIZE;
229	sb->s_blocksize_bits	= PAGE_SHIFT;
230	sb->s_magic		= RAMFS_MAGIC;
231	sb->s_op		= &ramfs_ops;
232	sb->s_time_gran		= 1;
233
234	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
235	sb->s_root = d_make_root(inode);
236	if (!sb->s_root)
237		return -ENOMEM;
238
239	return 0;
240}
241
242static int ramfs_get_tree(struct fs_context *fc)
243{
244	return get_tree_nodev(fc, ramfs_fill_super);
245}
246
247static void ramfs_free_fc(struct fs_context *fc)
248{
249	kfree(fc->s_fs_info);
250}
251
252static const struct fs_context_operations ramfs_context_ops = {
253	.free		= ramfs_free_fc,
254	.parse_param	= ramfs_parse_param,
255	.get_tree	= ramfs_get_tree,
256};
257
258int ramfs_init_fs_context(struct fs_context *fc)
259{
260	struct ramfs_fs_info *fsi;
261
262	fsi = kzalloc(sizeof(*fsi), GFP_KERNEL);
263	if (!fsi)
264		return -ENOMEM;
265
266	fsi->mount_opts.mode = RAMFS_DEFAULT_MODE;
267	fc->s_fs_info = fsi;
268	fc->ops = &ramfs_context_ops;
269	return 0;
270}
271
272static void ramfs_kill_sb(struct super_block *sb)
273{
274	kfree(sb->s_fs_info);
275	kill_litter_super(sb);
276}
277
278static struct file_system_type ramfs_fs_type = {
279	.name		= "ramfs",
280	.init_fs_context = ramfs_init_fs_context,
281	.parameters	= &ramfs_fs_parameters,
282	.kill_sb	= ramfs_kill_sb,
283	.fs_flags	= FS_USERNS_MOUNT,
284};
285
286static int __init init_ramfs_fs(void)
287{
288	return register_filesystem(&ramfs_fs_type);
289}
290fs_initcall(init_ramfs_fs);

  1/*
  2 * Resizable simple ram filesystem for Linux.
  3 *
  4 * Copyright (C) 2000 Linus Torvalds.
  5 *               2000 Transmeta Corp.
  6 *
  7 * Usage limits added by David Gibson, Linuxcare Australia.
  8 * This file is released under the GPL.
  9 */
 10
 11/*
 12 * NOTE! This filesystem is probably most useful
 13 * not as a real filesystem, but as an example of
 14 * how virtual filesystems can be written.
 15 *
 16 * It doesn't get much simpler than this. Consider
 17 * that this file implements the full semantics of
 18 * a POSIX-compliant read-write filesystem.
 19 *
 20 * Note in particular how the filesystem does not
 21 * need to implement any data structures of its own
 22 * to keep track of the virtual data: using the VFS
 23 * caches is sufficient.
 24 */
 25
 26#include <linux/fs.h>
 27#include <linux/pagemap.h>
 28#include <linux/highmem.h>
 29#include <linux/time.h>
 30#include <linux/init.h>
 31#include <linux/string.h>
 32#include <linux/backing-dev.h>
 33#include <linux/ramfs.h>
 34#include <linux/sched.h>
 35#include <linux/parser.h>
 36#include <linux/magic.h>
 37#include <linux/slab.h>
 38#include <linux/uaccess.h>
 39#include <linux/fs_context.h>
 40#include <linux/fs_parser.h>
 41#include "internal.h"
 42
 43struct ramfs_mount_opts {
 44	umode_t mode;
 45};
 46
 47struct ramfs_fs_info {
 48	struct ramfs_mount_opts mount_opts;
 49};
 50
 51#define RAMFS_DEFAULT_MODE	0755
 52
 53static const struct super_operations ramfs_ops;
 54static const struct inode_operations ramfs_dir_inode_operations;
 55
 56static const struct address_space_operations ramfs_aops = {
 57	.readpage	= simple_readpage,
 58	.write_begin	= simple_write_begin,
 59	.write_end	= simple_write_end,
 60	.set_page_dirty	= __set_page_dirty_no_writeback,
 61};
 62
 63struct inode *ramfs_get_inode(struct super_block *sb,
 64				const struct inode *dir, umode_t mode, dev_t dev)
 65{
 66	struct inode * inode = new_inode(sb);
 67
 68	if (inode) {
 69		inode->i_ino = get_next_ino();
 70		inode_init_owner(inode, dir, mode);
 71		inode->i_mapping->a_ops = &ramfs_aops;
 72		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
 73		mapping_set_unevictable(inode->i_mapping);
 74		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 75		switch (mode & S_IFMT) {
 76		default:
 77			init_special_inode(inode, mode, dev);
 78			break;
 79		case S_IFREG:
 80			inode->i_op = &ramfs_file_inode_operations;
 81			inode->i_fop = &ramfs_file_operations;
 82			break;
 83		case S_IFDIR:
 84			inode->i_op = &ramfs_dir_inode_operations;
 85			inode->i_fop = &simple_dir_operations;
 86
 87			/* directory inodes start off with i_nlink == 2 (for "." entry) */
 88			inc_nlink(inode);
 89			break;
 90		case S_IFLNK:
 91			inode->i_op = &page_symlink_inode_operations;
 92			inode_nohighmem(inode);
 93			break;
 94		}
 95	}
 96	return inode;
 97}
 98
 99/*
100 * File creation. Allocate an inode, and we're done..
101 */
102/* SMP-safe */
103static int
104ramfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
105{
106	struct inode * inode = ramfs_get_inode(dir->i_sb, dir, mode, dev);
107	int error = -ENOSPC;
108
109	if (inode) {
110		d_instantiate(dentry, inode);
111		dget(dentry);	/* Extra count - pin the dentry in core */
112		error = 0;
113		dir->i_mtime = dir->i_ctime = current_time(dir);
114	}
115	return error;
116}
117
118static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
119{
120	int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
121	if (!retval)
122		inc_nlink(dir);
123	return retval;
124}
125
126static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
127{
128	return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
129}
130
131static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
132{
133	struct inode *inode;
134	int error = -ENOSPC;
135
136	inode = ramfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
137	if (inode) {
138		int l = strlen(symname)+1;
139		error = page_symlink(inode, symname, l);
140		if (!error) {
141			d_instantiate(dentry, inode);
142			dget(dentry);
143			dir->i_mtime = dir->i_ctime = current_time(dir);
144		} else
145			iput(inode);
146	}
147	return error;
148}
149
150static const struct inode_operations ramfs_dir_inode_operations = {
151	.create		= ramfs_create,
152	.lookup		= simple_lookup,
153	.link		= simple_link,
154	.unlink		= simple_unlink,
155	.symlink	= ramfs_symlink,
156	.mkdir		= ramfs_mkdir,
157	.rmdir		= simple_rmdir,
158	.mknod		= ramfs_mknod,
159	.rename		= simple_rename,
160};
161
162/*
163 * Display the mount options in /proc/mounts.
164 */
165static int ramfs_show_options(struct seq_file *m, struct dentry *root)
166{
167	struct ramfs_fs_info *fsi = root->d_sb->s_fs_info;
168
169	if (fsi->mount_opts.mode != RAMFS_DEFAULT_MODE)
170		seq_printf(m, ",mode=%o", fsi->mount_opts.mode);
171	return 0;
172}
173
174static const struct super_operations ramfs_ops = {
175	.statfs		= simple_statfs,
176	.drop_inode	= generic_delete_inode,
177	.show_options	= ramfs_show_options,
178};
179
180enum ramfs_param {
181	Opt_mode,
182};
183
184const struct fs_parameter_spec ramfs_fs_parameters[] = {
185	fsparam_u32oct("mode",	Opt_mode),
186	{}
187};
188
 
 
 
 
 
189static int ramfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
190{
191	struct fs_parse_result result;
192	struct ramfs_fs_info *fsi = fc->s_fs_info;
193	int opt;
194
195	opt = fs_parse(fc, ramfs_fs_parameters, param, &result);
196	if (opt < 0) {
197		/*
198		 * We might like to report bad mount options here;
199		 * but traditionally ramfs has ignored all mount options,
200		 * and as it is used as a !CONFIG_SHMEM simple substitute
201		 * for tmpfs, better continue to ignore other mount options.
202		 */
203		if (opt == -ENOPARAM)
204			opt = 0;
205		return opt;
206	}
207
208	switch (opt) {
209	case Opt_mode:
210		fsi->mount_opts.mode = result.uint_32 & S_IALLUGO;
211		break;
212	}
213
214	return 0;
215}
216
217static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
218{
219	struct ramfs_fs_info *fsi = sb->s_fs_info;
220	struct inode *inode;
221
222	sb->s_maxbytes		= MAX_LFS_FILESIZE;
223	sb->s_blocksize		= PAGE_SIZE;
224	sb->s_blocksize_bits	= PAGE_SHIFT;
225	sb->s_magic		= RAMFS_MAGIC;
226	sb->s_op		= &ramfs_ops;
227	sb->s_time_gran		= 1;
228
229	inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
230	sb->s_root = d_make_root(inode);
231	if (!sb->s_root)
232		return -ENOMEM;
233
234	return 0;
235}
236
237static int ramfs_get_tree(struct fs_context *fc)
238{
239	return get_tree_nodev(fc, ramfs_fill_super);
240}
241
242static void ramfs_free_fc(struct fs_context *fc)
243{
244	kfree(fc->s_fs_info);
245}
246
247static const struct fs_context_operations ramfs_context_ops = {
248	.free		= ramfs_free_fc,
249	.parse_param	= ramfs_parse_param,
250	.get_tree	= ramfs_get_tree,
251};
252
253int ramfs_init_fs_context(struct fs_context *fc)
254{
255	struct ramfs_fs_info *fsi;
256
257	fsi = kzalloc(sizeof(*fsi), GFP_KERNEL);
258	if (!fsi)
259		return -ENOMEM;
260
261	fsi->mount_opts.mode = RAMFS_DEFAULT_MODE;
262	fc->s_fs_info = fsi;
263	fc->ops = &ramfs_context_ops;
264	return 0;
265}
266
267static void ramfs_kill_sb(struct super_block *sb)
268{
269	kfree(sb->s_fs_info);
270	kill_litter_super(sb);
271}
272
273static struct file_system_type ramfs_fs_type = {
274	.name		= "ramfs",
275	.init_fs_context = ramfs_init_fs_context,
276	.parameters	= ramfs_fs_parameters,
277	.kill_sb	= ramfs_kill_sb,
278	.fs_flags	= FS_USERNS_MOUNT,
279};
280
281static int __init init_ramfs_fs(void)
282{
283	return register_filesystem(&ramfs_fs_type);
284}
285fs_initcall(init_ramfs_fs);