Schedulers in Linux vs CFS

2018-07-11 16:17 Qwerto imported from Stackoverflow

In linux, which are the differences between sched_rr,sched_fifo,sched_other and the Completely Fair Scheduler ?

See also questions close to this topic

Running Linux on Mac?
Now I considered that I will install a hybrid MAC / it will be half OS X and half Linux Ubuntu *IF anyone has a bette idea for Linux edition please let me know, it will be used for developing mainly. Full-stack and Java, Swift, C++ *
- MacBook (13-inch, Aluminum, Late 2008) 2 GHz Intel Core 2 Duo 4 GB
  1067 MHz DDR3 NVIDIA GeForce 9400M 256 MB
Execute Bash Script via Cron Job
I've been searching for a while now, and I can't quite understand why I'm having this problem, nor find a usable solution. I'm trying to execute a bash script via a cron job.

I have the following two under the crontab -l listed for root.
```
* * * * * /tmp/test.sh
* * * * * /bin/echo "cron works" >> /tmp/file
```
The test.sh contains the following:
```
echo "test" >> debug.txt
```
With the following permissions:
```
-rwxrwxr-x  1 root    root    25 Jul 23 11:40 test.sh
```
I'm just trying to execute the test script once every minute. The second cron job where I'm outputting "cron works" to /tmp/file works fine but the first one doesn't.

I can see that they're both executing via grep CRON /var/log/syslog:
```
Jul 23 11:56:01 privacy CRON[6410]: (root) CMD (/tmp/test.sh)
Jul 23 11:56:01 privacy CRON[6411]: (root) CMD (/bin/echo "cron works" >> /tmp/file)
```
Any suggestions are appreciated, and if there's anymore information I can add, let me know.

Thanks.
Systemctl stop not execute when status is failed

I have a service, it will start a java application, when everything is fine, it work fine too.

But when something goes wrong, the java process still running, but 'systemctl status myservice' is failed. In this situation, when I try to stop this service by execute 'systemctl stop myservice', nothing happened, the process still existed, I still can found it by 'ps -ef |grep java'.

I know I can kill this process by execute 'systemctl kill myservice', but I stil l want to know why this happen, and how to solve this problem?

Thanks.
Bootable USB not detected in BIOS

Currently Using Ubuntu 16.04. Trying to install Windows 7 from an USB pendrive.

I followed every step correctly and the USB is perfectly bootable because it works on other Devices and gets detected.

Also tried enabling Legacy boot and Disabling Secure Boot.
Where the actual Network Connection is made below the OS
I am coming from the Node.js background where creating a server is as simple as:
```
require('http').createServer((i, o) => o.end('hello world')).listen(3000)
```
However, I am wondering what it would be like to implement this from scratch.

In the big picture I am wondering what the requirements are for implementing an HTTP server on bare metal without even an OS such as Linux. So at the scale of something like BareMetalOS. That is, what the general requirements are for connecting and sending data are through the network. I have never had to connect to any device drivers directly or anything like that, so I am not even sure what is involved or what it takes. So basically the question is how to make the connection so that one could build on top of it an HTTP server (which of course would require parsing the data as HTTP requests and such).

Wondering how to do this at the assembly level without relying on any external C libraries. Not actually necessarily how to write the assembly to implement this, but the general requirements for how to connect to any device driver or whatnot, to make that initial client/server connection over a network. Then from there I can formulate any more specific questions.

This is inherently a broad question, which is why I am just really asking this question:

Where the actual network connection is made below the OS.

That is, how do you send 1 bit of information from point a to point b. If it's some network driver that needs to be dealt with or what. I have started looking at socket.c but it seems even still too high-level and haven't found where the rubber meets the road. Where the actual request to send the bit onto the network happens.

Interrupt Descriptor Table, System crashing

* testing enviroment : virtual box 5.1.30 r118389
* assumption : i386
* repository : https://gitlab.com/tony2037/Zos
* make mykernel.iso` can generate .iso file
* Three file for IDT
    * interrupts.h
    * interrupts.cpp
    * interruptstubs.s
* gdt.* is for Global Descriptor Table
* types.h is for bits size define
* port.* is for port transporting
* Hey ~ I'm trying to develop a litter OS, but get the system crash at the part of IDT

interrupts.h : class of IDT

#include "types.h"
#include "port.h"
#include "gdt.h"
    class InterruptManager
    {
    protected:
        // Gate Descriptor is the entry of IDT
        struct GateDescriptor
        {
            uint16_t handlerAddressLowBits;
            uint16_t gdt_codeSegmentSelector;
            uint8_t reserved;
            uint8_t access;
            uint16_t handlerAddressHighBits;
        }__attribute__((packed));

        static GateDescriptor interruptDescriptorTable[256];

        struct InterruptDescriptorTablePointer
        {
            uint16_t size;
            uint32_t base;
        }__attribute__((packed));

        static void SetInterruptDescriptorTableEntry(
            uint8_t interruptNumber,
            uint16_t codeSegmentSelectorOffset,
            void (*handler)(),
            uint8_t DescriptorPrivilegeLevel,
            uint8_t DescriptorType
        );

        // Tell pic to send the interrupt
        // There is master pic and slabe pic
        // Need to commucate with both of them
        Port8BitSlow picMasterCommand;
        Port8BitSlow picMasterData;
        Port8BitSlow picSlaveCommand;
        Port8BitSlow picSlaveData;

    public:

        InterruptManager(GlobalDescriptorTable* gdt);
        ~InterruptManager();

        // tell cpu sending the interrupt
        void Activate();

        static uint32_t handleInterrupt(uint8_t interruptNumber, uint32_t esp);

        // Ignore the interrupt request
        static void IgnoreInterruptRequest();
        // For timer interrupt
        static void HandleInterruptRequest0x00();
        // For keyboard interrupt
        static void HandleInterruptRequest0x01();
    };
#endif

* GateDescriptor is the entry of the idt(most be bit-perfect). * There are 256 entries in the table. * SetInterruptDescriptorTableEntry is a function for set the entry. void(handler*)() is a function pointer to the handler function * There is three handler 0x00 for timer interrupt , 0x01 for keyboardinterrupt, others ignore S

interruptstubs.s Handling the interrupts

.set IRQ_BASE, 0x20

.section .text

.extern _ZN16InterruptManager15handleInterruptEhj

.global _ZN16InterruptManager22IgnoreInterruptRequestEv

.macro HandleException num
.global _ZN16InterruptManager16HandleException\num\()Ev
_ZN16InterruptManager16HandleException\num\()Ev:
    movb $\num, (interruptnumber)
    jmp int_bottom
.endm

.macro HandleInterruptRequest num
.global _ZN16InterruptManager26HandleInterruptRequest\num\()Ev
_ZN16InterruptManager26HandleInterruptRequest\num\()Ev:
    movb $\num + IRQ_BASE, (interruptnumber)
    jmp int_bottom
.endm

HandleInterruptRequest 0x00
HandleInterruptRequest 0x01

int_bottom:

    # put register in to the stack
    pusha
    pushl %ds
    pushl %es
    pushl %fs
    pushl %gs

    pushl %esp
    push (interruptnumber)
    call _ZN16InterruptManager15handleInterruptEhj
    # addl %5, %esp
    movl %eax, %esp

    # recover the value from stack
    popl %gs
    popl %fs
    popl %es
    popl %ds
    popa

# ignore the interrupt
_ZN16InterruptManager22IgnoreInterruptRequestEv:
    # tell cpu that we done the interrupt
    iret


.data
    interruptnumber: .byte 0

as below the handler function for 0x00, 0x01, ignore is define here as assembly. The strange name is the extern name of three handler function after compiled. What it did is just push everything in to the stack. and call handleInterrupt(defined in interrupts.cpp) which should printf("INTERRUPT") (but fuck crash ^^凸)

vbox.log : The log of virtual box

00:01:08.538227 GUI: User request to power VM off on Guru Meditation.
00:01:08.538256 GUI: Passing request to power VM off from machine-logic to UI session.
00:01:08.538261 GUI: Powering VM down on UI session power off request...
00:01:08.538566 Console: Machine state changed to 'Stopping'
00:01:08.538797 Console::powerDown(): A request to power off the VM has been issued (mMachineState=Stopping, InUninit=0)
00:01:08.538811 Display::handleDisplayResize: uScreenId=0 pvVRAM=0000000000000000 w=720 h=400 bpp=32 cbLine=0x0 flags=0x0

System crashed after printing two lines of words.

CPUM stats

00:01:08.538984 Guest CPUM (VCPU 0) state: 
00:01:08.538987 eax=00300de8 ebx=00010000 ecx=00000010 edx=000000a1 esi=00000000 edi=00000000
00:01:08.538989 eip=0010073b esp=00300dd8 ebp=00300e30 iopl=0      rf nv up ei pl zr ac po nc
00:01:08.538991 cs={0010 base=0000000000000000 limit=ffffffff flags=0000c09b} dr0=00000000 dr1=00000000
00:01:08.538994 ds={0018 base=0000000000000000 limit=ffffffff flags=0000c093} dr2=00000000 dr3=00000000
00:01:08.538996 es={0018 base=0000000000000000 limit=ffffffff flags=0000c093} dr4=00000000 dr5=00000000
00:01:08.538998 fs={0018 base=0000000000000000 limit=ffffffff flags=0000c093} dr6=ffff0ff0 dr7=00000400
00:01:08.539000 gs={0018 base=0000000000000000 limit=ffffffff flags=0000c093} cr0=00000011 cr2=00000000
00:01:08.539002 ss={0018 base=0000000000000000 limit=ffffffff flags=0000c093} cr3=00000000 cr4=00000000
00:01:08.539003 gdtr=0000000000200000:0030  idtr=0000000000300e40:07ff  eflags=00210216
00:01:08.539005 ldtr={0000 base=00000000 limit=0000ffff flags=00000082}
00:01:08.539007 tr  ={0000 base=00000000 limit=0000ffff flags=0000008b}
00:01:08.539008 SysEnter={cs=0000 eip=00000000 esp=00000000}

I've try to take the Activate() off, and the system works, so it must related to IDT. Thanks.

spring batch Trigger.nextExecutionTime does not check time

I want to call my job at 00:01:01 of every shamsi month. for that I implement org.springframework.scheduling.Trigger interface and my job has been called on the first day of shamsi month. but from 00:00:00 until 23:59:59 . It sees springing does not care about the time that I set.

@Component
public class PersianMonthlyJobTrigger implements Trigger {
    final Logger logger = Logger.getLogger(this.getClass());

    @Override
    public Date nextExecutionTime(TriggerContext triggerContext) {
        return getTriggerDate();
    }

    private Integer calculateNextDayOfJob() {

        int today = PersianCalendarUtils.getPersianDate();
        String nextDayOfJob;
        if (PersianCalendarUtils.getDayOfMonth(today) != 1) {//get first day of next month
            String month = String.valueOf(PersianCalendarUtils.getMonth(today));
            if (!month.equals("12")) {
                month = String.valueOf(Integer.valueOf(month) + 1);
                month = (month.length() == 2 ? month : "0" + month);
                nextDayOfJob = String.valueOf(PersianCalendarUtils.getYear(today) + month + "01");
            } else
                nextDayOfJob = (PersianCalendarUtils.getYear(today) + 1) + "0101";
        } else
            nextDayOfJob = String.valueOf(today);

        return PersianCalendarUtils.daysBetween(today, Integer.valueOf(nextDayOfJob));
    }

    private Date getTriggerDate() {
        Calendar nextExecutionTime = Calendar.getInstance();
        logger.info(nextExecutionTime.getTime());

        nextExecutionTime.set(Calendar.HOUR_OF_DAY, 0);
        nextExecutionTime.set(Calendar.MINUTE, 1);
        nextExecutionTime.set(Calendar.SECOND, 1);
        nextExecutionTime.set(Calendar.MILLISECOND, 1);

        nextExecutionTime.add(Calendar.DAY_OF_YEAR, calculateNextDayOfJob());
        logger.info(nextExecutionTime.getTime());
        return nextExecutionTime.getTime();
    }
}

my log output before setting calendar:

2018-07-23 12:34:28 INFO  ir.co.isc.schedule.PersianMonthlyJobTrigger:51 - Mon Jul 23 12:34:28 IRDT 2018

and after setting the time:

2018-07-23 12:34:28 INFO  ir.co.isc.schedule.PersianMonthlyJobTrigger:63 - Mon Jul 23 00:01:01 IRDT 2018

how can I solve this problem? my point is Spring call my job just only one at 00:00:01 of every shamsi month. thank you for helping me

Execute batch file on the event file creation

Hello(sorry for my english),

My problem is pretty simple : I put the file "PROD.7z" on my server (using FTP) in the directory C:\ftp.

I want to execute a batch file when PROD.7z comes in,

Is it possible to use the Task Scheduler at the creation of the file to execute my bacth? Or another way?

If possible i don't want to download a soft

Thank you
AWS ECS starting a container is very slow after 1 day

I'm using ECS scheduled task to run my cron jobs. I have around 6 jobs running at various times. 3 of my jobs run every 2 minutes. Everything works fine for the first day when I launch a new instance in the ECS cluster. Then after a day, I see lots of tasks are in a pending state. I ssh into my ECS EC2 instance and try to start a container manually using docker run command, it takes 4-5 minutes for the container to start. I have checked logs in /var/log/docker: I see this error

time="2018-07-23T01:06:46.688248652Z" level=error msg="Handler for GET /v1.21/containers/2f68db90950da30547c326780df5c90afd85495fa54d8b2fba7e2044a8c23024/json returned error: write unix /var/run/docker.sock->@: write: broken pipe" 2018-07-23 01:06:46.688296 I | http: multiple response.WriteHeader calls

I'm not sure if this is the cause of the issue. I can't think of any way to resolve this issue.

Please help.

Thank you

Related questions

Schedulers in Linux vs CFS

See also questions close to this topic