diff options
Diffstat (limited to 'fs/nfsd')
-rw-r--r-- | fs/nfsd/Kconfig | 12 | ||||
-rw-r--r-- | fs/nfsd/export.c | 418 | ||||
-rw-r--r-- | fs/nfsd/lockd.c | 2 | ||||
-rw-r--r-- | fs/nfsd/nfsctl.c | 343 | ||||
-rw-r--r-- | fs/nfsd/nfssvc.c | 7 |
5 files changed, 0 insertions, 782 deletions
diff --git a/fs/nfsd/Kconfig b/fs/nfsd/Kconfig index fbb2a5ef5817..10e6366608f2 100644 --- a/fs/nfsd/Kconfig +++ b/fs/nfsd/Kconfig | |||
@@ -28,18 +28,6 @@ config NFSD | |||
28 | 28 | ||
29 | If unsure, say N. | 29 | If unsure, say N. |
30 | 30 | ||
31 | config NFSD_DEPRECATED | ||
32 | bool "Include support for deprecated syscall interface to NFSD" | ||
33 | depends on NFSD | ||
34 | default y | ||
35 | help | ||
36 | The syscall interface to nfsd was obsoleted in 2.6.0 by a new | ||
37 | filesystem based interface. The old interface is due for removal | ||
38 | in 2.6.40. If you wish to remove the interface before then | ||
39 | say N. | ||
40 | |||
41 | In unsure, say Y. | ||
42 | |||
43 | config NFSD_V2_ACL | 31 | config NFSD_V2_ACL |
44 | bool | 32 | bool |
45 | depends on NFSD | 33 | depends on NFSD |
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c index b9566e46219f..f4cc1e2bfc54 100644 --- a/fs/nfsd/export.c +++ b/fs/nfsd/export.c | |||
@@ -797,58 +797,6 @@ exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp) | |||
797 | return ek; | 797 | return ek; |
798 | } | 798 | } |
799 | 799 | ||
800 | #ifdef CONFIG_NFSD_DEPRECATED | ||
801 | static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv, | ||
802 | struct svc_export *exp) | ||
803 | { | ||
804 | struct svc_expkey key, *ek; | ||
805 | |||
806 | key.ek_client = clp; | ||
807 | key.ek_fsidtype = fsid_type; | ||
808 | memcpy(key.ek_fsid, fsidv, key_len(fsid_type)); | ||
809 | key.ek_path = exp->ex_path; | ||
810 | key.h.expiry_time = NEVER; | ||
811 | key.h.flags = 0; | ||
812 | |||
813 | ek = svc_expkey_lookup(&key); | ||
814 | if (ek) | ||
815 | ek = svc_expkey_update(&key,ek); | ||
816 | if (ek) { | ||
817 | cache_put(&ek->h, &svc_expkey_cache); | ||
818 | return 0; | ||
819 | } | ||
820 | return -ENOMEM; | ||
821 | } | ||
822 | |||
823 | /* | ||
824 | * Find the client's export entry matching xdev/xino. | ||
825 | */ | ||
826 | static inline struct svc_expkey * | ||
827 | exp_get_key(svc_client *clp, dev_t dev, ino_t ino) | ||
828 | { | ||
829 | u32 fsidv[3]; | ||
830 | |||
831 | if (old_valid_dev(dev)) { | ||
832 | mk_fsid(FSID_DEV, fsidv, dev, ino, 0, NULL); | ||
833 | return exp_find_key(clp, FSID_DEV, fsidv, NULL); | ||
834 | } | ||
835 | mk_fsid(FSID_ENCODE_DEV, fsidv, dev, ino, 0, NULL); | ||
836 | return exp_find_key(clp, FSID_ENCODE_DEV, fsidv, NULL); | ||
837 | } | ||
838 | |||
839 | /* | ||
840 | * Find the client's export entry matching fsid | ||
841 | */ | ||
842 | static inline struct svc_expkey * | ||
843 | exp_get_fsid_key(svc_client *clp, int fsid) | ||
844 | { | ||
845 | u32 fsidv[2]; | ||
846 | |||
847 | mk_fsid(FSID_NUM, fsidv, 0, 0, fsid, NULL); | ||
848 | |||
849 | return exp_find_key(clp, FSID_NUM, fsidv, NULL); | ||
850 | } | ||
851 | #endif | ||
852 | 800 | ||
853 | static svc_export *exp_get_by_name(svc_client *clp, const struct path *path, | 801 | static svc_export *exp_get_by_name(svc_client *clp, const struct path *path, |
854 | struct cache_req *reqp) | 802 | struct cache_req *reqp) |
@@ -890,275 +838,7 @@ static struct svc_export *exp_parent(svc_client *clp, struct path *path) | |||
890 | return exp; | 838 | return exp; |
891 | } | 839 | } |
892 | 840 | ||
893 | #ifdef CONFIG_NFSD_DEPRECATED | ||
894 | /* | ||
895 | * Hashtable locking. Write locks are placed only by user processes | ||
896 | * wanting to modify export information. | ||
897 | * Write locking only done in this file. Read locking | ||
898 | * needed externally. | ||
899 | */ | ||
900 | |||
901 | static DECLARE_RWSEM(hash_sem); | ||
902 | |||
903 | void | ||
904 | exp_readlock(void) | ||
905 | { | ||
906 | down_read(&hash_sem); | ||
907 | } | ||
908 | |||
909 | static inline void | ||
910 | exp_writelock(void) | ||
911 | { | ||
912 | down_write(&hash_sem); | ||
913 | } | ||
914 | |||
915 | void | ||
916 | exp_readunlock(void) | ||
917 | { | ||
918 | up_read(&hash_sem); | ||
919 | } | ||
920 | |||
921 | static inline void | ||
922 | exp_writeunlock(void) | ||
923 | { | ||
924 | up_write(&hash_sem); | ||
925 | } | ||
926 | #else | ||
927 | |||
928 | /* hash_sem not needed once deprecated interface is removed */ | ||
929 | void exp_readlock(void) {} | ||
930 | static inline void exp_writelock(void){} | ||
931 | void exp_readunlock(void) {} | ||
932 | static inline void exp_writeunlock(void){} | ||
933 | |||
934 | #endif | ||
935 | |||
936 | #ifdef CONFIG_NFSD_DEPRECATED | ||
937 | static void exp_do_unexport(svc_export *unexp); | ||
938 | static int exp_verify_string(char *cp, int max); | ||
939 | |||
940 | static void exp_fsid_unhash(struct svc_export *exp) | ||
941 | { | ||
942 | struct svc_expkey *ek; | ||
943 | |||
944 | if ((exp->ex_flags & NFSEXP_FSID) == 0) | ||
945 | return; | ||
946 | |||
947 | ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid); | ||
948 | if (!IS_ERR(ek)) { | ||
949 | sunrpc_invalidate(&ek->h, &svc_expkey_cache); | ||
950 | cache_put(&ek->h, &svc_expkey_cache); | ||
951 | } | ||
952 | } | ||
953 | |||
954 | static int exp_fsid_hash(svc_client *clp, struct svc_export *exp) | ||
955 | { | ||
956 | u32 fsid[2]; | ||
957 | |||
958 | if ((exp->ex_flags & NFSEXP_FSID) == 0) | ||
959 | return 0; | ||
960 | |||
961 | mk_fsid(FSID_NUM, fsid, 0, 0, exp->ex_fsid, NULL); | ||
962 | return exp_set_key(clp, FSID_NUM, fsid, exp); | ||
963 | } | ||
964 | |||
965 | static int exp_hash(struct auth_domain *clp, struct svc_export *exp) | ||
966 | { | ||
967 | u32 fsid[2]; | ||
968 | struct inode *inode = exp->ex_path.dentry->d_inode; | ||
969 | dev_t dev = inode->i_sb->s_dev; | ||
970 | |||
971 | if (old_valid_dev(dev)) { | ||
972 | mk_fsid(FSID_DEV, fsid, dev, inode->i_ino, 0, NULL); | ||
973 | return exp_set_key(clp, FSID_DEV, fsid, exp); | ||
974 | } | ||
975 | mk_fsid(FSID_ENCODE_DEV, fsid, dev, inode->i_ino, 0, NULL); | ||
976 | return exp_set_key(clp, FSID_ENCODE_DEV, fsid, exp); | ||
977 | } | ||
978 | 841 | ||
979 | static void exp_unhash(struct svc_export *exp) | ||
980 | { | ||
981 | struct svc_expkey *ek; | ||
982 | struct inode *inode = exp->ex_path.dentry->d_inode; | ||
983 | |||
984 | ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino); | ||
985 | if (!IS_ERR(ek)) { | ||
986 | sunrpc_invalidate(&ek->h, &svc_expkey_cache); | ||
987 | cache_put(&ek->h, &svc_expkey_cache); | ||
988 | } | ||
989 | } | ||
990 | |||
991 | /* | ||
992 | * Export a file system. | ||
993 | */ | ||
994 | int | ||
995 | exp_export(struct nfsctl_export *nxp) | ||
996 | { | ||
997 | svc_client *clp; | ||
998 | struct svc_export *exp = NULL; | ||
999 | struct svc_export new; | ||
1000 | struct svc_expkey *fsid_key = NULL; | ||
1001 | struct path path; | ||
1002 | int err; | ||
1003 | |||
1004 | /* Consistency check */ | ||
1005 | err = -EINVAL; | ||
1006 | if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) || | ||
1007 | !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX)) | ||
1008 | goto out; | ||
1009 | |||
1010 | dprintk("exp_export called for %s:%s (%x/%ld fl %x).\n", | ||
1011 | nxp->ex_client, nxp->ex_path, | ||
1012 | (unsigned)nxp->ex_dev, (long)nxp->ex_ino, | ||
1013 | nxp->ex_flags); | ||
1014 | |||
1015 | /* Try to lock the export table for update */ | ||
1016 | exp_writelock(); | ||
1017 | |||
1018 | /* Look up client info */ | ||
1019 | if (!(clp = auth_domain_find(nxp->ex_client))) | ||
1020 | goto out_unlock; | ||
1021 | |||
1022 | |||
1023 | /* Look up the dentry */ | ||
1024 | err = kern_path(nxp->ex_path, 0, &path); | ||
1025 | if (err) | ||
1026 | goto out_put_clp; | ||
1027 | err = -EINVAL; | ||
1028 | |||
1029 | exp = exp_get_by_name(clp, &path, NULL); | ||
1030 | |||
1031 | memset(&new, 0, sizeof(new)); | ||
1032 | |||
1033 | /* must make sure there won't be an ex_fsid clash */ | ||
1034 | if ((nxp->ex_flags & NFSEXP_FSID) && | ||
1035 | (!IS_ERR(fsid_key = exp_get_fsid_key(clp, nxp->ex_dev))) && | ||
1036 | fsid_key->ek_path.mnt && | ||
1037 | (fsid_key->ek_path.mnt != path.mnt || | ||
1038 | fsid_key->ek_path.dentry != path.dentry)) | ||
1039 | goto finish; | ||
1040 | |||
1041 | if (!IS_ERR(exp)) { | ||
1042 | /* just a flags/id/fsid update */ | ||
1043 | |||
1044 | exp_fsid_unhash(exp); | ||
1045 | exp->ex_flags = nxp->ex_flags; | ||
1046 | exp->ex_anon_uid = nxp->ex_anon_uid; | ||
1047 | exp->ex_anon_gid = nxp->ex_anon_gid; | ||
1048 | exp->ex_fsid = nxp->ex_dev; | ||
1049 | |||
1050 | err = exp_fsid_hash(clp, exp); | ||
1051 | goto finish; | ||
1052 | } | ||
1053 | |||
1054 | err = check_export(path.dentry->d_inode, &nxp->ex_flags, NULL); | ||
1055 | if (err) goto finish; | ||
1056 | |||
1057 | err = -ENOMEM; | ||
1058 | |||
1059 | dprintk("nfsd: creating export entry %p for client %p\n", exp, clp); | ||
1060 | |||
1061 | new.h.expiry_time = NEVER; | ||
1062 | new.h.flags = 0; | ||
1063 | new.ex_pathname = kstrdup(nxp->ex_path, GFP_KERNEL); | ||
1064 | if (!new.ex_pathname) | ||
1065 | goto finish; | ||
1066 | new.ex_client = clp; | ||
1067 | new.ex_path = path; | ||
1068 | new.ex_flags = nxp->ex_flags; | ||
1069 | new.ex_anon_uid = nxp->ex_anon_uid; | ||
1070 | new.ex_anon_gid = nxp->ex_anon_gid; | ||
1071 | new.ex_fsid = nxp->ex_dev; | ||
1072 | |||
1073 | exp = svc_export_lookup(&new); | ||
1074 | if (exp) | ||
1075 | exp = svc_export_update(&new, exp); | ||
1076 | |||
1077 | if (!exp) | ||
1078 | goto finish; | ||
1079 | |||
1080 | if (exp_hash(clp, exp) || | ||
1081 | exp_fsid_hash(clp, exp)) { | ||
1082 | /* failed to create at least one index */ | ||
1083 | exp_do_unexport(exp); | ||
1084 | cache_flush(); | ||
1085 | } else | ||
1086 | err = 0; | ||
1087 | finish: | ||
1088 | kfree(new.ex_pathname); | ||
1089 | if (!IS_ERR_OR_NULL(exp)) | ||
1090 | exp_put(exp); | ||
1091 | if (!IS_ERR_OR_NULL(fsid_key)) | ||
1092 | cache_put(&fsid_key->h, &svc_expkey_cache); | ||
1093 | path_put(&path); | ||
1094 | out_put_clp: | ||
1095 | auth_domain_put(clp); | ||
1096 | out_unlock: | ||
1097 | exp_writeunlock(); | ||
1098 | out: | ||
1099 | return err; | ||
1100 | } | ||
1101 | |||
1102 | /* | ||
1103 | * Unexport a file system. The export entry has already | ||
1104 | * been removed from the client's list of exported fs's. | ||
1105 | */ | ||
1106 | static void | ||
1107 | exp_do_unexport(svc_export *unexp) | ||
1108 | { | ||
1109 | sunrpc_invalidate(&unexp->h, &svc_export_cache); | ||
1110 | exp_unhash(unexp); | ||
1111 | exp_fsid_unhash(unexp); | ||
1112 | } | ||
1113 | |||
1114 | |||
1115 | /* | ||
1116 | * unexport syscall. | ||
1117 | */ | ||
1118 | int | ||
1119 | exp_unexport(struct nfsctl_export *nxp) | ||
1120 | { | ||
1121 | struct auth_domain *dom; | ||
1122 | svc_export *exp; | ||
1123 | struct path path; | ||
1124 | int err; | ||
1125 | |||
1126 | /* Consistency check */ | ||
1127 | if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) || | ||
1128 | !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX)) | ||
1129 | return -EINVAL; | ||
1130 | |||
1131 | exp_writelock(); | ||
1132 | |||
1133 | err = -EINVAL; | ||
1134 | dom = auth_domain_find(nxp->ex_client); | ||
1135 | if (!dom) { | ||
1136 | dprintk("nfsd: unexport couldn't find %s\n", nxp->ex_client); | ||
1137 | goto out_unlock; | ||
1138 | } | ||
1139 | |||
1140 | err = kern_path(nxp->ex_path, 0, &path); | ||
1141 | if (err) | ||
1142 | goto out_domain; | ||
1143 | |||
1144 | err = -EINVAL; | ||
1145 | exp = exp_get_by_name(dom, &path, NULL); | ||
1146 | path_put(&path); | ||
1147 | if (IS_ERR(exp)) | ||
1148 | goto out_domain; | ||
1149 | |||
1150 | exp_do_unexport(exp); | ||
1151 | exp_put(exp); | ||
1152 | err = 0; | ||
1153 | |||
1154 | out_domain: | ||
1155 | auth_domain_put(dom); | ||
1156 | cache_flush(); | ||
1157 | out_unlock: | ||
1158 | exp_writeunlock(); | ||
1159 | return err; | ||
1160 | } | ||
1161 | #endif /* CONFIG_NFSD_DEPRECATED */ | ||
1162 | 842 | ||
1163 | /* | 843 | /* |
1164 | * Obtain the root fh on behalf of a client. | 844 | * Obtain the root fh on behalf of a client. |
@@ -1367,7 +1047,6 @@ static void *e_start(struct seq_file *m, loff_t *pos) | |||
1367 | unsigned hash, export; | 1047 | unsigned hash, export; |
1368 | struct cache_head *ch; | 1048 | struct cache_head *ch; |
1369 | 1049 | ||
1370 | exp_readlock(); | ||
1371 | read_lock(&svc_export_cache.hash_lock); | 1050 | read_lock(&svc_export_cache.hash_lock); |
1372 | if (!n--) | 1051 | if (!n--) |
1373 | return SEQ_START_TOKEN; | 1052 | return SEQ_START_TOKEN; |
@@ -1418,7 +1097,6 @@ static void e_stop(struct seq_file *m, void *p) | |||
1418 | __releases(svc_export_cache.hash_lock) | 1097 | __releases(svc_export_cache.hash_lock) |
1419 | { | 1098 | { |
1420 | read_unlock(&svc_export_cache.hash_lock); | 1099 | read_unlock(&svc_export_cache.hash_lock); |
1421 | exp_readunlock(); | ||
1422 | } | 1100 | } |
1423 | 1101 | ||
1424 | static struct flags { | 1102 | static struct flags { |
@@ -1550,97 +1228,6 @@ const struct seq_operations nfs_exports_op = { | |||
1550 | .show = e_show, | 1228 | .show = e_show, |
1551 | }; | 1229 | }; |
1552 | 1230 | ||
1553 | #ifdef CONFIG_NFSD_DEPRECATED | ||
1554 | /* | ||
1555 | * Add or modify a client. | ||
1556 | * Change requests may involve the list of host addresses. The list of | ||
1557 | * exports and possibly existing uid maps are left untouched. | ||
1558 | */ | ||
1559 | int | ||
1560 | exp_addclient(struct nfsctl_client *ncp) | ||
1561 | { | ||
1562 | struct auth_domain *dom; | ||
1563 | int i, err; | ||
1564 | struct in6_addr addr6; | ||
1565 | |||
1566 | /* First, consistency check. */ | ||
1567 | err = -EINVAL; | ||
1568 | if (! exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX)) | ||
1569 | goto out; | ||
1570 | if (ncp->cl_naddr > NFSCLNT_ADDRMAX) | ||
1571 | goto out; | ||
1572 | |||
1573 | /* Lock the hashtable */ | ||
1574 | exp_writelock(); | ||
1575 | |||
1576 | dom = unix_domain_find(ncp->cl_ident); | ||
1577 | |||
1578 | err = -ENOMEM; | ||
1579 | if (!dom) | ||
1580 | goto out_unlock; | ||
1581 | |||
1582 | /* Insert client into hashtable. */ | ||
1583 | for (i = 0; i < ncp->cl_naddr; i++) { | ||
1584 | ipv6_addr_set_v4mapped(ncp->cl_addrlist[i].s_addr, &addr6); | ||
1585 | auth_unix_add_addr(&init_net, &addr6, dom); | ||
1586 | } | ||
1587 | auth_unix_forget_old(dom); | ||
1588 | auth_domain_put(dom); | ||
1589 | |||
1590 | err = 0; | ||
1591 | |||
1592 | out_unlock: | ||
1593 | exp_writeunlock(); | ||
1594 | out: | ||
1595 | return err; | ||
1596 | } | ||
1597 | |||
1598 | /* | ||
1599 | * Delete a client given an identifier. | ||
1600 | */ | ||
1601 | int | ||
1602 | exp_delclient(struct nfsctl_client *ncp) | ||
1603 | { | ||
1604 | int err; | ||
1605 | struct auth_domain *dom; | ||
1606 | |||
1607 | err = -EINVAL; | ||
1608 | if (!exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX)) | ||
1609 | goto out; | ||
1610 | |||
1611 | /* Lock the hashtable */ | ||
1612 | exp_writelock(); | ||
1613 | |||
1614 | dom = auth_domain_find(ncp->cl_ident); | ||
1615 | /* just make sure that no addresses work | ||
1616 | * and that it will expire soon | ||
1617 | */ | ||
1618 | if (dom) { | ||
1619 | err = auth_unix_forget_old(dom); | ||
1620 | auth_domain_put(dom); | ||
1621 | } | ||
1622 | |||
1623 | exp_writeunlock(); | ||
1624 | out: | ||
1625 | return err; | ||
1626 | } | ||
1627 | |||
1628 | /* | ||
1629 | * Verify that string is non-empty and does not exceed max length. | ||
1630 | */ | ||
1631 | static int | ||
1632 | exp_verify_string(char *cp, int max) | ||
1633 | { | ||
1634 | int i; | ||
1635 | |||
1636 | for (i = 0; i < max; i++) | ||
1637 | if (!cp[i]) | ||
1638 | return i; | ||
1639 | cp[i] = 0; | ||
1640 | printk(KERN_NOTICE "nfsd: couldn't validate string %s\n", cp); | ||
1641 | return 0; | ||
1642 | } | ||
1643 | #endif /* CONFIG_NFSD_DEPRECATED */ | ||
1644 | 1231 | ||
1645 | /* | 1232 | /* |
1646 | * Initialize the exports module. | 1233 | * Initialize the exports module. |
@@ -1667,10 +1254,8 @@ nfsd_export_init(void) | |||
1667 | void | 1254 | void |
1668 | nfsd_export_flush(void) | 1255 | nfsd_export_flush(void) |
1669 | { | 1256 | { |
1670 | exp_writelock(); | ||
1671 | cache_purge(&svc_expkey_cache); | 1257 | cache_purge(&svc_expkey_cache); |
1672 | cache_purge(&svc_export_cache); | 1258 | cache_purge(&svc_export_cache); |
1673 | exp_writeunlock(); | ||
1674 | } | 1259 | } |
1675 | 1260 | ||
1676 | /* | 1261 | /* |
@@ -1682,12 +1267,9 @@ nfsd_export_shutdown(void) | |||
1682 | 1267 | ||
1683 | dprintk("nfsd: shutting down export module.\n"); | 1268 | dprintk("nfsd: shutting down export module.\n"); |
1684 | 1269 | ||
1685 | exp_writelock(); | ||
1686 | |||
1687 | cache_unregister(&svc_expkey_cache); | 1270 | cache_unregister(&svc_expkey_cache); |
1688 | cache_unregister(&svc_export_cache); | 1271 | cache_unregister(&svc_export_cache); |
1689 | svcauth_unix_purge(); | 1272 | svcauth_unix_purge(); |
1690 | 1273 | ||
1691 | exp_writeunlock(); | ||
1692 | dprintk("nfsd: export shutdown complete.\n"); | 1274 | dprintk("nfsd: export shutdown complete.\n"); |
1693 | } | 1275 | } |
diff --git a/fs/nfsd/lockd.c b/fs/nfsd/lockd.c index 7c831a2731fa..77e7a5cca888 100644 --- a/fs/nfsd/lockd.c +++ b/fs/nfsd/lockd.c | |||
@@ -35,10 +35,8 @@ nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp) | |||
35 | memcpy((char*)&fh.fh_handle.fh_base, f->data, f->size); | 35 | memcpy((char*)&fh.fh_handle.fh_base, f->data, f->size); |
36 | fh.fh_export = NULL; | 36 | fh.fh_export = NULL; |
37 | 37 | ||
38 | exp_readlock(); | ||
39 | nfserr = nfsd_open(rqstp, &fh, S_IFREG, NFSD_MAY_LOCK, filp); | 38 | nfserr = nfsd_open(rqstp, &fh, S_IFREG, NFSD_MAY_LOCK, filp); |
40 | fh_put(&fh); | 39 | fh_put(&fh); |
41 | exp_readunlock(); | ||
42 | /* We return nlm error codes as nlm doesn't know | 40 | /* We return nlm error codes as nlm doesn't know |
43 | * about nfsd, but nfsd does know about nlm.. | 41 | * about nfsd, but nfsd does know about nlm.. |
44 | */ | 42 | */ |
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 2b1449dd2f49..c7716143cbd1 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c | |||
@@ -24,15 +24,6 @@ | |||
24 | */ | 24 | */ |
25 | enum { | 25 | enum { |
26 | NFSD_Root = 1, | 26 | NFSD_Root = 1, |
27 | #ifdef CONFIG_NFSD_DEPRECATED | ||
28 | NFSD_Svc, | ||
29 | NFSD_Add, | ||
30 | NFSD_Del, | ||
31 | NFSD_Export, | ||
32 | NFSD_Unexport, | ||
33 | NFSD_Getfd, | ||
34 | NFSD_Getfs, | ||
35 | #endif | ||
36 | NFSD_List, | 27 | NFSD_List, |
37 | NFSD_Export_features, | 28 | NFSD_Export_features, |
38 | NFSD_Fh, | 29 | NFSD_Fh, |
@@ -59,15 +50,6 @@ enum { | |||
59 | /* | 50 | /* |
60 | * write() for these nodes. | 51 | * write() for these nodes. |
61 | */ | 52 | */ |
62 | #ifdef CONFIG_NFSD_DEPRECATED | ||
63 | static ssize_t write_svc(struct file *file, char *buf, size_t size); | ||
64 | static ssize_t write_add(struct file *file, char *buf, size_t size); | ||
65 | static ssize_t write_del(struct file *file, char *buf, size_t size); | ||
66 | static ssize_t write_export(struct file *file, char *buf, size_t size); | ||
67 | static ssize_t write_unexport(struct file *file, char *buf, size_t size); | ||
68 | static ssize_t write_getfd(struct file *file, char *buf, size_t size); | ||
69 | static ssize_t write_getfs(struct file *file, char *buf, size_t size); | ||
70 | #endif | ||
71 | static ssize_t write_filehandle(struct file *file, char *buf, size_t size); | 53 | static ssize_t write_filehandle(struct file *file, char *buf, size_t size); |
72 | static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size); | 54 | static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size); |
73 | static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size); | 55 | static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size); |
@@ -83,15 +65,6 @@ static ssize_t write_recoverydir(struct file *file, char *buf, size_t size); | |||
83 | #endif | 65 | #endif |
84 | 66 | ||
85 | static ssize_t (*write_op[])(struct file *, char *, size_t) = { | 67 | static ssize_t (*write_op[])(struct file *, char *, size_t) = { |
86 | #ifdef CONFIG_NFSD_DEPRECATED | ||
87 | [NFSD_Svc] = write_svc, | ||
88 | [NFSD_Add] = write_add, | ||
89 | [NFSD_Del] = write_del, | ||
90 | [NFSD_Export] = write_export, | ||
91 | [NFSD_Unexport] = write_unexport, | ||
92 | [NFSD_Getfd] = write_getfd, | ||
93 | [NFSD_Getfs] = write_getfs, | ||
94 | #endif | ||
95 | [NFSD_Fh] = write_filehandle, | 68 | [NFSD_Fh] = write_filehandle, |
96 | [NFSD_FO_UnlockIP] = write_unlock_ip, | 69 | [NFSD_FO_UnlockIP] = write_unlock_ip, |
97 | [NFSD_FO_UnlockFS] = write_unlock_fs, | 70 | [NFSD_FO_UnlockFS] = write_unlock_fs, |
@@ -130,16 +103,6 @@ static ssize_t nfsctl_transaction_write(struct file *file, const char __user *bu | |||
130 | 103 | ||
131 | static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) | 104 | static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) |
132 | { | 105 | { |
133 | #ifdef CONFIG_NFSD_DEPRECATED | ||
134 | static int warned; | ||
135 | if (file->f_dentry->d_name.name[0] == '.' && !warned) { | ||
136 | printk(KERN_INFO | ||
137 | "Warning: \"%s\" uses deprecated NFSD interface: %s." | ||
138 | " This will be removed in 2.6.40\n", | ||
139 | current->comm, file->f_dentry->d_name.name); | ||
140 | warned = 1; | ||
141 | } | ||
142 | #endif | ||
143 | if (! file->private_data) { | 106 | if (! file->private_data) { |
144 | /* An attempt to read a transaction file without writing | 107 | /* An attempt to read a transaction file without writing |
145 | * causes a 0-byte write so that the file can return | 108 | * causes a 0-byte write so that the file can return |
@@ -226,303 +189,6 @@ static const struct file_operations pool_stats_operations = { | |||
226 | * payload - write methods | 189 | * payload - write methods |
227 | */ | 190 | */ |
228 | 191 | ||
229 | #ifdef CONFIG_NFSD_DEPRECATED | ||
230 | /** | ||
231 | * write_svc - Start kernel's NFSD server | ||
232 | * | ||
233 | * Deprecated. /proc/fs/nfsd/threads is preferred. | ||
234 | * Function remains to support old versions of nfs-utils. | ||
235 | * | ||
236 | * Input: | ||
237 | * buf: struct nfsctl_svc | ||
238 | * svc_port: port number of this | ||
239 | * server's listener | ||
240 | * svc_nthreads: number of threads to start | ||
241 | * size: size in bytes of passed in nfsctl_svc | ||
242 | * Output: | ||
243 | * On success: returns zero | ||
244 | * On error: return code is negative errno value | ||
245 | */ | ||
246 | static ssize_t write_svc(struct file *file, char *buf, size_t size) | ||
247 | { | ||
248 | struct nfsctl_svc *data; | ||
249 | int err; | ||
250 | if (size < sizeof(*data)) | ||
251 | return -EINVAL; | ||
252 | data = (struct nfsctl_svc*) buf; | ||
253 | err = nfsd_svc(data->svc_port, data->svc_nthreads); | ||
254 | if (err < 0) | ||
255 | return err; | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | /** | ||
260 | * write_add - Add or modify client entry in auth unix cache | ||
261 | * | ||
262 | * Deprecated. /proc/net/rpc/auth.unix.ip is preferred. | ||
263 | * Function remains to support old versions of nfs-utils. | ||
264 | * | ||
265 | * Input: | ||
266 | * buf: struct nfsctl_client | ||
267 | * cl_ident: '\0'-terminated C string | ||
268 | * containing domain name | ||
269 | * of client | ||
270 | * cl_naddr: no. of items in cl_addrlist | ||
271 | * cl_addrlist: array of client addresses | ||
272 | * cl_fhkeytype: ignored | ||
273 | * cl_fhkeylen: ignored | ||
274 | * cl_fhkey: ignored | ||
275 | * size: size in bytes of passed in nfsctl_client | ||
276 | * Output: | ||
277 | * On success: returns zero | ||
278 | * On error: return code is negative errno value | ||
279 | * | ||
280 | * Note: Only AF_INET client addresses are passed in, since | ||
281 | * nfsctl_client.cl_addrlist contains only in_addr fields for addresses. | ||
282 | */ | ||
283 | static ssize_t write_add(struct file *file, char *buf, size_t size) | ||
284 | { | ||
285 | struct nfsctl_client *data; | ||
286 | if (size < sizeof(*data)) | ||
287 | return -EINVAL; | ||
288 | data = (struct nfsctl_client *)buf; | ||
289 | return exp_addclient(data); | ||
290 | } | ||
291 | |||
292 | /** | ||
293 | * write_del - Remove client from auth unix cache | ||
294 | * | ||
295 | * Deprecated. /proc/net/rpc/auth.unix.ip is preferred. | ||
296 | * Function remains to support old versions of nfs-utils. | ||
297 | * | ||
298 | * Input: | ||
299 | * buf: struct nfsctl_client | ||
300 | * cl_ident: '\0'-terminated C string | ||
301 | * containing domain name | ||
302 | * of client | ||
303 | * cl_naddr: ignored | ||
304 | * cl_addrlist: ignored | ||
305 | * cl_fhkeytype: ignored | ||
306 | * cl_fhkeylen: ignored | ||
307 | * cl_fhkey: ignored | ||
308 | * size: size in bytes of passed in nfsctl_client | ||
309 | * Output: | ||
310 | * On success: returns zero | ||
311 | * On error: return code is negative errno value | ||
312 | * | ||
313 | * Note: Only AF_INET client addresses are passed in, since | ||
314 | * nfsctl_client.cl_addrlist contains only in_addr fields for addresses. | ||
315 | */ | ||
316 | static ssize_t write_del(struct file *file, char *buf, size_t size) | ||
317 | { | ||
318 | struct nfsctl_client *data; | ||
319 | if (size < sizeof(*data)) | ||
320 | return -EINVAL; | ||
321 | data = (struct nfsctl_client *)buf; | ||
322 | return exp_delclient(data); | ||
323 | } | ||
324 | |||
325 | /** | ||
326 | * write_export - Export part or all of a local file system | ||
327 | * | ||
328 | * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred. | ||
329 | * Function remains to support old versions of nfs-utils. | ||
330 | * | ||
331 | * Input: | ||
332 | * buf: struct nfsctl_export | ||
333 | * ex_client: '\0'-terminated C string | ||
334 | * containing domain name | ||
335 | * of client allowed to access | ||
336 | * this export | ||
337 | * ex_path: '\0'-terminated C string | ||
338 | * containing pathname of | ||
339 | * directory in local file system | ||
340 | * ex_dev: fsid to use for this export | ||
341 | * ex_ino: ignored | ||
342 | * ex_flags: export flags for this export | ||
343 | * ex_anon_uid: UID to use for anonymous | ||
344 | * requests | ||
345 | * ex_anon_gid: GID to use for anonymous | ||
346 | * requests | ||
347 | * size: size in bytes of passed in nfsctl_export | ||
348 | * Output: | ||
349 | * On success: returns zero | ||
350 | * On error: return code is negative errno value | ||
351 | */ | ||
352 | static ssize_t write_export(struct file *file, char *buf, size_t size) | ||
353 | { | ||
354 | struct nfsctl_export *data; | ||
355 | if (size < sizeof(*data)) | ||
356 | return -EINVAL; | ||
357 | data = (struct nfsctl_export*)buf; | ||
358 | return exp_export(data); | ||
359 | } | ||
360 | |||
361 | /** | ||
362 | * write_unexport - Unexport a previously exported file system | ||
363 | * | ||
364 | * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred. | ||
365 | * Function remains to support old versions of nfs-utils. | ||
366 | * | ||
367 | * Input: | ||
368 | * buf: struct nfsctl_export | ||
369 | * ex_client: '\0'-terminated C string | ||
370 | * containing domain name | ||
371 | * of client no longer allowed | ||
372 | * to access this export | ||
373 | * ex_path: '\0'-terminated C string | ||
374 | * containing pathname of | ||
375 | * directory in local file system | ||
376 | * ex_dev: ignored | ||
377 | * ex_ino: ignored | ||
378 | * ex_flags: ignored | ||
379 | * ex_anon_uid: ignored | ||
380 | * ex_anon_gid: ignored | ||
381 | * size: size in bytes of passed in nfsctl_export | ||
382 | * Output: | ||
383 | * On success: returns zero | ||
384 | * On error: return code is negative errno value | ||
385 | */ | ||
386 | static ssize_t write_unexport(struct file *file, char *buf, size_t size) | ||
387 | { | ||
388 | struct nfsctl_export *data; | ||
389 | |||
390 | if (size < sizeof(*data)) | ||
391 | return -EINVAL; | ||
392 | data = (struct nfsctl_export*)buf; | ||
393 | return exp_unexport(data); | ||
394 | } | ||
395 | |||
396 | /** | ||
397 | * write_getfs - Get a variable-length NFS file handle by path | ||
398 | * | ||
399 | * Deprecated. /proc/fs/nfsd/filehandle is preferred. | ||
400 | * Function remains to support old versions of nfs-utils. | ||
401 | * | ||
402 | * Input: | ||
403 | * buf: struct nfsctl_fsparm | ||
404 | * gd_addr: socket address of client | ||
405 | * gd_path: '\0'-terminated C string | ||
406 | * containing pathname of | ||
407 | * directory in local file system | ||
408 | * gd_maxlen: maximum size of returned file | ||
409 | * handle | ||
410 | * size: size in bytes of passed in nfsctl_fsparm | ||
411 | * Output: | ||
412 | * On success: passed-in buffer filled with a knfsd_fh structure | ||
413 | * (a variable-length raw NFS file handle); | ||
414 | * return code is the size in bytes of the file handle | ||
415 | * On error: return code is negative errno value | ||
416 | * | ||
417 | * Note: Only AF_INET client addresses are passed in, since gd_addr | ||
418 | * is the same size as a struct sockaddr_in. | ||
419 | */ | ||
420 | static ssize_t write_getfs(struct file *file, char *buf, size_t size) | ||
421 | { | ||
422 | struct nfsctl_fsparm *data; | ||
423 | struct sockaddr_in *sin; | ||
424 | struct auth_domain *clp; | ||
425 | int err = 0; | ||
426 | struct knfsd_fh *res; | ||
427 | struct in6_addr in6; | ||
428 | |||
429 | if (size < sizeof(*data)) | ||
430 | return -EINVAL; | ||
431 | data = (struct nfsctl_fsparm*)buf; | ||
432 | err = -EPROTONOSUPPORT; | ||
433 | if (data->gd_addr.sa_family != AF_INET) | ||
434 | goto out; | ||
435 | sin = (struct sockaddr_in *)&data->gd_addr; | ||
436 | if (data->gd_maxlen > NFS3_FHSIZE) | ||
437 | data->gd_maxlen = NFS3_FHSIZE; | ||
438 | |||
439 | res = (struct knfsd_fh*)buf; | ||
440 | |||
441 | exp_readlock(); | ||
442 | |||
443 | ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); | ||
444 | |||
445 | clp = auth_unix_lookup(&init_net, &in6); | ||
446 | if (!clp) | ||
447 | err = -EPERM; | ||
448 | else { | ||
449 | err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen); | ||
450 | auth_domain_put(clp); | ||
451 | } | ||
452 | exp_readunlock(); | ||
453 | if (err == 0) | ||
454 | err = res->fh_size + offsetof(struct knfsd_fh, fh_base); | ||
455 | out: | ||
456 | return err; | ||
457 | } | ||
458 | |||
459 | /** | ||
460 | * write_getfd - Get a fixed-length NFS file handle by path (used by mountd) | ||
461 | * | ||
462 | * Deprecated. /proc/fs/nfsd/filehandle is preferred. | ||
463 | * Function remains to support old versions of nfs-utils. | ||
464 | * | ||
465 | * Input: | ||
466 | * buf: struct nfsctl_fdparm | ||
467 | * gd_addr: socket address of client | ||
468 | * gd_path: '\0'-terminated C string | ||
469 | * containing pathname of | ||
470 | * directory in local file system | ||
471 | * gd_version: fdparm structure version | ||
472 | * size: size in bytes of passed in nfsctl_fdparm | ||
473 | * Output: | ||
474 | * On success: passed-in buffer filled with nfsctl_res | ||
475 | * (a fixed-length raw NFS file handle); | ||
476 | * return code is the size in bytes of the file handle | ||
477 | * On error: return code is negative errno value | ||
478 | * | ||
479 | * Note: Only AF_INET client addresses are passed in, since gd_addr | ||
480 | * is the same size as a struct sockaddr_in. | ||
481 | */ | ||
482 | static ssize_t write_getfd(struct file *file, char *buf, size_t size) | ||
483 | { | ||
484 | struct nfsctl_fdparm *data; | ||
485 | struct sockaddr_in *sin; | ||
486 | struct auth_domain *clp; | ||
487 | int err = 0; | ||
488 | struct knfsd_fh fh; | ||
489 | char *res; | ||
490 | struct in6_addr in6; | ||
491 | |||
492 | if (size < sizeof(*data)) | ||
493 | return -EINVAL; | ||
494 | data = (struct nfsctl_fdparm*)buf; | ||
495 | err = -EPROTONOSUPPORT; | ||
496 | if (data->gd_addr.sa_family != AF_INET) | ||
497 | goto out; | ||
498 | err = -EINVAL; | ||
499 | if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS) | ||
500 | goto out; | ||
501 | |||
502 | res = buf; | ||
503 | sin = (struct sockaddr_in *)&data->gd_addr; | ||
504 | exp_readlock(); | ||
505 | |||
506 | ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); | ||
507 | |||
508 | clp = auth_unix_lookup(&init_net, &in6); | ||
509 | if (!clp) | ||
510 | err = -EPERM; | ||
511 | else { | ||
512 | err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE); | ||
513 | auth_domain_put(clp); | ||
514 | } | ||
515 | exp_readunlock(); | ||
516 | |||
517 | if (err == 0) { | ||
518 | memset(res,0, NFS_FHSIZE); | ||
519 | memcpy(res, &fh.fh_base, fh.fh_size); | ||
520 | err = NFS_FHSIZE; | ||
521 | } | ||
522 | out: | ||
523 | return err; | ||
524 | } | ||
525 | #endif /* CONFIG_NFSD_DEPRECATED */ | ||
526 | 192 | ||
527 | /** | 193 | /** |
528 | * write_unlock_ip - Release all locks used by a client | 194 | * write_unlock_ip - Release all locks used by a client |
@@ -1397,15 +1063,6 @@ static ssize_t write_recoverydir(struct file *file, char *buf, size_t size) | |||
1397 | static int nfsd_fill_super(struct super_block * sb, void * data, int silent) | 1063 | static int nfsd_fill_super(struct super_block * sb, void * data, int silent) |
1398 | { | 1064 | { |
1399 | static struct tree_descr nfsd_files[] = { | 1065 | static struct tree_descr nfsd_files[] = { |
1400 | #ifdef CONFIG_NFSD_DEPRECATED | ||
1401 | [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR}, | ||
1402 | [NFSD_Add] = {".add", &transaction_ops, S_IWUSR}, | ||
1403 | [NFSD_Del] = {".del", &transaction_ops, S_IWUSR}, | ||
1404 | [NFSD_Export] = {".export", &transaction_ops, S_IWUSR}, | ||
1405 | [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR}, | ||
1406 | [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR}, | ||
1407 | [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR}, | ||
1408 | #endif | ||
1409 | [NFSD_List] = {"exports", &exports_operations, S_IRUGO}, | 1066 | [NFSD_List] = {"exports", &exports_operations, S_IRUGO}, |
1410 | [NFSD_Export_features] = {"export_features", | 1067 | [NFSD_Export_features] = {"export_features", |
1411 | &export_features_operations, S_IRUGO}, | 1068 | &export_features_operations, S_IRUGO}, |
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c index 18743c4d8bca..bb8397f9da25 100644 --- a/fs/nfsd/nfssvc.c +++ b/fs/nfsd/nfssvc.c | |||
@@ -528,16 +528,9 @@ nfsd(void *vrqstp) | |||
528 | continue; | 528 | continue; |
529 | } | 529 | } |
530 | 530 | ||
531 | |||
532 | /* Lock the export hash tables for reading. */ | ||
533 | exp_readlock(); | ||
534 | |||
535 | validate_process_creds(); | 531 | validate_process_creds(); |
536 | svc_process(rqstp); | 532 | svc_process(rqstp); |
537 | validate_process_creds(); | 533 | validate_process_creds(); |
538 | |||
539 | /* Unlock export hash tables */ | ||
540 | exp_readunlock(); | ||
541 | } | 534 | } |
542 | 535 | ||
543 | /* Clear signals before calling svc_exit_thread() */ | 536 | /* Clear signals before calling svc_exit_thread() */ |