Get a clear, hands-on look at Linux’s standard input (STDIN), output (STDOUT), and error (STDERR) pipes! In this video, we explore how programs communicate using these essential streams, with practical examples in Yasm Assembly (no assembly knowledge needed!). Learn to redirect outputs, handle errors, and read inputs like a pro. Whether you’re a beginner or seasoned coder, this fun demo breaks down the basics of Linux pipes. Subscribe for more coding insights and check out the full tutorial on our site!

Introduction to STDIN, STDOUT, STDERR 00:00:00
Overview of Pipes in Linux 00:00:07
Explanation of File Descriptors 00:01:12
Demonstrating Echo Command 00:01:24
Redirecting Standard Output 00:02:02
C++ Example with cout and cerr 00:02:48
Purpose of Separate Error Pipe 00:03:28
Assembly Program Introduction 00:04:55
Creating Data Section in Yasm 00:05:22
Writing Helper Functions 00:07:37
Printing to Standard Output and Error 00:11:29
Testing Output Redirection 00:12:43
Standard Input Explanation 00:14:54
Creating Stack Buffer for Input 00:16:03
Reading from Standard Input 00:17:28
Piping Input to Program 00:20:54
Handling Null Terminators 00:22:02
Conclusion and Call to Subscribe 00:23:53

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody.

In this video I’m going to talk to you a little bit about standard input, standard output,

and standard error.

Three pipes that every program has in Linux that allow it to just communicate in a very

standard way.

I’m going to show you some example code written in Yasm Assembly, but assembly knowledge is

not necessarily required for this video.

You can just sort of follow along.

Anyway, what is standard input, standard output, and standard error?

Well for starters, every program that gets launched, under the hood, the operating system

will typically attach three pipes to it.

Basically one for standard input, one for standard output, and one for standard error.

the program pretty easily. So let’s see. Oh, I know what to do. There’s an echo command, right?

So here’s the program called echo. When the program launches, it’s going to have three pipes

attached to it, just like I told you before. These pipes also behave as file descriptors,

as if you had opened a file, but their file descriptor numbers are always zero and one and two.

Zero for standard input, one for standard output, and two for standard error. So if I launch the

program it’s going to get those three pipes those three file descriptors and

right away the standard output is going to get attached to the program running

our terminal here well not necessarily the actual terminal but bash under the

hood which is the program that we’re using to interact with the operating

system so basically the program launches and based on this incoming argument that

I give it hello then it’s going to print the string hello right but what it’s

its standard output pipe its standard output file descriptor I can test this

for sure by just sort of doing the command again and then muting its

standard output pipe with this little shell trick I’ll do a arrow or a greater

than angle bracket and I’ll just send the first pipe I’ll do one I’ll send it

to dev null and on Linux dev null is just if you send anything there it just

it’s just totally ignored so if i send uh the pipe labeled number one to just nowhere then notice how

it doesn’t show on the terminal for me right it’s pretty cool let’s go a little bit deeper into this

i just want you to see real fast before i write an example program in assembly what you would

probably end up doing in c plus plus so we usually do something like iostream in germane you know

We’ll say using std cout std c error std and l and so forth.

And then if you actually want to print a message to the user, we’ll say cout this message prints

to std out because that’s what cout does by default.

And then if we do c error, a lot of people haven’t actually seen this and I personally

always forget that it’s even there if you print to see error it prints a message to standard error

why would you want two different pipes that printed messages and one is called output and

one is called error well like i’ve said before in other videos it’s really convenient to be able to

have programs automate other programs for example if you have a program that is launching you know

a second program maybe the second program fails in some way or wants to complain to you in some way

or wants to complain to you in some way, it would usually, if it’s smart,

print the complaint to standard error.

It may not actually use C error because maybe it’s not a C++ program,

but it would print to pipe number two, file descriptor number two, standard error.

And then that way, the program that’s launching it can just sort of ignore messages

that happen on standard output because we can assume all of those messages

are just normal info messages that a human might want to see.

Or maybe you want to record to a log or something somewhere

log or something somewhere and just kind of save it away.

But the error messages are a little bit more important than the regular,

you know, normal messages.

So if you’re automating another program,

then your program probably wants to take standard output and either ignore it or

just kind of send it to a different file.

And then it wants to take standard error and pay more attention to it.

Write it to a log file, save it, maybe check that it’s actually blank.

And if it’s not empty, then maybe alarm bells go off.

Something went wrong.

We have to alert someone or, you know, make a database entry, send an email, whatever.

And yeah, just pipe one and pipe two is how you accomplish that.

So this is what’s happening in C++ when you do that sort of thing.

Okay, so now I would like to write a sample program that just kind of demonstrates this

real fast.

So please bear with me.

I’m going to go really fast for the assembly portion because this is not an assembly video.

to learn more about how to write assembly in the first place than see my other videos.

For now, I’m just going to create a little blank file here.

Let’s see where the heck is my window.

I’m on a multi-window system here.

Okay, so I’m just going to paste a little data section.

This is Yasm assembly.

A little data section.

I’m just going to fill it up with strings.

I’m going to make a string for the introduction.

Hello, the module has started.

A string announcing everything that we’re going to do.

We’re going to begin printing to standard output and standard error,

and then some messages that will go to each.

And then some messages that will go to each and then a standard input string, which we’ll

talk about after the standard output and standard error.

So just a bunch of strings.

I’m going to make a buffer size.

I’m going to make system call codes for reading, writing and exiting.

If you want to know more about system call codes, see my other videos and some file descriptors.

This is exactly what I just talked about.

The file descriptor for standard input is zero for standard output is one for standard

for standard error is two.

And then I’m going to do a system exit code of zero,

which actually doesn’t matter that much,

but I’m going to do it.

So now I’m going to make a, let’s see,

a global,

hmm, make a global.

Oh, did I already make the text section?

Here we go.

So there’s the text section.

So the data section is over now.

So data section is over now.

I’m going to make the tech section.

I’m going to make a global entry point called start.

Again, if you want to know more about assembly programming in general,

see my other videos.

But so this is the entry point of our program.

At the very end, we should probably just program that it exits with success

and test it out real fast.

So basically right now this program does nothing.

Let me just double check.

Clear and make run.

I have a make file under the hood, but this is not a make file video.

If you want to know more about make files, see my other videos.

know more about make files see my other videos but basically it just starts running and then

it just dies right away okay no problem let me actually can i i want to fix that make file

because it’s it’s labeled after like a different project that i was doing let’s do

there’s no need for me to even do this i’m just uh i just can’t help myself okay so there we go

going back to the editor.

We have a program that does nothing.

I’m going to copy paste in a couple of useful functions that I use elsewhere.

Again, this is not an assembly video.

So, so you can look at my code if you want to, if you just kind of want to know how this

works, but not the point of this video.

So I’m not going to spend too much time.

Maybe I’ll just briefly talk about what it does, but not the point of this video.

So the first thing I’m doing is I’m adding a function called print null terminated string

function called print null terminated string just you know it sweeps through a

string or actually it asks another function I made to find out how long the

string is and then it’ll print the string to some file handle that I gave

it like standard output or standard error and you know it calls on this other

function called string length which I just wrote in pure assembly for fun even

though I didn’t need to and it just kind of sweeps through the string until it

finds a zero and then it knows how long the string is and then CRLF just prints

is and then crlf just prints a carriage return new line uh carriage return new line just um

with the same idea with the print null terminated string function and you can see all my strings have

null terminators that’s the dot zero at the very end of it okay so we got those helper functions

uh the next thing that i need to add in here is

do an intro like my growling i used to have a professor who would go

and he would go oh god when something went wrong and i do that all the time even when things are

going right okay so i’m going to paste a little function here called intro and this is not going

to be anything important it’s just going to print a little hello message you know it just uses my

intro string and then just prints it with those other functions i made so that means now my my

I can call intro real fast and then it’ll return when it’s done.

If I just sort of run the program again, you can see after all the build messages,

it’s just printing that the module has started.

Okay, so nothing super important yet.

Now, what I’d like to do is capture some incoming arguments real quick because…

Let’s see standard input.

Well, that’s actually not going to work.

Let’s see what I want to do here.

No, I think that’s part of a different program.

OK, I’m going to call a demo.

I don’t think I need to add that one thing that I was just looking at.

So I’m going to call a function that’s going to be our main demo.

So it’s going to jump down somewhere.

I’ll just create the function down later.

So let’s see.

Where is it?

Standard input.

I’m going to start off by saying this is my standard input function which is this and

is this pop p and then pop r12 and then it returns if you don’t know what a prologue

and epilogue are or why I’m doing pushes and pops just see my other videos but basically

I’m responsible for preserving it.

And I’m going to use the base pointer to help me remember where the stack started.

I’m just going to choose to…

What did I do?

I started the wrong function.

I’m going to do that one later.

Okay, for now, let me go find where that other one is.

Oh, there it is.

Should have double checked.

I’m going way too fast.

I’ll just copy paste this whole thing from my solution.

So I’m going to do standard.

This video is a mess.

Honestly, it’s a mess, but that’s okay.

I’m going to try my best to explain it.

So I have this function standard output standard error and I’m calling it here.

So it should jump right down there as soon as the program starts.

The standard input one is not getting called yet, but we’ll call it at the end of this

video.

print null terminated string function to print a message to standard output.

Remember standard output was just you know pipe one. Standard error is going to

be pipe two. So if I go back here and I say I want to print this matches to that

pipe then it’ll go to standard output just like the echo program was doing

when we looked at it a moment ago. And then next we’re going to print to

Oh, that was just an announcement that we’re going to begin.

So this is the real message that will say this is definitely going to standard output.

And then this other message is going to go to standard error, which is when we when we

looked at C error or pipe number two a moment ago.

So basically, I’m just printing an announcement and then two important messages.

One is going to pipe one and one is going to pipe two for standard output and standard

error.

OK, like really not very complicated at all.

Right.

So if I run this program now, hopefully I didn’t crash it by copy pasting out of order here.

Yeah, there we go.

Clear and make run.

So notice how it says that the messages are going to be printed.

And then notice that both of my messages actually show up on the terminal.

The one that says this message will print to standard output, number one, pipe one.

This message will print to standard error, pipe two.

They both get printed to the terminal because by default, the terminal will just take both of those pipes.

both of those pipes it’ll take one and two standard output and error but I can

use those little redirection tricks to mute one or more of those pipes so I’m

gonna say pipe one which is standard output I’m just gonna redirect that to

dev null to say I don’t want to see standard output if I run it again

notice how the only thing you can see on the string or on the screen is standard

error pipe to file descriptor 2 on the other hand if I redirect file descriptor

descriptor to pipe two to nothing then I should see all the normal messages and not see the error

message notice right here it’s it prints all the regular you know make file stuff and then the

welcome message and then here’s our message that says this is going to be printed to standard output

so notice how the error message is missing so cool if I mute both of those I can do that I can

then nothing gets printed at all because that’s all we really have is standard output and standard

error all right not too bad right that’s the basic idea between redirecting and things you

could also do things like this if I okay this is not part of my plan but suppose I wanted to take

any error message and redirect it to instead of dev null I wanted to redirect it to some kind of

standard error.txt.

Notice how nothing seems to have shown up on the screen, but if I list the directory,

now there’s a text file called standard error that contains the error message.

So you can redirect pipes, you can reattach them if you’re like an elite hacker.

You can do lots of things with them, but that’s as far as I’m going to take it right now.

I’m going to remove that.

Now let’s look at standard input.

How do you send input to the program?

Remember when programs call other programs, they can send each other standard input too.

It’s just that when I launch something on the terminal, I’m just, you know, I’m the

human and so whatever I type or, you know, what command I type is going to go into standard

input if I do it the right way.

So let’s go back to the program here.

Okay, so let’s finish up standard input.

And let’s see the pre-made code that I had here.

I had the prolog and the epilog, right?

Move the base pointer

RBP and R12. Oh, I got to put the

Base pointer back into the stack pointer. Let’s see move

Again, this is not an assembly video. So just try to hang on here. So what I’m gonna do in this video

I thought I was cute when I was making this plan. I know I’m not like that clever, but um, I

Thought hey wouldn’t it be fun instead of having a global

or the BSS section. What if I just made the stack a buffer? This is kind of what you do when you make

a local array in C++. You’re making a buffer on the stack. So this is not a stack pointer video.

So long story short, I’m just going to keep track of where the stack pointer started with this base

pointer. That’s why I have to preserve it there. And then I’m just going to subtract my buffer size

from the stack pointer. And what is the buffer size? I’ve chosen to do a buffer size of about

So that means the user or me, I could send about eight kilobytes, maybe eight kilobytes

or less into standard input and be sure that it’s all actually going to be received by

the program.

And then I’m just going to use R12 to remember where the start of the buffer is, which is

just wherever the stack pointer started.

Because if we subtract and then the data that increases is actually increasing in memory,

but making room on the stack decreased, it’s just the way it works.

There’s going to be another stack video out there.

stack video out there anyway for now I just create a buffer on the stack and

then I’m gonna print a little hello message so I’m gonna print this so just

my message saying hey we’re about to do something from standard input and then

I’m gonna send that to a standard output so the message is gonna go to standard

output but I’m announcing that we’re about to read from standard input

assuming I actually cleaned up correctly let me double check this this should

It should just simply say that it’s going to without crashing.

Okay, looks good.

So then now I’m ready to actually read from standard input.

We’re going to use a system call from this.

If you want more information on system calls, see my other videos.

But basically you just go to the system call codes table,

look up appendix area of whatever textbook you’re using.

And you say, what’s the code to read?

I want the system to read.

what you know i want the system to read so i define that as system read and if you look up

here in my program it’s just call code zero so sys call code zero is to read from somewhere

and then uh where do i want to read from that’s the second argument for the standard

or for the system call i want to read from standard input that’s going to be the number zero

if you recall and then here is a pointer to the first character of wherever i want it to

read into. So it’s going to read from that pipe, but it has to, it has to write the data that it

read somewhere so that I can save it and access it. So R12 is basically going to be a bunch of

free bytes that I created on the stack. So I like, you know, I’m, I like made the stack bigger,

but it’s mostly empty or with junk data. And R12 is just pointing to the first byte that I have

reserved. So, you know, you could imagine maybe you make a global variable in the BSS section up

up at the top, you know, like an eight kilobyte array of bytes, and then just sort of point

it to that. But in my case, I’m just using the stack because I think it’s cooler. So

I tell it, Hey, that’s the first bite on the stack that you want that I want you to start

reading from. And then I give it the buffer size, which we just looked at. And then I

do a system call and then the system now should do all the hard work for me. It’ll look at

the pipe for standard input. It’ll grab all of it. And then it will only grab, you know,

it’ll stop if the input ends before that and then when I’m done I should be able

to actually read from the buffer which is sitting at R12 and print it to the

screen so the next thing I’m gonna copy paste in there is I’m gonna print what

I just read from standard input so this is another call to my function my little

doggy wants to go pee even though he’s completely lying he just went pee so at

wants to go outside and lift his leg and do nothing and then come back in and demand a treat.

I’ll let him do it in a few minutes just in case but trust me he’s lying he’s laid like five times

today. Anyway I sometimes I regret teaching him to growl at me. It’s so cute but like it’s not

cute right now. I don’t know maybe it is. Let me know in the comments. So basically I’m going to

take that R12 buffer that I just wrote to and I’m going to print that directly to standard output

output and this is not really the important part of the video.

So I’m going to do that and then I’m going to kind of clean up here at the end of the

function.

And then maybe I’ll say goodbye.

I think I just added a string for that.

So maybe I’ll say goodbye.

I’ll say goodbye before we end the function and then I’ll actually return.

So let me go here and run the program.

Let’s see, begin.

printed because we didn’t send anything and we also didn’t call that let me call

standard input call stdin and so now it’s actually gonna print basically

nothing oh I didn’t send it anything so it’s just kind of hanging you probably

want to check this sort of situation but that’s that’s not the point of this

video let me show you how to pipe some some stuff into standard input real fast

hello and then just put a little or bar in the shell this will take the output

of echo and instead of printing it to the terminal it’ll attach its standard

output into the standard input of make run pretty cool shell trick so now we

should see the word hello the word hello printed and that’s what it does we have

detected the following stdin and it says like here’s begin that’s just a string

that I had that I print every time and then here’s the string that it actually

And then it ends.

Pretty nice.

I think maybe we could probably do the empty thing if I just started typing here.

And then maybe I hit control D to detach the buffer.

And yeah, that’s what it does.

It sort of prints here and then it ends there.

Didn’t do a new line.

I think it probably doubled it for some reason because I…

Let’s see.

I didn’t plan for this.

Let me see.

plan for this let me see it printed oh because I did I did not null terminate the string so

actually what it did is it uh let’s see if we can do that real fast one more time I’m going to go

one two three four five then I’m going to just disconnect the standard input buffer because the

printing function needs a null terminator to know when to stop there’s not going to be a null

terminator because I just typed and disconnected the uh the input so it’s actually going to just

until it randomly finds a zero and then it’ll stop so if I disconnect it it

that explanation was bunk let me try that one more time I’m gonna go a bunch

of H’s I guess there is a null terminator I disconnect it no no see how

yeah these little symbols there so it does kind of print until it finds a

null terminator but I guess I was confused because it seemed like it

like it printed it twice what’s actually happening is when i type then it’s getting sent to the

terminal which and that’s not part of the program that we just wrote then when i disconnect standard

input then the program finally prints everything that i actually typed until it hits a null

terminator in this case it looks like it seems to have worked but uh if i just do like a couple

sevens and then disconnect probably have to do this a bunch of times before we’ll see those weird

What did I do? Hit enter. That seems to have worked. My dog is stressing me out

but I love him. Alright anyway just trust me on this sometimes it’s hitting the

null terminator in time sometimes it’s not. But I hope by now you understand the

difference between standard input standard output and standard error. Thank

you so much for watching this video that I’m recording and I hope you learned a

little bit of stuff and had a little bit of fun. I’m gonna let my dog lie to me

I’m gonna let my dog lie to me for a second and I’ll see you in the next video.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

and grow this community so we’ll be able to do more videos, longer videos, better videos,

or just I’ll be able to keep making videos in general. So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know

somebody subscribed or followed. It just wakes me up and I get filled with joy. That’s exactly what

happens every single time. So you could do it as a nice favor to me or you could troll me if you

want to just wake me up in the middle of the night, just subscribe and then I’ll just wake up.

wake up I promise that’s what will happen also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

video and it’ll take you to my main website where you can just kind of like

see all the videos I published and the services and tutorials and things that I

offer and all that good stuff and if you have a suggestion for clarifications or

or errata or just future videos that you want to see please leave a comment or if you just want to

say hey what’s up what’s going on you know just send me a comment whatever i also wake up for

those in the middle of the night i get i wake up in a cold sweat and i’m like it would really it

really mean the world to me i would really appreciate it so again thank you so much for

watching this video and um enjoy the cool music as as i fade into the darkness which is coming for us

Thank you.

The post Mastering Standard Input, Output, and Error (STDIN, STDOUT, STDERR) in Linux with Yasm Assembly Examples appeared first on NeuralLantern.com.

Ready to master x86-64 assembly? This video breaks down system services, showing you how to use syscalls to print messages, handle file descriptors, and exit programs cleanly. We’ll walk through a real assembly program, explain key concepts like standard output and file handles, and share tips from a top book on the subject. Whether you’re new to assembly or sharpening your skills, this tutorial is packed with clear examples and practical advice. Subscribe for more coding deep dives, and check out our upcoming file I/O video! #AssemblyProgramming #SystemCalls #x86_64 #CodingTutorials

Introduction to System Services 00:00:00
System Services in x86-64 Assembly 00:00:04
Recommended Book on Assembly 00:00:35
What is a System Service? 00:01:01
Example Assembly Program 00:01:21
Syscall Instruction Explanation 00:02:52
Standard Output and File Descriptors 00:04:01
Printing a String with Syscall 00:05:16
Exiting a Program with Syscall 00:07:21
Exit Codes and Program Success 00:08:02
Book Reference for System Services 00:09:51
Detailed System Write Service 00:11:01
Checking System Call Return Values 00:12:08
File Operations with System Calls 00:14:35
Closing Files and Best Practices 00:15:50
Other System Call Codes 00:16:43
File Permissions and Modes 00:17:20
Handling System Call Results 00:19:03
Future Video Plans and Wrap-Up 00:20:40
Call to Subscribe and Outro 00:21:28

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody in this video we’re going to talk a little bit about system services

in an x86-64 machine while programming in assembly

this video is going to focus on yasm assembly but this should also work for any other assembly

language that you program as long as you have the right kind of cpu x86-64 is also known as

that in mind okay so for starters let’s see here’s a wonderful book i love pushing this book i did

not write it the person who wrote it is a genius it’s called x86 64 assembly language programming

with the boot to it’s a free and open source book so anybody can go get it find his website

and here’s the version i’m using and honestly a really old version of this book is still really

good he just keeps you know making little improvements but it was it was good even a

even a long time ago. Anyway, so what is a system service? For starters, before I go into this book

a little bit more, what is the system service? Suppose for the sake of argument that I’ve

already written an assembly program, a pure assembly program, not a hybrid module program

or anything. If you want to learn assembly, see my other videos, but for now I’m just going to

assume you kind of already know how, so I’m just going to open up a pre-made program here.

I’m going to do nano so I can edit the assembly file just so you can see what’s inside of here.

just so you can see what’s inside of here.

Okay, so I hope the red is not too hard to see.

Oh, the tabs got ruined on Nano.

Hang on, let me see if I can just open this up in Genie.

Should have done that to begin with, okay.

Yeah, okay, I wrote it in Genie

and I guess I don’t have the tabs set up in Nano very well.

Okay, so here’s like my assembly program.

You know, I just have a little string here

string length and CRLF for like a line feed and some file descriptors and stuff

that I talk about in other videos here’s the entry point of the program just like

a little start entry point because it’s pure assembly and all I’m gonna do is

I’m gonna print a message right I’m just gonna print a little hello message and

then call on CRLF all CRLF does is just it just prints a new line so the program

if i run it right now you’ll just see what happens if i say let’s see clear and make run

then you can see there’s some stuff happening up here in the make file which i forgot to update

the title ignore that basically the real action is this line right here hello i’m printing using

a system service if you already know assembly then you have probably already seen this before

and it seems a little boring that’s good but i just want you to know that we’re using a system

system service to actually do the printing.

Kind of take it for granted here.

This little instruction called syscall.

What is a syscall?

Well, it’s just basically you set up some variables, some,

some codes, some data, whatever in, in some special registers.

One of the registers lets the system know what you want it to do.

One of the registers is like, or I guess all the following registers

if they’re needed, are just input to the system call that you’re trying to do.

do so in this case rax is letting the system know i want you to do this this code i want you to do

this certain thing i have a defined set up here called system right but if you look up in my

little defines area it’s just a number one so that means if i set the number one in rax i’m letting

the system know that i want it to write to some pipe to some file then you know depending on what

code you’re using rdi rsi rdx and other things may be needed or maybe not be needed at all

in this case when i’m writing somewhere it wants three arguments so i have to use rdi rsi and rdx

because those are the three arguments the first argument that it wants is where to print

see my other videos for a more in-depth explanation of file descriptors and pipes but just long story

pipes standard input standard output and standard error standard out is a pipe

number one let’s see where’s that yeah it’s just assigned a number one so

every program has its own number one pipe which is just standard output and I

guess I should say that it gets piped to file descriptor one it’s kind of like an

ambiguous term sort of but the system right call will write data to a file

file and if i give it a file handle of just one that lets the system know oh actually i want to

write to this standard output for the one particular process that we’re inside of but

you could open any file that you want and get like a file handle to it and the operating system will

realize oh you know i i associate that file handle i gave you with this certain open file that you

created or opened for reading or whatever um and so when you give the handle back it knows where

knows where to write. So in this case,

it’s treating the standard output just like a file,

just a file with a special handle of just one.

I’ll talk about that more in another video.

Then the next two arguments it wants is just the,

a pointer to the first character of the message that you want to print.

And then just an integer representing the length of the message that you want

to print. And if we just look up here again at my little hello,

my hello symbol points to an array of bytes, just characters.

bytes just characters there is no null terminator on there it’s just bytes only

and so when I give it you know message hello by itself what I’m really giving

it is a pointer to that H letter just a pointer to the memory look you know I’m

pointing to the memory location of the very first character in that string and

then for the length I’m just using a special token little shortcut thing

where you just put a dollar sign minus and then the name of another string and

and then the name of another string,

and then the assembler will compute the length of that string.

So this right here is the same thing as me

just typing the exact length of the string.

I don’t even know what it is.

I don’t feel like counting it.

You can at home if you want.

One, two, three, four, I’m not gonna do it.

Anyway, so we basically just say,

you know, I would like to write somewhere.

I would like to write to the standard output file,

file handle, I would like to, you know, to that pipe.

I would like to write, you know, this string,

you know this string and then i would like to tell you that this is how long that string is

and then after you set all that stuff up you just say system call and the system will go ahead and

do all of the hard work for you it’ll go figure out how to actually write data to the file and

you know figure out how to do everything that it’s supposed to do and all you have to do is

a little system call here right after this you can see that i have a call crlf that’s just a function

call i talked about functions in other videos but basically you know i’m just calling a function here

you know i’m just calling a function here and it does the same thing it makes a system call but

instead of printing the hello string it’s printing my crlf string and if you just kind of look at what

my crlf is it’s just these two characters 13 and 10 so like you know slash r slash n for carriage

return line feed that’s why i call it crlf so all this program does just print a message and then a

new line and then at the very end it does another system call to properly exit the program if this

hybrid program and I had like the entry point of main, you know, that the GCC libraries give you,

then I would probably just want to return at the end of this function. But since this is pure

assembly, I can actually just exit the program and be fine. So exit with success is a different

system call code. Notice how I have the symbol system exit loaded into RAX. And if you look up

here, system exit is just the code 60. So if I send a code of one into RAX, that means I want to write

a code of 60 somewhere that means i want to exit the program the only argument that takes is rdi

which is just what is the exit code that you want to return to the operating system so um

if you recall from some of my other videos let’s see if we do echo hello echo always succeeds at

least as far as i know there’s like it’s like really hard to make it fail if i echo hello then

the program echo launches and it will succeed by just printing the word hello like see how it just

like see how it just does that so that means after that command i could echo the special

variable dollar sign question mark just to see what the echo command exited with right it should

be a zero because it succeeded so you can see now a zero under the hello on the other hand

if i concatenate um let’s say a file that exists i should also get you know an error code that is a

So it’s a zero at the very end.

But if I try to concatenate a file that doesn’t actually exist,

I’ll put a OS release two because that doesn’t exist.

Notice how the cat command fails because it couldn’t find the file and the exit

code is a one.

So all you’re doing when setting RDI here is just controlling what exit code you

want your program to exit with.

This isn’t very convenient for a human running a program.

Maybe if you want to look at the exit code for some reason, but this is really,

really convenient for programs that want to automate other programs.

programs just keep in mind if you have a program that is executing another

program and it wants to see if that program succeeded the exit code is one

of the easiest ways to find out if the program succeeded so this is the whole

idea of this entire program we’re just using two system calls to print

something and then to exit the program hopefully this makes sense and now I

want to go show you this wonderful wonderful book if I didn’t already say

If I didn’t already say this before, sorry if I already did.

This book is written by a genius.

It’s called this.

Here’s the guy who wrote the book.

And here’s the version that I’m using, but old versions are good.

You can get this book for free on his website if you go find it.

So I’m just going to go to this assembly book, which deals with a lot of Yasm assembly tips

and tricks and tutorials and explanations and things.

And I’m going to go to the section labeled after system services.

So for me, this is a chapter 13 system services, just to give you a little explanation of what

this is.

You know, this is basically what I said.

It gives you, you know, a chance for your application to ask the operating system to

do something for you that you don’t want to program from scratch in assembly or that you

can’t program.

But here’s the real juicy details here.

If we go to, yeah, yeah.

Okay.

C, which is section 23.0 system services.

There’s a whole bunch of system services in here that you can, uh, that you can read about.

So for starters, if we go down a little bit, notice how it says basic system services.

If we go down a little bit, you can see right here, the system write service that we’ve

been using in the sample assembly program.

You know, when we’re just printing, we say code one is to write something.

And so this is what the table says.

you place inside of RAX before syscall.

Call code 1 is going to be to write characters and then it tells you what arguments it needs.

So like RDI is the file descriptor where do you want to write to.

Just like I said before you could give it a file handle that you already received from

opening a file or creating a file.

Or you could give it 0 or 1 or 2 if you want to try to write to one of the pipes although

actually file descriptor 0 is standard input I don’t think that would actually work.

zero to reading if you wanted to read the user’s input or or you know any input that that program

was given through its standard input rsi is just the address of the characters to write like we

talked about before and then rdx is the count of the characters to write notice how there are no

more arguments and that’s why i only gave it three arguments besides rex notice how it says here if

unsuccessful it returns a negative value if successful it returns the count of characters

count of characters actually written this is a really really good idea if you think about it

um a lot of new programmers they don’t really look at return codes when they call system services

or built-in c functions or built-in c++ functions they just kind of call it and hope for the best

but imagine if you uh if you try to write a huge long string in uh using system write call code one

and maybe some of the characters did write but the system decided to only write i don’t know half for

reason maybe it ran out of buffer maybe you know it interrupted you know your right or something

like that so it could happen what that would mean is that the return value it would be greater than

zero indicating that some characters were written but it’ll tell you exactly how many characters

were written so you’ll know that you got to keep calling the sys call until all the characters were

successfully written why would you do this i don’t know maybe you have a gigantic string like maybe

like a several gigabyte file and you wanted to copy it to another file so you’ll be calling

system write over and over again and system write it’s only going to write so many bytes at the same

time so you use the return value to figure out how far forward in the read buffer you need to advance

or you know whatever so that you can well write the entire complete file or the entire complete

string or whatever it is without any gaps without it being truncated and so forth and then of course

And then of course, if it returns a negative value, then it totally failed.

Like you tried to write to a bad file handle, like standard input or a file handle that

was closed or a file handle that was open for reading only, something like that.

And then you can use some if else, you know, branching logic.

I mean, not if else in assembly, it’s just going to be comparison and conditional jumping

or branching.

But you can have more control over your program, right?

Because you want your program to be able to respond to errors.

Let me just quickly cruise through all of the other options and let you know that

and let you know that in another video I’m gonna do a full tutorial for how to

copy one file to another by opening one file for reading and then like using

system calls to read from it and then open another file for writing and then

you know use system calls to write to it and I’m gonna do that looping buffer

stuff that I talked about before anyway so but for now I’m just gonna go through

the rest of these system call codes let’s see so first off we got open well

Well, if you want to open a file, then you just give it call code 2 and you pass in the

address here, you know, RDI, you say, here’s the address of a null terminated file name.

So that means somewhere in memory, you have to have the file name that you want to open

with a null terminator, like a zero at the end of the string, either the full path or

relative path to wherever the program is currently running.

And then RSI is going to be file status flags.

And what does that mean?

And what does that mean? We can actually just search for that.

I’m going to say control C to copy,

and then I’m going to do control F to search for that.

And let’s see what page of mine right now, 340.

If I go down to the search results for that,

it just explains what the file modes are. So if you put value zero,

that means read only you’re opening the file and read only mode value one.

That means a write only a value to allows reading and writing to the file.

So if you don’t know what that means, well, there it was.

What was I just on before?

40?

Oh, gosh.

Completely lost my…

Oh, yeah, 40.

Okay, so opening pretty easy, right?

Like if you didn’t know this before, you didn’t necessarily read me.

You could just look at this table and go, what do I want to do?

I want to open.

So here’s the code.

Here’s the address that it needs.

When you’re done opening a file, when you’re done working with a file,

you want to close that file unless the whole program is going to terminate.

unless the whole program is going to terminate at that point you i mean maybe you have a function

that gets called somewhat often and you kind of always have to open a file and sort of look at

something or write something and maybe you want to close it when the function is over right you

don’t want to have a file handle just open forever that’s a waste of memory and it might introduce

bad behavior to your program if you just have a bunch of file handles floating around that you

forgot about so it’s proper to close a file when you’re finished with it that’s just going to be

and it only wants one argument.

It just wants the file descriptor of the file that you wanted to close.

So if you open a file for a reading or to create it,

you get a file descriptor back.

You should probably hang on to it somewhere on the stack

or like in a global variable or like, you know, in a register or whatever.

Then when you’re done doing something to that file

and you’re sure that it’s time to close it,

just give that handle right back when you call code three to close it.

Then you can sort of like seek, you know,

forward and backwards to the file if you want to.

You can fork the current process.

You can fork the current process that’s kind of advanced for this video.

You can exit.

Remember before we exited from that program with code 60.

So that’s it. Call code 60.

If you didn’t watch this video, you could have gone through this table and just said,

Oh, you know, I want to terminate the executing process.

I do a system call with code 60 and I’ll give the exit status to RDI,

which is typically zero for success.

Bunch of other stuffs create, get the time of day,

and then the file modes that we talked about before.

we talked about before and then file permissions. Let’s see, where’s the permission. I think it’s

when you want to create a file. Yeah, right here. If we wanted to create a file, that’s code 85.

RDI is the name of the file, you know, like a pointer to the string. RSI is the file mode flags.

And then you’re thinking like, what are the file mode flags? Just go down here and then here you

go. All the file modes that you could ever want. You just look at it and go, well, I guess I can

I guess I can just copy paste this number right here and it’ll end up being, you know,

whatever is described on the left and the right.

Like the group has read, write and execute permissions and so forth.

I mean, really, if you look at this long enough, you’ll kind of realize that this is a quad

word because it has a Q on the end of it.

And the rest is just an octal file permissions notation where this first number here, notice

how the first two are zeros, but this first actual number here is something that applies

to the user and then the next one applies to the group the next one applies to others who are not

part of the user or group and this video is not about file permissions I’ll probably make one

later if I think people will actually watch it but yeah you can just kind of like look it up here if

you want to and just copy paste that into a define somewhere let’s see what else I just want to show

you a little code snip just to illustrate a little bit more what I was talking about before

for. People usually make this mistake, they’ll do see this is what people will usually do like new

programmers. Suppose this is a function pretend we’re in C or C++. For the time being, you call

some sort of a system function or an API of some other library. And you just you just hope that it

works, you just call it and then your program continues underneath, right? It’s a bad idea,

because maybe that failed, maybe there’s some action you need to take. So instead, it’s a really

really good idea to check the return result or i should say an even better idea is check the

documentation usually these types of you know c system calls or function calls or api calls or

whatever they’ll return something indicating success or failure sometimes the documentation

will tell you oh you’ve got to put like a pointer to some other data structure in the arguments

and then the result comes there of course just read the documentation but usually it’s just

So you want to grab the result and then check the result.

In this case I’m assuming this is sort of a standard function that will return zero

or greater on success like the system write call or the system read call and return less

than zero if it fails.

So here I’m just responding, you know, if it’s like if the result was greater than zero

then it’s like, yay we can proceed.

Maybe I’ll continue with my program in some way and if it’s not then I’ll print a complaint

then I’ll print a complaint to the user and then I’ll take some sort of an action

like I’ll write to a log file, send an email somewhere, you know,

do something to try and recover from the error and alert admins to the error.

And in this case, I’m just throwing an exception.

This video is not about exceptions, but so I just want you to know,

this is a good design pattern to not just discard the result of a call to

something. You should check the result and see what you’re supposed to do.

Let’s see, what else did I want to tip?

system services, file handles.

Yeah, okay, I think that’s everything that I wanted to tell you.

In future videos, I’m going to talk about, you know, some of this stuff much more in-depth,

like with my file.io video that I’m going to publish pretty soon, which is, you know,

it lets you read and write to files, and it uses a loop to read a little bit at a time.

Okay, thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’m outie.

Or something.

Goodbye.

you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more

videos longer videos better videos or just I’ll be able to keep making videos

in general so please do do me a kindness and and subscribe you know sometimes

I’m sleeping in the middle of the night and I just wake up because I know

somebody subscribed or followed it just wakes me up and I get filled with joy

that’s exactly what happens every single time so you could do it as a nice favor

could you control me if you want to just wake me up in the middle of the night

just subscribe and then I’ll just wake up I promise that’s what will happen

also if you look at the middle of the screen right now you should see a QR

code which you can scan in order to go to the website which I think is also

named somewhere at the bottom of this video and it’ll take you to my main

website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and if

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know just

send me a comment whatever i also wake up for those in the middle of the night i get i wake

up in a cold sweat and i’m like it would really it really mean the world to me i would really

appreciate it so again thank you so much for watching this video and um enjoy the cool music

as I fade into the darkness which is coming for us all.

Thank you.

The post Mastering System Services in x86-64 Assembly Programming appeared first on NeuralLantern.com.