mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-03 17:40:04 +00:00
![Mel Gorman](/assets/img/avatar_default.png)
It is often known at allocation time whether a page may be migrated or not. This patch adds a flag called __GFP_MOVABLE and a new mask called GFP_HIGH_MOVABLE. Allocations using the __GFP_MOVABLE can be either migrated using the page migration mechanism or reclaimed by syncing with backing storage and discarding. An API function very similar to alloc_zeroed_user_highpage() is added for __GFP_MOVABLE allocations called alloc_zeroed_user_highpage_movable(). The flags used by alloc_zeroed_user_highpage() are not changed because it would change the semantics of an existing API. After this patch is applied there are no in-kernel users of alloc_zeroed_user_highpage() so it probably should be marked deprecated if this patch is merged. Note that this patch includes a minor cleanup to the use of __GFP_ZERO in shmem.c to keep all flag modifications to inode->mapping in the shmem_dir_alloc() helper function. This clean-up suggestion is courtesy of Hugh Dickens. Additional credit goes to Christoph Lameter and Linus Torvalds for shaping the concept. Credit to Hugh Dickens for catching issues with shmem swap vector and ramfs allocations. [akpm@linux-foundation.org: build fix] [hugh@veritas.com: __GFP_ZERO cleanup] Signed-off-by: Mel Gorman <mel@csn.ul.ie> Cc: Andy Whitcroft <apw@shadowen.org> Cc: Christoph Lameter <clameter@sgi.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
229 lines
5.6 KiB
C
229 lines
5.6 KiB
C
/*
|
|
* 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 <asm/uaccess.h>
|
|
#include "internal.h"
|
|
|
|
/* some random number */
|
|
#define RAMFS_MAGIC 0x858458f6
|
|
|
|
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 = {
|
|
.ra_pages = 0, /* No readahead */
|
|
.capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_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_blocks = 0;
|
|
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);
|
|
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,
|
|
};
|
|
|
|
static int ramfs_fill_super(struct super_block * sb, void * data, int silent)
|
|
{
|
|
struct inode * inode;
|
|
struct dentry * root;
|
|
|
|
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 | 0755, 0);
|
|
if (!inode)
|
|
return -ENOMEM;
|
|
|
|
root = d_alloc_root(inode);
|
|
if (!root) {
|
|
iput(inode);
|
|
return -ENOMEM;
|
|
}
|
|
sb->s_root = root;
|
|
return 0;
|
|
}
|
|
|
|
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 struct file_system_type ramfs_fs_type = {
|
|
.name = "ramfs",
|
|
.get_sb = ramfs_get_sb,
|
|
.kill_sb = kill_litter_super,
|
|
};
|
|
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)
|
|
{
|
|
return register_filesystem(&rootfs_fs_type);
|
|
}
|
|
|
|
MODULE_LICENSE("GPL");
|