static callb_cpr_t *
frlock_serialize_blocked(flk_cb_when_t when, void *infop)
{
vnode_t *vp = (vnode_t *)infop;
if (when == FLK_BEFORE_SLEEP)
nbl_end_crit(vp);
else {
nbl_start_crit(vp, RW_WRITER);
}
return (NULL);
}
/* ARGSUSED */
int
fs_frlock(register vnode_t *vp, int cmd, struct flock64 *bfp, int flag,
offset_t offset, flk_callback_t *flk_cbp, cred_t *cr,
caller_context_t *ct)
{
int frcmd;
int nlmid;
int error = 0;
flk_callback_t serialize_callback;
int serialize = 0;
v_mode_t mode;
switch (cmd) {
case F_GETLK:
case F_O_GETLK:
if (flag & F_REMOTELOCK) {
frcmd = RCMDLCK;
} else if (flag & F_PXFSLOCK) {
frcmd = PCMDLCK;
} else {
frcmd = 0;
bfp->l_pid = ttoproc(curthread)->p_pid;
bfp->l_sysid = 0;
}
break;
case F_SETLK_NBMAND:
/*
* Are NBMAND locks allowed on this file?
*/
if (!vp->v_vfsp ||
!(vp->v_vfsp->vfs_flag & VFS_NBMAND)) {
error = EINVAL;
goto done;
}
if (vp->v_type != VREG) {
error = EINVAL;
goto done;
}
/*FALLTHROUGH*/
case F_SETLK:
if (flag & F_REMOTELOCK) {
frcmd = SETFLCK|RCMDLCK;
} else if (flag & F_PXFSLOCK) {
frcmd = SETFLCK|PCMDLCK;
} else {
frcmd = SETFLCK;
bfp->l_pid = ttoproc(curthread)->p_pid;
bfp->l_sysid = 0;
}
if (cmd == F_SETLK_NBMAND &&
(bfp->l_type == F_RDLCK || bfp->l_type == F_WRLCK)) {
frcmd |= NBMLCK;
}
if (nbl_need_check(vp)) {
nbl_start_crit(vp, RW_WRITER);
serialize = 1;
if (frcmd & NBMLCK) {
mode = (bfp->l_type == F_RDLCK) ?
V_READ : V_RDANDWR;
if (vn_is_mapped(vp, mode)) {
error = EAGAIN;
goto done;
}
}
}
break;
case F_SETLKW:
if (flag & F_REMOTELOCK) {
frcmd = SETFLCK|SLPFLCK|RCMDLCK;
} else if (flag & F_PXFSLOCK) {
frcmd = SETFLCK|SLPFLCK|PCMDLCK;
} else {
frcmd = SETFLCK|SLPFLCK;
bfp->l_pid = ttoproc(curthread)->p_pid;
bfp->l_sysid = 0;
}
if (nbl_need_check(vp)) {
nbl_start_crit(vp, RW_WRITER);
serialize = 1;
}
break;
case F_HASREMOTELOCKS:
nlmid = GETNLMID(bfp->l_sysid);
if (nlmid != 0) { /* booted as a cluster */
l_has_rmt(bfp) =
cl_flk_has_remote_locks_for_nlmid(vp, nlmid);
} else { /* not booted as a cluster */
l_has_rmt(bfp) = flk_has_remote_locks(vp);
}
goto done;
default:
error = EINVAL;
goto done;
}
/*
* If this is a blocking lock request and we're serializing lock
* requests, modify the callback list to leave the critical region
* while we're waiting for the lock.
*/
if (serialize && (frcmd & SLPFLCK) != 0) {
flk_add_callback(&serialize_callback,
frlock_serialize_blocked, vp, flk_cbp);
flk_cbp = &serialize_callback;
}
error = reclock(vp, bfp, frcmd, flag, offset, flk_cbp);
done:
if (serialize)
nbl_end_crit(vp);
return (error);
}
/*
* smb_common_rename
*
* Common code for renaming a file.
*
* If the source and destination are identical, we go through all
* the checks but we don't actually do the rename. If the source
* and destination files differ only in case, we do a case-sensitive
* rename. Otherwise, we do a full case-insensitive rename.
*
* Returns NT status values.
*
* Similar to smb_make_link(), below.
*/
uint32_t
smb_common_rename(smb_request_t *sr, smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi)
{
smb_node_t *src_fnode, *src_dnode, *dst_dnode;
smb_node_t *dst_fnode = 0;
smb_node_t *tnode;
char *new_name, *path;
DWORD status;
int rc, count;
tnode = sr->tid_tree->t_snode;
path = dst_fqi->fq_path.pn_path;
/* Check if attempting to rename a stream - not yet supported */
rc = smb_rename_check_stream(src_fqi, dst_fqi);
if (rc != 0)
return (smb_rename_errno2status(rc));
/*
* The source node may already have been provided,
* i.e. when called by SMB1/SMB2 smb_setinfo_rename.
* Not provided by smb_com_rename, smb_com_nt_rename.
*/
if (src_fqi->fq_fnode) {
smb_node_start_crit(src_fqi->fq_fnode, RW_READER);
smb_node_ref(src_fqi->fq_fnode);
smb_node_ref(src_fqi->fq_dnode);
} else {
/* lookup and validate src node */
rc = smb_rename_lookup_src(sr);
if (rc != 0)
return (smb_rename_errno2status(rc));
}
src_fnode = src_fqi->fq_fnode;
src_dnode = src_fqi->fq_dnode;
/*
* Find the destination dnode and last component.
* May already be provided, i.e. when called via
* SMB1 trans2 setinfo.
*/
if (dst_fqi->fq_dnode) {
/* called via smb_set_rename_info */
smb_node_ref(dst_fqi->fq_dnode);
} else {
/* called via smb2_setf_rename, smb_com_rename, etc. */
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&dst_fqi->fq_dnode, dst_fqi->fq_last_comp);
if (rc != 0) {
smb_rename_release_src(sr);
return (smb_rename_errno2status(rc));
}
}
dst_dnode = dst_fqi->fq_dnode;
new_name = dst_fqi->fq_last_comp;
/* If exact name match in same directory, we're done */
if ((src_dnode == dst_dnode) &&
(strcmp(src_fnode->od_name, new_name) == 0)) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (0);
}
/* Lookup destination node */
rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode,
dst_dnode, new_name, &dst_fqi->fq_fnode);
/* If the destination node doesn't already exist, validate new_name. */
if (rc == ENOENT) {
if (smb_is_invalid_filename(new_name)) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (NT_STATUS_OBJECT_NAME_INVALID);
}
}
/*
* Handle case where changing case of the same directory entry.
*
* If we found the dst node in the same directory as the src node,
* and their names differ only in case:
*
* If the tree is case sensitive (or mixed):
* Do case sensitive lookup to see if exact match exists.
* If the exact match is the same node as src_node we're done.
*
* If the tree is case insensitive:
* There is currently no way to tell if the case is different
* or not, so do the rename (unless the specified new name was
* mangled).
*/
if ((rc == 0) &&
(src_dnode == dst_dnode) &&
(smb_strcasecmp(src_fnode->od_name,
dst_fqi->fq_fnode->od_name, 0) == 0)) {
smb_node_release(dst_fqi->fq_fnode);
dst_fqi->fq_fnode = NULL;
if (smb_tree_has_feature(sr->tid_tree,
SMB_TREE_NO_CASESENSITIVE)) {
if (smb_strcasecmp(src_fnode->od_name,
dst_fqi->fq_last_comp, 0) != 0) {
smb_rename_release_src(sr);
smb_node_release(dst_dnode);
return (0);
}
} else {
rc = smb_fsop_lookup(sr, sr->user_cr,
SMB_CASE_SENSITIVE, tnode, dst_dnode, new_name,
&dst_fqi->fq_fnode);
if ((rc == 0) &&
(dst_fqi->fq_fnode == src_fnode)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_fnode);
smb_node_release(dst_dnode);
return (0);
}
}
}
if ((rc != 0) && (rc != ENOENT)) {
smb_rename_release_src(sr);
smb_node_release(dst_fqi->fq_dnode);
return (smb_rename_errno2status(rc));
}
if (dst_fqi->fq_fnode) {
/*
* Destination already exists. Do delete checks.
*/
dst_fnode = dst_fqi->fq_fnode;
if (!(sr->arg.dirop.flags && SMB_RENAME_FLAG_OVERWRITE)) {
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_OBJECT_NAME_COLLISION);
}
(void) smb_oplock_break(sr, dst_fnode,
SMB_OPLOCK_BREAK_TO_NONE | SMB_OPLOCK_BREAK_BATCH);
/*
* Wait (a little) for the oplock break to be
* responded to by clients closing handles.
* Hold node->n_lock as reader to keep new
* ofiles from showing up after we check.
*/
smb_node_rdlock(dst_fnode);
for (count = 0; count <= 12; count++) {
status = smb_node_delete_check(dst_fnode);
if (status != NT_STATUS_SHARING_VIOLATION)
break;
smb_node_unlock(dst_fnode);
delay(MSEC_TO_TICK(100));
smb_node_rdlock(dst_fnode);
}
if (status != NT_STATUS_SUCCESS) {
smb_node_unlock(dst_fnode);
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_ACCESS_DENIED);
}
/*
* Note, the combination of these two:
* smb_node_rdlock(node);
* nbl_start_crit(node->vp, RW_READER);
* is equivalent to this call:
* smb_node_start_crit(node, RW_READER)
*
* Cleanup after this point should use:
* smb_node_end_crit(dst_fnode)
*/
nbl_start_crit(dst_fnode->vp, RW_READER);
/*
* This checks nbl_share_conflict, nbl_lock_conflict
*/
status = smb_nbl_conflict(dst_fnode, 0, UINT64_MAX, NBL_REMOVE);
if (status != NT_STATUS_SUCCESS) {
smb_node_end_crit(dst_fnode);
smb_rename_release_src(sr);
smb_node_release(dst_fnode);
smb_node_release(dst_dnode);
return (NT_STATUS_ACCESS_DENIED);
}
new_name = dst_fnode->od_name;
}
rc = smb_fsop_rename(sr, sr->user_cr,
src_dnode, src_fnode->od_name,
dst_dnode, new_name);
if (rc == 0) {
/*
* Note that renames in the same directory are normally
* delivered in {old,new} pairs, and clients expect them
* in that order, if both events are delivered.
*/
int a_src, a_dst; /* action codes */
if (src_dnode == dst_dnode) {
a_src = FILE_ACTION_RENAMED_OLD_NAME;
a_dst = FILE_ACTION_RENAMED_NEW_NAME;
} else {
a_src = FILE_ACTION_REMOVED;
a_dst = FILE_ACTION_ADDED;
}
smb_node_notify_change(src_dnode, a_src, src_fnode->od_name);
smb_node_notify_change(dst_dnode, a_dst, new_name);
}
smb_rename_release_src(sr);
if (dst_fqi->fq_fnode) {
smb_node_end_crit(dst_fnode);
smb_node_release(dst_fnode);
}
smb_node_release(dst_dnode);
return (smb_rename_errno2status(rc));
}
/*
* smb_rename_lookup_src
*
* Lookup the src node, checking for sharing violations and
* breaking any existing BATCH oplock.
* Populate sr->arg.dirop.fqi
*
* Upon success, the dnode and fnode will have holds and the
* fnode will be in a critical section. These should be
* released using smb_rename_release_src().
*
* Returns errno values.
*/
static int
smb_rename_lookup_src(smb_request_t *sr)
{
smb_node_t *src_node, *tnode;
DWORD status;
int rc;
int count;
char *path;
smb_fqi_t *src_fqi = &sr->arg.dirop.fqi;
if (smb_is_stream_name(src_fqi->fq_path.pn_path))
return (EINVAL);
/* Lookup the source node */
tnode = sr->tid_tree->t_snode;
path = src_fqi->fq_path.pn_path;
rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode,
&src_fqi->fq_dnode, src_fqi->fq_last_comp);
if (rc != 0)
return (rc);
rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode,
src_fqi->fq_dnode, src_fqi->fq_last_comp, &src_fqi->fq_fnode);
if (rc != 0) {
smb_node_release(src_fqi->fq_dnode);
return (rc);
}
src_node = src_fqi->fq_fnode;
rc = smb_rename_check_attr(sr, src_node, src_fqi->fq_sattr);
if (rc != 0) {
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
return (rc);
}
/*
* Break BATCH oplock before ofile checks. If a client
* has a file open, this will force a flush or close,
* which may affect the outcome of any share checking.
*/
(void) smb_oplock_break(sr, src_node,
SMB_OPLOCK_BREAK_TO_LEVEL_II | SMB_OPLOCK_BREAK_BATCH);
/*
* Wait (a little) for the oplock break to be
* responded to by clients closing handles.
* Hold node->n_lock as reader to keep new
* ofiles from showing up after we check.
*/
smb_node_rdlock(src_node);
for (count = 0; count <= 12; count++) {
status = smb_node_rename_check(src_node);
if (status != NT_STATUS_SHARING_VIOLATION)
break;
smb_node_unlock(src_node);
delay(MSEC_TO_TICK(100));
smb_node_rdlock(src_node);
}
if (status != NT_STATUS_SUCCESS) {
smb_node_unlock(src_node);
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
return (EPIPE); /* = ERRbadshare */
}
/*
* Note, the combination of these two:
* smb_node_rdlock(node);
* nbl_start_crit(node->vp, RW_READER);
* is equivalent to this call:
* smb_node_start_crit(node, RW_READER)
*
* Cleanup after this point should use:
* smb_node_end_crit(src_node)
*/
nbl_start_crit(src_node->vp, RW_READER);
/*
* This checks nbl_share_conflict, nbl_lock_conflict
*/
status = smb_nbl_conflict(src_node, 0, UINT64_MAX, NBL_RENAME);
if (status != NT_STATUS_SUCCESS) {
smb_node_end_crit(src_node);
smb_node_release(src_fqi->fq_fnode);
smb_node_release(src_fqi->fq_dnode);
if (status == NT_STATUS_SHARING_VIOLATION)
return (EPIPE); /* = ERRbadshare */
return (EACCES);
}
/* NB: Caller expects holds on src_fqi fnode, dnode */
return (0);
}
/*
* File control.
*/
int
fcntl(int fdes, int cmd, intptr_t arg)
{
int iarg;
int error = 0;
int retval;
proc_t *p;
file_t *fp;
vnode_t *vp;
u_offset_t offset;
u_offset_t start;
struct vattr vattr;
int in_crit;
int flag;
struct flock sbf;
struct flock64 bf;
struct o_flock obf;
struct flock64_32 bf64_32;
struct fshare fsh;
struct shrlock shr;
struct shr_locowner shr_own;
offset_t maxoffset;
model_t datamodel;
int fdres;
#if defined(_ILP32) && !defined(lint) && defined(_SYSCALL32)
ASSERT(sizeof (struct flock) == sizeof (struct flock32));
ASSERT(sizeof (struct flock64) == sizeof (struct flock64_32));
#endif
#if defined(_LP64) && !defined(lint) && defined(_SYSCALL32)
ASSERT(sizeof (struct flock) == sizeof (struct flock64_64));
ASSERT(sizeof (struct flock64) == sizeof (struct flock64_64));
#endif
/*
* First, for speed, deal with the subset of cases
* that do not require getf() / releasef().
*/
switch (cmd) {
case F_GETFD:
if ((error = f_getfd_error(fdes, &flag)) == 0)
retval = flag;
goto out;
case F_SETFD:
error = f_setfd_error(fdes, (int)arg);
retval = 0;
goto out;
case F_GETFL:
if ((error = f_getfl(fdes, &flag)) == 0)
retval = (flag & (FMASK | FASYNC)) + FOPEN;
goto out;
case F_GETXFL:
if ((error = f_getfl(fdes, &flag)) == 0)
retval = flag + FOPEN;
goto out;
case F_BADFD:
if ((error = f_badfd(fdes, &fdres, (int)arg)) == 0)
retval = fdres;
goto out;
}
/*
* Second, for speed, deal with the subset of cases that
* require getf() / releasef() but do not require copyin.
*/
if ((fp = getf(fdes)) == NULL) {
error = EBADF;
goto out;
}
iarg = (int)arg;
switch (cmd) {
/* ONC_PLUS EXTRACT END */
case F_DUPFD:
p = curproc;
if ((uint_t)iarg >= p->p_fno_ctl) {
if (iarg >= 0)
fd_too_big(p);
error = EINVAL;
} else if ((retval = ufalloc_file(iarg, fp)) == -1) {
error = EMFILE;
} else {
mutex_enter(&fp->f_tlock);
fp->f_count++;
mutex_exit(&fp->f_tlock);
}
goto done;
case F_DUP2FD:
p = curproc;
if (fdes == iarg) {
retval = iarg;
} else if ((uint_t)iarg >= p->p_fno_ctl) {
if (iarg >= 0)
fd_too_big(p);
error = EBADF;
} else {
/*
* We can't hold our getf(fdes) across the call to
* closeandsetf() because it creates a window for
* deadlock: if one thread is doing dup2(a, b) while
* another is doing dup2(b, a), each one will block
* waiting for the other to call releasef(). The
* solution is to increment the file reference count
* (which we have to do anyway), then releasef(fdes),
* then closeandsetf(). Incrementing f_count ensures
* that fp won't disappear after we call releasef().
* When closeandsetf() fails, we try avoid calling
* closef() because of all the side effects.
*/
mutex_enter(&fp->f_tlock);
fp->f_count++;
mutex_exit(&fp->f_tlock);
releasef(fdes);
if ((error = closeandsetf(iarg, fp)) == 0) {
retval = iarg;
} else {
mutex_enter(&fp->f_tlock);
if (fp->f_count > 1) {
fp->f_count--;
mutex_exit(&fp->f_tlock);
} else {
mutex_exit(&fp->f_tlock);
(void) closef(fp);
}
}
goto out;
}
goto done;
case F_SETFL:
vp = fp->f_vnode;
flag = fp->f_flag;
if ((iarg & (FNONBLOCK|FNDELAY)) == (FNONBLOCK|FNDELAY))
iarg &= ~FNDELAY;
if ((error = VOP_SETFL(vp, flag, iarg, fp->f_cred)) == 0) {
iarg &= FMASK;
mutex_enter(&fp->f_tlock);
fp->f_flag &= ~FMASK | (FREAD|FWRITE);
fp->f_flag |= (iarg - FOPEN) & ~(FREAD|FWRITE);
mutex_exit(&fp->f_tlock);
}
retval = 0;
goto done;
}
/*
* Finally, deal with the expensive cases.
*/
retval = 0;
in_crit = 0;
maxoffset = MAXOFF_T;
datamodel = DATAMODEL_NATIVE;
#if defined(_SYSCALL32_IMPL)
if ((datamodel = get_udatamodel()) == DATAMODEL_ILP32)
maxoffset = MAXOFF32_T;
#endif
vp = fp->f_vnode;
flag = fp->f_flag;
offset = fp->f_offset;
switch (cmd) {
/* ONC_PLUS EXTRACT START */
/*
* The file system and vnode layers understand and implement
* locking with flock64 structures. So here once we pass through
* the test for compatibility as defined by LFS API, (for F_SETLK,
* F_SETLKW, F_GETLK, F_GETLKW, F_FREESP) we transform
* the flock structure to a flock64 structure and send it to the
* lower layers. Similarly in case of GETLK the returned flock64
* structure is transformed to a flock structure if everything fits
* in nicely, otherwise we return EOVERFLOW.
*/
case F_GETLK:
case F_O_GETLK:
case F_SETLK:
case F_SETLKW:
case F_SETLK_NBMAND:
/*
* Copy in input fields only.
*/
if (cmd == F_O_GETLK) {
if (datamodel != DATAMODEL_ILP32) {
error = EINVAL;
break;
}
if (copyin((void *)arg, &obf, sizeof (obf))) {
error = EFAULT;
break;
}
bf.l_type = obf.l_type;
bf.l_whence = obf.l_whence;
bf.l_start = (off64_t)obf.l_start;
bf.l_len = (off64_t)obf.l_len;
bf.l_sysid = (int)obf.l_sysid;
bf.l_pid = obf.l_pid;
} else if (datamodel == DATAMODEL_NATIVE) {
if (copyin((void *)arg, &sbf, sizeof (sbf))) {
error = EFAULT;
break;
}
/*
* XXX In an LP64 kernel with an LP64 application
* there's no need to do a structure copy here
* struct flock == struct flock64. However,
* we did it this way to avoid more conditional
* compilation.
*/
bf.l_type = sbf.l_type;
bf.l_whence = sbf.l_whence;
bf.l_start = (off64_t)sbf.l_start;
bf.l_len = (off64_t)sbf.l_len;
bf.l_sysid = sbf.l_sysid;
bf.l_pid = sbf.l_pid;
}
#if defined(_SYSCALL32_IMPL)
else {
struct flock32 sbf32;
if (copyin((void *)arg, &sbf32, sizeof (sbf32))) {
error = EFAULT;
break;
}
bf.l_type = sbf32.l_type;
bf.l_whence = sbf32.l_whence;
bf.l_start = (off64_t)sbf32.l_start;
bf.l_len = (off64_t)sbf32.l_len;
bf.l_sysid = sbf32.l_sysid;
bf.l_pid = sbf32.l_pid;
}
#endif /* _SYSCALL32_IMPL */
/*
* 64-bit support: check for overflow for 32-bit lock ops
*/
if ((error = flock_check(vp, &bf, offset, maxoffset)) != 0)
break;
/*
* Not all of the filesystems understand F_O_GETLK, and
* there's no need for them to know. Map it to F_GETLK.
*/
if ((error = VOP_FRLOCK(vp, (cmd == F_O_GETLK) ? F_GETLK : cmd,
&bf, flag, offset, NULL, fp->f_cred)) != 0)
break;
/*
* If command is GETLK and no lock is found, only
* the type field is changed.
*/
if ((cmd == F_O_GETLK || cmd == F_GETLK) &&
bf.l_type == F_UNLCK) {
/* l_type always first entry, always a short */
if (copyout(&bf.l_type, &((struct flock *)arg)->l_type,
sizeof (bf.l_type)))
error = EFAULT;
break;
}
if (cmd == F_O_GETLK) {
/*
* Return an SVR3 flock structure to the user.
*/
obf.l_type = (int16_t)bf.l_type;
obf.l_whence = (int16_t)bf.l_whence;
obf.l_start = (int32_t)bf.l_start;
obf.l_len = (int32_t)bf.l_len;
if (bf.l_sysid > SHRT_MAX || bf.l_pid > SHRT_MAX) {
/*
* One or both values for the above fields
* is too large to store in an SVR3 flock
* structure.
*/
error = EOVERFLOW;
break;
}
obf.l_sysid = (int16_t)bf.l_sysid;
obf.l_pid = (int16_t)bf.l_pid;
if (copyout(&obf, (void *)arg, sizeof (obf)))
error = EFAULT;
} else if (cmd == F_GETLK) {
/*
* Copy out SVR4 flock.
*/
int i;
if (bf.l_start > maxoffset || bf.l_len > maxoffset) {
error = EOVERFLOW;
break;
}
if (datamodel == DATAMODEL_NATIVE) {
for (i = 0; i < 4; i++)
sbf.l_pad[i] = 0;
/*
* XXX In an LP64 kernel with an LP64
* application there's no need to do a
* structure copy here as currently
* struct flock == struct flock64.
* We did it this way to avoid more
* conditional compilation.
*/
sbf.l_type = bf.l_type;
sbf.l_whence = bf.l_whence;
sbf.l_start = (off_t)bf.l_start;
sbf.l_len = (off_t)bf.l_len;
sbf.l_sysid = bf.l_sysid;
sbf.l_pid = bf.l_pid;
if (copyout(&sbf, (void *)arg, sizeof (sbf)))
error = EFAULT;
}
#if defined(_SYSCALL32_IMPL)
else {
struct flock32 sbf32;
if (bf.l_start > MAXOFF32_T ||
bf.l_len > MAXOFF32_T) {
error = EOVERFLOW;
break;
}
for (i = 0; i < 4; i++)
sbf32.l_pad[i] = 0;
sbf32.l_type = (int16_t)bf.l_type;
sbf32.l_whence = (int16_t)bf.l_whence;
sbf32.l_start = (off32_t)bf.l_start;
sbf32.l_len = (off32_t)bf.l_len;
sbf32.l_sysid = (int32_t)bf.l_sysid;
sbf32.l_pid = (pid32_t)bf.l_pid;
if (copyout(&sbf32,
(void *)arg, sizeof (sbf32)))
error = EFAULT;
}
#endif
}
break;
/* ONC_PLUS EXTRACT END */
case F_CHKFL:
/*
* This is for internal use only, to allow the vnode layer
* to validate a flags setting before applying it. User
* programs can't issue it.
*/
error = EINVAL;
break;
case F_ALLOCSP:
case F_FREESP:
case F_ALLOCSP64:
case F_FREESP64:
if ((flag & FWRITE) == 0) {
error = EBADF;
break;
}
if (vp->v_type != VREG) {
error = EINVAL;
break;
}
if (datamodel != DATAMODEL_ILP32 &&
(cmd == F_ALLOCSP64 || cmd == F_FREESP64)) {
error = EINVAL;
break;
}
#if defined(_ILP32) || defined(_SYSCALL32_IMPL)
if (datamodel == DATAMODEL_ILP32 &&
(cmd == F_ALLOCSP || cmd == F_FREESP)) {
struct flock32 sbf32;
/*
* For compatibility we overlay an SVR3 flock on an SVR4
* flock. This works because the input field offsets
* in "struct flock" were preserved.
*/
if (copyin((void *)arg, &sbf32, sizeof (sbf32))) {
error = EFAULT;
break;
} else {
bf.l_type = sbf32.l_type;
bf.l_whence = sbf32.l_whence;
bf.l_start = (off64_t)sbf32.l_start;
bf.l_len = (off64_t)sbf32.l_len;
bf.l_sysid = sbf32.l_sysid;
bf.l_pid = sbf32.l_pid;
}
}
#endif /* _ILP32 || _SYSCALL32_IMPL */
#if defined(_LP64)
if (datamodel == DATAMODEL_LP64 &&
(cmd == F_ALLOCSP || cmd == F_FREESP)) {
if (copyin((void *)arg, &bf, sizeof (bf))) {
error = EFAULT;
break;
}
}
#endif /* defined(_LP64) */
#if !defined(_LP64) || defined(_SYSCALL32_IMPL)
if (datamodel == DATAMODEL_ILP32 &&
(cmd == F_ALLOCSP64 || cmd == F_FREESP64)) {
if (copyin((void *)arg, &bf64_32, sizeof (bf64_32))) {
error = EFAULT;
break;
} else {
/*
* Note that the size of flock64 is different in
* the ILP32 and LP64 models, due to the l_pad
* field. We do not want to assume that the
* flock64 structure is laid out the same in
* ILP32 and LP64 environments, so we will
* copy in the ILP32 version of flock64
* explicitly and copy it to the native
* flock64 structure.
*/
bf.l_type = (short)bf64_32.l_type;
bf.l_whence = (short)bf64_32.l_whence;
bf.l_start = bf64_32.l_start;
bf.l_len = bf64_32.l_len;
bf.l_sysid = (int)bf64_32.l_sysid;
bf.l_pid = (pid_t)bf64_32.l_pid;
}
}
#endif /* !defined(_LP64) || defined(_SYSCALL32_IMPL) */
if (cmd == F_ALLOCSP || cmd == F_FREESP)
error = flock_check(vp, &bf, offset, maxoffset);
else if (cmd == F_ALLOCSP64 || cmd == F_FREESP64)
error = flock_check(vp, &bf, offset, MAXOFFSET_T);
if (error)
break;
if (vp->v_type == VREG && bf.l_len == 0 &&
bf.l_start > OFFSET_MAX(fp)) {
error = EFBIG;
break;
}
/*
* Make sure that there are no conflicting non-blocking
* mandatory locks in the region being manipulated. If
* there are such locks then return EACCES.
*/
if ((error = flock_get_start(vp, &bf, offset, &start)) != 0)
break;
if (nbl_need_check(vp)) {
u_offset_t begin;
ssize_t length;
nbl_start_crit(vp, RW_READER);
in_crit = 1;
vattr.va_mask = AT_SIZE;
if ((error = VOP_GETATTR(vp, &vattr, 0, CRED())) != 0)
break;
begin = start > vattr.va_size ? vattr.va_size : start;
length = vattr.va_size > start ? vattr.va_size - start :
start - vattr.va_size;
if (nbl_conflict(vp, NBL_WRITE, begin, length, 0)) {
error = EACCES;
break;
}
}
if (cmd == F_ALLOCSP64)
cmd = F_ALLOCSP;
else if (cmd == F_FREESP64)
cmd = F_FREESP;
error = VOP_SPACE(vp, cmd, &bf, flag, offset, fp->f_cred, NULL);
break;
#if !defined(_LP64) || defined(_SYSCALL32_IMPL)
/* ONC_PLUS EXTRACT START */
case F_GETLK64:
case F_SETLK64:
case F_SETLKW64:
case F_SETLK64_NBMAND:
/*
* Large Files: Here we set cmd as *LK and send it to
* lower layers. *LK64 is only for the user land.
* Most of the comments described above for F_SETLK
* applies here too.
* Large File support is only needed for ILP32 apps!
*/
if (datamodel != DATAMODEL_ILP32) {
error = EINVAL;
break;
}
if (cmd == F_GETLK64)
cmd = F_GETLK;
else if (cmd == F_SETLK64)
cmd = F_SETLK;
else if (cmd == F_SETLKW64)
cmd = F_SETLKW;
else if (cmd == F_SETLK64_NBMAND)
cmd = F_SETLK_NBMAND;
/*
* Note that the size of flock64 is different in the ILP32
* and LP64 models, due to the sucking l_pad field.
* We do not want to assume that the flock64 structure is
* laid out in the same in ILP32 and LP64 environments, so
* we will copy in the ILP32 version of flock64 explicitly
* and copy it to the native flock64 structure.
*/
if (copyin((void *)arg, &bf64_32, sizeof (bf64_32))) {
error = EFAULT;
break;
}
bf.l_type = (short)bf64_32.l_type;
bf.l_whence = (short)bf64_32.l_whence;
bf.l_start = bf64_32.l_start;
bf.l_len = bf64_32.l_len;
bf.l_sysid = (int)bf64_32.l_sysid;
bf.l_pid = (pid_t)bf64_32.l_pid;
if ((error = flock_check(vp, &bf, offset, MAXOFFSET_T)) != 0)
break;
if ((error = VOP_FRLOCK(vp, cmd, &bf, flag, offset,
NULL, fp->f_cred)) != 0)
break;
if ((cmd == F_GETLK) && bf.l_type == F_UNLCK) {
if (copyout(&bf.l_type, &((struct flock *)arg)->l_type,
sizeof (bf.l_type)))
error = EFAULT;
break;
}
if (cmd == F_GETLK) {
int i;
/*
* We do not want to assume that the flock64 structure
* is laid out in the same in ILP32 and LP64
* environments, so we will copy out the ILP32 version
* of flock64 explicitly after copying the native
* flock64 structure to it.
*/
for (i = 0; i < 4; i++)
bf64_32.l_pad[i] = 0;
bf64_32.l_type = (int16_t)bf.l_type;
bf64_32.l_whence = (int16_t)bf.l_whence;
bf64_32.l_start = bf.l_start;
bf64_32.l_len = bf.l_len;
bf64_32.l_sysid = (int32_t)bf.l_sysid;
bf64_32.l_pid = (pid32_t)bf.l_pid;
if (copyout(&bf64_32, (void *)arg, sizeof (bf64_32)))
error = EFAULT;
}
break;
/* ONC_PLUS EXTRACT END */
#endif /* !defined(_LP64) || defined(_SYSCALL32_IMPL) */
/* ONC_PLUS EXTRACT START */
case F_SHARE:
case F_SHARE_NBMAND:
case F_UNSHARE:
/*
* Copy in input fields only.
*/
if (copyin((void *)arg, &fsh, sizeof (fsh))) {
error = EFAULT;
break;
}
/*
* Local share reservations always have this simple form
*/
shr.s_access = fsh.f_access;
shr.s_deny = fsh.f_deny;
shr.s_sysid = 0;
shr.s_pid = ttoproc(curthread)->p_pid;
shr_own.sl_pid = shr.s_pid;
shr_own.sl_id = fsh.f_id;
shr.s_own_len = sizeof (shr_own);
shr.s_owner = (caddr_t)&shr_own;
error = VOP_SHRLOCK(vp, cmd, &shr, flag, fp->f_cred);
/* ONC_PLUS EXTRACT END */
break;
default:
error = EINVAL;
break;
}
if (in_crit)
nbl_end_crit(vp);
done:
releasef(fdes);
out:
if (error)
return (set_errno(error));
return (retval);
}
static int
smmap_common(caddr_t *addrp, size_t len,
int prot, int flags, struct file *fp, offset_t pos)
{
struct vnode *vp;
struct as *as = curproc->p_as;
uint_t uprot, maxprot, type;
int error;
int in_crit = 0;
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | _MAP_NEW |
_MAP_LOW32 | MAP_NORESERVE | MAP_ANON | MAP_ALIGN |
MAP_TEXT | MAP_INITDATA)) != 0) {
/* | MAP_RENAME */ /* not implemented, let user know */
return (EINVAL);
}
if ((flags & MAP_TEXT) && !(prot & PROT_EXEC)) {
return (EINVAL);
}
if ((flags & (MAP_TEXT | MAP_INITDATA)) == (MAP_TEXT | MAP_INITDATA)) {
return (EINVAL);
}
#if defined(__sparc)
/*
* See if this is an "old mmap call". If so, remember this
* fact and convert the flags value given to mmap to indicate
* the specified address in the system call must be used.
* _MAP_NEW is turned set by all new uses of mmap.
*/
if ((flags & _MAP_NEW) == 0)
flags |= MAP_FIXED;
#endif
flags &= ~_MAP_NEW;
type = flags & MAP_TYPE;
if (type != MAP_PRIVATE && type != MAP_SHARED)
return (EINVAL);
if (flags & MAP_ALIGN) {
if (flags & MAP_FIXED)
return (EINVAL);
/* alignment needs to be a power of 2 >= page size */
if (((uintptr_t)*addrp < PAGESIZE && (uintptr_t)*addrp != 0) ||
!ISP2((uintptr_t)*addrp))
return (EINVAL);
}
/*
* Check for bad lengths and file position.
* We let the VOP_MAP routine check for negative lengths
* since on some vnode types this might be appropriate.
*/
if (len == 0 || (pos & (u_offset_t)PAGEOFFSET) != 0)
return (EINVAL);
maxprot = PROT_ALL; /* start out allowing all accesses */
uprot = prot | PROT_USER;
if (fp == NULL) {
ASSERT(flags & MAP_ANON);
/* discard lwpchan mappings, like munmap() */
if ((flags & MAP_FIXED) && curproc->p_lcp != NULL)
lwpchan_delete_mapping(curproc, *addrp, *addrp + len);
as_rangelock(as);
error = zmap(as, addrp, len, uprot, flags, pos);
as_rangeunlock(as);
/*
* Tell machine specific code that lwp has mapped shared memory
*/
if (error == 0 && (flags & MAP_SHARED)) {
/* EMPTY */
LWP_MMODEL_SHARED_AS(*addrp, len);
}
return (error);
} else if ((flags & MAP_ANON) != 0)
return (EINVAL);
vp = fp->f_vnode;
/* Can't execute code from "noexec" mounted filesystem. */
if ((vp->v_vfsp->vfs_flag & VFS_NOEXEC) != 0)
maxprot &= ~PROT_EXEC;
/*
* These checks were added as part of large files.
*
* Return ENXIO if the initial position is negative; return EOVERFLOW
* if (offset + len) would overflow the maximum allowed offset for the
* type of file descriptor being used.
*/
if (vp->v_type == VREG) {
if (pos < 0)
return (ENXIO);
if ((offset_t)len > (OFFSET_MAX(fp) - pos))
return (EOVERFLOW);
}
if (type == MAP_SHARED && (fp->f_flag & FWRITE) == 0) {
/* no write access allowed */
maxprot &= ~PROT_WRITE;
}
/*
* XXX - Do we also adjust maxprot based on protections
* of the vnode? E.g. if no execute permission is given
* on the vnode for the current user, maxprot probably
* should disallow PROT_EXEC also? This is different
* from the write access as this would be a per vnode
* test as opposed to a per fd test for writability.
*/
/*
* Verify that the specified protections are not greater than
* the maximum allowable protections. Also test to make sure
* that the file descriptor does allows for read access since
* "write only" mappings are hard to do since normally we do
* the read from the file before the page can be written.
*/
if (((maxprot & uprot) != uprot) || (fp->f_flag & FREAD) == 0)
return (EACCES);
/*
* If the user specified an address, do some simple checks here
*/
if ((flags & MAP_FIXED) != 0) {
caddr_t userlimit;
/*
* Use the user address. First verify that
* the address to be used is page aligned.
* Then make some simple bounds checks.
*/
if (((uintptr_t)*addrp & PAGEOFFSET) != 0)
return (EINVAL);
userlimit = flags & _MAP_LOW32 ?
(caddr_t)USERLIMIT32 : as->a_userlimit;
switch (valid_usr_range(*addrp, len, uprot, as, userlimit)) {
case RANGE_OKAY:
break;
case RANGE_BADPROT:
return (ENOTSUP);
case RANGE_BADADDR:
default:
return (ENOMEM);
}
}
if ((prot & (PROT_READ | PROT_WRITE | PROT_EXEC)) &&
nbl_need_check(vp)) {
int svmand;
nbl_op_t nop;
nbl_start_crit(vp, RW_READER);
in_crit = 1;
error = nbl_svmand(vp, fp->f_cred, &svmand);
if (error != 0)
goto done;
if ((prot & PROT_WRITE) && (type == MAP_SHARED)) {
if (prot & (PROT_READ | PROT_EXEC)) {
nop = NBL_READWRITE;
} else {
nop = NBL_WRITE;
}
} else {
nop = NBL_READ;
}
if (nbl_conflict(vp, nop, 0, LONG_MAX, svmand, NULL)) {
error = EACCES;
goto done;
}
}
/* discard lwpchan mappings, like munmap() */
if ((flags & MAP_FIXED) && curproc->p_lcp != NULL)
lwpchan_delete_mapping(curproc, *addrp, *addrp + len);
/*
* Ok, now let the vnode map routine do its thing to set things up.
*/
error = VOP_MAP(vp, pos, as,
addrp, len, uprot, maxprot, flags, fp->f_cred, NULL);
if (error == 0) {
/*
* Tell machine specific code that lwp has mapped shared memory
*/
if (flags & MAP_SHARED) {
/* EMPTY */
LWP_MMODEL_SHARED_AS(*addrp, len);
}
if (vp->v_type == VREG &&
(flags & (MAP_TEXT | MAP_INITDATA)) != 0) {
/*
* Mark this as an executable vnode
*/
mutex_enter(&vp->v_lock);
vp->v_flag |= VVMEXEC;
mutex_exit(&vp->v_lock);
}
}
done:
if (in_crit)
nbl_end_crit(vp);
return (error);
}