| Current Path : /compat/linux/proc/self/root/usr/src/sys/netsmb/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //compat/linux/proc/self/root/usr/src/sys/netsmb/smb_iod.c |
/*-
* Copyright (c) 2000-2001 Boris Popov
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: release/9.1.0/sys/netsmb/smb_iod.c 206361 2010-04-07 16:50:38Z joel $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/endian.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/unistd.h>
#include <netsmb/smb.h>
#include <netsmb/smb_conn.h>
#include <netsmb/smb_rq.h>
#include <netsmb/smb_tran.h>
#include <netsmb/smb_trantcp.h>
#define SMBIOD_SLEEP_TIMO 2
#define SMBIOD_PING_TIMO 60 /* seconds */
#define SMB_IOD_EVLOCKPTR(iod) (&((iod)->iod_evlock))
#define SMB_IOD_EVLOCK(iod) smb_sl_lock(&((iod)->iod_evlock))
#define SMB_IOD_EVUNLOCK(iod) smb_sl_unlock(&((iod)->iod_evlock))
#define SMB_IOD_RQLOCKPTR(iod) (&((iod)->iod_rqlock))
#define SMB_IOD_RQLOCK(iod) smb_sl_lock(&((iod)->iod_rqlock))
#define SMB_IOD_RQUNLOCK(iod) smb_sl_unlock(&((iod)->iod_rqlock))
#define smb_iod_wakeup(iod) wakeup(&(iod)->iod_flags)
static MALLOC_DEFINE(M_SMBIOD, "SMBIOD", "SMB network io daemon");
static int smb_iod_next;
static int smb_iod_sendall(struct smbiod *iod);
static int smb_iod_disconnect(struct smbiod *iod);
static void smb_iod_thread(void *);
static __inline void
smb_iod_rqprocessed(struct smb_rq *rqp, int error)
{
SMBRQ_SLOCK(rqp);
rqp->sr_lerror = error;
rqp->sr_rpgen++;
rqp->sr_state = SMBRQ_NOTIFIED;
wakeup(&rqp->sr_state);
SMBRQ_SUNLOCK(rqp);
}
static void
smb_iod_invrq(struct smbiod *iod)
{
struct smb_rq *rqp;
/*
* Invalidate all outstanding requests for this connection
*/
SMB_IOD_RQLOCK(iod);
TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
if (rqp->sr_flags & SMBR_INTERNAL)
SMBRQ_SUNLOCK(rqp);
rqp->sr_flags |= SMBR_RESTART;
smb_iod_rqprocessed(rqp, ENOTCONN);
}
SMB_IOD_RQUNLOCK(iod);
}
static void
smb_iod_closetran(struct smbiod *iod)
{
struct smb_vc *vcp = iod->iod_vc;
struct thread *td = iod->iod_td;
if (vcp->vc_tdata == NULL)
return;
SMB_TRAN_DISCONNECT(vcp, td);
SMB_TRAN_DONE(vcp, td);
vcp->vc_tdata = NULL;
}
static void
smb_iod_dead(struct smbiod *iod)
{
iod->iod_state = SMBIOD_ST_DEAD;
smb_iod_closetran(iod);
smb_iod_invrq(iod);
}
static int
smb_iod_connect(struct smbiod *iod)
{
struct smb_vc *vcp = iod->iod_vc;
struct thread *td = iod->iod_td;
int error;
SMBIODEBUG("%d\n", iod->iod_state);
switch(iod->iod_state) {
case SMBIOD_ST_VCACTIVE:
SMBERROR("called for already opened connection\n");
return EISCONN;
case SMBIOD_ST_DEAD:
return ENOTCONN; /* XXX: last error code ? */
default:
break;
}
vcp->vc_genid++;
error = 0;
error = (int)SMB_TRAN_CREATE(vcp, td);
if (error)
goto fail;
SMBIODEBUG("tcreate\n");
if (vcp->vc_laddr) {
error = (int)SMB_TRAN_BIND(vcp, vcp->vc_laddr, td);
if (error)
goto fail;
}
SMBIODEBUG("tbind\n");
error = (int)SMB_TRAN_CONNECT(vcp, vcp->vc_paddr, td);
if (error)
goto fail;
SMB_TRAN_SETPARAM(vcp, SMBTP_SELECTID, &iod->iod_flags);
iod->iod_state = SMBIOD_ST_TRANACTIVE;
SMBIODEBUG("tconnect\n");
/* vcp->vc_mid = 0;*/
error = (int)smb_smb_negotiate(vcp, &iod->iod_scred);
if (error)
goto fail;
SMBIODEBUG("snegotiate\n");
error = (int)smb_smb_ssnsetup(vcp, &iod->iod_scred);
if (error)
goto fail;
iod->iod_state = SMBIOD_ST_VCACTIVE;
SMBIODEBUG("completed\n");
smb_iod_invrq(iod);
return (0);
fail:
smb_iod_dead(iod);
return (error);
}
static int
smb_iod_disconnect(struct smbiod *iod)
{
struct smb_vc *vcp = iod->iod_vc;
SMBIODEBUG("\n");
if (iod->iod_state == SMBIOD_ST_VCACTIVE) {
smb_smb_ssnclose(vcp, &iod->iod_scred);
iod->iod_state = SMBIOD_ST_TRANACTIVE;
}
vcp->vc_smbuid = SMB_UID_UNKNOWN;
smb_iod_closetran(iod);
iod->iod_state = SMBIOD_ST_NOTCONN;
return 0;
}
static int
smb_iod_treeconnect(struct smbiod *iod, struct smb_share *ssp)
{
int error;
if (iod->iod_state != SMBIOD_ST_VCACTIVE) {
if (iod->iod_state != SMBIOD_ST_DEAD)
return ENOTCONN;
iod->iod_state = SMBIOD_ST_RECONNECT;
error = smb_iod_connect(iod);
if (error)
return error;
}
SMBIODEBUG("tree reconnect\n");
SMBS_ST_LOCK(ssp);
ssp->ss_flags |= SMBS_RECONNECTING;
SMBS_ST_UNLOCK(ssp);
error = smb_smb_treeconnect(ssp, &iod->iod_scred);
SMBS_ST_LOCK(ssp);
ssp->ss_flags &= ~SMBS_RECONNECTING;
SMBS_ST_UNLOCK(ssp);
wakeup(&ssp->ss_vcgenid);
return error;
}
static int
smb_iod_sendrq(struct smbiod *iod, struct smb_rq *rqp)
{
struct thread *td = iod->iod_td;
struct smb_vc *vcp = iod->iod_vc;
struct smb_share *ssp = rqp->sr_share;
struct mbuf *m;
int error;
SMBIODEBUG("iod_state = %d\n", iod->iod_state);
switch (iod->iod_state) {
case SMBIOD_ST_NOTCONN:
smb_iod_rqprocessed(rqp, ENOTCONN);
return 0;
case SMBIOD_ST_DEAD:
iod->iod_state = SMBIOD_ST_RECONNECT;
return 0;
case SMBIOD_ST_RECONNECT:
return 0;
default:
break;
}
if (rqp->sr_sendcnt == 0) {
#ifdef movedtoanotherplace
if (vcp->vc_maxmux != 0 && iod->iod_muxcnt >= vcp->vc_maxmux)
return 0;
#endif
le16enc(rqp->sr_rqtid, ssp ? ssp->ss_tid : SMB_TID_UNKNOWN);
le16enc(rqp->sr_rquid, vcp ? vcp->vc_smbuid : 0);
mb_fixhdr(&rqp->sr_rq);
if (vcp->vc_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE)
smb_rq_sign(rqp);
}
if (rqp->sr_sendcnt++ > 5) {
rqp->sr_flags |= SMBR_RESTART;
smb_iod_rqprocessed(rqp, rqp->sr_lerror);
/*
* If all attempts to send a request failed, then
* something is seriously hosed.
*/
return ENOTCONN;
}
SMBSDEBUG("M:%04x, P:%04x, U:%04x, T:%04x\n", rqp->sr_mid, 0, 0, 0);
m_dumpm(rqp->sr_rq.mb_top);
m = m_copym(rqp->sr_rq.mb_top, 0, M_COPYALL, M_WAIT);
error = rqp->sr_lerror = SMB_TRAN_SEND(vcp, m, td);
if (error == 0) {
getnanotime(&rqp->sr_timesent);
iod->iod_lastrqsent = rqp->sr_timesent;
rqp->sr_flags |= SMBR_SENT;
rqp->sr_state = SMBRQ_SENT;
return 0;
}
/*
* Check for fatal errors
*/
if (SMB_TRAN_FATAL(vcp, error)) {
/*
* No further attempts should be made
*/
return ENOTCONN;
}
if (smb_rq_intr(rqp))
smb_iod_rqprocessed(rqp, EINTR);
return 0;
}
/*
* Process incoming packets
*/
static int
smb_iod_recvall(struct smbiod *iod)
{
struct smb_vc *vcp = iod->iod_vc;
struct thread *td = iod->iod_td;
struct smb_rq *rqp;
struct mbuf *m;
u_char *hp;
u_short mid;
int error;
switch (iod->iod_state) {
case SMBIOD_ST_NOTCONN:
case SMBIOD_ST_DEAD:
case SMBIOD_ST_RECONNECT:
return 0;
default:
break;
}
for (;;) {
m = NULL;
error = SMB_TRAN_RECV(vcp, &m, td);
if (error == EWOULDBLOCK)
break;
if (SMB_TRAN_FATAL(vcp, error)) {
smb_iod_dead(iod);
break;
}
if (error)
break;
if (m == NULL) {
SMBERROR("tran return NULL without error\n");
error = EPIPE;
continue;
}
m = m_pullup(m, SMB_HDRLEN);
if (m == NULL)
continue; /* wait for a good packet */
/*
* Now we got an entire and possibly invalid SMB packet.
* Be careful while parsing it.
*/
m_dumpm(m);
hp = mtod(m, u_char*);
if (bcmp(hp, SMB_SIGNATURE, SMB_SIGLEN) != 0) {
m_freem(m);
continue;
}
mid = SMB_HDRMID(hp);
SMBSDEBUG("mid %04x\n", (u_int)mid);
SMB_IOD_RQLOCK(iod);
TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
if (rqp->sr_mid != mid)
continue;
SMBRQ_SLOCK(rqp);
if (rqp->sr_rp.md_top == NULL) {
md_initm(&rqp->sr_rp, m);
} else {
if (rqp->sr_flags & SMBR_MULTIPACKET) {
md_append_record(&rqp->sr_rp, m);
} else {
SMBRQ_SUNLOCK(rqp);
SMBERROR("duplicate response %d (ignored)\n", mid);
break;
}
}
SMBRQ_SUNLOCK(rqp);
smb_iod_rqprocessed(rqp, 0);
break;
}
SMB_IOD_RQUNLOCK(iod);
if (rqp == NULL) {
SMBERROR("drop resp with mid %d\n", (u_int)mid);
/* smb_printrqlist(vcp);*/
m_freem(m);
}
}
/*
* check for interrupts
*/
SMB_IOD_RQLOCK(iod);
TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
if (smb_td_intr(rqp->sr_cred->scr_td)) {
smb_iod_rqprocessed(rqp, EINTR);
}
}
SMB_IOD_RQUNLOCK(iod);
return 0;
}
int
smb_iod_request(struct smbiod *iod, int event, void *ident)
{
struct smbiod_event *evp;
int error;
SMBIODEBUG("\n");
evp = smb_zmalloc(sizeof(*evp), M_SMBIOD, M_WAITOK);
evp->ev_type = event;
evp->ev_ident = ident;
SMB_IOD_EVLOCK(iod);
STAILQ_INSERT_TAIL(&iod->iod_evlist, evp, ev_link);
if ((event & SMBIOD_EV_SYNC) == 0) {
SMB_IOD_EVUNLOCK(iod);
smb_iod_wakeup(iod);
return 0;
}
smb_iod_wakeup(iod);
msleep(evp, SMB_IOD_EVLOCKPTR(iod), PWAIT | PDROP, "90evw", 0);
error = evp->ev_error;
free(evp, M_SMBIOD);
return error;
}
/*
* Place request in the queue.
* Request from smbiod have a high priority.
*/
int
smb_iod_addrq(struct smb_rq *rqp)
{
struct smb_vc *vcp = rqp->sr_vc;
struct smbiod *iod = vcp->vc_iod;
int error;
SMBIODEBUG("\n");
if (rqp->sr_cred->scr_td != NULL &&
rqp->sr_cred->scr_td->td_proc == iod->iod_p) {
rqp->sr_flags |= SMBR_INTERNAL;
SMB_IOD_RQLOCK(iod);
TAILQ_INSERT_HEAD(&iod->iod_rqlist, rqp, sr_link);
SMB_IOD_RQUNLOCK(iod);
for (;;) {
if (smb_iod_sendrq(iod, rqp) != 0) {
smb_iod_dead(iod);
break;
}
/*
* we don't need to lock state field here
*/
if (rqp->sr_state != SMBRQ_NOTSENT)
break;
tsleep(&iod->iod_flags, PWAIT, "90sndw", hz);
}
if (rqp->sr_lerror)
smb_iod_removerq(rqp);
return rqp->sr_lerror;
}
switch (iod->iod_state) {
case SMBIOD_ST_NOTCONN:
return ENOTCONN;
case SMBIOD_ST_DEAD:
error = smb_iod_request(vcp->vc_iod, SMBIOD_EV_CONNECT | SMBIOD_EV_SYNC, NULL);
if (error)
return error;
return EXDEV;
default:
break;
}
SMB_IOD_RQLOCK(iod);
for (;;) {
if (vcp->vc_maxmux == 0) {
SMBERROR("maxmux == 0\n");
break;
}
if (iod->iod_muxcnt < vcp->vc_maxmux)
break;
iod->iod_muxwant++;
msleep(&iod->iod_muxwant, SMB_IOD_RQLOCKPTR(iod),
PWAIT, "90mux", 0);
}
iod->iod_muxcnt++;
TAILQ_INSERT_TAIL(&iod->iod_rqlist, rqp, sr_link);
SMB_IOD_RQUNLOCK(iod);
smb_iod_wakeup(iod);
return 0;
}
int
smb_iod_removerq(struct smb_rq *rqp)
{
struct smb_vc *vcp = rqp->sr_vc;
struct smbiod *iod = vcp->vc_iod;
SMBIODEBUG("\n");
if (rqp->sr_flags & SMBR_INTERNAL) {
SMB_IOD_RQLOCK(iod);
TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
SMB_IOD_RQUNLOCK(iod);
return 0;
}
SMB_IOD_RQLOCK(iod);
while (rqp->sr_flags & SMBR_XLOCK) {
rqp->sr_flags |= SMBR_XLOCKWANT;
msleep(rqp, SMB_IOD_RQLOCKPTR(iod), PWAIT, "90xrm", 0);
}
TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
iod->iod_muxcnt--;
if (iod->iod_muxwant) {
iod->iod_muxwant--;
wakeup(&iod->iod_muxwant);
}
SMB_IOD_RQUNLOCK(iod);
return 0;
}
int
smb_iod_waitrq(struct smb_rq *rqp)
{
struct smbiod *iod = rqp->sr_vc->vc_iod;
int error;
SMBIODEBUG("\n");
if (rqp->sr_flags & SMBR_INTERNAL) {
for (;;) {
smb_iod_sendall(iod);
smb_iod_recvall(iod);
if (rqp->sr_rpgen != rqp->sr_rplast)
break;
tsleep(&iod->iod_flags, PWAIT, "90irq", hz);
}
smb_iod_removerq(rqp);
return rqp->sr_lerror;
}
SMBRQ_SLOCK(rqp);
if (rqp->sr_rpgen == rqp->sr_rplast)
msleep(&rqp->sr_state, SMBRQ_SLOCKPTR(rqp), PWAIT, "90wrq", 0);
rqp->sr_rplast++;
SMBRQ_SUNLOCK(rqp);
error = rqp->sr_lerror;
if (rqp->sr_flags & SMBR_MULTIPACKET) {
/*
* If request should stay in the list, then reinsert it
* at the end of queue so other waiters have chance to concur
*/
SMB_IOD_RQLOCK(iod);
TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
TAILQ_INSERT_TAIL(&iod->iod_rqlist, rqp, sr_link);
SMB_IOD_RQUNLOCK(iod);
} else
smb_iod_removerq(rqp);
return error;
}
static int
smb_iod_sendall(struct smbiod *iod)
{
struct smb_vc *vcp = iod->iod_vc;
struct smb_rq *rqp;
struct timespec ts, tstimeout;
int herror;
herror = 0;
/*
* Loop through the list of requests and send them if possible
*/
SMB_IOD_RQLOCK(iod);
TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
switch (rqp->sr_state) {
case SMBRQ_NOTSENT:
rqp->sr_flags |= SMBR_XLOCK;
SMB_IOD_RQUNLOCK(iod);
herror = smb_iod_sendrq(iod, rqp);
SMB_IOD_RQLOCK(iod);
rqp->sr_flags &= ~SMBR_XLOCK;
if (rqp->sr_flags & SMBR_XLOCKWANT) {
rqp->sr_flags &= ~SMBR_XLOCKWANT;
wakeup(rqp);
}
break;
case SMBRQ_SENT:
SMB_TRAN_GETPARAM(vcp, SMBTP_TIMEOUT, &tstimeout);
timespecadd(&tstimeout, &tstimeout);
getnanotime(&ts);
timespecsub(&ts, &tstimeout);
if (timespeccmp(&ts, &rqp->sr_timesent, >)) {
smb_iod_rqprocessed(rqp, ETIMEDOUT);
}
break;
default:
break;
}
if (herror)
break;
}
SMB_IOD_RQUNLOCK(iod);
if (herror == ENOTCONN)
smb_iod_dead(iod);
return 0;
}
/*
* "main" function for smbiod daemon
*/
static __inline void
smb_iod_main(struct smbiod *iod)
{
/* struct smb_vc *vcp = iod->iod_vc;*/
struct smbiod_event *evp;
/* struct timespec tsnow;*/
int error;
SMBIODEBUG("\n");
error = 0;
/*
* Check all interesting events
*/
for (;;) {
SMB_IOD_EVLOCK(iod);
evp = STAILQ_FIRST(&iod->iod_evlist);
if (evp == NULL) {
SMB_IOD_EVUNLOCK(iod);
break;
}
STAILQ_REMOVE_HEAD(&iod->iod_evlist, ev_link);
evp->ev_type |= SMBIOD_EV_PROCESSING;
SMB_IOD_EVUNLOCK(iod);
switch (evp->ev_type & SMBIOD_EV_MASK) {
case SMBIOD_EV_CONNECT:
iod->iod_state = SMBIOD_ST_RECONNECT;
evp->ev_error = smb_iod_connect(iod);
break;
case SMBIOD_EV_DISCONNECT:
evp->ev_error = smb_iod_disconnect(iod);
break;
case SMBIOD_EV_TREECONNECT:
evp->ev_error = smb_iod_treeconnect(iod, evp->ev_ident);
break;
case SMBIOD_EV_SHUTDOWN:
iod->iod_flags |= SMBIOD_SHUTDOWN;
break;
case SMBIOD_EV_NEWRQ:
break;
}
if (evp->ev_type & SMBIOD_EV_SYNC) {
SMB_IOD_EVLOCK(iod);
wakeup(evp);
SMB_IOD_EVUNLOCK(iod);
} else
free(evp, M_SMBIOD);
}
#if 0
if (iod->iod_state == SMBIOD_ST_VCACTIVE) {
getnanotime(&tsnow);
timespecsub(&tsnow, &iod->iod_pingtimo);
if (timespeccmp(&tsnow, &iod->iod_lastrqsent, >)) {
smb_smb_echo(vcp, &iod->iod_scred);
}
}
#endif
smb_iod_sendall(iod);
smb_iod_recvall(iod);
return;
}
void
smb_iod_thread(void *arg)
{
struct smbiod *iod = arg;
mtx_lock(&Giant);
/*
* Here we assume that the thread structure will be the same
* for an entire kthread (kproc, to be more precise) life.
*/
iod->iod_td = curthread;
smb_makescred(&iod->iod_scred, iod->iod_td, NULL);
while ((iod->iod_flags & SMBIOD_SHUTDOWN) == 0) {
smb_iod_main(iod);
SMBIODEBUG("going to sleep for %d ticks\n", iod->iod_sleeptimo);
if (iod->iod_flags & SMBIOD_SHUTDOWN)
break;
tsleep(&iod->iod_flags, PWAIT, "90idle", iod->iod_sleeptimo);
}
mtx_unlock(&Giant);
kproc_exit(0);
}
int
smb_iod_create(struct smb_vc *vcp)
{
struct smbiod *iod;
int error;
iod = smb_zmalloc(sizeof(*iod), M_SMBIOD, M_WAITOK);
iod->iod_id = smb_iod_next++;
iod->iod_state = SMBIOD_ST_NOTCONN;
iod->iod_vc = vcp;
iod->iod_sleeptimo = hz * SMBIOD_SLEEP_TIMO;
iod->iod_pingtimo.tv_sec = SMBIOD_PING_TIMO;
getnanotime(&iod->iod_lastrqsent);
vcp->vc_iod = iod;
smb_sl_init(&iod->iod_rqlock, "90rql");
TAILQ_INIT(&iod->iod_rqlist);
smb_sl_init(&iod->iod_evlock, "90evl");
STAILQ_INIT(&iod->iod_evlist);
error = kproc_create(smb_iod_thread, iod, &iod->iod_p,
RFNOWAIT, 0, "smbiod%d", iod->iod_id);
if (error) {
SMBERROR("can't start smbiod: %d", error);
free(iod, M_SMBIOD);
return error;
}
return 0;
}
int
smb_iod_destroy(struct smbiod *iod)
{
smb_iod_request(iod, SMBIOD_EV_SHUTDOWN | SMBIOD_EV_SYNC, NULL);
smb_sl_destroy(&iod->iod_rqlock);
smb_sl_destroy(&iod->iod_evlock);
free(iod, M_SMBIOD);
return 0;
}
int
smb_iod_init(void)
{
return 0;
}
int
smb_iod_done(void)
{
return 0;
}