tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace

Pull namespace bugfixes from Eric Biederman:
"This is three simple fixes against 3.9-rc1. I have tested each of
these fixes and verified they work correctly.

The userns oops in key_change_session_keyring and the BUG_ON triggered
by proc_ns_follow_link were found by Dave Jones.

I am including the enhancement for mount to only trigger requests of
filesystem modules here instead of delaying this for the 3.10 merge
window because it is both trivial and the kind of change that tends to
bit-rot if left untouched for two months."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace:
proc: Use nd_jump_link in proc_ns_follow_link
fs: Limit sys_mount to only request filesystem modules (Part 2).
fs: Limit sys_mount to only request filesystem modules.
userns: Stop oopsing in key_change_session_keyring

Linus Torvalds 72932611 8343bce1

+84 -19
+1
arch/ia64/kernel/perfmon.c
··· 619 619 .mount = pfmfs_mount, 620 620 .kill_sb = kill_anon_super, 621 621 }; 622 + MODULE_ALIAS_FS("pfmfs"); 622 623 623 624 DEFINE_PER_CPU(unsigned long, pfm_syst_info); 624 625 DEFINE_PER_CPU(struct task_struct *, pmu_owner);
+1
arch/powerpc/platforms/cell/spufs/inode.c
··· 749 749 .mount = spufs_mount, 750 750 .kill_sb = kill_litter_super, 751 751 }; 752 + MODULE_ALIAS_FS("spufs"); 752 753 753 754 static int __init spufs_init(void) 754 755 {
+1
arch/s390/hypfs/inode.c
··· 456 456 .mount = hypfs_mount, 457 457 .kill_sb = hypfs_kill_super 458 458 }; 459 + MODULE_ALIAS_FS("s390_hypfs"); 459 460 460 461 static const struct super_operations hypfs_s_ops = { 461 462 .statfs = simple_statfs,
+1
drivers/firmware/efivars.c
··· 1289 1289 .mount = efivarfs_mount, 1290 1290 .kill_sb = efivarfs_kill_sb, 1291 1291 }; 1292 + MODULE_ALIAS_FS("efivarfs"); 1292 1293 1293 1294 /* 1294 1295 * Handle negative dentry.
+1
drivers/infiniband/hw/ipath/ipath_fs.c
··· 410 410 .mount = ipathfs_mount, 411 411 .kill_sb = ipathfs_kill_super, 412 412 }; 413 + MODULE_ALIAS_FS("ipathfs"); 413 414 414 415 int __init ipath_init_ipathfs(void) 415 416 {
+1
drivers/infiniband/hw/qib/qib_fs.c
··· 604 604 .mount = qibfs_mount, 605 605 .kill_sb = qibfs_kill_super, 606 606 }; 607 + MODULE_ALIAS_FS("ipathfs"); 607 608 608 609 int __init qib_init_qibfs(void) 609 610 {
+1
drivers/misc/ibmasm/ibmasmfs.c
··· 110 110 .mount = ibmasmfs_mount, 111 111 .kill_sb = kill_litter_super, 112 112 }; 113 + MODULE_ALIAS_FS("ibmasmfs"); 113 114 114 115 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent) 115 116 {
+1
drivers/mtd/mtdchar.c
··· 1238 1238 .mount = mtd_inodefs_mount, 1239 1239 .kill_sb = kill_anon_super, 1240 1240 }; 1241 + MODULE_ALIAS_FS("mtd_inodefs"); 1241 1242 1242 1243 static int __init init_mtdchar(void) 1243 1244 {
+1
drivers/oprofile/oprofilefs.c
··· 276 276 .mount = oprofilefs_mount, 277 277 .kill_sb = kill_litter_super, 278 278 }; 279 + MODULE_ALIAS_FS("oprofilefs"); 279 280 280 281 281 282 int __init oprofilefs_register(void)
+1
drivers/staging/ccg/f_fs.c
··· 1223 1223 .mount = ffs_fs_mount, 1224 1224 .kill_sb = ffs_fs_kill_sb, 1225 1225 }; 1226 + MODULE_ALIAS_FS("functionfs"); 1226 1227 1227 1228 1228 1229 /* Driver's main init/cleanup functions *************************************/
+1
drivers/usb/gadget/f_fs.c
··· 1235 1235 .mount = ffs_fs_mount, 1236 1236 .kill_sb = ffs_fs_kill_sb, 1237 1237 }; 1238 + MODULE_ALIAS_FS("functionfs"); 1238 1239 1239 1240 1240 1241 /* Driver's main init/cleanup functions *************************************/
+1
drivers/usb/gadget/inode.c
··· 2105 2105 .mount = gadgetfs_mount, 2106 2106 .kill_sb = gadgetfs_kill_sb, 2107 2107 }; 2108 + MODULE_ALIAS_FS("gadgetfs"); 2108 2109 2109 2110 /*----------------------------------------------------------------------*/ 2110 2111
+1
drivers/xen/xenfs/super.c
··· 75 75 .mount = xenfs_mount, 76 76 .kill_sb = kill_litter_super, 77 77 }; 78 + MODULE_ALIAS_FS("xenfs"); 78 79 79 80 static int __init xenfs_init(void) 80 81 {
+1
fs/9p/vfs_super.c
··· 365 365 .owner = THIS_MODULE, 366 366 .fs_flags = FS_RENAME_DOES_D_MOVE, 367 367 }; 368 + MODULE_ALIAS_FS("9p");
+1
fs/adfs/super.c
··· 524 524 .kill_sb = kill_block_super, 525 525 .fs_flags = FS_REQUIRES_DEV, 526 526 }; 527 + MODULE_ALIAS_FS("adfs"); 527 528 528 529 static int __init init_adfs_fs(void) 529 530 {
+1
fs/affs/super.c
··· 622 622 .kill_sb = kill_block_super, 623 623 .fs_flags = FS_REQUIRES_DEV, 624 624 }; 625 + MODULE_ALIAS_FS("affs"); 625 626 626 627 static int __init init_affs_fs(void) 627 628 {
+1
fs/afs/super.c
··· 45 45 .kill_sb = afs_kill_super, 46 46 .fs_flags = 0, 47 47 }; 48 + MODULE_ALIAS_FS("afs"); 48 49 49 50 static const struct super_operations afs_super_ops = { 50 51 .statfs = afs_statfs,
+1
fs/autofs4/init.c
··· 26 26 .mount = autofs_mount, 27 27 .kill_sb = autofs4_kill_sb, 28 28 }; 29 + MODULE_ALIAS_FS("autofs"); 29 30 30 31 static int __init init_autofs4_fs(void) 31 32 {
+1
fs/befs/linuxvfs.c
··· 951 951 .kill_sb = kill_block_super, 952 952 .fs_flags = FS_REQUIRES_DEV, 953 953 }; 954 + MODULE_ALIAS_FS("befs"); 954 955 955 956 static int __init 956 957 init_befs_fs(void)
+1
fs/bfs/inode.c
··· 473 473 .kill_sb = kill_block_super, 474 474 .fs_flags = FS_REQUIRES_DEV, 475 475 }; 476 + MODULE_ALIAS_FS("bfs"); 476 477 477 478 static int __init init_bfs_fs(void) 478 479 {
+1
fs/binfmt_misc.c
··· 720 720 .mount = bm_mount, 721 721 .kill_sb = kill_litter_super, 722 722 }; 723 + MODULE_ALIAS_FS("binfmt_misc"); 723 724 724 725 static int __init init_misc_binfmt(void) 725 726 {
+1
fs/btrfs/super.c
··· 1558 1558 .kill_sb = btrfs_kill_super, 1559 1559 .fs_flags = FS_REQUIRES_DEV, 1560 1560 }; 1561 + MODULE_ALIAS_FS("btrfs"); 1561 1562 1562 1563 /* 1563 1564 * used by btrfsctl to scan devices when no FS is mounted
+1
fs/ceph/super.c
··· 952 952 .kill_sb = ceph_kill_sb, 953 953 .fs_flags = FS_RENAME_DOES_D_MOVE, 954 954 }; 955 + MODULE_ALIAS_FS("ceph"); 955 956 956 957 #define _STRINGIFY(x) #x 957 958 #define STRINGIFY(x) _STRINGIFY(x)
+1
fs/coda/inode.c
··· 329 329 .kill_sb = kill_anon_super, 330 330 .fs_flags = FS_BINARY_MOUNTDATA, 331 331 }; 332 + MODULE_ALIAS_FS("coda"); 332 333
+1
fs/configfs/mount.c
··· 114 114 .mount = configfs_do_mount, 115 115 .kill_sb = kill_litter_super, 116 116 }; 117 + MODULE_ALIAS_FS("configfs"); 117 118 118 119 struct dentry *configfs_pin_fs(void) 119 120 {
+1
fs/cramfs/inode.c
··· 573 573 .kill_sb = kill_block_super, 574 574 .fs_flags = FS_REQUIRES_DEV, 575 575 }; 576 + MODULE_ALIAS_FS("cramfs"); 576 577 577 578 static int __init init_cramfs_fs(void) 578 579 {
+1
fs/debugfs/inode.c
··· 299 299 .mount = debug_mount, 300 300 .kill_sb = kill_litter_super, 301 301 }; 302 + MODULE_ALIAS_FS("debugfs"); 302 303 303 304 static struct dentry *__create_file(const char *name, umode_t mode, 304 305 struct dentry *parent, void *data,
+1
fs/ecryptfs/main.c
··· 629 629 .kill_sb = ecryptfs_kill_block_super, 630 630 .fs_flags = 0 631 631 }; 632 + MODULE_ALIAS_FS("ecryptfs"); 632 633 633 634 /** 634 635 * inode_info_init_once
+1
fs/efs/super.c
··· 33 33 .kill_sb = kill_block_super, 34 34 .fs_flags = FS_REQUIRES_DEV, 35 35 }; 36 + MODULE_ALIAS_FS("efs"); 36 37 37 38 static struct pt_types sgi_pt_types[] = { 38 39 {0x00, "SGI vh"},
+1
fs/exofs/super.c
··· 1010 1010 .mount = exofs_mount, 1011 1011 .kill_sb = generic_shutdown_super, 1012 1012 }; 1013 + MODULE_ALIAS_FS("exofs"); 1013 1014 1014 1015 static int __init init_exofs(void) 1015 1016 {
+1
fs/ext2/super.c
··· 1536 1536 .kill_sb = kill_block_super, 1537 1537 .fs_flags = FS_REQUIRES_DEV, 1538 1538 }; 1539 + MODULE_ALIAS_FS("ext2"); 1539 1540 1540 1541 static int __init init_ext2_fs(void) 1541 1542 {
+1
fs/ext3/super.c
··· 3068 3068 .kill_sb = kill_block_super, 3069 3069 .fs_flags = FS_REQUIRES_DEV, 3070 3070 }; 3071 + MODULE_ALIAS_FS("ext3"); 3071 3072 3072 3073 static int __init init_ext3_fs(void) 3073 3074 {
+3 -2
fs/ext4/super.c
··· 90 90 .kill_sb = kill_block_super, 91 91 .fs_flags = FS_REQUIRES_DEV, 92 92 }; 93 + MODULE_ALIAS_FS("ext2"); 93 94 #define IS_EXT2_SB(sb) ((sb)->s_bdev->bd_holder == &ext2_fs_type) 94 95 #else 95 96 #define IS_EXT2_SB(sb) (0) ··· 105 104 .kill_sb = kill_block_super, 106 105 .fs_flags = FS_REQUIRES_DEV, 107 106 }; 107 + MODULE_ALIAS_FS("ext3"); 108 108 #define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type) 109 109 #else 110 110 #define IS_EXT3_SB(sb) (0) ··· 5154 5152 return 0; 5155 5153 return 1; 5156 5154 } 5157 - MODULE_ALIAS("ext2"); 5158 5155 #else 5159 5156 static inline void register_as_ext2(void) { } 5160 5157 static inline void unregister_as_ext2(void) { } ··· 5186 5185 return 0; 5187 5186 return 1; 5188 5187 } 5189 - MODULE_ALIAS("ext3"); 5190 5188 #else 5191 5189 static inline void register_as_ext3(void) { } 5192 5190 static inline void unregister_as_ext3(void) { } ··· 5199 5199 .kill_sb = kill_block_super, 5200 5200 .fs_flags = FS_REQUIRES_DEV, 5201 5201 }; 5202 + MODULE_ALIAS_FS("ext4"); 5202 5203 5203 5204 static int __init ext4_init_feat_adverts(void) 5204 5205 {
+1
fs/f2fs/super.c
··· 687 687 .kill_sb = kill_block_super, 688 688 .fs_flags = FS_REQUIRES_DEV, 689 689 }; 690 + MODULE_ALIAS_FS("f2fs"); 690 691 691 692 static int __init init_inodecache(void) 692 693 {
+1
fs/fat/namei_msdos.c
··· 668 668 .kill_sb = kill_block_super, 669 669 .fs_flags = FS_REQUIRES_DEV, 670 670 }; 671 + MODULE_ALIAS_FS("msdos"); 671 672 672 673 static int __init init_msdos_fs(void) 673 674 {
+1
fs/fat/namei_vfat.c
··· 1073 1073 .kill_sb = kill_block_super, 1074 1074 .fs_flags = FS_REQUIRES_DEV, 1075 1075 }; 1076 + MODULE_ALIAS_FS("vfat"); 1076 1077 1077 1078 static int __init init_vfat_fs(void) 1078 1079 {
+1 -1
fs/filesystems.c
··· 273 273 int len = dot ? dot - name : strlen(name); 274 274 275 275 fs = __get_fs_type(name, len); 276 - if (!fs && (request_module("%.*s", len, name) == 0)) 276 + if (!fs && (request_module("fs-%.*s", len, name) == 0)) 277 277 fs = __get_fs_type(name, len); 278 278 279 279 if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
+1 -1
fs/freevxfs/vxfs_super.c
··· 52 52 MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver"); 53 53 MODULE_LICENSE("Dual BSD/GPL"); 54 54 55 - MODULE_ALIAS("vxfs"); /* makes mount -t vxfs autoload the module */ 56 55 57 56 58 57 static void vxfs_put_super(struct super_block *); ··· 257 258 .kill_sb = kill_block_super, 258 259 .fs_flags = FS_REQUIRES_DEV, 259 260 }; 261 + MODULE_ALIAS_FS("vxfs"); /* makes mount -t vxfs autoload the module */ 260 262 261 263 static int __init 262 264 vxfs_init(void)
+1
fs/fuse/control.c
··· 341 341 .mount = fuse_ctl_mount, 342 342 .kill_sb = fuse_ctl_kill_sb, 343 343 }; 344 + MODULE_ALIAS_FS("fusectl"); 344 345 345 346 int __init fuse_ctl_init(void) 346 347 {
+2
fs/fuse/inode.c
··· 1117 1117 .mount = fuse_mount, 1118 1118 .kill_sb = fuse_kill_sb_anon, 1119 1119 }; 1120 + MODULE_ALIAS_FS("fuse"); 1120 1121 1121 1122 #ifdef CONFIG_BLOCK 1122 1123 static struct dentry *fuse_mount_blk(struct file_system_type *fs_type, ··· 1147 1146 .kill_sb = fuse_kill_sb_blk, 1148 1147 .fs_flags = FS_REQUIRES_DEV | FS_HAS_SUBTYPE, 1149 1148 }; 1149 + MODULE_ALIAS_FS("fuseblk"); 1150 1150 1151 1151 static inline int register_fuseblk(void) 1152 1152 {
+3 -1
fs/gfs2/ops_fstype.c
··· 20 20 #include <linux/gfs2_ondisk.h> 21 21 #include <linux/quotaops.h> 22 22 #include <linux/lockdep.h> 23 + #include <linux/module.h> 23 24 24 25 #include "gfs2.h" 25 26 #include "incore.h" ··· 1426 1425 .kill_sb = gfs2_kill_sb, 1427 1426 .owner = THIS_MODULE, 1428 1427 }; 1428 + MODULE_ALIAS_FS("gfs2"); 1429 1429 1430 1430 struct file_system_type gfs2meta_fs_type = { 1431 1431 .name = "gfs2meta", ··· 1434 1432 .mount = gfs2_mount_meta, 1435 1433 .owner = THIS_MODULE, 1436 1434 }; 1437 - 1435 + MODULE_ALIAS_FS("gfs2meta");
+1
fs/hfs/super.c
··· 466 466 .kill_sb = kill_block_super, 467 467 .fs_flags = FS_REQUIRES_DEV, 468 468 }; 469 + MODULE_ALIAS_FS("hfs"); 469 470 470 471 static void hfs_init_once(void *p) 471 472 {
+1
fs/hfsplus/super.c
··· 654 654 .kill_sb = kill_block_super, 655 655 .fs_flags = FS_REQUIRES_DEV, 656 656 }; 657 + MODULE_ALIAS_FS("hfsplus"); 657 658 658 659 static void hfsplus_init_once(void *p) 659 660 {
+1
fs/hppfs/hppfs.c
··· 748 748 .kill_sb = kill_anon_super, 749 749 .fs_flags = 0, 750 750 }; 751 + MODULE_ALIAS_FS("hppfs"); 751 752 752 753 static int __init init_hppfs(void) 753 754 {
+1
fs/hugetlbfs/inode.c
··· 896 896 .mount = hugetlbfs_mount, 897 897 .kill_sb = kill_litter_super, 898 898 }; 899 + MODULE_ALIAS_FS("hugetlbfs"); 899 900 900 901 static struct vfsmount *hugetlbfs_vfsmount[HUGE_MAX_HSTATE]; 901 902
+1 -2
fs/isofs/inode.c
··· 1556 1556 .kill_sb = kill_block_super, 1557 1557 .fs_flags = FS_REQUIRES_DEV, 1558 1558 }; 1559 + MODULE_ALIAS_FS("iso9660"); 1559 1560 1560 1561 static int __init init_iso9660_fs(void) 1561 1562 { ··· 1594 1593 module_init(init_iso9660_fs) 1595 1594 module_exit(exit_iso9660_fs) 1596 1595 MODULE_LICENSE("GPL"); 1597 - /* Actual filesystem name is iso9660, as requested in filesystems.c */ 1598 - MODULE_ALIAS("iso9660");
+1
fs/jffs2/super.c
··· 356 356 .mount = jffs2_mount, 357 357 .kill_sb = jffs2_kill_sb, 358 358 }; 359 + MODULE_ALIAS_FS("jffs2"); 359 360 360 361 static int __init init_jffs2_fs(void) 361 362 {
+1
fs/jfs/super.c
··· 833 833 .kill_sb = kill_block_super, 834 834 .fs_flags = FS_REQUIRES_DEV, 835 835 }; 836 + MODULE_ALIAS_FS("jfs"); 836 837 837 838 static void init_once(void *foo) 838 839 {
+1
fs/logfs/super.c
··· 608 608 .fs_flags = FS_REQUIRES_DEV, 609 609 610 610 }; 611 + MODULE_ALIAS_FS("logfs"); 611 612 612 613 static int __init logfs_init(void) 613 614 {
+1
fs/minix/inode.c
··· 660 660 .kill_sb = kill_block_super, 661 661 .fs_flags = FS_REQUIRES_DEV, 662 662 }; 663 + MODULE_ALIAS_FS("minix"); 663 664 664 665 static int __init init_minix_fs(void) 665 666 {
+1
fs/ncpfs/inode.c
··· 1051 1051 .kill_sb = kill_anon_super, 1052 1052 .fs_flags = FS_BINARY_MOUNTDATA, 1053 1053 }; 1054 + MODULE_ALIAS_FS("ncpfs"); 1054 1055 1055 1056 static int __init init_ncp_fs(void) 1056 1057 {
+2 -1
fs/nfs/super.c
··· 294 294 .kill_sb = nfs_kill_super, 295 295 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA, 296 296 }; 297 + MODULE_ALIAS_FS("nfs"); 297 298 EXPORT_SYMBOL_GPL(nfs_fs_type); 298 299 299 300 struct file_system_type nfs_xdev_fs_type = { ··· 334 333 .kill_sb = nfs_kill_super, 335 334 .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA, 336 335 }; 336 + MODULE_ALIAS_FS("nfs4"); 337 337 EXPORT_SYMBOL_GPL(nfs4_fs_type); 338 338 339 339 static int __init register_nfs4_fs(void) ··· 2719 2717 MODULE_PARM_DESC(send_implementation_id, 2720 2718 "Send implementation ID with NFSv4.1 exchange_id"); 2721 2719 MODULE_PARM_DESC(nfs4_unique_id, "nfs_client_id4 uniquifier string"); 2722 - MODULE_ALIAS("nfs4"); 2723 2720 2724 2721 #endif /* CONFIG_NFS_V4 */
+1
fs/nfsd/nfsctl.c
··· 1090 1090 .mount = nfsd_mount, 1091 1091 .kill_sb = nfsd_umount, 1092 1092 }; 1093 + MODULE_ALIAS_FS("nfsd"); 1093 1094 1094 1095 #ifdef CONFIG_PROC_FS 1095 1096 static int create_proc_exports_entry(void)
+1
fs/nilfs2/super.c
··· 1361 1361 .kill_sb = kill_block_super, 1362 1362 .fs_flags = FS_REQUIRES_DEV, 1363 1363 }; 1364 + MODULE_ALIAS_FS("nilfs2"); 1364 1365 1365 1366 static void nilfs_inode_init_once(void *obj) 1366 1367 {
+1
fs/ntfs/super.c
··· 3079 3079 .kill_sb = kill_block_super, 3080 3080 .fs_flags = FS_REQUIRES_DEV, 3081 3081 }; 3082 + MODULE_ALIAS_FS("ntfs"); 3082 3083 3083 3084 /* Stable names for the slab caches. */ 3084 3085 static const char ntfs_index_ctx_cache_name[] = "ntfs_index_ctx_cache";
+1
fs/ocfs2/dlmfs/dlmfs.c
··· 640 640 .mount = dlmfs_mount, 641 641 .kill_sb = kill_litter_super, 642 642 }; 643 + MODULE_ALIAS_FS("ocfs2_dlmfs"); 643 644 644 645 static int __init init_dlmfs_fs(void) 645 646 {
+1
fs/ocfs2/super.c
··· 1266 1266 .fs_flags = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE, 1267 1267 .next = NULL 1268 1268 }; 1269 + MODULE_ALIAS_FS("ocfs2"); 1269 1270 1270 1271 static int ocfs2_check_set_options(struct super_block *sb, 1271 1272 struct mount_options *options)
+1
fs/omfs/inode.c
··· 572 572 .kill_sb = kill_block_super, 573 573 .fs_flags = FS_REQUIRES_DEV, 574 574 }; 575 + MODULE_ALIAS_FS("omfs"); 575 576 576 577 static int __init init_omfs_fs(void) 577 578 {
+1
fs/openpromfs/inode.c
··· 432 432 .mount = openprom_mount, 433 433 .kill_sb = kill_anon_super, 434 434 }; 435 + MODULE_ALIAS_FS("openpromfs"); 435 436 436 437 static void op_inode_init_once(void *data) 437 438 {
+6 -6
fs/proc/namespaces.c
··· 118 118 struct super_block *sb = inode->i_sb; 119 119 struct proc_inode *ei = PROC_I(inode); 120 120 struct task_struct *task; 121 - struct dentry *ns_dentry; 121 + struct path ns_path; 122 122 void *error = ERR_PTR(-EACCES); 123 123 124 124 task = get_proc_task(inode); ··· 128 128 if (!ptrace_may_access(task, PTRACE_MODE_READ)) 129 129 goto out_put_task; 130 130 131 - ns_dentry = proc_ns_get_dentry(sb, task, ei->ns_ops); 132 - if (IS_ERR(ns_dentry)) { 133 - error = ERR_CAST(ns_dentry); 131 + ns_path.dentry = proc_ns_get_dentry(sb, task, ei->ns_ops); 132 + if (IS_ERR(ns_path.dentry)) { 133 + error = ERR_CAST(ns_path.dentry); 134 134 goto out_put_task; 135 135 } 136 136 137 - dput(nd->path.dentry); 138 - nd->path.dentry = ns_dentry; 137 + ns_path.mnt = mntget(nd->path.mnt); 138 + nd_jump_link(nd, &ns_path); 139 139 error = NULL; 140 140 141 141 out_put_task:
+1
fs/qnx4/inode.c
··· 412 412 .kill_sb = kill_block_super, 413 413 .fs_flags = FS_REQUIRES_DEV, 414 414 }; 415 + MODULE_ALIAS_FS("qnx4"); 415 416 416 417 static int __init init_qnx4_fs(void) 417 418 {
+1
fs/qnx6/inode.c
··· 672 672 .kill_sb = kill_block_super, 673 673 .fs_flags = FS_REQUIRES_DEV, 674 674 }; 675 + MODULE_ALIAS_FS("qnx6"); 675 676 676 677 static int __init init_qnx6_fs(void) 677 678 {
+1
fs/reiserfs/super.c
··· 2434 2434 .kill_sb = reiserfs_kill_sb, 2435 2435 .fs_flags = FS_REQUIRES_DEV, 2436 2436 }; 2437 + MODULE_ALIAS_FS("reiserfs"); 2437 2438 2438 2439 MODULE_DESCRIPTION("ReiserFS journaled filesystem"); 2439 2440 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
+1
fs/romfs/super.c
··· 599 599 .kill_sb = romfs_kill_sb, 600 600 .fs_flags = FS_REQUIRES_DEV, 601 601 }; 602 + MODULE_ALIAS_FS("romfs"); 602 603 603 604 /* 604 605 * inode storage initialiser
+2 -1
fs/sysv/super.c
··· 545 545 .kill_sb = kill_block_super, 546 546 .fs_flags = FS_REQUIRES_DEV, 547 547 }; 548 + MODULE_ALIAS_FS("sysv"); 548 549 549 550 static struct file_system_type v7_fs_type = { 550 551 .owner = THIS_MODULE, ··· 554 553 .kill_sb = kill_block_super, 555 554 .fs_flags = FS_REQUIRES_DEV, 556 555 }; 556 + MODULE_ALIAS_FS("v7"); 557 557 558 558 static int __init init_sysv_fs(void) 559 559 { ··· 588 586 589 587 module_init(init_sysv_fs) 590 588 module_exit(exit_sysv_fs) 591 - MODULE_ALIAS("v7"); 592 589 MODULE_LICENSE("GPL");
+1
fs/ubifs/super.c
··· 2174 2174 .mount = ubifs_mount, 2175 2175 .kill_sb = kill_ubifs_super, 2176 2176 }; 2177 + MODULE_ALIAS_FS("ubifs"); 2177 2178 2178 2179 /* 2179 2180 * Inode slab cache constructor.
+1
fs/ufs/super.c
··· 1500 1500 .kill_sb = kill_block_super, 1501 1501 .fs_flags = FS_REQUIRES_DEV, 1502 1502 }; 1503 + MODULE_ALIAS_FS("ufs"); 1503 1504 1504 1505 static int __init init_ufs_fs(void) 1505 1506 {
+1
fs/xfs/xfs_super.c
··· 1561 1561 .kill_sb = kill_block_super, 1562 1562 .fs_flags = FS_REQUIRES_DEV, 1563 1563 }; 1564 + MODULE_ALIAS_FS("xfs"); 1564 1565 1565 1566 STATIC int __init 1566 1567 xfs_init_zones(void)
+2
include/linux/fs.h
··· 1825 1825 struct lock_class_key i_mutex_dir_key; 1826 1826 }; 1827 1827 1828 + #define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME) 1829 + 1828 1830 extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags, 1829 1831 void *data, int (*fill_super)(struct super_block *, void *, int)); 1830 1832 extern struct dentry *mount_bdev(struct file_system_type *fs_type,
+1 -3
net/sunrpc/rpc_pipe.c
··· 1174 1174 .mount = rpc_mount, 1175 1175 .kill_sb = rpc_kill_sb, 1176 1176 }; 1177 + MODULE_ALIAS_FS("rpc_pipefs"); 1177 1178 1178 1179 static void 1179 1180 init_once(void *foo) ··· 1219 1218 kmem_cache_destroy(rpc_inode_cachep); 1220 1219 unregister_filesystem(&rpc_pipe_fs_type); 1221 1220 } 1222 - 1223 - /* Make 'mount -t rpc_pipefs ...' autoload this module. */ 1224 - MODULE_ALIAS("rpc_pipefs");
+1 -1
security/keys/process_keys.c
··· 839 839 new-> sgid = old-> sgid; 840 840 new->fsgid = old->fsgid; 841 841 new->user = get_uid(old->user); 842 - new->user_ns = get_user_ns(new->user_ns); 842 + new->user_ns = get_user_ns(old->user_ns); 843 843 new->group_info = get_group_info(old->group_info); 844 844 845 845 new->securebits = old->securebits;