CSE2031 lecture 12

SystemCalls

• Check out these books
  
  • Stevens Advanced Programming in the unix Environment
    
  • Robins&Robins – unix systems programming
    
  • 
    
• Processes
  
  • Fork
    
  • Exec….
    

  
   

• Files
  
  • Open
    
  • Close
    
  • Read
    
  • Write
    
  • Lseek
    
  • Dup
    
  • Dup2
    

 

PerProcess file Descriptor table	System wide open file table	I-Nodes
File descriptors	Flags	Disk / device
0	Offset
1	To i-node
2
..

• Write(fd,buf,50)
  
  • Fd
    
    • File descriptor
      
  • Buf
    
    • Void* char
      
  • 50
    
    • #bytes
      
• Write(fd,"Hello",6)
  
  • If this was typed after the first line there would be an offset of 56
    
• Lseek
  
  • Lseek(fd,offset,WHENCE)
    
    • Fd
      
      • File descriptor
        
    • Offset
      
    • WHENCE
      
      • SEEK_SET
        
      • SEEK_CUR
        
      • SEEK_END
        
• Dup
  
  • Duplicates a file descriptor using another file descriptor
    
    • Int dup(int oldfd);
      
    • Int dup2(int oldfd, int newfd)
      
  • Why would you want to do that?
    
    • Because you would never want to do this
      
      • Dup2(fd,1);
        
        • First argument is one you want copied
          
        • Second is what you want it copied on
          
      • Close(fd);
        
      • Printf("hello\n";
        
      • This would write at a file temp
        

int a[15]

 

 

int (*a)[15] /** a is a pointer to an array of 15 ints**/

 

int fd

fd = open("temp", _|_|_, 0660)

/*for the last input '0660' there should always be a leading 0 because it is an octal*/

/*_| represents space for flags*/

 

#define    O_WRONLY    1<<4

    O_TRUNK    1<<2

---------------------------------------

fd = open("temp", ..flag..)

write(fd,...)

close(fd)x

---------------------------------------

 

always check the return value from a system acall

 

if((fd = open("temp", ..flags..))<0){perror("...."); exit(1)}

 

for every file there exists an 'I-Node"

along with an I-Node there is a system-wide openfiletable

and with that there is a perprocess file descriptor table

CSE2031 Lecture 11

    #include<stdio.h>

 

int main(int argc, char* argv[])

{

 

return 0;

]

 

-------------------------------------------------------------

command line arguments

-------------------------------------------------------------

args can be accessed just like a normal allocated array

printf("%s\n", argx[2]);

 

-------------------------------------------------------------

bit operations

-------------------------------------------------------------

 

used to be used to pack and unpack things into small space, but space is cheap now.

 

operating on bits

 

logical operators (unary) bitwise complement ~

    bitwise AND    &

    bitwise XOR    `

    bitwise OR    |

 

shift operators

    left shift        <<

    right shift        >>

 

do not confuse & with &&

     or | with ||

 

right shift shifts in ?? on left end

for unsigned, zeros shifted on the left end

for signed, machine dependent

    -shift in zeros

    -shit in sign bits

int    a=1 << 31; /* shift 1 to high bit*/

unsinged    b = 1 << 31;

 

expn        representation

a        10000000 00000000 00000000 00000000

a >> 3        11110000 00000000 00000000 00000000

b        10000000 00000000 00000000 00000000

b >> 3        00010000 00000000 00000000 00000000

 

to turn bits on , use OR and 1's

v | 3 << 2

v | 00000000 00001100

has 3rd and 4th bit on, others as in v

 

to turn bits off, use AND and 0's

    v & ~(3<<2)

    v & 11111111 11110011

    has 3rd and 4th bit off, others as in v

 

masks

 

    -a string of bits used to extract bits from another expression

    -to find value of a particular bit in an expression

    - use a mask that is 1 at that bit and 0

 

otherwise

 

    1 << 2 as mask to query 3rd bit in v

    (v & (1 << 2) ) ? 1 : 0

 

    has value 1 if 3rd bit in v is 1 and 0 otherwise

 

bit representation of 255

    00000000 00000000 00000000 11111111

    

    0    --> all 0's

    ~0     --> all 1's

    ~0<<k     --> 111...11 000..0

~0(~0<<k)<<r     --> 000..0 11111111 000.00

 

CSE2031 Lecture 10

Specifier	Field type	Converted using	Arg is pointer to
d	Integer (optionally signed)	Strtol with base 10	Int
hd	''	''	Short int
ld	''	''	Long int
I	''	Strtol with base = 0 Reads 045 as octal Ox92 as hexadecimal
hi			Short
li	''	''	Long
O	Integer	Strtoul base 8	Unsigned int
ho	''	''	Unsigned short
Lo	''	''	Unsigned long
U	''	Base 10	''
Hu	''	''	''
Lu	''	''	''
X	Integer	Strtoul base 16 Does not accept AB	Unsigned int
Hx	''	''	''
Lx	''	''	''
E	Floating point input field	Strtol	Float
le	''	''	Double
Le	''	''	Long double

 

 

fscanf

-----------------------------------------

#include <stdio.h>

int fscanf(FILE*stream, const char * format, ...)

scanf is like fscanf(stdin,...)

sscanf(const char* src, ...format...

return value = # of text fields converted to values that are stored

scanf("%d %f", &n,&x)

return EOF if the function stops scanning

because the attempt to get next character it sets end of file or error indicator

for stream ferror(fp), feof(fp)

--------------------------------------------

format string

---------------------------------------------

can have white space

matches any amount of whitespace in the input

"%d<>%f

<> represents a space

literal text

scan conversion specifier

    -like those from printf ( sort of )

-------------------------------------------------

conversion specifier

---------------------------------------------------

-start w/ % sign

-*assignment supression

    looks like scanf(%d %*d %d &m)

-w field width

-conversion specifier

    -give type of argument to expect

        -always a pointer to something

    -how to determind conversion field

    -how to convert value to store

    

(a) scan set

[ ]

keep reading any of these characters (above)

{^ }

Don't read these characters (above)

b) otherwise (and usually)

    d

    i

    o    hl

    u

    x

    X

d and i are different in scan f

 

    eE

    fF    lL

    gG

 

    c

    s

    n

    p

 

-------------------------------

%wc    w chars no '\0' appended        store arg char*

defaults to 1 for %c

 

%ws    w chars                charx then append '\0'

default %s all of next token

 

scanf("%10c", buf)             reads first 10 chars even if it is whitespace

scanf("%10s", buf)            skips all the whitespace reads first 10 chars

 

char *p;

strtol(" 347atx ", &p, 6);

//skips whitespace and reads legal digits in 'this' base (this being 6)

//returns 22 (3 sixes + 4) and pointer p points to the 7

if value outside the range it will return LONG_MAX/ LONG_MIN + set errno to ERANGE

0 <-- system call

-1

x

---------------------------

file* <--Fopen

NULL

x

------------------------------

perror("usermessage");            prints out "usermessage: system error messsage" error message corresponding to error number

strerror(errno)                 returns appropriate error string

 

 

 

            

CSE 2031 Lecture 9

Assignment FAQ

Output files as they are read. For first question : instead of outputting palendromes output 'line is too long' after a certain length.

file* ß fopen(…)

file* fp;

fp = fopen("temp","a");

fprintf(fp,'%s\n", "Hello");

.

.

.

fclose(fp);

printf == fprintf(stdout,…);

"r+" opens a file for reading and writing

"w+" creates a file or truncates it if it exists and reads and writes to it

File descriptor talks to offset talks to inode

When you give a command like write you specify a file descriptor, where you find the data and how much you want to write

A file is a sequence of bytes,

Fseek, frewind, fsetpos are ways to specify the file pointer and where in the file you would like to go in the offset

States of a stream

• Opened
  
  • If you write you go to ..
    
    • Writing state
      
      • If you continue writing you stay in the write state
        
      • If you use seek or rewind you will go back to
        
        • Opened state
          
      • If you just finished writing then you read
        
        • Error state
          
  • If you read you go to
    
    • Reading state
      
      • If you continue reading you stay in the read state
        
      • I f you just finished reading then you write
        
        • Error state
          

 

Printf(format string; other args)

Format string

• Literal text
  
• Conversion specifier
  
  • Printf("hello world \n");
    
  • ^literal text
    
• Printf("n=%d\n", n);
  
  • Literal text
    
    • "n=" + "\n"
      
  • Conversion specifier
    
    • "%d"
      
  • Other arguments
    
    • "n"
      
• Using print f
  
  • A char and short is always converted to int
    
  • A float is always converted to double
    

Conversion specifier

• Starts with "%"
  
  • 4 components (in order)
    
    • Flags
      
    • Field width
      
    • Precision
      
    • Conversion specifier
      
      • first 3 are optional
        

 

d,i	Int	[-]ddd (where d are digits)
u	Unsigned int	ddd
o	Unsigned int	ddd 0-7
x	Unsigned int	ddd 0-9 a-f
X	Unsigned int	ddd 0-9 A-F

 

f	Double	[-]ddd.ddd
E,e	Double	[-]d.ddd e/E +/- dd
G,g	Double	-4<= exponent <precision (life f or e,E
c	Int	Treats int as unsigned char Prints the character
S	Char*	Output chars from array up to '\0'
P	Void*	System dependant Prints an address, usually in hexidecimal
N	Int*	Stores in variable; # of characters printed so far. No conversion
%		Writes a '%' sign

 

Length specifier in conversion specifier

• h,l,L
  
• you can have the h in front on the integer conversion specifiers
  
  • conversion specifier applies to short int (unsigned short int)
    
  • remember char / short args already promoted to int
    
  • convert arg to short before printing
    
• the L,f,e,E,g,G conversion specifier applies to long double argument
  
• do now use lowercase l or h with f,e,E,g,G
  

flags

• field width
  
  • %5d
    
    • Decimal no sign
      
    • Field width of size 5
      
  • %-d
    
    • Fiend width 5
      
    • '-' is a flag
      
      • Left jusitication
        
  • %*d
    
    • Take next arg as field width
      
    • Scanf("%*lf, …)
      
      • * in scanf the * says read a double from input
        

Precision

• After the period
  
• %.5d
  
  • Min # digits to output, pad left w/ 0's
    
• %.5f
  
  • # of fraction digits
    
• %.5g
  
  • Max # of significant digits
    
• &.5s
  
  • Max # of characters to print from the string
    

Flags

• -
  
  • Left justify
    
• 0
  
  • Pads with 0's
    
• +
  
  • Forces explicit plus sign
    
• ' ' (space)
  
  • Use a space instead of plus sign in the output
    
• #
  
  • Changes conversions
    
  • 0 à leading 0
    
  • %#F
    
    • The decimal sign is printed even if there is nothing after it
      

EATS 1011 Lecture 10

Clouds

Nacreous clouds

• A form of PSC (~10 microns)
  
• Formed by waves over mountains
  
• Text and other locations: nacreous clouds
  
• PSC
  
  • Polar stratospheric clouds
    
• Located about 15-25km
  
• Winter polar stratosphere is very cold 180-190 K
  
• HNO₃ and water form ice clouds
  
• Ice surfaces catalyse conversion of HCL to CL which attacks ozone and creates ozone hole
  
• Contains:
  
  • H₂O, h2SO₄, HNO₃, HCL
    

Noctilucent Clouds

• Only appear in polar regions
  
• Size ~.1 microns or smaller
  
• Very thin layer clouds:
  
  • Hard to see over head
    
  • Only visible at twilight or later w/ a long path for illumination
    
• At the summer mesopause
  
• Very cold ~100-140 K
  
  • 173 to 133 degrees celcius
    
• Frozen water
  
• Ccn probably meteoritic dust
  
• Wave structures revealed in ice formation
  
• Can be warning of increased methane (CH₄)`
  

Lapse Rates

• Environmental
  
• Γ_e environmental lapse rate
  
  • dT/dz = ΔT /ΔZ = - Γ_e
    
  • 'dry' adiabatic
    
    • g/C_p = Γ_dry
      
  • 'moist' adiabatic
    
    • g/C_p = Γ_moise
      
  • Γ_Moist < Γ_Dry
    
• Depends on the planet and the major gas
  
• AIR PARCEL(AP)
  
  • Think of an isolated unit of air maintaining its integrity
    
  • This doesn't work for long because of exchange of molecules etc
    
• Lapse rate is how the temp is going to change in height
  
• A steep lapse rate means large temperature change
  
• Adiabatic
  
  • No exchange of energy with outside
    
• Cooling
  
  • Important in Cloud formation and rain
    
• Mean global rate
  
  • ~6.5 C/Km
    
  • Inversion, temperature increases with height
    
• Specific heat @ constant pressure C_p energy add to raise temp 1Celsius for 1kg @ constant pressure
  
• Specific heat @ constant Volume C_v energy add to raise temp 1Celsius for 1kg @ constant pressure
  
  • C_p(air) = 1007 J/kg/Kelvin
    
    • For one Kg you have to have supply 1007 joules for 1 degree celcius difference
      
  • C_v(air) = 700 J/kg/Kelvin
    
• − T2 ) / (Z2 – Z1) = (-g)/Cp
  
  • Dry adiabatically
    
• -(T₁MC_p)
  
  • Extract heat
    
• + Mg(z₂-z₁)
  
  • Add potential energy
    
• + CpMT₂
  
  • Add heat