Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit 3d72ab8fdd44c872633b210dd1a4afd2910d0bbb

Authored by Chuck Lever
Committed by J. Bruce Fields
1 parent 017cb47f46
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

NFSD: Stricter buffer size checking in write_recoverydir() 

While it's not likely a pathname will be longer than
SIMPLE_TRANSACTION_SIZE, we should be more careful about just
plopping it into the output buffer without bounds checking.

Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>

Showing 1 changed file with 3 additions and 2 deletions Inline Diff

1 /* 1 /*
2 * linux/fs/nfsd/nfsctl.c 2 * linux/fs/nfsd/nfsctl.c
3 * 3 *
4 * Syscall interface to knfsd. 4 * Syscall interface to knfsd.
5 * 5 *
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 */ 7 */
8 8
9 #include <linux/module.h> 9 #include <linux/module.h>
10 10
11 #include <linux/linkage.h> 11 #include <linux/linkage.h>
12 #include <linux/time.h> 12 #include <linux/time.h>
13 #include <linux/errno.h> 13 #include <linux/errno.h>
14 #include <linux/fs.h> 14 #include <linux/fs.h>
15 #include <linux/namei.h> 15 #include <linux/namei.h>
16 #include <linux/fcntl.h> 16 #include <linux/fcntl.h>
17 #include <linux/net.h> 17 #include <linux/net.h>
18 #include <linux/in.h> 18 #include <linux/in.h>
19 #include <linux/syscalls.h> 19 #include <linux/syscalls.h>
20 #include <linux/unistd.h> 20 #include <linux/unistd.h>
21 #include <linux/slab.h> 21 #include <linux/slab.h>
22 #include <linux/proc_fs.h> 22 #include <linux/proc_fs.h>
23 #include <linux/seq_file.h> 23 #include <linux/seq_file.h>
24 #include <linux/pagemap.h> 24 #include <linux/pagemap.h>
25 #include <linux/init.h> 25 #include <linux/init.h>
26 #include <linux/inet.h> 26 #include <linux/inet.h>
27 #include <linux/string.h> 27 #include <linux/string.h>
28 #include <linux/smp_lock.h> 28 #include <linux/smp_lock.h>
29 #include <linux/ctype.h> 29 #include <linux/ctype.h>
30 30
31 #include <linux/nfs.h> 31 #include <linux/nfs.h>
32 #include <linux/nfsd_idmap.h> 32 #include <linux/nfsd_idmap.h>
33 #include <linux/lockd/bind.h> 33 #include <linux/lockd/bind.h>
34 #include <linux/sunrpc/svc.h> 34 #include <linux/sunrpc/svc.h>
35 #include <linux/sunrpc/svcsock.h> 35 #include <linux/sunrpc/svcsock.h>
36 #include <linux/nfsd/nfsd.h> 36 #include <linux/nfsd/nfsd.h>
37 #include <linux/nfsd/cache.h> 37 #include <linux/nfsd/cache.h>
38 #include <linux/nfsd/xdr.h> 38 #include <linux/nfsd/xdr.h>
39 #include <linux/nfsd/syscall.h> 39 #include <linux/nfsd/syscall.h>
40 #include <linux/lockd/lockd.h> 40 #include <linux/lockd/lockd.h>
41 41
42 #include <asm/uaccess.h> 42 #include <asm/uaccess.h>
43 #include <net/ipv6.h> 43 #include <net/ipv6.h>
44 44
45 /* 45 /*
46 * We have a single directory with 9 nodes in it. 46 * We have a single directory with 9 nodes in it.
47 */ 47 */
48 enum { 48 enum {
49 NFSD_Root = 1, 49 NFSD_Root = 1,
50 NFSD_Svc, 50 NFSD_Svc,
51 NFSD_Add, 51 NFSD_Add,
52 NFSD_Del, 52 NFSD_Del,
53 NFSD_Export, 53 NFSD_Export,
54 NFSD_Unexport, 54 NFSD_Unexport,
55 NFSD_Getfd, 55 NFSD_Getfd,
56 NFSD_Getfs, 56 NFSD_Getfs,
57 NFSD_List, 57 NFSD_List,
58 NFSD_Fh, 58 NFSD_Fh,
59 NFSD_FO_UnlockIP, 59 NFSD_FO_UnlockIP,
60 NFSD_FO_UnlockFS, 60 NFSD_FO_UnlockFS,
61 NFSD_Threads, 61 NFSD_Threads,
62 NFSD_Pool_Threads, 62 NFSD_Pool_Threads,
63 NFSD_Pool_Stats, 63 NFSD_Pool_Stats,
64 NFSD_Versions, 64 NFSD_Versions,
65 NFSD_Ports, 65 NFSD_Ports,
66 NFSD_MaxBlkSize, 66 NFSD_MaxBlkSize,
67 /* 67 /*
68 * The below MUST come last. Otherwise we leave a hole in nfsd_files[] 68 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
69 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops 69 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
70 */ 70 */
71 #ifdef CONFIG_NFSD_V4 71 #ifdef CONFIG_NFSD_V4
72 NFSD_Leasetime, 72 NFSD_Leasetime,
73 NFSD_RecoveryDir, 73 NFSD_RecoveryDir,
74 #endif 74 #endif
75 }; 75 };
76 76
77 /* 77 /*
78 * write() for these nodes. 78 * write() for these nodes.
79 */ 79 */
80 static ssize_t write_svc(struct file *file, char *buf, size_t size); 80 static ssize_t write_svc(struct file *file, char *buf, size_t size);
81 static ssize_t write_add(struct file *file, char *buf, size_t size); 81 static ssize_t write_add(struct file *file, char *buf, size_t size);
82 static ssize_t write_del(struct file *file, char *buf, size_t size); 82 static ssize_t write_del(struct file *file, char *buf, size_t size);
83 static ssize_t write_export(struct file *file, char *buf, size_t size); 83 static ssize_t write_export(struct file *file, char *buf, size_t size);
84 static ssize_t write_unexport(struct file *file, char *buf, size_t size); 84 static ssize_t write_unexport(struct file *file, char *buf, size_t size);
85 static ssize_t write_getfd(struct file *file, char *buf, size_t size); 85 static ssize_t write_getfd(struct file *file, char *buf, size_t size);
86 static ssize_t write_getfs(struct file *file, char *buf, size_t size); 86 static ssize_t write_getfs(struct file *file, char *buf, size_t size);
87 static ssize_t write_filehandle(struct file *file, char *buf, size_t size); 87 static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
88 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size); 88 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
89 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size); 89 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
90 static ssize_t write_threads(struct file *file, char *buf, size_t size); 90 static ssize_t write_threads(struct file *file, char *buf, size_t size);
91 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size); 91 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
92 static ssize_t write_versions(struct file *file, char *buf, size_t size); 92 static ssize_t write_versions(struct file *file, char *buf, size_t size);
93 static ssize_t write_ports(struct file *file, char *buf, size_t size); 93 static ssize_t write_ports(struct file *file, char *buf, size_t size);
94 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size); 94 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
95 #ifdef CONFIG_NFSD_V4 95 #ifdef CONFIG_NFSD_V4
96 static ssize_t write_leasetime(struct file *file, char *buf, size_t size); 96 static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
97 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size); 97 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
98 #endif 98 #endif
99 99
100 static ssize_t (*write_op[])(struct file *, char *, size_t) = { 100 static ssize_t (*write_op[])(struct file *, char *, size_t) = {
101 [NFSD_Svc] = write_svc, 101 [NFSD_Svc] = write_svc,
102 [NFSD_Add] = write_add, 102 [NFSD_Add] = write_add,
103 [NFSD_Del] = write_del, 103 [NFSD_Del] = write_del,
104 [NFSD_Export] = write_export, 104 [NFSD_Export] = write_export,
105 [NFSD_Unexport] = write_unexport, 105 [NFSD_Unexport] = write_unexport,
106 [NFSD_Getfd] = write_getfd, 106 [NFSD_Getfd] = write_getfd,
107 [NFSD_Getfs] = write_getfs, 107 [NFSD_Getfs] = write_getfs,
108 [NFSD_Fh] = write_filehandle, 108 [NFSD_Fh] = write_filehandle,
109 [NFSD_FO_UnlockIP] = write_unlock_ip, 109 [NFSD_FO_UnlockIP] = write_unlock_ip,
110 [NFSD_FO_UnlockFS] = write_unlock_fs, 110 [NFSD_FO_UnlockFS] = write_unlock_fs,
111 [NFSD_Threads] = write_threads, 111 [NFSD_Threads] = write_threads,
112 [NFSD_Pool_Threads] = write_pool_threads, 112 [NFSD_Pool_Threads] = write_pool_threads,
113 [NFSD_Versions] = write_versions, 113 [NFSD_Versions] = write_versions,
114 [NFSD_Ports] = write_ports, 114 [NFSD_Ports] = write_ports,
115 [NFSD_MaxBlkSize] = write_maxblksize, 115 [NFSD_MaxBlkSize] = write_maxblksize,
116 #ifdef CONFIG_NFSD_V4 116 #ifdef CONFIG_NFSD_V4
117 [NFSD_Leasetime] = write_leasetime, 117 [NFSD_Leasetime] = write_leasetime,
118 [NFSD_RecoveryDir] = write_recoverydir, 118 [NFSD_RecoveryDir] = write_recoverydir,
119 #endif 119 #endif
120 }; 120 };
121 121
122 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos) 122 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
123 { 123 {
124 ino_t ino = file->f_path.dentry->d_inode->i_ino; 124 ino_t ino = file->f_path.dentry->d_inode->i_ino;
125 char *data; 125 char *data;
126 ssize_t rv; 126 ssize_t rv;
127 127
128 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino]) 128 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
129 return -EINVAL; 129 return -EINVAL;
130 130
131 data = simple_transaction_get(file, buf, size); 131 data = simple_transaction_get(file, buf, size);
132 if (IS_ERR(data)) 132 if (IS_ERR(data))
133 return PTR_ERR(data); 133 return PTR_ERR(data);
134 134
135 rv = write_op[ino](file, data, size); 135 rv = write_op[ino](file, data, size);
136 if (rv >= 0) { 136 if (rv >= 0) {
137 simple_transaction_set(file, rv); 137 simple_transaction_set(file, rv);
138 rv = size; 138 rv = size;
139 } 139 }
140 return rv; 140 return rv;
141 } 141 }
142 142
143 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 143 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
144 { 144 {
145 if (! file->private_data) { 145 if (! file->private_data) {
146 /* An attempt to read a transaction file without writing 146 /* An attempt to read a transaction file without writing
147 * causes a 0-byte write so that the file can return 147 * causes a 0-byte write so that the file can return
148 * state information 148 * state information
149 */ 149 */
150 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos); 150 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
151 if (rv < 0) 151 if (rv < 0)
152 return rv; 152 return rv;
153 } 153 }
154 return simple_transaction_read(file, buf, size, pos); 154 return simple_transaction_read(file, buf, size, pos);
155 } 155 }
156 156
157 static const struct file_operations transaction_ops = { 157 static const struct file_operations transaction_ops = {
158 .write = nfsctl_transaction_write, 158 .write = nfsctl_transaction_write,
159 .read = nfsctl_transaction_read, 159 .read = nfsctl_transaction_read,
160 .release = simple_transaction_release, 160 .release = simple_transaction_release,
161 }; 161 };
162 162
163 static int exports_open(struct inode *inode, struct file *file) 163 static int exports_open(struct inode *inode, struct file *file)
164 { 164 {
165 return seq_open(file, &nfs_exports_op); 165 return seq_open(file, &nfs_exports_op);
166 } 166 }
167 167
168 static const struct file_operations exports_operations = { 168 static const struct file_operations exports_operations = {
169 .open = exports_open, 169 .open = exports_open,
170 .read = seq_read, 170 .read = seq_read,
171 .llseek = seq_lseek, 171 .llseek = seq_lseek,
172 .release = seq_release, 172 .release = seq_release,
173 .owner = THIS_MODULE, 173 .owner = THIS_MODULE,
174 }; 174 };
175 175
176 extern int nfsd_pool_stats_open(struct inode *inode, struct file *file); 176 extern int nfsd_pool_stats_open(struct inode *inode, struct file *file);
177 177
178 static struct file_operations pool_stats_operations = { 178 static struct file_operations pool_stats_operations = {
179 .open = nfsd_pool_stats_open, 179 .open = nfsd_pool_stats_open,
180 .read = seq_read, 180 .read = seq_read,
181 .llseek = seq_lseek, 181 .llseek = seq_lseek,
182 .release = seq_release, 182 .release = seq_release,
183 .owner = THIS_MODULE, 183 .owner = THIS_MODULE,
184 }; 184 };
185 185
186 /*----------------------------------------------------------------------------*/ 186 /*----------------------------------------------------------------------------*/
187 /* 187 /*
188 * payload - write methods 188 * payload - write methods
189 */ 189 */
190 190
191 /** 191 /**
192 * write_svc - Start kernel's NFSD server 192 * write_svc - Start kernel's NFSD server
193 * 193 *
194 * Deprecated. /proc/fs/nfsd/threads is preferred. 194 * Deprecated. /proc/fs/nfsd/threads is preferred.
195 * Function remains to support old versions of nfs-utils. 195 * Function remains to support old versions of nfs-utils.
196 * 196 *
197 * Input: 197 * Input:
198 * buf: struct nfsctl_svc 198 * buf: struct nfsctl_svc
199 * svc_port: port number of this 199 * svc_port: port number of this
200 * server's listener 200 * server's listener
201 * svc_nthreads: number of threads to start 201 * svc_nthreads: number of threads to start
202 * size: size in bytes of passed in nfsctl_svc 202 * size: size in bytes of passed in nfsctl_svc
203 * Output: 203 * Output:
204 * On success: returns zero 204 * On success: returns zero
205 * On error: return code is negative errno value 205 * On error: return code is negative errno value
206 */ 206 */
207 static ssize_t write_svc(struct file *file, char *buf, size_t size) 207 static ssize_t write_svc(struct file *file, char *buf, size_t size)
208 { 208 {
209 struct nfsctl_svc *data; 209 struct nfsctl_svc *data;
210 if (size < sizeof(*data)) 210 if (size < sizeof(*data))
211 return -EINVAL; 211 return -EINVAL;
212 data = (struct nfsctl_svc*) buf; 212 data = (struct nfsctl_svc*) buf;
213 return nfsd_svc(data->svc_port, data->svc_nthreads); 213 return nfsd_svc(data->svc_port, data->svc_nthreads);
214 } 214 }
215 215
216 /** 216 /**
217 * write_add - Add or modify client entry in auth unix cache 217 * write_add - Add or modify client entry in auth unix cache
218 * 218 *
219 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred. 219 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
220 * Function remains to support old versions of nfs-utils. 220 * Function remains to support old versions of nfs-utils.
221 * 221 *
222 * Input: 222 * Input:
223 * buf: struct nfsctl_client 223 * buf: struct nfsctl_client
224 * cl_ident: '\0'-terminated C string 224 * cl_ident: '\0'-terminated C string
225 * containing domain name 225 * containing domain name
226 * of client 226 * of client
227 * cl_naddr: no. of items in cl_addrlist 227 * cl_naddr: no. of items in cl_addrlist
228 * cl_addrlist: array of client addresses 228 * cl_addrlist: array of client addresses
229 * cl_fhkeytype: ignored 229 * cl_fhkeytype: ignored
230 * cl_fhkeylen: ignored 230 * cl_fhkeylen: ignored
231 * cl_fhkey: ignored 231 * cl_fhkey: ignored
232 * size: size in bytes of passed in nfsctl_client 232 * size: size in bytes of passed in nfsctl_client
233 * Output: 233 * Output:
234 * On success: returns zero 234 * On success: returns zero
235 * On error: return code is negative errno value 235 * On error: return code is negative errno value
236 * 236 *
237 * Note: Only AF_INET client addresses are passed in, since 237 * Note: Only AF_INET client addresses are passed in, since
238 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses. 238 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
239 */ 239 */
240 static ssize_t write_add(struct file *file, char *buf, size_t size) 240 static ssize_t write_add(struct file *file, char *buf, size_t size)
241 { 241 {
242 struct nfsctl_client *data; 242 struct nfsctl_client *data;
243 if (size < sizeof(*data)) 243 if (size < sizeof(*data))
244 return -EINVAL; 244 return -EINVAL;
245 data = (struct nfsctl_client *)buf; 245 data = (struct nfsctl_client *)buf;
246 return exp_addclient(data); 246 return exp_addclient(data);
247 } 247 }
248 248
249 /** 249 /**
250 * write_del - Remove client from auth unix cache 250 * write_del - Remove client from auth unix cache
251 * 251 *
252 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred. 252 * Deprecated. /proc/net/rpc/auth.unix.ip is preferred.
253 * Function remains to support old versions of nfs-utils. 253 * Function remains to support old versions of nfs-utils.
254 * 254 *
255 * Input: 255 * Input:
256 * buf: struct nfsctl_client 256 * buf: struct nfsctl_client
257 * cl_ident: '\0'-terminated C string 257 * cl_ident: '\0'-terminated C string
258 * containing domain name 258 * containing domain name
259 * of client 259 * of client
260 * cl_naddr: ignored 260 * cl_naddr: ignored
261 * cl_addrlist: ignored 261 * cl_addrlist: ignored
262 * cl_fhkeytype: ignored 262 * cl_fhkeytype: ignored
263 * cl_fhkeylen: ignored 263 * cl_fhkeylen: ignored
264 * cl_fhkey: ignored 264 * cl_fhkey: ignored
265 * size: size in bytes of passed in nfsctl_client 265 * size: size in bytes of passed in nfsctl_client
266 * Output: 266 * Output:
267 * On success: returns zero 267 * On success: returns zero
268 * On error: return code is negative errno value 268 * On error: return code is negative errno value
269 * 269 *
270 * Note: Only AF_INET client addresses are passed in, since 270 * Note: Only AF_INET client addresses are passed in, since
271 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses. 271 * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
272 */ 272 */
273 static ssize_t write_del(struct file *file, char *buf, size_t size) 273 static ssize_t write_del(struct file *file, char *buf, size_t size)
274 { 274 {
275 struct nfsctl_client *data; 275 struct nfsctl_client *data;
276 if (size < sizeof(*data)) 276 if (size < sizeof(*data))
277 return -EINVAL; 277 return -EINVAL;
278 data = (struct nfsctl_client *)buf; 278 data = (struct nfsctl_client *)buf;
279 return exp_delclient(data); 279 return exp_delclient(data);
280 } 280 }
281 281
282 /** 282 /**
283 * write_export - Export part or all of a local file system 283 * write_export - Export part or all of a local file system
284 * 284 *
285 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred. 285 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
286 * Function remains to support old versions of nfs-utils. 286 * Function remains to support old versions of nfs-utils.
287 * 287 *
288 * Input: 288 * Input:
289 * buf: struct nfsctl_export 289 * buf: struct nfsctl_export
290 * ex_client: '\0'-terminated C string 290 * ex_client: '\0'-terminated C string
291 * containing domain name 291 * containing domain name
292 * of client allowed to access 292 * of client allowed to access
293 * this export 293 * this export
294 * ex_path: '\0'-terminated C string 294 * ex_path: '\0'-terminated C string
295 * containing pathname of 295 * containing pathname of
296 * directory in local file system 296 * directory in local file system
297 * ex_dev: fsid to use for this export 297 * ex_dev: fsid to use for this export
298 * ex_ino: ignored 298 * ex_ino: ignored
299 * ex_flags: export flags for this export 299 * ex_flags: export flags for this export
300 * ex_anon_uid: UID to use for anonymous 300 * ex_anon_uid: UID to use for anonymous
301 * requests 301 * requests
302 * ex_anon_gid: GID to use for anonymous 302 * ex_anon_gid: GID to use for anonymous
303 * requests 303 * requests
304 * size: size in bytes of passed in nfsctl_export 304 * size: size in bytes of passed in nfsctl_export
305 * Output: 305 * Output:
306 * On success: returns zero 306 * On success: returns zero
307 * On error: return code is negative errno value 307 * On error: return code is negative errno value
308 */ 308 */
309 static ssize_t write_export(struct file *file, char *buf, size_t size) 309 static ssize_t write_export(struct file *file, char *buf, size_t size)
310 { 310 {
311 struct nfsctl_export *data; 311 struct nfsctl_export *data;
312 if (size < sizeof(*data)) 312 if (size < sizeof(*data))
313 return -EINVAL; 313 return -EINVAL;
314 data = (struct nfsctl_export*)buf; 314 data = (struct nfsctl_export*)buf;
315 return exp_export(data); 315 return exp_export(data);
316 } 316 }
317 317
318 /** 318 /**
319 * write_unexport - Unexport a previously exported file system 319 * write_unexport - Unexport a previously exported file system
320 * 320 *
321 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred. 321 * Deprecated. /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
322 * Function remains to support old versions of nfs-utils. 322 * Function remains to support old versions of nfs-utils.
323 * 323 *
324 * Input: 324 * Input:
325 * buf: struct nfsctl_export 325 * buf: struct nfsctl_export
326 * ex_client: '\0'-terminated C string 326 * ex_client: '\0'-terminated C string
327 * containing domain name 327 * containing domain name
328 * of client no longer allowed 328 * of client no longer allowed
329 * to access this export 329 * to access this export
330 * ex_path: '\0'-terminated C string 330 * ex_path: '\0'-terminated C string
331 * containing pathname of 331 * containing pathname of
332 * directory in local file system 332 * directory in local file system
333 * ex_dev: ignored 333 * ex_dev: ignored
334 * ex_ino: ignored 334 * ex_ino: ignored
335 * ex_flags: ignored 335 * ex_flags: ignored
336 * ex_anon_uid: ignored 336 * ex_anon_uid: ignored
337 * ex_anon_gid: ignored 337 * ex_anon_gid: ignored
338 * size: size in bytes of passed in nfsctl_export 338 * size: size in bytes of passed in nfsctl_export
339 * Output: 339 * Output:
340 * On success: returns zero 340 * On success: returns zero
341 * On error: return code is negative errno value 341 * On error: return code is negative errno value
342 */ 342 */
343 static ssize_t write_unexport(struct file *file, char *buf, size_t size) 343 static ssize_t write_unexport(struct file *file, char *buf, size_t size)
344 { 344 {
345 struct nfsctl_export *data; 345 struct nfsctl_export *data;
346 346
347 if (size < sizeof(*data)) 347 if (size < sizeof(*data))
348 return -EINVAL; 348 return -EINVAL;
349 data = (struct nfsctl_export*)buf; 349 data = (struct nfsctl_export*)buf;
350 return exp_unexport(data); 350 return exp_unexport(data);
351 } 351 }
352 352
353 /** 353 /**
354 * write_getfs - Get a variable-length NFS file handle by path 354 * write_getfs - Get a variable-length NFS file handle by path
355 * 355 *
356 * Deprecated. /proc/fs/nfsd/filehandle is preferred. 356 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
357 * Function remains to support old versions of nfs-utils. 357 * Function remains to support old versions of nfs-utils.
358 * 358 *
359 * Input: 359 * Input:
360 * buf: struct nfsctl_fsparm 360 * buf: struct nfsctl_fsparm
361 * gd_addr: socket address of client 361 * gd_addr: socket address of client
362 * gd_path: '\0'-terminated C string 362 * gd_path: '\0'-terminated C string
363 * containing pathname of 363 * containing pathname of
364 * directory in local file system 364 * directory in local file system
365 * gd_maxlen: maximum size of returned file 365 * gd_maxlen: maximum size of returned file
366 * handle 366 * handle
367 * size: size in bytes of passed in nfsctl_fsparm 367 * size: size in bytes of passed in nfsctl_fsparm
368 * Output: 368 * Output:
369 * On success: passed-in buffer filled with a knfsd_fh structure 369 * On success: passed-in buffer filled with a knfsd_fh structure
370 * (a variable-length raw NFS file handle); 370 * (a variable-length raw NFS file handle);
371 * return code is the size in bytes of the file handle 371 * return code is the size in bytes of the file handle
372 * On error: return code is negative errno value 372 * On error: return code is negative errno value
373 * 373 *
374 * Note: Only AF_INET client addresses are passed in, since gd_addr 374 * Note: Only AF_INET client addresses are passed in, since gd_addr
375 * is the same size as a struct sockaddr_in. 375 * is the same size as a struct sockaddr_in.
376 */ 376 */
377 static ssize_t write_getfs(struct file *file, char *buf, size_t size) 377 static ssize_t write_getfs(struct file *file, char *buf, size_t size)
378 { 378 {
379 struct nfsctl_fsparm *data; 379 struct nfsctl_fsparm *data;
380 struct sockaddr_in *sin; 380 struct sockaddr_in *sin;
381 struct auth_domain *clp; 381 struct auth_domain *clp;
382 int err = 0; 382 int err = 0;
383 struct knfsd_fh *res; 383 struct knfsd_fh *res;
384 struct in6_addr in6; 384 struct in6_addr in6;
385 385
386 if (size < sizeof(*data)) 386 if (size < sizeof(*data))
387 return -EINVAL; 387 return -EINVAL;
388 data = (struct nfsctl_fsparm*)buf; 388 data = (struct nfsctl_fsparm*)buf;
389 err = -EPROTONOSUPPORT; 389 err = -EPROTONOSUPPORT;
390 if (data->gd_addr.sa_family != AF_INET) 390 if (data->gd_addr.sa_family != AF_INET)
391 goto out; 391 goto out;
392 sin = (struct sockaddr_in *)&data->gd_addr; 392 sin = (struct sockaddr_in *)&data->gd_addr;
393 if (data->gd_maxlen > NFS3_FHSIZE) 393 if (data->gd_maxlen > NFS3_FHSIZE)
394 data->gd_maxlen = NFS3_FHSIZE; 394 data->gd_maxlen = NFS3_FHSIZE;
395 395
396 res = (struct knfsd_fh*)buf; 396 res = (struct knfsd_fh*)buf;
397 397
398 exp_readlock(); 398 exp_readlock();
399 399
400 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); 400 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
401 401
402 clp = auth_unix_lookup(&in6); 402 clp = auth_unix_lookup(&in6);
403 if (!clp) 403 if (!clp)
404 err = -EPERM; 404 err = -EPERM;
405 else { 405 else {
406 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen); 406 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
407 auth_domain_put(clp); 407 auth_domain_put(clp);
408 } 408 }
409 exp_readunlock(); 409 exp_readunlock();
410 if (err == 0) 410 if (err == 0)
411 err = res->fh_size + offsetof(struct knfsd_fh, fh_base); 411 err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
412 out: 412 out:
413 return err; 413 return err;
414 } 414 }
415 415
416 /** 416 /**
417 * write_getfd - Get a fixed-length NFS file handle by path (used by mountd) 417 * write_getfd - Get a fixed-length NFS file handle by path (used by mountd)
418 * 418 *
419 * Deprecated. /proc/fs/nfsd/filehandle is preferred. 419 * Deprecated. /proc/fs/nfsd/filehandle is preferred.
420 * Function remains to support old versions of nfs-utils. 420 * Function remains to support old versions of nfs-utils.
421 * 421 *
422 * Input: 422 * Input:
423 * buf: struct nfsctl_fdparm 423 * buf: struct nfsctl_fdparm
424 * gd_addr: socket address of client 424 * gd_addr: socket address of client
425 * gd_path: '\0'-terminated C string 425 * gd_path: '\0'-terminated C string
426 * containing pathname of 426 * containing pathname of
427 * directory in local file system 427 * directory in local file system
428 * gd_version: fdparm structure version 428 * gd_version: fdparm structure version
429 * size: size in bytes of passed in nfsctl_fdparm 429 * size: size in bytes of passed in nfsctl_fdparm
430 * Output: 430 * Output:
431 * On success: passed-in buffer filled with nfsctl_res 431 * On success: passed-in buffer filled with nfsctl_res
432 * (a fixed-length raw NFS file handle); 432 * (a fixed-length raw NFS file handle);
433 * return code is the size in bytes of the file handle 433 * return code is the size in bytes of the file handle
434 * On error: return code is negative errno value 434 * On error: return code is negative errno value
435 * 435 *
436 * Note: Only AF_INET client addresses are passed in, since gd_addr 436 * Note: Only AF_INET client addresses are passed in, since gd_addr
437 * is the same size as a struct sockaddr_in. 437 * is the same size as a struct sockaddr_in.
438 */ 438 */
439 static ssize_t write_getfd(struct file *file, char *buf, size_t size) 439 static ssize_t write_getfd(struct file *file, char *buf, size_t size)
440 { 440 {
441 struct nfsctl_fdparm *data; 441 struct nfsctl_fdparm *data;
442 struct sockaddr_in *sin; 442 struct sockaddr_in *sin;
443 struct auth_domain *clp; 443 struct auth_domain *clp;
444 int err = 0; 444 int err = 0;
445 struct knfsd_fh fh; 445 struct knfsd_fh fh;
446 char *res; 446 char *res;
447 struct in6_addr in6; 447 struct in6_addr in6;
448 448
449 if (size < sizeof(*data)) 449 if (size < sizeof(*data))
450 return -EINVAL; 450 return -EINVAL;
451 data = (struct nfsctl_fdparm*)buf; 451 data = (struct nfsctl_fdparm*)buf;
452 err = -EPROTONOSUPPORT; 452 err = -EPROTONOSUPPORT;
453 if (data->gd_addr.sa_family != AF_INET) 453 if (data->gd_addr.sa_family != AF_INET)
454 goto out; 454 goto out;
455 err = -EINVAL; 455 err = -EINVAL;
456 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS) 456 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
457 goto out; 457 goto out;
458 458
459 res = buf; 459 res = buf;
460 sin = (struct sockaddr_in *)&data->gd_addr; 460 sin = (struct sockaddr_in *)&data->gd_addr;
461 exp_readlock(); 461 exp_readlock();
462 462
463 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); 463 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
464 464
465 clp = auth_unix_lookup(&in6); 465 clp = auth_unix_lookup(&in6);
466 if (!clp) 466 if (!clp)
467 err = -EPERM; 467 err = -EPERM;
468 else { 468 else {
469 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE); 469 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
470 auth_domain_put(clp); 470 auth_domain_put(clp);
471 } 471 }
472 exp_readunlock(); 472 exp_readunlock();
473 473
474 if (err == 0) { 474 if (err == 0) {
475 memset(res,0, NFS_FHSIZE); 475 memset(res,0, NFS_FHSIZE);
476 memcpy(res, &fh.fh_base, fh.fh_size); 476 memcpy(res, &fh.fh_base, fh.fh_size);
477 err = NFS_FHSIZE; 477 err = NFS_FHSIZE;
478 } 478 }
479 out: 479 out:
480 return err; 480 return err;
481 } 481 }
482 482
483 /** 483 /**
484 * write_unlock_ip - Release all locks used by a client 484 * write_unlock_ip - Release all locks used by a client
485 * 485 *
486 * Experimental. 486 * Experimental.
487 * 487 *
488 * Input: 488 * Input:
489 * buf: '\n'-terminated C string containing a 489 * buf: '\n'-terminated C string containing a
490 * presentation format IPv4 address 490 * presentation format IPv4 address
491 * size: length of C string in @buf 491 * size: length of C string in @buf
492 * Output: 492 * Output:
493 * On success: returns zero if all specified locks were released; 493 * On success: returns zero if all specified locks were released;
494 * returns one if one or more locks were not released 494 * returns one if one or more locks were not released
495 * On error: return code is negative errno value 495 * On error: return code is negative errno value
496 * 496 *
497 * Note: Only AF_INET client addresses are passed in 497 * Note: Only AF_INET client addresses are passed in
498 */ 498 */
499 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) 499 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
500 { 500 {
501 struct sockaddr_in sin = { 501 struct sockaddr_in sin = {
502 .sin_family = AF_INET, 502 .sin_family = AF_INET,
503 }; 503 };
504 int b1, b2, b3, b4; 504 int b1, b2, b3, b4;
505 char c; 505 char c;
506 char *fo_path; 506 char *fo_path;
507 507
508 /* sanity check */ 508 /* sanity check */
509 if (size == 0) 509 if (size == 0)
510 return -EINVAL; 510 return -EINVAL;
511 511
512 if (buf[size-1] != '\n') 512 if (buf[size-1] != '\n')
513 return -EINVAL; 513 return -EINVAL;
514 514
515 fo_path = buf; 515 fo_path = buf;
516 if (qword_get(&buf, fo_path, size) < 0) 516 if (qword_get(&buf, fo_path, size) < 0)
517 return -EINVAL; 517 return -EINVAL;
518 518
519 /* get ipv4 address */ 519 /* get ipv4 address */
520 if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4) 520 if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4)
521 return -EINVAL; 521 return -EINVAL;
522 if (b1 > 255 || b2 > 255 || b3 > 255 || b4 > 255) 522 if (b1 > 255 || b2 > 255 || b3 > 255 || b4 > 255)
523 return -EINVAL; 523 return -EINVAL;
524 sin.sin_addr.s_addr = htonl((b1 << 24) | (b2 << 16) | (b3 << 8) | b4); 524 sin.sin_addr.s_addr = htonl((b1 << 24) | (b2 << 16) | (b3 << 8) | b4);
525 525
526 return nlmsvc_unlock_all_by_ip((struct sockaddr *)&sin); 526 return nlmsvc_unlock_all_by_ip((struct sockaddr *)&sin);
527 } 527 }
528 528
529 /** 529 /**
530 * write_unlock_fs - Release all locks on a local file system 530 * write_unlock_fs - Release all locks on a local file system
531 * 531 *
532 * Experimental. 532 * Experimental.
533 * 533 *
534 * Input: 534 * Input:
535 * buf: '\n'-terminated C string containing the 535 * buf: '\n'-terminated C string containing the
536 * absolute pathname of a local file system 536 * absolute pathname of a local file system
537 * size: length of C string in @buf 537 * size: length of C string in @buf
538 * Output: 538 * Output:
539 * On success: returns zero if all specified locks were released; 539 * On success: returns zero if all specified locks were released;
540 * returns one if one or more locks were not released 540 * returns one if one or more locks were not released
541 * On error: return code is negative errno value 541 * On error: return code is negative errno value
542 */ 542 */
543 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size) 543 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
544 { 544 {
545 struct path path; 545 struct path path;
546 char *fo_path; 546 char *fo_path;
547 int error; 547 int error;
548 548
549 /* sanity check */ 549 /* sanity check */
550 if (size == 0) 550 if (size == 0)
551 return -EINVAL; 551 return -EINVAL;
552 552
553 if (buf[size-1] != '\n') 553 if (buf[size-1] != '\n')
554 return -EINVAL; 554 return -EINVAL;
555 555
556 fo_path = buf; 556 fo_path = buf;
557 if (qword_get(&buf, fo_path, size) < 0) 557 if (qword_get(&buf, fo_path, size) < 0)
558 return -EINVAL; 558 return -EINVAL;
559 559
560 error = kern_path(fo_path, 0, &path); 560 error = kern_path(fo_path, 0, &path);
561 if (error) 561 if (error)
562 return error; 562 return error;
563 563
564 /* 564 /*
565 * XXX: Needs better sanity checking. Otherwise we could end up 565 * XXX: Needs better sanity checking. Otherwise we could end up
566 * releasing locks on the wrong file system. 566 * releasing locks on the wrong file system.
567 * 567 *
568 * For example: 568 * For example:
569 * 1. Does the path refer to a directory? 569 * 1. Does the path refer to a directory?
570 * 2. Is that directory a mount point, or 570 * 2. Is that directory a mount point, or
571 * 3. Is that directory the root of an exported file system? 571 * 3. Is that directory the root of an exported file system?
572 */ 572 */
573 error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb); 573 error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb);
574 574
575 path_put(&path); 575 path_put(&path);
576 return error; 576 return error;
577 } 577 }
578 578
579 /** 579 /**
580 * write_filehandle - Get a variable-length NFS file handle by path 580 * write_filehandle - Get a variable-length NFS file handle by path
581 * 581 *
582 * On input, the buffer contains a '\n'-terminated C string comprised of 582 * On input, the buffer contains a '\n'-terminated C string comprised of
583 * three alphanumeric words separated by whitespace. The string may 583 * three alphanumeric words separated by whitespace. The string may
584 * contain escape sequences. 584 * contain escape sequences.
585 * 585 *
586 * Input: 586 * Input:
587 * buf: 587 * buf:
588 * domain: client domain name 588 * domain: client domain name
589 * path: export pathname 589 * path: export pathname
590 * maxsize: numeric maximum size of 590 * maxsize: numeric maximum size of
591 * @buf 591 * @buf
592 * size: length of C string in @buf 592 * size: length of C string in @buf
593 * Output: 593 * Output:
594 * On success: passed-in buffer filled with '\n'-terminated C 594 * On success: passed-in buffer filled with '\n'-terminated C
595 * string containing a ASCII hex text version 595 * string containing a ASCII hex text version
596 * of the NFS file handle; 596 * of the NFS file handle;
597 * return code is the size in bytes of the string 597 * return code is the size in bytes of the string
598 * On error: return code is negative errno value 598 * On error: return code is negative errno value
599 */ 599 */
600 static ssize_t write_filehandle(struct file *file, char *buf, size_t size) 600 static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
601 { 601 {
602 char *dname, *path; 602 char *dname, *path;
603 int uninitialized_var(maxsize); 603 int uninitialized_var(maxsize);
604 char *mesg = buf; 604 char *mesg = buf;
605 int len; 605 int len;
606 struct auth_domain *dom; 606 struct auth_domain *dom;
607 struct knfsd_fh fh; 607 struct knfsd_fh fh;
608 608
609 if (size == 0) 609 if (size == 0)
610 return -EINVAL; 610 return -EINVAL;
611 611
612 if (buf[size-1] != '\n') 612 if (buf[size-1] != '\n')
613 return -EINVAL; 613 return -EINVAL;
614 buf[size-1] = 0; 614 buf[size-1] = 0;
615 615
616 dname = mesg; 616 dname = mesg;
617 len = qword_get(&mesg, dname, size); 617 len = qword_get(&mesg, dname, size);
618 if (len <= 0) 618 if (len <= 0)
619 return -EINVAL; 619 return -EINVAL;
620 620
621 path = dname+len+1; 621 path = dname+len+1;
622 len = qword_get(&mesg, path, size); 622 len = qword_get(&mesg, path, size);
623 if (len <= 0) 623 if (len <= 0)
624 return -EINVAL; 624 return -EINVAL;
625 625
626 len = get_int(&mesg, &maxsize); 626 len = get_int(&mesg, &maxsize);
627 if (len) 627 if (len)
628 return len; 628 return len;
629 629
630 if (maxsize < NFS_FHSIZE) 630 if (maxsize < NFS_FHSIZE)
631 return -EINVAL; 631 return -EINVAL;
632 if (maxsize > NFS3_FHSIZE) 632 if (maxsize > NFS3_FHSIZE)
633 maxsize = NFS3_FHSIZE; 633 maxsize = NFS3_FHSIZE;
634 634
635 if (qword_get(&mesg, mesg, size)>0) 635 if (qword_get(&mesg, mesg, size)>0)
636 return -EINVAL; 636 return -EINVAL;
637 637
638 /* we have all the words, they are in buf.. */ 638 /* we have all the words, they are in buf.. */
639 dom = unix_domain_find(dname); 639 dom = unix_domain_find(dname);
640 if (!dom) 640 if (!dom)
641 return -ENOMEM; 641 return -ENOMEM;
642 642
643 len = exp_rootfh(dom, path, &fh, maxsize); 643 len = exp_rootfh(dom, path, &fh, maxsize);
644 auth_domain_put(dom); 644 auth_domain_put(dom);
645 if (len) 645 if (len)
646 return len; 646 return len;
647 647
648 mesg = buf; 648 mesg = buf;
649 len = SIMPLE_TRANSACTION_LIMIT; 649 len = SIMPLE_TRANSACTION_LIMIT;
650 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size); 650 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
651 mesg[-1] = '\n'; 651 mesg[-1] = '\n';
652 return mesg - buf; 652 return mesg - buf;
653 } 653 }
654 654
655 /** 655 /**
656 * write_threads - Start NFSD, or report the current number of running threads 656 * write_threads - Start NFSD, or report the current number of running threads
657 * 657 *
658 * Input: 658 * Input:
659 * buf: ignored 659 * buf: ignored
660 * size: zero 660 * size: zero
661 * Output: 661 * Output:
662 * On success: passed-in buffer filled with '\n'-terminated C 662 * On success: passed-in buffer filled with '\n'-terminated C
663 * string numeric value representing the number of 663 * string numeric value representing the number of
664 * running NFSD threads; 664 * running NFSD threads;
665 * return code is the size in bytes of the string 665 * return code is the size in bytes of the string
666 * On error: return code is zero 666 * On error: return code is zero
667 * 667 *
668 * OR 668 * OR
669 * 669 *
670 * Input: 670 * Input:
671 * buf: C string containing an unsigned 671 * buf: C string containing an unsigned
672 * integer value representing the 672 * integer value representing the
673 * number of NFSD threads to start 673 * number of NFSD threads to start
674 * size: non-zero length of C string in @buf 674 * size: non-zero length of C string in @buf
675 * Output: 675 * Output:
676 * On success: NFS service is started; 676 * On success: NFS service is started;
677 * passed-in buffer filled with '\n'-terminated C 677 * passed-in buffer filled with '\n'-terminated C
678 * string numeric value representing the number of 678 * string numeric value representing the number of
679 * running NFSD threads; 679 * running NFSD threads;
680 * return code is the size in bytes of the string 680 * return code is the size in bytes of the string
681 * On error: return code is zero or a negative errno value 681 * On error: return code is zero or a negative errno value
682 */ 682 */
683 static ssize_t write_threads(struct file *file, char *buf, size_t size) 683 static ssize_t write_threads(struct file *file, char *buf, size_t size)
684 { 684 {
685 char *mesg = buf; 685 char *mesg = buf;
686 int rv; 686 int rv;
687 if (size > 0) { 687 if (size > 0) {
688 int newthreads; 688 int newthreads;
689 rv = get_int(&mesg, &newthreads); 689 rv = get_int(&mesg, &newthreads);
690 if (rv) 690 if (rv)
691 return rv; 691 return rv;
692 if (newthreads < 0) 692 if (newthreads < 0)
693 return -EINVAL; 693 return -EINVAL;
694 rv = nfsd_svc(NFS_PORT, newthreads); 694 rv = nfsd_svc(NFS_PORT, newthreads);
695 if (rv) 695 if (rv)
696 return rv; 696 return rv;
697 } 697 }
698 sprintf(buf, "%d\n", nfsd_nrthreads()); 698 sprintf(buf, "%d\n", nfsd_nrthreads());
699 return strlen(buf); 699 return strlen(buf);
700 } 700 }
701 701
702 /** 702 /**
703 * write_pool_threads - Set or report the current number of threads per pool 703 * write_pool_threads - Set or report the current number of threads per pool
704 * 704 *
705 * Input: 705 * Input:
706 * buf: ignored 706 * buf: ignored
707 * size: zero 707 * size: zero
708 * 708 *
709 * OR 709 * OR
710 * 710 *
711 * Input: 711 * Input:
712 * buf: C string containing whitespace- 712 * buf: C string containing whitespace-
713 * separated unsigned integer values 713 * separated unsigned integer values
714 * representing the number of NFSD 714 * representing the number of NFSD
715 * threads to start in each pool 715 * threads to start in each pool
716 * size: non-zero length of C string in @buf 716 * size: non-zero length of C string in @buf
717 * Output: 717 * Output:
718 * On success: passed-in buffer filled with '\n'-terminated C 718 * On success: passed-in buffer filled with '\n'-terminated C
719 * string containing integer values representing the 719 * string containing integer values representing the
720 * number of NFSD threads in each pool; 720 * number of NFSD threads in each pool;
721 * return code is the size in bytes of the string 721 * return code is the size in bytes of the string
722 * On error: return code is zero or a negative errno value 722 * On error: return code is zero or a negative errno value
723 */ 723 */
724 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size) 724 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
725 { 725 {
726 /* if size > 0, look for an array of number of threads per node 726 /* if size > 0, look for an array of number of threads per node
727 * and apply them then write out number of threads per node as reply 727 * and apply them then write out number of threads per node as reply
728 */ 728 */
729 char *mesg = buf; 729 char *mesg = buf;
730 int i; 730 int i;
731 int rv; 731 int rv;
732 int len; 732 int len;
733 int npools; 733 int npools;
734 int *nthreads; 734 int *nthreads;
735 735
736 mutex_lock(&nfsd_mutex); 736 mutex_lock(&nfsd_mutex);
737 npools = nfsd_nrpools(); 737 npools = nfsd_nrpools();
738 if (npools == 0) { 738 if (npools == 0) {
739 /* 739 /*
740 * NFS is shut down. The admin can start it by 740 * NFS is shut down. The admin can start it by
741 * writing to the threads file but NOT the pool_threads 741 * writing to the threads file but NOT the pool_threads
742 * file, sorry. Report zero threads. 742 * file, sorry. Report zero threads.
743 */ 743 */
744 mutex_unlock(&nfsd_mutex); 744 mutex_unlock(&nfsd_mutex);
745 strcpy(buf, "0\n"); 745 strcpy(buf, "0\n");
746 return strlen(buf); 746 return strlen(buf);
747 } 747 }
748 748
749 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL); 749 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
750 rv = -ENOMEM; 750 rv = -ENOMEM;
751 if (nthreads == NULL) 751 if (nthreads == NULL)
752 goto out_free; 752 goto out_free;
753 753
754 if (size > 0) { 754 if (size > 0) {
755 for (i = 0; i < npools; i++) { 755 for (i = 0; i < npools; i++) {
756 rv = get_int(&mesg, &nthreads[i]); 756 rv = get_int(&mesg, &nthreads[i]);
757 if (rv == -ENOENT) 757 if (rv == -ENOENT)
758 break; /* fewer numbers than pools */ 758 break; /* fewer numbers than pools */
759 if (rv) 759 if (rv)
760 goto out_free; /* syntax error */ 760 goto out_free; /* syntax error */
761 rv = -EINVAL; 761 rv = -EINVAL;
762 if (nthreads[i] < 0) 762 if (nthreads[i] < 0)
763 goto out_free; 763 goto out_free;
764 } 764 }
765 rv = nfsd_set_nrthreads(i, nthreads); 765 rv = nfsd_set_nrthreads(i, nthreads);
766 if (rv) 766 if (rv)
767 goto out_free; 767 goto out_free;
768 } 768 }
769 769
770 rv = nfsd_get_nrthreads(npools, nthreads); 770 rv = nfsd_get_nrthreads(npools, nthreads);
771 if (rv) 771 if (rv)
772 goto out_free; 772 goto out_free;
773 773
774 mesg = buf; 774 mesg = buf;
775 size = SIMPLE_TRANSACTION_LIMIT; 775 size = SIMPLE_TRANSACTION_LIMIT;
776 for (i = 0; i < npools && size > 0; i++) { 776 for (i = 0; i < npools && size > 0; i++) {
777 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' ')); 777 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
778 len = strlen(mesg); 778 len = strlen(mesg);
779 size -= len; 779 size -= len;
780 mesg += len; 780 mesg += len;
781 } 781 }
782 782
783 mutex_unlock(&nfsd_mutex); 783 mutex_unlock(&nfsd_mutex);
784 return (mesg-buf); 784 return (mesg-buf);
785 785
786 out_free: 786 out_free:
787 kfree(nthreads); 787 kfree(nthreads);
788 mutex_unlock(&nfsd_mutex); 788 mutex_unlock(&nfsd_mutex);
789 return rv; 789 return rv;
790 } 790 }
791 791
792 static ssize_t __write_versions(struct file *file, char *buf, size_t size) 792 static ssize_t __write_versions(struct file *file, char *buf, size_t size)
793 { 793 {
794 char *mesg = buf; 794 char *mesg = buf;
795 char *vers, *minorp, sign; 795 char *vers, *minorp, sign;
796 int len, num; 796 int len, num;
797 unsigned minor; 797 unsigned minor;
798 ssize_t tlen = 0; 798 ssize_t tlen = 0;
799 char *sep; 799 char *sep;
800 800
801 if (size>0) { 801 if (size>0) {
802 if (nfsd_serv) 802 if (nfsd_serv)
803 /* Cannot change versions without updating 803 /* Cannot change versions without updating
804 * nfsd_serv->sv_xdrsize, and reallocing 804 * nfsd_serv->sv_xdrsize, and reallocing
805 * rq_argp and rq_resp 805 * rq_argp and rq_resp
806 */ 806 */
807 return -EBUSY; 807 return -EBUSY;
808 if (buf[size-1] != '\n') 808 if (buf[size-1] != '\n')
809 return -EINVAL; 809 return -EINVAL;
810 buf[size-1] = 0; 810 buf[size-1] = 0;
811 811
812 vers = mesg; 812 vers = mesg;
813 len = qword_get(&mesg, vers, size); 813 len = qword_get(&mesg, vers, size);
814 if (len <= 0) return -EINVAL; 814 if (len <= 0) return -EINVAL;
815 do { 815 do {
816 sign = *vers; 816 sign = *vers;
817 if (sign == '+' || sign == '-') 817 if (sign == '+' || sign == '-')
818 num = simple_strtol((vers+1), &minorp, 0); 818 num = simple_strtol((vers+1), &minorp, 0);
819 else 819 else
820 num = simple_strtol(vers, &minorp, 0); 820 num = simple_strtol(vers, &minorp, 0);
821 if (*minorp == '.') { 821 if (*minorp == '.') {
822 if (num < 4) 822 if (num < 4)
823 return -EINVAL; 823 return -EINVAL;
824 minor = simple_strtoul(minorp+1, NULL, 0); 824 minor = simple_strtoul(minorp+1, NULL, 0);
825 if (minor == 0) 825 if (minor == 0)
826 return -EINVAL; 826 return -EINVAL;
827 if (nfsd_minorversion(minor, sign == '-' ? 827 if (nfsd_minorversion(minor, sign == '-' ?
828 NFSD_CLEAR : NFSD_SET) < 0) 828 NFSD_CLEAR : NFSD_SET) < 0)
829 return -EINVAL; 829 return -EINVAL;
830 goto next; 830 goto next;
831 } 831 }
832 switch(num) { 832 switch(num) {
833 case 2: 833 case 2:
834 case 3: 834 case 3:
835 case 4: 835 case 4:
836 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET); 836 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
837 break; 837 break;
838 default: 838 default:
839 return -EINVAL; 839 return -EINVAL;
840 } 840 }
841 next: 841 next:
842 vers += len + 1; 842 vers += len + 1;
843 tlen += len; 843 tlen += len;
844 } while ((len = qword_get(&mesg, vers, size)) > 0); 844 } while ((len = qword_get(&mesg, vers, size)) > 0);
845 /* If all get turned off, turn them back on, as 845 /* If all get turned off, turn them back on, as
846 * having no versions is BAD 846 * having no versions is BAD
847 */ 847 */
848 nfsd_reset_versions(); 848 nfsd_reset_versions();
849 } 849 }
850 /* Now write current state into reply buffer */ 850 /* Now write current state into reply buffer */
851 len = 0; 851 len = 0;
852 sep = ""; 852 sep = "";
853 for (num=2 ; num <= 4 ; num++) 853 for (num=2 ; num <= 4 ; num++)
854 if (nfsd_vers(num, NFSD_AVAIL)) { 854 if (nfsd_vers(num, NFSD_AVAIL)) {
855 len += sprintf(buf+len, "%s%c%d", sep, 855 len += sprintf(buf+len, "%s%c%d", sep,
856 nfsd_vers(num, NFSD_TEST)?'+':'-', 856 nfsd_vers(num, NFSD_TEST)?'+':'-',
857 num); 857 num);
858 sep = " "; 858 sep = " ";
859 } 859 }
860 if (nfsd_vers(4, NFSD_AVAIL)) 860 if (nfsd_vers(4, NFSD_AVAIL))
861 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION; minor++) 861 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION; minor++)
862 len += sprintf(buf+len, " %c4.%u", 862 len += sprintf(buf+len, " %c4.%u",
863 (nfsd_vers(4, NFSD_TEST) && 863 (nfsd_vers(4, NFSD_TEST) &&
864 nfsd_minorversion(minor, NFSD_TEST)) ? 864 nfsd_minorversion(minor, NFSD_TEST)) ?
865 '+' : '-', 865 '+' : '-',
866 minor); 866 minor);
867 len += sprintf(buf+len, "\n"); 867 len += sprintf(buf+len, "\n");
868 return len; 868 return len;
869 } 869 }
870 870
871 /** 871 /**
872 * write_versions - Set or report the available NFS protocol versions 872 * write_versions - Set or report the available NFS protocol versions
873 * 873 *
874 * Input: 874 * Input:
875 * buf: ignored 875 * buf: ignored
876 * size: zero 876 * size: zero
877 * Output: 877 * Output:
878 * On success: passed-in buffer filled with '\n'-terminated C 878 * On success: passed-in buffer filled with '\n'-terminated C
879 * string containing positive or negative integer 879 * string containing positive or negative integer
880 * values representing the current status of each 880 * values representing the current status of each
881 * protocol version; 881 * protocol version;
882 * return code is the size in bytes of the string 882 * return code is the size in bytes of the string
883 * On error: return code is zero or a negative errno value 883 * On error: return code is zero or a negative errno value
884 * 884 *
885 * OR 885 * OR
886 * 886 *
887 * Input: 887 * Input:
888 * buf: C string containing whitespace- 888 * buf: C string containing whitespace-
889 * separated positive or negative 889 * separated positive or negative
890 * integer values representing NFS 890 * integer values representing NFS
891 * protocol versions to enable ("+n") 891 * protocol versions to enable ("+n")
892 * or disable ("-n") 892 * or disable ("-n")
893 * size: non-zero length of C string in @buf 893 * size: non-zero length of C string in @buf
894 * Output: 894 * Output:
895 * On success: status of zero or more protocol versions has 895 * On success: status of zero or more protocol versions has
896 * been updated; passed-in buffer filled with 896 * been updated; passed-in buffer filled with
897 * '\n'-terminated C string containing positive 897 * '\n'-terminated C string containing positive
898 * or negative integer values representing the 898 * or negative integer values representing the
899 * current status of each protocol version; 899 * current status of each protocol version;
900 * return code is the size in bytes of the string 900 * return code is the size in bytes of the string
901 * On error: return code is zero or a negative errno value 901 * On error: return code is zero or a negative errno value
902 */ 902 */
903 static ssize_t write_versions(struct file *file, char *buf, size_t size) 903 static ssize_t write_versions(struct file *file, char *buf, size_t size)
904 { 904 {
905 ssize_t rv; 905 ssize_t rv;
906 906
907 mutex_lock(&nfsd_mutex); 907 mutex_lock(&nfsd_mutex);
908 rv = __write_versions(file, buf, size); 908 rv = __write_versions(file, buf, size);
909 mutex_unlock(&nfsd_mutex); 909 mutex_unlock(&nfsd_mutex);
910 return rv; 910 return rv;
911 } 911 }
912 912
913 /* 913 /*
914 * Zero-length write. Return a list of NFSD's current listener 914 * Zero-length write. Return a list of NFSD's current listener
915 * transports. 915 * transports.
916 */ 916 */
917 static ssize_t __write_ports_names(char *buf) 917 static ssize_t __write_ports_names(char *buf)
918 { 918 {
919 if (nfsd_serv == NULL) 919 if (nfsd_serv == NULL)
920 return 0; 920 return 0;
921 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT); 921 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
922 } 922 }
923 923
924 /* 924 /*
925 * A single 'fd' number was written, in which case it must be for 925 * A single 'fd' number was written, in which case it must be for
926 * a socket of a supported family/protocol, and we use it as an 926 * a socket of a supported family/protocol, and we use it as an
927 * nfsd listener. 927 * nfsd listener.
928 */ 928 */
929 static ssize_t __write_ports_addfd(char *buf) 929 static ssize_t __write_ports_addfd(char *buf)
930 { 930 {
931 char *mesg = buf; 931 char *mesg = buf;
932 int fd, err; 932 int fd, err;
933 933
934 err = get_int(&mesg, &fd); 934 err = get_int(&mesg, &fd);
935 if (err != 0 || fd < 0) 935 if (err != 0 || fd < 0)
936 return -EINVAL; 936 return -EINVAL;
937 937
938 err = nfsd_create_serv(); 938 err = nfsd_create_serv();
939 if (err != 0) 939 if (err != 0)
940 return err; 940 return err;
941 941
942 err = lockd_up(); 942 err = lockd_up();
943 if (err != 0) 943 if (err != 0)
944 goto out; 944 goto out;
945 945
946 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT); 946 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
947 if (err < 0) 947 if (err < 0)
948 lockd_down(); 948 lockd_down();
949 949
950 out: 950 out:
951 /* Decrease the count, but don't shut down the service */ 951 /* Decrease the count, but don't shut down the service */
952 nfsd_serv->sv_nrthreads--; 952 nfsd_serv->sv_nrthreads--;
953 return err; 953 return err;
954 } 954 }
955 955
956 /* 956 /*
957 * A '-' followed by the 'name' of a socket means we close the socket. 957 * A '-' followed by the 'name' of a socket means we close the socket.
958 */ 958 */
959 static ssize_t __write_ports_delfd(char *buf) 959 static ssize_t __write_ports_delfd(char *buf)
960 { 960 {
961 char *toclose; 961 char *toclose;
962 int len = 0; 962 int len = 0;
963 963
964 toclose = kstrdup(buf + 1, GFP_KERNEL); 964 toclose = kstrdup(buf + 1, GFP_KERNEL);
965 if (toclose == NULL) 965 if (toclose == NULL)
966 return -ENOMEM; 966 return -ENOMEM;
967 967
968 if (nfsd_serv != NULL) 968 if (nfsd_serv != NULL)
969 len = svc_sock_names(nfsd_serv, buf, 969 len = svc_sock_names(nfsd_serv, buf,
970 SIMPLE_TRANSACTION_LIMIT, toclose); 970 SIMPLE_TRANSACTION_LIMIT, toclose);
971 if (len >= 0) 971 if (len >= 0)
972 lockd_down(); 972 lockd_down();
973 973
974 kfree(toclose); 974 kfree(toclose);
975 return len; 975 return len;
976 } 976 }
977 977
978 /* 978 /*
979 * A transport listener is added by writing it's transport name and 979 * A transport listener is added by writing it's transport name and
980 * a port number. 980 * a port number.
981 */ 981 */
982 static ssize_t __write_ports_addxprt(char *buf) 982 static ssize_t __write_ports_addxprt(char *buf)
983 { 983 {
984 char transport[16]; 984 char transport[16];
985 int port, err; 985 int port, err;
986 986
987 if (sscanf(buf, "%15s %4u", transport, &port) != 2) 987 if (sscanf(buf, "%15s %4u", transport, &port) != 2)
988 return -EINVAL; 988 return -EINVAL;
989 989
990 if (port < 1 || port > USHORT_MAX) 990 if (port < 1 || port > USHORT_MAX)
991 return -EINVAL; 991 return -EINVAL;
992 992
993 err = nfsd_create_serv(); 993 err = nfsd_create_serv();
994 if (err != 0) 994 if (err != 0)
995 return err; 995 return err;
996 996
997 err = svc_create_xprt(nfsd_serv, transport, 997 err = svc_create_xprt(nfsd_serv, transport,
998 PF_INET, port, SVC_SOCK_ANONYMOUS); 998 PF_INET, port, SVC_SOCK_ANONYMOUS);
999 if (err < 0) { 999 if (err < 0) {
1000 /* Give a reasonable perror msg for bad transport string */ 1000 /* Give a reasonable perror msg for bad transport string */
1001 if (err == -ENOENT) 1001 if (err == -ENOENT)
1002 err = -EPROTONOSUPPORT; 1002 err = -EPROTONOSUPPORT;
1003 return err; 1003 return err;
1004 } 1004 }
1005 return 0; 1005 return 0;
1006 } 1006 }
1007 1007
1008 /* 1008 /*
1009 * A transport listener is removed by writing a "-", it's transport 1009 * A transport listener is removed by writing a "-", it's transport
1010 * name, and it's port number. 1010 * name, and it's port number.
1011 */ 1011 */
1012 static ssize_t __write_ports_delxprt(char *buf) 1012 static ssize_t __write_ports_delxprt(char *buf)
1013 { 1013 {
1014 struct svc_xprt *xprt; 1014 struct svc_xprt *xprt;
1015 char transport[16]; 1015 char transport[16];
1016 int port; 1016 int port;
1017 1017
1018 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2) 1018 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
1019 return -EINVAL; 1019 return -EINVAL;
1020 1020
1021 if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL) 1021 if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL)
1022 return -EINVAL; 1022 return -EINVAL;
1023 1023
1024 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port); 1024 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
1025 if (xprt == NULL) 1025 if (xprt == NULL)
1026 return -ENOTCONN; 1026 return -ENOTCONN;
1027 1027
1028 svc_close_xprt(xprt); 1028 svc_close_xprt(xprt);
1029 svc_xprt_put(xprt); 1029 svc_xprt_put(xprt);
1030 return 0; 1030 return 0;
1031 } 1031 }
1032 1032
1033 static ssize_t __write_ports(struct file *file, char *buf, size_t size) 1033 static ssize_t __write_ports(struct file *file, char *buf, size_t size)
1034 { 1034 {
1035 if (size == 0) 1035 if (size == 0)
1036 return __write_ports_names(buf); 1036 return __write_ports_names(buf);
1037 1037
1038 if (isdigit(buf[0])) 1038 if (isdigit(buf[0]))
1039 return __write_ports_addfd(buf); 1039 return __write_ports_addfd(buf);
1040 1040
1041 if (buf[0] == '-' && isdigit(buf[1])) 1041 if (buf[0] == '-' && isdigit(buf[1]))
1042 return __write_ports_delfd(buf); 1042 return __write_ports_delfd(buf);
1043 1043
1044 if (isalpha(buf[0])) 1044 if (isalpha(buf[0]))
1045 return __write_ports_addxprt(buf); 1045 return __write_ports_addxprt(buf);
1046 1046
1047 if (buf[0] == '-' && isalpha(buf[1])) 1047 if (buf[0] == '-' && isalpha(buf[1]))
1048 return __write_ports_delxprt(buf); 1048 return __write_ports_delxprt(buf);
1049 1049
1050 return -EINVAL; 1050 return -EINVAL;
1051 } 1051 }
1052 1052
1053 /** 1053 /**
1054 * write_ports - Pass a socket file descriptor or transport name to listen on 1054 * write_ports - Pass a socket file descriptor or transport name to listen on
1055 * 1055 *
1056 * Input: 1056 * Input:
1057 * buf: ignored 1057 * buf: ignored
1058 * size: zero 1058 * size: zero
1059 * Output: 1059 * Output:
1060 * On success: passed-in buffer filled with a '\n'-terminated C 1060 * On success: passed-in buffer filled with a '\n'-terminated C
1061 * string containing a whitespace-separated list of 1061 * string containing a whitespace-separated list of
1062 * named NFSD listeners; 1062 * named NFSD listeners;
1063 * return code is the size in bytes of the string 1063 * return code is the size in bytes of the string
1064 * On error: return code is zero or a negative errno value 1064 * On error: return code is zero or a negative errno value
1065 * 1065 *
1066 * OR 1066 * OR
1067 * 1067 *
1068 * Input: 1068 * Input:
1069 * buf: C string containing an unsigned 1069 * buf: C string containing an unsigned
1070 * integer value representing a bound 1070 * integer value representing a bound
1071 * but unconnected socket that is to be 1071 * but unconnected socket that is to be
1072 * used as an NFSD listener; listen(3) 1072 * used as an NFSD listener; listen(3)
1073 * must be called for a SOCK_STREAM 1073 * must be called for a SOCK_STREAM
1074 * socket, otherwise it is ignored 1074 * socket, otherwise it is ignored
1075 * size: non-zero length of C string in @buf 1075 * size: non-zero length of C string in @buf
1076 * Output: 1076 * Output:
1077 * On success: NFS service is started; 1077 * On success: NFS service is started;
1078 * passed-in buffer filled with a '\n'-terminated C 1078 * passed-in buffer filled with a '\n'-terminated C
1079 * string containing a unique alphanumeric name of 1079 * string containing a unique alphanumeric name of
1080 * the listener; 1080 * the listener;
1081 * return code is the size in bytes of the string 1081 * return code is the size in bytes of the string
1082 * On error: return code is a negative errno value 1082 * On error: return code is a negative errno value
1083 * 1083 *
1084 * OR 1084 * OR
1085 * 1085 *
1086 * Input: 1086 * Input:
1087 * buf: C string containing a "-" followed 1087 * buf: C string containing a "-" followed
1088 * by an integer value representing a 1088 * by an integer value representing a
1089 * previously passed in socket file 1089 * previously passed in socket file
1090 * descriptor 1090 * descriptor
1091 * size: non-zero length of C string in @buf 1091 * size: non-zero length of C string in @buf
1092 * Output: 1092 * Output:
1093 * On success: NFS service no longer listens on that socket; 1093 * On success: NFS service no longer listens on that socket;
1094 * passed-in buffer filled with a '\n'-terminated C 1094 * passed-in buffer filled with a '\n'-terminated C
1095 * string containing a unique name of the listener; 1095 * string containing a unique name of the listener;
1096 * return code is the size in bytes of the string 1096 * return code is the size in bytes of the string
1097 * On error: return code is a negative errno value 1097 * On error: return code is a negative errno value
1098 * 1098 *
1099 * OR 1099 * OR
1100 * 1100 *
1101 * Input: 1101 * Input:
1102 * buf: C string containing a transport 1102 * buf: C string containing a transport
1103 * name and an unsigned integer value 1103 * name and an unsigned integer value
1104 * representing the port to listen on, 1104 * representing the port to listen on,
1105 * separated by whitespace 1105 * separated by whitespace
1106 * size: non-zero length of C string in @buf 1106 * size: non-zero length of C string in @buf
1107 * Output: 1107 * Output:
1108 * On success: returns zero; NFS service is started 1108 * On success: returns zero; NFS service is started
1109 * On error: return code is a negative errno value 1109 * On error: return code is a negative errno value
1110 * 1110 *
1111 * OR 1111 * OR
1112 * 1112 *
1113 * Input: 1113 * Input:
1114 * buf: C string containing a "-" followed 1114 * buf: C string containing a "-" followed
1115 * by a transport name and an unsigned 1115 * by a transport name and an unsigned
1116 * integer value representing the port 1116 * integer value representing the port
1117 * to listen on, separated by whitespace 1117 * to listen on, separated by whitespace
1118 * size: non-zero length of C string in @buf 1118 * size: non-zero length of C string in @buf
1119 * Output: 1119 * Output:
1120 * On success: returns zero; NFS service no longer listens 1120 * On success: returns zero; NFS service no longer listens
1121 * on that transport 1121 * on that transport
1122 * On error: return code is a negative errno value 1122 * On error: return code is a negative errno value
1123 */ 1123 */
1124 static ssize_t write_ports(struct file *file, char *buf, size_t size) 1124 static ssize_t write_ports(struct file *file, char *buf, size_t size)
1125 { 1125 {
1126 ssize_t rv; 1126 ssize_t rv;
1127 1127
1128 mutex_lock(&nfsd_mutex); 1128 mutex_lock(&nfsd_mutex);
1129 rv = __write_ports(file, buf, size); 1129 rv = __write_ports(file, buf, size);
1130 mutex_unlock(&nfsd_mutex); 1130 mutex_unlock(&nfsd_mutex);
1131 return rv; 1131 return rv;
1132 } 1132 }
1133 1133
1134 1134
1135 int nfsd_max_blksize; 1135 int nfsd_max_blksize;
1136 1136
1137 /** 1137 /**
1138 * write_maxblksize - Set or report the current NFS blksize 1138 * write_maxblksize - Set or report the current NFS blksize
1139 * 1139 *
1140 * Input: 1140 * Input:
1141 * buf: ignored 1141 * buf: ignored
1142 * size: zero 1142 * size: zero
1143 * 1143 *
1144 * OR 1144 * OR
1145 * 1145 *
1146 * Input: 1146 * Input:
1147 * buf: C string containing an unsigned 1147 * buf: C string containing an unsigned
1148 * integer value representing the new 1148 * integer value representing the new
1149 * NFS blksize 1149 * NFS blksize
1150 * size: non-zero length of C string in @buf 1150 * size: non-zero length of C string in @buf
1151 * Output: 1151 * Output:
1152 * On success: passed-in buffer filled with '\n'-terminated C string 1152 * On success: passed-in buffer filled with '\n'-terminated C string
1153 * containing numeric value of the current NFS blksize 1153 * containing numeric value of the current NFS blksize
1154 * setting; 1154 * setting;
1155 * return code is the size in bytes of the string 1155 * return code is the size in bytes of the string
1156 * On error: return code is zero or a negative errno value 1156 * On error: return code is zero or a negative errno value
1157 */ 1157 */
1158 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size) 1158 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
1159 { 1159 {
1160 char *mesg = buf; 1160 char *mesg = buf;
1161 if (size > 0) { 1161 if (size > 0) {
1162 int bsize; 1162 int bsize;
1163 int rv = get_int(&mesg, &bsize); 1163 int rv = get_int(&mesg, &bsize);
1164 if (rv) 1164 if (rv)
1165 return rv; 1165 return rv;
1166 /* force bsize into allowed range and 1166 /* force bsize into allowed range and
1167 * required alignment. 1167 * required alignment.
1168 */ 1168 */
1169 if (bsize < 1024) 1169 if (bsize < 1024)
1170 bsize = 1024; 1170 bsize = 1024;
1171 if (bsize > NFSSVC_MAXBLKSIZE) 1171 if (bsize > NFSSVC_MAXBLKSIZE)
1172 bsize = NFSSVC_MAXBLKSIZE; 1172 bsize = NFSSVC_MAXBLKSIZE;
1173 bsize &= ~(1024-1); 1173 bsize &= ~(1024-1);
1174 mutex_lock(&nfsd_mutex); 1174 mutex_lock(&nfsd_mutex);
1175 if (nfsd_serv && nfsd_serv->sv_nrthreads) { 1175 if (nfsd_serv && nfsd_serv->sv_nrthreads) {
1176 mutex_unlock(&nfsd_mutex); 1176 mutex_unlock(&nfsd_mutex);
1177 return -EBUSY; 1177 return -EBUSY;
1178 } 1178 }
1179 nfsd_max_blksize = bsize; 1179 nfsd_max_blksize = bsize;
1180 mutex_unlock(&nfsd_mutex); 1180 mutex_unlock(&nfsd_mutex);
1181 } 1181 }
1182 return sprintf(buf, "%d\n", nfsd_max_blksize); 1182 return sprintf(buf, "%d\n", nfsd_max_blksize);
1183 } 1183 }
1184 1184
1185 #ifdef CONFIG_NFSD_V4 1185 #ifdef CONFIG_NFSD_V4
1186 extern time_t nfs4_leasetime(void); 1186 extern time_t nfs4_leasetime(void);
1187 1187
1188 static ssize_t __write_leasetime(struct file *file, char *buf, size_t size) 1188 static ssize_t __write_leasetime(struct file *file, char *buf, size_t size)
1189 { 1189 {
1190 /* if size > 10 seconds, call 1190 /* if size > 10 seconds, call
1191 * nfs4_reset_lease() then write out the new lease (seconds) as reply 1191 * nfs4_reset_lease() then write out the new lease (seconds) as reply
1192 */ 1192 */
1193 char *mesg = buf; 1193 char *mesg = buf;
1194 int rv, lease; 1194 int rv, lease;
1195 1195
1196 if (size > 0) { 1196 if (size > 0) {
1197 if (nfsd_serv) 1197 if (nfsd_serv)
1198 return -EBUSY; 1198 return -EBUSY;
1199 rv = get_int(&mesg, &lease); 1199 rv = get_int(&mesg, &lease);
1200 if (rv) 1200 if (rv)
1201 return rv; 1201 return rv;
1202 if (lease < 10 || lease > 3600) 1202 if (lease < 10 || lease > 3600)
1203 return -EINVAL; 1203 return -EINVAL;
1204 nfs4_reset_lease(lease); 1204 nfs4_reset_lease(lease);
1205 } 1205 }
1206 sprintf(buf, "%ld\n", nfs4_lease_time()); 1206 sprintf(buf, "%ld\n", nfs4_lease_time());
1207 return strlen(buf); 1207 return strlen(buf);
1208 } 1208 }
1209 1209
1210 /** 1210 /**
1211 * write_leasetime - Set or report the current NFSv4 lease time 1211 * write_leasetime - Set or report the current NFSv4 lease time
1212 * 1212 *
1213 * Input: 1213 * Input:
1214 * buf: ignored 1214 * buf: ignored
1215 * size: zero 1215 * size: zero
1216 * 1216 *
1217 * OR 1217 * OR
1218 * 1218 *
1219 * Input: 1219 * Input:
1220 * buf: C string containing an unsigned 1220 * buf: C string containing an unsigned
1221 * integer value representing the new 1221 * integer value representing the new
1222 * NFSv4 lease expiry time 1222 * NFSv4 lease expiry time
1223 * size: non-zero length of C string in @buf 1223 * size: non-zero length of C string in @buf
1224 * Output: 1224 * Output:
1225 * On success: passed-in buffer filled with '\n'-terminated C 1225 * On success: passed-in buffer filled with '\n'-terminated C
1226 * string containing unsigned integer value of the 1226 * string containing unsigned integer value of the
1227 * current lease expiry time; 1227 * current lease expiry time;
1228 * return code is the size in bytes of the string 1228 * return code is the size in bytes of the string
1229 * On error: return code is zero or a negative errno value 1229 * On error: return code is zero or a negative errno value
1230 */ 1230 */
1231 static ssize_t write_leasetime(struct file *file, char *buf, size_t size) 1231 static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
1232 { 1232 {
1233 ssize_t rv; 1233 ssize_t rv;
1234 1234
1235 mutex_lock(&nfsd_mutex); 1235 mutex_lock(&nfsd_mutex);
1236 rv = __write_leasetime(file, buf, size); 1236 rv = __write_leasetime(file, buf, size);
1237 mutex_unlock(&nfsd_mutex); 1237 mutex_unlock(&nfsd_mutex);
1238 return rv; 1238 return rv;
1239 } 1239 }
1240 1240
1241 extern char *nfs4_recoverydir(void); 1241 extern char *nfs4_recoverydir(void);
1242 1242
1243 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size) 1243 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
1244 { 1244 {
1245 char *mesg = buf; 1245 char *mesg = buf;
1246 char *recdir; 1246 char *recdir;
1247 int len, status; 1247 int len, status;
1248 1248
1249 if (size > 0) { 1249 if (size > 0) {
1250 if (nfsd_serv) 1250 if (nfsd_serv)
1251 return -EBUSY; 1251 return -EBUSY;
1252 if (size > PATH_MAX || buf[size-1] != '\n') 1252 if (size > PATH_MAX || buf[size-1] != '\n')
1253 return -EINVAL; 1253 return -EINVAL;
1254 buf[size-1] = 0; 1254 buf[size-1] = 0;
1255 1255
1256 recdir = mesg; 1256 recdir = mesg;
1257 len = qword_get(&mesg, recdir, size); 1257 len = qword_get(&mesg, recdir, size);
1258 if (len <= 0) 1258 if (len <= 0)
1259 return -EINVAL; 1259 return -EINVAL;
1260 1260
1261 status = nfs4_reset_recoverydir(recdir); 1261 status = nfs4_reset_recoverydir(recdir);
1262 } 1262 }
1263 sprintf(buf, "%s\n", nfs4_recoverydir()); 1263
1264 return strlen(buf); 1264 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1265 nfs4_recoverydir());
1265 } 1266 }
1266 1267
1267 /** 1268 /**
1268 * write_recoverydir - Set or report the pathname of the recovery directory 1269 * write_recoverydir - Set or report the pathname of the recovery directory
1269 * 1270 *
1270 * Input: 1271 * Input:
1271 * buf: ignored 1272 * buf: ignored
1272 * size: zero 1273 * size: zero
1273 * 1274 *
1274 * OR 1275 * OR
1275 * 1276 *
1276 * Input: 1277 * Input:
1277 * buf: C string containing the pathname 1278 * buf: C string containing the pathname
1278 * of the directory on a local file 1279 * of the directory on a local file
1279 * system containing permanent NFSv4 1280 * system containing permanent NFSv4
1280 * recovery data 1281 * recovery data
1281 * size: non-zero length of C string in @buf 1282 * size: non-zero length of C string in @buf
1282 * Output: 1283 * Output:
1283 * On success: passed-in buffer filled with '\n'-terminated C string 1284 * On success: passed-in buffer filled with '\n'-terminated C string
1284 * containing the current recovery pathname setting; 1285 * containing the current recovery pathname setting;
1285 * return code is the size in bytes of the string 1286 * return code is the size in bytes of the string
1286 * On error: return code is zero or a negative errno value 1287 * On error: return code is zero or a negative errno value
1287 */ 1288 */
1288 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size) 1289 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1289 { 1290 {
1290 ssize_t rv; 1291 ssize_t rv;
1291 1292
1292 mutex_lock(&nfsd_mutex); 1293 mutex_lock(&nfsd_mutex);
1293 rv = __write_recoverydir(file, buf, size); 1294 rv = __write_recoverydir(file, buf, size);
1294 mutex_unlock(&nfsd_mutex); 1295 mutex_unlock(&nfsd_mutex);
1295 return rv; 1296 return rv;
1296 } 1297 }
1297 1298
1298 #endif 1299 #endif
1299 1300
1300 /*----------------------------------------------------------------------------*/ 1301 /*----------------------------------------------------------------------------*/
1301 /* 1302 /*
1302 * populating the filesystem. 1303 * populating the filesystem.
1303 */ 1304 */
1304 1305
1305 static int nfsd_fill_super(struct super_block * sb, void * data, int silent) 1306 static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1306 { 1307 {
1307 static struct tree_descr nfsd_files[] = { 1308 static struct tree_descr nfsd_files[] = {
1308 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR}, 1309 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
1309 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR}, 1310 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
1310 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR}, 1311 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
1311 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR}, 1312 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
1312 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR}, 1313 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
1313 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR}, 1314 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
1314 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR}, 1315 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
1315 [NFSD_List] = {"exports", &exports_operations, S_IRUGO}, 1316 [NFSD_List] = {"exports", &exports_operations, S_IRUGO},
1316 [NFSD_FO_UnlockIP] = {"unlock_ip", 1317 [NFSD_FO_UnlockIP] = {"unlock_ip",
1317 &transaction_ops, S_IWUSR|S_IRUSR}, 1318 &transaction_ops, S_IWUSR|S_IRUSR},
1318 [NFSD_FO_UnlockFS] = {"unlock_filesystem", 1319 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1319 &transaction_ops, S_IWUSR|S_IRUSR}, 1320 &transaction_ops, S_IWUSR|S_IRUSR},
1320 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR}, 1321 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1321 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1322 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
1322 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1323 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
1323 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO}, 1324 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
1324 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR}, 1325 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
1325 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO}, 1326 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
1326 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO}, 1327 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
1327 #ifdef CONFIG_NFSD_V4 1328 #ifdef CONFIG_NFSD_V4
1328 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1329 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
1329 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR}, 1330 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
1330 #endif 1331 #endif
1331 /* last one */ {""} 1332 /* last one */ {""}
1332 }; 1333 };
1333 return simple_fill_super(sb, 0x6e667364, nfsd_files); 1334 return simple_fill_super(sb, 0x6e667364, nfsd_files);
1334 } 1335 }
1335 1336
1336 static int nfsd_get_sb(struct file_system_type *fs_type, 1337 static int nfsd_get_sb(struct file_system_type *fs_type,
1337 int flags, const char *dev_name, void *data, struct vfsmount *mnt) 1338 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1338 { 1339 {
1339 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt); 1340 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
1340 } 1341 }
1341 1342
1342 static struct file_system_type nfsd_fs_type = { 1343 static struct file_system_type nfsd_fs_type = {
1343 .owner = THIS_MODULE, 1344 .owner = THIS_MODULE,
1344 .name = "nfsd", 1345 .name = "nfsd",
1345 .get_sb = nfsd_get_sb, 1346 .get_sb = nfsd_get_sb,
1346 .kill_sb = kill_litter_super, 1347 .kill_sb = kill_litter_super,
1347 }; 1348 };
1348 1349
1349 #ifdef CONFIG_PROC_FS 1350 #ifdef CONFIG_PROC_FS
1350 static int create_proc_exports_entry(void) 1351 static int create_proc_exports_entry(void)
1351 { 1352 {
1352 struct proc_dir_entry *entry; 1353 struct proc_dir_entry *entry;
1353 1354
1354 entry = proc_mkdir("fs/nfs", NULL); 1355 entry = proc_mkdir("fs/nfs", NULL);
1355 if (!entry) 1356 if (!entry)
1356 return -ENOMEM; 1357 return -ENOMEM;
1357 entry = proc_create("exports", 0, entry, &exports_operations); 1358 entry = proc_create("exports", 0, entry, &exports_operations);
1358 if (!entry) 1359 if (!entry)
1359 return -ENOMEM; 1360 return -ENOMEM;
1360 return 0; 1361 return 0;
1361 } 1362 }
1362 #else /* CONFIG_PROC_FS */ 1363 #else /* CONFIG_PROC_FS */
1363 static int create_proc_exports_entry(void) 1364 static int create_proc_exports_entry(void)
1364 { 1365 {
1365 return 0; 1366 return 0;
1366 } 1367 }
1367 #endif 1368 #endif
1368 1369
1369 static int __init init_nfsd(void) 1370 static int __init init_nfsd(void)
1370 { 1371 {
1371 int retval; 1372 int retval;
1372 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n"); 1373 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1373 1374
1374 retval = nfs4_state_init(); /* nfs4 locking state */ 1375 retval = nfs4_state_init(); /* nfs4 locking state */
1375 if (retval) 1376 if (retval)
1376 return retval; 1377 return retval;
1377 nfsd_stat_init(); /* Statistics */ 1378 nfsd_stat_init(); /* Statistics */
1378 retval = nfsd_reply_cache_init(); 1379 retval = nfsd_reply_cache_init();
1379 if (retval) 1380 if (retval)
1380 goto out_free_stat; 1381 goto out_free_stat;
1381 retval = nfsd_export_init(); 1382 retval = nfsd_export_init();
1382 if (retval) 1383 if (retval)
1383 goto out_free_cache; 1384 goto out_free_cache;
1384 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 1385 nfsd_lockd_init(); /* lockd->nfsd callbacks */
1385 retval = nfsd_idmap_init(); 1386 retval = nfsd_idmap_init();
1386 if (retval) 1387 if (retval)
1387 goto out_free_lockd; 1388 goto out_free_lockd;
1388 retval = create_proc_exports_entry(); 1389 retval = create_proc_exports_entry();
1389 if (retval) 1390 if (retval)
1390 goto out_free_idmap; 1391 goto out_free_idmap;
1391 retval = register_filesystem(&nfsd_fs_type); 1392 retval = register_filesystem(&nfsd_fs_type);
1392 if (retval) 1393 if (retval)
1393 goto out_free_all; 1394 goto out_free_all;
1394 return 0; 1395 return 0;
1395 out_free_all: 1396 out_free_all:
1396 remove_proc_entry("fs/nfs/exports", NULL); 1397 remove_proc_entry("fs/nfs/exports", NULL);
1397 remove_proc_entry("fs/nfs", NULL); 1398 remove_proc_entry("fs/nfs", NULL);
1398 out_free_idmap: 1399 out_free_idmap:
1399 nfsd_idmap_shutdown(); 1400 nfsd_idmap_shutdown();
1400 out_free_lockd: 1401 out_free_lockd:
1401 nfsd_lockd_shutdown(); 1402 nfsd_lockd_shutdown();
1402 nfsd_export_shutdown(); 1403 nfsd_export_shutdown();
1403 out_free_cache: 1404 out_free_cache:
1404 nfsd_reply_cache_shutdown(); 1405 nfsd_reply_cache_shutdown();
1405 out_free_stat: 1406 out_free_stat:
1406 nfsd_stat_shutdown(); 1407 nfsd_stat_shutdown();
1407 nfsd4_free_slabs(); 1408 nfsd4_free_slabs();
1408 return retval; 1409 return retval;
1409 } 1410 }
1410 1411
1411 static void __exit exit_nfsd(void) 1412 static void __exit exit_nfsd(void)
1412 { 1413 {
1413 nfsd_export_shutdown(); 1414 nfsd_export_shutdown();
1414 nfsd_reply_cache_shutdown(); 1415 nfsd_reply_cache_shutdown();
1415 remove_proc_entry("fs/nfs/exports", NULL); 1416 remove_proc_entry("fs/nfs/exports", NULL);
1416 remove_proc_entry("fs/nfs", NULL); 1417 remove_proc_entry("fs/nfs", NULL);
1417 nfsd_stat_shutdown(); 1418 nfsd_stat_shutdown();
1418 nfsd_lockd_shutdown(); 1419 nfsd_lockd_shutdown();
1419 nfsd_idmap_shutdown(); 1420 nfsd_idmap_shutdown();
1420 nfsd4_free_slabs(); 1421 nfsd4_free_slabs();
1421 unregister_filesystem(&nfsd_fs_type); 1422 unregister_filesystem(&nfsd_fs_type);
1422 } 1423 }
1423 1424
1424 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1425 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1425 MODULE_LICENSE("GPL"); 1426 MODULE_LICENSE("GPL");
1426 module_init(init_nfsd) 1427 module_init(init_nfsd)
1427 module_exit(exit_nfsd) 1428 module_exit(exit_nfsd)
1428 1429