Unix

The /etc/inittab file is a script that controls most of the boot sequence. It dictates what programs and scripts to launch and at what runlevels.

A merit system is the process of hiring and promoting people based on their ability to do their job.

Yes, it is.

They are both administrator accounts and have privileges to do anything on the system.

Nothing. By default, ls will not show configuration files or directories that begin with a . These can be displayed by passing the -a parameter to ls. Ex. ls -a

• Concurrency control is the problem of synchronizing concurrent transactions (i.e., order the operations of concurrent transactions) such that the following two propertiesare achieved:

- the consistency of the DB is maintained

- the maximum degree of concurrency of operations is achieved

• Obviously, the serial execution of a set of transaction achieves consistency, if each single transaction is consistent

Conflicts

• Conflicting operations: Two operations Oij (x) and Okl(x) of transactions Ti and Tk

are in conflict iff at least one of the operations is a write, i.e.,

- Oij = read(x) and Okl = write(x)

- Oij = write(x) and Okl = read(x)

- Oij = write(x) and Okl = write(x)

• Intuitively, a conflict between two operations indicates that their order of execution is important.

• Read operations do not conflict with each other, hence the ordering of read operations does not matter.

• Example: Consider the following two transactions

T1: Read(x)

x ← x + 1

Write(x)

Commit

T2: Read(x)

x ← x + 1

Write(x)

Commit

- To preserve DB consistency, it is important that the read(x) of one transaction is not between read(x) and write(x) of the other transaction.

Schedules

• A schedule (history) specifies a possibly interleaved order of execution of the operations O of a set of transactions T = {T1, T2, . . . , Tn}, where Ti is specified by a partial order (Σi , ≺i). A schedule can be specified as a partial order over O, where - ΣT =Sn i=1 Σi - ≺T ⊇ Sn i=1 ≺I - For any two conflicting operations Oij , Okl ∈ ΣT , either Oij ≺T Okl or Okl ≺T Oij

• A schedule is serial if all transactions in T are executed serially.

• Example: Consider the following two transactions

T1: Read(x)

x ← x + 1

Write(x)

Commit

T2: Read(x)

x ← x + 1

Write(x)

Commit

- The two serial schedules are S1 = {Σ1, ≺1} and S2 = {Σ2, ≺2}, where

Σ1 = Σ2 = {R1(x), W1(x), C1, R2(x), W2(x), C2}

≺1= {(R1, W1),(R1, C1),(W1, C1),(R2, W2),(R2, C2),(W2, C2),

(C1, R2), . . . }

≺2= {(R1, W1),(R1, C1),(W1, C1),(R2, W2),(R2, C2),(W2, C2),

(C2, R1), . . . }

• We will also use the following notation:

- {T1, T2} = {R1(x), W1(x), C1, R2(x), W2(x), C2}

- {T2, T1} = {R2(x), W2(x), C2, R1(x), W1(x), C1}

Serializability

• Two schedules are said to be equivalent if they have the same effect on the DB.

• Conflict equivalence: Two schedules S1 and S2 defined over the same set of

transactions T = {T1, T2, . . . , Tn} are said to be conflict equivalent if for each pair

of conflicting operations Oij and Okl , whenever Oij <1 Okl then Oij <2 Okl.

- i.e., conflicting operations must be executed in the same order in both transactions.

• A concurrent schedule is said to be (conflict-)serializable iff it is conflict equivalent to a serial schedule

• A conflict-serializable schedule can be transformed into a serial schedule by swapping non-conflicting operations

• Example: Consider the following two schedules

T1: Read(x)

x ← x + 1

Write(x)

Write(z)

Commit

T2: Read(x)

x ← x + 1

Write(x)

Commit

- The schedule {R1(x), W1(x), R2(x), W2(x), W1(z), C2, C1} is

conflict-equivalent to {T1, T2} but not to {T2, T1}

Concurrency Control Algorithms

• Taxonomy of concurrency control algorithms

- Pessimistic methods assume that many transactions will conflict, thus the concurrent

execution of transactions is synchronized early in their execution life cycle

∗ Two-Phase Locking (2PL)

· Centralized (primary site) 2PL

· Primary copy 2PL · Distributed 2PL

∗ Timestamp Ordering (TO)

· Basic TO

· Multiversion TO

· Conservative TO

∗ Hybrid algorithms

- Optimistic methods assume that not too many transactions will conflict, thus delay

the synchronization of transactions until their termination

∗ Locking-based

∗ Timestamp ordering-based

DDB 2008/09 J. Gamper Page 10Locking Based Algorithms

• Locking-based concurrency algorithms ensure that data items shared by conflicting operations are accessed in a mutually exclusive way. This is accomplished by associating a "lock" with each such data item.

• Two types of locks (lock modes)

- read lock (rl) - also called shared lock

- write lock (wl) - also called exclusive lock

• Compatibility matrix of locks rli(x) wli(x) rlj (x) compatible not compatible

wlj (x) not compatible not compatible

• General locking algorithm

1. Before using a data item x, transaction requests lock for x from the lock manager

2. If x is already locked and the existing lock is incompatible with the requested lock, the transaction is delayed

3. Otherwise, the lock is granted Locking Based Algorithms

• Example: Consider the following two transactions

T1: Read(x)

x ← x + 1

Write(x)

Read(y)

y ← y − 1

Write(y)

T2: Read(x)

x ← x ∗ 2

Write(x)

Read(y)

y ← y ∗ 2

Write(y)

- The following schedule is a valid locking-based schedule (lri(x) indicates the

release of a lock on x):

S = {wl1(x), R1(x), W1(x), lr1(x)

wl2(x), R2(x), W2(x), lr2(x)

wl2(y), R2(y), W2(y), lr2(y)

wl1(y), R1(y), W1(y), lr1(y)}

- However, S is not serializable

∗ S cannot be transformed into a serial schedule by using only non-conflicting swaps

∗ The result is different from the result of any serial execution

Two-Phase Locking (2PL)

• Two-phase locking protocol

- Each transaction is executed in two phases

∗ Growing phase: the transaction obtains locks

∗ Shrinking phase: the transaction releases locks

- The lock point is the moment when transitioning from the growing phase to the

shrinking phase Two-Phase Locking (2PL) . . .

• Properties of the 2PL protocol

- Generates conflict-serializable schedules

- But schedules may cause cascading aborts

∗ If a transaction aborts after it releases a lock, it may cause other transactions that

have accessed the unlocked data item to abort as well

• Strict 2PL locking protocol

- Holds the locks till the end of the transaction

- Cascading aborts are avoided

DDB 2008/09 J. Gamper Page 14Two-Phase Locking (2PL) . . .

• Example: The schedule S of the previous example is not valid in the 2PL protocol:

S = {wl1(x), R1(x), W1(x), lr1(x)

wl2(x), R2(x), W2(x), lr2(x)

wl2(y), R2(y), W2(y), lr2(y)

wl1(y), R1(y), W1(y), lr1(y)}

- e.g., after lr1(x) (in line 1) transaction T1 cannot request the lock wl1(y) (in line 4).

- Valid schedule in the 2PL protocol

S = {wl1(x), R1(x), W1(x),

wl1(y), R1(y), W1(y), lr1(x), lr1(y)

wl2(x), R2(x), W2(x),

wl2(y), R2(y), W2(y), lr2(x), lr2(y)}

Timestamp Ordering . . .

• Basic timestamp ordering is "aggressive": It tries to execute an operation as soon as it receives it

• Conservative timestamp ordering delays each operation until there is an assurance that it will not be restarted, i.e., that no other transaction with a smaller timestamp can arrive

- For this, the operations of each transaction are buffered until an ordering can be established so that rejections are not possible

• If this condition can be guaranteed, the scheduler will never reject an operation

• However, this delay introduces the possibility for deadlocks

• Multiversion timestamp ordering

- Write operations do not modify the DB; instead, a new version of the data item is created: x1, x2, . . . , xn

- Ri(x) is always successful and is performed on the appropriate version of x, i.e., the version of x (say xv) such that wts(xv) is the largest timestamp less than ts(Ti)

- Wi(x) produces a new version xw with ts(xw) = ts(Ti) if the scheduler has not

yet processed any Rj (xr) on a version xr such that ts(Ti) < rts(xr)

i.e., the write is too late.

- Otherwise, the write is rejected.

• The previous concurrency control algorithms are pessimistic

• Optimistic concurrency control algorithms

- Delay the validation phase until just before the write phase

- Ti

run independently at each site on local copies of the DB (without updating the DB) - Validation test then checks whether the updates would maintain the DB consistent:

∗ If yes, all updates are performed ∗ If one fails, all Ti 's are rejected

• Potentially allow for a higher level of concurrency

Deadlock Management

• Deadlock: A set of transactions is in a deadlock situation if several transactions wait for each other. A deadlock requires an outside intervention to take place.

• Any locking-based concurrency control algorithm may result in a deadlock, since there is mutual exclusive access to data items and transactions may wait for a lock

• Some TO-based algorihtms that require the waiting of transactions may also cause deadlocks

• A Wait-for Graph (WFG) is a useful tool to identify deadlocks

- The nodes represent transactions

- An edge from Ti to Tj indicates that Ti is waiting for Tj

- If the WFG has a cycle, we have a deadlock situation

• Deadlock management in a DDBMS is more complicate, since lock management is not

centralized

• We might have global deadlock, which involves transactions running at different sites

• A Local Wait-for-Graph (LWFG) may not show the existence of global deadlocks

• A Global Wait-for Graph (GWFG), which is the union of all LWFGs, is needed

Deadlock Prevention

• Deadlock prevention: Guarantee that deadlocks never occur

- Check transaction when it is initiated, and start it only if all required resources are available.

- All resources which may be needed by a transaction must be predeclared

• Advantages

- No transaction rollback or restart is involved

- Requires no run-time support

• Disadvantages

- Reduced concurrency due to pre-allocation

- Evaluating whether an allocation is safe leads to added overhead

- Difficult to determine in advance the required resources

Conclusion

• Concurrency orders the operations of transactions such that two properties are

achieved: (i) the database is always in a consistent state and (ii) the maximum

concurrency of operations is achieved

• A schedule is some order of the operations of the given transactions. If a set of

transactions is executed one after the other, we have a serial schedule.

• There are two main groups of serializable concurrency control algorithms: locking based and timestamp based

• A transaction is deadlocked if two or more transactions are waiting for each other. A Wait-for graph (WFG) is used to identify deadlocks

• Centralized, distributed, and hierarchical schemas can be used to identify deadlocks

It is usually referred to simply as "SSH."

Look for a vi tutorial (they are usually online for Linux anyway). Or, search for "vi cheat sheet".

Example is in related links.

Possible attack against your computer. File /etc/hosts.equiv should be empty.

Open Source, whether it applies to an Operating System or a utility program means you have the source code and can modify it. Depending on the license used there may be some restrictions on your modifications so it is best to look at the license that comes with the Open Source software.

No, the shell needs both execute and read permissions to run the script.

Code running in kernel mode has unlimited access to hardware and CPU.

Code in user mode can't address memory that kernel mode does not allow it to.

Means Firewall Packet Filter.

Echo merely repeats its command line arguments as stated. The 'printf' command allows for formatted print and a more exacting method of printing out information. Printf requires you to specify the format of what you want to print; echo does not have this ability.

The default user shell is set in the password file as an entry for each account.

There are no advantages or disadvantages to Xenix, since it has no practical application for use in today's world. Like CP/M or System 1 on the Macintosh, Xenix cannot even be compared properly to modern systems.

The command 'Y' or 'yy' copies (yanks) one or more lines. To copy one line, two lines, 10 lines, and all lines to the end of the file, respectively:

Y

2Y

10Y

yG

To paste the text contained in the buffer above (uppercase P) or below the current cursor position (lowercase p), respectively:

P

p

It is also possible to yank text within a line. The following commands yank text from the current cursor position to the end of the word and the end of the line, respectively:

yw

y$

The same commands paste the text within a line. Lower case p pastes after the cursor position and upper case P pastes before.

Paste will also work with deleted text, either lines or parts of lines. Be careful not to execute any other commands prior to pasting as this will empty the buffer.

gzip filename ...

Check your limits on your account and shell by using ulimit -a. You may be able to set the value higher, but in some cases it is limited by the system administrator, so you may want to talk to them about the limitation.

PC means: "Personal computer"

If it's your PC it doesn't matter what OS you install. It's still a PC.

a system lets use A Operating system as a sample. a operating system is the system you'r running on your Computer.

i coul'd be Windows Xp, Windows Vista, Windows 7, Linux, Mac etc.

a process is something your comupter is working on. lets use internet explorer or the internet as a sample. when you are going to a web site you see a line on the button on the screen it is normal blue, but it can be other coloras to. the blue line is cal'd the "ProgsessBar" and is showing how much your computer has loaded of this site and how much is left.

so the difference between system and a process is BIG