taglinefilesource code
memcpy77arch/alpha/boot/tools/build.cmemcpy(bootblock, "Linux Test", 10);
memcpy77arch/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);
memcpy162arch/i386/boot/compressed/misc.cmemcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
memcpy281arch/i386/kernel/process.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
memcpy309arch/i386/kernel/process.cmemcpy(fpu,&current->tss.i387.hard,sizeof(*fpu));
memcpy142arch/i386/kernel/setup.cmemcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
memcpy162arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_oem,8);
memcpy165arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_productid,12);
memcpy229arch/i386/kernel/smp.cmemcpy(str,m->mpc_bustype,6);
memcpy383arch/i386/kernel/smp.cmemcpy(mp,trampoline_data,sizeof(trampoline_data));
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));
memcpy197arch/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),
memcpy214arch/sparc/kernel/process.cmemcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
memcpy223arch/sparc/kernel/process.cmemcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->tss.float_regs[0], (sizeof(unsigned long) * 32));
memcpy227arch/sparc/kernel/process.cmemcpy(&dump->fpu.fpstatus.fpq[0], &current->tss.fpqueue[0],
memcpy182arch/sparc/kernel/signal.cmemcpy(&sc->sigc_wbuf[window],
memcpy187arch/sparc/kernel/signal.cmemcpy(sframep, (char *)regs->u_regs[UREG_FP],
memcpy316arch/sparc/kernel/signal.cmemcpy(ossptr, &current->tss.sstk_info, sizeof(struct sigstack));
memcpy323arch/sparc/kernel/signal.cmemcpy(&current->tss.sstk_info, ssptr, sizeof(struct sigstack));
memcpy579arch/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));
memcpy2304drivers/block/floppy.cmemcpy(buffer, dma_buffer, size);
memcpy2306drivers/block/floppy.cmemcpy(dma_buffer, buffer, size);
memcpy2853drivers/block/floppy.cmemcpy(old_raw_cmd.reply, ptr->reply, 7);
memcpy2919drivers/block/floppy.cmemcpy(ptr->cmd, old_raw_cmd.cmd, 9);
memcpy3339drivers/block/floppy.cmemcpy((char *) UDP,
memcpy1075drivers/block/ide-cd.cmemcpy (rq->buffer,
memcpy4385drivers/block/ide-tape.cmemcpy (ptr,bh->data,IDETAPE_ALLOCATION_BLOCK);
memcpy4423drivers/block/ide-tape.cmemcpy (bh->data,ptr,IDETAPE_ALLOCATION_BLOCK);
memcpy50drivers/block/loop.cmemcpy(loop_buf, raw_buf, size);
memcpy52drivers/block/loop.cmemcpy(raw_buf, loop_buf, size);
memcpy311drivers/block/loop.cmemcpy(lo->lo_des_init,info.lo_init,8);
memcpy323drivers/block/loop.cmemcpy(lo->lo_encrypt_key, info.lo_encrypt_key,
memcpy348drivers/block/loop.cmemcpy(info.lo_encrypt_key, lo->lo_encrypt_key,
memcpy981drivers/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);
memcpy613drivers/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,
memcpy1650drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1653drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy64drivers/char/ftape/ftape-bsm.cmemcpy(list, bad_sector_map, sizeof(list));
memcpy118drivers/char/ftape/ftape-bsm.cmemcpy(buffer + offset, bad_sector_map, count);
memcpy157drivers/char/ftape/ftape-bsm.cmemcpy(bad_sector_map, buffer + 256, sizeof(bad_sector_map));
memcpy162drivers/char/ftape/ftape-bsm.cmemcpy(bad_sector_map, buffer + 256 + FAILED_SECTOR_LOG_SIZE,
memcpy331drivers/char/ftape/ftape-eof.cmemcpy(buffer + 30, linux_tape_label, strlen(linux_tape_label));
memcpy384drivers/char/ftape/ftape-eof.cmemcpy(eof_map, start, end - start);
memcpy392drivers/char/ftape/ftape-eof.cmemcpy(eof_map, address + 256, sizeof(eof_map));
memcpy434drivers/char/ftape/ftape-eof.cmemcpy(dest, eof_map, nr_of_eof_marks * sizeof(unsigned long));
memcpy438drivers/char/ftape/ftape-eof.cmemcpy(buffer + 256, eof_map, sizeof(eof_map));
memcpy140drivers/char/ftape/ftape-read.cmemcpy(destination, mseg.data, (mseg.blocks - 3) * SECTOR_SIZE);
memcpy91drivers/char/ftape/ftape-write.cmemcpy(mseg.data, source, (mseg.blocks - 3) * SECTOR_SIZE);
memcpy1508drivers/char/istallion.cmemcpy((shbuf + head), chbuf, stlen);
memcpy1639drivers/char/istallion.cmemcpy((shbuf + head), buf, stlen);
memcpy2296drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), arg, size);
memcpy2360drivers/char/istallion.cmemcpy(tty->flip.char_buf_ptr, (char *) (shbuf + tail), stlen);
memcpy2406drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &portp->asig, sizeof(asysigs_t));
memcpy2415drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
memcpy2490drivers/char/istallion.cmemcpy(portp->argp, (void *) &(cp->args[0]), portp->argsize);
memcpy2624drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->hostoffset), bitsize);
memcpy2646drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->slaveoffset), bitsize);
memcpy2669drivers/char/istallion.cmemcpy((((unsigned char *) hdrp) + brdp->slaveoffset), &bits[0], bitsize);
memcpy3515drivers/char/istallion.cmemcpy(&sig, sigsp, sizeof(cdkecpsig_t));
memcpy3668drivers/char/istallion.cmemcpy(&sig, sigsp, sizeof(cdkonbsig_t));
memcpy3928drivers/char/istallion.cmemcpy(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
memcpy3933drivers/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);
memcpy624drivers/char/random.cmemcpy(buf, (__u8 const *)tmp, i);
memcpy2494drivers/char/scc.cmemcpy(scc_wbuf, buf, cnt);
memcpy1349drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1351drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy947drivers/char/stallion.cmemcpy(head, chbuf, stlen);
memcpy1803drivers/char/tty_io.cmemcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
memcpy306drivers/isdn/icn/icn.cmemcpy(&dev->rcvbuf[channel][dev->rcvidx[channel]], rbuf_d, cnt);
memcpy369drivers/isdn/icn/icn.cmemcpy(sbuf_d, dev->spqueue[channel]->rptr, cnt);
memcpy700drivers/isdn/icn/icn.cmemcpy(p, buffer, len);
memcpy981drivers/isdn/icn/icn.cmemcpy(msg, buf, count);
memcpy1057drivers/isdn/icn/icn.cmemcpy(&a, c->num, sizeof(ulong));
memcpy1410drivers/isdn/icn/icn.cmemcpy((char *) dev2, (char *) dev, sizeof(icn_dev));
memcpy272drivers/isdn/isdn_common.cmemcpy(p, buf, len);
memcpy620drivers/isdn/isdn_common.cmemcpy(cp, p->rptr, copy_l);
memcpy1340drivers/isdn/isdn_common.cmemcpy(c.num, (char *) &iocts.arg, sizeof(ulong));
memcpy1342drivers/isdn/isdn_common.cmemcpy((char *) &iocts.arg, c.num, sizeof(ulong));
memcpy1628drivers/isdn/isdn_common.cmemcpy(skb_put(skb, len), buf, len);
memcpy103drivers/isdn/isdn_net.cmemcpy(&(dev->dev_addr[i]), &dev->pa_addr, sizeof(ulong));
memcpy1008drivers/isdn/isdn_net.cmemcpy(skb_put(skb, len), buf, len);
memcpy1057drivers/isdn/isdn_net.cmemcpy(eth->h_source,saddr,dev->addr_len);
memcpy1059drivers/isdn/isdn_net.cmemcpy(eth->h_source,dev->dev_addr,dev->addr_len);
memcpy1071drivers/isdn/isdn_net.cmemcpy(eth->h_dest,daddr,dev->addr_len);
memcpy1157drivers/isdn/isdn_net.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy435drivers/isdn/isdn_ppp.cmemcpy(bl->buf, buf, len);
memcpy753drivers/isdn/isdn_ppp.cmemcpy(skb->data, skb_old->data, skb_old->len);
memcpy830drivers/isdn/isdn_ppp.cmemcpy(skb->data+len,buf,pktlen);
memcpy1070drivers/isdn/isdn_ppp.cmemcpy((*skb)->data + cnt, q->skb->data, q->skb->len);
memcpy67drivers/isdn/isdn_tty.cmemcpy(tty->flip.char_buf_ptr, buf, len);
memcpy394drivers/isdn/isdn_tty.cmemcpy(&(info->xmit_buf[info->xmit_count]), buf, c);
memcpy412drivers/isdn/isdn_tty.cmemcpy(bufptr, "\1\0\1\0", 4);
memcpy1109drivers/isdn/isdn_tty.cmemcpy(m->mdmreg, m->profile, ISDN_MODEM_ANZREG);
memcpy1110drivers/isdn/isdn_tty.cmemcpy(m->msn, m->pmsn, ISDN_MSNLEN);
memcpy1117drivers/isdn/isdn_tty.cmemcpy(m->profile, m->mdmreg, ISDN_MODEM_ANZREG);
memcpy1118drivers/isdn/isdn_tty.cmemcpy(m->pmsn, m->msn, ISDN_MSNLEN);
memcpy2017drivers/isdn/isdn_tty.cmemcpy(bufptr, "\1\0\1\0", 4);
memcpy1293drivers/isdn/teles/callc.cmemcpy(ptr, buf, count);
memcpy891drivers/isdn/teles/card.cmemcpy(DATAPTR(cibh), DATAPTR(ibh), ibh->datasize);
memcpy1595drivers/isdn/teles/card.cmemcpy(&cards[i],&cards[i+1],sizeof(cards[i]));
memcpy305drivers/net/3c501.cmemcpy(dev->dev_addr, station_addr, ETH_ALEN);
memcpy1193drivers/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);
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);
memcpy1348drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
memcpy1365drivers/net/arcnet.cmemcpy(lp->sdev,dev,sizeof(struct device));
memcpy1805drivers/net/arcnet.cmemcpy((u_char*)arcsoft,
memcpy1815drivers/net/arcnet.cmemcpy((u_char*)arcsoft+hdrlen,
memcpy2313drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2444drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2495drivers/net/arcnet.cmemcpy(skb->data+skb->len,
memcpy2837drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
memcpy2889drivers/net/arcnet.cmemcpy(skb->data,(u_char *)arcsoft+1,length-1);
memcpy3024drivers/net/arcnet.cmemcpy((u_char *)soft + sizeof(struct S_ClientData)
memcpy1211drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
memcpy1212drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
memcpy1214drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
memcpy3217drivers/net/de4x5.cmemcpy((char *)&lp->phy[k],
memcpy1842drivers/net/depca.cmemcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
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 );
memcpy1161drivers/net/ibmtr.cmemcpy(dhb,ti->current_skb->data,hdr_len);
memcpy1168drivers/net/ibmtr.cmemcpy(dhb,ti->current_skb->data+sizeof(struct trh_hdr),
memcpy1250drivers/net/ibmtr.cmemcpy(data,&(rbuffer->data),lan_hdr_len);
memcpy1261drivers/net/ibmtr.cmemcpy(data,(unsigned char *)(&(rbuffer->data))+lan_hdr_len,rbuffer_len);
memcpy1267drivers/net/ibmtr.cmemcpy(data,&(rbuffer->data),rbuffer_len=ntohs(rbuffer->buf_len)),rbuffer->buf_ptr;
memcpy799drivers/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);
memcpy254drivers/net/new_tunnel.cmemcpy(new_skb->ip_hdr, skb->data, skb->len);
memcpy256drivers/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);
memcpy869drivers/net/plip.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy875drivers/net/plip.cmemcpy(&(eth->h_dest[i]), &dst, sizeof(unsigned long));
memcpy966drivers/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);
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);  /*    ""      ""       ""    "" */
memcpy368drivers/net/sunlance.cmemcpy (buf, (char *) &(ib->rx_buf [lp->rx_new][0]), pkt_len);
memcpy641drivers/net/sunlance.cmemcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
memcpy621drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, 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);
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);
memcpy1103drivers/scsi/53c7,8xx.cmemcpy ((void *) hostdata->synchronous_want, (void *) sdtr_message, 
memcpy1604drivers/scsi/53c7,8xx.cmemcpy ((void *) hostdata->script, (void *) SCRIPT, 
memcpy1991drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
memcpy2990drivers/scsi/53c7,8xx.cmemcpy ((void *) event->cmnd, (void *) c->cmnd, 
memcpy3083drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->addr, (void *) bp->old, sizeof(bp->old));
memcpy3158drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
memcpy3163drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
memcpy3265drivers/scsi/53c7,8xx.cmemcpy (hostdata->debug_write, buf, copy);
memcpy3658drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) wdtr_message,
memcpy3666drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) sdtr_message, 
memcpy3679drivers/scsi/53c7,8xx.cmemcpy ((void *) (tmp->select + 1), (void *) async_message, 
memcpy6299drivers/scsi/53c7,8xx.cmemcpy ((void *) &event, (void *) &(hostdata->events[i]),
memcpy1022drivers/scsi/BusLogic.cmemcpy(HostAdapter->ErrorRecoveryOption,
memcpy1485drivers/scsi/BusLogic.cmemcpy(HostAdapter->InstalledDevices, InstalledDevicesID0to7,
memcpy1487drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousValues,
memcpy1492drivers/scsi/BusLogic.cmemcpy(&HostAdapter->InstalledDevices[8], InstalledDevicesID8to15,
memcpy1494drivers/scsi/BusLogic.cmemcpy(&HostAdapter->SynchronousValues[8],
memcpy1498drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousPeriod, SynchronousPeriod,
memcpy1618drivers/scsi/BusLogic.cmemcpy(HostAdapter, &HostAdapterPrototype,
memcpy2165drivers/scsi/BusLogic.cmemcpy(CCB->CDB, CDB, CDB_Length);
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);
memcpy2053drivers/scsi/aic7xxx.cmemcpy((void *) scb->sense_cmd, (void *) generic_sense,
memcpy2070drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr,
memcpy2073drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &req_buf,
memcpy2076drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(scb->sense_sg.address), 4);
memcpy4092drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr, sizeof(scb->SCSI_cmd_pointer));
memcpy4097drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &cmd->request_buffer,
memcpy4099drivers/scsi/aic7xxx.cmemcpy(&sg, &cmd->request_buffer, sizeof(sg));
memcpy4100drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(sg[0].address), sizeof(scb->data_pointer));
memcpy4131drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &addr, sizeof(scb->SG_list_pointer));
memcpy4133drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &cmd->request_buffer, sizeof(scb->data_pointer));
memcpy698drivers/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));
memcpy1035drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1038drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
memcpy1044drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
memcpy1057drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1062drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1958drivers/scsi/fdomain.cmemcpy( data, do_read, sizeof( do_read ) );
memcpy635drivers/scsi/scsi.cmemcpy (SDpnt->vendor, scsi_result + 8, 8);
memcpy636drivers/scsi/scsi.cmemcpy (SDpnt->model, scsi_result + 16, 16);
memcpy637drivers/scsi/scsi.cmemcpy (SDpnt->rev, scsi_result + 32, 4);
memcpy903drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1053drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1206drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) generic_sense, 
memcpy1286drivers/scsi/scsi.cmemcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
memcpy1301drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
memcpy1702drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd,
memcpy2648drivers/scsi/scsi.cmemcpy(new_dma_malloc_freelist, dma_malloc_freelist, size);
memcpy2656drivers/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);
memcpy1668drivers/scsi/seagate.cmemcpy (data, cmd, 6);
memcpy1681drivers/scsi/seagate.cmemcpy (data, cmd, 6);
memcpy278drivers/scsi/sg.cmemcpy(device->header.sense_buffer, SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
memcpy164drivers/scsi/sr.cmemcpy((char *)SCpnt->request.buffer, 
memcpy176drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
memcpy191drivers/scsi/sr.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
memcpy274drivers/scsi/st.cmemcpy(STbuffer->b_data,
memcpy636drivers/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);
memcpy1404drivers/sound/ad1848.cmemcpy ((char *) &ad1848_pcm_operations[nr_ad1848_devs],
memcpy1624drivers/sound/gus_wave.cmemcpy ((char *) &samples[free_sample], &patch, sizeof_patch);
memcpy2593drivers/sound/gus_wave.cmemcpy (rec->data.data8, (char *) &samples[ptr],
memcpy2620drivers/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);
memcpy136drivers/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);
memcpy103fs/binfmt_aout.cmemcpy(corefile,"core.",5);
memcpy105fs/binfmt_aout.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy974fs/binfmt_elf.cmemcpy(elf.e_ident, ELFMAG, SELFMAG);
memcpy996fs/binfmt_elf.cmemcpy(corefile,"core.",5);
memcpy998fs/binfmt_elf.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy1129fs/buffer.cmemcpy(next->b_data, tmp->b_data, size);
memcpy1131fs/buffer.cmemcpy(tmp->b_data, next->b_data, size);
memcpy55fs/dcache.cmemcpy((void *) &newde->dc_dev, (void *) &de->dc_dev, \
memcpy209fs/dcache.cmemcpy(de->name, name, len);
memcpy598fs/dquot.cmemcpy(&dq_dqblk, dqblk, sizeof(struct dqblk));
memcpy310fs/ext2/namei.cmemcpy (de->name, name, namelen);
memcpy81fs/fat/cache.cmemcpy(c_bh->b_data,bh->b_data,SECTOR_SIZE);
memcpy91fs/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
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);
memcpy459fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
memcpy467fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy734fs/isofs/inode.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
memcpy745fs/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); \
memcpy441fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
memcpy449fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy275fs/msdos/namei.cmemcpy(de->name,name,MSDOS_NAME);
memcpy583fs/msdos/namei.cmemcpy(old_de->name,new_name,MSDOS_NAME);
memcpy671fs/msdos/namei.cmemcpy(free_de,old_de,sizeof(struct msdos_dir_entry));
memcpy672fs/msdos/namei.cmemcpy(free_de->name,new_name,MSDOS_NAME);
memcpy782fs/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);
memcpy263fs/ncpfs/ncplib_kernel.cmemcpy(target, structure, info_struct_size);
memcpy407fs/ncpfs/ncplib_kernel.cmemcpy(&(dest[1]), &sfd, 4);
memcpy495fs/ncpfs/ncplib_kernel.cmemcpy(target, ncp_reply_data(server, 0), sizeof(*target));
memcpy526fs/ncpfs/ncplib_kernel.cmemcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
memcpy347fs/nfs/dir.cmemcpy(name,__name,len);
memcpy172fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
memcpy239fs/nfs/nfsroot.cmemcpy(&sip, rarp_ptr, 4);
memcpy243fs/nfs/nfsroot.cmemcpy(&tip, rarp_ptr, 4);
memcpy700fs/nfs/nfsroot.cmemcpy(&nfs_file, filp, sizeof(struct file));
memcpy705fs/nfs/nfsroot.cmemcpy(&nfs_inode, nfs_file.f_inode, sizeof(struct inode));
memcpy925fs/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);
memcpy85fs/nfs/symlink.cmemcpy(res2, res, len);
memcpy477fs/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));
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);
memcpy202fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
memcpy234fs/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);
memcpy854fs/vfat/namei.cmemcpy(de, ps, sizeof(struct msdos_dir_slot));
memcpy1035fs/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))
memcpy285include/asm-i386/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy299include/asm-i386/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))
memcpy120include/asm-sparc/checksum.hmemcpy(dst, src, len);
memcpy103include/asm-sparc/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy105include/asm-sparc/segment.h#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
memcpy364include/asm-sparc/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy378include/asm-sparc/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy967include/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);
memcpy122ipc/msg.cmemcpy(msgh->msg_spot, (char *)(&(kdmp->id)), sizeof(long)); 
memcpy123ipc/msg.cmemcpy(msgh->msg_spot + sizeof(long), kdmp->text,
memcpy258ipc/msg.cmemcpy((char *)(&(kdmp->id)),
memcpy266ipc/msg.cmemcpy(kdmp->text,
memcpy169kernel/fork.cmemcpy(&tsk->files->close_on_exec, &current->files->close_on_exec,
memcpy190kernel/fork.cmemcpy(tsk->sig->action, current->sig->action, sizeof(tsk->sig->action));
memcpy784kernel/module.cmemcpy(newtab, intab, SYMSIZ + intab->n_symbols * INTSIZ);
memcpy790kernel/module.cmemcpy( ((char *)newtab) + SYMSIZ + intab->n_symbols * INTSIZ,
memcpy585lib/inflate.cmemcpy(slide + w, slide + d, e);
memcpy217mm/filemap.cmemcpy((void *) (offset + addr), buf, len);
memcpy487mm/filemap.cmemcpy((void *) new_page, (void *) page, PAGE_SIZE);
memcpy75mm/memory.cmemcpy((void *) to, (void *) from, PAGE_SIZE);
memcpy185mm/memory.cmemcpy(new_pg + USER_PTRS_PER_PGD, page_dir + USER_PTRS_PER_PGD,
memcpy77net/802/psnap.cmemcpy(skb_push(skb,5),dl->type,5);
memcpy106net/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));
memcpy133net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy193net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy202net/appletalk/aarp.cmemcpy(eah->hw_dst, sha, ETH_ALEN);
memcpy257net/appletalk/aarp.cmemcpy(eah->hw_src, dev->dev_addr, ETH_ALEN);
memcpy742net/appletalk/aarp.cmemcpy(a->hwaddr,ea->hw_src,ETH_ALEN);
memcpy1364net/appletalk/ddp.cmemcpy(uaddr,&sat,sizeof(sat));
memcpy2338net/ax25/af_ax25.cmemcpy(buff, daddr, dev->addr_len);  /* Address specified */
memcpy2346net/ax25/af_ax25.cmemcpy(buff, saddr, dev->addr_len);
memcpy2348net/ax25/af_ax25.cmemcpy(buff, dev->dev_addr, dev->addr_len);
memcpy97net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy102net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy90net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
memcpy458net/ax25/ax25_route.cmemcpy(&dest, skb->data + 1, AX25_ADDR_LEN);
memcpy459net/ax25/ax25_route.cmemcpy(&src,  skb->data + 8, AX25_ADDR_LEN);
memcpy644net/ax25/ax25_route.cmemcpy(ax25_dev->values, ax25_parms.values, AX25_MAX_VALUES * sizeof(short));
memcpy659net/ax25/ax25_route.cmemcpy(ax25_parms.values, ax25_dev->values, AX25_MAX_VALUES * sizeof(short));
memcpy355net/ax25/ax25_subr.cmemcpy(dest, buf + 0, AX25_ADDR_LEN);
memcpy357net/ax25/ax25_subr.cmemcpy(src,  buf + 7, AX25_ADDR_LEN);
memcpy368net/ax25/ax25_subr.cmemcpy(&digi->calls[d], buf, AX25_ADDR_LEN);
memcpy394net/ax25/ax25_subr.cmemcpy(buf, dest, AX25_ADDR_LEN);
memcpy403net/ax25/ax25_subr.cmemcpy(buf, src, AX25_ADDR_LEN);
memcpy427net/ax25/ax25_subr.cmemcpy(buf, &d->calls[ct], AX25_ADDR_LEN);
memcpy1036net/core/dev.cmemcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
memcpy1180net/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);
memcpy638net/core/skbuff.cmemcpy(n, skb, sizeof(*n));
memcpy690net/core/skbuff.cmemcpy(n->head,skb->head,skb->end-skb->head);
memcpy706net/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 */
memcpy683net/ipv4/arp.cmemcpy(arp_ptr, src_hw, dev->addr_len);
memcpy685net/ipv4/arp.cmemcpy(arp_ptr, &src_ip,4);
memcpy688net/ipv4/arp.cmemcpy(arp_ptr, target_hw, dev->addr_len);
memcpy692net/ipv4/arp.cmemcpy(arp_ptr, &dest_ip, 4);
memcpy866net/ipv4/arp.cmemcpy(&sip, arp_ptr, 4);
memcpy870net/ipv4/arp.cmemcpy(&tip, arp_ptr, 4);
memcpy952net/ipv4/arp.cmemcpy(ha, proxy_entry->ha, dev->addr_len);
memcpy1004net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1045net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1133net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1149net/ipv4/arp.cmemcpy(haddr, dev->dev_addr, dev->addr_len);
memcpy1173net/ipv4/arp.cmemcpy(haddr, dev->broadcast, dev->addr_len);
memcpy1251net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1765net/ipv4/arp.cmemcpy(entry->ha, ha, dev->addr_len);
memcpy1812net/ipv4/arp.cmemcpy(r->arp_ha.sa_data, &entry->ha, entry->dev->addr_len);
memcpy598net/ipv4/icmp.cmemcpy((void *)&times[0], icmph+1, 4);    /* Incoming stamp */
memcpy306net/ipv4/ip_forward.cmemcpy(ptr, skb->h.raw, skb->len);
memcpy307net/ipv4/ip_forward.cmemcpy(skb2->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy328net/ipv4/ip_forward.cmemcpy(skb_push(skb, dev2->hard_header_len), hh->hh_data, dev2->hard_header_len);
memcpy366net/ipv4/ip_forward.cmemcpy(&optptr[optptr[2]-5], &dev2->pa_addr, 4);
memcpy388net/ipv4/ip_forward.cmemcpy(&optptr[srrptr-1], &dev2->pa_addr, 4);
memcpy398net/ipv4/ip_forward.cmemcpy(&optptr[optptr[2]-9], &dev2->pa_addr, 4);
memcpy280net/ipv4/ip_fragment.cmemcpy(qp->iph, iph, ihlen + 8);
memcpy369net/ipv4/ip_fragment.cmemcpy(ptr, ((unsigned char *) qp->iph), qp->ihlen);
memcpy386net/ipv4/ip_fragment.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
memcpy461net/ipv4/ip_fragment.cmemcpy(qp->iph, iph, ihl+8);
memcpy747net/ipv4/ip_fragment.cmemcpy(skb2->h.raw, raw, hlen);
memcpy752net/ipv4/ip_fragment.cmemcpy(skb2->h.raw + hlen, ptr, len);
memcpy729net/ipv4/ip_fw.cmemcpy(p,buf,strlen(buf));
memcpy777net/ipv4/ip_fw.cmemcpy(skb2->data, skb->data, (p - (char *)skb->data));
memcpy778net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
memcpy779net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
memcpy1078net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
memcpy1116net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
memcpy369net/ipv4/ip_input.cmemcpy(&nexthop, &optptr[srrptr-1], 4);
memcpy383net/ipv4/ip_input.cmemcpy(&daddr, &optptr[srrptr-1], 4);
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));
memcpy95net/ipv4/ip_output.cmemcpy(newskb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy100net/ipv4/ip_output.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
memcpy130net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy163net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy667net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy843net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy459net/ipv4/ip_sockglue.cmemcpy(optbuf, sk->opt, sizeof(struct options)+sk->opt->optlen);
memcpy476net/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));
memcpy308net/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);
memcpy213net/ipv4/raw.cmemcpy(&sin, usin, sizeof(sin));
memcpy839net/ipv4/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
memcpy1263net/ipv4/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
memcpy2022net/ipv4/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
memcpy371net/ipv4/tcp_input.cmemcpy(newsk, sk, sizeof(*newsk));
memcpy405net/ipv4/tcp_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy627net/ipv4/tcp_output.cmemcpy(t1, th, sizeof(*t1));
memcpy707net/ipv4/tcp_output.cmemcpy(t1, skb->h.th, sizeof(*t1));
memcpy809net/ipv4/tcp_output.cmemcpy(t1, &sk->dummy_th, sizeof(*t1));
memcpy954net/ipv4/tcp_output.cmemcpy(nth, th, sizeof(*th));
memcpy1012net/ipv4/tcp_output.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
memcpy260net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy292net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy554net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
memcpy652net/ipx/af_ipx.cmemcpy(dest_node, dev->broadcast, addr_len);
memcpy654net/ipx/af_ipx.cmemcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
memcpy819net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
memcpy910net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), dev->dev_addr, dev->addr_len);
memcpy984net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
memcpy1011net/ipx/af_ipx.cmemcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
memcpy1012net/ipx/af_ipx.cmemcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
memcpy1039net/ipx/af_ipx.cmemcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
memcpy1098net/ipx/af_ipx.cmemcpy(rt->ir_router_node, node, IPX_NODE_LEN);
memcpy1207net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
memcpy1213net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
memcpy1218net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
memcpy1223net/ipx/af_ipx.cmemcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
memcpy1294net/ipx/af_ipx.cmemcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
memcpy1728net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node,
memcpy1733net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, addr->sipx_node, IPX_NODE_LEN);
memcpy1752net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node, 
memcpy1806net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc->if_node,
memcpy1818net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.dest_addr.node,
memcpy1854net/ipx/af_ipx.cmemcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
memcpy1860net/ipx/af_ipx.cmemcpy(sipx.sipx_node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
memcpy1862net/ipx/af_ipx.cmemcpy(sipx.sipx_node, 
memcpy1875net/ipx/af_ipx.cmemcpy(uaddr,&sipx,sizeof(sipx));
memcpy1997net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc
memcpy2019net/ipx/af_ipx.cmemcpy(usipx->sipx_node,sk->protinfo.af_ipx.dest_addr.node,IPX_NODE_LEN);
memcpy2063net/ipx/af_ipx.cmemcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
memcpy1145net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 7, AX25_ADDR_LEN);
memcpy80net/netrom/nr_dev.cmemcpy(buff, (saddr != NULL) ? saddr : dev->dev_addr, dev->addr_len);
memcpy87net/netrom/nr_dev.cmemcpy(buff, daddr, dev->addr_len);
memcpy144net/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);
memcpy430net/unix/af_unix.cmemcpy(sk->protinfo.af_unix.name, sunaddr->sun_path, addr_len+1);
memcpy816net/unix/af_unix.cmemcpy(&fdnum,skb->h.filp,sizeof(int));
memcpy866net/unix/af_unix.cmemcpy(skb->h.filp,&fpnum,sizeof(int));
memcpy867net/unix/af_unix.cmemcpy(skb->h.filp+sizeof(int),fp,fpnum*sizeof(struct file *));
memcpy1121net/unix/af_unix.cmemcpy(sunaddr->sun_path, skb->sk->protinfo.af_unix.name, 108);