I have a problem with slab.c where it fails to boot the kernel.
The first call to kmem_cache_create():about line 1063: using the
INDEX_AC parameter succeeds and exits via the kcc:left_over route.
The second call to kmem_cache_create():about line 1069: using the
INDEX_L3 parameter fails and exits via the kcc:break_flag route.

On a PC that manages to boot, the exit route in both cases is
"kcc:left_over".

Please see below where I have added printk statements for
"kcc:left_over" and "kcc:break_flag" etc.
See attached .config file for kernel config.
This succeeds in booting on one of my machines, but not the other.
On the other I am netbooting linux.
Main line kernels 2.6.12 etc. all boot correctly on the netbooting linux.

This slab.c code looks rather complicated to me, so I was hoping that
someone else could help me out a bit.


Extract from about line 1651 of mm/slab.c

                /*
                 * Calculate size (in pages) of slabs, and the num of
objs per
                 * slab.  This could be made much more intelligent.  For
now,
                 * try to avoid using high page-orders for slabs.  When the
                 * gfp() funcs are more friendly towards high-order
requests,
                 * this should be changed.
                 */
                do {
                        unsigned int break_flag = 0;
cal_wastage:
                        cache_estimate(cachep->gfporder, size, align, flags,
                                                &left_over, &cachep->num);
                        if (break_flag) {
                                printk("kcc:break_flag\n");
                                break;
                        }
                        if (cachep->gfporder >= MAX_GFP_ORDER) {
                                printk("kcc:GFP_ORDER\n");
                                break;
                        }
                        if (!cachep->num)
                                goto next;
                        if (flags & CFLGS_OFF_SLAB &&
                                        cachep->num > offslab_limit) {
                                /* This num of objs will cause problems. */
                                cachep->gfporder--;
                                break_flag++;
                                goto cal_wastage;
                        }
                        /*
                         * Large num of objs is good, but v. large slabs are
                         * currently bad for the gfp()s.
                         */
                        if (cachep->gfporder >= slab_break_gfp_order) {
                                printk("kcc:slab_break_gfp_order\n");
                                break;
                        }

                        if ((left_over*8) <=
(PAGE_SIZE<<cachep->gfporder)) {
                                printk("kcc:left_over\n");
                                break;  /* Acceptable internal
fragmentation. */
                        }
next:
                        cachep->gfporder++;
                } while (1);
        }

        if (!cachep->num) {
                printk("kmem_cache_create: couldn't create cache %s.\n",
name);
                kmem_cache_free(&cache_cache, cachep);
                cachep = NULL;
                goto opps;
        }