Problem:
To backup files/folders in OneDrive, you need to move the files/folders under "OneDrive" cloud folder.
This can be painful if you already have applications/links referring to this source folder.
Moving your folder to 'OneDrive' cloud folder is disruptive here.
Alas! Those applications will break, and it is not easy to fix the links to new locations one by one.
Solution:
Move the files/folders to 'OneDrive' cloud folder as you do normally.
Example:
a.) Win + R, "CMD", Ctrl + Shift + Enter to enter Administrator mode.
b.) C:\Users\Saravanan\Desktop> mklink /D C:\Users\Saravanan\Desktop\Step_One "C:\Users\Saravanan\OneDrive - My corportation\Step_One"
Here, I moved my "Step_One" folder from Desktop to OneDrive, and then I created a link in Desktop to new location of this folder under OneDrive.
This will make transparent redirect of file pointers to new locations for your applications, and make your OneDrive transition easy :-)
sshd (OpenSSH Daemon) is the daemon program for
ssh(1).
Together these programs replace rlogin(1) and rsh(1),
and provide secure encrypted communications between two untrusted hosts over an
insecure network.
sshd listens for connections from clients. It is normally started at boot from /etc/rc. It
forks a new daemon for each incoming connection. The forked daemons handle key exchange, encryption,
authentication, command execution, and data exchange.
-d'
Debug mode. The server sends verbose debug
output to the system log, and does not put itself in the background. The
server also will not fork and will only process one connection. This option
is only intended for debugging for the server. Multiple -d options increase the debugging level.
Maximum is 3.
2.)
SSH(1) BSD General Commands Manual SSH(1)
NAME ssh â OpenSSH SSH client (remote login program)
-v Verbose mode. Causes ssh to print debugging messages about its progress. This is helpful in debugging connection, authentication, and configuraâ tion problems. Multiple -v options increase the verbosity. The maximum is 3.
However, I put all these documentation in a two pages here.
# cat
/tmp/crash-help-strings.txt
*filesmodrunqunion
aliasforeachmountsearchvm
asciifusernetsetvtop
btgdbpsigwaitq
btophelppsstructwhatis
devirqpteswapwr
diskmemptobsymq
evallistptovsys
exitlogrdtask
extendmachrepeattimer
#
1. ) Documentation for crash command *:
NAME
* - pointer-to short-cut
SYNOPSIS
* (struct or union command arguments)
DESCRIPTION
This command is a short-cut command that replaces the requirement to enter
"struct" or "union" command names. For details on the arguments to
those commands, enter "help struct" or "help union".
EXAMPLES
Dump the page structure at address c02943c0:
DESCRIPTION
This command creates an alias for a given command string. If no arguments
are entered, the current list of aliases are displayed. If one argument is
entered, the command string for that alias, if any, is displayed.
alias the single word to be used as an alias
command string the word(s) that will be substituted for the alias
Aliases may be created in four manners:
1. entering the alias in $HOME/.crashrc.
2. entering the alias in .crashrc in the current directory.
3. executing an input file containing the alias command.
4. during runtime with this command.
During initialization, $HOME/.crashrc is read first, followed by the
.crashrc file in the current directory. Aliases in the .crashrc file
in the current directory override those in $HOME/.crashrc. Aliases
entered with this command or by runtime input file override those
defined in either .crashrc file. Aliases may be deleted by entering an
empty string for the second argument. If redirection characters are to
be part of the command string, the command string must be enclosed by
quotation marks.
Note that there are a number of helpful built-in aliases -- see the
first example below.
EXAMPLES
Display the currently-defined aliases, which in this example, only
consist of the built-in aliases:
crash> alias
ORIGIN ALIAS COMMAND
builtin man help
builtin ? help
builtin quit q
builtin sf set scroll off
builtin sn set scroll on
builtin hex set radix 16
builtin dec set radix 10
builtin g gdb
builtin px p -x
builtin pd p -d
builtin for foreach
builtin size *
builtin dmesg log
builtin lsmod mod
builtin last ps -l
Create a new alias to be added to the list:
crash> alias kp kmem -p
ORIGIN ALIAS COMMAND
runtime kp kmem -p
0 1 2 3 4 5 6 7
+-------------------------------
0 | NUL DLE SP 0 @ P ' p
1 | SOH DC1 ! 1 A Q a q
2 | STX DC2 " 2 B R b r
3 | ETX DC3 # 3 C S c s
4 | EOT DC4 $ 4 D T d t
5 | ENQ NAK % 5 E U e u
6 | ACK SYN & 6 F V f v
7 | BEL ETB ` 7 G W g w
8 | BS CAN ( 8 H X h x
9 | HT EM ) 9 I Y i y
A | LF SUB * : J Z j z
B | VT ESC + ; K [ k {
C | FF FS , < L \ l |
D | CR GS _ = M ] m }
E | SO RS . > N ^ n ~
F | SI US / ? O - o DEL
DESCRIPTION
Display a kernel stack backtrace. If no arguments are given, the stack
trace of the current context will be displayed.
-a displays the stack traces of the active task on each CPU.
(only applicable to crash dumps)
-g displays the stack traces of all threads in the thread group of
the target task; the thread group leader will be displayed first.
-r display raw stack data, consisting of a memory dump of the two
pages of memory containing the task_union structure.
-t display all text symbols found from the last known stack location
to the top of the stack. (helpful if the back trace fails)
-T display all text symbols found from just above the task_struct or
thread_info to the top of the stack. (helpful if the back trace
fails or the -t option starts too high in the process stack).
-l show file and line number of each stack trace text location.
-e search the stack for possible kernel and user mode exception frames.
-E search the IRQ stacks (x86, x86_64 and ppc64), and the exception
stacks (x86_64) for possible exception frames; all other arguments
will be ignored since this is not a context-sensitive operation.
-f display all stack data contained in a frame; this option can be
used to determine the arguments passed to each function; on ia64,
the argument register contents are dumped.
-F similar to -f, except that the stack data is displayed symbolically
when appropriate; if the stack data references a slab cache object,
the name of the slab cache will be displayed in brackets; on ia64,
the substitution is done to the argument register contents.
-o x86: use old backtrace method, permissable only on kernels that were
compiled without the -fomit-frame_pointer.
x86_64: use old backtrace method, which dumps potentially stale
kernel text return addresses found on the stack.
-O x86: use old backtrace method by default, permissable only on kernels
that were compiled without the -fomit-frame_pointer; subsequent usage
of this option toggles the backtrace method.
x86_64: use old backtrace method by default; subsequent usage of this
option toggles the backtrace method.
-R ref display stack trace only if there is a reference to this symbol
or text address.
-I ip use ip as the starting text location.
-S sp use sp as the starting stack frame address.
pid displays the stack trace(s) of this pid.
taskp displays the stack trace the the task referenced by this hexadecimal
task_struct pointer.
Multiple pid and taskp arguments may be specified.
Note that all examples below are for x86 only. The output format will differ
for other architectures. x86 backtraces from kernels that were compiled
with the --fomit-frame-pointer CFLAG occasionally will drop stack frames,
or display a stale frame reference. When in doubt as to the accuracy of a
backtrace, the -t or -T options may help fill in the blanks.
EXAMPLES
Display the stack trace of the active task(s) when the kernel panicked:
crash> bt -a
PID: 286 TASK: c0b3a000 CPU: 0 COMMAND: "in.rlogind"
#0 [c0b3be90] crash_save_current_state at c011aed0
#1 [c0b3bea4] panic at c011367c
#2 [c0b3bee8] tulip_interrupt at c01bc820
#3 [c0b3bf08] handle_IRQ_event at c010a551
#4 [c0b3bf2c] do_8259A_IRQ at c010a319
#5 [c0b3bf3c] do_IRQ at c010a653
#6 [c0b3bfbc] ret_from_intr at c0109634
EAX: 00000000 EBX: c0e68280 ECX: 00000000 EDX: 00000004 EBP: c0b3bfbc
DS: 0018 ESI: 00000004 ES: 0018 EDI: c0e68284
CS: 0010 EIP: c012f803 ERR: ffffff09 EFLAGS: 00000246
#7 [c0b3bfbc] sys_select at c012f803
#8 [c0b3bfc0] system_call at c0109598
EAX: 0000008e EBX: 00000004 ECX: bfffc9a0 EDX: 00000000
DS: 002b ESI: bfffc8a0 ES: 002b EDI: 00000000
SS: 002b ESP: bfffc82c EBP: bfffd224
CS: 0023 EIP: 400d032e ERR: 0000008e EFLAGS: 00000246
Display the stack traces of task f2814000 and PID 1592:
crash> bt f2814000 1592
PID: 1018 TASK: f2814000 CPU: 1 COMMAND: "java"
#0 [f2815db4] schedule at c011af85
#1 [f2815de4] __down at c010600f
#2 [f2815e14] __down_failed at c01061b3
#3 [f2815e24] stext_lock (via drain_cpu_caches) at c025fa55
#4 [f2815ec8] kmem_cache_shrink_nr at c013a53e
#5 [f2815ed8] do_try_to_free_pages at c013f402
#6 [f2815f04] try_to_free_pages at c013f8d2
#7 [f2815f1c] _wrapped_alloc_pages at c01406bd
#8 [f2815f40] __alloc_pages at c014079d
#9 [f2815f60] __get_free_pages at c014083e
#10 [f2815f68] do_fork at c011cebb
#11 [f2815fa4] sys_clone at c0105ceb
#12 [f2815fc0] system_call at c010740c
EAX: 00000078 EBX: 00000f21 ECX: bc1ffbd8 EDX: bc1ffbe0
DS: 002b ESI: 00000000 ES: 002b EDI: bc1ffd04
SS: 002b ESP: 0807316c EBP: 080731bc
CS: 0023 EIP: 4012881e ERR: 00000078 EFLAGS: 00000296
In order to examine each stack frame's contents use the bt -f option.
From the extra frame data that is displayed, the arguments passed to each
function can be determined. Re-examining the PID 1592 trace above:
Typically the arguments passed to a function will be the last values
that were pushed onto the stack by the next higher-numbered function, i.e.,
the lowest stack addresses in the frame above the called function's
stack frame. That can be verified by disassembling the calling function.
For example, the arguments passed from sys_read() to pipe_read() above
are the file pointer, the user buffer address, the count, and a pointer
to the file structure's f_pos field. Looking at the frame #3 data for
sys_read(), the last four items pushed onto the stack (lowest addresses)
are f27ae680, bffed4a3, 00000001, and f27ae6a0 -- which are the 4 arguments
above, in that order. Note that the first (highest address) stack content
in frame #2 data for pipe_read() is c0148be8, which is the return address
back to sys_read().
Dump the text symbols found in the current context's stack:
crash> bt -t
PID: 1357 TASK: c1aa0000 CPU: 0 COMMAND: "lockd"
START: schedule at c01190e0
[c1aa1f28] dput at c0157dbc
[c1aa1f4c] schedule_timeout at c0124cd4
[c1aa1f78] svc_recv at cb22c4d8 [sunrpc]
[c1aa1f98] put_files_struct at c011eb21
[c1aa1fcc] nlmclnt_proc at cb237bef [lockd]
[c1aa1ff0] kernel_thread at c0105826
[c1aa1ff8] nlmclnt_proc at cb237a60 [lockd]
Search the current stack for possible exception frames:
Display the back trace from a dumpfile that resulted from an attempt to
insmod the sample "crash.c" kernel module that comes as part of the
Red Hat netdump package:
DESCRIPTION
This command translates a hexadecimal address to its page number.
EXAMPLES
crash> btop 512a000
512a000: 512a
6. ) Documentation for crash command dev:
NAME
dev - device data
SYNOPSIS
dev [-i | -p | -d]
DESCRIPTION
If no argument is entered, this command dumps character and block
device data.
-i display I/O port usage; on 2.4 kernels, also display I/O memory usage.
-p display PCI device data.
-d display disk I/O statistics:
TOTAL: total number of allocated in-progress I/O requests
SYNC: I/O requests that are synchronous
ASYNC: I/O requests that are asynchronous
READ: I/O requests that are reads (older kernels)
WRITE: I/O requests that are writes (older kernels)
DRV: I/O requests that are in-flight in the device driver
SYNOPSIS
dis [-rludx][-b [num]] [address | symbol | (expression)] [count]
DESCRIPTION
This command disassembles source code instructions starting (or ending) at
a text address that may be expressed by value, symbol or expression:
-r (reverse) displays all instructions from the start of the
routine up to and including the designated address.
-l displays source code line number data in addition to the
disassembly output.
-u address is a user virtual address in the current context;
otherwise the address is assumed to be a kernel virtual address.
If this option is used, then -r and -l are ignored.
-x override default output format with hexadecimal format.
-d override default output format with decimal format.
-b [num] modify the pre-calculated number of encoded bytes to skip after
a kernel BUG ("ud2a") instruction; with no argument, displays
the current number of bytes being skipped. (x86 and x86_64 only)
address starting hexadecimal text address.
symbol symbol of starting text address. On ppc64, the symbol
preceded by '.' is used.
(expression) expression evaluating to a starting text address.
count the number of instructions to be disassembled (default is 1).
If no count argument is entered, and the starting address
is entered as a text symbol, then the whole routine will be
disassembled. The count argument is ignored when used with
the -r option.
EXAMPLES
Disassemble the sys_signal() routine without, and then with, line numbers:
DESCRIPTION This command evaluates an expression or numeric value, and displays its result in hexadecimal, decimal, octal and binary. If the resultant value is an integral number of gigabytes, megabytes, or kilobytes, a short-hand translation of the number will also be shown next to the hexadecimal value. If the most significant bit is set, the decimal display will show both unsigned and signed (negative) values. Expressions must of the format (x operator y), where "x" and "y" may be either numeric values or symbols. The list of operators are:
+ - & | ^ * % / << >>
Enclosing the expression within parentheses is optional except when the "|", "<<" or ">>" operators are used. The single "value" argument may be a number or symbol. Number arguments must be hexadecimal or decimal. A leading "0x" identifies a number as hexadecimal, but is not required when obvious. Numbers may be followed by the letters "k" or "K", "m" or "M", and "g" or "G", which multiplies the value by a factor of 1024, 1 megabyte or 1 gigabyte, respectively. Numeric arguments may be preceded by the one's complement operator ~.
-b Indicate which bit positions in the resultant value are set. -l Numeric arguments are presumed to be 64-bit values, and the result will be expressed as a 64-bit value. (ignored on 64-bit processors) However, if either operand or the resultant value are 64-bit values, then the result will be also be expressed as a 64-bit value.
The -b and -l options must precede the expression or value arguments.
DESCRIPTION This command dynamically loads or unloads crash extension shared object libraries:
shared-object load the specified shared object file; more than one one object file may be entered. -u shared-object unload the specified shared object file; if no file arguments are specified, unload all objects.
If the shared-object filename is not expressed with a fully-qualified pathname, the following directories will be searched in the order shown, and the first instance of the file that is found will be selected:
1. the current working directory 2. the directory specified in the CRASH_EXTENSIONS environment variable 3. /usr/lib64/crash/extensions (64-bit architectures) 4. /usr/lib/crash/extensions
If no arguments are entered, the current set of shared object files and a list of their commands will be displayed. The registered commands contained in each shared object file will appear automatically in the "help" command screen.
An example of a shared object prototype file, and how to compile it into a shared object, is appended below.
CREATING A SHARED OBJECT The extend command loads shared object files using dlopen(3), which in turn calls the shared object's _init() function. The shared object's _init() function should register its command set by calling register_extension(), passing it a pointer to an array of one or more structures of the following type:
Each command_table_entry structure contains the ASCII name of a command, the command's function address, a pointer to an array of help data strings, and a flags field. The help_data field is optional; if it is non-NULL, it should point to an array of character strings used by the "help" command, and during command failures. The flags field currently has one available bit setting, REFRESH_TASK_TABLE, which should be set if it is preferable to reload the current set of running processes just prior to executing the command (on a live system). Terminate the array of command_table_entry structures with an entry with a NULL command name.
Below is an example shared object file consisting of just one command, called "echo", which simply echoes back all arguments passed to it. Note the comments contained within it for further details. Cut and paste the following output into a file, and call it, for example, "echo.c". Then compiled in either of two manners. Either manually like so:
where must be one of the MACHINE_TYPE #define's in defs.h, and where $(TARGET_CFLAGS) is the same as it is declared in the top-level Makefile after a build is completed. Or alternatively, the "echo.c" file can be copied into the "extensions" subdirectory, and compiled automatically like so:
make extensions
The echo.so file may be dynamically linked into crash during runtime, or during initialization by putting "extend echo.so" into a .crashrc file located in the current directory, or in the user's $HOME directory.
---------------------------------- cut here ----------------------------------
#include "defs.h" /* From the crash source top-level directory */
void cmd_echo(); /* Declare the commands and their help data. */ char *help_echo[];
static struct command_table_entry command_table[] = { "echo", cmd_echo, help_echo, 0, /* One or more commands, */ NULL, /* terminated by NULL, */ };
_init() /* Register the command set. */ { register_extension(command_table); }
/* * The _fini() function is called if the shared object is unloaded. * If desired, perform any cleanups here. */ _fini() { }
/* * Arguments are passed to the command functions in the global args[argcnt] * array. See getopt(3) for info on dash arguments. Check out defs.h and * other crash commands for usage of the myriad of utility routines available * to accomplish what your task. */ void cmd_echo() { int c;
while (args[optind]) fprintf(fp, "%s ", args[optind++]);
fprintf(fp, "\n"); }
/* * The optional help data is simply an array of strings in a defined format. * For example, the "help echo" command will use the help_echo[] string * array below to create a help page that looks like this: * * NAME * echo - echoes back its arguments * * SYNOPSIS * echo arg ... * * DESCRIPTION * This command simply echoes back its arguments. * * EXAMPLE * Echo back all command arguments: * * crash> echo hello, world * hello, world * */
char *help_echo[] = { "echo", /* command name */ "echo", /* command name */ "echoes back its arguments", /* short description */ "arg ...", /* argument synopsis, or " " if none */
" This command simply echoes back its arguments.", "\nEXAMPLE", " Echo back all command arguments:\n", " crash> echo hello, world", " hello, world", NULL }; 11. ) Documentation for crash command files:
DESCRIPTION This command displays information about open files of a context. It prints the context's current root directory and current working directory, and then for each open file descriptor it prints a pointer to its file struct, a pointer to its dentry struct, a pointer to the inode, the file type, and the pathname. If no arguments are entered, the current context is used. The -R option, typically invoked from "foreach files", searches for references to a supplied number, address, or filename argument, and prints only the essential information leading up to and including the reference. The -d option is not context specific, and only shows the data requested.
-d dentry given a hexadecimal dentry address, display its inode, super block, file type, and full pathname. -R reference search for references to this file descriptor number, filename, or dentry, inode, or file structure address. pid a process PID. taskp a hexadecimal task_struct pointer.
EXAMPLES Display the open files of the current context:
DESCRIPTION This command allows for a an examination of various kernel data associated with any, or all, tasks in the system, without having to set the context to each targeted task.
pid perform the command(s) on this PID. taskp perform the command(s) on task referenced by this hexadecimal task_struct pointer. name perform the command(s) on all commands with this name. If the command name can be confused with a foreach command name, then precede the name string with a "\". user perform the command(s) on all user (non-kernel) threads. kernel perform the command(s) on all kernel threads. active perform the command(s) on the active thread on each CPU.
If none of the task-identifying arguments above are entered, the command will be performed on all tasks.
command select one or more of the following commands to be run on the tasks selected, or on all tasks:
bt run the "bt" command (optional flags: -r -t -l -e -R -f -F -o) vm run the "vm" command (optional flags: -p -v -m -R) task run the "task" command (optional flags: -R -d -x) files run the "files" command (optional flag: -R) net run the "net" command (optional flags: -s -S -R) set run the "set" command sig run the "sig" command (optional flag: -g) vtop run the "vtop" command (optional flags: -c -u -k)
flag Pass this optional flag to the command selected. argument Pass this argument to the command selected.
A header containing the PID, task address, cpu and command name will be pre-pended before the command output for each selected task. Consult the help page of each of the command types above for details.
Display the task_struct structure for each "bash" command:
crash> foreach bash task ...
Display the open files for all tasks:
crash> foreach files ...
13. ) Documentation for crash command fuser:
NAME fuser - file users
SYNOPSIS fuser [pathname | inode]
DESCRIPTION This command displays the tasks using specified files or sockets. Tasks will be listed that reference the file as the current working directory, root directory, an open file descriptor, or that mmap the file. If the file is held open in the kernel by the lockd server on behalf of a client discretionary file lock, the client hostname is listed.
pathname the full pathname of the file. inode the hexadecimal inode address for the file.
EXAMPLES Display the tasks using file /usr/lib/libkfm.so.2.0.0
DESCRIPTION This command passes its arguments directly to gdb for processing. This is typically not necessary, but where ambiguities between crash and gdb command names exist, this will force the command to be executed by gdb.
EXAMPLES crash> gdb help List of classes of commands:
aliases -- Aliases of other commands breakpoints -- Making program stop at certain points data -- Examining data files -- Specifying and examining files internals -- Maintenance commands obscure -- Obscure features running -- Running the program stack -- Examining the stack status -- Status inquiries support -- Support facilities tracepoints -- Tracing of program execution without stopping the program user-defined -- User-defined commands
Type "help" followed by a class name for a list of commands in that class. Type "help" followed by command name for full documentation. Command name abbreviations are allowed if unambiguous.
