~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/blocklayout/extents.c

Version: ~ [ linux-5.2-rc4 ] ~ [ linux-5.1.9 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.50 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.125 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.181 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.181 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/fs/nfs/blocklayout/blocklayout.h
  3  *
  4  *  Module for the NFSv4.1 pNFS block layout driver.
  5  *
  6  *  Copyright (c) 2006 The Regents of the University of Michigan.
  7  *  All rights reserved.
  8  *
  9  *  Andy Adamson <andros@citi.umich.edu>
 10  *  Fred Isaman <iisaman@umich.edu>
 11  *
 12  * permission is granted to use, copy, create derivative works and
 13  * redistribute this software and such derivative works for any purpose,
 14  * so long as the name of the university of michigan is not used in
 15  * any advertising or publicity pertaining to the use or distribution
 16  * of this software without specific, written prior authorization.  if
 17  * the above copyright notice or any other identification of the
 18  * university of michigan is included in any copy of any portion of
 19  * this software, then the disclaimer below must also be included.
 20  *
 21  * this software is provided as is, without representation from the
 22  * university of michigan as to its fitness for any purpose, and without
 23  * warranty by the university of michigan of any kind, either express
 24  * or implied, including without limitation the implied warranties of
 25  * merchantability and fitness for a particular purpose.  the regents
 26  * of the university of michigan shall not be liable for any damages,
 27  * including special, indirect, incidental, or consequential damages,
 28  * with respect to any claim arising out or in connection with the use
 29  * of the software, even if it has been or is hereafter advised of the
 30  * possibility of such damages.
 31  */
 32 
 33 #include "blocklayout.h"
 34 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
 35 
 36 /* Bit numbers */
 37 #define EXTENT_INITIALIZED 0
 38 #define EXTENT_WRITTEN     1
 39 #define EXTENT_IN_COMMIT   2
 40 #define INTERNAL_EXISTS    MY_MAX_TAGS
 41 #define INTERNAL_MASK      ((1 << INTERNAL_EXISTS) - 1)
 42 
 43 /* Returns largest t<=s s.t. t%base==0 */
 44 static inline sector_t normalize(sector_t s, int base)
 45 {
 46         sector_t tmp = s; /* Since do_div modifies its argument */
 47         return s - do_div(tmp, base);
 48 }
 49 
 50 static inline sector_t normalize_up(sector_t s, int base)
 51 {
 52         return normalize(s + base - 1, base);
 53 }
 54 
 55 /* Complete stub using list while determine API wanted */
 56 
 57 /* Returns tags, or negative */
 58 static int32_t _find_entry(struct my_tree *tree, u64 s)
 59 {
 60         struct pnfs_inval_tracking *pos;
 61 
 62         dprintk("%s(%llu) enter\n", __func__, s);
 63         list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
 64                 if (pos->it_sector > s)
 65                         continue;
 66                 else if (pos->it_sector == s)
 67                         return pos->it_tags & INTERNAL_MASK;
 68                 else
 69                         break;
 70         }
 71         return -ENOENT;
 72 }
 73 
 74 static inline
 75 int _has_tag(struct my_tree *tree, u64 s, int32_t tag)
 76 {
 77         int32_t tags;
 78 
 79         dprintk("%s(%llu, %i) enter\n", __func__, s, tag);
 80         s = normalize(s, tree->mtt_step_size);
 81         tags = _find_entry(tree, s);
 82         if ((tags < 0) || !(tags & (1 << tag)))
 83                 return 0;
 84         else
 85                 return 1;
 86 }
 87 
 88 /* Creates entry with tag, or if entry already exists, unions tag to it.
 89  * If storage is not NULL, newly created entry will use it.
 90  * Returns number of entries added, or negative on error.
 91  */
 92 static int _add_entry(struct my_tree *tree, u64 s, int32_t tag,
 93                       struct pnfs_inval_tracking *storage)
 94 {
 95         int found = 0;
 96         struct pnfs_inval_tracking *pos;
 97 
 98         dprintk("%s(%llu, %i, %p) enter\n", __func__, s, tag, storage);
 99         list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
100                 if (pos->it_sector > s)
101                         continue;
102                 else if (pos->it_sector == s) {
103                         found = 1;
104                         break;
105                 } else
106                         break;
107         }
108         if (found) {
109                 pos->it_tags |= (1 << tag);
110                 return 0;
111         } else {
112                 struct pnfs_inval_tracking *new;
113                 new = storage;
114                 new->it_sector = s;
115                 new->it_tags = (1 << tag);
116                 list_add(&new->it_link, &pos->it_link);
117                 return 1;
118         }
119 }
120 
121 /* XXXX Really want option to not create */
122 /* Over range, unions tag with existing entries, else creates entry with tag */
123 static int _set_range(struct my_tree *tree, int32_t tag, u64 s, u64 length)
124 {
125         u64 i;
126 
127         dprintk("%s(%i, %llu, %llu) enter\n", __func__, tag, s, length);
128         for (i = normalize(s, tree->mtt_step_size); i < s + length;
129              i += tree->mtt_step_size)
130                 if (_add_entry(tree, i, tag, NULL))
131                         return -ENOMEM;
132         return 0;
133 }
134 
135 /* Ensure that future operations on given range of tree will not malloc */
136 static int _preload_range(struct pnfs_inval_markings *marks,
137                 u64 offset, u64 length)
138 {
139         u64 start, end, s;
140         int count, i, used = 0, status = -ENOMEM;
141         struct pnfs_inval_tracking **storage;
142         struct my_tree  *tree = &marks->im_tree;
143 
144         dprintk("%s(%llu, %llu) enter\n", __func__, offset, length);
145         start = normalize(offset, tree->mtt_step_size);
146         end = normalize_up(offset + length, tree->mtt_step_size);
147         count = (int)(end - start) / (int)tree->mtt_step_size;
148 
149         /* Pre-malloc what memory we might need */
150         storage = kcalloc(count, sizeof(*storage), GFP_NOFS);
151         if (!storage)
152                 return -ENOMEM;
153         for (i = 0; i < count; i++) {
154                 storage[i] = kmalloc(sizeof(struct pnfs_inval_tracking),
155                                      GFP_NOFS);
156                 if (!storage[i])
157                         goto out_cleanup;
158         }
159 
160         spin_lock_bh(&marks->im_lock);
161         for (s = start; s < end; s += tree->mtt_step_size)
162                 used += _add_entry(tree, s, INTERNAL_EXISTS, storage[used]);
163         spin_unlock_bh(&marks->im_lock);
164 
165         status = 0;
166 
167  out_cleanup:
168         for (i = used; i < count; i++) {
169                 if (!storage[i])
170                         break;
171                 kfree(storage[i]);
172         }
173         kfree(storage);
174         return status;
175 }
176 
177 /* We are relying on page lock to serialize this */
178 int bl_is_sector_init(struct pnfs_inval_markings *marks, sector_t isect)
179 {
180         int rv;
181 
182         spin_lock_bh(&marks->im_lock);
183         rv = _has_tag(&marks->im_tree, isect, EXTENT_INITIALIZED);
184         spin_unlock_bh(&marks->im_lock);
185         return rv;
186 }
187 
188 /* Assume start, end already sector aligned */
189 static int
190 _range_has_tag(struct my_tree *tree, u64 start, u64 end, int32_t tag)
191 {
192         struct pnfs_inval_tracking *pos;
193         u64 expect = 0;
194 
195         dprintk("%s(%llu, %llu, %i) enter\n", __func__, start, end, tag);
196         list_for_each_entry_reverse(pos, &tree->mtt_stub, it_link) {
197                 if (pos->it_sector >= end)
198                         continue;
199                 if (!expect) {
200                         if ((pos->it_sector == end - tree->mtt_step_size) &&
201                             (pos->it_tags & (1 << tag))) {
202                                 expect = pos->it_sector - tree->mtt_step_size;
203                                 if (pos->it_sector < tree->mtt_step_size || expect < start)
204                                         return 1;
205                                 continue;
206                         } else {
207                                 return 0;
208                         }
209                 }
210                 if (pos->it_sector != expect || !(pos->it_tags & (1 << tag)))
211                         return 0;
212                 expect -= tree->mtt_step_size;
213                 if (expect < start)
214                         return 1;
215         }
216         return 0;
217 }
218 
219 static int is_range_written(struct pnfs_inval_markings *marks,
220                             sector_t start, sector_t end)
221 {
222         int rv;
223 
224         spin_lock_bh(&marks->im_lock);
225         rv = _range_has_tag(&marks->im_tree, start, end, EXTENT_WRITTEN);
226         spin_unlock_bh(&marks->im_lock);
227         return rv;
228 }
229 
230 /* Marks sectors in [offest, offset_length) as having been initialized.
231  * All lengths are step-aligned, where step is min(pagesize, blocksize).
232  * Currently assumes offset is page-aligned
233  */
234 int bl_mark_sectors_init(struct pnfs_inval_markings *marks,
235                              sector_t offset, sector_t length)
236 {
237         sector_t start, end;
238 
239         dprintk("%s(offset=%llu,len=%llu) enter\n",
240                 __func__, (u64)offset, (u64)length);
241 
242         start = normalize(offset, marks->im_block_size);
243         end = normalize_up(offset + length, marks->im_block_size);
244         if (_preload_range(marks, start, end - start))
245                 goto outerr;
246 
247         spin_lock_bh(&marks->im_lock);
248         if (_set_range(&marks->im_tree, EXTENT_INITIALIZED, offset, length))
249                 goto out_unlock;
250         spin_unlock_bh(&marks->im_lock);
251 
252         return 0;
253 
254 out_unlock:
255         spin_unlock_bh(&marks->im_lock);
256 outerr:
257         return -ENOMEM;
258 }
259 
260 /* Marks sectors in [offest, offset+length) as having been written to disk.
261  * All lengths should be block aligned.
262  */
263 static int mark_written_sectors(struct pnfs_inval_markings *marks,
264                                 sector_t offset, sector_t length)
265 {
266         int status;
267 
268         dprintk("%s(offset=%llu,len=%llu) enter\n", __func__,
269                 (u64)offset, (u64)length);
270         spin_lock_bh(&marks->im_lock);
271         status = _set_range(&marks->im_tree, EXTENT_WRITTEN, offset, length);
272         spin_unlock_bh(&marks->im_lock);
273         return status;
274 }
275 
276 static void print_short_extent(struct pnfs_block_short_extent *be)
277 {
278         dprintk("PRINT SHORT EXTENT extent %p\n", be);
279         if (be) {
280                 dprintk("        be_f_offset %llu\n", (u64)be->bse_f_offset);
281                 dprintk("        be_length   %llu\n", (u64)be->bse_length);
282         }
283 }
284 
285 static void print_clist(struct list_head *list, unsigned int count)
286 {
287         struct pnfs_block_short_extent *be;
288         unsigned int i = 0;
289 
290         ifdebug(FACILITY) {
291                 printk(KERN_DEBUG "****************\n");
292                 printk(KERN_DEBUG "Extent list looks like:\n");
293                 list_for_each_entry(be, list, bse_node) {
294                         i++;
295                         print_short_extent(be);
296                 }
297                 if (i != count)
298                         printk(KERN_DEBUG "\n\nExpected %u entries\n\n\n", count);
299                 printk(KERN_DEBUG "****************\n");
300         }
301 }
302 
303 /* Note: In theory, we should do more checking that devid's match between
304  * old and new, but if they don't, the lists are too corrupt to salvage anyway.
305  */
306 /* Note this is very similar to bl_add_merge_extent */
307 static void add_to_commitlist(struct pnfs_block_layout *bl,
308                               struct pnfs_block_short_extent *new)
309 {
310         struct list_head *clist = &bl->bl_commit;
311         struct pnfs_block_short_extent *old, *save;
312         sector_t end = new->bse_f_offset + new->bse_length;
313 
314         dprintk("%s enter\n", __func__);
315         print_short_extent(new);
316         print_clist(clist, bl->bl_count);
317         bl->bl_count++;
318         /* Scan for proper place to insert, extending new to the left
319          * as much as possible.
320          */
321         list_for_each_entry_safe(old, save, clist, bse_node) {
322                 if (new->bse_f_offset < old->bse_f_offset)
323                         break;
324                 if (end <= old->bse_f_offset + old->bse_length) {
325                         /* Range is already in list */
326                         bl->bl_count--;
327                         kfree(new);
328                         return;
329                 } else if (new->bse_f_offset <=
330                                 old->bse_f_offset + old->bse_length) {
331                         /* new overlaps or abuts existing be */
332                         if (new->bse_mdev == old->bse_mdev) {
333                                 /* extend new to fully replace old */
334                                 new->bse_length += new->bse_f_offset -
335                                                 old->bse_f_offset;
336                                 new->bse_f_offset = old->bse_f_offset;
337                                 list_del(&old->bse_node);
338                                 bl->bl_count--;
339                                 kfree(old);
340                         }
341                 }
342         }
343         /* Note that if we never hit the above break, old will not point to a
344          * valid extent.  However, in that case &old->bse_node==list.
345          */
346         list_add_tail(&new->bse_node, &old->bse_node);
347         /* Scan forward for overlaps.  If we find any, extend new and
348          * remove the overlapped extent.
349          */
350         old = list_prepare_entry(new, clist, bse_node);
351         list_for_each_entry_safe_continue(old, save, clist, bse_node) {
352                 if (end < old->bse_f_offset)
353                         break;
354                 /* new overlaps or abuts old */
355                 if (new->bse_mdev == old->bse_mdev) {
356                         if (end < old->bse_f_offset + old->bse_length) {
357                                 /* extend new to fully cover old */
358                                 end = old->bse_f_offset + old->bse_length;
359                                 new->bse_length = end - new->bse_f_offset;
360                         }
361                         list_del(&old->bse_node);
362                         bl->bl_count--;
363                         kfree(old);
364                 }
365         }
366         dprintk("%s: after merging\n", __func__);
367         print_clist(clist, bl->bl_count);
368 }
369 
370 /* Note the range described by offset, length is guaranteed to be contained
371  * within be.
372  * new will be freed, either by this function or add_to_commitlist if they
373  * decide not to use it, or after LAYOUTCOMMIT uses it in the commitlist.
374  */
375 int bl_mark_for_commit(struct pnfs_block_extent *be,
376                     sector_t offset, sector_t length,
377                     struct pnfs_block_short_extent *new)
378 {
379         sector_t new_end, end = offset + length;
380         struct pnfs_block_layout *bl = container_of(be->be_inval,
381                                                     struct pnfs_block_layout,
382                                                     bl_inval);
383 
384         mark_written_sectors(be->be_inval, offset, length);
385         /* We want to add the range to commit list, but it must be
386          * block-normalized, and verified that the normalized range has
387          * been entirely written to disk.
388          */
389         new->bse_f_offset = offset;
390         offset = normalize(offset, bl->bl_blocksize);
391         if (offset < new->bse_f_offset) {
392                 if (is_range_written(be->be_inval, offset, new->bse_f_offset))
393                         new->bse_f_offset = offset;
394                 else
395                         new->bse_f_offset = offset + bl->bl_blocksize;
396         }
397         new_end = normalize_up(end, bl->bl_blocksize);
398         if (end < new_end) {
399                 if (is_range_written(be->be_inval, end, new_end))
400                         end = new_end;
401                 else
402                         end = new_end - bl->bl_blocksize;
403         }
404         if (end <= new->bse_f_offset) {
405                 kfree(new);
406                 return 0;
407         }
408         new->bse_length = end - new->bse_f_offset;
409         new->bse_devid = be->be_devid;
410         new->bse_mdev = be->be_mdev;
411 
412         spin_lock(&bl->bl_ext_lock);
413         add_to_commitlist(bl, new);
414         spin_unlock(&bl->bl_ext_lock);
415         return 0;
416 }
417 
418 static void print_bl_extent(struct pnfs_block_extent *be)
419 {
420         dprintk("PRINT EXTENT extent %p\n", be);
421         if (be) {
422                 dprintk("        be_f_offset %llu\n", (u64)be->be_f_offset);
423                 dprintk("        be_length   %llu\n", (u64)be->be_length);
424                 dprintk("        be_v_offset %llu\n", (u64)be->be_v_offset);
425                 dprintk("        be_state    %d\n", be->be_state);
426         }
427 }
428 
429 static void
430 destroy_extent(struct kref *kref)
431 {
432         struct pnfs_block_extent *be;
433 
434         be = container_of(kref, struct pnfs_block_extent, be_refcnt);
435         dprintk("%s be=%p\n", __func__, be);
436         kfree(be);
437 }
438 
439 void
440 bl_put_extent(struct pnfs_block_extent *be)
441 {
442         if (be) {
443                 dprintk("%s enter %p (%i)\n", __func__, be,
444                         atomic_read(&be->be_refcnt.refcount));
445                 kref_put(&be->be_refcnt, destroy_extent);
446         }
447 }
448 
449 struct pnfs_block_extent *bl_alloc_extent(void)
450 {
451         struct pnfs_block_extent *be;
452 
453         be = kmalloc(sizeof(struct pnfs_block_extent), GFP_NOFS);
454         if (!be)
455                 return NULL;
456         INIT_LIST_HEAD(&be->be_node);
457         kref_init(&be->be_refcnt);
458         be->be_inval = NULL;
459         return be;
460 }
461 
462 static void print_elist(struct list_head *list)
463 {
464         struct pnfs_block_extent *be;
465         dprintk("****************\n");
466         dprintk("Extent list looks like:\n");
467         list_for_each_entry(be, list, be_node) {
468                 print_bl_extent(be);
469         }
470         dprintk("****************\n");
471 }
472 
473 static inline int
474 extents_consistent(struct pnfs_block_extent *old, struct pnfs_block_extent *new)
475 {
476         /* Note this assumes new->be_f_offset >= old->be_f_offset */
477         return (new->be_state == old->be_state) &&
478                 ((new->be_state == PNFS_BLOCK_NONE_DATA) ||
479                  ((new->be_v_offset - old->be_v_offset ==
480                    new->be_f_offset - old->be_f_offset) &&
481                   new->be_mdev == old->be_mdev));
482 }
483 
484 /* Adds new to appropriate list in bl, modifying new and removing existing
485  * extents as appropriate to deal with overlaps.
486  *
487  * See bl_find_get_extent for list constraints.
488  *
489  * Refcount on new is already set.  If end up not using it, or error out,
490  * need to put the reference.
491  *
492  * bl->bl_ext_lock is held by caller.
493  */
494 int
495 bl_add_merge_extent(struct pnfs_block_layout *bl,
496                      struct pnfs_block_extent *new)
497 {
498         struct pnfs_block_extent *be, *tmp;
499         sector_t end = new->be_f_offset + new->be_length;
500         struct list_head *list;
501 
502         dprintk("%s enter with be=%p\n", __func__, new);
503         print_bl_extent(new);
504         list = &bl->bl_extents[bl_choose_list(new->be_state)];
505         print_elist(list);
506 
507         /* Scan for proper place to insert, extending new to the left
508          * as much as possible.
509          */
510         list_for_each_entry_safe_reverse(be, tmp, list, be_node) {
511                 if (new->be_f_offset >= be->be_f_offset + be->be_length)
512                         break;
513                 if (new->be_f_offset >= be->be_f_offset) {
514                         if (end <= be->be_f_offset + be->be_length) {
515                                 /* new is a subset of existing be*/
516                                 if (extents_consistent(be, new)) {
517                                         dprintk("%s: new is subset, ignoring\n",
518                                                 __func__);
519                                         bl_put_extent(new);
520                                         return 0;
521                                 } else {
522                                         goto out_err;
523                                 }
524                         } else {
525                                 /* |<--   be   -->|
526                                  *          |<--   new   -->| */
527                                 if (extents_consistent(be, new)) {
528                                         /* extend new to fully replace be */
529                                         new->be_length += new->be_f_offset -
530                                                 be->be_f_offset;
531                                         new->be_f_offset = be->be_f_offset;
532                                         new->be_v_offset = be->be_v_offset;
533                                         dprintk("%s: removing %p\n", __func__, be);
534                                         list_del(&be->be_node);
535                                         bl_put_extent(be);
536                                 } else {
537                                         goto out_err;
538                                 }
539                         }
540                 } else if (end >= be->be_f_offset + be->be_length) {
541                         /* new extent overlap existing be */
542                         if (extents_consistent(be, new)) {
543                                 /* extend new to fully replace be */
544                                 dprintk("%s: removing %p\n", __func__, be);
545                                 list_del(&be->be_node);
546                                 bl_put_extent(be);
547                         } else {
548                                 goto out_err;
549                         }
550                 } else if (end > be->be_f_offset) {
551                         /*           |<--   be   -->|
552                          *|<--   new   -->| */
553                         if (extents_consistent(new, be)) {
554                                 /* extend new to fully replace be */
555                                 new->be_length += be->be_f_offset + be->be_length -
556                                         new->be_f_offset - new->be_length;
557                                 dprintk("%s: removing %p\n", __func__, be);
558                                 list_del(&be->be_node);
559                                 bl_put_extent(be);
560                         } else {
561                                 goto out_err;
562                         }
563                 }
564         }
565         /* Note that if we never hit the above break, be will not point to a
566          * valid extent.  However, in that case &be->be_node==list.
567          */
568         list_add(&new->be_node, &be->be_node);
569         dprintk("%s: inserting new\n", __func__);
570         print_elist(list);
571         /* FIXME - The per-list consistency checks have all been done,
572          * should now check cross-list consistency.
573          */
574         return 0;
575 
576  out_err:
577         bl_put_extent(new);
578         return -EIO;
579 }
580 
581 /* Returns extent, or NULL.  If a second READ extent exists, it is returned
582  * in cow_read, if given.
583  *
584  * The extents are kept in two seperate ordered lists, one for READ and NONE,
585  * one for READWRITE and INVALID.  Within each list, we assume:
586  * 1. Extents are ordered by file offset.
587  * 2. For any given isect, there is at most one extents that matches.
588  */
589 struct pnfs_block_extent *
590 bl_find_get_extent(struct pnfs_block_layout *bl, sector_t isect,
591             struct pnfs_block_extent **cow_read)
592 {
593         struct pnfs_block_extent *be, *cow, *ret;
594         int i;
595 
596         dprintk("%s enter with isect %llu\n", __func__, (u64)isect);
597         cow = ret = NULL;
598         spin_lock(&bl->bl_ext_lock);
599         for (i = 0; i < EXTENT_LISTS; i++) {
600                 list_for_each_entry_reverse(be, &bl->bl_extents[i], be_node) {
601                         if (isect >= be->be_f_offset + be->be_length)
602                                 break;
603                         if (isect >= be->be_f_offset) {
604                                 /* We have found an extent */
605                                 dprintk("%s Get %p (%i)\n", __func__, be,
606                                         atomic_read(&be->be_refcnt.refcount));
607                                 kref_get(&be->be_refcnt);
608                                 if (!ret)
609                                         ret = be;
610                                 else if (be->be_state != PNFS_BLOCK_READ_DATA)
611                                         bl_put_extent(be);
612                                 else
613                                         cow = be;
614                                 break;
615                         }
616                 }
617                 if (ret &&
618                     (!cow_read || ret->be_state != PNFS_BLOCK_INVALID_DATA))
619                         break;
620         }
621         spin_unlock(&bl->bl_ext_lock);
622         if (cow_read)
623                 *cow_read = cow;
624         print_bl_extent(ret);
625         return ret;
626 }
627 
628 /* Similar to bl_find_get_extent, but called with lock held, and ignores cow */
629 static struct pnfs_block_extent *
630 bl_find_get_extent_locked(struct pnfs_block_layout *bl, sector_t isect)
631 {
632         struct pnfs_block_extent *be, *ret = NULL;
633         int i;
634 
635         dprintk("%s enter with isect %llu\n", __func__, (u64)isect);
636         for (i = 0; i < EXTENT_LISTS; i++) {
637                 if (ret)
638                         break;
639                 list_for_each_entry_reverse(be, &bl->bl_extents[i], be_node) {
640                         if (isect >= be->be_f_offset + be->be_length)
641                                 break;
642                         if (isect >= be->be_f_offset) {
643                                 /* We have found an extent */
644                                 dprintk("%s Get %p (%i)\n", __func__, be,
645                                         atomic_read(&be->be_refcnt.refcount));
646                                 kref_get(&be->be_refcnt);
647                                 ret = be;
648                                 break;
649                         }
650                 }
651         }
652         print_bl_extent(ret);
653         return ret;
654 }
655 
656 int
657 encode_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
658                                struct xdr_stream *xdr,
659                                const struct nfs4_layoutcommit_args *arg)
660 {
661         struct pnfs_block_short_extent *lce, *save;
662         unsigned int count = 0;
663         __be32 *p, *xdr_start;
664 
665         dprintk("%s enter\n", __func__);
666         /* BUG - creation of bl_commit is buggy - need to wait for
667          * entire block to be marked WRITTEN before it can be added.
668          */
669         spin_lock(&bl->bl_ext_lock);
670         /* Want to adjust for possible truncate */
671         /* We now want to adjust argument range */
672 
673         /* XDR encode the ranges found */
674         xdr_start = xdr_reserve_space(xdr, 8);
675         if (!xdr_start)
676                 goto out;
677         list_for_each_entry_safe(lce, save, &bl->bl_commit, bse_node) {
678                 p = xdr_reserve_space(xdr, 7 * 4 + sizeof(lce->bse_devid.data));
679                 if (!p)
680                         break;
681                 p = xdr_encode_opaque_fixed(p, lce->bse_devid.data, NFS4_DEVICEID4_SIZE);
682                 p = xdr_encode_hyper(p, lce->bse_f_offset << SECTOR_SHIFT);
683                 p = xdr_encode_hyper(p, lce->bse_length << SECTOR_SHIFT);
684                 p = xdr_encode_hyper(p, 0LL);
685                 *p++ = cpu_to_be32(PNFS_BLOCK_READWRITE_DATA);
686                 list_move_tail(&lce->bse_node, &bl->bl_committing);
687                 bl->bl_count--;
688                 count++;
689         }
690         xdr_start[0] = cpu_to_be32((xdr->p - xdr_start - 1) * 4);
691         xdr_start[1] = cpu_to_be32(count);
692 out:
693         spin_unlock(&bl->bl_ext_lock);
694         dprintk("%s found %i ranges\n", __func__, count);
695         return 0;
696 }
697 
698 /* Helper function to set_to_rw that initialize a new extent */
699 static void
700 _prep_new_extent(struct pnfs_block_extent *new,
701                  struct pnfs_block_extent *orig,
702                  sector_t offset, sector_t length, int state)
703 {
704         kref_init(&new->be_refcnt);
705         /* don't need to INIT_LIST_HEAD(&new->be_node) */
706         memcpy(&new->be_devid, &orig->be_devid, sizeof(struct nfs4_deviceid));
707         new->be_mdev = orig->be_mdev;
708         new->be_f_offset = offset;
709         new->be_length = length;
710         new->be_v_offset = orig->be_v_offset - orig->be_f_offset + offset;
711         new->be_state = state;
712         new->be_inval = orig->be_inval;
713 }
714 
715 /* Tries to merge be with extent in front of it in list.
716  * Frees storage if not used.
717  */
718 static struct pnfs_block_extent *
719 _front_merge(struct pnfs_block_extent *be, struct list_head *head,
720              struct pnfs_block_extent *storage)
721 {
722         struct pnfs_block_extent *prev;
723 
724         if (!storage)
725                 goto no_merge;
726         if (&be->be_node == head || be->be_node.prev == head)
727                 goto no_merge;
728         prev = list_entry(be->be_node.prev, struct pnfs_block_extent, be_node);
729         if ((prev->be_f_offset + prev->be_length != be->be_f_offset) ||
730             !extents_consistent(prev, be))
731                 goto no_merge;
732         _prep_new_extent(storage, prev, prev->be_f_offset,
733                          prev->be_length + be->be_length, prev->be_state);
734         list_replace(&prev->be_node, &storage->be_node);
735         bl_put_extent(prev);
736         list_del(&be->be_node);
737         bl_put_extent(be);
738         return storage;
739 
740  no_merge:
741         kfree(storage);
742         return be;
743 }
744 
745 static u64
746 set_to_rw(struct pnfs_block_layout *bl, u64 offset, u64 length)
747 {
748         u64 rv = offset + length;
749         struct pnfs_block_extent *be, *e1, *e2, *e3, *new, *old;
750         struct pnfs_block_extent *children[3];
751         struct pnfs_block_extent *merge1 = NULL, *merge2 = NULL;
752         int i = 0, j;
753 
754         dprintk("%s(%llu, %llu)\n", __func__, offset, length);
755         /* Create storage for up to three new extents e1, e2, e3 */
756         e1 = kmalloc(sizeof(*e1), GFP_ATOMIC);
757         e2 = kmalloc(sizeof(*e2), GFP_ATOMIC);
758         e3 = kmalloc(sizeof(*e3), GFP_ATOMIC);
759         /* BUG - we are ignoring any failure */
760         if (!e1 || !e2 || !e3)
761                 goto out_nosplit;
762 
763         spin_lock(&bl->bl_ext_lock);
764         be = bl_find_get_extent_locked(bl, offset);
765         rv = be->be_f_offset + be->be_length;
766         if (be->be_state != PNFS_BLOCK_INVALID_DATA) {
767                 spin_unlock(&bl->bl_ext_lock);
768                 goto out_nosplit;
769         }
770         /* Add e* to children, bumping e*'s krefs */
771         if (be->be_f_offset != offset) {
772                 _prep_new_extent(e1, be, be->be_f_offset,
773                                  offset - be->be_f_offset,
774                                  PNFS_BLOCK_INVALID_DATA);
775                 children[i++] = e1;
776                 print_bl_extent(e1);
777         } else
778                 merge1 = e1;
779         _prep_new_extent(e2, be, offset,
780                          min(length, be->be_f_offset + be->be_length - offset),
781                          PNFS_BLOCK_READWRITE_DATA);
782         children[i++] = e2;
783         print_bl_extent(e2);
784         if (offset + length < be->be_f_offset + be->be_length) {
785                 _prep_new_extent(e3, be, e2->be_f_offset + e2->be_length,
786                                  be->be_f_offset + be->be_length -
787                                  offset - length,
788                                  PNFS_BLOCK_INVALID_DATA);
789                 children[i++] = e3;
790                 print_bl_extent(e3);
791         } else
792                 merge2 = e3;
793 
794         /* Remove be from list, and insert the e* */
795         /* We don't get refs on e*, since this list is the base reference
796          * set when init'ed.
797          */
798         if (i < 3)
799                 children[i] = NULL;
800         new = children[0];
801         list_replace(&be->be_node, &new->be_node);
802         bl_put_extent(be);
803         new = _front_merge(new, &bl->bl_extents[RW_EXTENT], merge1);
804         for (j = 1; j < i; j++) {
805                 old = new;
806                 new = children[j];
807                 list_add(&new->be_node, &old->be_node);
808         }
809         if (merge2) {
810                 /* This is a HACK, should just create a _back_merge function */
811                 new = list_entry(new->be_node.next,
812                                  struct pnfs_block_extent, be_node);
813                 new = _front_merge(new, &bl->bl_extents[RW_EXTENT], merge2);
814         }
815         spin_unlock(&bl->bl_ext_lock);
816 
817         /* Since we removed the base reference above, be is now scheduled for
818          * destruction.
819          */
820         bl_put_extent(be);
821         dprintk("%s returns %llu after split\n", __func__, rv);
822         return rv;
823 
824  out_nosplit:
825         kfree(e1);
826         kfree(e2);
827         kfree(e3);
828         dprintk("%s returns %llu without splitting\n", __func__, rv);
829         return rv;
830 }
831 
832 void
833 clean_pnfs_block_layoutupdate(struct pnfs_block_layout *bl,
834                               const struct nfs4_layoutcommit_args *arg,
835                               int status)
836 {
837         struct pnfs_block_short_extent *lce, *save;
838 
839         dprintk("%s status %d\n", __func__, status);
840         list_for_each_entry_safe(lce, save, &bl->bl_committing, bse_node) {
841                 if (likely(!status)) {
842                         u64 offset = lce->bse_f_offset;
843                         u64 end = offset + lce->bse_length;
844 
845                         do {
846                                 offset = set_to_rw(bl, offset, end - offset);
847                         } while (offset < end);
848                         list_del(&lce->bse_node);
849 
850                         kfree(lce);
851                 } else {
852                         list_del(&lce->bse_node);
853                         spin_lock(&bl->bl_ext_lock);
854                         add_to_commitlist(bl, lce);
855                         spin_unlock(&bl->bl_ext_lock);
856                 }
857         }
858 }
859 
860 int bl_push_one_short_extent(struct pnfs_inval_markings *marks)
861 {
862         struct pnfs_block_short_extent *new;
863 
864         new = kmalloc(sizeof(*new), GFP_NOFS);
865         if (unlikely(!new))
866                 return -ENOMEM;
867 
868         spin_lock_bh(&marks->im_lock);
869         list_add(&new->bse_node, &marks->im_extents);
870         spin_unlock_bh(&marks->im_lock);
871 
872         return 0;
873 }
874 
875 struct pnfs_block_short_extent *
876 bl_pop_one_short_extent(struct pnfs_inval_markings *marks)
877 {
878         struct pnfs_block_short_extent *rv = NULL;
879 
880         spin_lock_bh(&marks->im_lock);
881         if (!list_empty(&marks->im_extents)) {
882                 rv = list_entry((&marks->im_extents)->next,
883                                 struct pnfs_block_short_extent, bse_node);
884                 list_del_init(&rv->bse_node);
885         }
886         spin_unlock_bh(&marks->im_lock);
887 
888         return rv;
889 }
890 
891 void bl_free_short_extents(struct pnfs_inval_markings *marks, int num_to_free)
892 {
893         struct pnfs_block_short_extent *se = NULL, *tmp;
894 
895         if (num_to_free <= 0)
896                 return;
897 
898         spin_lock(&marks->im_lock);
899         list_for_each_entry_safe(se, tmp, &marks->im_extents, bse_node) {
900                 list_del(&se->bse_node);
901                 kfree(se);
902                 if (--num_to_free == 0)
903                         break;
904         }
905         spin_unlock(&marks->im_lock);
906 
907         BUG_ON(num_to_free > 0);
908 }
909 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp