xref: /titanic_41/usr/src/uts/common/fs/smbsrv/smb_ofile.c (revision cf115f3609b69ef25a8b5a1c0a4a5afa19271fa8)
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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
24  */
25 
26 /*
27  * General Structures Layout
28  * -------------------------
29  *
30  * This is a simplified diagram showing the relationship between most of the
31  * main structures.
32  *
33  * +-------------------+
34  * |     SMB_INFO      |
35  * +-------------------+
36  *          |
37  *          |
38  *          v
39  * +-------------------+       +-------------------+      +-------------------+
40  * |     SESSION       |<----->|     SESSION       |......|      SESSION      |
41  * +-------------------+       +-------------------+      +-------------------+
42  *   |          |
43  *   |          |
44  *   |          v
45  *   |  +-------------------+     +-------------------+   +-------------------+
46  *   |  |       USER        |<--->|       USER        |...|       USER        |
47  *   |  +-------------------+     +-------------------+   +-------------------+
48  *   |
49  *   |
50  *   v
51  * +-------------------+       +-------------------+      +-------------------+
52  * |       TREE        |<----->|       TREE        |......|       TREE        |
53  * +-------------------+       +-------------------+      +-------------------+
54  *      |         |
55  *      |         |
56  *      |         v
57  *      |     +-------+       +-------+      +-------+
58  *      |     | OFILE |<----->| OFILE |......| OFILE |
59  *      |     +-------+       +-------+      +-------+
60  *      |
61  *      |
62  *      v
63  *  +-------+       +------+      +------+
64  *  | ODIR  |<----->| ODIR |......| ODIR |
65  *  +-------+       +------+      +------+
66  *
67  *
68  * Ofile State Machine
69  * ------------------
70  *
71  *    +-------------------------+	 T0
72  *    |  SMB_OFILE_STATE_OPEN   |<----------- Creation/Allocation
73  *    +-------------------------+
74  *		    |
75  *		    | T1
76  *		    |
77  *		    v
78  *    +-------------------------+
79  *    | SMB_OFILE_STATE_CLOSING |
80  *    +-------------------------+
81  *		    |
82  *		    | T2
83  *		    |
84  *		    v
85  *    +-------------------------+    T3
86  *    | SMB_OFILE_STATE_CLOSED  |----------> Deletion/Free
87  *    +-------------------------+
88  *
89  * SMB_OFILE_STATE_OPEN
90  *
91  *    While in this state:
92  *      - The ofile is queued in the list of ofiles of its tree.
93  *      - References will be given out if the ofile is looked up.
94  *
95  * SMB_OFILE_STATE_CLOSING
96  *
97  *    While in this state:
98  *      - The ofile is queued in the list of ofiles of its tree.
99  *      - References will not be given out if the ofile is looked up.
100  *      - The file is closed and the locks held are being released.
101  *      - The resources associated with the ofile remain.
102  *
103  * SMB_OFILE_STATE_CLOSED
104  *
105  *    While in this state:
106  *      - The ofile is queued in the list of ofiles of its tree.
107  *      - References will not be given out if the ofile is looked up.
108  *      - The resources associated with the ofile remain.
109  *
110  * Transition T0
111  *
112  *    This transition occurs in smb_ofile_open(). A new ofile is created and
113  *    added to the list of ofiles of a tree.
114  *
115  * Transition T1
116  *
117  *    This transition occurs in smb_ofile_close().
118  *
119  * Transition T2
120  *
121  *    This transition occurs in smb_ofile_release(). The resources associated
122  *    with the ofile are freed as well as the ofile structure. For the
123  *    transition to occur, the ofile must be in the SMB_OFILE_STATE_CLOSED
124  *    state and the reference count be zero.
125  *
126  * Comments
127  * --------
128  *
129  *    The state machine of the ofile structures is controlled by 3 elements:
130  *      - The list of ofiles of the tree it belongs to.
131  *      - The mutex embedded in the structure itself.
132  *      - The reference count.
133  *
134  *    There's a mutex embedded in the ofile structure used to protect its fields
135  *    and there's a lock embedded in the list of ofiles of a tree. To
136  *    increment or to decrement the reference count the mutex must be entered.
137  *    To insert the ofile into the list of ofiles of the tree and to remove
138  *    the ofile from it, the lock must be entered in RW_WRITER mode.
139  *
140  *    Rules of access to a ofile structure:
141  *
142  *    1) In order to avoid deadlocks, when both (mutex and lock of the ofile
143  *       list) have to be entered, the lock must be entered first.
144  *
145  *    2) All actions applied to an ofile require a reference count.
146  *
147  *    3) There are 2 ways of getting a reference count. One is when the ofile
148  *       is opened. The other one when the ofile is looked up. This translates
149  *       into 2 functions: smb_ofile_open() and smb_ofile_lookup_by_fid().
150  *
151  *    It should be noted that the reference count of an ofile registers the
152  *    number of references to the ofile in other structures (such as an smb
153  *    request). The reference count is not incremented in these 2 instances:
154  *
155  *    1) The ofile is open. An ofile is anchored by his state. If there's
156  *       no activity involving an ofile currently open, the reference count
157  *       of that ofile is zero.
158  *
159  *    2) The ofile is queued in the list of ofiles of its tree. The fact of
160  *       being queued in that list is NOT registered by incrementing the
161  *       reference count.
162  */
163 #include <smbsrv/smb_kproto.h>
164 #include <smbsrv/smb_fsops.h>
165 
166 static boolean_t smb_ofile_is_open_locked(smb_ofile_t *);
167 static smb_ofile_t *smb_ofile_close_and_next(smb_ofile_t *);
168 static int smb_ofile_netinfo_encode(smb_ofile_t *, uint8_t *, size_t,
169     uint32_t *);
170 static int smb_ofile_netinfo_init(smb_ofile_t *, smb_netfileinfo_t *);
171 static void smb_ofile_netinfo_fini(smb_netfileinfo_t *);
172 
173 /*
174  * smb_ofile_open
175  */
176 smb_ofile_t *
smb_ofile_open(smb_request_t * sr,smb_node_t * node,struct open_param * op,uint16_t ftype,uint32_t uniqid,smb_error_t * err)177 smb_ofile_open(
178     smb_request_t	*sr,
179     smb_node_t		*node,
180     struct open_param	*op,
181     uint16_t		ftype,
182     uint32_t		uniqid,
183     smb_error_t		*err)
184 {
185 	smb_tree_t	*tree = sr->tid_tree;
186 	smb_ofile_t	*of;
187 	uint16_t	fid;
188 	smb_attr_t	attr;
189 	int		rc;
190 	enum errstates { EMPTY, FIDALLOC, CRHELD, MUTEXINIT };
191 	enum errstates	state = EMPTY;
192 
193 	if (smb_idpool_alloc(&tree->t_fid_pool, &fid)) {
194 		err->status = NT_STATUS_TOO_MANY_OPENED_FILES;
195 		err->errcls = ERRDOS;
196 		err->errcode = ERROR_TOO_MANY_OPEN_FILES;
197 		return (NULL);
198 	}
199 	state = FIDALLOC;
200 
201 	of = kmem_cache_alloc(smb_cache_ofile, KM_SLEEP);
202 	bzero(of, sizeof (smb_ofile_t));
203 	of->f_magic = SMB_OFILE_MAGIC;
204 	of->f_refcnt = 1;
205 	of->f_fid = fid;
206 	of->f_uniqid = uniqid;
207 	of->f_opened_by_pid = sr->smb_pid;
208 	of->f_granted_access = op->desired_access;
209 	of->f_share_access = op->share_access;
210 	of->f_create_options = op->create_options;
211 	of->f_cr = (op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) ?
212 	    smb_user_getprivcred(sr->uid_user) : sr->uid_user->u_cred;
213 	crhold(of->f_cr);
214 	state = CRHELD;
215 	of->f_ftype = ftype;
216 	of->f_server = tree->t_server;
217 	of->f_session = tree->t_session;
218 	/*
219 	 * grab a ref for of->f_user
220 	 * released in smb_ofile_delete()
221 	 */
222 	smb_user_hold_internal(sr->uid_user);
223 	of->f_user = sr->uid_user;
224 	of->f_tree = tree;
225 	of->f_node = node;
226 
227 	mutex_init(&of->f_mutex, NULL, MUTEX_DEFAULT, NULL);
228 	state = MUTEXINIT;
229 	of->f_state = SMB_OFILE_STATE_OPEN;
230 
231 	if (ftype == SMB_FTYPE_MESG_PIPE) {
232 		/* See smb_opipe_open. */
233 		of->f_pipe = op->pipe;
234 		smb_server_inc_pipes(of->f_server);
235 	} else {
236 		ASSERT(ftype == SMB_FTYPE_DISK); /* Regular file, not a pipe */
237 		ASSERT(node);
238 
239 		if (of->f_granted_access == FILE_EXECUTE)
240 			of->f_flags |= SMB_OFLAGS_EXECONLY;
241 
242 		bzero(&attr, sizeof (smb_attr_t));
243 		attr.sa_mask = SMB_AT_UID | SMB_AT_DOSATTR;
244 		rc = smb_node_getattr(NULL, node, of->f_cr, NULL, &attr);
245 		if (rc != 0) {
246 			err->status = NT_STATUS_INTERNAL_ERROR;
247 			err->errcls = ERRDOS;
248 			err->errcode = ERROR_INTERNAL_ERROR;
249 			goto errout;
250 		}
251 		if (crgetuid(of->f_cr) == attr.sa_vattr.va_uid) {
252 			/*
253 			 * Add this bit for the file's owner even if it's not
254 			 * specified in the request (Windows behavior).
255 			 */
256 			of->f_granted_access |= FILE_READ_ATTRIBUTES;
257 		}
258 
259 		if (smb_node_is_file(node)) {
260 			of->f_mode =
261 			    smb_fsop_amask_to_omode(of->f_granted_access);
262 			if (smb_fsop_open(node, of->f_mode, of->f_cr) != 0) {
263 				err->status = NT_STATUS_ACCESS_DENIED;
264 				err->errcls = ERRDOS;
265 				err->errcode = ERROR_ACCESS_DENIED;
266 				goto errout;
267 			}
268 		}
269 
270 		if (tree->t_flags & SMB_TREE_READONLY)
271 			of->f_flags |= SMB_OFLAGS_READONLY;
272 
273 		/*
274 		 * Note that if we created_readonly, that
275 		 * will _not_ yet show in attr.sa_dosattr
276 		 * so creating a readonly file gives the
277 		 * caller a writable handle as it should.
278 		 */
279 		if (attr.sa_dosattr & FILE_ATTRIBUTE_READONLY)
280 			of->f_flags |= SMB_OFLAGS_READONLY;
281 
282 		smb_node_inc_open_ofiles(node);
283 		smb_node_add_ofile(node, of);
284 		smb_node_ref(node);
285 		smb_server_inc_files(of->f_server);
286 	}
287 	smb_llist_enter(&tree->t_ofile_list, RW_WRITER);
288 	smb_llist_insert_tail(&tree->t_ofile_list, of);
289 	smb_llist_exit(&tree->t_ofile_list);
290 	atomic_inc_32(&tree->t_open_files);
291 	atomic_inc_32(&of->f_session->s_file_cnt);
292 	return (of);
293 
294 errout:
295 	switch (state) {
296 	case MUTEXINIT:
297 		mutex_destroy(&of->f_mutex);
298 		smb_user_release(of->f_user);
299 		/*FALLTHROUGH*/
300 	case CRHELD:
301 		crfree(of->f_cr);
302 		of->f_magic = 0;
303 		kmem_cache_free(smb_cache_ofile, of);
304 		/*FALLTHROUGH*/
305 	case FIDALLOC:
306 		smb_idpool_free(&tree->t_fid_pool, fid);
307 		/*FALLTHROUGH*/
308 	case EMPTY:
309 		break;
310 	}
311 	return (NULL);
312 }
313 
314 /*
315  * smb_ofile_close
316  */
317 void
smb_ofile_close(smb_ofile_t * of,int32_t mtime_sec)318 smb_ofile_close(smb_ofile_t *of, int32_t mtime_sec)
319 {
320 	timestruc_t now;
321 	uint32_t flags = 0;
322 
323 	SMB_OFILE_VALID(of);
324 
325 	mutex_enter(&of->f_mutex);
326 	ASSERT(of->f_refcnt);
327 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
328 		mutex_exit(&of->f_mutex);
329 		return;
330 	}
331 	of->f_state = SMB_OFILE_STATE_CLOSING;
332 	mutex_exit(&of->f_mutex);
333 
334 	if (of->f_ftype == SMB_FTYPE_MESG_PIPE) {
335 		smb_opipe_close(of);
336 		smb_server_dec_pipes(of->f_server);
337 	} else {
338 		smb_attr_t *pa = &of->f_pending_attr;
339 
340 		/*
341 		 * In here we make changes to of->f_pending_attr
342 		 * while not holding of->f_mutex.  This is OK
343 		 * because we've changed f_state to CLOSING,
344 		 * so no more threads will take this path.
345 		 */
346 		if (mtime_sec != 0) {
347 			pa->sa_vattr.va_mtime.tv_sec = mtime_sec;
348 			pa->sa_mask |= SMB_AT_MTIME;
349 		}
350 
351 		/*
352 		 * If we have ever modified data via this handle
353 		 * (write or truncate) and if the mtime was not
354 		 * set via this handle, update the mtime again
355 		 * during the close.  Windows expects this.
356 		 * [ MS-FSA 2.1.5.4 "Update Timestamps" ]
357 		 */
358 		if (of->f_written &&
359 		    (pa->sa_mask & SMB_AT_MTIME) == 0) {
360 			pa->sa_mask |= SMB_AT_MTIME;
361 			gethrestime(&now);
362 			pa->sa_vattr.va_mtime = now;
363 		}
364 
365 		if (of->f_flags & SMB_OFLAGS_SET_DELETE_ON_CLOSE) {
366 			if (smb_tree_has_feature(of->f_tree,
367 			    SMB_TREE_CATIA)) {
368 				flags |= SMB_CATIA;
369 			}
370 			(void) smb_node_set_delete_on_close(of->f_node,
371 			    of->f_cr, flags);
372 		}
373 		smb_fsop_unshrlock(of->f_cr, of->f_node, of->f_uniqid);
374 		smb_node_destroy_lock_by_ofile(of->f_node, of);
375 
376 		if (smb_node_is_file(of->f_node)) {
377 			(void) smb_fsop_close(of->f_node, of->f_mode,
378 			    of->f_cr);
379 			smb_oplock_release(of->f_node, of);
380 		}
381 		if (smb_node_dec_open_ofiles(of->f_node) == 0) {
382 			/*
383 			 * Last close. The f_pending_attr has
384 			 * only times (atime,ctime,mtime) so
385 			 * we can borrow it to commit the
386 			 * n_pending_dosattr from the node.
387 			 */
388 			pa->sa_dosattr =
389 			    of->f_node->n_pending_dosattr;
390 			if (pa->sa_dosattr != 0)
391 				pa->sa_mask |= SMB_AT_DOSATTR;
392 			/* Let's leave this zero when not in use. */
393 			of->f_node->n_allocsz = 0;
394 		}
395 		if (pa->sa_mask != 0) {
396 			/*
397 			 * Commit any pending attributes from
398 			 * the ofile we're closing.  Note that
399 			 * we pass NULL as the ofile to setattr
400 			 * so it will write to the file system
401 			 * and not keep anything on the ofile.
402 			 * This clears n_pending_dosattr if
403 			 * there are no opens, otherwise the
404 			 * dosattr will be pending again.
405 			 */
406 			(void) smb_node_setattr(NULL, of->f_node,
407 			    of->f_cr, NULL, pa);
408 		}
409 
410 		/*
411 		 * Cancel any notify change requests that
412 		 * may be using this open instance.
413 		 */
414 		if (of->f_node->n_fcn.fcn_count)
415 			smb_notify_file_closed(of);
416 
417 		smb_server_dec_files(of->f_server);
418 	}
419 	atomic_dec_32(&of->f_tree->t_open_files);
420 
421 	mutex_enter(&of->f_mutex);
422 	ASSERT(of->f_refcnt);
423 	ASSERT(of->f_state == SMB_OFILE_STATE_CLOSING);
424 	of->f_state = SMB_OFILE_STATE_CLOSED;
425 	mutex_exit(&of->f_mutex);
426 }
427 
428 /*
429  * smb_ofile_close_all
430  *
431  *
432  */
433 void
smb_ofile_close_all(smb_tree_t * tree)434 smb_ofile_close_all(
435     smb_tree_t		*tree)
436 {
437 	smb_ofile_t	*of;
438 
439 	ASSERT(tree);
440 	ASSERT(tree->t_magic == SMB_TREE_MAGIC);
441 
442 	smb_llist_enter(&tree->t_ofile_list, RW_READER);
443 	of = smb_llist_head(&tree->t_ofile_list);
444 	while (of) {
445 		ASSERT(of->f_magic == SMB_OFILE_MAGIC);
446 		ASSERT(of->f_tree == tree);
447 		of = smb_ofile_close_and_next(of);
448 	}
449 	smb_llist_exit(&tree->t_ofile_list);
450 }
451 
452 /*
453  * smb_ofiles_close_by_pid
454  *
455  *
456  */
457 void
smb_ofile_close_all_by_pid(smb_tree_t * tree,uint16_t pid)458 smb_ofile_close_all_by_pid(
459     smb_tree_t		*tree,
460     uint16_t		pid)
461 {
462 	smb_ofile_t	*of;
463 
464 	ASSERT(tree);
465 	ASSERT(tree->t_magic == SMB_TREE_MAGIC);
466 
467 	smb_llist_enter(&tree->t_ofile_list, RW_READER);
468 	of = smb_llist_head(&tree->t_ofile_list);
469 	while (of) {
470 		ASSERT(of->f_magic == SMB_OFILE_MAGIC);
471 		ASSERT(of->f_tree == tree);
472 		if (of->f_opened_by_pid == pid) {
473 			of = smb_ofile_close_and_next(of);
474 		} else {
475 			of = smb_llist_next(&tree->t_ofile_list, of);
476 		}
477 	}
478 	smb_llist_exit(&tree->t_ofile_list);
479 }
480 
481 /*
482  * If the enumeration request is for ofile data, handle it here.
483  * Otherwise, return.
484  *
485  * This function should be called with a hold on the ofile.
486  */
487 int
smb_ofile_enum(smb_ofile_t * of,smb_svcenum_t * svcenum)488 smb_ofile_enum(smb_ofile_t *of, smb_svcenum_t *svcenum)
489 {
490 	uint8_t *pb;
491 	uint_t nbytes;
492 	int rc;
493 
494 	ASSERT(of);
495 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
496 	ASSERT(of->f_refcnt);
497 
498 	if (svcenum->se_type != SMB_SVCENUM_TYPE_FILE)
499 		return (0);
500 
501 	if (svcenum->se_nskip > 0) {
502 		svcenum->se_nskip--;
503 		return (0);
504 	}
505 
506 	if (svcenum->se_nitems >= svcenum->se_nlimit) {
507 		svcenum->se_nitems = svcenum->se_nlimit;
508 		return (0);
509 	}
510 
511 	pb = &svcenum->se_buf[svcenum->se_bused];
512 
513 	rc = smb_ofile_netinfo_encode(of, pb, svcenum->se_bavail,
514 	    &nbytes);
515 	if (rc == 0) {
516 		svcenum->se_bavail -= nbytes;
517 		svcenum->se_bused += nbytes;
518 		svcenum->se_nitems++;
519 	}
520 
521 	return (rc);
522 }
523 
524 /*
525  * Take a reference on an open file.
526  */
527 boolean_t
smb_ofile_hold(smb_ofile_t * of)528 smb_ofile_hold(smb_ofile_t *of)
529 {
530 	ASSERT(of);
531 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
532 
533 	mutex_enter(&of->f_mutex);
534 
535 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
536 		mutex_exit(&of->f_mutex);
537 		return (B_FALSE);
538 	}
539 	of->f_refcnt++;
540 
541 	mutex_exit(&of->f_mutex);
542 	return (B_TRUE);
543 }
544 
545 /*
546  * Release a reference on a file.  If the reference count falls to
547  * zero and the file has been closed, post the object for deletion.
548  * Object deletion is deferred to avoid modifying a list while an
549  * iteration may be in progress.
550  */
551 void
smb_ofile_release(smb_ofile_t * of)552 smb_ofile_release(smb_ofile_t *of)
553 {
554 	SMB_OFILE_VALID(of);
555 
556 	mutex_enter(&of->f_mutex);
557 	ASSERT(of->f_refcnt);
558 	of->f_refcnt--;
559 	switch (of->f_state) {
560 	case SMB_OFILE_STATE_OPEN:
561 	case SMB_OFILE_STATE_CLOSING:
562 		break;
563 
564 	case SMB_OFILE_STATE_CLOSED:
565 		if (of->f_refcnt == 0)
566 			smb_tree_post_ofile(of->f_tree, of);
567 		break;
568 
569 	default:
570 		ASSERT(0);
571 		break;
572 	}
573 	mutex_exit(&of->f_mutex);
574 }
575 
576 /*
577  * smb_ofile_request_complete
578  *
579  * During oplock acquisition, all other oplock requests on the node
580  * are blocked until the acquire request completes and the response
581  * is on the wire.
582  * Call smb_oplock_broadcast to notify the node that the request
583  * has completed.
584  *
585  * THIS MECHANISM RELIES ON THE FACT THAT THE OFILE IS NOT REMOVED
586  * FROM THE SR UNTIL REQUEST COMPLETION (when the sr is destroyed)
587  */
588 void
smb_ofile_request_complete(smb_ofile_t * of)589 smb_ofile_request_complete(smb_ofile_t *of)
590 {
591 	SMB_OFILE_VALID(of);
592 
593 	switch (of->f_ftype) {
594 	case SMB_FTYPE_DISK:
595 		ASSERT(of->f_node);
596 		smb_oplock_broadcast(of->f_node);
597 		break;
598 	case SMB_FTYPE_MESG_PIPE:
599 		break;
600 	default:
601 		break;
602 	}
603 }
604 
605 /*
606  * smb_ofile_lookup_by_fid
607  *
608  * Find the open file whose fid matches the one specified in the request.
609  * If we can't find the fid or the shares (trees) don't match, we have a
610  * bad fid.
611  */
612 smb_ofile_t *
smb_ofile_lookup_by_fid(smb_request_t * sr,uint16_t fid)613 smb_ofile_lookup_by_fid(
614     smb_request_t	*sr,
615     uint16_t		fid)
616 {
617 	smb_tree_t	*tree = sr->tid_tree;
618 	smb_llist_t	*of_list;
619 	smb_ofile_t	*of;
620 
621 	ASSERT(tree->t_magic == SMB_TREE_MAGIC);
622 
623 	of_list = &tree->t_ofile_list;
624 
625 	smb_llist_enter(of_list, RW_READER);
626 	of = smb_llist_head(of_list);
627 	while (of) {
628 		ASSERT(of->f_magic == SMB_OFILE_MAGIC);
629 		ASSERT(of->f_tree == tree);
630 		if (of->f_fid == fid)
631 			break;
632 		of = smb_llist_next(of_list, of);
633 	}
634 	if (of == NULL)
635 		goto out;
636 
637 	/*
638 	 * Only allow use of a given FID with the same UID that
639 	 * was used to open it.  MS-CIFS 3.3.5.14
640 	 */
641 	if (of->f_user != sr->uid_user) {
642 		of = NULL;
643 		goto out;
644 	}
645 
646 	mutex_enter(&of->f_mutex);
647 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
648 		mutex_exit(&of->f_mutex);
649 		of = NULL;
650 		goto out;
651 	}
652 	of->f_refcnt++;
653 	mutex_exit(&of->f_mutex);
654 
655 out:
656 	smb_llist_exit(of_list);
657 	return (of);
658 }
659 
660 /*
661  * smb_ofile_lookup_by_uniqid
662  *
663  * Find the open file whose uniqid matches the one specified in the request.
664  */
665 smb_ofile_t *
smb_ofile_lookup_by_uniqid(smb_tree_t * tree,uint32_t uniqid)666 smb_ofile_lookup_by_uniqid(smb_tree_t *tree, uint32_t uniqid)
667 {
668 	smb_llist_t	*of_list;
669 	smb_ofile_t	*of;
670 
671 	ASSERT(tree->t_magic == SMB_TREE_MAGIC);
672 
673 	of_list = &tree->t_ofile_list;
674 	smb_llist_enter(of_list, RW_READER);
675 	of = smb_llist_head(of_list);
676 
677 	while (of) {
678 		ASSERT(of->f_magic == SMB_OFILE_MAGIC);
679 		ASSERT(of->f_tree == tree);
680 
681 		if (of->f_uniqid == uniqid) {
682 			if (smb_ofile_hold(of)) {
683 				smb_llist_exit(of_list);
684 				return (of);
685 			}
686 		}
687 
688 		of = smb_llist_next(of_list, of);
689 	}
690 
691 	smb_llist_exit(of_list);
692 	return (NULL);
693 }
694 
695 /*
696  * Disallow NetFileClose on certain ofiles to avoid side-effects.
697  * Closing a tree root is not allowed: use NetSessionDel or NetShareDel.
698  * Closing SRVSVC connections is not allowed because this NetFileClose
699  * request may depend on this ofile.
700  */
701 boolean_t
smb_ofile_disallow_fclose(smb_ofile_t * of)702 smb_ofile_disallow_fclose(smb_ofile_t *of)
703 {
704 	ASSERT(of);
705 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
706 	ASSERT(of->f_refcnt);
707 
708 	switch (of->f_ftype) {
709 	case SMB_FTYPE_DISK:
710 		ASSERT(of->f_tree);
711 		return (of->f_node == of->f_tree->t_snode);
712 
713 	case SMB_FTYPE_MESG_PIPE:
714 		ASSERT(of->f_pipe);
715 		if (smb_strcasecmp(of->f_pipe->p_name, "SRVSVC", 0) == 0)
716 			return (B_TRUE);
717 		break;
718 	default:
719 		break;
720 	}
721 
722 	return (B_FALSE);
723 }
724 
725 /*
726  * smb_ofile_set_flags
727  *
728  * Return value:
729  *
730  *	Current flags value
731  *
732  */
733 void
smb_ofile_set_flags(smb_ofile_t * of,uint32_t flags)734 smb_ofile_set_flags(
735     smb_ofile_t		*of,
736     uint32_t		flags)
737 {
738 	ASSERT(of);
739 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
740 	ASSERT(of->f_refcnt);
741 
742 	mutex_enter(&of->f_mutex);
743 	of->f_flags |= flags;
744 	mutex_exit(&of->f_mutex);
745 }
746 
747 /*
748  * smb_ofile_seek
749  *
750  * Return value:
751  *
752  *	0		Success
753  *	EINVAL		Unknown mode
754  *	EOVERFLOW	offset too big
755  *
756  */
757 int
smb_ofile_seek(smb_ofile_t * of,ushort_t mode,int32_t off,uint32_t * retoff)758 smb_ofile_seek(
759     smb_ofile_t		*of,
760     ushort_t		mode,
761     int32_t		off,
762     uint32_t		*retoff)
763 {
764 	u_offset_t	newoff = 0;
765 	int		rc = 0;
766 	smb_attr_t	attr;
767 
768 	ASSERT(of);
769 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
770 	ASSERT(of->f_refcnt);
771 
772 	mutex_enter(&of->f_mutex);
773 	switch (mode) {
774 	case SMB_SEEK_SET:
775 		if (off < 0)
776 			newoff = 0;
777 		else
778 			newoff = (u_offset_t)off;
779 		break;
780 
781 	case SMB_SEEK_CUR:
782 		if (off < 0 && (-off) > of->f_seek_pos)
783 			newoff = 0;
784 		else
785 			newoff = of->f_seek_pos + (u_offset_t)off;
786 		break;
787 
788 	case SMB_SEEK_END:
789 		bzero(&attr, sizeof (smb_attr_t));
790 		attr.sa_mask |= SMB_AT_SIZE;
791 		rc = smb_fsop_getattr(NULL, zone_kcred(), of->f_node, &attr);
792 		if (rc != 0) {
793 			mutex_exit(&of->f_mutex);
794 			return (rc);
795 		}
796 		if (off < 0 && (-off) > attr.sa_vattr.va_size)
797 			newoff = 0;
798 		else
799 			newoff = attr.sa_vattr.va_size + (u_offset_t)off;
800 		break;
801 
802 	default:
803 		mutex_exit(&of->f_mutex);
804 		return (EINVAL);
805 	}
806 
807 	/*
808 	 * See comments at the beginning of smb_seek.c.
809 	 * If the offset is greater than UINT_MAX, we will return an error.
810 	 */
811 
812 	if (newoff > UINT_MAX) {
813 		rc = EOVERFLOW;
814 	} else {
815 		of->f_seek_pos = newoff;
816 		*retoff = (uint32_t)newoff;
817 	}
818 	mutex_exit(&of->f_mutex);
819 	return (rc);
820 }
821 
822 /*
823  * smb_ofile_is_open
824  */
825 boolean_t
smb_ofile_is_open(smb_ofile_t * of)826 smb_ofile_is_open(smb_ofile_t *of)
827 {
828 	boolean_t	rc;
829 
830 	SMB_OFILE_VALID(of);
831 
832 	mutex_enter(&of->f_mutex);
833 	rc = smb_ofile_is_open_locked(of);
834 	mutex_exit(&of->f_mutex);
835 	return (rc);
836 }
837 
838 /* *************************** Static Functions ***************************** */
839 
840 /*
841  * Determine whether or not an ofile is open.
842  * This function must be called with the mutex held.
843  */
844 static boolean_t
smb_ofile_is_open_locked(smb_ofile_t * of)845 smb_ofile_is_open_locked(smb_ofile_t *of)
846 {
847 	switch (of->f_state) {
848 	case SMB_OFILE_STATE_OPEN:
849 		return (B_TRUE);
850 
851 	case SMB_OFILE_STATE_CLOSING:
852 	case SMB_OFILE_STATE_CLOSED:
853 		return (B_FALSE);
854 
855 	default:
856 		ASSERT(0);
857 		return (B_FALSE);
858 	}
859 }
860 
861 /*
862  * This function closes the file passed in (if appropriate) and returns the
863  * next open file in the list of open files of the tree of the open file passed
864  * in. It requires that the list of open files of the tree be entered in
865  * RW_READER mode before being called.
866  */
867 static smb_ofile_t *
smb_ofile_close_and_next(smb_ofile_t * of)868 smb_ofile_close_and_next(smb_ofile_t *of)
869 {
870 	smb_ofile_t	*next_of;
871 	smb_tree_t	*tree;
872 
873 	ASSERT(of);
874 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
875 
876 	mutex_enter(&of->f_mutex);
877 	switch (of->f_state) {
878 	case SMB_OFILE_STATE_OPEN:
879 		/* The file is still open. */
880 		of->f_refcnt++;
881 		ASSERT(of->f_refcnt);
882 		tree = of->f_tree;
883 		mutex_exit(&of->f_mutex);
884 		smb_llist_exit(&of->f_tree->t_ofile_list);
885 		smb_ofile_close(of, 0);
886 		smb_ofile_release(of);
887 		smb_llist_enter(&tree->t_ofile_list, RW_READER);
888 		next_of = smb_llist_head(&tree->t_ofile_list);
889 		break;
890 	case SMB_OFILE_STATE_CLOSING:
891 	case SMB_OFILE_STATE_CLOSED:
892 		/*
893 		 * The ofile exists but is closed or
894 		 * in the process being closed.
895 		 */
896 		mutex_exit(&of->f_mutex);
897 		next_of = smb_llist_next(&of->f_tree->t_ofile_list, of);
898 		break;
899 	default:
900 		ASSERT(0);
901 		mutex_exit(&of->f_mutex);
902 		next_of = smb_llist_next(&of->f_tree->t_ofile_list, of);
903 		break;
904 	}
905 	return (next_of);
906 }
907 
908 /*
909  * Delete an ofile.
910  *
911  * Remove the ofile from the tree list before freeing resources
912  * associated with the ofile.
913  */
914 void
smb_ofile_delete(void * arg)915 smb_ofile_delete(void *arg)
916 {
917 	smb_tree_t	*tree;
918 	smb_ofile_t	*of = (smb_ofile_t *)arg;
919 
920 	SMB_OFILE_VALID(of);
921 	ASSERT(of->f_refcnt == 0);
922 	ASSERT(of->f_state == SMB_OFILE_STATE_CLOSED);
923 	ASSERT(!SMB_OFILE_OPLOCK_GRANTED(of));
924 
925 	tree = of->f_tree;
926 	smb_llist_enter(&tree->t_ofile_list, RW_WRITER);
927 	smb_llist_remove(&tree->t_ofile_list, of);
928 	smb_idpool_free(&tree->t_fid_pool, of->f_fid);
929 	atomic_dec_32(&tree->t_session->s_file_cnt);
930 	smb_llist_exit(&tree->t_ofile_list);
931 
932 	mutex_enter(&of->f_mutex);
933 	mutex_exit(&of->f_mutex);
934 
935 	if (of->f_ftype == SMB_FTYPE_MESG_PIPE) {
936 		smb_opipe_dealloc(of->f_pipe);
937 		of->f_pipe = NULL;
938 	} else {
939 		ASSERT(of->f_ftype == SMB_FTYPE_DISK);
940 		ASSERT(of->f_node != NULL);
941 		smb_node_rem_ofile(of->f_node, of);
942 		smb_node_release(of->f_node);
943 	}
944 
945 	of->f_magic = (uint32_t)~SMB_OFILE_MAGIC;
946 	mutex_destroy(&of->f_mutex);
947 	crfree(of->f_cr);
948 	smb_user_release(of->f_user);
949 	kmem_cache_free(smb_cache_ofile, of);
950 }
951 
952 /*
953  * smb_ofile_access
954  *
955  * This function will check to see if the access requested is granted.
956  * Returns NT status codes.
957  */
958 uint32_t
smb_ofile_access(smb_ofile_t * of,cred_t * cr,uint32_t access)959 smb_ofile_access(smb_ofile_t *of, cred_t *cr, uint32_t access)
960 {
961 
962 	if ((of == NULL) || (cr == zone_kcred()))
963 		return (NT_STATUS_SUCCESS);
964 
965 	/*
966 	 * If the request is for something
967 	 * I don't grant it is an error
968 	 */
969 	if (~(of->f_granted_access) & access) {
970 		if (!(of->f_granted_access & ACCESS_SYSTEM_SECURITY) &&
971 		    (access & ACCESS_SYSTEM_SECURITY)) {
972 			return (NT_STATUS_PRIVILEGE_NOT_HELD);
973 		}
974 		return (NT_STATUS_ACCESS_DENIED);
975 	}
976 
977 	return (NT_STATUS_SUCCESS);
978 }
979 
980 /*
981  * smb_ofile_share_check
982  *
983  * Check if ofile was opened with share access NONE (0).
984  * Returns: B_TRUE  - share access non-zero
985  *          B_FALSE - share access NONE
986  */
987 boolean_t
smb_ofile_share_check(smb_ofile_t * of)988 smb_ofile_share_check(smb_ofile_t *of)
989 {
990 	return (!SMB_DENY_ALL(of->f_share_access));
991 }
992 
993 /*
994  * check file sharing rules for current open request
995  * against existing open instances of the same file
996  *
997  * Returns NT_STATUS_SHARING_VIOLATION if there is any
998  * sharing conflict, otherwise returns NT_STATUS_SUCCESS.
999  */
1000 uint32_t
smb_ofile_open_check(smb_ofile_t * of,uint32_t desired_access,uint32_t share_access)1001 smb_ofile_open_check(smb_ofile_t *of, uint32_t desired_access,
1002     uint32_t share_access)
1003 {
1004 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
1005 
1006 	mutex_enter(&of->f_mutex);
1007 
1008 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
1009 		mutex_exit(&of->f_mutex);
1010 		return (NT_STATUS_INVALID_HANDLE);
1011 	}
1012 
1013 	/* if it's just meta data */
1014 	if ((of->f_granted_access & FILE_DATA_ALL) == 0) {
1015 		mutex_exit(&of->f_mutex);
1016 		return (NT_STATUS_SUCCESS);
1017 	}
1018 
1019 	/*
1020 	 * Check requested share access against the
1021 	 * open granted (desired) access
1022 	 */
1023 	if (SMB_DENY_DELETE(share_access) && (of->f_granted_access & DELETE)) {
1024 		mutex_exit(&of->f_mutex);
1025 		return (NT_STATUS_SHARING_VIOLATION);
1026 	}
1027 
1028 	if (SMB_DENY_READ(share_access) &&
1029 	    (of->f_granted_access & (FILE_READ_DATA | FILE_EXECUTE))) {
1030 		mutex_exit(&of->f_mutex);
1031 		return (NT_STATUS_SHARING_VIOLATION);
1032 	}
1033 
1034 	if (SMB_DENY_WRITE(share_access) &&
1035 	    (of->f_granted_access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
1036 		mutex_exit(&of->f_mutex);
1037 		return (NT_STATUS_SHARING_VIOLATION);
1038 	}
1039 
1040 	/* check requested desired access against the open share access */
1041 	if (SMB_DENY_DELETE(of->f_share_access) && (desired_access & DELETE)) {
1042 		mutex_exit(&of->f_mutex);
1043 		return (NT_STATUS_SHARING_VIOLATION);
1044 	}
1045 
1046 	if (SMB_DENY_READ(of->f_share_access) &&
1047 	    (desired_access & (FILE_READ_DATA | FILE_EXECUTE))) {
1048 		mutex_exit(&of->f_mutex);
1049 		return (NT_STATUS_SHARING_VIOLATION);
1050 	}
1051 
1052 	if (SMB_DENY_WRITE(of->f_share_access) &&
1053 	    (desired_access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
1054 		mutex_exit(&of->f_mutex);
1055 		return (NT_STATUS_SHARING_VIOLATION);
1056 	}
1057 
1058 	mutex_exit(&of->f_mutex);
1059 	return (NT_STATUS_SUCCESS);
1060 }
1061 
1062 /*
1063  * smb_ofile_rename_check
1064  *
1065  * An open file can be renamed if
1066  *
1067  *  1. isn't opened for data writing or deleting
1068  *
1069  *  2. Opened with "Deny Delete" share mode
1070  *         But not opened for data reading or executing
1071  *         (opened for accessing meta data)
1072  */
1073 
1074 uint32_t
smb_ofile_rename_check(smb_ofile_t * of)1075 smb_ofile_rename_check(smb_ofile_t *of)
1076 {
1077 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
1078 
1079 	mutex_enter(&of->f_mutex);
1080 
1081 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
1082 		mutex_exit(&of->f_mutex);
1083 		return (NT_STATUS_INVALID_HANDLE);
1084 	}
1085 
1086 	if (of->f_granted_access &
1087 	    (FILE_WRITE_DATA | FILE_APPEND_DATA | DELETE)) {
1088 		mutex_exit(&of->f_mutex);
1089 		return (NT_STATUS_SHARING_VIOLATION);
1090 	}
1091 
1092 	if ((of->f_share_access & FILE_SHARE_DELETE) == 0) {
1093 		if (of->f_granted_access &
1094 		    (FILE_READ_DATA | FILE_EXECUTE)) {
1095 			mutex_exit(&of->f_mutex);
1096 			return (NT_STATUS_SHARING_VIOLATION);
1097 		}
1098 	}
1099 
1100 	mutex_exit(&of->f_mutex);
1101 	return (NT_STATUS_SUCCESS);
1102 }
1103 
1104 /*
1105  * smb_ofile_delete_check
1106  *
1107  * An open file can be deleted only if opened for
1108  * accessing meta data. Share modes aren't important
1109  * in this case.
1110  *
1111  * NOTE: there is another mechanism for deleting an
1112  * open file that NT clients usually use.
1113  * That's setting "Delete on close" flag for an open
1114  * file.  In this way the file will be deleted after
1115  * last close. This flag can be set by SmbTrans2SetFileInfo
1116  * with FILE_DISPOSITION_INFO information level.
1117  * For setting this flag, the file should be opened by
1118  * DELETE access in the FID that is passed in the Trans2
1119  * request.
1120  */
1121 
1122 uint32_t
smb_ofile_delete_check(smb_ofile_t * of)1123 smb_ofile_delete_check(smb_ofile_t *of)
1124 {
1125 	ASSERT(of->f_magic == SMB_OFILE_MAGIC);
1126 
1127 	mutex_enter(&of->f_mutex);
1128 
1129 	if (of->f_state != SMB_OFILE_STATE_OPEN) {
1130 		mutex_exit(&of->f_mutex);
1131 		return (NT_STATUS_INVALID_HANDLE);
1132 	}
1133 
1134 	if (of->f_granted_access &
1135 	    (FILE_READ_DATA | FILE_WRITE_DATA |
1136 	    FILE_APPEND_DATA | FILE_EXECUTE | DELETE)) {
1137 		mutex_exit(&of->f_mutex);
1138 		return (NT_STATUS_SHARING_VIOLATION);
1139 	}
1140 
1141 	mutex_exit(&of->f_mutex);
1142 	return (NT_STATUS_SUCCESS);
1143 }
1144 
1145 cred_t *
smb_ofile_getcred(smb_ofile_t * of)1146 smb_ofile_getcred(smb_ofile_t *of)
1147 {
1148 	return (of->f_cr);
1149 }
1150 
1151 /*
1152  * smb_ofile_set_delete_on_close
1153  *
1154  * Set the DeleteOnClose flag on the smb file. When the file is closed,
1155  * the flag will be transferred to the smb node, which will commit the
1156  * delete operation and inhibit subsequent open requests.
1157  *
1158  * When DeleteOnClose is set on an smb_node, the common open code will
1159  * reject subsequent open requests for the file. Observation of Windows
1160  * 2000 indicates that subsequent opens should be allowed (assuming
1161  * there would be no sharing violation) until the file is closed using
1162  * the fid on which the DeleteOnClose was requested.
1163  */
1164 void
smb_ofile_set_delete_on_close(smb_ofile_t * of)1165 smb_ofile_set_delete_on_close(smb_ofile_t *of)
1166 {
1167 	mutex_enter(&of->f_mutex);
1168 	of->f_flags |= SMB_OFLAGS_SET_DELETE_ON_CLOSE;
1169 	mutex_exit(&of->f_mutex);
1170 }
1171 
1172 /*
1173  * Encode open file information into a buffer; needed in user space to
1174  * support RPC requests.
1175  */
1176 static int
smb_ofile_netinfo_encode(smb_ofile_t * of,uint8_t * buf,size_t buflen,uint32_t * nbytes)1177 smb_ofile_netinfo_encode(smb_ofile_t *of, uint8_t *buf, size_t buflen,
1178     uint32_t *nbytes)
1179 {
1180 	smb_netfileinfo_t	fi;
1181 	int			rc;
1182 
1183 	rc = smb_ofile_netinfo_init(of, &fi);
1184 	if (rc == 0) {
1185 		rc = smb_netfileinfo_encode(&fi, buf, buflen, nbytes);
1186 		smb_ofile_netinfo_fini(&fi);
1187 	}
1188 
1189 	return (rc);
1190 }
1191 
1192 static int
smb_ofile_netinfo_init(smb_ofile_t * of,smb_netfileinfo_t * fi)1193 smb_ofile_netinfo_init(smb_ofile_t *of, smb_netfileinfo_t *fi)
1194 {
1195 	smb_user_t	*user;
1196 	smb_tree_t	*tree;
1197 	smb_node_t	*node;
1198 	char		*path;
1199 	char		*buf;
1200 	int		rc;
1201 
1202 	ASSERT(of);
1203 	user = of->f_user;
1204 	tree = of->f_tree;
1205 	ASSERT(user);
1206 	ASSERT(tree);
1207 
1208 	buf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1209 
1210 	switch (of->f_ftype) {
1211 	case SMB_FTYPE_DISK:
1212 		node = of->f_node;
1213 		ASSERT(node);
1214 
1215 		fi->fi_permissions = of->f_granted_access;
1216 		fi->fi_numlocks = smb_lock_get_lock_count(node, of);
1217 
1218 		path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1219 
1220 		if (node != tree->t_snode) {
1221 			rc = smb_node_getshrpath(node, tree, path, MAXPATHLEN);
1222 			if (rc != 0)
1223 				(void) strlcpy(path, node->od_name, MAXPATHLEN);
1224 		}
1225 
1226 		(void) snprintf(buf, MAXPATHLEN, "%s:%s", tree->t_sharename,
1227 		    path);
1228 		kmem_free(path, MAXPATHLEN);
1229 		break;
1230 
1231 	case SMB_FTYPE_MESG_PIPE:
1232 		ASSERT(of->f_pipe);
1233 
1234 		fi->fi_permissions = FILE_READ_DATA | FILE_WRITE_DATA |
1235 		    FILE_EXECUTE;
1236 		fi->fi_numlocks = 0;
1237 		(void) snprintf(buf, MAXPATHLEN, "\\PIPE\\%s",
1238 		    of->f_pipe->p_name);
1239 		break;
1240 
1241 	default:
1242 		kmem_free(buf, MAXPATHLEN);
1243 		return (-1);
1244 	}
1245 
1246 	fi->fi_fid = of->f_fid;
1247 	fi->fi_uniqid = of->f_uniqid;
1248 	fi->fi_pathlen = strlen(buf) + 1;
1249 	fi->fi_path = smb_mem_strdup(buf);
1250 	kmem_free(buf, MAXPATHLEN);
1251 
1252 	fi->fi_namelen = user->u_domain_len + user->u_name_len + 2;
1253 	fi->fi_username = kmem_alloc(fi->fi_namelen, KM_SLEEP);
1254 	(void) snprintf(fi->fi_username, fi->fi_namelen, "%s\\%s",
1255 	    user->u_domain, user->u_name);
1256 	return (0);
1257 }
1258 
1259 static void
smb_ofile_netinfo_fini(smb_netfileinfo_t * fi)1260 smb_ofile_netinfo_fini(smb_netfileinfo_t *fi)
1261 {
1262 	if (fi == NULL)
1263 		return;
1264 
1265 	if (fi->fi_path)
1266 		smb_mem_free(fi->fi_path);
1267 	if (fi->fi_username)
1268 		kmem_free(fi->fi_username, fi->fi_namelen);
1269 
1270 	bzero(fi, sizeof (smb_netfileinfo_t));
1271 }
1272 
1273 /*
1274  * A query of user and group quotas may span multiple requests.
1275  * f_quota_resume is used to determine where the query should
1276  * be resumed, in a subsequent request. f_quota_resume contains
1277  * the SID of the last quota entry returned to the client.
1278  */
1279 void
smb_ofile_set_quota_resume(smb_ofile_t * ofile,char * resume)1280 smb_ofile_set_quota_resume(smb_ofile_t *ofile, char *resume)
1281 {
1282 	ASSERT(ofile);
1283 	mutex_enter(&ofile->f_mutex);
1284 	if (resume == NULL)
1285 		bzero(ofile->f_quota_resume, SMB_SID_STRSZ);
1286 	else
1287 		(void) strlcpy(ofile->f_quota_resume, resume, SMB_SID_STRSZ);
1288 	mutex_exit(&ofile->f_mutex);
1289 }
1290 
1291 void
smb_ofile_get_quota_resume(smb_ofile_t * ofile,char * buf,int bufsize)1292 smb_ofile_get_quota_resume(smb_ofile_t *ofile, char *buf, int bufsize)
1293 {
1294 	ASSERT(ofile);
1295 	mutex_enter(&ofile->f_mutex);
1296 	(void) strlcpy(buf, ofile->f_quota_resume, bufsize);
1297 	mutex_exit(&ofile->f_mutex);
1298 }
1299