Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/mm/frame_vector.c

  1 #include <linux/kernel.h>
  2 #include <linux/errno.h>
  3 #include <linux/err.h>
  4 #include <linux/mm.h>
  5 #include <linux/slab.h>
  6 #include <linux/vmalloc.h>
  7 #include <linux/pagemap.h>
  8 #include <linux/sched.h>
  9 
 10 /**
 11  * get_vaddr_frames() - map virtual addresses to pfns
 12  * @start:      starting user address
 13  * @nr_frames:  number of pages / pfns from start to map
 14  * @gup_flags:  flags modifying lookup behaviour
 15  * @vec:        structure which receives pages / pfns of the addresses mapped.
 16  *              It should have space for at least nr_frames entries.
 17  *
 18  * This function maps virtual addresses from @start and fills @vec structure
 19  * with page frame numbers or page pointers to corresponding pages (choice
 20  * depends on the type of the vma underlying the virtual address). If @start
 21  * belongs to a normal vma, the function grabs reference to each of the pages
 22  * to pin them in memory. If @start belongs to VM_IO | VM_PFNMAP vma, we don't
 23  * touch page structures and the caller must make sure pfns aren't reused for
 24  * anything else while he is using them.
 25  *
 26  * The function returns number of pages mapped which may be less than
 27  * @nr_frames. In particular we stop mapping if there are more vmas of
 28  * different type underlying the specified range of virtual addresses.
 29  * When the function isn't able to map a single page, it returns error.
 30  *
 31  * This function takes care of grabbing mmap_sem as necessary.
 32  */
 33 int get_vaddr_frames(unsigned long start, unsigned int nr_frames,
 34                      unsigned int gup_flags, struct frame_vector *vec)
 35 {
 36         struct mm_struct *mm = current->mm;
 37         struct vm_area_struct *vma;
 38         int ret = 0;
 39         int err;
 40         int locked;
 41 
 42         if (nr_frames == 0)
 43                 return 0;
 44 
 45         if (WARN_ON_ONCE(nr_frames > vec->nr_allocated))
 46                 nr_frames = vec->nr_allocated;
 47 
 48         down_read(&mm->mmap_sem);
 49         locked = 1;
 50         vma = find_vma_intersection(mm, start, start + 1);
 51         if (!vma) {
 52                 ret = -EFAULT;
 53                 goto out;
 54         }
 55         if (!(vma->vm_flags & (VM_IO | VM_PFNMAP))) {
 56                 vec->got_ref = true;
 57                 vec->is_pfns = false;
 58                 ret = get_user_pages_locked(start, nr_frames,
 59                         gup_flags, (struct page **)(vec->ptrs), &locked);
 60                 goto out;
 61         }
 62 
 63         vec->got_ref = false;
 64         vec->is_pfns = true;
 65         do {
 66                 unsigned long *nums = frame_vector_pfns(vec);
 67 
 68                 while (ret < nr_frames && start + PAGE_SIZE <= vma->vm_end) {
 69                         err = follow_pfn(vma, start, &nums[ret]);
 70                         if (err) {
 71                                 if (ret == 0)
 72                                         ret = err;
 73                                 goto out;
 74                         }
 75                         start += PAGE_SIZE;
 76                         ret++;
 77                 }
 78                 /*
 79                  * We stop if we have enough pages or if VMA doesn't completely
 80                  * cover the tail page.
 81                  */
 82                 if (ret >= nr_frames || start < vma->vm_end)
 83                         break;
 84                 vma = find_vma_intersection(mm, start, start + 1);
 85         } while (vma && vma->vm_flags & (VM_IO | VM_PFNMAP));
 86 out:
 87         if (locked)
 88                 up_read(&mm->mmap_sem);
 89         if (!ret)
 90                 ret = -EFAULT;
 91         if (ret > 0)
 92                 vec->nr_frames = ret;
 93         return ret;
 94 }
 95 EXPORT_SYMBOL(get_vaddr_frames);
 96 
 97 /**
 98  * put_vaddr_frames() - drop references to pages if get_vaddr_frames() acquired
 99  *                      them
100  * @vec:        frame vector to put
101  *
102  * Drop references to pages if get_vaddr_frames() acquired them. We also
103  * invalidate the frame vector so that it is prepared for the next call into
104  * get_vaddr_frames().
105  */
106 void put_vaddr_frames(struct frame_vector *vec)
107 {
108         int i;
109         struct page **pages;
110 
111         if (!vec->got_ref)
112                 goto out;
113         pages = frame_vector_pages(vec);
114         /*
115          * frame_vector_pages() might needed to do a conversion when
116          * get_vaddr_frames() got pages but vec was later converted to pfns.
117          * But it shouldn't really fail to convert pfns back...
118          */
119         if (WARN_ON(IS_ERR(pages)))
120                 goto out;
121         for (i = 0; i < vec->nr_frames; i++)
122                 put_page(pages[i]);
123         vec->got_ref = false;
124 out:
125         vec->nr_frames = 0;
126 }
127 EXPORT_SYMBOL(put_vaddr_frames);
128 
129 /**
130  * frame_vector_to_pages - convert frame vector to contain page pointers
131  * @vec:        frame vector to convert
132  *
133  * Convert @vec to contain array of page pointers.  If the conversion is
134  * successful, return 0. Otherwise return an error. Note that we do not grab
135  * page references for the page structures.
136  */
137 int frame_vector_to_pages(struct frame_vector *vec)
138 {
139         int i;
140         unsigned long *nums;
141         struct page **pages;
142 
143         if (!vec->is_pfns)
144                 return 0;
145         nums = frame_vector_pfns(vec);
146         for (i = 0; i < vec->nr_frames; i++)
147                 if (!pfn_valid(nums[i]))
148                         return -EINVAL;
149         pages = (struct page **)nums;
150         for (i = 0; i < vec->nr_frames; i++)
151                 pages[i] = pfn_to_page(nums[i]);
152         vec->is_pfns = false;
153         return 0;
154 }
155 EXPORT_SYMBOL(frame_vector_to_pages);
156 
157 /**
158  * frame_vector_to_pfns - convert frame vector to contain pfns
159  * @vec:        frame vector to convert
160  *
161  * Convert @vec to contain array of pfns.
162  */
163 void frame_vector_to_pfns(struct frame_vector *vec)
164 {
165         int i;
166         unsigned long *nums;
167         struct page **pages;
168 
169         if (vec->is_pfns)
170                 return;
171         pages = (struct page **)(vec->ptrs);
172         nums = (unsigned long *)pages;
173         for (i = 0; i < vec->nr_frames; i++)
174                 nums[i] = page_to_pfn(pages[i]);
175         vec->is_pfns = true;
176 }
177 EXPORT_SYMBOL(frame_vector_to_pfns);
178 
179 /**
180  * frame_vector_create() - allocate & initialize structure for pinned pfns
181  * @nr_frames:  number of pfns slots we should reserve
182  *
183  * Allocate and initialize struct pinned_pfns to be able to hold @nr_pfns
184  * pfns.
185  */
186 struct frame_vector *frame_vector_create(unsigned int nr_frames)
187 {
188         struct frame_vector *vec;
189         int size = sizeof(struct frame_vector) + sizeof(void *) * nr_frames;
190 
191         if (WARN_ON_ONCE(nr_frames == 0))
192                 return NULL;
193         /*
194          * This is absurdly high. It's here just to avoid strange effects when
195          * arithmetics overflows.
196          */
197         if (WARN_ON_ONCE(nr_frames > INT_MAX / sizeof(void *) / 2))
198                 return NULL;
199         /*
200          * Avoid higher order allocations, use vmalloc instead. It should
201          * be rare anyway.
202          */
203         if (size <= PAGE_SIZE)
204                 vec = kmalloc(size, GFP_KERNEL);
205         else
206                 vec = vmalloc(size);
207         if (!vec)
208                 return NULL;
209         vec->nr_allocated = nr_frames;
210         vec->nr_frames = 0;
211         return vec;
212 }
213 EXPORT_SYMBOL(frame_vector_create);
214 
215 /**
216  * frame_vector_destroy() - free memory allocated to carry frame vector
217  * @vec:        Frame vector to free
218  *
219  * Free structure allocated by frame_vector_create() to carry frames.
220  */
221 void frame_vector_destroy(struct frame_vector *vec)
222 {
223         /* Make sure put_vaddr_frames() got called properly... */
224         VM_BUG_ON(vec->nr_frames > 0);
225         kvfree(vec);
226 }
227 EXPORT_SYMBOL(frame_vector_destroy);
228 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us