void client_destroy(client_t *cli) { rpc_common_destroy(cli->comm); buf_destroy(cli->buf_recv); buf_destroy(cli->buf_send); free(cli); LOG_DEBUG("a client destroyed"); }
static void vndiodone(struct buf *bp) { struct vndxfer *vnx = VND_BUFTOXFER(bp); struct vnd_softc *vnd = vnx->vx_vnd; struct buf *obp = bp->b_private; int s = splbio(); KASSERT(&vnx->vx_buf == bp); KASSERT(vnd->sc_active > 0); #ifdef DEBUG if (vnddebug & VDB_IO) { printf("vndiodone1: bp %p iodone: error %d\n", bp, bp->b_error); } #endif disk_unbusy(&vnd->sc_dkdev, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ)); vnd->sc_active--; if (vnd->sc_active == 0) { wakeup(&vnd->sc_tab); } splx(s); obp->b_error = bp->b_error; obp->b_resid = bp->b_resid; buf_destroy(bp); VND_PUTXFER(vnd, vnx); biodone(obp); }
static void cbufpool_dtor(void *arg, void *obj) { struct cbuf *cbp = obj; buf_destroy(&cbp->cb_buf); }
/* sanitize given string and replace all invalid UTF-8 sequences with "?" */ char * utf8(const char *s, unsigned int l) { struct template_buffer *buf = buf_init(l); unsigned char *ptr = (unsigned char *)s; unsigned int v, o; if (!buf) return NULL; for (o = 0; o < l; o++) { /* ascii char */ if ((*ptr >= 0x01) && (*ptr <= 0x7F)) { if (!buf_putchar(buf, (char)*ptr++)) break; } /* invalid byte or multi byte sequence */ else { if (!(v = _validate_utf8(&ptr, l - o, buf))) break; o += (v - 1); } } return buf_destroy(buf); }
static void test_teardown(void) { buf_destroy(&buf); response_destroy(&rsp); request_destroy(&req); }
char * striptags(const char *s, unsigned int l) { struct template_buffer *buf = buf_init(l); unsigned char *ptr = (unsigned char *)s; unsigned char *end = ptr + l; unsigned char *tag; unsigned char prev; char esq[8]; int esl; for (prev = ' '; ptr < end; ptr++) { if ((*ptr == '<') && ((ptr + 2) < end) && ((*(ptr + 1) == '/') || isalpha(*(ptr + 1)))) { for (tag = ptr; tag < end; tag++) { if (*tag == '>') { if (!isspace(prev)) buf_putchar(buf, ' '); ptr = tag; prev = ' '; break; } } } else if (isspace(*ptr)) { if (!isspace(prev)) buf_putchar(buf, *ptr); prev = *ptr; } else { switch(*ptr) { case '"': case '\'': case '<': case '>': case '&': esl = snprintf(esq, sizeof(esq), "&#%i;", *ptr); buf_append(buf, esq, esl); break; default: buf_putchar(buf, *ptr); break; } prev = *ptr; } } return buf_destroy(buf); }
/*---------------------------------------------------------------------------*/ void output_close(struct thread_ctx_s *ctx) { bool running; LOG_INFO("[%p] close media renderer", ctx); LOCK_O; running = ctx->output_running; ctx->output_running = THREAD_KILLED; UNLOCK_O; // still a race condition if a stream just ended a bit before ... if (running) pthread_join(ctx->output_thread, NULL); output_free_icy(ctx); buf_destroy(ctx->outputbuf); if (ctx->encodebuf) buf_destroy(ctx->encodebuf); }
static void ilo_resource_destroy(struct pipe_screen *screen, struct pipe_resource *res) { if (res->target == PIPE_BUFFER) buf_destroy(ilo_buffer(res)); else tex_destroy(ilo_texture(res)); }
/* Sanitize given string and strip all invalid XML bytes * Validate UTF-8 sequences * Escape XML control chars */ char * pcdata(const char *s, unsigned int l) { struct template_buffer *buf = buf_init(l); unsigned char *ptr = (unsigned char *)s; unsigned int o, v; char esq[8]; int esl; if (!buf) return NULL; for (o = 0; o < l; o++) { /* Invalid XML bytes */ if (((*ptr >= 0x00) && (*ptr <= 0x08)) || ((*ptr >= 0x0B) && (*ptr <= 0x0C)) || ((*ptr >= 0x0E) && (*ptr <= 0x1F)) || (*ptr == 0x7F)) { ptr++; } /* Escapes */ else if ((*ptr == 0x26) || (*ptr == 0x27) || (*ptr == 0x22) || (*ptr == 0x3C) || (*ptr == 0x3E)) { esl = snprintf(esq, sizeof(esq), "&#%i;", *ptr); if (!buf_append(buf, esq, esl)) break; ptr++; } /* ascii char */ else if (*ptr <= 0x7F) { buf_putchar(buf, (char)*ptr++); } /* multi byte sequence */ else { if (!(v = _validate_utf8(&ptr, l - o, buf))) break; o += (v - 1); } } return buf_destroy(buf); }
static void si_free(struct scsi_ioctl *si) { int s; s = splbio(); LIST_REMOVE(si, si_list); splx(s); buf_destroy(&si->si_bp); free(si, M_TEMP); }
// main function //////////////////////////////////////////////////////////////////////////////// int main(int argc, char *argv[]) { // Description // The main function serves as a wrapper that calls the test functions. // // Returns // main returns 0 on successful completion or -1 in case of failure. // variable declaration app_init(); buf_init(); test_buf_put_buf_get(); buf_destroy(); return 0; }
// main function //////////////////////////////////////////////////////////////////////////////// int main(int argc, char *argv[]) { // Description // The main function serves as a wrapper for the functions that implement // the program features. // // Returns // main returns 0 on successful completion or -1 in case of failure. // variable declaration app_init(); buf_init(); getter(); buf_destroy(); return 0; }
int main(int argc, char * argv[]) { buf_init(80); //printf("buf_init returns: %d\n", buf_init(3)); char buf; /* arxi empeirou kodika */ while( 1337 + 1337) { buf_get(&buf); //printf("We got : %c\n", buf); if ( buf == 'q' ) { //printf("\n Bye! :)\n"); break; } } /* telos empeirou kodika */ buf_destroy(); //printf("buf_destroy returns: %d\n", buf_destroy() ); return 0; }
unsigned int test_buf(void) { const char *testfunc = "buf"; unsigned int fails = 0, i; buf_t buf; /* Initialize it */ if (!buf_init(&buf)) { TEST_FAIL("buf_init failed"); fails++; return (1); } buf_lock(&buf); /* Empty it, while already empty */ buf_empty(&buf); if (buf_cur(&buf) != 0) { TEST_FAIL("buf_empty() did not empty while empty"); fails++; } /* The number of bytes left should be the full size */ if (buf_max(&buf) != (buf_left(&buf)+1)) { TEST_FAIL("max != left of an empty buffer"); fails++; } /* Put something in there */ if (!buf_put(&buf, "01234567879012345")) { TEST_FAIL("Could not do a buf_put() odd"); fails++; } /* Check the length */ if ((buf_cur(&buf)) == 16) { TEST_FAIL("Added something but it did not match (cur)"); fails++; } /* Check the length */ if ((buf_max(&buf) - buf_left(&buf)) == 16) { TEST_FAIL("Added something but it did not match (max-left)"); fails++; } /* Shift only a little bit */ buf_shift(&buf, 5); if ((buf_cur(&buf)) == 11) { TEST_FAIL("Shifted some but not enough"); fails++; } /* Shift the rest */ buf_shift(&buf, buf_cur(&buf)); if ((buf_cur(&buf)) != 0) { TEST_FAIL("Tried to shift the rest, but failed"); fails++; } /* Put a lot of junk in there */ for (i = 0; buf_left(&buf) >= 17; i++) { if (!buf_put(&buf, "01234567879012345")) { TEST_FAIL("Could not buf_put() while it should (B)"); fails++; break; } } /* Empty it completely */ buf_empty(&buf); /* Check the length */ if ((buf_cur(&buf)) != 0) { TEST_FAIL("Should have been empty"); fails++; } /* Add a bit */ buf_added(&buf, 100); /* Check the length */ if ((buf_cur(&buf)) != 100) { TEST_FAIL("Should have been 100"); fails++; } /* This calls and thus exercises buf_vprintf() too */ if (!buf_printf(&buf, "%s::%u", "12345", 67890)) { TEST_FAIL("buf_printf() failed"); fails++; } /* Check the length */ if ((buf_cur(&buf)) != 112) { TEST_FAIL("Should have been 112"); fails++; } /* Should always work to get a buffer */ if (buf_buffer(&buf) == NULL) { TEST_FAIL("Buffer did not exist!?"); fails++; } /* The end should always exist */ if (buf_bufend(&buf) == NULL) { TEST_FAIL("Buffer End did not exist!?"); fails++; } /* The end should always exist and be the begin when empty */ buf_empty(&buf); if (buf_bufend(&buf) != buf_bufend(&buf)) { TEST_FAIL("Buffer Begin != End when empty"); fails++; } buf_unlock(&buf); buf_destroy(&buf); return (fails); }
void sconn_destroy(sconn_t *sconn) { free(sconn->pjob); buf_destroy(sconn->buf_recv); buf_destroy(sconn->buf_send); }
void check_options (void) { int i; const char * m4 = NULL; if (lex_compat) { if (C_plus_plus) flexerror (_("Can't use -+ with -l option")); if (fulltbl || fullspd) flexerror (_("Can't use -f or -F with -l option")); if (reentrant || bison_bridge_lval) flexerror (_ ("Can't use --reentrant or --bison-bridge with -l option")); yytext_is_array = true; do_yylineno = true; use_read = false; } #if 0 /* This makes no sense whatsoever. I'm removing it. */ if (do_yylineno) /* This should really be "maintain_backup_tables = true" */ reject_really_used = true; #endif if (csize == unspecified) { if ((fulltbl || fullspd) && !useecs) csize = DEFAULT_CSIZE; else csize = CSIZE; } if (interactive == unspecified) { if (fulltbl || fullspd) interactive = false; else interactive = true; } if (fulltbl || fullspd) { if (usemecs) flexerror (_ ("-Cf/-CF and -Cm don't make sense together")); if (interactive) flexerror (_("-Cf/-CF and -I are incompatible")); if (lex_compat) flexerror (_ ("-Cf/-CF are incompatible with lex-compatibility mode")); if (fulltbl && fullspd) flexerror (_ ("-Cf and -CF are mutually exclusive")); } if (C_plus_plus && fullspd) flexerror (_("Can't use -+ with -CF option")); if (C_plus_plus && yytext_is_array) { lwarn (_("%array incompatible with -+ option")); yytext_is_array = false; } if (C_plus_plus && (reentrant)) flexerror (_("Options -+ and --reentrant are mutually exclusive.")); if (C_plus_plus && bison_bridge_lval) flexerror (_("bison bridge not supported for the C++ scanner.")); if (useecs) { /* Set up doubly-linked equivalence classes. */ /* We loop all the way up to csize, since ecgroup[csize] is * the position used for NUL characters. */ ecgroup[1] = NIL; for (i = 2; i <= csize; ++i) { ecgroup[i] = i - 1; nextecm[i - 1] = i; } nextecm[csize] = NIL; } else { /* Put everything in its own equivalence class. */ for (i = 1; i <= csize; ++i) { ecgroup[i] = i; nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ } } if (extra_type) buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type); if (!use_stdout) { FILE *prev_stdout; if (!did_outfilename) { char *suffix; if (C_plus_plus) suffix = "cc"; else suffix = "c"; snprintf (outfile_path, sizeof(outfile_path), outfile_template, prefix, suffix); outfilename = outfile_path; } prev_stdout = freopen (outfilename, "w+", stdout); if (prev_stdout == NULL) lerr (_("could not create %s"), outfilename); outfile_created = 1; } /* Setup the filter chain. */ output_chain = filter_create_int(NULL, filter_tee_header, headerfilename); if ( !(m4 = getenv("M4"))) { char *slash; m4 = M4; if ((slash = strrchr(M4, '/')) != NULL) { m4 = slash+1; /* break up $PATH */ const char *path = getenv("PATH"); if (!path) { m4 = M4; } else { int m4_length = strlen(m4); do { size_t length = strlen(path); struct stat sbuf; const char *endOfDir = strchr(path, ':'); if (!endOfDir) endOfDir = path+length; { char *m4_path = calloc(endOfDir-path + 1 + m4_length + 1, 1); memcpy(m4_path, path, endOfDir-path); m4_path[endOfDir-path] = '/'; memcpy(m4_path + (endOfDir-path) + 1, m4, m4_length + 1); if (stat(m4_path, &sbuf) == 0 && (S_ISREG(sbuf.st_mode)) && sbuf.st_mode & S_IXUSR) { m4 = m4_path; break; } free(m4_path); } path = endOfDir+1; } while (path[0]); if (!path[0]) m4 = M4; } } } filter_create_ext(output_chain, m4, "-P", 0); filter_create_int(output_chain, filter_fix_linedirs, NULL); /* For debugging, only run the requested number of filters. */ if (preproc_level > 0) { filter_truncate(output_chain, preproc_level); filter_apply_chain(output_chain); } yyout = stdout; /* always generate the tablesverify flag. */ buf_m4_define (&m4defs_buf, "M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0"); if (tablesext) gentables = false; if (tablesverify) /* force generation of C tables. */ gentables = true; if (tablesext) { FILE *tablesout; struct yytbl_hdr hdr; char *pname = 0; size_t nbytes = 0; buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL); if (!tablesfilename) { nbytes = strlen (prefix) + strlen (tablesfile_template) + 2; tablesfilename = pname = calloc(nbytes, 1); snprintf (pname, nbytes, tablesfile_template, prefix); } if ((tablesout = fopen (tablesfilename, "w")) == NULL) lerr (_("could not create %s"), tablesfilename); free(pname); tablesfilename = 0; yytbl_writer_init (&tableswr, tablesout); nbytes = strlen (prefix) + strlen ("tables") + 2; tablesname = calloc(nbytes, 1); snprintf (tablesname, nbytes, "%stables", prefix); yytbl_hdr_init (&hdr, flex_version, tablesname); if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0) flexerror (_("could not write tables header")); } if (skelname && (skelfile = fopen (skelname, "r")) == NULL) lerr (_("can't open skeleton file %s"), skelname); if (reentrant) { buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL); if (yytext_is_array) buf_m4_define (&m4defs_buf, "M4_YY_TEXT_IS_ARRAY", NULL); } if ( bison_bridge_lval) buf_m4_define (&m4defs_buf, "M4_YY_BISON_LVAL", NULL); if ( bison_bridge_lloc) buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL); if (strchr(prefix, '[') || strchr(prefix, ']')) flexerror(_("Prefix cannot include '[' or ']'")); buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix); if (did_outfilename) line_directive_out (stdout, 0); if (do_yylineno) buf_m4_define (&m4defs_buf, "M4_YY_USE_LINENO", NULL); /* Create the alignment type. */ buf_strdefine (&userdef_buf, "YY_INT_ALIGNED", long_align ? "long int" : "short int"); /* Define the start condition macros. */ { struct Buf tmpbuf; buf_init(&tmpbuf, sizeof(char)); for (i = 1; i <= lastsc; i++) { char *str, *fmt = "#define %s %d\n"; size_t strsz; strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2; str = malloc(strsz); if (!str) flexfatal(_("allocation of macro definition failed")); snprintf(str, strsz, fmt, scname[i], i - 1); buf_strappend(&tmpbuf, str); free(str); } buf_m4_define(&m4defs_buf, "M4_YY_SC_DEFS", tmpbuf.elts); buf_destroy(&tmpbuf); } /* This is where we begin writing to the file. */ /* Dump the %top code. */ if( top_buf.elts) outn((char*) top_buf.elts); /* Dump the m4 definitions. */ buf_print_strings(&m4defs_buf, stdout); m4defs_buf.nelts = 0; /* memory leak here. */ /* Place a bogus line directive, it will be fixed in the filter. */ if (gen_line_dirs) outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n"); /* Dump the user defined preproc directives. */ if (userdef_buf.elts) outn ((char *) (userdef_buf.elts)); skelout (); /* %% [1.0] */ }
static int ld_ataraid_start_span(struct ld_softc *ld, struct buf *bp) { struct ld_ataraid_softc *sc = (void *) ld; struct ataraid_array_info *aai = sc->sc_aai; struct ataraid_disk_info *adi; SIMPLEQ_HEAD(, cbuf) cbufq; struct cbuf *cbp; char *addr; daddr_t bn; long bcount, rcount; u_int comp; /* Allocate component buffers. */ SIMPLEQ_INIT(&cbufq); addr = bp->b_data; /* Find the first component. */ comp = 0; adi = &aai->aai_disks[comp]; bn = bp->b_rawblkno; while (bn >= adi->adi_compsize) { bn -= adi->adi_compsize; adi = &aai->aai_disks[++comp]; } bp->b_resid = bp->b_bcount; for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) { rcount = bp->b_bcount; if ((adi->adi_compsize - bn) < btodb(rcount)) rcount = dbtob(adi->adi_compsize - bn); cbp = ld_ataraid_make_cbuf(sc, bp, comp, bn, addr, rcount); if (cbp == NULL) { /* Free the already allocated component buffers. */ while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); buf_destroy(&cbp->cb_buf); CBUF_PUT(cbp); } return (EAGAIN); } /* * For a span, we always know we advance to the next disk, * and always start at offset 0 on that disk. */ adi = &aai->aai_disks[++comp]; bn = 0; SIMPLEQ_INSERT_TAIL(&cbufq, cbp, cb_q); addr += rcount; } /* Now fire off the requests. */ while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); if ((cbp->cb_buf.b_flags & B_READ) == 0) { mutex_enter(&cbp->cb_buf.b_vp->v_interlock); cbp->cb_buf.b_vp->v_numoutput++; mutex_exit(&cbp->cb_buf.b_vp->v_interlock); } VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf); } return (0); }
static int ld_ataraid_start_raid0(struct ld_softc *ld, struct buf *bp) { struct ld_ataraid_softc *sc = (void *) ld; struct ataraid_array_info *aai = sc->sc_aai; struct ataraid_disk_info *adi; SIMPLEQ_HEAD(, cbuf) cbufq; struct cbuf *cbp, *other_cbp; char *addr; daddr_t bn, cbn, tbn, off; long bcount, rcount; u_int comp; const int read = bp->b_flags & B_READ; const int mirror = aai->aai_level & AAI_L_RAID1; int error; /* Allocate component buffers. */ SIMPLEQ_INIT(&cbufq); addr = bp->b_data; bn = bp->b_rawblkno; bp->b_resid = bp->b_bcount; for (bcount = bp->b_bcount; bcount > 0; bcount -= rcount) { tbn = bn / aai->aai_interleave; off = bn % aai->aai_interleave; if (__predict_false(tbn == aai->aai_capacity / aai->aai_interleave)) { /* Last stripe. */ daddr_t sz = (aai->aai_capacity - (tbn * aai->aai_interleave)) / aai->aai_width; comp = off / sz; cbn = ((tbn / aai->aai_width) * aai->aai_interleave) + (off % sz); rcount = min(bcount, dbtob(sz)); } else { comp = tbn % aai->aai_width; cbn = ((tbn / aai->aai_width) * aai->aai_interleave) + off; rcount = min(bcount, dbtob(aai->aai_interleave - off)); } /* * See if a component is valid. */ try_mirror: adi = &aai->aai_disks[comp]; if ((adi->adi_status & ADI_S_ONLINE) == 0) { if (mirror && comp < aai->aai_width) { comp += aai->aai_width; goto try_mirror; } /* * No component available. */ error = EIO; goto free_and_exit; } cbp = ld_ataraid_make_cbuf(sc, bp, comp, cbn, addr, rcount); if (cbp == NULL) { resource_shortage: error = EAGAIN; free_and_exit: /* Free the already allocated component buffers. */ while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); buf_destroy(&cbp->cb_buf); CBUF_PUT(cbp); } return (error); } SIMPLEQ_INSERT_TAIL(&cbufq, cbp, cb_q); if (mirror && !read && comp < aai->aai_width) { comp += aai->aai_width; adi = &aai->aai_disks[comp]; if (adi->adi_status & ADI_S_ONLINE) { other_cbp = ld_ataraid_make_cbuf(sc, bp, comp, cbn, addr, rcount); if (other_cbp == NULL) goto resource_shortage; SIMPLEQ_INSERT_TAIL(&cbufq, other_cbp, cb_q); other_cbp->cb_other = cbp; cbp->cb_other = other_cbp; } } bn += btodb(rcount); addr += rcount; } /* Now fire off the requests. */ while ((cbp = SIMPLEQ_FIRST(&cbufq)) != NULL) { SIMPLEQ_REMOVE_HEAD(&cbufq, cb_q); if ((cbp->cb_buf.b_flags & B_READ) == 0) { mutex_enter(&cbp->cb_buf.b_vp->v_interlock); cbp->cb_buf.b_vp->v_numoutput++; mutex_exit(&cbp->cb_buf.b_vp->v_interlock); } VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf); } return (0); }
/* * Called at interrupt time. Mark the component as done and if all * components are done, take an "interrupt". */ static void ld_ataraid_iodone_raid0(struct buf *vbp) { struct cbuf *cbp = (struct cbuf *) vbp, *other_cbp; struct buf *bp = cbp->cb_obp; struct ld_ataraid_softc *sc = cbp->cb_sc; struct ataraid_array_info *aai = sc->sc_aai; struct ataraid_disk_info *adi; long count; int s, iodone; s = splbio(); iodone = cbp->cb_flags & CBUF_IODONE; other_cbp = cbp->cb_other; if (other_cbp != NULL) /* You are alone */ other_cbp->cb_other = NULL; if (cbp->cb_buf.b_error != 0) { /* * Mark this component broken. */ adi = &aai->aai_disks[cbp->cb_comp]; adi->adi_status &= ~ADI_S_ONLINE; printf("%s: error %d on component %d (%s)\n", device_xname(sc->sc_ld.sc_dv), bp->b_error, cbp->cb_comp, device_xname(adi->adi_dev)); /* * If we didn't see an error yet and we are reading * RAID1 disk, try another component. */ if (bp->b_error == 0 && (cbp->cb_buf.b_flags & B_READ) != 0 && (aai->aai_level & AAI_L_RAID1) != 0 && cbp->cb_comp < aai->aai_width) { cbp->cb_comp += aai->aai_width; adi = &aai->aai_disks[cbp->cb_comp]; if (adi->adi_status & ADI_S_ONLINE) { cbp->cb_buf.b_error = 0; VOP_STRATEGY(cbp->cb_buf.b_vp, &cbp->cb_buf); goto out; } } if (iodone || other_cbp != NULL) /* * If I/O on other component successfully done * or the I/O is still in progress, no need * to tell an error to upper layer. */ ; else { bp->b_error = cbp->cb_buf.b_error ? cbp->cb_buf.b_error : EIO; } /* XXX Update component config blocks. */ } else { /* * If other I/O is still in progress, tell it that * our I/O is successfully done. */ if (other_cbp != NULL) other_cbp->cb_flags |= CBUF_IODONE; } count = cbp->cb_buf.b_bcount; buf_destroy(&cbp->cb_buf); CBUF_PUT(cbp); if (other_cbp != NULL) goto out; /* If all done, "interrupt". */ bp->b_resid -= count; if (bp->b_resid < 0) panic("ld_ataraid_iodone_raid0: count"); if (bp->b_resid == 0) lddone(&sc->sc_ld, bp); out: splx(s); }
void PKT_end(PTInstVar pvar) { buf_destroy(&pvar->pkt_state.buf, &pvar->pkt_state.buflen); }