Accessing and Controlling UNIX Devices

Last time: Finish Filesystems

Prof. Brian D. Davison

Computer Science & Engineering, Lehigh University

Additional Credits

Announcements

• P5: High 100, Low 40, Mean 83
• SQ7: High 10, Low 7, Mean 9.5
• HW4: High 10, Low 6.5, Mean 8.2
• HW6: High 8, Low 0, Mean 7.0
• Reminder: HW #7 due Friday
• Today's schedule
  • Accessing and Controlling UNIX Devices
  • Solution to touch and ls -l

UNIX Devices

• UNIX treats devices much like files
  • Devices have filenames (typically in /dev)
  • Devices contain information and have properties
  • You can read and write bytes to a device
  • Use same system calls (e.g., open(), read(), write(), lseek(), close(), stat()).
• Not all devices support all file operations (e.g., write(), lseek(), etc.)
  • Can you think of examples of such devices?

UNIX Devices

• UNIX treats devices much like files
  • Devices have filenames (ls /dev)
  • Devices contain information and have properties
  • You can read and write bytes to a device
  • Use same system calls (e.g., open(), read(), write(), lseek(), close(), stat()).
• Not all devices support all file operations (e.g., write(), lseek(), etc.)
  • Mouse, terminals
• Some special devices exist: /dev/null, /dev/zero, etc.

Example: UNIX Terminals

• The UNIX terminal is a simple device that acts much like a file.
• Terminal emulation is still used by telnet, ssh, xterm, since hardwired terminals are rarely used today.
• Use tty to tell the name of the current terminal device.
• Try cat /etc/motd > terminal-device-name
• Or any other command... to read or write to the device

Devices have properties

• Just like files, devices have properties (but not always the same)
• We can see these properties (stored in the inode) using ls -l
  • Type of file (c=character, b=block) different
  • Owner, modification time, permissions the same (wouldn't want others to be able to read from your keyboard)
  • Not really files, but provide connections to the device
  • No size, but have major and minor device numbers, which specify which driver handles the file, and a parameter to the driver

Devices are different from files

• After open()ing, files and devices are accessed via file descriptors.
• Settings for the fd are stored in the kernel
  • For files, the use of buffering is such a setting
  • For device like a terminal, we have baud rates, parity, echo mode, buffering, cr/lf translation
• Many of these attributes can be controlled by the programmer.

Controlling file descriptor attributes

• Here's the way to control buffering:

  #include <fcntl.h>
  
  int v;
  v = fcntl(fd, F_GETFL);
  v |= O_SYNC;
  fcntl(fd, F_SETFL, v);
  

• Can do the same for other attributes, like O_APPEND (which makes lseek() and write() atomic)

Terminals are rather different from files

• Connections to ttys have additional attributes for a human interface
• In the naive model, output of a program is sent directly to be viewed by the user, and input by the user is sent directly to the program
• The naive model is false. There is processing between the user and the program.
  • You press return/enter (ascii 13), process sees newline (ascii 10)
  • Program prints newline, terminal sees cr+nl
  • The program sees no input until you press enter

Terminals are rather different from files

• The terminal driver handles
  • Translation
  • Buffering
  • Editing
  • Echo
  • Wrapping

Viewing and changing terminal settings

• Use stty -a to see all terminal settings
• There are many settings, e.g.:
  • -olcuc -- don't convert from lower case to upper case
  • onlcr -- add newline to a carriage return (for output)
  • echo -- show keys pressed (without requiring program to do it explicitly)
• stty can allow the shell to control some settings
• A program can (and often needs to) control the terminal settings

Controlling changing terminal settings

• Many user programs (e.g., editors) need to control what happens in response to user input
• What settings are available? See stty man page, header files
• Working with settings:

  #include <termios.h>
  
  struct termios settings;
  
  tcgetattr(fd, &settings);
  //test, set or clear bits
  tcsetattr(fd, how, &settings);
  

• Bit processing:
  • test a bit: if (flagset & MASK)
  • set a bit: flagset |= MASK;
  • clear a bit: flagset &= ~MASK;

Sample code: echostate.c

/* echostate.c
 *   reports current state of echo bit in tty driver for fd 0
 *   shows how to read attributes from driver and test a bit
 */

#include  <stdio.h>
#include  <termios.h>

main()
{
      struct termios info;
      int rv;

      rv = tcgetattr( 0, &info );     /* read values from driver */

      if ( rv == -1 ){
           perror( "tcgetattr");
           exit(1);
      }
      if ( info.c_lflag & ECHO )
           printf(" echo is on , since its bit is 1\n");
      else
           printf(" echo if OFF, since its bit is 0\n");
}

Sample code: setecho.c

/* setecho.c
 *   usage:  setecho [y|n]
 *   shows:  how to read, change, reset tty attributes
 */

#include        <stdio.h>
#include        <termios.h>

#define  oops(s,x) { perror(s); exit(x); }

main(int ac, char *av[])
{
      struct termios info;

      if ( ac == 1 ) 
            exit(0);

      if ( tcgetattr(0,&info) == -1 )          /* get attribs   */
            oops("tcgettattr", 1);

      if ( av[1][0] == 'y' )
            info.c_lflag |= ECHO ;          /* turn on bit    */
      else
            info.c_lflag &= ~ECHO ;         /* turn off bit   */

      if ( tcsetattr(0,TCSANOW,&info) == -1 ) /* set attribs    */
            oops("tcsetattr",2);
}

Discussion: let's revisit the utility touch(1)

• Did you succeed in implementing touch?
• How does your code do it?
   
  
• One possible solution can be found here.

Implementing ls -l

• We started with a working version of ls.
• Were you able to implement the important details of ls -l?
  • Size, last modified
  • Owner and group
  • Type and permissions

Solution to ls -l

• Need to pull together a number of helpful library functions:
  • The lstat() function provides the file details we need.
  • The getpwuid() function provides access to user information.
  • Use ctime() to convert modification time.
  • Use bitwise masks from </sys/stat.h> to extract types and permissions from mode.
• A sample solution (mostly complete) is here.