# Using ftrace to Selectively Trace Parent Functions ## Background Taking the code in the memory cgroup subsystem as an example, the `__memory_events_show` function has two call sites, namely `memory_events_show` and `memory_events_local_show`. The code is as follows:
# Overview 
## Compile BusyBox to Generate _install ### Install Build Dependencies bison/flex ```shell sudo apt-get install bison -y sudo apt-get install flex -y ```
# Environment Setup - Install the compilation and debugging components - Since I only had an x86 environment with WSL on hand, I needed to use emulation to compile, run, and debug ARM programs - Referencing this [gist article](https://gist.github.com/luk6xff/9f8d2520530a823944355e59343eadc1), it is possible to run armv8 programs on an x86 environment. The steps are as follows: - Install on WSL: - Cross-compilation environment: `sudo apt-get install libc6-dev-arm64-cross gcc-aarch64-linux-gnu` - QEMU emulation environment: `sudo apt-get install qemu qemu-system qemu-user`
# Address Access Example Taking the access to the user-space **virtual address** 0x0000007000003000 as an example, consider the following code. ```C #include <sys/mman.h> #include <stdio.h> int main() { unsigned long long *x = (unsigned long long)0x0000007000003000; int *p = (int*)mmap(0x0000007000003000, sizeof(unsigned long long) * 10, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); printf("before write, x = %llu\n", *x); *x = 1; printf("after write, x = %llu\n", *x); } ``` If the user-space virtual address `0x0000007000003000` is not mapped in advance via mmap with read and write permissions, a `Segmentation fault (core dumped)` will occur, because `0x0000007000003000` is not managed as a vma (virtual memory area) allocated through mmap or brk in the process's virtual address space, and thus the virtual address is not accessible at this point. The output after compilation is as follows. ``` before write, x = 0 after write, x = 1 ``` As can be seen, a new value was successfully written to the user-space virtual address `0x0000007000003000`.
KKBOX is a leading music streaming service in Asia, boasting the world's most comprehensive collection of Asian pop music. This paper conducts a data mining analysis on the music dataset that KKBOX has provided to the Kaggle community. Through initial cleaning and analysis of the dataset, we propose four data mining–related questions: correlation analysis among features in the dataset, song clustering, user clustering, and predicting whether a user will listen to a particular song repeatedly within a month. We then select appropriate algorithms—such as the K-prototypes clustering algorithm, the t-SNE high-dimensional data visualization algorithm, and the LightGBM algorithm—to address these data mining problems, and finally present corresponding conclusions. In doing so, we explore the application of data mining algorithms to a real-world dataset, transforming knowledge from the data mining classroom into truly practical technology.
A smart contract is a code contract and algorithmic contract that will become a foundational technology of the future digital society. It utilizes protocols and user interfaces to complete all steps of the contractual process. This article summarizes the main technical characteristics of smart contracts as well as existing trustworthiness and security issues, and proposes applying formal methods to the modeling, model checking, and formal verification of smart contracts to support the generation of large-scale smart contracts.
The research history of face recognition is quite long-standing. As early as 1888 and 1910, Galton published two articles in *Nature* on using faces for personal identification, analyzing the human ability of face recognition. However, at that time, the problem of automatic face recognition was beyond reach. In recent years, face recognition research has attracted the attention of many researchers, and a variety of technical methods have emerged. In particular, since 1990, face recognition has made significant progress. Almost all well-known universities of science and engineering and major IT companies have research groups working on related studies. In the early stages, traditional face recognition was usually studied as a general pattern recognition problem. The main technical approaches adopted were geometric feature-based methods. This was largely reflected in the study of profile silhouettes, where a great deal of research was devoted to the extraction and analysis of structural features from facial silhouette curves. Subsequently, appearance-based modeling methods such as Eigenface, Fisherface, and elastic graph matching were continuously proposed. Starting from the late 1990s, researchers began to focus on face recognition under real-world conditions, proposing different face space models, including linear modeling methods represented by Linear Discriminant Analysis, nonlinear modeling methods represented by kernel-based methods, and 3D face recognition methods based on 3D information. New feature representations were proposed, including local descriptors (Gabor Face, LBP Face, etc.) and deep learning methods. Since 2014, deep learning + big data (massive labeled face data) has become the mainstream technical approach in the field of face recognition. Deep neural networks such as VGGFace, DeepFace, and FaceNet have been continuously proposed, and face recognition accuracy has been steadily improving. In 2014, Facebook's work DeepFace, published at CVPR 2014, combined big data (4 million face images) with deep convolutional networks, approaching human-level recognition accuracy on the LFW dataset. Google's work FaceNet, published at CVPR 2015, surpassed human-level recognition accuracy on the LFW dataset by adopting the Triplet Loss function.
The goal of this project is to perform risk analysis for the P2P Internet finance industry, establish standardized risk assessment dimensions and risk assessment models, identify high-risk P2P Internet finance enterprises, and ultimately generate automated risk analysis reports for P2P Internet finance enterprises. This project selected over 800 representative enterprises in the P2P Internet finance industry. Based on massive historical data from multiple aspects and dimensions of these enterprises, appropriate risk assessment dimensions were chosen and risk assessment models were built to analyze the risks currently faced by these P2P Internet finance enterprises. The overall risk profile and risk profiles across different domains of each enterprise were evaluated, and risk reports for P2P Internet finance enterprises were generated, providing an intuitive and accurate display of risk data, risk indicators, and risk ratings across all aspects of the enterprises. This meets the regulatory needs of Internet finance supervision and facilitates risk monitoring of Internet finance enterprises.
The simulation is divided into 3 parts: - **P2P Network Simulation** - Use Mininet to build networks with different topologies (such as star, ring, tree, and mesh), and limit the bandwidth of different links. - Each node can generate certain types of data, communicate with other nodes, and build a local database that records the addresses of different nodes and the data types of each node. - Transmit data (of different sizes and in varying quantities) between different nodes. --- - **Blockchain Simulation** - Implement a simulation of the blockchain network. - Simulate transactions (blocks) of the P2P network and the propagation logic. - Implement the PoW algorithm to simulate mining. - Limit link bandwidth and test the network latency and forking conditions under different block sizes and block generation intervals. - Use the PBFT protocol for consensus. --- - **Attack Simulation** - Conduct experiments on the basis of the simulated Bitcoin network. - Run simulation experiments and record the probability of a successful attack (being able to produce a longer chain that invalidates certain existing blocks) under different hashing power levels. - BGP hijacking and Eclipse attacks. The project repository is located at https://github.com/131250106/bitcoin
This post is a summary of the 5th assignment for the Fall 2018 Computational Linguistics course, with the task of using a `Hidden Markov Model` to calculate sentence probabilities.
This article is a summary of the 6th assignment for the Fall 2018 Computational Linguistics course, with the task of generating adversarial input sequences based on RNN. First, let me give an overall introduction to the concept of adversarial example attacks. Some researchers have found that although deep neural networks achieve very high accuracy, applying small perturbations to the input can cause the model's prediction results to be completely wrong. For images, such perturbations are usually so subtle that they are imperceptible (humans cannot intuitively perceive the perturbation in the image), yet these adversarial input examples can successfully fool deep learning models. This type of attack that deceives neural network models can be broadly divided into two categories: untargeted attacks only need to make the predicted result of the image inconsistent with the original label, while targeted attacks need to misclassify the image as a specific class. It is worth noting that researchers have found that generated adversarial examples are still effective on other models, which is known as the transferability of adversarial examples.
Currently, with the rapid development of multi-core computer hardware, multithreaded concurrent programs are gaining increasing popularity and widespread adoption. However, due to the hidden nature of shared memory space access and the randomness of concurrent thread scheduling, multithreaded programs are highly susceptible to concurrency defects, which are often difficult to detect and reproduce. Existing concurrency defect detection methods all have their limitations; for example, methods based on system testing and symbolic execution cannot scale to large concurrent programs due to state space explosion, while methods based on probabilistic scheduling have a very low defect hit rate. To address the enormous challenges faced in concurrent program testing today, the DATE team developed DATE-Confu, a multithreaded concurrency defect detection tool for JVM applications based on dynamic program testing techniques. The tool takes JVM executable programs under test (.class files or .jar files) as input and outputs the set of concurrency defects detected in the program. Currently, the tool can detect six categories of serious concurrency defects, including data races, deadlocks, and null pointer dereferences. Users can select which types of concurrency defects to detect based on their needs. The key innovation of DATE-Confu lies in its effective combination of guided schedule fuzzing techniques and symbolic trace analysis techniques. The figure below shows the architecture diagram of DATE-Confu. The tool uses fuzzing techniques to efficiently traverse the enormous state space of multithreaded programs, while the symbolic trace analysis techniques rapidly discover unexplored control branches in the program under test, thereby providing effective information for iterative fuzzing and enabling DATE-Confu to reach higher coverage faster. DATE-Confu has so far been tested on multiple industrial-level projects. The experiments conducted to date have demonstrated that DATE-Confu achieves high testing efficiency and is capable of uncovering deeper-hidden concurrency defects.
This system employs machine learning methods and a big data platform to train on a massive volume of job seekers' resumes. Unlike ordinary conditional filtering, this system can efficiently and accurately provide suitable and reliable talent recommendations from a big data processing perspective for IT positions that recruiters are looking to fill, reducing recruitment costs and using big data technology to bridge the gap between recruiters and outstanding talent. Through research on massive resume data and company recruitment information, this project analyzes the characteristic features of personal resumes, companies, and company positions. From the recruiter's perspective, it conducts exploratory research centered on personalized recommendation technology to help recruiters obtain talent information in a more accurate and efficient manner. Based on this concept, a prototype system is implemented that can automatically recommend more appropriate resumes based on the characteristics of job postings.
**Abstract** Sitting posture detection is helpful for preventing musculoskeletal disorders. With the development of motion-sensing cameras and related software development kits (SDKs), it is possible to implement an application using skeleton detection technology. In this paper, a method is introduced to detect sitting posture from a lateral view without disturbing the user. To analyze video stream information, a skeleton thinning algorithm is described, and an averaging process is used to specifically locate the main joints from the lateral side. The results show this method has high accuracy when detecting improper sitting postures. **Keywords** Ergonomics; Motion-sensing Camera; Gesture Recognition; OpenNI