taglinefilesource code
memcpy77arch/alpha/boot/tools/build.cmemcpy(bootblock, "Linux Test", 10);
memcpy88arch/alpha/kernel/ksyms.cXNOVERS(memcpy),
memcpy201arch/alpha/kernel/process.cmemcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8);
memcpy159arch/alpha/lib/checksum.cmemcpy(dst, src, len);
memcpy173arch/i386/boot/compressed/misc.cmemcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
memcpy318arch/i386/kernel/process.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
memcpy346arch/i386/kernel/process.cmemcpy(fpu,&current->tss.i387.hard,sizeof(*fpu));
memcpy149arch/i386/kernel/setup.cmemcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
memcpy177arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_oem,8);
memcpy180arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_productid,12);
memcpy243arch/i386/kernel/smp.cmemcpy(str,m->mpc_bustype,6);
memcpy456arch/i386/kernel/smp.cmemcpy(mp,trampoline_data,sizeof(trampoline_data));
memcpy3927arch/m68k/amiga/amifb.cmemcpy(var->data, sprite->u.nonlaced.data, sizeof(var->data));
memcpy3937arch/m68k/amiga/amifb.cmemcpy(sprite->u.nonlaced.data, var->data, sizeof(var->data));
memcpy4347arch/m68k/amiga/amifb.cmemcpy(to, from, len);
memcpy266arch/m68k/amiga/amikeyb.cmemcpy (plain_map, amiplain_map, sizeof(plain_map));
memcpy46arch/m68k/amiga/amisound.cmemcpy (snd_data, sine_data, sizeof(sine_data));
memcpy754arch/m68k/amiga/config.cmemcpy(savekmsg->data+savekmsg->size, b, len);
memcpy2487arch/m68k/atari/atafb.cmemcpy(to,from,len);
memcpy769arch/m68k/atari/atakeyb.cmemcpy (plain_map, ataplain_map, sizeof(plain_map));
memcpy260arch/m68k/boot/amiga/bootstrap.cmemcpy(&bi.bi_amiga.autocon[i], cdp, sizeof(struct ConfigDev));
memcpy644arch/m68k/boot/amiga/bootstrap.cmemcpy ((void *)(memptr + kexec.a_text + kexec.a_data), &bi,
memcpy681arch/m68k/boot/amiga/bootstrap.cmemcpy (startfunc, &copyall, startcodesize);
memcpy828arch/m68k/boot/atari/bootstrap.cmemcpy ((void *)(memptr + kernel_size),
memcpy909arch/m68k/boot/atari/bootstrap.cmemcpy ((void *) 0x400, &copyall, &copyallend - &copyall);
memcpy41arch/m68k/kernel/ksyms.cXNOVERS(memcpy),
memcpy131arch/m68k/kernel/setup.cmemcpy(saved_command_line, *cmdline_p, CL_SIZE);
memcpy439arch/m68k/mm/init.cmemcpy (rd_start, rdp, ramdisk_length);
memcpy547arch/mips/kernel/gdb-stub.csp = memcpy(newsp, sp, 16 * 4);
memcpy298arch/mips/kernel/setup.cmemcpy(&drive_info, &boot_info.drive_info, sizeof(drive_info));
memcpy311arch/mips/kernel/setup.cmemcpy(saved_command_line, command_line, CL_SIZE);
memcpy145arch/mips/lib/checksum.cmemcpy(dst, src, len);
memcpy184arch/mips/mm/init.cmemcpy((void *) to,
memcpy59arch/ppc/kernel/signal.cmemcpy(regs, int_regs, sizeof(*regs));
memcpy198arch/ppc/kernel/signal.cmemcpy(regs_ptr, regs, sizeof(*regs));
memcpy20arch/sparc/kernel/ksyms.cextern void * memcpy(void *,const void *,size_t);
memcpy27arch/sparc/kernel/ksyms.cX(memcpy),
memcpy293arch/sparc/kernel/process.cmemcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
memcpy302arch/sparc/kernel/process.cmemcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->tss.float_regs[0], (sizeof(unsigned long) * 32));
memcpy306arch/sparc/kernel/process.cmemcpy(&dump->fpu.fpstatus.fpq[0], &current->tss.fpqueue[0],
memcpy185arch/sparc/kernel/signal.cmemcpy(&sc->sigc_wbuf[window],
memcpy190arch/sparc/kernel/signal.cmemcpy(sframep, (char *)regs->u_regs[UREG_FP],
memcpy336arch/sparc/kernel/signal.cmemcpy(ossptr, &current->tss.sstk_info, sizeof(struct sigstack));
memcpy343arch/sparc/kernel/signal.cmemcpy(&current->tss.sstk_info, ssptr, sizeof(struct sigstack));
memcpy588arch/sparc/kernel/sparc-stub.csp = memcpy(newsp, sp, 16 * 4);
memcpy25arch/sparc/kernel/windows.cmemcpy(&tp->reg_window[i], &tp->reg_window[i+1], sizeof(struct reg_window));
memcpy57arch/sparc/kernel/windows.cmemcpy((char *) sp, &tp->reg_window[window], sizeof(struct reg_window));
memcpy2412drivers/block/floppy.cmemcpy(buffer, dma_buffer, size);
memcpy2414drivers/block/floppy.cmemcpy(dma_buffer, buffer, size);
memcpy2962drivers/block/floppy.cmemcpy(old_raw_cmd.reply, ptr->reply, 7);
memcpy3028drivers/block/floppy.cmemcpy(ptr->cmd, old_raw_cmd.cmd, 9);
memcpy3483drivers/block/floppy.cmemcpy((char *) UDP,
memcpy1048drivers/block/ide-cd.cmemcpy (rq->buffer,
memcpy2372drivers/block/ide-cd.cmemcpy (mcn.medium_catalog_number, mcnbuf+9,
memcpy4398drivers/block/ide-tape.cmemcpy (ptr,bh->data,IDETAPE_ALLOCATION_BLOCK);
memcpy4436drivers/block/ide-tape.cmemcpy (bh->data,ptr,IDETAPE_ALLOCATION_BLOCK);
memcpy52drivers/block/loop.cmemcpy(loop_buf, raw_buf, size);
memcpy54drivers/block/loop.cmemcpy(raw_buf, loop_buf, size);
memcpy331drivers/block/loop.cmemcpy(lo->lo_des_init,info.lo_init,8);
memcpy343drivers/block/loop.cmemcpy(lo->lo_encrypt_key, info.lo_encrypt_key,
memcpy368drivers/block/loop.cmemcpy(info.lo_encrypt_key, lo->lo_encrypt_key,
memcpy996drivers/cdrom/aztcd.cmemcpy(CURRENT -> buffer, azt_buf + offs, nr_sectors * 512);
memcpy1306drivers/cdrom/cdu31a.cmemcpy(buffer,
memcpy1317drivers/cdrom/cdu31a.cmemcpy(buffer,
memcpy658drivers/cdrom/cm206.cmemcpy(dest, source, 512); 
memcpy662drivers/cdrom/cm206.cmemcpy(dest, source, 512); 
memcpy247drivers/cdrom/gscd.cmemcpy(CURRENT -> buffer, gscd_buf + offs, 512);
memcpy614drivers/cdrom/mcd.cmemcpy(CURRENT -> buffer, mcd_buf + offs, nr_sectors * 512);
memcpy1025drivers/cdrom/optcd.cmemcpy(CURRENT -> buffer, buf + offs, nr_sectors * 512);
memcpy4400drivers/cdrom/sbpcd.cmemcpy(CURRENT->buffer, D_S[d].sbp_buf + offs, 512);
memcpy946drivers/cdrom/sjcd.cmemcpy( CURRENT->buffer, sjcd_buf + offs, nr_sectors * 512 );
memcpy679drivers/cdrom/sonycd535.cmemcpy(toc->tracks + i, track_address_buffer, 5);
memcpy910drivers/cdrom/sonycd535.cmemcpy(CURRENT->buffer,
memcpy1664drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1667drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy63drivers/char/ftape/ftape-bsm.cmemcpy(list, bad_sector_map, sizeof(list));
memcpy117drivers/char/ftape/ftape-bsm.cmemcpy(buffer + offset, bad_sector_map, count);
memcpy156drivers/char/ftape/ftape-bsm.cmemcpy(bad_sector_map, buffer + 256, sizeof(bad_sector_map));
memcpy161drivers/char/ftape/ftape-bsm.cmemcpy(bad_sector_map, buffer + 256 + FAILED_SECTOR_LOG_SIZE,
memcpy330drivers/char/ftape/ftape-eof.cmemcpy(buffer + 30, linux_tape_label, strlen(linux_tape_label));
memcpy383drivers/char/ftape/ftape-eof.cmemcpy(eof_map, start, end - start);
memcpy391drivers/char/ftape/ftape-eof.cmemcpy(eof_map, address + 256, sizeof(eof_map));
memcpy433drivers/char/ftape/ftape-eof.cmemcpy(dest, eof_map, nr_of_eof_marks * sizeof(unsigned long));
memcpy437drivers/char/ftape/ftape-eof.cmemcpy(buffer + 256, eof_map, sizeof(eof_map));
memcpy139drivers/char/ftape/ftape-read.cmemcpy(destination, mseg.data, (mseg.blocks - 3) * SECTOR_SIZE);
memcpy90drivers/char/ftape/ftape-write.cmemcpy(mseg.data, source, (mseg.blocks - 3) * SECTOR_SIZE);
memcpy1415drivers/char/istallion.cmemcpy((shbuf + head), chbuf, stlen);
memcpy1546drivers/char/istallion.cmemcpy((shbuf + head), buf, stlen);
memcpy2211drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), arg, size);
memcpy2275drivers/char/istallion.cmemcpy(tty->flip.char_buf_ptr, (char *) (shbuf + tail), stlen);
memcpy2321drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &portp->asig, sizeof(asysigs_t));
memcpy2330drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
memcpy2405drivers/char/istallion.cmemcpy(portp->argp, (void *) &(cp->args[0]), portp->argsize);
memcpy2545drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->hostoffset), bitsize);
memcpy2567drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->slaveoffset), bitsize);
memcpy2590drivers/char/istallion.cmemcpy((((unsigned char *) hdrp) + brdp->slaveoffset), &bits[0], bitsize);
memcpy3409drivers/char/istallion.cmemcpy(&sig, sigsp, sizeof(cdkecpsig_t));
memcpy3565drivers/char/istallion.cmemcpy(&sig, sigsp, sizeof(cdkonbsig_t));
memcpy3824drivers/char/istallion.cmemcpy(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
memcpy3829drivers/char/istallion.cmemcpy(&onbsig, onbsigp, sizeof(cdkonbsig_t));
memcpy548drivers/char/n_tty.cmemcpy(tty->read_buf + tty->read_head, cp, i);
memcpy556drivers/char/n_tty.cmemcpy(tty->read_buf + tty->read_head, cp, i);
memcpy607drivers/char/pcxx.cmemcpy(ch->txptr + head, buf, stlen);
memcpy943drivers/char/pcxx.cmemcpy(&boards[numcards],&board, sizeof(board));
memcpy1168drivers/char/pcxx.cmemcpy(bios, pcxx_bios, pcxx_nbios);
memcpy1189drivers/char/pcxx.cmemcpy(bios, pcxx_bios, pcxx_nbios);
memcpy1213drivers/char/pcxx.cmemcpy(fepos, pcxx_cook, pcxx_ncook);
memcpy1804drivers/char/pcxx.cmemcpy(rptr, ch->rxptr + tail, piece);
memcpy624drivers/char/random.cmemcpy(buf, (__u8 const *)tmp, i);
memcpy1232drivers/char/riscom8.cmemcpy(port->xmit_buf + port->xmit_head, tmp_buf, c);
memcpy1234drivers/char/riscom8.cmemcpy(port->xmit_buf + port->xmit_head, buf, c);
memcpy2494drivers/char/scc.cmemcpy(scc_wbuf, buf, cnt);
memcpy1370drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1372drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy909drivers/char/stallion.cmemcpy(head, chbuf, stlen);
memcpy1806drivers/char/tty_io.cmemcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
memcpy310drivers/isdn/icn/icn.cmemcpy(&dev->rcvbuf[channel][dev->rcvidx[channel]], rbuf_d, cnt);
memcpy373drivers/isdn/icn/icn.cmemcpy(sbuf_d, dev->spqueue[channel]->rptr, cnt);
memcpy707drivers/isdn/icn/icn.cmemcpy(p, buffer, len);
memcpy990drivers/isdn/icn/icn.cmemcpy(msg, buf, count);
memcpy1066drivers/isdn/icn/icn.cmemcpy(&a, c->num, sizeof(ulong));
memcpy1419drivers/isdn/icn/icn.cmemcpy((char *) dev2, (char *) dev, sizeof(icn_dev));
memcpy283drivers/isdn/isdn_common.cmemcpy(p, buf, len);
memcpy634drivers/isdn/isdn_common.cmemcpy(cp, p->rptr, copy_l);
memcpy1383drivers/isdn/isdn_common.cmemcpy(c.num, (char *) &iocts.arg, sizeof(ulong));
memcpy1385drivers/isdn/isdn_common.cmemcpy((char *) &iocts.arg, c.num, sizeof(ulong));
memcpy1680drivers/isdn/isdn_common.cmemcpy(skb_put(skb, len), buf, len);
memcpy112drivers/isdn/isdn_net.cmemcpy(&(dev->dev_addr[i]), &dev->pa_addr, sizeof(ulong));
memcpy1045drivers/isdn/isdn_net.cmemcpy(skb_put(skb, len), buf, len);
memcpy1094drivers/isdn/isdn_net.cmemcpy(eth->h_source,saddr,dev->addr_len);
memcpy1096drivers/isdn/isdn_net.cmemcpy(eth->h_source,dev->dev_addr,dev->addr_len);
memcpy1108drivers/isdn/isdn_net.cmemcpy(eth->h_dest,daddr,dev->addr_len);
memcpy1199drivers/isdn/isdn_net.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy439drivers/isdn/isdn_ppp.cmemcpy(bl->buf, buf, len);
memcpy762drivers/isdn/isdn_ppp.cmemcpy(skb->data, skb_old->data, skb_old->len);
memcpy839drivers/isdn/isdn_ppp.cmemcpy(skb->data+len,buf,pktlen);
memcpy1079drivers/isdn/isdn_ppp.cmemcpy((*skb)->data + cnt, q->skb->data, q->skb->len);
memcpy72drivers/isdn/isdn_tty.cmemcpy(tty->flip.char_buf_ptr, buf, len);
memcpy400drivers/isdn/isdn_tty.cmemcpy(&(info->xmit_buf[info->xmit_count]), buf, c);
memcpy418drivers/isdn/isdn_tty.cmemcpy(bufptr, "\1\0\1\0", 4);
memcpy1113drivers/isdn/isdn_tty.cmemcpy(m->mdmreg, m->profile, ISDN_MODEM_ANZREG);
memcpy1114drivers/isdn/isdn_tty.cmemcpy(m->msn, m->pmsn, ISDN_MSNLEN);
memcpy1121drivers/isdn/isdn_tty.cmemcpy(m->profile, m->mdmreg, ISDN_MODEM_ANZREG);
memcpy1122drivers/isdn/isdn_tty.cmemcpy(m->pmsn, m->msn, ISDN_MSNLEN);
memcpy2021drivers/isdn/isdn_tty.cmemcpy(bufptr, "\1\0\1\0", 4);
memcpy113drivers/isdn/pcbit/capi.cmemcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
memcpy433drivers/isdn/pcbit/capi.cmemcpy(info->data.setup.CallingPN, skb->data + count + 1, 
memcpy461drivers/isdn/pcbit/capi.cmemcpy(info->data.setup.CalledPN, skb->data + count + 1, 
memcpy543drivers/isdn/pcbit/capi.cmemcpy(str, skb->data + 2, len - 1);
memcpy649drivers/isdn/pcbit/capi.cmemcpy(str, hdr + 1, hdrlen - 1);
memcpy760drivers/isdn/pcbit/drv.c(flag ? memcpy_tofs(d, s, len) : memcpy(d, s, len))
memcpy1101drivers/isdn/pcbit/drv.cmemcpy(ptr->msn, sp, len - 1);
memcpy1407drivers/isdn/teles/callc.cmemcpy(ptr, buf, count);
memcpy894drivers/isdn/teles/card.cmemcpy(DATAPTR(cibh), DATAPTR(ibh), ibh->datasize);
memcpy1598drivers/isdn/teles/card.cmemcpy(&cards[i],&cards[i+1],sizeof(cards[i]));
memcpy305drivers/net/3c501.cmemcpy(dev->dev_addr, station_addr, ETH_ALEN);
memcpy741drivers/net/3c505.cmemcpy(skb_put(skb, adapter->current_dma.length), adapter->dma_buffer, adapter->current_dma.length);
memcpy1097drivers/net/3c505.cmemcpy(adapter->dma_buffer, skb->data, nlen);
memcpy1306drivers/net/3c505.cmemcpy(adapter->tx_pcb.data.multicast[i], dmi->dmi_addr, 6);
memcpy718drivers/net/3c507.cmemcpy((void*)dev->mem_end-10, init_words, 10);
memcpy721drivers/net/3c507.cmemcpy((char*)dev->mem_start, init_words + 5, sizeof(init_words) - 10);
memcpy724drivers/net/3c507.cmemcpy((char*)dev->mem_start+SA_OFFSET, dev->dev_addr,
memcpy787drivers/net/3c507.cmemcpy(write_ptr, buf, length);
memcpy855drivers/net/3c507.cmemcpy(skb_put(skb,pkt_len), data_frame + 5, pkt_len);
memcpy597drivers/net/a2065.cmemcpy(priv->tx_buff[entry], skb->data, skb->len);
memcpy289drivers/net/apricot.cmemcpy (lp->i596_config, init_setup, 14);
memcpy293drivers/net/apricot.cmemcpy (lp->eth_addr, dev->dev_addr, 6);
memcpy352drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len);
memcpy980drivers/net/apricot.cmemcpy(cp, dmi,6);
memcpy1356drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
memcpy1373drivers/net/arcnet.cmemcpy(lp->sdev,dev,sizeof(struct device));
memcpy1813drivers/net/arcnet.cmemcpy((u_char*)arcsoft,
memcpy1823drivers/net/arcnet.cmemcpy((u_char*)arcsoft+hdrlen,
memcpy2321drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2452drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2503drivers/net/arcnet.cmemcpy(skb->data+skb->len,
memcpy2845drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
memcpy2897drivers/net/arcnet.cmemcpy(skb->data,(u_char *)arcsoft+1,length-1);
memcpy3032drivers/net/arcnet.cmemcpy((u_char *)soft + sizeof(struct S_ClientData)
memcpy516drivers/net/atarilance.clp->memcpy_f = init_rec->slow_flag ? slow_memcpy : memcpy;
memcpy566drivers/net/atarilance.cmemcpy( dev->dev_addr, OldRieblDefHwaddr, 6 );
memcpy1145drivers/net/atarilance.cmemcpy( dev->dev_addr, saddr->sa_data, dev->addr_len );
memcpy2659drivers/net/de4x5.cmemcpy(skb_put(p,tlen), bus_to_virt(lp->rx_ring[lp->rx_old].buf),tlen);
memcpy2660drivers/net/de4x5.cmemcpy(skb_put(p,len-tlen), bus_to_virt(lp->rx_ring[0].buf), len-tlen);
memcpy2662drivers/net/de4x5.cmemcpy(skb_put(p,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf),len);
memcpy3446drivers/net/de4x5.cmemcpy((char *)&lp->phy[k],
memcpy1844drivers/net/depca.cmemcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
memcpy487drivers/net/dgrs.cmemcpy(p, S2H(tbdp->buf), amt);
memcpy518drivers/net/dgrs.cmemcpy(p, S2H(tbdp->buf), amt);
memcpy584drivers/net/dgrs.cmemcpy( (char *) S2H(rbdp->buf) + count, skb->data + i, amt);
memcpy882drivers/net/dgrs.cmemcpy(priv->vmem, dgrs_code, dgrs_ncode);  /* Load code */
memcpy915drivers/net/dgrs.cmemcpy(priv->bcomm->bc_ipaddr, dgrs_ipaddr, 4);
memcpy916drivers/net/dgrs.cmemcpy(priv->bcomm->bc_ipxnet, &dgrs_ipxnet, 4);
memcpy1004drivers/net/dgrs.cmemcpy(dev->dev_addr, priv->port->ethaddr, 6);
memcpy487drivers/net/dgrs_driver.cmemcpy(p, S2H(tbdp->buf), amt);
memcpy518drivers/net/dgrs_driver.cmemcpy(p, S2H(tbdp->buf), amt);
memcpy584drivers/net/dgrs_driver.cmemcpy( (char *) S2H(rbdp->buf) + count, skb->data + i, amt);
memcpy882drivers/net/dgrs_driver.cmemcpy(priv->vmem, dgrs_code, dgrs_ncode);  /* Load code */
memcpy915drivers/net/dgrs_driver.cmemcpy(priv->bcomm->bc_ipaddr, dgrs_ipaddr, 4);
memcpy916drivers/net/dgrs_driver.cmemcpy(priv->bcomm->bc_ipxnet, &dgrs_ipxnet, 4);
memcpy1004drivers/net/dgrs_driver.cmemcpy(dev->dev_addr, priv->port->ethaddr, 6);
memcpy153drivers/net/dlci.cmemcpy(dest, &hdr, hlen);
memcpy433drivers/net/dlci.cmemcpy(&dlp->config, &config, sizeof(struct dlci_conf));
memcpy1047drivers/net/eth16i.cmemcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
memcpy668drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
memcpy770drivers/net/hp100.cmemcpy( ptr, lp -> mem_ptr_virt, ( pkt_len + 3 ) & ~3 );
memcpy848drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
memcpy143drivers/net/net_init.cmemcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
memcpy261drivers/net/new_tunnel.cmemcpy(new_skb->ip_hdr, skb->data, skb->len);
memcpy263drivers/net/new_tunnel.cmemcpy(new_skb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy599drivers/net/ni52.cmemcpy((char *)&ias_cmd->iaddr,(char *) dev->dev_addr,ETH_ALEN);
memcpy668drivers/net/ni52.cmemcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr,6);
memcpy1179drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
memcpy718drivers/net/ni65.cmemcpy((char *) tmdp->u.buffer,(char *)skb->data,
memcpy444drivers/net/pi2.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
memcpy567drivers/net/pi2.cmemcpy(cfix, (char *) cur_buf->data,
memcpy656drivers/net/pi2.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
memcpy1280drivers/net/pi2.cmemcpy(dev->dev_addr, sa->sa_data, dev->addr_len);  /* addr is an AX.25 shifted ASCII */
memcpy1433drivers/net/pi2.cmemcpy(dev->broadcast, ax25_bcast, 7);
memcpy1434drivers/net/pi2.cmemcpy(dev->dev_addr, ax25_test, 7);
memcpy871drivers/net/plip.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy877drivers/net/plip.cmemcpy(&(eth->h_dest[i]), &dst, sizeof(unsigned long));
memcpy968drivers/net/plip.cmemcpy(&(dev->dev_addr[i]), &dev->pa_addr, sizeof(unsigned long));
memcpy1206drivers/net/ppp.cmemcpy (skb_put(skb,count), data, count);  /* move data */
memcpy2456drivers/net/ppp.cmemcpy (ppp->xmit_async_map, temp_tbl,
memcpy2751drivers/net/ppp.cmemcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
memcpy743drivers/net/pt.cmemcpy(dev->dev_addr, sa->sa_data, dev->addr_len);    /* addr is an AX.25 shifted ASCII */
memcpy900drivers/net/pt.cmemcpy(dev->broadcast, ax25_bcast, 7);
memcpy901drivers/net/pt.cmemcpy(dev->dev_addr, ax25_test, 7);
memcpy1407drivers/net/pt.cmemcpy(cfix, (char*)cur_buf->data, pkt_len - 1);
memcpy1409drivers/net/pt.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
memcpy1638drivers/net/pt.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
memcpy95drivers/net/sdla.cmemcpy(temp, base, bytes);
memcpy120drivers/net/sdla.cmemcpy(base, temp, bytes);
memcpy432drivers/net/sdla.cmemcpy(cmd_buf->data, inbuf, inlen);
memcpy465drivers/net/sdla.cmemcpy(outbuf, cmd_buf->data, *outlen);
memcpy470drivers/net/sdla.cmemcpy(&status, cmd_buf->data, len > sizeof(status) ? sizeof(status) : len);
memcpy1020drivers/net/sdla.cmemcpy(&data.config, &flp->config, sizeof(struct frad_conf));
memcpy1150drivers/net/sdla.cmemcpy(&flp->config, &data.config, sizeof(struct frad_conf));
memcpy1188drivers/net/sdla.cmemcpy(&data.config, &flp->config, sizeof(struct frad_conf));
memcpy1192drivers/net/sdla.cmemcpy(&flp->config, &data.config, sizeof(struct frad_conf));
memcpy1255drivers/net/sdla.cmemcpy(&data, &flp->config, sizeof(struct frad_conf));
memcpy1256drivers/net/sk_g16.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
memcpy1601drivers/net/sk_g16.cmemcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
memcpy471drivers/net/skeleton.cmemcpy(skb_put(skb,pkt_len), (void*)dev->rmem_start,
memcpy442drivers/net/slhc.cmemcpy(&cs->cs_ip,ip,20);
memcpy443drivers/net/slhc.cmemcpy(&cs->cs_tcp,th,20);
memcpy464drivers/net/slhc.cmemcpy(cp,new_seq,deltaS);  /* Write list of deltas */
memcpy465drivers/net/slhc.cmemcpy(cp+deltaS,icp+hlen,isize-hlen);
memcpy475drivers/net/slhc.cmemcpy(&cs->cs_ip,ip,20);
memcpy476drivers/net/slhc.cmemcpy(&cs->cs_tcp,th,20);
memcpy478drivers/net/slhc.cmemcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
memcpy480drivers/net/slhc.cmemcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4);
memcpy483drivers/net/slhc.cmemcpy(ocp, icp, isize);
memcpy614drivers/net/slhc.cmemcpy(cp, ip, 20);
memcpy618drivers/net/slhc.cmemcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4);
memcpy628drivers/net/slhc.cmemcpy(cp, thp, 20);
memcpy632drivers/net/slhc.cmemcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4);
memcpy679drivers/net/slhc.cmemcpy(&cs->cs_ip,icp,20);
memcpy680drivers/net/slhc.cmemcpy(&cs->cs_tcp,icp + ihl*4,20);
memcpy682drivers/net/slhc.cmemcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4);
memcpy684drivers/net/slhc.cmemcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4);
memcpy283drivers/net/slip.cmemcpy(sl->xbuff, sl->xhead, sl->xleft);
memcpy293drivers/net/slip.cmemcpy(sl->rbuff, orbuff, sl->rcount);
memcpy390drivers/net/slip.cmemcpy(skb_put(skb,count), sl->rbuff, count);
memcpy1034drivers/net/slip.cmemcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
memcpy1302drivers/net/slip.cmemcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);  /* Only activated in AX.25 mode */
memcpy1303drivers/net/slip.cmemcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);  /*    ""      ""       ""    "" */
memcpy509drivers/net/strip.cmemcpy(strip_info->tx_buff, strip_info->tx_head, strip_info->tx_left);
memcpy521drivers/net/strip.cmemcpy(strip_info->sx_buff, osbuff, strip_info->sx_count);
memcpy751drivers/net/strip.cmemcpy(skb_put(skb, count), strip_info->rx_buff, count);
memcpy1008drivers/net/strip.cmemcpy(dev->dev_addr, addr, 7);
memcpy708drivers/net/sunlance.cmemcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
memcpy1022drivers/net/tulip.cmemcpy(skb_put(skb, pkt_len),
memcpy722drivers/net/wavelan.cmemcpy(&ias.ias_addr[0], (unsigned char *)&dev->dev_addr[0], sizeof(ias.ias_addr));
memcpy946drivers/net/wavelan.cmemcpy(&dev->dev_addr[0], &psa.psa_univ_mac_addr[0], WAVELAN_ADDR_SIZE);
memcpy931drivers/net/wic.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy937drivers/net/wic.cmemcpy(&(eth->h_dest[i]), &dst, sizeof(unsigned long));
memcpy381drivers/net/znet.cmemcpy(zn.tx_cur, buf, semi_cnt);
memcpy383drivers/net/znet.cmemcpy(zn.tx_start, buf + semi_cnt, length - semi_cnt);
memcpy386drivers/net/znet.cmemcpy(zn.tx_cur, buf, skb->len);
memcpy501drivers/net/znet.cmemcpy(zn.rx_end, zn.rx_start, 8);
memcpy562drivers/net/znet.cmemcpy(skb_put(skb,semi_cnt), zn.rx_cur, semi_cnt);
memcpy563drivers/net/znet.cmemcpy(skb_put(skb,pkt_len-semi_cnt), zn.rx_start,
memcpy566drivers/net/znet.cmemcpy(skb_put(skb,pkt_len), zn.rx_cur, pkt_len);
memcpy651drivers/net/znet.cmemcpy(zn.tx_cur, i593_init, sizeof(i593_init));
memcpy658drivers/net/znet.cmemcpy(zn.tx_cur, addrs, addrs_len);
memcpy711drivers/net/znet.cmemcpy(zn.tx_cur, i593_init, sizeof(i593_init));
memcpy716drivers/net/znet.cmemcpy(zn.tx_cur, dev->dev_addr, 6);
memcpy970drivers/sbus/char/suncons.cmemcpy (cursor_info->bits [0], cursor->mask, bytes);
memcpy971drivers/sbus/char/suncons.cmemcpy (cursor_info->bits [1], cursor->image, bytes);
memcpy1103drivers/sbus/char/sunserial.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1106drivers/sbus/char/sunserial.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy1123drivers/scsi/53c7,8xx.cmemcpy ((void *) hostdata->synchronous_want, (void *) sdtr_message, 
memcpy1624drivers/scsi/53c7,8xx.cmemcpy ((void *) hostdata->script, (void *) SCRIPT, 
memcpy2011drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
memcpy3010drivers/scsi/53c7,8xx.cmemcpy ((void *) event->cmnd, (void *) c->cmnd, 
memcpy3103drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->addr, (void *) bp->old, sizeof(bp->old));
memcpy3178drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
memcpy3183drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
memcpy3285drivers/scsi/53c7,8xx.cmemcpy (hostdata->debug_write, buf, copy);
memcpy3678drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) wdtr_message,
memcpy3686drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) sdtr_message, 
memcpy3699drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) async_message, 
memcpy6319drivers/scsi/53c7,8xx.cmemcpy ((void *) &event, (void *) &(hostdata->events[i]),
memcpy1260drivers/scsi/BusLogic.cmemcpy(HostAdapter->ErrorRecoveryStrategy,
memcpy1740drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousValues,
memcpy1744drivers/scsi/BusLogic.cmemcpy(&HostAdapter->SynchronousValues[8],
memcpy1747drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousPeriod, SynchronousPeriod,
memcpy1939drivers/scsi/BusLogic.cmemcpy(HostAdapter, &HostAdapterPrototype,
memcpy2546drivers/scsi/BusLogic.cmemcpy(CCB->CDB, CDB, CDB_Length);
memcpy96drivers/scsi/a2091.cmemcpy (HDATA(instance)->dma_bounce_buffer,
memcpy100drivers/scsi/a2091.cmemcpy (HDATA(instance)->dma_bounce_buffer,
memcpy167drivers/scsi/a2091.cmemcpy (SCpnt->SCp.ptr, 
memcpy178drivers/scsi/a2091.cmemcpy (SCpnt->request_buffer,
memcpy77drivers/scsi/a3000.cmemcpy (HDATA(a3000_host)->dma_bounce_buffer,
memcpy80drivers/scsi/a3000.cmemcpy (HDATA(a3000_host)->dma_bounce_buffer,
memcpy161drivers/scsi/a3000.cmemcpy (SCpnt->SCp.ptr,
memcpy170drivers/scsi/a3000.cmemcpy (SCpnt->request_buffer,
memcpy3562drivers/scsi/advansys.cmemcpy(curbuf, cp, cnt);
memcpy3570drivers/scsi/advansys.cmemcpy(curbuf, cp, cnt);
memcpy4750drivers/scsi/advansys.cmemcpy(buf, s, ret);
memcpy466drivers/scsi/aha1542.cmemcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], 
memcpy602drivers/scsi/aha1542.cmemcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
memcpy220drivers/scsi/aha1740.cmemcpy(SCtmp->sense_buffer, ecbptr->sense, 
memcpy322drivers/scsi/aha1740.cmemcpy(ecb[ecbno].cdb, cmd, ecb[ecbno].cdblen);
memcpy2105drivers/scsi/aic7xxx.cmemcpy((void *) scb->sense_cmd, (void *) generic_sense,
memcpy2122drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr,
memcpy2125drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &req_buf,
memcpy2128drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(scb->sense_sg.address), 4);
memcpy4168drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr, sizeof(scb->SCSI_cmd_pointer));
memcpy4173drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &cmd->request_buffer,
memcpy4175drivers/scsi/aic7xxx.cmemcpy(&sg, &cmd->request_buffer, sizeof(sg));
memcpy4176drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(sg[0].address), sizeof(scb->data_pointer));
memcpy4207drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &addr, sizeof(scb->SG_list_pointer));
memcpy4209drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &cmd->request_buffer, sizeof(scb->data_pointer));
memcpy457drivers/scsi/atari_scsi.cmemcpy( atari_dma_orig_addr, (void *)PTOV(atari_dma_startaddr),
memcpy941drivers/scsi/atari_scsi.cmemcpy( atari_dma_buffer, data, count );
memcpy323drivers/scsi/dtc.cmemcpy(d, (char *)(base + DTC_DATA_BUF), 128);
memcpy373drivers/scsi/dtc.cmemcpy((char *)(base + DTC_DATA_BUF), src, 128);
memcpy702drivers/scsi/eata.cmemcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
memcpy501drivers/scsi/eata_dma.cmemcpy(cp->cp_cdb, cmd->cmnd, cmd->cmd_len);
memcpy355drivers/scsi/eata_pio.cmemcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
memcpy1087drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1090drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
memcpy1096drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
memcpy1109drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1114drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy2010drivers/scsi/fdomain.cmemcpy( data, do_read, sizeof( do_read ) );
memcpy105drivers/scsi/gvp11.cmemcpy (HDATA(cmd->host)->dma_bounce_buffer,
memcpy109drivers/scsi/gvp11.cmemcpy (HDATA(cmd->host)->dma_bounce_buffer,
memcpy154drivers/scsi/gvp11.cmemcpy (SCpnt->SCp.ptr, 
memcpy165drivers/scsi/gvp11.cmemcpy (SCpnt->request_buffer,
memcpy662drivers/scsi/scsi.cmemcpy (SDpnt->vendor, scsi_result + 8, 8);
memcpy663drivers/scsi/scsi.cmemcpy (SDpnt->model, scsi_result + 16, 16);
memcpy664drivers/scsi/scsi.cmemcpy (SDpnt->rev, scsi_result + 32, 4);
memcpy936drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1102drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1259drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) generic_sense, 
memcpy1339drivers/scsi/scsi.cmemcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
memcpy1356drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
memcpy1762drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd,
memcpy2860drivers/scsi/scsi.cmemcpy(new_dma_malloc_freelist, dma_malloc_freelist, size);
memcpy2868drivers/scsi/scsi.cmemcpy(new_dma_malloc_pages, dma_malloc_pages, size);
memcpy221drivers/scsi/scsi_debug.cmemcpy(buff, sense_buffer, bufflen);
memcpy238drivers/scsi/scsi_debug.cmemcpy(&buff[8],"Foo Inc",7);
memcpy239drivers/scsi/scsi_debug.cmemcpy(&buff[16],"XYZZY",5);
memcpy240drivers/scsi/scsi_debug.cmemcpy(&buff[32],"1",1);
memcpy345drivers/scsi/scsi_debug.cmemcpy(buff, &target, sizeof(target));
memcpy346drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
memcpy347drivers/scsi/scsi_debug.cmemcpy(buff+60, &block, sizeof(block));
memcpy348drivers/scsi/scsi_debug.cmemcpy(buff+64, SCpnt, sizeof(Scsi_Cmnd));
memcpy353drivers/scsi/scsi_debug.cmemcpy(buff+128, bh, sizeof(struct buffer_head));
memcpy250drivers/scsi/sd.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, 
memcpy265drivers/scsi/sd.cmemcpy(SCpnt->request.buffer, SCpnt->buffer,
memcpy811drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
memcpy831drivers/scsi/sd.cmemcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
memcpy1669drivers/scsi/seagate.cmemcpy (data, cmd, 6);
memcpy1682drivers/scsi/seagate.cmemcpy (data, cmd, 6);
memcpy278drivers/scsi/sg.cmemcpy(device->header.sense_buffer, SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
memcpy165drivers/scsi/sr.cmemcpy((char *)SCpnt->request.buffer, 
memcpy177drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
memcpy192drivers/scsi/sr.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
memcpy508drivers/scsi/sr_ioctl.cmemcpy (mcn.medium_catalog_number, buffer + 9, 13);
memcpy284drivers/scsi/st.cmemcpy(STbuffer->b_data,
memcpy1408drivers/scsi/st.cmemcpy(STm, &(STp->modes[0]), sizeof(ST_mode));
memcpy658drivers/scsi/u14-34f.cmemcpy(cpp->scsi_cdbs, SCpnt->cmnd, cpp->scsi_cdbs_len);
memcpy733drivers/scsi/ultrastor.cmemcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
memcpy913drivers/scsi/wd7000.cmemcpy(scb->cdb, cdb, cdblen);
memcpy1427drivers/sound/ad1848.cmemcpy ((char *) &ad1848_pcm_operations[nr_ad1848_devs],
memcpy1625drivers/sound/gus_wave.cmemcpy ((char *) &samples[free_sample], &patch, sizeof_patch);
memcpy2594drivers/sound/gus_wave.cmemcpy (rec->data.data8, (char *) &samples[ptr],
memcpy2621drivers/sound/gus_wave.cmemcpy ((char *) &samples[ptr], rec->data.data8,
memcpy1133drivers/sound/mpu401.cmemcpy ((char *) mpu401_synth_operations[num_midis],
memcpy1139drivers/sound/mpu401.cmemcpy ((char *) mpu401_synth_operations[num_midis],
memcpy1144drivers/sound/mpu401.cmemcpy ((char *) &mpu401_midi_operations[num_midis],
memcpy1151drivers/sound/mpu401.cmemcpy ((char *) &mpu_synth_info[num_midis],
memcpy367drivers/sound/opl3.cmemcpy ((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof (*instr));
memcpy197drivers/sound/sequencer.cmemcpy (&iqueue[iqtail * IEV_SZ], event_rec, len);
memcpy424drivers/sound/sequencer.cmemcpy (&queue[qtail * EV_SZ], note, EV_SZ);
memcpy56drivers/sound/sound_switch.cmemcpy (&status_buf[status_len], s, l);
memcpy88drivers/sound/sound_switch.cmemcpy (&status_buf[status_len], &buf[10 - l], l);
memcpy135drivers/sound/soundcard.cmemcpy ((char *) &files[dev], (char *) &tmp_file, sizeof (tmp_file));
memcpy484drivers/sound/sscape.cmemcpy (audio_devs[devc->my_audiodev]->dmap_out->raw_buf, block, size);
memcpy208fs/affs/inode.cmemcpy (buf,name,len);
memcpy103fs/binfmt_aout.cmemcpy(corefile,"core.",5);
memcpy105fs/binfmt_aout.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy984fs/binfmt_elf.cmemcpy(elf.e_ident, ELFMAG, SELFMAG);
memcpy1006fs/binfmt_elf.cmemcpy(corefile,"core.",5);
memcpy1008fs/binfmt_elf.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy1186fs/buffer.cmemcpy(next->b_data, tmp->b_data, size);
memcpy1188fs/buffer.cmemcpy(tmp->b_data, next->b_data, size);
memcpy56fs/dcache.cmemcpy((void *) &newde->dc_dev, (void *) &de->dc_dev, dcache_datalen)
memcpy220fs/dcache.cmemcpy(de->name, name, len);
memcpy598fs/dquot.cmemcpy(&dq_dqblk, dqblk, sizeof(struct dqblk));
memcpy310fs/ext2/namei.cmemcpy (de->name, name, namelen);
memcpy82fs/fat/cache.cmemcpy(c_bh->b_data,bh->b_data,SECTOR_SIZE);
memcpy92fs/fat/cache.cmemcpy(c_bh2->b_data,bh2->b_data,SECTOR_SIZE);
memcpy189fs/fat/dir.cmemcpy(&unicode[offset], ds->name0_4, 10);
memcpy191fs/fat/dir.cmemcpy(&unicode[offset], ds->name5_10, 12);
memcpy193fs/fat/dir.cmemcpy(&unicode[offset], ds->name11_12, 4);
memcpy280fs/fat/dir.cmemcpy(&longname[long_len+1], bufname, i+dotoffset);
memcpy222fs/fat/file.cmemcpy (pre.bhlist,pre.bhlist+MSDOS_PREFETCH/2
memcpy316fs/fat/inode.cmemcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options));
memcpy1704fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
memcpy1709fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
memcpy1714fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
memcpy1719fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
memcpy179fs/isofs/dir.cmemcpy(tmpde, de, bufsize - offset);
memcpy187fs/isofs/dir.cmemcpy(bufsize - offset + (char *) tmpde, bh->b_data, next_offset);
memcpy493fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
memcpy501fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy782fs/isofs/inode.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
memcpy797fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy118fs/isofs/namei.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
memcpy128fs/isofs/namei.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy72fs/isofs/rock.cmemcpy(buffer, bh->b_data + offset, 1024 - offset); \
memcpy81fs/isofs/rock.cmemcpy(buffer + offset1, bh->b_data + offset, cont_size - offset1); \
memcpy443fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
memcpy451fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy275fs/msdos/namei.cmemcpy(de->name,name,MSDOS_NAME);
memcpy585fs/msdos/namei.cmemcpy(old_de->name,new_name,MSDOS_NAME);
memcpy672fs/msdos/namei.cmemcpy(free_de,old_de,sizeof(struct msdos_dir_entry));
memcpy673fs/msdos/namei.cmemcpy(free_de->name,new_name,MSDOS_NAME);
memcpy808fs/ncpfs/dir.cmemcpy(name, __name, len);
memcpy59fs/ncpfs/ncplib_kernel.cmemcpy(&(server->packet[server->current_size]), source, size);
memcpy187fs/ncpfs/ncplib_kernel.cmemcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
memcpy258fs/ncpfs/ncplib_kernel.cmemcpy(target, structure, info_struct_size);
memcpy392fs/ncpfs/ncplib_kernel.cmemcpy(&(dest[1]), &sfd, 4);
memcpy480fs/ncpfs/ncplib_kernel.cmemcpy(target, ncp_reply_data(server, 0), sizeof(*target));
memcpy511fs/ncpfs/ncplib_kernel.cmemcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
memcpy368fs/nfs/dir.cmemcpy(name,__name,len);
memcpy188fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
memcpy318fs/nfs/nfsroot.cmemcpy(&sip, rarp_ptr, 4);
memcpy322fs/nfs/nfsroot.cmemcpy(&tip, rarp_ptr, 4);
memcpy696fs/nfs/nfsroot.cmemcpy(xmit_bootp->hw_addr, best_dev->dev_addr, best_dev->addr_len);
memcpy776fs/nfs/nfsroot.cmemcpy(&netmask.sin_addr.s_addr, ext+1, 4);
memcpy780fs/nfs/nfsroot.cmemcpy(&gateway.sin_addr.s_addr, ext+1, 4);
memcpy1646fs/nfs/nfsroot.cmemcpy(p, nfs_path, len);
memcpy120fs/nfs/proc.cmemcpy(p, string, len);
memcpy129fs/nfs/proc.cmemcpy(string, p, len);
memcpy160fs/nfs/proc.cmemcpy(data, p, len);
memcpy310fs/nfs/rpcsock.cmemcpy(iov, req->rq_svec, req->rq_snr * sizeof(iov[0]));
memcpy390fs/nfs/rpcsock.cmemcpy(iov, req->rq_rvec, req->rq_rnr * sizeof(iov[0]));
memcpy85fs/nfs/symlink.cmemcpy(res2, res, len);
memcpy482fs/proc/array.cdo { memcpy(buffer, string, strlen(string)); \
memcpy367fs/smbfs/dir.cmemcpy(path, parentname, parentlen + 1);
memcpy397fs/smbfs/dir.cmemcpy(path, parentname, len);
memcpy405fs/smbfs/dir.cmemcpy(path, parentname, parentlen);
memcpy407fs/smbfs/dir.cmemcpy(path + parentlen + 1, name, len);
memcpy105fs/smbfs/proc.cmemcpy(p, data, len);
memcpy125fs/smbfs/proc.cmemcpy(data, p, len);
memcpy930fs/smbfs/proc.cmemcpy(entry->path, p+9, 13);
memcpy1024fs/smbfs/proc.cmemcpy(status,
memcpy378fs/smbfs/sock.cmemcpy(*param + WVAL(inbuf,smb_prdisp),
memcpy389fs/smbfs/sock.cmemcpy(*data + WVAL(inbuf,smb_drdisp),
memcpy85fs/sysv/balloc.cmemcpy(flc_blocks, sb->sv_sb_flc_blocks, *flc_count * sizeof(sysv_zone_t));
memcpy194fs/sysv/balloc.cmemcpy(sb->sv_sb_flc_blocks, flc_blocks, *flc_count * sizeof(sysv_zone_t));
memcpy94fs/sysv/dir.cmemcpy(&sde, de, sizeof(struct sysv_dir_entry));
memcpy132fs/ufs/ufs_super.cmemcpy((char *)usb, bh1->b_data, BLOCK_SIZE);
memcpy133fs/ufs/ufs_super.cmemcpy((char *)usb + BLOCK_SIZE, bh2->b_data,
memcpy59fs/umsdos/dir.cmemcpy (zname,name,name_len);
memcpy446fs/umsdos/dir.cmemcpy (d->entry->name,name,name_len);
memcpy473fs/umsdos/dir.cmemcpy (entry->name,UMSDOS_PSDROOT_NAME,UMSDOS_PSDROOT_LEN+1);
memcpy563fs/umsdos/dir.cmemcpy (ptbpath,entry.name,entry.name_len);
memcpy580fs/umsdos/dir.cmemcpy (ptbpath,entry.name,entry.name_len);
memcpy227fs/umsdos/emd.cmemcpy (buf->buffer,buf->buffer+buf->pos,mustmove);
memcpy203fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
memcpy235fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
memcpy289fs/umsdos/mangle.cmemcpy (info->fake.fname,fname,msdos_len);
memcpy356fs/umsdos/mangle.cmemcpy (basen,info->fake.fname,base_len);
memcpy374fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
memcpy870fs/vfat/namei.cmemcpy(de, ps, sizeof(struct msdos_dir_slot));
memcpy1051fs/vfat/namei.cmemcpy(de->name,name,MSDOS_NAME);
memcpy222fs/xiafs/namei.cmemcpy(de->d_name, name, namelen);
memcpy93include/asm-alpha/segment.hmemcpy(to, from, n);
memcpy100include/asm-alpha/segment.hmemcpy(to, from, n);
memcpy77include/asm-i386/io.h#define memcpy_fromio(a,b,c)  memcpy((a),(void *)(b),(c))
memcpy78include/asm-i386/io.h#define memcpy_toio(a,b,c)  memcpy((void *)(a),(b),(c))
memcpy72include/asm-i386/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy86include/asm-i386/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy242include/asm-m68k/string.hmemcpy((to),(from),(n)))
memcpy70include/asm-m68k/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy84include/asm-m68k/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy85include/asm-mips/io.h#define memcpy_fromio(a,b,c)  memcpy((a),(void *)(b),(c))
memcpy86include/asm-mips/io.h#define memcpy_toio(a,b,c)  memcpy((void *)(a),(b),(c))
memcpy112include/asm-mips/segment.hmemcpy(to, from, n);
memcpy119include/asm-mips/segment.hmemcpy(to, from, n);
memcpy30include/asm-mips/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy44include/asm-mips/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy103include/asm-ppc/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy105include/asm-ppc/segment.h#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
memcpy285include/asm-sparc/checksum.hmemcpy(dst, src, len);
memcpy105include/asm-sparc/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy107include/asm-sparc/segment.h#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
memcpy81include/asm-sparc/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy95include/asm-sparc/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy969include/linux/soundcard.h_pm_info.device=dev, memcpy(_pm_info.data.data8, pgm, 128), \
memcpy30include/linux/string.hextern void * memcpy(void *,const void *,size_t);
memcpy125ipc/msg.cmemcpy(msgh->msg_spot, (char *)(&(kdmp->id)), sizeof(long)); 
memcpy126ipc/msg.cmemcpy(msgh->msg_spot + sizeof(long), kdmp->text,
memcpy301ipc/msg.cmemcpy((char *)(&(kdmp->id)),
memcpy309ipc/msg.cmemcpy(kdmp->text,
memcpy171kernel/fork.cmemcpy(&tsk->files->close_on_exec, &current->files->close_on_exec,
memcpy192kernel/fork.cmemcpy(tsk->sig->action, current->sig->action, sizeof(tsk->sig->action));
memcpy728kernel/module.cmemcpy(newtab, intab, SYMSIZ + intab->n_symbols * INTSIZ);
memcpy734kernel/module.cmemcpy( ((char *)newtab) + SYMSIZ + intab->n_symbols * INTSIZ,
memcpy585lib/inflate.cmemcpy(slide + w, slide + d, e);
memcpy229mm/filemap.cmemcpy((void *) (offset + addr), buf, len);
memcpy776mm/filemap.cmemcpy((void *) new_page, (void *) page, PAGE_SIZE);
memcpy66mm/memory.cmemcpy((void *) to, (void *) from, PAGE_SIZE);
memcpy173mm/memory.cmemcpy(new_pg + USER_PTRS_PER_PGD, page_dir + USER_PTRS_PER_PGD,
memcpy78net/802/psnap.cmemcpy(skb_push(skb,5),dl->type,5);
memcpy115net/802/psnap.cmemcpy(proto->type, desc,5);
memcpy52net/802/tr.cmemcpy(trh->saddr,saddr,dev->addr_len);
memcpy63net/802/tr.cmemcpy(trh->daddr,daddr,dev->addr_len);
memcpy146net/802/tr.cmemcpy(&trh->rseg[0],&entry->rseg[0],8*sizeof(unsigned short));
memcpy191net/802/tr.cmemcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
memcpy192net/802/tr.cmemcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
memcpy208net/802/tr.cmemcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
memcpy131net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy191net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy200net/appletalk/aarp.cmemcpy(eah->hw_dst, sha, ETH_ALEN);
memcpy255net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy743net/appletalk/aarp.cmemcpy(a->hwaddr,ea->hw_src,ETH_ALEN);
memcpy1385net/appletalk/ddp.cmemcpy(uaddr,&sat,sizeof(sat));
memcpy2496net/ax25/af_ax25.cmemcpy(buff, daddr, dev->addr_len);  /* Address specified */
memcpy2504net/ax25/af_ax25.cmemcpy(buff, saddr, dev->addr_len);
memcpy2506net/ax25/af_ax25.cmemcpy(buff, dev->dev_addr, dev->addr_len);
memcpy108net/ax25/ax25_in.cmemcpy(skbn->data, skbo->data, hdrlen);  /* copy address field */
memcpy114net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy120net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy123net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
memcpy135net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
memcpy605net/ax25/ax25_route.cmemcpy(&dest, skb->data    , AX25_ADDR_LEN);
memcpy606net/ax25/ax25_route.cmemcpy(&src,  skb->data + 7, AX25_ADDR_LEN);
memcpy794net/ax25/ax25_route.cmemcpy(ax25_dev->values, ax25_parms.values, AX25_MAX_VALUES * sizeof(short));
memcpy810net/ax25/ax25_route.cmemcpy(ax25_parms.values, ax25_dev->values, AX25_MAX_VALUES * sizeof(short));
memcpy358net/ax25/ax25_subr.cmemcpy(dest, buf + 0, AX25_ADDR_LEN);
memcpy360net/ax25/ax25_subr.cmemcpy(src,  buf + 7, AX25_ADDR_LEN);
memcpy371net/ax25/ax25_subr.cmemcpy(&digi->calls[d], buf, AX25_ADDR_LEN);
memcpy397net/ax25/ax25_subr.cmemcpy(buf, dest, AX25_ADDR_LEN);
memcpy406net/ax25/ax25_subr.cmemcpy(buf, src, AX25_ADDR_LEN);
memcpy430net/ax25/ax25_subr.cmemcpy(buf, &d->calls[ct], AX25_ADDR_LEN);
memcpy896net/bridge/br.cmemcpy(skb->h.eth->h_dest, bridge_ula, ETH_ALEN);
memcpy897net/bridge/br.cmemcpy(skb->h.eth->h_source, dev->dev_addr, ETH_ALEN);
memcpy917net/bridge/br.cmemcpy(skb->h.raw, config_bpdu, sizeof(Config_bpdu));
memcpy952net/bridge/br.cmemcpy(skb->h.eth->h_dest, bridge_ula, ETH_ALEN);
memcpy953net/bridge/br.cmemcpy(skb->h.eth->h_source, dev->dev_addr, ETH_ALEN);
memcpy973net/bridge/br.cmemcpy(skb->h.raw, bpdu, sizeof(Tcn_bpdu));
memcpy1026net/bridge/br.cmemcpy(bridge_info.bridge_id.BRIDGE_ID_ULA, dev->dev_addr, 6);
memcpy1215net/bridge/br.cmemcpy(f->ula, skb->h.eth->h_source, 6);
memcpy1434net/bridge/br.cmemcpy(&br_stats.bridge_data, &bridge_info, sizeof(Bridge_data));
memcpy1435net/bridge/br.cmemcpy(&br_stats.port_data, &port_info, sizeof(Port_data)*No_of_ports);
memcpy1055net/core/dev.cmemcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
memcpy1205net/core/dev.cmemcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
memcpy123net/core/dev_mcast.cmemcpy(dmi->dmi_addr, addr, alen);
memcpy268net/core/net_alias.cmemcpy(dev->broadcast, main_dev->broadcast, MAX_ADDR_LEN);
memcpy269net/core/net_alias.cmemcpy(dev->dev_addr, main_dev->dev_addr, MAX_ADDR_LEN);
memcpy751net/core/skbuff.cmemcpy(n, skb, sizeof(*n));
memcpy799net/core/skbuff.cmemcpy(n->head,skb->head,skb->end-skb->head);
memcpy815net/core/skbuff.cmemcpy(n->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy110net/ethernet/eth.cmemcpy(eth->h_source,saddr,dev->addr_len);
memcpy112net/ethernet/eth.cmemcpy(eth->h_source,dev->dev_addr,dev->addr_len);
memcpy126net/ethernet/eth.cmemcpy(eth->h_dest,daddr,dev->addr_len);
memcpy152net/ethernet/eth.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy241net/ethernet/eth.cmemcpy(hh->hh_data+6, dev->dev_addr, ETH_ALEN);
memcpy258net/ethernet/eth.cmemcpy(hh->hh_data, haddr, ETH_ALEN);
memcpy269net/ethernet/eth.cmemcpy(dest->data,src,length);
memcpy279net/ethernet/eth.cmemcpy(dest->data,src,length);
memcpy288net/ethernet/eth.cmemcpy(dest->data,src,sizeof(struct iphdr)+ETH_HLEN);  /* ethernet is always >= 34 */
memcpy450net/ipv4/arp.cmemcpy (arpreq.ha, entry->ha, MAX_ADDR_LEN);
memcpy536net/ipv4/arp.cmemcpy (entry->ha, retreq.ha, MAX_ADDR_LEN);
memcpy870net/ipv4/arp.cmemcpy(arp_ptr, src_hw, dev->addr_len);
memcpy872net/ipv4/arp.cmemcpy(arp_ptr, &src_ip,4);
memcpy875net/ipv4/arp.cmemcpy(arp_ptr, target_hw, dev->addr_len);
memcpy879net/ipv4/arp.cmemcpy(arp_ptr, &dest_ip, 4);
memcpy1054net/ipv4/arp.cmemcpy(&sip, arp_ptr, 4);
memcpy1058net/ipv4/arp.cmemcpy(&tip, arp_ptr, 4);
memcpy1140net/ipv4/arp.cmemcpy(ha, proxy_entry->ha, dev->addr_len);
memcpy1197net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1248net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1341net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1359net/ipv4/arp.cmemcpy(haddr, dev->dev_addr, dev->addr_len);
memcpy1383net/ipv4/arp.cmemcpy(haddr, dev->broadcast, dev->addr_len);
memcpy1463net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1982net/ipv4/arp.cmemcpy(entry->ha, ha, dev->addr_len);
memcpy2033net/ipv4/arp.cmemcpy(r->arp_ha.sa_data, &entry->ha, entry->dev->addr_len);
memcpy867net/ipv4/icmp.cmemcpy((void *)&times[0], icmph+1, 4);    /* Incoming stamp */
memcpy315net/ipv4/ip_forward.cmemcpy(ptr, skb->h.raw, skb->len);
memcpy316net/ipv4/ip_forward.cmemcpy(skb2->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy337net/ipv4/ip_forward.cmemcpy(skb_push(skb, dev2->hard_header_len), hh->hh_data, dev2->hard_header_len);
memcpy375net/ipv4/ip_forward.cmemcpy(&optptr[optptr[2]-5], &dev2->pa_addr, 4);
memcpy397net/ipv4/ip_forward.cmemcpy(&optptr[srrptr-1], &dev2->pa_addr, 4);
memcpy407net/ipv4/ip_forward.cmemcpy(&optptr[optptr[2]-9], &dev2->pa_addr, 4);
memcpy267net/ipv4/ip_fragment.cmemcpy(qp->iph, iph, ihlen + 8);
memcpy356net/ipv4/ip_fragment.cmemcpy(ptr, ((unsigned char *) qp->iph), qp->ihlen);
memcpy373net/ipv4/ip_fragment.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
memcpy448net/ipv4/ip_fragment.cmemcpy(qp->iph, iph, ihl+8);
memcpy730net/ipv4/ip_fragment.cmemcpy(skb2->h.raw, raw, hlen);
memcpy735net/ipv4/ip_fragment.cmemcpy(skb2->h.raw + hlen, ptr, len);
memcpy566net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
memcpy608net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
memcpy372net/ipv4/ip_input.cmemcpy(&nexthop, &optptr[srrptr-1], 4);
memcpy386net/ipv4/ip_input.cmemcpy(&daddr, &optptr[srrptr-1], 4);
memcpy511net/ipv4/ip_masq_app.cmemcpy(skb->data + o_offset + n_len,o_buf + o_len,
memcpy515net/ipv4/ip_masq_app.cmemcpy(skb->data + o_offset, n_buf, n_len);
memcpy541net/ipv4/ip_masq_app.cmemcpy(n_skb->data, skb->data, o_offset);
memcpy542net/ipv4/ip_masq_app.cmemcpy(n_skb->data + o_offset, n_buf, n_len);
memcpy543net/ipv4/ip_masq_app.cmemcpy(n_skb->data + o_offset + n_len, o_buf + o_len,
memcpy162net/ipv4/ip_masq_ftp.cmemcpy(p,buf,buf_len);
memcpy204net/ipv4/ip_masq_irc.cmemcpy(addr_beg_p,buf,buf_len);
memcpy35net/ipv4/ip_options.cmemcpy(skb->proto_priv, opt, sizeof(struct options));
memcpy36net/ipv4/ip_options.cmemcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
memcpy41net/ipv4/ip_options.cmemcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
memcpy46net/ipv4/ip_options.cmemcpy(iph+opt->rr+iph[opt->rr+2]-5, &saddr, 4);
memcpy48net/ipv4/ip_options.cmemcpy(iph+opt->ts+iph[opt->ts+2]-9, &saddr, 4);
memcpy55net/ipv4/ip_options.cmemcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
memcpy103net/ipv4/ip_options.cmemcpy(dptr, sptr+sopt->rr, optlen);
memcpy118net/ipv4/ip_options.cmemcpy(dptr, sptr+sopt->ts, optlen);
memcpy138net/ipv4/ip_options.cmemcpy(&addr, sptr+soffset-9, 4);
memcpy164net/ipv4/ip_options.cmemcpy(&faddr, &start[soffset-1], 4);
memcpy166net/ipv4/ip_options.cmemcpy(&dptr[doffset-1], &start[soffset-1], 4);
memcpy175net/ipv4/ip_options.cmemcpy(&start[doffset-1], &daddr, 4);
memcpy309net/ipv4/ip_options.cmemcpy(&opt->faddr, &optptr[3], 4);
memcpy341net/ipv4/ip_options.cmemcpy(&optptr[optptr[2]-1], &skb->dev->pa_addr, 4);
memcpy392net/ipv4/ip_options.cmemcpy(&optptr[ts->ptr-1], &skb->dev->pa_addr, 4);
memcpy408net/ipv4/ip_options.cmemcpy(&addr, &optptr[ts->ptr-1], 4);
memcpy428net/ipv4/ip_options.cmemcpy(timeptr, &midtime, sizeof(__u32));
memcpy100net/ipv4/ip_output.cmemcpy(newskb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy105net/ipv4/ip_output.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
memcpy135net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy168net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy671net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy847net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy470net/ipv4/ip_sockglue.cmemcpy(optbuf, sk->opt, sizeof(struct options)+sk->opt->optlen);
memcpy487net/ipv4/ip_sockglue.cmemcpy(optptr+3, &opt->faddr, 4);
memcpy269net/ipv4/ipmr.cmemcpy(skb->data,pkt->data,ihl);
memcpy387net/ipv4/ipmr.cmemcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
memcpy414net/ipv4/ipmr.cmemcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
memcpy317net/ipv4/packet.cmemcpy(sk->protinfo.af_packet.device_name,name,15);
memcpy249net/ipv4/rarp.cmemcpy(&sip,rarp_ptr,4);
memcpy253net/ipv4/rarp.cmemcpy(&tip,rarp_ptr,4);
memcpy372net/ipv4/rarp.cmemcpy(&entry->ha, &r.arp_ha.sa_data, hlen);
memcpy426net/ipv4/rarp.cmemcpy(r.arp_ha.sa_data, &entry->ha, entry->hlen);
memcpy235net/ipv4/raw.cmemcpy(&sin, usin, sizeof(sin));
memcpy827net/ipv4/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
memcpy1928net/ipv4/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
memcpy374net/ipv4/tcp_input.cmemcpy(newsk, sk, sizeof(*newsk));
memcpy412net/ipv4/tcp_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy634net/ipv4/tcp_output.cmemcpy(t1, th, sizeof(*t1));
memcpy714net/ipv4/tcp_output.cmemcpy(t1, skb->h.th, sizeof(*t1));
memcpy865net/ipv4/tcp_output.cmemcpy(t1, &sk->dummy_th, sizeof(*t1));
memcpy979net/ipv4/tcp_output.cmemcpy(nth, th, sizeof(*th));
memcpy1037net/ipv4/tcp_output.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
memcpy258net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy290net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy567net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
memcpy665net/ipx/af_ipx.cmemcpy(dest_node, dev->broadcast, addr_len);
memcpy667net/ipx/af_ipx.cmemcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
memcpy833net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
memcpy931net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
memcpy935net/ipx/af_ipx.cmemcpy(intrfc->if_node, idef->ipx_node, IPX_NODE_LEN);
memcpy1009net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
memcpy1036net/ipx/af_ipx.cmemcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
memcpy1037net/ipx/af_ipx.cmemcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
memcpy1064net/ipx/af_ipx.cmemcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
memcpy1123net/ipx/af_ipx.cmemcpy(rt->ir_router_node, node, IPX_NODE_LEN);
memcpy1290net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
memcpy1296net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
memcpy1301net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
memcpy1306net/ipx/af_ipx.cmemcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
memcpy1386net/ipx/af_ipx.cmemcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
memcpy1806net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node,
memcpy1811net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, addr->sipx_node, IPX_NODE_LEN);
memcpy1830net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node, 
memcpy1884net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc->if_node,
memcpy1896net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.dest_addr.node,
memcpy1934net/ipx/af_ipx.cmemcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
memcpy1940net/ipx/af_ipx.cmemcpy(sipx.sipx_node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
memcpy1942net/ipx/af_ipx.cmemcpy(sipx.sipx_node, 
memcpy1955net/ipx/af_ipx.cmemcpy(uaddr,&sipx,sizeof(sipx));
memcpy2082net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc
memcpy2104net/ipx/af_ipx.cmemcpy(usipx->sipx_node,sk->protinfo.af_ipx.dest_addr.node,IPX_NODE_LEN);
memcpy2149net/ipx/af_ipx.cmemcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
memcpy1206net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 7, AX25_ADDR_LEN);
memcpy82net/netrom/nr_dev.cmemcpy(buff, (saddr != NULL) ? saddr : dev->dev_addr, dev->addr_len);
memcpy89net/netrom/nr_dev.cmemcpy(buff, daddr, dev->addr_len);
memcpy155net/netrom/nr_dev.cmemcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
memcpy77net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy82net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy59net/netrom/nr_out.cmemcpy(transport, skb->data, NR_TRANSPORT_LEN);
memcpy77net/netrom/nr_out.cmemcpy(skb_put(skbn, len), skb->data, len);
memcpy82net/netrom/nr_out.cmemcpy(skbn->data, transport, NR_TRANSPORT_LEN);
memcpy211net/netrom/nr_out.cmemcpy(dptr, &sk->nr->source_addr, AX25_ADDR_LEN);
memcpy217net/netrom/nr_out.cmemcpy(dptr, &sk->nr->dest_addr, AX25_ADDR_LEN);
memcpy121net/netrom/nr_route.cmemcpy(&nr_node->mnemonic, mnemonic, sizeof(nr_node->mnemonic));
memcpy195net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->user_addr, AX25_ADDR_LEN);
memcpy200net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->source_addr, AX25_ADDR_LEN);
memcpy261net/netrom/nr_subr.cmemcpy(dptr, skb->data + 7, AX25_ADDR_LEN);
memcpy267net/netrom/nr_subr.cmemcpy(dptr, skb->data + 0, AX25_ADDR_LEN);
memcpy415net/unix/af_unix.cmemcpy(sk->protinfo.af_unix.name, sunaddr->sun_path, addr_len+1);
memcpy808net/unix/af_unix.cmemcpy(&fdnum,skb->h.filp,sizeof(int));
memcpy861net/unix/af_unix.cmemcpy(skb->h.filp,&fpnum,sizeof(int));
memcpy863net/unix/af_unix.cmemcpy(skb->h.filp+sizeof(int),fp,fpnum*sizeof(struct file *));
memcpy1127net/unix/af_unix.cmemcpy(sunaddr->sun_path, skb->sk->protinfo.af_unix.name, 108);