Blame view

lib/scatterlist.c 12 KB
0db9299f4   Jens Axboe   SG: Move function...
1
2
3
4
5
6
7
8
9
10
  /*
   * Copyright (C) 2007 Jens Axboe <jens.axboe@oracle.com>
   *
   * Scatterlist handling helpers.
   *
   * This source code is licensed under the GNU General Public License,
   * Version 2. See the file COPYING for more details.
   */
  #include <linux/module.h>
  #include <linux/scatterlist.h>
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
11
  #include <linux/highmem.h>
0db9299f4   Jens Axboe   SG: Move function...
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
  
  /**
   * sg_next - return the next scatterlist entry in a list
   * @sg:		The current sg entry
   *
   * Description:
   *   Usually the next entry will be @sg@ + 1, but if this sg element is part
   *   of a chained scatterlist, it could jump to the start of a new
   *   scatterlist array.
   *
   **/
  struct scatterlist *sg_next(struct scatterlist *sg)
  {
  #ifdef CONFIG_DEBUG_SG
  	BUG_ON(sg->sg_magic != SG_MAGIC);
  #endif
  	if (sg_is_last(sg))
  		return NULL;
  
  	sg++;
  	if (unlikely(sg_is_chain(sg)))
  		sg = sg_chain_ptr(sg);
  
  	return sg;
  }
  EXPORT_SYMBOL(sg_next);
  
  /**
   * sg_last - return the last scatterlist entry in a list
   * @sgl:	First entry in the scatterlist
   * @nents:	Number of entries in the scatterlist
   *
   * Description:
   *   Should only be used casually, it (currently) scans the entire list
   *   to get the last entry.
   *
   *   Note that the @sgl@ pointer passed in need not be the first one,
   *   the important bit is that @nents@ denotes the number of entries that
   *   exist from @sgl@.
   *
   **/
  struct scatterlist *sg_last(struct scatterlist *sgl, unsigned int nents)
  {
  #ifndef ARCH_HAS_SG_CHAIN
  	struct scatterlist *ret = &sgl[nents - 1];
  #else
  	struct scatterlist *sg, *ret = NULL;
  	unsigned int i;
  
  	for_each_sg(sgl, sg, nents, i)
  		ret = sg;
  
  #endif
  #ifdef CONFIG_DEBUG_SG
  	BUG_ON(sgl[0].sg_magic != SG_MAGIC);
  	BUG_ON(!sg_is_last(ret));
  #endif
  	return ret;
  }
  EXPORT_SYMBOL(sg_last);
  
  /**
   * sg_init_table - Initialize SG table
   * @sgl:	   The SG table
   * @nents:	   Number of entries in table
   *
   * Notes:
   *   If this is part of a chained sg table, sg_mark_end() should be
   *   used only on the last table part.
   *
   **/
  void sg_init_table(struct scatterlist *sgl, unsigned int nents)
  {
  	memset(sgl, 0, sizeof(*sgl) * nents);
  #ifdef CONFIG_DEBUG_SG
  	{
  		unsigned int i;
  		for (i = 0; i < nents; i++)
  			sgl[i].sg_magic = SG_MAGIC;
  	}
  #endif
  	sg_mark_end(&sgl[nents - 1]);
  }
  EXPORT_SYMBOL(sg_init_table);
  
  /**
   * sg_init_one - Initialize a single entry sg list
   * @sg:		 SG entry
   * @buf:	 Virtual address for IO
   * @buflen:	 IO length
   *
   **/
  void sg_init_one(struct scatterlist *sg, const void *buf, unsigned int buflen)
  {
  	sg_init_table(sg, 1);
  	sg_set_buf(sg, buf, buflen);
  }
  EXPORT_SYMBOL(sg_init_one);
  
  /*
   * The default behaviour of sg_alloc_table() is to use these kmalloc/kfree
   * helpers.
   */
  static struct scatterlist *sg_kmalloc(unsigned int nents, gfp_t gfp_mask)
  {
  	if (nents == SG_MAX_SINGLE_ALLOC)
  		return (struct scatterlist *) __get_free_page(gfp_mask);
  	else
  		return kmalloc(nents * sizeof(struct scatterlist), gfp_mask);
  }
  
  static void sg_kfree(struct scatterlist *sg, unsigned int nents)
  {
  	if (nents == SG_MAX_SINGLE_ALLOC)
  		free_page((unsigned long) sg);
  	else
  		kfree(sg);
  }
  
  /**
   * __sg_free_table - Free a previously mapped sg table
   * @table:	The sg table header to use
7cedb1f17   James Bottomley   SG: work with the...
134
   * @max_ents:	The maximum number of entries per single scatterlist
0db9299f4   Jens Axboe   SG: Move function...
135
136
137
   * @free_fn:	Free function
   *
   *  Description:
7cedb1f17   James Bottomley   SG: work with the...
138
139
140
   *    Free an sg table previously allocated and setup with
   *    __sg_alloc_table().  The @max_ents value must be identical to
   *    that previously used with __sg_alloc_table().
0db9299f4   Jens Axboe   SG: Move function...
141
142
   *
   **/
7cedb1f17   James Bottomley   SG: work with the...
143
144
  void __sg_free_table(struct sg_table *table, unsigned int max_ents,
  		     sg_free_fn *free_fn)
0db9299f4   Jens Axboe   SG: Move function...
145
146
147
148
149
150
151
152
153
154
155
156
  {
  	struct scatterlist *sgl, *next;
  
  	if (unlikely(!table->sgl))
  		return;
  
  	sgl = table->sgl;
  	while (table->orig_nents) {
  		unsigned int alloc_size = table->orig_nents;
  		unsigned int sg_size;
  
  		/*
7cedb1f17   James Bottomley   SG: work with the...
157
  		 * If we have more than max_ents segments left,
0db9299f4   Jens Axboe   SG: Move function...
158
159
160
161
  		 * then assign 'next' to the sg table after the current one.
  		 * sg_size is then one less than alloc size, since the last
  		 * element is the chain pointer.
  		 */
7cedb1f17   James Bottomley   SG: work with the...
162
163
164
  		if (alloc_size > max_ents) {
  			next = sg_chain_ptr(&sgl[max_ents - 1]);
  			alloc_size = max_ents;
0db9299f4   Jens Axboe   SG: Move function...
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
  			sg_size = alloc_size - 1;
  		} else {
  			sg_size = alloc_size;
  			next = NULL;
  		}
  
  		table->orig_nents -= sg_size;
  		free_fn(sgl, alloc_size);
  		sgl = next;
  	}
  
  	table->sgl = NULL;
  }
  EXPORT_SYMBOL(__sg_free_table);
  
  /**
   * sg_free_table - Free a previously allocated sg table
   * @table:	The mapped sg table header
   *
   **/
  void sg_free_table(struct sg_table *table)
  {
7cedb1f17   James Bottomley   SG: work with the...
187
  	__sg_free_table(table, SG_MAX_SINGLE_ALLOC, sg_kfree);
0db9299f4   Jens Axboe   SG: Move function...
188
189
190
191
192
193
194
  }
  EXPORT_SYMBOL(sg_free_table);
  
  /**
   * __sg_alloc_table - Allocate and initialize an sg table with given allocator
   * @table:	The sg table header to use
   * @nents:	Number of entries in sg list
7cedb1f17   James Bottomley   SG: work with the...
195
   * @max_ents:	The maximum number of entries the allocator returns per call
0db9299f4   Jens Axboe   SG: Move function...
196
197
198
   * @gfp_mask:	GFP allocation mask
   * @alloc_fn:	Allocator to use
   *
7cedb1f17   James Bottomley   SG: work with the...
199
200
201
202
203
204
   * Description:
   *   This function returns a @table @nents long. The allocator is
   *   defined to return scatterlist chunks of maximum size @max_ents.
   *   Thus if @nents is bigger than @max_ents, the scatterlists will be
   *   chained in units of @max_ents.
   *
0db9299f4   Jens Axboe   SG: Move function...
205
206
207
208
209
   * Notes:
   *   If this function returns non-0 (eg failure), the caller must call
   *   __sg_free_table() to cleanup any leftover allocations.
   *
   **/
7cedb1f17   James Bottomley   SG: work with the...
210
211
  int __sg_alloc_table(struct sg_table *table, unsigned int nents,
  		     unsigned int max_ents, gfp_t gfp_mask,
0db9299f4   Jens Axboe   SG: Move function...
212
213
214
215
216
217
  		     sg_alloc_fn *alloc_fn)
  {
  	struct scatterlist *sg, *prv;
  	unsigned int left;
  
  #ifndef ARCH_HAS_SG_CHAIN
7cedb1f17   James Bottomley   SG: work with the...
218
  	BUG_ON(nents > max_ents);
0db9299f4   Jens Axboe   SG: Move function...
219
220
221
222
223
224
225
226
  #endif
  
  	memset(table, 0, sizeof(*table));
  
  	left = nents;
  	prv = NULL;
  	do {
  		unsigned int sg_size, alloc_size = left;
7cedb1f17   James Bottomley   SG: work with the...
227
228
  		if (alloc_size > max_ents) {
  			alloc_size = max_ents;
0db9299f4   Jens Axboe   SG: Move function...
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
  			sg_size = alloc_size - 1;
  		} else
  			sg_size = alloc_size;
  
  		left -= sg_size;
  
  		sg = alloc_fn(alloc_size, gfp_mask);
  		if (unlikely(!sg))
  			return -ENOMEM;
  
  		sg_init_table(sg, alloc_size);
  		table->nents = table->orig_nents += sg_size;
  
  		/*
  		 * If this is the first mapping, assign the sg table header.
  		 * If this is not the first mapping, chain previous part.
  		 */
  		if (prv)
7cedb1f17   James Bottomley   SG: work with the...
247
  			sg_chain(prv, max_ents, sg);
0db9299f4   Jens Axboe   SG: Move function...
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
  		else
  			table->sgl = sg;
  
  		/*
  		 * If no more entries after this one, mark the end
  		 */
  		if (!left)
  			sg_mark_end(&sg[sg_size - 1]);
  
  		/*
  		 * only really needed for mempool backed sg allocations (like
  		 * SCSI), a possible improvement here would be to pass the
  		 * table pointer into the allocator and let that clear these
  		 * flags
  		 */
  		gfp_mask &= ~__GFP_WAIT;
  		gfp_mask |= __GFP_HIGH;
  		prv = sg;
  	} while (left);
  
  	return 0;
  }
  EXPORT_SYMBOL(__sg_alloc_table);
  
  /**
   * sg_alloc_table - Allocate and initialize an sg table
   * @table:	The sg table header to use
   * @nents:	Number of entries in sg list
   * @gfp_mask:	GFP allocation mask
   *
   *  Description:
   *    Allocate and initialize an sg table. If @nents@ is larger than
   *    SG_MAX_SINGLE_ALLOC a chained sg table will be setup.
   *
   **/
  int sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask)
  {
  	int ret;
7cedb1f17   James Bottomley   SG: work with the...
286
287
  	ret = __sg_alloc_table(table, nents, SG_MAX_SINGLE_ALLOC,
  			       gfp_mask, sg_kmalloc);
0db9299f4   Jens Axboe   SG: Move function...
288
  	if (unlikely(ret))
7cedb1f17   James Bottomley   SG: work with the...
289
  		__sg_free_table(table, SG_MAX_SINGLE_ALLOC, sg_kfree);
0db9299f4   Jens Axboe   SG: Move function...
290
291
292
293
  
  	return ret;
  }
  EXPORT_SYMBOL(sg_alloc_table);
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
294
295
  
  /**
137d3edb4   Tejun Heo   sg: reimplement s...
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
   * sg_miter_start - start mapping iteration over a sg list
   * @miter: sg mapping iter to be started
   * @sgl: sg list to iterate over
   * @nents: number of sg entries
   *
   * Description:
   *   Starts mapping iterator @miter.
   *
   * Context:
   *   Don't care.
   */
  void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl,
  		    unsigned int nents, unsigned int flags)
  {
  	memset(miter, 0, sizeof(struct sg_mapping_iter));
  
  	miter->__sg = sgl;
  	miter->__nents = nents;
  	miter->__offset = 0;
6de7e356f   Sebastian Andrzej Siewior   lib/scatterlist: ...
315
  	WARN_ON(!(flags & (SG_MITER_TO_SG | SG_MITER_FROM_SG)));
137d3edb4   Tejun Heo   sg: reimplement s...
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
  	miter->__flags = flags;
  }
  EXPORT_SYMBOL(sg_miter_start);
  
  /**
   * sg_miter_next - proceed mapping iterator to the next mapping
   * @miter: sg mapping iter to proceed
   *
   * Description:
   *   Proceeds @miter@ to the next mapping.  @miter@ should have been
   *   started using sg_miter_start().  On successful return,
   *   @miter@->page, @miter@->addr and @miter@->length point to the
   *   current mapping.
   *
   * Context:
   *   IRQ disabled if SG_MITER_ATOMIC.  IRQ must stay disabled till
   *   @miter@ is stopped.  May sleep if !SG_MITER_ATOMIC.
   *
   * Returns:
   *   true if @miter contains the next mapping.  false if end of sg
   *   list is reached.
   */
  bool sg_miter_next(struct sg_mapping_iter *miter)
  {
  	unsigned int off, len;
  
  	/* check for end and drop resources from the last iteration */
  	if (!miter->__nents)
  		return false;
  
  	sg_miter_stop(miter);
  
  	/* get to the next sg if necessary.  __offset is adjusted by stop */
23c560a99   Tejun Heo   scatterlist: make...
349
350
351
352
353
354
  	while (miter->__offset == miter->__sg->length) {
  		if (--miter->__nents) {
  			miter->__sg = sg_next(miter->__sg);
  			miter->__offset = 0;
  		} else
  			return false;
137d3edb4   Tejun Heo   sg: reimplement s...
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
  	}
  
  	/* map the next page */
  	off = miter->__sg->offset + miter->__offset;
  	len = miter->__sg->length - miter->__offset;
  
  	miter->page = nth_page(sg_page(miter->__sg), off >> PAGE_SHIFT);
  	off &= ~PAGE_MASK;
  	miter->length = min_t(unsigned int, len, PAGE_SIZE - off);
  	miter->consumed = miter->length;
  
  	if (miter->__flags & SG_MITER_ATOMIC)
  		miter->addr = kmap_atomic(miter->page, KM_BIO_SRC_IRQ) + off;
  	else
  		miter->addr = kmap(miter->page) + off;
  
  	return true;
  }
  EXPORT_SYMBOL(sg_miter_next);
  
  /**
   * sg_miter_stop - stop mapping iteration
   * @miter: sg mapping iter to be stopped
   *
   * Description:
   *   Stops mapping iterator @miter.  @miter should have been started
   *   started using sg_miter_start().  A stopped iteration can be
   *   resumed by calling sg_miter_next() on it.  This is useful when
   *   resources (kmap) need to be released during iteration.
   *
   * Context:
   *   IRQ disabled if the SG_MITER_ATOMIC is set.  Don't care otherwise.
   */
  void sg_miter_stop(struct sg_mapping_iter *miter)
  {
  	WARN_ON(miter->consumed > miter->length);
  
  	/* drop resources from the last iteration */
  	if (miter->addr) {
  		miter->__offset += miter->consumed;
6de7e356f   Sebastian Andrzej Siewior   lib/scatterlist: ...
395
396
  		if (miter->__flags & SG_MITER_TO_SG)
  			flush_kernel_dcache_page(miter->page);
137d3edb4   Tejun Heo   sg: reimplement s...
397
398
399
400
  		if (miter->__flags & SG_MITER_ATOMIC) {
  			WARN_ON(!irqs_disabled());
  			kunmap_atomic(miter->addr, KM_BIO_SRC_IRQ);
  		} else
f652c521e   Arjan van de Ven   lib/scatterlist.c...
401
  			kunmap(miter->page);
137d3edb4   Tejun Heo   sg: reimplement s...
402
403
404
405
406
407
408
409
410
411
  
  		miter->page = NULL;
  		miter->addr = NULL;
  		miter->length = 0;
  		miter->consumed = 0;
  	}
  }
  EXPORT_SYMBOL(sg_miter_stop);
  
  /**
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
412
413
414
415
416
417
418
419
420
421
422
423
424
425
   * sg_copy_buffer - Copy data between a linear buffer and an SG list
   * @sgl:		 The SG list
   * @nents:		 Number of SG entries
   * @buf:		 Where to copy from
   * @buflen:		 The number of bytes to copy
   * @to_buffer: 		 transfer direction (non zero == from an sg list to a
   * 			 buffer, 0 == from a buffer to an sg list
   *
   * Returns the number of copied bytes.
   *
   **/
  static size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents,
  			     void *buf, size_t buflen, int to_buffer)
  {
137d3edb4   Tejun Heo   sg: reimplement s...
426
427
  	unsigned int offset = 0;
  	struct sg_mapping_iter miter;
50bed2e28   FUJITA Tomonori   sg: disable inter...
428
  	unsigned long flags;
6de7e356f   Sebastian Andrzej Siewior   lib/scatterlist: ...
429
430
431
432
433
434
  	unsigned int sg_flags = SG_MITER_ATOMIC;
  
  	if (to_buffer)
  		sg_flags |= SG_MITER_FROM_SG;
  	else
  		sg_flags |= SG_MITER_TO_SG;
137d3edb4   Tejun Heo   sg: reimplement s...
435

6de7e356f   Sebastian Andrzej Siewior   lib/scatterlist: ...
436
  	sg_miter_start(&miter, sgl, nents, sg_flags);
137d3edb4   Tejun Heo   sg: reimplement s...
437

50bed2e28   FUJITA Tomonori   sg: disable inter...
438
  	local_irq_save(flags);
137d3edb4   Tejun Heo   sg: reimplement s...
439
440
441
442
443
444
445
  	while (sg_miter_next(&miter) && offset < buflen) {
  		unsigned int len;
  
  		len = min(miter.length, buflen - offset);
  
  		if (to_buffer)
  			memcpy(buf + offset, miter.addr, len);
6de7e356f   Sebastian Andrzej Siewior   lib/scatterlist: ...
446
  		else
137d3edb4   Tejun Heo   sg: reimplement s...
447
  			memcpy(miter.addr, buf + offset, len);
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
448

137d3edb4   Tejun Heo   sg: reimplement s...
449
  		offset += len;
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
450
  	}
137d3edb4   Tejun Heo   sg: reimplement s...
451
  	sg_miter_stop(&miter);
50bed2e28   FUJITA Tomonori   sg: disable inter...
452
  	local_irq_restore(flags);
137d3edb4   Tejun Heo   sg: reimplement s...
453
  	return offset;
b1adaf65b   FUJITA Tomonori   [SCSI] block: add...
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
  }
  
  /**
   * sg_copy_from_buffer - Copy from a linear buffer to an SG list
   * @sgl:		 The SG list
   * @nents:		 Number of SG entries
   * @buf:		 Where to copy from
   * @buflen:		 The number of bytes to copy
   *
   * Returns the number of copied bytes.
   *
   **/
  size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
  			   void *buf, size_t buflen)
  {
  	return sg_copy_buffer(sgl, nents, buf, buflen, 0);
  }
  EXPORT_SYMBOL(sg_copy_from_buffer);
  
  /**
   * sg_copy_to_buffer - Copy from an SG list to a linear buffer
   * @sgl:		 The SG list
   * @nents:		 Number of SG entries
   * @buf:		 Where to copy to
   * @buflen:		 The number of bytes to copy
   *
   * Returns the number of copied bytes.
   *
   **/
  size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
  			 void *buf, size_t buflen)
  {
  	return sg_copy_buffer(sgl, nents, buf, buflen, 1);
  }
  EXPORT_SYMBOL(sg_copy_to_buffer);