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