X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=mm%2Fshmem.c;h=2ffa1cc1686bdc64cea3c9cf77609db8c5c6aa71;hb=6a77f38946aaee1cd85eeec6cf4229b204c15071;hp=8951a2a5023f3b7b7b141ab35ff98699c8eb7281;hpb=87fc8d1bb10cd459024a742c6a10961fefcef18f;p=linux-2.6.git diff --git a/mm/shmem.c b/mm/shmem.c index 8951a2a50..2ffa1cc16 100644 --- a/mm/shmem.c +++ b/mm/shmem.c @@ -10,6 +10,10 @@ * Copyright (C) 2002-2004 VERITAS Software Corporation. * Copyright (C) 2004 Andi Kleen, SuSE Labs * + * Extended attribute support for tmpfs: + * Copyright (c) 2004, Luke Kenneth Casson Leighton + * Copyright (c) 2004 Red Hat, Inc., James Morris + * * This file is released under the GPL. */ @@ -41,6 +45,7 @@ #include #include #include +#include #include #include #include @@ -60,6 +65,9 @@ #define SHMEM_PAGEIN VM_READ #define SHMEM_TRUNCATE VM_WRITE +/* Definition to limit shmem_truncate's steps between cond_rescheds */ +#define LATENCY_LIMIT 64 + /* Pretend that each entry is of this size in directory's i_size */ #define BOGO_DIRENT_SIZE 20 @@ -170,6 +178,7 @@ static struct address_space_operations shmem_aops; static struct file_operations shmem_file_operations; static struct inode_operations shmem_inode_operations; static struct inode_operations shmem_dir_inode_operations; +static struct inode_operations shmem_special_inode_operations; static struct vm_operations_struct shmem_vm_ops; static struct backing_dev_info shmem_backing_dev_info = { @@ -179,15 +188,15 @@ static struct backing_dev_info shmem_backing_dev_info = { }; static LIST_HEAD(shmem_swaplist); -static spinlock_t shmem_swaplist_lock = SPIN_LOCK_UNLOCKED; +static DEFINE_SPINLOCK(shmem_swaplist_lock); -static void shmem_free_block(struct inode *inode) +static void shmem_free_blocks(struct inode *inode, long pages) { struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb); if (sbinfo) { spin_lock(&sbinfo->stat_lock); - sbinfo->free_blocks++; - inode->i_blocks -= BLOCKS_PER_PAGE; + sbinfo->free_blocks += pages; + inode->i_blocks -= pages*BLOCKS_PER_PAGE; spin_unlock(&sbinfo->stat_lock); } } @@ -212,15 +221,9 @@ static void shmem_recalc_inode(struct inode *inode) freed = info->alloced - info->swapped - inode->i_mapping->nrpages; if (freed > 0) { - struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb); info->alloced -= freed; shmem_unacct_blocks(info->flags, freed); - if (sbinfo) { - spin_lock(&sbinfo->stat_lock); - sbinfo->free_blocks += freed; - inode->i_blocks -= freed*BLOCKS_PER_PAGE; - spin_unlock(&sbinfo->stat_lock); - } + shmem_free_blocks(inode, freed); } } @@ -365,15 +368,14 @@ static swp_entry_t *shmem_swp_alloc(struct shmem_inode_info *info, unsigned long } spin_unlock(&info->lock); - page = shmem_dir_alloc(mapping_gfp_mask(inode->i_mapping)); + page = shmem_dir_alloc(mapping_gfp_mask(inode->i_mapping) | __GFP_ZERO); if (page) { - clear_highpage(page); page->nr_swapped = 0; } spin_lock(&info->lock); if (!page) { - shmem_free_block(inode); + shmem_free_blocks(inode, 1); return ERR_PTR(-ENOMEM); } if (sgp != SGP_WRITE && @@ -386,7 +388,7 @@ static swp_entry_t *shmem_swp_alloc(struct shmem_inode_info *info, unsigned long } if (page) { /* another task gave its page, or truncated the file */ - shmem_free_block(inode); + shmem_free_blocks(inode, 1); shmem_dir_free(page); } if (info->next_index <= index && !IS_ERR(entry)) @@ -415,6 +417,49 @@ static int shmem_free_swp(swp_entry_t *dir, swp_entry_t *edir) return freed; } +static int shmem_map_and_free_swp(struct page *subdir, + int offset, int limit, struct page ***dir) +{ + swp_entry_t *ptr; + int freed = 0; + + ptr = shmem_swp_map(subdir); + for (; offset < limit; offset += LATENCY_LIMIT) { + int size = limit - offset; + if (size > LATENCY_LIMIT) + size = LATENCY_LIMIT; + freed += shmem_free_swp(ptr+offset, ptr+offset+size); + if (need_resched()) { + shmem_swp_unmap(ptr); + if (*dir) { + shmem_dir_unmap(*dir); + *dir = NULL; + } + cond_resched(); + ptr = shmem_swp_map(subdir); + } + } + shmem_swp_unmap(ptr); + return freed; +} + +static void shmem_free_pages(struct list_head *next) +{ + struct page *page; + int freed = 0; + + do { + page = container_of(next, struct page, lru); + next = next->next; + shmem_dir_free(page); + freed++; + if (freed >= LATENCY_LIMIT) { + cond_resched(); + freed = 0; + } + } while (next); +} + static void shmem_truncate(struct inode *inode) { struct shmem_inode_info *info = SHMEM_I(inode); @@ -422,10 +467,15 @@ static void shmem_truncate(struct inode *inode) unsigned long size; unsigned long limit; unsigned long stage; + unsigned long diroff; struct page **dir; + struct page *topdir; + struct page *middir; struct page *subdir; - struct page *empty; swp_entry_t *ptr; + LIST_HEAD(pages_to_free); + long nr_pages_to_free = 0; + long nr_swaps_freed = 0; int offset; int freed; @@ -438,14 +488,22 @@ static void shmem_truncate(struct inode *inode) info->flags |= SHMEM_TRUNCATE; limit = info->next_index; info->next_index = idx; + topdir = info->i_indirect; + if (topdir && idx <= SHMEM_NR_DIRECT) { + info->i_indirect = NULL; + nr_pages_to_free++; + list_add(&topdir->lru, &pages_to_free); + } + spin_unlock(&info->lock); + if (info->swapped && idx < SHMEM_NR_DIRECT) { ptr = info->i_direct; size = limit; if (size > SHMEM_NR_DIRECT) size = SHMEM_NR_DIRECT; - info->swapped -= shmem_free_swp(ptr+idx, ptr+size); + nr_swaps_freed = shmem_free_swp(ptr+idx, ptr+size); } - if (!info->i_indirect) + if (!topdir) goto done2; BUG_ON(limit <= SHMEM_NR_DIRECT); @@ -454,36 +512,38 @@ static void shmem_truncate(struct inode *inode) offset = idx % ENTRIES_PER_PAGE; idx -= offset; - empty = NULL; - dir = shmem_dir_map(info->i_indirect); + dir = shmem_dir_map(topdir); stage = ENTRIES_PER_PAGEPAGE/2; - if (idx < ENTRIES_PER_PAGEPAGE/2) - dir += idx/ENTRIES_PER_PAGE; - else { + if (idx < ENTRIES_PER_PAGEPAGE/2) { + middir = topdir; + diroff = idx/ENTRIES_PER_PAGE; + } else { dir += ENTRIES_PER_PAGE/2; dir += (idx - ENTRIES_PER_PAGEPAGE/2)/ENTRIES_PER_PAGEPAGE; while (stage <= idx) stage += ENTRIES_PER_PAGEPAGE; + middir = *dir; if (*dir) { - subdir = *dir; - size = ((idx - ENTRIES_PER_PAGEPAGE/2) % + diroff = ((idx - ENTRIES_PER_PAGEPAGE/2) % ENTRIES_PER_PAGEPAGE) / ENTRIES_PER_PAGE; - if (!size && !offset) { - empty = subdir; + if (!diroff && !offset) { *dir = NULL; + nr_pages_to_free++; + list_add(&middir->lru, &pages_to_free); } shmem_dir_unmap(dir); - dir = shmem_dir_map(subdir) + size; + dir = shmem_dir_map(middir); } else { + diroff = 0; offset = 0; idx = stage; } } - for (; idx < limit; idx += ENTRIES_PER_PAGE, dir++) { + for (; idx < limit; idx += ENTRIES_PER_PAGE, diroff++) { if (unlikely(idx == stage)) { - shmem_dir_unmap(dir-1); - dir = shmem_dir_map(info->i_indirect) + + shmem_dir_unmap(dir); + dir = shmem_dir_map(topdir) + ENTRIES_PER_PAGE/2 + idx/ENTRIES_PER_PAGEPAGE; while (!*dir) { dir++; @@ -492,50 +552,43 @@ static void shmem_truncate(struct inode *inode) goto done1; } stage = idx + ENTRIES_PER_PAGEPAGE; - subdir = *dir; + middir = *dir; *dir = NULL; + nr_pages_to_free++; + list_add(&middir->lru, &pages_to_free); shmem_dir_unmap(dir); - if (empty) { - shmem_dir_free(empty); - shmem_free_block(inode); - } - empty = subdir; - cond_resched_lock(&info->lock); - dir = shmem_dir_map(subdir); + cond_resched(); + dir = shmem_dir_map(middir); + diroff = 0; } - subdir = *dir; + subdir = dir[diroff]; if (subdir && subdir->nr_swapped) { - ptr = shmem_swp_map(subdir); size = limit - idx; if (size > ENTRIES_PER_PAGE) size = ENTRIES_PER_PAGE; - freed = shmem_free_swp(ptr+offset, ptr+size); - shmem_swp_unmap(ptr); - info->swapped -= freed; + freed = shmem_map_and_free_swp(subdir, + offset, size, &dir); + if (!dir) + dir = shmem_dir_map(middir); + nr_swaps_freed += freed; + if (offset) + spin_lock(&info->lock); subdir->nr_swapped -= freed; + if (offset) + spin_unlock(&info->lock); BUG_ON(subdir->nr_swapped > offset); } if (offset) offset = 0; else if (subdir) { - *dir = NULL; - shmem_dir_free(subdir); - shmem_free_block(inode); + dir[diroff] = NULL; + nr_pages_to_free++; + list_add(&subdir->lru, &pages_to_free); } } done1: - shmem_dir_unmap(dir-1); - if (empty) { - shmem_dir_free(empty); - shmem_free_block(inode); - } - if (info->next_index <= SHMEM_NR_DIRECT) { - shmem_dir_free(info->i_indirect); - info->i_indirect = NULL; - shmem_free_block(inode); - } + shmem_dir_unmap(dir); done2: - BUG_ON(info->swapped > info->next_index); if (inode->i_mapping->nrpages && (info->flags & SHMEM_PAGEIN)) { /* * Call truncate_inode_pages again: racing shmem_unuse_inode @@ -544,13 +597,24 @@ done2: * Also, though shmem_getpage checks i_size before adding to * cache, no recheck after: so fix the narrow window there too. */ - spin_unlock(&info->lock); truncate_inode_pages(inode->i_mapping, inode->i_size); - spin_lock(&info->lock); } + + spin_lock(&info->lock); info->flags &= ~SHMEM_TRUNCATE; + info->swapped -= nr_swaps_freed; + if (nr_pages_to_free) + shmem_free_blocks(inode, nr_pages_to_free); shmem_recalc_inode(inode); spin_unlock(&info->lock); + + /* + * Empty swap vector directory pages to be freed? + */ + if (!list_empty(&pages_to_free)) { + pages_to_free.prev->next = NULL; + shmem_free_pages(pages_to_free.next); + } } static int shmem_notify_change(struct dentry *dentry, struct iattr *attr) @@ -658,9 +722,6 @@ static int shmem_unuse_inode(struct shmem_inode_info *info, swp_entry_t entry, s } if (!info->i_indirect) goto lost2; - /* we might be racing with shmem_truncate */ - if (limit <= SHMEM_NR_DIRECT) - goto lost2; dir = shmem_dir_map(info->i_indirect); stage = SHMEM_NR_DIRECT + ENTRIES_PER_PAGEPAGE/2; @@ -847,7 +908,7 @@ shmem_alloc_page(unsigned long gfp, struct shmem_inode_info *info, pvma.vm_policy = mpol_shared_policy_lookup(&info->policy, idx); pvma.vm_pgoff = idx; pvma.vm_end = PAGE_SIZE; - page = alloc_page_vma(gfp, &pvma, 0); + page = alloc_page_vma(gfp | __GFP_ZERO, &pvma, 0); mpol_free(pvma.vm_policy); return page; } @@ -863,7 +924,7 @@ static inline struct page * shmem_alloc_page(unsigned long gfp,struct shmem_inode_info *info, unsigned long idx) { - return alloc_page(gfp); + return alloc_page(gfp | __GFP_ZERO); } #endif @@ -1043,7 +1104,7 @@ repeat: idx); if (!filepage) { shmem_unacct_blocks(info->flags, 1); - shmem_free_block(inode); + shmem_free_blocks(inode, 1); error = -ENOMEM; goto failed; } @@ -1061,7 +1122,7 @@ repeat: spin_unlock(&info->lock); page_cache_release(filepage); shmem_unacct_blocks(info->flags, 1); - shmem_free_block(inode); + shmem_free_blocks(inode, 1); filepage = NULL; if (error) goto failed; @@ -1072,7 +1133,6 @@ repeat: info->alloced++; spin_unlock(&info->lock); - clear_highpage(filepage); flush_dcache_page(filepage); SetPageUptodate(filepage); } @@ -1101,6 +1161,8 @@ struct page *shmem_nopage(struct vm_area_struct *vma, unsigned long address, int idx = (address - vma->vm_start) >> PAGE_SHIFT; idx += vma->vm_pgoff; idx >>= PAGE_CACHE_SHIFT - PAGE_SHIFT; + if (((loff_t) idx << PAGE_CACHE_SHIFT) >= i_size_read(inode)) + return NOPAGE_SIGBUS; error = shmem_getpage(inode, idx, &page, SGP_CACHE, type); if (error) @@ -1229,16 +1291,17 @@ shmem_get_inode(struct super_block *sb, int mode, dev_t dev) info = SHMEM_I(inode); memset(info, 0, (char *)inode - (char *)info); spin_lock_init(&info->lock); - mpol_shared_policy_init(&info->policy); INIT_LIST_HEAD(&info->swaplist); switch (mode & S_IFMT) { default: + inode->i_op = &shmem_special_inode_operations; init_special_inode(inode, mode, dev); break; case S_IFREG: inode->i_op = &shmem_inode_operations; inode->i_fop = &shmem_file_operations; + mpol_shared_policy_init(&info->policy); break; case S_IFDIR: inode->i_nlink++; @@ -1248,8 +1311,17 @@ shmem_get_inode(struct super_block *sb, int mode, dev_t dev) inode->i_fop = &simple_dir_operations; break; case S_IFLNK: + /* + * Must not load anything in the rbtree, + * mpol_free_shared_policy will not be called. + */ + mpol_shared_policy_init(&info->policy); break; } + } else if (sbinfo) { + spin_lock(&sbinfo->stat_lock); + sbinfo->free_inodes++; + spin_unlock(&sbinfo->stat_lock); } return inode; } @@ -1755,6 +1827,12 @@ static void shmem_put_link(struct dentry *dentry, struct nameidata *nd) static struct inode_operations shmem_symlink_inline_operations = { .readlink = generic_readlink, .follow_link = shmem_follow_link_inline, +#ifdef CONFIG_TMPFS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = generic_listxattr, + .removexattr = generic_removexattr, +#endif }; static struct inode_operations shmem_symlink_inode_operations = { @@ -1762,6 +1840,12 @@ static struct inode_operations shmem_symlink_inode_operations = { .readlink = generic_readlink, .follow_link = shmem_follow_link, .put_link = shmem_put_link, +#ifdef CONFIG_TMPFS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = generic_listxattr, + .removexattr = generic_removexattr, +#endif }; static int shmem_parse_options(char *options, int *mode, uid_t *uid, gid_t *gid, unsigned long *blocks, unsigned long *inodes) @@ -1861,6 +1945,12 @@ static void shmem_put_super(struct super_block *sb) sb->s_fs_info = NULL; } +#ifdef CONFIG_TMPFS_XATTR +static struct xattr_handler *shmem_xattr_handlers[]; +#else +#define shmem_xattr_handlers NULL +#endif + static int shmem_fill_super(struct super_block *sb, void *data, int silent) { @@ -1903,6 +1993,9 @@ static int shmem_fill_super(struct super_block *sb, sbinfo->max_inodes = inodes; sbinfo->free_inodes = inodes; } + sb->s_xattr = shmem_xattr_handlers; +#else + sb->s_flags |= MS_NOUSER; #endif sb->s_maxbytes = SHMEM_MAX_BYTES; @@ -1941,7 +2034,10 @@ static struct inode *shmem_alloc_inode(struct super_block *sb) static void shmem_destroy_inode(struct inode *inode) { - mpol_free_shared_policy(&SHMEM_I(inode)->policy); + if ((inode->i_mode & S_IFMT) == S_IFREG) { + /* only struct inode is valid if it's an inline symlink */ + mpol_free_shared_policy(&SHMEM_I(inode)->policy); + } kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode)); } @@ -1994,6 +2090,12 @@ static struct file_operations shmem_file_operations = { static struct inode_operations shmem_inode_operations = { .truncate = shmem_truncate, .setattr = shmem_notify_change, +#ifdef CONFIG_TMPFS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = generic_listxattr, + .removexattr = generic_removexattr, +#endif }; static struct inode_operations shmem_dir_inode_operations = { @@ -2007,6 +2109,21 @@ static struct inode_operations shmem_dir_inode_operations = { .rmdir = shmem_rmdir, .mknod = shmem_mknod, .rename = shmem_rename, +#ifdef CONFIG_TMPFS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = generic_listxattr, + .removexattr = generic_removexattr, +#endif +#endif +}; + +static struct inode_operations shmem_special_inode_operations = { +#ifdef CONFIG_TMPFS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = generic_listxattr, + .removexattr = generic_removexattr, #endif }; @@ -2031,6 +2148,49 @@ static struct vm_operations_struct shmem_vm_ops = { #endif }; + +#ifdef CONFIG_TMPFS_SECURITY + +static size_t shmem_xattr_security_list(struct inode *inode, char *list, size_t list_len, + const char *name, size_t name_len) +{ + return security_inode_listsecurity(inode, list, list_len); +} + +static int shmem_xattr_security_get(struct inode *inode, const char *name, void *buffer, size_t size) +{ + if (strcmp(name, "") == 0) + return -EINVAL; + return security_inode_getsecurity(inode, name, buffer, size); +} + +static int shmem_xattr_security_set(struct inode *inode, const char *name, const void *value, size_t size, int flags) +{ + if (strcmp(name, "") == 0) + return -EINVAL; + return security_inode_setsecurity(inode, name, value, size, flags); +} + +struct xattr_handler shmem_xattr_security_handler = { + .prefix = XATTR_SECURITY_PREFIX, + .list = shmem_xattr_security_list, + .get = shmem_xattr_security_get, + .set = shmem_xattr_security_set, +}; + +#endif /* CONFIG_TMPFS_SECURITY */ + +#ifdef CONFIG_TMPFS_XATTR + +static struct xattr_handler *shmem_xattr_handlers[] = { +#ifdef CONFIG_TMPFS_SECURITY + &shmem_xattr_security_handler, +#endif + NULL +}; + +#endif /* CONFIG_TMPFS_XATTR */ + static struct super_block *shmem_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data) { @@ -2163,5 +2323,3 @@ int shmem_zero_setup(struct vm_area_struct *vma) vma->vm_ops = &shmem_vm_ops; return 0; } - -EXPORT_SYMBOL(shmem_file_setup);