repo_name
stringlengths 6
97
| path
stringlengths 3
341
| text
stringlengths 8
1.02M
|
|---|---|---|
zhusonghe/PaddleClas-1
|
deploy/cpp/include/cls.h
|
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include "paddle_inference_api.h"
#include <chrono>
#include <iomanip>
#include <iostream>
#include <ostream>
#include <vector>
#include <cstring>
#include <fstream>
#include <numeric>
#include "include/cls_config.h"
#include <include/preprocess_op.h>
using namespace paddle_infer;
namespace PaddleClas {
class Classifier {
public:
explicit Classifier(const ClsConfig &config) {
this->use_gpu_ = config.use_gpu;
this->gpu_id_ = config.gpu_id;
this->gpu_mem_ = config.gpu_mem;
this->cpu_math_library_num_threads_ = config.cpu_threads;
this->use_fp16_ = config.use_fp16;
this->use_mkldnn_ = config.use_mkldnn;
this->use_tensorrt_ = config.use_tensorrt;
this->mean_ = config.mean;
this->std_ = config.std;
this->resize_short_size_ = config.resize_short_size;
this->scale_ = config.scale;
this->crop_size_ = config.crop_size;
this->ir_optim_ = config.ir_optim;
LoadModel(config.cls_model_path, config.cls_params_path);
}
// Load Paddle inference model
void LoadModel(const std::string &model_path, const std::string ¶ms_path);
// Run predictor
void Run(cv::Mat &img, std::vector<float> &out_data, std::vector<int> &idx,
std::vector<double> ×);
private:
std::shared_ptr <Predictor> predictor_;
bool use_gpu_ = false;
int gpu_id_ = 0;
int gpu_mem_ = 4000;
int cpu_math_library_num_threads_ = 4;
bool use_mkldnn_ = false;
bool use_tensorrt_ = false;
bool use_fp16_ = false;
bool ir_optim_ = true;
std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
std::vector<float> std_ = {0.229f, 0.224f, 0.225f};
float scale_ = 0.00392157;
int resize_short_size_ = 256;
int crop_size_ = 224;
// pre-process
ResizeImg resize_op_;
Normalize normalize_op_;
Permute permute_op_;
CenterCropImg crop_op_;
};
} // namespace PaddleClas
|
zhusonghe/PaddleClas-1
|
deploy/cpp_shitu/include/nms.h
|
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This code is adpated from opencv(https://github.com/opencv/opencv)
#include <algorithm>
#include <include/object_detector.h>
template<typename T>
static inline bool SortScorePairDescend(const std::pair<float, T> &pair1,
const std::pair<float, T> &pair2) {
return pair1.first > pair2.first;
}
float RectOverlap(const Detection::ObjectResult &a,
const Detection::ObjectResult &b) {
float Aa = (a.rect[2] - a.rect[0] + 1) * (a.rect[3] - a.rect[1] + 1);
float Ab = (b.rect[2] - b.rect[0] + 1) * (b.rect[3] - b.rect[1] + 1);
int iou_w = max(min(a.rect[2], b.rect[2]) - max(a.rect[0], b.rect[0]) + 1, 0);
int iou_h = max(min(a.rect[3], b.rect[3]) - max(a.rect[1], b.rect[1]) + 1, 0);
float Aab = iou_w * iou_h;
return Aab / (Aa + Ab - Aab);
}
// Get max scores with corresponding indices.
// scores: a set of scores.
// threshold: only consider scores higher than the threshold.
// top_k: if -1, keep all; otherwise, keep at most top_k.
// score_index_vec: store the sorted (score, index) pair.
inline void
GetMaxScoreIndex(const std::vector <Detection::ObjectResult> &det_result,
const float threshold,
std::vector <std::pair<float, int>> &score_index_vec) {
// Generate index score pairs.
for (size_t i = 0; i < det_result.size(); ++i) {
if (det_result[i].confidence > threshold) {
score_index_vec.push_back(std::make_pair(det_result[i].confidence, i));
}
}
// Sort the score pair according to the scores in descending order
std::stable_sort(score_index_vec.begin(), score_index_vec.end(),
SortScorePairDescend<int>);
// // Keep top_k scores if needed.
// if (top_k > 0 && top_k < (int)score_index_vec.size())
// {
// score_index_vec.resize(top_k);
// }
}
void NMSBoxes(const std::vector <Detection::ObjectResult> det_result,
const float score_threshold, const float nms_threshold,
std::vector<int> &indices) {
int a = 1;
// Get top_k scores (with corresponding indices).
std::vector <std::pair<float, int>> score_index_vec;
GetMaxScoreIndex(det_result, score_threshold, score_index_vec);
// Do nms
indices.clear();
for (size_t i = 0; i < score_index_vec.size(); ++i) {
const int idx = score_index_vec[i].second;
bool keep = true;
for (int k = 0; k < (int) indices.size() && keep; ++k) {
const int kept_idx = indices[k];
float overlap = RectOverlap(det_result[idx], det_result[kept_idx]);
keep = overlap <= nms_threshold;
}
if (keep)
indices.push_back(idx);
}
}
|
zhusonghe/PaddleClas-1
|
deploy/lite_shitu/include/recognition.h
|
// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "paddle_api.h" // NOLINT
#include "json/json.h"
#include <arm_neon.h>
#include <chrono>
#include <fstream>
#include <iostream>
#include <math.h>
#include <opencv2/opencv.hpp>
#include <stdlib.h>
#include <sys/time.h>
#include <vector>
using namespace paddle::lite_api; // NOLINT
using namespace std;
namespace PPShiTu {
struct RESULT {
std::string class_name;
int class_id;
float score;
};
class Recognition {
public:
explicit Recognition(const Json::Value &config_file) {
MobileConfig config;
if (config_file["Global"]["rec_model_path"].as<std::string>().empty()) {
std::cout << "Please set [rec_model_path] in config file" << std::endl;
exit(-1);
}
config.set_model_from_file(
config_file["Global"]["rec_model_path"].as<std::string>());
this->predictor = CreatePaddlePredictor<MobileConfig>(config);
if (config_file["Global"]["rec_label_path"].as<std::string>().empty()) {
std::cout << "Please set [rec_label_path] in config file" << std::endl;
exit(-1);
}
LoadLabel(config_file["Global"]["rec_label_path"].as<std::string>());
SetPreProcessParam(config_file["RecPreProcess"]["transform_ops"]);
if (!config_file["Global"].isMember("return_k")){
this->topk = config_file["Global"]["return_k"].as<int>();
}
printf("rec model create!\n");
}
void LoadLabel(std::string path) {
std::ifstream file;
std::vector<std::string> label_list;
file.open(path);
while (file) {
std::string line;
std::getline(file, line);
std::string::size_type pos = line.find(" ");
if (pos != std::string::npos) {
line = line.substr(pos);
}
this->label_list.push_back(line);
}
file.clear();
file.close();
}
void SetPreProcessParam(const Json::Value &config_file) {
for (const auto &item : config_file) {
auto op_name = item["type"].as<std::string>();
if (op_name == "ResizeImage") {
this->size = item["size"].as<int>();
} else if (op_name == "NormalizeImage") {
this->mean.clear();
this->std.clear();
for (auto tmp : item["mean"]) {
this->mean.emplace_back(tmp.as<float>());
}
for (auto tmp : item["std"]) {
this->std.emplace_back(1 / tmp.as<float>());
}
this->scale = item["scale"].as<double>();
}
}
}
std::vector<RESULT> RunRecModel(const cv::Mat &img, double &cost_time);
std::vector<RESULT> PostProcess(const float *output_data, int output_size,
cv::Mat &output_image);
cv::Mat ResizeImage(const cv::Mat &img);
void NeonMeanScale(const float *din, float *dout, int size);
private:
std::shared_ptr<PaddlePredictor> predictor;
std::vector<std::string> label_list;
std::vector<float> mean = {0.485f, 0.456f, 0.406f};
std::vector<float> std = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
double scale = 0.00392157;
float size = 224;
int topk = 5;
};
} // namespace PPShiTu
|
zhusonghe/PaddleClas-1
|
deploy/lite_shitu/include/config_parser.h
|
<filename>deploy/lite_shitu/include/config_parser.h
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include "json/json.h"
#ifdef _WIN32
#define OS_PATH_SEP "\\"
#else
#define OS_PATH_SEP "/"
#endif
namespace PPShiTu {
void load_jsonf(std::string jsonfile, Json::Value& jsondata);
// Inference model configuration parser
class ConfigPaser {
public:
ConfigPaser() {}
~ConfigPaser() {}
bool load_config(const Json::Value& config) {
// Get model arch : YOLO, SSD, RetinaNet, RCNN, Face
if (config["Global"].isMember("det_arch")) {
arch_ = config["Global"]["det_arch"].as<std::string>();
} else {
std::cerr << "Please set model arch,"
<< "support value : YOLO, SSD, RetinaNet, RCNN, Face."
<< std::endl;
return false;
}
// Get Preprocess for preprocessing
if (config.isMember("DetPreProcess")) {
preprocess_info_ = config["DetPreProcess"]["transform_ops"];
} else {
std::cerr << "Please set Preprocess." << std::endl;
return false;
}
// Get label_list for visualization
if (config["Global"].isMember("label_list")) {
label_list_.clear();
for (auto item : config["Global"]["label_list"]) {
label_list_.emplace_back(item.as<std::string>());
}
} else {
std::cerr << "Please set label_list." << std::endl;
return false;
}
// Get NMS for postprocess
if (config.isMember("DetPostProcess")) {
nms_info_ = config["DetPostProcess"];
}
// Get fpn_stride in PicoDet
if (config["Global"].isMember("det_fpn_stride")) {
fpn_stride_.clear();
for (auto item : config["Global"]["det_fpn_stride"]) {
fpn_stride_.emplace_back(item.as<int>());
}
}
return true;
}
std::string arch_;
Json::Value preprocess_info_;
Json::Value nms_info_;
std::vector<std::string> label_list_;
std::vector<int> fpn_stride_;
};
} // namespace PPShiTu
|
zhusonghe/PaddleClas-1
|
deploy/cpp_shitu/include/object_detector.h
|
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include <ctime>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include "paddle_inference_api.h" // NOLINT
#include "include/preprocess_op_det.h"
#include "include/yaml_config.h"
using namespace paddle_infer;
namespace Detection {
// Object Detection Result
struct ObjectResult {
// Rectangle coordinates of detected object: left, right, top, down
std::vector<int> rect;
// Class id of detected object
int class_id;
// Confidence of detected object
float confidence;
};
// Generate visualization colormap for each class
std::vector<int> GenerateColorMap(int num_class);
// Visualiztion Detection Result
cv::Mat VisualizeResult(const cv::Mat &img,
const std::vector <ObjectResult> &results,
const std::vector <std::string> &lables,
const std::vector<int> &colormap, const bool is_rbox);
class ObjectDetector {
public:
explicit ObjectDetector(const YAML::Node &config_file) {
this->use_gpu_ = config_file["Global"]["use_gpu"].as<bool>();
if (config_file["Global"]["gpu_id"].IsDefined())
this->gpu_id_ = config_file["Global"]["gpu_id"].as<int>();
this->gpu_mem_ = config_file["Global"]["gpu_mem"].as<int>();
this->cpu_math_library_num_threads_ =
config_file["Global"]["cpu_num_threads"].as<int>();
this->use_mkldnn_ = config_file["Global"]["enable_mkldnn"].as<bool>();
this->use_tensorrt_ = config_file["Global"]["use_tensorrt"].as<bool>();
this->use_fp16_ = config_file["Global"]["use_fp16"].as<bool>();
this->model_dir_ =
config_file["Global"]["det_inference_model_dir"].as<std::string>();
this->threshold_ = config_file["Global"]["threshold"].as<float>();
this->max_det_results_ = config_file["Global"]["max_det_results"].as<int>();
this->image_shape_ =
config_file["Global"]["image_shape"].as < std::vector < int >> ();
this->label_list_ =
config_file["Global"]["labe_list"].as < std::vector < std::string >> ();
this->ir_optim_ = config_file["Global"]["ir_optim"].as<bool>();
this->batch_size_ = config_file["Global"]["batch_size"].as<int>();
preprocessor_.Init(config_file["DetPreProcess"]["transform_ops"]);
LoadModel(model_dir_, batch_size_, run_mode);
}
// Load Paddle inference model
void LoadModel(const std::string &model_dir, const int batch_size = 1,
const std::string &run_mode = "fluid");
// Run predictor
void Predict(const std::vector <cv::Mat> imgs, const int warmup = 0,
const int repeats = 1,
std::vector <ObjectResult> *result = nullptr,
std::vector<int> *bbox_num = nullptr,
std::vector<double> *times = nullptr);
const std::vector <std::string> &GetLabelList() const {
return this->label_list_;
}
const float &GetThreshold() const { return this->threshold_; }
private:
bool use_gpu_ = true;
int gpu_id_ = 0;
int gpu_mem_ = 800;
int cpu_math_library_num_threads_ = 6;
std::string run_mode = "fluid";
bool use_mkldnn_ = false;
bool use_tensorrt_ = false;
bool batch_size_ = 1;
bool use_fp16_ = false;
std::string model_dir_;
float threshold_ = 0.5;
float max_det_results_ = 5;
std::vector<int> image_shape_ = {3, 640, 640};
std::vector <std::string> label_list_;
bool ir_optim_ = true;
bool det_permute_ = true;
bool det_postprocess_ = true;
int min_subgraph_size_ = 30;
bool use_dynamic_shape_ = false;
int trt_min_shape_ = 1;
int trt_max_shape_ = 1280;
int trt_opt_shape_ = 640;
bool trt_calib_mode_ = false;
// Preprocess image and copy data to input buffer
void Preprocess(const cv::Mat &image_mat);
// Postprocess result
void Postprocess(const std::vector <cv::Mat> mats,
std::vector <ObjectResult> *result, std::vector<int> bbox_num,
bool is_rbox);
std::shared_ptr <Predictor> predictor_;
Preprocessor preprocessor_;
ImageBlob inputs_;
std::vector<float> output_data_;
std::vector<int> out_bbox_num_data_;
};
} // namespace Detection
|
zhusonghe/PaddleClas-1
|
deploy/cpp_shitu/include/preprocess_op_det.h
|
<gh_stars>100-1000
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include <glog/logging.h>
#include <yaml-cpp/yaml.h>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
namespace Detection {
// Object for storing all preprocessed data
class ImageBlob {
public:
// image width and height
std::vector<float> im_shape_;
// Buffer for image data after preprocessing
std::vector<float> im_data_;
// in net data shape(after pad)
std::vector<float> in_net_shape_;
// Evaluation image width and height
// std::vector<float> eval_im_size_f_;
// Scale factor for image size to origin image size
std::vector<float> scale_factor_;
};
// Abstraction of preprocessing opration class
class PreprocessOp {
public:
virtual void Init(const YAML::Node &item) = 0;
virtual void Run(cv::Mat *im, ImageBlob *data) = 0;
};
class InitInfo : public PreprocessOp {
public:
virtual void Init(const YAML::Node &item) {}
virtual void Run(cv::Mat *im, ImageBlob *data);
};
class NormalizeImage : public PreprocessOp {
public:
virtual void Init(const YAML::Node &item) {
mean_ = item["mean"].as < std::vector < float >> ();
scale_ = item["std"].as < std::vector < float >> ();
is_scale_ = item["is_scale"].as<bool>();
}
virtual void Run(cv::Mat *im, ImageBlob *data);
private:
// CHW or HWC
std::vector<float> mean_;
std::vector<float> scale_;
bool is_scale_;
};
class Permute : public PreprocessOp {
public:
virtual void Init(const YAML::Node &item) {}
virtual void Run(cv::Mat *im, ImageBlob *data);
};
class Resize : public PreprocessOp {
public:
virtual void Init(const YAML::Node &item) {
interp_ = item["interp"].as<int>();
// max_size_ = item["target_size"].as<int>();
keep_ratio_ = item["keep_ratio"].as<bool>();
target_size_ = item["target_size"].as < std::vector < int >> ();
}
// Compute best resize scale for x-dimension, y-dimension
std::pair<double, double> GenerateScale(const cv::Mat &im);
virtual void Run(cv::Mat *im, ImageBlob *data);
private:
int interp_ = 2;
bool keep_ratio_;
std::vector<int> target_size_;
std::vector<int> in_net_shape_;
};
// Models with FPN need input shape % stride == 0
class PadStride : public PreprocessOp {
public:
virtual void Init(const YAML::Node &item) {
stride_ = item["stride"].as<int>();
}
virtual void Run(cv::Mat *im, ImageBlob *data);
private:
int stride_;
};
class Preprocessor {
public:
void Init(const YAML::Node &config_node) {
// initialize image info at first
ops_["InitInfo"] = std::make_shared<InitInfo>();
for (int i = 0; i < config_node.size(); ++i) {
if (config_node[i]["DetResize"].IsDefined()) {
ops_["Resize"] = std::make_shared<Resize>();
ops_["Resize"]->Init(config_node[i]["DetResize"]);
}
if (config_node[i]["DetNormalizeImage"].IsDefined()) {
ops_["NormalizeImage"] = std::make_shared<NormalizeImage>();
ops_["NormalizeImage"]->Init(config_node[i]["DetNormalizeImage"]);
}
if (config_node[i]["DetPermute"].IsDefined()) {
ops_["Permute"] = std::make_shared<Permute>();
ops_["Permute"]->Init(config_node[i]["DetPermute"]);
}
if (config_node[i]["DetPadStrid"].IsDefined()) {
ops_["PadStride"] = std::make_shared<PadStride>();
ops_["PadStride"]->Init(config_node[i]["DetPadStrid"]);
}
}
}
void Run(cv::Mat *im, ImageBlob *data);
public:
static const std::vector <std::string> RUN_ORDER;
private:
std::unordered_map <std::string, std::shared_ptr<PreprocessOp>> ops_;
};
} // namespace Detection
|
zhusonghe/PaddleClas-1
|
deploy/lite_shitu/include/utils.h
|
<filename>deploy/lite_shitu/include/utils.h
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include <algorithm>
#include <ctime>
#include <include/recognition.h>
#include <memory>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
namespace PPShiTu {
// Object Detection Result
struct ObjectResult {
// Rectangle coordinates of detected object: left, right, top, down
std::vector<int> rect;
// Class id of detected object
int class_id;
// Confidence of detected object
float confidence;
// RecModel result
std::vector<RESULT> rec_result;
};
void nms(std::vector<ObjectResult> &input_boxes, float nms_threshold, bool rec_nms=false);
} // namespace PPShiTu
|
zhusonghe/PaddleClas-1
|
deploy/cpp_shitu/include/feature_extracter.h
|
<filename>deploy/cpp_shitu/include/feature_extracter.h
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include "paddle_inference_api.h"
#include <chrono>
#include <iomanip>
#include <iostream>
#include <ostream>
#include <vector>
#include <cstring>
#include <fstream>
#include <numeric>
#include <include/preprocess_op.h>
#include <include/yaml_config.h>
using namespace paddle_infer;
namespace Feature {
class FeatureExtracter {
public:
explicit FeatureExtracter(const YAML::Node &config_file) {
this->use_gpu_ = config_file["Global"]["use_gpu"].as<bool>();
if (config_file["Global"]["gpu_id"].IsDefined())
this->gpu_id_ = config_file["Global"]["gpu_id"].as<int>();
else
this->gpu_id_ = 0;
this->gpu_mem_ = config_file["Global"]["gpu_mem"].as<int>();
this->cpu_math_library_num_threads_ =
config_file["Global"]["cpu_num_threads"].as<int>();
this->use_mkldnn_ = config_file["Global"]["enable_mkldnn"].as<bool>();
this->use_tensorrt_ = config_file["Global"]["use_tensorrt"].as<bool>();
this->use_fp16_ = config_file["Global"]["use_fp16"].as<bool>();
this->cls_model_path_ =
config_file["Global"]["rec_inference_model_dir"].as<std::string>() +
OS_PATH_SEP + "inference.pdmodel";
this->cls_params_path_ =
config_file["Global"]["rec_inference_model_dir"].as<std::string>() +
OS_PATH_SEP + "inference.pdiparams";
this->resize_size_ =
config_file["RecPreProcess"]["transform_ops"][0]["ResizeImage"]["size"]
.as<int>();
this->scale_ = config_file["RecPreProcess"]["transform_ops"][1]["NormalizeImage"]["scale"].as<float>();
this->mean_ = config_file["RecPreProcess"]["transform_ops"][1]
["NormalizeImage"]["mean"]
.as < std::vector < float >> ();
this->std_ = config_file["RecPreProcess"]["transform_ops"][1]
["NormalizeImage"]["std"]
.as < std::vector < float >> ();
if (config_file["Global"]["rec_feature_normlize"].IsDefined())
this->feature_norm =
config_file["Global"]["rec_feature_normlize"].as<bool>();
LoadModel(cls_model_path_, cls_params_path_);
}
// Load Paddle inference model
void LoadModel(const std::string &model_path, const std::string ¶ms_path);
// Run predictor
void Run(cv::Mat &img, std::vector<float> &out_data,
std::vector<double> ×);
void FeatureNorm(std::vector<float> &feature);
std::shared_ptr <Predictor> predictor_;
private:
bool use_gpu_ = false;
int gpu_id_ = 0;
int gpu_mem_ = 4000;
int cpu_math_library_num_threads_ = 4;
bool use_mkldnn_ = false;
bool use_tensorrt_ = false;
bool feature_norm = true;
bool use_fp16_ = false;
std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
std::vector<float> std_ = {0.229f, 0.224f, 0.225f};
float scale_ = 0.00392157;
int resize_size_ = 224;
int resize_short_ = 224;
std::string cls_model_path_;
std::string cls_params_path_;
// pre-process
ResizeImg resize_op_;
Normalize normalize_op_;
Permute permute_op_;
};
} // namespace Feature
|
NightfallDM/xbook2
|
library/xlibc/stdlib/qsort.c
|
<gh_stars>0
#include <stdlib.h>
#include <string.h>
void swap(char * a, char * b, size_t width)
{
char tmp;
while (width--) {
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
char * partition(char * lo, char * hi, int (*comp)(const void *, const void *), size_t width)
{
char * i = lo;
char * j = hi;
while (i <= j) {
do {
i += width;
if (i == hi) break;
} while ((*comp)(i, lo) < 0);
while (1) {
if ((*comp)(j, lo) <= 0)
break;
j -= width;
}
if (i <= j)
swap(i, j, width);
}
swap(j, lo, width);
return j;
}
void sort(char * lo, char * hi, int (*comp)(const void *, const void *), size_t width) {
char * p;
if (lo >= hi) return;
p = partition(lo, hi, comp, width);
sort(lo, p - width, comp, width);
sort(p + width, hi, comp, width);
}
void qsort(void * base, size_t num, size_t width, int (*comp)(const void *, const void *)) {
char * lo = (char *) base;
char * hi = (char *) base;
hi += (num - 1) * width;
sort(lo, hi, comp, width);
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/ioctl.h
|
<filename>library/xlibc/include/sys/ioctl.h
#ifndef _SYS_IOCTL_H
#define _SYS_IOCTL_H
/* 设备控制码：
0~15位：命令（0-0x7FFF系统保留，0x8000-0xffff用户自定义）
16~31位：设备类型
*/
#ifndef DEVCTL_CODE
#define DEVCTL_CODE(type, cmd) \
((unsigned int) ((((type) & 0xffff) << 16) | ((cmd) & 0xffff)))
#endif
/* 设备标志 */
#define DEV_NOWAIT 0x01 /* 非阻塞方式 */
/* 定义系统的设备控制码 */
/* 控制台 */
#define CONIO_CLEAR DEVCTL_CODE('c', 1)
#define CONIO_SCROLL DEVCTL_CODE('c', 2)
#define CONIO_SETCOLOR DEVCTL_CODE('c', 3)
#define CONIO_GETCOLOR DEVCTL_CODE('c', 4)
#define CONIO_SETPOS DEVCTL_CODE('c', 5)
#define CONIO_GETPOS DEVCTL_CODE('c', 6)
/* disk */
#define DISKIO_GETSIZE DEVCTL_CODE('d', 1)
#define DISKIO_CLEAR DEVCTL_CODE('d', 2)
/* tty */
#define TTYIO_CLEAR CONIO_CLEAR
#define TTYIO_SCROLL CONIO_SCROLL
#define TTYIO_SETCOLOR CONIO_SETCOLOR
#define TTYIO_GETCOLOR CONIO_GETCOLOR
#define TTYIO_SETPOS CONIO_SETPOS
#define TTYIO_GETPOS CONIO_GETPOS
#define TTYIO_HOLDER DEVCTL_CODE('t', 1)
#define TTYIO_VISITOR DEVCTL_CODE('t', 2)
#define TTYIO_DETACH DEVCTL_CODE('t', 3)
#define TTYIO_COMBINE DEVCTL_CODE('t', 4)
/* net */
#define NETIO_GETMAC DEVCTL_CODE('n', 1)
#define NETIO_SETMAC DEVCTL_CODE('n', 2)
/* video */
typedef struct _video_info {
char bits_per_pixel; /* 每个像素的位数 */
short bytes_per_scan_line; /* 单行的字节数 */
short x_resolution, y_resolution; /* 分辨率x，y */
} video_info_t;
#define VIDEOIO_GETINFO DEVCTL_CODE('v', 1) /* get video info */
/* even */
#define EVENIO_GETLED DEVCTL_CODE('e', 1) /* get led states */
#endif /* _SYS_IOCTL_H */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/spinlock.h
|
<gh_stars>0
#ifndef _SYS_SPINLOCK_H
#define _SYS_SPINLOCK_H
#include <arch/atomic.h>
typedef struct {
volatile int lock;
} spinlock_t;
/* 默认初始化为未初始化的自旋锁 */
#define SPIN_LOCK_INIT() \
{.lock = 0}
int spin_lock_init(spinlock_t *lock);
int spin_lock(spinlock_t *lock);
int spin_trylock(spinlock_t *lock);
int spin_unlock(spinlock_t *lock);
int spin_is_locked(spinlock_t *lock);
#endif /* _SYS_SPINLOCK_H */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/srvcall.h
|
<reponame>NightfallDM/xbook2
#ifndef _SYS_SRVCALL_H
#define _SYS_SRVCALL_H
/**
* 系统调用是用户态陷入内核，让内核帮忙执行一些内容。
* 服务调用是用户态转移到用户态，让服务进程帮忙执行一些内容。
* srvcall, 传入参数，然后先陷入内核，然后寻找到对应的服务进程。
* 查看服务进程的状态，如果可转移，那么就直接转移，不然，就等待。
*
* 服务进程，先通过系统调用，进入到可服务状态，等待其它进程跳转服务。
* 先查看就绪队列，如果有就从里面挑选一个出来，并执行。然后继续陷入
* 内核挑选，直到就绪队列为空，然后就进入阻塞等待状态。
*
* 服务进程：处于可转移状态，当第一个进程跳转的时候，将参数传递给它
* 然后唤醒它。然后阻塞调用进程。
* 处于不可转移状态，说明正在处理一个转移，那么，就需要把当前进程挂到
* 服务进程的就绪队列，然后阻塞自己，等待服务进程处理完服务后并解除
* 阻塞。
*/
#define SRV_FS 0
#define SRV_NET 1
#define SRV_GUI 2
#define SRVIO_SERVICE 0 /* 流向服务 */
#define SRVIO_USER 1 /* 流向用户 */
#define SRVARG_NR 8
#define GETSRV_DATA(arg, idx, type) \
((type) ((arg)->data[(idx)]))
#define GETSRV_SIZE(arg, idx) \
((arg)->size[(idx)])
#define SETSRV_DATA(arg, idx, value) \
(arg)->data[(idx)] = (unsigned long) (value)
#define SETSRV_SIZE(arg, idx, value) \
(arg)->size[(idx)] = (unsigned long) (value)
#define SETSRV_RETVAL(arg, value) \
(arg)->retval = (unsigned long) (value)
#define GETSRV_RETVAL(arg, type) \
((type) ((arg)->retval))
#define SETSRV_ARG(arg, idx, value, len) \
(arg)->data[(idx)] = (unsigned long) (value); (arg)->size[(idx)] = (len)
#define SETSRV_IO(arg, iobits) \
(arg)->io = (iobits)
#define GETSRV_IO(arg, type) \
((type) ((arg)->io))
typedef struct _srvarg {
unsigned long data[SRVARG_NR]; /* 参数的值 */
long size[SRVARG_NR]; /* 参数的大小 */
/* 参数io：有8位，
某位置1，表示对应的参数是用户流向，需要把数据读取回用户进程
某位置0，表示对应的参数是服务流向，需要把数据写入服务进程 */
unsigned char io;
unsigned long retval; /* 返回值 */
} srvarg_t;
#define DEFINE_SRVARG(name) \
srvarg_t name; \
memset(&(name), 0, sizeof(srvarg_t))
int srvcall_bind(int port);
int srvcall_unbind(int port);
int srvcall_listen(int port, srvarg_t *arg);
int srvcall_ack(int port, srvarg_t *arg);
int srvcall(int port, srvarg_t *arg);
int srvcall_fetch(int port, srvarg_t *arg);
int srvcall_inbuffer(srvarg_t *arg);
#endif /* _SYS_SRVCALL_H */
|
NightfallDM/xbook2
|
src/include/xbook/resource.h
|
#ifndef _XBOOK_RESOURCE_H
#define _XBOOK_RESOURCE_H
#include <types.h>
#include <stddef.h>
/* 每个进程可持有的资源数量 */
#define RES_NR 64
#define RES_MASK 0x00ffffff
/* 资源本身的标志，0~15位 */
#define RES_LOCAL_MASK 0x0000ffff
/* 资源管理类型的标志，24~31是主类型 */
#define RES_MASTER_MASK 0xff000000
/* 资源管理类型的标志，16~23位是从类型 */
#define RES_SLAVER_MASK 0x00ff0000
/* 资源管理类型的标志，16~31位，16~23位是从类型，24~31是主类型 */
#define RES_GLOBAL_MASK (RES_MASTER_MASK | RES_SLAVER_MASK)
typedef struct {
unsigned long flags; /* 打开时的资源类型 */
unsigned long handle; /* 资源句柄 */
} res_item_t;
typedef struct {
res_item_t table[RES_NR]; /* 资源储存表 */
} resource_t;
#define IS_BAD_RES(res) \
(res < 0 || res >= RES_NR)
void resource_init(resource_t *res);
void resource_copy(resource_t *dst, resource_t *src);
void resource_release(resource_t *res);
int resource_item_copy(int dst_res, int src_res);
void dump_resource(resource_t *res);
int sys_getres(char *resname, unsigned long resflg, unsigned long arg);
int sys_putres(int res);
int sys_readres(int res, off_t off, void *buffer, size_t count);
int sys_writeres(int res, off_t off, void *buffer, size_t count);
int sys_ctlres(int res, unsigned int cmd, unsigned long arg);
void *sys_mmap(int res, size_t length, int flags);
unsigned long sys_unid(int id);
#endif /* _XBOOK_RESOURCE_H */
|
NightfallDM/xbook2
|
library/xlibc/include/xcons.h
|
#ifndef _XLIBC_XCONSOLE_H
#define _XLIBC_XCONSOLE_H
#define XCONS_KMOD_SHIFT_L 0x01
#define XCONS_KMOD_SHIFT_R 0x02
#define XCONS_KMOD_SHIFT (XCONS_KMOD_SHIFT_L | XCONS_KMOD_SHIFT_R)
#define XCONS_KMOD_CTRL_L 0x04
#define XCONS_KMOD_CTRL_R 0x08
#define XCONS_KMOD_CTRL (XCONS_KMOD_CTRL_L | XCONS_KMOD_CTRL_R)
#define XCONS_KMOD_ALT_L 0x10
#define XCONS_KMOD_ALT_R 0x20
#define XCONS_KMOD_ALT (XCONS_KMOD_ALT_L | XCONS_KMOD_ALT_R)
#define XCONS_KMOD_PAD 0x40
#define XCONS_KMOD_NUM 0x80
#define XCONS_KMOD_CAPS 0x100
int xcons_clear();
int xcons_getkey(int *buf, int flags);
int xcons_putstr(void *buf, int len);
#endif /* _XLIBC_XCONSOLE_H */
|
NightfallDM/xbook2
|
src/include/sys/res.h
|
<reponame>NightfallDM/xbook2<gh_stars>0
#ifndef _SYS_RES_H
#define _SYS_RES_H
/* 资源类型 */
#define RES_DEV 0x1000000 /* device resource */
#define RES_IPC 0x2000000 /* ipc resource */
/* 资源的控制命令 */
#define RES_REDIR 1
#define DEVICE_NAME_LEN 32
/* 设备项 */
typedef struct __devent {
short de_type; /* device type */
char de_name[DEVICE_NAME_LEN]; /* device name */
} devent_t;
typedef enum _device_type {
DEVICE_TYPE_BEEP, /* 蜂鸣器设备 */
DEVICE_TYPE_DISK, /* 磁盘设备 */
DEVICE_TYPE_KEYBOARD, /* 键盘设备 */
DEVICE_TYPE_MOUSE, /* 鼠标设备 */
DEVICE_TYPE_NULL, /* 空设备 */
DEVICE_TYPE_PORT, /* 端口设备 */
DEVICE_TYPE_SERIAL_PORT, /* 串口设备 */
DEVICE_TYPE_PARALLEL_PORT, /* 并口设备 */
DEVICE_TYPE_PHYSIC_NETCARD, /* 物理网卡设备 */
DEVICE_TYPE_PRINTER, /* 打印机设备 */
DEVICE_TYPE_SCANNER, /* 扫描仪设备 */
DEVICE_TYPE_SCREEN, /* 屏幕设备 */
DEVICE_TYPE_SOUND, /* 声音设备 */
DEVICE_TYPE_STREAM, /* 流设备 */
DEVICE_TYPE_UNKNOWN, /* 未知设备 */
DEVICE_TYPE_VIDEO, /* 视频设备 */
DEVICE_TYPE_VIRTUAL_DISK, /* 虚拟磁盘设备 */
DEVICE_TYPE_VIRTUAL_CHAR, /* 虚拟字符设备 */
DEVICE_TYPE_WAVE_IN, /* 声音输入设备 */
DEVICE_TYPE_WAVE_OUT, /* 声音输出设备 */
DEVICE_TYPE_8042_PORT, /* 8042端口设备 */
DEVICE_TYPE_NETWORK, /* 网络设备 */
DEVICE_TYPE_BUS_EXTERNDER, /* BUS总线扩展设备 */
DEVICE_TYPE_ACPI, /* ACPI设备 */
MAX_DEVICE_TYPE_NR
} device_type_t;
#endif /* _SYS_RES_H */
|
NightfallDM/xbook2
|
library/xlibc/syslib/time.c
|
<filename>library/xlibc/syslib/time.c
#include <sys/time.h>
#include <sys/syscall.h>
#include <time.h>
#include <errno.h>
/**
* alarm - 设置一个闹钟
* @second: 闹钟产生的时间
*
* @return: return left second before alarm
*/
unsigned long alarm(unsigned long second)
{
return syscall1(unsigned long , SYS_ALARM, second);
}
/**
* ktime - 获取内核时间
* @ktm: 内核时间结构
*/
unsigned long ktime(ktime_t *ktm)
{
return syscall1(int, SYS_KTIME, ktm);
}
#if 0
/**
* clock - 获取内核运行时钟数
*/
clock_t clock()
{
return syscall0(clock_t, SYS_GETTICKS);
}
#endif
/**
* gettimeofday - 获取当前的时间
* @tv: 时间
* @tz: 时区
*
* 成功返回0，失败返回-1
*/
int gettimeofday(struct timeval *tv, struct timezone *tz)
{
return syscall2(int, SYS_GETTIMEOFDAY, tv, tz);
}
/**
* clock_gettime - 获取时机
* @clockid: 获取的类型
* @ts: 时间结构
*
* 成功返回0，失败返回-1
*/
int clock_gettime(clockid_t clockid, struct timespec *ts)
{
return syscall2(int, SYS_CLOCK_GETTIME, clockid, ts);
}
int ktimeto(ktime_t *ktm, struct tm *tm)
{
if (!ktm || !tm)
return -1;
tm->tm_year = ktm->year - 1900;
tm->tm_yday = ktm->year_day;
tm->tm_mon = ktm->month;
tm->tm_mday = ktm->day;
tm->tm_hour = ktm->hour;
tm->tm_min = ktm->minute;
tm->tm_sec = ktm->second;
tm->tm_wday = ktm->week_day;
tm->tm_isdst = -1;
return 0;
}
/**
* usleep - 以微妙为单位休眠
* @usec: 要休眠的时间（微秒）
*
* 休眠过程中被打断，那么剩余的休眠时间（微秒）将被返回
*
* 成功返回0，失败返回-1
*/
int usleep(useconds_t usec)
{
struct timeval tvin, tvout;
tvin.tv_sec = usec / 1000000L;
tvin.tv_usec = usec % 1000000L;
long retv = syscall2(int, SYS_USLEEP, &tvin, &tvout);
if (!retv)
return 0;
_set_errno(retv);
return -1;
}
|
NightfallDM/xbook2
|
src/include/sys/srvcall.h
|
<gh_stars>0
#ifndef _SYS_SRVCALL_H
#define _SYS_SRVCALL_H
#define SRVIO_SERVICE 0 /* 流向服务 */
#define SRVIO_USER 1 /* 流向用户 */
#define SRVIO_BOTH 3 /* 双向 */
#define SRVARG_NR 8
typedef struct _srvarg {
unsigned long data[SRVARG_NR]; /* 参数的值 */
long size[SRVARG_NR]; /* 参数的大小 */
/* 参数io：有8位，
某位置1，表示对应的参数是用户流向，需要把数据读取回用户进程
某位置0，表示对应的参数是服务流向，需要把数据写入服务进程 */
unsigned char io;
unsigned long retval; /* 返回值 */
} srvarg_t;
#endif /* _SYS_SRVCALL_H */
|
NightfallDM/xbook2
|
src/vmm/dma.c
|
<reponame>NightfallDM/xbook2
#include <arch/page.h>
#include <arch/ioremap.h>
#include <xbook/vmarea.h>
#include <xbook/dma.h>
#include <math.h>
int alloc_dma_buffer(struct dma_region *d)
{
/* 参数检测 */
if (!d->p.size)
return -1;
int npages = DIV_ROUND_UP(d->p.size, PAGE_SIZE);
d->p.address = alloc_pages(npages);
if(d->p.address == 0)
return -1;
addr_t vaddr = alloc_vaddr(d->p.size);
if (vaddr == 0) {
free_pages(d->p.address);
return -1;
}
if (__ioremap(d->p.address, vaddr, d->p.size) < 0) {
free_vaddr(vaddr, d->p.size);
free_pages(d->p.address);
return -1;
}
d->v = vaddr;
return 0;
}
int free_dma_buffer(struct dma_region *d)
{
/* 参数检测 */
if (!d->p.size || !d->p.address || !d->v)
return -1;
if (__iounmap(d->v, d->p.size) < 0) {
return -1;
}
free_vaddr(d->v, d->p.size);
free_pages(d->p.address);
d->p.address = d->v = 0;
return 0;
}
|
NightfallDM/xbook2
|
src/kernel/alarm.c
|
#include <xbook/alarm.h>
#include <xbook/task.h>
#include <xbook/clock.h>
#include <xbook/debug.h>
#include <xbook/trigger.h>
#define DEBUG_LOCAL 0
unsigned long sys_alarm(unsigned long second)
{
task_t *cur = current_task;
/* 需要返回上次剩余的秒数 */
unsigned long old_second = cur->alarm.second;
if (second == 0) {
cur->alarm.flags = 0; /* 取消闹钟 */
} else {
cur->alarm.flags = 1; /* 定时器生效 */
cur->alarm.second = second; /* 设定秒数 */
cur->alarm.ticks = HZ; /* 设置ticks数 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_alarm: alarm seconds %d ticks %d\n", second, cur->alarm.ticks);
#endif
}
return old_second; /* 返回上次剩余时间 */
}
void update_alarms()
{
task_t *task;
unsigned long flags; /* 遍历期间需要关闭中断 */
save_intr(flags);
list_for_each_owner (task, &task_global_list, global_list) {
if (task->alarm.flags) {
task->alarm.ticks--;
if (!task->alarm.ticks) {
task->alarm.second--;
/* alarmTicks和时钟相关 */
task->alarm.ticks = HZ;
/* 如果时间结束，那么就发送SIGALRM信号 */
if (!task->alarm.second) {
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "update_alarms: task %d do alarm.\n", task->pid);
#endif
sys_trigger_active(TRIGALARM, task->pid);
task->alarm.flags = 0;
}
}
}
}
restore_intr(flags);
}
|
NightfallDM/xbook2
|
src/include/types.h
|
<filename>src/include/types.h
#ifndef _XBOOK_TYPES_H
#define _XBOOK_TYPES_H
#include <xbook/config.h>
typedef long pid_t;
typedef unsigned long flags_t;
typedef unsigned long register_t; //寄存器
typedef unsigned long off_t; //偏移类型的变量
typedef unsigned long sector_t;
typedef unsigned int mode_t;
typedef unsigned long dev_t;
typedef unsigned long blksize_t;
typedef unsigned long blkcnt_t;
typedef long clock_t;
typedef long time_t;
typedef int clockid_t;
typedef unsigned long addr_t;
typedef unsigned long ino_t;
typedef unsigned long nlink_t;
typedef unsigned int uid_t;
typedef unsigned int gid_t;
typedef unsigned long useconds_t;
typedef long kobjid_t; /* kernel object id */
typedef signed char s8_t;
typedef unsigned char u8_t;
typedef signed short s16_t;
typedef unsigned short u16_t;
typedef signed int s32_t;
typedef unsigned int u32_t;
typedef signed long long s64_t;
typedef unsigned long long u64_t;
typedef long long loff_t;
/* 在线程中作为形参 */
typedef void task_func_t(void *);
#endif /* _XBOOK_TYPES_H */
|
NightfallDM/xbook2
|
library/pthread/pthread_spinlock.c
|
<gh_stars>1-10
#include <pthread.h>
#include <arch/xchg.h>
#include <sys/proc.h>
#include <stdio.h>
#include <errno.h>
/* 自选一定次数后，才进行yeild */
#define __SPIN_COUNT 10
int pthread_spin_init(pthread_spinlock_t *lock, int pshared)
{
if (!lock)
return EINVAL;
//lock->count = 0;
atomic_set(&lock->count, 0);
lock->pshared = pshared;
return 0;
}
int pthread_spin_destroy(pthread_spinlock_t *lock)
{
if (!lock)
return EINVAL;
lock->pshared = 0;
if (atomic_get(&lock->count) == 1) {
//lock->count = 0;
atomic_set(&lock->count, 0);
return EBUSY; /* 繁忙 */
}
//lock->count = 0;
atomic_set(&lock->count, 0);
return 0;
}
int pthread_spin_lock(pthread_spinlock_t *lock)
{
if (!lock)
return EINVAL;
int i;
while (1)
{
for (i = 0; i < __SPIN_COUNT; i++) { /* 尝试多次后才让出cpu，以减少进程间切换。 */
if (pthread_spin_trylock(lock) == 0)
return 0;
}
sched_yeild();
}
return 0;
}
int pthread_spin_trylock(pthread_spinlock_t *lock)
{
if (!lock)
return EINVAL;
uint32_t oldvale;
/* 如果返回的旧值是0，那么成功获取，如果是1表示已经被占用，需要等待 */
oldvale = atomic_xchg(&lock->count, 1);
//oldvale = test_and_set(&lock->count, 1);
if (oldvale != 1) /* 没有上锁就成功 */
return 0;
else
return EBUSY; /* EBUSY繁忙 */
}
int pthread_spin_unlock(pthread_spinlock_t *lock)
{
if (!lock)
return EINVAL;
atomic_dec(&lock->count);
//lock->count = 0;
return 0;
}
int pthread_spin_is_locked(pthread_spinlock_t *lock)
{
if (!lock)
return EINVAL;
return atomic_get(&lock->count);
}
|
NightfallDM/xbook2
|
user/bosh/cmd.c
|
<reponame>NightfallDM/xbook2
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <ctype.h>
#include <math.h>
#include <sys/ipc.h>
#include <sys/res.h>
#include <sys/wait.h>
#include <sys/proc.h>
#include <sys/sys.h>
#include <sys/vmm.h>
#include <sys/time.h>
#include <arch/const.h>
#include <time.h>
#include <dirent.h>
#include <fcntl.h>
#include <xcons.h>
#include <sys/stat.h>
#include <sys/trigger.h>
/// 程序本地头文件
#include "cmd.h"
#include "shell.h"
cmd_man_t *cmdman;
extern char **environ;
#define DEBUG_LOCAL 0
/**
* cmd_parse - 从输入的命令行解析参数
* @cmd_str: 命令行缓冲
* @argv: 参数数组
* @token: 分割符
*/
int cmd_parse(char * cmd_str, char **argv, char token)
{
if(cmd_str == NULL){
return -1;
}
int arg_idx = 0;
while(arg_idx < MAX_ARG_NR){
argv[arg_idx] = NULL;
arg_idx++;
}
char *next = cmd_str;
int argc = 0;
while(*next){
//跳过token字符
while(*next == token){
next++;
}
//如果最后一个参数后有空格 例如"cd / "
if(*next ==0){
break;
}
//存入一个字符串地址，保存一个参数项
argv[argc] = next;
//每一个参数确定后，next跳到这个参数的最后面
while(*next && *next != token){
next++;
}
//如果此时还没有解析完，就把这个空格变成'\0'，当做字符串结尾
if(*next){
*next++ = 0;
}
//参数越界，解析失败
if(argc > MAX_ARG_NR){
return -1;
}
//指向下一个参数
argc++;
//让下一个字符串指向0
argv[argc] = 0;
}
return argc;
}
int do_daemon(const char *pathname, char *const *argv)
{
int pid = fork();
if (pid == -1)
return -1;
if (pid == 0) {
/* 子进程执行程序 */
pid = execv(pathname, (char *const *) argv);
/* 如果执行出错就退出 */
if (pid == -1) {
shell_printf("file %s not executable!\n", argv[0]);
exit(pid); /* 退出 */
}
}
/* 父进程直接返回 */
return 0;
}
int execute_cmd(int argc, char **argv)
{
if (argc < 1)
return -1; /* at least 1 arg */
int status = 0;
int daemon = 0;
int arg_idx = 0;
/* scan deamon */
while (arg_idx < argc) {
/* 如果在末尾，并且是单独的'&'符号，才当做后台应用 */
if (!strcmp(argv[arg_idx], "&") && (arg_idx == argc - 1)) {
daemon = 1; /* 是后台进程 */
argc--; /* 参数-1 */
break;
}
arg_idx++;
}
/* 先执行内建命令，再选择磁盘中的命令 */
if (do_buildin_cmd(argc, argv)) {
/* 如果是后台程序，直接运行 */
if (daemon) {
return do_daemon((const char *) argv[0], (char *const *) argv);
}
/* 在末尾添加上结束参数 */
argv[argc] = NULL;
int pid;
int recv_pipe[2]; /* 接收数据的管道 */
int xmit_pipe[2]; /* 传输数据的管道 */
/* 创建发送和接收的管道 */
if (pipe(recv_pipe) < 0) {
shell_printf("%s: create recv pipe failed!\n", APP_NAME);
return -1;
}
if (pipe(xmit_pipe) < 0) {
shell_printf("%s: create xmit pipe failed!\n", APP_NAME);
close(recv_pipe[0]);
close(recv_pipe[1]);
return -1;
}
char buf[513] = {0};
char key;
/* 创建一个进程 */
pid = fork();
if (pid == -1) { /* fork失败 */
shell_printf("%s: fork child failed!\n", APP_NAME);
close(recv_pipe[0]);
close(recv_pipe[1]);
close(xmit_pipe[0]);
close(xmit_pipe[1]);
return -1;
} else if (pid > 0) { /* 父进程 */
/* 关闭不用的管道端口 */
close(recv_pipe[1]);
close(xmit_pipe[0]);
/* 非阻塞 */
ioctl(recv_pipe[0], F_SETFL, O_NONBLOCK);
int rdbytes;
#if DEBUG_LOCAL == 1
shell_printf("%s: parent wait child %d\n", APP_NAME, pid);
#endif
int child_exit = 0;
while (1) {
/* shell程序等待子进程退出 */
int waitret = waitpid(-1, &status, WNOHANG);
/* 没有子进程 */
if (waitret > 0) {
#if DEBUG_LOCAL == 1
shell_printf("%s: pid %d exit with %x.\n", APP_NAME, waitret, status);
#endif
/* 子进程成功退出 */
child_exit = 1;
} else if (waitret < 0) {
/* 此时可能还有管道数据尚未处理完，因此还需要继续处理 */
if (rdbytes > 0) {
rdbytes = -1; /* 并不退出 */
} else {
if (child_exit > 0) {
#if DEBUG_LOCAL == 1
shell_printf("%s: wait child process success!\n", APP_NAME);
#endif
close(recv_pipe[0]); /* 关闭输出读者 */
close(xmit_pipe[1]); /* 关闭输入写者 */
return 0;
} else {
shell_printf("%s: wait child process failed!\n", APP_NAME);
close(recv_pipe[0]); /* 关闭输出读者 */
close(xmit_pipe[1]); /* 关闭输入写者 */
return -1;
}
}
}
/* ----接收管道---- */
memset(buf, 0, 513);
rdbytes = read(recv_pipe[0], buf, 512);
if (rdbytes > 0) {
#if DEBUG_LOCAL == 1
shell_printf("%s: read bytes %d\n", APP_NAME, rdbytes);
#endif
/* 输出子进程传递来的数据 */
shell_printf(buf);
printf(buf);
}
/* ----输入管道---- */
if (!shell_event_poll(&key, pid)) {
int wrret = write(xmit_pipe[1], &key, 1);
if (wrret < 0) {
shell_printf("%s: write key %d to pipe failed!\n", APP_NAME, key);
}
}
}
} else { /* 子进程 */
/* 设置为忽略，避免在初始化过程中被打断 */
trigger(TRIGLSOFT, TRIG_IGN);
/* 关闭不用的管道端口 */
close(recv_pipe[0]);
close(xmit_pipe[1]);
int new_fd;
/* 把输出管道重定向到标准输出资源 */
new_fd = dup2(recv_pipe[1], RES_STDOUTNO);
if (new_fd < 0) {
shell_printf("%s: redirect pipe to stdout failed!\n", APP_NAME);
close(recv_pipe[1]);
close(xmit_pipe[0]);
exit(pid); /* 退出 */
}
close(recv_pipe[1]);
/* 把输入管道重定向到标准输入资源 */
new_fd = dup2(xmit_pipe[0], RES_STDINNO);
if (new_fd < 0) {
shell_printf("%s: redirect pipe to stdin failed!\n", APP_NAME);
close(xmit_pipe[0]);
exit(pid); /* 退出 */
}
close(xmit_pipe[0]);
/* 恢复默认触发 */
trigger(TRIGLSOFT, TRIG_DFL);
/* 子进程执行程序 */
pid = execv((const char *) argv[0], (char *const *) argv);
/* 如果执行出错就退出 */
if (pid == -1) {
shell_printf("file %s not executable!\n", argv[0]);
exit(pid); /* 退出 */
}
}
}
return 0;
}
typedef int (*cmd_func_t) (int argc, char **argv);
int cmd_cls(int argc, char **argv)
{
//printf("cls: argc %d\n", argc);
if ( argc != 1 ) {
shell_printf("cls: no argument support!\n");
return -1;
}
xcons_clear();
return 0;
}
struct gui_argb {
unsigned char blue;
unsigned char green;
unsigned char red;
unsigned char alpha;
};
/**
* cmd_set - 设置终端的属性
*
* option: cursors [0-3] 设置光标形状，例如： set cursors 1
* cursorc rgb值 设置光标颜色，例如： set cursorc 255 192 168
* backc rgb值 设置背景颜色，例如： set backc 0 50 100
* fontc rgb值 设置字体颜色，例如： set fonts 192 168 255
*
* 后续采用配置文件的方式来配置参数
*/
int cmd_set(int argc, char **argv)
{
if (argc < 2) {
/* 打印set命令信息 */
//shell_printf("set: too few arguments!\n");
shell_printf("Usage: set [option]\n");
shell_printf("Option:\n");
shell_printf(" cursors set cursor shape. shape is [0-3].\n");
shell_printf(" cursorc set cursor color. color is red[0-255] green[0-255] blue[0-255].\n");
shell_printf(" backc set background color. color is red[0-255] green[0-255] blue[0-255].\n");
shell_printf(" fontc set font color. color is red[0-255] green[0-255] blue[0-255].\n");
return -1;
}
#if 0
struct gui_argb color;
/* */
if (!strcmp(argv[1], "cursors")) {
if (argc != 3) {
shell_printf("set: try 'set cursors [0-3]' again!\n");
return -1;
}
if (isdigitstr(argv[2])) {
int shape = atoi(argv[2]);
if (shape >= CS_SOLID_FRAME && shape < CS_MAX_NR) {
set_cursor_shape(shape);
} else {
shell_printf("set: cursor shape type error!\n");
return -1;
}
} else {
shell_printf("set: cursor shape arg is invalid!\n");
return -1;
}
} else if (!strcmp(argv[1], "cursorc")) {
if (argc != 5) {
shell_printf("set: try 'set cursorc read[0-255] green[0-255] blue[0-255]' again!\n");
return -1;
}
color.alpha = 255;
if (isdigitstr(argv[2])) {
color.red = (unsigned char) atoi(argv[2]);
} else {
shell_printf("set: cursor color read is invalid!\n");
return -1;
}
if (isdigitstr(argv[3])) {
color.green = (unsigned char) atoi(argv[3]);
} else {
shell_printf("set: cursor color green is invalid!\n");
return -1;
}
if (isdigitstr(argv[4])) {
color.blue = (unsigned char) atoi(argv[4]);
} else {
shell_printf("set: cursor color blue is invalid!\n");
return -1;
}
/* 获取了完整值，设置颜色 */
set_cursor_color(*(GUI_COLOR *)&color);
} else if (!strcmp(argv[1], "backc")) {
if (argc != 5) {
shell_printf("set: try 'set backc read[0-255] green[0-255] blue[0-255]' again!\n");
return -1;
}
color.alpha = 255;
if (isdigitstr(argv[2])) {
color.red = (unsigned char) atoi(argv[2]);
} else {
shell_printf("set: back ground color read is invalid!\n");
return -1;
}
if (isdigitstr(argv[3])) {
color.green = (unsigned char) atoi(argv[3]);
} else {
shell_printf("set: back ground color green is invalid!\n");
return -1;
}
if (isdigitstr(argv[4])) {
color.blue = (unsigned char) atoi(argv[4]);
} else {
shell_printf("set: back ground color blue is invalid!\n");
return -1;
}
/* 获取了完整值，设置颜色 */
con_set_back_color(*(GUI_COLOR *)&color);
/* 刷新屏幕 */
con_flush();
} else if (!strcmp(argv[1], "fontc")) {
if (argc != 5) {
shell_printf("set: try 'set fontc read[0-255] green[0-255] blue[0-255]' again!\n");
return -1;
}
color.alpha = 255;
if (isdigitstr(argv[2])) {
color.red = (unsigned char) atoi(argv[2]);
} else {
shell_printf("set: font color read is invalid!\n");
return -1;
}
if (isdigitstr(argv[3])) {
color.green = (unsigned char) atoi(argv[3]);
} else {
shell_printf("set: font color green is invalid!\n");
return -1;
}
if (isdigitstr(argv[4])) {
color.blue = (unsigned char) atoi(argv[4]);
} else {
shell_printf("set: font color blue is invalid!\n");
return -1;
}
/* 获取了完整值，设置颜色 */
con_set_font_color(*(GUI_COLOR *)&color);
/* 刷新屏幕 */
con_flush();
} else {
shell_printf("set: invalid option!\n");
return -1;
}
#endif
return 0;
}
static const char *proc_print_status[] = {
"READY",
"RUNNING",
"BLOCKED",
"WAITING",
"STOPED",
"ZOMBIE",
"DIED"
};
/**
* cmd_ps - 查看任务
*/
int cmd_ps(int argc, char **argv)
{
tstate_t ts;
int num = 0;
int all = 0;
if (argc > 1) {
char *p = (char *)argv[1];
if (*p == '-') {
p++;
switch (*p)
{
case 'a': /* 显示所有信息 */
all = 1;
break;
case 'h': /* 显示帮助信息 */
shell_printf("Usage: ps [option]\n");
shell_printf("Option:\n");
shell_printf(" -a Print all tasks. Example: ps -a \n");
shell_printf(" -h Get help of ps. Example: ps -h \n");
shell_printf("Note: If no arguments, only print user process.\n");
return 0;
default:
shell_printf("ps: unknown option!\n");
return -1;
}
} else {
shell_printf("ps: unknown argument!\n");
return -1;
}
}
shell_printf(" PID PPID STAT PRO TICKS NAME\n");
while (!tstate(&ts, &num)) {
/* 如果没有全部标志，就只显示用户进程。也就是ppid不为-1的进程 */
if (!all) {
if (ts.ts_ppid == -1)
continue;
}
shell_printf("%6d %6d %8s %6d %10d %s\n",
ts.ts_pid, ts.ts_ppid, proc_print_status[(unsigned char) ts.ts_state], ts.ts_priority,
ts.ts_runticks, ts.ts_name);
}
return 0;
}
int cmd_ver(int argc, char **argv)
{
char buf[SYS_VER_LEN] = {0};
getver(buf, SYS_VER_LEN);
shell_printf("%s\n",buf);
return 0;
}
int cmd_exit(int argc, char **argv)
{
exit_cmd_man();
exit(0);
return 0;
}
int cmd_mem(int argc, char **argv)
{
if (argc > 1) {
shell_printf("free: no arguments support!\n");
return -1;
}
mstate_t ms;
mstate(&ms);
shell_printf(" TOTAL USED FREE\n");
shell_printf("%14dB%14dB%14dB\n", ms.ms_total, ms.ms_used, ms.ms_free);
shell_printf("%14dM%14dM%14dM\n", ms.ms_total / MB, ms.ms_used / MB, ms.ms_free / MB);
return 0;
}
int cmd_date(int argc, char **argv)
{
ktime_t ktm;
ktime(&ktm);
struct tm tm;
ktimeto(&ktm, &tm);
shell_printf("date: %s\n", asctime(&tm));
return 0;
}
static void __ls(char *pathname, int detail)
{
DIR *dir = opendir(pathname);
if(dir == NULL){
printf("opendir failed!\n");
return;
}
rewinddir(dir);
struct dirent *de;
char subpath[MAX_PATH_LEN];
struct stat fstat;
char type;
char attrR, attrW, attrX; /* 读写，执行属性 */
do {
if ((de = readdir(dir)) == NULL) {
break;
}
//printf("de.type:%d", de.type);
if (detail) {
/* 列出详细信息 */
if (de->d_attr & DE_DIR) {
type = 'd';
} else {
type = '-';
}
memset(subpath, 0, MAX_PATH_LEN);
/* 合并路径 */
strcat(subpath, pathname);
strcat(subpath, "/");
strcat(subpath, de->d_name);
memset(&fstat, 0, sizeof(struct stat));
/* 如果获取失败就获取下一个 */
if (stat(subpath, &fstat)) {
continue;
}
if (fstat.st_mode & S_IREAD) {
attrR = 'r';
} else {
attrR = '-';
}
if (fstat.st_mode & S_IWRITE) {
attrW = 'w';
} else {
attrW = '-';
}
if (fstat.st_mode & S_IEXEC) {
attrX = 'x';
} else {
attrX = '-';
}
/* 类型,属性，文件日期，大小，名字 */
shell_printf("%c%c%c%c %04d/%02d/%02d %02d:%02d:%02d %12d %s\n",
type, attrR, attrW, attrX,
FILE_TIME_YEA(fstat.st_mtime>>16),
FILE_TIME_MON(fstat.st_mtime>>16),
FILE_TIME_DAY(fstat.st_mtime>>16),
FILE_TIME_HOU(fstat.st_mtime&0xffff),
FILE_TIME_MIN(fstat.st_mtime&0xffff),
FILE_TIME_SEC(fstat.st_mtime&0xffff),
fstat.st_size, de->d_name);
//printf("type:%x inode:%d name:%s\n", de.type, de.inode, de.name);
} else {
shell_printf("%s ", de->d_name);
}
} while (1);
closedir(dir);
if (!detail) {
shell_printf("\n");
}
}
int cmd_ls(int argc, char **argv)
{
/*int i;
for (i = 0; i < argc; i++) {
shell_printf("%s ",argv[i]);
}*/
/* 只有一个参数 */
if (argc == 1) {
/* 列出当前工作目录所在的文件 */
__ls(".", 0);
} else {
/* */
int arg_path_nr = 0;
int arg_idx = 1; //跳过argv[0]
char *path = NULL;
int detail = 0;
while(arg_idx < argc){
if(argv[arg_idx][0] == '-'){//可选参数
char *option = &argv[arg_idx][1];
/* 有可选参数 */
if (*option) {
/* 列出详细信息 */
if (*option == 'l') {
detail = 1;
} else if (*option == 'h') {
shell_printf("Usage: ls [option]\n");
shell_printf("Option:\n");
shell_printf(" -l Print all infomation about file or directory. Example: ls -l \n");
shell_printf(" -h Get help of ls. Example: ls -h \n");
shell_printf(" [dir] Print [dir] file or directory. Example: ls / \n");
shell_printf("Note: If no arguments, only print name in cwd.\n");
return 0;
}
}
} else {
if(arg_path_nr == 0){
/* 获取路径 */
path = argv[arg_idx];
arg_path_nr = 1;
}else{
shell_printf("ls: only support one path!\n");
return -1;
}
}
arg_idx++;
}
if (path == NULL) { /* 没有路径就列出当前目录 */
__ls(".", detail);
} else { /* 有路径就列出路径 */
__ls(path, detail);
}
}
return 0;
}
int cmd_cd(int argc, char **argv)
{
//printf("pwd: argc %d\n", argc);
if(argc > 2){
shell_printf("cd: only support 1 argument!\n");
return -1;
}
/*int i;
for (i = 0; i < argc; i++) {
shell_printf("%s",argv[i]);
}*/
/* 只有1个参数，是cd，那么不处理 */
if (argc == 1) {
return 0;
}
char *path = argv[1];
if(chdir(path) == -1){
shell_printf("cd: no such directory %s\n",argv[1]);
return -1;
}
/* 设置工作目录缓存 */
memset(cmdman->cwd_cache, 0, MAX_PATH_LEN);
getcwd(cmdman->cwd_cache, MAX_PATH_LEN);
return 0;
}
int cmd_pwd(int argc, char **argv)
{
//printf("pwd: argc %d\n", argc);
if(argc != 1){
shell_printf("pwd: no argument support!\n");
return -1;
}else{
char path[MAX_PATH] = {0};
getcwd(path, MAX_PATH);
shell_printf("%s\n", path);
/*char cwdpath[MAX_PATH_LEN];
if(!getcwd(cwdpath, MAX_PATH_LEN)){
printf("%s\n", cwdpath);
}else{
printf("pwd: get current work directory failed!\n");
}*/
}
return 0;
}
int cmd_copy(int argc, char **argv)
{
if(argc < 3){
shell_printf("cp: command syntax is incorrect.\n");
return -1;
}
if(!strcmp(argv[1], ".") || !strcmp(argv[1], "..")){
shell_printf("cp: src pathnamne can't be . or .. \n");
return -1;
}
if(!strcmp(argv[2], ".") || !strcmp(argv[2], "..")){
shell_printf("cp: dst pathname can't be . or .. \n");
return -1;
}
/* 如果2者相等则不能进行操作 */
if (!strcmp(argv[1], argv[2])) {
shell_printf("cp: source file and dest file must be differern!\n");
return -1;
}
/* 复制逻辑：
1. 打开两个文件，不存在则创建，已经存在则截断
2. 复制数据
3.关闭文件
*/
int fdrd = open(argv[1], O_RDONLY, 0);
if (fdrd == -1) {
shell_printf("cp: open file %s failed!\n", argv[1]);
return -1;
}
/* 如果文件已经存在则截断 */
int fdwr = open(argv[2], O_CREAT | O_WRONLY | O_TRUNC, 0);
if (fdwr == -1) {
shell_printf("cp: open file %s failed!\n", argv[2]);
close(fdrd);
return -1;
}
struct stat fstat;
if (stat(argv[1], &fstat) < 0) {
shell_printf("mv: get file %s state failed!\n", argv[1]);
close(fdrd);
close(fdwr);
return -1;
}
/* 每次操作512字节 */
char *buf = malloc(fstat.st_size);
if (buf == NULL) {
shell_printf("cp: malloc for size %d failed!\n", fstat.st_size);
goto err;
}
char *p = buf;
int size = fstat.st_size;
int readBytes;
/* 每次读取64kb */
int chunk = (size & 0xffff) + 1;
/* 如果chunk为0，就设置块大小 */
if (chunk == 0) {
chunk = 0xffff;
size -= 0xffff;
}
while (size > 0) {
readBytes = read(fdrd, p, chunk);
//printf("read:%d\n", readBytes);
if (readBytes == -1) { /* 应该检查是错误还是结束 */
goto failed;
}
if (write(fdwr, p, readBytes) == -1) {
goto failed;
}
p += chunk;
size -= 0xffff;
chunk = 0xffff;
}
/* 设置模式和原来文件一样 */
chmod(argv[2], fstat.st_mode);
free(buf);
/* 复制结束 */
close(fdrd);
close(fdwr);
return 0;
failed:
shell_printf("cp: transmit data error!\n");
free(buf);
err:
/* 复制结束 */
close(fdrd);
close(fdwr);
return -1;
}
int cmd_move(int argc, char *argv[])
{
if(argc < 3){
shell_printf("mv: command syntax is incorrect.\n");
return -1;
}
if(!strcmp(argv[1], ".") || !strcmp(argv[1], "..")){
shell_printf("mv: src pathnamne can't be . or .. \n");
return -1;
}
if(!strcmp(argv[2], ".") || !strcmp(argv[2], "..")){
shell_printf("mv: dst pathname can't be . or .. \n");
return -1;
}
/* 如果2者相等则不能进行操作 */
if (!strcmp(argv[1], argv[2])) {
shell_printf("mv: source file and dest file must be differern!\n");
return -1;
}
/* 复制逻辑：
1. 打开两个文件，不存在则创建，已经存在则截断
2. 复制数据
3.关闭文件
*/
int fdrd = open(argv[1], O_RDONLY, 0);
if (fdrd == -1) {
shell_printf("mv: open file %s failed!\n", argv[1]);
return -1;
}
/* 如果文件已经存在则截断 */
int fdwr = open(argv[2], O_CREAT | O_WRONLY | O_TRUNC, 0);
if (fdwr == -1) {
shell_printf("mv: open file %s failed!\n", argv[2]);
close(fdrd);
return -1;
}
struct stat fstat;
if (stat(argv[1], &fstat) < 0) {
shell_printf("mv: get file %s state failed!\n", argv[1]);
close(fdrd);
close(fdwr);
return -1;
}
/* 每次操作512字节 */
char *buf = malloc(fstat.st_size);
if (buf == NULL) {
shell_printf("mv: malloc for size %d failed!\n", fstat.st_size);
goto err;
}
char *p = buf;
int size = fstat.st_size;
int readBytes;
/* 每次读取64kb */
int chunk = (size & 0xffff) + 1;
if (chunk == 0) {
chunk = 0xffff;
size -= 0xffff;
}
while (size > 0) {
readBytes = read(fdrd, p, chunk);
//printf("read:%d\n", readBytes);
if (readBytes == -1) { /* 应该检查是错误还是结束 */
goto failed;
}
if (write(fdwr, p, readBytes) == -1) {
goto failed;
}
p += chunk;
size -= 0xffff;
chunk = 0xffff;
}
/* 设置模式和原来文件一样 */
chmod(argv[2], fstat.st_mode);
free(buf);
/* 复制结束 */
close(fdrd);
close(fdwr);
/* 移动后删除源文件 */
if(remove(argv[1]) == 0){
//shell_printf("mv: delete source file %s success.\n", argv[1]);
}else{
shell_printf("mv: delete source file %s faild!\n", argv[1]);
/* 删除复制后的文件 */
remove(argv[2]);
}
return 0;
failed:
printf("mv: transmit data error!\n");
free(buf);
err:
/* 复制结束 */
close(fdrd);
close(fdwr);
return -1;
}
int cmd_rename(int argc, char *argv[])
{
if(argc < 3){
shell_printf("rename: command syntax is incorrect.\n");
return -1;
}
if(!strcmp(argv[1], ".") || !strcmp(argv[1], "..")){
shell_printf("rename: pathnamne can't be . or .. \n");
return -1;
}
if(!strcmp(argv[2], ".") || !strcmp(argv[2], "..")){
shell_printf("rename: new name can't be . or .. \n");
return -1;
}
if(!rename(argv[1], argv[2])){
//shell_printf("rename: %s to %s sucess!\n", argv[1], argv[2]);
return 0;
}else{
shell_printf("rename: %s to %s faild!\n", argv[1], argv[2]);
return -1;
}
return 0;
}
int cmd_mkdir(int argc, char *argv[])
{
int ret = -1;
if(argc != 2){
shell_printf("mkdir: no argument support!\n");
}else{
if(mkdir(argv[1], 0) == 0){
//shell_printf("mkdir: create a dir %s success.\n", argv[1]);
ret = 0;
}else{
shell_printf("mkdir: create directory %s faild!\n", argv[1]);
}
}
return ret;
}
int cmd_rmdir(int argc, char *argv[])
{
int ret = -1;
if(argc != 2){
shell_printf("mkdir: no argument support!\n");
}else{
if(rmdir(argv[1]) == 0){
//shell_printf("rmdir: remove %s success.\n", argv[1]);
ret = 0;
}else{
shell_printf("rmdir: remove %s faild!\n", argv[1]);
}
}
return ret;
}
int cmd_rm(int argc, char *argv[])
{
int ret = -1;
if(argc != 2){
shell_printf("rm: no argument support!\n");
}else{
if(remove(argv[1]) == 0){
//shell_printf("rm: delete %s success.\n", argv[1]);
ret = 0;
}else{
shell_printf("rm: delete %s faild!\n", argv[1]);
}
}
return ret;
}
/*
touch: create a file
*/
static int cmd_touch(int argc, char *argv[])
{
//printf("argc: %d\n", argc);
if(argc == 1){ //只有一个参数，自己的名字，退出
shell_printf("touch: please input filename!\n");
return 0;
}
if(argc > 2){
shell_printf("touch: only support 2 argument!\n");
return -1;
}
const char *path = (const char *)argv[1];
int fd = open(path, O_CREAT | O_RDWR, 0);
if(fd == -1){
shell_printf("touch: fd %d error\n", fd);
return 0;
}
close(fd);
return 0;
}
/**
* cmd_trig - trig命令
* 1.命令格式：
* trig [参数] [进程号]
* 2.命令功能：
* 发送指定的信号到相应进程。不指定型号将发送SIGTERM（15）终止指定进程。
* 3.命令参数：
* -l 信号，若果不加信号的编号参数，则使用“-l”参数会列出全部的信号名称
* -s 指定发送信号
*
* 4.举例：
* trig 10 // 默认方式杀死进程10
* trig -9 10 // 用SIGtrig杀死进程10
* trig -SIGtrig 10 // 用SIGtrig杀死进程10
* trig -trig 10 // 用SIGtrig杀死进程10
* trig -l // 列出所有信号
* trig -l trig // 列出trig对应的信号值
* trig -l SIGtrig // 列出trig对应的信号值
* 就实现以上命令，足矣。
*
*/
#define MAX_SUPPORT_SIG_NR 10
/* 信号的字符串列表，用于查找信号对应的信号值 */
char *trigger_table[MAX_SUPPORT_SIG_NR][2] = {
{"NULL", "NULL"}, /* 信号对应的值 */
{"TRIGHW", "HW"}, /* 信号对应的值 */
{"TRIGDBG", "DBG"}, /* 信号对应的值 */
{"TRIGPAUSE", "PAU"}, /* 信号对应的值 */
{"TRIGRESUM", "RESUM"}, /* 信号对应的值 */
{"TRIGHSOFT", "HSOFT"}, /* 信号对应的值 */
{"TRIGLSOFT", "LSOFT"}, /* 信号对应的值 */
{"TRIGUSR0", "USR0"}, /* 信号对应的值 */
{"TRIGUSR1", "USR1"}, /* 信号对应的值 */
{"TRIGALARM", "ALARM"}, /* 信号对应的值 */
};
/**
* find_trigger_in_table - 在表中查找信号
* @name：信号名称
*
*
* 找到返回信号值，没找到返回0
*/
int find_trigger_in_table(char *name)
{
int idx;
int trigno = -1;
for (idx = 1; idx < MAX_SUPPORT_SIG_NR; idx++) {
/* 字符串相同就找到 */
if (!strcmp(trigger_table[idx][0], name) || !strcmp(trigger_table[idx][1], name)) {
trigno = idx;
break;
}
}
/* 找到就返回信号 */
if (trigno != -1) {
return trigno;
}
return 0;
}
int cmd_trig(int argc, char **argv)
{
if(argc < 2){
shell_printf("trig: too few arguments.\n");
return -1;
}
//默认 argv[1]是进程的pid
int trigno = TRIGLSOFT; /* 默认是TERM信号，如果没有指定信号的话 */
int pid = -1;
char *p;
/* 不列出信号 */
bool list_trigger = false;
/* 是否有可选参数 */
bool has_option = false;
bool pid_negative = false; /* pid为负数 */
/* 找出pid和trigno */
int idx = 1;
/* 扫描查看是否有可选参数 */
while (idx < argc) {
/* 有可选参数，并且是在第一个参数的位置 */
if (argv[idx][0] == '-' && argv[idx][1] != '\0' && idx == 1) {
has_option = true;
p = (char *)(argv[idx] + 1);
/* 查看是什么选项 */
if (*p == 'l' && p[1] == '\0') { /* 是 -l选项 */
list_trigger = true; /* 需要列出信号 */
} else {
/* 是纯数字，即 -12 */
if (isdigitstr((const char *)p)) {
/* 转换成数值 */
trigno = atoi(p);
if (1 > trigno || trigno >= MAX_SUPPORT_SIG_NR) {
shell_printf("trig: trigger %s number not support!\n", trigno);
return -1;
}
} else { /* 不是是纯数字，即 -trig，但也可能找不到 */
trigno = find_trigger_in_table(p);
/* 找到信号 */
if (trigno <= 0) {
shell_printf("trig: trigger %s not found!\n", p);
return -1;
}
}
}
} else if (argv[idx][0] != '\0' && idx == 1) { /* 还是第一个参数，是没有选项的状态 */
p = (char *)(argv[idx]);
/* 此时就是进程pid */
/* 是纯数字，即 -12 */
if (*p == '-') { /* 可能是负数 */
pid_negative = true;
p++;
}
if (isdigitstr((const char *)p)) {
/* 转换成数值 */
pid = atoi(p);
/* 如果是负的，就要进行负数处理 */
if (pid_negative)
pid = -pid;
} else {
shell_printf("trig: process id %s error!\n", p);
return -1;
}
} else if (argv[idx][0] != '\0' && idx == 2) { /* 第二个参数 */
p = (char *)(argv[idx]);
/*
如果是纯数字，就是进程id。
如果是字符串，就是信号值
*/
if (list_trigger) {
/* 是列出信号，就直接解析信号值 */
trigno = find_trigger_in_table(p);
/* 找到信号 */
if (trigno <= 0) {
shell_printf("trig: trigger %s not found!\n", p);
return -1;
}
} else {
/* 是纯数字，即 -12 */
if (*p == '-') { /* 可能是负数 */
pid_negative = true;
p++;
}
if (isdigitstr((const char *)p)) {
/* 转换成数值 */
pid = atoi(p);
/* 如果是负的，就要进行负数处理 */
if (pid_negative)
pid = -pid;
} else {
shell_printf("trig: process id %s must be number!\n", p);
return -1;
}
}
}
idx++;
}
if (has_option) {
/* 是列出信号 */
if (list_trigger) {
if (argc == 2) {
/* trig -l # 列出所有 */
//printf("list all signum\n");
shell_printf(" 1) TRIGHW 2) TRIGDBG 3) TRIGPAUSE 4) TRIGRESUM 5) TRIGHSOFT "\
" 6) TRIGLSOFT 7) TRIGUSR0 8) TRIGUSR1 9) TRIGALARM\n");
} else {
/* 单独列出信号值 */
shell_printf("%d\n", trigno);
}
} else { /* 不是列出信号，就是执行信号 */
if (argc == 2) {
//printf("send trigger %d no pid\n", trigno);
shell_printf("trig: please order process id!\n");
return -1;
} else {
//printf("send trigger %d to pid %d\n", trigno, pid);
if (triggeron(trigno, pid) == -1) {
shell_printf("trig: pid %d failed.\n", pid);
return -1;
}
}
}
} else {
//printf("send trigger %d tp pid %d\n", trigno, pid);
if (triggeron(trigno, pid) == -1) {
shell_printf("trig: pid %d failed.\n", pid);
return -1;
}
}
return 0;
}
int cmd_help(int argc, char **argv)
{
if(argc != 1){
shell_printf("help: no argument support!\n");
return -1;
}
shell_printf(" cls clean screen.\n"\
" exit exit shell.\n"\
" mem print memory info.\n"\
" ps print tasks.\n"\
" date show date.\n"\
" ls list files.\n"\
" cd change current work directory.\n"\
" pwd print current work directory.\n"\
" trigger active process trigger.\n"\
" ver show os version.\n");
return 0;
}
/* buildin cmd struct */
struct buildin_cmd {
char *name;
cmd_func_t cmd_func;
};
/* cmd table */
struct buildin_cmd buildin_cmd_table[] = {
{"cls", cmd_cls},
{"ps", cmd_ps},
{"help", cmd_help},
{"ver", cmd_ver},
{"exit", cmd_exit},
{"mem", cmd_mem},
{"date", cmd_date},
{"ls", cmd_ls},
{"cd", cmd_cd},
{"pwd", cmd_pwd},
{"trig", cmd_trig},
{"cp", cmd_copy},
{"mv", cmd_move},
{"rn", cmd_rename},
{"mkdir", cmd_mkdir},
{"rmdir", cmd_rmdir},
{"rm", cmd_rm},
{"touch", cmd_touch},
};
int do_buildin_cmd(int cmd_argc, char **cmd_argv)
{
int cmd_nr = ARRAY_SIZE(buildin_cmd_table);
struct buildin_cmd *cmd_ptr;
int i = 0;
/* scan cmd table */
for (i = 0; i < cmd_nr; i++) {
cmd_ptr = &buildin_cmd_table[i];
if (!strcmp(cmd_ptr->name, cmd_argv[0])) {
if (cmd_ptr->cmd_func(cmd_argc, cmd_argv)) {
//shell_printf("do_buildin_cmd: %s failed!\n", cmd_argv[0]);
}
return 0;
}
}
/* not a buildin cmd */
return -1;
}
void print_prompt()
{
shell_printf("%s>", cmdman->cwd_cache);
}
void print_cmdline()
{
shell_printf(cmdman->cmd_line);
}
char *cmd_argv[MAX_ARG_NR] = {0};
void cmd_loop()
{
while (1) {
print_prompt();
memset(cmdman->cmd_line, 0, CMD_LINE_LEN);
if (shell_readline() < 0)
break;
/* 如果什么也没有输入，就回到开始处 */
if(cmdman->cmd_line[0] == 0)
continue;
/* 处理数据 */
//printf("cmd: %s\n", cmd_line);
/* 记录历史缓冲区 */
//cmd_buf_insert();
int argnum = -1;
argnum = cmd_parse(cmdman->cmd_line, cmd_argv, ' ');
if(argnum == -1){
shell_printf("%s: num of arguments exceed %d\n", APP_NAME, MAX_ARG_NR);
continue;
}
#if 0
/* 打印参数 */
int i;
for (i = 0; i < argnum; i++) {
printf("arg[%d]=%s\n", i, cmd_argv[i]);
}
#endif
if (execute_cmd(argnum, cmd_argv)) {
//shell_printf("%s: execute cmd %s falied!\n", APP_NAME, cmd_argv[0]);
}
}
}
char *shell_environment[3] = {
"/bin",
"/sbin",
NULL
};
int init_cmd_man()
{
cmdman = malloc(SIZE_CMD_MAN);
if (cmdman == NULL)
return -1;
memset(cmdman, 0, SIZE_CMD_MAN);
memset(cmdman->cwd_cache, 0, MAX_PATH_LEN);
getcwd(cmdman->cwd_cache, MAX_PATH_LEN);
chdir("/");
environ = shell_environment;
return 0;
}
void exit_cmd_man()
{
free(cmdman);
}
|
NightfallDM/xbook2
|
src/gui/lowlevel/keyboard.c
|
<gh_stars>0
#include <string.h>
#include <stdio.h>
#include <xbook/driver.h>
#include <sys/ioctl.h>
#include <xbook/kmalloc.h>
#include <xbook/vmarea.h>
/// 程序本地头文件
#include <gui/keyboard.h>
#include <gui/event.h>
#include <sys/input.h>
#include <gui/console/console.h>
#ifndef GUI_KEYBOARD_DEVICE_NAME
#define GUI_KEYBOARD_DEVICE_NAME "kbd"
#endif
static int kbd_handle = 0;
/*
static unsigned char caps_lock_value = 0;
static unsigned char num_lock_value = 0;
*/
gui_keyboard_t gui_keyboard = {0};
/* 特殊按键：
ALT+TAB 切换窗口 */
/* 需要记录一些按键的状态，尤其是组合按键的时候就很有必要了。 */
int __process_special_key(int keycode, int press)
{
if (keycode == KEY_E || keycode == KEY_e) {
/* alt + tab */
if (gui_keyboard.key_modify & GUI_KMOD_ALT_L) {
if (press) {
#if DEBUG_LOCAL == 1
/* switch window */
printf("[keyboard] [alt + tab] switch window.\n");
#endif
}
return 1;
}
}
return 0;
}
/* Keyboard mapping table */
static const unsigned char map_table[] = {
KEY_ESCAPE, KEY_ESCAPE,
KEY_BACKSPACE, KEY_BACKSPACE,
KEY_TAB, KEY_TAB,
/* 0x00, KEY_BACK_TAB,*/
KEY_PAUSE, KEY_PAUSE,
KEY_PRINT, KEY_PRINT,
KEY_SYSREQ, KEY_SYSREQ,
KEY_CLEAR, KEY_CLEAR,
KEY_INSERT, KEY_INSERT,
KEY_ENTER, KEY_ENTER,
KEY_DELETE, KEY_DELETE,
KEY_KP_ENTER, KEY_ENTER,
KEY_LEFT, KEY_LEFT,
KEY_RIGHT, KEY_RIGHT,
KEY_UP, KEY_UP,
KEY_DOWN, KEY_DOWN,
KEY_HOME, KEY_HOME,
KEY_END, KEY_END,
KEY_PAGEUP, KEY_PAGEUP,
KEY_PAGEDOWN, KEY_PAGEDOWN,
KEY_KP0, KEY_INSERT,
KEY_KP_PERIOD, KEY_DELETE,
KEY_KP1, KEY_END,
KEY_KP2, KEY_DOWN,
KEY_KP3, KEY_PAGEDOWN,
KEY_KP4, KEY_LEFT,
KEY_KP5, KEY_5,
KEY_KP6, KEY_RIGHT,
KEY_KP7, KEY_HOME,
KEY_KP8, KEY_UP,
KEY_KP9, KEY_PAGEUP,
KEY_SPACE, KEY_SPACE, /* */
KEY_EXCLAIM, KEY_EXCLAIM, /* ! */
KEY_QUOTEDBL, KEY_QUOTEDBL, /* " */
KEY_HASH, KEY_HASH, /* # */
KEY_DOLLAR, KEY_DOLLAR, /* $ */
KEY_PERSENT, KEY_PERSENT, /* % */
KEY_AMPERSAND, KEY_AMPERSAND, /* & */
KEY_LEFTPAREN, KEY_LEFTPAREN, /* ( */
KEY_RIGHTPAREN, KEY_RIGHTPAREN, /* ) */
KEY_ASTERISK, KEY_ASTERISK, /* * */
KEY_KP_MULTIPLY, KEY_ASTERISK, /* * */
KEY_PLUS, KEY_PLUS, /* + */
KEY_KP_PLUS, KEY_PLUS, /* + */
KEY_COMMA, KEY_COMMA, /* , */
KEY_MINUS, KEY_MINUS, /* - */
KEY_KP_MINUS, KEY_MINUS, /* - */
KEY_PERIOD, KEY_PERIOD, /* . */
KEY_SLASH, KEY_SLASH, /* / */
KEY_KP_DIVIDE, KEY_SLASH, /* / */
KEY_0, KEY_0, /* 0 */
KEY_1, KEY_1, /* 1 */
KEY_2, KEY_2, /* 2 */
KEY_3, KEY_3, /* 3 */
KEY_4, KEY_4, /* 4 */
KEY_5, KEY_5, /* 5 */
KEY_6, KEY_6, /* 6 */
KEY_7, KEY_7, /* 7 */
KEY_8, KEY_8, /* 8 */
KEY_9, KEY_9, /* 9 */
KEY_KP0, KEY_0, /* 0 */
KEY_KP1, KEY_1, /* 1 */
KEY_KP2, KEY_2, /* 2 */
KEY_KP3, KEY_3, /* 3 */
KEY_KP4, KEY_4, /* 4 */
KEY_KP5, KEY_5, /* 5 */
KEY_KP6, KEY_6, /* 6 */
KEY_KP7, KEY_7, /* 7 */
KEY_KP8, KEY_8, /* 8 */
KEY_KP9, KEY_9, /* 9 */
KEY_COLON, KEY_COLON, /* : */
KEY_SEMICOLON, KEY_SEMICOLON, /* ; */
KEY_LESS, KEY_LESS, /* < */
KEY_EQUALS, KEY_EQUALS, /* = */
KEY_GREATER, KEY_GREATER, /* > */
KEY_QUESTION, KEY_QUESTION, /* ? */
KEY_AT, KEY_AT, /* @ */
KEY_A, KEY_A, /* A */
KEY_B, KEY_B, /* B */
KEY_C, KEY_C, /* C */
KEY_D, KEY_D, /* D */
KEY_E, KEY_E, /* E */
KEY_F, KEY_F, /* F */
KEY_G, KEY_G, /* G */
KEY_H, KEY_H, /* H */
KEY_I, KEY_I, /* I */
KEY_J, KEY_J, /* J */
KEY_K, KEY_K, /* K */
KEY_L, KEY_L, /* L */
KEY_M, KEY_M, /* M */
KEY_N, KEY_N, /* N */
KEY_O, KEY_O, /* O */
KEY_P, KEY_P, /* P */
KEY_Q, KEY_Q, /* Q */
KEY_R, KEY_R, /* R */
KEY_S, KEY_S, /* S */
KEY_T, KEY_T, /* T */
KEY_U, KEY_U, /* U */
KEY_V, KEY_V, /* V */
KEY_W, KEY_W, /* W */
KEY_X, KEY_X, /* X */
KEY_Y, KEY_Y, /* Y */
KEY_Z, KEY_Z, /* Z */
KEY_a, KEY_a, /* A */
KEY_b, KEY_b, /* B */
KEY_c, KEY_c, /* C */
KEY_d, KEY_d, /* D */
KEY_e, KEY_e, /* E */
KEY_f, KEY_f, /* F */
KEY_g, KEY_g, /* G */
KEY_h, KEY_h, /* H */
KEY_i, KEY_i, /* I */
KEY_j, KEY_j, /* J */
KEY_k, KEY_k, /* K */
KEY_l, KEY_l, /* L */
KEY_m, KEY_m, /* M */
KEY_n, KEY_n, /* N */
KEY_o, KEY_o, /* O */
KEY_p, KEY_p, /* P */
KEY_q, KEY_q, /* Q */
KEY_r, KEY_r, /* R */
KEY_s, KEY_s, /* S */
KEY_t, KEY_t, /* T */
KEY_u, KEY_u, /* U */
KEY_v, KEY_v, /* V */
KEY_w, KEY_w, /* W */
KEY_x, KEY_x, /* X */
KEY_y, KEY_y, /* Y */
KEY_z, KEY_z, /* Z */
KEY_LEFTSQUAREBRACKET, KEY_LEFTSQUAREBRACKET, /* [ */
KEY_BACKSLASH, KEY_BACKSLASH, /* \ */
KEY_RIGHTSQUAREBRACKET, KEY_RIGHTSQUAREBRACKET, /* ] */
KEY_CARET, KEY_CARET, /* ^ */
KEY_UNDERSCRE, KEY_UNDERSCRE, /* _ */
KEY_BACKQUOTE, KEY_BACKQUOTE, /* ` */
KEY_LEFTBRACKET, KEY_LEFTBRACKET, /* { */
KEY_VERTICAL, KEY_VERTICAL, /* | */
KEY_RIGHTBRACKET, KEY_RIGHTBRACKET, /* } */
KEY_TILDE, KEY_TILDE, /* ~ */
KEY_QUOTE, KEY_QUOTE, /* ' */
KEY_F1, KEY_F1,
KEY_F2, KEY_F2,
KEY_F3, KEY_F3,
KEY_F4, KEY_F4,
KEY_F5, KEY_F5,
KEY_F6, KEY_F6,
KEY_F7, KEY_F7,
KEY_F8, KEY_F8,
KEY_F9, KEY_F9,
KEY_F10, KEY_F10,
KEY_F11, KEY_F11,
KEY_F12, KEY_F12,
KEY_LSHIFT, KEY_LSHIFT,
KEY_RSHIFT, KEY_RCTRL,
KEY_LCTRL, KEY_LCTRL,
KEY_RCTRL, KEY_RCTRL,
KEY_LALT, KEY_LALT,
KEY_RALT, KEY_RALT,
KEY_LMETA, KEY_LMETA,
KEY_RMETA, KEY_RMETA,
KEY_CAPSLOCK, KEY_CAPSLOCK,
KEY_NUMLOCK, KEY_NUMLOCK,
KEY_SCROLLOCK, KEY_SCROLLOCK,
0xFF, KEY_UNKNOWN
};
/**
* 键值转换
*/
static unsigned char code_switch(int code)
{
unsigned char key_value = '?';
unsigned int i = 0;
for ( i = 0; i < sizeof(map_table); i += 2 ) {
if (map_table[i] == code) {
key_value = map_table[i + 1]; // 返回转换后的键值
break;
}
}
return key_value;
}
static int gui_key_pressed(int keycode)
{
#if DEBUG_LOCAL == 1
printf("[keyboard ] key %x->%c pressed.\n", keycode, keycode);
#endif
/* 处理修饰按键 */
if (keycode == KEY_NUMLOCK) {
/* 如果数字锁按键已经置位，那么就清除 */
if (gui_keyboard.key_modify & GUI_KMOD_NUM) {
gui_keyboard.key_modify &= ~GUI_KMOD_NUM;
} else { /* 没有则添加数字锁 */
gui_keyboard.key_modify |= GUI_KMOD_NUM;
}
}
if (keycode == KEY_CAPSLOCK) {
/* 如果大写锁按键已经置位，那么就清除 */
if (gui_keyboard.key_modify & GUI_KMOD_CAPS) {
gui_keyboard.key_modify &= ~GUI_KMOD_CAPS;
} else { /* 没有则添加数字锁 */
gui_keyboard.key_modify |= GUI_KMOD_CAPS;
}
}
/* 处理CTRL, ALT, SHIFT*/
switch (keycode) {
case KEY_LSHIFT: /* left shift */
gui_keyboard.key_modify |= GUI_KMOD_SHIFT_L;
break;
case KEY_RSHIFT: /* right shift */
gui_keyboard.key_modify |= GUI_KMOD_SHIFT_R;
break;
case KEY_LALT: /* left alt */
gui_keyboard.key_modify |= GUI_KMOD_ALT_L;
break;
case KEY_RALT: /* right alt */
gui_keyboard.key_modify |= GUI_KMOD_ALT_R;
break;
case KEY_LCTRL: /* left ctl */
gui_keyboard.key_modify |= GUI_KMOD_CTRL_L;
break;
case KEY_RCTRL: /* right ctl */
gui_keyboard.key_modify |= GUI_KMOD_CTRL_R;
break;
default:
break;
}
/* 如果是一些特殊按键，就做预处理 */
if (__process_special_key(keycode, 1))
return -1;
/* 使用按键,keydown, keycode, modify */
/*gui_keyboard.keyevent.state = 0;
gui_keyboard.keyevent.code = code_switch(keycode);
gui_keyboard.keyevent.modify = gui_keyboard.key_modify;
return 0;*/
gui_event e;
e.type = GUI_EVENT_KEY;
e.key.code = code_switch(keycode);
e.key.modify = gui_keyboard.key_modify;
e.key.state = GUI_PRESSED;
return gui_event_add(&e);
}
static int gui_key_released(int keycode)
{
#if DEBUG_LOCAL == 1
printf("[keyboard ] key %x->%c released.\n", keycode, keycode);
#endif
/* 处理CTRL, ALT, SHIFT*/
switch (keycode) {
case KEY_LSHIFT: /* left shift */
gui_keyboard.key_modify &= ~GUI_KMOD_SHIFT_L;
break;
case KEY_RSHIFT: /* right shift */
gui_keyboard.key_modify &= ~GUI_KMOD_SHIFT_R;
break;
case KEY_LALT: /* left alt */
gui_keyboard.key_modify &= ~GUI_KMOD_ALT_L;
break;
case KEY_RALT: /* right alt */
gui_keyboard.key_modify &= ~GUI_KMOD_ALT_R;
break;
case KEY_LCTRL: /* left ctl */
gui_keyboard.key_modify &= ~GUI_KMOD_CTRL_L;
break;
case KEY_RCTRL: /* right ctl */
gui_keyboard.key_modify &= ~GUI_KMOD_CTRL_R;
break;
default:
break;
}
/* 如果是一些特殊按键，就做预处理 */
if (__process_special_key(keycode, 0))
return -1;
/* 使用按键,keyup, keycode, modify */
/*gui_keyboard.keyevent.state = 1;
gui_keyboard.keyevent.code = code_switch(keycode);
gui_keyboard.keyevent.modify = gui_keyboard.key_modify;
*/
gui_event e;
e.type = GUI_EVENT_KEY;
e.key.code = code_switch(keycode);
e.key.modify = gui_keyboard.key_modify;
e.key.state = GUI_RELEASED;
return gui_event_add(&e);
}
static int keyboard_open(void)
{
kbd_handle = device_open( GUI_KEYBOARD_DEVICE_NAME, 0);
if ( kbd_handle < 0 )
return -1;
int ledstate;
device_devctl( kbd_handle, EVENIO_GETLED,(unsigned long) &ledstate);
if ( ledstate&0x01 )
gui_keyboard.ledstate |= GUI_KMOD_NUM;
if ( ledstate & 0x02 )
gui_keyboard.ledstate |= GUI_KMOD_CAPS;
return 0;
}
static int keyboard_close(void)
{
return device_close(kbd_handle);
}
static int keyboard_read()
{
struct input_event event;
int ret = 0;
memset(&event, 0, sizeof(event));
ret = device_read(kbd_handle, &event, sizeof(event), 0);
if ( ret < 0 )
return -1;
switch (event.type)
{
case EV_KEY:
/* 图形服务先处理按键，然后再根据按键值传输给当前活动的窗口 */
if ( (event.value) > 0 ) { /* key presssed */
//printf("input key. %d\n", event.value);
//res_write(1, 0, "key\n", 4);
return gui_key_pressed(event.code);
} else { /* key released */
return gui_key_released(event.code);
}
default:
break;
}
return -1;
}
int gui_init_keyboard()
{
memset(&gui_keyboard, 0, sizeof(gui_keyboard));
gui_keyboard.ledstate = 0;
gui_keyboard.open = keyboard_open;
gui_keyboard.close = keyboard_close;
gui_keyboard.read = keyboard_read;
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/types.h
|
#ifndef _TYPES_H_
#define _TYPES_H_
#define MACHINE_WIDTH 32
#define TRUE 1
#define FALSE 0
typedef unsigned char bool_t;
typedef unsigned short uint16_t;
typedef short int16_t;
typedef char int8_t;
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
typedef int uint32_t;
struct Page_e {
uint32_t attr: 12;
uint32_t addr: 20;
}__attribute__((packed));
typedef struct Page_e pde_t;
typedef struct Page_e pte_t;
#endif //_TYPES_H_
|
NightfallDM/xbook2
|
library/xlibc/stdio/asprintf.c
|
<reponame>NightfallDM/xbook2<gh_stars>1-10
/*
* libc/stdio/asprintf.c
*/
#include <stdio.h>
int asprintf(char ** s, const char * fmt, ...)
{
va_list ap;
int ret;
va_start(ap, fmt);
ret = vasprintf(s, fmt, ap);
va_end(ap);
return ret;
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/tss.c
|
#include <arch/tss.h>
#include <arch/segment.h>
#include <arch/registers.h>
#include <arch/pmem.h>
#include <string.h>
#include <xbook/task.h>
/* tss对象 */
tss_t tss;
tss_t *get_tss()
{
return &tss;
}
void update_tss_info(unsigned long task_addr)
{
// 更新tss.esp0的值为任务的内核栈顶
tss.esp0 = (unsigned long)(task_addr + TASK_KSTACK_SIZE);
}
void init_tss()
{
memset(&tss, 0, sizeof(tss));
// 内核的内核栈
tss.esp0 = KERNEL_STATCK_TOP;
// 内核栈选择子
tss.ss0 = KERNEL_DATA_SEL;
tss.iobase = sizeof(tss);
// 加载tss register
load_tr(KERNEL_TSS_SEL);
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/instruction.h
|
#ifndef _ARCH_INSTRUCTION_H
#define _ARCH_INSTRUCTION_H
void __invlpg_asm(unsigned int addr);
#define __invlpg_inline(vaddr) asm volatile ("invlpg %0"::"m" (vaddr):"memory")
/* __invlpg_asm or __invlpg_inline */
#define flush_tbl(vaddr) __invlpg_inline(vaddr)
void __cpuid(unsigned int id_eax, unsigned int *eax,
unsigned int *ebx, unsigned int *ecx, unsigned int *edx);
void __cpu_lazy();
void __cpu_idle(void);
char __xchg8(char *ptr, char value);
short __xchg16(short *ptr, short value);
int __xchg32(int *ptr, int value);
/* x86特性 */
#define X86_FEATURE_XMM2 (0*32+26) /* Streaming SIMD Extensions-2 */
/*
* Alternative instructions for different CPU types or capabilities.
*
* This allows to use optimized instructions even on generic binary
* kernels.
*
* length of oldinstr must be longer or equal the length of newinstr
* It can be padded with nops as needed.
*
* For non barrier like inlines please define new variants
* without volatile and memory clobber.
*/
#define alternative(oldinstr, newinstr, feature) \
asm volatile ("661:\n\t" oldinstr "\n662:\n" \
".section .altinstructions,\"a\"\n" \
" .align 4\n" \
" .long 661b\n" /* label */ \
" .long 663f\n" /* new instruction */ \
" .byte %c0\n" /* feature bit */ \
" .byte 662b-661b\n" /* sourcelen */ \
" .byte 664f-663f\n" /* replacementlen */ \
".previous\n" \
".section .altinstr_replacement,\"ax\"\n" \
"663:\n\t" newinstr "\n664:\n" /* replacement */\
".previous" :: "i" (feature) : "memory")
#define mb() alternative("lock; addl $0,0(%%esp)", "mfence", X86_FEATURE_XMM2)
#define rmb() alternative("lock; addl $0,0(%%esp)", "lfence", X86_FEATURE_XMM2)
#ifdef CONFIG_X86_OOSTORE
/* Actually there are no OOO store capable CPUs for now that do SSE,
but make it already an possibility. */
#define wmb() Alternative("lock; addl $0,0(%%esp)", "sfence", X86_FEATURE_XMM)
#else
#define wmb() __asm__ __volatile__ ("": : :"memory")
#endif
/* The "volatile" is due to gcc bugs */
#define barrier() __asm__ __volatile__("": : :"memory")
#define xchg(ptr,v) ((__typeof__(*(ptr)))__xchg((unsigned int) \
(v),(ptr),sizeof(*(ptr))))
/**
* __Xchg: 交换一个内存地址和一个数值的值
* @x: 数值
* @ptr: 内存指针
* @size: 地址值的字节大小
*
* 返回交换前地址中的值
*/
static inline unsigned int __xchg(unsigned int x,
volatile void * ptr, int size)
{
int old;
switch (size) {
case 1:
old = __xchg8((char *)ptr, x);
break;
case 2:
old = __xchg16((short *)ptr, x);
break;
case 4:
old = __xchg32((int *)ptr, x);
break;
}
return old;
}
#endif /* _ARCH_INSTRUCTION_H */
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/mp.c
|
/*
* MultiProcessor support for xbook2
* Search memory for MP description structures.
* */
// reference to xv6-public,thanks to them. :-)
#include<arch/types.h>
#include<arch/mp.h>
void
mpinit(void){
}
|
NightfallDM/xbook2
|
src/gui/graph/rect.c
|
#include <gui/screen.h>
#include <gui/rect.h>
/* 封装screen */
void gui_draw_rect_fill(int x, int y, int width, int height, GUI_COLOR color)
{
gui_screen.output_rect_fill(x, y, x + width - 1, y + height - 1, color);
}
/* 封装screen */
void gui_draw_rect(int x, int y, int width, int height, GUI_COLOR color)
{
/* left */
gui_screen.output_vline(x, y, y + height - 1, color);
/* right */
gui_screen.output_vline(x + width - 1, y, y + height - 1, color);
/* top */
gui_screen.output_hline(x, x + width - 1, y, color);
/* bottom */
gui_screen.output_hline(x, x + width - 1, y + height - 1, color);
}
|
NightfallDM/xbook2
|
library/xlibc/math/fabs.c
|
/*
File: fabs.c
Contains: For abs(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT fabs(M_FLOAT x) {
return (x < 0 ? -x : x);
}
|
NightfallDM/xbook2
|
library/xlibc/math/sqrt.c
|
/*
File: sqrt.c
Contains: For sqrt(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT sqrt(float x) {
/* It's not important */
if (fabs(x) < EPSILON)
return (0.0);
float x2 = x * 0.5F, y = x;
long i = *(long*) & y;
i = 0x5f3759df - (i >> 1);
y = *(float*) & i;
y *= (1.5F - (x2 * y * y));
y *= (1.5F - (x2 * y * y));
return (1.0 / y);
}
|
NightfallDM/xbook2
|
src/include/xbook/sem.h
|
#ifndef _XBOOK_SEM_H
#define _XBOOK_SEM_H
/* 用户可以使用的信号量 */
#include "semaphore.h"
/* 最多有多少个信号量 */
#define SEM_MAX_NR 128
/* 信号量的最大值, int 型数据最大值 */
#define SEM_MAX_VALUE (2147483647)
#define SEM_NAME_LEN 24
/* 信号量结构 */
typedef struct {
unsigned short id; /* 信号量id */
semaphore_t sema; /* 内核信号量，用户信号量是对内核信号量的封装 */
char name[SEM_NAME_LEN]; /* 名字 */
} sem_t;
sem_t *sem_alloc(char *name, int value);
int sem_free(sem_t *shm);
int sem_get(char *name, int value, int semflg);
int sem_put(int semid);
int sem_down(int semid, int semflg);
int sem_up(int semid);
void init_sem();
int sys_sem_get(char *name, int value, int semflg);
int sys_sem_put(int semid);
int sys_sem_down(int semid, int semflg);
int sys_sem_up(int semid);
#endif /* _XBOOK_SEM_H */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/types.h
|
<gh_stars>0
#ifndef _SYS_TYPES_H
#define _SYS_TYPES_H
#include <stddef.h>
#include <stdint.h>
#include <types.h>
#define DIR_NAME_LEN 256
#define DE_RDONLY 0x01 /* read only */
#define DE_HIDDEN 0x02 /* hidden */
#define DE_SYSTEM 0x04 /* system */
#define DE_DIR 0x10 /* dir */
#define DE_ARCHIVE 0x20 /* archive */
typedef struct dirent {
size_t d_size; /* 目录项大小 */
uint32_t d_time; /* 时间 */
uint32_t d_date; /* 日期 */
mode_t d_attr; /* 属性 */
char d_name[DIR_NAME_LEN]; /* 名字 */
} dirent_t;
typedef long ssize_t;
#endif /* _SYS_TYPES_H */
|
NightfallDM/xbook2
|
src/fs/fsal/fsalif.c
|
#include <fsal/fsal.h>
#include <fsal/dir.h>
#include <fsal/fstype.h>
#include <stddef.h>
#include <xbook/diskman.h>
#include <xbook/debug.h>
static int __open(void *path, int flags)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
//srvprint("open path:%s\n", new_path);
/* 执行打开 */
return fsal->open(new_path, flags);
}
static int __close(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->close(idx);
}
static int __ftruncate(int idx, off_t offset)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->ftruncate(idx, offset);
}
static int __read(int idx, void *buf, size_t size)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->read(idx, buf, size);
}
static int __write(int idx, void *buf, size_t size)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->write(idx, buf, size);
}
static int __lseek(int idx, off_t off, int whence)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->lseek(idx, off, whence);
}
static int __fsync(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->fsync(idx);
}
static int __opendir(char *path)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0) {
printk("path %s switch error!\n", path);
return -1;
}
/* 执行打开 */
return fsal->opendir(new_path);
}
static int __closedir(int idx)
{
if (ISBAD_FSAL_DIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_dir_t *pdir = FSAL_I2D(idx);
fsal_t *fsal = pdir->fsal;
if (fsal == NULL)
return -1;
return fsal->closedir(idx);
}
static int __readdir(int idx, void *buf)
{
if (ISBAD_FSAL_DIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_dir_t *pdir = FSAL_I2D(idx);
fsal_t *fsal = pdir->fsal;
if (fsal == NULL)
return -1;
return fsal->readdir(idx, buf);
}
static int __mkdir(char *path, mode_t mode)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->mkdir(new_path, mode);
}
static int __unlink(char *path)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->unlink(new_path);
}
static int __rename(char *old_path, char *new_path)
{
if (old_path == NULL || new_path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(old_path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", old_path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", old_path);
return -1;
}
/* 转换路径 */
char old_path2[MAX_PATH] = {0};
if (fsal_path_switch(fpath, old_path2, old_path) < 0)
return -1;
char new_path2[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path2, new_path) < 0)
return -1;
/* 执行打开 */
return fsal->rename(old_path2, new_path2);
}
static int __state(char *path, void *buf)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->state(new_path, buf);
}
static int __fstat(int idx, void *buf)
{
if (ISBAD_FSAL_DIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_dir_t *pdir = FSAL_I2D(idx);
fsal_t *fsal = pdir->fsal;
if (fsal == NULL)
return -1;
return fsal->fstat(idx, buf);
}
static int __chmod(char *path, mode_t mode)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->chmod(new_path, mode);
}
static int __fchmod(int idx, mode_t mode)
{
if (ISBAD_FSAL_DIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_dir_t *pdir = FSAL_I2D(idx);
fsal_t *fsal = pdir->fsal;
if (fsal == NULL)
return -1;
return fsal->fchmod(idx, mode);
}
static int __utime(char *path, time_t actime, time_t modtime)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->utime(new_path, actime, modtime);
}
static int __feof(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->feof(idx);
}
static int __ferror(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->ferror(idx);
}
static off_t __ftell(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->ftell(idx);
}
static size_t __fsize(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->fsize(idx);
}
static int __rewind(int idx)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->rewind(idx);
}
static int __rewinddir(int idx)
{
if (ISBAD_FSAL_DIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_dir_t *fp = FSAL_I2D(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->rewinddir(idx);
}
static int __rmdir(char *path)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->rmdir(new_path);
}
static int __chdir(char *path)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->chdir(new_path);
}
static int __ioctl(int idx, int cmd, unsigned long arg)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->ioctl(idx, cmd, arg);
}
static int __fcntl(int idx, int cmd, long arg)
{
if (ISBAD_FSAL_FIDX(idx))
return -1;
/* 查找对应的文件系统 */
fsal_file_t *fp = FSAL_I2F(idx);
fsal_t *fsal = fp->fsal;
if (fsal == NULL)
return -1;
return fsal->fcntl(idx, cmd, arg);
}
/* 挂载文件系统 */
int __mount(
char *source, /* 需要挂载的资源 */
char *target, /* 挂载到的目标位置 */
char *fstype, /* 文件系统类型 */
unsigned long mountflags /* 挂载标志 */
) {
if (source == NULL || target == NULL || fstype == NULL)
return -1;
/* 查找要挂载的资源 */
if (disk_res_find((char *) source) < 0) {
printk("[%s] %s: source %s not found!\n", FS_MODEL_NAME, __func__, source);
return -1;
}
/* 查看目标位置是否可用 */
if (fsal_path_find((void *) target, 0) != NULL) {
printk("[%s] %s: target %s had mounted!\n", FS_MODEL_NAME, __func__, target);
return -1;
}
/* 查找文件系统类型 */
fsal_t *fsal = fstype_find((char *)fstype);
if (fsal == NULL) {
printk("[%s] %s: filesystem type %s not found!\n", FS_MODEL_NAME, __func__, fstype);
return -1;
}
printk("[%s] %s: will mount fs source %s target %s fstype %s.\n",
FS_MODEL_NAME, __func__, source, target, fstype);
/* 执行对应类型文件系统的挂载 */
int retval = fsal->mount(source, target, fstype, mountflags);
if (retval < 0) {
printk("[%s] %s: mount fs source %s target %s fstype %s failed!\n",
FS_MODEL_NAME, __func__, source, target, fstype);
return -1;
}
return 0;
}
static int __unmount(char *path, unsigned long flags)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find(path, 0);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, path) < 0)
return -1;
/* 执行打开 */
return fsal->unmount(new_path, flags);
}
/* 创建文件系统 */
int __mkfs(
char *source, /* 需要创建FS的设备 */
char *fstype, /* 文件系统类型 */
unsigned long flags /* 标志 */
) {
if (source == NULL || fstype == NULL)
return -1;
/* 查找要挂载的资源 */
if (disk_res_find(source) < 0) {
printk("[%s] %s: source %s not found!\n", FS_MODEL_NAME, __func__, source);
return -1;
}
/* 查找文件系统类型 */
fsal_t *fsal = fstype_find((char *)fstype);
if (fsal == NULL) {
printk("[%s] %s: filesystem type %s not found!\n", FS_MODEL_NAME, __func__, fstype);
return -1;
}
printk("[%s] %s: will make fs on source %s fstype %s.\n",
FS_MODEL_NAME, __func__, source, fstype);
/* 执行对应类型文件系统的挂载 */
int retval = fsal->mkfs(source, fstype, flags);
if (retval < 0) {
printk("[%s] %s: make fs source %s fstype %s failed!\n",
FS_MODEL_NAME, __func__, source, fstype);
return -1;
}
return 0;
}
static int __access(const char *path, int mode)
{
if (path == NULL)
return -1;
fsal_path_t *fpath = fsal_path_find((void *) path, 1);
if (fpath == NULL) {
printk("path %s not found!\n", path);
return -1;
}
/* 查找对应的文件系统 */
fsal_t *fsal = fpath->fsal;
if (fsal == NULL) {
printk("path %s fsal error!\n", path);
return -1;
}
/* 转换路径 */
char new_path[MAX_PATH] = {0};
if (fsal_path_switch(fpath, new_path, (char *) path) < 0)
return -1;
/* 执行打开 */
return fsal->access(new_path, mode);
}
fsal_t fsif = {
.mkfs = __mkfs,
.mount = __mount,
.unmount = __unmount,
.open = __open,
.close = __close,
.read = __read,
.write = __write,
.lseek = __lseek,
.opendir = __opendir,
.closedir = __closedir,
.readdir = __readdir,
.mkdir = __mkdir,
.unlink = __unlink,
.rename = __rename,
.ftruncate = __ftruncate,
.fsync = __fsync,
.state = __state,
.chmod = __chmod,
.fchmod = __fchmod,
.utime = __utime,
.feof = __feof,
.ferror = __ferror,
.ftell = __ftell,
.fsize = __fsize,
.rewind = __rewind,
.rewinddir = __rewinddir,
.rmdir = __rmdir,
.chdir = __chdir,
.ioctl = __ioctl,
.fcntl = __fcntl,
.fstat = __fstat,
.access = __access,
};
|
NightfallDM/xbook2
|
src/include/gui/console/console.h
|
<gh_stars>0
#ifndef __TERMINAL_CONSOLE_H__
#define __TERMINAL_CONSOLE_H__
#include <stddef.h>
#include <gui/color.h>
#include <xbook/fifoio.h>
/* 80*25*20 = 10kb */
#define CON_FRAME_NR 20
#define CON_CHAR_WIDTH 8
#define CON_CHAR_HEIGHT 16
#define CON_CLOUMNS 80
#define CON_ROWS 25
#define CON_BUFFER_SIZE (CON_CLOUMNS * CON_ROWS * CON_FRAME_NR)
#define CON_SCREEN_WIDTH (CON_CHAR_WIDTH * CON_CLOUMNS)
#define CON_SCREEN_HEIGHT (CON_CHAR_HEIGHT * CON_ROWS)
#define CON_SCREEN_BG_COLOR COLOR_BLACK
#define CON_SCREEN_FONT_COLOR COLOR_WHITE
#define CON_MOUSE_COLOR COLOR_BLUE
/* ANSC */
#define CON_CODEPAGE 0
#define CON_SCROLL_UP -1
#define CON_SCROLL_DOWN 1
#define CON_RDPIPE_BUF_LEN 1024
typedef struct {
char *buffer; /* 字符缓冲区 */
char *cur_pos; /* 当前缓冲区的起始位置 */
size_t buflen; /* 缓冲区长度：最大长度 */
short width; /* 窗口宽度 */
short height; /* 窗口高度 */
short columns; /* 窗口列数 */
short rows; /* 窗口行数 */
char char_width; /* 字符宽度 */
char char_height; /* 字符高度 */
int columns_width; /* 总列宽度 */
int rows_height; /* 总行高度 */
int codepage; /* 代码页 */
GUI_COLOR background_color; /* 背景颜色 */
GUI_COLOR font_color; /* 字体颜色 */
GUI_COLOR mouse_color; /* 鼠标颜色 */
fifo_io_t *keyfifo;
/// 函数指针
void (*outc) (char);
void (*outs) (char *);
void (*clear) ();
void (*clear_area) (int, int, unsigned int, unsigned int);
} con_screen_t;
extern con_screen_t gui_con_screen;
int gui_init_console();
void scroll_screen(int dir, int lines, int cursorx, int cursory);
int cprintf(const char *fmt, ...);
void con_set_chars(char ch, int counts, int x, int y);
void print_prompt();
void con_put_str(char *str);
void con_ouput_visual(char ch, int x, int y);
void con_region_chars(int x0, int y0, int x1, int y1);
void con_flush();
void con_flush2(int mx0, int my0, int mx1, int my1);
void con_flush_area(int x0, int y0, int x1, int y1);
void con_get_chars(char *buf, int counts, int x, int y);
void con_set_back_color(GUI_COLOR color);
void con_set_font_color(GUI_COLOR color);
static inline void con_get_char(char *ch, int x, int y)
{
if (gui_con_screen.cur_pos + y * gui_con_screen.columns + x > gui_con_screen.buffer + gui_con_screen.buflen)
return;
*ch = gui_con_screen.cur_pos[y * gui_con_screen.columns + x];
}
static inline void con_set_char(char ch, int x, int y)
{
if (gui_con_screen.cur_pos + y * gui_con_screen.columns + x > gui_con_screen.buffer + gui_con_screen.buflen)
return;
//保存字符
gui_con_screen.cur_pos[y * gui_con_screen.columns + x] = ch;
}
int con_event_poll(char *buf, int pid);
int con_event_loop(char *buf, int count);
int con_loop();
int sys_xcon_get(int *key, int flags);
void sys_xcon_clear();
int sys_xcon_put(void *buf, int len);
#endif /* __TERMINAL_CONSOLE_H__ */
|
NightfallDM/xbook2
|
user/tests/trig_test.c
|
<reponame>NightfallDM/xbook2<filename>user/tests/trig_test.c<gh_stars>0
#include "test.h"
#include <sys/trigger.h>
void trig_handler(int trig)
{
printf("trig: %d handled!\n", trig);
}
void alarm_handler(int trig)
{
printf("alarm: handled\n");
}
int trig_test(int argc, char *argv[])
{
printf("----trig test----\n");
/* 忽略信号 */
//trigger(TRIGLSOFT, TRIG_IGN);
trig_action_t ta, oldta;
ta.handler = trig_handler;
ta.mask = 0;
ta.flags = TA_ONCSHOT;
trigger_action(TRIGLSOFT, &ta, &oldta);
printf("old ta: %x\n", oldta.handler);
triggeron(TRIGLSOFT, getpid());
trigset_t set;
trigaddset(&set, TRIGLSOFT);
trigprocmask(TRIG_BLOCK, &set, NULL);
trigger(TRIGALARM, alarm_handler);
alarm(3);
sleep(5);
trigprocmask(TRIG_UNBLOCK, &set, NULL);
while (1)
{
usleep(500*1000);
trigpending(&set);
printf("trig set: %x\n", set);
}
return 0;
}
|
NightfallDM/xbook2
|
library/xlibc/stdio/rename.c
|
<filename>library/xlibc/stdio/rename.c
/*
* libc/stdio/rename.c
*/
#include <stdio.h>
#include <unistd.h>
int rename(const char * old, const char * new)
{
return _rename(old, new);
}
|
NightfallDM/xbook2
|
library/xlibc/math/acos.c
|
<reponame>NightfallDM/xbook2
/*
File: acos.c
Contains: For arccos(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT acos(M_FLOAT x) {
return atan2(sqrt(1.0 - x * x), x);
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/time.c
|
#include <arch/time.h>
void __udelay(int usec)
{
int i, j;
for (i = 0; i < 10 * usec; i++);
for (j = 0; j < 100; j++);
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/kfile.h
|
<filename>library/xlibc/include/sys/kfile.h
#ifndef _SYS_KFILE_H
#define _SYS_KFILE_H
typedef struct {
unsigned char *file;
unsigned long size;
} kfile_t;
#endif /* _SYS_KFILE_H */
|
NightfallDM/xbook2
|
library/xlibc/include/time.h
|
#ifndef __XLIBC_TIME_H__
#define __XLIBC_TIME_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <types.h>
#include <sys/time.h>
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long __tm_gmtoff;
const char * __tm_zone;
};
clock_t clock(void);
time_t time(time_t * t);
time_t mktime(struct tm * tm);
double difftime (time_t, time_t);
struct tm * gmtime(const time_t * t);
struct tm * localtime(const time_t * t);
char * asctime(const struct tm * tm);
char * ctime(const time_t * t);
size_t strftime(char * s, size_t max, const char * fmt, const struct tm * t);
int __secs_to_tm(long long t, struct tm * tm);
long long __tm_to_secs(const struct tm * tm);
/* ktime to tm */
int ktimeto(ktime_t *ktm, struct tm *tm);
#ifdef __cplusplus
}
#endif
#endif /* __XLIBC_TIME_H__ */
|
NightfallDM/xbook2
|
src/include/xbook/kmalloc.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_KMALLOC_H
#define _XBOOK_KMALLOC_H
#include "memcache.h"
#endif /* _XBOOK_KMALLOC_H */
|
NightfallDM/xbook2
|
library/xlibc/include/arch/xchg.h
|
#ifndef _LIB_ARCH_XCHG_H
#define _LIB_ARCH_XCHG_H
#include <arch/config.h>
#define test_and_set __test_and_set
#endif /* _LIB_ARCH_XCHG_H */
|
NightfallDM/xbook2
|
library/xlibc/math/round.c
|
/*
File: round.c
Contains: For rounding
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT round(M_FLOAT x) {
if (x > 0)
return (int)(x + 0.5);
return (int)(x - 0.5);
}
|
NightfallDM/xbook2
|
src/fs/fs.c
|
<reponame>NightfallDM/xbook2<gh_stars>0
#include <xbook/fs.h>
#include <xbook/diskman.h>
#include <xbook/debug.h>
#include <fsal/fsal.h>
#include <fsal/fstype.h>
#include <stddef.h>
#include <unistd.h>
#include <dirent.h>
int init_fs()
{
if (init_disk_driver() < 0)
panic("[fs]: init disk driver failed!\n");
/* 初始化接口部分 */
if (init_fstype() < 0) {
panic("init fstype failed, service stopped!\n");
}
/* 初始化文件系统抽象层 */
if (init_fsal() < 0) {
panic("init fsal failed, service stopped!\n");
}
#if 0
/* test */
int fd = sys_open("/root/kfs", O_CREAT | O_RDWR, 0);
if (fd < 0)
return -1;
int fd1 = sys_open("/root/kfs", O_CREAT | O_RDWR, 0);
if (fd1 < 0)
return -1;
printk("fd %d fd1 %d.\n", fd, fd1);
int wr = sys_write(fd, "hello", 5);
printk("write file:%d %d bytes.\n", fd, wr);
sys_close(fd);
fd = sys_open("/root/kfs", O_CREAT | O_RDWR, 0);
if (fd < 0)
return -1;
char buf[10];
int rd = sys_read(fd, buf, 10);
printk("read file:%d %d bytes.\n", fd, rd);
sys_close(fd);
printk("data:%s\n", buf);
dir_t dir = sys_opendir("/");
if (dir < 0) {
printk("open dir failed!\n");
}
dirent_t dirent;
do {
if (sys_readdir(dir, &dirent) < 0)
break;
printk("dir: %s\n", dirent.d_name);
} while (1);
sys_closedir(dir);
#endif
return 0;
}
|
NightfallDM/xbook2
|
library/xlibc/include/exit.h
|
<reponame>NightfallDM/xbook2<filename>library/xlibc/include/exit.h
#ifndef __XLIBC_EXIT_H__
#define __XLIBC_EXIT_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/proc.h>
enum {
EXIT_SUCCESS = 0,
EXIT_FAILURE = 1,
};
void abort(void);
#define exit _exit
#ifdef __cplusplus
}
#endif
#endif /* __XLIBC_EXIT_H__ */
|
NightfallDM/xbook2
|
library/xlibc/include/setjmp.h
|
<gh_stars>0
#ifndef _XLIBC_SETJMP_H
#define _XLIBC_SETJMP_H
/*my_setjmp.h*/
/*
* c程序不允许函数的嵌套定义。
* 所以除了返回调用哪个函数的表达式外，c语言没有提供其他将控制权转移到一个函数之外的简单方法。
* c语言使用库函数实现非本地控制转移。
* jmp_buf类型，标量数据对象类型。
* longjmp函数，用来实现非本地控制转移。
* setjmp宏，把当前调用的上下文信息存储到一个jmp_buf类型的数据对象中，并在你想把控制权传递给相应的
* longjmp调用的地方做标记。
* 两个潜在危险:包含setjmp宏达表达式；在执行setjmp的函数中声明的动态存储空间。
*
* 一般电脑有一定数量的寄存器，在对表达式进行求值的时候，寄存器用来保存中间结果。
* 但在计算一个非常复杂的表达式时，这些寄存器可能不够用，这时用户就会迫使代码生成器把中间结果存储在动态存储空间中。
* c标准规定把包含setjmp的表达式作为子表达式使用。为了排除某些可能把中间结果存储在setjmp未知的动态存储空间中的表达式。
* 所以可编写switch(setjmp(buf)...,if(2<setjmp(buf))...if(!setjmp(buf))...setjmp(buf).
* 不能可靠把setjmp的值赋给其他的变量，如n=setjmp(buf).标准未定义。
*
* 宏setjmp的调用应该只出现在下面某个上下文环境中。
* 1,一个选择或者循环语句的整个控制表达式。
* 2,关系运算符或者等于运算符的其中一个操作数，另一个操数是一个整值常量表达式，它的结果表达式是一个选择或循环语言的整个控制表达式。
* 3,一元操作符!的操作数，它的结果表达式是一个选择或循环语句的整个控制表达式。
* 4,是一个表达式语句(可能强制转换为void类型)的整个表达式。
* 函数longjmp使用相应的jmp_buf参数来恢复程序的相同调用中宏setjmp的最近一次调用保存的环境。
* 因为它能绕过常规的函数调用和返回机制，所以函数longjmp可以在中断/信号和其他相关的函数的上下文环境中正确地执行。
* 函数longjmp不能让宏setjmp返回0，如果val为0，这宏setjmp返回1.
*
* 建议以以下标准方式使用:
* 1,把每个对setjmp的调用分离到一个独立的小函数中。那样就会使出现动态声明的数据对象被longjmp调用恢复的情况减少到最少。
* 2,在一个switch语句的控制表达式中调用setjmp。
* 3,在switch语句的case 0(process)中调用的函数中执行所以实际的过程。
* 4,通过执行longjmp(1)调用，在任意位置报告错误并且重新启动process。
* 5,通过执行longjmp(2)调用，在任意位置报告错误并终止process。
*
* jmp_buf是一个数组类型。
* 在信号处理器的内部调用longjmp，会出警告。
*
* 唯一可靠的实现方式是汇编来实现。
*
*/
#ifndef MY_SETJMP_H_
#define MY_SETJMP_H_
/*
#ifndef _YVALS_H_
#include "yvals.h"
#endif
*/
#define _ILONG 1
#define _CSIGN 1
#define _MBMAX 2
#define _JBFP 1
#define _JBMOV 60
#define _JBOFF 4
#define _NSETJMP 17
#define _SIGABRT 6
#define _SIGMAX 32
typedef int jmp_buf[_NSETJMP];
int setjmp(jmp_buf env);
//void longjmp(jmpbuf, int);
void longjmp(jmp_buf env, int val);
#endif
#endif /* _XLIBC_SETJMP_H */
|
NightfallDM/xbook2
|
src/include/xbook/vmm.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_VMM_H
#define _XBOOK_VMM_H
#include <arch/page.h>
#define USER_VMM_SIZE PAGE_OFFSET
#define USER_STACK_TOP USER_VMM_SIZE
#define VMM_UNMAPPED_BASE (USER_VMM_SIZE / 2)
/* 进程空间虚拟内存管理 */
typedef struct vmm {
void *page_storage; /* 虚拟内存管理的结构 */
void *vmspace_head; /* 虚拟空间头,设置成空类型，使用时转换类型 */
unsigned long code_start, code_end; /* 代码空间范围 */
unsigned long data_start, data_end; /* 数据空间范围 */
unsigned long heap_start, heap_end; /* 堆空间范围 */
unsigned long map_start, map_end; /* 映射空间范围 */
unsigned long stack_start, stack_end; /* 栈空间范围 */
} vmm_t;
/* 物理内存信息 */
typedef struct {
unsigned long ms_total; /* 物理内存总大小 */
unsigned long ms_free; /* 物理内存空闲大小 */
unsigned long ms_used; /* 物理内存已使用大小 */
} mstate_t;
int sys_mstate(mstate_t *ms);
#define vmm_alloc() (vmm_t *)kmalloc(sizeof(vmm_t))
#define vmm_free(vmm) kfree(vmm)
void vmm_init(vmm_t *vmm);
int vmm_exit(vmm_t *vmm);
int vmm_release_space(vmm_t *vmm);
int vmm_unmap_space(vmm_t *vmm);
int vmm_unmap_space_maparea(vmm_t *vmm);
void dump_vmm(vmm_t *vmm);
void vmm_active(vmm_t *vmm);
#endif /* _XBOOK_VMM_H */
|
NightfallDM/xbook2
|
src/driver/disk/ahci.c
|
#include <xbook/debug.h>
#include <xbook/kernel.h>
#include <const.h>
#include <math.h>
#include <xbook/softirq.h>
#include <xbook/vine.h>
#include <xbook/driver.h>
#include <string.h>
#include <xbook/clock.h>
#include <arch/io.h>
#include <arch/interrupt.h>
#include <arch/cpu.h>
#include <arch/ioremap.h>
#include <arch/memory.h>
#include <xbook/kmalloc.h>
#include <xbook/pci.h>
#include <xbook/mutexlock.h>
#include <xbook/cpu.h>
#include <xbook/bitops.h>
#include <xbook/dma.h>
#include <xbook/task.h>
#include <assert.h>
#include <sys/ioctl.h>
#include <stdio.h>
/* 配置开始 */
/* #define DEBUG_AHCI */
/* 配置结束 */
#define DRV_NAME "ahci-disk"
#define DRV_VERSION "0.1"
#define DEV_NAME "sata"
/* AHCI设备最多的磁盘数量 */
#define MAX_AHCI_DISK_NR 4
/* AHCI磁盘数在BIOS阶段可以储存到这个地址，直接从里面或取就可以了 */
#define AHCI_DISK_NR_ADDR (KERN_VADDR + 0x0475)
typedef enum
{
FIS_TYPE_REG_H2D = 0x27, // Register FIS - host to device
FIS_TYPE_REG_D2H = 0x34, // Register FIS - device to host
FIS_TYPE_DMA_ACT = 0x39, // DMA activate FIS - device to host
FIS_TYPE_DMA_SETUP = 0x41, // DMA setup FIS - bidirectional
FIS_TYPE_DATA = 0x46, // Data FIS - bidirectional
FIS_TYPE_BIST = 0x58, // BIST activate FIS - bidirectional
FIS_TYPE_PIO_SETUP = 0x5F, // PIO setup FIS - device to host
FIS_TYPE_DEV_BITS = 0xA1, // Set device bits FIS - device to host
} FIS_TYPE;
struct fis_reg_host_to_device {
uint8_t fis_type;
uint8_t pmport:4;
uint8_t reserved0:3;
uint8_t c:1;
uint8_t command;
uint8_t feature_l;
uint8_t lba0;
uint8_t lba1;
uint8_t lba2;
uint8_t device;
uint8_t lba3;
uint8_t lba4;
uint8_t lba5;
uint8_t feature_h;
uint8_t count_l;
uint8_t count_h;
uint8_t icc;
uint8_t control;
uint8_t reserved1[4];
}__attribute__ ((packed));
struct fis_reg_device_to_host {
uint8_t fis_type;
uint8_t pmport:4;
uint8_t reserved0:2;
uint8_t interrupt:1;
uint8_t reserved1:1;
uint8_t status;
uint8_t error;
uint8_t lba0;
uint8_t lba1;
uint8_t lba2;
uint8_t device;
uint8_t lba3;
uint8_t lba4;
uint8_t lba5;
uint8_t reserved2;
uint8_t count_l;
uint8_t count_h;
uint8_t reserved3[2];
uint8_t reserved4[4];
}__attribute__ ((packed));
struct fis_data {
uint8_t fis_type;
uint8_t pmport:4;
uint8_t reserved0:4;
uint8_t reserved1[2];
uint32_t data[1];
}__attribute__ ((packed));
struct fis_pio_setup {
uint8_t fis_type;
uint8_t pmport:4;
uint8_t reserved0:1;
uint8_t direction:1;
uint8_t interrupt:1;
uint8_t reserved1:1;
uint8_t status;
uint8_t error;
uint8_t lba0;
uint8_t lba1;
uint8_t lba2;
uint8_t device;
uint8_t lba3;
uint8_t lba4;
uint8_t lba5;
uint8_t reserved2;
uint8_t count_l;
uint8_t count_h;
uint8_t reserved3;
uint8_t e_status;
uint16_t transfer_count;
uint8_t reserved4[2];
}__attribute__ ((packed));
struct fis_dma_setup {
uint8_t fis_type;
uint8_t pmport:4;
uint8_t reserved0:1;
uint8_t direction:1;
uint8_t interrupt:1;
uint8_t auto_activate:1;
uint8_t reserved1[2];
uint64_t dma_buffer_id;
uint32_t reserved2;
uint32_t dma_buffer_offset;
uint32_t transfer_count;
uint32_t reserved3;
}__attribute__ ((packed));
struct fis_dev_bits {
volatile uint8_t fis_type;
volatile uint8_t pmport:4;
volatile uint8_t reserved0:2;
volatile uint8_t interrupt:1;
volatile uint8_t notification:1;
volatile uint8_t status;
volatile uint8_t error;
volatile uint32_t protocol;
}__attribute__ ((packed));
struct hba_port {
volatile uint32_t command_list_base_l;
volatile uint32_t command_list_base_h;
volatile uint32_t fis_base_l;
volatile uint32_t fis_base_h;
volatile uint32_t interrupt_status;
volatile uint32_t interrupt_enable;
volatile uint32_t command;
volatile uint32_t reserved0;
volatile uint32_t task_file_data;
volatile uint32_t signature;
volatile uint32_t sata_status;
volatile uint32_t sata_control;
volatile uint32_t sata_error;
volatile uint32_t sata_active;
volatile uint32_t command_issue;
volatile uint32_t sata_notification;
volatile uint32_t fis_based_switch_control;
volatile uint32_t reserved1[11];
volatile uint32_t vendor[4];
}__attribute__ ((packed));
struct hba_memory {
volatile uint32_t capability;
volatile uint32_t global_host_control;
volatile uint32_t interrupt_status;
volatile uint32_t port_implemented;
volatile uint32_t version;
volatile uint32_t ccc_control;
volatile uint32_t ccc_ports;
volatile uint32_t em_location;
volatile uint32_t em_control;
volatile uint32_t ext_capabilities;
volatile uint32_t bohc;
volatile uint8_t reserved[0xA0 - 0x2C];
volatile uint8_t vendor[0x100 - 0xA0];
volatile struct hba_port ports[1];
}__attribute__ ((packed));
struct hba_received_fis {
volatile struct fis_dma_setup fis_ds;
volatile uint8_t pad0[4];
volatile struct fis_pio_setup fis_ps;
volatile uint8_t pad1[12];
volatile struct fis_reg_device_to_host fis_r;
volatile uint8_t pad2[4];
volatile struct fis_dev_bits fis_sdb;
volatile uint8_t ufis[64];
volatile uint8_t reserved[0x100 - 0xA0];
}__attribute__ ((packed));
struct hba_command_header {
uint8_t fis_length:5;
uint8_t atapi:1;
uint8_t write:1;
uint8_t prefetchable:1;
uint8_t reset:1;
uint8_t bist:1;
uint8_t clear_busy_upon_r_ok:1;
uint8_t reserved0:1;
uint8_t pmport:4;
uint16_t prdt_len;
volatile uint32_t prdb_count;
uint32_t command_table_base_l;
uint32_t command_table_base_h;
uint32_t reserved1[4];
}__attribute__ ((packed));
struct hba_prdt_entry {
uint32_t data_base_l;
uint32_t data_base_h;
uint32_t reserved0;
uint32_t byte_count:22;
uint32_t reserved1:9;
uint32_t interrupt_on_complete:1;
}__attribute__ ((packed));
struct hba_command_table {
uint8_t command_fis[64];
uint8_t acmd[16];
uint8_t reserved[48];
struct hba_prdt_entry prdt_entries[1];
}__attribute__ ((packed));
#define HBA_COMMAND_HEADER_NUM 32
struct ata_identify {
uint16_t ata_device;
uint16_t dont_care[48];
uint16_t cap0;
uint16_t cap1;
uint16_t obs[2];
uint16_t free_fall;
uint16_t dont_care_2[8];
uint16_t dma_mode0;
uint16_t pio_modes;
uint16_t dont_care_3[4];
uint16_t additional_supported;
uint16_t rsv1[6];
uint16_t serial_ata_cap0;
uint16_t rsv2;
uint16_t serial_ata_features;
uint16_t serial_ata_features_enabled;
uint16_t maj_ver;
uint16_t min_ver;
uint16_t features0;
uint16_t features1;
uint16_t features2;
uint16_t features3;
uint16_t features4;
uint16_t features5;
uint16_t udma_modes;
uint16_t dont_care_4[11];
uint64_t lba48_addressable_sectors;
uint16_t wqewqe[2];
uint16_t ss_1;
uint16_t rrrrr[4];
uint32_t ss_2;
/* ...and more */
};
#define HBA_PxCMD_ST (1 << 0)
#define HBA_PxCMD_CR (1 << 15)
#define HBA_PxCMD_FR (1 << 14)
#define HBA_PxCMD_FRE (1 << 4)
#define HBA_GHC_AHCI_ENABLE (1 << 31)
#define HBA_GHC_INTERRUPT_ENABLE (1 << 1)
#define HBA_GHC_RESET (1 << 0)
#define ATA_CMD_IDENTIFY 0xEC
#define ATA_DEV_BUSY 0x80
#define ATA_DEV_DRQ 0x08
#define ATA_DEV_ERR 0x01
#define ATA_CMD_READ_DMA_EX 0x25
#define ATA_CMD_WRITE_DMA_EX 0x35
#define PRDT_MAX_COUNT 0x1000
#define PRDT_MAX_ENTRIES 65535
#define ATA_TFD_TIMEOUT 1000000
#define AHCI_CMD_TIMEOUT 1000000
#define ATA_SECTOR_SIZE 512
#define AHCI_DEFAULT_INT 0
#define SATA_SIG_ATA 0x00000101 // SATA drive
#define SATA_SIG_ATAPI 0xEB140101 // SATAPI drive
#define SATA_SIG_SEMB 0xC33C0101 // Enclosure management bridge
#define SATA_SIG_PM 0x96690101 // Port multiplier
/* AHCI device type */
#define AHCI_DEV_NULL 0
#define AHCI_DEV_SATA 1
#define AHCI_DEV_SEMB 2
#define AHCI_DEV_PM 3
#define AHCI_DEV_SATAPI 4
#define HBA_PORT_IPM_ACTIVE 1
#define HBA_PORT_DET_PRESENT 3
typedef struct _device_extension {
device_object_t *device_object; /* 设备对象 */
unsigned int size; // Size in Sectors.
/* 状态信息 */
unsigned int read_sectors; // 读取了多少扇区
unsigned int write_sectors; // 写入了多少扇区
uint32_t type;
int idx;
mutexlock_t lock;
void *fis_virt, *clb_virt;
struct dma_region dma_clb, dma_fis;
void *ch[HBA_COMMAND_HEADER_NUM];
struct dma_region ch_dmas[HBA_COMMAND_HEADER_NUM];
struct ata_identify identify;
uint32_t slots;
int created;
} device_extension_t;
/* 声明驱动全局变量 */
static pci_device_t *ahci_pci;
static int ahci_int = 0;
static struct hba_memory *hba_mem;
static device_extension_t *ports[32];
static int ahci_next_device = 0;
pci_device_t *get_ahci_pci (void)
{
pci_device_t *ahci = pci_locate_class(0x1, 0x6);
if(!ahci) ahci = pci_locate_device(0x8086, 0x8c03);
if(!ahci) ahci = pci_locate_device(0x8086, 0x2922);
if(!ahci)
return NULL;
#ifdef DEBUG_AHCI
pr_dbg("[ahci]: device vendorID %x deviceID %x class code %x\n", ahci->vendor_id, ahci->device_id, ahci->class_code);
#endif
//pci_device_dump(ahci);
hba_mem = (void *)(addr_t)ahci->bar[5].base_addr;
pci_enable_bus_mastering(ahci);
/* 映射IO物理内存地址到虚拟地址中，才能对设备映射到内存的地址进行操作 */
if (__ioremap((addr_t)hba_mem, (addr_t)ahci->bar[5].base_addr, ahci->bar[5].length) < 0) {
pr_err("[ahci] device ioremap on %x length %x failed!\n", ahci->bar[5].base_addr, ahci->bar[5].length);
return NULL;
}
flush_tlb(); // 刷新快表
#ifdef DEBUG_AHCI
pr_dbg("[ahci]: mapping hba_mem to %x -> %x\n", hba_mem, ahci->bar[5].base_addr);
pr_dbg("[ahci]: using interrupt %d\n", ahci->irq_line);
#endif
ahci_int = ahci->irq_line;
return ahci;
}
uint32_t ahci_flush_commands(struct hba_port *port)
{
/* the commands may not take effect until the command
* register is read again by software, because reasons.
*/
volatile uint32_t c = port->command;
c=c;
return c;
}
void ahci_stop_port_command_engine(volatile struct hba_port *port)
{
port->command &= ~HBA_PxCMD_ST;
port->command &= ~HBA_PxCMD_FRE;
while((port->command & HBA_PxCMD_CR) || (port->command & HBA_PxCMD_FR))
cpu_pause();
}
void ahci_start_port_command_engine(volatile struct hba_port *port)
{
while(port->command & HBA_PxCMD_CR);
port->command |= HBA_PxCMD_FRE;
port->command |= HBA_PxCMD_ST;
ahci_flush_commands((struct hba_port *)port);
}
void ahci_init_hba(struct hba_memory *abar)
{
if(abar->ext_capabilities & 1) {
/* request BIOS/OS ownership handoff */
printk(KERN_NOTICE "[ahci]: requesting AHCI ownership change\n");
abar->bohc |= (1 << 1);
while((abar->bohc & 1) || !(abar->bohc & (1<<1))) cpu_pause();
printk(KERN_NOTICE "[ahci]: ownership change completed\n");
}
/* enable the AHCI and reset it */
abar->global_host_control |= HBA_GHC_AHCI_ENABLE;
abar->global_host_control |= HBA_GHC_RESET;
/* wait for reset to complete */
while(abar->global_host_control & HBA_GHC_RESET) cpu_pause();
/* enable the AHCI and interrupts */
abar->global_host_control |= HBA_GHC_AHCI_ENABLE;
abar->global_host_control |= HBA_GHC_INTERRUPT_ENABLE;
mdelay(20);
#ifdef DEBUG_AHCI
printk(KERN_INFO "[ahci]: caps: %x %x ver:%x ctl: %x\n", abar->capability, abar->ext_capabilities, abar->version, abar->global_host_control);
#endif
}
struct hba_command_header *ahci_initialize_command_header(struct hba_memory *abar, struct hba_port *port, device_extension_t *dev, int slot, int write, int atapi, int prd_entries, int fis_len)
{
struct hba_command_header *h = (struct hba_command_header *)dev->clb_virt;
h += slot;
h->write=write ? 1 : 0;
h->prdb_count=0;
h->atapi=atapi ? 1 : 0;
h->fis_length = fis_len;
h->prdt_len=prd_entries;
h->prefetchable=0;
h->bist=0;
h->pmport=0;
h->reset=0;
return h;
}
struct fis_reg_host_to_device *ahci_initialize_fis_host_to_device(struct hba_memory *abar, struct hba_port *port, device_extension_t *dev, int slot, int cmdctl, int ata_command)
{
struct hba_command_table *tbl = (struct hba_command_table *)(dev->ch[slot]);
struct fis_reg_host_to_device *fis = (struct fis_reg_host_to_device *)(tbl->command_fis);
memset(fis, 0, sizeof(*fis));
fis->fis_type = FIS_TYPE_REG_H2D;
fis->command = ata_command;
fis->c=cmdctl?1:0;
return fis;
}
void ahci_send_command(struct hba_port *port, int slot)
{
port->interrupt_status = ~0;
port->command_issue = (1 << slot);
ahci_flush_commands(port);
}
int ahci_write_prdt(struct hba_memory *abar, struct hba_port *port, device_extension_t *dev, int slot, int offset, int length, addr_t virt_buffer)
{
int num_entries = ((length-1) / PRDT_MAX_COUNT) + 1;
struct hba_command_table *tbl = (struct hba_command_table *)(dev->ch[slot]);
int i;
struct hba_prdt_entry *prd;
for(i=0;i<num_entries-1;i++)
{
/* TODO: do we need to do this? */
addr_t phys_buffer;
phys_buffer = addr_v2p(virt_buffer);
//mm_virtual_getmap(virt_buffer, &phys_buffer, 0);
prd = &tbl->prdt_entries[i+offset];
prd->byte_count = PRDT_MAX_COUNT-1;
prd->data_base_l = low32(phys_buffer);
prd->data_base_h = 0;
prd->interrupt_on_complete=0;
length -= PRDT_MAX_COUNT;
virt_buffer += PRDT_MAX_COUNT;
}
addr_t phys_buffer;
phys_buffer = addr_v2p(virt_buffer);
//mm_virtual_getmap(virt_buffer, &phys_buffer, 0);
prd = &tbl->prdt_entries[i+offset];
prd->byte_count = length-1;
prd->data_base_l = low32(phys_buffer);
prd->data_base_h = 0;
prd->interrupt_on_complete=0;
return num_entries;
}
void ahci_reset_device(struct hba_memory *abar, struct hba_port *port, device_extension_t *dev)
{
/* TODO: This needs to clear out old commands and lock properly so that new commands can't get sent
* while the device is resetting */
#ifdef DEBUG_AHCI
printk(KERN_NOTICE "[ahci]: device %d: sending COMRESET and reinitializing\n", dev->idx);
#endif
ahci_stop_port_command_engine(port);
port->sata_error = ~0;
/* power on, spin up */
port->command |= 2;
port->command |= 4;
ahci_flush_commands(port);
mdelay(1);
/* initialize state */
port->interrupt_status = ~0; /* clear pending interrupts */
port->interrupt_enable = AHCI_DEFAULT_INT; /* we want some interrupts */
port->command &= ~((1 << 27) | (1 << 26)); /* clear some bits */
port->sata_control |= 1;
mdelay(10);
port->sata_control |= (~1);
mdelay(10);
port->interrupt_status = ~0; /* clear pending interrupts */
port->interrupt_enable = AHCI_DEFAULT_INT; /* we want some interrupts */
ahci_start_port_command_engine(port);
dev->slots=0;
port->sata_error = ~0;
}
int ahci_port_dma_data_transfer(struct hba_memory *abar, struct hba_port *port, device_extension_t *dev, int slot, int write, addr_t virt_buffer, int sectors, uint64_t lba)
{
int timeout;
int fis_len = sizeof(struct fis_reg_host_to_device) / 4;
int ne = ahci_write_prdt(abar, port, dev,
slot, 0, ATA_SECTOR_SIZE * sectors, virt_buffer);
ahci_initialize_command_header(abar,
port, dev, slot, write, 0, ne, fis_len);
struct fis_reg_host_to_device *fis = ahci_initialize_fis_host_to_device(abar,
port, dev, slot, 1, write ? ATA_CMD_WRITE_DMA_EX : ATA_CMD_READ_DMA_EX);
fis->device = 1<<6;
/* WARNING: assumes little-endian */
fis->count_l = sectors & 0xFF;
fis->count_h = (sectors >> 8) & 0xFF;
fis->lba0 = (unsigned char)( lba & 0xFF);
fis->lba1 = (unsigned char)((lba >> 8) & 0xFF);
fis->lba2 = (unsigned char)((lba >> 16) & 0xFF);
fis->lba3 = (unsigned char)((lba >> 24) & 0xFF);
fis->lba4 = (unsigned char)((lba >> 32) & 0xFF);
fis->lba5 = (unsigned char)((lba >> 40) & 0xFF);
port->sata_error = ~0;
timeout = ATA_TFD_TIMEOUT;
while ((port->task_file_data & (ATA_DEV_BUSY | ATA_DEV_DRQ)) && --timeout)
{
//tm_schedule();
// cpu yeild
//cpu_pause();
task_yeild();
}
if(!timeout) goto port_hung;
port->sata_error = ~0;
ahci_send_command(port, slot);
timeout = ATA_TFD_TIMEOUT;
while ((port->task_file_data & (ATA_DEV_BUSY | ATA_DEV_DRQ)) && --timeout)
{
//cpu_pause();
task_yeild();
}
if(!timeout) goto port_hung;
timeout = AHCI_CMD_TIMEOUT;
while(--timeout)
{
if(!((port->sata_active | port->command_issue) & (1 << slot)))
break;
//cpu_pause();
task_yeild();
}
if(!timeout) goto port_hung;
if(port->sata_error)
{
printk(KERN_ERR "[ahci]: device %d: ahci error\n", dev->idx);
goto error;
}
if(port->task_file_data & ATA_DEV_ERR)
{
printk(KERN_ERR "[ahci]: device %d: task file data error\n", dev->idx);
goto error;
}
return 1;
port_hung:
printk(KERN_ERR "[ahci]: device %d: port hung\n", dev->idx);
error:
printk(KERN_ERR "[ahci]: device %d: tfd=%x, serr=%x\n",
dev->idx, port->task_file_data, port->sata_error);
ahci_reset_device(abar, port, dev);
return 0;
}
int ahci_device_identify_ahci(struct hba_memory *abar,
struct hba_port *port, device_extension_t *dev)
{
int fis_len = sizeof(struct fis_reg_host_to_device) / 4;
struct dma_region dma;
dma.p.size = 0x1000;
dma.p.alignment = 0x1000;
alloc_dma_buffer(&dma);
ahci_write_prdt(abar, port, dev, 0, 0, 512, (addr_t)dma.v);
ahci_initialize_command_header(abar,
port, dev, 0, 0, 0, 1, fis_len);
ahci_initialize_fis_host_to_device(abar,
port, dev, 0, 1, ATA_CMD_IDENTIFY);
int timeout = ATA_TFD_TIMEOUT;
port->sata_error = ~0;
while ((port->task_file_data & (ATA_DEV_BUSY | ATA_DEV_DRQ)) && --timeout)
cpu_pause();
if(!timeout)
{
printk(KERN_ERR "[ahci]: device %d: identify 1: port hung\n", dev->idx);
printk(KERN_ERR "[ahci]: device %d: identify 1: tfd=%x, serr=%x\n",
dev->idx, port->task_file_data, port->sata_error);
free_dma_buffer(&dma);
return 0;
}
ahci_send_command(port, 0);
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "[AHCI]: port %d sata active %x command issue %x\n", dev->idx, port->sata_active, port->command_issue);
#endif
timeout = AHCI_CMD_TIMEOUT;
while(--timeout)
{
if(!((port->sata_active | port->command_issue) & 1))
break;
}
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "[AHCI]: port %d sata active %x command issue %x\n", dev->idx, port->sata_active, port->command_issue);
#endif
if(!timeout)
{
printk(KERN_ERR "[ahci]: device %d: identify 2: port hung\n", dev->idx);
printk(KERN_ERR "[ahci]: device %d: identify 2: tfd=%x, serr=%x\n",
dev->idx, port->task_file_data, port->sata_error);
free_dma_buffer(&dma);
return 0;
}
memcpy(&dev->identify, (void *)dma.v, sizeof(struct ata_identify));
free_dma_buffer(&dma);
#ifdef DEBUG_AHCI
printk(KERN_INFO "[ahci]: device %d: num sectors=%d: %x, %x\n", dev->idx,
dev->identify.lba48_addressable_sectors, dev->identify.ss_2);
#endif
return 1;
}
uint32_t ahci_check_type(volatile struct hba_port *port)
{
port->command &= ~1;
while(port->command & (1 << 15)) cpu_pause();
port->command &= ~(1 << 4);
while(port->command & (1 << 14)) cpu_pause();
io_mfence();
port->command |= 2;
io_mfence();
mdelay(10);
uint32_t s = port->sata_status;
//printk(KERN_INFO "[ahci]: port data: sig=%x, stat=%x, ctl=%x, sac=%x\n", port->signature, s, port->command, port->sata_active);
uint8_t ipm, det;
ipm = (s >> 8) & 0x0F;
det = s & 0x0F;
//printk(KERN_INFO "[ahci]: port check: ipm=%x, det=%x\n", ipm, det);
if(ipm != HBA_PORT_IPM_ACTIVE || det != HBA_PORT_DET_PRESENT)
return AHCI_DEV_NULL;
switch (port->signature)
{
case SATA_SIG_ATAPI:
return AHCI_DEV_SATAPI;
case SATA_SIG_SEMB:
return AHCI_DEV_SEMB;
case SATA_SIG_PM:
return AHCI_DEV_PM;
default:
return AHCI_DEV_SATA;
}
return AHCI_DEV_SATA;
}
int ahci_initialize_device(struct hba_memory *abar, device_extension_t *dev)
{
#ifdef DEBUG_AHCI
printk(KERN_INFO "[ahci]: initializing device %d\n", dev->idx);
#endif
struct hba_port *port = (struct hba_port *)&abar->ports[dev->idx];
ahci_stop_port_command_engine(port);
port->sata_error = ~0;
/* power on, spin up */
port->command |= (2 | 4);
ahci_flush_commands(port);
mdelay(1);
/* initialize state */
port->interrupt_status = ~0; /* clear pending interrupts */
port->interrupt_enable = AHCI_DEFAULT_INT; /* we want some interrupts */
port->command &= ~1;
while(port->command & (1 << 15)) cpu_pause();
port->command &= ~((1 << 27) | (1 << 26) | 1); /* clear some bits */
ahci_flush_commands(port);
#ifdef DEBUG_AHCI
pr_dbg("[AHCI]: step1: port %d sata status %x control %x.\n", dev->idx,
port->sata_status, port->sata_control);
#endif
/* start reset sata */
port->sata_control |= 1;
mdelay(20);
#ifdef DEBUG_AHCI
pr_dbg("[AHCI]: step2: port %d sata status %x control %x.\n", dev->idx,
port->sata_status, port->sata_control);
#endif
/* close DET, after init sata device done. */
port->sata_control &= (~1);
mdelay(10);
#ifdef DEBUG_AHCI
pr_dbg("[AHCI]: step3: port %d sata status %x control %x.\n", dev->idx,
port->sata_status, port->sata_control);
#endif
while(!(port->sata_status & 1)) cpu_pause();
port->sata_error = ~0;
port->command |= (1 << 28); /* set interface to active */
while((port->sata_status >> 8) != 1) cpu_pause();
port->interrupt_status = ~0; /* clear pending interrupts */
port->interrupt_enable = AHCI_DEFAULT_INT; /* we want some interrupts */
#ifdef DEBUG_AHCI
pr_dbg("[AHCI]: map command list dma addr and fis dma addr start.\n");
#endif
/* map memory */
addr_t clb_phys, fis_phys;
dev->dma_clb.p.size = 0x2000;
dev->dma_clb.p.alignment = 0x1000;
dev->dma_fis.p.size = 0x1000;
dev->dma_fis.p.alignment = 0x1000;
alloc_dma_buffer(&dev->dma_clb);
alloc_dma_buffer(&dev->dma_fis);
dev->clb_virt = (void *)dev->dma_clb.v;
dev->fis_virt = (void *)dev->dma_fis.v;
clb_phys = dev->dma_clb.p.address;
fis_phys = dev->dma_fis.p.address;
dev->slots=0;
struct hba_command_header *h = (struct hba_command_header *)dev->clb_virt;
int i;
for(i=0;i<HBA_COMMAND_HEADER_NUM;i++) {
dev->ch_dmas[i].p.size = 0x1000;
dev->ch_dmas[i].p.alignment = 0x1000;
alloc_dma_buffer(&dev->ch_dmas[i]);
dev->ch[i] = (void *)dev->ch_dmas[i].v;
memset(h, 0, sizeof(*h));
h->command_table_base_l = low32(dev->ch_dmas[i].p.address);
h->command_table_base_h = 0;
h++;
}
port->command_list_base_l = low32(clb_phys);
port->command_list_base_h = 0;
port->fis_base_l = low32(fis_phys);
port->fis_base_h = 0;
ahci_start_port_command_engine(port);
port->sata_error = ~0;
#ifdef DEBUG_AHCI
pr_dbg("[AHCI]: map command list dma addr and fis dma addr done.\n");
#endif
return ahci_device_identify_ahci(abar, port, dev);
}
iostatus_t ahci_create_device(driver_object_t *driver, device_extension_t *dev)
{
iostatus_t status ;
device_object_t *devobj;
char devname[DEVICE_NAME_LEN] = {0};
sprintf(devname, "%s%d", DEV_NAME, ahci_next_device++);
/* 初始化一些其它内容 */
status = io_create_device(driver, 0, devname, DEVICE_TYPE_DISK, &devobj);
if (status != IO_SUCCESS) {
printk(KERN_ERR "[ahci]: create device on port %d failed!\n", dev->idx);
return status;
}
/* buffered io mode */
devobj->flags = DO_BUFFERED_IO;
devobj->device_extension = dev;
dev->device_object = devobj;
dev->created = 1;
return status;
}
void ahci_probe_ports(driver_object_t *driver, struct hba_memory *abar)
{
uint32_t pi = abar->port_implemented;
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "[ahci]: ports implemented: %x\n", pi);
#endif
int i=0;
while(i < 32) {
if(pi & 1) {
uint32_t type = ahci_check_type(&abar->ports[i]);
if(type == AHCI_DEV_SATA) { /* SATA device */
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "[ahci]: detected SATA device on port %d\n", i);
#endif
/* 创建设备扩展 */
ports[i] = kmalloc(sizeof(device_extension_t));
ports[i]->type = type;
ports[i]->idx = i;
mutexlock_init(&(ports[i]->lock));
if(ahci_initialize_device(abar, ports[i])) {
/* create one device on port i */
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "[ahci]: success to initialize device %d, disabling port\n", i);
#endif
if (ahci_create_device(driver, ports[i]) < 0) {
printk(KERN_ERR "[ahci]: failed to create device %d, disabling port\n", i);
}
} else {
printk(KERN_ERR "[ahci]: failed to initialize device %d, disabling port\n", i);
}
} else if(type == AHCI_DEV_SATAPI) { /* SATA device */
printk(KERN_WARING "[ahci]: not support SATAPI device on port %d now!\n", i);
} else if(type == AHCI_DEV_PM) { /* SATA device */
printk(KERN_WARING "[ahci]: not support Port multiplier on port %d now!\n", i);
} else if(type == AHCI_DEV_SEMB) { /* SATA device */
printk(KERN_WARING "[ahci]: not support Enclosure management bridge on port %d now!\n", i);
}
/* 暂时不处理其它类型的设备 */
}
i++;
pi >>= 1;
}
}
int ahci_port_acquire_slot(device_extension_t *dev)
{
while(1) {
int i;
mutex_lock(&dev->lock);
for(i=0;i<32;i++)
{
if(!(dev->slots & (1 << i))) {
dev->slots |= (1 << i);
mutex_unlock(&dev->lock);
return i;
}
}
mutex_unlock(&dev->lock);
// yeild
//cpu_pause();
task_yeild();
}
}
void ahci_port_release_slot(device_extension_t *dev, int slot)
{
mutex_lock(&dev->lock);
dev->slots &= ~(1 << slot);
mutex_unlock(&dev->lock);
}
/* since a DMA transfer must write to contiguous physical RAM, we need to allocate
* buffers that allow us to create PRDT entries that do not cross a page boundary.
* That means that each PRDT entry can transfer a maximum of PAGE_SIZE bytes (for
* 0x1000 page size, that's 8 sectors). Thus, we allocate a buffer that is page aligned,
* in a multiple of PAGE_SIZE, so that the PRDT will write to contiguous physical ram
* (the key here is that the buffer need not be contiguous across multiple PRDT entries).
*/
int ahci_rw_multiple_do(int rw, int min, uint64_t blk, unsigned char *out_buffer, int count)
{
uint32_t length = count * ATA_SECTOR_SIZE;
int d = min;
device_extension_t *dev = ports[d];
uint64_t end_blk = dev->identify.lba48_addressable_sectors;
if(blk >= end_blk)
return 0;
if((blk+count) > end_blk)
count = end_blk - blk;
if(!count)
return 0;
int num_pages = ((ATA_SECTOR_SIZE * (count-1)) / PAGE_SIZE) + 1;
ASSERT(length <= (unsigned)num_pages * 0x1000);
struct dma_region dma;
dma.p.size = 0x1000 * num_pages;
dma.p.alignment = 0x1000;
alloc_dma_buffer(&dma);
int num_read_blocks = count;
struct hba_port *port = (struct hba_port *)&hba_mem->ports[dev->idx];
if(rw == 1)
memcpy((void *)dma.v, out_buffer, length);
int slot=ahci_port_acquire_slot(dev);
if(!ahci_port_dma_data_transfer(hba_mem, port, dev, slot, rw == 1 ? 1 : 0, (addr_t)dma.v, count, blk))
num_read_blocks = 0;
ahci_port_release_slot(dev, slot);
if(rw == 0 && num_read_blocks)
memcpy(out_buffer, (void *)dma.v, length);
free_dma_buffer(&dma);
return num_read_blocks * ATA_SECTOR_SIZE;
}
/* and then since there is a maximum transfer amount because of the page size
* limit, wrap the transfer function to allow for bigger transfers than that even.
*/
int ahci_rw_multiple(int rw, int min, uint64_t blk, unsigned char *out_buffer, int count)
{
int i=0;
int ret=0;
int c = count;
for(i=0;i<count;i+=(PRDT_MAX_ENTRIES * PRDT_MAX_COUNT) / ATA_SECTOR_SIZE)
{
int n = (PRDT_MAX_ENTRIES * PRDT_MAX_COUNT) / ATA_SECTOR_SIZE;
if(n > c)
n=c;
ret += ahci_rw_multiple_do(rw, min, blk+i, out_buffer + ret, n);
c -= n;
}
return ret;
}
/**
* ahci_read_sector - 读扇区
* @dev: 设备
* @lba: 逻辑扇区地址
* @count: 扇区数
* @buf: 扇区缓冲
*
* 数据读取磁盘，成功返回读取到的数据数量，失败返回0
*/
static int ahci_read_sector(device_extension_t *ext,
unsigned int lba,
void *buf,
unsigned int count)
{
return ahci_rw_multiple(0, ext->idx, lba, buf, count);
}
/**
* ahci_write_sector - 写扇区
* @dev: 设备
* @lba: 逻辑扇区地址
* @count: 扇区数
* @buf: 扇区缓冲
*
* 把数据写入磁盘，成功返回写入的数据数量，失败返回0
*/
static int ahci_write_sector(
device_extension_t *ext,
unsigned int lba,
void *buf,
unsigned int count
) {
return ahci_rw_multiple(1, ext->idx, lba, buf, count);
}
iostatus_t ahci_devctl(device_object_t *device, io_request_t *ioreq)
{
unsigned int ctlcode = ioreq->parame.devctl.code;
unsigned long arg = ioreq->parame.devctl.arg;
device_extension_t *ext = device->device_extension;
iostatus_t status = IO_SUCCESS;
int infomation = 0;
switch (ctlcode)
{
case DISKIO_GETSIZE:
*((unsigned int *) arg) = ext->size;
break;
case DISKIO_CLEAR:
//ahci_clean_disk(device->device_extension, arg);
break;
default:
infomation = -1;
status = IO_FAILED;
break;
}
ioreq->io_status.status = status;
ioreq->io_status.infomation = infomation;
io_complete_request(ioreq);
return status;
}
iostatus_t ahci_read(device_object_t *device, io_request_t *ioreq)
{
long len;
iostatus_t status = IO_SUCCESS;
sector_t sectors = DIV_ROUND_UP(ioreq->parame.read.length, SECTOR_SIZE);
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "ahci_read: buf=%x sectors=%d off=%x\n",
ioreq->system_buffer, sectors, ioreq->parame.read.offset);
#endif
len = ahci_read_sector(device->device_extension, ioreq->parame.read.offset,
ioreq->system_buffer, sectors);
if (!len) { /* 执行失败 */
status = IO_FAILED;
len = 0;
}
//loop_delay(1);
ioreq->io_status.status = status;
ioreq->io_status.infomation = len;
io_complete_request(ioreq);
return status;
}
iostatus_t ahci_write(device_object_t *device, io_request_t *ioreq)
{
long len;
iostatus_t status = IO_SUCCESS;
sector_t sectors = DIV_ROUND_UP(ioreq->parame.write.length, SECTOR_SIZE);
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "ahci_write: buf=%x sectors=%d off=%x\n",
ioreq->system_buffer, sectors, ioreq->parame.write.offset);
#endif
len = ahci_write_sector(device->device_extension, ioreq->parame.write.offset,
ioreq->system_buffer, sectors);
if (!len) { /* 执行失败 */
status = IO_FAILED;
len = 0;
}
ioreq->io_status.status = status;
ioreq->io_status.infomation = len;
io_complete_request(ioreq);
return status;
}
/**
* ahci_handler - ahci硬盘中断处理函数
* @irq: 中断号
* @data: 中断的数据
*/
static int ahci_handler(unsigned long irq, unsigned long data)
{
int i;
for(i=0;i<32;i++) {
if(hba_mem->interrupt_status & (1 << i)) {
pr_dbg("ahci: interrupt %d occur!\n", i);
hba_mem->ports[i].interrupt_status = ~0;
hba_mem->interrupt_status = (1 << i);
ahci_flush_commands((struct hba_port *)&hba_mem->ports[i]);
}
}
return 0;
}
static iostatus_t ahci_enter(driver_object_t *driver)
{
iostatus_t status = IO_SUCCESS;
printk(KERN_INFO "[ahci]: initializing ahci driver...\n");
if(!(ahci_pci = get_ahci_pci())) {
printk(KERN_ERR "[ahci]: no AHCI controllers present!\n");
status = IO_FAILED;
return status;
}
if (register_irq(ahci_int, ahci_handler, IRQF_SHARED, "ahci", "ahci driver", (addr_t)driver) < 0) {
printk(KERN_ERR "[ahci]: register interrupt failed!\n");
/* 需要取消内存映射以及关闭ahci总线 */
status = IO_FAILED;
return status;
}
ahci_init_hba(hba_mem);
ahci_probe_ports(driver, hba_mem);
printk(KERN_INFO "[ahci]: initializing ahci driver done.\n");
//spin("ahci");
return status;
}
static iostatus_t ahci_exit(driver_object_t *driver)
{
/* 遍历所有对象 */
device_object_t *devobj, *next;
device_extension_t *ext;
unregister_irq(ahci_int, driver);
/* 由于涉及到要释放devobj，所以需要使用safe版本 */
list_for_each_owner_safe (devobj, next, &driver->device_list, list) {
ext = devobj->device_extension;
free_dma_buffer(&(ext->dma_clb));
free_dma_buffer(&(ext->dma_fis));
int j;
for(j = 0; j < HBA_COMMAND_HEADER_NUM; j++)
free_dma_buffer(&(ext->ch_dmas[j]));
kfree(ext);
io_delete_device(devobj); /* 删除每一个设备 */
}
string_del(&driver->name); /* 删除驱动名 */
return IO_SUCCESS;
}
iostatus_t ahci_driver_vine(driver_object_t *driver)
{
iostatus_t status = IO_SUCCESS;
/* 绑定驱动信息 */
driver->driver_enter = ahci_enter;
driver->driver_exit = ahci_exit;
driver->dispatch_function[IOREQ_READ] = ahci_read;
driver->dispatch_function[IOREQ_WRITE] = ahci_write;
driver->dispatch_function[IOREQ_DEVCTL] = ahci_devctl;
/* 初始化驱动名字 */
string_new(&driver->name, DRV_NAME, DRIVER_NAME_LEN);
#ifdef DEBUG_AHCI
printk(KERN_DEBUG "ahci_driver_vine: driver name=%s\n",
driver->name.text);
#endif
return status;
}
|
NightfallDM/xbook2
|
src/include/xbook/ktime.h
|
#ifndef _XBOOK_KTIME_H
#define _XBOOK_KTIME_H
#include <arch/time.h>
#include <sys/ktime.h>
#include <sys/time.h>
extern ktime_t ktime;
void update_ktime();
void print_ktime();
void sys_get_ktime(ktime_t *time);
void init_ktime();
static inline unsigned long ktime2uint32()
{
unsigned short date = KTIME_DATE(ktime.year, ktime.month, ktime.day);
unsigned short time = KTIME_TIME(ktime.hour, ktime.minute, ktime.second);
return (date << 16) | time;
}
int sys_gettimeofday(struct timeval *tv, struct timezone *tz);
int sys_clock_gettime(clockid_t clockid, struct timespec *ts);
unsigned long timeval_to_systicks(struct timeval *tv);
void systicks_to_timeval(unsigned long ticks, struct timeval *tv);
unsigned long timespec_to_systicks(struct timespec *ts);
void systicks_to_timespec(unsigned long ticks, struct timespec *ts);
#endif /* _XBOOK_KTIME_H */
|
NightfallDM/xbook2
|
library/xlibc/math/ldexp.c
|
<gh_stars>0
/*
File: ldexp.c
Contains: For x * 2^exp
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT ldexp(M_FLOAT x, int exp) {
return (x * (double)pow(2.0, exp));
}
|
NightfallDM/xbook2
|
src/ipc/msgqueue.c
|
<gh_stars>0
#include <xbook/msgqueue.h>
#include <xbook/debug.h>
#include <string.h>
#include <math.h>
#include <sys/ipc.h>
/* debug msgq : 1 enable, 0 disable */
#define DEBUG_MSGQ 0
/* 消息队列表 */
msg_queue_t *msg_queue_table;
/* 保护消息队列的分配与释放 */
DEFINE_SEMAPHORE(msg_queue_mutex, 1);
/**
* msg_queue_find_by_name - 通过名字查找消息队列
* @name: 消息队列的名字
*
* @return: 如果消息队列已经在消息队列表中，就返回消息队列指针，
* 没有则返回NULL
*/
static msg_queue_t *msg_queue_find_by_name(char *name)
{
msg_queue_t *msgq;
int i;
for (i = 0; i < MSGQ_MAX_NR; i++) {
msgq = &msg_queue_table[i];
if (msgq->name[0] != '\0') { /* 有名字才进行比较 */
if (!strcmp(msgq->name, name)) {
return msgq;
}
}
}
return NULL;
}
/**
* msg_queue_find_by_id - 通过id查找消息队列
* @id: 消息队列的id
*
* @return: 如果消息队列已经在消息队列表中，就返回消息队列指针，
* 没有则返回NULL
*/
static msg_queue_t *msg_queue_find_by_id(int msgid)
{
msg_queue_t *msgq;
int i;
for (i = 0; i < MSGQ_MAX_NR; i++) {
msgq = &msg_queue_table[i];
/* id相同并且正在使用，才找到 */
if (msgq->id == msgid && msgq->name[0] != '\0') {
return msgq;
}
}
return NULL;
}
/**
* msg_queue_alloc - 分配一个消息队列
* @name: 名字
* @flags: 标志
*
* 从消息队列表中分配一个消息队列
*
* @return: 成功返回消息队列结构的地址，失败返flags回NULL
*/
msg_queue_t *msg_queue_alloc(char *name)
{
msg_queue_t *msgq;
int i;
for (i = 0; i < MSGQ_MAX_NR; i++) {
msgq = &msg_queue_table[i];
if (msgq->name[0] == '\0') { /* 没有名字才使用 */
/* 设置消息队列名字 */
memcpy(msgq->name, name, MSGQ_NAME_LEN);
msgq->name[MSGQ_NAME_LEN - 1] = '\0';
INIT_LIST_HEAD(&msgq->msg_list);
msgq->msgs = 0;
msgq->msgsz = MSG_MAX_LEN; /* 默认消息长度 */
/* 发送者和接受者等待队列 */
wait_queue_init(&msgq->senders);
wait_queue_init(&msgq->receivers);
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_alloc: msgq id=%d\n", msgq->id);
#endif
return msgq; /* 返回消息队列 */
}
}
return NULL;
}
/**
* msg_queue_free - 释放一个消息队列
* @msgq: 消息队列
*
* @return: 成功返回0，失败返回-1
*/
int msg_queue_free(msg_queue_t *msgq)
{
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_free: msgq id=%d msgs=%d\n", msgq->id, msgq->msgs);
#endif
memset(msgq->name, 0, MSGQ_NAME_LEN);
return 0;
}
/**
* msg_queue_get - 获取一个消息队列
*
* @name: 消息队列名
* @flags: 获取标志
* IPC_CREAT: 如果消息队列不存在，则创建一个新的消息队列，否则就打开
* IPC_EXCL: 和CREAT一起使用，则要求创建一个新的消息队列，若已存在，就返回-1。
* 相当于在CREAT上面加了一个必须不存在的限定。
*
* @return: 成功返回消息队列id，失败返回-1
*/
int msg_queue_get(char *name, unsigned long flags)
{
/* 检测参数 */
if (name == NULL)
return -1;
char craete_new = 0; /* 是否需要创建一个新的消息队列 */
msg_queue_t *msgq;
int retval = -1;
/* get msg queue table access */
semaphore_down(&msg_queue_mutex);
/* 有创建标志 */
if (flags & IPC_CREAT) { /* 创建一个新的消息队列 */
if (flags & IPC_EXCL) { /* 必须不存在才行 */
craete_new = 1; /* 需要创建一个新的消息队列 */
}
msgq = msg_queue_find_by_name(name);
if (msgq) { /* 消息队列已经存在 */
/* 必须创建一个新的，不能是已经存在的，故错误 */
if (craete_new) {
goto err;
}
retval = msgq->id; /* 已经存在，那么就返回已经存在的消息队列的id */
} else { /* 不存在则创建一个新的 */
msgq = msg_queue_alloc(name);
if (msgq == NULL) {
goto err;
}
retval = msgq->id; /* 返回消息队列id */
}
}
err:
semaphore_up(&msg_queue_mutex);
/* 没有创建标志，直接返回错误 */
return retval;
}
/**
* msg_queue_put - 释放一个消息队列
*
* @msgid: 消息队列id
*
* @return: 成功返回0，失败返回-1
*/
int msg_queue_put(int msgid)
{
msg_queue_t *msgq;
/* get msg queue table access */
semaphore_down(&msg_queue_mutex);
msgq = msg_queue_find_by_id(msgid);
if (msgq) { /* 消息队列存在 */
#if DEBUG_msgq == 1
printk(KERN_INFO "msgq msgs %d.\n", msgq->msgs);
#endif
/* 先释放所有队列中的消息 */
msg_queue_free(msgq);
semaphore_up(&msg_queue_mutex);
return 0;
}
semaphore_up(&msg_queue_mutex);
/* 没有找到消息队列 */
return -1;
}
void msg_init(msg_t *msg, long type, void *text, size_t length)
{
INIT_LIST_HEAD(&msg->list);
msg->type = type;
msg->length = length;
memcpy(msg->buf, text, length);
}
/**
* msg_queue_send - 把一条消息添加到消息队列
* @msgid: 消息队列id
* @msgbuf: 消息数据
* @size: 消息大小，不包括long int 的type。
* @msgflg: 消息标志，IPC_NOWAIT表示队列满不等待，否则就要等待。
*
* @return: 成功返回0，失败返回-1
*/
int msg_queue_send(int msgid, void *msgbuf, size_t size, int msgflg)
{
msg_queue_t *msgq;
/* get msg queue table access */
semaphore_down(&msg_queue_mutex);
msgq = msg_queue_find_by_id(msgid);
if (msgq == NULL) { /* not found message queue */
semaphore_up(&msg_queue_mutex);
printk(KERN_DEBUG "msg_queue_send: not found message queue!\n");
return -1;
}
semaphore_up(&msg_queue_mutex);
//task_t *cur = current_task;
/* get msg queue */
semaphore_down(&msgq->mutex);
if (size > msgq->msgsz) {
size = msgq->msgsz; /* 截断消息 */
#if DEBUG_MSGQ == 1
printk(KERN_NOTICE "msg_queue_send: message too long, truncated!\n");
#endif
}
/* 如果消息队列已经满了，就根据标志来判断进行什么样的操作 */
if (msgq->msgs > MSGQ_MAX_MSGS) {
if (msgflg & IPC_NOWAIT) { /* 有不等待标志，直接返回 */
semaphore_up(&msgq->mutex);
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_send: message queue full, no wait!\n");
#endif
return -1;
}
#if DEBUG_MSGQ == 1
printk(KERN_NOTICE ">>> sender wait.\n\n");
#endif
/* 没有不等待标志，就阻塞 */
wait_queue_add(&msgq->senders, current_task);
semaphore_up(&msgq->mutex);
task_block(TASK_BLOCKED); /* 阻塞自己 */
semaphore_down(&msgq->mutex); /* 唤醒后再次获取 */
}
/* 分配一个消息 */
msg_t *msg = kmalloc(sizeof(msg_t) + size);
if (msg == NULL) {
semaphore_up(&msgq->mutex);
return -1;
}
long *msg_header = (long *) msgbuf;
/* 填写消息 */
msg_init(msg, *msg_header, msg_header + 1, size);
/* 把消息添加到队列 */
list_add(&msg->list, &msgq->msg_list);
msgq->msgs++;
/* 发送完后，检测是否有等待接收中的任务，并将它唤醒 */
wait_queue_wakeup(&msgq->receivers);
semaphore_up(&msgq->mutex);
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_send: send msg type=%d len:%d ok!\n", msg->type, msg->length);
#endif
return 0;
}
/**
* msg_queue_recv - 从一个消息队列中获取消息
* @msgid: 消息队列id
* @msgbuf: 消息数据
* @msgsz: 消息大小，不包括long int 的type。
* @msgtype: 消息类型，实现接收优先级
* =0：表示返回队列里的第一条消息
* >0：返回队列第一条类型等于msgtype的消息。
* <0：返回队列第一条类型小于等于msgtype绝对值的消息。
*
* @msgflg: 消息标志：
* IPC_NOWAIT：队列没有可读消息不等待，返回错误
* IPC_NOERROR：消息大小超过size时被截断
* msgtype>0且msgflg=IPC_EXCEPT：接收类型不等于msgtype的第一条消息
*
* @return: 成功返回实际接收的数据量，失败返回-1
*/
int msg_queue_recv(int msgid, void *msgbuf, size_t msgsz, long msgtype, int msgflg)
{
msg_queue_t *msgq;
/* get msg queue table access */
semaphore_down(&msg_queue_mutex);
msgq = msg_queue_find_by_id(msgid);
if (msgq == NULL) { /* not found message queue */
semaphore_up(&msg_queue_mutex);
printk(KERN_DEBUG "msg_queue_recv: not found message queue!\n");
return -1;
}
semaphore_up(&msg_queue_mutex);
/* get msg queue access */
semaphore_down(&msgq->mutex);
/* 如果消息队列为空，就根据标志来判断进行什么样的操作 */
if (!msgq->msgs) {
if (msgflg & IPC_NOWAIT) { /* 有不等待标志，直接返回 */
semaphore_up(&msgq->mutex);
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_recv: message queue empty, no wait!\n");
#endif
return -1;
}
#if DEBUG_MSGQ == 1
printk(KERN_NOTICE "<<< receiver wait.\n");
#endif
/* 没有不等待标志，就阻塞 */
wait_queue_add(&msgq->receivers, current_task);
semaphore_up(&msgq->mutex);
task_block(TASK_BLOCKED); /* 阻塞自己 */
semaphore_down(&msgq->mutex); /* 唤醒后再次获取 */
}
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "receive start.\n");
#endif
/* 根据msgtype获取一个消息 */
msg_t *msg = NULL, *tmp;
if (msgtype > 0) { /* 第一个分支 */
if (msgflg & IPC_EXCEPT) { /* 获取第一个非msgtype类型消息 */
list_for_each_owner (tmp, &msgq->msg_list, list) {
if (tmp->type != msgtype) { /* 类型不相等，是我们需要的消息 */
msg = tmp;
break;
}
}
} else { /* 获取第一个类型相等的消息 */
list_for_each_owner (tmp, &msgq->msg_list, list) {
if (tmp->type == msgtype) { /* 类型不相等，是我们需要的消息 */
msg = tmp;
break;
}
}
}
} else if (msgtype == 0) { /* 获取第一个消息 */
/* 获取链表第一个消息 */
msg = list_first_owner_or_null(&msgq->msg_list, msg_t, list);
} else { /* 获取第一个小于等于msgtype绝对值的消息 */
msgtype = ABS(msgtype);
list_for_each_owner (tmp, &msgq->msg_list, list) {
if (tmp->type <= msgtype) {
msg = tmp;
break;
}
}
}
if (msg == NULL) { /* 没找到相匹配的消息 */
semaphore_up(&msgq->mutex);
printk(KERN_DEBUG "msg_queue_recv: message not found!\n");
return -1;
}
/* 找到消息，从链表删除 */
list_del(&msg->list);
msgq->msgs--; /* 消息数减少1 */
unsigned short len = msg->length;
/* 复制数据到缓冲区 */
if (msgflg & IPC_NOERROR) {
if (len > msgsz) { /* 超过参数传递的大小，截断 */
len = msgsz;
}
}
long *msg_header = (long *) msgbuf;
*msg_header = msg->type;
memcpy((void *)(msg_header + 1), msg->buf, len);
#if DEBUG_MSGQ == 1
printk(KERN_DEBUG "msg_queue_recv: recv msg type=%d len:%d ok!\n", msg->type, msg->length);
#endif
/* 释放消息 */
kfree(msg);
/* 接收完后，检测是否有等待发送中的任务，并将它唤醒 */
wait_queue_wakeup(&msgq->senders);
semaphore_up(&msgq->mutex);
return len;
}
/**
* init_msg_queue - 初始化消息队列
*/
void init_msg_queue()
{
msg_queue_table = (msg_queue_t *)kmalloc(sizeof(msg_queue_t) * MSGQ_MAX_NR);
if (msg_queue_table == NULL) /* must be ok! */
panic(KERN_EMERG "init_msg_queue: alloc mem for msg_queue_table failed! :(\n");
//printk(KERN_DEBUG "init_msg_queue: alloc mem table at %x\n", msg_queue_table);
int i;
for (i = 0; i < MSGQ_MAX_NR; i++) {
msg_queue_table[i].id = 1 + i + i * 2;
/* init msg list in each msg queue */
INIT_LIST_HEAD(&msg_queue_table[i].msg_list);
msg_queue_table[i].msgs = 0;
semaphore_init(&msg_queue_table[i].mutex, 1); /* 初始化为1，表示有没有持有锁 */
memset(msg_queue_table[i].name, 0, MSGQ_NAME_LEN);
}
#if 0
int msgid = msg_queue_get("test", IPC_CREAT);
if (msgid < 0) {
printk(KERN_DEBUG "get msgq failed!\n");
}
printk(KERN_DEBUG "get msgq %d.\n", msgid);
msgid = msg_queue_get("test", IPC_CREAT | IPC_EXCL);
if (msgid < 0) {
printk(KERN_DEBUG "get msgq failed!\n");
}
printk(KERN_DEBUG "get msgq %d.\n", msgid);
if (msg_queue_put(msgid) < 0) {
printk(KERN_DEBUG "put msgq %d failed!\n", msgid);
}
#endif
}
int sys_msgque_get(char *name, unsigned long flags)
{
return msg_queue_get(name, flags);
}
int sys_msgque_put(int msgid)
{
return msg_queue_put(msgid);
}
int sys_msgque_send(int msgid, void *msgbuf, size_t size, int msgflg)
{
return msg_queue_send(msgid, msgbuf, size, msgflg);
}
int sys_msgque_recv(int msgid, void *msgbuf, size_t msgsz, int msgflg)
{
long *msgtype = (long *) msgbuf;
return msg_queue_recv(msgid, msgbuf, msgsz, *msgtype, msgflg);
}
|
NightfallDM/xbook2
|
src/include/xbook/trigger.h
|
#ifndef _XBOOK_TRIGGER_H
#define _XBOOK_TRIGGER_H
#include <types.h>
#include <sys/trigger.h>
#include <arch/interrupt.h>
#include <xbook/spinlock.h>
#define TRIG_LEFT (1 << 0) /* 有剩余的触发器没处理 */
#define TRIG_CATCHED (1 << 1) /* 触发器被捕捉，并且已经处理了 */
typedef struct {
trigset_t blocked; /* 阻塞触发器集 */
trigset_t set; /* 触发器集 */
trig_action_t actions[TRIG_NR]; /* 触发器行为 */
pid_t touchers[TRIG_NR]; /* 触发者进程id */
unsigned long flags; /* 触发器标志 */
spinlock_t trig_lock;
} triggers_t;
typedef struct {
char *ret_addr; /* 记录返回地址 */
unsigned long trig; /* 触发器 */
trigset_t oldmask; /* 执行前的遮罩 */
trap_frame_t trap_frame; /* 保存原来的栈框 */
char ret_code[8]; /* 构建返回的系统调用代码 */
} trigger_frame_t;
void trigger_init(triggers_t *triggers);
int trigger_force(int trig, pid_t pid);
int sys_trigger_active(int trig, pid_t pid);
int sys_trigger_handler(int trig, trighandler_t handler);
int sys_trigger_action(int trig, trig_action_t *act, trig_action_t *oldact);
int sys_trigger_return(unsigned int ebx, unsigned int ecx, unsigned int esi, unsigned int edi, trap_frame_t *frame);
int sys_trigger_proc_mask(int how, trigset_t *set, trigset_t *oldset);
int sys_trigger_pending(trigset_t *set);
/**
* trigger_calc_left - 计算是否还有信号需要处理
*/
static inline void trigger_calc_left(triggers_t *trigger)
{
if (trigger->set > 1)
trigger->flags |= TRIG_LEFT;
else
trigger->flags &= ~TRIG_LEFT;
}
static inline void trigger_set_action(triggers_t *trigger, int trig, trig_action_t *ta)
{
trigger->actions[trig - 1].flags = ta->flags;
trigger->actions[trig - 1].handler = ta->handler;
trigger->actions[trig - 1].mask = ta->mask;
/* remove HSOFT and PAUSE */
trigdelset(&trigger->actions[trig - 1].mask, trigmask(TRIGHSOFT) | trigmask(TRIGPAUSE));
}
static inline void trigger_get_action(triggers_t *trigger, int trig, trig_action_t *ta)
{
ta->flags = trigger->actions[trig - 1].flags;
ta->handler = trigger->actions[trig - 1].handler;
ta->mask = trigger->actions[trig - 1].mask;
}
#endif /* _XBOOK_TRIGGER_H */
|
NightfallDM/xbook2
|
src/include/xbook/elf32.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_ELF32_H
#define _XBOOK_ELF32_H
#include <stdint.h>
/* 自定义的elf类型 */
typedef uint32_t Elf32_Word, Elf32_Addr, Elf32_Off;
typedef uint16_t Elf32_Half;
/* 32位elf头 */
struct Elf32_Ehdr {
unsigned char e_ident[16];
Elf32_Half e_type;
Elf32_Half e_machine;
Elf32_Word e_version;
Elf32_Addr e_entry;
Elf32_Off e_phoff;
Elf32_Off e_shoff;
Elf32_Word e_flags;
Elf32_Half e_ehsize;
Elf32_Half e_phentsize;
Elf32_Half e_phnum;
Elf32_Half e_shentsize;
Elf32_Half e_shnum;
Elf32_Half e_shstrndx;
};
/* 程序头表Program header.就是段描述头 */
struct Elf32_Phdr {
Elf32_Word p_type; // 见下面的enum segment_type
Elf32_Off p_offset;
Elf32_Addr p_vaddr;
Elf32_Addr p_paddr;
Elf32_Word p_filesz;
Elf32_Word p_memsz;
Elf32_Word p_flags;
Elf32_Word p_align;
};
/* 段类型 */
enum segment_type {
PT_NULL, // 忽略
PT_LOAD, // 可加载程序段
PT_DYNAMIC, // 动态加载信息
PT_INTERP, // 动态加载器名称
PT_NOTE, // 一些辅助信息
PT_SHLIB, // 保留
PT_PHDR // 程序头表
};
#define ELF32_PF_X (1 << 0) /* Segment is executable */
#define ELF32_PF_W (1 << 1) /* Segment is writable */
#define ELF32_PF_R (1 << 2) /* Segment is readable */
#define ELF32_PF_MASKOS 0x0ff00000 /* OS-specific */
#define ELF32_PF_MASKPROC 0xf0000000 /* Processor-specific */
#define ELF32_PHDR_CODE (ELF32_PF_X | ELF32_PF_R) /* 代码段 */
#define ELF32_PHDR_DATA (ELF32_PF_W | ELF32_PF_R) /* 数据段 */
#endif /* _XBOOK_ELF32_H */
|
NightfallDM/xbook2
|
src/include/assert.h
|
<gh_stars>0
#ifndef _XBOOK_ASEERT_H
#define _XBOOK_ASEERT_H
//断言
#define CONFIG_ASSERT 1
#if CONFIG_ASSERT == 1
void assertion_failure(char *exp, char *file, char *baseFile, int line);
#define ASSERT(exp) if (exp) ; \
else assertion_failure(#exp, __FILE__, __BASE_FILE__, __LINE__)
#else
#define ASSERT(exp)
#endif
#endif /* _XBOOK_ASEERT_H */
|
NightfallDM/xbook2
|
library/xlibc/arpa/inet.c
|
<filename>library/xlibc/arpa/inet.c<gh_stars>0
#include <arpa/inet.h>
// 短整型大小端互换
#define endian_swap16(a) \
((((uint16_t)(a) & 0xff00) >> 8) | \
(((uint16_t)(a) & 0x00ff) << 8))
// 长整型大小端互换
#define endian_swap32(a) \
((((uint32_t)(a) & 0xff000000) >> 24) | \
(((uint32_t)(a) & 0x00ff0000) >> 8) | \
(((uint32_t)(a) & 0x0000ff00) << 8) | \
(((uint32_t)(a) & 0x000000ff) << 24))
// 本机大端返回1，小端返回0
static int check_cpu_endian()
{
union{
uint32_t i;
unsigned char s[4];
}c;
c.i = 0x12345678;
return (0x12 == c.s[0]);
}
// 模拟htonl函数，本机字节序转网络字节序
uint32_t htonl(uint32_t h)
{
// 若本机为大端，与网络字节序同，直接返回
// 若本机为小端，转换成大端再返回
return check_cpu_endian() ? h : endian_swap32(h);
}
// 模拟ntohl函数，网络字节序转本机字节序
uint32_t ntohl(uint32_t n)
{
// 若本机为大端，与网络字节序同，直接返回
// 若本机为小端，网络数据转换成小端再返回
return check_cpu_endian() ? n : endian_swap32(n);
}
// 模拟htons函数，本机字节序转网络字节序
uint16_t htons(uint16_t h)
{
// 若本机为大端，与网络字节序同，直接返回
// 若本机为小端，转换成大端再返回
return check_cpu_endian() ? h : endian_swap16(h);
}
// 模拟ntohs函数，网络字节序转本机字节序
uint16_t ntohs(uint16_t n)
{
// 若本机为大端，与网络字节序同，直接返回
// 若本机为小端，网络数据转换成小端再返回
return check_cpu_endian() ? n : endian_swap16(n);
}
|
NightfallDM/xbook2
|
src/include/xbook/pci.h
|
#ifndef _ARCH_PCI_H
#define _ARCH_PCI_H
/*
【简介】
PCI是什么？PCI是Peripheral Component Interconnect(外设部件互连标准)的缩写，
它是目前个人电脑中使用最为广泛的接口，几乎所有的主板产品上都带有这种插槽。
PCI有三个相互独立的物理地址空间：设备存储器地址空间、I/O地址空间和配置空间。
配置空间是PCI所特有的一个物理空间。由于PCI支持设备即插即用，所以PCI设备不占
用固定的内存地址空间或I/O地址空间，而是由操作系统决定其映射的基址。
PCI总线规范定义的配置空间总长度为256个字节，配置信息按一定的顺序和大小依次存放。
前64个字节的配置空间称为配置头，对于所有的设备都一样，配置头的主要功能是用来识别设备、
定义主机访问PCI卡的方式（I/O访问或者存储器访问，还有中断信息）。
其余的192个字节称为本地配置空间（设备有关区），主要定义卡上局部总线的特性、本地空间基地址及范围等。
【配置空间中的重要信息】
Vendor ID：厂商ID。知名的设备厂商的ID。FFFFh是一个非法厂商ID，可它来判断PCI设备是否存在。
Device ID：设备ID。某厂商生产的设备的ID。操作系统就是凭着 Vendor ID和Device ID 找到对应驱动程序的。
Class Code：类代码。共三字节，分别是 类代码、子类代码、编程接口。类代码不仅用于区分设备类型，还是编程接口的规范，这就是为什么会有通用驱动程序。
IRQ Line：IRQ编号。PC机以前是靠两片8259芯片来管理16个硬件中断。
现在为了支持对称多处理器，有了APIC（高级可编程中断控制器），它支持管理24个中断。
IRQ Pin：中断引脚。PCI有4个中断引脚，该寄存器表明该设备连接的是哪个引脚。
【访问配置空间】
如何访问配置空间呢？可通过访问0xCF8h、0xCFCh端口来实现。
0xCF8h: CONFIG_ADDRESS。PCI配置空间地址端口。
0xCFCh: CONFIG_DATA。PCI配置空间数据端口。
【CONFIG_ADDRESS寄存器格式】
31 位： Enabled位。
23:16 位： 总线编号。
15:11 位： 设备编号。
10: 8 位：功能编号。
7: 2 位：配置空间寄存器编号。
1: 0 位：恒为“00”。这是因为CF8h、CFCh端口是32位端口。
*/
#define PCI_CONFIG_ADDR 0xCF8 /*PCI配置空间地址端口*/
#define PCI_CONFIG_DATA 0xCFC /*PCI配置空间数据端口*/
/*PCI配置空间数据的偏移*/
#define PCI_DEVICE_VENDER 0x00
#define PCI_STATUS_COMMAND 0x04
#define PCI_CLASS_CODE_REVISION_ID 0x08
#define PCI_BIST_HEADER_TYPE_LATENCY_TIMER_CACHE_LINE 0x0C
#define PCI_BASS_ADDRESS0 0x10
#define PCI_BASS_ADDRESS1 0x14
#define PCI_BASS_ADDRESS2 0x18
#define PCI_BASS_ADDRESS3 0x1C
#define PCI_BASS_ADDRESS4 0x20
#define PCI_BASS_ADDRESS5 0x24
#define PCI_CARD_BUS_POINTER 0x28
#define PCI_SUBSYSTEM_ID 0x2C
#define PCI_EXPANSION_ROM_BASE_ADDR 0x30
#define PCI_CAPABILITY_LIST 0x34
#define PCI_RESERVED 0x38
#define PCI_MAX_LNT_MIN_GNT_IRQ_PIN_IRQ_LINE 0x3C
/*IO地址和MEM地址的地址mask*/
#define PCI_BASE_ADDR_MEM_MASK (~0x0FUL)
#define PCI_BASE_ADDR_IO_MASK (~0x03UL)
#define PCI_BAR_TYPE_INVALID 0
#define PCI_BAR_TYPE_MEM 1
#define PCI_BAR_TYPE_IO 2
#define PCI_MAX_BAR 6 /*每个设备最多有6地址信息*/
#define PCI_MAX_BUS 256 /*PCI总共有256个总线*/
#define PCI_MAX_DEV 32 /*PCI每条总线上总共有32个设备*/
#define PCI_MAX_FUN 8 /*PCI设备总共有8个功能号*/
#define PCI_MAX_DEVICE_NR 256 /*系统最大支持检测多少个设备*/
/*PCI地址bar结构体，保存Bass Address （0~5）的信息*/
typedef struct pci_device_bar
{
unsigned int type; /*地址bar的类型（IO地址/MEM地址）*/
unsigned int base_addr; /*地址的值*/
unsigned int length; /*地址的长度*/
} pci_device_bar_t;
#define PCI_DEVICE_INVALID 0
#define PCI_DEVICE_USING 1
/*
PCI设备结构体，用于保存我们所需要的pci信息，并不是和硬件的一样
*/
typedef struct pci_device
{
int flags; /*device flags*/
unsigned char bus; /*bus总线号*/
unsigned char dev; /*device号*/
unsigned char function; /*功能号*/
unsigned short vendor_id; /*配置空间:Vendor ID*/
unsigned short device_id; /*配置空间:Device ID*/
unsigned short command; /*配置空间:Command*/
unsigned short status; /*配置空间:Status*/
unsigned int class_code; /*配置空间:Class Code*/
unsigned char revision_id; /*配置空间:Revision ID*/
unsigned char multi_function; /*多功能标志*/
unsigned int card_bus_pointer;
unsigned short subsystem_vendor_id;
unsigned short subsystem_device_id;
unsigned int expansion_rom_base_addr;
unsigned int capability_list;
unsigned char irq_line; /*配置空间:IRQ line*/
unsigned char irq_pin; /*配置空间:IRQ pin*/
unsigned char min_gnt;
unsigned char max_lat;
pci_device_bar_t bar[PCI_MAX_BAR]; /*有6个地址信息*/
} pci_device_t;
unsigned int pci_device_get_io_addr(pci_device_t *device);
unsigned int pci_device_get_mem_addr(pci_device_t *device);
unsigned int pci_device_get_irq_line(pci_device_t *device);
void pci_enable_bus_mastering(pci_device_t *device);
pci_device_t* pci_get_device(unsigned int vendor_id, unsigned int device_id);
pci_device_t* pci_get_device_by_class_code(unsigned int class, unsigned int sub_class);
pci_device_t *pci_locate_device(unsigned short vendor, unsigned short device);
pci_device_t *pci_locate_class(unsigned short class, unsigned short _subclass);
void pci_device_bar_dump(pci_device_bar_t *bar);
void pci_device_dump(pci_device_t *device);
unsigned int pci_device_read(pci_device_t *device, unsigned int reg);
void pci_device_write(pci_device_t *device, unsigned int reg, unsigned int value);
void init_pci();
#endif /* _ARCH_PCI_H */
|
NightfallDM/xbook2
|
src/include/xbook/netcard.h
|
#ifndef _XBOOK_NETCARD_H
#define _XBOOK_NETCARD_H
#include <list.h>
#include <types.h>
#include <xbook/driver.h>
/* 磁盘驱动器 */
typedef struct {
list_t list; /* 信息链表 */
int solt; /* 插槽位置 */
int handle; /* 资源句柄 */
devent_t devent; /* 设备项 */
char virname[DEVICE_NAME_LEN]; /* 虚拟网卡名字 */
} netcard_info_t;
/* 支持2个网卡 */
#define NETCARD_SOLT_NR 2
typedef struct {
int (*open)(int);
int (*close)(int);
int (*read)(int , void *, size_t );
int (*write)(int , void *, size_t );
int (*ioctl)(int , unsigned int , unsigned long );
} netcard_drvier_t;
extern netcard_drvier_t drv_netcard;
int netcard_probe_device(device_type_t type);
void netcard_info_print();
int init_netcard_driver();
int netcard_res_find(char *name);
#endif /* _XBOOK_NETCARD_H */
|
NightfallDM/xbook2
|
src/gui/console/clipboard.c
|
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stddef.h>
#include <gui/console/console.h>
#include <gui/console/cursor.h>
#include <gui/console/clipboard.h>
#include <gui/mouse.h>
#include <gui/screen.h>
#include <xbook/kmalloc.h>
clipboard_t clipboard;
int init_clipboard()
{
clipboard.click_x = -1;
clipboard.click_y = -1;
clipboard.start_x = -1;
clipboard.start_y = -1;
clipboard.mx = -1;
clipboard.my = -1;
clipboard.state = CLIPBOARD_AVALI;
clipboard.buflen = gui_con_screen.rows * gui_con_screen.columns;
clipboard.buf = kmalloc(clipboard.buflen);
if (clipboard.buf == NULL)
return -1;
memset(clipboard.buf, 0, clipboard.buflen);
return 0;
}
void exit_clipboard()
{
kfree(clipboard.buf);
}
void clipboard_start_select(int x, int y)
{
/* 开始框选 */
con_flush();
clipboard.click_x = x;
clipboard.click_y = y;
clipboard.start_x = x;
clipboard.start_y = y;
clipboard.mx = x;
clipboard.my = y;
con_region_chars(x, y, x, y);
clipboard.state = CLIPBOARD_START;
}
void clipboard_end_select()
{
clipboard.click_x = -1;
clipboard.click_y = -1;
clipboard.state = CLIPBOARD_END;
}
void clipboard_move_select(int x, int y)
{
/* 持续框选 */
if (clipboard.click_x >= 0 && clipboard.click_y >= 0) {
/* 刷新范围内的窗口 */
con_flush2(clipboard.mx, clipboard.my, x, y);
clipboard.mx = x;
clipboard.my = y;
/* 选择选取 */
con_region_chars(clipboard.click_x, clipboard.click_y, x, y);
}
}
void clipboard_break_select()
{
con_flush();
clipboard.click_x = -1;
clipboard.click_y = -1;
/* 被打断时，要把鼠标上次的颜色设置成背景色 */
gui_mouse.old_color = gui_screen.gui_to_screen_color(gui_con_screen.background_color);
gui_mouse.show(gui_mouse.x, gui_mouse.y);
}
/**
* clipboard_copy_select - 复制选中的内容
*
*/
void clipboard_copy_select()
{
/* 复制选中的内容 */
if (clipboard.state == CLIPBOARD_AVALI) { /* 空闲状态，把剪切板中的内容复制到命令行 */
focus_cursor();
int buflen = strlen(clipboard.buf);
if (buflen > 0) {
/* 对剪切板进行数据复制操作 */
//cmdline_set(clipboard.buf, buflen);
}
} else if (clipboard.state == CLIPBOARD_END) { /* 选择完毕，复制选中的内容 */
/*printf("start: %d, %d end: %d, %d\n", clipboard.start_x, clipboard.start_y,
clipboard.mx, clipboard.my);
*/
int x0 = clipboard.start_x, y0 = clipboard.start_y;
int x1 = clipboard.mx, y1 = clipboard.my;
int x, y;
int start_cx = -1, start_cy = -1; /* 尚未计算字符起始位置 */
int cx, cy; /* 尚未计算字符起始位置 */
int counts = 0; /* 字符数量 */
/* 计算刷新区域 */
int left, right, top, bottom;
top = min(y0, y1);
bottom = max(y0, y1);
/* 取整对齐 */
top = top / gui_con_screen.char_height * gui_con_screen.char_height;
bottom = bottom / gui_con_screen.char_height * gui_con_screen.char_height + gui_con_screen.char_height;
/* 计算行数 */
int lines = (bottom - top) / gui_con_screen.char_height;
//printf("lines=%d\n", lines);
if (lines > 1) { /* 选取多行，就需要刷新多行 */
if (y1 > y0) { /* 第一个点位于上方，那么，第一行的左边就是第一个点 */
left = x0;
} else { /* 第二个点位于上方，那么，第一行的左边就是第二个点 */
left = x1;
}
/* 第一行从左最小到右边框 */
right = gui_con_screen.width;
left = left / gui_con_screen.char_width * gui_con_screen.char_width;
y = top;
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 记录字符起始位置 */
if (start_cx == -1 && start_cy == -1) {
start_cx = cx;
start_cy = cy;
}
counts++;
}
y += gui_con_screen.char_height;
if (lines > 2) { /* 大于2行 */
/* 整行都选择 */
left = 0;
right = gui_con_screen.width;
while (lines > 2) {
for (x = left; x < right; x += gui_con_screen.char_width) {
counts++;
}
y += gui_con_screen.char_height;
lines--;
}
}
if (y1 > y0) {
right = x1; /* 第二个点位于下方，那么，最后一行的右边就是第二个点 */
} else {
right = x0; /* 第一个点位于下方，那么，最后一行的右边就是第一个点 */
}
/* 从左边框到最右最大 */
left = 0;
right = right / gui_con_screen.char_width * gui_con_screen.char_width + gui_con_screen.char_width;
/* 最后一行 */
for (x = left; x < right; x += gui_con_screen.char_width) {
counts++;
}
} else {
/* 最左到最右 */
left = min(x0, x1);
right = max(x0, x1);
left = left / gui_con_screen.char_width * gui_con_screen.char_width;
right = right / gui_con_screen.char_width * gui_con_screen.char_width + gui_con_screen.char_width;
y = top;
for (x = left; x < right; x += gui_con_screen.char_width) {
cx = x / gui_con_screen.char_width;
cy = y / gui_con_screen.char_height;
/* 记录字符起始位置 */
if (start_cx == -1 && start_cy == -1) {
start_cx = cx;
start_cy = cy;
}
counts++;
}
}
//printf("cx=%d, cy=%d, counts=%d\n", start_cx, start_cy, counts);
int buflen = min(clipboard.buflen, counts);
memset(clipboard.buf, 0, clipboard.buflen);
/* 获取字符 */
con_get_chars(clipboard.buf, buflen, start_cx, start_cy);
clipboard.state = CLIPBOARD_AVALI;
/* 重置选区 */
clipboard_break_select();
}
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/arch.h
|
#ifndef _X86_ARCH_H
#define _X86_ARCH_H
#include <arch/atomic.h>
#include <arch/bootmem.h>
#include <arch/cmos.h>
#include <arch/config.h>
#include <arch/gate.h>
#include <arch/io.h>
#include <arch/io.h>
#include <arch/interrupt.h>
#include <arch/instruction.h>
#include <arch/page.h>
#include <arch/pmem.h>
#include <arch/time.h>
#include <arch/ioremap.h>
#include <arch/task.h>
#endif /* _X86_ARCH_H */
|
NightfallDM/xbook2
|
library/xlibc/math/atan.c
|
/*
File: atan.c
Contains: For arctan(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT atan(M_FLOAT x) {
return (MATH_PI_4 * x - x * (fabs(x) - 1) * (0.2447 + 0.0663 * fabs(x)));
}
|
NightfallDM/xbook2
|
src/task/exec.c
|
<gh_stars>0
#include <xbook/process.h>
#include <string.h>
#include <xbook/pthread.h>
#include <xbook/srvcall.h>
#include <xbook/vmspace.h>
#include <xbook/debug.h>
#include <xbook/elf32.h>
#include <arch/interrupt.h>
#include <arch/task.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fsal/dir.h>
#include <fsal/fsal.h>
/**
* exec使用新的镜像以及堆栈替换原有的内容。
* 注意，加载代码和数据的过程中，不会释放掉已经映射的内容，
* 只是把虚拟内存空间结构释放掉。
* 内存映射也是安全映射，即如果虚拟地址没有映射才映射，已经映射就不映射。
* 只有在退出进程的时候才释放所有资源。这样也在一定程度上提高了效率，
* 但是占用的内存变大，是空间换取时间的做法。
*
* 如果在线程中执行exec，那么线程会全部关闭，并把当前进程用新进程镜像替换。
*
*/
#define DEBUG_LOCAL 0
/**
* do_execute - 替换当前进程的运行镜像
*
* @pathname: 文件路径名字
* @name: 进程的名字
* @argv: 参数的指针
* @envp: 环境的指针
*
* 通过给出的文件，解析加载镜像。
*
* @return: 失败返回-1，成功不返回
*/
static int do_execute(const char *pathname, char *name, const char *argv[], const char *envp[])
{
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "%s: enter.\n", __func__);
#endif
/* 没有参数或者参数错误 */
task_t *cur = current_task;
unsigned long flags;
save_intr(flags);
/* 执行新进程的时候，需要关闭旧进程的子线程。 */
close_other_threads(cur);
restore_intr(flags);
/* 根据文件信息创建临时原始块 */
int fd = sys_open(pathname, O_RDONLY, 0);
if (fd < 0) { /* file not exist! */
return -1;
}
struct stat sbuf;
if (sys_stat(pathname, &sbuf) < 0) {
pr_err("[exec]: %s: file stat failed!\n", __func__);
goto free_tmp_fd;
}
if (!sbuf.st_size) {
pr_err("[exec]: %s: file size is zero!\n", __func__);
goto free_tmp_fd;
}
#ifdef CONFIG_32BIT /* 32位 elf 头解析 */
/* 读取文件头 */
struct Elf32_Ehdr elf_header;
memset(&elf_header, 0, sizeof(struct Elf32_Ehdr));
sys_lseek(fd, 0, SEEK_SET);
if (sys_read(fd, &elf_header, sizeof(struct Elf32_Ehdr)) != sizeof(struct Elf32_Ehdr)) {
printk(KERN_ERR "sys_exec_file: read elf header failed!\n");
goto free_tmp_fd;
}
/* 检验elf头，看它是否为一个elf格式的程序 */
if (memcmp(elf_header.e_ident, "\177ELF\1\1\1", 7) || \
elf_header.e_type != 2 || \
elf_header.e_machine != 3 || \
elf_header.e_version != 1 || \
elf_header.e_phnum > 1024 || \
elf_header.e_phentsize != sizeof(struct Elf32_Phdr)) {
printk(KERN_DEBUG "sys_exec_file: ident=%s type=%d machine=%d version=%d phnum=%d\n",
elf_header.e_ident, elf_header.e_type, elf_header.e_machine,
elf_header.e_version, elf_header.e_phnum, elf_header.e_phentsize);
/* 头文件检测出错 */
printk(KERN_ERR "sys_exec_file: it is not a elf format file!\n", name);
goto free_tmp_fd;
}
#else /* CONFIG_64BIT 64位 elf 头解析 */
#endif
#if DEBUG_LOCAL == 1
int argc = 0;
printk(KERN_DEBUG "%s: dump args:\n", __func__);
if (argv) {
while (argv[argc]) {
printk(KERN_DEBUG "arg: %s\n", argv[argc]);
argc++;
}
}
int envc = 0;
printk(KERN_DEBUG "%s: dump envp:\n", __func__);
if (envp) {
while (envp[envc]) {
printk(KERN_DEBUG "env: %s\n", envp[envc]);
envc++;
}
}
#endif
/* 由于需要重载镜像数据，而传递的参数是在用户数据中，因此需要先保存
参数，然后再重载镜像 */
char *tmp_arg = kmalloc(PAGE_SIZE);
if (tmp_arg == NULL) {
printk(KERN_ERR "sys_exec_file: it is not a elf format file!\n", name);
goto free_tmp_fd;
}
/* 备份参数和环境 */
char **new_envp = NULL;
unsigned long arg_bottom;
proc_build_arg((unsigned long) tmp_arg + PAGE_SIZE, &arg_bottom, (char **) envp, &new_envp);
char **new_argv = NULL;
proc_build_arg(arg_bottom, NULL, (char **) argv, &new_argv);
/* 备份进程名 */
char tmp_name[MAX_TASK_NAMELEN] = {0};
strcpy(tmp_name, name);
/* 取消空间映射 */
// vmm_unmap_space(cur->vmm);
vmm_unmap_space_maparea(cur->vmm);
/* 释放虚拟空间地址管理，后面映射时重新加载镜像 */
vmm_release_space(cur->vmm);
/* 加载镜像 */
if (proc_load_image(cur->vmm, &elf_header, fd) < 0) {
printk(KERN_ERR "sys_exec_file: load_image failed!\n");
goto free_tmp_arg;
}
/* 构建中断栈框 */
trap_frame_t *frame = (trap_frame_t *)\
((unsigned long)cur + TASK_KSTACK_SIZE - sizeof(trap_frame_t));
proc_make_trap_frame(cur);
/* 初始化用户栈 */
if(proc_stack_init(cur, frame, new_argv, new_envp) < 0){
/* !!!需要取消已经加载镜像虚拟地址映射 */
goto free_loaded_image;
}
kfree(tmp_arg); /* 不需要了，释放掉 */
sys_close(fd); /* 正常关闭文件 */
/* 初始化用户堆 */
proc_heap_init(cur);
/* 初始化用户映射区域 */
proc_map_space_init(cur);
/* 初始化触发器 */
trigger_init(cur->triggers);
/* 如果是从一个多线程执行的，那么就会有线程结构体，由于在close_other_threads
的时候，把thread_count置0，因此，在此需要重新初始化线程描述（将thread_count置1） */
pthread_desc_init(cur->pthread);
fs_fd_reinit(cur);
/* 解除服务调用绑定 */
sys_srvcall_unbind(-1);
#if DEBUG_LOCAL == 1
if (cur->pthread) {
printk(KERN_DEBUG "%s: thread count %d\n", __func__, atomic_get(&cur->pthread->thread_count));
}
#endif
/* 执行程序的时候需要继承原有进程的资源，因此不在这里初始化资源 */
/* 设置执行入口 */
user_entry_point(frame, (unsigned long)elf_header.e_entry);
/* 设置进程名 */
memset(cur->name, 0, MAX_TASK_NAMELEN);
strcpy(cur->name, tmp_name);
//dump_trap_frame(frame);
/* 切换到进程执行 */
switch_to_user(frame);
/* 不会继续往后执行 */
free_loaded_image:
/* 释放已经加载的镜像，不过由于已经替换了新的镜像，回不去了，就直接exit吧。 */
sys_exit(-1);
free_tmp_arg:
kfree(tmp_arg);
free_tmp_fd:
sys_close(fd);
return -1;
}
int sys_execve(const char *pathname, const char *argv[], const char *envp[])
{
/* 检查参数 */
if (pathname == NULL)
return -1;
/* 先查看pathname是否在根目录下 */
char *p = (char *) pathname;
char newpath[MAX_PATH];
memset(newpath, 0, MAX_PATH);
/* 是在根目录下面，就查看这个目录 */
if (*p == '/') {
wash_path(p, newpath);
if (!sys_access((const char *) newpath, F_OK)) { /* file exist */
/* 名字指向文件名 */
char *name = strrchr(newpath, '/');
if (name) {
name++; /* 跳过'/' */
} else { /* 找到'/'，那就和路径一样 */
name = (char *) newpath;
}
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "execute: full path: %s -> %s\n", newpath, name);
#endif
/* 尝试替换镜像 */
if (do_execute((const char *) p, name, argv, envp) < 0) {
/* 替换失败 */
printk(KERN_ERR "%s: path %s not executable!", __func__, newpath);
return -1;
}
}
} else if ((*p == '.' && *(p+1) == '/') || (*p == '.' && *(p+1) == '.' && *(p+2) == '/')) { /* 当前目录 */
/* 构建路径 */
build_path(p, newpath);
#if DEBUG_LOCAL == 0
printk(KERN_DEBUG "execute: merged path: %s from %s\n", newpath, p);
#endif
if (!sys_access(newpath, F_OK)) { /* file exist */
char *pname = strrchr(newpath, '/');
if (pname)
pname++;
else
pname = newpath;
/* 替换镜像 */
if (do_execute((const char* )newpath, (char *)pname, argv, envp)) {
/* 替换失败 */
printk(KERN_ERR "%s: path %s not executable!", __func__, newpath);
return -1;
}
}
} else { /* 不是在根目录下面，只有文件名，需要进行和环境变量组合 */
if (envp) { /* 有环境才进行组合 */
char **env = (char **) envp;
char *q;
while (*env) {
q = *env;
/* 构建路径 */
strcpy(newpath, q);
if (newpath[strlen(newpath) - 1] != '/') {
strcat(newpath, "/");
}
strcat(newpath, p);
char finalpath[MAX_PATH] = {0};
wash_path(newpath, finalpath);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "execute: merged path: %s from %s\n", finalpath, p);
#endif
/* 尝试执行 */
if (!sys_access(finalpath, F_OK)) { /* file exist */
char *pname = strrchr(finalpath, '/');
if (pname)
pname++;
else
pname = finalpath;
/* 替换镜像 */
do_execute((const char* )finalpath, (char *)pname, argv, envp);
}
env++;
memset(newpath, 0, MAX_PATH);
}
}
}
printk(KERN_ERR "%s: path %s not exist or not executable!\n", __func__, pathname);
return -1; /* 失败 */
}
|
NightfallDM/xbook2
|
library/xlibc/include/sys/dir.h
|
<filename>library/xlibc/include/sys/dir.h
#ifndef _SYS_DIR_H
#define _SYS_DIR_H
void build_path(const char *path, char *out_path);
#endif /* _SYS_DIR_H */
|
NightfallDM/xbook2
|
library/xlibc/stdlib/labs.c
|
#include<stdlib.h>
long int labs(long int const i)
{
return i>0?i:-i;
}
|
NightfallDM/xbook2
|
src/include/gui/screen.h
|
<reponame>NightfallDM/xbook2
#ifndef __GUISRV_DRIVER_SCREEN_H__
#define __GUISRV_DRIVER_SCREEN_H__
#include <gui/color.h>
typedef struct {
int width;
int height;
/* 颜色转换 */
SCREEN_COLOR (*gui_to_screen_color)(GUI_COLOR gui_color);
GUI_COLOR (*screen_to_gui_color)(SCREEN_COLOR screen_color);
int (*open)(void);
int (*close)(void);
int (*output_pixel)(int x, int y, SCREEN_COLOR color);
int (*input_pixel)(int x, int y, SCREEN_COLOR *color);
int (*output_hline)(int left, int right, int top, SCREEN_COLOR color);
int (*output_vline)(int left, int top, int bottom, SCREEN_COLOR color);
int (*output_rect_fill)(int left, int top, int right, int bottom, SCREEN_COLOR color);
} gui_screen_t;
extern gui_screen_t gui_screen;
int gui_init_screen();
#endif /* __GUISRV_DRIVER_SCREEN_H__ */
|
NightfallDM/xbook2
|
library/xlibc/math/log2.c
|
/*
File: log2.c
Contains: For log(2)(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT log2(float x) {
union {
float f;
unsigned int i;
} vx = { x };
union {
unsigned int i;
float f;
} mx = { (vx.i & 0x007FFFFF) | (0x7e << 23) };
float y = vx.i;
y *= 1.0 / (1 << 23);
return (y - 124.22544637f - 1.498030302f * mx.f - 1.72587999f / (0.3520887068f + mx.f));
}
|
NightfallDM/xbook2
|
src/arch/x86/mach-i386/task.c
|
#include <arch/task.h>
#include <arch/interrupt.h>
#include <arch/segment.h>
#include <xbook/syscall.h>
#include <xbook/trigger.h>
#include <xbook/vmspace.h>
#include <xbook/process.h>
#include <xbook/debug.h>
#include <string.h>
void __user_trap_frame_init(trap_frame_t *frame)
{
/* 数据段 */
frame->ds = frame->es = \
frame->fs = frame->gs = USER_DATA_SEL;
/* 代码段 */
frame->cs = USER_CODE_SEL;
/* 栈段 */
frame->ss = USER_STACK_SEL;
/* 设置通用寄存器的值 */
frame->edi = frame->esi = \
frame->ebp = frame->esp_dummy = 0;
frame->eax = frame->ebx = \
frame->ecx = frame->edx = 0;
/* 为了能让程序首次运行，这里需要设置eflags的值 */
frame->eflags = (EFLAGS_MBS | EFLAGS_IF_1 | EFLAGS_IOPL_0);
}
void __ktask_trap_frame_init(trap_frame_t *frame)
{
/* 数据段 */
frame->ds = frame->es = \
frame->fs = frame->gs = SERVE_DATA_SEL;
/* 代码段 */
frame->cs = SERVE_CODE_SEL;
/* 栈段 */
frame->ss = SERVE_STACK_SEL;
/* 设置通用寄存器的值 */
frame->edi = frame->esi = \
frame->ebp = frame->esp_dummy = 0;
frame->eax = frame->ebx = \
frame->ecx = frame->edx = 0;
/* 为了能让程序首次运行，这里需要设置eflags的值 */
frame->eflags = (EFLAGS_MBS | EFLAGS_IF_1 | EFLAGS_IOPL_1);
}
void __kernel_trap_frame_init(trap_frame_t *frame)
{
/* 数据段 */
frame->ds = frame->es = \
frame->fs = frame->gs = KERNEL_DATA_SEL;
/* 代码段 */
frame->cs = KERNEL_CODE_SEL;
/* 栈段 */
frame->ss = KERNEL_STACK_SEL;
/* 设置通用寄存器的值 */
frame->edi = frame->esi = \
frame->ebp = frame->esp_dummy = 0;
frame->eax = frame->ebx = \
frame->ecx = frame->edx = 0;
/* 为了能让程序首次运行，这里需要设置eflags的值 */
frame->eflags = (EFLAGS_MBS | EFLAGS_IF_1 | EFLAGS_IOPL_1);
}
void __build_trigger_frame(int trig, void *_act, trap_frame_t *frame)
{
trig_action_t *act = (trig_action_t *)_act;
/* 获取信号栈框，在用户的esp栈下面 */
trigger_frame_t *trigger_frame = (trigger_frame_t *)((frame->esp - sizeof(trigger_frame_t)) & -8UL);
/*
printk("trap frame %x, signal frame esp %x, %x\n",
frame->esp, frame->esp - sizeof(trigger_frame_t), (frame->esp - sizeof(trigger_frame_t)) & -8UL);
*/
/* 传递给handler的参数 */
trigger_frame->trig = trig;
trigger_frame->oldmask = current_task->triggers->blocked;
/* 把中断栈保存到信号栈中 */
memcpy(&trigger_frame->trap_frame, frame, sizeof(trap_frame_t));
/* 设置返回地址为构建的返回代码 */
trigger_frame->ret_addr = trigger_frame->ret_code;
/* 构建返回代码，系统调用封装
模拟系统调用来实现从用户态返回到内核态
mov eax, SYS_TRIGRET
int 0x40
*/
trigger_frame->ret_code[0] = 0xb8; /* 给eax赋值的机器码 */
*(uint32_t *)(trigger_frame->ret_code + 1) = SYS_TRIGRET; /* 把系统调用号填进去 */
*(uint16_t *)(trigger_frame->ret_code + 5) = 0x40cd; /* int对应的指令是0xcd，系统调用中断号是0x40 */
/* 设置中断栈的eip成为用户设定的处理函数 */
frame->eip = (unsigned int)act->handler;
/* 设置运行时的栈 */
frame->esp = (unsigned int)trigger_frame;
/* 设置成用户态的段寄存器 */
frame->ds = frame->es = frame->fs = frame->gs = USER_DATA_SEL;
frame->ss = USER_STACK_SEL;
frame->cs = USER_CODE_SEL;
}
void __build_user_thread_frame(trap_frame_t *frame, void *arg, void *func,
void *thread_entry, void *stack_top)
{
frame->ebx = (unsigned long) arg; /* 参数 */
frame->ecx = (unsigned long) func; /* 线程例程入口 */
frame->eip = (unsigned long) thread_entry;
frame->esp = (unsigned long) stack_top;
}
/**
* KernelThread - 执行内核线程
* @function: 要执行的线程
* @arg: 参数
*
* 改变当前的执行流，去执行我们选择的内核线程
*/
static void kernel_thread(task_func_t *function, void *arg)
{
enable_intr(); /* 在启动前需要打开中断，避免启动后不能产生时钟中断调度 */
function(arg);
}
/**
* __make_task_stack - 创建一个线程的执行环境
* @task: 线程结构体
* @function: 要去执行的函数
* @arg: 参数
*/
void __make_task_stack(task_t *task, task_func_t *function, void *arg)
{
/* 预留中断栈 */
task->kstack -= sizeof(trap_frame_t);
/* 预留线程栈 */
task->kstack -= sizeof(thread_stack_t);
thread_stack_t *thread_stack = (thread_stack_t *)task->kstack;
/* 填写线程栈信息 */
// 在kernel_thread中去改变执行流，从而可以传递一个参数
thread_stack->eip = kernel_thread;
thread_stack->function = function;
thread_stack->arg = arg;
thread_stack->ebp = thread_stack->ebx = \
thread_stack->esi = thread_stack->edi = 0;
}
int __fork_bulid_child_stack(task_t *child)
{
/* 1.让子进程返回0 */
/* 获取中断栈框 */
trap_frame_t *frame = (trap_frame_t *)(
(unsigned long)child + TASK_KSTACK_SIZE - sizeof(trap_frame_t));
/*
printk("edi: %x esi: %x ebp: %x esp: %x\n",
frame->edi, frame->esi, frame->ebp, frame->esp);
printk("ebx: %x edx: %x ecx: %x eax: %x\n",
frame->ebx, frame->edx, frame->ecx, frame->eax);
printk("gs: %x fs: %x es: %x ds: %x\n",
frame->gs, frame->fs, frame->es, frame->ds);
printk("err: %x eip: %x cs: %x eflags: %x\n",
frame->errorCode, frame->eip, frame->cs, frame->eflags);
printk("esp: %x ss: %x\n",
frame->esp, frame->ss);
*/
//printk(PART_TIP "task at %x fram at %x\n", child, frame);
/* 设置eax为0，就相当于设置了子任务的返回值为0 */
frame->eax = 0;
/* 线程栈我们需要的数据只有5个，即ebp，ebx，edi，esi，eip */
thread_stack_t *thread_stack = (thread_stack_t *)\
((unsigned long *)frame - 5);
/* 把SwitchTo的返回地址设置成InterruptExit，直接从中断返回 */
//thread_stack->eip = (unsigned long)&InterruptExit;
thread_stack->eip = (void *)intr_exit;
//printk(PART_TIP "thread_stack eip %x\n", thread_stack->eip);
/* 下面的赋值只是用来使线程栈构建更清晰，下面2行的赋值其实不必要，
因为在进入InterruptExit之后会进行一系列pop把寄存器覆盖掉 */
thread_stack->ebp = thread_stack->ebx = \
thread_stack->esi = thread_stack->edi = 0;
/* 把构建的线程栈的栈顶最为switch_to恢复数据时的栈顶 */
child->kstack = (uint8_t *)&thread_stack->ebp;
//printk(PART_TIP "kstack %x\n", child->kstack);
/* 2.为SwitchTo构建线程环境，在中断栈框下面 */
//unsigned long *retAddrInthread_stack = (unsigned long *)frame - 1;
/* 这3行只是为了梳理线程栈中的关系，不一定要写出来 */
/* unsigned long *esiInInthread_stack = (unsigned long *)frame - 2;
unsigned long *ediInInthread_stack = (unsigned long *)frame - 3;
unsigned long *ebxInInthread_stack = (unsigned long *)frame - 4; */
/* ebp在线程栈中的地址便是当时esp（0级栈的栈顶），也就是esp
为 "(unsigned long *)frame - 5"*/
//unsigned long *ebpInInthread_stack = (unsigned long *)frame - 5;
/* 把SwitchTo的返回地址设置成InterruptExit，直接从中断返回 */
// *retAddrInthread_stack = (unsigned long)&InterruptExit;
/* 下面的赋值只是用来使线程栈构建更清晰，下面2行的赋值其实不必要，
因为在进入InterruptExit之后会进行一系列pop把寄存器覆盖掉 */
/* *ebpInInthread_stack = *ebxInInthread_stack = \
*ediInInthread_stack = *esiInInthread_stack = 0;*/
/* 把构建的线程栈的栈顶最为SwitchTo恢复数据时的栈顶 */
//child->kstack = (uint8_t *)ebpInInthread_stack;
return 0;
}
/**
* __proc_stack_init - 初始化用户栈和参数
*
*/
int __proc_stack_init(task_t *task, trap_frame_t *frame, char **argv, char **envp)
{
vmm_t *vmm = task->vmm;
vmm->stack_end = USER_STACK_TOP;
vmm->stack_start = vmm->stack_end - DEFAULT_STACK_SIZE; /* 栈大小 */
/* 固定位置，初始化时需要一个固定位置，向下拓展时才动态。 */
if (vmspace_mmap(vmm->stack_start, 0, vmm->stack_end - vmm->stack_start , PROT_USER | PROT_WRITE,
VMS_MAP_FIXED | VMS_MAP_STACK) == ((void *)-1)) {
return -1;
}
memset((void *) vmm->stack_start, 0, vmm->stack_end - vmm->stack_start);
int argc = 0;
char **new_envp = NULL;
unsigned long arg_bottom = 0;
argc = proc_build_arg(vmm->stack_end, &arg_bottom, envp, &new_envp);
char **new_argv = NULL;
argc = proc_build_arg(arg_bottom, &arg_bottom, argv, &new_argv);
/* 记录参数个数 */
frame->ecx = argc;
/* 记录参数地址 */
frame->ebx = (unsigned int) new_argv;
/* 记录环境地址 */
frame->edx = (unsigned int) new_envp;
/* 记录栈顶 */
if (!arg_bottom) { /* 解析参数出错 */
vmspace_unmmap(vmm->stack_start, vmm->stack_end - vmm->stack_start);
return -1;
}
frame->esp = (unsigned long) arg_bottom; /* 栈位于参数的下面 */
frame->ebp = frame->esp;
#if 0 /* stack info */
printk(KERN_DEBUG "task %s arg space: start %x end %x\n",
(current_task)->name, vmm->arg_start, vmm->arg_end);
printk(KERN_DEBUG "task %s stack space: start %x end %x\n",
(current_task)->name, vmm->stack_start, vmm->stack_end);
printk(KERN_DEBUG "stack %x argc %d argv %x\n", frame->esp, frame->ecx, frame->ebx);
#endif
#if 0 /* print args */
int i = 0;
while (new_argv[i]) {
printk("[%x %x]", new_argv[i], new_argv[i][0]);
printk("%s ", new_argv[i]);
i++;
}
#endif
return 0;
}
/**
* __trigger_return - 执行完可捕捉触发器后返回
* @frame: 栈
*
*/
int __trigger_return(trap_frame_t *frame)
{
//printk("arg is %x %x %x %x %x\n", ebx, ecx, esi, edi, frame);
//printk("usr esp - 4:%x esp:%x\n", *(uint32_t *)(frame->esp - 4), *(uint32_t *)frame->esp);
/* 原本trigger_frame是在用户栈esp-trigger_frameSize这个位置，但是由于调用了用户处理程序后，
函数会把返回地址弹出，也就是esp+4，所以，需要通过esp-4才能获取到trigger_frame */
trigger_frame_t *trigger_frame = (trigger_frame_t *)(frame->esp - 4);
trigset_t oldset = trigger_frame->oldmask;
triggers_t *trigger = current_task->triggers;
spin_lock_irq(&trigger->trig_lock);
trigger->blocked = oldset;
trigger_calc_left(trigger);
spin_unlock_irq(&trigger->trig_lock);
/* 还原之前的中断栈 */
memcpy(frame, &trigger_frame->trap_frame, sizeof(trap_frame_t));
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "sys_trigger_return: ret val 0x%x.\n", frame->eax);
#endif
/* 会修改eax的值，返回eax的值 */
return frame->eax;
}
void dump_task_kstack(thread_stack_t *kstack)
{
printk(KERN_INFO "eip:%x func:%x arg:%x ebp:%x ebx:%x esi:%x edi:%x\n",
kstack->eip, kstack->function, kstack->arg, kstack->ebp, kstack->ebx, kstack->esi, kstack->edi);
}
|
NightfallDM/xbook2
|
src/kernel/driver.c
|
#include <xbook/driver.h>
#include <math.h>
#include <xbook/vine.h>
#include <xbook/debug.h>
#include <assert.h>
#include <xbook/mdl.h>
#include <xbook/clock.h>
#include <string.h>
#include <xbook/vmspace.h>
#include <sys/ioctl.h>
#include <xbook/pci.h>
#include <xbook/config.h>
#include <xbook/vmarea.h>
#define DEBUG_LOCAL 0
/* 驱动链表头 */
LIST_HEAD(driver_list_head);
/* 驱动藤蔓表：
虚拟设备必须在物理设备初始化完成后
*/
driver_func_t driver_vine_table[] = {
serial_driver_vine, /* char */
console_driver_vine, /* char */
#ifdef CONFIG_AHCI
ahci_driver_vine, /* disk */
#else
ide_driver_vine, /* disk */
#endif
rtl8139_driver_vine, /* net */
keyboard_driver_vine, /* input */
ramdisk_driver_vine, /* disk */
vbe_driver_vine, /* video */
mouse_driver_vine, /* input */
tty_driver_vine, /* filter: tty */
null_driver_vine, /* filter: null */
};
/* 打开的设备表 */
device_object_t *device_handle_table[DEVICE_HANDLE_NR];
/* 维护驱动的锁 */
DEFINE_SPIN_LOCK_UNLOCKED(driver_lock);
iostatus_t default_device_dispatch(device_object_t *device, io_request_t *ioreq)
{
ioreq->io_status.infomation = 0;
ioreq->io_status.status = IO_SUCCESS;
io_complete_request(ioreq);
return IO_SUCCESS; /* 默认是表示执行成功 */
}
#if DEBUG_LOCAL == 2 /* print devices */
static void print_drivers()
{
driver_object_t *drvobj;
device_object_t *devobj;
int device_count;
printk(KERN_INFO "io system info-> drivers\n");
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
printk(KERN_INFO "driver: name=%s\n", drvobj->name.text);
device_count = 0;
list_for_each_owner (devobj, &drvobj->device_list, list) {
printk(KERN_INFO " device: name=%s\n", devobj->name.text);
device_count++;
}
printk(KERN_INFO " device: count=%d\n", device_count);
}
}
static void print_drivers_mini()
{
driver_object_t *drvobj;
device_object_t *devobj;
int device_count;
printk(KERN_INFO "io system info-> drivers\n");
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
list_for_each_owner (devobj, &drvobj->device_list, list) {
printk("%s ", devobj->name.text);
}
}
printk("\n");
}
#endif
static driver_object_t *io_search_driver_by_name(char *drvname)
{
driver_object_t *drvobj;
spin_lock(&driver_lock);
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
if (!strcmp(drvobj->name.text, drvname)) {
spin_unlock(&driver_lock);
return drvobj;
}
}
spin_unlock(&driver_lock);
return NULL;
}
/**
* device_handle_table_search_by_name - 通过名字来搜索一个设备句柄
* @name: 设备名
*
* @return: 成功返回设备指针，失败返回NULL
*/
device_object_t *device_handle_table_search_by_name(char *name)
{
device_object_t *devobj;
int i;
for (i = 0; i < DEVICE_HANDLE_NR; i++) {
devobj = device_handle_table[i];
if (devobj != NULL) {
if (!strcmp(devobj->name.text, name)) {
return devobj;
}
}
}
return NULL;
}
/**
* device_handle_find_by_object - 通过设备来搜索一个设备句柄
* @devobj: 设备对象
*
* @return: 成功返回句柄，失败返回-1
*/
handle_t device_handle_find_by_object(device_object_t *devobj)
{
device_object_t *_devobj;
int i;
for (i = 0; i < DEVICE_HANDLE_NR; i++) {
_devobj = device_handle_table[i];
if (_devobj == devobj) {
return i;
}
}
return -1;
}
/**
* device_handle_table_insert - 把一个设备插入到设备句柄表
* @devobj: 设备
*
* @return: 成功返回句柄，失败返回-1
*/
int device_handle_table_insert(device_object_t *devobj)
{
device_object_t **_devobj;
int i;
for (i = 0; i < DEVICE_HANDLE_NR; i++) {
_devobj = &device_handle_table[i];
if (*_devobj == NULL) { /* 表项如果空闲，就插入 */
*_devobj = devobj;
return i;
}
}
return -1;
}
/**
* device_handle_table_remove - 把一个设备从设备句柄表中删除
* @devobj: 设备
*
* @return: 成功返回0，失败返回-1
*/
int device_handle_table_remove(device_object_t *devobj)
{
device_object_t **_devobj;
int i;
for (i = 0; i < DEVICE_HANDLE_NR; i++) {
_devobj = &device_handle_table[i];
if (*_devobj) { /* 表项如果空闲，就插入 */
if (!strcmp((*_devobj)->name.text, devobj->name.text) &&
(*_devobj)->type == devobj->type) {
*_devobj = NULL; /* 设置为NULL，表示删除 */
return 0;
}
}
}
return -1;
}
/**
* io_search_device_by_name - 通过名字来搜索一个设备
* @name: 设备名
*
* @return: 成功返回设备指针，失败返回NULL
*/
device_object_t *io_search_device_by_name(char *name)
{
driver_object_t *drvobj;
device_object_t *devobj;
spin_lock(&driver_lock);
/* 先到表里面查找，没有找到就去驱动链表查找 */
devobj = device_handle_table_search_by_name(name);
if (devobj) {
spin_unlock(&driver_lock);
return devobj;
}
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
list_for_each_owner (devobj, &drvobj->device_list, list) {
if (!strcmp(devobj->name.text, name)) {
spin_unlock(&driver_lock);
return devobj;
}
}
}
spin_unlock(&driver_lock);
return NULL;
}
void driver_object_init(driver_object_t *driver)
{
INIT_LIST_HEAD(&driver->device_list);
INIT_LIST_HEAD(&driver->list);
driver->drver_extension = NULL;
driver->driver_enter = NULL;
driver->driver_exit = NULL;
int i;
for (i = 0; i < MAX_IOREQ_FUNCTION_NR; i++) {
driver->dispatch_function[i] = default_device_dispatch;
}
string_init(&driver->name);
spinlock_init(&driver->device_lock);
}
/**
* driver_object_create - 根据藤蔓创建驱动
* @vine: 藤蔓
*
* 藤蔓是指向一个驱动的一个函数指针，通过调用这个指针来创建一个驱动
*
* @return: 成功返回0，失败返回-1
*/
int driver_object_create(driver_func_t vine)
{
driver_object_t *drvobj;
iostatus_t status;
drvobj = kmalloc(sizeof(driver_object_t));
if (drvobj == NULL)
return -1;
/* 初始化驱动对象 */
driver_object_init(drvobj);
status = vine(drvobj);
if (status != IO_SUCCESS) {
kfree(drvobj); /* 释放驱动对象 */
return -1;
}
/* 执行驱动进入部分 */
if (drvobj->driver_enter)
status = drvobj->driver_enter(drvobj);
if (status != IO_SUCCESS) {
kfree(drvobj); /* 释放驱动对象 */
return -1;
}
unsigned long flags;
spin_lock_irqsave(&driver_lock, flags);
/* 将驱动添加到系统中 */
ASSERT(!list_find(&drvobj->list, &driver_list_head));
//printk("%s: <%x %x>\n", __func__,&drvobj->list, &driver_list_head);
list_add_tail(&drvobj->list, &driver_list_head);
spin_unlock_irqrestore(&driver_lock, flags);
return 0;
}
int driver_object_delete(driver_object_t *driver)
{
iostatus_t status = IO_SUCCESS;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "driver_object_delete: driver %s delete start.\n",
driver->name.text);
#endif
/* 执行驱动进入部分 */
if (driver->driver_exit)
status = driver->driver_exit(driver);
if (status != IO_SUCCESS) {
return -1;
}
unsigned long flags;
spin_lock_irqsave(&driver_lock, flags);
/* 将驱动添加到系统中 */
ASSERT(list_find(&driver->list, &driver_list_head));
list_del(&driver->list);
spin_unlock_irqrestore(&driver_lock, flags);
/* 释放掉驱动对象 */
kfree(driver);
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "driver_object_delete: driver delete done.\n");
#endif
return status;
}
/**
* io_device_queue_init - 设备队列初始化
* @queue: 队列
*/
void io_device_queue_init(device_queue_t *queue)
{
/* 初始化设备队列 */
spinlock_init(&queue->lock);
INIT_LIST_HEAD(&queue->list_head);
wait_queue_init(&queue->wait_queue);
queue->entry_count = 0;
}
/**
* io_search_device_by_name - 通过名字来搜索一个设备
* @name: 设备名
*
* @return: 成功返回设备指针，失败返回NULL
*/
device_object_t *io_iterative_search_device_by_type(device_object_t *devptr, device_type_t type)
{
driver_object_t *drvobj;
device_object_t *devobj;
int flags = 0; /* 标记可迭代对象 */
spin_lock(&driver_lock);
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
list_for_each_owner (devobj, &drvobj->device_list, list) {
if (devobj->type == type) { /* 设备类型 */
/* 搜索是第一个设备 */
if (devptr == NULL) {
spin_unlock(&driver_lock);
return devobj;
} else {
if (flags) { /* 可以选择下一个设备，就直接返回下一个设备 */
spin_unlock(&driver_lock);
return devobj;
}
if (devptr == devobj) { /* 找到和当前设备一样的设备 */
flags = 1; /* 下一次就是后面的迭代设备对象 */
}
}
}
}
}
spin_unlock(&driver_lock);
return NULL;
}
/**
* sys_devscan - 扫描某种类型的设备
* @de: 输入的设备项
* @type: 设备类型
* @out: 输出设备项
*
* @return: 成功返回0，失败返回-1
*/
int sys_devscan(devent_t *de, device_type_t type, devent_t *out)
{
if (!out)
return -1;
driver_object_t *drvobj;
device_object_t *devobj;
int flags = 0; /* 标记可迭代对象 */
spin_lock(&driver_lock);
/* 遍历所有的驱动 */
list_for_each_owner (drvobj, &driver_list_head, list) {
list_for_each_owner (devobj, &drvobj->device_list, list) {
if (devobj->type == type) { /* 设备类型 */
/* 搜索是第一个设备 */
if (de == NULL) {
memset(out->de_name, 0, DEVICE_NAME_LEN);
strcpy(out->de_name, devobj->name.text);
out->de_type = type;
spin_unlock(&driver_lock);
return 0;
} else {
if (flags) { /* 可以选择下一个设备，就直接返回下一个设备 */
memset(out->de_name, 0, DEVICE_NAME_LEN);
strcpy(out->de_name, devobj->name.text);
out->de_type = type;
spin_unlock(&driver_lock);
return 0;
}
if (!strcmp(de->de_name, devobj->name.text)) { /* 找到和当前设备一样的设备 */
flags = 1; /* 下一次就是后面的迭代设备对象 */
}
}
}
}
}
spin_unlock(&driver_lock);
return -1;
}
/**
* io_create_device - 创建一个设备
*
* 在驱动里面创建一个设备。
* 注意：device参数是一个需要传回的设备指针
*
* @return: 成功返回IO_SUCCESS，失败返回IO_FAILED
*/
iostatus_t io_create_device(
driver_object_t *driver,
unsigned long device_extension_size,
char *device_name,
device_type_t type,
device_object_t **device
) {
device_object_t *devobj;
devobj = kmalloc(sizeof(device_object_t) + device_extension_size);
if (devobj == NULL)
return IO_FAILED;
/* 填写设备信息 */
INIT_LIST_HEAD(&devobj->list);
devobj->type = type;
if (device_extension_size > 0)
devobj->device_extension = (void *) (devobj + 1); /* 设备扩展的空间位于设备末尾 */
else /* 没有扩展就指向NULL */
devobj->device_extension = NULL;
devobj->flags = 0;
atomic_set(&devobj->reference, 0);
devobj->cur_ioreq = NULL;
devobj->reserved = 0;
/* 如果创建字符串失败，就返回 */
if (string_new(&devobj->name, device_name, DEVICE_NAME_LEN)) {
kfree(devobj);
return IO_FAILED;
}
devobj->driver = driver; /* 绑定驱动 */
spinlock_init(&devobj->lock.spinlock); /* 初始化设备锁-自旋锁 */
mutexlock_init(&devobj->lock.mutexlock); /* 初始化设备锁-互斥锁 */
spin_lock(&driver->device_lock);
/* 设备创建好后，添加到驱动链表上 */
ASSERT(!list_find(&devobj->list, &driver->device_list));
//printk("%s: <%x %x>\n", __func__,&devobj->list, &driver->device_list);
list_add_tail(&devobj->list, &driver->device_list);
spin_unlock(&driver->device_lock);
/* 把设备地址保存到device里面 */
*device = devobj;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "io_create_device: create device done.\n");
#endif
return IO_SUCCESS;
}
/**
* io_delete_device - 删除一个设备
*/
void io_delete_device(
device_object_t *device
) {
if (device == NULL)
return;
device_object_t *devobj;
spin_lock(&driver_lock);
/* 查看是否还在使用中 */
devobj = device_handle_table_search_by_name(device->name.text);
if (devobj) { /* 在使用中就从句柄表中删除 */
printk(KERN_DEBUG "io_delete_device: device %s is using!\n",
devobj->name.text);
device_handle_table_remove(devobj);
}
spin_unlock(&driver_lock);
devobj = device;
driver_object_t *driver = device->driver;
spin_lock(&driver->device_lock);
/* 先从驱动链表中删除 */
ASSERT(list_find(&devobj->list, &driver->device_list));
list_del(&devobj->list);
spin_unlock(&driver->device_lock);
string_del(&devobj->name); /* 释放名字 */
/* 释放设备对象 */
kfree(devobj);
}
io_request_t *io_request_alloc()
{
io_request_t *ioreq = kmalloc(sizeof(io_request_t));
if (ioreq)
memset(ioreq, 0, sizeof(io_request_t));
return ioreq;
}
void io_request_free(io_request_t *ioreq)
{
kfree(ioreq);
}
iostatus_t io_call_dirver(device_object_t *device, io_request_t *ioreq)
{
iostatus_t status= IO_SUCCESS;
driver_dispatch_t func = NULL;
/* 根据设备类型选择不同的锁 */
switch (device->type)
{
case DEVICE_TYPE_SERIAL_PORT:
case DEVICE_TYPE_SCREEN:
case DEVICE_TYPE_KEYBOARD:
case DEVICE_TYPE_MOUSE:
case DEVICE_TYPE_VIRTUAL_CHAR:
spin_lock(&device->lock.spinlock);
break;
case DEVICE_TYPE_DISK:
mutex_lock(&device->lock.mutexlock);
break;
default:
break;
}
/* 选择操作函数 */
if (ioreq->flags & IOREQ_OPEN_OPERATION) {
func = device->driver->dispatch_function[IOREQ_OPEN];
} else if (ioreq->flags & IOREQ_CLOSE_OPERATION) {
func = device->driver->dispatch_function[IOREQ_CLOSE];
} else if (ioreq->flags & IOREQ_READ_OPERATION) {
func = device->driver->dispatch_function[IOREQ_READ];
} else if (ioreq->flags & IOREQ_WRITE_OPERATION) {
func = device->driver->dispatch_function[IOREQ_WRITE];
} else if (ioreq->flags & IOREQ_DEVCTL_OPERATION) {
func = device->driver->dispatch_function[IOREQ_DEVCTL];
} else if (ioreq->flags & IOREQ_MMAP_OPERATION) {
func = device->driver->dispatch_function[IOREQ_MMAP];
}
if (func)
status = func(device, ioreq); /* 执行操作 */
return status;
}
io_request_t *io_build_sync_request(
unsigned long function,
device_object_t *devobj,
void *buffer,
unsigned long length,
unsigned long offset,
io_status_block_t *io_status_block
){
io_request_t *ioreq = io_request_alloc();
if (ioreq == NULL) {
io_status_block->status = IO_FAILED;
return NULL;
}
ioreq->devobj = devobj;
/* 设置请求的状态 */
if (io_status_block) {
ioreq->io_status = *io_status_block;
} else {
ioreq->io_status.infomation = 0;
ioreq->io_status.status = IO_FAILED;
}
INIT_LIST_HEAD(&ioreq->list);
ioreq->system_buffer = NULL;
ioreq->user_buffer = buffer; /* 指向用户地址 */
ioreq->mdl_address = NULL;
if (buffer) {
if (devobj->flags & DO_BUFFERED_IO) {
/* 分配一个内存缓冲区 */
if (length >= MAX_MEM_CACHE_SIZE) {
length = MAX_MEM_CACHE_SIZE; /* 调整大小 */
printk(KERN_WARING "io_build_sync_request: length too big!\n");
}
ioreq->system_buffer = kmalloc(length);
if (ioreq->system_buffer == NULL) {
kfree(ioreq);
return NULL;
}
ioreq->flags |= IOREQ_BUFFERED_IO;
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "io_build_sync_request: system buffer.\n");
#endif
} else if (devobj->flags & DO_DIRECT_IO) {
ioreq->mdl_address = mdl_alloc(buffer, length, FALSE, ioreq);
if (ioreq->mdl_address == NULL) {
kfree(ioreq);
return NULL;
}
/* 分配内存描述列表 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "io_build_sync_request: direct buffer.\n");
#endif
} else { /* 直接使用用户地址 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "io_build_sync_request: user buffer.\n");
#endif
}
}
unsigned long flags;
switch (function)
{
case IOREQ_OPEN:
ioreq->flags |= IOREQ_OPEN_OPERATION;
ioreq->parame.open.devname = NULL;
ioreq->parame.open.flags = 0;
break;
case IOREQ_CLOSE:
ioreq->flags |= IOREQ_CLOSE_OPERATION;
break;
case IOREQ_READ:
ioreq->flags |= IOREQ_READ_OPERATION;
ioreq->parame.read.length = length;
ioreq->parame.read.offset = offset;
break;
case IOREQ_WRITE:
ioreq->flags |= IOREQ_WRITE_OPERATION;
ioreq->parame.write.length = length;
ioreq->parame.write.offset = offset;
/* 把数据复制到内核缓冲区，不允许产生中断 */
if (devobj->flags & DO_BUFFERED_IO) {
save_intr(flags);
memcpy(ioreq->system_buffer, buffer, length);
restore_intr(flags);
}
break;
case IOREQ_DEVCTL:
ioreq->flags |= IOREQ_DEVCTL_OPERATION;
ioreq->parame.devctl.code = 0;
ioreq->parame.devctl.arg = 0;
break;
case IOREQ_MMAP:
ioreq->flags |= IOREQ_MMAP_OPERATION;
ioreq->parame.mmap.flags = offset;
ioreq->parame.mmap.length = length;
break;
default:
break;
}
return ioreq;
}
void io_complete_request(io_request_t *ioreq)
{
if (ioreq->io_status.status == IO_FAILED)
ioreq->io_status.infomation = -1;
ioreq->flags |= IOREQ_COMPLETION; /* 添加完成标志 */
/* 根据设备类型选择不同的锁 */
switch (ioreq->devobj->type)
{
case DEVICE_TYPE_SERIAL_PORT:
case DEVICE_TYPE_SCREEN:
case DEVICE_TYPE_KEYBOARD:
case DEVICE_TYPE_MOUSE:
case DEVICE_TYPE_VIRTUAL_CHAR:
spin_unlock(&ioreq->devobj->lock.spinlock);
break;
case DEVICE_TYPE_DISK:
mutex_unlock(&ioreq->devobj->lock.mutexlock);
break;
default:
break;
}
}
static int io_complete_check(io_request_t *ioreq, iostatus_t status)
{
if (status == IO_SUCCESS) { /* 执行成功 */
if (ioreq->io_status.status == IO_SUCCESS &&
ioreq->flags & IOREQ_COMPLETION) { /* 请求完成 */
return 0;
}
}
return -1;
}
void io_device_queue_cleanup(device_queue_t *queue)
{
device_queue_entry_t *entry, *next;
unsigned long irqflags;
spin_lock_irqsave(&queue->lock, irqflags);
/* 由于要删除队列成员，所以需要用safe版本 */
list_for_each_owner_safe (entry, next, &queue->list_head, list) {
list_del(&entry->list); /* 从链表删除 */
kfree(entry); /* 释放空间 */
}
spin_unlock_irqrestore(&queue->lock, irqflags);
}
iostatus_t io_device_queue_append(device_queue_t *queue, unsigned char *buf, int len)
{
unsigned long irqflags;
spin_lock_irqsave(&queue->lock, irqflags);
if (queue->entry_count > DEVICE_QUEUE_ENTRY_NR) { /* 超过队列项数，就先丢弃数据包 */
#if DEBUG_LOCLA == 1
printk(KERN_NOTICE "io_device_queue_append: device queue full!\n");
#endif
spin_unlock_irqrestore(&queue->lock, irqflags);
return IO_FAILED;
}
device_queue_entry_t *entry = kmalloc(sizeof(device_queue_entry_t) + len);
if (entry == NULL) {
spin_unlock_irqrestore(&queue->lock, irqflags);
return IO_FAILED;
}
list_add_tail(&entry->list, &queue->list_head);
queue->entry_count++;
entry->buf = (unsigned char *) (entry + 1);
entry->length = len;
memcpy(entry->buf, buf, len);
spin_unlock_irqrestore(&queue->lock, irqflags);
wait_queue_wakeup(&queue->wait_queue);
#if DEBUG_LOCLA == 1
printk(KERN_DEBUG "io_device_queue_put: pid=%d len=%d.\n",
queue->wait_queue.task->pid, len);
#endif
return IO_SUCCESS;
}
int io_device_queue_pickup2(device_queue_t *queue, unsigned char *buf, int buflen, int flags)
{
unsigned long irqflags;
spin_lock_irqsave(&queue->lock, irqflags);
if (!queue->entry_count) { /* 没有数据包 */
if (flags & IO_NOWAIT) { /* 不进行等待 */
spin_unlock_irqrestore(&queue->lock, irqflags);
return -1;
}
wait_queue_add(&queue->wait_queue, current_task);
spin_unlock_irqrestore(&queue->lock, irqflags);
task_block(TASK_BLOCKED);
spin_lock_irqsave(&queue->lock, irqflags);
}
device_queue_entry_t *entry;
entry = list_first_owner(&queue->list_head, device_queue_entry_t, list);
list_del(&entry->list);
queue->entry_count--;
int len = MIN(entry->length, buflen);
memcpy(buf, entry->buf, len);
kfree(entry);
spin_unlock_irqrestore(&queue->lock, irqflags);
#if DEBUG_LOCLA == 1
printk(KERN_DEBUG "io_device_queue_get: pid=%d len=%d.\n",
queue->wait_queue.task->pid, len);
#endif
return len;
}
int io_device_queue_pickup(device_queue_t *queue, unsigned char *buf, int buflen, int flags)
{
unsigned long irqflags;
spin_lock_irqsave(&queue->lock, irqflags);
if (!queue->entry_count) { /* 没有数据包 */
if (flags & IO_NOWAIT) { /* 不进行等待 */
spin_unlock_irqrestore(&queue->lock, irqflags);
return -1;
}
wait_queue_add(&queue->wait_queue, current_task);
spin_unlock_irqrestore(&queue->lock, irqflags);
task_block(TASK_BLOCKED);
spin_lock_irqsave(&queue->lock, irqflags);
}
device_queue_entry_t *entry;
entry = list_first_owner(&queue->list_head, device_queue_entry_t, list);
list_del(&entry->list);
queue->entry_count--;
int len = MIN(entry->length, buflen);
memcpy(buf, entry->buf, len);
kfree(entry);
spin_unlock_irqrestore(&queue->lock, irqflags);
#if DEBUG_LOCLA == 1
printk(KERN_DEBUG "io_device_queue_get: pid=%d len=%d.\n",
queue->wait_queue.task->pid, len);
#endif
return len;
}
iostatus_t io_device_increase_reference(device_object_t *devobj)
{
/* 增加引用 */
if (atomic_get(&devobj->reference) >= 0) {
atomic_inc(&devobj->reference);
} else {
printk(KERN_ERR "device_open: reference %d error!\n", atomic_get(&devobj->reference));
return IO_FAILED;
}
return IO_SUCCESS;
}
iostatus_t io_device_decrease_reference(device_object_t *devobj)
{
/* 减少引用 */
if (atomic_get(&devobj->reference) >= 0) {
atomic_dec(&devobj->reference);
} else {
printk(KERN_ERR "device_close: reference %d error!\n", atomic_get(&devobj->reference));
return IO_FAILED;
}
return IO_SUCCESS;
}
/**
* device_open - 打开设备操作
* @devname: 设备名
* @flags: 设备的标志
*
* @return: 成功返回设备的handle，失败返回-1
*/
handle_t device_open(char *devname, unsigned int flags)
{
device_object_t *devobj;
/* 搜索设备 */
devobj = io_search_device_by_name(devname);
if (devobj == NULL) {
printk(KERN_ERR "device_open: device %s not found!\n", devname);
return -1;
}
iostatus_t status = IO_SUCCESS;
status = io_device_increase_reference(devobj);
if (status == IO_FAILED) {
printk(KERN_ERR "device_open: increase reference failed!\n");
return -1;
}
io_request_t *ioreq = NULL;
/* 引用计数为1，才真正打开 */
if (atomic_get(&devobj->reference) == 1) {
ioreq = io_build_sync_request(IOREQ_OPEN, devobj, NULL, 0, 0, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "device_open: alloc io request packet failed!\n", atomic_get(&devobj->reference));
goto rollback_ref;
}
ioreq->parame.open.devname = devname;
ioreq->parame.open.flags = flags;
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
io_request_free((ioreq));
/* 真正打开的时候才创建句柄 */
spin_lock(&driver_lock);
handle_t handle = device_handle_table_insert(devobj);
if (handle == -1) {
printk(KERN_ERR "device_open: insert device handle tabel failed!\n");
spin_unlock(&driver_lock);
return -1; /* 插入句柄表失败 */
}
spin_unlock(&driver_lock);
return handle;
}
io_request_free(ioreq);
/* 失败则跳转到回滚 */
goto rollback_ref;
} else {
handle_t handle = device_handle_find_by_object(devobj);
return handle;
}
rollback_ref:
printk(KERN_ERR "device_open: do dispatch failed!\n");
io_device_decrease_reference(devobj);
return -1;
}
/**
* device_close - 关闭设备操作
* @handle: 设备句柄
*
* @return: 成功返回0，失败返回-1
*/
int device_close(handle_t handle)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return -1;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "device_close: device object error by handle=%d!\n", handle);
/* 应该激活一个触发器，让调用者停止运行 */
return -1;
}
iostatus_t status = IO_SUCCESS;
status = io_device_decrease_reference(devobj);
if (status == IO_FAILED) {
return -1;
}
io_request_t *ioreq = NULL;
if (!atomic_get(&devobj->reference)) { /* 最后一次关闭才关闭 */
ioreq = io_build_sync_request(IOREQ_CLOSE, devobj, NULL, 0, 0, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "device_close: alloc io request packet failed!\n", atomic_get(&devobj->reference));
goto rollback_ref;
}
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
/* 真正关闭的时候，才删除句柄 */
spin_lock(&driver_lock);
if (device_handle_table_remove(devobj)) {
printk(KERN_ERR "device_close: device=%s remove from device handle table failed!\n",
devobj->name.text);
spin_unlock(&driver_lock);
return -1;
}
spin_unlock(&driver_lock);
io_request_free((ioreq));
return 0;
}
io_request_free(ioreq);
/* 失败则跳转到回滚 */
goto rollback_ref;
} else {
/* 引用计数>=1，直接返回0 */
return 0;
}
rollback_ref:
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "device_close: do dispatch failed!\n");
#endif
io_device_increase_reference(devobj);
return -1;
}
/**
* device_mmap - 映射设备操作
* @handle: 设备句柄
* @length: 设备资源长度
* @flags: 标志
*
* @return: 成功返回映射后的地址，失败返回NULL
*/
void *device_mmap(handle_t handle, size_t length, int flags)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return NULL;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "%s: device object error by handle=%d!\n", __func__, handle);
/* 应该激活一个触发器，让调用者停止运行 */
return NULL;
}
iostatus_t status = IO_SUCCESS;
io_request_t *ioreq = NULL;
ioreq = io_build_sync_request(IOREQ_MMAP, devobj, NULL, length, flags, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "%s: alloc io request packet failed!\n", __func__);
return NULL;
}
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
void *mapaddr = NULL;
/* 对获取的物理地址进行映射 */
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "%s: get device phy addr:%x\n", __func__, ioreq->io_status.infomation);
#endif
if (ioreq->io_status.infomation) { /* 有物理地址，说明获取成功，再做进一步设置 */
/* 进行内存映射 */
if (flags & IO_KERNEL)
mapaddr = ioremap(ioreq->io_status.infomation, length);
else
mapaddr = vmspace_mmap(0, ioreq->io_status.infomation, length,
PROT_USER | PROT_WRITE, VMS_MAP_SHARED | VMS_MAP_REMAP);
}
io_request_free((ioreq));
return mapaddr;
}
#if DEBUG_LOCAL == 1
printk(KERN_DEBUG "%s: do dispatch failed!\n", __func__);
#endif
io_request_free((ioreq));
return NULL;
}
/**
* device_grow - 增加设备引用计数
* @handle: 设备句柄
*
* @return: 成功返回0，失败返回-1
*/
int device_grow(handle_t handle)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return -1;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "device_close: device object error by handle=%d!\n", handle);
/* 应该激活一个触发器，让调用者停止运行 */
return -1;
}
if (io_device_increase_reference(devobj) == IO_SUCCESS)
return 0;
return -1;
}
/**
* device_read - 从设备读取数据
* @handle: 设备句柄
* @buffer: 缓冲区
* @size: 数据长度
* @offset: 偏移位置
*
* @return: 成功返回读取的数据量，失败返回-1
*/
ssize_t device_read(handle_t handle, void *buffer, size_t length, off_t offset)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return -1;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "device_read: device object error by handle=%d!\n", handle);
/* 应该激活一个触发器，让调用者停止运行 */
return -1;
}
int len;
iostatus_t status = IO_SUCCESS;
io_request_t *ioreq = NULL;
ioreq = io_build_sync_request(IOREQ_READ, devobj, buffer, length, offset, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "device_read: alloc io request packet failed!\n");
return -1;
}
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
//printk("io complete.\n");
len = ioreq->io_status.infomation;
/* 如果是内存缓冲区，就需要从内核缓冲区复制到用户空间 */
if (devobj->flags & DO_BUFFERED_IO) {
/* 复制数据到用户空间 */
unsigned long flags;
save_intr(flags);
memcpy(ioreq->user_buffer, ioreq->system_buffer, len);
restore_intr(flags);
kfree(ioreq->system_buffer);
} else if (devobj->flags & DO_DIRECT_IO) {
/* 删除映射 */
printk(KERN_DEBUG "device_read: read done. free mdl.\n");
mdl_free(ioreq->mdl_address);
ioreq->mdl_address = NULL;
}
/* 读取后，分发到已经其它在设备上的进程中去 */
io_request_free((ioreq));
//printk("io ret.\n");
return len;
}
#if DEBUG_LOCAL == 1
printk(KERN_ERR "device_read: do dispatch failed!\n");
#endif
/* rollback_ioreq */
io_request_free(ioreq);
return -1;
}
/**
* device_write - 往设备写入数据
* @handle: 设备句柄
* @buffer: 缓冲区
* @size: 数据长度
* @offset: 偏移位置
*
* @return: 成功写入读取的数据量，失败返回-1
*/
ssize_t device_write(handle_t handle, void *buffer, size_t length, off_t offset)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return -1;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "device_write: device object error by handle=%d!\n", handle);
/* 应该激活一个触发器，让调用者停止运行 */
return -1;
}
iostatus_t status = IO_SUCCESS;
io_request_t *ioreq = NULL;
ioreq = io_build_sync_request(IOREQ_WRITE, devobj, buffer, length, offset, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "device_write: alloc io request packet failed!\n");
return -1;
}
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
if (devobj->flags & DO_DIRECT_IO) {
/* 删除映射 */
printk(KERN_DEBUG "device_write: write done. free mdl.\n");
mdl_free(ioreq->mdl_address);
ioreq->mdl_address = NULL;
}
unsigned int len = ioreq->io_status.infomation;
io_request_free((ioreq));
return len;
}
#if DEBUG_LOCAL == 1
printk(KERN_ERR "device_write: do dispatch failed!\n");
#endif
/* rollback_ioreq */
io_request_free(ioreq);
return -1;
}
/**
* device_devctl - 往设备写入数据
* @handle: 设备句柄
* @buffer: 缓冲区
* @size: 数据长度
* @offset: 偏移位置
*
* @return: 成功返回信息数，失败返回-1
*/
ssize_t device_devctl(handle_t handle, unsigned int code, unsigned long arg)
{
if (IS_BAD_DEVICE_HANDLE(handle))
return -1;
device_object_t *devobj;
devobj = GET_DEVICE_BY_HANDLE(handle);
/* 获取设备 */
if (devobj == NULL) {
printk(KERN_ERR "device_devctl: device object error by handle=%d!\n", handle);
/* 应该激活一个触发器，让调用者停止运行 */
return -1;
}
iostatus_t status = IO_SUCCESS;
io_request_t *ioreq = NULL;
ioreq = io_build_sync_request(IOREQ_DEVCTL, devobj, NULL, 0, 0, NULL);
if (ioreq == NULL) {
printk(KERN_ERR "device_devctl: alloc io request packet failed!\n");
return -1;
}
ioreq->parame.devctl.code = code;
ioreq->parame.devctl.arg = arg;
status = io_call_dirver(devobj, ioreq);
if (!io_complete_check(ioreq, status)) {
unsigned int infomation = ioreq->io_status.infomation;
io_request_free((ioreq));
return infomation;
}
#if DEBUG_LOCAL == 1
printk(KERN_ERR "device_devctl: do dispatch failed!\n");
#endif
/* rollback_ioreq */
io_request_free(ioreq);
return -1;
}
int io_uninstall_driver(char *drvname)
{
driver_object_t *drvobj;
drvobj = io_search_driver_by_name(drvname);
if (!drvobj)
return -1;
if (driver_object_delete(drvobj)) {
printk(KERN_ERR "io_uninstall_driver: delete driver %s failed!\n", drvname);
}
return 0;
}
void dump_device_object(device_object_t *device)
{
printk(KERN_DEBUG "dump_device_object: type=%d driver=%x extension=%x flags=%x reference=%x name=%s\n",
device->type, device->driver, device->device_extension, device->flags,
atomic_get(&device->reference), device->name.text);
}
int input_even_init(input_even_buf_t *evbuf)
{
spinlock_init(&evbuf->lock);
evbuf->head = evbuf->tail = 0;
memset(evbuf->evbuf, 0, sizeof(input_event_t) * EVBUF_SIZE);
return 0;
}
int input_even_put(input_even_buf_t *evbuf, input_event_t *even)
{
unsigned long flags;
spin_lock_irqsave(&evbuf->lock, flags);
evbuf->evbuf[evbuf->head++] = *even;
evbuf->head &= EVBUF_SIZE - 1;
spin_unlock_irqrestore(&evbuf->lock, flags);
return 0;
}
int input_even_get(input_even_buf_t *evbuf, input_event_t *even)
{
unsigned long flags;
spin_lock_irqsave(&evbuf->lock, flags);
if (evbuf->head == evbuf->tail) { /* 没有数据后就返回 */
spin_unlock_irqrestore(&evbuf->lock, flags);
return -1;
}
*even = evbuf->evbuf[evbuf->tail++];
evbuf->tail &= EVBUF_SIZE - 1;
spin_unlock_irqrestore(&evbuf->lock, flags);
return 0;
}
/* 初始化驱动架构 */
void init_driver_arch()
{
driver_func_t vine;
int i;
/* 初始化设备句柄表，要在初始化驱动前，因为驱动中可能有虚拟驱动调用物理设备 */
for (i = 0; i < DEVICE_HANDLE_NR; i++) {
device_handle_table[i] = NULL;
}
/* 初始化总线系统 */
init_pci();
/* 初始化驱动程序 */
for (i = 0; i < ARRAY_SIZE(driver_vine_table); i++) {
vine = driver_vine_table[i];
if (driver_object_create(vine)) {
printk(KERN_ERR "init_driver_arch: create one driver failed!\n");
}
}
#if DEBUG_LOCAL == 2
//print_drivers_mini();
/* 输出所有驱动以及设备 */
print_drivers();
#endif
#if 0
int sda = device_open("sata0", 0);
if (sda < 0)
panic(KERN_DEBUG "open sda0 failed!\n");
/*
char *buffer;
for (i = 200; i <= 220; i++) {
char *buffer = kmalloc(PAGE_SIZE * i);
memset(buffer, 0, PAGE_SIZE);
printk(KERN_DEBUG "read on %d len=%d\n", i, device_read(sda, buffer, SECTOR_SIZE * i, i));
printk(KERN_DEBUG "%x %x\n", buffer[0], buffer[511]);
memset(buffer, i, PAGE_SIZE);
printk(KERN_DEBUG "write to %d len=%d\n", i, device_write(sda, buffer, SECTOR_SIZE * i, i));
kfree(buffer);
}*/
char *buffer = kmalloc(PAGE_SIZE);
memset(buffer, 0, PAGE_SIZE);
printk(KERN_DEBUG "read on %d len=%d\n", 0, device_read(sda, buffer, SECTOR_SIZE, 0));
uint32_t *p = (uint32_t *) buffer;
for (i = 0; i < SECTOR_SIZE / sizeof(uint32_t); i++) {
printk("%x ", p[i]);
}
spin("ahci test.");
#endif
#if 0
handle_t null = device_open("null", 0);
if (null < 0)
panic(KERN_DEBUG "open null failed!\n");
char *buffer = kmalloc(PAGE_SIZE);
memset(buffer, 0xff, PAGE_SIZE);
printk(KERN_DEBUG "write len=%d\n", device_write(null, buffer, PAGE_SIZE, 0));
memset(buffer, 0, PAGE_SIZE);
printk(KERN_DEBUG "read len=%d\n", device_read(null, buffer, PAGE_SIZE, 0));
printk(KERN_DEBUG "%x %x: %x %x\n", buffer[0], buffer[511], buffer[512], buffer[1023]);
#endif
#if 0
handle_t ramd = device_open("vfloppy", 0);
if (ramd < 0)
panic(KERN_DEBUG "open ramdisk failed!\n");
char *buffer = kmalloc(PAGE_SIZE);
memset(buffer, 0xff, PAGE_SIZE);
printk(KERN_DEBUG "write len=%d\n", device_write(ramd, buffer, PAGE_SIZE, 1));
memset(buffer, 0, PAGE_SIZE);
printk(KERN_DEBUG "read len=%d\n", device_read(ramd, buffer, PAGE_SIZE, 0));
printk(KERN_DEBUG "%x %x: %x %x\n", buffer[0], buffer[511], buffer[512], buffer[1023]);
device_devctl(ramd, DISKIO_CLEAR, 0);
printk(KERN_DEBUG "disk sectors=%d\n", device_devctl(ramd, DISKIO_GETSIZE, 0));
#endif
#if 0
handle_t net0 = device_open("rtl8139", 0);
if (net0 < 0)
printk("open rtl 8139 failed!\n");
loop_delay(100);
char *net_buf = kmalloc(2048);
if (net_buf == NULL) {
panic("alloc for net buf failed!\n");
}
while (1) {
loop_delay(10);
//device_write(net0, net_buf, 128, 0);
int len = device_read(net0, net_buf, 2048, 0);
if (len > 0)
dump_buffer(net_buf, len, 1);
}
device_close(net0);
loop_delay(100);
net0 = device_open("rtl8139", 0);
if (net0 < 0)
printk("open rtl 8139 failed!\n");
while (1)
{
}
#endif
#if 0
handle_t handle = device_open("com0", 123);
printk(KERN_DEBUG "init_driver_arch: open device handle=%d\n", handle);
if (handle >= 0)
dump_device_object(GET_DEVICE_BY_HANDLE(handle));
handle_t handle1 = device_open("com1", 123);
printk(KERN_DEBUG "init_driver_arch: open device handle=%d\n", handle);
if (handle1 >= 0)
dump_device_object(GET_DEVICE_BY_HANDLE(handle1));
handle_t con0 = device_open("con0", 0);
printk(KERN_DEBUG "init_driver_arch: open device handle=%d\n", con0);
if (handle >= 0)
dump_device_object(GET_DEVICE_BY_HANDLE(con0));
device_write(handle, "hello, com0\n", 12, 0);
device_write(handle1, "hello, com1\n", 12, 0);
device_devctl(con0, CODE_CON_SETPOS, 10 * 80 + 0);
device_devctl(con0, CODE_CON_SETCOLOR, 0x5);
device_write(con0, "hello, con0!\nsecond line.\nabc\n", 32, 0);
device_devctl(con0, CODE_CON_SETPOS, 10 * 80 + 0);
char buf[32] = {0, };
device_read(con0, buf, 32, 0);
printk(KERN_DEBUG "read buffer:%s\n", buf);
printk(KERN_DEBUG "get pos:%d color:%d\n", device_devctl(con0, CODE_CON_GETPOS, 0), device_devctl(con0, CODE_CON_GETCOLOR, 0));
iostatus_t status;
status = device_close(handle);
printk(KERN_DEBUG "init_driver_arch: close devce ihandle=%d status=%d\n", handle, status);
handle_t ide0 = device_open("ide0", 0);
printk(KERN_DEBUG "init_driver_arch: open device handle=%d\n", ide0);
if (handle >= 0)
dump_device_object(GET_DEVICE_BY_HANDLE(ide0));
char *disk_buf = kmalloc(256 * 1024);
if (disk_buf == NULL)
panic("kmalloc for disk buf failed!\n");
printk(KERN_DEBUG "read disk:%d\n", device_read(ide0, disk_buf, 256 * 1024, 0));
printk(KERN_DEBUG "write disk:%d\n", device_write(ide0, disk_buf, 256 * 1024, 0));
dump_buffer(disk_buf, 32, 1);
/*
io_uninstall_driver("uart-serial");
io_uninstall_driver("vga-console");
io_uninstall_driver("ide-disk");
*/
#endif
//spin("test");
}
|
NightfallDM/xbook2
|
src/include/fsal/fsal.h
|
#ifndef __FILESRV_FSAL_H__
#define __FILESRV_FSAL_H__
/* File system abstraction layer (FSAL) 文件系统抽象层 */
#include "../../fs/fatfs/ff.h"
#include <types.h>
#include <stddef.h>
#include <stdint.h>
#include <list.h>
#define ROOT_DISK_NAME "disk0"
#define ROOT_DIR_PATH "/root"
#define FS_MODEL_NAME "fsal"
typedef struct {
list_t list; /* 系统抽象的链表 */
char *name; /* 文件系统抽象层名字 */
char **subtable; /* 子系统表 */
int (*mkfs)(char *, char *, unsigned long );
int (*mount)(char *, char *, char *, unsigned long );
int (*unmount)(char *, unsigned long );
int (*open)(void *, int );
int (*close)(int );
int (*read)(int , void *, size_t );
int (*write)(int , void *, size_t );
int (*lseek)(int , off_t , int );
int (*opendir)(char *);
int (*closedir)(int);
int (*readdir)(int , void *);
int (*mkdir)(char *, mode_t);
int (*unlink)(char *);
int (*rename)(char *, char *);
int (*ftruncate)(int , off_t);
int (*fsync)(int );
int (*state)(char *, void *);
int (*chmod)(char *, mode_t);
int (*fchmod)(int , mode_t);
int (*utime)(char *, time_t, time_t);
int (*feof)(int );
int (*ferror)(int );
off_t (*ftell)(int );
size_t (*fsize)(int );
int (*rewind)(int );
int (*rewinddir)(int );
int (*rmdir)(char *);
int (*chdir)(char *);
int (*ioctl)(int, int, unsigned long);
int (*fcntl)(int, int, long);
int (*fstat)(int, void *);
int (*access)(const char *, int);
void *extention;
} fsal_t;
/* 文件抽象层接口 */
extern fsal_t fsif;
int init_fsal();
#define MT_REMKFS 0x01 /* 挂在前需要格式化磁盘 */
#define MT_DELAYED 0x02 /* 延时挂载 */
/* 允许打开的文件数量 */
#define FSAL_FILE_OPEN_NR 128
#define FSAL_FILE_USED 0X01
typedef struct _fsal_file {
char flags; /* 文件标志 */
fsal_t *fsal; /* 文件系统抽象 */
union {
FIL fatfs; /* fatfs文件结构 */
} file;
} fsal_file_t;
extern fsal_file_t *fsal_file_table;
/* 文件指针转换成在表中的索引 */
#define FSAL_F2I(file) ((int) ((file) - fsal_file_table))
/* 在表中的索引转换成文件指针 */
#define FSAL_I2F(idx) ((fsal_file_t *)(&fsal_file_table[(idx)]))
#define ISBAD_FSAL_FIDX(idx) ((idx) < 0 || (idx) >= FSAL_FILE_OPEN_NR)
fsal_file_t *fsal_file_alloc();
int fsal_file_free(fsal_file_t *file);
/* 路径转换长度，一般是路径的前缀。例如/root, c: */
#define FASL_PATH_LEN 24
/* 路径转换表项数 */
#define FASL_PATH_NR 12
/* 路径转换 */
typedef struct {
fsal_t *fsal; /* 文件系统抽象 */
char path[FASL_PATH_LEN]; /* 具体文件系统的文件路径名 */
char alpath[FASL_PATH_LEN]; /* 抽象层路径 */
} fsal_path_t;
extern fsal_path_t *fsal_path_table;
#define FSAL_PATH_TABLE_SIZE (sizeof(fsal_path_t) * FASL_PATH_NR)
int init_fsal_path_table();
int fsal_path_insert(void *path, char *alpath, fsal_t *fsal);
int fsal_path_remove(void *path);
void fsal_path_print();
fsal_path_t *fsal_path_alloc();
fsal_path_t *fsal_path_find(void *alpath, int inmaster);
int fsal_path_switch(fsal_path_t *fpath, char *new_path, char *old_path);
int fsal_list_dir(char* path);
#include <xbook/task.h>
int fs_fd_init(task_t *task);
int fs_fd_exit(task_t *task);
int local_fd_install(int resid, unsigned int flags);
int local_fd_uninstall(int local_fd);
int local_fd_install_to(int resid, int newfd, unsigned int flags);
file_fd_t *fd_local_to_file(int local_fd);
int handle_to_local_fd(int handle, unsigned int flags);
int fs_fd_copy(task_t *src, task_t *dest);
int fs_fd_reinit(task_t *cur);
#endif /* __FILESRV_FSAL_H__ */
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/gate.h
|
#ifndef _X86_GATE_H
#define _X86_GATE_H
/* IDT 的虚拟地址 */
#define IDT_VADDR 0x80200800
#define IDT_LIMIT 0x000007ff
#define DA_TaskGate 0x85 /* 任务门类型值 */
#define DA_386CGate 0x8C /* 386 调用门类型值 */
#define DA_386IGate 0x8E /* 386 中断门类型值 */
#define DA_386TGate 0x8F /* 386 陷阱门类型值 */
#define DA_GATE_DPL0 0
#define DA_GATE_DPL1 1
#define DA_GATE_DPL2 2
#define DA_GATE_DPL3 3
/*
门描述符结构
*/
struct gate_descriptor {
unsigned short offset_low, selector;
unsigned char datacount;
unsigned char attributes; /* P(1) DPL(2) DT(1) TYPE(4) */
unsigned short offset_high;
};
void init_gate_descriptor();
#endif /* _X86_GATE_H */
|
NightfallDM/xbook2
|
library/xlibc/include/sys/list.h
|
<gh_stars>0
#ifndef _SYS_LIST_H
#define _SYS_LIST_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
/*
* 链表数据结构，在看了Linux的链表结构之后，觉得他那个比较通用，
* 而且也比较清晰，所以我打算移植一个过来。本文件里面的都是内联函数，
* 使用的时候会编译在调用的地方。并且还有很多宏定义。
*/
/*
* 链表结构体
*/
typedef struct list {
struct list *prev;
struct list *next;
} list_t;
/* 为链表结构赋值 */
#define LIST_HEAD_INIT(name) { &(name), &(name) }
/* 创建并赋值 */
#define LIST_HEAD(name) \
struct list name = LIST_HEAD_INIT(name)
/* 让链表内容指针指向自己本身 */
static inline void init_list(struct list *list)
{
list->next = list;
list->prev = list;
}
/* 把一个新的节点new插入到prev后，next前 */
static inline void __list_add(struct list *new,
struct list *prev,
struct list *next)
{
//new和next绑定关系
next->prev = new;
new->next = next;
//new和next绑定关系
new->prev = prev;
prev->next = new;
}
/*
* list_add - 添加一个新的节点到链表头
* @new： 要新添加的节点
* @head：要添加到哪个链表头
*
* 把一个节点添加到链表头后面，相当于添加到整个链表的最前面。
*/
static inline void list_add(struct list *new, struct list *head)
{
// :) 插入到链表头和链表头的下一个节点之间
__list_add(new, head, head->next);
}
/*
* list_add_before - 把节点添加到一个节点前面
* @new： 要新添加的节点
* @head：比较的节点
*
* 把一个新节点添加到一个节点前面。旧节点的前驱需要指向新节点，
* 旧节点的前驱指向新节点，新节点的前驱指向旧节点的前驱，后驱指向旧节点。
*
*/
static inline void list_add_before(struct list *new, struct list *node)
{
node->prev->next = new;
new->prev = node->prev;
new->next = node;
node->prev = new;
}
/*
* list_add_after - 把节点添加到一个节点后面
* @new： 要新添加的节点
* @head：比较的节点
*
* 把一个新节点添加到一个节点后面。旧节点的后驱需要指向新节点，
* 旧节点的后驱指向新节点，新节点的前驱指向旧节点，后驱指向旧节点的后驱。
*
*/
static inline void list_add_after(struct list *new, struct list *node)
{
node->next->prev = new;
new->prev = node;
new->next = node->next;
node->next = new;
}
/*
* list_add_tail - 添加一个新的节点到链表尾
* @new： 要新添加的节点
* @head：要添加到哪个链表头
*
* 把一个节点添加到链表头前面，相当于添加到整个链表的最后面。
*/
static inline void list_add_tail(struct list *new, struct list *head)
{
// :) 插入到链表头前一个和链表头之间
__list_add(new, head->prev, head);
}
/* 把一个节点从链表中删除 */
static inline void __list_del(struct list *prev, struct list *next)
{
// ^_^ 把前一个和下一个进行关联，那中间一个就被删去了
next->prev = prev;
prev->next = next;
}
/* 把一个节点从链表中删除 */
static inline void __list_del_node(struct list *node)
{
// 传入节点的前一个和后一个，执行后只是脱离链表，而自身还保留了节点信息
__list_del(node->prev, node->next);
}
/*
* list_del - 把节点从链表中删除
* @node：要删除的节点
*
* 把一个已经存在于链表中的节点删除
*/
static inline void list_del(struct list *node)
{
__list_del_node(node);
// @.@ 把前驱指针和后驱指针都指向空，完全脱离
node->prev = NULL;
node->next = NULL;
}
/*
* list_del_init - 把节点从链表中删除
* @node：要删除的节点
*
* 把一个已经存在于链表中的节点删除
*/
static inline void list_del_init(struct list *node)
{
__list_del_node(node);
//初始化节点，使得可以成为链表头，我猜的。:-)
init_list(node);
}
/*
* list_replace - 用新的节点替代旧的节点
* @old：旧的节点
* @new：要插入的新节点
*
* 用一个节点替代已经存在于链表中的节点
*/
static inline void list_replace(struct list *old, struct list *new)
{
/*
@.@ 把old的前后指针都指向new，那么new就替代了old，真可恶！
不过，旧的节点中还保留了链表的信息
*/
new->next = old->next;
new->next->prev = new;
new->prev = old->prev;
new->prev->next = new;
}
static inline void list_replace_init(struct list *old, struct list *new)
{
/*
先把old取代，然后把old节点初始化，使它完全脱离链表。
*/
list_replace(old, new);
init_list(old);
}
/*
* list_move - 从一个链表删除，然后移动到另外一个链表头后面
* @node：要操作的节点
* @head：新的链表头
*/
static inline void list_move(struct list *node, struct list *head)
{
// ^.^ 先把自己脱离关系，然后添加到新的链表
__list_del_node(node);
list_add(node, head);
}
/*
* list_move_tail - 从一个链表删除，然后移动到另外一个链表头前面
* @node：要操作的节点
* @head：新的链表头
*/
static inline void list_move_tail(struct list *node, struct list *head)
{
// ^.^ 先把自己脱离关系，然后添加到新的链表
__list_del_node(node);
list_add_tail(node, head);
}
/*
* list_is_first - 检测节点是否是链表中的第一个节点
* @node：要检测的节点
* @head：链表头
*/
static inline int list_is_first(const struct list *node,
const struct list *head)
{
return (node->prev == head); //节点的前一个是否为链表头
}
/*
* list_is_last - 检测节点是否是链表中的最后一个节点
* @node：要检测的节点
* @head：链表头
*/
static inline int list_is_last(const struct list *node,
const struct list *head)
{
return (node->next == head); //节点的后一个是否为链表头
}
/*
* list_empty - 测试链表是否为空链表
* @head：链表头
*
* 把链表头传进去，通过链表头来判断
*/
static inline int list_empty(const struct list *head)
{
return (head->next == head); //链表头的下一个是否为自己
}
/* ！！！！前方！！！！高能！！！！ */
/*
* list_owner - 获取节点的宿主
* @ptr： 节点的指针
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*/
#define list_owner(ptr, type, member) container_of(ptr, type, member)
/* 嘻嘻，就这样就把container_of用上了 */
/*
* list_first_owner - 获取链表中的第一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：链表不能为空
*/
#define list_first_owner(head, type, member) \
list_owner((head)->next, type, member)
/*
* list_last_owner - 获取链表中的最后一个宿主
* @head: 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：链表不能为空
*/
#define list_last_owner(head, type, member) \
list_owner((head)->prev, type, member)
/*
* list_first_owner_or_null - 获取链表中的第一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：如果链表是空就返回NULL
*/
#define list_first_owner_or_null(head, type, member) ({ \
struct list *__head = (head); \
struct list *__pos = (__head->next); \
__pos != __head ? list_owner(__pos, type, member) : NULL; \
})
/*
* list_last_owner_or_null - 获取链表中的最后一个宿主
* @head： 链表头
* @type： 宿主结构体的类型
* @member: 节点在宿主结构体中的名字
*
* 注：如果链表是空就返回NULL
*/
#define list_last_owner_or_null(head, type, member) ({ \
struct list *__head = (head); \
struct list *__pos = (__head->prev); \
__pos != __head ? list_owner(__pos, type, member) : NULL; \
})
/*
* list_next_owner - 获取链表中的下一个宿主
* @pos： 临时宿主的指针
* @member: 节点在宿主结构体中的名字
*/
#define list_next_owner(pos, member) \
list_owner((pos)->member.next, typeof(*(pos)), member)
/*
* list_prev_onwer - 获取链表中的前一个宿主
* @pos： 临时宿主的指针
* @member: 节点在宿主结构体中的名字
*/
#define list_prev_onwer(pos, member) \
list_owner((pos)->member.prev, typeof(*(pos)), member)
/* 把代码自己打一遍，好累啊！但是感觉这些东西也更加明白了 */
/* 记住啦，这是遍历链表节点，不是宿主 -->>*/
/*
* list_for_each - 从前往后遍历每一个链表节点
* @pos： 节点指针
* @head: 链表头
*/
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/*
* list_find - 从前往后遍历查找链表节点
* @list: 要查找的节点指针
* @head: 链表头
*
* 找到返回1，否则返回0
*/
static inline int list_find(struct list *list, struct list *head)
{
struct list *node;
list_for_each(node, head) {
// 找到一样的
if (node == list) {
return 1;
}
}
return 0;
}
/*
* list_length - 获取链表长度
* @head: 链表头
*/
static inline int list_length(struct list *head)
{
struct list *list;
int n = 0;
list_for_each(list, head) {
// 找到一样的
if (list == head)
break;
n++;
}
return n;
}
/*
* list_for_each_prev - 从后往前遍历每一个链表节点
* @pos： 节点指针
* @head: 链表头
*/
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/*
* list_for_each_safe - 从前往后遍历每一个链表节点
* @pos: 节点指针
* @_next: 临时节点指针（为了避免和pos->next混淆，在前面加_）
* @head: 链表头
*
* 用next来保存下一个节点指针，如果在遍历过程中pos出的节点被删除了，
* 还是可以继续往后面遍历其它节点。
*/
#define list_for_each_safe(pos, _next, head) \
for (pos = (head)->next, _next = pos->next; pos != (head); \
pos = _next, _next = pos->next)
/*
* list_for_each_prev_safe - 从后往前遍历每一个链表节点
* @pos: 节点指针
* @_prev: 临时节点指针（为了避免和pos->prev混淆，在前面加_）
* @head: 链表头
*
* 用prev来保存前一个节点指针，如果在遍历过程中pos出的节点被删除了，
* 还是可以继续往前面遍历其它节点。
*/
#define list_for_each_prev_safe(pos, _prev, head) \
for (pos = (head)->prev, _prev = pos->prev; pos != (head); \
pos = _prev, _prev = pos->prev)
/* <<-- 遍历链表节点结束了，接下来开始的是遍历宿主 -->> */
/*
* list_for_each_owner - 从前往后遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @head: 链表头
* @member: 节点在宿主中的名字
*/
#define list_for_each_owner(pos, head, member) \
for (pos = list_first_owner(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_next_owner(pos, member))
/*
* list_for_each_owner_reverse - 从后往前遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @head: 链表头
* @member: 节点在宿主中的名字
*/
#define list_for_each_owner_reverse(pos, head, member) \
for (pos = list_last_owner(head, typeof(*pos), member); \
&pos->member != (head); \
pos = list_prev_onwer(pos, member))
/*
* list_for_each_owner_safe - 从前往后遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @next: 临时指向下一个节点的指针
* @head: 链表头
* @member: 节点在宿主中的名字
*
* 可以保证在遍历过程中如果
*/
#define list_for_each_owner_safe(pos, next, head, member) \
for (pos = list_first_owner(head, typeof(*pos), member), \
next = list_next_owner(pos, member); \
&pos->member != (head); \
pos = next, next = list_next_owner(next, member))
/*
* list_for_each_owner_reverse_safe - 从后往前遍历每一个链表节点宿主
* @pos: 宿主类型结构体指针
* @_prev: 临时指向前一个节点的指针
* @head: 链表头
* @member: 节点在宿主中的名字
*
* 可以保证在遍历过程中如果
*/
#define list_for_each_owner_reverse_safe(pos, prev, head, member) \
for (pos = list_last_owner(head, typeof(*pos), member), \
prev = list_prev_onwer(pos, member); \
&pos->member != (head); \
pos = prev, prev = list_prev_onwer(prev, member))
/* <<-- 遍历链表宿主也结束了，very nice 啊！ */
/*
* Double linked lists with a single pointer list head.
* Mostly useful for hash tables where the two pointer list head is
* too wasteful.
* You lose the ability to access the tail in O(1).
*/
struct hlist_head {
struct hlist_node * first;
};
struct hlist_node {
struct hlist_node * next, ** pprev;
};
#define HLIST_HEAD(name) \
struct hlist_head name = { .first = NULL }
static inline void init_hlist_head(struct hlist_head * hlist)
{
hlist->first = NULL;
}
static inline void init_hlist_node(struct hlist_node * h)
{
h->next = NULL;
h->pprev = NULL;
}
static inline int hlist_unhashed(const struct hlist_node * h)
{
return !h->pprev;
}
static inline int hlist_empty(const struct hlist_head * h)
{
return !h->first;
}
static inline void __hlist_del(struct hlist_node * n)
{
struct hlist_node * next = n->next;
struct hlist_node ** pprev = n->pprev;
*pprev = next;
if(next)
next->pprev = pprev;
}
static inline void hlist_del(struct hlist_node * n)
{
__hlist_del(n);
n->next = 0;
n->pprev = 0;
}
static inline void hlist_del_init(struct hlist_node * n)
{
if(!hlist_unhashed(n))
{
__hlist_del(n);
init_hlist_node(n);
}
}
static inline void hlist_add_head(struct hlist_node * n, struct hlist_head * h)
{
struct hlist_node * first = h->first;
n->next = first;
if(first)
first->pprev = &n->next;
h->first = n;
n->pprev = &h->first;
}
/* next must be != NULL */
static inline void hlist_add_before(struct hlist_node * n,
struct hlist_node * next)
{
n->pprev = next->pprev;
n->next = next;
next->pprev = &n->next;
*(n->pprev) = n;
}
static inline void hlist_add_behind(struct hlist_node * n,
struct hlist_node * prev)
{
n->next = prev->next;
prev->next = n;
n->pprev = &prev->next;
if(n->next)
n->next->pprev = &n->next;
}
/* after that we'll appear to be on some hlist and hlist_del will work */
static inline void hlist_add_fake(struct hlist_node * n)
{
n->pprev = &n->next;
}
static inline int hlist_fake(struct hlist_node * h)
{
return h->pprev == &h->next;
}
/*
* Check whether the node is the only node of the head without
* accessing head:
*/
static inline int hlist_is_singular_node(struct hlist_node * n, struct hlist_head * h)
{
return !n->next && n->pprev == &h->first;
}
/*
* Move a list from one list head to another. Fixup the pprev
* reference of the first entry if it exists.
*/
static inline void hlist_move_list(struct hlist_head * old,
struct hlist_head * new)
{
new->first = old->first;
if(new->first)
new->first->pprev = &new->first;
old->first = NULL;
}
#define hlist_entry(ptr, type, member) \
container_of(ptr, type, member)
#define hlist_for_each(pos, head) \
for (pos = (head)->first; pos; pos = pos->next)
#define hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)
#define hlist_entry_safe(ptr, type, member) \
({ typeof(ptr) ____ptr = (ptr); \
____ptr ? hlist_entry(____ptr, type, member) : NULL; \
})
/**
* hlist_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry(pos, head, member) \
for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member); \
pos; \
pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
/**
* hlist_for_each_entry_continue - iterate over a hlist continuing after current point
* @pos: the type * to use as a loop cursor.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_continue(pos, member) \
for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member); \
pos; \
pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
/**
* hlist_for_each_entry_from - iterate over a hlist continuing from current point
* @pos: the type * to use as a loop cursor.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_from(pos, member) \
for (; pos; \
pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
/**
* hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop cursor.
* @n: another &struct hlist_node to use as temporary storage
* @head: the head for your list.
* @member: the name of the hlist_node within the struct.
*/
#define hlist_for_each_entry_safe(pos, n, head, member) \
for (pos = hlist_entry_safe((head)->first, typeof(*pos), member); \
pos && ({ n = pos->member.next; 1; }); \
pos = hlist_entry_safe(n, typeof(*pos), member))
#ifdef __cplusplus
}
#endif
#endif /* _SYS_LIST_H */
|
NightfallDM/xbook2
|
src/include/xbook/dma.h
|
#ifndef _XBOOK_VMM_DMA_H
#define _XBOOK_VMM_DMA_H
#include <types.h>
struct mm_physical_region {
addr_t address;
size_t size;
addr_t alignment;
};
struct dma_region {
struct mm_physical_region p;
addr_t v;
};
int alloc_dma_buffer(struct dma_region *);
int free_dma_buffer(struct dma_region *);
#endif /* _XBOOK_VMM_DMA_H */
|
NightfallDM/xbook2
|
library/xlibc/syslib/res.c
|
<filename>library/xlibc/syslib/res.c<gh_stars>0
#include <sys/syscall.h>
#include <sys/res.h>
/**
* res_open() - get device resource
*
* @name: res name
* @flags: res flags
* @arg: res arg
*
* res_open a device, if didn't res_open, can't operate the device.
*
* @return: res idx in table >= 0, -1 is failed.
*/
int res_open(char *name, unsigned long flags, unsigned long arg)
{
return syscall3(int, SYS_GETRES, name, flags, arg);
}
/**
* res_close() - release device resource
*
* @res: res index in table
*
* remember res_close at the end of program.
*
* @return: 0 is sucess, -1 is failed
*/
int res_close(int res)
{
return syscall1(int, SYS_PUTRES, res);
}
/**
* res_write() - write data to device resource
*
* @res: res index in table
* @buffer: data buffer
* @size: buffer length (bytes)
*
* @return: (write bytes) >= 0 is sucess, -1 is failed
*/
int res_write(int res, off_t off, void *buffer, size_t size)
{
return syscall4(int, SYS_WRITERES, res, off, buffer, size);
}
/**
* res_read() - read data from device resource
*
* @res: res index in table
* @buffer: data buffer
* @size: buffer length (bytes)
*
* @return: (read bytes) >= 0 is sucess, -1 is failed
*/
int res_read(int res, off_t off, void *buffer, size_t size)
{
return syscall4(int, SYS_READRES, res, off, buffer, size);
}
/**
* res_ioctl() - control resource
*
* @res: res index in table
* @cmd: command for res
* @arg: command arg
*
* control device by cmd, cmd always support by driver.
*
* @return: (info) >= 0 is sucess, -1 is failed
*/
int res_ioctl(int res, unsigned int cmd, unsigned long arg)
{
return syscall3(int, SYS_CTLRES, res, cmd, arg);
}
/**
* dev_scan - 扫描设备
* @de: 输入设备项，为NULL时表示第一次扫描开始
* @type: 设备的类型
* @out: 输出的设备项
*
* 成功返回0，失败返回-1
*/
int dev_scan(devent_t *de, device_type_t type, devent_t *out)
{
return syscall3(int, SYS_DEVSCAN, de, type, out);
}
/**
* sys_mmap - 映射资源
* @res: 资源
* @length: 长度
* @flags: 映射标志
*
* @return: 成功返回映射后的地址，失败返回NULL
*/
void *res_mmap(int res, size_t length, int flags)
{
return syscall3(void *, SYS_MMAP, res, length, flags);
}
/**
* unid - 生成一个唯一的id值
* @id: 参考值
*/
unid_t res_unid(int id)
{
return syscall1(unid_t , SYS_UNID, id);
}
/**
* res_redirect() - res redirect
*
* @old_res: old_res index in table
* @new_res: new_res index in table
*
* redirect old res to new res, if new res exist, close new res first,
* then redirect old res to new res, after that, remove old res index
* int table.
*
* @return: new res >= 0 is sucess, -1 is failed
*/
int res_redirect(int old_res, int new_res)
{
return res_ioctl(old_res, RES_REDIR, new_res);
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/mp.h
|
/*
*Structrue that use in "mp.c" for MultiProcessor
* */
struct mp { // floating pointer
uint8_t signature[4]; // "_MP_"
void * physaddr; // phys addr of MP config table
uint8_t length;
uint8_t specrev; // [14]
uint8_t checksum; // all bytes must add up to 0
uint8_t type; // MP system config type
};
struct mpconf { // configuration table header
uint8_t signature[4]; // "PCMP"
uint8_t length; // total table length
uint8_t version; // [14]
uint8_t checksum; // all bytes must add up to 0
uint8_t product[20]; // product id
uint32_t *oemtable; // OEM table pointer
uint16_t oemlength; // OEM table length
uint16_t entry; // entry count
uint32_t *lapicaddr; // address of local APIC
uint16_t xlength; // extended table length
uint8_t xchecksum; // extended table checksum
uint8_t reserved;
};
struct mpproc { // processor table entry
uint8_t type; // entry type (0)
uint8_t apicid; // local APIC id
uint8_t version; // local APIC Version
uint8_t flags; // CPU flags 0x02 mean the bootstrap processor
#define MPBOOT 0x02 // This proc is the bootstrap processor
uint8_t signature[4]; // CPU signature
uint32_t feature;
uint8_t reserved[8];
};
struct mpioapic { // I/O APIC table entry
uint8_t type; // entry type (2)
uint8_t apicno; // I/O APIC id
uint8_t version; // I/O APIC version
uint8_t flags; // I/O APIC flags
uint32_t *addr; // I/O APIC address
};
// Table entry types
#define MPPROC 0x00 // One per processor
#define MPBUS 0x01 // One per bus
#define MPIOAPIC 0x02 // One per I/O APIC
#define MPIOINTR 0x03 // One per bus interrupt source
#define MPLINTR 0x04 // One per system interrupt source
|
NightfallDM/xbook2
|
src/include/sys/time.h
|
#ifndef _SYS_TIME_H
#define _SYS_TIME_H
#include <types.h>
#define CLOCK_REALTIME 1 /*系统统当前时间，从1970年1.1日算起*/
#define CLOCK_MONOTONIC 2 /*系统的启动时间，不能被设置*/
#define CLOCK_PROCESS_CPUTIME_ID 3 /* 本进程运行时间*/
#define CLOCK_THREAD_CPUTIME_ID 4 /*本线程运行时间*/
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};
struct timezone {
int tz_minuteswest; //miniutes west of Greenwich
int tz_dsttime; //type of DST correction
};
#ifndef _TIMESPEC
#define _TIMESPEC
struct timespec {
time_t tv_sec; // seconds
long tv_nsec; // and nanoseconds
};
#endif
#endif /* _SYS_TIME_H */
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/ioremap.h
|
<filename>src/arch/x86/include/arch/ioremap.h
#ifndef _X86_IOREMAP_H
#define _X86_IOREMAP_H
#include <stddef.h>
int __ioremap(unsigned long paddr, unsigned long vaddr, size_t size);
int __iounmap(unsigned long addr, size_t size);
#endif /* _X86_IOREMAP_H */
|
NightfallDM/xbook2
|
library/xlibc/socket/socket.c
|
<gh_stars>0
#include <unistd.h>
#include <types.h>
#include <stddef.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/syscall.h>
int socket(int domain, int type, int protocol)
{
return syscall3(int, SYS_SOCKET, domain, type, protocol);
}
int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
{
return syscall3(int, SYS_BIND, sockfd, my_addr, addrlen);
}
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen)
{
return syscall3(int, SYS_CONNECT, sockfd, serv_addr, addrlen);
}
int listen(int sockfd, int backlog)
{
return syscall2(int, SYS_LISTEN, sockfd, backlog);
}
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
return syscall3(int, SYS_ACCEPT, sockfd, addr, addrlen);
}
int send(int sockfd, const void *buf, int len, int flags)
{
return syscall4(int, SYS_SEND, sockfd, buf, len, flags);
}
int recv(int sockfd, void *buf, int len, unsigned int flags)
{
return syscall4(int, SYS_RECV, sockfd, buf, len, flags);
}
int sendto(int sockfd, const void *buf, int len, unsigned int flags,
const struct sockaddr *to, socklen_t tolen)
{
struct _sockarg arg;
arg.buf = (void *)buf;
arg.len = len;
arg.flags = flags;
arg.to_from = (struct sockaddr *) to;
arg.tolen = tolen;
return syscall2(int, SYS_SENDTO, sockfd, &arg);
}
int recvfrom(int sockfd, void *buf, int len, unsigned int flags,
struct sockaddr *from, socklen_t *fromlen)
{
struct _sockarg arg;
arg.buf = (void *)buf;
arg.len = len;
arg.flags = flags;
arg.to_from = (struct sockaddr *) from;
arg.fromlen = fromlen;
return syscall2(int, SYS_RECVFROM, sockfd, &arg);
}
int shutdown(int sockfd, int how)
{
return syscall2(int, SYS_SHUTDOWN, sockfd, how);
}
int getpeername(int sockfd, struct sockaddr *serv_addr, socklen_t *addrlen)
{
return syscall3(int, SYS_GETPEERNAME, sockfd, serv_addr, addrlen);
}
int getsockname(int sockfd, struct sockaddr *my_addr, socklen_t *addrlen)
{
return syscall3(int, SYS_GETSOCKNAME, sockfd, my_addr, addrlen);
}
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen)
{
return syscall4(int, SYS_GETSOCKOPT, sockfd, ((level & 0xffff) << 16) | (optname & 0xffff),
optval, optlen);
}
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
{
return syscall4(int, SYS_SETSOCKOPT, sockfd, ((level & 0xffff) << 16) | (optname & 0xffff),
optval, optlen);
}
int ioctlsocket(int sockfd, int request, void *arg)
{
return syscall3(int, SYS_IOCTLSOCKET, sockfd, request, arg);
}
int select(int maxfdp, fd_set *readfds, fd_set *writefds, fd_set *exceptset, struct timeval *timeout)
{
struct _sockfd_set fd_sets;
fd_sets.readfds = readfds;
fd_sets.writefds = writefds;
fd_sets.errorfds = exceptset;
return syscall3(int, SYS_SELECT, maxfdp, &fd_sets, timeout);
}
|
NightfallDM/xbook2
|
library/xlibc/stdio/fputs.c
|
/*
* libc/stdio/fputs.c
*/
#include <string.h>
#include <stdio.h>
int fputs(const char * s, FILE * f)
{
return ((__stdio_write(f, (unsigned char *)s, strlen(s)) <= 0) ? EOF : 0);
}
|
NightfallDM/xbook2
|
src/vmm/mdl.c
|
<reponame>NightfallDM/xbook2<gh_stars>0
#include <xbook/mdl.h>
#include <xbook/memcache.h>
#include <xbook/debug.h>
#include <xbook/vmarea.h>
/**
* mdl_alloc - 分配一个内存描述列表
* @vaddr: 用户虚拟地址
* @length: 数据长度
* @later: 描述列表不是第一个
* @ioreq: 输入输出请求
*
* 分配并映射内存，在内核中分配一个内核虚拟地址，映射到和用户的虚拟地址的物理页一样的物理页，
* 相当于共享了用户虚拟地址的物理页，这样，就可以通过内核的虚拟地址来访问用户的虚拟地址。
*
* @return: 成功返回mdl指针，失败返回NULL
*/
mdl_t *mdl_alloc(void *vaddr, unsigned long length,
bool later, io_request_t *ioreq)
{
if (!length || vaddr == NULL)
return NULL;
/* 分配mdl空间 */
mdl_t *mdl = kmalloc(sizeof(mdl_t));
if (mdl == NULL) {
return NULL;
}
/* 获取虚拟地址页对齐的地址 */
mdl->start_vaddr = (void *) (((unsigned long) vaddr) & PAGE_ADDR_MASK);
mdl->byte_offset = (char *)vaddr - (char *)mdl->start_vaddr;
if (length > MDL_MAX_SIZE) {
length = MDL_MAX_SIZE; /* 剪切长度 */
printk(KERN_NOTICE "mdl_alloc: length=%x too long!\n", length);
}
mdl->byte_count = length;
mdl->task = current_task;
mdl->next = NULL;
unsigned long flags; /* 关闭并保存中断 */
save_intr(flags);
unsigned long phyaddr = addr_v2p((unsigned long) mdl->start_vaddr);
printk(KERN_DEBUG "mdl_alloc: viraddr=%x phyaddr=%x\n", vaddr, phyaddr);
unsigned long pages = PAGE_ALIGN(length) / PAGE_SIZE;
printk(KERN_DEBUG "mdl_alloc: length=%d pages=%d\n", length, pages);
/* 分配一个虚拟地址 */
unsigned long mapped_vaddr = alloc_vaddr(length);
if (!mapped_vaddr) {
kfree(mdl);
restore_intr(flags);
return NULL;
}
mdl->mapped_vaddr = (void *) mapped_vaddr;
/* 映射固定内存页（虚拟地址和物理地址都指定了） */
map_pages_fixed(mapped_vaddr, phyaddr, length, PROT_KERN | PROT_WRITE);
restore_intr(flags);
printk(KERN_DEBUG "mdl_alloc: map success!\n");
/* 有请求才进行关联 */
if (ioreq) {
if (later) { /* 插入到末尾 */
printk(KERN_DEBUG "mdl_alloc: insert tail.\n");
mdl_t *cur = ioreq->mdl_address;
while (cur != NULL) {
if (cur->next == NULL) {
cur->next = mdl;
break;
}
cur = cur->next;
}
} else { /* 队首 */
printk(KERN_DEBUG "mdl_alloc: insert head.\n");
mdl->next = ioreq->mdl_address;
ioreq->mdl_address = mdl;
}
}
return mdl;
}
/**
* mdl_free - 释放内存描述列表
* @mdl: 内存描述列表
*
*/
void mdl_free(mdl_t *mdl)
{
if (mdl == NULL)
return;
printk(KERN_DEBUG "mdl_free: vaddr=%x length=%d byte offset=%d mapped vaddr=%x.\n",
mdl->start_vaddr, mdl->byte_count, mdl->byte_offset, mdl->mapped_vaddr);
unsigned long flags; /* 关闭并保存中断 */
save_intr(flags);
/* 取消共享内存映射 */
unmap_pages_safe((unsigned long) mdl->mapped_vaddr, mdl->byte_count, 1);
free_vaddr((unsigned long) mdl->mapped_vaddr, mdl->byte_count); /* 释放映射后的虚拟地址 */
restore_intr(flags);
kfree(mdl); /* 释放mdl结构 */
}
|
NightfallDM/xbook2
|
library/xlibc/syslib/waitque.c
|
<filename>library/xlibc/syslib/waitque.c<gh_stars>0
#include <sys/syscall.h>
#include <sys/waitque.h>
/**
* waitque_create - 创建一个等待队列
*
* 返回一个等待队列句柄，成功返回>=0，失败返回-1
*/
int waitque_create()
{
return syscall0(int, SYS_WAITQUE_CREATE);
}
/**
* waitque_destroy - 销毁一个等待队列
* @handle: 句柄
*
* 成功返回0，失败返回-1
*/
int waitque_destroy(int handle)
{
return syscall1(int, SYS_WAITQUE_DESTROY, handle);
}
/**
* waitque_wait - 把自己添加到等待队列
* @handle: 句柄
* @value: 对地址里面的值进行操作
*
* 成功返回0，失败返回-1
*/
int waitque_wait(int handle, void *addr, unsigned int wqflags, unsigned long value)
{
return syscall4(int, SYS_WAITQUE_WAIT, handle, addr, wqflags, value);
}
/**
* waitque_wake - 从等待队列唤醒一个任务
* @handle: 句柄
*
* 成功返回0，失败返回-1
*/
int waitque_wake(int handle, void *addr, unsigned int wqflags, unsigned long value)
{
return syscall4(int, SYS_WAITQUE_WAKE, handle, addr, wqflags, value);
}
|
NightfallDM/xbook2
|
src/include/xbook/rwlock.h
|
<reponame>NightfallDM/xbook2
#ifndef _XBOOK_RWLOCK_H
#define _XBOOK_RWLOCK_H
/* 读写锁机制：
读者优先
写者优先
读写公平
*/
#include "mutexlock.h"
/* rwlock 读写优先参数 */
enum rwlock_arg {
RWLOCK_RD_FIRST = 0, /* 读者优先 */
RWLOCK_WR_FIRST, /* 写着优先 */
RWLOCK_RW_FAIR, /* 读写公平 */
};
typedef struct rwlock {
int count; /* 读者数 */
mutexlock_t count_mutex; /* 保护count更新时的互斥 */
mutexlock_t rw_mutex; /* 保证读者和写着互斥访问资源 */
mutexlock_t write_mutex; /* 用于实现“写优先” */
/* 读写锁上锁和解锁函数指针 */
void (*read_lock)(struct rwlock *);
void (*write_lock)(struct rwlock *);
void (*read_unlock)(struct rwlock *);
void (*write_unlock)(struct rwlock *);
} rwlock_t;
#define RWLOCK_INIT_RD_FIRST(lockname) \
{ .count = 0 \
, .count_mutex = MUTEX_LOCK_INIT((lockname).count_mutex) \
, .rw_mutex = MUTEX_LOCK_INIT((lockname).rw_mutex) \
, .write_mutex = MUTEX_LOCK_INIT((lockname).write_mutex) \
, .read_lock = __rwlock_read_lock_rd_first \
, .read_unlock = __rwlock_read_unlock_rd_first \
, .write_lock = __rwlock_write_lock_rd_first \
, .write_unlock = __rwlock_write_unlock_rd_first \
}
#define RWLOCK_INIT_WR_FIRST(lockname) \
{ .count = 0 \
, .count_mutex = MUTEX_LOCK_INIT((lockname).count_mutex) \
, .rw_mutex = MUTEX_LOCK_INIT((lockname).rw_mutex) \
, .write_mutex = MUTEX_LOCK_INIT((lockname).write_mutex) \
, .read_lock = __rwlock_read_lock_wr_first \
, .read_unlock = __rwlock_read_unlock_wr_first \
, .write_lock = __rwlock_write_lock_wr_first \
, .write_unlock = __rwlock_write_unlock_wr_first \
}
#define RWLOCK_INIT_RW_FAIR(lockname) \
{ .count = 0 \
, .count_mutex = MUTEX_LOCK_INIT((lockname).count_mutex) \
, .rw_mutex = MUTEX_LOCK_INIT((lockname).rw_mutex) \
, .write_mutex = MUTEX_LOCK_INIT((lockname).write_mutex) \
, .read_lock = __rwlock_read_lock_rw_fair \
, .read_unlock = __rwlock_read_unlock_rw_fair \
, .write_lock = __rwlock_write_lock_rw_fair \
, .write_unlock = __rwlock_write_unlock_rw_fair \
}
#define DEFINE_RWLOCK_RD_FIRST(lockname) \
rwlock_t lockname = RWLOCK_INIT_RD_FIRST(lockname)
#define DEFINE_RWLOCK_WR_FIRST(lockname) \
rwlock_t lockname = RWLOCK_INIT_WR_FIRST(lockname)
#define DEFINE_RWLOCK_RW_FAIR(lockname) \
rwlock_t lockname = RWLOCK_INIT_RW_FAIR(lockname)
/* ----读优先---- */
static inline void __rwlock_read_lock_rd_first(rwlock_t *lock)
{
mutex_lock(&lock->count_mutex); /* 互斥访问count变量 */
if (lock->count == 0) /* 当第一个读进程读取共享资源时 */
mutex_lock(&lock->rw_mutex); /* 阻止写进程写 */
lock->count++; /* 读者计数加1 */
mutex_unlock(&lock->count_mutex); /* 释放对count的互斥 */
}
static inline void __rwlock_read_unlock_rd_first(rwlock_t *lock)
{
mutex_lock(&lock->count_mutex); /* 互斥访问count变量 */
lock->count--; /* 读者计数减1 */
if (lock->count == 0) /* 当最后一个读进程读取共享资源时 */
mutex_unlock(&lock->rw_mutex); /* 允许写进程写 */
mutex_unlock(&lock->count_mutex); /* 释放对count的互斥 */
}
static inline void __rwlock_write_lock_rd_first(rwlock_t *lock)
{
mutex_lock(&lock->rw_mutex); /* 互斥访问读写资源 */
}
static inline void __rwlock_write_unlock_rd_first(rwlock_t *lock)
{
mutex_unlock(&lock->rw_mutex); /* 互斥访问读写资源 */
}
/* ----写优先---- */
static inline void __rwlock_read_lock_wr_first(rwlock_t *lock)
{
mutex_lock(&lock->write_mutex); /* 在无写进程请求时进入 */
mutex_lock(&lock->count_mutex); /* 互斥访问count变量 */
if (lock->count == 0) /* 当第一个读进程读取共享资源时 */
mutex_lock(&lock->rw_mutex); /* 阻止写进程写 */
lock->count++; /* 读者计数加1 */
mutex_unlock(&lock->count_mutex); /* 释放对count的互斥 */
mutex_unlock(&lock->write_mutex); /* 恢复对共享资源的访问 */
}
#define __rwlock_read_unlock_wr_first __rwlock_read_unlock_rd_first
static inline void __rwlock_write_lock_wr_first(rwlock_t *lock)
{
mutex_lock(&lock->write_mutex); /* 在无写进程请求时进入 */
mutex_lock(&lock->rw_mutex); /* 互斥访问读写资源 */
}
static inline void __rwlock_write_unlock_wr_first(rwlock_t *lock)
{
mutex_unlock(&lock->rw_mutex); /* 互斥访问读写资源 */
mutex_unlock(&lock->write_mutex); /* 恢复对共享资源的访问 */
}
/* ----读写公平---- */
#define __rwlock_read_lock_rw_fair __rwlock_read_lock_wr_first
#define __rwlock_read_unlock_rw_fair __rwlock_read_unlock_wr_first
static inline void __rwlock_write_lock_rw_fair(rwlock_t *lock)
{
mutex_lock(&lock->write_mutex); /* 在无写进程请求时进入 */
mutex_lock(&lock->rw_mutex); /* 互斥访问读写资源 */
mutex_unlock(&lock->write_mutex); /* 恢复对共享资源的访问 */
}
static inline void __rwlock_write_unlock_rw_fair(rwlock_t *lock)
{
mutex_unlock(&lock->rw_mutex); /* 互斥访问读写资源 */
}
void rwlock_init(rwlock_t *lock, enum rwlock_arg arg);
static inline void rwlock_rdlock(rwlock_t *lock)
{
if (lock->read_lock)
lock->read_lock(lock);
}
static inline void rwlock_wrlock(rwlock_t *lock)
{
if (lock->write_lock)
lock->write_lock(lock);
}
static inline void rwlock_rdunlock(rwlock_t *lock)
{
if (lock->read_unlock)
lock->read_unlock(lock);
}
static inline void rwlock_wrunlock(rwlock_t *lock)
{
if (lock->write_unlock)
lock->write_unlock(lock);
}
#endif /* _XBOOK_RWLOCK_H */
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/page.h
|
<filename>src/arch/x86/include/arch/page.h
#ifndef _ARCH_PAGE_H
#define _ARCH_PAGE_H
#include "interrupt.h"
// 页目录类型
typedef unsigned int pde_t;
// 页表类型
typedef unsigned int pte_t;
//PDT = PAGE DIR TABLE
//内核的页目录表物理地址
#define PAGE_DIR_PHY_ADDR 0X201000
//内核的页目录表虚拟地址
#define PAGE_DIR_VIR_ADDR 0X80201000
//PT = PAGE TABLE
//内核的页表物理地址
#define PAGE_TABLE_PHY_ADDR 0X202000
//内核的页表虚拟地址
#define PAGE_TABLE_VIR_ADDR 0X80202000
// 在loader中初始化了2个页表，满足需要
#define PAGE_TABLE_PHY_NR 2
#define PG_P_1 1 // 0001 exist in memory
#define PG_P_0 0 // 0000 not exist in memory
#define PG_RW_R 0 // 0000 R/W read/execute
#define PG_RW_W 2 // 0010 R/W read/write/execute
#define PG_US_S 0 // 0000 U/S system level, cpl0,1,2
#define PG_US_U 4 // 0100 U/S user level, cpl3
#define PAGE_SHIFT 12
#define PAGE_SIZE (1U<<PAGE_SHIFT)
#define PAGE_MASK (~(PAGE_SIZE-1))
#define PAGE_INSIDE (PAGE_SIZE-1)
//一个页有多少项
#define PAGE_ENTRY_NR 1024
//获取页目录项的索引(存放了页表的地址和属性)
#define PDE_IDX(addr) ((addr & 0xffc00000) >> 22)
//获取页表项的索引(存放了页的地址和属性)
#define PTE_IDX(addr) ((addr & 0x003ff000) >> 12)
/* 一点内存中页的数量 */
#define PAGE_NR_IN_1GB (0X40000000 / PAGE_SIZE)
#define PAGE_NR_IN_16MB (0X1000000 / PAGE_SIZE)
// 保证值和页的大小对齐
#define PAGE_ALIGN(value) ((value + PAGE_SIZE - 1) & PAGE_MASK)
// 检测pte存在
#define PAGE_PTE_EXIST(entry) (entry & PAGE_P_1)
// 通过and运算把一个页地址去掉属性部分
#define PAGE_ADDR_MASK 0xfffff000
/* 页故障导致的错误码 */
#define PG_ERR_NONE_PRESENT (0<<0)
#define PG_ERR_PROTECT (1<<0)
#define PG_ERR_READ (0<<1)
#define PG_ERR_WRITE (1<<1)
#define PG_ERR_SUPERVISOR (0<<2)
#define PG_ERR_USER (1<<2)
static inline pde_t *get_kpdir_ptr()
{
return (pde_t *)PAGE_DIR_VIR_ADDR;
}
/**
* get_pde_ptr - 获取pde
* @vaddr: 虚拟地址
*
* 通过虚拟地址获取它对应的pde
*/
static inline pde_t *get_pde_ptr(unsigned int vaddr)
{
// 获取地址对应的页目录项地址
pde_t *pde = (unsigned int *)(0xfffff000 + \
PDE_IDX(vaddr)*4);
return pde;
}
/**
* get_pte_ptr - 获取pte
* @vaddr: 虚拟地址
*
* 通过虚拟地址获取它对应的pte
*/
static inline pte_t *get_pte_ptr(unsigned int vaddr)
{
// 获取页表项地址
pte_t *pte = (unsigned int *)(0xffc00000 + \
((vaddr & 0xffc00000) >> 10) + PTE_IDX(vaddr)*4);
return pte;
}
unsigned long __alloc_pages(unsigned long count);
int __free_pages(unsigned long page);
void __page_link(unsigned long va, unsigned long pa, unsigned long prot);
void __page_unlink(unsigned long vaddr);
int __map_pages(unsigned long start, unsigned long len, unsigned long prot);
int __unmap_pages(unsigned long vaddr, unsigned long len);
int __map_pages_safe(unsigned long start, unsigned long len, unsigned long prot);
int __unmap_pages_safe(unsigned long start, unsigned long len, char fixed);
int __map_pages_fixed(unsigned long start, unsigned long addr,
unsigned long len, unsigned long prot);
// 该地址是2GB虚拟地址的偏移
#define PAGE_OFFSET 0X80000000
/* 普通地址转换成物理地址 */
#define __pa(x) ((unsigned long)(x) - PAGE_OFFSET)
/* 普通地址转换成虚拟地址 */
#define __va(x) ((void *)((unsigned long)(x) + PAGE_OFFSET))
/* 非连续内存地址转换 */
unsigned long __addr_v2p(unsigned long vaddr);
int mem_self_mapping(unsigned int start, unsigned int end);
unsigned long *__copy_kernel_page_dir();
/* active page dir */
void __page_dir_active(unsigned int page, int on);
int do_page_fault(trap_frame_t *frame);
/* protect flags */
#define PROT_NONE 0x0 /* page can not be accessed */
#define PROT_READ 0x1 /* page can be read */
#define PROT_WRITE 0x2 /* page can be written */
#define PROT_EXEC 0x4 /* page can be executed */
#define PROT_KERN 0x8 /* page in kernel */
#define PROT_USER 0x10 /* page in user */
#define PROT_REMAP 0x20 /* page remap */
static inline unsigned long v2p(void *address)
{
return __pa(address);
}
static inline void *p2v(unsigned long address)
{
return __va(address);
}
#define alloc_pages(count) __alloc_pages(count)
#define free_pages(addr) __free_pages(addr)
#define alloc_page() alloc_pages(1)
#define free_page(addr) free_pages(addr)
#define page_link(va, pa, prot) __page_link(va, pa, prot)
#define page_unlink(va) __page_unlink(va)
#define map_pages(start, len, prot) __map_pages(start, len, prot)
#define unmap_pages(va, len) __unmap_pages(va, len)
#define map_pages_fixed(start, addr, len, prot) __map_pages_fixed(start, addr, len, prot)
#define map_pages_safe(start, len, prot) __map_pages_safe(start, len, prot);
#define unmap_pages_safe(start, len, fixed) __unmap_pages_safe(start, len, fixed);
#define addr2page(addr) __page2mem_node(addr);
#define page2addr(page) __mem_node2page(page);
#define get_free_page_nr __get_free_page_nr
#define get_total_page_nr __get_total_page_nr
#define copy_kernel_page_storge __copy_kernel_page_dir
#define page_dir_active __page_dir_active
#define sched_preempt __sched_preempt
#define addr_v2p(addr) __addr_v2p(addr)
#endif /* _ARCH_PAGE_H */
|
NightfallDM/xbook2
|
user/tests/test_png.c
|
<filename>user/tests/test_png.c
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <png.h>
#include "test.h"
#define PNG_BYTES_TO_CHECK 8
#define HAVE_ALPHA 1
#define NOT_HAVE_ALPHA 0
typedef struct _pic_data pic_data;
struct _pic_data {
int width, height; //长宽
int bit_depth; //位深度
int alpha_flag; //是否有透明通道
unsigned char *rgba;//实际rgb数据
};
int check_is_png(FILE **fp, const char *filename) //检查是否png文件
{
char checkheader[PNG_BYTES_TO_CHECK]; //查询是否png头
*fp = fopen(filename, "rb");
if (*fp == NULL) {
printf("open failed ...1\n");
return -1;
}
if (fread(checkheader, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) //读取png文件长度错误直接退出
return -1;
return png_sig_cmp((png_const_bytep)checkheader, 0, PNG_BYTES_TO_CHECK); //0正确, 非0错误
}
int decode_png(const char *filename, pic_data *out) //取出png文件中的rgb数据
{
png_structp png_ptr; //png文件句柄
png_infop info_ptr;//png图像信息句柄
FILE *fp;
if (check_is_png(&fp, filename) != 0) {
printf("file is not png ...\n");
return -1;
}
printf("launcher[%s] ...\n", PNG_LIBPNG_VER_STRING); //打印当前libpng版本号
//1: 初始化libpng的数据结构 :png_ptr, info_ptr
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info_ptr = png_create_info_struct(png_ptr);
//2: 设置错误的返回点
setjmp(png_jmpbuf(png_ptr));
rewind(fp); //等价fseek(fp, 0, SEEK_SET);
//3: 把png结构体和文件流io进行绑定
png_init_io(png_ptr, fp);
//4:读取png文件信息以及强转转换成RGBA:8888数据格式
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0); //读取文件信息
int channels, color_type;
channels = png_get_channels(png_ptr, info_ptr); //通道数量
color_type = png_get_color_type(png_ptr, info_ptr);//颜色类型
out->bit_depth = png_get_bit_depth(png_ptr, info_ptr);//位深度
out->width = png_get_image_width(png_ptr, info_ptr);//宽
out->height = png_get_image_height(png_ptr, info_ptr);//高
//if(color_type == PNG_COLOR_TYPE_PALETTE)
// png_set_palette_to_rgb(png_ptr);//要求转换索引颜色到RGB
//if(color_type == PNG_COLOR_TYPE_GRAY && out->bit_depth < 8)
// png_set_expand_gray_1_2_4_to_8(png_ptr);//要求位深度强制8bit
//if(out->bit_depth == 16)
// png_set_strip_16(png_ptr);//要求位深度强制8bit
//if(png_get_valid(png_ptr,info_ptr,PNG_INFO_tRNS))
// png_set_tRNS_to_alpha(png_ptr);
//if(color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
// png_set_gray_to_rgb(png_ptr);//灰度必须转换成RG
printf("channels = %d color_type = %d bit_depth = %d width = %d height = %d ...\n",
channels, color_type, out->bit_depth, out->width, out->height);
int i, j, k;
int size, pos = 0;
int temp;
//5: 读取实际的rgb数据
png_bytepp row_pointers; //实际存储rgb数据的buf
row_pointers = png_get_rows(png_ptr, info_ptr); //也可以分别每一行获取png_get_rowbytes();
size = out->width * out->height; //申请内存先计算空间
if (channels == 4 || color_type == PNG_COLOR_TYPE_RGB_ALPHA) { //判断是24位还是32位
out->alpha_flag = HAVE_ALPHA; //记录是否有透明通道
size *= (sizeof(unsigned char) * 4); //size = out->width * out->height * channel
out->rgba = (png_bytep)malloc(size);
if (NULL == out->rgba) {
printf("malloc rgba faile ...\n");
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(fp);
return -1;
}
//从row_pointers里读出实际的rgb数据出来
temp = channels - 1;
for (i = 0; i < out->height; i++)
for (j = 0; j < out->width * 4; j += 4)
for (k = temp; k >= 0; k--)
out->rgba[pos++] = row_pointers[i][j + k];
} else if (channels == 3 || color_type == PNG_COLOR_TYPE_RGB) { //判断颜色深度是24位还是32位
out->alpha_flag = NOT_HAVE_ALPHA;
size *= (sizeof(unsigned char) * 3);
out->rgba = (png_bytep)malloc(size);
if (NULL == out->rgba) {
printf("malloc rgba faile ...\n");
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(fp);
return -1;
}
//从row_pointers里读出实际的rgb数据
temp = (3 * out->width);
for (i = 0; i < out->height; i ++) {
for (j = 0; j < temp; j += 3) {
out->rgba[pos++] = row_pointers[i][j+2];
out->rgba[pos++] = row_pointers[i][j+1];
out->rgba[pos++] = row_pointers[i][j+0];
}
}
} else return -1;
//6:销毁内存
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(fp);
//此时， 我们的out->rgba里面已经存储有实际的rgb数据了
//处理完成以后free(out->rgba)
return 0;
}
int RotationRight90(unsigned char * src, int srcW, int srcH, int channel) //顺时针旋转90度
{
unsigned char * tempSrc = NULL; //临时的buf用来记录原始的图像(未旋转之前的图像)
int mSize = srcW * srcH * sizeof(char) * channel;
int i = 0;
int j = 0;
int k = 0;
//int l = 3;
int desW = 0;
int desH = 0;
desW = srcH;
desH = srcW;
tempSrc = (unsigned char *)malloc(sizeof(char) * srcW * srcH * channel);
memcpy(tempSrc, src, mSize); //拷贝原始图像至tempbuf
for(i = 0; i < desH; i ++)
{
for(j = 0; j < desW; j ++)
{
for(k = 0; k < channel; k ++)
{
src[(i * desW + j) * channel + k] = tempSrc[((srcH - 1 - j) * srcW + i) * channel + k]; //替换像素
}
}
}
free(tempSrc);
return 0;
}
int write_png_file(const char *filename , pic_data *out) //生成一个新的png图像
{
png_structp png_ptr;
png_infop info_ptr;
png_byte color_type;
png_bytep * row_pointers;
FILE *fp = fopen(filename, "wb");
if (NULL == fp) {
printf("open failed ...2\n");
return -1;
}
//1: 初始化libpng结构体
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
if (!png_ptr) {
printf("png_create_write_struct failed ...\n");
return -1;
}
//2: 初始化png_infop结构体 ，
//此结构体包含了图像的各种信息如尺寸，像素位深, 颜色类型等等
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
printf("png_create_info_struct failed ...\n");
return -1;
}
//3: 设置错误返回点
if (setjmp(png_jmpbuf(png_ptr))) {
printf("error during init_io ...\n");
return -1;
}
//4:绑定文件IO到Png结构体
png_init_io(png_ptr, fp);
if (setjmp(png_jmpbuf(png_ptr))) {
printf("error during init_io ...\n");
return -1;
}
if (out->alpha_flag == HAVE_ALPHA) color_type = PNG_COLOR_TYPE_RGB_ALPHA;
else color_type = PNG_COLOR_TYPE_RGB;
//5：设置以及写入头部信息到Png文件
png_set_IHDR(png_ptr, info_ptr, out->width, out->height, out->bit_depth,
color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
if (setjmp(png_jmpbuf(png_ptr))) {
printf("error during init_io ...\n");
return -1;
}
int channels, temp;
int i, j, pos = 0;
if (out->alpha_flag == HAVE_ALPHA) {
channels = 4;
temp = (4 * out->width);
printf("have alpha ...\n");
} else {
channels = 3;
temp = (3 * out->width);
printf("not have alpha ...\n");
}
// 顺时针旋转90度 ， 旋转完了一定要把width 和height调换 不然得到的图像是花的 旋转三次就是逆时针旋转一次
//RotationRight90(out->rgba, out->width, out->height, channels);
//RotationRight90(out->rgba, out->height, out->width, channels);
//RotationRight90(out->rgba, out->width, out->height, channels);
row_pointers = (png_bytep*)malloc(out->height * sizeof(png_bytep));
for (i = 0; i < out->height; i++) {
row_pointers[i] = (png_bytep)malloc(temp* sizeof(unsigned char));
for (j = 0; j < temp; j += channels) {
if (channels == 4) {
row_pointers[i][j+3] = out->rgba[pos++];
row_pointers[i][j+2] = out->rgba[pos++];
row_pointers[i][j+1] = out->rgba[pos++];
row_pointers[i][j+0] = out->rgba[pos++];
} else {
row_pointers[i][j+2] = out->rgba[pos++];
row_pointers[i][j+1] = out->rgba[pos++];
row_pointers[i][j+0] = out->rgba[pos++];
}
}
}
//6: 写入rgb数据到Png文件
png_write_image(png_ptr, (png_bytepp)row_pointers);
if (setjmp(png_jmpbuf(png_ptr))) {
printf("error during init_io ...\n");
return -1;
}
//7: 写入尾部信息
png_write_end(png_ptr, NULL);
//8:释放内存 ,销毁png结构体
for (i = 0; i < out->height; i ++)
free(row_pointers[i]);
free(row_pointers);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
return 0;
}
int test_png_main(int argc, char **argv)
{
pic_data out;
if (argc == 3) {
decode_png(argv[2], &out);
//write_png_file(argv[2], &out);
/* 绘制像素 */
unsigned char *p;
uint32_t color;
int x, y;
for (y = 0; y < out.height; y++) {
for (x = 0; x < out.width; x++) {
unsigned char r, g, b, a = 255;
if (out.alpha_flag & HAVE_ALPHA) {
p = out.rgba + (y * out.width + x) * 4;
a = *p++;
b = *p++;
g = *p++;
r = *p++;
} else {
p = out.rgba + (y * out.width + x) * 3;
b = *p++;
g = *p++;
r = *p++;
}
color = (a << 24) | (r << 16) | (g << 8) |(b) ;
screen_output_pixel(x, y , color);
}
}
free(out.rgba);
return 0;
} else {
printf("please input two file, \nargv[2]:source.png");
}
return -1;
}
|
NightfallDM/xbook2
|
src/include/gui/mouse.h
|
<reponame>NightfallDM/xbook2
#ifndef __GUISRV_DRIVER_MOUSE_H__
#define __GUISRV_DRIVER_MOUSE_H__
#include <gui/color.h>
typedef struct _gui_mouse {
int (*open)(void);
int (*close)(void);
int (*read)(void);
int x, y;
int last_x; /* 上次坐标 */
int last_y;
SCREEN_COLOR old_color; /* 鼠标原来的颜色 */
void (*motion)(void);
void (*button_down)(int);
void (*button_up)(int);
void (*show)(int , int );
} gui_mouse_t;
extern gui_mouse_t gui_mouse;
int gui_init_mouse();
#endif /* __GUISRV_DRIVER_MOUSE_H__ */
|
NightfallDM/xbook2
|
src/include/gui/font.h
|
#ifndef __GUISRV_FONT_FONT_H__
#define __GUISRV_FONT_FONT_H__
#include <types.h>
#include <stdint.h>
#include <gui/color.h>
/* 字体数量 */
#define GUI_MAX_FONT_NR 10
#define GUI_FONT_NAME_LEN 24
#define GUI_FONT_COPYRIGHT_NAME_LEN 24
typedef struct _gui_font {
char name[GUI_FONT_NAME_LEN]; /* 字体名字 */
char copyright[GUI_FONT_COPYRIGHT_NAME_LEN]; /* 字体版权 */
uint8_t *addr; /* 字体数据地址 */
int width; /* 单字宽度 */
int height; /* 单字宽度 */
} gui_font_t;
extern gui_font_t *font_current;
#define current_font font_current
void gui_init_font();
int gui_register_font(gui_font_t *font);
gui_font_t *gui_get_font(char *name);
int gui_unregister_font(gui_font_t *font);
gui_font_t *gui_select_font(char *name);
#define CONFIG_FONT_STANDARD
/* 导入字体注册 */
#ifdef CONFIG_FONT_STANDARD
extern void gui_register_font_standard();
#endif
#ifdef CONFIG_FONT_SIMSUN
extern void gui_register_font_simsun();
#endif
#endif /* __GUISRV_FONT_FONT_H__ */
|
NightfallDM/xbook2
|
src/include/xbook/schedule.h
|
#ifndef _XBOOK_SCHEDULE_H
#define _XBOOK_SCHEDULE_H
#include "task.h"
#include <list.h>
#include <assert.h>
#include "debug.h"
/*任务优先级 */
enum task_priority {
TASK_PRIO_BEST = 0, /* 最佳优先级 */
TASK_PRIO_RT, /* 实时优先级 */
TASK_PRIO_USER, /* 用户优先级 */
TASK_PRIO_IDLE, /* IDLE优先级 */
};
extern priority_queue_t *highest_prio_queue;
extern priority_queue_t priority_queue[];
/* 优先级队列数量 */
#define MAX_PRIORITY_NR 4
#define ADJUST_HIGHEST_PRIO(highest) \
while (!(highest->length) && (highest->priority < MAX_PRIORITY_NR - 1)) highest++
#define is_task_in_priority_queue(task) (task->prio_queue == NULL ? 0 : 1)
void schedule();
void init_schedule();
void launch_task();
/**
* is_all_priority_queue_empty - 判断优先级队列是否为空
*/
static inline int is_all_priority_queue_empty()
{
priority_queue_t *queue = highest_prio_queue;
for (; queue < priority_queue + MAX_PRIORITY_NR; queue++) {
if (queue->length > 0) /* 如果优先级队列长度大于0，说明不为空 */
return 0;
}
return 1;
}
/**
* task_priority_queue_add_tail - 把任务添加到特权级队列末尾
* @task: 任务
*
*/
static inline void task_priority_queue_add_tail(task_t *task)
{
task->prio_queue = &priority_queue[task->priority];
//printk("> task %s tp:%d hp:%d", task->name, task->priority, highest_prio_queue->priority);
ASSERT(!list_find(&task->list, &task->prio_queue->list));
// 添加到就绪队列
list_add_tail(&task->list, &task->prio_queue->list);
task->prio_queue->length++; /* 长度+1 */
/* 如果有更高的优先级，那么就把最高优先级指向它 */
if (task->priority < highest_prio_queue->priority) {
//printk("b tp:%d hp:%d", task->priority, highest_prio_queue->priority);
highest_prio_queue = task->prio_queue;
}
}
/**
* task_priority_queue_add_head - 把任务添加到特权级队列头部
* @task: 任务
*
*/
static inline void task_priority_queue_add_head(task_t *task)
{
task->prio_queue = &priority_queue[task->priority];
ASSERT(!list_find(&task->list, &task->prio_queue->list));
// 添加到就绪队列
list_add(&task->list, &task->prio_queue->list);
task->prio_queue->length++; /* 长度+1 */
/* 如果有更高的优先级，那么就把最高优先级指向它 */
if (task->priority < highest_prio_queue->priority) {
highest_prio_queue = task->prio_queue;
}
}
task_t *task_priority_queue_fetch_first();
void print_priority_queue(int prio);
#endif /* _XBOOK_SCHEDULE_H */
|
NightfallDM/xbook2
|
library/xlibc/math/modf.c
|
/*
File: modf.c
Contains: Decompose x to get the integer and fractional parts
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
double modf(double x, double *intptr) {
if (intptr == NULL)
return *(double*)NULL;
double fraction = x;
*intptr = (double)(int)x;
return (fraction - *intptr);
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/pmem.h
|
<reponame>NightfallDM/xbook2
#ifndef _X86_PMEM_H
#define _X86_PMEM_H
#include "atomic.h"
#include <xbook/memcache.h>
// 0MB~1MB是体系结构相关的内存分布
#define BIOS_MEM_ADDR 0X000000000
#define BIOS_MEM_SIZE 0X000100000 // 1MB
// 1MB~2MB是内核镜像
#define KERNEL_MEM_ADDR (BIOS_MEM_ADDR+BIOS_MEM_SIZE)
#define KERNEL_MEM_SIZE 0X000100000 // 1MB
// 2MB~8MB是系统重要信息的存放地址
#define MATERIAL_MEM_ADDR (KERNEL_MEM_ADDR+KERNEL_MEM_SIZE)
#define MATERIAL_MEM_SIZE 0X000600000 // 6MB
// 8MB~16MB是设备DMA的地址
#define DMA_MEM_ADDR (MATERIAL_MEM_ADDR+MATERIAL_MEM_SIZE)
#define DMA_MEM_SIZE 0X000800000 // 10MB
// ---- 以上是必须的基本内存使用情况 ----
// 16M以上是普通内存开始地址
#define NORMAL_MEM_ADDR (DMA_MEM_ADDR+DMA_MEM_SIZE)
#define TOP_MEM_ADDR 0xFFFFFFFF // 最高内存地址
/* 空内存，当前页目录表物理地址的映射（不可访问） */
#define NULL_MEM_SIZE 0X400000
#define NULL_MEM_ADDR (TOP_MEM_ADDR - NULL_MEM_SIZE + 1)
#define HIGH_MEM_SIZE 0x8000000 // 非连续性内存128MB
/* 非连续内存起始地址, 4MB+128MB*/
#define HIGH_MEM_ADDR (TOP_MEM_ADDR - (HIGH_MEM_SIZE + NULL_MEM_SIZE) + 1)
#define __VMAREA_BASE HIGH_MEM_ADDR
#define __VMAREA_END NULL_MEM_ADDR
/* 内核栈 */
#define KERNEL_STATCK_TOP 0x8009f000
#define KERNEL_STATCK_BOTTOM (KERNEL_STATCK_TOP - (TASK_KSTACK_SIZE))
/* mem_node 内存节点，用于管理每一段物理内存（以页为单位） */
typedef struct {
unsigned int count; /* 内存节点占用的页数 */
unsigned int flags; /* 节点标志 */
int reference; /* 引用次数 */
mem_cache_t *cache; /* 内存缓冲 */
mem_group_t *group; /* 内存组 */
} mem_node_t;
#define SIZEOF_MEM_NODE sizeof(mem_node_t)
#define MEM_NODE_MARK_CHACHE_GROUP(node, cache, group) \
node->cache = cache; \
node->group = group
#define MEM_NODE_CLEAR_GROUP_CACHE(node) \
node->cache = NULL; \
node->group = NULL
#define MEM_NODE_GET_GROUP(node) node->group
#define MEM_NODE_GET_CACHE(node) node->cache
#define CHECK_MEM_NODE(node) \
if (node == NULL) panic("Mem node error!\n")
int init_pmem();
void dump_mem_node(mem_node_t *node);
mem_node_t *__page2mem_node(unsigned int page);
unsigned int __mem_node2page(mem_node_t *node);
mem_node_t *get_free_mem_node();
unsigned long __get_free_page_nr();
unsigned long __get_total_page_nr();
#endif /*_X86_PMEM_H */
|
NightfallDM/xbook2
|
src/include/xbook/alarm.h
|
<filename>src/include/xbook/alarm.h
#ifndef _XBOOK_ALARM_H
#define _XBOOK_ALARM_H
/* 闹钟结构 */
typedef struct alarm_struct {
char flags; /* 有效标志 */
unsigned long ticks; /* ticks计数 */
unsigned long second; /* 秒数 */
} alarm_t;
static inline void alarm_init(alarm_t *alarm)
{
alarm->flags = 0;
alarm->ticks = 0;
alarm->second = 0;
}
unsigned long sys_alarm(unsigned long second);
void update_alarms();
#endif /* _XBOOK_ALARM_H */
|
NightfallDM/xbook2
|
library/xlibc/math/sinh.c
|
<gh_stars>0
/*
File: sinh.c
Contains: For sinh(x)
Written by: GUI
Copyright: (C) 2017-2020 by GuEe Studio for Book OS. All rights reserved.
*/
#include <math.h>
M_FLOAT sinh(M_FLOAT x) {
double exponent = exp(x);
return ((exponent - 1.0 / exponent) / 2.0);
}
|
NightfallDM/xbook2
|
library/xlibc/syslib/vmm.c
|
#include <sys/syscall.h>
#include <sys/vmm.h>
/**
* heap() - memory heap operate
*
* @heap: heap value
*
* if heap = 0, return current heap value.
* if heap > old heap, expand heap up.
* if heap < old heap, shrink heap down.
* if heap = old heap, do nothing.
*
* @return: always return newest heap value
*/
void *heap(void *heap)
{
return syscall1(void *, SYS_HEAP, heap);
}
/**
* munmap() - ummap memory range
* @addr: start addr
* @length: memory length
*
* @return: success is 0, failed is -1
*/
int munmap(void *addr, size_t length)
{
return syscall2(int , SYS_MUNMAP, addr, length);
}
/**
* mstate() - get memory state
* @ms: memory state
*
* @return: success is 0, failed is -1
*/
int mstate(mstate_t *ms)
{
return syscall1(int , SYS_MSTATE, ms);
}
|
NightfallDM/xbook2
|
library/pthread/semaphore.c
|
<filename>library/pthread/semaphore.c
#include <semaphore.h>
#include <errno.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/time.h>
int sem_init(sem_t *sem, int pshared, unsigned int value)
{
if (sem == NULL || value > SEM_VALUE_MAX) {
return EINVAL;
}
if (pshared) {
return ENOSYS;
}
int status;
status = pthread_mutex_init(&sem->mutex, NULL);
if(status != 0)
goto error;
status = pthread_cond_init(&sem->cond, NULL);
if(status != 0)
{
pthread_mutex_destroy(&sem->mutex);
goto error;
}
sem->value = value;
sem->valid = SEM_VALID;
return 0;
error:
return status;
}
int sem_destroy(sem_t *sem)
{
int status1, status2;
if(sem == NULL || sem->valid != SEM_VALID) {
return EINVAL;
}
sem->value = 0;
sem->valid = 0;
//try best to destroy all object, so judge the status' after all
//object destroy
status1 = pthread_mutex_destroy(&sem->mutex);
status2 = pthread_cond_destroy(&sem->cond);
if(status1 != 0)
return status1;
return status2;
}
/**
* returns 0 on success; on error, -1 is returned and errno
* is set to indicate the error.
*/
int sem_getvalue(sem_t *sem, int *sval)
{
if (sem == NULL || sval == NULL) {
return EINVAL;
}
*sval = sem->value;
return 0;
}
static void cleanup_unlock(void* arg)
{
pthread_mutex_t *mutex = (pthread_mutex_t*)arg;
pthread_mutex_unlock(mutex);
}
int sem_wait(sem_t *sem)
{
int status;
if(sem == NULL || sem->valid != SEM_VALID) {
return EINVAL;
}
status = pthread_mutex_lock(&sem->mutex);
if(status != 0)
return status;
//因为pthread_cond_wait是可取消点。所以当线程在pthread_cond_wait
//中睡眠的时候，其他线程调用thread_cancel取消这个睡眠的线程时,
//睡眠的线程将苏醒，然后继续锁住mutex, 之后就退出终止。
//所以，要设定一个清理函数，发生这种情况时，在清理函数中解锁。
pthread_cleanup_push(cleanup_unlock, &sem->mutex);
while(sem->value <= 0) {
//cann't be interruptted by a signal
status = pthread_cond_wait(&sem->cond, &sem->mutex);
if( status != 0 )
break;
}
--sem->value; //可用资源减一
pthread_cleanup_pop(0);
//ignore the error. if status == 0 and unlock return not 0.
//we cann't return this message to user. it will confuse the user
//the signal is sucessful, but return error code
pthread_mutex_unlock(&sem->mutex);
return status;
}
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout)
{
int status;
if(sem == NULL || sem->valid != SEM_VALID) {
return EINVAL;
}
status = pthread_mutex_lock(&sem->mutex);
if( status != 0 )
return status;
pthread_cleanup_push(cleanup_unlock, &sem->mutex);
while(sem->value <= 0) {
status = pthread_cond_timedwait(&sem->cond, &sem->mutex, abs_timeout);
if( status == EINTR ) //can be interruptted by a signal.
continue;
else
break;
}
if(status == 0)
--sem->value;
pthread_cleanup_pop(0);
//ignore the error. if status == 0 and unlock return not 0.
//we cann't return this message to user. it will confuse the user
//the signal is sucessful, but return error code
pthread_mutex_unlock(&sem->mutex);
return status;
}
int sem_timedwait2(sem_t* sem, int msecs)
{
struct timeval now;
struct timespec waittime;
if(msecs < 0)
msecs = 0;
int sec = msecs / 1000;
gettimeofday(&now, NULL);
waittime.tv_sec = now.tv_sec + sec;
waittime.tv_nsec = (now.tv_usec + (msecs%1000)*1000)*1000;
return sem_timedwait(sem, &waittime);
}
int sem_trywait(sem_t *sem)
{
if (sem == NULL) {
return EINVAL;
}
/* 没有超时时间，直接返回 */
int status = sem_timedwait(sem, NULL);
//int status = sem_timedwait2(sem, 0);
if( status == ETIMEDOUT )
return EAGAIN;
return status;
}
int sem_post(sem_t *sem)
{
int status;
if( sem == NULL || sem->valid != SEM_VALID ) {
return EINVAL;
}
status = pthread_mutex_lock(&sem->mutex);
if( status != 0 )
goto error;
++sem->value; //加一，表示可用资源多了一个
status = pthread_mutex_unlock(&sem->mutex);
if( status != 0 )
goto error;
status = pthread_cond_signal(&sem->cond);
if (sem->value > SEM_VALUE_MAX)
return EOVERFLOW;
error:
return status;
}
|
NightfallDM/xbook2
|
library/xlibc/unistd/mount.c
|
#include <unistd.h>
#include <types.h>
#include <stddef.h>
#include <string.h>
#include <math.h>
#include <sys/srvcall.h>
#include <srv/filesrv.h>
int mount(
const char *source,
const char *target,
const char *fstype,
unsigned long flags
) {
if (source == NULL || target == NULL || fstype == NULL)
return -1;
DEFINE_SRVARG(srvarg);
SETSRV_ARG(&srvarg, 0, FILESRV_MOUNT, 0);
SETSRV_ARG(&srvarg, 1, source, strlen(source) + 1);
SETSRV_ARG(&srvarg, 2, target, strlen(target) + 1);
SETSRV_ARG(&srvarg, 3, fstype, strlen(fstype) + 1);
SETSRV_ARG(&srvarg, 4, flags, 0);
SETSRV_RETVAL(&srvarg, -1);
if (!srvcall(SRV_FS, &srvarg)) {
if (GETSRV_RETVAL(&srvarg, int) == -1) {
return -1;
}
return 0;
}
return -1;
}
int unmount(const char *source, unsigned long flags)
{
if (source == NULL)
return -1;
DEFINE_SRVARG(srvarg);
SETSRV_ARG(&srvarg, 0, FILESRV_UNMOUNT, 0);
SETSRV_ARG(&srvarg, 1, source, strlen(source) + 1);
SETSRV_ARG(&srvarg, 2, flags, 0);
SETSRV_RETVAL(&srvarg, -1);
if (!srvcall(SRV_FS, &srvarg)) {
if (GETSRV_RETVAL(&srvarg, int) == -1) {
return -1;
}
return 0;
}
return -1;
}
int mkfs(
const char *source,
const char *fstype,
unsigned long flags
) {
if (source == NULL || fstype == NULL)
return -1;
DEFINE_SRVARG(srvarg);
SETSRV_ARG(&srvarg, 0, FILESRV_MKFS, 0);
SETSRV_ARG(&srvarg, 1, source, strlen(source) + 1);
SETSRV_ARG(&srvarg, 2, fstype, strlen(fstype) + 1);
SETSRV_ARG(&srvarg, 3, flags, 0);
SETSRV_RETVAL(&srvarg, -1);
if (!srvcall(SRV_FS, &srvarg)) {
if (GETSRV_RETVAL(&srvarg, int) == -1) {
return -1;
}
return 0;
}
return -1;
}
|
NightfallDM/xbook2
|
src/include/xbook/cpu.h
|
<filename>src/include/xbook/cpu.h
#ifndef _XBOOK_CPU_H
#define _XBOOK_CPU_H
#include <arch/cpu.h>
static inline void cpu_pause(void)
{
arch_cpu_pause();
}
#endif /* _XBOOK_CPU_H */
|
NightfallDM/xbook2
|
src/include/xbook/synclock.h
|
<reponame>NightfallDM/xbook2<filename>src/include/xbook/synclock.h
/*
同步锁：
用于同步，让进程可以有序地执行
*/
#ifndef _XBOOK_SYNCLOCK_H
#define _XBOOK_SYNCLOCK_H
#include <xbook/semaphore.h>
#include <xbook/task.h>
#include <assert.h>
typedef struct synclock {
task_t *holder; // 锁的持有者
semaphore_t semaphore; // 用多元信号量来实现锁
unsigned int reapt_count; // 锁的持有者重复申请锁的次数
} synclock_t;
#define SYNC_LOCK_INIT(lockname) \
{ .holder = NULL \
, .semaphore = SEMAPHORE_INIT((lockname).semaphore, 1) \
, .reapt_count = 0 \
}
#define DEFINE_SYNC_LOCK(lockname) \
synclock_t lockname = SYNC_LOCK_INIT(lockname)
/**
* synclock_init - 初始化同步锁
* @lock: 锁对象
*/
static inline void synclock_init(synclock_t *lock)
{
lock->holder = NULL; // 最开始没有持有者
lock->reapt_count = 0; // 一次都没有重复
// 初始信号量为1，表示可以被使用一次
semaphore_init(&lock->semaphore, 1);
}
/**
* sync_lock - 同步锁加锁
* @lock: 锁对象
*/
static inline void sync_lock(synclock_t *lock)
{
if (lock->holder != current_task) { // 自己没有锁才获取信号量
/* 获取信号量，如果信号量已经被其它任务占用，那么自己就等待
直到信号量被其它任务释放，自己才可以获取*/
semaphore_down(&lock->semaphore);
lock->holder = current_task; // 当自己成功获取信号量后才把锁的持有者设置成当前任务
ASSERT(lock->reapt_count == 0); // 有新的任务第一次获取锁，说明锁还没有被任务重复获取
lock->reapt_count = 1; // 现在被新的任务获取了，所以现在有1次获取
} else {
/*自己已经获取锁，在这里又来获取，所以就直接增加重复次数，而不执行获取信号量的操作*/
lock->reapt_count++;
}
}
/**
* sync_unlock - 同步锁解锁
* @lock: 锁对象
*/
static inline void sync_unlock(synclock_t *lock)
{
ASSERT(lock->holder == current_task); // 释放的时候自己必须持有锁
if (lock->reapt_count > 1) { // 如果自己获取多次，那么只有等次数为1时才会真正释放信号量
lock->reapt_count--; // 减少重复次数并返回
return;
}
// 到这儿的话，就可以真正释放信号量了，相当于到达最外层的锁释放
ASSERT(lock->reapt_count == 1);
lock->holder = NULL; // 没有锁的持有者，锁处于未持有状态
lock->reapt_count = 0; // 释放后没有任务持有锁，重复次数为0
semaphore_up(&lock->semaphore); // 执行信号量up操作，释放信号量
}
#endif /* _XBOOK_SYNCLOCK_H */
|
NightfallDM/xbook2
|
library/pthread/pthread_mutex.c
|
<reponame>NightfallDM/xbook2<filename>library/pthread/pthread_mutex.c
#include <pthread.h>
#include <sys/waitque.h>
#include <sys/proc.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)
{
if (!mutex) {
return EINVAL;
}
*mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
if (mutexattr) { /* 修改成参数中的值 */
memcpy(&mutex->mattr, mutexattr, sizeof(pthread_mutexattr_t));
}
mutex->kind = mutex->mattr.type; /* 和属性一致 */
/* 创建内核的锁的等待队列 */
mutex->waitque = waitque_create();
if (mutex->waitque < 0)
return ENOMEM;
return 0;
}
int pthread_mutex_destroy(pthread_mutex_t *mutex)
{
if (!mutex)
return EINVAL;
mutex->count = 0;
mutex->owner = 0;
mutex->kind = 0;
if (mutex->waitque >= 0)
waitque_destroy(mutex->waitque);
mutex->waitque = -1;
mutex->lock = 0;
pthread_spin_init(&mutex->spin, PTHREAD_PROCESS_PRIVATE);
memset(&mutex->mattr, 0, sizeof(pthread_mutexattr_t));
return 0;
}
int pthread_mutex_lock(pthread_mutex_t *mutex)
{
if (!mutex)
return EINVAL;
/* 如果是通过静态方式创建，那么waitque就需要重新获取 */
if (mutex->waitque == -1) {
mutex->waitque = waitque_create();
if (mutex->waitque < 0)
return ENOMEM;
}
if (mutex->kind == PTHREAD_MUTEX_NORMAL) { /* 普通锁 */
while (1) { /* 用循环避免“惊群”效应 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
/* 如果0，那么说明该互斥锁已经被其它线程持有，自己等待 */
if (!test_and_set(&mutex->lock, 0)) {
/*
在即将阻塞前，需要释放mutex->spin自旋锁。但是释放后到waitque_wait之前的这一部分
空间是有可能切换到其它线程，其它线程就可能会同时到达这里。那么就违背了准则。
从获取锁到阻塞期间必须是原子的。
因此，这里不进行pthread_spin_unlock(&mutex->spin);
而是通过waitque_wait，来对自旋锁的值进行操作，来修改自旋锁的值，实现解锁。
因为waitque_wait的执行是原子的，所以只有当他调度出去后，才会产生调度。
*/
//printf("had locked!\n");
/* 设置自选锁值为0，并且阻塞自己 */
waitque_wait(mutex->waitque, (void *) &mutex->spin, WAITQUE_ZERO, 0);
} else {
mutex->lock = 0; /* 获得锁 */
mutex->owner = pthread_self();
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
break;
}
}
} else if (mutex->kind == PTHREAD_MUTEX_ERRORCHECK) { /* 检查锁 */
while (1) { /* 用循环避免“惊群”效应 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (mutex->owner > 0) { /* 已经有线程持有锁 */
if (mutex->owner == pthread_self()) { /* 重复获取锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EDEADLK;
} else { /* 获取其它线程的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM;
}
}
/* 如果非0，那么说明该互斥锁已经被其它线程持有，自己等待 */
if (!test_and_set(&mutex->lock, 0)) {
/*
在即将阻塞前，需要释放mutex->spin自旋锁。但是释放后到waitque_wait之前的这一部分
空间是有可能切换到其它线程，其它线程就可能会同时到达这里。那么就违背了准则。
从获取锁到阻塞期间必须是原子的。
因此，这里不进行pthread_spin_unlock(&mutex->spin);
而是通过waitque_wait，来对自旋锁的值进行操作，来修改自旋锁的值，实现解锁。
因为waitque_wait的执行是原子的，所以只有当他调度出去后，才会产生调度。
*/
//printf("had locked!\n");
/* 设置自选锁值为0，并且阻塞自己 */
waitque_wait(mutex->waitque, (void *) &mutex->spin, WAITQUE_ZERO, 0);
} else {
mutex->lock = 0; /* 获得锁 */
mutex->owner = pthread_self();
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
break;
}
}
} else if (mutex->kind == PTHREAD_MUTEX_RECURSIVE) { /* 可重入锁 */
while (1) { /* 用循环避免“惊群”效应 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (mutex->owner > 0) { /* 已经有线程持有锁 */
if (mutex->owner == pthread_self()) { /* 重复获取锁 */
mutex->count++; /* 重入次数增加 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return 0;
} else { /* 获取其它线程的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM;
}
}
/* 第一次获取时，count必须为0 */
if (mutex->count > 0) {
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EDEADLK;
}
/* 如果非0，那么说明该互斥锁已经被其它线程持有，自己等待 */
if (!test_and_set(&mutex->lock, 0)) {
/*
在即将阻塞前，需要释放mutex->spin自旋锁。但是释放后到waitque_wait之前的这一部分
空间是有可能切换到其它线程，其它线程就可能会同时到达这里。那么就违背了准则。
从获取锁到阻塞期间必须是原子的。
因此，这里不进行pthread_spin_unlock(&mutex->spin);
而是通过waitque_wait，来对自旋锁的值进行操作，来修改自旋锁的值，实现解锁。
因为waitque_wait的执行是原子的，所以只有当他调度出去后，才会产生调度。
*/
//printf("had locked!\n");
/* 设置自选锁值为0，并且阻塞自己 */
waitque_wait(mutex->waitque, (void *) &mutex->spin, WAITQUE_ZERO, 0);
} else {
mutex->lock = 0; /* 获得锁 */
mutex->owner = pthread_self();
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
break;
}
}
}
return 0;
}
int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
if (!mutex)
return EINVAL;
/* 如果是通过静态方式创建，那么waitque就需要重新获取 */
if (mutex->waitque == -1) {
mutex->waitque = waitque_create();
if (mutex->waitque < 0)
return ENOMEM;
}
if (mutex->kind == PTHREAD_MUTEX_NORMAL) { /* 普通锁 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁的操作 */
//printf("[unlock] %d\n", pthread_self());
mutex->lock = 1; /* 释放锁 */
mutex->owner = 0;
waitque_wake(mutex->waitque, NULL, 0, 0);
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
} else if (mutex->kind == PTHREAD_MUTEX_ERRORCHECK) { /* 检测锁 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁的操作 */
if (mutex->lock == 1) { /* 尝试解锁已经解锁的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM; /* 不允许访问 */
}
mutex->lock = 1; /* 释放锁 */
mutex->owner = 0;
waitque_wake(mutex->waitque, NULL, 0, 0);
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
} else if (mutex->kind == PTHREAD_MUTEX_RECURSIVE) { /* 可重入锁 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁的操作 */
if (mutex->lock == 1) { /* 尝试解锁已经解锁的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM; /* 不允许访问 */
}
if (mutex->owner > 0) { /* 已经有线程持有锁 */
if (mutex->owner == pthread_self()) { /* 重复释放锁 */
if (mutex->count > 0) { /* 重入次数大于0，需要自己释放锁 */
mutex->count--; /* 减少重入次数 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return 0; /* 解锁成功 */
}
/* 如果count = 0，那么就会到后面去真正释放锁 */
}
}
mutex->lock = 1; /* 释放锁 */
mutex->owner = 0;
waitque_wake(mutex->waitque, NULL, 0, 0);
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
}
return 0;
}
int pthread_mutex_trylock(pthread_mutex_t *mutex)
{
if (!mutex)
return EINVAL;
if (mutex->kind == PTHREAD_MUTEX_NORMAL) { /* 普通锁 */
/* 可以获取 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (!test_and_set(&mutex->lock, 0)) { /* 非1，表示不能被获取，直接返回 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EBUSY;
}
mutex->lock = 0; /* 锁值减少 */
mutex->owner = pthread_self();
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
} else if (mutex->kind == PTHREAD_MUTEX_ERRORCHECK) { /* 检测锁 */
/* 可以获取 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (mutex->owner > 0) { /* 已经有线程持有锁 */
if (mutex->owner == pthread_self()) { /* 重复获取锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EDEADLK;
} else { /* 获取其它线程的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM;
}
}
/* 可以获取 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (!test_and_set(&mutex->lock, 0)) { /* 非1，表示不能被获取，直接返回 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EBUSY;
}
mutex->owner = pthread_self(); /* 更新占有者 */
mutex->lock = 0; /* 锁值减少 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
} else if (mutex->kind == PTHREAD_MUTEX_RECURSIVE) { /* 可重入锁 */
/* 可以获取 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (mutex->owner > 0) { /* 已经有线程持有锁 */
if (mutex->owner == pthread_self()) { /* 重复获取锁 */
mutex->count++; /* 重入次数增加 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return 0;
} else { /* 获取其它线程的锁 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EPERM;
}
}
/* 可以获取 */
pthread_spin_lock(&mutex->spin); /* 获得对互斥锁得操作 */
if (!test_and_set(&mutex->lock, 0)) { /* 非1，表示不能被获取，直接返回 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
return EBUSY;
}
mutex->owner = pthread_self(); /* 更新占有者 */
mutex->lock = 0; /* 锁值减少 */
pthread_spin_unlock(&mutex->spin); /* 取消对互斥锁得操作 */
}
return 0;
}
/**
* pthread_mutexattr_init - 初始化互斥锁属性
* @mattr: 互斥锁
*
* 成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。
* ENOMEM 描述: 内存不足，无法初始化互斥锁属性对象。
*/
int pthread_mutexattr_init(pthread_mutexattr_t *mattr)
{
if (!mattr)
return EINVAL;
mattr->pshared = PTHREAD_PROCESS_PRIVATE;
mattr->type = PTHREAD_MUTEX_DEFAULT;
return 0;
}
int pthread_mutexattr_destroy(pthread_mutexattr_t *mattr)
{
if (!mattr)
return EINVAL;
mattr->pshared = 0;
mattr->type = 0;
return 0;
}
int pthread_mutexattr_setpshared(pthread_mutexattr_t *mattr, int pshared)
{
if (!mattr)
return EINVAL;
mattr->pshared = pshared;
return 0;
}
int pthread_mutexattr_getpshared(pthread_mutexattr_t *mattr, int *pshared)
{
if (!mattr)
return EINVAL;
if (pshared)
*pshared = mattr->pshared;
return 0;
}
int pthread_mutexattr_settype(pthread_mutexattr_t *mattr , int type)
{
if (!mattr)
return EINVAL;
mattr->type = type;
return 0;
}
int pthread_mutexattr_gettype(pthread_mutexattr_t *mattr , int *type)
{
if (!mattr)
return EINVAL;
if (type)
*type = mattr->type;
return 0;
}
|
NightfallDM/xbook2
|
src/arch/x86/include/arch/segment.h
|
#ifndef _X86_SEGMENT_H
#define _X86_SEGMENT_H
/*
* 段的相关信息会出现在这个文件中
*/
/* 描述符类型值说明 */
#define DA_32 0x4000 /* 32 位段 */
#define DA_G 0x8000 /* 段界限粒度为 4K 字节 */
#define DA_DPL0 0x00 /* DPL = 0 */
#define DA_DPL1 0x20 /* DPL = 1 */
#define DA_DPL2 0x40 /* DPL = 2 */
#define DA_DPL3 0x60 /* DPL = 3 */
/* 存储段描述符类型值说明 */
#define DA_DR 0x90 /* 存在的只读数据段类型值 */
#define DA_DRW 0x92 /* 存在的可读写数据段属性值 */
#define DA_DRWA 0x93 /* 存在的已访问可读写数据段类型值 */
#define DA_C 0x98 /* 存在的只执行代码段属性值 */
#define DA_CR 0x9A /* 存在的可执行可读代码段属性值 */
#define DA_CCO 0x9C /* 存在的只执行一致代码段属性值 */
#define DA_CCOR 0x9E /* 存在的可执行可读一致代码段属性值 */
/* 系统段描述符类型值说明 */
#define DA_LDT 0x82 /* 局部描述符表段类型值 */
#define DA_386TSS 0x89 /* 可用 386 任务状态段类型值 */
/* 选择子类型值说明 */
/* 其中, SA_ : Selector Attribute */
#define SA_RPL0 0
#define SA_RPL1 1
#define SA_RPL2 2
#define SA_RPL3 3
#define SA_TIG 0
#define SA_TIL 4
//index of descriptor
#define INDEX_DUMMY 0
#define INDEX_KERNEL_C 1
#define INDEX_KERNEL_RW 2
#define INDEX_TSS 3
#define INDEX_USER_C 4
#define INDEX_USER_RW 5
#define INDEX_SERVE_C 6
#define INDEX_SERVE_RW 7
//选择子...
//内核代码，数据，栈，视频
#define KERNEL_CODE_SEL ((INDEX_KERNEL_C << 3) + (SA_TIG << 2) + SA_RPL0)
#define KERNEL_DATA_SEL ((INDEX_KERNEL_RW << 3) + (SA_TIG << 2) + SA_RPL0)
#define KERNEL_STACK_SEL KERNEL_DATA_SEL
//用户代码，数据，栈
#define USER_CODE_SEL ((INDEX_USER_C << 3) + (SA_TIG << 2) + SA_RPL3)
#define USER_DATA_SEL ((INDEX_USER_RW << 3) + (SA_TIG << 2) + SA_RPL3)
#define USER_STACK_SEL USER_DATA_SEL
//TSS
#define KERNEL_TSS_SEL ((INDEX_TSS << 3) + (SA_TIG << 2) + SA_RPL0)
//用户代码，数据，栈
#define SERVE_CODE_SEL ((INDEX_SERVE_C << 3) + (SA_TIG << 2) + SA_RPL1)
#define SERVE_DATA_SEL ((INDEX_SERVE_RW << 3) + (SA_TIG << 2) + SA_RPL1)
#define SERVE_STACK_SEL SERVE_DATA_SEL
/* GDT 的虚拟地址 */
#define GDT_VADDR 0x80200000
#define GDT_LIMIT 0x000007ff
/*
段描述符结构
*/
struct segment_descriptor {
unsigned short limit_low, base_low;
unsigned char base_mid, access_right;
unsigned char limit_high, base_high;
};
//初始化段描述符
void init_segment_descriptor();
#endif /*_X86_SEGMENT_H*/
|
NightfallDM/xbook2
|
user/bosh/shell.h
|
<filename>user/bosh/shell.h
#ifndef _BOSH_SHELL_H
#define _BOSH_SHELL_H
#include <stddef.h>
#define APP_NAME "bosh"
int shell_event_poll(char *buf, int pid);
int shell_readline();
void shell_putchar(char ch);
int shell_printf(const char *fmt, ...);
#endif /* _BOSH_SHELL_H */
|
NightfallDM/xbook2
|
src/gui/font/font.c
|
#include <string.h>
#include <gui/font.h>
#include <gui/screen.h>
/* 字体表，存放字体信息 */
gui_font_t font_table[GUI_MAX_FONT_NR];
gui_font_t *font_current;
gui_font_t *gui_get_font(char *name)
{
int i;
for (i = 0; i < GUI_MAX_FONT_NR; i++) {
if (!strcmp(font_table[i].name, name)) {
return &font_table[i];
}
}
return NULL;
}
int gui_register_font(gui_font_t *font)
{
int i;
for (i = 0; i < GUI_MAX_FONT_NR; i++) {
if (font_table[i].addr == NULL) {
/* 注册数据 */
font_table[i] = *font;
return 0;
}
}
return -1;
}
int gui_unregister_font(gui_font_t *font)
{
int i;
for (i = 0; i < GUI_MAX_FONT_NR; i++) {
if (&font_table[i] == font) {
font_table[i].width = 0;
font_table[i].height = 0;
font_table[i].addr = NULL;
return 0;
}
}
return -1;
}
gui_font_t *gui_select_font(char *name)
{
gui_font_t *font = gui_get_font(name);
if (font)
font_current = font;
return font;
}
void gui_init_font()
{
int i;
for (i = 0; i < GUI_MAX_FONT_NR; i++) {
font_table[i].addr = NULL;
font_table[i].width = font_table[i].height = 0;
}
font_current = NULL;
/* 注册字体 */
#ifdef CONFIG_FONT_SIMSUN
gui_register_font_simsun();
#endif /* CONFIG_FONT_SIMSUN */
#ifdef CONFIG_FONT_STANDARD
gui_register_font_standard();
#endif /* CONFIG_FONT_STANDARD */
/* 选择一个默认字体 */
gui_select_font("standard");
}
|
NightfallDM/xbook2
|
src/vmm/memcache.c
|
<filename>src/vmm/memcache.c
/*
* file: kernel/mm/mem_cache.c
* auther: <NAME>
* time: 2019/10/1
* copyright: (C) 2018-2020 by Book OS developers. All rights reserved.
*/
#include <arch/page.h>
#include <arch/interrupt.h>
#include <arch/pmem.h>
#include <xbook/config.h>
#include <xbook/memcache.h>
#include <xbook/debug.h>
#include <string.h>
#include <math.h>
#include <string.h>
#include <xbook/bitmap.h>
/*
* cache_size - cache大小的描述
*/
static cache_size_t cache_size[] = {
#if PAGE_SIZE == 4096
{32, NULL},
#endif
{64, NULL},
{128, NULL},
{256, NULL},
/* 小于1KB的，就在单个页中进行分割 */
{512, NULL},
{1024, NULL},
{2048, NULL},
{4096, NULL},
{8*1024, NULL},
{16*1024, NULL},
{32*1024, NULL},
{64*1024, NULL},
/* 通常情况下最大支持128KB的内存分配，需要在1MB内完成对象分割 */
{128*1024, NULL},
/* 配置大内存的分配 */
#ifdef CONFIG_LARGE_ALLOCS
{256*1024, NULL},
{512*1024, NULL},
{1024*1024, NULL},
{2*1024*1024, NULL},
{4*1024*1024, NULL},
#endif
{0, NULL}, // 用于索引判断结束
};
/*
* 通过页的大小来选择cache数量
*/
#if PAGE_SIZE == 4096
#ifdef CONFIG_LARGE_ALLOCS
#define MAX_MEM_CACHE_NR 18
#else
#define MAX_MEM_CACHE_NR 13
#endif
#else
#ifdef CONFIG_LARGE_ALLOCS
#define MAX_MEM_CACHE_NR 17
#else
#define MAX_MEM_CACHE_NR 12
#endif
#endif
/* 最开始的groupcache */
mem_cache_t mem_cache_table[MAX_MEM_CACHE_NR];
void dump_mem_cache(mem_cache_t *cache)
{
printk("----Mem Cache----\n");
printk("object size %d count %d\n", cache->object_size, cache->object_count);
printk("flags %x name %s\n", cache->flags, cache->name);
printk("full %x partial %x free %x\n", cache->full_groups, cache->partial_groups, cache->free_groups);
}
void dump_mem_group(mem_group_t *group)
{
printk("----Mem Group----\n");
printk("map bits %x len %d\n", group->map.bits, group->map.byte_length);
printk("objects %x flags %x list %x\n", group->objects, group->flags, group->list);
printk("using %d free %x\n", group->using_count, group->free_count);
}
int mem_cache_init(mem_cache_t *cache, char *name, size_t size, flags_t flags)
{
if (!size)
return -1;
// 初始化链表
INIT_LIST_HEAD(&cache->full_groups);
INIT_LIST_HEAD(&cache->partial_groups);
INIT_LIST_HEAD(&cache->free_groups);
/* 根据size来选择不同的储存方式，以节约内存 */
if (size < 1024) { // 如果是小于1024，那么就放到单个页中。
/* 地址和8字节对齐，因为在结构体后面存放位图，位图是8字节为单位的 */
unsigned int group_size = ALIGN_WITH(SIZEOF_MEM_GROUP, 8);
/* 如果是32字节为准，那么，就位图就只需要16字节即可 */
unsigned int left_size = PAGE_SIZE - group_size - 16;
// 对象数量
cache->object_count = left_size / size;;
} else if (size <= 128 * 1024) { // 如果是小于128kb，就放到1MB以内
cache->object_count = (1 * MB) / size;
} else if (size <= 4 * 1024 * 1024) { // 如果是小于4MB，就放到4MB以内
cache->object_count = (4 * MB) / size;
} else {
/* 超过最大范围，则每一个缓存4个对象 */
cache->object_count = 4;
}
// 对象的大小
cache->object_size = size;
// 设定cache的标志
cache->flags = flags;
// 设置名字
memset(cache->name, 0, MEM_CACHE_NAME_LEN);
strcpy(cache->name, name);
//dump_mem_cache(cache);
return 0;
}
static void *mem_cache_alloc_pages(unsigned long count)
{
unsigned long page = alloc_pages(count);
if (!page)
return NULL;
return p2v(page);
}
static int mem_cache_free_pages(void *address)
{
if (address == NULL)
return -1;
unsigned int page = v2p(address);
if (!page)
return -1;
free_pages(page);
return 0;
}
static int mem_group_init(
mem_cache_t *cache,
mem_group_t *group,
flags_t flags
) {
// 把group添加到free链表
list_add(&group->list, &cache->free_groups);
// 位图位于group结构后面
unsigned char *map = (unsigned char *)(group + 1);
// 设定位图
group->map.byte_length = DIV_ROUND_UP(cache->object_count, 8);
group->map.bits = (unsigned char *)map;
bitmap_init(&group->map);
mem_node_t *node;
/* 根据缓冲中记录的对象大小进行不同的设定 */
if (cache->object_size < 1024) {
group->objects = map + 16;
/* 转换成节点，并标记 */
node = addr2page(v2p(group));
CHECK_MEM_NODE(node);
MEM_NODE_MARK_CHACHE_GROUP(node, cache, group);
} else {
unsigned int pages = DIV_ROUND_UP(cache->object_count * cache->object_size, PAGE_SIZE);
group->objects = mem_cache_alloc_pages(pages);
if (group->objects == NULL) {
printk(KERN_ERR "alloc page for mem objects failed\n");
return -1;
}
int i;
for (i = 0; i < pages; i++) {
node = addr2page(v2p(group->objects + i * PAGE_SIZE));
CHECK_MEM_NODE(node);
MEM_NODE_MARK_CHACHE_GROUP(node, cache, group);
}
}
group->using_count = 0;
group->free_count = cache->object_count;
group->flags = flags;
//dump_mem_group(group);
return 0;
}
/*
* groupCreate - 创建一个新的group
* @cache: group所在的cache
* @flags:创建的标志
*
* 如果成功返回，失败返回-1
*/
static int create_mem_group(mem_cache_t *cache, flags_t flags)
{
mem_group_t *group;
unsigned irqflags;
save_intr(irqflags);
//printk("cache %s need a new group %x!\n", cache->name, cache->object_size);
/* 为内存组分配一个页 */
group = mem_cache_alloc_pages(1);
if (group == NULL) {
printk(KERN_ERR "alloc page for mem group failed!\n");
restore_intr(irqflags);
return -1;
}
if (mem_group_init(cache, group, flags)) {
printk(KERN_ERR "init mem group failed!\n");
goto free_group;
}
restore_intr(irqflags);
// 创建成功
return 0;
free_group:
// 释放对象组的页
mem_cache_free_pages(group);
restore_intr(irqflags);
return -1;
}
static int make_mem_caches()
{
// 指向cache大小的指针
cache_size_t *cachesz = cache_size;
// mem_cache_table
mem_cache_t *mem_cache = &mem_cache_table[0];
//printk("mem_cache_table addr %x size %d\n", mem_cache, sizeof(mem_cache_t));
// 如果没有遇到大小为0的cache，就会把cache初始化
while (cachesz->cache_size) {
/* 初始化缓存信息 */
if (mem_cache_init(mem_cache, "mem cache", cachesz->cache_size, 0)) {
printk("create mem cache failed!\n");
return -1;
}
// 设定cachePtr
cachesz->mem_cache = mem_cache;
// 指向下一个mem cache
mem_cache++;
// 指向下一个cache size
cachesz++;
}
return 0;
}
/*
* __mem_cache_alloc_object - 在group中分配一个对象
* @cache: 对象所在的cache
* @group: 对象所在的group
*
* 在当前cache中分配一个对象
*/
static void *__mem_cache_alloc_object(mem_cache_t *cache, mem_group_t *group)
{
void *object;
// 做一些标志的设定
// 从位图中获取一个空闲的对象
int idx = bitmap_scan(&group->map, 1);
// 分配失败
if (idx == -1) {
/* 没有可用对象了 */
printk(KERN_EMERG "bitmap scan failed!\n");
return NULL;
}
// 设定为已经使用
bitmap_set(&group->map, idx, 1);
// 获取object的位置
object = group->objects + idx * cache->object_size;
// 改变group的使用情况
group->using_count++;
group->free_count--;
// 判断group是否已经使用完了
if (group->free_count == 0) {
// 从partial的这链表删除
list_del(&group->list);
// 添加到full中去
list_add_tail(&group->list, &cache->full_groups);
}
return object;
}
/*
* mem_cache_alloc_object - 在group中分配一个对象
* @cache: 对象所在的cache
* @flags: 分配需要的标志
*
* 在当前cache中分配一个对象
*/
void *mem_cache_alloc_object(mem_cache_t *cache)
{
void *object;
mem_group_t *group;
// 存在空闲的就分配并且返回
list_t *partialList, *node;
// 检测分配环境
unsigned long flags;
retry_alloc_object:
// 要关闭中断，并保存寄存器环境
save_intr(flags);
partialList = &cache->partial_groups;
// 指向partial中的第一个group
node = partialList->next;
//printk("cache size %x\n", cache->object_size);
// 如果partial是空的
if (list_empty(partialList)) {
//printk("partialList empty\n");
list_t *freeList;
freeList = &cache->free_groups;
// 如果free是空的
if (list_empty(freeList)) {
//printk("free empty\n");
// 需要创建一个新的group
goto new_group;
}
// 指向第一个组
node = freeList->next;
// 把node从free list中删除
list_del(node);
// 把node添加到partial中去
list_add_tail(node, partialList);
}
//printk("kmalloc: found a node.\n");
/* 现在node是partial中的一个节点 */
group = list_owner(node, mem_group_t, list);
//printk("group %x cache size %x\n", group, cache->object_size);
object = __mem_cache_alloc_object(cache, group);
// 要恢复中断状态
restore_intr(flags);
return object;
new_group:
// 没有group，添加一个新的group
// 恢复中断状况
// 要恢复中断状态
restore_intr(flags);
//printk("kmalloc: need a new group.\n");
// 添加新的group
if (create_mem_group(cache, 0))
return NULL; // 如果创建一个group失败就返回
goto retry_alloc_object;
return NULL;
}
/*
* kmalloc - 分配一个对象
* @size: 对象的大小
* @flags: 分配需要的flags
*
* 分配一个size大小的内存
*/
void *kmalloc(size_t size)
{
// 如果越界了就返回空
if (size > MAX_MEM_CACHE_SIZE) {
printk(KERN_NOTICE "kmalloc size %d too big!", size);
return NULL;
}
cache_size_t *cachesz = &cache_size[0];
while (cachesz->cache_size) {
// 如果找到一个大于等于当前大小的cache，就跳出循环
if (cachesz->cache_size >= size)
break;
// 指向下一个大小描述
cachesz++;
}
//printk("des %x cache %x size %x\n", sizeDes, sizeDes->cachePtr, sizeDes->cachePtr->object_size);
void *p = mem_cache_alloc_object(cachesz->mem_cache);
return p;
}
/*
* __mem_cache_free_object - 释放一个group对象
* @cache: 对象所在的cache
* @object: 对象的指针
*
* 释放group对象，而不是group，group用destory
*/
static void __mem_cache_free_object(mem_cache_t *cache, void *object)
{
mem_group_t *group;
// 获取group
// 获取页
mem_node_t *node = addr2page(v2p(object));
CHECK_MEM_NODE(node);
//printk("OBJECT %x page %x cache %x", object, page, page->groupCache);
// 遍历cache的3个链表。然后查看group是否有这个对象的地址
group = MEM_NODE_GET_GROUP(node);
// 如果查询失败，就返回，代表没有进行释放
if (group == NULL)
panic(KERN_EMERG "group get from page bad!\n");
//printk("get object group %x\n", group);
// 把group中对应的object释放，也就是把位图清除
// 找到位图的索引
int index = (((unsigned char *)object) - group->objects)/cache->object_size;
// 检测index是否正确
if (index < 0 || index > group->map.byte_length*8)
panic(KERN_EMERG "map index bad range!\n");
// 把位图设置为0，就说明它没有使用了
bitmap_set(&group->map, index, 0);
int unsing = group->using_count;
/*
dump_mem_group(group);
DumpMemNode(node);*/
//printk("kfree: found group and node.\n");
// 使用中的对象数减少
group->using_count--;
// 空闲的对象数增加
group->free_count++;
// 没有使用中的对象
if (!group->using_count) {
// 把它放到free空闲列表
list_del(&group->list);
list_add_tail(&group->list, &cache->free_groups);
//printk("kfree: free to free group.\n");
//memset(group->map.bits, 0, group->map.byte_length);
//printk("free to cache %x name %s group %x\n", cache, cache->name, group);
} else if (unsing == cache->object_count) {
// 释放之前这个是满的group，现在释放后，就到partial中去
list_del(&group->list);
list_add_tail(&group->list, &cache->partial_groups);
//printk("kfree: free to partial group.\n");
}
}
/*
* mem_cache_free_object - 释放一个group对象
* @cache: 对象所在的cache
* @object: 对象的指针
*
* 释放group对象，而不是group，group用destory
*/
void mem_cache_free_object(mem_cache_t *cache, void *object)
{
// 检测环境
// 关闭中断
unsigned long flags;
save_intr(flags);
__mem_cache_free_object(cache, object);
// 打开中断
restore_intr(flags);
}
/*
* kfree - 释放一个对象占用的内存
* @object: 对象的指针
*/
void kfree(void *objcet)
{
if (!objcet)
return;
mem_cache_t *cache;
// 获取对象所在的页
mem_node_t *node = addr2page(v2p(objcet));
CHECK_MEM_NODE(node);
// 转换成group cache
cache = MEM_NODE_GET_CACHE(node);
//dump_mem_cache(cache);
//printk("get object group cache %x\n", cache);
// 调用核心函数
mem_cache_free_object(cache, (void *)objcet);
}
/*
* group_destory - 销毁group
* @cache: group所在的cache
* @group: 要销毁的group
*
* 销毁一个group,成功返回0，失败返回-1
*/
static int group_destory(mem_cache_t *cache, mem_group_t *group)
{
// 删除链表关系
list_del(&group->list);
/* 根据缓冲中记录的对象大小进行不同的设定 */
if (cache->object_size < 1024) {
/* 只释放group所在的内存，因为所有数据都在里面 */
if (mem_cache_free_pages(group))
return -1;
} else {
/* 要释放group和对象所在的页 */
if (mem_cache_free_pages(group->objects))
return -1;
if (mem_cache_free_pages(group))
return -1;
}
return 0;
}
/**
* __mem_cache_shrink - 收缩内存大小
* @cache: 收缩哪个缓冲区的大小
*/
static int __mem_cache_shrink(mem_cache_t *cache)
{
mem_group_t *group, *next;
int ret = 0;
list_for_each_owner_safe(group, next, &cache->free_groups, list) {
// 销毁成功才计算销毁数量
//printk("find a free group %x\n", group);
if(!group_destory(cache, group))
ret++;
}
return ret;
}
/**
* SlabCacheShrink - 收缩内存大小
* @cache: 收缩哪个缓冲区的大小
*/
static int mem_cahce_shrink(mem_cache_t *cache)
{
int ret;
// cache出错的话就返回
if (!cache)
return 0;
// 用自旋锁来保护结构
unsigned long flags;
save_intr(flags);
// 收缩内存
ret = __mem_cache_shrink(cache);
// 打开锁
restore_intr(flags);
// 返回收缩了的内存大小
return ret * cache->object_count * cache->object_size;
}
/**
* SlabCacheAllShrink - 对所有的cache都进行收缩
*/
int kmshrink()
{
// 释放了的大小
size_t size = 0;
// 指向cache的指针
cache_size_t *cachesz = &cache_size[0];
// 对每一个cache都进行收缩
while (cachesz->cache_size) {
// 收缩大小
size += mem_cahce_shrink(cachesz->mem_cache);
// 指向下一个cache大小描述
cachesz++;
}
return size;
}
int init_mem_caches()
{
/* make basic mem caches */
make_mem_caches();
#if 0 /* test */
char *a = kmalloc(32);
char *b = kmalloc(512);
char *c = kmalloc(1024);
char *d = kmalloc(128*1024);
//memset(d, 0, 512*1024);
a = kmalloc(32);
b = kmalloc(512);
c = kmalloc(1024);
d = kmalloc(128*1024);
printk("a=%x, b=%x,c=%x,d=%x,\n", a, b,c,d);
kfree(a);
kfree(b);
kfree(c);
kfree(d);
a = kmalloc(32);
b = kmalloc(512);
c = kmalloc(1024);
d = kmalloc(128*1024);
printk("a=%x, b=%x,c=%x,d=%x,\n", a, b,c,d);
kfree(a);
kfree(b);
kfree(c);
kfree(d);
a = kmalloc(64);
b = kmalloc(256);
c = kmalloc(4096);
d = kmalloc(64*1024);
printk("a=%x, b=%x,c=%x,d=%x,\n", a, b,c,d);
int i = 0;
char *table[10];
for (i = 0; i < 10; i++) {
table[i] = kmalloc(128*1024);
printk("x=%x\n", table[i]);
}
for (i = 0; i < 10; i++) {
kfree(table[i]);
}
size_t size = kmshrink();
printk("shrink size %x bytes %d MB\n", size, size/MB);
for (i = 0; i < 10; i++) {
table[i] = kmalloc(1*MB);
printk("x=%x\n", table[i]);
}
for (i = 0; i < 10; i++) {
kfree(table[i]);
}
size = kmshrink();
printk("shrink size %x bytes %d MB\n", size, size/MB);
mem_cache_t newcache;
mem_cache_init(&newcache, "new cache", 10 * MB, 0);
void *na = mem_cache_alloc_object(&newcache);
if (na == NULL)
printk("alloc failed\n");
memset(na, 0, 10 * MB);
printk("alloc at %p\n", na);
void *nb = mem_cache_alloc_object(&newcache);
if (nb == NULL)
printk("alloc failed\n");
memset(nb, 0, 10 * MB);
printk("alloc at %p\n", nb);
mem_cache_free_object(&newcache, na);
mem_cache_free_object(&newcache, nb);
size = kmshrink();
printk("shrink size %x bytes %d MB\n", size, size/MB);
unsigned long free_size = get_free_page_nr();
unsigned long total_size = get_total_page_nr();
printk("total:%d free:%d used:%d\n", total_size, free_size, total_size - free_size);
#endif
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.