Find the answer to your Linux question:
Results 1 to 6 of 6
Hi, I would like to know what is the name or source code location of the device driver for ramdisks in the Linux Kernel. (major=1) Thanks in advance...
Enjoy an ad free experience by logging in. Not a member yet? Register.
  1. #1
    JC1
    JC1 is offline
    Just Joined!
    Join Date
    Apr 2011
    Posts
    3

    Ramdisk device driver


    Hi,

    I would like to know what is the name or source code location of the device driver for ramdisks in the Linux Kernel. (major=1)

    Thanks in advance

  2. #2
    Linux Guru Rubberman's Avatar
    Join Date
    Apr 2009
    Location
    I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
    Posts
    11,737
    Do you have the kernel source installed on your system?
    Sometimes, real fast is almost as good as real time.
    Just remember, Semper Gumbi - always be flexible!

  3. #3
    JC1
    JC1 is offline
    Just Joined!
    Join Date
    Apr 2011
    Posts
    3
    Yes, I do.

  4. $spacer_open
    $spacer_close
  5. #4
    Linux Guru Rubberman's Avatar
    Join Date
    Apr 2009
    Location
    I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
    Posts
    11,737
    What kernel are you running? Post the output of "uname -r" here.
    Sometimes, real fast is almost as good as real time.
    Just remember, Semper Gumbi - always be flexible!

  6. #5
    JC1
    JC1 is offline
    Just Joined!
    Join Date
    Apr 2011
    Posts
    3
    2.6.32.22.1.amd64-smp

  7. #6
    Linux Guru Rubberman's Avatar
    Join Date
    Apr 2009
    Location
    I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
    Posts
    11,737
    Go to the source directory where you would configure and build the kernel. You will find the ram disc driver here: fs/ramfs

    Besides the Makefile, there are only 3 source files and 1 header.
    Code:
    /* internal.h: ramfs internal definitions
     *
     * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
     * Written by David Howells (dhowells@redhat.com)
     *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation; either version
     * 2 of the License, or (at your option) any later version.
     */
    
    
    extern const struct address_space_operations ramfs_aops;
    extern const struct inode_operations ramfs_file_inode_operations;
    Code:
    /* file-mmu.c: ramfs MMU-based file operations
     *
     * Resizable simple ram filesystem for Linux.
     *
     * Copyright (C) 2000 Linus Torvalds.
     *               2000 Transmeta Corp.
     *
     * Usage limits added by David Gibson, Linuxcare Australia.
     * This file is released under the GPL.
     */
    
    /*
     * NOTE! This filesystem is probably most useful
     * not as a real filesystem, but as an example of
     * how virtual filesystems can be written.
     *
     * It doesn't get much simpler than this. Consider
     * that this file implements the full semantics of
     * a POSIX-compliant read-write filesystem.
     *
     * Note in particular how the filesystem does not
     * need to implement any data structures of its own
     * to keep track of the virtual data: using the VFS
     * caches is sufficient.
     */
    
    #include <linux/fs.h>
    #include <linux/mm.h>
    #include <linux/ramfs.h>
    
    #include "internal.h"
    
    const struct address_space_operations ramfs_aops = {
    	.readpage	= simple_readpage,
    	.write_begin	= simple_write_begin,
    	.write_end	= simple_write_end,
    	.set_page_dirty = __set_page_dirty_no_writeback,
    };
    
    const struct file_operations ramfs_file_operations = {
    	.read		= do_sync_read,
    	.aio_read	= generic_file_aio_read,
    	.write		= do_sync_write,
    	.aio_write	= generic_file_aio_write,
    	.mmap		= generic_file_mmap,
    	.fsync		= simple_sync_file,
    	.splice_read	= generic_file_splice_read,
    	.splice_write	= generic_file_splice_write,
    	.llseek		= generic_file_llseek,
    };
    
    const struct inode_operations ramfs_file_inode_operations = {
    	.getattr	= simple_getattr,
    };
    Code:
    /* file-nommu.c: no-MMU version of ramfs
     *
     * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
     * Written by David Howells (dhowells@redhat.com)
     *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation; either version
     * 2 of the License, or (at your option) any later version.
     */
    
    #include <linux/module.h>
    #include <linux/fs.h>
    #include <linux/mm.h>
    #include <linux/pagemap.h>
    #include <linux/highmem.h>
    #include <linux/init.h>
    #include <linux/string.h>
    #include <linux/backing-dev.h>
    #include <linux/ramfs.h>
    #include <linux/pagevec.h>
    #include <linux/mman.h>
    #include <linux/sched.h>
    
    #include <asm/uaccess.h>
    #include "internal.h"
    
    static int ramfs_nommu_setattr(struct dentry *, struct iattr *);
    
    const struct address_space_operations ramfs_aops = {
    	.readpage		= simple_readpage,
    	.write_begin		= simple_write_begin,
    	.write_end		= simple_write_end,
    	.set_page_dirty		= __set_page_dirty_no_writeback,
    };
    
    const struct file_operations ramfs_file_operations = {
    	.mmap			= ramfs_nommu_mmap,
    	.get_unmapped_area	= ramfs_nommu_get_unmapped_area,
    	.read			= do_sync_read,
    	.aio_read		= generic_file_aio_read,
    	.write			= do_sync_write,
    	.aio_write		= generic_file_aio_write,
    	.fsync			= simple_sync_file,
    	.splice_read		= generic_file_splice_read,
    	.splice_write		= generic_file_splice_write,
    	.llseek			= generic_file_llseek,
    };
    
    const struct inode_operations ramfs_file_inode_operations = {
    	.setattr		= ramfs_nommu_setattr,
    	.getattr		= simple_getattr,
    };
    
    /*****************************************************************************/
    /*
     * add a contiguous set of pages into a ramfs inode when it's truncated from
     * size 0 on the assumption that it's going to be used for an mmap of shared
     * memory
     */
    int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
    {
    	unsigned long npages, xpages, loop, limit;
    	struct page *pages;
    	unsigned order;
    	void *data;
    	int ret;
    
    	/* make various checks */
    	order = get_order(newsize);
    	if (unlikely(order >= MAX_ORDER))
    		return -EFBIG;
    
    	ret = inode_newsize_ok(inode, newsize);
    	if (ret)
    		return ret;
    
    	i_size_write(inode, newsize);
    
    	/* allocate enough contiguous pages to be able to satisfy the
    	 * request */
    	pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order);
    	if (!pages)
    		return -ENOMEM;
    
    	/* split the high-order page into an array of single pages */
    	xpages = 1UL << order;
    	npages = (newsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
    
    	split_page(pages, order);
    
    	/* trim off any pages we don't actually require */
    	for (loop = npages; loop < xpages; loop++)
    		__free_page(pages + loop);
    
    	/* clear the memory we allocated */
    	newsize = PAGE_SIZE * npages;
    	data = page_address(pages);
    	memset(data, 0, newsize);
    
    	/* attach all the pages to the inode's address space */
    	for (loop = 0; loop < npages; loop++) {
    		struct page *page = pages + loop;
    
    		ret = add_to_page_cache_lru(page, inode->i_mapping, loop,
    					GFP_KERNEL);
    		if (ret < 0)
    			goto add_error;
    
    		/* prevent the page from being discarded on memory pressure */
    		SetPageDirty(page);
    
    		unlock_page(page);
    	}
    
    	return 0;
    
    add_error:
    	while (loop < npages)
    		__free_page(pages + loop++);
    	return ret;
    }
    
    /*****************************************************************************/
    /*
     * check that file shrinkage doesn't leave any VMAs dangling in midair
     */
    static int ramfs_nommu_check_mappings(struct inode *inode,
    				      size_t newsize, size_t size)
    {
    	struct vm_area_struct *vma;
    	struct prio_tree_iter iter;
    
    	/* search for VMAs that fall within the dead zone */
    	vma_prio_tree_foreach(vma, &iter, &inode->i_mapping->i_mmap,
    			      newsize >> PAGE_SHIFT,
    			      (size + PAGE_SIZE - 1) >> PAGE_SHIFT
    			      ) {
    		/* found one - only interested if it's shared out of the page
    		 * cache */
    		if (vma->vm_flags & VM_SHARED)
    			return -ETXTBSY; /* not quite true, but near enough */
    	}
    
    	return 0;
    }
    
    /*****************************************************************************/
    /*
     *
     */
    static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size)
    {
    	int ret;
    
    	/* assume a truncate from zero size is going to be for the purposes of
    	 * shared mmap */
    	if (size == 0) {
    		if (unlikely(newsize >> 32))
    			return -EFBIG;
    
    		return ramfs_nommu_expand_for_mapping(inode, newsize);
    	}
    
    	/* check that a decrease in size doesn't cut off any shared mappings */
    	if (newsize < size) {
    		ret = ramfs_nommu_check_mappings(inode, newsize, size);
    		if (ret < 0)
    			return ret;
    	}
    
    	ret = vmtruncate(inode, newsize);
    
    	return ret;
    }
    
    /*****************************************************************************/
    /*
     * handle a change of attributes
     * - we're specifically interested in a change of size
     */
    static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
    {
    	struct inode *inode = dentry->d_inode;
    	unsigned int old_ia_valid = ia->ia_valid;
    	int ret = 0;
    
    	/* POSIX UID/GID verification for setting inode attributes */
    	ret = inode_change_ok(inode, ia);
    	if (ret)
    		return ret;
    
    	/* pick out size-changing events */
    	if (ia->ia_valid & ATTR_SIZE) {
    		loff_t size = i_size_read(inode);
    		if (ia->ia_size != size) {
    			ret = ramfs_nommu_resize(inode, ia->ia_size, size);
    			if (ret < 0 || ia->ia_valid == ATTR_SIZE)
    				goto out;
    		} else {
    			/* we skipped the truncate but must still update
    			 * timestamps
    			 */
    			ia->ia_valid |= ATTR_MTIME|ATTR_CTIME;
    		}
    	}
    
    	ret = inode_setattr(inode, ia);
     out:
    	ia->ia_valid = old_ia_valid;
    	return ret;
    }
    
    /*****************************************************************************/
    /*
     * try to determine where a shared mapping can be made
     * - we require that:
     *   - the pages to be mapped must exist
     *   - the pages be physically contiguous in sequence
     */
    unsigned long ramfs_nommu_get_unmapped_area(struct file *file,
    					    unsigned long addr, unsigned long len,
    					    unsigned long pgoff, unsigned long flags)
    {
    	unsigned long maxpages, lpages, nr, loop, ret;
    	struct inode *inode = file->f_path.dentry->d_inode;
    	struct page **pages = NULL, **ptr, *page;
    	loff_t isize;
    
    	if (!(flags & MAP_SHARED))
    		return addr;
    
    	/* the mapping mustn't extend beyond the EOF */
    	lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
    	isize = i_size_read(inode);
    
    	ret = -EINVAL;
    	maxpages = (isize + PAGE_SIZE - 1) >> PAGE_SHIFT;
    	if (pgoff >= maxpages)
    		goto out;
    
    	if (maxpages - pgoff < lpages)
    		goto out;
    
    	/* gang-find the pages */
    	ret = -ENOMEM;
    	pages = kzalloc(lpages * sizeof(struct page *), GFP_KERNEL);
    	if (!pages)
    		goto out_free;
    
    	nr = find_get_pages(inode->i_mapping, pgoff, lpages, pages);
    	if (nr != lpages)
    		goto out_free_pages; /* leave if some pages were missing */
    
    	/* check the pages for physical adjacency */
    	ptr = pages;
    	page = *ptr++;
    	page++;
    	for (loop = lpages; loop > 1; loop--)
    		if (*ptr++ != page++)
    			goto out_free_pages;
    
    	/* okay - all conditions fulfilled */
    	ret = (unsigned long) page_address(pages[0]);
    
    out_free_pages:
    	ptr = pages;
    	for (loop = nr; loop > 0; loop--)
    		put_page(*ptr++);
    out_free:
    	kfree(pages);
    out:
    	return ret;
    }
    
    /*****************************************************************************/
    /*
     * set up a mapping for shared memory segments
     */
    int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma)
    {
    	if (!(vma->vm_flags & VM_SHARED))
    		return -ENOSYS;
    
    	file_accessed(file);
    	vma->vm_ops = &generic_file_vm_ops;
    	return 0;
    }
    Code:
    /*
     * Resizable simple ram filesystem for Linux.
     *
     * Copyright (C) 2000 Linus Torvalds.
     *               2000 Transmeta Corp.
     *
     * Usage limits added by David Gibson, Linuxcare Australia.
     * This file is released under the GPL.
     */
    
    /*
     * NOTE! This filesystem is probably most useful
     * not as a real filesystem, but as an example of
     * how virtual filesystems can be written.
     *
     * It doesn't get much simpler than this. Consider
     * that this file implements the full semantics of
     * a POSIX-compliant read-write filesystem.
     *
     * Note in particular how the filesystem does not
     * need to implement any data structures of its own
     * to keep track of the virtual data: using the VFS
     * caches is sufficient.
     */
    
    #include <linux/module.h>
    #include <linux/fs.h>
    #include <linux/pagemap.h>
    #include <linux/highmem.h>
    #include <linux/time.h>
    #include <linux/init.h>
    #include <linux/string.h>
    #include <linux/backing-dev.h>
    #include <linux/ramfs.h>
    #include <linux/sched.h>
    #include <linux/parser.h>
    #include <linux/magic.h>
    #include <asm/uaccess.h>
    #include "internal.h"
    
    #define RAMFS_DEFAULT_MODE	0755
    
    static const struct super_operations ramfs_ops;
    static const struct inode_operations ramfs_dir_inode_operations;
    
    static struct backing_dev_info ramfs_backing_dev_info = {
    	.name		= "ramfs",
    	.ra_pages	= 0,	/* No readahead */
    	.capabilities	= BDI_CAP_NO_ACCT_AND_WRITEBACK |
    			  BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY |
    			  BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP,
    };
    
    struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev)
    {
    	struct inode * inode = new_inode(sb);
    
    	if (inode) {
    		inode->i_mode = mode;
    		inode->i_uid = current_fsuid();
    		inode->i_gid = current_fsgid();
    		inode->i_mapping->a_ops = &ramfs_aops;
    		inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info;
    		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
    		mapping_set_unevictable(inode->i_mapping);
    		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
    		switch (mode & S_IFMT) {
    		default:
    			init_special_inode(inode, mode, dev);
    			break;
    		case S_IFREG:
    			inode->i_op = &ramfs_file_inode_operations;
    			inode->i_fop = &ramfs_file_operations;
    			break;
    		case S_IFDIR:
    			inode->i_op = &ramfs_dir_inode_operations;
    			inode->i_fop = &simple_dir_operations;
    
    			/* directory inodes start off with i_nlink == 2 (for "." entry) */
    			inc_nlink(inode);
    			break;
    		case S_IFLNK:
    			inode->i_op = &page_symlink_inode_operations;
    			break;
    		}
    	}
    	return inode;
    }
    
    /*
     * File creation. Allocate an inode, and we're done..
     */
    /* SMP-safe */
    static int
    ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
    {
    	struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev);
    	int error = -ENOSPC;
    
    	if (inode) {
    		if (dir->i_mode & S_ISGID) {
    			inode->i_gid = dir->i_gid;
    			if (S_ISDIR(mode))
    				inode->i_mode |= S_ISGID;
    		}
    		d_instantiate(dentry, inode);
    		dget(dentry);	/* Extra count - pin the dentry in core */
    		error = 0;
    		dir->i_mtime = dir->i_ctime = CURRENT_TIME;
    	}
    	return error;
    }
    
    static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
    {
    	int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
    	if (!retval)
    		inc_nlink(dir);
    	return retval;
    }
    
    static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
    {
    	return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
    }
    
    static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
    {
    	struct inode *inode;
    	int error = -ENOSPC;
    
    	inode = ramfs_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0);
    	if (inode) {
    		int l = strlen(symname)+1;
    		error = page_symlink(inode, symname, l);
    		if (!error) {
    			if (dir->i_mode & S_ISGID)
    				inode->i_gid = dir->i_gid;
    			d_instantiate(dentry, inode);
    			dget(dentry);
    			dir->i_mtime = dir->i_ctime = CURRENT_TIME;
    		} else
    			iput(inode);
    	}
    	return error;
    }
    
    static const struct inode_operations ramfs_dir_inode_operations = {
    	.create		= ramfs_create,
    	.lookup		= simple_lookup,
    	.link		= simple_link,
    	.unlink		= simple_unlink,
    	.symlink	= ramfs_symlink,
    	.mkdir		= ramfs_mkdir,
    	.rmdir		= simple_rmdir,
    	.mknod		= ramfs_mknod,
    	.rename		= simple_rename,
    };
    
    static const struct super_operations ramfs_ops = {
    	.statfs		= simple_statfs,
    	.drop_inode	= generic_delete_inode,
    	.show_options	= generic_show_options,
    };
    
    struct ramfs_mount_opts {
    	umode_t mode;
    };
    
    enum {
    	Opt_mode,
    	Opt_err
    };
    
    static const match_table_t tokens = {
    	{Opt_mode, "mode=%o"},
    	{Opt_err, NULL}
    };
    
    struct ramfs_fs_info {
    	struct ramfs_mount_opts mount_opts;
    };
    
    static int ramfs_parse_options(char *data, struct ramfs_mount_opts *opts)
    {
    	substring_t args[MAX_OPT_ARGS];
    	int option;
    	int token;
    	char *p;
    
    	opts->mode = RAMFS_DEFAULT_MODE;
    
    	while ((p = strsep(&data, ",")) != NULL) {
    		if (!*p)
    			continue;
    
    		token = match_token(p, tokens, args);
    		switch (token) {
    		case Opt_mode:
    			if (match_octal(&args[0], &option))
    				return -EINVAL;
    			opts->mode = option & S_IALLUGO;
    			break;
    		/*
    		 * We might like to report bad mount options here;
    		 * but traditionally ramfs has ignored all mount options,
    		 * and as it is used as a !CONFIG_SHMEM simple substitute
    		 * for tmpfs, better continue to ignore other mount options.
    		 */
    		}
    	}
    
    	return 0;
    }
    
    static int ramfs_fill_super(struct super_block * sb, void * data, int silent)
    {
    	struct ramfs_fs_info *fsi;
    	struct inode *inode = NULL;
    	struct dentry *root;
    	int err;
    
    	save_mount_options(sb, data);
    
    	fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL);
    	sb->s_fs_info = fsi;
    	if (!fsi) {
    		err = -ENOMEM;
    		goto fail;
    	}
    
    	err = ramfs_parse_options(data, &fsi->mount_opts);
    	if (err)
    		goto fail;
    
    	sb->s_maxbytes		= MAX_LFS_FILESIZE;
    	sb->s_blocksize		= PAGE_CACHE_SIZE;
    	sb->s_blocksize_bits	= PAGE_CACHE_SHIFT;
    	sb->s_magic		= RAMFS_MAGIC;
    	sb->s_op		= &ramfs_ops;
    	sb->s_time_gran		= 1;
    
    	inode = ramfs_get_inode(sb, S_IFDIR | fsi->mount_opts.mode, 0);
    	if (!inode) {
    		err = -ENOMEM;
    		goto fail;
    	}
    
    	root = d_alloc_root(inode);
    	sb->s_root = root;
    	if (!root) {
    		err = -ENOMEM;
    		goto fail;
    	}
    
    	return 0;
    fail:
    	kfree(fsi);
    	sb->s_fs_info = NULL;
    	iput(inode);
    	return err;
    }
    
    int ramfs_get_sb(struct file_system_type *fs_type,
    	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
    {
    	return get_sb_nodev(fs_type, flags, data, ramfs_fill_super, mnt);
    }
    
    static int rootfs_get_sb(struct file_system_type *fs_type,
    	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
    {
    	return get_sb_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super,
    			    mnt);
    }
    
    static void ramfs_kill_sb(struct super_block *sb)
    {
    	kfree(sb->s_fs_info);
    	kill_litter_super(sb);
    }
    
    static struct file_system_type ramfs_fs_type = {
    	.name		= "ramfs",
    	.get_sb		= ramfs_get_sb,
    	.kill_sb	= ramfs_kill_sb,
    };
    static struct file_system_type rootfs_fs_type = {
    	.name		= "rootfs",
    	.get_sb		= rootfs_get_sb,
    	.kill_sb	= kill_litter_super,
    };
    
    static int __init init_ramfs_fs(void)
    {
    	return register_filesystem(&ramfs_fs_type);
    }
    
    static void __exit exit_ramfs_fs(void)
    {
    	unregister_filesystem(&ramfs_fs_type);
    }
    
    module_init(init_ramfs_fs)
    module_exit(exit_ramfs_fs)
    
    int __init init_rootfs(void)
    {
    	int err;
    
    	err = bdi_init(&ramfs_backing_dev_info);
    	if (err)
    		return err;
    
    	err = register_filesystem(&rootfs_fs_type);
    	if (err)
    		bdi_destroy(&ramfs_backing_dev_info);
    
    	return err;
    }
    
    MODULE_LICENSE("GPL");
    Sometimes, real fast is almost as good as real time.
    Just remember, Semper Gumbi - always be flexible!

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •