tree: https://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git master head: bb4f21f1ae06af0da93077b493a550d472bf18ac commit: e4da156335d4cc6a6da53aa74409fbfe12c9d684 [12/38] Merge remote-tracking branch 'drm/drm-next' into renesas-drivers config: i386-defconfig (attached as .config) compiler: gcc-7 (Debian 7.3.0-1) 7.3.0 reproduce: git checkout e4da156335d4cc6a6da53aa74409fbfe12c9d684 # save the attached .config to linux build tree make ARCH=i386
All errors (new ones prefixed by >>):
drivers/gpu//drm/i915/i915_gem.c: In function
'i915_gem_object_get_pages_gtt':
>> drivers/gpu//drm/i915/i915_gem.c:2562:19: error: called object
>> 'totalram_pages' is not a function or function pointer
if (page_count > totalram_pages())
^~~~~~~~~~~~~~
In file included from include/linux/shmem_fs.h:6:0,
from drivers/gpu//drm/i915/i915_drv.h:47,
from drivers/gpu//drm/i915/i915_gem.c:31:
include/linux/swap.h:313:22: note: declared here
extern unsigned long totalram_pages;
^~~~~~~~~~~~~~
vim +/totalram_pages +2562 drivers/gpu//drm/i915/i915_gem.c
2532
2533 static int i915_gem_object_get_pages_gtt(struct drm_i915_gem_object
*obj)
2534 {
2535 struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
2536 const unsigned long page_count = obj->base.size / PAGE_SIZE;
2537 unsigned long i;
2538 struct address_space *mapping;
2539 struct sg_table *st;
2540 struct scatterlist *sg;
2541 struct sgt_iter sgt_iter;
2542 struct page *page;
2543 unsigned long last_pfn = 0; /* suppress gcc warning */
2544 unsigned int max_segment = i915_sg_segment_size();
2545 unsigned int sg_page_sizes;
2546 struct pagevec pvec;
2547 gfp_t noreclaim;
2548 int ret;
2549
2550 /*
2551 * Assert that the object is not currently in any GPU domain.
As it
2552 * wasn't in the GTT, there shouldn't be any way it could have
been in
2553 * a GPU cache
2554 */
2555 GEM_BUG_ON(obj->read_domains & I915_GEM_GPU_DOMAINS);
2556 GEM_BUG_ON(obj->write_domain & I915_GEM_GPU_DOMAINS);
2557
2558 /*
2559 * If there's no chance of allocating enough pages for the whole
2560 * object, bail early.
2561 */
> 2562 if (page_count > totalram_pages())
2563 return -ENOMEM;
2564
2565 st = kmalloc(sizeof(*st), GFP_KERNEL);
2566 if (st == NULL)
2567 return -ENOMEM;
2568
2569 rebuild_st:
2570 if (sg_alloc_table(st, page_count, GFP_KERNEL)) {
2571 kfree(st);
2572 return -ENOMEM;
2573 }
2574
2575 /*
2576 * Get the list of pages out of our struct file. They'll be
pinned
2577 * at this point until we release them.
2578 *
2579 * Fail silently without starting the shrinker
2580 */
2581 mapping = obj->base.filp->f_mapping;
2582 mapping_set_unevictable(mapping);
2583 noreclaim = mapping_gfp_constraint(mapping, ~__GFP_RECLAIM);
2584 noreclaim |= __GFP_NORETRY | __GFP_NOWARN;
2585
2586 sg = st->sgl;
2587 st->nents = 0;
2588 sg_page_sizes = 0;
2589 for (i = 0; i < page_count; i++) {
2590 const unsigned int shrink[] = {
2591 I915_SHRINK_BOUND | I915_SHRINK_UNBOUND |
I915_SHRINK_PURGEABLE,
2592 0,
2593 }, *s = shrink;
2594 gfp_t gfp = noreclaim;
2595
2596 do {
2597 cond_resched();
2598 page = shmem_read_mapping_page_gfp(mapping, i,
gfp);
2599 if (likely(!IS_ERR(page)))
2600 break;
2601
2602 if (!*s) {
2603 ret = PTR_ERR(page);
2604 goto err_sg;
2605 }
2606
2607 i915_gem_shrink(dev_priv, 2 * page_count, NULL,
*s++);
2608
2609 /*
2610 * We've tried hard to allocate the memory by
reaping
2611 * our own buffer, now let the real VM do its
job and
2612 * go down in flames if truly OOM.
2613 *
2614 * However, since graphics tend to be
disposable,
2615 * defer the oom here by reporting the ENOMEM
back
2616 * to userspace.
2617 */
2618 if (!*s) {
2619 /* reclaim and warn, but no oom */
2620 gfp = mapping_gfp_mask(mapping);
2621
2622 /*
2623 * Our bo are always dirty and so we
require
2624 * kswapd to reclaim our pages (direct
reclaim
2625 * does not effectively begin pageout
of our
2626 * buffers on its own). However, direct
reclaim
2627 * only waits for kswapd when under
allocation
2628 * congestion. So as a result
__GFP_RECLAIM is
2629 * unreliable and fails to actually
reclaim our
2630 * dirty pages -- unless you try over
and over
2631 * again with !__GFP_NORETRY. However,
we still
2632 * want to fail this allocation rather
than
2633 * trigger the out-of-memory killer and
for
2634 * this we want __GFP_RETRY_MAYFAIL.
2635 */
2636 gfp |= __GFP_RETRY_MAYFAIL;
2637 }
2638 } while (1);
2639
2640 if (!i ||
2641 sg->length >= max_segment ||
2642 page_to_pfn(page) != last_pfn + 1) {
2643 if (i) {
2644 sg_page_sizes |= sg->length;
2645 sg = sg_next(sg);
2646 }
2647 st->nents++;
2648 sg_set_page(sg, page, PAGE_SIZE, 0);
2649 } else {
2650 sg->length += PAGE_SIZE;
2651 }
2652 last_pfn = page_to_pfn(page);
2653
2654 /* Check that the i965g/gm workaround works. */
2655 WARN_ON((gfp & __GFP_DMA32) && (last_pfn >=
0x00100000UL));
2656 }
2657 if (sg) { /* loop terminated early; short sg table */
2658 sg_page_sizes |= sg->length;
2659 sg_mark_end(sg);
2660 }
2661
2662 /* Trim unused sg entries to avoid wasting memory. */
2663 i915_sg_trim(st);
2664
2665 ret = i915_gem_gtt_prepare_pages(obj, st);
2666 if (ret) {
2667 /*
2668 * DMA remapping failed? One possible cause is that
2669 * it could not reserve enough large entries, asking
2670 * for PAGE_SIZE chunks instead may be helpful.
2671 */
2672 if (max_segment > PAGE_SIZE) {
2673 for_each_sgt_page(page, sgt_iter, st)
2674 put_page(page);
2675 sg_free_table(st);
2676
2677 max_segment = PAGE_SIZE;
2678 goto rebuild_st;
2679 } else {
2680 dev_warn(&dev_priv->drm.pdev->dev,
2681 "Failed to DMA remap %lu pages\n",
2682 page_count);
2683 goto err_pages;
2684 }
2685 }
2686
2687 if (i915_gem_object_needs_bit17_swizzle(obj))
2688 i915_gem_object_do_bit_17_swizzle(obj, st);
2689
2690 __i915_gem_object_set_pages(obj, st, sg_page_sizes);
2691
2692 return 0;
2693
2694 err_sg:
2695 sg_mark_end(sg);
2696 err_pages:
2697 mapping_clear_unevictable(mapping);
2698 pagevec_init(&pvec);
2699 for_each_sgt_page(page, sgt_iter, st) {
2700 if (!pagevec_add(&pvec, page))
2701 check_release_pagevec(&pvec);
2702 }
2703 if (pagevec_count(&pvec))
2704 check_release_pagevec(&pvec);
2705 sg_free_table(st);
2706 kfree(st);
2707
2708 /*
2709 * shmemfs first checks if there is enough memory to allocate
the page
2710 * and reports ENOSPC should there be insufficient, along with
the usual
2711 * ENOMEM for a genuine allocation failure.
2712 *
2713 * We use ENOSPC in our driver to mean that we have run out of
aperture
2714 * space and so want to translate the error from shmemfs back
to our
2715 * usual understanding of ENOMEM.
2716 */
2717 if (ret == -ENOSPC)
2718 ret = -ENOMEM;
2719
2720 return ret;
2721 }
2722
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
.config.gz
Description: application/gzip
