sys/netproto/smb/smb_iod.c

   1 /*
   2  * Copyright (c) 2000-2001 Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/netsmb/smb_iod.c,v 1.1.2.2 2002/04/23 03:45:01 bp Exp $
  33  * $DragonFly: src/sys/netproto/smb/smb_iod.c,v 1.15 2007/02/03 17:05:58 corecode Exp $
  34  */
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/proc.h>
  39 #include <sys/kernel.h>
  40 #include <sys/kthread.h>
  41 #include <sys/malloc.h>
  42 #include <sys/mbuf.h>
  43 #include <sys/unistd.h>
  44
  45 #include "smb.h"
  46 #include "smb_conn.h"
  47 #include "smb_rq.h"
  48 #include "smb_tran.h"
  49 #include "smb_trantcp.h"
  50
  51
  52 #define SMBIOD_SLEEP_TIMO       2
  53 #define SMBIOD_PING_TIMO        60      /* seconds */
  54
  55 #define SMB_IOD_EVLOCKPTR(iod)  (&(iod)->iod_evlock)
  56 #define SMB_IOD_EVLOCK(iod)     smb_sl_lock(&(iod)->iod_evlock)
  57 #define SMB_IOD_EVUNLOCK(iod)   smb_sl_unlock(&(iod)->iod_evlock)
  58 #define SMB_IOD_EVINTERLOCK(iod) (&(iod)->iod_evlock)
  59
  60 #define SMB_IOD_RQLOCKPTR(iod)  (&(iod)->iod_rqlock)
  61 #define SMB_IOD_RQLOCK(iod)     smb_sl_lock(&((iod)->iod_rqlock))
  62 #define SMB_IOD_RQUNLOCK(iod)   smb_sl_unlock(&(iod)->iod_rqlock)
  63 #define SMB_IOD_RQINTERLOCK(iod) (&(iod)->iod_rqlock)
  64
  65 #define smb_iod_wakeup(iod)     wakeup(&(iod)->iod_flags)
  66
  67
  68 static MALLOC_DEFINE(M_SMBIOD, "SMBIOD", "SMB network io daemon");
  69
  70 static int smb_iod_next;
  71
  72 static int  smb_iod_sendall(struct smbiod *iod);
  73 static int  smb_iod_disconnect(struct smbiod *iod);
  74 static void smb_iod_thread(void *);
  75
  76 static __inline void
  77 smb_iod_rqprocessed(struct smb_rq *rqp, int error)
  78 {
  79         SMBRQ_SLOCK(rqp);
  80         rqp->sr_lerror = error;
  81         rqp->sr_rpgen++;
  82         rqp->sr_state = SMBRQ_NOTIFIED;
  83         wakeup(&rqp->sr_state);
  84         SMBRQ_SUNLOCK(rqp);
  85 }
  86
  87 static void
  88 smb_iod_invrq(struct smbiod *iod)
  89 {
  90         struct smb_rq *rqp;
  91
  92         /*
  93          * Invalidate all outstanding requests for this connection
  94          */
  95         SMB_IOD_RQLOCK(iod);
  96         TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
  97 #if 0
  98                 /* this makes no sense whatsoever XXX */
  99                 if (rqp->sr_flags & SMBR_INTERNAL)
 100                         SMBRQ_SUNLOCK(rqp);
 101 #endif
 102                 rqp->sr_flags |= SMBR_RESTART;
 103                 smb_iod_rqprocessed(rqp, ENOTCONN);
 104         }
 105         SMB_IOD_RQUNLOCK(iod);
 106 }
 107
 108 static void
 109 smb_iod_closetran(struct smbiod *iod)
 110 {
 111         struct smb_vc *vcp = iod->iod_vc;
 112         struct thread *td = iod->iod_td;
 113
 114         if (vcp->vc_tdata == NULL)
 115                 return;
 116         SMB_TRAN_DISCONNECT(vcp, td);
 117         SMB_TRAN_DONE(vcp, td);
 118         vcp->vc_tdata = NULL;
 119 }
 120
 121 static void
 122 smb_iod_dead(struct smbiod *iod)
 123 {
 124         iod->iod_state = SMBIOD_ST_DEAD;
 125         smb_iod_closetran(iod);
 126         smb_iod_invrq(iod);
 127 }
 128
 129 static int
 130 smb_iod_connect(struct smbiod *iod)
 131 {
 132         struct smb_vc *vcp = iod->iod_vc;
 133         struct thread *td = iod->iod_td;
 134         int error;
 135
 136         SMBIODEBUG("%d\n", iod->iod_state);
 137         switch(iod->iod_state) {
 138             case SMBIOD_ST_VCACTIVE:
 139                 SMBERROR("called for already opened connection\n");
 140                 return EISCONN;
 141             case SMBIOD_ST_DEAD:
 142                 return ENOTCONN;        /* XXX: last error code ? */
 143             default:
 144                 break;
 145         }
 146         vcp->vc_genid++;
 147         error = 0;
 148         itry {
 149                 ithrow(SMB_TRAN_CREATE(vcp, td));
 150                 SMBIODEBUG("tcreate\n");
 151                 if (vcp->vc_laddr) {
 152                         ithrow(SMB_TRAN_BIND(vcp, vcp->vc_laddr, td));
 153                 }
 154                 SMBIODEBUG("tbind\n");
 155                 ithrow(SMB_TRAN_CONNECT(vcp, vcp->vc_paddr, td));
 156                 SMB_TRAN_SETPARAM(vcp, SMBTP_SELECTID, &iod->iod_flags);
 157                 iod->iod_state = SMBIOD_ST_TRANACTIVE;
 158                 SMBIODEBUG("tconnect\n");
 159 /*              vcp->vc_mid = 0;*/
 160                 ithrow(smb_smb_negotiate(vcp, &iod->iod_scred));
 161                 SMBIODEBUG("snegotiate\n");
 162                 ithrow(smb_smb_ssnsetup(vcp, &iod->iod_scred));
 163                 iod->iod_state = SMBIOD_ST_VCACTIVE;
 164                 SMBIODEBUG("completed\n");
 165                 smb_iod_invrq(iod);
 166         } icatch(error) {
 167                 smb_iod_dead(iod);
 168         } ifinally {
 169         } iendtry;
 170         return error;
 171 }
 172
 173 static int
 174 smb_iod_disconnect(struct smbiod *iod)
 175 {
 176         struct smb_vc *vcp = iod->iod_vc;
 177
 178         SMBIODEBUG("\n");
 179         if (iod->iod_state == SMBIOD_ST_VCACTIVE) {
 180                 smb_smb_ssnclose(vcp, &iod->iod_scred);
 181                 iod->iod_state = SMBIOD_ST_TRANACTIVE;
 182         }
 183         vcp->vc_smbuid = SMB_UID_UNKNOWN;
 184         smb_iod_closetran(iod);
 185         iod->iod_state = SMBIOD_ST_NOTCONN;
 186         return 0;
 187 }
 188
 189 static int
 190 smb_iod_treeconnect(struct smbiod *iod, struct smb_share *ssp)
 191 {
 192         int error;
 193
 194         if (iod->iod_state != SMBIOD_ST_VCACTIVE) {
 195                 if (iod->iod_state != SMBIOD_ST_DEAD)
 196                         return ENOTCONN;
 197                 iod->iod_state = SMBIOD_ST_RECONNECT;
 198                 error = smb_iod_connect(iod);
 199                 if (error)
 200                         return error;
 201         }
 202         SMBIODEBUG("tree reconnect\n");
 203         SMBS_ST_LOCK(ssp);
 204         ssp->ss_flags |= SMBS_RECONNECTING;
 205         SMBS_ST_UNLOCK(ssp);
 206         error = smb_smb_treeconnect(ssp, &iod->iod_scred);
 207         SMBS_ST_LOCK(ssp);
 208         ssp->ss_flags &= ~SMBS_RECONNECTING;
 209         SMBS_ST_UNLOCK(ssp);
 210         wakeup(&ssp->ss_vcgenid);
 211         return error;
 212 }
 213
 214 static int
 215 smb_iod_sendrq(struct smbiod *iod, struct smb_rq *rqp)
 216 {
 217         struct thread *td = iod->iod_td;
 218         struct smb_vc *vcp = iod->iod_vc;
 219         struct smb_share *ssp = rqp->sr_share;
 220         struct mbuf *m;
 221         int error;
 222
 223         SMBIODEBUG("iod_state = %d\n", iod->iod_state);
 224         switch (iod->iod_state) {
 225             case SMBIOD_ST_NOTCONN:
 226                 smb_iod_rqprocessed(rqp, ENOTCONN);
 227                 return 0;
 228             case SMBIOD_ST_DEAD:
 229                 iod->iod_state = SMBIOD_ST_RECONNECT;
 230                 return 0;
 231             case SMBIOD_ST_RECONNECT:
 232                 return 0;
 233             default:
 234                 break;
 235         }
 236         if (rqp->sr_sendcnt == 0) {
 237 #ifdef movedtoanotherplace
 238                 if (vcp->vc_maxmux != 0 && iod->iod_muxcnt >= vcp->vc_maxmux)
 239                         return 0;
 240 #endif
 241                 *rqp->sr_rqtid = htoles(ssp ? ssp->ss_tid : SMB_TID_UNKNOWN);
 242                 *rqp->sr_rquid = htoles(vcp ? vcp->vc_smbuid : 0);
 243                 mb_fixhdr(&rqp->sr_rq);
 244         }
 245         if (rqp->sr_sendcnt++ > 5) {
 246                 rqp->sr_flags |= SMBR_RESTART;
 247                 smb_iod_rqprocessed(rqp, rqp->sr_lerror);
 248                 /*
 249                  * If all attempts to send a request failed, then
 250                  * something is seriously hosed.
 251                  */
 252                 return ENOTCONN;
 253         }
 254         SMBSDEBUG("M:%04x, P:%04x, U:%04x, T:%04x\n", rqp->sr_mid, 0, 0, 0);
 255         m_dumpm(rqp->sr_rq.mb_top);
 256         m = m_copym(rqp->sr_rq.mb_top, 0, M_COPYALL, MB_WAIT);
 257         error = rqp->sr_lerror = m ? SMB_TRAN_SEND(vcp, m, td) : ENOBUFS;
 258         if (error == 0) {
 259                 getnanotime(&rqp->sr_timesent);
 260                 iod->iod_lastrqsent = rqp->sr_timesent;
 261                 rqp->sr_flags |= SMBR_SENT;
 262                 rqp->sr_state = SMBRQ_SENT;
 263                 return 0;
 264         }
 265         /*
 266          * Check for fatal errors
 267          */
 268         if (SMB_TRAN_FATAL(vcp, error)) {
 269                 /*
 270                  * No further attempts should be made
 271                  */
 272                 return ENOTCONN;
 273         }
 274         if (smb_rq_intr(rqp))
 275                 smb_iod_rqprocessed(rqp, EINTR);
 276         return 0;
 277 }
 278
 279 /*
 280  * Process incoming packets
 281  */
 282 static int
 283 smb_iod_recvall(struct smbiod *iod)
 284 {
 285         struct smb_vc *vcp = iod->iod_vc;
 286         struct thread *td = iod->iod_td;
 287         struct smb_rq *rqp;
 288         struct mbuf *m;
 289         u_char *hp;
 290         u_short mid;
 291         int error;
 292
 293         switch (iod->iod_state) {
 294             case SMBIOD_ST_NOTCONN:
 295             case SMBIOD_ST_DEAD:
 296             case SMBIOD_ST_RECONNECT:
 297                 return 0;
 298             default:
 299                 break;
 300         }
 301         for (;;) {
 302                 m = NULL;
 303                 error = SMB_TRAN_RECV(vcp, &m, td);
 304                 if (error == EWOULDBLOCK)
 305                         break;
 306                 if (SMB_TRAN_FATAL(vcp, error)) {
 307                         smb_iod_dead(iod);
 308                         break;
 309                 }
 310                 if (error)
 311                         break;
 312                 if (m == NULL) {
 313                         SMBERROR("tran return NULL without error\n");
 314                         error = EPIPE;
 315                         continue;
 316                 }
 317                 m = m_pullup(m, SMB_HDRLEN);
 318                 if (m == NULL)
 319                         continue;       /* wait for a good packet */
 320                 /*
 321                  * Now we got an entire and possibly invalid SMB packet.
 322                  * Be careful while parsing it.
 323                  */
 324                 m_dumpm(m);
 325                 hp = mtod(m, u_char*);
 326                 if (bcmp(hp, SMB_SIGNATURE, SMB_SIGLEN) != 0) {
 327                         m_freem(m);
 328                         continue;
 329                 }
 330                 mid = SMB_HDRMID(hp);
 331                 SMBSDEBUG("mid %04x\n", (u_int)mid);
 332                 SMB_IOD_RQLOCK(iod);
 333                 TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
 334                         if (rqp->sr_mid != mid)
 335                                 continue;
 336                         SMBRQ_SLOCK(rqp);
 337                         if (rqp->sr_rp.md_top == NULL) {
 338                                 md_initm(&rqp->sr_rp, m);
 339                         } else {
 340                                 if (rqp->sr_flags & SMBR_MULTIPACKET) {
 341                                         md_append_record(&rqp->sr_rp, m);
 342                                 } else {
 343                                         SMBRQ_SUNLOCK(rqp);
 344                                         SMBERROR("duplicate response %d (ignored)\n", mid);
 345                                         break;
 346                                 }
 347                         }
 348                         SMBRQ_SUNLOCK(rqp);
 349                         smb_iod_rqprocessed(rqp, 0);
 350                         break;
 351                 }
 352                 SMB_IOD_RQUNLOCK(iod);
 353                 if (rqp == NULL) {
 354                         SMBERROR("drop resp with mid %d\n", (u_int)mid);
 355 /*                      smb_printrqlist(vcp);*/
 356                         m_freem(m);
 357                 }
 358         }
 359         /*
 360          * check for interrupts
 361          */
 362         SMB_IOD_RQLOCK(iod);
 363         TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
 364                 if (smb_proc_intr(rqp->sr_cred->scr_td)) {
 365                         smb_iod_rqprocessed(rqp, EINTR);
 366                 }
 367         }
 368         SMB_IOD_RQUNLOCK(iod);
 369         return 0;
 370 }
 371
 372 int
 373 smb_iod_request(struct smbiod *iod, int event, void *ident)
 374 {
 375         struct smbiod_event *evp;
 376         int error;
 377
 378         SMBIODEBUG("\n");
 379         evp = smb_zmalloc(sizeof(*evp), M_SMBIOD, M_WAITOK);
 380         evp->ev_type = event;
 381         evp->ev_ident = ident;
 382         SMB_IOD_EVLOCK(iod);
 383         STAILQ_INSERT_TAIL(&iod->iod_evlist, evp, ev_link);
 384         if ((event & SMBIOD_EV_SYNC) == 0) {
 385                 SMB_IOD_EVUNLOCK(iod);
 386                 smb_iod_wakeup(iod);
 387                 return 0;
 388         }
 389         smb_iod_wakeup(iod);
 390         smb_sleep(evp, SMB_IOD_EVINTERLOCK(iod), PDROP, "90evw", 0);
 391         error = evp->ev_error;
 392         kfree(evp, M_SMBIOD);
 393         return error;
 394 }
 395
 396 /*
 397  * Place request in the queue.
 398  * Request from smbiod have a high priority.
 399  */
 400 int
 401 smb_iod_addrq(struct smb_rq *rqp)
 402 {
 403         struct smb_vc *vcp = rqp->sr_vc;
 404         struct smbiod *iod = vcp->vc_iod;
 405         int error;
 406
 407         SMBIODEBUG("\n");
 408         if (rqp->sr_cred->scr_td == iod->iod_td) {
 409                 rqp->sr_flags |= SMBR_INTERNAL;
 410                 SMB_IOD_RQLOCK(iod);
 411                 TAILQ_INSERT_HEAD(&iod->iod_rqlist, rqp, sr_link);
 412                 SMB_IOD_RQUNLOCK(iod);
 413                 for (;;) {
 414                         if (smb_iod_sendrq(iod, rqp) != 0) {
 415                                 smb_iod_dead(iod);
 416                                 break;
 417                         }
 418                         /*
 419                          * we don't need to lock state field here
 420                          */
 421                         if (rqp->sr_state != SMBRQ_NOTSENT)
 422                                 break;
 423                         tsleep(&iod->iod_flags, 0, "90sndw", hz);
 424                 }
 425                 if (rqp->sr_lerror)
 426                         smb_iod_removerq(rqp);
 427                 return rqp->sr_lerror;
 428         }
 429
 430         switch (iod->iod_state) {
 431             case SMBIOD_ST_NOTCONN:
 432                 return ENOTCONN;
 433             case SMBIOD_ST_DEAD:
 434                 error = smb_iod_request(vcp->vc_iod, SMBIOD_EV_CONNECT | SMBIOD_EV_SYNC, NULL);
 435                 if (error)
 436                         return error;
 437                 return EXDEV;
 438             default:
 439                 break;
 440         }
 441
 442         SMB_IOD_RQLOCK(iod);
 443         for (;;) {
 444                 if (vcp->vc_maxmux == 0) {
 445                         SMBERROR("maxmux == 0\n");
 446                         break;
 447                 }
 448                 if (iod->iod_muxcnt < vcp->vc_maxmux)
 449                         break;
 450                 iod->iod_muxwant++;
 451                 smb_sleep(&iod->iod_muxwant, SMB_IOD_RQINTERLOCK(iod), 0, "90mux", 0);
 452         }
 453         iod->iod_muxcnt++;
 454         TAILQ_INSERT_TAIL(&iod->iod_rqlist, rqp, sr_link);
 455         SMB_IOD_RQUNLOCK(iod);
 456         smb_iod_wakeup(iod);
 457         return 0;
 458 }
 459
 460 int
 461 smb_iod_removerq(struct smb_rq *rqp)
 462 {
 463         struct smb_vc *vcp = rqp->sr_vc;
 464         struct smbiod *iod = vcp->vc_iod;
 465
 466         SMBIODEBUG("\n");
 467         if (rqp->sr_flags & SMBR_INTERNAL) {
 468                 SMB_IOD_RQLOCK(iod);
 469                 TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
 470                 SMB_IOD_RQUNLOCK(iod);
 471                 return 0;
 472         }
 473         SMB_IOD_RQLOCK(iod);
 474         while (rqp->sr_flags & SMBR_XLOCK) {
 475                 rqp->sr_flags |= SMBR_XLOCKWANT;
 476                 smb_sleep(rqp, SMB_IOD_RQINTERLOCK(iod), 0, "90xrm", 0);
 477         }
 478         TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
 479         iod->iod_muxcnt--;
 480         if (iod->iod_muxwant) {
 481                 iod->iod_muxwant--;
 482                 wakeup(&iod->iod_muxwant);
 483         }
 484         SMB_IOD_RQUNLOCK(iod);
 485         return 0;
 486 }
 487
 488 int
 489 smb_iod_waitrq(struct smb_rq *rqp)
 490 {
 491         struct smbiod *iod = rqp->sr_vc->vc_iod;
 492         int error;
 493
 494         SMBIODEBUG("\n");
 495         if (rqp->sr_flags & SMBR_INTERNAL) {
 496                 for (;;) {
 497                         smb_iod_sendall(iod);
 498                         smb_iod_recvall(iod);
 499                         if (rqp->sr_rpgen != rqp->sr_rplast)
 500                                 break;
 501                         tsleep(&iod->iod_flags, 0, "90irq", hz);
 502                 }
 503                 smb_iod_removerq(rqp);
 504                 return rqp->sr_lerror;
 505
 506         }
 507         SMBRQ_SLOCK(rqp);
 508         if (rqp->sr_rpgen == rqp->sr_rplast)
 509                 smb_sleep(&rqp->sr_state, SMBRQ_INTERLOCK(rqp), 0, "90wrq", 0);
 510         rqp->sr_rplast++;
 511         SMBRQ_SUNLOCK(rqp);
 512         error = rqp->sr_lerror;
 513         if (rqp->sr_flags & SMBR_MULTIPACKET) {
 514                 /*
 515                  * If request should stay in the list, then reinsert it
 516                  * at the end of queue so other waiters have chance to concur
 517                  */
 518                 SMB_IOD_RQLOCK(iod);
 519                 TAILQ_REMOVE(&iod->iod_rqlist, rqp, sr_link);
 520                 TAILQ_INSERT_TAIL(&iod->iod_rqlist, rqp, sr_link);
 521                 SMB_IOD_RQUNLOCK(iod);
 522         } else
 523                 smb_iod_removerq(rqp);
 524         return error;
 525 }
 526
 527
 528 static int
 529 smb_iod_sendall(struct smbiod *iod)
 530 {
 531         struct smb_vc *vcp = iod->iod_vc;
 532         struct smb_rq *rqp;
 533         struct timespec ts, tstimeout;
 534         int herror;
 535
 536         herror = 0;
 537         /*
 538          * Loop through the list of requests and send them if possible
 539          */
 540         SMB_IOD_RQLOCK(iod);
 541         TAILQ_FOREACH(rqp, &iod->iod_rqlist, sr_link) {
 542                 switch (rqp->sr_state) {
 543                     case SMBRQ_NOTSENT:
 544                         rqp->sr_flags |= SMBR_XLOCK;
 545                         SMB_IOD_RQUNLOCK(iod);
 546                         herror = smb_iod_sendrq(iod, rqp);
 547                         SMB_IOD_RQLOCK(iod);
 548                         rqp->sr_flags &= ~SMBR_XLOCK;
 549                         if (rqp->sr_flags & SMBR_XLOCKWANT) {
 550                                 rqp->sr_flags &= ~SMBR_XLOCKWANT;
 551                                 wakeup(rqp);
 552                         }
 553                         break;
 554                     case SMBRQ_SENT:
 555                         SMB_TRAN_GETPARAM(vcp, SMBTP_TIMEOUT, &tstimeout);
 556                         timespecadd(&tstimeout, &tstimeout);
 557                         getnanotime(&ts);
 558                         timespecsub(&ts, &tstimeout);
 559                         if (timespeccmp(&ts, &rqp->sr_timesent, >)) {
 560                                 smb_iod_rqprocessed(rqp, ETIMEDOUT);
 561                         }
 562                         break;
 563                     default:
 564                         break;
 565                 }
 566                 if (herror)
 567                         break;
 568         }
 569         SMB_IOD_RQUNLOCK(iod);
 570         if (herror == ENOTCONN)
 571                 smb_iod_dead(iod);
 572         return 0;
 573 }
 574
 575 /*
 576  * "main" function for smbiod daemon
 577  */
 578 static __inline void
 579 smb_iod_main(struct smbiod *iod)
 580 {
 581 /*      struct smb_vc *vcp = iod->iod_vc;*/
 582         struct smbiod_event *evp;
 583 /*      struct timespec tsnow;*/
 584         int error;
 585
 586         SMBIODEBUG("\n");
 587         error = 0;
 588
 589         /*
 590          * Check all interesting events
 591          */
 592         for (;;) {
 593                 SMB_IOD_EVLOCK(iod);
 594                 evp = STAILQ_FIRST(&iod->iod_evlist);
 595                 if (evp == NULL) {
 596                         SMB_IOD_EVUNLOCK(iod);
 597                         break;
 598                 }
 599                 STAILQ_REMOVE_HEAD(&iod->iod_evlist, ev_link);
 600                 evp->ev_type |= SMBIOD_EV_PROCESSING;
 601                 SMB_IOD_EVUNLOCK(iod);
 602                 switch (evp->ev_type & SMBIOD_EV_MASK) {
 603                     case SMBIOD_EV_CONNECT:
 604                         iod->iod_state = SMBIOD_ST_RECONNECT;
 605                         evp->ev_error = smb_iod_connect(iod);
 606                         break;
 607                     case SMBIOD_EV_DISCONNECT:
 608                         evp->ev_error = smb_iod_disconnect(iod);
 609                         break;
 610                     case SMBIOD_EV_TREECONNECT:
 611                         evp->ev_error = smb_iod_treeconnect(iod, evp->ev_ident);
 612                         break;
 613                     case SMBIOD_EV_SHUTDOWN:
 614                         iod->iod_flags |= SMBIOD_SHUTDOWN;
 615                         break;
 616                     case SMBIOD_EV_NEWRQ:
 617                         break;
 618                 }
 619                 if (evp->ev_type & SMBIOD_EV_SYNC) {
 620                         SMB_IOD_EVLOCK(iod);
 621                         wakeup(evp);
 622                         SMB_IOD_EVUNLOCK(iod);
 623                 } else
 624                         kfree(evp, M_SMBIOD);
 625         }
 626 #if 0
 627         if (iod->iod_state == SMBIOD_ST_VCACTIVE) {
 628                 getnanotime(&tsnow);
 629                 timespecsub(&tsnow, &iod->iod_pingtimo);
 630                 if (timespeccmp(&tsnow, &iod->iod_lastrqsent, >)) {
 631                         smb_smb_echo(vcp, &iod->iod_scred);
 632                 }
 633         }
 634 #endif
 635         smb_iod_sendall(iod);
 636         smb_iod_recvall(iod);
 637         return;
 638 }
 639
 640 #define kthread_create_compat   kthread_create2
 641 #define kthread_exit_compat     kthread_exit2
 642
 643 void
 644 smb_iod_thread(void *arg)
 645 {
 646         struct smbiod *iod = arg;
 647
 648         smb_makescred(&iod->iod_scred, iod->iod_td, NULL);
 649         while ((iod->iod_flags & SMBIOD_SHUTDOWN) == 0) {
 650                 smb_iod_main(iod);
 651                 SMBIODEBUG("going to sleep for %d ticks\n", iod->iod_sleeptimo);
 652                 if (iod->iod_flags & SMBIOD_SHUTDOWN)
 653                         break;
 654                 tsleep(&iod->iod_flags, 0, "90idle", iod->iod_sleeptimo);
 655         }
 656         kthread_exit_compat();
 657 }
 658
 659 int
 660 smb_iod_create(struct smb_vc *vcp)
 661 {
 662         struct smbiod *iod;
 663         struct proc *newp = NULL;
 664         int error;
 665
 666         iod = smb_zmalloc(sizeof(*iod), M_SMBIOD, M_WAITOK);
 667         iod->iod_id = smb_iod_next++;
 668         iod->iod_state = SMBIOD_ST_NOTCONN;
 669         iod->iod_vc = vcp;
 670         iod->iod_sleeptimo = hz * SMBIOD_SLEEP_TIMO;
 671         iod->iod_pingtimo.tv_sec = SMBIOD_PING_TIMO;
 672         getnanotime(&iod->iod_lastrqsent);
 673         vcp->vc_iod = iod;
 674         smb_sl_init(&iod->iod_rqlock, "90rql");
 675         TAILQ_INIT(&iod->iod_rqlist);
 676         smb_sl_init(&iod->iod_evlock, "90evl");
 677         STAILQ_INIT(&iod->iod_evlist);
 678         error = kthread_create_compat(smb_iod_thread, iod, &newp,
 679             RFNOWAIT, "smbiod%d", iod->iod_id);
 680         if (error) {
 681                 SMBERROR("can't start smbiod: %d", error);
 682                 kfree(iod, M_SMBIOD);
 683                 return error;
 684         }
 685         /* XXX lwp */
 686         iod->iod_td = ONLY_LWP_IN_PROC(newp)->lwp_thread;
 687         return 0;
 688 }
 689
 690 int
 691 smb_iod_destroy(struct smbiod *iod)
 692 {
 693         smb_iod_request(iod, SMBIOD_EV_SHUTDOWN | SMBIOD_EV_SYNC, NULL);
 694         smb_sl_destroy(&iod->iod_rqlock);
 695         smb_sl_destroy(&iod->iod_evlock);
 696         kfree(iod, M_SMBIOD);
 697         return 0;
 698 }
 699
 700 int
 701 smb_iod_init(void)
 702 {
 703         return 0;
 704 }
 705
 706 int
 707 smb_iod_done(void)
 708 {
 709         return 0;
 710 }
 711