Lines Matching defs:offset
222 u16 offset;
229 int offset;
231 offset = nc->offset - SZ_1K;
232 if (likely(offset >= 0))
241 offset = PAGE_SIZE - SZ_1K;
242 page_ref_add(page, offset / SZ_1K);
245 nc->offset = offset;
246 return nc->va + offset;
2514 int offset = skb_headlen(skb);
2524 if (offset >= len)
2528 int end = offset + skb_frag_size(&skb_shinfo(skb)->frags[i]);
2531 offset = end;
2535 skb_frag_size_set(&skb_shinfo(skb)->frags[i++], len - offset);
2550 int end = offset + frag->len;
2566 offset = end;
2571 unlikely((err = pskb_trim(frag, len - offset))))
2607 int offset = skb_checksum_start_offset(skb) + skb->csum_offset;
2609 if (offset + sizeof(__sum16) > hdlen)
2675 * Certainly, it is possible to add an offset to skb data,
2770 * @offset: offset in source
2782 int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
2788 if (offset > (int)skb->len - len)
2792 if ((copy = start - offset) > 0) {
2795 skb_copy_from_linear_data_offset(skb, offset, to, copy);
2798 offset += copy;
2806 WARN_ON(start > offset + len);
2809 if ((copy = end - offset) > 0) {
2818 skb_frag_off(f) + offset - start,
2827 offset += copy;
2836 WARN_ON(start > offset + len);
2839 if ((copy = end - offset) > 0) {
2842 if (skb_copy_bits(frag_iter, offset - start, to, copy))
2846 offset += copy;
2870 unsigned int *offset,
2878 *len = min_t(unsigned int, *len, pfrag->size - pfrag->offset);
2880 memcpy(page_address(pfrag->page) + pfrag->offset,
2881 page_address(page) + *offset, *len);
2882 *offset = pfrag->offset;
2883 pfrag->offset += *len;
2890 unsigned int offset)
2894 (spd->partial[spd->nr_pages - 1].offset +
2895 spd->partial[spd->nr_pages - 1].len == offset);
2899 * Fill page/offset/length into spd, if it can hold more pages.
2903 unsigned int *len, unsigned int offset,
2911 page = linear_to_page(page, len, &offset, sk);
2915 if (spd_can_coalesce(spd, page, offset)) {
2922 spd->partial[spd->nr_pages].offset = offset;
2968 unsigned int *offset, unsigned int *len,
2982 offset, len, spd,
2995 offset, len, spd, false, sk, pipe))
3000 if (*offset >= iter->len) {
3001 *offset -= iter->len;
3008 if (__skb_splice_bits(iter, pipe, offset, len, spd, sk))
3019 int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
3034 __skb_splice_bits(skb, pipe, &offset, &tlen, &spd, sk);
3067 static int __skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset,
3078 while (offset < skb_headlen(skb) && len) {
3082 slen = min_t(int, len, skb_headlen(skb) - offset);
3083 kv.iov_base = skb->data + offset;
3094 offset += ret;
3102 /* Make offset relative to start of frags */
3103 offset -= skb_headlen(skb);
3109 if (offset < skb_frag_size(frag))
3112 offset -= skb_frag_size(frag);
3118 slen = min_t(size_t, len, skb_frag_size(frag) - offset);
3127 skb_frag_off(frag) + offset);
3137 offset += ret;
3141 offset = 0;
3166 int skb_send_sock_locked(struct sock *sk, struct sk_buff *skb, int offset,
3169 return __skb_send_sock(sk, skb, offset, len, sendmsg_locked);
3174 int skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset, int len)
3176 return __skb_send_sock(sk, skb, offset, len, sendmsg_unlocked);
3182 * @offset: offset in destination
3191 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
3197 if (offset > (int)skb->len - len)
3200 if ((copy = start - offset) > 0) {
3203 skb_copy_to_linear_data_offset(skb, offset, from, copy);
3206 offset += copy;
3214 WARN_ON(start > offset + len);
3217 if ((copy = end - offset) > 0) {
3226 skb_frag_off(frag) + offset - start,
3235 offset += copy;
3244 WARN_ON(start > offset + len);
3247 if ((copy = end - offset) > 0) {
3250 if (skb_store_bits(frag_iter, offset - start,
3255 offset += copy;
3269 __wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
3273 int i, copy = start - offset;
3282 skb->data + offset, copy, csum);
3285 offset += copy;
3293 WARN_ON(start > offset + len);
3296 if ((copy = end - offset) > 0) {
3306 skb_frag_off(frag) + offset - start,
3321 offset += copy;
3329 WARN_ON(start > offset + len);
3332 if ((copy = end - offset) > 0) {
3336 csum2 = __skb_checksum(frag_iter, offset - start,
3342 offset += copy;
3353 __wsum skb_checksum(const struct sk_buff *skb, int offset,
3361 return __skb_checksum(skb, offset, len, csum, &ops);
3367 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
3371 int i, copy = start - offset;
3380 csum = csum_partial_copy_nocheck(skb->data + offset, to,
3384 offset += copy;
3392 WARN_ON(start > offset + len);
3395 if ((copy = end - offset) > 0) {
3406 skb_frag_off(frag) + offset - start,
3419 offset += copy;
3429 WARN_ON(start > offset + len);
3432 if ((copy = end - offset) > 0) {
3436 offset - start,
3441 offset += copy;
3520 int offset, int len)
3589 unsigned int offset;
3606 offset = from->data - (unsigned char *)page_address(page);
3607 __skb_fill_page_desc(to, 0, page, offset, plen);
4086 * @from: lower offset of data to be read
4087 * @to: upper offset of data to be read
4112 * lower offset specified to skb_prepare_seq_read(). Assigns
4115 * offset has been reached.
4230 static unsigned int skb_ts_get_next_block(unsigned int offset, const u8 **text,
4234 return skb_seq_read(offset, text, TS_SKB_CB(state));
4245 * @from: search offset
4251 * subsequent occurrences of the pattern. Returns the offset
4274 int offset, size_t size, size_t max_frags)
4278 if (skb_can_coalesce(skb, i, page, offset)) {
4283 skb_fill_page_desc_noacc(skb, i, page, offset, size);
4328 unsigned int offset)
4338 skb_push(skb, -skb_network_offset(skb) + offset);
4378 skb_push(nskb, -skb_network_offset(nskb) + offset);
4388 offset + tnl_hlen);
4435 unsigned int offset = doffset;
4540 len = head_skb->len - offset;
4545 hsize = skb_headlen(head_skb) - offset;
4561 while (pos < offset + len) {
4565 if (pos + size > offset + len)
4629 skb_copy_and_csum_bits(head_skb, offset,
4636 if (skb_copy_bits(head_skb, offset, skb_put(nskb, len), len))
4644 skb_copy_from_linear_data_offset(head_skb, offset,
4653 while (pos < offset + len) {
4690 if (pos < offset) {
4691 skb_frag_off_add(nskb_frag, offset - pos);
4692 skb_frag_size_sub(nskb_frag, offset - pos);
4697 if (pos + size <= offset + len) {
4702 skb_frag_size_sub(nskb_frag, pos + size - (offset + len));
4728 } while ((offset += len) < head_skb->len);
4868 __skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len,
4872 int i, copy = start - offset;
4882 sg_set_buf(sg, skb->data + offset, copy);
4886 offset += copy;
4892 WARN_ON(start > offset + len);
4895 if ((copy = end - offset) > 0) {
4903 skb_frag_off(frag) + offset - start);
4907 offset += copy;
4915 WARN_ON(start > offset + len);
4918 if ((copy = end - offset) > 0) {
4924 ret = __skb_to_sgvec(frag_iter, sg+elt, offset - start,
4931 offset += copy;
4943 * @offset: The offset into the buffer's contents to start mapping
4951 int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
4953 int nsg = __skb_to_sgvec(skb, sg, offset, len, 0);
4984 int offset, int len)
4986 return __skb_to_sgvec(skb, sg, offset, len, 0);
5372 * @off: the offset from start to place the checksum.
5604 * skb_checksum_setup - set up partial checksum offset
5688 unsigned int offset = skb_transport_offset(skb);
5695 if (!pskb_may_pull(skb_chk, offset))
5698 skb_pull_rcsum(skb_chk, offset);
5700 skb_push_rcsum(skb_chk, offset);
5782 unsigned int offset;
5794 offset = from->data - (unsigned char *)page_address(page);
5797 page, offset, skb_headlen(from));
5953 int offset = skb->data - skb_mac_header(skb);
5956 if (WARN_ONCE(offset,
5957 "__skb_vlan_pop got skb with skb->data not at mac header (offset %d)\n",
5958 offset)) {
6020 int offset = skb->data - skb_mac_header(skb);
6023 if (WARN_ONCE(offset,
6024 "skb_vlan_push got skb with skb->data not at mac header (offset %d)\n",
6025 offset)) {
6615 return (void *)ext + (ext->offset[id] * SKB_EXT_ALIGN_VALUE);
6632 memset(new->offset, 0, sizeof(new->offset));
6693 ext->offset[id] = newoff;
6739 new->offset[id] = newoff;
6860 size_t offset, size_t len)
6866 csum = csum_partial(kaddr + offset, len, 0);