fs/binfmt_flat.c:828:9: error: void value not ignored as it ought to be

[kbuild test robot]

Hi Al,

FYI, the error/warning still remains.

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head:   0a07b238e5f488b459b6113a62e06b6aab017f71
commit: 468138d78510688fb5476f98d23f11ac6a63229a binfmt_flat: flat_{get,put}_addr_from_rp() should be able to fail
date:   4 weeks ago
config: m32r-oaks32r_defconfig (attached as .config)
compiler: m32r-linux-gcc (GCC) 6.2.0
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        git checkout 468138d78510688fb5476f98d23f11ac6a63229a
        # save the attached .config to linux build tree
        make.cross ARCH=m32r 

All errors (new ones prefixed by >>):

   In file included from include/linux/kernel.h:13:0,
                    from fs/binfmt_flat.c:20:
   fs/binfmt_flat.c: In function 'load_flat_file':
   include/linux/kern_levels.h:4:18: warning: format '%ld' expects argument of type 'long int', but argument 2 has type 'u32 {aka unsigned int}' [-Wformat=]
    #define KERN_SOH "\001"  /* ASCII Start Of Header */
                     ^
   include/linux/printk.h:136:11: note: in definition of macro 'no_printk'
       printk(fmt, ##__VA_ARGS__); \
              ^~~
   include/linux/kern_levels.h:14:20: note: in expansion of macro 'KERN_SOH'
    #define KERN_DEBUG KERN_SOH "7" /* debug-level messages */
                       ^~~~~~~~
   include/linux/printk.h:339:12: note: in expansion of macro 'KERN_DEBUG'
     no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
               ^~~~~~~~~~
   fs/binfmt_flat.c:577:3: note: in expansion of macro 'pr_debug'
      pr_debug("Allocated data+bss+stack (%ld bytes): %lx\n",
      ^~~~~~~~
>> fs/binfmt_flat.c:828:9: error: void value not ignored as it ought to be
        ret = flat_put_addr_at_rp(rp, addr, relval);
            ^

vim +828 fs/binfmt_flat.c

   506	
   507		/*
   508		 * Check initial limits. This avoids letting people circumvent
   509		 * size limits imposed on them by creating programs with large
   510		 * arrays in the data or bss.
   511		 */
   512		rlim = rlimit(RLIMIT_DATA);
   513		if (rlim >= RLIM_INFINITY)
   514			rlim = ~0;
   515		if (data_len + bss_len > rlim) {
   516			ret = -ENOMEM;
   517			goto err;
   518		}
   519	
   520		/* Flush all traces of the currently running executable */
   521		if (id == 0) {
   522			ret = flush_old_exec(bprm);
   523			if (ret)
   524				goto err;
   525	
   526			/* OK, This is the point of no return */
   527			set_personality(PER_LINUX_32BIT);
   528			setup_new_exec(bprm);
   529		}
   530	
   531		/*
   532		 * calculate the extra space we need to map in
   533		 */
   534		extra = max_t(unsigned long, bss_len + stack_len,
   535				relocs * sizeof(unsigned long));
   536	
   537		/*
   538		 * there are a couple of cases here,  the separate code/data
   539		 * case,  and then the fully copied to RAM case which lumps
   540		 * it all together.
   541		 */
   542		if (!IS_ENABLED(CONFIG_MMU) && !(flags & (FLAT_FLAG_RAM|FLAT_FLAG_GZIP))) {
   543			/*
   544			 * this should give us a ROM ptr,  but if it doesn't we don't
   545			 * really care
   546			 */
   547			pr_debug("ROM mapping of file (we hope)\n");
   548	
   549			textpos = vm_mmap(bprm->file, 0, text_len, PROT_READ|PROT_EXEC,
   550					  MAP_PRIVATE|MAP_EXECUTABLE, 0);
   551			if (!textpos || IS_ERR_VALUE(textpos)) {
   552				ret = textpos;
   553				if (!textpos)
   554					ret = -ENOMEM;
   555				pr_err("Unable to mmap process text, errno %d\n", ret);
   556				goto err;
   557			}
   558	
   559			len = data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long);
   560			len = PAGE_ALIGN(len);
   561			realdatastart = vm_mmap(NULL, 0, len,
   562				PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE, 0);
   563	
   564			if (realdatastart == 0 || IS_ERR_VALUE(realdatastart)) {
   565				ret = realdatastart;
   566				if (!realdatastart)
   567					ret = -ENOMEM;
   568				pr_err("Unable to allocate RAM for process data, "
   569				       "errno %d\n", ret);
   570				vm_munmap(textpos, text_len);
   571				goto err;
   572			}
   573			datapos = ALIGN(realdatastart +
   574					MAX_SHARED_LIBS * sizeof(unsigned long),
   575					FLAT_DATA_ALIGN);
   576	
   577			pr_debug("Allocated data+bss+stack (%ld bytes): %lx\n",
   578				 data_len + bss_len + stack_len, datapos);
   579	
   580			fpos = ntohl(hdr->data_start);
   581	#ifdef CONFIG_BINFMT_ZFLAT
   582			if (flags & FLAT_FLAG_GZDATA) {
   583				result = decompress_exec(bprm, fpos, (char *)datapos,
   584							 full_data, 0);
   585			} else
   586	#endif
   587			{
   588				result = read_code(bprm->file, datapos, fpos,
   589						full_data);
   590			}
   591			if (IS_ERR_VALUE(result)) {
   592				ret = result;
   593				pr_err("Unable to read data+bss, errno %d\n", ret);
   594				vm_munmap(textpos, text_len);
   595				vm_munmap(realdatastart, len);
   596				goto err;
   597			}
   598	
   599			reloc = (u32 __user *)
   600				(datapos + (ntohl(hdr->reloc_start) - text_len));
   601			memp = realdatastart;
   602			memp_size = len;
   603		} else {
   604	
   605			len = text_len + data_len + extra + MAX_SHARED_LIBS * sizeof(u32);
   606			len = PAGE_ALIGN(len);
   607			textpos = vm_mmap(NULL, 0, len,
   608				PROT_READ | PROT_EXEC | PROT_WRITE, MAP_PRIVATE, 0);
   609	
   610			if (!textpos || IS_ERR_VALUE(textpos)) {
   611				ret = textpos;
   612				if (!textpos)
   613					ret = -ENOMEM;
   614				pr_err("Unable to allocate RAM for process text/data, "
   615				       "errno %d\n", ret);
   616				goto err;
   617			}
   618	
   619			realdatastart = textpos + ntohl(hdr->data_start);
   620			datapos = ALIGN(realdatastart +
   621					MAX_SHARED_LIBS * sizeof(u32),
   622					FLAT_DATA_ALIGN);
   623	
   624			reloc = (u32 __user *)
   625				(datapos + (ntohl(hdr->reloc_start) - text_len));
   626			memp = textpos;
   627			memp_size = len;
   628	#ifdef CONFIG_BINFMT_ZFLAT
   629			/*
   630			 * load it all in and treat it like a RAM load from now on
   631			 */
   632			if (flags & FLAT_FLAG_GZIP) {
   633	#ifndef CONFIG_MMU
   634				result = decompress_exec(bprm, sizeof(struct flat_hdr),
   635						 (((char *)textpos) + sizeof(struct flat_hdr)),
   636						 (text_len + full_data
   637							  - sizeof(struct flat_hdr)),
   638						 0);
   639				memmove((void *) datapos, (void *) realdatastart,
   640						full_data);
   641	#else
   642				/*
   643				 * This is used on MMU systems mainly for testing.
   644				 * Let's use a kernel buffer to simplify things.
   645				 */
   646				long unz_text_len = text_len - sizeof(struct flat_hdr);
   647				long unz_len = unz_text_len + full_data;
   648				char *unz_data = vmalloc(unz_len);
   649				if (!unz_data) {
   650					result = -ENOMEM;
   651				} else {
   652					result = decompress_exec(bprm, sizeof(struct flat_hdr),
   653								 unz_data, unz_len, 0);
   654					if (result == 0 &&
   655					    (copy_to_user((void __user *)textpos + sizeof(struct flat_hdr),
   656							  unz_data, unz_text_len) ||
   657					     copy_to_user((void __user *)datapos,
   658							  unz_data + unz_text_len, full_data)))
   659						result = -EFAULT;
   660					vfree(unz_data);
   661				}
   662	#endif
   663			} else if (flags & FLAT_FLAG_GZDATA) {
   664				result = read_code(bprm->file, textpos, 0, text_len);
   665				if (!IS_ERR_VALUE(result)) {
   666	#ifndef CONFIG_MMU
   667					result = decompress_exec(bprm, text_len, (char *) datapos,
   668							 full_data, 0);
   669	#else
   670					char *unz_data = vmalloc(full_data);
   671					if (!unz_data) {
   672						result = -ENOMEM;
   673					} else {
   674						result = decompress_exec(bprm, text_len,
   675							       unz_data, full_data, 0);
   676						if (result == 0 &&
   677						    copy_to_user((void __user *)datapos,
   678								 unz_data, full_data))
   679							result = -EFAULT;
   680						vfree(unz_data);
   681					}
   682	#endif
   683				}
   684			} else
   685	#endif /* CONFIG_BINFMT_ZFLAT */
   686			{
   687				result = read_code(bprm->file, textpos, 0, text_len);
   688				if (!IS_ERR_VALUE(result))
   689					result = read_code(bprm->file, datapos,
   690							   ntohl(hdr->data_start),
   691							   full_data);
   692			}
   693			if (IS_ERR_VALUE(result)) {
   694				ret = result;
   695				pr_err("Unable to read code+data+bss, errno %d\n", ret);
   696				vm_munmap(textpos, text_len + data_len + extra +
   697					MAX_SHARED_LIBS * sizeof(u32));
   698				goto err;
   699			}
   700		}
   701	
   702		start_code = textpos + sizeof(struct flat_hdr);
   703		end_code = textpos + text_len;
   704		text_len -= sizeof(struct flat_hdr); /* the real code len */
   705	
   706		/* The main program needs a little extra setup in the task structure */
   707		if (id == 0) {
   708			current->mm->start_code = start_code;
   709			current->mm->end_code = end_code;
   710			current->mm->start_data = datapos;
   711			current->mm->end_data = datapos + data_len;
   712			/*
   713			 * set up the brk stuff, uses any slack left in data/bss/stack
   714			 * allocation.  We put the brk after the bss (between the bss
   715			 * and stack) like other platforms.
   716			 * Userspace code relies on the stack pointer starting out at
   717			 * an address right at the end of a page.
   718			 */
   719			current->mm->start_brk = datapos + data_len + bss_len;
   720			current->mm->brk = (current->mm->start_brk + 3) & ~3;
   721	#ifndef CONFIG_MMU
   722			current->mm->context.end_brk = memp + memp_size - stack_len;
   723	#endif
   724		}
   725	
   726		if (flags & FLAT_FLAG_KTRACE) {
   727			pr_info("Mapping is %lx, Entry point is %x, data_start is %x\n",
   728				textpos, 0x00ffffff&ntohl(hdr->entry), ntohl(hdr->data_start));
   729			pr_info("%s %s: TEXT=%lx-%lx DATA=%lx-%lx BSS=%lx-%lx\n",
   730				id ? "Lib" : "Load", bprm->filename,
   731				start_code, end_code, datapos, datapos + data_len,
   732				datapos + data_len, (datapos + data_len + bss_len + 3) & ~3);
   733		}
   734	
   735		/* Store the current module values into the global library structure */
   736		libinfo->lib_list[id].start_code = start_code;
   737		libinfo->lib_list[id].start_data = datapos;
   738		libinfo->lib_list[id].start_brk = datapos + data_len + bss_len;
   739		libinfo->lib_list[id].text_len = text_len;
   740		libinfo->lib_list[id].loaded = 1;
   741		libinfo->lib_list[id].entry = (0x00ffffff & ntohl(hdr->entry)) + textpos;
   742		libinfo->lib_list[id].build_date = ntohl(hdr->build_date);
   743	
   744		/*
   745		 * We just load the allocations into some temporary memory to
   746		 * help simplify all this mumbo jumbo
   747		 *
   748		 * We've got two different sections of relocation entries.
   749		 * The first is the GOT which resides at the beginning of the data segment
   750		 * and is terminated with a -1.  This one can be relocated in place.
   751		 * The second is the extra relocation entries tacked after the image's
   752		 * data segment. These require a little more processing as the entry is
   753		 * really an offset into the image which contains an offset into the
   754		 * image.
   755		 */
   756		if (flags & FLAT_FLAG_GOTPIC) {
   757			for (rp = (u32 __user *)datapos; ; rp++) {
   758				u32 addr, rp_val;
   759				if (get_user(rp_val, rp))
   760					return -EFAULT;
   761				if (rp_val == 0xffffffff)
   762					break;
   763				if (rp_val) {
   764					addr = calc_reloc(rp_val, libinfo, id, 0);
   765					if (addr == RELOC_FAILED) {
   766						ret = -ENOEXEC;
   767						goto err;
   768					}
   769					if (put_user(addr, rp))
   770						return -EFAULT;
   771				}
   772			}
   773		}
   774	
   775		/*
   776		 * Now run through the relocation entries.
   777		 * We've got to be careful here as C++ produces relocatable zero
   778		 * entries in the constructor and destructor tables which are then
   779		 * tested for being not zero (which will always occur unless we're
   780		 * based from address zero).  This causes an endless loop as __start
   781		 * is at zero.  The solution used is to not relocate zero addresses.
   782		 * This has the negative side effect of not allowing a global data
   783		 * reference to be statically initialised to _stext (I've moved
   784		 * __start to address 4 so that is okay).
   785		 */
   786		if (rev > OLD_FLAT_VERSION) {
   787			u32 __maybe_unused persistent = 0;
   788			for (i = 0; i < relocs; i++) {
   789				u32 addr, relval;
   790	
   791				/*
   792				 * Get the address of the pointer to be
   793				 * relocated (of course, the address has to be
   794				 * relocated first).
   795				 */
   796				if (get_user(relval, reloc + i))
   797					return -EFAULT;
   798				relval = ntohl(relval);
   799				if (flat_set_persistent(relval, &persistent))
   800					continue;
   801				addr = flat_get_relocate_addr(relval);
   802				rp = (u32 __user *)calc_reloc(addr, libinfo, id, 1);
   803				if (rp == (u32 __user *)RELOC_FAILED) {
   804					ret = -ENOEXEC;
   805					goto err;
   806				}
   807	
   808				/* Get the pointer's value.  */
   809				ret = flat_get_addr_from_rp(rp, relval, flags,
   810								&addr, &persistent);
   811				if (unlikely(ret))
   812					goto err;
   813	
   814				if (addr != 0) {
   815					/*
   816					 * Do the relocation.  PIC relocs in the data section are
   817					 * already in target order
   818					 */
   819					if ((flags & FLAT_FLAG_GOTPIC) == 0)
   820						addr = ntohl(addr);
   821					addr = calc_reloc(addr, libinfo, id, 0);
   822					if (addr == RELOC_FAILED) {
   823						ret = -ENOEXEC;
   824						goto err;
   825					}
   826	
   827					/* Write back the relocated pointer.  */
 > 828					ret = flat_put_addr_at_rp(rp, addr, relval);
   829					if (unlikely(ret))
   830						goto err;
   831				}
   832			}
   833		} else {
   834			for (i = 0; i < relocs; i++) {
   835				u32 relval;
   836				if (get_user(relval, reloc + i))
   837					return -EFAULT;
   838				relval = ntohl(relval);
   839				old_reloc(relval);
   840			}
   841		}
   842	
   843		flush_icache_range(start_code, end_code);
   844	
   845		/* zero the BSS,  BRK and stack areas */
   846		if (clear_user((void __user *)(datapos + data_len), bss_len +
   847			       (memp + memp_size - stack_len -		/* end brk */
   848			       libinfo->lib_list[id].start_brk) +	/* start brk */
   849			       stack_len))
   850			return -EFAULT;
   851	
   852		return 0;
   853	err:
   854		return ret;
   855	}
   856	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

Attachment: .config.gz
Description: application/gzip