1da6c28aaSamw /*
2da6c28aaSamw * CDDL HEADER START
3da6c28aaSamw *
4da6c28aaSamw * The contents of this file are subject to the terms of the
5da6c28aaSamw * Common Development and Distribution License (the "License").
6da6c28aaSamw * You may not use this file except in compliance with the License.
7da6c28aaSamw *
8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9da6c28aaSamw * or http://www.opensolaris.org/os/licensing.
10da6c28aaSamw * See the License for the specific language governing permissions
11da6c28aaSamw * and limitations under the License.
12da6c28aaSamw *
13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each
14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the
16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying
17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner]
18da6c28aaSamw *
19da6c28aaSamw * CDDL HEADER END
20da6c28aaSamw */
21da6c28aaSamw /*
22c5866007SKeyur Desai * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23525641e8SGordon Ross * Copyright 2011-2020 Tintri by DDN, Inc. All rights reserved.
246d1c73b5SDan Vatca * Copyright 2016 Syneto S.R.L. All rights reserved.
2548bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved.
26*11eb4918SGordon Ross * Copyright 2021-2023 RackTop Systems, Inc.
27da6c28aaSamw */
28da6c28aaSamw
29da6c28aaSamw /*
30da6c28aaSamw * General Structures Layout
31da6c28aaSamw * -------------------------
32da6c28aaSamw *
33da6c28aaSamw * This is a simplified diagram showing the relationship between most of the
34da6c28aaSamw * main structures.
35da6c28aaSamw *
36da6c28aaSamw * +-------------------+
37da6c28aaSamw * | SMB_INFO |
38da6c28aaSamw * +-------------------+
39da6c28aaSamw * |
40da6c28aaSamw * |
41da6c28aaSamw * v
42da6c28aaSamw * +-------------------+ +-------------------+ +-------------------+
43da6c28aaSamw * | SESSION |<----->| SESSION |......| SESSION |
44da6c28aaSamw * +-------------------+ +-------------------+ +-------------------+
453b13a1efSThomas Keiser * | |
463b13a1efSThomas Keiser * | |
473b13a1efSThomas Keiser * | v
483b13a1efSThomas Keiser * | +-------------------+ +-------------------+ +-------------------+
493b13a1efSThomas Keiser * | | USER |<--->| USER |...| USER |
503b13a1efSThomas Keiser * | +-------------------+ +-------------------+ +-------------------+
513b13a1efSThomas Keiser * |
523b13a1efSThomas Keiser * |
533b13a1efSThomas Keiser * v
54da6c28aaSamw * +-------------------+ +-------------------+ +-------------------+
55da6c28aaSamw * | TREE |<----->| TREE |......| TREE |
56da6c28aaSamw * +-------------------+ +-------------------+ +-------------------+
57da6c28aaSamw * | |
58da6c28aaSamw * | |
59da6c28aaSamw * | v
60da6c28aaSamw * | +-------+ +-------+ +-------+
61da6c28aaSamw * | | OFILE |<----->| OFILE |......| OFILE |
62da6c28aaSamw * | +-------+ +-------+ +-------+
63da6c28aaSamw * |
64da6c28aaSamw * |
65da6c28aaSamw * v
66da6c28aaSamw * +-------+ +------+ +------+
67da6c28aaSamw * | ODIR |<----->| ODIR |......| ODIR |
68da6c28aaSamw * +-------+ +------+ +------+
69da6c28aaSamw *
70da6c28aaSamw *
71da6c28aaSamw * Ofile State Machine
72da6c28aaSamw * ------------------
73da6c28aaSamw *
74da6c28aaSamw * +-------------------------+ T0
75811599a4SMatt Barden * | SMB_OFILE_STATE_OPEN |<--+-------- Creation/Allocation
76811599a4SMatt Barden * +-------------------------+ |
77811599a4SMatt Barden * | | | T5
78811599a4SMatt Barden * | | +---------------------------+
79811599a4SMatt Barden * | | | SMB_OFILE_STATE_RECONNECT |
80811599a4SMatt Barden * | | +---------------------------+
81811599a4SMatt Barden * | | ^
82811599a4SMatt Barden * | v |
83811599a4SMatt Barden * | +---------------+ |
84811599a4SMatt Barden * | | STATE_SAVE_DH | |
85811599a4SMatt Barden * | | STATE_SAVING | |
86811599a4SMatt Barden * | +---------------+ |
87811599a4SMatt Barden * | | | T4
88811599a4SMatt Barden * | T1 | T3 +--------------------------+
89811599a4SMatt Barden * | +------>| SMB_OFILE_STATE_ORPHANED |
90811599a4SMatt Barden * v +--------------------------+
91811599a4SMatt Barden * +-------------------------+ | |
92811599a4SMatt Barden * | SMB_OFILE_STATE_CLOSING |<--+ T6 | T7
93811599a4SMatt Barden * +-------------------------+ |
94811599a4SMatt Barden * | ^ v
95811599a4SMatt Barden * | T2 | T8 +-------------------------+
96811599a4SMatt Barden * | +-------| SMB_OFILE_STATE_EXPIRED |
97811599a4SMatt Barden * v +-------------------------+
98da6c28aaSamw * +-------------------------+
99da6c28aaSamw * | SMB_OFILE_STATE_CLOSED |----------> Deletion/Free
100811599a4SMatt Barden * +-------------------------+ T9
101da6c28aaSamw *
102da6c28aaSamw * SMB_OFILE_STATE_OPEN
103da6c28aaSamw *
104da6c28aaSamw * While in this state:
105da6c28aaSamw * - The ofile is queued in the list of ofiles of its tree.
106da6c28aaSamw * - References will be given out if the ofile is looked up.
107da6c28aaSamw *
108811599a4SMatt Barden * SMB_OFILE_STATE_SAVE_DH
109811599a4SMatt Barden *
110811599a4SMatt Barden * Similar to state _CLOSING, but instead of deleting the ofile,
111811599a4SMatt Barden * it leaves the ofile in state _ORPHANED (for later reclaim).
112811599a4SMatt Barden * Will move to _SAVING after last ref, then _ORPHANED.
113811599a4SMatt Barden *
114811599a4SMatt Barden * While in this state:
115811599a4SMatt Barden * - The ofile has been marked for preservation during a
116811599a4SMatt Barden * walk of the tree ofile list to close multiple files.
117811599a4SMatt Barden * - References will not be given out if the ofile is looked up,
118811599a4SMatt Barden * except for oplock break processing.
119811599a4SMatt Barden * - Still affects Sharing Violation rules
120811599a4SMatt Barden *
121811599a4SMatt Barden * SMB_OFILE_STATE_SAVING
122811599a4SMatt Barden *
123811599a4SMatt Barden * Transient state used to keep oplock break processing out
124811599a4SMatt Barden * while the ofile moves to state _ORPHANED.
125811599a4SMatt Barden *
126811599a4SMatt Barden * While in this state:
127811599a4SMatt Barden * - References will not be given out if the ofile is looked up,
128811599a4SMatt Barden * except for oplock break processing.
129811599a4SMatt Barden * - Still affects Sharing Violation rules
130811599a4SMatt Barden *
131da6c28aaSamw * SMB_OFILE_STATE_CLOSING
132da6c28aaSamw *
133811599a4SMatt Barden * Close has been requested. Stay in this state until the last
134811599a4SMatt Barden * ref. is gone, then move to state _CLOSED
135811599a4SMatt Barden *
136da6c28aaSamw * While in this state:
137da6c28aaSamw * - The ofile is queued in the list of ofiles of its tree.
138da6c28aaSamw * - References will not be given out if the ofile is looked up.
139da6c28aaSamw * - The file is closed and the locks held are being released.
140da6c28aaSamw * - The resources associated with the ofile remain.
141da6c28aaSamw *
142da6c28aaSamw * SMB_OFILE_STATE_CLOSED
143da6c28aaSamw *
144da6c28aaSamw * While in this state:
145da6c28aaSamw * - The ofile is queued in the list of ofiles of its tree.
146da6c28aaSamw * - References will not be given out if the ofile is looked up.
147da6c28aaSamw * - The resources associated with the ofile remain.
148da6c28aaSamw *
149811599a4SMatt Barden * SMB_OFILE_STATE_ORPHANED
150811599a4SMatt Barden *
151811599a4SMatt Barden * While in this state:
152811599a4SMatt Barden * - The ofile is queued in the list of ofiles of its tree.
153811599a4SMatt Barden * - Can be reclaimed by the original owner
154811599a4SMatt Barden * - References will not be given out if the ofile is looked up.
155811599a4SMatt Barden * - All the tree, user, and session "up" pointers are NULL!
156811599a4SMatt Barden * - Will eventually be "expired" if not reclaimed
157811599a4SMatt Barden * - Can be closed if its oplock is broken
158811599a4SMatt Barden * - Still affects Sharing Violation rules
159811599a4SMatt Barden *
160811599a4SMatt Barden * SMB_OFILE_STATE_EXPIRED
161811599a4SMatt Barden *
162811599a4SMatt Barden * While in this state:
163811599a4SMatt Barden * - The ofile is queued in the list of ofiles of its tree.
164811599a4SMatt Barden * - References will not be given out if the ofile is looked up.
165811599a4SMatt Barden * - The ofile has not been reclaimed and will soon be closed,
166811599a4SMatt Barden * due to, for example, the durable handle timer expiring, or its
167811599a4SMatt Barden * oplock being broken.
168811599a4SMatt Barden * - Cannot be reclaimed at this point
169811599a4SMatt Barden *
170811599a4SMatt Barden * SMB_OFILE_STATE_RECONNECT
171811599a4SMatt Barden *
172811599a4SMatt Barden * Transient state used to keep oplock break processing out
173811599a4SMatt Barden * while the ofile moves from state _ORPHANED to _OPEN.
174811599a4SMatt Barden *
175811599a4SMatt Barden * While in this state:
176811599a4SMatt Barden * - The ofile is being reclaimed; do not touch it.
177811599a4SMatt Barden * - References will not be given out if the ofile is looked up.
178811599a4SMatt Barden * - Still affects Sharing Violation rules
179811599a4SMatt Barden * - see smb2_dh_reconnect() for which members need to be avoided
180811599a4SMatt Barden *
181da6c28aaSamw * Transition T0
182da6c28aaSamw *
183da6c28aaSamw * This transition occurs in smb_ofile_open(). A new ofile is created and
184da6c28aaSamw * added to the list of ofiles of a tree.
185da6c28aaSamw *
186da6c28aaSamw * Transition T1
187da6c28aaSamw *
188811599a4SMatt Barden * This transition occurs in smb_ofile_close(). Note that this only happens
189811599a4SMatt Barden * when we determine that an ofile should be closed in spite of its durable
190811599a4SMatt Barden * handle properties.
191da6c28aaSamw *
192da6c28aaSamw * Transition T2
193da6c28aaSamw *
194da6c28aaSamw * This transition occurs in smb_ofile_release(). The resources associated
195da6c28aaSamw * with the ofile are freed as well as the ofile structure. For the
196da6c28aaSamw * transition to occur, the ofile must be in the SMB_OFILE_STATE_CLOSED
197da6c28aaSamw * state and the reference count be zero.
198da6c28aaSamw *
199811599a4SMatt Barden * Transition T3
200811599a4SMatt Barden *
201811599a4SMatt Barden * This transition occurs in smb_ofile_orphan_dh(). It happens during an
202811599a4SMatt Barden * smb2 logoff, or during a session disconnect when certain conditions are
203811599a4SMatt Barden * met. The ofile and structures above it will be kept around until the ofile
204811599a4SMatt Barden * either gets reclaimed, expires after f_timeout_offset nanoseconds, or its
205811599a4SMatt Barden * oplock is broken.
206811599a4SMatt Barden *
207811599a4SMatt Barden * Transition T4
208811599a4SMatt Barden *
209811599a4SMatt Barden * This transition occurs in smb2_dh_reconnect(). An smb2 create request
210811599a4SMatt Barden * with a DURABLE_HANDLE_RECONNECT(_V2) create context has been
211811599a4SMatt Barden * recieved from the original owner. If leases are supported or it's
212811599a4SMatt Barden * RECONNECT_V2, reconnect is subject to additional conditions. The ofile
213811599a4SMatt Barden * will be unwired from the old, disconnected session, tree, and user,
214811599a4SMatt Barden * and wired up to its new context.
215811599a4SMatt Barden *
216811599a4SMatt Barden * Transition T5
217811599a4SMatt Barden *
218811599a4SMatt Barden * This transition occurs in smb2_dh_reconnect(). The ofile has been
219811599a4SMatt Barden * successfully reclaimed.
220811599a4SMatt Barden *
221811599a4SMatt Barden * Transition T6
222811599a4SMatt Barden *
223811599a4SMatt Barden * This transition occurs in smb_ofile_close(). The ofile has been orphaned
224811599a4SMatt Barden * while some thread was blocked, and that thread closes the ofile. Can only
225811599a4SMatt Barden * happen when the ofile is orphaned due to an SMB2 LOGOFF request.
226811599a4SMatt Barden *
227811599a4SMatt Barden * Transition T7
228811599a4SMatt Barden *
229811599a4SMatt Barden * This transition occurs in smb_session_durable_timers() and
23072b35b05SGordon Ross * smb_oplock_send_break(). The ofile will soon be closed.
231811599a4SMatt Barden * In the former case, f_timeout_offset nanoseconds have passed since
232811599a4SMatt Barden * the ofile was orphaned. In the latter, an oplock break occured
233811599a4SMatt Barden * on the ofile while it was orphaned.
234811599a4SMatt Barden *
235811599a4SMatt Barden * Transition T8
236811599a4SMatt Barden *
237811599a4SMatt Barden * This transition occurs in smb_ofile_close().
238811599a4SMatt Barden *
239811599a4SMatt Barden * Transition T9
240811599a4SMatt Barden *
241811599a4SMatt Barden * This transition occurs in smb_ofile_delete().
242811599a4SMatt Barden *
243da6c28aaSamw * Comments
244da6c28aaSamw * --------
245da6c28aaSamw *
246da6c28aaSamw * The state machine of the ofile structures is controlled by 3 elements:
247da6c28aaSamw * - The list of ofiles of the tree it belongs to.
248da6c28aaSamw * - The mutex embedded in the structure itself.
249da6c28aaSamw * - The reference count.
250da6c28aaSamw *
251da6c28aaSamw * There's a mutex embedded in the ofile structure used to protect its fields
252da6c28aaSamw * and there's a lock embedded in the list of ofiles of a tree. To
253da6c28aaSamw * increment or to decrement the reference count the mutex must be entered.
254da6c28aaSamw * To insert the ofile into the list of ofiles of the tree and to remove
255da6c28aaSamw * the ofile from it, the lock must be entered in RW_WRITER mode.
256da6c28aaSamw *
257da6c28aaSamw * Rules of access to a ofile structure:
258da6c28aaSamw *
259da6c28aaSamw * 1) In order to avoid deadlocks, when both (mutex and lock of the ofile
260811599a4SMatt Barden * list) have to be entered, the lock must be entered first. Additionally,
261811599a4SMatt Barden * f_mutex must not be held when removing the ofile from sv_persistid_ht.
262da6c28aaSamw *
263da6c28aaSamw * 2) All actions applied to an ofile require a reference count.
264da6c28aaSamw *
265da6c28aaSamw * 3) There are 2 ways of getting a reference count. One is when the ofile
266da6c28aaSamw * is opened. The other one when the ofile is looked up. This translates
267da6c28aaSamw * into 2 functions: smb_ofile_open() and smb_ofile_lookup_by_fid().
268da6c28aaSamw *
269da6c28aaSamw * It should be noted that the reference count of an ofile registers the
270da6c28aaSamw * number of references to the ofile in other structures (such as an smb
271da6c28aaSamw * request). The reference count is not incremented in these 2 instances:
272da6c28aaSamw *
27348bbca81SDaniel Hoffman * 1) The ofile is open. An ofile is anchored by its state. If there's
274da6c28aaSamw * no activity involving an ofile currently open, the reference count
275da6c28aaSamw * of that ofile is zero.
276da6c28aaSamw *
277da6c28aaSamw * 2) The ofile is queued in the list of ofiles of its tree. The fact of
278da6c28aaSamw * being queued in that list is NOT registered by incrementing the
279da6c28aaSamw * reference count.
280da6c28aaSamw */
281811599a4SMatt Barden #include <smbsrv/smb2_kproto.h>
282da6c28aaSamw #include <smbsrv/smb_fsops.h>
283811599a4SMatt Barden #include <sys/time.h>
2848d94f651SGordon Ross #include <sys/random.h>
285da6c28aaSamw
2861fcced4cSJordan Brown static boolean_t smb_ofile_is_open_locked(smb_ofile_t *);
287811599a4SMatt Barden static void smb_ofile_delete(void *arg);
288811599a4SMatt Barden static void smb_ofile_save_dh(void *arg);
289811599a4SMatt Barden
2901fcced4cSJordan Brown static int smb_ofile_netinfo_encode(smb_ofile_t *, uint8_t *, size_t,
2911fcced4cSJordan Brown uint32_t *);
2921fcced4cSJordan Brown static int smb_ofile_netinfo_init(smb_ofile_t *, smb_netfileinfo_t *);
2931fcced4cSJordan Brown static void smb_ofile_netinfo_fini(smb_netfileinfo_t *);
294da6c28aaSamw
2958d94f651SGordon Ross /*
2968d94f651SGordon Ross * The uniq_fid is a CIFS-server-wide unique identifier for an ofile
2978d94f651SGordon Ross * which is used to uniquely identify open instances for the
2988d94f651SGordon Ross * VFS share reservation and POSIX locks.
2998d94f651SGordon Ross */
3008d94f651SGordon Ross static volatile uint32_t smb_fids = 0;
3018d94f651SGordon Ross #define SMB_UNIQ_FID() atomic_inc_32_nv(&smb_fids)
3028d94f651SGordon Ross
3032cf6b79fSGordon Ross /*
3042cf6b79fSGordon Ross * AVL Comparator for t_ofile_list
3052cf6b79fSGordon Ross *
3062cf6b79fSGordon Ross * NB: can only access f_fid because smb_ofile_lookup_by_fid
3072cf6b79fSGordon Ross * doesn't pass in an entire smb_ofile_t.
3082cf6b79fSGordon Ross */
3092cf6b79fSGordon Ross int
smb_ofile_avl_compare(const void * v1,const void * v2)3102cf6b79fSGordon Ross smb_ofile_avl_compare(const void *v1, const void *v2)
3112cf6b79fSGordon Ross {
3122cf6b79fSGordon Ross const smb_ofile_t *of1 = v1;
3132cf6b79fSGordon Ross const smb_ofile_t *of2 = v2;
3142cf6b79fSGordon Ross
3152cf6b79fSGordon Ross return (AVL_CMP(of1->f_fid, of2->f_fid));
3162cf6b79fSGordon Ross }
3172cf6b79fSGordon Ross
318da6c28aaSamw /*
31994047d49SGordon Ross * smb_ofile_alloc
32094047d49SGordon Ross * Allocate an ofile and fill in it's "up" pointers, but
32194047d49SGordon Ross * do NOT link it into the tree's list of ofiles or the
32294047d49SGordon Ross * node's list of ofiles. An ofile in this state is a
32394047d49SGordon Ross * "proposed" open passed to the oplock break code.
32494047d49SGordon Ross *
32594047d49SGordon Ross * If we don't get as far as smb_ofile_open with this OF,
32694047d49SGordon Ross * call smb_ofile_free() to free this object.
3278d94f651SGordon Ross *
3288d94f651SGordon Ross * Note: The following sr members may be null during
3298d94f651SGordon Ross * persistent handle import: session, uid_usr, tid_tree
330da6c28aaSamw */
331da6c28aaSamw smb_ofile_t *
smb_ofile_alloc(smb_request_t * sr,smb_arg_open_t * op,smb_node_t * node,uint16_t ftype,uint16_t tree_fid)33294047d49SGordon Ross smb_ofile_alloc(
3333b13a1efSThomas Keiser smb_request_t *sr,
33494047d49SGordon Ross smb_arg_open_t *op,
33594047d49SGordon Ross smb_node_t *node, /* optional (may be NULL) */
336da6c28aaSamw uint16_t ftype,
3378d94f651SGordon Ross uint16_t tree_fid)
338da6c28aaSamw {
3398d94f651SGordon Ross smb_user_t *user = sr->uid_user; /* optional */
3408d94f651SGordon Ross smb_tree_t *tree = sr->tid_tree; /* optional */
341da6c28aaSamw smb_ofile_t *of;
342da6c28aaSamw
3438622ec45SGordon Ross of = kmem_cache_alloc(smb_cache_ofile, KM_SLEEP);
344da6c28aaSamw bzero(of, sizeof (smb_ofile_t));
345da6c28aaSamw of->f_magic = SMB_OFILE_MAGIC;
346bfe5e737SGordon Ross
347bfe5e737SGordon Ross mutex_init(&of->f_mutex, NULL, MUTEX_DEFAULT, NULL);
348bfe5e737SGordon Ross list_create(&of->f_notify.nc_waiters, sizeof (smb_request_t),
349bfe5e737SGordon Ross offsetof(smb_request_t, sr_waiters));
3508d94f651SGordon Ross mutex_init(&of->dh_nvlock, NULL, MUTEX_DEFAULT, NULL);
351bfe5e737SGordon Ross
35294047d49SGordon Ross of->f_state = SMB_OFILE_STATE_ALLOC;
353da6c28aaSamw of->f_refcnt = 1;
354811599a4SMatt Barden of->f_ftype = ftype;
35594047d49SGordon Ross of->f_fid = tree_fid;
356811599a4SMatt Barden /* of->f_persistid see smb2_create */
3578d94f651SGordon Ross of->f_uniqid = SMB_UNIQ_FID();
35868b2bbf2SGordon Ross of->f_opened_by_pid = sr->smb_pid;
359c8ec8eeaSjose borrego of->f_granted_access = op->desired_access;
360c8ec8eeaSjose borrego of->f_share_access = op->share_access;
361c8ec8eeaSjose borrego of->f_create_options = op->create_options;
3628d94f651SGordon Ross if (user != NULL) {
3638d94f651SGordon Ross if ((op->create_options & FILE_OPEN_FOR_BACKUP_INTENT) != 0)
3648d94f651SGordon Ross of->f_cr = smb_user_getprivcred(user);
3658d94f651SGordon Ross else
3668d94f651SGordon Ross of->f_cr = user->u_cred;
3678d94f651SGordon Ross crhold(of->f_cr);
3688d94f651SGordon Ross }
3698d94f651SGordon Ross of->f_server = sr->sr_server;
3708d94f651SGordon Ross of->f_session = sr->session; /* may be NULL */
3718d94f651SGordon Ross
3726f58980aSGordon Ross (void) memset(of->f_lock_seq, -1, SMB_OFILE_LSEQ_MAX);
373bfe5e737SGordon Ross
37494047d49SGordon Ross of->f_mode = smb_fsop_amask_to_omode(of->f_granted_access);
37594047d49SGordon Ross if ((of->f_granted_access & FILE_DATA_ALL) == FILE_EXECUTE)
37694047d49SGordon Ross of->f_flags |= SMB_OFLAGS_EXECONLY;
37794047d49SGordon Ross
37894047d49SGordon Ross /*
37994047d49SGordon Ross * In case a lease is requested, copy the lease keys now so
38094047d49SGordon Ross * any oplock breaks during open don't break those on our
38194047d49SGordon Ross * other handles that might have the same lease.
38294047d49SGordon Ross */
38394047d49SGordon Ross bcopy(op->lease_key, of->TargetOplockKey, SMB_LEASE_KEY_SZ);
38494047d49SGordon Ross bcopy(op->parent_lease_key, of->ParentOplockKey, SMB_LEASE_KEY_SZ);
38594047d49SGordon Ross
3863b13a1efSThomas Keiser /*
387811599a4SMatt Barden * grab a ref for of->f_user and of->f_tree
38894047d49SGordon Ross * We know the user and tree must be "live" because
38994047d49SGordon Ross * this SR holds references to them. The node ref. is
39094047d49SGordon Ross * held by our caller, until smb_ofile_open puts this
39194047d49SGordon Ross * ofile on the node ofile list with smb_node_add_ofile.
3923b13a1efSThomas Keiser */
3938d94f651SGordon Ross if (user != NULL) {
3948d94f651SGordon Ross smb_user_hold_internal(user);
3958d94f651SGordon Ross of->f_user = user;
3968d94f651SGordon Ross }
3978d94f651SGordon Ross if (tree != NULL) {
3988d94f651SGordon Ross smb_tree_hold_internal(tree);
3998d94f651SGordon Ross of->f_tree = tree;
4008d94f651SGordon Ross }
4018d94f651SGordon Ross of->f_node = node; /* may be NULL */
4025fd03bc0SGordon Ross
40394047d49SGordon Ross return (of);
40494047d49SGordon Ross }
4052c2961f8Sjose borrego
40694047d49SGordon Ross /*
40794047d49SGordon Ross * smb_ofile_open
40894047d49SGordon Ross *
40994047d49SGordon Ross * Complete an open on an ofile that was previously allocated by
41094047d49SGordon Ross * smb_ofile_alloc, by putting it on the tree ofile list and
41194047d49SGordon Ross * (if it's a file) the node ofile list.
41294047d49SGordon Ross */
41394047d49SGordon Ross void
smb_ofile_open(smb_request_t * sr,smb_arg_open_t * op,smb_ofile_t * of)41494047d49SGordon Ross smb_ofile_open(
41594047d49SGordon Ross smb_request_t *sr,
41694047d49SGordon Ross smb_arg_open_t *op,
41794047d49SGordon Ross smb_ofile_t *of)
41894047d49SGordon Ross {
41994047d49SGordon Ross smb_tree_t *tree = sr->tid_tree;
42094047d49SGordon Ross smb_node_t *node = of->f_node;
4212c2961f8Sjose borrego
42294047d49SGordon Ross ASSERT(of->f_state == SMB_OFILE_STATE_ALLOC);
423088ae41eSGordon Ross ASSERT(of->f_fid != 0);
424088ae41eSGordon Ross
42594047d49SGordon Ross of->f_state = SMB_OFILE_STATE_OPEN;
426da6c28aaSamw
42794047d49SGordon Ross switch (of->f_ftype) {
42894047d49SGordon Ross case SMB_FTYPE_BYTE_PIPE:
42994047d49SGordon Ross case SMB_FTYPE_MESG_PIPE:
43094047d49SGordon Ross /* See smb_opipe_open. */
43194047d49SGordon Ross of->f_pipe = op->pipe;
43294047d49SGordon Ross smb_server_inc_pipes(of->f_server);
43394047d49SGordon Ross break;
43494047d49SGordon Ross case SMB_FTYPE_DISK:
43594047d49SGordon Ross case SMB_FTYPE_PRINTER:
43694047d49SGordon Ross /* Regular file, not a pipe */
43794047d49SGordon Ross ASSERT(node != NULL);
4388c10a865Sas
4392c2961f8Sjose borrego smb_node_inc_open_ofiles(node);
440fc724630SAlan Wright smb_node_add_ofile(node, of);
4418b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States smb_node_ref(node);
442148c5f43SAlan Wright smb_server_inc_files(of->f_server);
44394047d49SGordon Ross break;
44494047d49SGordon Ross default:
44594047d49SGordon Ross ASSERT(0);
446da6c28aaSamw }
4472cf6b79fSGordon Ross ASSERT(of->f_fid != 0);
4482cf6b79fSGordon Ross smb_lavl_enter(&tree->t_ofile_list, RW_WRITER);
4492cf6b79fSGordon Ross smb_lavl_insert(&tree->t_ofile_list, of);
4502cf6b79fSGordon Ross smb_lavl_exit(&tree->t_ofile_list);
4511fcced4cSJordan Brown atomic_inc_32(&tree->t_open_files);
452da6c28aaSamw atomic_inc_32(&of->f_session->s_file_cnt);
453bfe5e737SGordon Ross
454da6c28aaSamw }
455da6c28aaSamw
456da6c28aaSamw /*
457da6c28aaSamw * smb_ofile_close
458811599a4SMatt Barden *
459811599a4SMatt Barden * Incoming states: (where from)
460811599a4SMatt Barden * SMB_OFILE_STATE_OPEN protocol close, smb_ofile_drop
461811599a4SMatt Barden * SMB_OFILE_STATE_EXPIRED called via smb2_dh_expire
462811599a4SMatt Barden * SMB_OFILE_STATE_ORPHANED smb2_dh_shutdown
46372b35b05SGordon Ross *
46472b35b05SGordon Ross * Not that this enters the of->node->n_ofile_list rwlock as reader,
46572b35b05SGordon Ross * (via smb_oplock_close) so this must not be called while holding
46672b35b05SGordon Ross * that rwlock.
467da6c28aaSamw */
468c8ec8eeaSjose borrego void
smb_ofile_close(smb_ofile_t * of,int32_t mtime_sec)4695fd03bc0SGordon Ross smb_ofile_close(smb_ofile_t *of, int32_t mtime_sec)
470da6c28aaSamw {
471a90cf9f2SGordon Ross smb_attr_t *pa;
472da6c28aaSamw
4735fd03bc0SGordon Ross SMB_OFILE_VALID(of);
4745fd03bc0SGordon Ross
4751f0845f1SGordon Ross if (of->f_ftype == SMB_FTYPE_DISK) {
47672b35b05SGordon Ross smb_oplock_close(of);
4771f0845f1SGordon Ross }
4781f0845f1SGordon Ross
479da6c28aaSamw mutex_enter(&of->f_mutex);
480da6c28aaSamw ASSERT(of->f_refcnt);
481811599a4SMatt Barden
482811599a4SMatt Barden switch (of->f_state) {
483811599a4SMatt Barden case SMB_OFILE_STATE_OPEN:
484811599a4SMatt Barden case SMB_OFILE_STATE_ORPHANED:
485811599a4SMatt Barden case SMB_OFILE_STATE_EXPIRED:
486811599a4SMatt Barden of->f_state = SMB_OFILE_STATE_CLOSING;
487811599a4SMatt Barden mutex_exit(&of->f_mutex);
488811599a4SMatt Barden break;
489811599a4SMatt Barden default:
490da6c28aaSamw mutex_exit(&of->f_mutex);
49168b2bbf2SGordon Ross return;
49268b2bbf2SGordon Ross }
493da6c28aaSamw
4948d94f651SGordon Ross /*
4958d94f651SGordon Ross * Only one thread here (the one that that set f_state closing)
4968d94f651SGordon Ross */
497a90cf9f2SGordon Ross switch (of->f_ftype) {
498a90cf9f2SGordon Ross case SMB_FTYPE_BYTE_PIPE:
499a90cf9f2SGordon Ross case SMB_FTYPE_MESG_PIPE:
50068b2bbf2SGordon Ross smb_opipe_close(of);
50168b2bbf2SGordon Ross smb_server_dec_pipes(of->f_server);
502a90cf9f2SGordon Ross break;
5035fd03bc0SGordon Ross
504a90cf9f2SGordon Ross case SMB_FTYPE_DISK:
5058d94f651SGordon Ross if (of->dh_persist)
5068d94f651SGordon Ross smb2_dh_close_persistent(of);
507811599a4SMatt Barden if (of->f_persistid != 0)
508811599a4SMatt Barden smb_ofile_del_persistid(of);
509811599a4SMatt Barden /* FALLTHROUGH */
51094047d49SGordon Ross
511811599a4SMatt Barden case SMB_FTYPE_PRINTER: /* or FTYPE_DISK */
51268b2bbf2SGordon Ross /*
51368b2bbf2SGordon Ross * In here we make changes to of->f_pending_attr
51468b2bbf2SGordon Ross * while not holding of->f_mutex. This is OK
51568b2bbf2SGordon Ross * because we've changed f_state to CLOSING,
51668b2bbf2SGordon Ross * so no more threads will take this path.
51768b2bbf2SGordon Ross */
518a90cf9f2SGordon Ross pa = &of->f_pending_attr;
51968b2bbf2SGordon Ross if (mtime_sec != 0) {
52068b2bbf2SGordon Ross pa->sa_vattr.va_mtime.tv_sec = mtime_sec;
52168b2bbf2SGordon Ross pa->sa_mask |= SMB_AT_MTIME;
52268b2bbf2SGordon Ross }
523da6c28aaSamw
52468b2bbf2SGordon Ross if (of->f_flags & SMB_OFLAGS_SET_DELETE_ON_CLOSE) {
525811599a4SMatt Barden /* We delete using the on-disk name. */
526811599a4SMatt Barden uint32_t flags = SMB_CASE_SENSITIVE;
52768b2bbf2SGordon Ross (void) smb_node_set_delete_on_close(of->f_node,
52868b2bbf2SGordon Ross of->f_cr, flags);
52968b2bbf2SGordon Ross }
53068b2bbf2SGordon Ross smb_fsop_unshrlock(of->f_cr, of->f_node, of->f_uniqid);
53168b2bbf2SGordon Ross smb_node_destroy_lock_by_ofile(of->f_node, of);
532dc20a302Sas
53368b2bbf2SGordon Ross if (smb_node_is_file(of->f_node)) {
53468b2bbf2SGordon Ross (void) smb_fsop_close(of->f_node, of->f_mode,
53568b2bbf2SGordon Ross of->f_cr);
536a90cf9f2SGordon Ross } else {
537a90cf9f2SGordon Ross /*
538a90cf9f2SGordon Ross * If there was an odir, close it.
539a90cf9f2SGordon Ross */
540a90cf9f2SGordon Ross if (of->f_odir != NULL)
541a90cf9f2SGordon Ross smb_odir_close(of->f_odir);
542bfe5e737SGordon Ross /*
543bfe5e737SGordon Ross * Cancel any notify change requests that
544bfe5e737SGordon Ross * might be watching this open file (dir),
545bfe5e737SGordon Ross * and unsubscribe it from node events.
546bfe5e737SGordon Ross *
547bfe5e737SGordon Ross * Can't hold f_mutex when calling smb_notify_ofile.
548bfe5e737SGordon Ross * Don't really need it when unsubscribing, but
549bfe5e737SGordon Ross * harmless, and consistent with subscribing.
550bfe5e737SGordon Ross */
551bfe5e737SGordon Ross if (of->f_notify.nc_subscribed)
552bfe5e737SGordon Ross smb_notify_ofile(of,
553bfe5e737SGordon Ross FILE_ACTION_HANDLE_CLOSED, NULL);
554bfe5e737SGordon Ross mutex_enter(&of->f_mutex);
555bfe5e737SGordon Ross if (of->f_notify.nc_subscribed) {
556bfe5e737SGordon Ross of->f_notify.nc_subscribed = B_FALSE;
557bfe5e737SGordon Ross smb_node_fcn_unsubscribe(of->f_node);
558bfe5e737SGordon Ross of->f_notify.nc_filter = 0;
559bfe5e737SGordon Ross }
560bfe5e737SGordon Ross mutex_exit(&of->f_mutex);
56168b2bbf2SGordon Ross }
56268b2bbf2SGordon Ross if (smb_node_dec_open_ofiles(of->f_node) == 0) {
563da6c28aaSamw /*
5645cb2894aSGordon Ross * Last close. If we're not deleting
5655cb2894aSGordon Ross * the file, apply any pending attrs.
5665cb2894aSGordon Ross * Leave allocsz zero when no open files,
5675cb2894aSGordon Ross * just to avoid confusion, because it's
5685cb2894aSGordon Ross * only updated when there are opens.
56994047d49SGordon Ross * XXX: Just do this on _every_ close.
570da6c28aaSamw */
57149d83597SMatt Barden mutex_enter(&of->f_node->n_mutex);
57249d83597SMatt Barden if (of->f_node->flags & NODE_FLAGS_DELETE_ON_CLOSE) {
57349d83597SMatt Barden smb_node_delete_on_close(of->f_node);
57449d83597SMatt Barden pa->sa_mask = 0;
57549d83597SMatt Barden }
5765cb2894aSGordon Ross of->f_node->n_allocsz = 0;
57749d83597SMatt Barden mutex_exit(&of->f_node->n_mutex);
57868b2bbf2SGordon Ross }
57968b2bbf2SGordon Ross if (pa->sa_mask != 0) {
58068b2bbf2SGordon Ross /*
58168b2bbf2SGordon Ross * Commit any pending attributes from
58268b2bbf2SGordon Ross * the ofile we're closing. Note that
58368b2bbf2SGordon Ross * we pass NULL as the ofile to setattr
58468b2bbf2SGordon Ross * so it will write to the file system
58568b2bbf2SGordon Ross * and not keep anything on the ofile.
58668b2bbf2SGordon Ross */
58768b2bbf2SGordon Ross (void) smb_node_setattr(NULL, of->f_node,
58868b2bbf2SGordon Ross of->f_cr, NULL, pa);
589da6c28aaSamw }
590f8e30ca2SGordon Ross /*
591f8e30ca2SGordon Ross * Don't want the performance cost of generating
592f8e30ca2SGordon Ross * change notify events on every write. Instead:
593f8e30ca2SGordon Ross * Keep track of the fact that we have written
594f8e30ca2SGordon Ross * data via this handle, and do change notify
595f8e30ca2SGordon Ross * work on the first write, and during close.
596f8e30ca2SGordon Ross */
597f8e30ca2SGordon Ross if (of->f_written) {
598f8e30ca2SGordon Ross smb_node_notify_modified(of->f_node);
599f8e30ca2SGordon Ross }
600da6c28aaSamw
60168b2bbf2SGordon Ross smb_server_dec_files(of->f_server);
602a90cf9f2SGordon Ross break;
603da6c28aaSamw }
60468b2bbf2SGordon Ross
605811599a4SMatt Barden /*
606811599a4SMatt Barden * Keep f_state == SMB_OFILE_STATE_CLOSING
607811599a4SMatt Barden * until the last ref. is dropped, in
608811599a4SMatt Barden * smb_ofile_release()
609811599a4SMatt Barden */
610da6c28aaSamw }
611da6c28aaSamw
612*11eb4918SGordon Ross uint32_t smb2_savedh_timeout = 60; /* sec. */
613*11eb4918SGordon Ross
614da6c28aaSamw /*
615811599a4SMatt Barden * "Destructor" function for smb_ofile_close_all, and
616811599a4SMatt Barden * smb_ofile_close_all_by_pid, called after the llist lock
617811599a4SMatt Barden * for tree list has been exited. Our job is to either
618811599a4SMatt Barden * close this ofile, or (if durable) set state _SAVE_DH.
619da6c28aaSamw *
620811599a4SMatt Barden * The next interesting thing happens when the last ref.
621811599a4SMatt Barden * on this ofile calls smb_ofile_release(), where we
622811599a4SMatt Barden * eihter delete the ofile, or (if durable) leave it
623811599a4SMatt Barden * in the persistid hash table for possible reclaim.
624*11eb4918SGordon Ross * (state becomes "orphaned").
625*11eb4918SGordon Ross *
626*11eb4918SGordon Ross * In case references dont't ever leave (eg. ref leak bug)
627*11eb4918SGordon Ross * arrange for smb2_durable_timers() to move this ofile from
628*11eb4918SGordon Ross * state SAVE_DH to state CLOSING. The dh_expire_time set
629*11eb4918SGordon Ross * on SAVE_DH ofiles here is temporary, and replaced with
630*11eb4918SGordon Ross * the negotiated expiration time when it becomes ORPHANED.
631da6c28aaSamw *
632811599a4SMatt Barden * This is run via smb_llist_post (after smb_llist_exit)
633811599a4SMatt Barden * because smb_ofile_close can block, and we'd rather not
634811599a4SMatt Barden * block while holding the ofile list as reader.
635da6c28aaSamw */
636811599a4SMatt Barden static void
smb_ofile_drop(void * arg)637811599a4SMatt Barden smb_ofile_drop(void *arg)
638da6c28aaSamw {
639811599a4SMatt Barden smb_ofile_t *of = arg;
640da6c28aaSamw
641811599a4SMatt Barden SMB_OFILE_VALID(of);
642da6c28aaSamw
643811599a4SMatt Barden mutex_enter(&of->f_mutex);
644811599a4SMatt Barden switch (of->f_state) {
645811599a4SMatt Barden case SMB_OFILE_STATE_OPEN:
646811599a4SMatt Barden /* DH checks under mutex. */
647811599a4SMatt Barden if (of->f_ftype == SMB_FTYPE_DISK &&
648811599a4SMatt Barden of->dh_vers != SMB2_NOT_DURABLE &&
649811599a4SMatt Barden smb_dh_should_save(of)) {
650811599a4SMatt Barden /*
651811599a4SMatt Barden * Tell smb_ofile_release() to
652811599a4SMatt Barden * make this an _ORPHANED DH.
653811599a4SMatt Barden */
654811599a4SMatt Barden of->f_state = SMB_OFILE_STATE_SAVE_DH;
655*11eb4918SGordon Ross of->dh_expire_time = gethrtime() +
656*11eb4918SGordon Ross SEC2NSEC(smb2_savedh_timeout);
657811599a4SMatt Barden mutex_exit(&of->f_mutex);
658811599a4SMatt Barden break;
659811599a4SMatt Barden }
660811599a4SMatt Barden /* OK close it. */
661811599a4SMatt Barden mutex_exit(&of->f_mutex);
662811599a4SMatt Barden smb_ofile_close(of, 0);
663811599a4SMatt Barden break;
664811599a4SMatt Barden
665811599a4SMatt Barden default:
666811599a4SMatt Barden /* Something else closed it already. */
667811599a4SMatt Barden mutex_exit(&of->f_mutex);
668811599a4SMatt Barden break;
669da6c28aaSamw }
670811599a4SMatt Barden
671811599a4SMatt Barden /*
672811599a4SMatt Barden * Release the ref acquired during the traversal loop.
673811599a4SMatt Barden * Note that on the last ref, this ofile will be
674811599a4SMatt Barden * removed from the tree list etc.
675811599a4SMatt Barden * See: smb_llist_post, smb_ofile_delete
676811599a4SMatt Barden */
677811599a4SMatt Barden smb_ofile_release(of);
678da6c28aaSamw }
679da6c28aaSamw
680da6c28aaSamw /*
681811599a4SMatt Barden * smb_ofile_close_all
682da6c28aaSamw *
683da6c28aaSamw *
684da6c28aaSamw */
685da6c28aaSamw void
smb_ofile_close_all(smb_tree_t * tree,uint32_t pid)686811599a4SMatt Barden smb_ofile_close_all(
687da6c28aaSamw smb_tree_t *tree,
688811599a4SMatt Barden uint32_t pid)
689da6c28aaSamw {
690da6c28aaSamw smb_ofile_t *of;
6912cf6b79fSGordon Ross smb_lavl_t *la;
692da6c28aaSamw
693da6c28aaSamw ASSERT(tree);
694da6c28aaSamw ASSERT(tree->t_magic == SMB_TREE_MAGIC);
695da6c28aaSamw
6962cf6b79fSGordon Ross la = &tree->t_ofile_list;
697811599a4SMatt Barden
6982cf6b79fSGordon Ross smb_lavl_enter(la, RW_READER);
6992cf6b79fSGordon Ross for (of = smb_lavl_first(la);
700811599a4SMatt Barden of != NULL;
7012cf6b79fSGordon Ross of = smb_lavl_next(la, of)) {
702da6c28aaSamw ASSERT(of->f_magic == SMB_OFILE_MAGIC);
703da6c28aaSamw ASSERT(of->f_tree == tree);
704811599a4SMatt Barden if (pid != 0 && of->f_opened_by_pid != pid)
705811599a4SMatt Barden continue;
706811599a4SMatt Barden if (smb_ofile_hold(of)) {
7072cf6b79fSGordon Ross smb_lavl_post(la, of, smb_ofile_drop);
708da6c28aaSamw }
709da6c28aaSamw }
710811599a4SMatt Barden
711811599a4SMatt Barden /*
712811599a4SMatt Barden * Drop the lock and process the llist dtor queue.
713811599a4SMatt Barden * Calls smb_ofile_drop on ofiles that were open.
714811599a4SMatt Barden */
7152cf6b79fSGordon Ross smb_lavl_exit(la);
716da6c28aaSamw }
717da6c28aaSamw
7181fcced4cSJordan Brown /*
7191fcced4cSJordan Brown * If the enumeration request is for ofile data, handle it here.
7201fcced4cSJordan Brown * Otherwise, return.
7211fcced4cSJordan Brown *
7221fcced4cSJordan Brown * This function should be called with a hold on the ofile.
7231fcced4cSJordan Brown */
7241fcced4cSJordan Brown int
smb_ofile_enum(smb_ofile_t * of,smb_svcenum_t * svcenum)7251fcced4cSJordan Brown smb_ofile_enum(smb_ofile_t *of, smb_svcenum_t *svcenum)
7261fcced4cSJordan Brown {
7271fcced4cSJordan Brown uint8_t *pb;
7281fcced4cSJordan Brown uint_t nbytes;
7291fcced4cSJordan Brown int rc;
7301fcced4cSJordan Brown
7311fcced4cSJordan Brown ASSERT(of);
7321fcced4cSJordan Brown ASSERT(of->f_magic == SMB_OFILE_MAGIC);
7331fcced4cSJordan Brown ASSERT(of->f_refcnt);
7341fcced4cSJordan Brown
7351fcced4cSJordan Brown if (svcenum->se_type != SMB_SVCENUM_TYPE_FILE)
7361fcced4cSJordan Brown return (0);
7371fcced4cSJordan Brown
7381fcced4cSJordan Brown if (svcenum->se_nskip > 0) {
7391fcced4cSJordan Brown svcenum->se_nskip--;
7401fcced4cSJordan Brown return (0);
7411fcced4cSJordan Brown }
7421fcced4cSJordan Brown
7431fcced4cSJordan Brown if (svcenum->se_nitems >= svcenum->se_nlimit) {
7441fcced4cSJordan Brown svcenum->se_nitems = svcenum->se_nlimit;
7451fcced4cSJordan Brown return (0);
7461fcced4cSJordan Brown }
7471fcced4cSJordan Brown
7481fcced4cSJordan Brown pb = &svcenum->se_buf[svcenum->se_bused];
7491fcced4cSJordan Brown
7501fcced4cSJordan Brown rc = smb_ofile_netinfo_encode(of, pb, svcenum->se_bavail,
7511fcced4cSJordan Brown &nbytes);
7521fcced4cSJordan Brown if (rc == 0) {
7531fcced4cSJordan Brown svcenum->se_bavail -= nbytes;
7541fcced4cSJordan Brown svcenum->se_bused += nbytes;
7551fcced4cSJordan Brown svcenum->se_nitems++;
7561fcced4cSJordan Brown }
7571fcced4cSJordan Brown
7581fcced4cSJordan Brown return (rc);
7591fcced4cSJordan Brown }
7601fcced4cSJordan Brown
761811599a4SMatt Barden /*
762811599a4SMatt Barden * Take a reference on an open file, in any of the states:
76372b35b05SGordon Ross * RECONNECT, SAVE_DH, OPEN, ORPHANED, EXPIRED.
764811599a4SMatt Barden * Return TRUE if ref taken. Used for oplock breaks.
765811599a4SMatt Barden *
766811599a4SMatt Barden * Note: When the oplock break code calls this, it holds the
767811599a4SMatt Barden * node ofile list lock and node oplock mutex. When we see
768811599a4SMatt Barden * an ofile in states RECONNECT or SAVING, we know the ofile
769811599a4SMatt Barden * is gaining or losing it's tree, and that happens quickly,
770811599a4SMatt Barden * so we just wait for that work to finish. However, the
771811599a4SMatt Barden * waiting for state transitions here means we have to be
772811599a4SMatt Barden * careful not to re-enter the node list lock or otherwise
773811599a4SMatt Barden * block on things that could cause a deadlock. Waiting
774811599a4SMatt Barden * just on of->f_mutex here is OK.
775811599a4SMatt Barden */
776811599a4SMatt Barden boolean_t
smb_ofile_hold_olbrk(smb_ofile_t * of)777811599a4SMatt Barden smb_ofile_hold_olbrk(smb_ofile_t *of)
778811599a4SMatt Barden {
779811599a4SMatt Barden boolean_t ret = B_FALSE;
780811599a4SMatt Barden
781811599a4SMatt Barden ASSERT(of);
782811599a4SMatt Barden ASSERT(of->f_magic == SMB_OFILE_MAGIC);
783811599a4SMatt Barden
784811599a4SMatt Barden mutex_enter(&of->f_mutex);
785811599a4SMatt Barden
786811599a4SMatt Barden again:
787811599a4SMatt Barden switch (of->f_state) {
788811599a4SMatt Barden case SMB_OFILE_STATE_RECONNECT:
789811599a4SMatt Barden case SMB_OFILE_STATE_SAVING:
790811599a4SMatt Barden cv_wait(&of->f_cv, &of->f_mutex);
791811599a4SMatt Barden goto again;
792811599a4SMatt Barden
793811599a4SMatt Barden case SMB_OFILE_STATE_OPEN:
794811599a4SMatt Barden case SMB_OFILE_STATE_SAVE_DH:
79572b35b05SGordon Ross case SMB_OFILE_STATE_ORPHANED:
79672b35b05SGordon Ross case SMB_OFILE_STATE_EXPIRED:
797811599a4SMatt Barden of->f_refcnt++;
798811599a4SMatt Barden ret = B_TRUE;
799811599a4SMatt Barden break;
800811599a4SMatt Barden
80172b35b05SGordon Ross /*
80272b35b05SGordon Ross * This is called only when an ofile has an oplock,
80372b35b05SGordon Ross * so if we come across states that should not have
80472b35b05SGordon Ross * an oplock, let's debug how that happened.
80572b35b05SGordon Ross */
806811599a4SMatt Barden default:
80772b35b05SGordon Ross ASSERT(0);
808811599a4SMatt Barden break;
809811599a4SMatt Barden }
810811599a4SMatt Barden mutex_exit(&of->f_mutex);
811811599a4SMatt Barden
812811599a4SMatt Barden return (ret);
813811599a4SMatt Barden }
814811599a4SMatt Barden
8151fcced4cSJordan Brown /*
8161fcced4cSJordan Brown * Take a reference on an open file.
8171fcced4cSJordan Brown */
8181fcced4cSJordan Brown boolean_t
smb_ofile_hold(smb_ofile_t * of)8191fcced4cSJordan Brown smb_ofile_hold(smb_ofile_t *of)
8201fcced4cSJordan Brown {
8211fcced4cSJordan Brown ASSERT(of);
8221fcced4cSJordan Brown ASSERT(of->f_magic == SMB_OFILE_MAGIC);
8231fcced4cSJordan Brown
8241fcced4cSJordan Brown mutex_enter(&of->f_mutex);
8251fcced4cSJordan Brown
82668b2bbf2SGordon Ross if (of->f_state != SMB_OFILE_STATE_OPEN) {
8271fcced4cSJordan Brown mutex_exit(&of->f_mutex);
82868b2bbf2SGordon Ross return (B_FALSE);
8291fcced4cSJordan Brown }
83068b2bbf2SGordon Ross of->f_refcnt++;
8311fcced4cSJordan Brown
8321fcced4cSJordan Brown mutex_exit(&of->f_mutex);
83368b2bbf2SGordon Ross return (B_TRUE);
8341fcced4cSJordan Brown }
8351fcced4cSJordan Brown
836525641e8SGordon Ross /*
837525641e8SGordon Ross * Void arg variant of smb_ofile_release for use with smb_llist_post.
838525641e8SGordon Ross * This is needed because smb_ofile_release may need to enter the
839525641e8SGordon Ross * smb_llist as writer when it drops the last reference, so when
840525641e8SGordon Ross * we're in the llist as reader, use smb_llist_post with this
841525641e8SGordon Ross * function to arrange for the release call at llist_exit.
842525641e8SGordon Ross */
843525641e8SGordon Ross void
smb_ofile_release_LL(void * arg)844525641e8SGordon Ross smb_ofile_release_LL(void *arg)
845525641e8SGordon Ross {
846525641e8SGordon Ross smb_ofile_t *of = arg;
847525641e8SGordon Ross
848525641e8SGordon Ross SMB_OFILE_VALID(of);
849525641e8SGordon Ross smb_ofile_release(of);
850525641e8SGordon Ross }
851525641e8SGordon Ross
852da6c28aaSamw /*
8539fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * Release a reference on a file. If the reference count falls to
8549fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * zero and the file has been closed, post the object for deletion.
8559fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * Object deletion is deferred to avoid modifying a list while an
8569fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * iteration may be in progress.
857811599a4SMatt Barden *
858811599a4SMatt Barden * We're careful to avoid dropping f_session etc. until the last
859811599a4SMatt Barden * reference goes away. The oplock break code depends on that
860811599a4SMatt Barden * not changing while it holds a ref. on an ofile.
861da6c28aaSamw */
862da6c28aaSamw void
smb_ofile_release(smb_ofile_t * of)863cb174861Sjoyce mcintosh smb_ofile_release(smb_ofile_t *of)
864da6c28aaSamw {
865811599a4SMatt Barden smb_tree_t *tree = of->f_tree;
866811599a4SMatt Barden boolean_t delete = B_FALSE;
867811599a4SMatt Barden
8689fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_OFILE_VALID(of);
869da6c28aaSamw
870da6c28aaSamw mutex_enter(&of->f_mutex);
871811599a4SMatt Barden ASSERT(of->f_refcnt > 0);
872da6c28aaSamw of->f_refcnt--;
873811599a4SMatt Barden
874da6c28aaSamw switch (of->f_state) {
875da6c28aaSamw case SMB_OFILE_STATE_OPEN:
876811599a4SMatt Barden case SMB_OFILE_STATE_ORPHANED:
877811599a4SMatt Barden case SMB_OFILE_STATE_EXPIRED:
878da6c28aaSamw break;
879da6c28aaSamw
880811599a4SMatt Barden case SMB_OFILE_STATE_SAVE_DH:
881811599a4SMatt Barden ASSERT(tree != NULL);
882811599a4SMatt Barden if (of->f_refcnt == 0) {
883811599a4SMatt Barden of->f_state = SMB_OFILE_STATE_SAVING;
8842cf6b79fSGordon Ross smb_lavl_post(&tree->t_ofile_list, of,
885811599a4SMatt Barden smb_ofile_save_dh);
886811599a4SMatt Barden }
887811599a4SMatt Barden break;
888811599a4SMatt Barden
889811599a4SMatt Barden case SMB_OFILE_STATE_CLOSING:
890811599a4SMatt Barden /* Note, tree == NULL on _ORPHANED */
891811599a4SMatt Barden if (of->f_refcnt == 0) {
892811599a4SMatt Barden of->f_state = SMB_OFILE_STATE_CLOSED;
893811599a4SMatt Barden if (tree == NULL) {
894811599a4SMatt Barden /* Skip smb_llist_post */
895811599a4SMatt Barden delete = B_TRUE;
896811599a4SMatt Barden break;
897811599a4SMatt Barden }
8982cf6b79fSGordon Ross smb_lavl_post(&tree->t_ofile_list, of,
899811599a4SMatt Barden smb_ofile_delete);
900811599a4SMatt Barden }
901da6c28aaSamw break;
902da6c28aaSamw
903da6c28aaSamw default:
904da6c28aaSamw ASSERT(0);
905da6c28aaSamw break;
906da6c28aaSamw }
907da6c28aaSamw mutex_exit(&of->f_mutex);
908811599a4SMatt Barden
909811599a4SMatt Barden /*
910811599a4SMatt Barden * When we drop the last ref. on an expired DH, it's no longer
911811599a4SMatt Barden * in any tree, so skip the smb_llist_post and just call
912811599a4SMatt Barden * smb_ofile_delete directly.
913811599a4SMatt Barden */
914811599a4SMatt Barden if (delete) {
915811599a4SMatt Barden smb_ofile_delete(of);
916811599a4SMatt Barden }
917da6c28aaSamw }
918da6c28aaSamw
919da6c28aaSamw /*
920da6c28aaSamw * smb_ofile_lookup_by_fid
921da6c28aaSamw *
922da6c28aaSamw * Find the open file whose fid matches the one specified in the request.
923da6c28aaSamw * If we can't find the fid or the shares (trees) don't match, we have a
924da6c28aaSamw * bad fid.
925da6c28aaSamw */
926da6c28aaSamw smb_ofile_t *
smb_ofile_lookup_by_fid(smb_request_t * sr,uint16_t fid)927da6c28aaSamw smb_ofile_lookup_by_fid(
9283b13a1efSThomas Keiser smb_request_t *sr,
929da6c28aaSamw uint16_t fid)
930da6c28aaSamw {
9313b13a1efSThomas Keiser smb_tree_t *tree = sr->tid_tree;
9322cf6b79fSGordon Ross smb_lavl_t *lavl;
933da6c28aaSamw smb_ofile_t *of;
9342cf6b79fSGordon Ross uint16_t cmp_fid;
935da6c28aaSamw
9362cf6b79fSGordon Ross CTASSERT(offsetof(smb_ofile_t, f_fid) == 0);
937da6c28aaSamw ASSERT(tree->t_magic == SMB_TREE_MAGIC);
938da6c28aaSamw
9392cf6b79fSGordon Ross cmp_fid = fid;
940da6c28aaSamw
9412cf6b79fSGordon Ross lavl = &tree->t_ofile_list;
9422cf6b79fSGordon Ross
9432cf6b79fSGordon Ross smb_lavl_enter(lavl, RW_READER);
9442cf6b79fSGordon Ross of = avl_find(&lavl->la_tree, &cmp_fid, NULL);
9453b13a1efSThomas Keiser if (of == NULL)
9463b13a1efSThomas Keiser goto out;
9473b13a1efSThomas Keiser
9483b13a1efSThomas Keiser /*
9493b13a1efSThomas Keiser * Only allow use of a given FID with the same UID that
9503b13a1efSThomas Keiser * was used to open it. MS-CIFS 3.3.5.14
9513b13a1efSThomas Keiser */
9523b13a1efSThomas Keiser if (of->f_user != sr->uid_user) {
9533b13a1efSThomas Keiser of = NULL;
9543b13a1efSThomas Keiser goto out;
9553b13a1efSThomas Keiser }
9563b13a1efSThomas Keiser
957811599a4SMatt Barden /* inline smb_ofile_hold() */
9583b13a1efSThomas Keiser mutex_enter(&of->f_mutex);
9593b13a1efSThomas Keiser if (of->f_state != SMB_OFILE_STATE_OPEN) {
9603b13a1efSThomas Keiser mutex_exit(&of->f_mutex);
9613b13a1efSThomas Keiser of = NULL;
9623b13a1efSThomas Keiser goto out;
9633b13a1efSThomas Keiser }
9643b13a1efSThomas Keiser of->f_refcnt++;
9653b13a1efSThomas Keiser mutex_exit(&of->f_mutex);
9663b13a1efSThomas Keiser
9673b13a1efSThomas Keiser out:
9682cf6b79fSGordon Ross smb_lavl_exit(lavl);
969da6c28aaSamw return (of);
970da6c28aaSamw }
971da6c28aaSamw
9721fcced4cSJordan Brown /*
9731fcced4cSJordan Brown * smb_ofile_lookup_by_uniqid
9741fcced4cSJordan Brown *
9751fcced4cSJordan Brown * Find the open file whose uniqid matches the one specified in the request.
9761fcced4cSJordan Brown */
9771fcced4cSJordan Brown smb_ofile_t *
smb_ofile_lookup_by_uniqid(smb_tree_t * tree,uint32_t uniqid)9781fcced4cSJordan Brown smb_ofile_lookup_by_uniqid(smb_tree_t *tree, uint32_t uniqid)
9791fcced4cSJordan Brown {
9802cf6b79fSGordon Ross smb_lavl_t *lavl;
9811fcced4cSJordan Brown smb_ofile_t *of;
9821fcced4cSJordan Brown
9831fcced4cSJordan Brown ASSERT(tree->t_magic == SMB_TREE_MAGIC);
9841fcced4cSJordan Brown
9852cf6b79fSGordon Ross lavl = &tree->t_ofile_list;
9862cf6b79fSGordon Ross smb_lavl_enter(lavl, RW_READER);
9872cf6b79fSGordon Ross of = smb_lavl_first(lavl);
9881fcced4cSJordan Brown
9891fcced4cSJordan Brown while (of) {
9901fcced4cSJordan Brown ASSERT(of->f_magic == SMB_OFILE_MAGIC);
9911fcced4cSJordan Brown ASSERT(of->f_tree == tree);
9921fcced4cSJordan Brown
9931fcced4cSJordan Brown if (of->f_uniqid == uniqid) {
9941fcced4cSJordan Brown if (smb_ofile_hold(of)) {
9952cf6b79fSGordon Ross smb_lavl_exit(lavl);
9961fcced4cSJordan Brown return (of);
9971fcced4cSJordan Brown }
9981fcced4cSJordan Brown }
9991fcced4cSJordan Brown
10002cf6b79fSGordon Ross of = smb_lavl_next(lavl, of);
10011fcced4cSJordan Brown }
10021fcced4cSJordan Brown
10032cf6b79fSGordon Ross smb_lavl_exit(lavl);
10041fcced4cSJordan Brown return (NULL);
10051fcced4cSJordan Brown }
10061fcced4cSJordan Brown
1007817fa55fSGordon Ross /*
1008817fa55fSGordon Ross * Durable ID (or persistent ID)
1009817fa55fSGordon Ross */
1010817fa55fSGordon Ross
1011811599a4SMatt Barden static smb_ofile_t *
smb_ofile_hold_cb(smb_ofile_t * of)1012811599a4SMatt Barden smb_ofile_hold_cb(smb_ofile_t *of)
1013811599a4SMatt Barden {
1014811599a4SMatt Barden smb_ofile_t *ret = of;
1015811599a4SMatt Barden
1016811599a4SMatt Barden mutex_enter(&of->f_mutex);
1017811599a4SMatt Barden if (of->f_state == SMB_OFILE_STATE_ORPHANED)
1018811599a4SMatt Barden /* inline smb_ofile_hold() */
1019811599a4SMatt Barden of->f_refcnt++;
1020811599a4SMatt Barden else
1021811599a4SMatt Barden ret = NULL;
1022811599a4SMatt Barden
1023811599a4SMatt Barden mutex_exit(&of->f_mutex);
1024811599a4SMatt Barden return (ret);
1025811599a4SMatt Barden }
1026811599a4SMatt Barden
1027811599a4SMatt Barden /*
1028811599a4SMatt Barden * Lookup an ofile by persistent ID, and return ONLY if in state ORPHANED
1029811599a4SMatt Barden * This is used by SMB2 create "reclaim".
1030811599a4SMatt Barden */
1031811599a4SMatt Barden smb_ofile_t *
smb_ofile_lookup_by_persistid(smb_request_t * sr,uint64_t persistid)1032811599a4SMatt Barden smb_ofile_lookup_by_persistid(smb_request_t *sr, uint64_t persistid)
1033811599a4SMatt Barden {
1034811599a4SMatt Barden smb_hash_t *hash;
1035811599a4SMatt Barden smb_bucket_t *bucket;
1036811599a4SMatt Barden smb_llist_t *ll;
1037811599a4SMatt Barden smb_ofile_t *of;
1038811599a4SMatt Barden uint_t idx;
1039811599a4SMatt Barden
10408d94f651SGordon Ross if (persistid == 0)
10418d94f651SGordon Ross return (NULL);
10428d94f651SGordon Ross
1043811599a4SMatt Barden hash = sr->sr_server->sv_persistid_ht;
1044811599a4SMatt Barden idx = smb_hash_uint64(hash, persistid);
1045811599a4SMatt Barden bucket = &hash->buckets[idx];
1046811599a4SMatt Barden ll = &bucket->b_list;
1047811599a4SMatt Barden
1048811599a4SMatt Barden smb_llist_enter(ll, RW_READER);
1049811599a4SMatt Barden of = smb_llist_head(ll);
1050811599a4SMatt Barden while (of != NULL) {
1051811599a4SMatt Barden if (of->f_persistid == persistid)
1052811599a4SMatt Barden break;
1053811599a4SMatt Barden of = smb_llist_next(ll, of);
1054811599a4SMatt Barden }
1055811599a4SMatt Barden if (of != NULL)
1056811599a4SMatt Barden of = smb_ofile_hold_cb(of);
1057811599a4SMatt Barden smb_llist_exit(ll);
1058811599a4SMatt Barden
1059811599a4SMatt Barden return (of);
1060811599a4SMatt Barden }
1061811599a4SMatt Barden
1062811599a4SMatt Barden /*
10638d94f651SGordon Ross * Create a (unique) durable/persistent ID for a new ofile,
10648d94f651SGordon Ross * and add this ofile to the persistid hash table. This ID
10658d94f651SGordon Ross * is referred to as the persistent ID in the protocol spec,
10668d94f651SGordon Ross * so that's what we call it too, though the persistence may
10678d94f651SGordon Ross * vary. "Durable" handles are persistent across reconnects
10688d94f651SGordon Ross * but not server reboots. Persistent handles are persistent
10698d94f651SGordon Ross * across server reboots too.
10708d94f651SGordon Ross *
10718d94f651SGordon Ross * Note that persistent IDs need to be unique for the lifetime of
10728d94f651SGordon Ross * any given ofile. For normal (non-persistent) ofiles we can just
10738d94f651SGordon Ross * use a persistent ID derived from the ofile memory address, as
10748d94f651SGordon Ross * these don't ever live beyond the current OS boot lifetime.
10758d94f651SGordon Ross *
10768d94f651SGordon Ross * Persistent handles are re-imported after server restart, and
10778d94f651SGordon Ross * generally have a different memory address after import than
10788d94f651SGordon Ross * they had in the previous OS boot lifetime, so for these we
10798d94f651SGordon Ross * use a randomly assigned value that won't conflict with any
10808d94f651SGordon Ross * non-persistent (durable) handles. Ensuring that a randomly
10818d94f651SGordon Ross * generated ID is unique requires a search of the ofiles in one
10828d94f651SGordon Ross * hash bucket, which we'd rather avoid for non-persistent opens.
10838d94f651SGordon Ross *
10848d94f651SGordon Ross * The solution used here is to divide the persistent ID space
10858d94f651SGordon Ross * in half (odd and even values) where durable opens use an ID
10868d94f651SGordon Ross * derived from the ofile address (which is always even), and
10878d94f651SGordon Ross * persistent opens use an ID generated randomly (always odd).
10888d94f651SGordon Ross *
10898d94f651SGordon Ross * smb_ofile_set_persistid_dh() sets a durable handle ID and
10908d94f651SGordon Ross * smb_ofile_set_persistid_ph() sets a persistent handle ID.
1091811599a4SMatt Barden */
1092811599a4SMatt Barden void
smb_ofile_set_persistid_dh(smb_ofile_t * of)10938d94f651SGordon Ross smb_ofile_set_persistid_dh(smb_ofile_t *of)
1094811599a4SMatt Barden {
1095811599a4SMatt Barden smb_hash_t *hash = of->f_server->sv_persistid_ht;
1096811599a4SMatt Barden smb_bucket_t *bucket;
1097811599a4SMatt Barden smb_llist_t *ll;
10988d94f651SGordon Ross uint64_t persistid;
1099811599a4SMatt Barden uint_t idx;
1100811599a4SMatt Barden
11018d94f651SGordon Ross persistid = (uintptr_t)of;
11028d94f651SGordon Ross /* Avoid showing object addresses */
11038d94f651SGordon Ross persistid ^= ((uintptr_t)&smb_cache_ofile);
11048d94f651SGordon Ross /* make sure it's even */
11058d94f651SGordon Ross persistid &= ~((uint64_t)1);
1106811599a4SMatt Barden
11078d94f651SGordon Ross idx = smb_hash_uint64(hash, persistid);
11088d94f651SGordon Ross bucket = &hash->buckets[idx];
11098d94f651SGordon Ross ll = &bucket->b_list;
11108d94f651SGordon Ross smb_llist_enter(ll, RW_WRITER);
11118d94f651SGordon Ross if (of->f_persistid == 0) {
11128d94f651SGordon Ross of->f_persistid = persistid;
11138d94f651SGordon Ross smb_llist_insert_tail(ll, of);
11148d94f651SGordon Ross }
11158d94f651SGordon Ross smb_llist_exit(ll);
11168d94f651SGordon Ross }
11178d94f651SGordon Ross
11188d94f651SGordon Ross void
smb_ofile_set_persistid_ph(smb_ofile_t * of)11198d94f651SGordon Ross smb_ofile_set_persistid_ph(smb_ofile_t *of)
11208d94f651SGordon Ross {
11218d94f651SGordon Ross uint64_t persistid;
11228d94f651SGordon Ross int rc;
11238d94f651SGordon Ross
11248d94f651SGordon Ross top:
11258d94f651SGordon Ross (void) random_get_pseudo_bytes((uint8_t *)&persistid,
11268d94f651SGordon Ross sizeof (persistid));
11278d94f651SGordon Ross if (persistid == 0) {
11288d94f651SGordon Ross cmn_err(CE_NOTE, "random gave all zeros!");
11298d94f651SGordon Ross goto top;
11308d94f651SGordon Ross }
11318d94f651SGordon Ross /* make sure it's odd */
11328d94f651SGordon Ross persistid |= (uint64_t)1;
11338d94f651SGordon Ross
11348d94f651SGordon Ross /*
11358d94f651SGordon Ross * Try inserting with this persistent ID.
11368d94f651SGordon Ross */
11378d94f651SGordon Ross rc = smb_ofile_insert_persistid(of, persistid);
11388d94f651SGordon Ross if (rc == EEXIST)
11398d94f651SGordon Ross goto top;
11408d94f651SGordon Ross if (rc != 0) {
11418d94f651SGordon Ross cmn_err(CE_NOTE, "set persistid rc=%d", rc);
11428d94f651SGordon Ross }
11438d94f651SGordon Ross }
11448d94f651SGordon Ross
11458d94f651SGordon Ross /*
11468d94f651SGordon Ross * Insert an ofile into the persistid hash table.
11478d94f651SGordon Ross * If the persistent ID is in use, error.
11488d94f651SGordon Ross */
11498d94f651SGordon Ross int
smb_ofile_insert_persistid(smb_ofile_t * new_of,uint64_t persistid)11508d94f651SGordon Ross smb_ofile_insert_persistid(smb_ofile_t *new_of, uint64_t persistid)
11518d94f651SGordon Ross {
11528d94f651SGordon Ross smb_hash_t *hash = new_of->f_server->sv_persistid_ht;
11538d94f651SGordon Ross smb_bucket_t *bucket;
11548d94f651SGordon Ross smb_llist_t *ll;
11558d94f651SGordon Ross smb_ofile_t *of;
11568d94f651SGordon Ross uint_t idx;
11578d94f651SGordon Ross
11588d94f651SGordon Ross ASSERT(persistid != 0);
11598d94f651SGordon Ross
11608d94f651SGordon Ross /*
11618d94f651SGordon Ross * Look to see if this key alreay exists.
11628d94f651SGordon Ross */
11638d94f651SGordon Ross idx = smb_hash_uint64(hash, persistid);
1164811599a4SMatt Barden bucket = &hash->buckets[idx];
1165811599a4SMatt Barden ll = &bucket->b_list;
11668d94f651SGordon Ross
1167811599a4SMatt Barden smb_llist_enter(ll, RW_WRITER);
11688d94f651SGordon Ross of = smb_llist_head(ll);
11698d94f651SGordon Ross while (of != NULL) {
11708d94f651SGordon Ross if (of->f_persistid == persistid) {
11718d94f651SGordon Ross /* already in use */
11728d94f651SGordon Ross smb_llist_exit(ll);
11738d94f651SGordon Ross return (EEXIST);
11748d94f651SGordon Ross }
11758d94f651SGordon Ross of = smb_llist_next(ll, of);
11768d94f651SGordon Ross }
11778d94f651SGordon Ross
11788d94f651SGordon Ross /* Not found, so OK to insert. */
11798d94f651SGordon Ross if (new_of->f_persistid == 0) {
11808d94f651SGordon Ross new_of->f_persistid = persistid;
11818d94f651SGordon Ross smb_llist_insert_tail(ll, new_of);
11828d94f651SGordon Ross }
1183811599a4SMatt Barden smb_llist_exit(ll);
11848d94f651SGordon Ross
11858d94f651SGordon Ross return (0);
1186811599a4SMatt Barden }
1187811599a4SMatt Barden
1188811599a4SMatt Barden void
smb_ofile_del_persistid(smb_ofile_t * of)1189811599a4SMatt Barden smb_ofile_del_persistid(smb_ofile_t *of)
1190811599a4SMatt Barden {
1191811599a4SMatt Barden smb_hash_t *hash = of->f_server->sv_persistid_ht;
1192811599a4SMatt Barden smb_bucket_t *bucket;
1193811599a4SMatt Barden smb_llist_t *ll;
1194811599a4SMatt Barden uint_t idx;
1195811599a4SMatt Barden
1196811599a4SMatt Barden idx = smb_hash_uint64(hash, of->f_persistid);
1197811599a4SMatt Barden bucket = &hash->buckets[idx];
1198811599a4SMatt Barden ll = &bucket->b_list;
1199811599a4SMatt Barden smb_llist_enter(ll, RW_WRITER);
12008d94f651SGordon Ross if (of->f_persistid != 0) {
12018d94f651SGordon Ross smb_llist_remove(ll, of);
12028d94f651SGordon Ross of->f_persistid = 0;
12038d94f651SGordon Ross }
1204811599a4SMatt Barden smb_llist_exit(ll);
1205811599a4SMatt Barden }
1206811599a4SMatt Barden
12071fcced4cSJordan Brown /*
12081fcced4cSJordan Brown * Disallow NetFileClose on certain ofiles to avoid side-effects.
12091fcced4cSJordan Brown * Closing a tree root is not allowed: use NetSessionDel or NetShareDel.
12101fcced4cSJordan Brown * Closing SRVSVC connections is not allowed because this NetFileClose
12111fcced4cSJordan Brown * request may depend on this ofile.
12121fcced4cSJordan Brown */
12131fcced4cSJordan Brown boolean_t
smb_ofile_disallow_fclose(smb_ofile_t * of)12141fcced4cSJordan Brown smb_ofile_disallow_fclose(smb_ofile_t *of)
12151fcced4cSJordan Brown {
12161fcced4cSJordan Brown ASSERT(of);
12171fcced4cSJordan Brown ASSERT(of->f_magic == SMB_OFILE_MAGIC);
12181fcced4cSJordan Brown ASSERT(of->f_refcnt);
12191fcced4cSJordan Brown
12201fcced4cSJordan Brown switch (of->f_ftype) {
12211fcced4cSJordan Brown case SMB_FTYPE_DISK:
12221fcced4cSJordan Brown ASSERT(of->f_tree);
12231fcced4cSJordan Brown return (of->f_node == of->f_tree->t_snode);
12241fcced4cSJordan Brown
12251fcced4cSJordan Brown case SMB_FTYPE_MESG_PIPE:
12261fcced4cSJordan Brown ASSERT(of->f_pipe);
1227bbf6f00cSJordan Brown if (smb_strcasecmp(of->f_pipe->p_name, "SRVSVC", 0) == 0)
12281fcced4cSJordan Brown return (B_TRUE);
12291fcced4cSJordan Brown break;
12301fcced4cSJordan Brown default:
12311fcced4cSJordan Brown break;
12321fcced4cSJordan Brown }
12331fcced4cSJordan Brown
12341fcced4cSJordan Brown return (B_FALSE);
12351fcced4cSJordan Brown }
12361fcced4cSJordan Brown
1237da6c28aaSamw /*
1238da6c28aaSamw * smb_ofile_set_flags
1239da6c28aaSamw *
1240da6c28aaSamw * Return value:
1241da6c28aaSamw *
1242da6c28aaSamw * Current flags value
1243da6c28aaSamw *
1244da6c28aaSamw */
1245da6c28aaSamw void
smb_ofile_set_flags(smb_ofile_t * of,uint32_t flags)1246da6c28aaSamw smb_ofile_set_flags(
1247da6c28aaSamw smb_ofile_t *of,
1248da6c28aaSamw uint32_t flags)
1249da6c28aaSamw {
1250da6c28aaSamw ASSERT(of);
1251da6c28aaSamw ASSERT(of->f_magic == SMB_OFILE_MAGIC);
1252da6c28aaSamw ASSERT(of->f_refcnt);
1253da6c28aaSamw
1254da6c28aaSamw mutex_enter(&of->f_mutex);
1255da6c28aaSamw of->f_flags |= flags;
1256da6c28aaSamw mutex_exit(&of->f_mutex);
1257da6c28aaSamw }
1258f96bd5c8SAlan Wright
1259da6c28aaSamw /*
1260da6c28aaSamw * smb_ofile_seek
1261da6c28aaSamw *
1262da6c28aaSamw * Return value:
1263da6c28aaSamw *
1264da6c28aaSamw * 0 Success
1265da6c28aaSamw * EINVAL Unknown mode
1266da6c28aaSamw * EOVERFLOW offset too big
1267da6c28aaSamw *
1268da6c28aaSamw */
1269da6c28aaSamw int
smb_ofile_seek(smb_ofile_t * of,ushort_t mode,int32_t off,uint32_t * retoff)1270da6c28aaSamw smb_ofile_seek(
1271da6c28aaSamw smb_ofile_t *of,
1272da6c28aaSamw ushort_t mode,
1273da6c28aaSamw int32_t off,
1274da6c28aaSamw uint32_t *retoff)
1275da6c28aaSamw {
127655bf511dSas u_offset_t newoff = 0;
1277da6c28aaSamw int rc = 0;
1278037cac00Sjoyce mcintosh smb_attr_t attr;
1279da6c28aaSamw
1280da6c28aaSamw ASSERT(of);
1281da6c28aaSamw ASSERT(of->f_magic == SMB_OFILE_MAGIC);
1282da6c28aaSamw ASSERT(of->f_refcnt);
1283da6c28aaSamw
1284da6c28aaSamw mutex_enter(&of->f_mutex);
1285da6c28aaSamw switch (mode) {
1286da6c28aaSamw case SMB_SEEK_SET:
1287da6c28aaSamw if (off < 0)
1288da6c28aaSamw newoff = 0;
1289da6c28aaSamw else
129055bf511dSas newoff = (u_offset_t)off;
1291da6c28aaSamw break;
1292da6c28aaSamw
1293da6c28aaSamw case SMB_SEEK_CUR:
1294da6c28aaSamw if (off < 0 && (-off) > of->f_seek_pos)
1295da6c28aaSamw newoff = 0;
1296da6c28aaSamw else
129755bf511dSas newoff = of->f_seek_pos + (u_offset_t)off;
1298da6c28aaSamw break;
1299da6c28aaSamw
1300da6c28aaSamw case SMB_SEEK_END:
1301037cac00Sjoyce mcintosh bzero(&attr, sizeof (smb_attr_t));
1302037cac00Sjoyce mcintosh attr.sa_mask |= SMB_AT_SIZE;
13038622ec45SGordon Ross rc = smb_fsop_getattr(NULL, zone_kcred(), of->f_node, &attr);
1304037cac00Sjoyce mcintosh if (rc != 0) {
1305037cac00Sjoyce mcintosh mutex_exit(&of->f_mutex);
1306037cac00Sjoyce mcintosh return (rc);
1307037cac00Sjoyce mcintosh }
1308037cac00Sjoyce mcintosh if (off < 0 && (-off) > attr.sa_vattr.va_size)
1309da6c28aaSamw newoff = 0;
1310da6c28aaSamw else
1311037cac00Sjoyce mcintosh newoff = attr.sa_vattr.va_size + (u_offset_t)off;
1312da6c28aaSamw break;
1313da6c28aaSamw
1314da6c28aaSamw default:
1315da6c28aaSamw mutex_exit(&of->f_mutex);
1316da6c28aaSamw return (EINVAL);
1317da6c28aaSamw }
1318da6c28aaSamw
131955bf511dSas /*
132055bf511dSas * See comments at the beginning of smb_seek.c.
132155bf511dSas * If the offset is greater than UINT_MAX, we will return an error.
132255bf511dSas */
132355bf511dSas
132455bf511dSas if (newoff > UINT_MAX) {
1325da6c28aaSamw rc = EOVERFLOW;
1326da6c28aaSamw } else {
1327da6c28aaSamw of->f_seek_pos = newoff;
1328da6c28aaSamw *retoff = (uint32_t)newoff;
1329da6c28aaSamw }
1330da6c28aaSamw mutex_exit(&of->f_mutex);
1331da6c28aaSamw return (rc);
1332da6c28aaSamw }
1333da6c28aaSamw
13346d1c73b5SDan Vatca /*
13356d1c73b5SDan Vatca * smb_ofile_flush
13366d1c73b5SDan Vatca *
13376d1c73b5SDan Vatca * If writes on this file are not synchronous, flush it using the NFSv3
13386d1c73b5SDan Vatca * commit interface.
13396d1c73b5SDan Vatca *
13406d1c73b5SDan Vatca * XXX - todo: Flush named pipe should drain writes.
13416d1c73b5SDan Vatca */
13426d1c73b5SDan Vatca void
smb_ofile_flush(struct smb_request * sr,struct smb_ofile * of)13436d1c73b5SDan Vatca smb_ofile_flush(struct smb_request *sr, struct smb_ofile *of)
13446d1c73b5SDan Vatca {
13456d1c73b5SDan Vatca switch (of->f_ftype) {
13466d1c73b5SDan Vatca case SMB_FTYPE_DISK:
13476d1c73b5SDan Vatca if ((of->f_node->flags & NODE_FLAGS_WRITE_THROUGH) == 0)
13486d1c73b5SDan Vatca (void) smb_fsop_commit(sr, of->f_cr, of->f_node);
13496d1c73b5SDan Vatca break;
13506d1c73b5SDan Vatca default:
13516d1c73b5SDan Vatca break;
13526d1c73b5SDan Vatca }
13536d1c73b5SDan Vatca }
13546d1c73b5SDan Vatca
1355da6c28aaSamw /*
1356da6c28aaSamw * smb_ofile_is_open
1357da6c28aaSamw */
1358da6c28aaSamw boolean_t
smb_ofile_is_open(smb_ofile_t * of)13592c2961f8Sjose borrego smb_ofile_is_open(smb_ofile_t *of)
1360da6c28aaSamw {
13611fcced4cSJordan Brown boolean_t rc;
1362da6c28aaSamw
13632c2961f8Sjose borrego SMB_OFILE_VALID(of);
1364da6c28aaSamw
1365da6c28aaSamw mutex_enter(&of->f_mutex);
13661fcced4cSJordan Brown rc = smb_ofile_is_open_locked(of);
1367da6c28aaSamw mutex_exit(&of->f_mutex);
1368da6c28aaSamw return (rc);
1369da6c28aaSamw }
1370da6c28aaSamw
1371da6c28aaSamw /* *************************** Static Functions ***************************** */
1372da6c28aaSamw
13731fcced4cSJordan Brown /*
13741fcced4cSJordan Brown * Determine whether or not an ofile is open.
13751fcced4cSJordan Brown * This function must be called with the mutex held.
13761fcced4cSJordan Brown */
13771fcced4cSJordan Brown static boolean_t
smb_ofile_is_open_locked(smb_ofile_t * of)13781fcced4cSJordan Brown smb_ofile_is_open_locked(smb_ofile_t *of)
13791fcced4cSJordan Brown {
1380811599a4SMatt Barden ASSERT(MUTEX_HELD(&of->f_mutex));
1381811599a4SMatt Barden
13821fcced4cSJordan Brown switch (of->f_state) {
13831fcced4cSJordan Brown case SMB_OFILE_STATE_OPEN:
1384811599a4SMatt Barden case SMB_OFILE_STATE_SAVE_DH:
1385811599a4SMatt Barden case SMB_OFILE_STATE_SAVING:
1386811599a4SMatt Barden case SMB_OFILE_STATE_ORPHANED:
1387811599a4SMatt Barden case SMB_OFILE_STATE_RECONNECT:
13881fcced4cSJordan Brown return (B_TRUE);
13891fcced4cSJordan Brown
13901fcced4cSJordan Brown case SMB_OFILE_STATE_CLOSING:
13911fcced4cSJordan Brown case SMB_OFILE_STATE_CLOSED:
1392811599a4SMatt Barden case SMB_OFILE_STATE_EXPIRED:
13931fcced4cSJordan Brown return (B_FALSE);
13941fcced4cSJordan Brown
13951fcced4cSJordan Brown default:
13961fcced4cSJordan Brown ASSERT(0);
13971fcced4cSJordan Brown return (B_FALSE);
13981fcced4cSJordan Brown }
13991fcced4cSJordan Brown }
14001fcced4cSJordan Brown
1401da6c28aaSamw /*
1402811599a4SMatt Barden * smb_ofile_save_dh
1403811599a4SMatt Barden *
1404811599a4SMatt Barden * Called via smb_llist_post (after smb_llist_exit) when the last ref.
1405811599a4SMatt Barden * on this ofile has gone, and this ofile is a "durable handle" (DH)
1406811599a4SMatt Barden * that has state we've decided to save.
1407811599a4SMatt Barden *
1408811599a4SMatt Barden * This does parts of what smb_ofile_delete would do, including:
1409811599a4SMatt Barden * remove the ofile from the tree ofile list and related.
1410811599a4SMatt Barden *
1411811599a4SMatt Barden * We leave the ofile in state ORPHANED, ready for reconnect
1412811599a4SMatt Barden * or expiration via smb2_dh_expire (see smb_ofile_delete).
1413da6c28aaSamw */
1414811599a4SMatt Barden static void
smb_ofile_save_dh(void * arg)1415811599a4SMatt Barden smb_ofile_save_dh(void *arg)
1416da6c28aaSamw {
1417811599a4SMatt Barden smb_ofile_t *of = (smb_ofile_t *)arg;
1418811599a4SMatt Barden smb_tree_t *tree = of->f_tree;
1419da6c28aaSamw
1420811599a4SMatt Barden SMB_OFILE_VALID(of);
1421811599a4SMatt Barden ASSERT(of->f_refcnt == 0);
1422811599a4SMatt Barden ASSERT(of->f_ftype == SMB_FTYPE_DISK);
1423811599a4SMatt Barden ASSERT(of->f_state == SMB_OFILE_STATE_SAVING);
1424811599a4SMatt Barden
1425811599a4SMatt Barden atomic_dec_32(&of->f_session->s_file_cnt);
1426811599a4SMatt Barden atomic_dec_32(&of->f_tree->t_open_files);
14272cf6b79fSGordon Ross smb_lavl_enter(&tree->t_ofile_list, RW_WRITER);
14282cf6b79fSGordon Ross smb_lavl_remove(&tree->t_ofile_list, of);
14292cf6b79fSGordon Ross smb_lavl_exit(&tree->t_ofile_list);
1430da6c28aaSamw
1431811599a4SMatt Barden /*
1432811599a4SMatt Barden * This ofile is no longer on t_ofile_list, however...
1433811599a4SMatt Barden *
1434811599a4SMatt Barden * This is called via smb_llist_post, which means it may run
1435811599a4SMatt Barden * BEFORE smb_ofile_release drops f_mutex (if another thread
1436811599a4SMatt Barden * flushes the delete queue before we do). Synchronize.
1437811599a4SMatt Barden */
1438da6c28aaSamw mutex_enter(&of->f_mutex);
1439a5a9a6bbSGordon Ross DTRACE_PROBE1(ofile__exit, smb_ofile_t *, of);
1440811599a4SMatt Barden mutex_exit(&of->f_mutex);
1441811599a4SMatt Barden
1442811599a4SMatt Barden /*
1443811599a4SMatt Barden * Keep f_notify state, lease, and
1444811599a4SMatt Barden * keep on node ofile list.
1445811599a4SMatt Barden * Keep of->f_cr until reclaim.
1446811599a4SMatt Barden */
1447811599a4SMatt Barden
1448811599a4SMatt Barden ASSERT(of->f_fid != 0);
1449811599a4SMatt Barden smb_idpool_free(&tree->t_fid_pool, of->f_fid);
1450811599a4SMatt Barden of->f_fid = 0;
1451811599a4SMatt Barden smb_tree_release(of->f_tree);
1452811599a4SMatt Barden of->f_tree = NULL;
1453811599a4SMatt Barden smb_user_release(of->f_user);
1454811599a4SMatt Barden of->f_user = NULL;
1455811599a4SMatt Barden of->f_session = NULL;
1456811599a4SMatt Barden
1457811599a4SMatt Barden /*
1458811599a4SMatt Barden * Make it "orphaned" so it can now be reclaimed.
1459811599a4SMatt Barden * Note that smb_ofile_hold_olbrk() may have blocked
1460811599a4SMatt Barden * for state SMB_OFILE_STATE_SAVING, so wake it.
1461811599a4SMatt Barden */
1462811599a4SMatt Barden mutex_enter(&of->f_mutex);
1463811599a4SMatt Barden of->dh_expire_time = gethrtime() + of->dh_timeout_offset;
1464811599a4SMatt Barden of->f_state = SMB_OFILE_STATE_ORPHANED;
1465811599a4SMatt Barden cv_broadcast(&of->f_cv);
1466811599a4SMatt Barden mutex_exit(&of->f_mutex);
1467da6c28aaSamw }
1468da6c28aaSamw
1469da6c28aaSamw /*
14709fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * Delete an ofile.
1471da6c28aaSamw *
147294047d49SGordon Ross * Approximately the inverse of smb_ofile_alloc()
1473811599a4SMatt Barden * Called via smb_llist_post (after smb_llist_exit)
1474811599a4SMatt Barden * when the last ref. on this ofile has gone.
1475811599a4SMatt Barden *
1476811599a4SMatt Barden * Normally,this removes the ofile from the tree list and
1477811599a4SMatt Barden * then frees resources held on the ofile. However, when
1478811599a4SMatt Barden * we're expiring an orphaned durable handle, the linkage
1479811599a4SMatt Barden * into the tree lists etc. have already been destroyed.
1480811599a4SMatt Barden * This case is distinguished by of->f_tree == NULL.
1481da6c28aaSamw */
1482811599a4SMatt Barden static void
smb_ofile_delete(void * arg)14839fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_ofile_delete(void *arg)
1484da6c28aaSamw {
14859fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_ofile_t *of = (smb_ofile_t *)arg;
1486811599a4SMatt Barden smb_tree_t *tree = of->f_tree;
14879fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
14889fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States SMB_OFILE_VALID(of);
1489da6c28aaSamw ASSERT(of->f_refcnt == 0);
1490da6c28aaSamw ASSERT(of->f_state == SMB_OFILE_STATE_CLOSED);
1491da6c28aaSamw
1492811599a4SMatt Barden if (tree != NULL) {
1493811599a4SMatt Barden ASSERT(of->f_user != NULL);
1494811599a4SMatt Barden ASSERT(of->f_session != NULL);
1495811599a4SMatt Barden atomic_dec_32(&of->f_session->s_file_cnt);
1496811599a4SMatt Barden atomic_dec_32(&of->f_tree->t_open_files);
14972cf6b79fSGordon Ross smb_lavl_enter(&tree->t_ofile_list, RW_WRITER);
14982cf6b79fSGordon Ross smb_lavl_remove(&tree->t_ofile_list, of);
14992cf6b79fSGordon Ross smb_lavl_exit(&tree->t_ofile_list);
1500811599a4SMatt Barden }
15019fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
1502bfe5e737SGordon Ross /*
1503bfe5e737SGordon Ross * Remove this ofile from the node's n_ofile_list so it
1504bfe5e737SGordon Ross * can't be found by list walkers like notify or oplock.
1505bfe5e737SGordon Ross * Keep the node ref. until later in this function so
1506bfe5e737SGordon Ross * of->f_node remains valid while we destroy the ofile.
1507bfe5e737SGordon Ross */
1508bfe5e737SGordon Ross if (of->f_ftype == SMB_FTYPE_DISK ||
1509bfe5e737SGordon Ross of->f_ftype == SMB_FTYPE_PRINTER) {
15101f0845f1SGordon Ross smb_node_t *node = of->f_node;
15111f0845f1SGordon Ross
15121f0845f1SGordon Ross /*
15131f0845f1SGordon Ross * Oplock cleanup should have made sure that
15141f0845f1SGordon Ross * excl_open does not point to this ofile.
15151f0845f1SGordon Ross */
15161f0845f1SGordon Ross VERIFY(node->n_oplock.excl_open != of);
15171f0845f1SGordon Ross
1518bfe5e737SGordon Ross /*
1519bfe5e737SGordon Ross * Note smb_ofile_close did smb_node_dec_open_ofiles()
1520bfe5e737SGordon Ross */
15211f0845f1SGordon Ross smb_node_rem_ofile(node, of);
1522bfe5e737SGordon Ross }
1523bfe5e737SGordon Ross
1524811599a4SMatt Barden /*
1525811599a4SMatt Barden * This ofile is no longer on any lists, however...
1526811599a4SMatt Barden *
1527811599a4SMatt Barden * This is called via smb_llist_post, which means it may run
1528811599a4SMatt Barden * BEFORE smb_ofile_release drops f_mutex (if another thread
1529811599a4SMatt Barden * flushes the delete queue before we do). Synchronize.
1530811599a4SMatt Barden */
15319fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_enter(&of->f_mutex);
153294047d49SGordon Ross of->f_state = SMB_OFILE_STATE_ALLOC;
1533a5a9a6bbSGordon Ross DTRACE_PROBE1(ofile__exit, smb_ofile_t *, of);
15349fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_exit(&of->f_mutex);
1535da6c28aaSamw
1536a90cf9f2SGordon Ross switch (of->f_ftype) {
1537a90cf9f2SGordon Ross case SMB_FTYPE_BYTE_PIPE:
1538a90cf9f2SGordon Ross case SMB_FTYPE_MESG_PIPE:
15399fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_opipe_dealloc(of->f_pipe);
15403db3f65cSamw of->f_pipe = NULL;
1541a90cf9f2SGordon Ross break;
1542a90cf9f2SGordon Ross case SMB_FTYPE_DISK:
1543bfe5e737SGordon Ross ASSERT(of->f_notify.nc_subscribed == B_FALSE);
1544bfe5e737SGordon Ross MBC_FLUSH(&of->f_notify.nc_buffer);
1545a90cf9f2SGordon Ross if (of->f_odir != NULL)
1546a90cf9f2SGordon Ross smb_odir_release(of->f_odir);
154794047d49SGordon Ross if (of->f_lease != NULL) {
154894047d49SGordon Ross smb2_lease_rele(of->f_lease);
154994047d49SGordon Ross of->f_lease = NULL;
155094047d49SGordon Ross }
1551bfe5e737SGordon Ross /* FALLTHROUGH */
1552bfe5e737SGordon Ross case SMB_FTYPE_PRINTER:
1553bfe5e737SGordon Ross /*
1554bfe5e737SGordon Ross * Did smb_node_rem_ofile above.
1555bfe5e737SGordon Ross */
1556bfe5e737SGordon Ross ASSERT(of->f_node != NULL);
1557da6c28aaSamw smb_node_release(of->f_node);
1558a90cf9f2SGordon Ross break;
1559a90cf9f2SGordon Ross default:
1560a90cf9f2SGordon Ross ASSERT(!"f_ftype");
1561a90cf9f2SGordon Ross break;
1562da6c28aaSamw }
1563da6c28aaSamw
156494047d49SGordon Ross smb_ofile_free(of);
156594047d49SGordon Ross }
156694047d49SGordon Ross
156794047d49SGordon Ross void
smb_ofile_free(smb_ofile_t * of)156894047d49SGordon Ross smb_ofile_free(smb_ofile_t *of)
156994047d49SGordon Ross {
157094047d49SGordon Ross smb_tree_t *tree = of->f_tree;
157194047d49SGordon Ross
157294047d49SGordon Ross ASSERT(of->f_state == SMB_OFILE_STATE_ALLOC);
157394047d49SGordon Ross
1574817fa55fSGordon Ross /* Make sure it's not in the persistid hash. */
1575817fa55fSGordon Ross ASSERT(of->f_persistid == 0);
1576817fa55fSGordon Ross
1577811599a4SMatt Barden if (tree != NULL) {
1578811599a4SMatt Barden if (of->f_fid != 0)
1579811599a4SMatt Barden smb_idpool_free(&tree->t_fid_pool, of->f_fid);
1580811599a4SMatt Barden smb_tree_release(of->f_tree);
1581811599a4SMatt Barden smb_user_release(of->f_user);
1582811599a4SMatt Barden }
1583811599a4SMatt Barden
1584811599a4SMatt Barden if (of->f_cr != NULL)
1585811599a4SMatt Barden crfree(of->f_cr);
1586811599a4SMatt Barden
1587da6c28aaSamw of->f_magic = (uint32_t)~SMB_OFILE_MAGIC;
1588bfe5e737SGordon Ross list_destroy(&of->f_notify.nc_waiters);
15898d94f651SGordon Ross mutex_destroy(&of->dh_nvlock);
1590da6c28aaSamw mutex_destroy(&of->f_mutex);
15918622ec45SGordon Ross kmem_cache_free(smb_cache_ofile, of);
1592da6c28aaSamw }
1593da6c28aaSamw
1594da6c28aaSamw /*
1595da6c28aaSamw * smb_ofile_access
1596da6c28aaSamw *
1597da6c28aaSamw * This function will check to see if the access requested is granted.
1598da6c28aaSamw * Returns NT status codes.
1599da6c28aaSamw */
1600da6c28aaSamw uint32_t
smb_ofile_access(smb_ofile_t * of,cred_t * cr,uint32_t access)1601da6c28aaSamw smb_ofile_access(smb_ofile_t *of, cred_t *cr, uint32_t access)
1602da6c28aaSamw {
1603da6c28aaSamw
16048622ec45SGordon Ross if ((of == NULL) || (cr == zone_kcred()))
1605da6c28aaSamw return (NT_STATUS_SUCCESS);
1606da6c28aaSamw
1607da6c28aaSamw /*
1608da6c28aaSamw * If the request is for something
1609da6c28aaSamw * I don't grant it is an error
1610da6c28aaSamw */
1611da6c28aaSamw if (~(of->f_granted_access) & access) {
1612da6c28aaSamw if (!(of->f_granted_access & ACCESS_SYSTEM_SECURITY) &&
1613da6c28aaSamw (access & ACCESS_SYSTEM_SECURITY)) {
1614da6c28aaSamw return (NT_STATUS_PRIVILEGE_NOT_HELD);
1615da6c28aaSamw }
1616da6c28aaSamw return (NT_STATUS_ACCESS_DENIED);
1617da6c28aaSamw }
1618da6c28aaSamw
1619da6c28aaSamw return (NT_STATUS_SUCCESS);
1620da6c28aaSamw }
16213ad684d6Sjb
1622cb174861Sjoyce mcintosh /*
1623cb174861Sjoyce mcintosh * smb_ofile_share_check
1624cb174861Sjoyce mcintosh *
1625cb174861Sjoyce mcintosh * Check if ofile was opened with share access NONE (0).
1626cb174861Sjoyce mcintosh * Returns: B_TRUE - share access non-zero
1627cb174861Sjoyce mcintosh * B_FALSE - share access NONE
1628cb174861Sjoyce mcintosh */
1629cb174861Sjoyce mcintosh boolean_t
smb_ofile_share_check(smb_ofile_t * of)1630cb174861Sjoyce mcintosh smb_ofile_share_check(smb_ofile_t *of)
1631cb174861Sjoyce mcintosh {
1632cb174861Sjoyce mcintosh return (!SMB_DENY_ALL(of->f_share_access));
1633cb174861Sjoyce mcintosh }
16343ad684d6Sjb
16353ad684d6Sjb /*
16363ad684d6Sjb * check file sharing rules for current open request
16373ad684d6Sjb * against existing open instances of the same file
16383ad684d6Sjb *
16393ad684d6Sjb * Returns NT_STATUS_SHARING_VIOLATION if there is any
16403ad684d6Sjb * sharing conflict, otherwise returns NT_STATUS_SUCCESS.
16413ad684d6Sjb */
16423ad684d6Sjb uint32_t
smb_ofile_open_check(smb_ofile_t * of,uint32_t desired_access,uint32_t share_access)16439fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_ofile_open_check(smb_ofile_t *of, uint32_t desired_access,
16443ad684d6Sjb uint32_t share_access)
16453ad684d6Sjb {
1646811599a4SMatt Barden uint32_t ret;
1647811599a4SMatt Barden
16483ad684d6Sjb ASSERT(of->f_magic == SMB_OFILE_MAGIC);
16493ad684d6Sjb
16503ad684d6Sjb mutex_enter(&of->f_mutex);
16513ad684d6Sjb
1652811599a4SMatt Barden if (!smb_ofile_is_open_locked(of)) {
1653811599a4SMatt Barden ret = NT_STATUS_INVALID_HANDLE;
1654811599a4SMatt Barden goto out;
16553ad684d6Sjb }
16563ad684d6Sjb
16573ad684d6Sjb /* if it's just meta data */
16583ad684d6Sjb if ((of->f_granted_access & FILE_DATA_ALL) == 0) {
1659811599a4SMatt Barden ret = NT_STATUS_SUCCESS;
1660811599a4SMatt Barden goto out;
16613ad684d6Sjb }
16623ad684d6Sjb
16633ad684d6Sjb /*
16643ad684d6Sjb * Check requested share access against the
16653ad684d6Sjb * open granted (desired) access
16663ad684d6Sjb */
16673ad684d6Sjb if (SMB_DENY_DELETE(share_access) && (of->f_granted_access & DELETE)) {
1668811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1669811599a4SMatt Barden goto out;
16703ad684d6Sjb }
16713ad684d6Sjb
16723ad684d6Sjb if (SMB_DENY_READ(share_access) &&
16733ad684d6Sjb (of->f_granted_access & (FILE_READ_DATA | FILE_EXECUTE))) {
1674811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1675811599a4SMatt Barden goto out;
16763ad684d6Sjb }
16773ad684d6Sjb
16783ad684d6Sjb if (SMB_DENY_WRITE(share_access) &&
16793ad684d6Sjb (of->f_granted_access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
1680811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1681811599a4SMatt Barden goto out;
16823ad684d6Sjb }
16833ad684d6Sjb
16843ad684d6Sjb /* check requested desired access against the open share access */
16853ad684d6Sjb if (SMB_DENY_DELETE(of->f_share_access) && (desired_access & DELETE)) {
1686811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1687811599a4SMatt Barden goto out;
16883ad684d6Sjb }
16893ad684d6Sjb
16903ad684d6Sjb if (SMB_DENY_READ(of->f_share_access) &&
16913ad684d6Sjb (desired_access & (FILE_READ_DATA | FILE_EXECUTE))) {
1692811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1693811599a4SMatt Barden goto out;
16943ad684d6Sjb }
16953ad684d6Sjb
16963ad684d6Sjb if (SMB_DENY_WRITE(of->f_share_access) &&
16973ad684d6Sjb (desired_access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
1698811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1699811599a4SMatt Barden goto out;
17003ad684d6Sjb }
17013ad684d6Sjb
1702811599a4SMatt Barden ret = NT_STATUS_SUCCESS;
1703811599a4SMatt Barden out:
17043ad684d6Sjb mutex_exit(&of->f_mutex);
1705811599a4SMatt Barden return (ret);
17063ad684d6Sjb }
17073ad684d6Sjb
17083ad684d6Sjb /*
17093ad684d6Sjb * smb_ofile_rename_check
17103ad684d6Sjb *
1711575d359dSGordon Ross * This does the work described in MS-FSA 2.1.5.1.2.2 (Algorithm
1712575d359dSGordon Ross * to Check Sharing Access to an Existing Stream or Directory),
1713575d359dSGordon Ross * where the "open in-progress" has DesiredAccess = DELETE and
1714575d359dSGordon Ross * SharingMode = SHARE_READ | SHARE_WRITE | SHARE_DELETE.
17153ad684d6Sjb */
17163ad684d6Sjb
17173ad684d6Sjb uint32_t
smb_ofile_rename_check(smb_ofile_t * of)17183ad684d6Sjb smb_ofile_rename_check(smb_ofile_t *of)
17193ad684d6Sjb {
1720811599a4SMatt Barden uint32_t ret;
1721811599a4SMatt Barden
17223ad684d6Sjb ASSERT(of->f_magic == SMB_OFILE_MAGIC);
17233ad684d6Sjb
17243ad684d6Sjb mutex_enter(&of->f_mutex);
17253ad684d6Sjb
1726811599a4SMatt Barden if (!smb_ofile_is_open_locked(of)) {
1727811599a4SMatt Barden ret = NT_STATUS_INVALID_HANDLE;
1728811599a4SMatt Barden goto out;
17293ad684d6Sjb }
17303ad684d6Sjb
1731575d359dSGordon Ross if ((of->f_granted_access & FILE_DATA_ALL) == 0) {
1732811599a4SMatt Barden ret = NT_STATUS_SUCCESS;
1733811599a4SMatt Barden goto out;
17343ad684d6Sjb }
17353ad684d6Sjb
17363ad684d6Sjb if ((of->f_share_access & FILE_SHARE_DELETE) == 0) {
1737811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1738811599a4SMatt Barden goto out;
17393ad684d6Sjb }
17403ad684d6Sjb
1741811599a4SMatt Barden ret = NT_STATUS_SUCCESS;
1742811599a4SMatt Barden out:
17433ad684d6Sjb mutex_exit(&of->f_mutex);
1744811599a4SMatt Barden return (ret);
17453ad684d6Sjb }
17463ad684d6Sjb
17473ad684d6Sjb /*
17483ad684d6Sjb * smb_ofile_delete_check
17493ad684d6Sjb *
17503ad684d6Sjb * An open file can be deleted only if opened for
17513ad684d6Sjb * accessing meta data. Share modes aren't important
17523ad684d6Sjb * in this case.
17533ad684d6Sjb *
17543ad684d6Sjb * NOTE: there is another mechanism for deleting an
17553ad684d6Sjb * open file that NT clients usually use.
17563ad684d6Sjb * That's setting "Delete on close" flag for an open
17573ad684d6Sjb * file. In this way the file will be deleted after
17583ad684d6Sjb * last close. This flag can be set by SmbTrans2SetFileInfo
17593ad684d6Sjb * with FILE_DISPOSITION_INFO information level.
17603ad684d6Sjb * For setting this flag, the file should be opened by
17613ad684d6Sjb * DELETE access in the FID that is passed in the Trans2
17623ad684d6Sjb * request.
17633ad684d6Sjb */
17643ad684d6Sjb
17653ad684d6Sjb uint32_t
smb_ofile_delete_check(smb_ofile_t * of)17663ad684d6Sjb smb_ofile_delete_check(smb_ofile_t *of)
17673ad684d6Sjb {
1768811599a4SMatt Barden uint32_t ret;
1769811599a4SMatt Barden
17703ad684d6Sjb ASSERT(of->f_magic == SMB_OFILE_MAGIC);
17713ad684d6Sjb
17723ad684d6Sjb mutex_enter(&of->f_mutex);
17733ad684d6Sjb
1774811599a4SMatt Barden if (!smb_ofile_is_open_locked(of)) {
1775811599a4SMatt Barden ret = NT_STATUS_INVALID_HANDLE;
1776811599a4SMatt Barden goto out;
17773ad684d6Sjb }
17783ad684d6Sjb
17793ad684d6Sjb if (of->f_granted_access &
17803ad684d6Sjb (FILE_READ_DATA | FILE_WRITE_DATA |
17813ad684d6Sjb FILE_APPEND_DATA | FILE_EXECUTE | DELETE)) {
1782811599a4SMatt Barden ret = NT_STATUS_SHARING_VIOLATION;
1783811599a4SMatt Barden goto out;
17843ad684d6Sjb }
17853ad684d6Sjb
1786811599a4SMatt Barden ret = NT_STATUS_SUCCESS;
1787811599a4SMatt Barden out:
17883ad684d6Sjb mutex_exit(&of->f_mutex);
1789811599a4SMatt Barden return (ret);
17903ad684d6Sjb }
1791b89a8333Snatalie li - Sun Microsystems - Irvine United States
1792b89a8333Snatalie li - Sun Microsystems - Irvine United States cred_t *
smb_ofile_getcred(smb_ofile_t * of)1793b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_ofile_getcred(smb_ofile_t *of)
1794b89a8333Snatalie li - Sun Microsystems - Irvine United States {
1795b89a8333Snatalie li - Sun Microsystems - Irvine United States return (of->f_cr);
1796b89a8333Snatalie li - Sun Microsystems - Irvine United States }
17978b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States
17988b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States /*
17998b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * smb_ofile_set_delete_on_close
18008b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States *
18018b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * Set the DeleteOnClose flag on the smb file. When the file is closed,
18028b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * the flag will be transferred to the smb node, which will commit the
18038b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * delete operation and inhibit subsequent open requests.
18048b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States *
18058b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * When DeleteOnClose is set on an smb_node, the common open code will
18068b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * reject subsequent open requests for the file. Observation of Windows
18078b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * 2000 indicates that subsequent opens should be allowed (assuming
18088b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * there would be no sharing violation) until the file is closed using
18098b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States * the fid on which the DeleteOnClose was requested.
18108b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States */
18118b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States void
smb_ofile_set_delete_on_close(smb_request_t * sr,smb_ofile_t * of)181294047d49SGordon Ross smb_ofile_set_delete_on_close(smb_request_t *sr, smb_ofile_t *of)
18138b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States {
181494047d49SGordon Ross uint32_t status;
181594047d49SGordon Ross
181694047d49SGordon Ross /*
181794047d49SGordon Ross * Break any oplock handle caching.
181894047d49SGordon Ross */
181994047d49SGordon Ross status = smb_oplock_break_SETINFO(of->f_node, of,
182094047d49SGordon Ross FileDispositionInformation);
182194047d49SGordon Ross if (status == NT_STATUS_OPLOCK_BREAK_IN_PROGRESS) {
182294047d49SGordon Ross if (sr->session->dialect >= SMB_VERS_2_BASE)
182394047d49SGordon Ross (void) smb2sr_go_async(sr);
1824525641e8SGordon Ross (void) smb_oplock_wait_break(sr, of->f_node, 0);
182594047d49SGordon Ross }
182694047d49SGordon Ross
18278b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States mutex_enter(&of->f_mutex);
18288b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States of->f_flags |= SMB_OFLAGS_SET_DELETE_ON_CLOSE;
18298b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States mutex_exit(&of->f_mutex);
18308b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States }
18311fcced4cSJordan Brown
18321fcced4cSJordan Brown /*
18331fcced4cSJordan Brown * Encode open file information into a buffer; needed in user space to
18341fcced4cSJordan Brown * support RPC requests.
18351fcced4cSJordan Brown */
18361fcced4cSJordan Brown static int
smb_ofile_netinfo_encode(smb_ofile_t * of,uint8_t * buf,size_t buflen,uint32_t * nbytes)18371fcced4cSJordan Brown smb_ofile_netinfo_encode(smb_ofile_t *of, uint8_t *buf, size_t buflen,
18381fcced4cSJordan Brown uint32_t *nbytes)
18391fcced4cSJordan Brown {
18401fcced4cSJordan Brown smb_netfileinfo_t fi;
18411fcced4cSJordan Brown int rc;
18421fcced4cSJordan Brown
18431fcced4cSJordan Brown rc = smb_ofile_netinfo_init(of, &fi);
18441fcced4cSJordan Brown if (rc == 0) {
18451fcced4cSJordan Brown rc = smb_netfileinfo_encode(&fi, buf, buflen, nbytes);
18461fcced4cSJordan Brown smb_ofile_netinfo_fini(&fi);
18471fcced4cSJordan Brown }
18481fcced4cSJordan Brown
18491fcced4cSJordan Brown return (rc);
18501fcced4cSJordan Brown }
18511fcced4cSJordan Brown
18521fcced4cSJordan Brown static int
smb_ofile_netinfo_init(smb_ofile_t * of,smb_netfileinfo_t * fi)18531fcced4cSJordan Brown smb_ofile_netinfo_init(smb_ofile_t *of, smb_netfileinfo_t *fi)
18541fcced4cSJordan Brown {
18551fcced4cSJordan Brown smb_user_t *user;
18561fcced4cSJordan Brown smb_tree_t *tree;
18571fcced4cSJordan Brown smb_node_t *node;
18581fcced4cSJordan Brown char *path;
18591fcced4cSJordan Brown char *buf;
18601fcced4cSJordan Brown int rc;
18611fcced4cSJordan Brown
18621fcced4cSJordan Brown ASSERT(of);
18631fcced4cSJordan Brown user = of->f_user;
18641fcced4cSJordan Brown tree = of->f_tree;
18651fcced4cSJordan Brown ASSERT(user);
18661fcced4cSJordan Brown ASSERT(tree);
18671fcced4cSJordan Brown
18681fcced4cSJordan Brown buf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
18691fcced4cSJordan Brown
18701fcced4cSJordan Brown switch (of->f_ftype) {
18711fcced4cSJordan Brown case SMB_FTYPE_DISK:
18721fcced4cSJordan Brown node = of->f_node;
18731fcced4cSJordan Brown ASSERT(node);
18741fcced4cSJordan Brown
18751fcced4cSJordan Brown fi->fi_permissions = of->f_granted_access;
1876148c5f43SAlan Wright fi->fi_numlocks = smb_lock_get_lock_count(node, of);
18771fcced4cSJordan Brown
18781fcced4cSJordan Brown path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
18791fcced4cSJordan Brown
18801fcced4cSJordan Brown if (node != tree->t_snode) {
1881148c5f43SAlan Wright rc = smb_node_getshrpath(node, tree, path, MAXPATHLEN);
1882148c5f43SAlan Wright if (rc != 0)
18831fcced4cSJordan Brown (void) strlcpy(path, node->od_name, MAXPATHLEN);
18841fcced4cSJordan Brown }
18851fcced4cSJordan Brown
18861fcced4cSJordan Brown (void) snprintf(buf, MAXPATHLEN, "%s:%s", tree->t_sharename,
18871fcced4cSJordan Brown path);
18881fcced4cSJordan Brown kmem_free(path, MAXPATHLEN);
18891fcced4cSJordan Brown break;
18901fcced4cSJordan Brown
18911fcced4cSJordan Brown case SMB_FTYPE_MESG_PIPE:
18921fcced4cSJordan Brown ASSERT(of->f_pipe);
18931fcced4cSJordan Brown
18941fcced4cSJordan Brown fi->fi_permissions = FILE_READ_DATA | FILE_WRITE_DATA |
18951fcced4cSJordan Brown FILE_EXECUTE;
18961fcced4cSJordan Brown fi->fi_numlocks = 0;
18971fcced4cSJordan Brown (void) snprintf(buf, MAXPATHLEN, "\\PIPE\\%s",
18981fcced4cSJordan Brown of->f_pipe->p_name);
18991fcced4cSJordan Brown break;
19001fcced4cSJordan Brown
19011fcced4cSJordan Brown default:
19021fcced4cSJordan Brown kmem_free(buf, MAXPATHLEN);
19031fcced4cSJordan Brown return (-1);
19041fcced4cSJordan Brown }
19051fcced4cSJordan Brown
19061fcced4cSJordan Brown fi->fi_fid = of->f_fid;
19071fcced4cSJordan Brown fi->fi_uniqid = of->f_uniqid;
19081fcced4cSJordan Brown fi->fi_pathlen = strlen(buf) + 1;
19099fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States fi->fi_path = smb_mem_strdup(buf);
19101fcced4cSJordan Brown kmem_free(buf, MAXPATHLEN);
19111fcced4cSJordan Brown
19121fcced4cSJordan Brown fi->fi_namelen = user->u_domain_len + user->u_name_len + 2;
19131fcced4cSJordan Brown fi->fi_username = kmem_alloc(fi->fi_namelen, KM_SLEEP);
19141fcced4cSJordan Brown (void) snprintf(fi->fi_username, fi->fi_namelen, "%s\\%s",
19151fcced4cSJordan Brown user->u_domain, user->u_name);
19161fcced4cSJordan Brown return (0);
19171fcced4cSJordan Brown }
19181fcced4cSJordan Brown
19191fcced4cSJordan Brown static void
smb_ofile_netinfo_fini(smb_netfileinfo_t * fi)19201fcced4cSJordan Brown smb_ofile_netinfo_fini(smb_netfileinfo_t *fi)
19211fcced4cSJordan Brown {
19221fcced4cSJordan Brown if (fi == NULL)
19231fcced4cSJordan Brown return;
19241fcced4cSJordan Brown
19251fcced4cSJordan Brown if (fi->fi_path)
19269fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_mem_free(fi->fi_path);
19271fcced4cSJordan Brown if (fi->fi_username)
19281fcced4cSJordan Brown kmem_free(fi->fi_username, fi->fi_namelen);
19291fcced4cSJordan Brown
19301fcced4cSJordan Brown bzero(fi, sizeof (smb_netfileinfo_t));
19311fcced4cSJordan Brown }
19329fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
19339fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States /*
19349fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * A query of user and group quotas may span multiple requests.
19359fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * f_quota_resume is used to determine where the query should
19369fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * be resumed, in a subsequent request. f_quota_resume contains
19379fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States * the SID of the last quota entry returned to the client.
19389fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States */
19399fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States void
smb_ofile_set_quota_resume(smb_ofile_t * ofile,char * resume)19409fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_ofile_set_quota_resume(smb_ofile_t *ofile, char *resume)
19419fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States {
19429fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(ofile);
19439fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_enter(&ofile->f_mutex);
19449fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (resume == NULL)
19459fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States bzero(ofile->f_quota_resume, SMB_SID_STRSZ);
19469fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States else
19479fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States (void) strlcpy(ofile->f_quota_resume, resume, SMB_SID_STRSZ);
19489fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_exit(&ofile->f_mutex);
19499fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
19509fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
19519fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States void
smb_ofile_get_quota_resume(smb_ofile_t * ofile,char * buf,int bufsize)19529fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_ofile_get_quota_resume(smb_ofile_t *ofile, char *buf, int bufsize)
19539fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States {
19549fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ASSERT(ofile);
19559fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_enter(&ofile->f_mutex);
19569fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States (void) strlcpy(buf, ofile->f_quota_resume, bufsize);
19579fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States mutex_exit(&ofile->f_mutex);
19589fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
1959