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.

rpc_mkpipe_dentry(): saner calling conventions

Instead of returning a dentry or ERR_PTR(-E...), return 0 and store
dentry into pipe->dentry on success and return -E... on failure.

Callers are happier that way...

NOTE: dummy rpc_pipe is getting ->dentry set; we never access that,
since we
1) never call rpc_unlink() for it (dentry is taken out by
->kill_sb())
2) never call rpc_queue_upcall() for it (writing to that
sucker fails; no downcalls are ever submitted, so no replies are
going to arrive)
IOW, having that ->dentry set (and left dangling) is harmless,
if ugly; cleaner solution will take more massage.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Al Viro 19a6314a bccea4ed

+45 -79
+16 -25
fs/nfs/blocklayout/rpc_pipefs.c
··· 141 141 .destroy_msg = bl_pipe_destroy_msg, 142 142 }; 143 143 144 - static struct dentry *nfs4blocklayout_register_sb(struct super_block *sb, 144 + static int nfs4blocklayout_register_sb(struct super_block *sb, 145 145 struct rpc_pipe *pipe) 146 146 { 147 - struct dentry *dir, *dentry; 147 + struct dentry *dir; 148 + int err; 148 149 149 150 dir = rpc_d_lookup_sb(sb, NFS_PIPE_DIRNAME); 150 151 if (dir == NULL) 151 - return ERR_PTR(-ENOENT); 152 - dentry = rpc_mkpipe_dentry(dir, "blocklayout", NULL, pipe); 152 + return -ENOENT; 153 + err = rpc_mkpipe_dentry(dir, "blocklayout", NULL, pipe); 153 154 dput(dir); 154 - return dentry; 155 + return err; 155 156 } 156 157 157 158 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event, ··· 161 160 struct super_block *sb = ptr; 162 161 struct net *net = sb->s_fs_info; 163 162 struct nfs_net *nn = net_generic(net, nfs_net_id); 164 - struct dentry *dentry; 165 163 int ret = 0; 166 164 167 165 if (!try_module_get(THIS_MODULE)) ··· 173 173 174 174 switch (event) { 175 175 case RPC_PIPEFS_MOUNT: 176 - dentry = nfs4blocklayout_register_sb(sb, nn->bl_device_pipe); 177 - if (IS_ERR(dentry)) { 178 - ret = PTR_ERR(dentry); 179 - break; 180 - } 181 - nn->bl_device_pipe->dentry = dentry; 176 + ret = nfs4blocklayout_register_sb(sb, nn->bl_device_pipe); 182 177 break; 183 178 case RPC_PIPEFS_UMOUNT: 184 179 rpc_unlink(nn->bl_device_pipe); ··· 190 195 .notifier_call = rpc_pipefs_event, 191 196 }; 192 197 193 - static struct dentry *nfs4blocklayout_register_net(struct net *net, 194 - struct rpc_pipe *pipe) 198 + static int nfs4blocklayout_register_net(struct net *net, struct rpc_pipe *pipe) 195 199 { 196 200 struct super_block *pipefs_sb; 197 - struct dentry *dentry; 201 + int ret; 198 202 199 203 pipefs_sb = rpc_get_sb_net(net); 200 204 if (!pipefs_sb) 201 - return NULL; 202 - dentry = nfs4blocklayout_register_sb(pipefs_sb, pipe); 205 + return 0; 206 + ret = nfs4blocklayout_register_sb(pipefs_sb, pipe); 203 207 rpc_put_sb_net(net); 204 - return dentry; 208 + return ret; 205 209 } 206 210 207 211 static void nfs4blocklayout_unregister_net(struct net *net, ··· 218 224 static int nfs4blocklayout_net_init(struct net *net) 219 225 { 220 226 struct nfs_net *nn = net_generic(net, nfs_net_id); 221 - struct dentry *dentry; 227 + int err; 222 228 223 229 mutex_init(&nn->bl_mutex); 224 230 init_waitqueue_head(&nn->bl_wq); 225 231 nn->bl_device_pipe = rpc_mkpipe_data(&bl_upcall_ops, 0); 226 232 if (IS_ERR(nn->bl_device_pipe)) 227 233 return PTR_ERR(nn->bl_device_pipe); 228 - dentry = nfs4blocklayout_register_net(net, nn->bl_device_pipe); 229 - if (IS_ERR(dentry)) { 234 + err = nfs4blocklayout_register_net(net, nn->bl_device_pipe); 235 + if (unlikely(err)) 230 236 rpc_destroy_pipe_data(nn->bl_device_pipe); 231 - return PTR_ERR(dentry); 232 - } 233 - nn->bl_device_pipe->dentry = dentry; 234 - return 0; 237 + return err; 235 238 } 236 239 237 240 static void nfs4blocklayout_net_exit(struct net *net)
+1 -7
fs/nfs/nfs4idmap.c
··· 432 432 struct rpc_pipe_dir_object *pdo) 433 433 { 434 434 struct idmap *idmap = pdo->pdo_data; 435 - struct rpc_pipe *pipe = idmap->idmap_pipe; 436 - struct dentry *dentry; 437 435 438 - dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe); 439 - if (IS_ERR(dentry)) 440 - return PTR_ERR(dentry); 441 - pipe->dentry = dentry; 442 - return 0; 436 + return rpc_mkpipe_dentry(dir, "idmap", idmap, idmap->idmap_pipe); 443 437 } 444 438 445 439 static const struct rpc_pipe_dir_object_ops nfs_idmap_pipe_dir_object_ops = {
+14 -23
fs/nfsd/nfs4recover.c
··· 950 950 .destroy_msg = cld_pipe_destroy_msg, 951 951 }; 952 952 953 - static struct dentry * 953 + static int 954 954 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe) 955 955 { 956 - struct dentry *dir, *dentry; 956 + struct dentry *dir; 957 + int err; 957 958 958 959 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR); 959 960 if (dir == NULL) 960 - return ERR_PTR(-ENOENT); 961 - dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe); 961 + return -ENOENT; 962 + err = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe); 962 963 dput(dir); 963 - return dentry; 964 + return err; 964 965 } 965 966 966 - static struct dentry * 967 + static int 967 968 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe) 968 969 { 969 970 struct super_block *sb; 970 - struct dentry *dentry; 971 + int err; 971 972 972 973 sb = rpc_get_sb_net(net); 973 974 if (!sb) 974 - return NULL; 975 - dentry = nfsd4_cld_register_sb(sb, pipe); 975 + return 0; 976 + err = nfsd4_cld_register_sb(sb, pipe); 976 977 rpc_put_sb_net(net); 977 - return dentry; 978 + return err; 978 979 } 979 980 980 981 static void ··· 995 994 __nfsd4_init_cld_pipe(struct net *net) 996 995 { 997 996 int ret; 998 - struct dentry *dentry; 999 997 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1000 998 struct cld_net *cn; 1001 999 ··· 1015 1015 spin_lock_init(&cn->cn_lock); 1016 1016 INIT_LIST_HEAD(&cn->cn_list); 1017 1017 1018 - dentry = nfsd4_cld_register_net(net, cn->cn_pipe); 1019 - if (IS_ERR(dentry)) { 1020 - ret = PTR_ERR(dentry); 1018 + ret = nfsd4_cld_register_net(net, cn->cn_pipe); 1019 + if (unlikely(ret)) 1021 1020 goto err_destroy_data; 1022 - } 1023 1021 1024 - cn->cn_pipe->dentry = dentry; 1025 1022 #ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING 1026 1023 cn->cn_has_legacy = false; 1027 1024 #endif ··· 2111 2114 struct net *net = sb->s_fs_info; 2112 2115 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2113 2116 struct cld_net *cn = nn->cld_net; 2114 - struct dentry *dentry; 2115 2117 int ret = 0; 2116 2118 2117 2119 if (!try_module_get(THIS_MODULE)) ··· 2123 2127 2124 2128 switch (event) { 2125 2129 case RPC_PIPEFS_MOUNT: 2126 - dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe); 2127 - if (IS_ERR(dentry)) { 2128 - ret = PTR_ERR(dentry); 2129 - break; 2130 - } 2131 - cn->cn_pipe->dentry = dentry; 2130 + ret = nfsd4_cld_register_sb(sb, cn->cn_pipe); 2132 2131 break; 2133 2132 case RPC_PIPEFS_UMOUNT: 2134 2133 rpc_unlink(cn->cn_pipe);
+1 -1
include/linux/sunrpc/rpc_pipe_fs.h
··· 127 127 128 128 struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags); 129 129 void rpc_destroy_pipe_data(struct rpc_pipe *pipe); 130 - extern struct dentry *rpc_mkpipe_dentry(struct dentry *, const char *, void *, 130 + extern int rpc_mkpipe_dentry(struct dentry *, const char *, void *, 131 131 struct rpc_pipe *); 132 132 extern void rpc_unlink(struct rpc_pipe *); 133 133 extern int register_rpc_pipefs(void);
+1 -6
net/sunrpc/auth_gss/auth_gss.c
··· 895 895 struct rpc_pipe_dir_object *pdo) 896 896 { 897 897 struct gss_pipe *p = pdo->pdo_data; 898 - struct dentry *dentry; 899 898 900 - dentry = rpc_mkpipe_dentry(dir, p->name, p->clnt, p->pipe); 901 - if (IS_ERR(dentry)) 902 - return PTR_ERR(dentry); 903 - p->pipe->dentry = dentry; 904 - return 0; 899 + return rpc_mkpipe_dentry(dir, p->name, p->clnt, p->pipe); 905 900 } 906 901 907 902 static const struct rpc_pipe_dir_object_ops gss_pipe_dir_object_ops = {
+12 -17
net/sunrpc/rpc_pipe.c
··· 702 702 * The @private argument passed here will be available to all these methods 703 703 * from the file pointer, via RPC_I(file_inode(file))->private. 704 704 */ 705 - struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name, 705 + int rpc_mkpipe_dentry(struct dentry *parent, const char *name, 706 706 void *private, struct rpc_pipe *pipe) 707 707 { 708 708 struct dentry *dentry; ··· 717 717 718 718 inode_lock_nested(dir, I_MUTEX_PARENT); 719 719 dentry = __rpc_lookup_create_exclusive(parent, name); 720 - if (IS_ERR(dentry)) 721 - goto out; 720 + if (IS_ERR(dentry)) { 721 + inode_unlock(dir); 722 + return PTR_ERR(dentry); 723 + } 722 724 err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops, 723 725 private, pipe); 724 - if (err) 725 - goto out_err; 726 - out: 726 + if (unlikely(err)) 727 + pr_warn("%s() failed to create pipe %pd/%s (errno = %d)\n", 728 + __func__, parent, name, err); 729 + else 730 + pipe->dentry = dentry; 727 731 inode_unlock(dir); 728 - return dentry; 729 - out_err: 730 - dentry = ERR_PTR(err); 731 - printk(KERN_WARNING "%s: %s() failed to create pipe %pd/%s (errno = %d)\n", 732 - __FILE__, __func__, parent, name, 733 - err); 734 - goto out; 732 + return err; 735 733 } 736 734 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry); 737 735 ··· 1183 1185 int ret = 0; 1184 1186 struct dentry *gssd_dentry; 1185 1187 struct dentry *clnt_dentry = NULL; 1186 - struct dentry *pipe_dentry = NULL; 1187 1188 1188 1189 /* We should never get this far if "gssd" doesn't exist */ 1189 1190 gssd_dentry = try_lookup_noperm(&QSTR(files[RPCAUTH_gssd].name), root); ··· 1206 1209 dput(clnt_dentry); 1207 1210 return ret; 1208 1211 } 1209 - pipe_dentry = rpc_mkpipe_dentry(clnt_dentry, "gssd", NULL, pipe_data); 1212 + ret = rpc_mkpipe_dentry(clnt_dentry, "gssd", NULL, pipe_data); 1210 1213 dput(clnt_dentry); 1211 - if (IS_ERR(pipe_dentry)) 1212 - ret = PTR_ERR(pipe_dentry); 1213 1214 return ret; 1214 1215 } 1215 1216