����JFIF��������� Mr.X
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

deexcl@216.73.217.71: ~ $
#!/usr/bin/perl
# SPDX-License-Identifier: GPL-2.0
#
# Generates a linker script that specifies the correct initcall order.
#
# Copyright (C) 2019 Google LLC

use strict;
use warnings;
use IO::Handle;
use IO::Select;
use POSIX ":sys_wait_h";

my $nm = $ENV{'NM'} || die "$0: ERROR: NM not set?";
my $objtree = $ENV{'objtree'} || '.';

## currently active child processes
my $jobs = {};		# child process pid -> file handle
## results from child processes
my $results = {};	# object index -> [ { level, secname }, ... ]

## reads _NPROCESSORS_ONLN to determine the maximum number of processes to
## start
sub get_online_processors {
	open(my $fh, "getconf _NPROCESSORS_ONLN 2>/dev/null |")
		or die "$0: ERROR: failed to execute getconf: $!";
	my $procs = <$fh>;
	close($fh);

	if (!($procs =~ /^\d+$/)) {
		return 1;
	}

	return int($procs);
}

## writes results to the parent process
## format: <file index> <initcall level> <base initcall section name>
sub write_results {
	my ($index, $initcalls) = @_;

	# sort by the counter value to ensure the order of initcalls within
	# each object file is correct
	foreach my $counter (sort { $a <=> $b } keys(%{$initcalls})) {
		my $level = $initcalls->{$counter}->{'level'};

		# section name for the initcall function
		my $secname = $initcalls->{$counter}->{'module'} . '__' .
			      $counter . '_' .
			      $initcalls->{$counter}->{'line'} . '_' .
			      $initcalls->{$counter}->{'function'};

		print "$index $level $secname\n";
	}
}

## reads a result line from a child process and adds it to the $results array
sub read_results{
	my ($fh) = @_;

	# each child prints out a full line w/ autoflush and exits after the
	# last line, so even if buffered I/O blocks here, it shouldn't block
	# very long
	my $data = <$fh>;

	if (!defined($data)) {
		return 0;
	}

	chomp($data);

	my ($index, $level, $secname) = $data =~
		/^(\d+)\ ([^\ ]+)\ (.*)$/;

	if (!defined($index) ||
		!defined($level) ||
		!defined($secname)) {
		die "$0: ERROR: child process returned invalid data: $data\n";
	}

	$index = int($index);

	if (!exists($results->{$index})) {
		$results->{$index} = [];
	}

	push (@{$results->{$index}}, {
		'level'   => $level,
		'secname' => $secname
	});

	return 1;
}

## finds initcalls from an object file or all object files in an archive, and
## writes results back to the parent process
sub find_initcalls {
	my ($index, $file) = @_;

	die "$0: ERROR: file $file doesn't exist?" if (! -f $file);

	open(my $fh, "\"$nm\" --defined-only \"$file\" 2>/dev/null |")
		or die "$0: ERROR: failed to execute \"$nm\": $!";

	my $initcalls = {};

	while (<$fh>) {
		chomp;

		# check for the start of a new object file (if processing an
		# archive)
		my ($path)= $_ =~ /^(.+)\:$/;

		if (defined($path)) {
			write_results($index, $initcalls);
			$initcalls = {};
			next;
		}

		# look for an initcall
		my ($module, $counter, $line, $symbol) = $_ =~
			/[a-z]\s+__initcall__(\S*)__(\d+)_(\d+)_(.*)$/;

		if (!defined($module)) {
			$module = ''
		}

		if (!defined($counter) ||
			!defined($line) ||
			!defined($symbol)) {
			next;
		}

		# parse initcall level
		my ($function, $level) = $symbol =~
			/^(.*)((early|rootfs|con|[0-9])s?)$/;

		die "$0: ERROR: invalid initcall name $symbol in $file($path)"
			if (!defined($function) || !defined($level));

		$initcalls->{$counter} = {
			'module'   => $module,
			'line'     => $line,
			'function' => $function,
			'level'    => $level,
		};
	}

	close($fh);
	write_results($index, $initcalls);
}

## waits for any child process to complete, reads the results, and adds them to
## the $results array for later processing
sub wait_for_results {
	my ($select) = @_;

	my $pid = 0;
	do {
		# unblock children that may have a full write buffer
		foreach my $fh ($select->can_read(0)) {
			read_results($fh);
		}

		# check for children that have exited, read the remaining data
		# from them, and clean up
		$pid = waitpid(-1, WNOHANG);
		if ($pid > 0) {
			if (!exists($jobs->{$pid})) {
				next;
			}

			my $fh = $jobs->{$pid};
			$select->remove($fh);

			while (read_results($fh)) {
				# until eof
			}

			close($fh);
			delete($jobs->{$pid});
		}
	} while ($pid > 0);
}

## forks a child to process each file passed in the command line and collects
## the results
sub process_files {
	my $index = 0;
	my $njobs = $ENV{'PARALLELISM'} || get_online_processors();
	my $select = IO::Select->new();

	while (my $file = shift(@ARGV)) {
		# fork a child process and read it's stdout
		my $pid = open(my $fh, '-|');

		if (!defined($pid)) {
			die "$0: ERROR: failed to fork: $!";
		} elsif ($pid) {
			# save the child process pid and the file handle
			$select->add($fh);
			$jobs->{$pid} = $fh;
		} else {
			# in the child process
			STDOUT->autoflush(1);
			find_initcalls($index, "$objtree/$file");
			exit;
		}

		$index++;

		# limit the number of children to $njobs
		if (scalar(keys(%{$jobs})) >= $njobs) {
			wait_for_results($select);
		}
	}

	# wait for the remaining children to complete
	while (scalar(keys(%{$jobs})) > 0) {
		wait_for_results($select);
	}
}

sub generate_initcall_lds() {
	process_files();

	my $sections = {};	# level -> [ secname, ...]

	# sort results to retain link order and split to sections per
	# initcall level
	foreach my $index (sort { $a <=> $b } keys(%{$results})) {
		foreach my $result (@{$results->{$index}}) {
			my $level = $result->{'level'};

			if (!exists($sections->{$level})) {
				$sections->{$level} = [];
			}

			push(@{$sections->{$level}}, $result->{'secname'});
		}
	}

	die "$0: ERROR: no initcalls?" if (!keys(%{$sections}));

	# print out a linker script that defines the order of initcalls for
	# each level
	print "SECTIONS {\n";

	foreach my $level (sort(keys(%{$sections}))) {
		my $section;

		if ($level eq 'con') {
			$section = '.con_initcall.init';
		} else {
			$section = ".initcall${level}.init";
		}

		print "\t${section} : {\n";

		foreach my $secname (@{$sections->{$level}}) {
			print "\t\t*(${section}..${secname}) ;\n";
		}

		print "\t}\n";
	}

	print "}\n";
}

generate_initcall_lds();

Filemanager

Name Type Size Permission Actions
atomic Folder 0755
basic Folder 0755
clang-tools Folder 0755
coccinelle Folder 0755
dtc Folder 0755
dummy-tools Folder 0755
gcc-plugins Folder 0755
gdb Folder 0755
genksyms Folder 0755
include Folder 0755
kconfig Folder 0755
ksymoops Folder 0755
mod Folder 0755
package Folder 0755
selinux Folder 0755
Kbuild.include File 10.24 KB 0644
Kconfig.include File 2.56 KB 0644
Lindent File 506 B 0755
Makefile File 1.74 KB 0644
Makefile.asm-generic File 1.82 KB 0644
Makefile.btf File 1.07 KB 0644
Makefile.build File 17.1 KB 0644
Makefile.clean File 2.02 KB 0644
Makefile.compiler File 2.79 KB 0644
Makefile.dtbinst File 998 B 0644
Makefile.extrawarn File 3.25 KB 0644
Makefile.gcc-plugins File 2.57 KB 0644
Makefile.headersinst File 2.88 KB 0644
Makefile.host File 4.63 KB 0644
Makefile.kasan File 2.45 KB 0644
Makefile.kcov File 333 B 0644
Makefile.kcsan File 1004 B 0644
Makefile.kmsan File 208 B 0644
Makefile.lib File 21.16 KB 0644
Makefile.modfinal File 2.74 KB 0644
Makefile.modinst File 2.39 KB 0644
Makefile.modpost File 4.16 KB 0644
Makefile.package File 6.61 KB 0644
Makefile.randstruct File 410 B 0644
Makefile.ubsan File 837 B 0644
Makefile.userprogs File 1.57 KB 0644
Makefile.vmlinux File 890 B 0644
Makefile.vmlinux_o File 2.54 KB 0644
adjust_autoksyms.sh File 2.11 KB 0755
as-version.sh File 2.05 KB 0755
asn1_compiler File 30.13 KB 0755
asn1_compiler.c File 35.32 KB 0644
bin2c.c File 743 B 0644
bloat-o-meter File 3.36 KB 0755
bootgraph.pl File 5.64 KB 0755
bpf_doc.py File 31.73 KB 0755
cc-can-link.sh File 170 B 0755
cc-version.sh File 1.35 KB 0755
check-sysctl-docs File 4.37 KB 0755
check_extable.sh File 4.93 KB 0755
checkdeclares.pl File 1.1 KB 0644
checkincludes.pl File 1.94 KB 0755
checkkconfigsymbols.py File 15.88 KB 0755
checkpatch.pl File 224.16 KB 0755
checkstack.pl File 5.9 KB 0755
checksyscalls.sh File 7.34 KB 0755
checkversion.pl File 2.15 KB 0755
cleanfile File 3.46 KB 0755
cleanpatch File 5.06 KB 0755
coccicheck File 7.89 KB 0755
config File 4.67 KB 0755
const_structs.checkpatch File 1009 B 0644
decode_stacktrace.sh File 6.56 KB 0755
decodecode File 2.89 KB 0755
depmod.sh File 1.41 KB 0755
dev-needs.sh File 6.08 KB 0755
diffconfig File 4.12 KB 0755
documentation-file-ref-check File 5.6 KB 0755
export_report.pl File 4.49 KB 0755
extract-cert File 14.12 KB 0755
extract-cert.c File 3.63 KB 0644
extract-ikconfig File 1.7 KB 0755
extract-module-sig.pl File 3.65 KB 0755
extract-sys-certs.pl File 3.74 KB 0755
extract-vmlinux File 1.66 KB 0755
extract_xc3028.pl File 44.61 KB 0755
faddr2line File 6.16 KB 0755
file-size.sh File 90 B 0755
find-unused-docs.sh File 1.28 KB 0755
gcc-ld File 715 B 0755
gcc-x86_32-has-stack-protector.sh File 412 B 0755
gcc-x86_64-has-stack-protector.sh File 202 B 0755
gen_autoksyms.sh File 1.4 KB 0755
gen_ksymdeps.sh File 403 B 0755
gen_packed_field_checks.c File 1.19 KB 0644
generate_initcall_order.pl File 5.94 KB 0755
generate_rust_target.rs File 5.26 KB 0644
get_abi.pl File 15.09 KB 0755
get_dvb_firmware File 24.54 KB 0755
get_feat.pl File 14.34 KB 0755
get_maintainer.pl File 67.13 KB 0755
gfp-translate File 1.71 KB 0755
headerdep.pl File 3.5 KB 0755
headers_check.pl File 3.73 KB 0755
headers_install.sh File 3.17 KB 0755
insert-sys-cert.c File 8.87 KB 0644
install.sh File 990 B 0755
jobserver-exec File 2.16 KB 0755
kallsyms File 18.23 KB 0755
kallsyms.c File 20.38 KB 0644
kernel-doc File 66.32 KB 0755
ld-version.sh File 1.67 KB 0755
leaking_addresses.pl File 12.8 KB 0755
link-vmlinux.sh File 8.88 KB 0755
makelst File 812 B 0755
markup_oops.pl File 7.92 KB 0755
min-tool-version.sh File 473 B 0755
mkcompile_h File 2.59 KB 0755
mksysmap File 1.33 KB 0755
mkuboot.sh File 418 B 0755
module.lds File 432 B 0644
module.lds.S File 1.49 KB 0644
modules-check.sh File 431 B 0755
nsdeps File 1.63 KB 0644
objdiff File 2.83 KB 0755
objdump-func File 715 B 0755
pahole-version.sh File 273 B 0755
parse-maintainers.pl File 4.54 KB 0755
patch-kernel File 9.95 KB 0755
profile2linkerlist.pl File 410 B 0755
prune-kernel File 712 B 0755
recordmcount.c File 16.69 KB 0644
recordmcount.h File 19.37 KB 0644
recordmcount.pl File 17.61 KB 0755
remove-stale-files File 1.35 KB 0755
setlocalversion File 3.59 KB 0755
show_delta File 3.01 KB 0755
sign-file File 22.16 KB 0755
sign-file.c File 9.93 KB 0644
sorttable File 22.12 KB 0755
sorttable.c File 7.62 KB 0644
sorttable.h File 12.85 KB 0644
spdxcheck-test.sh File 323 B 0644
spelling.txt File 31.92 KB 0644
sphinx-pre-install File 24.29 KB 0755
split-man.pl File 600 B 0755
stackdelta File 1.84 KB 0755
stackusage File 798 B 0755
subarch.include File 641 B 0644
syscallhdr.sh File 1.89 KB 0755
syscallnr.sh File 1.45 KB 0644
syscalltbl.sh File 1.46 KB 0755
tags.sh File 9.66 KB 0755
test_fortify.sh File 2.23 KB 0644
tools-support-relr.sh File 550 B 0755
unifdef File 34.12 KB 0755
unifdef.c File 34.8 KB 0644
ver_linux File 2.59 KB 0755
xen-hypercalls.sh File 386 B 0644
xz_wrap.sh File 567 B 0755