WEBVTT

1
00:00:01.890 --> 00:00:09.960
William Cheng: Okay, this is the third part of lecture 11 I just remember that I forgot to mention one little thing in the second part.

2
00:00:10.500 --> 00:00:17.850
William Cheng: Whenever you get a page for you get paid for at a single virtual address right the example that I gave is if you access. One of the memory location over here.

3
00:00:18.510 --> 00:00:23.400
William Cheng: For example over here. If it turns out that the access over here is is no access

4
00:00:23.910 --> 00:00:29.820
William Cheng: You're gonna you're gonna cause a trap you trapping the operating system. Okay. So you started out with a single virtual address

5
00:00:30.210 --> 00:00:40.620
William Cheng: So then what do you do, right. So the picture that we saw you know later is that there's an address space implementation that described all your memory segments. They have started dress. They have a length.

6
00:00:41.130 --> 00:00:47.250
William Cheng: So what you will do is that you will use that virtual address when it comes to Colonel, you know, which virtual just give you a page fault.

7
00:00:47.550 --> 00:00:55.920
William Cheng: Then, so now what you have to do is say, you simply do a linear search over here. Well done, this data structure and find out that virtual address which memory segment it belongs

8
00:00:56.460 --> 00:01:03.840
William Cheng: Okay, so for example you know if the address is in this range, whether they belong to the first memory segment. If the address belongs to the second range over here, then it belong to the second

9
00:01:04.170 --> 00:01:11.310
William Cheng: The second every segment. So all you do is to take that virtual address and you do a linear search over here and the as the as region over here.

10
00:01:11.760 --> 00:01:22.950
William Cheng: They are sorted by virtual address okay this example, the smallest ones on the left, the largest one is on the rise. So, therefore, you do a linear search, pretty soon you're going to find out you know which which memory segment.

11
00:01:23.370 --> 00:01:30.420
William Cheng: Which memory seven mini belongs. And then what you do is that you use the information is that as region and try to figure it out if we can resolve that.

12
00:01:32.100 --> 00:01:40.560
William Cheng: You can resolve that page fault, okay. If you cannot resolve that pays for all then you kill the program in the kernel. So, therefore, you know, the user process is killed.

13
00:01:40.800 --> 00:01:45.540
William Cheng: Unless there's a you know signal handler that in that case, you go, you know, go to the user space able to settle handler.

14
00:01:45.930 --> 00:01:50.580
William Cheng: If it turns out that there is a way for you to resolve that problem or. For example, if the data is not, you know,

15
00:01:51.450 --> 00:01:57.030
William Cheng: It's not a physical memory that in that case you will go to the desk right you will ask these objects over here to transfer data.

16
00:01:57.390 --> 00:02:06.030
William Cheng: From the right place into memory and then you change your virtual I just met you go back into the user space program and the user spiritual and we'll try that. Try that member reference. One more time.

17
00:02:06.510 --> 00:02:16.080
William Cheng: That. So again, you know, this list over here is sorted according to the virtual dress and of course you know these memory segment. They are not allowed to overlap.

18
00:02:16.500 --> 00:02:23.730
William Cheng: Right, because, you know, here's, here's a tech segment. Here's the data side, where are you allowed to have them overlap and some virtual dresses. Of course, you know, they're not allowed.

19
00:02:24.150 --> 00:02:37.530
William Cheng: So they have in this case, they don't have any overlap. So, this this particular search. It's pretty straightforward. Okay, so that's how you. That's how you start resolving, you know, a baseball later on in chapter seven, we're going to see more of

20
00:02:39.690 --> 00:02:47.700
William Cheng: Going to see more detail so so that so that you know exactly what to do and also in Colonel three. That's one of them. The main thing that you have to learn how to implement. Yeah.

21
00:02:48.480 --> 00:02:53.820
William Cheng: Alright, so, so we're done with this part. And now we're going to go back to chapter one, as we mentioned before.

22
00:02:54.180 --> 00:03:00.870
William Cheng: Now we know the difference between virtual file system and the actual file system. And now you realize that all the stuff that we talked about a chapter one.

23
00:03:01.410 --> 00:03:07.350
William Cheng: So they are you know part of the file abstraction. So, therefore, you know, we're talking about the the virtual file system.

24
00:03:07.650 --> 00:03:13.950
William Cheng: Okay, in chapter six. We're going to see how the data can be laid out on the disk. And then we're gonna talk about the actual file system. Right.

25
00:03:14.730 --> 00:03:21.720
William Cheng: Okay, so this is the last set of slides in Chapter ones over here we're going to start talking about files. The first 13 slides.

26
00:03:22.230 --> 00:03:29.250
William Cheng: overlap with the the earlier time when we talk about chapter one. So I'm just going to sort of flip through the slides over here.

27
00:03:29.730 --> 00:03:38.250
William Cheng: We talked about what the thought abstraction is what the file system API is what are the special file descriptor the file descriptor table. We've gone through some examples over here.

28
00:03:38.520 --> 00:03:49.410
William Cheng: And we also show you how you can redirect the IO. We also show you the rules of allocating fault table and verify the script to entry. Will you try to create a new file, you know, etc.

29
00:03:50.250 --> 00:03:59.880
William Cheng: And then we come to the last slide over here and this is the you know what will. What will the last time when we come to chapter one. This was the last slide. And now we know that there's more detail right because because

30
00:04:01.260 --> 00:04:11.790
William Cheng: This picture over here. We're actually we're talking about the other virtual classes, then and now we know that on the right hand side, there's more stuff right there's the either on the right hand side over here, there is the actual process and all the right stuff.

31
00:04:12.360 --> 00:04:18.750
William Cheng: Okay, so, so again, now we're going to sort of still focus on you know the the virtual POS system because we're still in chapter one.

32
00:04:19.740 --> 00:04:21.900
William Cheng: Okay. So in this case, again let that so sort of

33
00:04:22.440 --> 00:04:31.410
William Cheng: remind ourselves, you know, what is actually inside the virtual POS system. And there's a file abstraction. Right. And then for the fall. What can you do to the file. Well, you can without being in the previous example in the fall, I

34
00:04:32.280 --> 00:04:36.540
William Cheng: Know that the other sort of the I know points that points to. You need to be able to create a file.

35
00:04:36.810 --> 00:04:43.560
William Cheng: So how do you create a file, right. So if you're inside the virtual file system, you can start to create a file the virtual file system doesn't know how to create a file.

36
00:04:44.340 --> 00:04:53.970
William Cheng: Right. Why doesn't know how to do that, right, because the act in order for you to create a file, you need to know what is the data structure on desk so therefore you need the actual of us to do that.

37
00:04:54.660 --> 00:05:01.350
William Cheng: Okay, so therefore on the verge of a system. There's nothing you can do other than call a function is that the actual process that and the actual file system will create a powerful you

38
00:05:01.680 --> 00:05:06.510
William Cheng: And then once you create a file. If you want to write to the file. Does the virtual file system know how to write to the file.

39
00:05:06.750 --> 00:05:16.890
William Cheng: I mean, clearly the verge of buses and has no clue how to write to the file. So in that case, again, what it needs to do is the is to find the function pointer and then call out the actual file system, the actual fosters that will help you to write it down to the bottom.

40
00:05:17.700 --> 00:05:27.150
William Cheng: Okay, so. So anyway, the virtual file system. It's pretty boring. Okay. Because in the end, it can't really do anything real because anything real you need to be needs to be done inside the, you know, inside actual file system.

41
00:05:28.170 --> 00:05:34.680
William Cheng: So, so, so, since we're doing chapter one. We're going to sort of see the rest of what the virtual file system is supposed to do. Yeah. Alright.

42
00:05:35.940 --> 00:05:38.190
William Cheng: So, so sort of give a quick review of

43
00:05:38.520 --> 00:05:43.860
William Cheng: You know why, but will you make an open system called when you make the racism called will you make the racism, because it made made the closest them call

44
00:05:43.980 --> 00:05:49.890
William Cheng: So again on top over here where the user space and the bottom over here with kernel space. We're not joining any of the hardware here.

45
00:05:50.310 --> 00:05:57.030
William Cheng: Before we saw a bunch of stuff happening, the processes subsystem and now things gonna happen inside the cell, the file subsystem. Okay.

46
00:05:57.360 --> 00:06:03.300
William Cheng: Alright, so let's start with the open system called right or we hear open system called the first argument over here is going to be a file system path.

47
00:06:03.690 --> 00:06:05.820
William Cheng: You need to try to find a particular file over here.

48
00:06:06.480 --> 00:06:15.360
William Cheng: So in this goes, what we'll do is is is a system called going to tap into the operating system. Right. So we start with open and as soon as you execute that we try and do the ordinances there and what the organism.

49
00:06:15.690 --> 00:06:20.910
William Cheng: Has to do right now is to make sure that this file exists. Okay, if you try to open a file right so

50
00:06:21.390 --> 00:06:26.790
William Cheng: Depending how you want to open it. If you want to open this file to create a file. And in that case, you have to make sure that it doesn't exist.

51
00:06:27.180 --> 00:06:32.220
William Cheng: But if you want to open the file for reading. I mean, our example, have you tried to read a file, then we're going to make sure that this exists.

52
00:06:33.000 --> 00:06:40.080
William Cheng: That so so so this pretty operation over you're going to try to the file system. And now the file system actually has gone through a pretty long process.

53
00:06:40.290 --> 00:06:44.670
William Cheng: Tried to find out whether this file exists or not. Right, so they don't. I'm going to sort of see exactly what what

54
00:06:44.850 --> 00:06:53.880
William Cheng: Has to be done right, but the basic idea over here is that, you know, at some point over year, you know, the we're going to make sure that you have access right to this file, this file exists.

55
00:06:54.360 --> 00:06:58.590
William Cheng: So again you warm up one and two, you know the difference between a file exists or not or whether you have access to

56
00:06:59.460 --> 00:07:07.590
William Cheng: That. So if you have access to the file, this file exists. Well, in the hope is that we're going to sort of build this path, all the way to this particular file. So, so where's this part.

57
00:07:07.770 --> 00:07:11.700
William Cheng: This part is sitting on this somewhere. So there's food that takes over here sitting on this.

58
00:07:12.450 --> 00:07:14.100
William Cheng: Okay, so when he said, open the file the of the

59
00:07:14.340 --> 00:07:21.060
William Cheng: The other opportunities and actually is going to build this long list of data structure started out with the fallout jazz or so we need that there's a file descriptor table.

60
00:07:21.240 --> 00:07:25.080
William Cheng: And there's the file object over here the file object points to the I know table, the

61
00:07:25.320 --> 00:07:34.080
William Cheng: Table is going to point to something and eventually is also going to point to it. As I mentioned, it's going to point to the device driver, the device driver know how to get data from the desk right so so we're sort of

62
00:07:34.620 --> 00:07:40.140
William Cheng: You know, build a really long list of objects over here that eventually pointed this data on that they are on the desk.

63
00:07:40.890 --> 00:07:48.030
William Cheng: Okay, I'm clearly at the level of the virtual file system, the virtual bosses that has no idea how this is done. Right. So all the nose is how to make a function call.

64
00:07:48.420 --> 00:07:51.690
William Cheng: Into the actual process me the actual file system will make sure that everything is set up.

65
00:07:52.410 --> 00:08:02.130
William Cheng: Okay, so in the end if you are capable will open this far, lots of data structure inside a kernel is being is going to be set up and then in the end, you know, we're going to allocate an entry instead of file descriptor table.

66
00:08:02.370 --> 00:08:07.440
William Cheng: Yeah, I'm going to return the array index into the file descriptor table and that will be the return value over here.

67
00:08:08.280 --> 00:08:14.700
William Cheng: That. So when what's up. If you can actually open this file. We're going to sort of check access right you know make sure that the Father exists all that's kind of saw

68
00:08:14.970 --> 00:08:18.750
William Cheng: Where we're done over here, right. We know that eventually we're going to put into this date on the file.

69
00:08:19.050 --> 00:08:22.290
William Cheng: Okay, we also want the beginning right the beginnings can be a file descriptor table.

70
00:08:22.530 --> 00:08:31.890
William Cheng: An entry is that if I just go to the table. Is there a point in the fall object, the object is going to point to, you know, the I know Tabor, all that kind of stuff there many, many leveling direction, but eventually will point to the desk.

71
00:08:32.580 --> 00:08:38.580
William Cheng: Okay, so the open system is actually very complicated. It's only involved many, many things inside of our system, but eventually will set up this path.

72
00:08:38.760 --> 00:08:45.300
William Cheng: And if everything is OK. You will allocate a new entry. Again, the way you allocate this new entry instead of a descriptor table in chapter one. We talked about the rule, right.

73
00:08:45.450 --> 00:08:50.430
William Cheng: You go down this list, you find the first spot that's open or you have to add okay that that about descriptor table entry.

74
00:08:51.510 --> 00:08:54.780
William Cheng: And then eventually when everything is fine. Over here you return to follow the script over here.

75
00:08:54.960 --> 00:09:03.540
William Cheng: Into the user space. And now you treat the father script, but as a handle into the ordinances there. So next time we need to call read or write a closed, you need to pass the head back to the office up

76
00:09:03.870 --> 00:09:15.420
William Cheng: There. So in our example here. I'm going to call the racism call. So the first argument here is that would be the handle. And so in this case we for the Unix and Linux system. You notice it's an array index into the file descriptor table.

77
00:09:16.230 --> 00:09:22.740
William Cheng: And then the second argument over here is going to be the data that you need to count on me to copy data into. And then the third argument is that how many

78
00:09:22.950 --> 00:09:29.550
William Cheng: How many bytes of data you want to, you want to get copies of this buffer. OK. So the third argument here is going to be the maximum number of bytes.

79
00:09:29.760 --> 00:09:39.150
William Cheng: Typically is going to get the size of this buffer. So this one is a little weird over here. I say, I only want to read up to 100 bytes for whatever reason, right, it doesn't really matter what the reason is. Just as an example.

80
00:09:39.900 --> 00:09:43.500
William Cheng: Right, so we are going to make the system called right the reader, we're gonna try this out of Colonel

81
00:09:43.680 --> 00:09:49.350
William Cheng: And then in this case the file descriptor over here. I'm going to make sure that this entry over here is done now, right, because it is possible

82
00:09:49.500 --> 00:09:55.830
William Cheng: You know, in between you close the file or something like that. So, so, so why is it found that the other file descriptor entry just using an array index.

83
00:09:56.040 --> 00:10:00.210
William Cheng: Make sure this one doesn't point to a null pointer, then I will follow the logic over here.

84
00:10:00.480 --> 00:10:09.390
William Cheng: Why does that get into the fall object. How do I read data from the desk. So again, the virtual person doesn't know what to do. So all it will need to do is to use the file object. There's a real function pointer.

85
00:10:09.570 --> 00:10:13.710
William Cheng: You go through the reef function over here and then the actual file system will do the reading for you.

86
00:10:13.980 --> 00:10:21.360
William Cheng: Right. So what would the actual file system do it right the actual busting them over here will take them off on this and then copy into this buffer in the user space.

87
00:10:21.870 --> 00:10:28.620
William Cheng: Okay. How does it do that why it's a lot of work to get that done. So while you're working on your kernel three you can actually sort of figure out exactly how this is done. Okay.

88
00:10:29.280 --> 00:10:32.580
William Cheng: Alright, so now I'm just gonna assume that some magic is going to happen eventually data.

89
00:10:32.850 --> 00:10:41.610
William Cheng: Transfer over here and the return value is going to be the number of bytes. I get copied into this this buffer. So in this case, the number of bytes over here has to be less than or equal to 100 bytes.

90
00:10:42.060 --> 00:10:46.080
William Cheng: Okay, if it goes over here, we only asked it to read the maximum 100 bytes there.

91
00:10:46.740 --> 00:10:51.720
William Cheng: So, so in this case it will return to you. And then, then what you can do is that, and also read before we turn over here.

92
00:10:51.840 --> 00:10:59.910
William Cheng: Inside of our agenda, we need to update the cursor position right so so let's say you return 51 or something like that. So in this case, of course, the position is going to be 51

93
00:11:00.090 --> 00:11:06.690
William Cheng: So next time. Will you try to read it again. Now we're going to start reading from fall offset 51 and then start reading the next so many number of bytes.

94
00:11:07.470 --> 00:11:12.360
William Cheng: OK. So again, this example, we're, we're only read was The next time over here. We're going to call close

95
00:11:12.570 --> 00:11:21.030
William Cheng: When we close close over, you're going to get troubles that option. Is this a use the star descriptor as an array index over here. And then what we need to do is that we need to change this into a null pointer.

96
00:11:21.900 --> 00:11:27.090
William Cheng: Okay, so remember the fall logic has a reference count. So when you remove a pointer to the fallout. Do you have a detriment the reference

97
00:11:27.570 --> 00:11:37.800
William Cheng: In the reference on go to zero, you can actually destroy all these things right. If the reference count doesn't go to zero, that means that there's something else inside the operating system still using this fall. Why, in that case, you leave it alone.

98
00:11:38.550 --> 00:11:44.760
William Cheng: OK. So again, we're going to use reference counting mechanism inside the colonel to determine whether an object can be free or not. Yeah.

99
00:11:46.230 --> 00:11:54.510
William Cheng: Alright, so we're here you know here says, you know, so one thing that has happened is, is that when you close the file descriptor this pretty good answers over here is going to be zero and that is going to point to know

100
00:11:54.660 --> 00:12:02.640
William Cheng: And now you can reuse it. And in this example over here the file object, the reference Congress still bigger than zero, so therefore going to keep it around inside the cardinal alright

101
00:12:07.590 --> 00:12:11.310
William Cheng: Alright, so the bomber jacket and not not the advocate a good reference cards because zero

102
00:12:13.410 --> 00:12:20.700
William Cheng: So, so that's sort of a quick review of what happened inside the file system, will you make open system called followed by read and then followed by close. Yeah.

103
00:12:21.390 --> 00:12:29.490
William Cheng: Alright so what. So what's important to remember is that, you know, when over here. So, so as I mentioned this, you know, every call to open

104
00:12:30.210 --> 00:12:43.200
William Cheng: Yeah, whenever you call open it will create a new entry in the file in this is about about table. Another way to say is that every time we open a return successfully he will create a new file object.

105
00:12:44.250 --> 00:12:49.920
William Cheng: Okay, so that's just the way Unix and Linux implement this, you know. So whenever you call open. They never share an existing

106
00:12:50.610 --> 00:12:57.510
William Cheng: Is in the file object, it always create a new one. Right. So when he creates a new I the reference code is going to equal to one, two Christmases you're going to be able to zero.

107
00:12:57.720 --> 00:13:03.930
William Cheng: And then, you know, however you open the file that goes into file access and then the, the, I know pointers or the point you know i put upon the rest of the way.

108
00:13:04.620 --> 00:13:08.400
William Cheng: OK. So again, these are the things that happened at the virtual file system level right

109
00:13:08.760 --> 00:13:18.330
William Cheng: Alright, so let's take a look at these example to see what the, what would the Fallen code do I'll be here. So what I will do is I will, I will, for coffee shop process. Right. So the code over here is going to be executed a child process.

110
00:13:18.510 --> 00:13:23.190
William Cheng: The parent over here. Continue right here. So the parent typically what we'll do is that a wave, which are process to die.

111
00:13:23.520 --> 00:13:31.260
William Cheng: Yeah. So in this case, what would a child processes do right the child classes will close by the script or one and close out this script or two. So now the trial process will

112
00:13:31.860 --> 00:13:37.260
William Cheng: Only zero entry zero be he'll be back all the other one, the one and two over here. They're all pointed out.

113
00:13:38.010 --> 00:13:43.410
William Cheng: There. And then what it will do that will make the open system calls. So this one I'm going to call it you know home slash species.

114
00:13:43.710 --> 00:13:51.720
William Cheng: Output. I'm going to open this for right only because I know that, you know, according to the rule of allocating file descriptor. When I call open successfully.

115
00:13:52.260 --> 00:13:58.950
William Cheng: The return value over here has to be able to walk right because that will be the first entry over there that's available and next time when I call open the second time over here the return

116
00:13:59.580 --> 00:14:12.300
William Cheng: Again to to be to that. So in this case, the first argument over here. They are both the same file. So what I'm doing over here is I'm redirecting both the standard standard output and standard error to the same file.

117
00:14:13.440 --> 00:14:16.110
William Cheng: Yeah. So in this case, you know, from from this point on,

118
00:14:16.320 --> 00:14:24.750
William Cheng: If I, if I secure program over here for the program needs to write to standard out. Where would it go right it will go to file descriptor one would just a home site. He says, I'll put

119
00:14:24.930 --> 00:14:30.660
William Cheng: When he tried to print an error message board ago why it's called to standard error over here, they naturally will go to exactly the same file.

120
00:14:31.260 --> 00:14:40.020
William Cheng: Okay, so, so if that's what you want that this is the kind of code that you will. Right. Right. But we need to understand exactly what you're getting. Okay, so let's sort of all, you know, draw a picture like this.

121
00:14:40.890 --> 00:14:42.840
William Cheng: So after we execute closer and closer one

122
00:14:43.050 --> 00:14:53.100
William Cheng: This one become a no entry and this will be kind of nice entry. And now what we call open over here. I went to their new file object and then going to allocate the first available entry will be here to pointed out why. So when we're done. It will look like this.

123
00:14:53.880 --> 00:14:57.780
William Cheng: Okay, so in this case the file descriptor number one over here will point to this fall. I just

124
00:14:58.380 --> 00:15:05.100
William Cheng: Pointed this file descriptor will be an array index into this hard scripted table. And then over here we have a file object pointers all point to the object.

125
00:15:05.310 --> 00:15:13.830
William Cheng: reference counting go to zero the world we open the file. We're going to copy this information over here into into the demo right here. So, this one will remember how this was open.

126
00:15:14.040 --> 00:15:19.260
William Cheng: Right, and then the cursor position is reset to zero. And then the I know point is over here. And where does the point to

127
00:15:19.530 --> 00:15:29.220
William Cheng: Where is it again. It points to the actual process there. But we know that, you know, if you follow the pointer. You have to keep following the partner. Eventually this I know partner will point to slash home site species are y'all put

128
00:15:29.730 --> 00:15:37.140
William Cheng: Okay, however, that's do that at the virtual classes that we don't know how that's done right. We just trust that the actual file system will build that path to point to that file.

129
00:15:38.250 --> 00:15:46.410
William Cheng: So continue to execute a second function call over here. So I'm going to call open exactly the same arguments over here. Every time we call open, we're going to end up with a new file object over here.

130
00:15:46.680 --> 00:15:56.250
William Cheng: Okay, so again the file object reference call equals zero, the mode over here will be the same thing location will be zero. And now the return of the script over here. Be equal to two. And then this point, at what point right here.

131
00:15:57.330 --> 00:16:05.340
William Cheng: That so they will look like this. Okay, so this object. And these are these are two different far larger. What about the I know pointer to day point to the same thing.

132
00:16:06.600 --> 00:16:12.210
William Cheng: Okay, well, we know that this one points into the actual process. And when it points to the actual Wasilla in today's show the same pointer.

133
00:16:12.690 --> 00:16:24.150
William Cheng: What we don't know that depends on the implementation of the actual process them right because at the virtual bosses and I'm over here, we have no idea how the actual file system works. We just know that if we if we have a real function pointer. We call the function, everything will

134
00:16:25.200 --> 00:16:31.470
William Cheng: Everything will work just fine. Okay, so we're going to trust that those kind of function. The function pointer works. So, India, we know that, you know,

135
00:16:32.160 --> 00:16:43.020
William Cheng: Maybe this one will eventually wanted this file this pointer over here, eventually they will also point to the same file. So at the beginning they started at different point at some point they're gonna start doing to merge and then in the end it will point to the same thing.

136
00:16:43.590 --> 00:16:48.090
William Cheng: Okay, exactly where they merged. We have no idea because we don't know how the actual file system is doing this.

137
00:16:48.660 --> 00:16:57.300
William Cheng: OK. So again, don't assume anything about the actual file system. At this time, but this part over here since is the virtue of us that we know we're learning how the virtual POS system work. Okay.

138
00:16:57.540 --> 00:17:06.000
William Cheng: Every time he kept hoping you get a brand new file object that's just the rule that right. So this guy's gonna start writing your program. Right. So, for example,

139
00:17:07.230 --> 00:17:14.760
William Cheng: The child classes over here at a program where this whole process over here right 100 points to standard out. Okay, so what you wrote was a bystander. I

140
00:17:15.090 --> 00:17:19.980
William Cheng: Guess standard always file descriptor one over here. So now this picture over here against the Charles

141
00:17:20.520 --> 00:17:32.340
William Cheng: Space over here so far descriptor number one over here, you're going to write this one. So the way that you perform the you know the the right function, I will you pass that information to the actual process that you need to pass the current, current position.

142
00:17:32.820 --> 00:17:37.020
William Cheng: Right, because what you do is that you, you know, writing the data to the, you know, to, to that particular file.

143
00:17:37.590 --> 00:17:42.660
William Cheng: You know, so what do we need to do is that you need to tell the actual of us is that, where do you start where do you start writing

144
00:17:43.320 --> 00:17:52.350
William Cheng: Okay, so, so, so, you know, the, the, the file can be a really, really big file. Right. Do you want to start from the beginning, do you want to start from here we're going to start writing data. So that's called the cursor position.

145
00:17:52.830 --> 00:18:02.490
William Cheng: Okay, so what do we do is that you will Kurt you'll take the fall location over here also the curses you pass it into the actual file system. So the actual file system over here well right 100 bytes over here into this file.

146
00:18:04.020 --> 00:18:08.940
William Cheng: Okay, so now what do we do, is that whenever he turns over here it's going to return the number of bytes address. And so let's assume that

147
00:18:09.060 --> 00:18:18.420
William Cheng: 100 bytes has been written over here. So when this one is done this location is going to get modified to become 100 so next time, will you call it the racism call again it will start writing at location 100

148
00:18:19.770 --> 00:18:26.340
William Cheng: Okay, so that's why we need to remember the cursor position because when you try to write you continue from where you left off, right, because that's part of the context.

149
00:18:26.580 --> 00:18:35.340
William Cheng: Of your program you know where you are writing you know inside a particular file. Okay. All right. But what if the next time over here. You don't want you to, you know, right, to say, what do you think righteous standard error.

150
00:18:36.480 --> 00:18:39.600
William Cheng: Okay, if you're ready to stand there again, you know, the racism cause pretty dumb.

151
00:18:39.840 --> 00:18:48.360
William Cheng: Right you spot the script or two over here. We're gonna follow the ponder over here. We're going to take the offset zero here, pass it to the actual processor. So we're, we're going to end up writing the error message.

152
00:18:48.750 --> 00:18:56.520
William Cheng: Well, the error message is going to hear a star ready and memory. Look, the signing a fall off zero. So we're going to end our wiping out some of the data we have written out

153
00:18:57.870 --> 00:19:07.770
William Cheng: To the file that. So, therefore, when you call. So, so why is the location will be become 100 but you know the file the cursor position for for the other file object is still seeing a zero.

154
00:19:08.580 --> 00:19:16.710
William Cheng: Okay, so therefore, when you write to file descriptor to over here we're going to end up wifey me out that wiping out the data that you have written previously, is that OK.

155
00:19:17.730 --> 00:19:23.070
William Cheng: OK, so if that's what you want. And that's okay. But if that's not what you want. The ratio code this way. Okay. So as it turns out that

156
00:19:23.370 --> 00:19:26.340
William Cheng: The reason this behave this way is because of the way we roll our code.

157
00:19:26.610 --> 00:19:31.710
William Cheng: That the organism, just follow your instructions. If you say you know when you tried to write your standard standard error.

158
00:19:31.920 --> 00:19:39.540
William Cheng: You want to wipe out that the data instead of out. What know you write the code you as the auspices of to execute call like that. What they will do that for you.

159
00:19:40.350 --> 00:19:47.700
William Cheng: Know that so so if you don't want this to happen. What should you do right what you should do is I, you should you should be what you want is that you want to be able to share the same file object.

160
00:19:48.000 --> 00:19:58.650
William Cheng: You understand that are in the sense in the air to share the same file object. So in this case, once you finish writing 100 bytes of data into the file and next time. If you read the standard error, you want to start fo offset 100

161
00:19:59.490 --> 00:20:08.280
William Cheng: Again, so the only way to do it is for them to share the same project, right. So in this case you should not call open twice because every time you call obey you get a brand new file object.

162
00:20:09.600 --> 00:20:10.560
William Cheng: So, therefore, what should you do

163
00:20:10.830 --> 00:20:17.910
William Cheng: We go. We're going to learn a new this new system call. So we're gonna still do the same thing. I'm going to close one close to over here. Then we're going to do open wise, we're going to get a new file object.

164
00:20:18.090 --> 00:20:21.480
William Cheng: And then the next system call over here to tell us to share a file object.

165
00:20:21.960 --> 00:20:28.980
William Cheng: Okay, the name of the system called is called dupe. Okay, so do what we're here to say that I want to share file descriptor. Number one, and give me a

166
00:20:29.310 --> 00:20:34.080
William Cheng: Give me another new file descriptor again. How do you allocate a new file descriptor. I will follow exactly the same rule.

167
00:20:34.350 --> 00:20:37.200
William Cheng: We go to the file descriptor type of find the first entry is going to be

168
00:20:37.500 --> 00:20:43.860
William Cheng: That's available. So in this case we are we're using while we're using zero. So, therefore, the next available entry over here is equal to two.

169
00:20:44.070 --> 00:20:50.520
William Cheng: And then we're going to share a file descriptor one and two over here and they will point to the St. Paul object. Yeah. So the picture look like this.

170
00:20:51.210 --> 00:20:59.430
William Cheng: Because, again, we closed one and close to these tools to become null pointer. So when we call open, we're going to create a new file. I've never saw that before. And that's exactly what happened is before

171
00:20:59.610 --> 00:21:05.250
William Cheng: So now we call dupe right so. So again, what we do is that we're going to make a duplicate of our, you know,

172
00:21:05.850 --> 00:21:12.780
William Cheng: We're gonna make a duplicate of file descriptor one into the new file descriptors. Okay, I'm going to come down this file descriptor tab over here.

173
00:21:12.990 --> 00:21:22.860
William Cheng: Find the first entry that's available that will be file descriptor to right here and then this one will be sharing the same a follow up debt as file descriptor one right so they will going to point to that one like this, right.

174
00:21:23.070 --> 00:21:28.590
William Cheng: And now we need to change the reference gotta go to to because now we have two pointer pointing to exactly the same object.

175
00:21:28.980 --> 00:21:39.060
William Cheng: That so we're done. It will look like this. They thought the script for one and two, both of them share the same file object over here. So when you try to perform I write operation for 100 bytes. So I using standard

176
00:21:39.780 --> 00:21:42.990
William Cheng: When you finished writing it. The follow up cursor position will be equal to 100

177
00:21:43.170 --> 00:21:53.010
William Cheng: And next time when you try to write your standard error when this guy is, again, we're going to pass the cursor position of 100 into the actual process. Now, so therefore the error message will appear after the first 100

178
00:21:54.090 --> 00:22:02.670
William Cheng: OK. So again, if that's what you want. You were like, whoa, like this, but if you prefer the previous behavior that you will open the file twice, you get the ZTE how you want to write your code.

179
00:22:03.090 --> 00:22:14.130
William Cheng: Okay. Both ways are correct. Okay. But again, your coach should reflect your intention. So you need to express your intention, you know, clearly, your code, right. Otherwise, you know, bad things gonna happen. Yeah.

180
00:22:18.480 --> 00:22:25.110
William Cheng: All right. There are also other you know tube system call. I think there's a dupe too. I also think there's a dupe three still got a few

181
00:22:25.560 --> 00:22:30.420
William Cheng: So when you're doing your kernel to assignment. If you see a function that you have never seen before, that you have to implement

182
00:22:30.600 --> 00:22:43.410
William Cheng: All you need to do is look at the man pages on the next right. So in this case, if you don't know what to to as you say man do to right and then read the man is very carefully to understand, you know what, what should be the behavior or that you have to implement

183
00:22:44.400 --> 00:22:49.620
William Cheng: OK. So again, you know, if it's Colonel to you should read the comment blog and all that kind of stuff. Yeah. All right.

184
00:22:51.480 --> 00:22:59.460
William Cheng: Okay, so, so, so over here says you know what, if you actually, you know, allocate a file descriptor entropy for the fork.

185
00:23:00.000 --> 00:23:04.290
William Cheng: Okay. So in this example, we call for quite hear it but right before we actually will open a file.

186
00:23:05.280 --> 00:23:14.400
William Cheng: Okay, so again, you know, the fallout data is inside. Inside the current also therefore they're sort of considered to be part of your extended address pay they keep track up the you know the

187
00:23:14.730 --> 00:23:18.030
William Cheng: The open for state for you, right, what is the current position, all that kind of stuff.

188
00:23:18.450 --> 00:23:24.330
William Cheng: Okay. So in this case, once you you know so so well. Well, once you open the file And now we mentioned before.

189
00:23:24.600 --> 00:23:30.450
William Cheng: The extent that address space survive the exact the exact address space also survived fork mess. Oh yeah, well, you

190
00:23:30.690 --> 00:23:40.560
William Cheng: When you make the fourth system call you make a copy. You are you taking a parent process and you you create a child process and the child process gets a copy of the address space.

191
00:23:41.010 --> 00:23:50.460
William Cheng: We're guys. But again, I'd be very, very careful to say that the child get a copy of the address space. I didn't really say exactly what happened to the extended address me as it turns out, you're sharing the extended address space.

192
00:23:51.150 --> 00:24:03.030
William Cheng: Yeah, so therefore once we open a file, you know, and they said, we remember we remember that instead extended I guess phase. Now, when we perform a phone system call. Well, then in that case the child. The child will share the parents extended outer space. Yeah.

193
00:24:03.630 --> 00:24:10.260
William Cheng: So the pictures don't look like this is over here again the code over here that is I'm going to open up all over here. So at the beginning. We all have the parents address space over here.

194
00:24:10.440 --> 00:24:14.340
William Cheng: The parents executing this code, we try to open the fall. We're going to quit and you'll follow me here.

195
00:24:14.730 --> 00:24:28.110
William Cheng: Despise going to call log. It's right only. So we're going to allocate this entry over here 012 345-501-2345. This is number five over here. So in this case, log file over here will be equal to five.

196
00:24:28.440 --> 00:24:34.110
William Cheng: Okay, so we're going to allocate a new file object over here. I'm going to point to it. So this will be gone. So we're done. It will look like this.

197
00:24:35.250 --> 00:24:39.210
William Cheng: So long time over here will be equal to five. Okay, so now we're going to go

198
00:24:39.720 --> 00:24:43.200
William Cheng: We're going to fork over child process when we for carpet tile process. We're gonna say

199
00:24:43.410 --> 00:24:54.390
William Cheng: When I create an address space for the child again by copy the parent address space. So when you copy the paragraph spaces. The child is a child log file is also global and local variable and this will be equal to five.

200
00:24:54.780 --> 00:25:03.150
William Cheng: Okay, and then every process has their own file descriptor table, right. So, therefore, you know, the child processes over here also has a file descriptor tables. In this case, what we'll do is

201
00:25:03.450 --> 00:25:07.470
William Cheng: We'll take the parents file descriptor table will make a copy into the child file descriptor table.

202
00:25:07.650 --> 00:25:15.360
William Cheng: When you copy pointer and they point to the same place. So in the fifth entries over here. We also got appointed this object. And now the reference count over here. It's going to be equal to two.

203
00:25:16.440 --> 00:25:21.150
William Cheng: Okay, so what this operation is done right, it will look like this. Okay, so, so, so

204
00:25:22.080 --> 00:25:28.140
William Cheng: So in this case, once we're finished the fork over here, then you know he's not a colonel, it will it will look like this.

205
00:25:28.350 --> 00:25:36.990
William Cheng: And now we see two different ways for the reference, how to go to to write. One way is for you to make a dupe system call and the other way is that when you forgot the trial process.

206
00:25:37.200 --> 00:25:46.500
William Cheng: So when we create the file before you do the fork and at the time when you do a fork and now you know the small object that will have a reference column bigger they will be there equal a bigger than one.

207
00:25:47.580 --> 00:25:54.150
William Cheng: That is an example over here at the parent over here is going to write to the log file, right. So again, how does the parent right to the log file or unlawful.

208
00:25:54.360 --> 00:26:04.320
William Cheng: equals to five you'll follow this pointer over here and then you will pass the cursor position over here into the actual file system. And so that's it over here. You, you, you write 100 bytes right when this

209
00:26:04.830 --> 00:26:09.780
William Cheng: Is done successfully, you know, the cursor location over here is going to be equal to 100

210
00:26:10.350 --> 00:26:21.210
William Cheng: Okay, so what if the child also want to run right to the same file the channel also tried to write to file descriptor number five over here. Why, in that case, again, it will start writing and cursor position 100. Okay. Is that what you want.

211
00:26:22.290 --> 00:26:25.410
William Cheng: Okay, so if that's what you want. They'll be fine for these two processes.

212
00:26:26.790 --> 00:26:35.430
William Cheng: To share this file object. So sharing. So every dangerous, right, it is possible that a parent and a child they try to write it as far as exactly the same time on in that case.

213
00:26:35.610 --> 00:26:41.160
William Cheng: That behavior is going to be unpredictable. Right. Or if the parent or the child tried to one tried to read on one side, right.

214
00:26:41.340 --> 00:26:48.420
William Cheng: Oh, when they try to read at the same time you one of the finishes early over here, then he will update the cursor position. One of the other processes will read from a different place.

215
00:26:49.320 --> 00:26:58.230
William Cheng: Okay, so this kind of sharing over here. Again, it's very, very dangerous. So this is, this is kind of behavior that you want. That's perfect. Right. Yeah. But otherwise, if it's not, then you shouldn't read your code this way.

216
00:26:59.070 --> 00:27:04.830
William Cheng: Okay, so, so, so one. So what, why would somebody want to do that. Right. So maybe the long side over here. Maybe the parent and a child wants

217
00:27:05.220 --> 00:27:12.960
William Cheng: To share file. So let's say here's a follow on the desk over here called log file. So that's it. The parent always right to the first part of the file and the chart over here, right. The second part of our

218
00:27:13.110 --> 00:27:18.210
William Cheng: So in that case, maybe there's a way for the parent and child to communicate by writing data to a shared file.

219
00:27:18.900 --> 00:27:25.560
William Cheng: Guys, because right now when you do things like this. The log file here, become a shared file. Okay, so the question is that, you know, is this a really good idea.

220
00:27:25.950 --> 00:27:35.940
William Cheng: Okay, we haven't really talked about to process it. How do they actually you know coordinate with each other so they can share a file so far in fifth edition Unix. There's no way for them to actually share a file share file nicely.

221
00:27:36.810 --> 00:27:42.330
William Cheng: Okay, so in that case, when both of them try to you know update a cursor position at the same time, bad things might happen.

222
00:27:43.140 --> 00:27:50.280
William Cheng: Okay, so what will be the right way for the parent of a child they tried to sort of communicate with each other. Okay, so there's one way to do it. And that's what we're going to look at next.

223
00:27:51.090 --> 00:27:58.380
William Cheng: Is over here. So, so that the parent child process can communicate using such as share file descriptor, although it's difficult to synchronize that

224
00:27:58.950 --> 00:28:07.620
William Cheng: Okay, so they're going to end up sharing the cursor position. And once you, you know, read or write from a file. The person has us going to change. So the other process is going to pick up the current

225
00:28:07.860 --> 00:28:16.620
William Cheng: Value of the cursor position. So in that case, it can be really bad. Okay. All right. So one way to do it for the to process to communicate is to use a Unix pipe.

226
00:28:17.070 --> 00:28:27.810
William Cheng: Okay, so a pipe is a means for one process to send data to another process directly as we are right into a file. So how do you do as it were writing to a bar or use a file descriptor.

227
00:28:28.080 --> 00:28:31.590
William Cheng: You could use a file descriptor right we use the file descriptor, you're going to write to the file.

228
00:28:32.010 --> 00:28:36.390
William Cheng: So here's an example or whatever. You know what a pipeline guy so so again it's like a water pipe.

229
00:28:36.810 --> 00:28:44.850
William Cheng: Okay, you have one process over here. And so it's a standard process, it will, right, to the right end of the pipe another process over here will read from the region at the pipe.

230
00:28:45.060 --> 00:28:49.320
William Cheng: Right, so this end of the part over here is write only and this end of the pioneers read only.

231
00:28:49.800 --> 00:28:54.690
William Cheng: Okay, so you have two processes they attached to a different end of the pipe and now they can communicate with each other.

232
00:28:55.110 --> 00:29:03.270
William Cheng: Okay, the pipe is a uni directional object over here. So one process over here. We're right, to the right and and the other one will refund the reader. So how do you implement a pipe.

233
00:29:04.320 --> 00:29:08.520
William Cheng: While you actually already know that how to do that you use a producer consumer problem.

234
00:29:09.960 --> 00:29:12.330
William Cheng: Right, so, you know, this will be the producer right and this will be the come

235
00:29:13.350 --> 00:29:18.780
William Cheng: Over to this is the producer. This will be the consumer. So you already see the CO how to implement a Unix pipe.

236
00:29:19.350 --> 00:29:26.580
William Cheng: Okay, so, yeah, we can use a finite buffer right and then we'll use a conveyor belt or something like that. And this way you know one process could right and then the other.

237
00:29:26.730 --> 00:29:33.840
William Cheng: One can read. You can read it in parallel. And right in parallel, right, or if they're writing and reading on the same spot. Well, in that case, one process has to wait, yeah.

238
00:29:35.730 --> 00:29:42.600
William Cheng: So the way you create a pipe pipe is an object inside a corner and now we notice a producing consumer is the instance of producing consumer problem.

239
00:29:42.990 --> 00:29:55.050
William Cheng: So how do you create a pipe things out of Colonel, there's a system called for you to create a pipe and you know the the system called, it's called pipe. What do you will do is that this function will return to you to file descriptor one for writing to the pipe at the animal for reading

240
00:29:56.430 --> 00:29:59.250
William Cheng: Reading from the type of so therefore the code will look like this.

241
00:30:00.060 --> 00:30:10.650
William Cheng: That. So what we'll do is that you first you need to, you know, allocate to your two integers ones to receive the file descriptor for the reason that the pipe and the other ones for receiving the

242
00:30:11.130 --> 00:30:20.820
William Cheng: file descriptor for the right of the pie. Okay. So this guy is going to declare two integers over here, right. So the these two into one will be referred to SP zero the edible will be referred to the PS1.

243
00:30:21.180 --> 00:30:27.240
William Cheng: Po boy. So that's why it's a real to part two integers over here and I'm going to pass this array to the pipes are some call

244
00:30:27.540 --> 00:30:38.640
William Cheng: Okay, when this function returns success will be against you read them and paste. By now, how to determine whether it's successful or not what this function returns successfully PR zero will refer to the end of the pipe.

245
00:30:39.480 --> 00:30:47.280
William Cheng: Guys, again, I'm Pilate one over here, referred to the right end of the pipe. OK. So the way I remember is that, you know, again, if you remember the standard file descriptor.

246
00:30:47.640 --> 00:30:54.360
William Cheng: file descriptor zero is standard in for the script or one and two are for output as a zero is for reading and one and two is for writing

247
00:30:54.750 --> 00:31:04.980
William Cheng: Okay, so therefore PR zero is were reading and Peter, what is for writing. Okay, so that's how I can memorize it. So can you try to do things consistently. So this way, it makes it easier to remember

248
00:31:05.820 --> 00:31:12.630
William Cheng: Right. So what we do is, I'm going to create a pipe have things that are Colonel, and then I'm going to create a child process. And now we're going to have the parent

249
00:31:13.020 --> 00:31:16.440
William Cheng: Connect to the right end of the pie, while the child connect to the other to read and

250
00:31:16.920 --> 00:31:21.690
William Cheng: Write how to actually set up this connection right this cut over here was to show you how to do that. So over here.

251
00:31:21.990 --> 00:31:26.310
William Cheng: You know, we're going to call forth. So this is the code for the child. And then this is the Copa the parent

252
00:31:26.550 --> 00:31:33.270
William Cheng: OK, so the chart over here, we're gonna we're going to read from the pipe over here. So what we need to do is that we need to actually close the right end of the pipe.

253
00:31:33.810 --> 00:31:40.530
William Cheng: Very good child only want to read from it. If you don't close this, the run of the pipe, you know, as it turns out that you're going to get weird things happening is that a carnal.

254
00:31:40.980 --> 00:31:43.920
William Cheng: Says every this case you're required to close it right into the pipe.

255
00:31:44.160 --> 00:31:49.050
William Cheng: Yeah, so you close rather the parable here. And then what you would do is that you will read from the region of the pie.

256
00:31:49.170 --> 00:32:00.090
William Cheng: So we here. There's an infinitely what we hear a while read from the buffer over here and the size of Buffalo be good at. So he can keep writing commands on the parent one command at a time. So we're gonna assume that every command is less than 80 characters.

257
00:32:00.780 --> 00:32:09.180
William Cheng: So guys, are we here, we can actually lead to come out on the parent over here. So at the beginning, the parent hasn't, you know, written any commands through to the chakras. So in this case, the racism whole block.

258
00:32:09.540 --> 00:32:13.440
William Cheng: Right, so again it blocked because we have a producer consumer problem. Yeah.

259
00:32:14.100 --> 00:32:21.420
William Cheng: Right, what would the parent, the parent over here. What are those are the parent on these, right, to the right of the pie. So therefore, the parent needs to close the beat of the pie.

260
00:32:21.660 --> 00:32:30.540
William Cheng: At the bottom of the pile here is going to be p zero. So there was one called P zero right here. And then what we'll do is we'll go through an infinite loop over here, it would generate data to

261
00:32:30.900 --> 00:32:39.930
William Cheng: Generate commands with a child process. And then he will perform the right operation to right into the right end of the pipe and then this way, you know, the child can receive data for reading from the readout pipe.

262
00:32:41.040 --> 00:32:45.840
William Cheng: Or as this case. Now the parent and a child can communicate with each other, you know, through this way. But, you know,

263
00:32:46.110 --> 00:32:52.830
William Cheng: Most of communication, only the parent can send a command to the child and there's no way for the child to extend a result back to the parent

264
00:32:53.070 --> 00:32:59.370
William Cheng: So how do you say resolve on the phone for the job back to the parent, you need to create a second pipe. Okay. So, therefore, you know, again, the pipe is

265
00:32:59.970 --> 00:33:07.800
William Cheng: Uni directional. So only goes one ways and this example it go from the parent to child if you want the child to send data back to the parent. All you have to do is create another pipe.

266
00:33:08.190 --> 00:33:19.470
William Cheng: Yeah. Alright. So let's see, you know, at this example. What happened is that the current all that. So again, you make the pipe system call we finished making a pipe system call over here PR zero over here, it's gonna

267
00:33:21.510 --> 00:33:25.650
William Cheng: It's gonna correspond to the reading of the pipe and Peele one over here is going to correspond to the right.

268
00:33:26.250 --> 00:33:33.720
William Cheng: Now, so this guy's, what would this look like, right. So this is the example that we see over here. This is 0123 and four.

269
00:33:34.320 --> 00:33:39.000
William Cheng: So in this case, again, when we tried to allocate a file descriptor table over here. We're going to allocate using the same rule.

270
00:33:39.210 --> 00:33:42.180
William Cheng: Go down there at the file descriptor table, find the first entry that

271
00:33:42.390 --> 00:33:52.140
William Cheng: It's available at this time, we only have the parent process because we have called forget. So inside a parent address space over here P of zero with this function return is going to be equal to three.

272
00:33:52.350 --> 00:34:04.620
William Cheng: And then p one over here is going to be reject equals two, four. Okay, and then again three is going to be the the the return of the pipe because file descriptor zero is for reading. So, so if this is a weed out of the park over here. Then we're going to read from here.

273
00:34:05.370 --> 00:34:08.340
William Cheng: If this is the right of the park. Then we're going to sort of right like like this.

274
00:34:08.730 --> 00:34:17.850
William Cheng: Okay, I can't remember which way that I saw the picture of your eyes. Okay, is the p zero P is going to vote for reading over here. So, it will be attached to this end of the pipe and PR one over the orientation of the sentence.

275
00:34:20.100 --> 00:34:22.830
William Cheng: Okay. So at this point I can you actually talk to yourself.

276
00:34:23.100 --> 00:34:30.840
William Cheng: You can actually talk to yourself. Right. So if you if you right to the relevant to the pipe over here, you can actually read the real answer this case, you can actually read the data, you said to yourself that

277
00:34:31.230 --> 00:34:37.470
William Cheng: But our goal here is for the parent to child so to communicate. So at this point, we're going to for coffee child processor. So if you're going to call forth

278
00:34:37.710 --> 00:34:44.910
William Cheng: When we finish, you know, the Chopra says over here. I said address space is that child will get a copy of the variable we here is a p zero is going to appeal one

279
00:34:45.120 --> 00:34:52.380
William Cheng: What is P zero P AMP z is going to be a silly quarter three MP or well here, equal to four. Right. So if your child process over here. Again, it says on

280
00:34:53.820 --> 00:35:01.890
William Cheng: The top lessons over here get its own file descriptor table. We're going to copy over here where we copy the pointer. They point to the same place. So therefore, the

281
00:35:02.130 --> 00:35:08.790
William Cheng: Return of the pipe over here also go to file descriptor three right here and the writer of the pipe over here also go to file descriptor for

282
00:35:10.080 --> 00:35:21.660
William Cheng: Okay, so when we finished making the fourth system card, it will look like this in the kernel guys okay the char address space over here is the copy of the pair, we get a copy of the the the the

283
00:35:22.470 --> 00:35:35.070
William Cheng: The, the file descriptor table. So therefore, we are sharing, you know, the return of the pilot will be here. Both of them goes to, you know, a file descriptor entry number three. And we also sharing the right into the pipe and they will go to file descriptor. Number four.

284
00:35:36.150 --> 00:35:44.520
William Cheng: That's what again when you when you copy you know will will copy point and they point to the same place. Okay. Over here, there's a file object over here, there's

285
00:35:44.790 --> 00:35:51.900
William Cheng: Another file object, the file descriptor the table of your points with objects and these fell off jack represent different ends of the different ends of the pipe.

286
00:35:52.860 --> 00:36:00.540
William Cheng: OK. So again, the pipe itself is implemented in a producer consumer problem. And now we use file descriptor to actually to to access data that

287
00:36:02.310 --> 00:36:16.530
William Cheng: Oh, I am so, so, so there was what we're gonna do right inside the chakras. So we are going to close PR one. How do you close to one there. So Peter, what is right here is equal to fall. I'm going to close file descriptor entry over here for number four. So, this one will point to now.

288
00:36:17.670 --> 00:36:23.880
William Cheng: Okay, so. So this guy's when we're done with that it will look like this. Are we here at this, this one will pointing all over here, this entry is gone over here.

289
00:36:24.150 --> 00:36:35.190
William Cheng: And at the same time what the parent will do is that they will close p zero P of zeros file descriptor three over here. So we're going to turn this one to another pointer and then this will not pointed that anymore. So we're done with it will look like this.

290
00:36:35.730 --> 00:36:43.680
William Cheng: Okay, so now you can see that there's a path on the parent of the child, the path that we've the parent right to file descriptor one over here is going to going to the right of the park.

291
00:36:43.890 --> 00:36:48.900
William Cheng: And it can only be read from the reading of the Bible be here and the reading of the pipe is inside the child process.

292
00:36:50.100 --> 00:37:00.120
William Cheng: OK, so now there's a path as gay established from the parents into child. Right. So when this point on, you know, the parent over here can call. Right, right, right, right, right. And the child here called movie me to come up on the path.

293
00:37:01.770 --> 00:37:12.360
William Cheng: Okay, so, so this is how the UNIX prep work. So, you know. So again, you know, if you raise all the other invalid point over here at this will be only path. You can write and then you can read it from here. Yeah.

294
00:37:14.100 --> 00:37:20.970
William Cheng: Alright, so you actually, you saw the piping action your warm up one already. Right. What you want to play. There's a bunch of commands like this card f of

295
00:37:21.450 --> 00:37:30.150
William Cheng: Zero over here and there is a vertical bar, the vertical bar is the UNIX pipe character. Okay, so what it does. Over here is that, you know, again, you're, you're, you're

296
00:37:30.450 --> 00:37:35.760
William Cheng: Logging shot is very, very simple. All it does is every one line at a time. We look for the greater than symbols.

297
00:37:36.180 --> 00:37:40.650
William Cheng: You know, for you know output redirection look for the lesson symbol for input redirection

298
00:37:40.860 --> 00:37:47.460
William Cheng: They also look for the pipe character. If you see the pipe character. It means that on the left hand side over here we're going to run one child process.

299
00:37:47.670 --> 00:37:56.100
William Cheng: On the right hand side, you're going to run a different child process. And we're going to connect the standard output of the first process over here to the standard input of the second process.

300
00:37:56.640 --> 00:38:08.880
William Cheng: Okay, again, the way you connect that it's using a Unix pipe. Right. So this way when the first poll on over here right to standard out. He actually right, to the right end of the pipe. When the second program over here re from standard in a refund the standard

301
00:38:09.900 --> 00:38:10.890
William Cheng: Refund the beat of the pie.

302
00:38:12.750 --> 00:38:19.800
William Cheng: OK, so those of you who run into problems in warm up one, you know, try to sort of treat this as a file. So as it turns out I yeah so so when I

303
00:38:20.070 --> 00:38:26.460
William Cheng: When I run the program dot slash warm up one. So our lesson f0 computer using a Pac Man, there's actually a difference.

304
00:38:27.150 --> 00:38:35.280
William Cheng: OK. So again, if you remember from chapter one. When you do IO redirection over here. We're going to map standard into this particular file. So we're actually we're reading from a file.

305
00:38:36.000 --> 00:38:47.160
William Cheng: Okay, if you use a pipe over here you are using a producer consumer problem. And in this case, we're using a bounded buffer. So, therefore, you know, the buffer, you know, since the buffer is bounded. It can be the same size as a real file.

306
00:38:47.400 --> 00:38:54.120
William Cheng: Okay, so this fall over here. Maybe you know 10 megabytes long over here. What is the size of a pipe. Right. Since we're using producer.

307
00:38:54.570 --> 00:39:01.980
William Cheng: Consumer there's only maybe a few kilobytes over here. So in this case, you know, if you try to write too much data. Well, then the data will disappear from the pipe.

308
00:39:02.550 --> 00:39:12.510
William Cheng: Okay, so therefore the behavior over here is going to be very, very different. Now I'm not going to show you exactly, you know, with the code for doing this. But if you Google, you know, you know how to implement a system.

309
00:39:13.710 --> 00:39:17.280
William Cheng: To connect the standard out of a program to a standard you know program, you're going to find

310
00:39:17.550 --> 00:39:24.330
William Cheng: You know, sort of few lines of code, how to how to do that. Right. So again, it's only a few lines of code because, you know, in the end, you're logging shows very simple

311
00:39:25.140 --> 00:39:33.030
William Cheng: That I also just the last thing I want to sort of talk about the logging shot over here is that, you know, there's another character you can attach to your command line.

312
00:39:33.210 --> 00:39:38.010
William Cheng: And that's the ampersand character. The ampersand character meaning to run this program in the background.

313
00:39:38.490 --> 00:39:46.530
William Cheng: What does it mean to run a program the background all the means, again, running a program. The Badwater over here's why. So you're running a child processes HR process is run independently for the

314
00:39:46.860 --> 00:39:53.520
William Cheng: Hundred pair running in the background. That means that the logging shot over here. Well now wait for the child process to finish before giving the problem.

315
00:39:54.150 --> 00:39:59.610
William Cheng: Okay, so therefore the charge is running in parallel. And now the parent process will give you the prompt so you can type in another command.

316
00:40:00.510 --> 00:40:09.210
William Cheng: Okay so running things in Babylon is actually pretty simple. If you don't have the ampersand character me on mean. It means that you're running this program in the foreground. So what does it mean to run the program.

317
00:40:09.450 --> 00:40:19.890
William Cheng: That means that the parent process will wait for the child to die before it gives another prop. Okay, so that's all that means. So again, this can be implemented very, very, very in a straightforward manner.

318
00:40:21.840 --> 00:40:29.340
William Cheng: Alright, so the next thing I want to talk about is that, you know, there's also, you know, we talked about, you know, open read and write. So those offers sequential I O

319
00:40:29.730 --> 00:40:32.670
William Cheng: There's also another way to access the file is called random access

320
00:40:32.910 --> 00:40:43.680
William Cheng: So in this case, you know, what happened is that, you know, we have a file you want to actually go to access the file at a random location or I mean not use a random location you wanted. You want to sort of jump into the middle of the file and try to access data.

321
00:40:44.190 --> 00:40:47.730
William Cheng: Okay, so for example if you have a fall over here. That's one gigabyte in size.

322
00:40:48.300 --> 00:40:54.180
William Cheng: Okay, and you don't really want to go from the beginning, you know, because the data you want to access over here is actually 500 megabytes into the file.

323
00:40:54.900 --> 00:41:01.500
William Cheng: Okay. So this guy's. What do you want to do is that you want to move your cursor position to 500 megabytes per file and then you want to start reading from there.

324
00:41:02.070 --> 00:41:09.330
William Cheng: Okay, so there's a simple for you to do that. That's simply manipulate the cursor position. Okay, so, so the function of you is called LC

325
00:41:10.800 --> 00:41:18.450
William Cheng: LC function takes three arguments. The first argument says, which file you want to perform the Sikh operation on so again CIF just means change the cursor position.

326
00:41:18.780 --> 00:41:27.300
William Cheng: Okay. And the second one second argument over here is a how much you know how much do you want to me. So this will be the asset. Right. So if you have a cursor position over here you could so

327
00:41:27.600 --> 00:41:36.750
William Cheng: If you want to, you know, sort of move the cursor position forward you put a positive value over here if you want to move the cursor position backwards. You can also do that. So in this case, you can actually use a negative number.

328
00:41:37.080 --> 00:41:47.730
William Cheng: That the third arguments over here can take three different value if it's equal to six set six said that means that we are you know i know this offset needs to be measure from the beginning of the file.

329
00:41:48.390 --> 00:41:53.250
William Cheng: Okay, if this argument over here is see cursor. That means that you know this offset over here will be taken.

330
00:41:53.460 --> 00:42:01.920
William Cheng: Relative to the current cursor position right so if the current position and cause of disease 100 and if you add minus one, two, you're going to end up, you know, say your cursor position to 99

331
00:42:02.610 --> 00:42:11.160
William Cheng: Yeah, the last argument if there are also go here. If it's equal to seek in that in this case you are measuring the offside starting from the end of the file, right. Where's the end of the file.

332
00:42:12.060 --> 00:42:22.230
William Cheng: So for example, if I fall over. Here's 100 bytes law. Okay. That one's by slow, then the file all sudden he's had a fall over here is going to be 0123 all the way to 99

333
00:42:22.950 --> 00:42:27.570
William Cheng: Okay, so if the first 100 days long the opposite. You can use 02222 299

334
00:42:27.780 --> 00:42:35.940
William Cheng: As I mentioned before, in the in the UNIX system. If you want to make a far bigger. All you have to do is to put a cursor position after the end of it, and then you right to it. And now if I become bigger

335
00:42:36.270 --> 00:42:41.760
William Cheng: Okay, but when you try to read from a file, you can only read from the valor, you know, the sort of those

336
00:42:42.930 --> 00:42:51.630
William Cheng: Locations. Okay, so this case when you try to read one of our you can only go from zero to 99 you can never go to negative index over here or anything beyond 99

337
00:42:52.980 --> 00:42:57.960
William Cheng: Or so in this case the secant over here will be equal to the perverse opposition or 100 100

338
00:42:58.170 --> 00:43:07.020
William Cheng: Because that's the end of the far so the end of the file is actually beyond the current end right because the last fight over years 99 so when your cursor position or 99 you are not at the end.

339
00:43:07.740 --> 00:43:15.150
William Cheng: Okay. Only way your cursor position 100 then you're at the end you actually up your copy of the current end of the file. And that's where the Sikh Ennis

340
00:43:15.720 --> 00:43:21.000
William Cheng: Okay, so let's take a look at this call to see what it does. Over here, I'm going to perform a C Corp on this file over here.

341
00:43:21.270 --> 00:43:29.490
William Cheng: See cannot be equal to 100 right and then we subtract from or equal to 99 so now there's no option is that we actually was said. So here's the file object.

342
00:43:30.420 --> 00:43:37.860
William Cheng: That when this function returns successfully. So in this case, the cursor position over here will point to $99 you have the value of 99

343
00:43:39.210 --> 00:43:48.330
William Cheng: Alright, so again, when this function return over here whenever you turn a value that's not equal to negative one, that means that he has returned successfully and now the cursor position has been set to 100 minus once we put in

344
00:43:49.020 --> 00:43:51.660
William Cheng: There. And then what we'll do is always going to stay in an infinite loop.

345
00:43:51.930 --> 00:44:04.080
William Cheng: Well, the return value of yours, not equal to minus y. So that means a sequence successful, what we will do is that will read from the same file one bite into the buffer. So in this case we want to refund. This right over here at, where do we copy into while there's a

346
00:44:04.560 --> 00:44:12.510
William Cheng: There's a buffer data structure over here. We're going to copy this data into this buffer right here. Right. And when we perform the read operation over here. We also a dentist appointment.

347
00:44:12.960 --> 00:44:20.250
William Cheng: Okay, so in this case the reader will return one. So in this case, the cursor is, you know, if you will be 100 will point to beyond the end of the far right now.

348
00:44:20.580 --> 00:44:27.870
William Cheng: Okay, and that's okay to point to beyond the alpha, as long as we don't try to reframe around what we tried to refund the piano. And if I were going to get the end of our condition.

349
00:44:29.010 --> 00:44:38.400
William Cheng: So this card over here we're going to run one we're going to write a standard out. I want to stand out over here, this buffer of one character. So the data that we just read over here. We're going to print it onto the screen.

350
00:44:38.820 --> 00:44:41.220
William Cheng: Okay, so therefore this part over here is, don't go into the screen.

351
00:44:41.730 --> 00:44:46.020
William Cheng: Okay. And then what we do is, I'm going to perform LLC. Right. So getting the same file over here.

352
00:44:46.290 --> 00:44:56.160
William Cheng: Relative to the current cursive buzzer and conquer something go to 100 we're going to subtract two from. So now it's going to be equal to 9898 is going to point to the second path on the end of the file.

353
00:44:56.340 --> 00:44:58.890
William Cheng: And then we're going to go to the beginning of this infinite loop over here.

354
00:44:59.160 --> 00:45:04.560
William Cheng: Right. So this guy is the return value is not equal to minus y. So, therefore, we're going to read one by into the buffer over here.

355
00:45:04.710 --> 00:45:13.800
William Cheng: Going to read this part over here into the buffer. And then we're going to print it out again this fight over here will get displayed over here. So at this point the cursor position will be pointing to 99

356
00:45:14.040 --> 00:45:24.180
William Cheng: Yeah. And then we're going to subtract it from to over here and there will be 197 so to appointed this guy right here we come to the top over here read this data into buffer and then print it out. So what does this program do

357
00:45:24.930 --> 00:45:34.230
William Cheng: Right, this program print this 100 by file in reverse order from the last fight to the first by okay not a very useful program, but he sort of show you that this can be done.

358
00:45:35.040 --> 00:45:41.520
William Cheng: Guys. So eventually, when you go you know when you finish a copy in the first bite the first part over here it says. The Bible says zero

359
00:45:41.700 --> 00:45:49.500
William Cheng: The cursor position over here will be equal to one when you subtract two from it, you will get negative one. And that is going to return an error value and then and then this program will terminate.

360
00:45:50.910 --> 00:45:54.630
William Cheng: OK. So again, you know, please understand, you know, how this actually works. Yeah.

361
00:45:57.570 --> 00:46:07.170
William Cheng: So actually this is this is the same place at the end of lecture 11 from the summer of 2009 so I'm going to stop right here. And next time we're going to see

362
00:46:07.530 --> 00:46:13.650
William Cheng: You know how to how to implement other kinds of file inside of our system so far, we're going to talk about when we talk about a regular file.

363
00:46:14.040 --> 00:46:21.660
William Cheng: So what I was talking about semicolon device right at device just a major device number minus device number. We haven't really talked about how to implement a directory

364
00:46:22.110 --> 00:46:34.560
William Cheng: So next lecture, we're going to see how to implement directory. Right. So again, we're only doing this at the virtual the VM FS level chapter six. We're going to show you how to implement a directory inside the actual VA system that right