android/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ANDROID: GKI: set vfs-only exports into their own namespace

Browse Source 
We have namespaces, so use them for all vfs-exported namespaces so that
filesystems can use them, but not anything else.

Some in-kernel drivers that do direct filesystem accesses (because they
serve up files) are also allowed access to these symbols to keep 'make
allmodconfig' builds working properly, but it is not needed for Android
kernel images.

Bug: 157965270
Bug: 210074446
Cc: Matthias Maennich <maennich@google.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: Iaf6140baf3a18a516ab2d5c3966235c42f3f70de
This commit is contained in:
Greg Kroah-Hartman 2020-07-02 12:51:03 +02:00
parent 27fc5a7c69
commit d483eed85f
96 changed files with 156 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
drivers/mtd/nand/raw/nandsim.c
View File

@ -2453,5 +2453,6 @@ static void __exit ns_cleanup_module(void)
module_exit(ns_cleanup_module);
MODULE_LICENSE ("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_AUTHOR ("Artem B. Bityuckiy");
MODULE_DESCRIPTION ("The NAND flash simulator");

1
drivers/mtd/ubi/build.c
View File

@ -1476,3 +1476,4 @@ MODULE_VERSION(__stringify(UBI_VERSION));
MODULE_DESCRIPTION("UBI - Unsorted Block Images");
MODULE_AUTHOR("Artem Bityutskiy");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);

1
drivers/nvme/target/core.c
View File

@ -1602,3 +1602,4 @@ module_init(nvmet_init);
module_exit(nvmet_exit);
MODULE_LICENSE("GPL v2");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);

1
drivers/target/target_core_configfs.c
View File

@ -3644,6 +3644,7 @@ static void __exit target_core_exit_configfs(void)
MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS");
MODULE_AUTHOR("nab@Linux-iSCSI.org");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
module_init(target_core_init_configfs);
module_exit(target_core_exit_configfs);

1
drivers/target/target_core_file.c
View File

@ -956,6 +956,7 @@ static void __exit fileio_module_exit(void)
MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
MODULE_AUTHOR("nab@Linux-iSCSI.org");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
module_init(fileio_module_init);
module_exit(fileio_module_exit);

1
drivers/usb/gadget/function/f_mass_storage.c
View File

@ -3446,6 +3446,7 @@ static struct usb_function *fsg_alloc(struct usb_function_instance *fi)
DECLARE_USB_FUNCTION_INIT(mass_storage, fsg_alloc_inst, fsg_alloc);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_AUTHOR("Michal Nazarewicz");
/************************* Module parameters *************************/

1
drivers/usb/gadget/function/f_uac1_legacy.c
View File

@ -1015,4 +1015,5 @@ static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
DECLARE_USB_FUNCTION_INIT(uac1_legacy, f_audio_alloc_inst, f_audio_alloc);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_AUTHOR("Bryan Wu");

1
drivers/usb/gadget/function/storage_common.c
View File

@ -520,3 +520,4 @@ ssize_t fsg_store_inquiry_string(struct fsg_lun *curlun, const char *buf,
EXPORT_SYMBOL_GPL(fsg_store_inquiry_string);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);

1
fs/9p/v9fs.c
View File

@ -738,3 +738,4 @@ MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

2
fs/Makefile
View File

@ -6,6 +6,8 @@
# Rewritten to use lists instead of if-statements.
#
subdir-ccflags-y += -DANDROID_GKI_VFS_EXPORT_ONLY=VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver
obj-y := open.o read_write.o file_table.o super.o \
char_dev.o stat.o exec.o pipe.o namei.o fcntl.o \
ioctl.o readdir.o select.o dcache.o inode.o \

1
fs/adfs/super.c
View File

@ -492,3 +492,4 @@ static void __exit exit_adfs_fs(void)
module_init(init_adfs_fs)
module_exit(exit_adfs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/affs/super.c
View File

@ -676,6 +676,7 @@ static void __exit exit_affs_fs(void)
MODULE_DESCRIPTION("Amiga filesystem support for Linux");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_affs_fs)
module_exit(exit_affs_fs)

1
fs/afs/main.c
View File

@ -18,6 +18,7 @@
MODULE_DESCRIPTION("AFS Client File System");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
unsigned afs_debug;
module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO);

6
fs/attr.c
View File

@ -114,7 +114,7 @@ int setattr_prepare(struct dentry *dentry, struct iattr *attr)
return 0;
}
EXPORT_SYMBOL(setattr_prepare);
EXPORT_SYMBOL_NS(setattr_prepare, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* inode_newsize_ok - may this inode be truncated to a given size
@ -158,7 +158,7 @@ int inode_newsize_ok(const struct inode *inode, loff_t offset)
out_big:
return -EFBIG;
}
EXPORT_SYMBOL(inode_newsize_ok);
EXPORT_SYMBOL_NS(inode_newsize_ok, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* setattr_copy - copy simple metadata updates into the generic inode
@ -345,4 +345,4 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **de
return error;
}
EXPORT_SYMBOL(notify_change);
EXPORT_SYMBOL_NS(notify_change, ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/autofs/init.c
View File

@ -44,3 +44,4 @@ static void __exit exit_autofs_fs(void)
module_init(init_autofs_fs)
module_exit(exit_autofs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

4
fs/bad_inode.c
View File

@ -207,7 +207,7 @@ void make_bad_inode(struct inode *inode)
inode->i_opflags &= ~IOP_XATTR;
inode->i_fop = &bad_file_ops;
}
EXPORT_SYMBOL(make_bad_inode);
EXPORT_SYMBOL_NS(make_bad_inode, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* This tests whether an inode has been flagged as bad. The test uses
@ -227,7 +227,7 @@ bool is_bad_inode(struct inode *inode)
return (inode->i_op == &bad_inode_ops);
}
EXPORT_SYMBOL(is_bad_inode);
EXPORT_SYMBOL_NS(is_bad_inode, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* iget_failed - Mark an under-construction inode as dead and release it

1
fs/befs/linuxvfs.c
View File

@ -34,6 +34,7 @@
MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
MODULE_AUTHOR("Will Dyson");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
/* The units the vfs expects inode->i_blocks to be in */
#define VFS_BLOCK_SIZE 512

1
fs/bfs/inode.c
View File

@ -22,6 +22,7 @@
MODULE_AUTHOR("Tigran Aivazian <aivazian.tigran@gmail.com>");
MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
#undef DEBUG

1
fs/binfmt_misc.c
View File

@ -832,3 +832,4 @@ static void __exit exit_misc_binfmt(void)
core_initcall(init_misc_binfmt);
module_exit(exit_misc_binfmt);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

4
fs/block_dev.c
View File

@ -186,7 +186,7 @@ int sb_set_blocksize(struct super_block *sb, int size)
return sb->s_blocksize;
}
EXPORT_SYMBOL(sb_set_blocksize);
EXPORT_SYMBOL_NS(sb_set_blocksize, ANDROID_GKI_VFS_EXPORT_ONLY);
int sb_min_blocksize(struct super_block *sb, int size)
{
@ -196,7 +196,7 @@ int sb_min_blocksize(struct super_block *sb, int size)
return sb_set_blocksize(sb, size);
}
EXPORT_SYMBOL(sb_min_blocksize);
EXPORT_SYMBOL_NS(sb_min_blocksize, ANDROID_GKI_VFS_EXPORT_ONLY);
static int
blkdev_get_block(struct inode *inode, sector_t iblock,

1
fs/btrfs/super.c
View File

@ -2597,6 +2597,7 @@ late_initcall(init_btrfs_fs);
module_exit(exit_btrfs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_SOFTDEP("pre: crc32c");
MODULE_SOFTDEP("pre: xxhash64");
MODULE_SOFTDEP("pre: sha256");

34
fs/buffer.c
View File

@ -173,7 +173,7 @@ void end_buffer_write_sync(struct buffer_head *bh, int uptodate)
unlock_buffer(bh);
put_bh(bh);
}
EXPORT_SYMBOL(end_buffer_write_sync);
EXPORT_SYMBOL_NS(end_buffer_write_sync, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Various filesystems appear to want __find_get_block to be non-blocking.
@ -419,7 +419,7 @@ void mark_buffer_async_write(struct buffer_head *bh)
{
mark_buffer_async_write_endio(bh, end_buffer_async_write);
}
EXPORT_SYMBOL(mark_buffer_async_write);
EXPORT_SYMBOL_NS(mark_buffer_async_write, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
@ -674,7 +674,7 @@ int __set_page_dirty_buffers(struct page *page)
return newly_dirty;
}
EXPORT_SYMBOL(__set_page_dirty_buffers);
EXPORT_SYMBOL_NS(__set_page_dirty_buffers, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Write out and wait upon a list of buffers.
@ -1141,7 +1141,7 @@ void mark_buffer_dirty(struct buffer_head *bh)
__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
}
}
EXPORT_SYMBOL(mark_buffer_dirty);
EXPORT_SYMBOL_NS(mark_buffer_dirty, ANDROID_GKI_VFS_EXPORT_ONLY);
void mark_buffer_write_io_error(struct buffer_head *bh)
{
@ -1159,7 +1159,7 @@ void mark_buffer_write_io_error(struct buffer_head *bh)
errseq_set(&sb->s_wb_err, -EIO);
rcu_read_unlock();
}
EXPORT_SYMBOL(mark_buffer_write_io_error);
EXPORT_SYMBOL_NS(mark_buffer_write_io_error, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Decrement a buffer_head's reference count. If all buffers against a page
@ -1176,7 +1176,7 @@ void __brelse(struct buffer_head * buf)
}
WARN(1, KERN_ERR "VFS: brelse: Trying to free free buffer\n");
}
EXPORT_SYMBOL(__brelse);
EXPORT_SYMBOL_NS(__brelse, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* bforget() is like brelse(), except it discards any
@ -1195,7 +1195,7 @@ void __bforget(struct buffer_head *bh)
}
__brelse(bh);
}
EXPORT_SYMBOL(__bforget);
EXPORT_SYMBOL_NS(__bforget, ANDROID_GKI_VFS_EXPORT_ONLY);
static struct buffer_head *__bread_slow(struct buffer_head *bh)
{
@ -1376,7 +1376,7 @@ void __breadahead(struct block_device *bdev, sector_t block, unsigned size)
brelse(bh);
}
}
EXPORT_SYMBOL(__breadahead);
EXPORT_SYMBOL_NS(__breadahead, ANDROID_GKI_VFS_EXPORT_ONLY);
void __breadahead_gfp(struct block_device *bdev, sector_t block, unsigned size,
gfp_t gfp)
@ -1411,7 +1411,7 @@ __bread_gfp(struct block_device *bdev, sector_t block,
bh = __bread_slow(bh);
return bh;
}
EXPORT_SYMBOL(__bread_gfp);
EXPORT_SYMBOL_NS(__bread_gfp, ANDROID_GKI_VFS_EXPORT_ONLY);
static void __invalidate_bh_lrus(struct bh_lru *b)
{
@ -1573,7 +1573,7 @@ void block_invalidatepage(struct page *page, unsigned int offset,
out:
return;
}
EXPORT_SYMBOL(block_invalidatepage);
EXPORT_SYMBOL_NS(block_invalidatepage, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
@ -1609,7 +1609,7 @@ void create_empty_buffers(struct page *page,
attach_page_private(page, head);
spin_unlock(&page->mapping->private_lock);
}
EXPORT_SYMBOL(create_empty_buffers);
EXPORT_SYMBOL_NS(create_empty_buffers, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* clean_bdev_aliases: clean a range of buffers in block device
@ -1683,7 +1683,7 @@ void clean_bdev_aliases(struct block_device *bdev, sector_t block, sector_t len)
break;
}
}
EXPORT_SYMBOL(clean_bdev_aliases);
EXPORT_SYMBOL_NS(clean_bdev_aliases, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Size is a power-of-two in the range 512..PAGE_SIZE,
@ -1941,7 +1941,7 @@ void page_zero_new_buffers(struct page *page, unsigned from, unsigned to)
bh = bh->b_this_page;
} while (bh != head);
}
EXPORT_SYMBOL(page_zero_new_buffers);
EXPORT_SYMBOL_NS(page_zero_new_buffers, ANDROID_GKI_VFS_EXPORT_ONLY);
static void
iomap_to_bh(struct inode *inode, sector_t block, struct buffer_head *bh,
@ -2275,7 +2275,7 @@ int block_is_partially_uptodate(struct page *page, unsigned long from,
return ret;
}
EXPORT_SYMBOL(block_is_partially_uptodate);
EXPORT_SYMBOL_NS(block_is_partially_uptodate, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Generic "read page" function for block devices that have the normal
@ -3142,7 +3142,7 @@ void ll_rw_block(int op, int op_flags, int nr, struct buffer_head *bhs[])
unlock_buffer(bh);
}
}
EXPORT_SYMBOL(ll_rw_block);
EXPORT_SYMBOL_NS(ll_rw_block, ANDROID_GKI_VFS_EXPORT_ONLY);
void write_dirty_buffer(struct buffer_head *bh, int op_flags)
{
@ -3189,13 +3189,13 @@ int __sync_dirty_buffer(struct buffer_head *bh, int op_flags)
}
return ret;
}
EXPORT_SYMBOL(__sync_dirty_buffer);
EXPORT_SYMBOL_NS(__sync_dirty_buffer, ANDROID_GKI_VFS_EXPORT_ONLY);
int sync_dirty_buffer(struct buffer_head *bh)
{
return __sync_dirty_buffer(bh, REQ_SYNC);
}
EXPORT_SYMBOL(sync_dirty_buffer);
EXPORT_SYMBOL_NS(sync_dirty_buffer, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* try_to_free_buffers() checks if all the buffers on this particular page

1
fs/cachefiles/main.c
View File

@ -28,6 +28,7 @@ MODULE_PARM_DESC(cachefiles_debug, "CacheFiles debugging mask");
MODULE_DESCRIPTION("Mounted-filesystem based cache");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
struct kmem_cache *cachefiles_object_jar;

1
fs/ceph/super.c
View File

@ -1323,3 +1323,4 @@ MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
MODULE_AUTHOR("Patience Warnick <patience@newdream.net>");
MODULE_DESCRIPTION("Ceph filesystem for Linux");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/cifs/cifsfs.c
View File

@ -1692,6 +1692,7 @@ exit_cifs(void)
MODULE_AUTHOR("Steve French");
MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_DESCRIPTION
("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
"also older servers complying with the SNIA CIFS Specification)");

1
fs/coda/psdev.c
View File

@ -388,6 +388,7 @@ MODULE_AUTHOR("Jan Harkes, Peter J. Braam");
MODULE_DESCRIPTION("Coda Distributed File System VFS interface");
MODULE_ALIAS_CHARDEV_MAJOR(CODA_PSDEV_MAJOR);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_VERSION("7.0");
static int __init init_coda(void)

1
fs/cramfs/inode.c
View File

@ -1010,3 +1010,4 @@ static void __exit exit_cramfs_fs(void)
module_init(init_cramfs_fs)
module_exit(exit_cramfs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

6
fs/dcache.c
View File

@ -2110,7 +2110,7 @@ struct dentry *d_obtain_alias(struct inode *inode)
{
return __d_obtain_alias(inode, true);
}
EXPORT_SYMBOL(d_obtain_alias);
EXPORT_SYMBOL_NS(d_obtain_alias, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* d_obtain_root - find or allocate a dentry for a given inode
@ -2184,7 +2184,7 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
}
return found;
}
EXPORT_SYMBOL(d_add_ci);
EXPORT_SYMBOL_NS(d_add_ci, ANDROID_GKI_VFS_EXPORT_ONLY);
static inline bool d_same_name(const struct dentry *dentry,
@ -3065,7 +3065,7 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
__d_add(dentry, inode);
return NULL;
}
EXPORT_SYMBOL(d_splice_alias);
EXPORT_SYMBOL_NS(d_splice_alias, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Test whether new_dentry is a subdirectory of old_dentry.

2
fs/direct-io.c
View File

@ -1380,7 +1380,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
end_io, submit_io, flags);
}
EXPORT_SYMBOL(__blockdev_direct_IO);
EXPORT_SYMBOL_NS(__blockdev_direct_IO, ANDROID_GKI_VFS_EXPORT_ONLY);
static __init int dio_init(void)
{

1
fs/ecryptfs/main.c
View File

@ -891,6 +891,7 @@ MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@us.ibm.com>");
MODULE_DESCRIPTION("eCryptfs");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(ecryptfs_init)
module_exit(ecryptfs_exit)

1
fs/efivarfs/super.c
View File

@ -272,6 +272,7 @@ static __exit void efivarfs_exit(void)
MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr");
MODULE_DESCRIPTION("EFI Variable Filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_ALIAS_FS("efivarfs");
module_init(efivarfs_init);

1
fs/efs/inode.c
View File

@ -311,3 +311,4 @@ efs_block_t efs_map_block(struct inode *inode, efs_block_t block) {
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/erofs/super.c
View File

@ -752,4 +752,5 @@ module_exit(erofs_module_exit);
MODULE_DESCRIPTION("Enhanced ROM File System");
MODULE_AUTHOR("Gao Xiang, Chao Yu, Miao Xie, CONSUMER BG, HUAWEI Inc.");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/exfat/super.c
View File

@ -836,5 +836,6 @@ module_exit(exit_exfat_fs);
MODULE_ALIAS_FS("exfat");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_DESCRIPTION("exFAT filesystem support");
MODULE_AUTHOR("Samsung Electronics Co., Ltd.");

1
fs/ext2/super.c
View File

@ -1650,5 +1650,6 @@ static void __exit exit_ext2_fs(void)
MODULE_AUTHOR("Remy Card and others");
MODULE_DESCRIPTION("Second Extended Filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_ext2_fs)
module_exit(exit_ext2_fs)

1
fs/ext4/super.c
View File

@ -6735,6 +6735,7 @@ static void __exit ext4_exit_fs(void)
MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
MODULE_DESCRIPTION("Fourth Extended Filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_SOFTDEP("pre: crc32c");
module_init(ext4_init_fs)
module_exit(ext4_exit_fs)

1
fs/f2fs/super.c
View File

@ -4415,5 +4415,6 @@ module_exit(exit_f2fs_fs)
MODULE_AUTHOR("Samsung Electronics's Praesto Team");
MODULE_DESCRIPTION("Flash Friendly File System");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_SOFTDEP("pre: crc32");

1
fs/fat/inode.c
View File

@ -1979,3 +1979,4 @@ module_init(init_fat_fs)
module_exit(exit_fat_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/fat/namei_msdos.c
View File

@ -680,6 +680,7 @@ static void __exit exit_msdos_fs(void)
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_AUTHOR("Werner Almesberger");
MODULE_DESCRIPTION("MS-DOS filesystem support");

1
fs/fat/namei_vfat.c
View File

@ -1077,6 +1077,7 @@ static void __exit exit_vfat_fs(void)
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_DESCRIPTION("VFAT filesystem support");
MODULE_AUTHOR("Gordon Chaffee");

1
fs/freevxfs/vxfs_super.c
View File

@ -52,6 +52,7 @@
MODULE_AUTHOR("Christoph Hellwig, Krzysztof Blaszkowski");
MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static struct kmem_cache *vxfs_inode_cachep;

8
fs/fs-writeback.c
View File

@ -2338,7 +2338,7 @@ void __mark_inode_dirty(struct inode *inode, int flags)
out_unlock_inode:
spin_unlock(&inode->i_lock);
}
EXPORT_SYMBOL(__mark_inode_dirty);
EXPORT_SYMBOL_NS(__mark_inode_dirty, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* The @s_sync_lock is used to serialise concurrent sync operations
@ -2504,7 +2504,7 @@ void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)
__writeback_inodes_sb_nr(sb, get_nr_dirty_pages(), reason, true);
up_read(&sb->s_umount);
}
EXPORT_SYMBOL(try_to_writeback_inodes_sb);
EXPORT_SYMBOL_NS(try_to_writeback_inodes_sb, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* sync_inodes_sb - sync sb inode pages
@ -2571,7 +2571,7 @@ int write_inode_now(struct inode *inode, int sync)
might_sleep();
return writeback_single_inode(inode, &wbc);
}
EXPORT_SYMBOL(write_inode_now);
EXPORT_SYMBOL_NS(write_inode_now, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* sync_inode - write an inode and its pages to disk.
@ -2608,4 +2608,4 @@ int sync_inode_metadata(struct inode *inode, int wait)
return sync_inode(inode, &wbc);
}
EXPORT_SYMBOL(sync_inode_metadata);
EXPORT_SYMBOL_NS(sync_inode_metadata, ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/fuse/inode.c
View File

@ -27,6 +27,7 @@
MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
MODULE_DESCRIPTION("Filesystem in Userspace");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static struct kmem_cache *fuse_inode_cachep;
struct list_head fuse_conn_list;

1
fs/gfs2/main.c
View File

@ -260,6 +260,7 @@ static void __exit exit_gfs2_fs(void)
MODULE_DESCRIPTION("Global File System");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_gfs2_fs);
module_exit(exit_gfs2_fs);

1
fs/hfs/super.c
View File

@ -29,6 +29,7 @@
static struct kmem_cache *hfs_inode_cachep;
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static int hfs_sync_fs(struct super_block *sb, int wait)
{

1
fs/hfsplus/super.c
View File

@ -617,6 +617,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
MODULE_AUTHOR("Brad Boyer");
MODULE_DESCRIPTION("Extended Macintosh Filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static struct kmem_cache *hfsplus_inode_cachep;

1
fs/hpfs/super.c
View File

@ -791,3 +791,4 @@ static void __exit exit_hpfs_fs(void)
module_init(init_hpfs_fs)
module_exit(exit_hpfs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/incfs/main.c
View File

@ -44,5 +44,6 @@ module_init(init_incfs_module);
module_exit(cleanup_incfs_module);
MODULE_LICENSE("GPL v2");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_AUTHOR("Eugene Zemtsov <ezemtsov@google.com>");
MODULE_DESCRIPTION("Incremental File System");

36
fs/inode.c
View File

@ -307,7 +307,7 @@ void drop_nlink(struct inode *inode)
if (!inode->i_nlink)
atomic_long_inc(&inode->i_sb->s_remove_count);
}
EXPORT_SYMBOL(drop_nlink);
EXPORT_SYMBOL_NS(drop_nlink, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* clear_nlink - directly zero an inode's link count
@ -346,7 +346,7 @@ void set_nlink(struct inode *inode, unsigned int nlink)
inode->__i_nlink = nlink;
}
}
EXPORT_SYMBOL(set_nlink);
EXPORT_SYMBOL_NS(set_nlink, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* inc_nlink - directly increment an inode's link count
@ -399,7 +399,7 @@ void inode_init_once(struct inode *inode)
__address_space_init_once(&inode->i_data);
i_size_ordered_init(inode);
}
EXPORT_SYMBOL(inode_init_once);
EXPORT_SYMBOL_NS(inode_init_once, ANDROID_GKI_VFS_EXPORT_ONLY);
static void init_once(void *foo)
{
@ -423,7 +423,7 @@ void ihold(struct inode *inode)
{
WARN_ON(atomic_inc_return(&inode->i_count) < 2);
}
EXPORT_SYMBOL(ihold);
EXPORT_SYMBOL_NS(ihold, ANDROID_GKI_VFS_EXPORT_ONLY);
static void inode_lru_list_add(struct inode *inode)
{
@ -503,7 +503,7 @@ void __insert_inode_hash(struct inode *inode, unsigned long hashval)
spin_unlock(&inode->i_lock);
spin_unlock(&inode_hash_lock);
}
EXPORT_SYMBOL(__insert_inode_hash);
EXPORT_SYMBOL_NS(__insert_inode_hash, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* __remove_inode_hash - remove an inode from the hash
@ -519,7 +519,7 @@ void __remove_inode_hash(struct inode *inode)
spin_unlock(&inode->i_lock);
spin_unlock(&inode_hash_lock);
}
EXPORT_SYMBOL(__remove_inode_hash);
EXPORT_SYMBOL_NS(__remove_inode_hash, ANDROID_GKI_VFS_EXPORT_ONLY);
void clear_inode(struct inode *inode)
{
@ -539,7 +539,7 @@ void clear_inode(struct inode *inode)
/* don't need i_lock here, no concurrent mods to i_state */
inode->i_state = I_FREEING | I_CLEAR;
}
EXPORT_SYMBOL(clear_inode);
EXPORT_SYMBOL_NS(clear_inode, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Free the inode passed in, removing it from the lists it is still connected
@ -1001,7 +1001,7 @@ void unlock_new_inode(struct inode *inode)
wake_up_bit(&inode->i_state, __I_NEW);
spin_unlock(&inode->i_lock);
}
EXPORT_SYMBOL(unlock_new_inode);
EXPORT_SYMBOL_NS(unlock_new_inode, ANDROID_GKI_VFS_EXPORT_ONLY);
void discard_new_inode(struct inode *inode)
{
@ -1158,7 +1158,7 @@ struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
}
return inode;
}
EXPORT_SYMBOL(iget5_locked);
EXPORT_SYMBOL_NS(iget5_locked, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* iget_locked - obtain an inode from a mounted file system
@ -1290,7 +1290,7 @@ ino_t iunique(struct super_block *sb, ino_t max_reserved)
return res;
}
EXPORT_SYMBOL(iunique);
EXPORT_SYMBOL_NS(iunique, ANDROID_GKI_VFS_EXPORT_ONLY);
struct inode *igrab(struct inode *inode)
{
@ -1373,7 +1373,7 @@ struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
}
return inode;
}
EXPORT_SYMBOL(ilookup5);
EXPORT_SYMBOL_NS(ilookup5, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* ilookup - search for an inode in the inode cache
@ -1852,7 +1852,7 @@ void touch_atime(const struct path *path)
skip_update:
sb_end_write(inode->i_sb);
}
EXPORT_SYMBOL(touch_atime);
EXPORT_SYMBOL_NS(touch_atime, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* The logic we want is
@ -1948,7 +1948,7 @@ int file_remove_privs(struct file *file)
return error;
}
EXPORT_SYMBOL(file_remove_privs);
EXPORT_SYMBOL_NS(file_remove_privs, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* file_update_time - update mtime and ctime time
@ -2129,7 +2129,7 @@ void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
" inode %s:%lu\n", mode, inode->i_sb->s_id,
inode->i_ino);
}
EXPORT_SYMBOL(init_special_inode);
EXPORT_SYMBOL_NS(init_special_inode, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* inode_init_owner - Init uid,gid,mode for new inode according to posix standards
@ -2155,7 +2155,7 @@ void inode_init_owner(struct inode *inode, const struct inode *dir,
inode->i_gid = current_fsgid();
inode->i_mode = mode;
}
EXPORT_SYMBOL(inode_init_owner);
EXPORT_SYMBOL_NS(inode_init_owner, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* inode_owner_or_capable - check current task permissions to inode
@ -2209,7 +2209,7 @@ void inode_dio_wait(struct inode *inode)
if (atomic_read(&inode->i_dio_count))
__inode_dio_wait(inode);
}
EXPORT_SYMBOL(inode_dio_wait);
EXPORT_SYMBOL_NS(inode_dio_wait, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* inode_set_flags - atomically set some inode flags
@ -2233,7 +2233,7 @@ void inode_set_flags(struct inode *inode, unsigned int flags,
WARN_ON_ONCE(flags & ~mask);
set_mask_bits(&inode->i_flags, mask, flags);
}
EXPORT_SYMBOL(inode_set_flags);
EXPORT_SYMBOL_NS(inode_set_flags, ANDROID_GKI_VFS_EXPORT_ONLY);
void inode_nohighmem(struct inode *inode)
{
@ -2270,7 +2270,7 @@ struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode)
WARN(1, "invalid file time granularity: %u", gran);
return t;
}
EXPORT_SYMBOL(timestamp_truncate);
EXPORT_SYMBOL_NS(timestamp_truncate, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* current_time - Return FS time

4
fs/ioctl.c
View File

@ -146,7 +146,7 @@ int fiemap_fill_next_extent(struct fiemap_extent_info *fieinfo, u64 logical,
return 1;
return (flags & FIEMAP_EXTENT_LAST) ? 1 : 0;
}
EXPORT_SYMBOL(fiemap_fill_next_extent);
EXPORT_SYMBOL_NS(fiemap_fill_next_extent, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* fiemap_prep - check validity of requested flags for fiemap
@ -191,7 +191,7 @@ int fiemap_prep(struct inode *inode, struct fiemap_extent_info *fieinfo,
ret = filemap_write_and_wait(inode->i_mapping);
return ret;
}
EXPORT_SYMBOL(fiemap_prep);
EXPORT_SYMBOL_NS(fiemap_prep, ANDROID_GKI_VFS_EXPORT_ONLY);
static int ioctl_fiemap(struct file *filp, struct fiemap __user *ufiemap)
{

1
fs/isofs/inode.c
View File

@ -1610,3 +1610,4 @@ static void __exit exit_iso9660_fs(void)
module_init(init_iso9660_fs)
module_exit(exit_iso9660_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/jbd2/journal.c
View File

@ -3012,6 +3012,7 @@ static void __exit journal_exit(void)
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(journal_init);
module_exit(journal_exit);

1
fs/jffs2/super.c
View File

@ -439,3 +439,4 @@ MODULE_DESCRIPTION("The Journalling Flash File System, v2");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
// the sake of this tag. It's Free Software.
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/jfs/super.c
View File

@ -37,6 +37,7 @@
MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static struct kmem_cache *jfs_inode_cachep;

2
fs/libfs.c
View File

@ -225,7 +225,7 @@ ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t
{
return -EISDIR;
}
EXPORT_SYMBOL(generic_read_dir);
EXPORT_SYMBOL_NS(generic_read_dir, ANDROID_GKI_VFS_EXPORT_ONLY);
const struct file_operations simple_dir_operations = {
.open = dcache_dir_open,

1
fs/minix/inode.c
View File

@ -719,4 +719,5 @@ static void __exit exit_minix_fs(void)
module_init(init_minix_fs)
module_exit(exit_minix_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

4
fs/mpage.c
View File

@ -430,7 +430,7 @@ void mpage_readahead(struct readahead_control *rac, get_block_t get_block)
if (args.bio)
mpage_bio_submit(REQ_OP_READ, REQ_RAHEAD, args.bio);
}
EXPORT_SYMBOL(mpage_readahead);
EXPORT_SYMBOL_NS(mpage_readahead, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* This isn't called much at all
@ -448,7 +448,7 @@ int mpage_readpage(struct page *page, get_block_t get_block)
mpage_bio_submit(REQ_OP_READ, 0, args.bio);
return 0;
}
EXPORT_SYMBOL(mpage_readpage);
EXPORT_SYMBOL_NS(mpage_readpage, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Writing is not so simple.

14
fs/namei.c
View File

@ -2533,7 +2533,7 @@ int kern_path(const char *name, unsigned int flags, struct path *path)
return filename_lookup(AT_FDCWD, getname_kernel(name),
flags, path, NULL);
}
EXPORT_SYMBOL(kern_path);
EXPORT_SYMBOL_NS(kern_path, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
@ -2887,7 +2887,7 @@ int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
fsnotify_create(dir, dentry);
return error;
}
EXPORT_SYMBOL(vfs_create);
EXPORT_SYMBOL_NS(vfs_create, ANDROID_GKI_VFS_EXPORT_ONLY);
int vfs_mkobj(struct dentry *dentry, umode_t mode,
int (*f)(struct dentry *, umode_t, void *),
@ -3727,7 +3727,7 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
fsnotify_mkdir(dir, dentry);
return error;
}
EXPORT_SYMBOL(vfs_mkdir);
EXPORT_SYMBOL_NS(vfs_mkdir, ANDROID_GKI_VFS_EXPORT_ONLY);
static long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
{
@ -3802,7 +3802,7 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
d_delete(dentry);
return error;
}
EXPORT_SYMBOL(vfs_rmdir);
EXPORT_SYMBOL_NS(vfs_rmdir, ANDROID_GKI_VFS_EXPORT_ONLY);
long do_rmdir(int dfd, struct filename *name)
{
@ -3924,7 +3924,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegate
return error;
}
EXPORT_SYMBOL(vfs_unlink);
EXPORT_SYMBOL_NS(vfs_unlink, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Make sure that the actual truncation of the file will occur outside its
@ -4159,7 +4159,7 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
fsnotify_link(dir, inode, new_dentry);
return error;
}
EXPORT_SYMBOL(vfs_link);
EXPORT_SYMBOL_NS(vfs_link, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* Hardlinks are often used in delicate situations. We avoid
@ -4419,7 +4419,7 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
return error;
}
EXPORT_SYMBOL(vfs_rename);
EXPORT_SYMBOL_NS(vfs_rename, ANDROID_GKI_VFS_EXPORT_ONLY);
static int do_renameat2(int olddfd, const char __user *oldname, int newdfd,
const char __user *newname, unsigned int flags)

4
fs/namespace.c
View File

@ -415,7 +415,7 @@ int mnt_want_write_file(struct file *file)
sb_end_write(file_inode(file)->i_sb);
return ret;
}
EXPORT_SYMBOL_GPL(mnt_want_write_file);
EXPORT_SYMBOL_NS_GPL(mnt_want_write_file, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* __mnt_drop_write - give up write access to a mount
@ -457,7 +457,7 @@ void mnt_drop_write_file(struct file *file)
__mnt_drop_write_file(file);
sb_end_write(file_inode(file)->i_sb);
}
EXPORT_SYMBOL(mnt_drop_write_file);
EXPORT_SYMBOL_NS(mnt_drop_write_file, ANDROID_GKI_VFS_EXPORT_ONLY);
static int mnt_make_readonly(struct mount *mnt)
{

1
fs/nfs/inode.c
View File

@ -2326,6 +2326,7 @@ static void __exit exit_nfs_fs(void)
/* Not quite true; I just maintain it */
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_param(enable_ino64, bool, 0644);
module_init(init_nfs_fs)

1
fs/nfs/nfs4super.c
View File

@ -309,6 +309,7 @@ static void __exit exit_nfs_v4(void)
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_nfs_v4);
module_exit(exit_nfs_v4);

1
fs/nfsd/nfsctl.c
View File

@ -1580,5 +1580,6 @@ static void __exit exit_nfsd(void)
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_nfsd)
module_exit(exit_nfsd)

1
fs/nilfs2/super.c
View File

@ -53,6 +53,7 @@ MODULE_AUTHOR("NTT Corp.");
MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
"(NILFS)");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
static struct kmem_cache *nilfs_inode_cachep;
struct kmem_cache *nilfs_transaction_cachep;

6
fs/nls/nls_base.c
View File

@ -541,8 +541,8 @@ struct nls_table *load_nls_default(void)
}
EXPORT_SYMBOL(unregister_nls);
EXPORT_SYMBOL(unload_nls);
EXPORT_SYMBOL(load_nls);
EXPORT_SYMBOL(load_nls_default);
EXPORT_SYMBOL_NS(unload_nls, ANDROID_GKI_VFS_EXPORT_ONLY);
EXPORT_SYMBOL_NS(load_nls, ANDROID_GKI_VFS_EXPORT_ONLY);
EXPORT_SYMBOL_NS(load_nls_default, ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_LICENSE("Dual BSD/GPL");

1
fs/nls/nls_euc-jp.c
View File

@ -578,3 +578,4 @@ module_init(init_nls_euc_jp)
module_exit(exit_nls_euc_jp)
MODULE_LICENSE("Dual BSD/GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/nls/nls_koi8-ru.c
View File

@ -80,3 +80,4 @@ module_init(init_nls_koi8_ru)
module_exit(exit_nls_koi8_ru)
MODULE_LICENSE("Dual BSD/GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/ntfs/super.c
View File

@ -3186,6 +3186,7 @@ MODULE_AUTHOR("Anton Altaparmakov <anton@tuxera.com>");
MODULE_DESCRIPTION("NTFS 1.2/3.x driver - Copyright (c) 2001-2014 Anton Altaparmakov and Tuxera Inc.");
MODULE_VERSION(NTFS_VERSION);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
#ifdef DEBUG
module_param(debug_msgs, bint, 0);
MODULE_PARM_DESC(debug_msgs, "Enable debug messages.");

1
fs/ocfs2/dlmfs/dlmfs.c
View File

@ -615,6 +615,7 @@ static void __exit exit_dlmfs_fs(void)
MODULE_AUTHOR("Oracle");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_DESCRIPTION("OCFS2 DLM-Filesystem");
module_init(init_dlmfs_fs)

1
fs/ocfs2/super.c
View File

@ -71,6 +71,7 @@ static struct dentry *ocfs2_debugfs_root;
MODULE_AUTHOR("Oracle");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_DESCRIPTION("OCFS2 cluster file system");
struct mount_options

1
fs/omfs/inode.c
View File

@ -20,6 +20,7 @@
MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>");
MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
struct buffer_head *omfs_bread(struct super_block *sb, sector_t block)
{

4
fs/open.c
View File

@ -1158,7 +1158,7 @@ struct file *filp_open(const char *filename, int flags, umode_t mode)
}
return file;
}
EXPORT_SYMBOL(filp_open);
EXPORT_SYMBOL_NS(filp_open, ANDROID_GKI_VFS_EXPORT_ONLY);
/* ANDROID: Allow drivers to open only block files from kernel mode */
struct file *filp_open_block(const char *filename, int flags, umode_t mode)
@ -1390,7 +1390,7 @@ int generic_file_open(struct inode * inode, struct file * filp)
return 0;
}
EXPORT_SYMBOL(generic_file_open);
EXPORT_SYMBOL_NS(generic_file_open, ANDROID_GKI_VFS_EXPORT_ONLY);
/*
* This is used by subsystems that don't want seekable

1
fs/orangefs/orangefs-mod.c
View File

@ -36,6 +36,7 @@ int orangefs_dcache_timeout_msecs = 50;
int orangefs_getattr_timeout_msecs = 50;
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_AUTHOR("ORANGEFS Development Team");
MODULE_DESCRIPTION("The Linux Kernel VFS interface to ORANGEFS");
MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see orangefs-debug.h for values)");

1
fs/overlayfs/super.c
View File

@ -20,6 +20,7 @@
MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
MODULE_DESCRIPTION("Overlay filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
struct ovl_dir_cache;

1
fs/qnx4/inode.c
View File

@ -420,4 +420,5 @@ static void __exit exit_qnx4_fs(void)
module_init(init_qnx4_fs)
module_exit(exit_qnx4_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/qnx6/inode.c
View File

@ -679,3 +679,4 @@ static void __exit exit_qnx6_fs(void)
module_init(init_qnx6_fs)
module_exit(exit_qnx6_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

4
fs/read_write.c
View File

@ -471,7 +471,7 @@ ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
return ret;
return __kernel_read(file, buf, count, pos);
}
EXPORT_SYMBOL(kernel_read);
EXPORT_SYMBOL_NS(kernel_read, ANDROID_GKI_VFS_EXPORT_ONLY);
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
@ -580,7 +580,7 @@ ssize_t kernel_write(struct file *file, const void *buf, size_t count,
file_end_write(file);
return ret;
}
EXPORT_SYMBOL(kernel_write);
EXPORT_SYMBOL_NS(kernel_write, ANDROID_GKI_VFS_EXPORT_ONLY);
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{

1
fs/reiserfs/super.c
View File

@ -2655,6 +2655,7 @@ MODULE_ALIAS_FS("reiserfs");
MODULE_DESCRIPTION("ReiserFS journaled filesystem");
MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_reiserfs_fs);
module_exit(exit_reiserfs_fs);

1
fs/romfs/super.c
View File

@ -666,3 +666,4 @@ module_exit(exit_romfs_fs);
MODULE_DESCRIPTION("Direct-MTD Capable RomFS");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL"); /* Actually dual-licensed, but it doesn't matter for */
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

4
fs/splice.c
View File

@ -326,7 +326,7 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
return ret;
}
EXPORT_SYMBOL(generic_file_splice_read);
EXPORT_SYMBOL_NS(generic_file_splice_read, ANDROID_GKI_VFS_EXPORT_ONLY);
const struct pipe_buf_operations default_pipe_buf_ops = {
.release = generic_pipe_buf_release,
@ -722,7 +722,7 @@ iter_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
return ret;
}
EXPORT_SYMBOL(iter_file_splice_write);
EXPORT_SYMBOL_NS(iter_file_splice_write, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* generic_splice_sendpage - splice data from a pipe to a socket

1
fs/squashfs/super.c
View File

@ -498,3 +498,4 @@ module_exit(exit_squashfs_fs);
MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
MODULE_AUTHOR("Phillip Lougher <phillip@squashfs.org.uk>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

2
fs/stat.c
View File

@ -49,7 +49,7 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
stat->blksize = i_blocksize(inode);
stat->blocks = inode->i_blocks;
}
EXPORT_SYMBOL(generic_fillattr);
EXPORT_SYMBOL_NS(generic_fillattr, ANDROID_GKI_VFS_EXPORT_ONLY);
/**
* vfs_getattr_nosec - getattr without security checks

4
fs/super.c
View File

@ -1435,7 +1435,7 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
error:
return ERR_PTR(error);
}
EXPORT_SYMBOL(mount_bdev);
EXPORT_SYMBOL_NS(mount_bdev, ANDROID_GKI_VFS_EXPORT_ONLY);
void kill_block_super(struct super_block *sb)
{
@ -1449,7 +1449,7 @@ void kill_block_super(struct super_block *sb)
blkdev_put(bdev, mode | FMODE_EXCL);
}
EXPORT_SYMBOL(kill_block_super);
EXPORT_SYMBOL_NS(kill_block_super, ANDROID_GKI_VFS_EXPORT_ONLY);
#endif
struct dentry *mount_nodev(struct file_system_type *fs_type,

2
fs/sync.c
View File

@ -66,7 +66,7 @@ int sync_filesystem(struct super_block *sb)
return ret;
return __sync_filesystem(sb, 1);
}
EXPORT_SYMBOL(sync_filesystem);
EXPORT_SYMBOL_NS(sync_filesystem, ANDROID_GKI_VFS_EXPORT_ONLY);
static void sync_inodes_one_sb(struct super_block *sb, void *arg)
{

1
fs/sysv/super.c
View File

@ -592,3 +592,4 @@ static void __exit exit_sysv_fs(void)
module_init(init_sysv_fs)
module_exit(exit_sysv_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/ubifs/super.c
View File

@ -2476,6 +2476,7 @@ static void __exit ubifs_exit(void)
module_exit(ubifs_exit);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_VERSION(__stringify(UBIFS_VERSION));
MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter");
MODULE_DESCRIPTION("UBIFS - UBI File System");

1
fs/udf/super.c
View File

@ -2543,5 +2543,6 @@ static unsigned int udf_count_free(struct super_block *sb)
MODULE_AUTHOR("Ben Fennema");
MODULE_DESCRIPTION("Universal Disk Format Filesystem");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(init_udf_fs)
module_exit(exit_udf_fs)

1
fs/ufs/super.c
View File

@ -1542,3 +1542,4 @@ static void __exit exit_ufs_fs(void)
module_init(init_ufs_fs)
module_exit(exit_ufs_fs)
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/vboxsf/super.c
View File

@ -490,4 +490,5 @@ module_exit(vboxsf_fini);
MODULE_DESCRIPTION("Oracle VM VirtualBox Module for Host File System Access");
MODULE_AUTHOR("Oracle Corporation");
MODULE_LICENSE("GPL v2");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
MODULE_ALIAS_FS("vboxsf");

6
fs/xattr.c
View File

@ -291,7 +291,7 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
}
return error;
}
EXPORT_SYMBOL_GPL(vfs_setxattr);
EXPORT_SYMBOL_NS_GPL(vfs_setxattr, ANDROID_GKI_VFS_EXPORT_ONLY);
static ssize_t
xattr_getsecurity(struct inode *inode, const char *name, void *value,
@ -405,7 +405,7 @@ vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
{
return __vfs_getxattr(dentry, dentry->d_inode, name, value, size, 0);
}
EXPORT_SYMBOL_GPL(vfs_getxattr);
EXPORT_SYMBOL_NS_GPL(vfs_getxattr, ANDROID_GKI_VFS_EXPORT_ONLY);
ssize_t
vfs_listxattr(struct dentry *dentry, char *list, size_t size)
@ -425,7 +425,7 @@ vfs_listxattr(struct dentry *dentry, char *list, size_t size)
}
return error;
}
EXPORT_SYMBOL_GPL(vfs_listxattr);
EXPORT_SYMBOL_NS_GPL(vfs_listxattr, ANDROID_GKI_VFS_EXPORT_ONLY);
int
__vfs_removexattr(struct dentry *dentry, const char *name)

1
fs/xfs/xfs_super.c
View File

@ -2224,3 +2224,4 @@ module_exit(exit_xfs_fs);
MODULE_AUTHOR("Silicon Graphics, Inc.");
MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);

1
fs/zonefs/super.c
View File

@ -1799,5 +1799,6 @@ static void __exit zonefs_exit(void)
MODULE_AUTHOR("Damien Le Moal");
MODULE_DESCRIPTION("Zone file system for zoned block devices");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
module_init(zonefs_init);
module_exit(zonefs_exit);

1
lib/test_lockup.c
View File

@ -595,5 +595,6 @@ static int __init test_lockup_init(void)
module_init(test_lockup_init);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_AUTHOR("Konstantin Khlebnikov <khlebnikov@yandex-team.ru>");
MODULE_DESCRIPTION("Test module to generate lockups");

1
net/9p/mod.c
View File

@ -189,4 +189,5 @@ MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_DESCRIPTION("Plan 9 Resource Sharing Support (9P2000)");

1
net/bpfilter/bpfilter_kern.c
View File

@ -134,3 +134,4 @@ static void __exit fini_umh(void)
module_init(load_umh);
module_exit(fini_umh);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);

1
net/sunrpc/sunrpc_syms.c
View File

@ -139,5 +139,6 @@ cleanup_sunrpc(void)
rcu_barrier(); /* Wait for completion of call_rcu()'s */
}
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
fs_initcall(init_sunrpc); /* Ensure we're initialised before nfs */
module_exit(cleanup_sunrpc);

1
net/unix/af_unix.c
View File

@ -2986,4 +2986,5 @@ fs_initcall(af_unix_init);
module_exit(af_unix_exit);
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
MODULE_ALIAS_NETPROTO(PF_UNIX);