change wifi driver to cypress

hc

2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390

 kernel/fs/nfs/getroot.c
..
..
@@ -1,12 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /* getroot.c: get the root dentry for an NFS mount
2
3
  *
3
4
  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4
5
  * Written by David Howells (dhowells@redhat.com)
5
- *
6
- * This program is free software; you can redistribute it and/or
7
- * modify it under the terms of the GNU General Public License
8
- * as published by the Free Software Foundation; either version
9
- * 2 of the License, or (at your option) any later version.
10
6
  */
11
7
 
12
8
 #include <linux/module.h>
..
..
@@ -68,66 +64,102 @@
68
64
 /*
69
65
  * get an NFS2/NFS3 root dentry from the root filehandle
70
66
  */
71
-struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
72
-			    const char *devname)
67
+int nfs_get_root(struct super_block *s, struct fs_context *fc)
73
68
 {
74
-	struct nfs_server *server = NFS_SB(sb);
69
+	struct nfs_fs_context *ctx = nfs_fc2context(fc);
70
+	struct nfs_server *server = NFS_SB(s);
75
71
 	struct nfs_fsinfo fsinfo;
76
-	struct dentry *ret;
72
+	struct dentry *root;
77
73
 	struct inode *inode;
78
-	void *name = kstrdup(devname, GFP_KERNEL);
79
-	int error;
74
+	char *name;
75
+	int error = -ENOMEM;
76
+	unsigned long kflags = 0, kflags_out = 0;
80
77
 
78
+	name = kstrdup(fc->source, GFP_KERNEL);
81
79
 	if (!name)
82
-		return ERR_PTR(-ENOMEM);
80
+		goto out;
83
81
 
84
82
 	/* get the actual root for this mount */
85
83
 	fsinfo.fattr = nfs_alloc_fattr();
86
-	if (fsinfo.fattr == NULL) {
87
-		kfree(name);
88
-		return ERR_PTR(-ENOMEM);
89
-	}
84
+	if (fsinfo.fattr == NULL)
85
+		goto out_name;
90
86
 
91
-	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
87
+	fsinfo.fattr->label = nfs4_label_alloc(server, GFP_KERNEL);
88
+	if (IS_ERR(fsinfo.fattr->label))
89
+		goto out_fattr;
90
+	error = server->nfs_client->rpc_ops->getroot(server, ctx->mntfh, &fsinfo);
92
91
 	if (error < 0) {
93
92
 		dprintk("nfs_get_root: getattr error = %d\n", -error);
94
-		ret = ERR_PTR(error);
95
-		goto out;
93
+		nfs_errorf(fc, "NFS: Couldn't getattr on root");
94
+		goto out_label;
96
95
 	}
97
96
 
98
-	inode = nfs_fhget(sb, mntfh, fsinfo.fattr, NULL);
97
+	inode = nfs_fhget(s, ctx->mntfh, fsinfo.fattr, NULL);
99
98
 	if (IS_ERR(inode)) {
100
99
 		dprintk("nfs_get_root: get root inode failed\n");
101
-		ret = ERR_CAST(inode);
102
-		goto out;
100
+		error = PTR_ERR(inode);
101
+		nfs_errorf(fc, "NFS: Couldn't get root inode");
102
+		goto out_label;
103
103
 	}
104
104
 
105
-	error = nfs_superblock_set_dummy_root(sb, inode);
106
-	if (error != 0) {
107
-		ret = ERR_PTR(error);
108
-		goto out;
109
-	}
105
+	error = nfs_superblock_set_dummy_root(s, inode);
106
+	if (error != 0)
107
+		goto out_label;
110
108
 
111
109
 	/* root dentries normally start off anonymous and get spliced in later
112
110
 	 * if the dentry tree reaches them; however if the dentry already
113
111
 	 * exists, we'll pick it up at this point and use it as the root
114
112
 	 */
115
-	ret = d_obtain_root(inode);
116
-	if (IS_ERR(ret)) {
113
+	root = d_obtain_root(inode);
114
+	if (IS_ERR(root)) {
117
115
 		dprintk("nfs_get_root: get root dentry failed\n");
118
-		goto out;
116
+		error = PTR_ERR(root);
117
+		nfs_errorf(fc, "NFS: Couldn't get root dentry");
118
+		goto out_label;
119
119
 	}
120
120
 
121
-	security_d_instantiate(ret, inode);
122
-	spin_lock(&ret->d_lock);
123
-	if (IS_ROOT(ret) && !ret->d_fsdata &&
124
-	    !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
125
-		ret->d_fsdata = name;
121
+	security_d_instantiate(root, inode);
122
+	spin_lock(&root->d_lock);
123
+	if (IS_ROOT(root) && !root->d_fsdata &&
124
+	    !(root->d_flags & DCACHE_NFSFS_RENAMED)) {
125
+		root->d_fsdata = name;
126
126
 		name = NULL;
127
127
 	}
128
-	spin_unlock(&ret->d_lock);
129
-out:
130
-	kfree(name);
128
+	spin_unlock(&root->d_lock);
129
+	fc->root = root;
130
+	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL)
131
+		kflags |= SECURITY_LSM_NATIVE_LABELS;
132
+	if (ctx->clone_data.sb) {
133
+		if (d_inode(fc->root)->i_fop != &nfs_dir_operations) {
134
+			error = -ESTALE;
135
+			goto error_splat_root;
136
+		}
137
+		/* clone lsm security options from the parent to the new sb */
138
+		error = security_sb_clone_mnt_opts(ctx->clone_data.sb,
139
+						   s, kflags, &kflags_out);
140
+	} else {
141
+		error = security_sb_set_mnt_opts(s, fc->security,
142
+							kflags, &kflags_out);
143
+	}
144
+	if (error)
145
+		goto error_splat_root;
146
+	if (NFS_SB(s)->caps & NFS_CAP_SECURITY_LABEL &&
147
+		!(kflags_out & SECURITY_LSM_NATIVE_LABELS))
148
+		NFS_SB(s)->caps &= ~NFS_CAP_SECURITY_LABEL;
149
+
150
+	nfs_setsecurity(inode, fsinfo.fattr, fsinfo.fattr->label);
151
+	error = 0;
152
+
153
+out_label:
154
+	nfs4_label_free(fsinfo.fattr->label);
155
+out_fattr:
131
156
 	nfs_free_fattr(fsinfo.fattr);
132
-	return ret;
157
+out_name:
158
+	kfree(name);
159
+out:
160
+	return error;
161
+error_splat_root:
162
+	dput(fc->root);
163
+	fc->root = NULL;
164
+	goto out_label;
133
165
 }