Heart of Electron

Home All posts

17 September 2022

Startup file text (look carefully while copy and past in keil )

Saurabh Suryawanshi

;/*****************************************************************************/

;/* STARTUP.S: Startup file for Philips LPC2000 */

;/*****************************************************************************/

;/* <<< Use Configuration Wizard in Context Menu >>> */

;/*****************************************************************************/

;/* This file is part of the uVision/ARM development tools. */

;/* This software may only be used under the terms of a valid, current, */

;/* end user licence from KEIL for a compatible version of KEIL software */

;/* development tools. Nothing else gives you the right to use this software. */

;/*****************************************************************************/

;/*

; * The STARTUP.S code is executed after CPU Reset. This file may be

; * translated with the following SET symbols. In uVision these SET

; * symbols are entered under Options - ASM - Define.

; *

; * REMAP: when set the startup code initializes the register MEMMAP

; * which overwrites the settings of the CPU configuration pins. The

; * startup and interrupt vectors are remapped from:

; * 0x00000000 default setting (not remapped)

; * 0x80000000 when EXTMEM_MODE is used

; * 0x40000000 when RAM_MODE is used

; *

; * EXTMEM_MODE: when set the device is configured for code execution

; * from external memory starting at address 0x80000000.

; *

; * RAM_MODE: when set the device is configured for code execution

; * from on-chip RAM starting at address 0x40000000.

; *

; * EXTERNAL_MODE: when set the PIN2SEL values are written that enable

; * the external BUS at startup.

; */

; Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs

Mode_USR EQU 0x10

Mode_FIQ EQU 0x11

Mode_IRQ EQU 0x12

Mode_SVC EQU 0x13

Mode_ABT EQU 0x17

Mode_UND EQU 0x1B

Mode_SYS EQU 0x1F

I_Bit EQU 0x80 ; when I bit is set, IRQ is disabled

F_Bit EQU 0x40 ; when F bit is set, FIQ is disabled

;// <h> Stack Configuration (Stack Sizes in Bytes)

;// <o0> Undefined Mode <0x0-0xFFFFFFFF:8>

;// <o1> Supervisor Mode <0x0-0xFFFFFFFF:8>

;// <o2> Abort Mode <0x0-0xFFFFFFFF:8>

;// <o3> Fast Interrupt Mode <0x0-0xFFFFFFFF:8>

;// <o4> Interrupt Mode <0x0-0xFFFFFFFF:8>

;// <o5> User/System Mode <0x0-0xFFFFFFFF:8>

;// </h>

UND_Stack_Size EQU 0x00000000

SVC_Stack_Size EQU 0x00000008

ABT_Stack_Size EQU 0x00000000

FIQ_Stack_Size EQU 0x00000000

IRQ_Stack_Size EQU 0x00000080

USR_Stack_Size EQU 0x00000400

ISR_Stack_Size EQU (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \

FIQ_Stack_Size + IRQ_Stack_Size)

AREA STACK, NOINIT, READWRITE, ALIGN=3

Stack_Mem SPACE USR_Stack_Size

__initial_sp SPACE ISR_Stack_Size

Stack_Top

;// <h> Heap Configuration

;// <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF>

;// </h>

Heap_Size EQU 0x00000000

AREA HEAP, NOINIT, READWRITE, ALIGN=3

__heap_base

Heap_Mem SPACE Heap_Size

__heap_limit

; VPBDIV definitions

VPBDIV EQU 0xE01FC100 ; VPBDIV Address

;// <e> VPBDIV Setup

;// Peripheral Bus Clock Rate

;// <o1.0..1> VPBDIV: VPB Clock

;// <0=> VPB Clock = CPU Clock / 4

;// <1=> VPB Clock = CPU Clock

;// <2=> VPB Clock = CPU Clock / 2

;// <o1.4..5> XCLKDIV: XCLK Pin

;// <0=> XCLK Pin = CPU Clock / 4

;// <1=> XCLK Pin = CPU Clock

;// <2=> XCLK Pin = CPU Clock / 2

;// </e>

VPBDIV_SETUP EQU 0

VPBDIV_Val EQU 0x00000000

; Phase Locked Loop (PLL) definitions

PLL_BASE EQU 0xE01FC080 ; PLL Base Address

PLLCON_OFS EQU 0x00 ; PLL Control Offset

PLLCFG_OFS EQU 0x04 ; PLL Configuration Offset

PLLSTAT_OFS EQU 0x08 ; PLL Status Offset

PLLFEED_OFS EQU 0x0C ; PLL Feed Offset

PLLCON_PLLE EQU (1<<0) ; PLL Enable

PLLCON_PLLC EQU (1<<1) ; PLL Connect

PLLCFG_MSEL EQU (0x1F<<0) ; PLL Multiplier

PLLCFG_PSEL EQU (0x03<<5) ; PLL Divider

PLLSTAT_PLOCK EQU (1<<10) ; PLL Lock Status

;// <e> PLL Setup

;// <o1.0..4> MSEL: PLL Multiplier Selection

;// <1-32><#-1>

;// M Value

;// <o1.5..6> PSEL: PLL Divider Selection

;// <0=> 1 <1=> 2 <2=> 4 <3=> 8

;// P Value

;// </e>

PLL_SETUP EQU 1

PLLCFG_Val EQU 0x00000024

; Memory Accelerator Module (MAM) definitions

MAM_BASE EQU 0xE01FC000 ; MAM Base Address

MAMCR_OFS EQU 0x00 ; MAM Control Offset

MAMTIM_OFS EQU 0x04 ; MAM Timing Offset

;// <e> MAM Setup

;// <o1.0..1> MAM Control

;// <0=> Disabled

;// <1=> Partially Enabled

;// <2=> Fully Enabled

;// Mode

;// <o2.0..2> MAM Timing

;// <0=> Reserved <1=> 1 <2=> 2 <3=> 3

;// <4=> 4 <5=> 5 <6=> 6 <7=> 7

;// Fetch Cycles

;// </e>

MAM_SETUP EQU 1

MAMCR_Val EQU 0x00000002

MAMTIM_Val EQU 0x00000004

; External Memory Controller (EMC) definitions

EMC_BASE EQU 0xFFE00000 ; EMC Base Address

BCFG0_OFS EQU 0x00 ; BCFG0 Offset

BCFG1_OFS EQU 0x04 ; BCFG1 Offset

BCFG2_OFS EQU 0x08 ; BCFG2 Offset

BCFG3_OFS EQU 0x0C ; BCFG3 Offset

;// <e> External Memory Controller (EMC)

EMC_SETUP EQU 0

;// <e> Bank Configuration 0 (BCFG0)

;// <o1.0..3> IDCY: Idle Cycles <0-15>

;// <o1.5..9> WST1: Wait States 1 <0-31>

;// <o1.11..15> WST2: Wait States 2 <0-31>

;// <o1.10> RBLE: Read Byte Lane Enable

;// <o1.26> WP: Write Protect

;// <o1.27> BM: Burst ROM

;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit

;// <2=> 32-bit <3=> Reserved

;// </e>

BCFG0_SETUP EQU 0

BCFG0_Val EQU 0x0000FBEF

;// <e> Bank Configuration 1 (BCFG1)

;// <o1.0..3> IDCY: Idle Cycles <0-15>

;// <o1.5..9> WST1: Wait States 1 <0-31>

;// <o1.11..15> WST2: Wait States 2 <0-31>

;// <o1.10> RBLE: Read Byte Lane Enable

;// <o1.26> WP: Write Protect

;// <o1.27> BM: Burst ROM

;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit

;// <2=> 32-bit <3=> Reserved

;// </e>

BCFG1_SETUP EQU 0

BCFG1_Val EQU 0x0000FBEF

;// <e> Bank Configuration 2 (BCFG2)

;// <o1.0..3> IDCY: Idle Cycles <0-15>

;// <o1.5..9> WST1: Wait States 1 <0-31>

;// <o1.11..15> WST2: Wait States 2 <0-31>

;// <o1.10> RBLE: Read Byte Lane Enable

;// <o1.26> WP: Write Protect

;// <o1.27> BM: Burst ROM

;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit

;// <2=> 32-bit <3=> Reserved

;// </e>

BCFG2_SETUP EQU 0

BCFG2_Val EQU 0x0000FBEF

;// <e> Bank Configuration 3 (BCFG3)

;// <o1.0..3> IDCY: Idle Cycles <0-15>

;// <o1.5..9> WST1: Wait States 1 <0-31>

;// <o1.11..15> WST2: Wait States 2 <0-31>

;// <o1.10> RBLE: Read Byte Lane Enable

;// <o1.26> WP: Write Protect

;// <o1.27> BM: Burst ROM

;// <o1.28..29> MW: Memory Width <0=> 8-bit <1=> 16-bit

;// <2=> 32-bit <3=> Reserved

;// </e>

BCFG3_SETUP EQU 0

BCFG3_Val EQU 0x0000FBEF

;// </e> End of EMC

; External Memory Pins definitions

PINSEL2 EQU 0xE002C014 ; PINSEL2 Address

PINSEL2_Val EQU 0x0E6149E4 ; CS0..3, OE, WE, BLS0..3,

; D0..31, A2..23, JTAG Pins

PRESERVE8

; Area Definition and Entry Point

; Startup Code must be linked first at Address at which it expects to run.

AREA RESET, CODE, READONLY

ARM

; Exception Vectors

; Mapped to Address 0.

; Absolute addressing mode must be used.

; Dummy Handlers are implemented as infinite loops which can be modified.

Vectors LDR PC, Reset_Addr

LDR PC, Undef_Addr

LDR PC, SWI_Addr

LDR PC, PAbt_Addr

LDR PC, DAbt_Addr

NOP ; Reserved Vector

; LDR PC, IRQ_Addr

LDR PC, [PC, #-0x0FF0] ; Vector from VicVectAddr

LDR PC, FIQ_Addr

Reset_Addr DCD Reset_Handler

Undef_Addr DCD Undef_Handler

SWI_Addr DCD SWI_Handler

PAbt_Addr DCD PAbt_Handler

DAbt_Addr DCD DAbt_Handler

DCD 0 ; Reserved Address

IRQ_Addr DCD IRQ_Handler

FIQ_Addr DCD FIQ_Handler

Undef_Handler B Undef_Handler

SWI_Handler B SWI_Handler

PAbt_Handler B PAbt_Handler

DAbt_Handler B DAbt_Handler

IRQ_Handler B IRQ_Handler

FIQ_Handler B FIQ_Handler

; Reset Handler

EXPORT Reset_Handler

Reset_Handler

; Setup External Memory Pins

IF :DEF:EXTERNAL_MODE

LDR R0, =PINSEL2

LDR R1, =PINSEL2_Val

STR R1, [R0]

ENDIF

; Setup External Memory Controller

IF EMC_SETUP <> 0

LDR R0, =EMC_BASE

IF BCFG0_SETUP <> 0

LDR R1, =BCFG0_Val

STR R1, [R0, #BCFG0_OFS]

ENDIF

IF BCFG1_SETUP <> 0

LDR R1, =BCFG1_Val

STR R1, [R0, #BCFG1_OFS]

ENDIF

IF BCFG2_SETUP <> 0

LDR R1, =BCFG2_Val

STR R1, [R0, #BCFG2_OFS]

ENDIF

IF BCFG3_SETUP <> 0

LDR R1, =BCFG3_Val

STR R1, [R0, #BCFG3_OFS]

ENDIF

ENDIF ; EMC_SETUP

; Setup VPBDIV

IF VPBDIV_SETUP <> 0

LDR R0, =VPBDIV

LDR R1, =VPBDIV_Val

STR R1, [R0]

ENDIF

; Setup PLL

IF PLL_SETUP <> 0

LDR R0, =PLL_BASE

MOV R1, #0xAA

MOV R2, #0x55

; Configure and Enable PLL

MOV R3, #PLLCFG_Val

STR R3, [R0, #PLLCFG_OFS]

MOV R3, #PLLCON_PLLE

STR R3, [R0, #PLLCON_OFS]

STR R1, [R0, #PLLFEED_OFS]

STR R2, [R0, #PLLFEED_OFS]

; Wait until PLL Locked

PLL_Loop LDR R3, [R0, #PLLSTAT_OFS]

ANDS R3, R3, #PLLSTAT_PLOCK

BEQ PLL_Loop

; Switch to PLL Clock

MOV R3, #(PLLCON_PLLE:OR:PLLCON_PLLC)

STR R3, [R0, #PLLCON_OFS]

STR R1, [R0, #PLLFEED_OFS]

STR R2, [R0, #PLLFEED_OFS]

ENDIF ; PLL_SETUP

; Setup MAM

IF MAM_SETUP <> 0

LDR R0, =MAM_BASE

MOV R1, #MAMTIM_Val

STR R1, [R0, #MAMTIM_OFS]

MOV R1, #MAMCR_Val

STR R1, [R0, #MAMCR_OFS]

ENDIF ; MAM_SETUP

; Memory Mapping (when Interrupt Vectors are in RAM)

MEMMAP EQU 0xE01FC040 ; Memory Mapping Control

IF :DEF:REMAP

LDR R0, =MEMMAP

IF :DEF:EXTMEM_MODE

MOV R1, #3

ELIF :DEF:RAM_MODE

MOV R1, #2

ELSE

MOV R1, #1

ENDIF

STR R1, [R0]

ENDIF

; Initialise Interrupt System

; ...

; Setup Stack for each mode

LDR R0, =Stack_Top

; Enter Undefined Instruction Mode and set its Stack Pointer

MSR CPSR_c, #Mode_UND:OR:I_Bit:OR:F_Bit

MOV SP, R0

SUB R0, R0, #UND_Stack_Size

; Enter Abort Mode and set its Stack Pointer

MSR CPSR_c, #Mode_ABT:OR:I_Bit:OR:F_Bit

MOV SP, R0

SUB R0, R0, #ABT_Stack_Size

; Enter FIQ Mode and set its Stack Pointer

MSR CPSR_c, #Mode_FIQ:OR:I_Bit:OR:F_Bit

MOV SP, R0

SUB R0, R0, #FIQ_Stack_Size

; Enter IRQ Mode and set its Stack Pointer

MSR CPSR_c, #Mode_IRQ:OR:I_Bit:OR:F_Bit

MOV SP, R0

SUB R0, R0, #IRQ_Stack_Size

; Enter Supervisor Mode and set its Stack Pointer

MSR CPSR_c, #Mode_SVC:OR:I_Bit:OR:F_Bit

MOV SP, R0

SUB R0, R0, #SVC_Stack_Size

; Enter User Mode and set its Stack Pointer

MSR CPSR_c, #Mode_USR

IF :DEF:__MICROLIB

EXPORT __initial_sp

ELSE

MOV SP, R0

SUB SL, SP, #USR_Stack_Size

ENDIF

; Enter the C code

IMPORT __main

LDR R0, =__main

BX R0

IF :DEF:__MICROLIB

EXPORT __heap_base

EXPORT __heap_limit

ELSE

; User Initial Stack & Heap

AREA |.text|, CODE, READONLY

IMPORT __use_two_region_memory

EXPORT __user_initial_stackheap

__user_initial_stackheap

LDR R0, = Heap_Mem

LDR R1, =(Stack_Mem + USR_Stack_Size)

LDR R2, = (Heap_Mem + Heap_Size)

LDR R3, = Stack_Mem

BX LR

ENDIF

END

17 February 2022

Linux Questions

Saurabh Suryawanshi

Define shell

A shell is a program that acts as the interface between you and the UNIX system, allowing you

to enter commands for the operating system to execute

2. Describe different types of shell

There are many different shells in use. They are

1. Bourne shell (sh)

The Bourne shell, or sh, was the default Unix shell of Unix Version 7. It was developed by Stephen Bourne, of AT&T BellLaboratories.

2. C shell (csh)

This is a Unix shell and a command processor that is run in a text window. The character % is the default prompt for the C shell. File commands can also be read easily by the C shell, which is known as a script

3. Korn shell (ksh)

The Korn shell is the UNIX shell (command execution program, often called a command interpreter ) that was developed by David Korn of Bell Labs as a comprehensive combined version of other major UNIX shells.

3. Write down the responsibility of the shell ?

Shell responsibilities

1. Program Execution

2. Variable and Filename Substitution

3. I/O Redirection

4. Pipeline Hookup

5. Environment Control

6. Interpreted Programming Language

1.Program Execution:

• The shell is responsible for the execution of all programs that you request fromyour terminal.

• Each time you type in a line to the shell, the shell analyzes the line and thendetermines what to do. The line that is typed to the shell is known more formallyas the command line. The shell scans this command line and determines the name of the program to be executed and what arguments to pass to the program.

2.Variable and Filename Substitution:

• Like any other programming language, the shell lets you assign values to variables. Whenever you specify one of these variables on the command line, preceded by adollar sign, the shell substitutes the value assigned to the variable at that point.

3. I/O Redirection:

• It is the shell's responsibility to take care of input and output redirection on the command

line. It scans the command line for the occurrence of the special redirection characters <,>, or >>.

4.Pipeline Hookup:

• Just as the shell scans the command line looking for redirection characters, it also looks for the pipe character For each such character that it finds, it connects the standard output from the command preceding the | to the standard input of the one following the. It then initiates execution of both programs.

5.Environment Control:

• The shell provides certain commands that let you customize your environment. Your environment includes home directory, the characters that the shell displays toprompt you to type in a command, and a list of the directories to be searched whenever you request that a program be executed.

6.Interpreted Programming Language:

• The shell has its own built-in programming language. This language is interpreted, meaning that the shell analyzes each statement in the language one line at a time and then executes it. This differs from programming languages such as C and FORTRAN, in which the programming statements are typically compiled into a machine-executable

form before they are executed.

• Programs developed in interpreted programming languages are typically easier to debug and modify than compiled ones. However, they usually take much longer to execute than their compiled equivalents.

4. What is shell scripting ?

A shell script is a list of commands in a computer program that is run by the Unix shell which is a command line interpreter. A shell script usually has comments that describe the steps.

5. Write down different use of commands in user mode and kernel mode

The User mode is normal mode where the process has limited access. While the Kernel mode is the privileged mode where the process has unrestricted access to system resources like hardware, memory, etc.

User mode

-c = We can add comment field for the useraccount.

-d = To modify the directory for any existing user account.

-e = Using this option we can make the account expiry in specific period.

-g = Change the primary group for a User.

-G = To add a supplementary groups

Kernel Mode The kernel’s command-line parameters — The Linux Kernel documentation

agp = [AGP]

acpi= [HW,ACPI,X86,ARM64]

apic= [APIC,X86-32]

autoconf=[IPV6]

ataflop= [HW,M68k]

6. Define system calls and describe its working.

System calls are provided by UNIX to access and control files and devices.

7. Define process in Linux describe different types of state of a process

A process is an active program. It can also be said as a program that is under execution. It is more than the program code as it includes the program counter, process stack, registers, program code etc. Compared to this, the program code is only the text section.

In Unix/Linux operating systems, processes can be in one of the following states:

1. RUNNING & RUNNABLE

2. INTERRRUPTABLE_SLEEP

3. UNINTERRUPTABLE_SLEEP

4. STOPPED

5. ZOMBIE

1. RUNNING & RUNNABLE

When the CPU executes a process, it will be in a RUNNING state. When the process is not waiting for any resource and ready to be executed by the CPU, it will be in the RUNNABLE state.

2. INTERRUPTABLE_SLEEP:

When a process is in INTERRUPTABLE_SLEEP, it will wake up from the middle of sleep and process new signals sent to it.

3. UNINTERRUPTABLE_SLEEP:

When a process is in UNINTERRUPTABLE_SLEEP, it will not wake up from the middle of sleep even though new signals are sent to it.

4. STOPPED

STOPPED state indicates that the process has been suspended from proceeding further. In Linux when you issue the ‘Ctrl + Z’ command it will issue a SIGSTOP signal to the process.

5. ZOMBIE

A process will terminate when it calls ‘system exit’ API or when someone else kills the process. When a process terminates, it will release all the data structures and the resources it holds.

8. Define define Demos

A daemon (also known as background processes) is a Linux or UNIX program that runs in the background.

9. Define threads & differance between threads and process

Thread-

Thread is the segment of a process means a process can have multiple threads and these multiple threads are contained within a process. A thread has three states: Running, Ready, and Blocked.

Thread takes less time to terminate as compared to process but unlike process threads do not isolate.

Comparison Basis	Process	Thread
Definition	A process is a program under execution i.e an active program.	A thread is a lightweight process that can be managed independently by a scheduler.
Context switching time	Processes require more time for context switching as they are more heavy.	Threads require less time for context switching as they are lighter than processes.
Memory Sharing	Processes are totally independent and don’t share memory.	A thread may share some memory with its peer threads.
Communication	Communication between processes requires more time than between threads.	Communication between threads requires less time than between processes .
Blocked	If a process gets blocked, remaining processes can continue execution.	If a user level thread gets blocked, all of its peer threads also get blocked.
Resource Consumption	Processes require more resources than threads.	Threads generally need less resources than processes.
Dependency	Individual processes are independent of each other.	Threads are parts of a process and so are dependent.
Data and Code sharing	Processes have independent data and code segments.	A thread shares the data segment, code segment, files etc. with its peer threads.
Treatment by OS	All the different processes are treated separately by the operating system.	All user level peer threads are treated as a single task by the operating system.
Time for creation	Processes require more time for creation.	Threads require less time for creation.
Time for termination	Processes require more time for termination.	Threads require less time for termination.

10. Describe the concept of virtual memory in Linux

Linux supports virtual memory, that is, using a disk as an extension of RAM so that the effective size of usable memory grows correspondingly. The kernel will write the contents of a currently unused block of memory to the hard disk so that the memory can be used for another purpose.

When the original contents are needed again, they are read back into memory. This is all made completely transparent to the user; programs running under Linux only see the larger amount of memory available and don't notice that parts of them reside on the disk from time to time.

11 Describe a executable file format in Linux

The standard Linux executable format is named Executable and Linking Format ( ELF). It was developed by Unix System Laboratories and is now the most widely used format in the Unix world. Several well-known Unix operating systems, such as System V Release 4 and Sun’s Solaris 2, have adopted ELF as their main executable format.

Older Linux versions supported another format named Assembler OUTput Format (a.out); actually, there were several versions of that format floating around the Unix world. It is seldom used now, since ELF is much more practical.

Linux supports many other different formats for executable files; in this way, it can run programs compiled for other operating systems, such as MS-DOS EXE programs or BSD Unix’s COFF executables. A few executable formats, like Java or bash scripts, are platform-independent. Example are : load_binary ,load_shlib ,core_dump

12 Define linking and loading in Linux

Loading:

Bringing the program from secondary memory to main memory is called Loading.

Linking:

Establishing the linking between all the modules or all the functions of the program in order to continue the program execution is called linking.

13 Describe concept of semaphores & mutex

Mutex:

A mutex provides mutual exclusion, either producer or consumer can have the key (mutex) and proceed with their work. As long as the buffer is filled by the producer, the consumer needs to wait, and vice versa.

At any point of time, only one thread can work with the entire buffer. The concept can be generalized using semaphore.

Semaphore:

A semaphore is a generalized mutex. In lieu of a single buffer, we can split the 4 KB buffer into four 1 KB buffers (identical resources). A semaphore can be associated with these four buffers. The consumer and producer can work on different buffers at the same time.

31 January 2022

Shell Scripting With Basic Examples

Saurabh Suryawanshi

1. Write a shell script to evaluate arithmetic operations. (addition, subtraction, multiplication and division)

Step 1 Creating script file using Nano editor

Step 2 Writing code with no error and save the script

Step 3 Gives execute permission and then run the script and get input from user and see the output

2. Write a shell script to calculate simple interest.

Step 1 Creating script file using Nano editor

Step 2 Writing code with no error and save the script

Step 3 Gives execute permission and then run the script and get input from user and see the output

3. Write a shell Script to determine largest among three integer number.

Step 1 Creating script file using Nano editor

Step 2 Writing code with no error and save the script

Step 3 Gives execute permission and then run the script and get input from user and see the output

4. Write a shell script to find sum of first n natural numbers.

Step 1 Creating script file using Nano editor

Step 2 Writing code with no error and save the script

Step 3 Gives execute permission and then run the script and get input from user and see the output

5. Write a shell script to find whether a given number is prime.

Step 1 Creating script file using Nano editor

Step 2 Writing code with no error and save the script

Step 3 Gives execute permission and then run the script and get input from user and see the output

6. Write a shell script to find factorial of a given number.

Step 1 Creating script file using Nano editor