1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/sysmacros.h>
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/fcntl.h>
31 #include <sys/vfs.h>
32 #include <sys/vnode.h>
33 #include <sys/share.h>
34 #include <sys/cmn_err.h>
35 #include <sys/kmem.h>
36 #include <sys/debug.h>
37 #include <sys/t_lock.h>
38 #include <sys/errno.h>
39 #include <sys/nbmlock.h>
40
41 int share_debug = 0;
42
43 #ifdef DEBUG
44 static void print_shares(struct vnode *);
45 static void print_share(struct shrlock *);
46 #endif
47
48 static int isreadonly(struct vnode *);
49
50 /*
51 * Add the share reservation shr to vp.
52 */
53 int
54 add_share(struct vnode *vp, struct shrlock *shr)
55 {
56 struct shrlocklist *shrl;
57
58 /*
59 * An access of zero is not legal, however some older clients
60 * generate it anyways. Allow the request only if it is
61 * coming from a remote system. Be generous in what you
62 * accept and strict in what you send.
63 */
64 if ((shr->s_access == 0) && (GETSYSID(shr->s_sysid) == 0)) {
65 return (EINVAL);
66 }
67
68 /*
69 * Sanity check to make sure we have valid options.
70 * There is known overlap but it doesn't hurt to be careful.
71 */
72 if (shr->s_access & ~(F_RDACC|F_WRACC|F_RWACC|F_RMACC|F_MDACC)) {
73 return (EINVAL);
74 }
75 if (shr->s_deny & ~(F_NODNY|F_RDDNY|F_WRDNY|F_RWDNY|F_COMPAT|
76 F_MANDDNY|F_RMDNY)) {
77 return (EINVAL);
78 }
79
80 mutex_enter(&vp->v_lock);
81 for (shrl = vp->v_shrlocks; shrl != NULL; shrl = shrl->next) {
82 /*
83 * If the share owner matches previous request
84 * do special handling.
85 */
86 if ((shrl->shr->s_sysid == shr->s_sysid) &&
87 (shrl->shr->s_pid == shr->s_pid) &&
88 (shrl->shr->s_own_len == shr->s_own_len) &&
89 bcmp(shrl->shr->s_owner, shr->s_owner,
90 shr->s_own_len) == 0) {
91
92 /*
93 * If the existing request is F_COMPAT and
94 * is the first share then allow any F_COMPAT
95 * from the same process. Trick: If the existing
96 * F_COMPAT is write access then it must have
97 * the same owner as the first.
98 */
99 if ((shrl->shr->s_deny & F_COMPAT) &&
100 (shr->s_deny & F_COMPAT) &&
101 ((shrl->next == NULL) ||
102 (shrl->shr->s_access & F_WRACC)))
103 break;
104 }
105
106 /*
107 * If a first share has been done in compatibility mode
108 * handle the special cases.
109 */
110 if ((shrl->shr->s_deny & F_COMPAT) && (shrl->next == NULL)) {
111
112 if (!(shr->s_deny & F_COMPAT)) {
113 /*
114 * If not compat and want write access or
115 * want to deny read or
116 * write exists, fails
117 */
118 if ((shr->s_access & F_WRACC) ||
119 (shr->s_deny & F_RDDNY) ||
120 (shrl->shr->s_access & F_WRACC)) {
121 mutex_exit(&vp->v_lock);
122 return (EAGAIN);
123 }
124 /*
125 * If read only file allow, this may allow
126 * a deny write but that is meaningless on
127 * a read only file.
128 */
129 if (isreadonly(vp))
130 break;
131 mutex_exit(&vp->v_lock);
132 return (EAGAIN);
133 }
134 /*
135 * This is a compat request and read access
136 * and the first was also read access
137 * we always allow it, otherwise we reject because
138 * we have handled the only valid write case above.
139 */
140 if ((shr->s_access == F_RDACC) &&
141 (shrl->shr->s_access == F_RDACC))
142 break;
143 mutex_exit(&vp->v_lock);
144 return (EAGAIN);
145 }
146
147 /*
148 * If we are trying to share in compatibility mode
149 * and the current share is compat (and not the first)
150 * we don't know enough.
151 */
152 if ((shrl->shr->s_deny & F_COMPAT) && (shr->s_deny & F_COMPAT))
153 continue;
154
155 /*
156 * If this is a compat we check for what can't succeed.
157 */
158 if (shr->s_deny & F_COMPAT) {
159 /*
160 * If we want write access or
161 * if anyone is denying read or
162 * if anyone has write access we fail
163 */
164 if ((shr->s_access & F_WRACC) ||
165 (shrl->shr->s_deny & F_RDDNY) ||
166 (shrl->shr->s_access & F_WRACC)) {
167 mutex_exit(&vp->v_lock);
168 return (EAGAIN);
169 }
170 /*
171 * If the first was opened with only read access
172 * and is a read only file we allow.
173 */
174 if (shrl->next == NULL) {
175 if ((shrl->shr->s_access == F_RDACC) &&
176 isreadonly(vp)) {
177 break;
178 }
179 mutex_exit(&vp->v_lock);
180 return (EAGAIN);
181 }
182 /*
183 * We still can't determine our fate so continue
184 */
185 continue;
186 }
187
188 /*
189 * Simple bitwise test, if we are trying to access what
190 * someone else is denying or we are trying to deny
191 * what someone else is accessing we fail.
192 */
193 if ((shr->s_access & shrl->shr->s_deny) ||
194 (shr->s_deny & shrl->shr->s_access)) {
195 mutex_exit(&vp->v_lock);
196 return (EAGAIN);
197 }
198 }
199
200 shrl = kmem_alloc(sizeof (struct shrlocklist), KM_SLEEP);
201 shrl->shr = kmem_alloc(sizeof (struct shrlock), KM_SLEEP);
202 shrl->shr->s_access = shr->s_access;
203 shrl->shr->s_deny = shr->s_deny;
204
205 /*
206 * Make sure no other deny modes are also set with F_COMPAT
207 */
208 if (shrl->shr->s_deny & F_COMPAT)
209 shrl->shr->s_deny = F_COMPAT;
210 shrl->shr->s_sysid = shr->s_sysid; /* XXX ref cnt? */
211 shrl->shr->s_pid = shr->s_pid;
212 shrl->shr->s_own_len = shr->s_own_len;
213 shrl->shr->s_owner = kmem_alloc(shr->s_own_len, KM_SLEEP);
214 bcopy(shr->s_owner, shrl->shr->s_owner, shr->s_own_len);
215 shrl->next = vp->v_shrlocks;
216 vp->v_shrlocks = shrl;
217 #ifdef DEBUG
218 if (share_debug)
219 print_shares(vp);
220 #endif
221
222 mutex_exit(&vp->v_lock);
223
224 return (0);
225 }
226
227 /*
228 * nlmid sysid pid
229 * ===== ===== ===
230 * !=0 !=0 =0 in cluster; NLM lock
231 * !=0 =0 =0 in cluster; special case for NLM lock
232 * !=0 =0 !=0 in cluster; PXFS local lock
233 * !=0 !=0 !=0 cannot happen
234 * =0 !=0 =0 not in cluster; NLM lock
235 * =0 =0 !=0 not in cluster; local lock
236 * =0 =0 =0 cannot happen
237 * =0 !=0 !=0 cannot happen
238 */
239 static int
240 is_match_for_del(struct shrlock *shr, struct shrlock *element)
241 {
242 int nlmid1, nlmid2;
243 int result = 0;
244
245 nlmid1 = GETNLMID(shr->s_sysid);
246 nlmid2 = GETNLMID(element->s_sysid);
247
248 if (nlmid1 != 0) { /* in a cluster */
249 if (GETSYSID(shr->s_sysid) != 0 && shr->s_pid == 0) {
250 /*
251 * Lock obtained through nlm server. Just need to
252 * compare whole sysids. pid will always = 0.
253 */
254 result = shr->s_sysid == element->s_sysid;
255 } else if (GETSYSID(shr->s_sysid) == 0 && shr->s_pid == 0) {
256 /*
257 * This is a special case. The NLM server wishes to
258 * delete all share locks obtained through nlmid1.
259 */
260 result = (nlmid1 == nlmid2);
261 } else if (GETSYSID(shr->s_sysid) == 0 && shr->s_pid != 0) {
262 /*
263 * Lock obtained locally through PXFS. Match nlmids
264 * and pids.
265 */
266 result = (nlmid1 == nlmid2 &&
267 shr->s_pid == element->s_pid);
268 }
269 } else { /* not in a cluster */
270 result = ((shr->s_sysid == 0 &&
271 shr->s_pid == element->s_pid) ||
272 (shr->s_sysid != 0 &&
273 shr->s_sysid == element->s_sysid));
274 }
275 return (result);
276 }
277
278 /*
279 * Delete the given share reservation. Returns 0 if okay, EINVAL if the
280 * share could not be found. If the share reservation is an NBMAND share
281 * reservation, signal anyone waiting for the share to go away (e.g.,
282 * blocking lock requests).
283 */
284
285 int
286 del_share(struct vnode *vp, struct shrlock *shr)
287 {
288 struct shrlocklist *shrl;
289 struct shrlocklist **shrlp;
290 int found = 0;
291 int is_nbmand = 0;
292
293 mutex_enter(&vp->v_lock);
294 /*
295 * Delete the shares with the matching sysid and owner
296 * But if own_len == 0 and sysid == 0 delete all with matching pid
297 * But if own_len == 0 delete all with matching sysid.
298 */
299 shrlp = &vp->v_shrlocks;
300 while (*shrlp) {
301 if ((shr->s_own_len == (*shrlp)->shr->s_own_len &&
302 (bcmp(shr->s_owner, (*shrlp)->shr->s_owner,
303 shr->s_own_len) == 0)) ||
304
305 (shr->s_own_len == 0 &&
306 is_match_for_del(shr, (*shrlp)->shr))) {
307
308 shrl = *shrlp;
309 *shrlp = shrl->next;
310
311 if (shrl->shr->s_deny & F_MANDDNY)
312 is_nbmand = 1;
313
314 /* XXX deref sysid */
315 kmem_free(shrl->shr->s_owner, shrl->shr->s_own_len);
316 kmem_free(shrl->shr, sizeof (struct shrlock));
317 kmem_free(shrl, sizeof (struct shrlocklist));
318 found++;
319 continue;
320 }
321 shrlp = &(*shrlp)->next;
322 }
323
324 if (is_nbmand)
325 cv_broadcast(&vp->v_cv);
326
327 mutex_exit(&vp->v_lock);
328 return (found ? 0 : EINVAL);
329 }
330
331 /*
332 * Clean up all local share reservations that the given process has with
333 * the given file.
334 */
335 void
336 cleanshares(struct vnode *vp, pid_t pid)
337 {
338 struct shrlock shr;
339
340 if (vp->v_shrlocks == NULL)
341 return;
342
343 shr.s_access = 0;
344 shr.s_deny = 0;
345 shr.s_pid = pid;
346 shr.s_sysid = 0;
347 shr.s_own_len = 0;
348 shr.s_owner = NULL;
349
350 (void) del_share(vp, &shr);
351 }
352
353 static int
354 is_match_for_has_remote(int32_t sysid1, int32_t sysid2)
355 {
356 int result = 0;
357
358 if (GETNLMID(sysid1) != 0) { /* in a cluster */
359 if (GETSYSID(sysid1) != 0) {
360 /*
361 * Lock obtained through nlm server. Just need to
362 * compare whole sysids.
363 */
364 result = (sysid1 == sysid2);
365 } else if (GETSYSID(sysid1) == 0) {
366 /*
367 * This is a special case. The NLM server identified
368 * by nlmid1 wishes to find out if it has obtained
369 * any share locks on the vnode.
370 */
371 result = (GETNLMID(sysid1) == GETNLMID(sysid2));
372 }
373 } else { /* not in a cluster */
374 result = ((sysid1 != 0 && sysid1 == sysid2) ||
375 (sysid1 == 0 && sysid2 != 0));
376 }
377 return (result);
378 }
379
380
381 /*
382 * Determine whether there are any shares for the given vnode
383 * with a remote sysid. Returns zero if not, non-zero if there are.
384 * If sysid is non-zero then determine if this sysid has a share.
385 *
386 * Note that the return value from this function is potentially invalid
387 * once it has been returned. The caller is responsible for providing its
388 * own synchronization mechanism to ensure that the return value is useful.
389 */
390 int
391 shr_has_remote_shares(vnode_t *vp, int32_t sysid)
392 {
393 struct shrlocklist *shrl;
394 int result = 0;
395
396 mutex_enter(&vp->v_lock);
397 shrl = vp->v_shrlocks;
398 while (shrl) {
399 if (is_match_for_has_remote(sysid, shrl->shr->s_sysid)) {
400
401 result = 1;
402 break;
403 }
404 shrl = shrl->next;
405 }
406 mutex_exit(&vp->v_lock);
407 return (result);
408 }
409
410 static int
411 isreadonly(struct vnode *vp)
412 {
413 return (vp->v_type != VCHR && vp->v_type != VBLK &&
414 vp->v_type != VFIFO && vn_is_readonly(vp));
415 }
416
417 #ifdef DEBUG
418 static void
419 print_shares(struct vnode *vp)
420 {
421 struct shrlocklist *shrl;
422
423 if (vp->v_shrlocks == NULL) {
424 printf("<NULL>\n");
425 return;
426 }
427
428 shrl = vp->v_shrlocks;
429 while (shrl) {
430 print_share(shrl->shr);
431 shrl = shrl->next;
432 }
433 }
434
435 static void
436 print_share(struct shrlock *shr)
437 {
438 int i;
439
440 if (shr == NULL) {
441 printf("<NULL>\n");
442 return;
443 }
444
445 printf(" access(%d): ", shr->s_access);
446 if (shr->s_access & F_RDACC)
447 printf("R");
448 if (shr->s_access & F_WRACC)
449 printf("W");
450 if ((shr->s_access & (F_RDACC|F_WRACC)) == 0)
451 printf("N");
452 printf("\n");
453 printf(" deny: ");
454 if (shr->s_deny & F_COMPAT)
455 printf("C");
456 if (shr->s_deny & F_RDDNY)
457 printf("R");
458 if (shr->s_deny & F_WRDNY)
459 printf("W");
460 if (shr->s_deny == F_NODNY)
461 printf("N");
462 printf("\n");
463 printf(" sysid: %d\n", shr->s_sysid);
464 printf(" pid: %d\n", shr->s_pid);
465 printf(" owner: [%d]", shr->s_own_len);
466 printf("'");
467 for (i = 0; i < shr->s_own_len; i++)
468 printf("%02x", (unsigned)shr->s_owner[i]);
469 printf("'\n");
470 }
471 #endif
472
473 /*
474 * Return non-zero if the given I/O request conflicts with a registered
475 * share reservation.
476 *
477 * A process is identified by the tuple (sysid, pid). When the caller
478 * context is passed to nbl_share_conflict, the sysid and pid in the
479 * caller context are used. Otherwise the sysid is zero, and the pid is
480 * taken from the current process.
481 *
482 * Conflict Algorithm:
483 * 1. An op request of NBL_READ will fail if a different
484 * process has a mandatory share reservation with deny read.
485 *
486 * 2. An op request of NBL_WRITE will fail if a different
487 * process has a mandatory share reservation with deny write.
488 *
489 * 3. An op request of NBL_READWRITE will fail if a different
490 * process has a mandatory share reservation with deny read
491 * or deny write.
492 *
493 * 4. An op request of NBL_REMOVE will fail if there is
494 * a mandatory share reservation with an access of read,
495 * write, or remove. (Anything other than meta data access).
496 *
497 * 5. An op request of NBL_RENAME will fail if there is
498 * a mandatory share reservation with:
499 * a) access write or access remove
500 * or
501 * b) access read and deny remove
502 *
503 * Otherwise there is no conflict and the op request succeeds.
504 *
505 * This behavior is required for interoperability between
506 * the nfs server, cifs server, and local access.
507 * This behavior can result in non-posix semantics.
508 *
509 * When mandatory share reservations are enabled, a process
510 * should call nbl_share_conflict to determine if the
511 * desired operation would conflict with an existing share
512 * reservation.
513 *
514 * The call to nbl_share_conflict may be skipped if the
515 * process has an existing share reservation and the operation
516 * is being performed in the context of that existing share
517 * reservation.
518 */
519 int
520 nbl_share_conflict(vnode_t *vp, nbl_op_t op, caller_context_t *ct)
521 {
522 struct shrlocklist *shrl;
523 int conflict = 0;
524 pid_t pid;
525 int sysid;
526
527 ASSERT(nbl_in_crit(vp));
528
529 if (ct == NULL) {
530 pid = curproc->p_pid;
531 sysid = 0;
532 } else {
533 pid = ct->cc_pid;
534 sysid = ct->cc_sysid;
535 }
536
537 mutex_enter(&vp->v_lock);
538 for (shrl = vp->v_shrlocks; shrl != NULL; shrl = shrl->next) {
539 if (!(shrl->shr->s_deny & F_MANDDNY))
540 continue;
541 /*
542 * NBL_READ, NBL_WRITE, and NBL_READWRITE need to
543 * check if the share reservation being examined
544 * belongs to the current process.
545 * NBL_REMOVE and NBL_RENAME do not.
546 * This behavior is required by the conflict
547 * algorithm described above.
548 */
549 switch (op) {
550 case NBL_READ:
551 if ((shrl->shr->s_deny & F_RDDNY) &&
552 (shrl->shr->s_sysid != sysid ||
553 shrl->shr->s_pid != pid))
554 conflict = 1;
555 break;
556 case NBL_WRITE:
557 if ((shrl->shr->s_deny & F_WRDNY) &&
558 (shrl->shr->s_sysid != sysid ||
559 shrl->shr->s_pid != pid))
560 conflict = 1;
561 break;
562 case NBL_READWRITE:
563 if ((shrl->shr->s_deny & F_RWDNY) &&
564 (shrl->shr->s_sysid != sysid ||
565 shrl->shr->s_pid != pid))
566 conflict = 1;
567 break;
568 case NBL_REMOVE:
569 if (shrl->shr->s_access & (F_RWACC|F_RMACC))
570 conflict = 1;
571 break;
572 case NBL_RENAME:
573 if (shrl->shr->s_access & (F_WRACC|F_RMACC))
574 conflict = 1;
575
576 else if ((shrl->shr->s_access & F_RDACC) &&
577 (shrl->shr->s_deny & F_RMDNY))
578 conflict = 1;
579 break;
580 #ifdef DEBUG
581 default:
582 cmn_err(CE_PANIC,
583 "nbl_share_conflict: bogus op (%d)",
584 op);
585 break;
586 #endif
587 }
588 if (conflict)
589 break;
590 }
591
592 mutex_exit(&vp->v_lock);
593 return (conflict);
594 }
595
596 /*
597 * Determine if the given process has a NBMAND share reservation on the
598 * given vnode. Returns 1 if the process has such a share reservation,
599 * returns 0 otherwise.
600 */
601 int
602 proc_has_nbmand_share_on_vp(vnode_t *vp, pid_t pid)
603 {
604 struct shrlocklist *shrl;
605
606 /*
607 * Any NBMAND share reservation on the vp for this process?
608 */
609 mutex_enter(&vp->v_lock);
610 for (shrl = vp->v_shrlocks; shrl != NULL; shrl = shrl->next) {
611 if (shrl->shr->s_sysid == 0 &&
612 (shrl->shr->s_deny & F_MANDDNY) &&
613 (shrl->shr->s_pid == pid)) {
614 mutex_exit(&vp->v_lock);
615 return (1);
616 }
617 }
618 mutex_exit(&vp->v_lock);
619
620 return (0);
621 }