taglinefilesource code
memcpy77arch/alpha/boot/tools/build.cmemcpy(bootblock, "Linux Test", 10);
memcpy200arch/alpha/kernel/process.cmemcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8);
memcpy159arch/alpha/lib/checksum.cmemcpy(dst, src, len);
memcpy404arch/i386/boot/compressed/inflate.cmemcpy(slide + w, slide + d, e);
memcpy124arch/i386/boot/compressed/misc.cmemcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
memcpy251arch/i386/boot/compressed/misc.cmemcpy(&output_data[output_ptr], (char *)window, outcnt);
memcpy211arch/i386/kernel/process.cmemcpy(p->ldt, current->ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
memcpy239arch/i386/kernel/process.cmemcpy(fpu,&current->tss.i387.hard,sizeof(*fpu));
memcpy134arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_oem,8);
memcpy137arch/i386/kernel/smp.cmemcpy(str,mpc->mpc_productid,12);
memcpy193arch/i386/kernel/smp.cmemcpy(str,m->mpc_bustype,6);
memcpy341arch/i386/kernel/smp.cmemcpy(mp,trampoline_data,sizeof(trampoline_data));
memcpy155arch/mips/kernel/process.cmemcpy(&dump->i387,&current->tss.i387.hard,sizeof(dump->i387));
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);
memcpy3342drivers/block/floppy.cmemcpy((char *) UDP,
memcpy1068drivers/block/ide-cd.cmemcpy (rq->buffer,
memcpy49drivers/block/ramdisk.c(void ) memcpy(addr,
memcpy53drivers/block/ramdisk.c(void) memcpy(CURRENT->buffer, 
memcpy183drivers/block/ramdisk.c(void) memcpy(cp, bh->b_data, BLOCK_SIZE);
memcpy977drivers/cdrom/aztcd.cmemcpy(CURRENT -> buffer, azt_buf + offs, nr_sectors * 512);
memcpy1307drivers/cdrom/cdu31a.cmemcpy(buffer,
memcpy1318drivers/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);
memcpy625drivers/cdrom/mcd.cmemcpy(CURRENT -> buffer, mcd_buf + offs, nr_sectors * 512);
memcpy697drivers/cdrom/optcd.cmemcpy(CURRENT -> buffer, opt_buf + offs, nr_sectors * 512);
memcpy4355drivers/cdrom/sbpcd.cmemcpy(CURRENT->buffer, D_S[d].sbp_buf + offs, 512);
memcpy1006drivers/cdrom/sjcd.cmemcpy( CURRENT->buffer, sjcd_buf + offs, nr_sectors * 512 );
memcpy677drivers/cdrom/sonycd535.cmemcpy(toc->tracks + i, track_address_buffer, 5);
memcpy908drivers/cdrom/sonycd535.cmemcpy(CURRENT->buffer,
memcpy1644drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1647drivers/char/cyclades.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy1463drivers/char/istallion.cmemcpy((shbuf + head), chbuf, stlen);
memcpy1592drivers/char/istallion.cmemcpy((shbuf + head), buf, stlen);
memcpy2216drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), arg, size);
memcpy2280drivers/char/istallion.cmemcpy(tty->flip.char_buf_ptr, (char *) (shbuf + tail), stlen);
memcpy2326drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &portp->asig, sizeof(asysigs_t));
memcpy2335drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
memcpy2410drivers/char/istallion.cmemcpy(portp->argp, (void *) &(cp->args[0]), portp->argsize);
memcpy2542drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->hostoffset), bitsize);
memcpy2564drivers/char/istallion.cmemcpy(&bits[0], (((unsigned char *) hdrp) + brdp->slaveoffset), bitsize);
memcpy2587drivers/char/istallion.cmemcpy((((unsigned char *) hdrp) + brdp->slaveoffset), &bits[0], bitsize);
memcpy3425drivers/char/istallion.cmemcpy(&sig, sigsp, sizeof(cdkecpsig_t));
memcpy3576drivers/char/istallion.cmemcpy(&sig, sigsp, 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);
memcpy618drivers/char/random.cmemcpy(buf, (__u8 const *)tmp, i);
memcpy2165drivers/char/scc.cmemcpy(tbuf, buf, cnt);
memcpy1320drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
memcpy1323drivers/char/serial.cmemcpy(info->xmit_buf + info->xmit_head, buf, c);
memcpy951drivers/char/stallion.cmemcpy(head, chbuf, stlen);
memcpy1768drivers/char/tty_io.cmemcpy(tty_std_termios.c_cc, INIT_C_CC, NCCS);
memcpy268drivers/net/3c501.cmemcpy(dev->dev_addr, station_addr, ETH_ALEN);
memcpy1190drivers/net/3c505.cmemcpy(adapter->tx_pcb.data.multicast[i], addrs+6*i,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);
memcpy291drivers/net/apricot.cmemcpy (lp->i596_config, init_setup, 14);
memcpy295drivers/net/apricot.cmemcpy (lp->eth_addr, dev->dev_addr, 6);
memcpy354drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len);
memcpy983drivers/net/apricot.cmemcpy (((char *)(cmd + 1))+2, addrs, num_addrs * 6);
memcpy1156drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
memcpy1169drivers/net/arcnet.cmemcpy(lp->sdev,dev,sizeof(struct device));
memcpy1560drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
memcpy1794drivers/net/arcnet.cmemcpy((u_char*)arcsoft,
memcpy1796drivers/net/arcnet.cmemcpy((u_char*)arcsoft+hdrlen,
memcpy2323drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2466drivers/net/arcnet.cmemcpy((u_char *)soft+EXTRA_CLIENTDATA,
memcpy2517drivers/net/arcnet.cmemcpy(skb->data+skb->len,
memcpy2584drivers/net/arcnet.cmemcpy(skb->data,(u_char *)arcsoft+1,length-1);
memcpy2635drivers/net/arcnet.cmemcpy((u_char *)soft + sizeof(struct S_ClientData)
memcpy1157drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
memcpy1158drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
memcpy1160drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
memcpy1799drivers/net/depca.cmemcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
memcpy1043drivers/net/eth16i.cmemcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
memcpy861drivers/net/ewrk3.cmemcpy(buf, skb->data, PRELOAD);        /* Write PRELOAD bytes */
memcpy863drivers/net/ewrk3.cmemcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
memcpy868drivers/net/ewrk3.cmemcpy(buf, skb->data, skb->len);       /* Write data bytes */
memcpy1046drivers/net/ewrk3.cmemcpy(p, buf, pkt_len);
memcpy1688drivers/net/ewrk3.cmemcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
memcpy672drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
memcpy774drivers/net/hp100.cmemcpy( ptr, lp -> mem_ptr_virt, ( pkt_len + 3 ) & ~3 );
memcpy1111drivers/net/ibmtr.cmemcpy(dhb,ti->current_skb->data,hdr_len);
memcpy1118drivers/net/ibmtr.cmemcpy(dhb,ti->current_skb->data+sizeof(struct trh_hdr),
memcpy1200drivers/net/ibmtr.cmemcpy(data,&(rbuffer->data),lan_hdr_len);
memcpy1211drivers/net/ibmtr.cmemcpy(data,(unsigned char *)(&(rbuffer->data))+lan_hdr_len,rbuffer_len);
memcpy1217drivers/net/ibmtr.cmemcpy(data,&(rbuffer->data),rbuffer_len=ntohs(rbuffer->buf_len)),rbuffer->buf_ptr;
memcpy801drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
memcpy140drivers/net/net_init.cmemcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
memcpy502drivers/net/ni52.cmemcpy((char *)&ias_cmd->iaddr,(char *) dev->dev_addr,ETH_ALEN);
memcpy621drivers/net/ni52.cmemcpy((char *) mc_cmd->mc_list[i],((char (*)[6]) addrs)[i],6);
memcpy810drivers/net/ni52.cmemcpy(skb_put(skb,totlen),(char *) p->base+(unsigned long) rbd->buffer, totlen);
memcpy989drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
memcpy534drivers/net/ni65.cmemcpy(skb_put(skb,len),p->recv_skb[p->rmdnum]->data,len);
memcpy611drivers/net/ni65.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff),(char *)skb->data,skb->len);
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));
memcpy1274drivers/net/ppp.cmemcpy (skb_put(skb,count), data, count);  /* move data */
memcpy2558drivers/net/ppp.cmemcpy (ppp->xmit_async_map, temp_tbl,
memcpy2791drivers/net/ppp.cmemcpy (&temp.p, &ppp->stats, sizeof (struct pppstat));
memcpy3001drivers/net/ppp.cmemcpy (&hdr[1], data, len);
memcpy3100drivers/net/ppp.cmemcpy (&hdr[1], data, len);
memcpy1262drivers/net/sk_g16.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
memcpy1607drivers/net/sk_g16.cmemcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
memcpy446drivers/net/skeleton.cmemcpy(skb_put(skb,pkt_len), (void*)dev->rmem_start,
memcpy441drivers/net/slhc.cmemcpy(&cs->cs_ip,ip,20);
memcpy442drivers/net/slhc.cmemcpy(&cs->cs_tcp,th,20);
memcpy463drivers/net/slhc.cmemcpy(cp,new_seq,deltaS);  /* Write list of deltas */
memcpy464drivers/net/slhc.cmemcpy(cp+deltaS,icp+hlen,isize-hlen);
memcpy474drivers/net/slhc.cmemcpy(&cs->cs_ip,ip,20);
memcpy475drivers/net/slhc.cmemcpy(&cs->cs_tcp,th,20);
memcpy477drivers/net/slhc.cmemcpy(cs->cs_ipopt, ip+1, ((ip->ihl) - 5) * 4);
memcpy479drivers/net/slhc.cmemcpy(cs->cs_tcpopt, th+1, ((th->doff) - 5) * 4);
memcpy482drivers/net/slhc.cmemcpy(ocp, icp, isize);
memcpy613drivers/net/slhc.cmemcpy(cp, ip, 20);
memcpy617drivers/net/slhc.cmemcpy(cp, cs->cs_ipopt, (ip->ihl - 5) * 4);
memcpy627drivers/net/slhc.cmemcpy(cp, thp, 20);
memcpy631drivers/net/slhc.cmemcpy(cp, cs->cs_tcpopt, ((thp->doff) - 5) * 4);
memcpy678drivers/net/slhc.cmemcpy(&cs->cs_ip,icp,20);
memcpy679drivers/net/slhc.cmemcpy(&cs->cs_tcp,icp + ihl*4,20);
memcpy681drivers/net/slhc.cmemcpy(cs->cs_ipopt, icp + sizeof(struct iphdr), (ihl - 5) * 4);
memcpy683drivers/net/slhc.cmemcpy(cs->cs_tcpopt, icp + ihl*4 + sizeof(struct tcphdr), (cs->cs_tcp.doff - 5) * 4);
memcpy276drivers/net/slip.cmemcpy(sl->xbuff, sl->xhead, sl->xleft);
memcpy286drivers/net/slip.cmemcpy(sl->rbuff, orbuff, sl->rcount);
memcpy383drivers/net/slip.cmemcpy(skb_put(skb,count), sl->rbuff, count);
memcpy1001drivers/net/slip.cmemcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
memcpy1211drivers/net/slip.cmemcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);  /* Only activated in AX.25 mode */
memcpy1212drivers/net/slip.cmemcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);  /*    ""      ""       ""    "" */
memcpy625drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len);
memcpy223drivers/net/tunnel.cmemcpy(skb2->h.iph, skb->data, ip_header_len );
memcpy224drivers/net/tunnel.cmemcpy(skb2->data + ip_header_len, skb->data, skb->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);
memcpy656drivers/net/znet.cmemcpy(zn.tx_cur, i593_init, sizeof(i593_init));
memcpy663drivers/net/znet.cmemcpy(zn.tx_cur, addrs, addrs_len);
memcpy717drivers/net/znet.cmemcpy(zn.tx_cur, i593_init, sizeof(i593_init));
memcpy722drivers/net/znet.cmemcpy(zn.tx_cur, dev->dev_addr, 6);
memcpy1061drivers/scsi/53c7,8xx.cmemcpy ((void *) hostdata->script, (void *) SCRIPT, 
memcpy1409drivers/scsi/53c7,8xx.cmemcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
memcpy2046drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->addr, (void *) bp->old, sizeof(bp->old));
memcpy2120drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
memcpy2125drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
memcpy2225drivers/scsi/53c7,8xx.cmemcpy (hostdata->debug_write, buf, copy);
memcpy939drivers/scsi/BusLogic.cmemcpy(HostAdapter->ErrorRecoveryOption,
memcpy1408drivers/scsi/BusLogic.cmemcpy(HostAdapter->InstalledDevices, InstalledDevicesID0to7,
memcpy1410drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousValues,
memcpy1415drivers/scsi/BusLogic.cmemcpy(&HostAdapter->InstalledDevices[8], InstalledDevicesID8to15,
memcpy1417drivers/scsi/BusLogic.cmemcpy(&HostAdapter->SynchronousValues[8],
memcpy1421drivers/scsi/BusLogic.cmemcpy(HostAdapter->SynchronousPeriod, SynchronousPeriod,
memcpy1541drivers/scsi/BusLogic.cmemcpy(HostAdapter, &HostAdapterPrototype,
memcpy2040drivers/scsi/BusLogic.cmemcpy(CCB->CDB, CDB, CDB_Length);
memcpy469drivers/scsi/aha1542.cmemcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen], 
memcpy605drivers/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);
memcpy2592drivers/scsi/aic7xxx.cmemcpy((void *) scb->sense_cmd, (void *) generic_sense,
memcpy2608drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr,
memcpy2611drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &req_buf,
memcpy2616drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(scb->sense_sg.address), 4);
memcpy4520drivers/scsi/aic7xxx.cmemcpy(scb->SCSI_cmd_pointer, &addr, sizeof(scb->SCSI_cmd_pointer));
memcpy4529drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &cmd->request_buffer,
memcpy4531drivers/scsi/aic7xxx.cmemcpy(&sg, &cmd->request_buffer, sizeof(sg));
memcpy4532drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(sg[0].address), sizeof(scb->data_pointer));
memcpy4561drivers/scsi/aic7xxx.cmemcpy(scb->SG_list_pointer, &addr, sizeof(scb->SG_list_pointer));
memcpy4565drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &cmd->request_buffer, sizeof(scb->data_pointer));
memcpy4664drivers/scsi/aic7xxx.cmemcpy(scb->host_scb, &scb, sizeof(scb));
memcpy698drivers/scsi/eata.cmemcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
memcpy502drivers/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));
memcpy1025drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1028drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
memcpy1034drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
memcpy1047drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1052drivers/scsi/fdomain.cmemcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
memcpy1948drivers/scsi/fdomain.cmemcpy( data, do_read, sizeof( do_read ) );
memcpy557drivers/scsi/scsi.cmemcpy(SDpnt->vendor, scsi_result+8, 8);
memcpy558drivers/scsi/scsi.cmemcpy(SDpnt->model, scsi_result+16, 16);
memcpy559drivers/scsi/scsi.cmemcpy(SDpnt->rev, scsi_result+32, 4);
memcpy876drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1026drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
memcpy1179drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) generic_sense, 
memcpy1259drivers/scsi/scsi.cmemcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
memcpy1274drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
memcpy1668drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd,
memcpy2601drivers/scsi/scsi.cmemcpy(new_dma_malloc_freelist, dma_malloc_freelist, dma_sectors >> 3);
memcpy2608drivers/scsi/scsi.cmemcpy(new_dma_malloc_pages, dma_malloc_pages,
memcpy224drivers/scsi/scsi_debug.cmemcpy(buff, sense_buffer, bufflen);
memcpy241drivers/scsi/scsi_debug.cmemcpy(&buff[8],"Foo Inc",7);
memcpy242drivers/scsi/scsi_debug.cmemcpy(&buff[16],"XYZZY",5);
memcpy243drivers/scsi/scsi_debug.cmemcpy(&buff[32],"1",1);
memcpy348drivers/scsi/scsi_debug.cmemcpy(buff, &target, sizeof(target));
memcpy349drivers/scsi/scsi_debug.cmemcpy(buff+sizeof(target), cmd, 24);
memcpy350drivers/scsi/scsi_debug.cmemcpy(buff+60, &block, sizeof(block));
memcpy351drivers/scsi/scsi_debug.cmemcpy(buff+64, SCpnt, sizeof(Scsi_Cmnd));
memcpy356drivers/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);
memcpy266drivers/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);
memcpy1377drivers/sound/ad1848.cmemcpy ((char *) &ad1848_pcm_operations[nr_ad1848_devs],
memcpy1622drivers/sound/gus_wave.cmemcpy ((char *) &samples[free_sample], &patch, sizeof_patch);
memcpy2590drivers/sound/gus_wave.cmemcpy (rec->data.data8, (char *) &samples[ptr],
memcpy2617drivers/sound/gus_wave.cmemcpy ((char *) &samples[ptr], rec->data.data8,
memcpy1100drivers/sound/mpu401.cmemcpy ((char *) mpu401_synth_operations[num_midis],
memcpy1106drivers/sound/mpu401.cmemcpy ((char *) mpu401_synth_operations[num_midis],
memcpy1111drivers/sound/mpu401.cmemcpy ((char *) &mpu401_midi_operations[num_midis],
memcpy1118drivers/sound/mpu401.cmemcpy ((char *) &mpu_synth_info[num_midis],
memcpy364drivers/sound/opl3.cmemcpy ((char *) &(devc->i_map[instr_no]), (char *) instr, sizeof (*instr));
memcpy197drivers/sound/sequencer.cmemcpy (&iqueue[iqtail * IEV_SZ], event, len);
memcpy439drivers/sound/sequencer.cmemcpy (&queue[qtail * EV_SZ], note, EV_SZ);
memcpy64drivers/sound/sound_switch.cmemcpy (&status_buf[status_len], s, l);
memcpy96drivers/sound/sound_switch.cmemcpy (&status_buf[status_len], &buf[10 - l], l);
memcpy144drivers/sound/soundcard.cmemcpy ((char *) &files[dev], (char *) &tmp_file, sizeof (tmp_file));
memcpy502drivers/sound/sscape.cmemcpy (audio_devs[devc->my_audiodev]->dmap_out->raw_buf, block, size);
memcpy994fs/binfmt_elf.cmemcpy(elf.e_ident, ELFMAG, SELFMAG);
memcpy1016fs/binfmt_elf.cmemcpy(corefile,"core.",5);
memcpy1018fs/binfmt_elf.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy1207fs/buffer.cmemcpy((void *) where, bh[i]->b_data, size);
memcpy1232fs/buffer.cmemcpy(bh[i]->b_data, (void *) address, size);
memcpy55fs/dcache.cmemcpy((void *) &newde->dc_dev, (void *) &de->dc_dev, \
memcpy209fs/dcache.cmemcpy(de->name, name, len);
memcpy190fs/exec.cmemcpy(corefile,"core.",5);
memcpy192fs/exec.cmemcpy(corefile+5,current->comm,sizeof(current->comm));
memcpy310fs/ext2/namei.cmemcpy (de->name, name, namelen);
memcpy1695fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
memcpy1700fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
memcpy1705fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
memcpy1710fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
memcpy177fs/isofs/dir.cmemcpy(tmpde, de, bufsize - offset);
memcpy185fs/isofs/dir.cmemcpy(bufsize - offset + (char *) tmpde, bh->b_data, next_offset);
memcpy448fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
memcpy456fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
memcpy723fs/isofs/inode.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
memcpy734fs/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);
memcpy81fs/msdos/fat.cmemcpy(c_bh->b_data,bh->b_data,SECTOR_SIZE);
memcpy91fs/msdos/fat.cmemcpy(c_bh2->b_data,bh2->b_data,SECTOR_SIZE);
memcpy217fs/msdos/file.cmemcpy (pre.bhlist,pre.bhlist+MSDOS_PREFETCH/2
memcpy222fs/msdos/namei.cmemcpy(de->name,name,MSDOS_NAME);
memcpy525fs/msdos/namei.cmemcpy(old_de->name,new_name,MSDOS_NAME);
memcpy612fs/msdos/namei.cmemcpy(free_de,old_de,sizeof(struct msdos_dir_entry));
memcpy613fs/msdos/namei.cmemcpy(free_de->name,new_name,MSDOS_NAME);
memcpy345fs/nfs/dir.cmemcpy(name,__name,len);
memcpy157fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
memcpy207fs/nfs/nfsroot.cmemcpy(&sip, rarp_ptr, 4);
memcpy211fs/nfs/nfsroot.cmemcpy(&tip, rarp_ptr, 4);
memcpy559fs/nfs/nfsroot.cmemcpy(&nfs_file, filp, sizeof(struct file));
memcpy564fs/nfs/nfsroot.cmemcpy(&nfs_inode, nfs_file.f_inode, sizeof(struct inode));
memcpy780fs/nfs/nfsroot.cmemcpy(p, nfs_path, len);
memcpy118fs/nfs/proc.cmemcpy(p, string, len);
memcpy127fs/nfs/proc.cmemcpy(string, p, len);
memcpy162fs/nfs/proc.cmemcpy(data, p, len);
memcpy83fs/nfs/symlink.cmemcpy(res2, res, len);
memcpy365fs/smbfs/dir.cmemcpy(path, parentname, parentlen + 1);
memcpy395fs/smbfs/dir.cmemcpy(path, parentname, len);
memcpy403fs/smbfs/dir.cmemcpy(path, parentname, parentlen);
memcpy405fs/smbfs/dir.cmemcpy(path + parentlen + 1, name, len);
memcpy100fs/smbfs/proc.cmemcpy(p, data, len);
memcpy120fs/smbfs/proc.cmemcpy(data, p, len);
memcpy925fs/smbfs/proc.cmemcpy(entry->path, p+9, 13);
memcpy1019fs/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));
memcpy92fs/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);
memcpy201fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
memcpy233fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
memcpy290fs/umsdos/mangle.cmemcpy (info->fake.fname,fname,msdos_len);
memcpy357fs/umsdos/mangle.cmemcpy (basen,info->fake.fname,base_len);
memcpy375fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
memcpy222fs/xiafs/namei.cmemcpy(de->d_name, name, namelen);
memcpy115include/asm-alpha/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy117include/asm-alpha/segment.h#define memcpy_tofs(to, from, n) memcpy((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))
memcpy280include/asm-i386/termios.hmemcpy(termios->c_cc, termio->c_cc, NCC);
memcpy294include/asm-i386/termios.hmemcpy(termio->c_cc, termios->c_cc, NCC);
memcpy81include/asm-mips/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy83include/asm-mips/segment.h#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
memcpy69include/asm-sparc/segment.h#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
memcpy71include/asm-sparc/segment.h#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
memcpy966include/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);
memcpy167kernel/fork.cmemcpy(&tsk->files->close_on_exec, &current->files->close_on_exec,
memcpy188kernel/fork.cmemcpy(tsk->sig->action, current->sig->action, sizeof(tsk->sig->action));
memcpy749kernel/module.cmemcpy(newtab, intab, SYMSIZ + intab->n_symbols * INTSIZ);
memcpy755kernel/module.cmemcpy( ((char *)newtab) + SYMSIZ + intab->n_symbols * INTSIZ,
memcpy62mm/memory.c#define copy_page(from,to) memcpy((void *) to, (void *) from, PAGE_SIZE)
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);
memcpy700net/appletalk/aarp.cmemcpy(a->hwaddr,ea->hw_src,ETH_ALEN);
memcpy1350net/appletalk/ddp.cmemcpy(uaddr,&sat,sizeof(sat));
memcpy622net/ax25/af_ax25.cmemcpy(&ax25->source_addr, src,  sizeof(ax25_address));
memcpy623net/ax25/af_ax25.cmemcpy(&ax25->dest_addr,   dest, sizeof(ax25_address));
memcpy630net/ax25/af_ax25.cmemcpy(ax25->digipeat, digi, sizeof(ax25_digi));
memcpy1019net/ax25/af_ax25.cmemcpy(&ax25->source_addr, &osk->ax25->source_addr, sizeof(ax25_address));
memcpy1139net/ax25/af_ax25.cmemcpy(&sk->ax25->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
memcpy1141net/ax25/af_ax25.cmemcpy(&sk->ax25->source_addr, call, sizeof(ax25_address));
memcpy1210net/ax25/af_ax25.cmemcpy(&sk->ax25->digipeat->calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
memcpy1226net/ax25/af_ax25.cmemcpy(&sk->ax25->dest_addr, &addr->sax25_call, sizeof(ax25_address));
memcpy1345net/ax25/af_ax25.cmemcpy(&sax->fsa_ax25.sax25_call, addr, sizeof(ax25_address));
memcpy1355net/ax25/af_ax25.cmemcpy(&sax->fsa_digipeater[i], &sk->ax25->digipeat->calls[i], sizeof(ax25_address));
memcpy1594net/ax25/af_ax25.cmemcpy(&ax25->source_addr, &dest, sizeof(ax25_address));
memcpy1595net/ax25/af_ax25.cmemcpy(&ax25->dest_addr,   &src,  sizeof(ax25_address));
memcpy1729net/ax25/af_ax25.cmemcpy(&dtmp.calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
memcpy1736net/ax25/af_ax25.cmemcpy(&sax, usax, sizeof(sax));
memcpy1747net/ax25/af_ax25.cmemcpy(&sax.sax25_call, &sk->ax25->dest_addr, sizeof(ax25_address));
memcpy1877net/ax25/af_ax25.cmemcpy(&sax->sax25_call, &dest, sizeof(ax25_address));
memcpy1886net/ax25/af_ax25.cmemcpy(&fsa->fsa_digipeater[ct], &digi.calls[ct], sizeof(ax25_address));
memcpy2216net/ax25/af_ax25.cmemcpy(buff, daddr, dev->addr_len);  /* Address specified */
memcpy2224net/ax25/af_ax25.cmemcpy(buff, saddr, dev->addr_len);
memcpy2226net/ax25/af_ax25.cmemcpy(buff, dev->dev_addr, dev->addr_len);
memcpy95net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy100net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
memcpy89net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
memcpy126net/ax25/ax25_route.cmemcpy(ax25_rt->digipeat, digi, sizeof(ax25_digi));
memcpy381net/ax25/ax25_route.cmemcpy(&ax25->source_addr, call, sizeof(ax25_address));
memcpy385net/ax25/ax25_route.cmemcpy(ax25->digipeat, ax25_rt->digipeat, sizeof(ax25_digi));
memcpy569net/ax25/ax25_route.cmemcpy(ax25_dev->values, ax25_parms.values, AX25_MAX_VALUES * sizeof(short));
memcpy584net/ax25/ax25_route.cmemcpy(ax25_parms.values, ax25_dev->values, AX25_MAX_VALUES * sizeof(short));
memcpy345net/ax25/ax25_subr.cif (dest != NULL) memcpy(dest, buf + 0, AX25_ADDR_LEN);
memcpy346net/ax25/ax25_subr.cif (src != NULL)  memcpy(src,  buf + 7, AX25_ADDR_LEN);
memcpy358net/ax25/ax25_subr.cmemcpy(&digi->calls[d], buf, AX25_ADDR_LEN);
memcpy384net/ax25/ax25_subr.cmemcpy(buf, dest, AX25_ADDR_LEN);
memcpy393net/ax25/ax25_subr.cmemcpy(buf, src, AX25_ADDR_LEN);
memcpy417net/ax25/ax25_subr.cmemcpy(buf, &d->calls[ct], AX25_ADDR_LEN);
memcpy531net/core/dev.cmemcpy(to, buff, amount);
memcpy1052net/core/dev.cmemcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
memcpy1186net/core/dev.cmemcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
memcpy125net/core/dev_mcast.cmemcpy(tmp,dmi->dmi_addr, dmi->dmi_addrlen);
memcpy174net/core/dev_mcast.cmemcpy(dmi->dmi_addr, addr, alen);
memcpy620net/core/skbuff.cmemcpy(n->head,skb->head,skb->end-skb->head);
memcpy632net/core/skbuff.cmemcpy(n->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy109net/ethernet/eth.cmemcpy(eth->h_source,saddr,dev->addr_len);
memcpy111net/ethernet/eth.cmemcpy(eth->h_source,dev->dev_addr,dev->addr_len);
memcpy125net/ethernet/eth.cmemcpy(eth->h_dest,daddr,dev->addr_len);
memcpy151net/ethernet/eth.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
memcpy240net/ethernet/eth.cmemcpy(hh->hh_data+6, dev->dev_addr, ETH_ALEN);
memcpy257net/ethernet/eth.cmemcpy(hh->hh_data, haddr, ETH_ALEN);
memcpy275net/ethernet/eth.cmemcpy(dest->data,src,length);
memcpy284net/ethernet/eth.cmemcpy(dest->data,src,sizeof(struct iphdr)+ETH_HLEN);  /* ethernet is always >= 34 */
memcpy668net/ipv4/arp.cmemcpy(arp_ptr, src_hw, dev->addr_len);
memcpy670net/ipv4/arp.cmemcpy(arp_ptr, &src_ip,4);
memcpy673net/ipv4/arp.cmemcpy(arp_ptr, target_hw, dev->addr_len);
memcpy677net/ipv4/arp.cmemcpy(arp_ptr, &dest_ip, 4);
memcpy851net/ipv4/arp.cmemcpy(&sip, arp_ptr, 4);
memcpy855net/ipv4/arp.cmemcpy(&tip, arp_ptr, 4);
memcpy917net/ipv4/arp.cmemcpy(ha, proxy_entry->ha, dev->addr_len);
memcpy969net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1010net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
memcpy1089net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1105net/ipv4/arp.cmemcpy(haddr, dev->dev_addr, dev->addr_len);
memcpy1129net/ipv4/arp.cmemcpy(haddr, dev->broadcast, dev->addr_len);
memcpy1203net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
memcpy1690net/ipv4/arp.cmemcpy(&entry->ha, dev->dev_addr, dev->addr_len);
memcpy1692net/ipv4/arp.cmemcpy(&entry->ha, &r->arp_ha.sa_data, dev->addr_len);
memcpy1739net/ipv4/arp.cmemcpy(r->arp_ha.sa_data, &entry->ha, entry->dev->addr_len);
memcpy586net/ipv4/icmp.cmemcpy((void *)&times[0], icmph+1, 4);    /* Incoming stamp */
memcpy299net/ipv4/ip_forward.cmemcpy(ptr, skb->h.raw, skb->len);
memcpy300net/ipv4/ip_forward.cmemcpy(skb2->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy321net/ipv4/ip_forward.cmemcpy(skb_push(skb, dev2->hard_header_len), hh->hh_data, dev2->hard_header_len);
memcpy347net/ipv4/ip_forward.cmemcpy(&optptr[optptr[2]-5], &dev2->pa_addr, 4);
memcpy369net/ipv4/ip_forward.cmemcpy(&optptr[srrptr-1], &dev2->pa_addr, 4);
memcpy379net/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);
memcpy710net/ipv4/ip_fw.cmemcpy(p,buf,strlen(buf));
memcpy758net/ipv4/ip_fw.cmemcpy(skb2->data, skb->data, (p - (char *)skb->data));
memcpy759net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
memcpy760net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
memcpy1064net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
memcpy343net/ipv4/ip_input.cmemcpy(&nexthop, &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));
memcpy94net/ipv4/ip_output.cmemcpy(newskb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
memcpy99net/ipv4/ip_output.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
memcpy128net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy160net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy663net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy839net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
memcpy449net/ipv4/ip_sockglue.cmemcpy(optbuf, sk->opt, sizeof(struct options)+sk->opt->optlen);
memcpy466net/ipv4/ip_sockglue.cmemcpy(optptr+3, &opt->faddr, 4);
memcpy268net/ipv4/ipmr.cmemcpy(skb->data,pkt->data,ihl);
memcpy385net/ipv4/ipmr.cmemcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
memcpy412net/ipv4/ipmr.cmemcpy(cache->mfc_ttls, mfc->mfcc_ttls,sizeof(cache->mfc_ttls));
memcpy304net/ipv4/packet.cmemcpy(sk->protinfo.af_packet.device_name,dev,15);
memcpy439net/ipv4/packet.cmemcpy(saddr->sa_data,skb->dev->name, 14);
memcpy248net/ipv4/rarp.cmemcpy(&sip,rarp_ptr,4);
memcpy252net/ipv4/rarp.cmemcpy(&tip,rarp_ptr,4);
memcpy371net/ipv4/rarp.cmemcpy(&entry->ha, &r.arp_ha.sa_data, hlen);
memcpy422net/ipv4/rarp.cmemcpy(r.arp_ha.sa_data, &entry->ha, entry->hlen);
memcpy203net/ipv4/raw.cmemcpy(&sin, usin, sizeof(sin));
memcpy711net/ipv4/tcp.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
memcpy1602net/ipv4/tcp.cmemcpy(t1, th, sizeof(*t1));
memcpy1665net/ipv4/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
memcpy2108net/ipv4/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
memcpy2647net/ipv4/tcp.cmemcpy(t1, th, sizeof(*t1));
memcpy2784net/ipv4/tcp.cmemcpy(t1, th, sizeof(*t1));
memcpy2977net/ipv4/tcp.cmemcpy(newsk, sk, sizeof(*newsk));
memcpy3169net/ipv4/tcp.cmemcpy(t1, skb->h.th, sizeof(*t1));
memcpy4610net/ipv4/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
memcpy5306net/ipv4/tcp.cmemcpy(nth, th, th->doff * 4);
memcpy5327net/ipv4/tcp.cmemcpy(skb_put(buff,win_size), tcp_data_start, win_size);
memcpy5398net/ipv4/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
memcpy254net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy286net/ipv4/udp.cmemcpy(to, ufh, sizeof(struct udphdr));
memcpy466net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
memcpy520net/ipx/af_ipx.cmemcpy(dest_node, dev->broadcast, addr_len);
memcpy522net/ipx/af_ipx.cmemcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
memcpy687net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
memcpy778net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), dev->dev_addr, dev->addr_len);
memcpy852net/ipx/af_ipx.cmemcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
memcpy879net/ipx/af_ipx.cmemcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
memcpy880net/ipx/af_ipx.cmemcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
memcpy906net/ipx/af_ipx.cmemcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
memcpy963net/ipx/af_ipx.cmemcpy(rt->ir_router_node, node, IPX_NODE_LEN);
memcpy1070net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN);
memcpy1073net/ipx/af_ipx.cmemcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
memcpy1144net/ipx/af_ipx.cmemcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
memcpy1585net/ipx/af_ipx.cmemcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN);
memcpy1620net/ipx/af_ipx.cmemcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
memcpy1625net/ipx/af_ipx.cmemcpy(sipx.sipx_node, sk->ipx_intrfc->if_node,
memcpy1636net/ipx/af_ipx.cmemcpy(uaddr,&sipx,sizeof(sipx));
memcpy1771net/ipx/af_ipx.cmemcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN);
memcpy1815net/ipx/af_ipx.cmemcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
memcpy709net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   &addr->fsa_digipeater[0],   sizeof(ax25_address));
memcpy710net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
memcpy720net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
memcpy721net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
memcpy776net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
memcpy777net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
memcpy784net/netrom/af_netrom.cmemcpy(&sk->nr->dest_addr, &addr->sax25_call, sizeof(ax25_address));
memcpy898net/netrom/af_netrom.cmemcpy(&sax->fsa_ax25.sax25_call, &sk->nr->user_addr, sizeof(ax25_address));
memcpy899net/netrom/af_netrom.cmemcpy(&sax->fsa_digipeater[0],   &sk->nr->dest_addr, sizeof(ax25_address));
memcpy904net/netrom/af_netrom.cmemcpy(&sax->fsa_ax25.sax25_call, &sk->nr->source_addr, sizeof(ax25_address));
memcpy979net/netrom/af_netrom.cmemcpy(&make->nr->source_addr, dest, sizeof(ax25_address));
memcpy980net/netrom/af_netrom.cmemcpy(&make->nr->dest_addr,   src,  sizeof(ax25_address));
memcpy981net/netrom/af_netrom.cmemcpy(&make->nr->user_addr,   user, sizeof(ax25_address));
memcpy1053net/netrom/af_netrom.cmemcpy(&sax, usax, sizeof(sax));
memcpy1062net/netrom/af_netrom.cmemcpy(&sax.sax25_call, &sk->nr->dest_addr, sizeof(ax25_address));
memcpy1169net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 7, sizeof(ax25_address));
memcpy1171net/netrom/af_netrom.cmemcpy(sax, &addr, sizeof(*sax));
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);
memcpy143net/netrom/nr_dev.cmemcpy(dev->dev_addr, addr, 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, sizeof(ax25_address));
memcpy217net/netrom/nr_out.cmemcpy(dptr, &sk->nr->dest_addr,   sizeof(ax25_address));
memcpy91net/netrom/nr_route.cmemcpy(&nr_neigh->callsign, ax25, sizeof(ax25_address));
memcpy105net/netrom/nr_route.cmemcpy(nr_neigh->digipeat, ax25_digi, sizeof(*ax25_digi));
memcpy121net/netrom/nr_route.cmemcpy(&nr_node->callsign, nr, sizeof(ax25_address));
memcpy122net/netrom/nr_route.cmemcpy(&nr_node->mnemonic, mnemonic, sizeof(nr_node->mnemonic));
memcpy358net/netrom/nr_route.cmemcpy(&nr_neigh->callsign, callsign, sizeof(ax25_address));
memcpy195net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->user_addr, sizeof(ax25_address));
memcpy200net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->source_addr, sizeof(ax25_address));
memcpy261net/netrom/nr_subr.cmemcpy(dptr, skb->data + 7, AX25_ADDR_LEN);
memcpy267net/netrom/nr_subr.cmemcpy(dptr, skb->data + 0, AX25_ADDR_LEN);
memcpy424net/unix/af_unix.cmemcpy(sk->protinfo.af_unix.name, sunaddr->sun_path, addr_len+1);
memcpy870net/unix/af_unix.cmemcpy(sunaddr->sun_path, skb->sk->protinfo.af_unix.name, 108);