Print this page
re #13613 rb4516 Tunables needs volatile keyword
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/nfs/nfs4_common.c
+++ new/usr/src/uts/common/fs/nfs/nfs4_common.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 - *
24 - * Copyright 2011, 2012 Nexenta Systems, Inc. All rights reserved.
23 + * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 24 * Copyright 2013 Joyent, Inc. All rights reserved.
26 25 */
27 26
28 27 /*
29 28 * This is the loadable module wrapper.
30 29 */
31 30 #include <sys/systm.h>
32 31 #include <sys/modctl.h>
33 32 #include <sys/syscall.h>
34 33 #include <sys/ddi.h>
35 34 #include <sys/cmn_err.h>
36 35
37 36 #include <nfs/nfs.h>
38 37 #include <nfs/nfs_clnt.h>
39 38 #include <nfs/nfs4.h>
40 39 #include <nfs/rnode4.h>
41 40
42 41 /*
43 42 * The global tag list.
44 43 */
45 44 ctag_t nfs4_ctags[] = NFS4_TAG_INITIALIZER;
46 45
47 46 /*
48 47 * The NFS Version 4 client VFS.
49 48 */
50 49 static vfsdef_t vfw4 = {
51 50 VFSDEF_VERSION,
52 51 "nfs4",
53 52 nfs4init,
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
54 53 VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS,
55 54 NULL
56 55 };
57 56
58 57 struct modlfs modlfs4 = {
59 58 &mod_fsops,
60 59 "network filesystem version 4",
61 60 &vfw4
62 61 };
63 62
64 -uint_t nfs4_max_transfer_size = 32 * 1024;
65 -uint_t nfs4_max_transfer_size_cots = 1024 * 1024;
66 -uint_t nfs4_max_transfer_size_rdma = 1024 * 1024;
63 +volatile uint_t nfs4_max_transfer_size = 32 * 1024;
64 +volatile uint_t nfs4_max_transfer_size_cots = 1024 * 1024;
65 +volatile uint_t nfs4_max_transfer_size_rdma = 1024 * 1024;
67 66
68 67 int
69 68 nfs4tsize(void)
70 69 {
71 70 /*
72 71 * For the moment, just return nfs4_max_transfer_size until we
73 72 * can query the appropriate transport.
74 73 */
75 74 return (nfs4_max_transfer_size);
76 75 }
77 76
78 77 uint_t
79 78 nfs4_tsize(struct knetconfig *knp)
80 79 {
81 80
82 81 if (knp->knc_semantics == NC_TPI_COTS_ORD ||
83 82 knp->knc_semantics == NC_TPI_COTS)
84 83 return (nfs4_max_transfer_size_cots);
85 84 if (knp->knc_semantics == NC_TPI_RDMA)
86 85 return (nfs4_max_transfer_size_rdma);
87 86 return (nfs4_max_transfer_size);
88 87 }
89 88
90 89 uint_t
91 90 rfs4_tsize(struct svc_req *req)
92 91 {
93 92
94 93 if (req->rq_xprt->xp_type == T_COTS_ORD ||
95 94 req->rq_xprt->xp_type == T_COTS)
96 95 return (nfs4_max_transfer_size_cots);
97 96 if (req->rq_xprt->xp_type == T_RDMA)
98 97 return (nfs4_max_transfer_size_rdma);
99 98 return (nfs4_max_transfer_size);
100 99 }
101 100
102 101 int
103 102 nfs4_setopts(vnode_t *vp, model_t model, struct nfs_args *buf)
104 103 {
105 104 mntinfo4_t *mi; /* mount info, pointed at by vfs */
106 105 STRUCT_HANDLE(nfs_args, args);
107 106 int flags;
108 107
109 108 #ifdef lint
110 109 model = model;
111 110 #endif
112 111
113 112 STRUCT_SET_HANDLE(args, model, buf);
114 113
115 114 flags = STRUCT_FGET(args, flags);
116 115
117 116 /*
118 117 * Set option fields in mount info record
119 118 */
120 119 mi = VTOMI4(vp);
121 120
122 121
123 122 if (flags & NFSMNT_NOAC) {
124 123 mutex_enter(&mi->mi_lock);
125 124 mi->mi_flags |= MI4_NOAC;
126 125 mutex_exit(&mi->mi_lock);
127 126 PURGE_ATTRCACHE4(vp);
128 127 }
129 128
130 129 mutex_enter(&mi->mi_lock);
131 130 if (flags & NFSMNT_NOCTO)
132 131 mi->mi_flags |= MI4_NOCTO;
133 132 if (flags & NFSMNT_LLOCK)
134 133 mi->mi_flags |= MI4_LLOCK;
135 134 if (flags & NFSMNT_GRPID)
136 135 mi->mi_flags |= MI4_GRPID;
137 136 mutex_exit(&mi->mi_lock);
138 137
139 138 if (flags & NFSMNT_RETRANS) {
140 139 if (STRUCT_FGET(args, retrans) < 0)
141 140 return (EINVAL);
142 141 mi->mi_retrans = STRUCT_FGET(args, retrans);
143 142 }
144 143 if (flags & NFSMNT_TIMEO) {
145 144 if (STRUCT_FGET(args, timeo) <= 0)
146 145 return (EINVAL);
147 146 mi->mi_timeo = STRUCT_FGET(args, timeo);
148 147 }
149 148 if (flags & NFSMNT_RSIZE) {
150 149 if (STRUCT_FGET(args, rsize) <= 0)
151 150 return (EINVAL);
152 151 mi->mi_tsize = MIN(mi->mi_tsize, STRUCT_FGET(args, rsize));
153 152 mi->mi_curread = MIN(mi->mi_curread, mi->mi_tsize);
154 153 }
155 154 if (flags & NFSMNT_WSIZE) {
156 155 if (STRUCT_FGET(args, wsize) <= 0)
157 156 return (EINVAL);
158 157 mi->mi_stsize = MIN(mi->mi_stsize, STRUCT_FGET(args, wsize));
159 158 mi->mi_curwrite = MIN(mi->mi_curwrite, mi->mi_stsize);
160 159 }
161 160 if (flags & NFSMNT_ACREGMIN) {
162 161 if (STRUCT_FGET(args, acregmin) < 0)
163 162 mi->mi_acregmin = SEC2HR(ACMINMAX);
164 163 else
165 164 mi->mi_acregmin = SEC2HR(MIN(STRUCT_FGET(args,
166 165 acregmin), ACMINMAX));
167 166 }
168 167 if (flags & NFSMNT_ACREGMAX) {
169 168 if (STRUCT_FGET(args, acregmax) < 0)
170 169 mi->mi_acregmax = SEC2HR(ACMAXMAX);
171 170 else
172 171 mi->mi_acregmax = SEC2HR(MIN(STRUCT_FGET(args,
173 172 acregmax), ACMAXMAX));
174 173 }
175 174 if (flags & NFSMNT_ACDIRMIN) {
176 175 if (STRUCT_FGET(args, acdirmin) < 0)
177 176 mi->mi_acdirmin = SEC2HR(ACMINMAX);
178 177 else
179 178 mi->mi_acdirmin = SEC2HR(MIN(STRUCT_FGET(args,
180 179 acdirmin), ACMINMAX));
181 180 }
182 181 if (flags & NFSMNT_ACDIRMAX) {
183 182 if (STRUCT_FGET(args, acdirmax) < 0)
184 183 mi->mi_acdirmax = SEC2HR(ACMAXMAX);
185 184 else
186 185 mi->mi_acdirmax = SEC2HR(MIN(STRUCT_FGET(args,
187 186 acdirmax), ACMAXMAX));
188 187 }
189 188
190 189 return (0);
191 190 }
192 191
193 192 /*
194 193 * This returns 1 if the seqid should be bumped upon receiving this
195 194 * 'res->status' for a seqid dependent operation; otherwise return 0.
196 195 */
197 196 int
198 197 nfs4_need_to_bump_seqid(COMPOUND4res_clnt *res)
199 198 {
200 199 int i, seqid_dep_op = 0;
201 200 nfs_resop4 *resop;
202 201
203 202 resop = res->array;
204 203
205 204 for (i = 0; i < res->array_len; i++) {
206 205 switch (resop[i].resop) {
207 206 case OP_CLOSE:
208 207 case OP_OPEN:
209 208 case OP_OPEN_CONFIRM:
210 209 case OP_OPEN_DOWNGRADE:
211 210 case OP_LOCK:
212 211 case OP_LOCKU:
213 212 seqid_dep_op = 1;
214 213 break;
215 214 default:
216 215 continue;
217 216 }
218 217 }
219 218
220 219 if (!seqid_dep_op)
221 220 return (0);
222 221
223 222 switch (res->status) {
224 223 case NFS4ERR_STALE_CLIENTID:
225 224 case NFS4ERR_STALE_STATEID:
226 225 case NFS4ERR_BAD_STATEID:
227 226 case NFS4ERR_BAD_SEQID:
228 227 case NFS4ERR_BADXDR:
229 228 case NFS4ERR_OLD_STATEID:
230 229 case NFS4ERR_RESOURCE:
231 230 case NFS4ERR_NOFILEHANDLE:
232 231 return (0);
233 232 default:
234 233 return (1);
235 234 }
236 235 }
237 236
238 237 /*
239 238 * Returns 1 if the error is a RPC error that we should retry.
240 239 */
241 240 int
242 241 nfs4_rpc_retry_error(int error)
243 242 {
244 243 switch (error) {
245 244 case ETIMEDOUT:
246 245 case ECONNREFUSED:
247 246 case ENETDOWN:
248 247 case ENETUNREACH:
249 248 case ENETRESET:
250 249 case ECONNABORTED:
251 250 case EHOSTUNREACH:
252 251 case ECONNRESET:
253 252 return (1);
254 253 default:
255 254 return (0);
256 255 }
257 256 }
258 257
259 258 char *
260 259 nfs4_stat_to_str(nfsstat4 error)
261 260 {
262 261 static char buf[40];
263 262
264 263 switch (error) {
265 264 case NFS4_OK:
266 265 return ("NFS4_OK");
267 266 case NFS4ERR_PERM:
268 267 return ("NFS4ERR_PERM");
269 268 case NFS4ERR_NOENT:
270 269 return ("NFS4ERR_NOENT");
271 270 case NFS4ERR_IO:
272 271 return ("NFS4ERR_IO");
273 272 case NFS4ERR_NXIO:
274 273 return ("NFS4ERR_NXIO");
275 274 case NFS4ERR_ACCESS:
276 275 return ("NFS4ERR_ACCESS");
277 276 case NFS4ERR_EXIST:
278 277 return ("NFS4ERR_EXIST");
279 278 case NFS4ERR_XDEV:
280 279 return ("NFS4ERR_XDEV");
281 280 case NFS4ERR_NOTDIR:
282 281 return ("NFS4ERR_NOTDIR");
283 282 case NFS4ERR_ISDIR:
284 283 return ("NFS4ERR_ISDIR");
285 284 case NFS4ERR_INVAL:
286 285 return ("NFS4ERR_INVAL");
287 286 case NFS4ERR_FBIG:
288 287 return ("NFS4ERR_FBIG");
289 288 case NFS4ERR_NOSPC:
290 289 return ("NFS4ERR_NOSPC");
291 290 case NFS4ERR_ROFS:
292 291 return ("NFS4ERR_ROFS");
293 292 case NFS4ERR_MLINK:
294 293 return ("NFS4ERR_MLINK");
295 294 case NFS4ERR_NAMETOOLONG:
296 295 return ("NFS4ERR_NAMETOOLONG");
297 296 case NFS4ERR_NOTEMPTY:
298 297 return ("NFSS4ERR_NOTEMPTY");
299 298 case NFS4ERR_DQUOT:
300 299 return ("NFS4ERR_DQUOT");
301 300 case NFS4ERR_STALE:
302 301 return ("NFS4ERR_STALE");
303 302 case NFS4ERR_BADHANDLE:
304 303 return ("NFS4ERR_BADHANDLE");
305 304 case NFS4ERR_BAD_COOKIE:
306 305 return ("NFS4ERR_BAD_COOKIE");
307 306 case NFS4ERR_NOTSUPP:
308 307 return ("NFS4ERR_NOTSUPP");
309 308 case NFS4ERR_TOOSMALL:
310 309 return ("NFS4ERR_TOOSMALL");
311 310 case NFS4ERR_SERVERFAULT:
312 311 return ("NFS4ERR_SERVERFAULT");
313 312 case NFS4ERR_BADTYPE:
314 313 return ("NFS4ERR_BADTYPE");
315 314 case NFS4ERR_DELAY:
316 315 return ("NFS4ERR_DELAY");
317 316 case NFS4ERR_SAME:
318 317 return ("NFS4ERR_SAME");
319 318 case NFS4ERR_DENIED:
320 319 return ("NFS4ERR_DENIED");
321 320 case NFS4ERR_EXPIRED:
322 321 return ("NFS4ERR_EXPIRED");
323 322 case NFS4ERR_LOCKED:
324 323 return ("NFS4ERR_LOCKED");
325 324 case NFS4ERR_GRACE:
326 325 return ("NFS4ERR_GRACE");
327 326 case NFS4ERR_FHEXPIRED:
328 327 return ("NFS4ERR_FHEXPIRED");
329 328 case NFS4ERR_SHARE_DENIED:
330 329 return ("NFS4ERR_SHARE_DENIED");
331 330 case NFS4ERR_WRONGSEC:
332 331 return ("NFS4ERR_WRONGSEC");
333 332 case NFS4ERR_CLID_INUSE:
334 333 return ("NFS4ERR_CLID_INUSE");
335 334 case NFS4ERR_RESOURCE:
336 335 return ("NFS4ERR_RESOURCE");
337 336 case NFS4ERR_MOVED:
338 337 return ("NFS4ERR_MOVED");
339 338 case NFS4ERR_NOFILEHANDLE:
340 339 return ("NFS4ERR_NOFILEHANDLE");
341 340 case NFS4ERR_MINOR_VERS_MISMATCH:
342 341 return ("NFS4ERR_MINOR_VERS_MISMATCH");
343 342 case NFS4ERR_STALE_CLIENTID:
344 343 return ("NFS4ERR_STALE_CLIENTID");
345 344 case NFS4ERR_STALE_STATEID:
346 345 return ("NFS4ERR_STALE_STATEID");
347 346 case NFS4ERR_OLD_STATEID:
348 347 return ("NFS4ERR_OLD_STATEID");
349 348 case NFS4ERR_BAD_STATEID:
350 349 return ("NFS4ERR_BAD_STATEID");
351 350 case NFS4ERR_BAD_SEQID:
352 351 return ("NFS4ERR_BAD_SEQID");
353 352 case NFS4ERR_NOT_SAME:
354 353 return ("NFS4ERR_NOT_SAME");
355 354 case NFS4ERR_LOCK_RANGE:
356 355 return ("NFS4ERR_LOCK_RANGE");
357 356 case NFS4ERR_SYMLINK:
358 357 return ("NFS4ERR_SYMLINK");
359 358 case NFS4ERR_RESTOREFH:
360 359 return ("NFS4ERR_RESTOREFH");
361 360 case NFS4ERR_LEASE_MOVED:
362 361 return ("NFS4ERR_LEASE_MOVED");
363 362 case NFS4ERR_ATTRNOTSUPP:
364 363 return ("NFS4ERR_ATTRNOTSUPP");
365 364 case NFS4ERR_NO_GRACE:
366 365 return ("NFS4ERR_NO_GRACE");
367 366 case NFS4ERR_RECLAIM_BAD:
368 367 return ("NFS4ERR_RECLAIM_BAD");
369 368 case NFS4ERR_RECLAIM_CONFLICT:
370 369 return ("NFS4ERR_RECLAIM_CONFLICT");
371 370 case NFS4ERR_BADXDR:
372 371 return ("NFS4ERR_BADXDR");
373 372 case NFS4ERR_LOCKS_HELD:
374 373 return ("NFS4ERR_LOCKS_HELD");
375 374 case NFS4ERR_OPENMODE:
376 375 return ("NFS4ERR_OPENMODE");
377 376 case NFS4ERR_BADOWNER:
378 377 return ("NFS4ERR_BADOWNER");
379 378 case NFS4ERR_BADCHAR:
380 379 return ("NFS4ERR_BADCHAR");
381 380 case NFS4ERR_BADNAME:
382 381 return ("NFS4ERR_BADNAME");
383 382 case NFS4ERR_BAD_RANGE:
384 383 return ("NFS4ERR_BAD_RANGE");
385 384 case NFS4ERR_LOCK_NOTSUPP:
386 385 return ("NFS4ERR_LOCK_NOTSUPP");
387 386 case NFS4ERR_OP_ILLEGAL:
388 387 return ("NFS4ERR_OP_ILLEGAL");
389 388 case NFS4ERR_DEADLOCK:
390 389 return ("NFS4ERR_DEADLOCK");
391 390 case NFS4ERR_FILE_OPEN:
392 391 return ("NFS4ERR_FILE_OPEN");
393 392 case NFS4ERR_ADMIN_REVOKED:
394 393 return ("NFS4ERR_ADMIN_REVOKED");
395 394 case NFS4ERR_CB_PATH_DOWN:
396 395 return ("NFS4ERR_CB_PATH_DOWN");
397 396 default:
398 397 (void) snprintf(buf, 40, "Unknown error %d", (int)error);
399 398 return (buf);
400 399 }
401 400 }
402 401
403 402 char *
404 403 nfs4_recov_action_to_str(nfs4_recov_t what)
405 404 {
406 405 static char buf[40];
407 406
408 407 switch (what) {
409 408 case NR_STALE:
410 409 return ("NR_STALE");
411 410 case NR_FAILOVER:
412 411 return ("NR_FAILOVER");
413 412 case NR_CLIENTID:
414 413 return ("NR_CLIENTID");
415 414 case NR_OPENFILES:
416 415 return ("NR_OPENFILES");
417 416 case NR_WRONGSEC:
418 417 return ("NR_WRONGSEC");
419 418 case NR_EXPIRED:
420 419 return ("NR_EXPIRED");
421 420 case NR_BAD_STATEID:
422 421 return ("NR_BAD_STATEID");
423 422 case NR_FHEXPIRED:
424 423 return ("NR_FHEXPIRED");
425 424 case NR_BADHANDLE:
426 425 return ("NR_BADHANDLE");
427 426 case NR_BAD_SEQID:
428 427 return ("NR_BAD_SEQID");
429 428 case NR_OLDSTATEID:
430 429 return ("NR_OLDSTATEID");
431 430 case NR_GRACE:
432 431 return ("NR_GRACE");
433 432 case NR_DELAY:
434 433 return ("NR_DELAY");
435 434 case NR_LOST_LOCK:
436 435 return ("NR_LOST_LOCK");
437 436 case NR_LOST_STATE_RQST:
438 437 return ("NR_LOST_STATE_RQST");
439 438 case NR_MOVED:
440 439 return ("NR_MOVED");
441 440 default:
442 441 (void) snprintf(buf, 40, "Unknown, code %d", (int)what);
443 442 return (buf);
444 443 }
445 444 }
446 445
447 446 char *
448 447 nfs4_op_to_str(nfs_opnum4 op)
449 448 {
450 449 static char buf[40];
451 450
452 451 switch (REAL_OP4(op)) {
453 452 case OP_ACCESS:
454 453 return ("OP_ACCESS");
455 454 case OP_CLOSE:
456 455 return ("OP_CLOSE");
457 456 case OP_COMMIT:
458 457 return ("OP_COMMIT");
459 458 case OP_CREATE:
460 459 return ("OP_CREATE");
461 460 case OP_DELEGPURGE:
462 461 return ("OP_DELEGPURGE");
463 462 case OP_DELEGRETURN:
464 463 return ("OP_DELEGRETURN");
465 464 case OP_GETATTR:
466 465 return ("OP_GETATTR");
467 466 case OP_GETFH:
468 467 return ("OP_GETFH");
469 468 case OP_LINK:
470 469 return ("OP_LINK");
471 470 case OP_LOCK:
472 471 return ("OP_LOCK");
473 472 case OP_LOCKT:
474 473 return ("OP_LOCKT");
475 474 case OP_LOCKU:
476 475 return ("OP_LOCKU");
477 476 case OP_LOOKUP:
478 477 return ("OP_LOOKUP");
479 478 case OP_LOOKUPP:
480 479 return ("OP_LOOKUPP");
481 480 case OP_NVERIFY:
482 481 return ("OP_NVERIFY");
483 482 case OP_OPEN:
484 483 return ("OP_OPEN");
485 484 case OP_OPENATTR:
486 485 return ("OP_OPENATTR");
487 486 case OP_OPEN_CONFIRM:
488 487 return ("OP_OPEN_CONFIRM");
489 488 case OP_OPEN_DOWNGRADE:
490 489 return ("OP_OPEN_DOWNGRADE");
491 490 case OP_PUTFH:
492 491 return ("OP_PUTFH");
493 492 case OP_PUTPUBFH:
494 493 return ("OP_PUTPUBFH");
495 494 case OP_PUTROOTFH:
496 495 return ("OP_PUTROOTFH");
497 496 case OP_READ:
498 497 return ("OP_READ");
499 498 case OP_READDIR:
500 499 return ("OP_READDIR");
501 500 case OP_READLINK:
502 501 return ("OP_READLINK");
503 502 case OP_REMOVE:
504 503 return ("OP_REMOVE");
505 504 case OP_RENAME:
506 505 return ("OP_RENAME");
507 506 case OP_RENEW:
508 507 return ("OP_RENEW");
509 508 case OP_RESTOREFH:
510 509 return ("OP_RESTOREFH");
511 510 case OP_SAVEFH:
512 511 return ("OP_SAVEFH");
513 512 case OP_SECINFO:
514 513 return ("OP_SECINFO");
515 514 case OP_SETATTR:
516 515 return ("OP_SETATTR");
517 516 case OP_SETCLIENTID:
518 517 return ("OP_SETCLIENTID");
519 518 case OP_SETCLIENTID_CONFIRM:
520 519 return ("OP_SETCLIENTID_CONFIRM");
521 520 case OP_VERIFY:
522 521 return ("OP_VERIFY");
523 522 case OP_WRITE:
524 523 return ("OP_WRITE");
525 524 case OP_RELEASE_LOCKOWNER:
526 525 return ("OP_RELEASE_LOCKOWNER");
527 526 case OP_ILLEGAL:
528 527 return ("OP_ILLEGAL");
529 528 default:
530 529 (void) snprintf(buf, 40, "Unknown op %d", (int)op);
531 530 return (buf);
532 531 }
533 532 }
|
↓ open down ↓ |
457 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX