Cisc vs Risc

CISC (Complex Instruction Set Computers)
The primary goal of CISC architecture is to complete a task in as few lines of assembly as possible.
One of the primary advantages of this system is that the compiler has to do very little work to translate a high-level language statement into assembly. Because the length of the code is relatively short, very little RAM is required to store instructions. The emphasis is put on building complex instructions directly into the hardware.
Examples of CISC processors are the System/360 (excluding the ‘scientific’ Model 44), VAX, PDP-11, Motorola 68000 family, and Intel x86 architecture based processors.

 

Characteristics of a CISC architecture:
* Emphasis on hardware;
* Includes multi-clock complex instructions;
* Small code sizes;
* Complex data types in hardware; some CISCs have byte string instructions, or support complex numbers;

RISC (Reduced instruction set computer) is a type of microprocessor architecture that utilizes a small, highly-optimized set of instructions, rather than a more specialized set ofinstructions often found in other types of architectures.
RISC processors only use simple instructions that can be executed within one clock cycle.
Well known RISC families include Alpha, ARC, ARM, AVR, MIPS, PA-RISC, Power Architecture (including PowerPC), SuperH, and SPARC.

Characteristics of a RISC architecture:
* Emphasis on software;
* Single-clock, reduced instruction only;
* Uniform instruction format, using a single word with the opcode in the same bit positions in every instruction, demanding less decoding;
* Identical general purpose registers, allowing any register to be used in any context, simplifying compiler design;
* Simple addressing modes. Complex addressing performed via sequences of arithmetic and/or load-store operations;
* Typically larger code sizes;
* Few data types in hardware;

The CISC approach attempts to minimize the number of instructions per program, sacrificing the number of cycles per instruction. RISC does the opposite, reducing the cycles per instruction at the cost of the number of instructions per program.

Sniffing USB port on Linux

The linux kernel has a facility called “usbmon” which can be used to sniff the USB bus.
So the output is really easy to collect, even from the command line shell or using libpcap parser like tcpdump or wireshark.
Let’s see how we can do that:
Simply mount debugfs and load the usbmon module, if usbmon is built into the kernel.
$ sudo mount -t debugfs none_debugs /sys/kernel/debug
$ sudo modprobe usbmon
Verify that bus sockets are present.
$ sudo ls /sys/kernel/debug/usbmon
0s 0u 1s 1t 1u 2s 2t 2u 3s 3t 3u 4s 4t 4u

Now you can choose to either use the socket ‘0u’ (to capture packets on all buses),
or find the bus used by your device, so run
$ sudo cat /proc/bus/usb/devices
or may be
$ sudo lsusb
and find the T-line which corresponds to the device.
If my device is connected to the forth bus
Start ‘cat’ like this
$ sudo cat /sys/kernel/debug/usbmon/4u
With wireshark it’s more verbose so run, wireshark and select usbmon4 usb bus 4.

Happy sniffing,

Code names of Debian

When a Debian distribution is in the development stage, it has no version number but a codename. The purpose of these code names is to make easier the mirroring of the Debian distributions.
The code names of Debian releases are names of characters from the film Toy Story. The unstable, development distribution is permanently nicknamed sid, after the emotionally unstable next-door neighbor boy who regularly destroyed toys.

Code names of Debian
Code names of Debian