Tôi gặp vấn đề này sau khi nâng cấp Lubfox từ 12.10 lên 13.04.

Tôi nhấn Ctrl+ Alt+ 1, nhập thông tin đăng nhập, mật khẩu, đợi hai giây và nhận : ♦: command not found". Sau thông báo này tôi có thể gõ lệnh mà không gặp vấn đề gì, nhưng đó là gì?

echo $PATH
/usr/lib/lightdm/lightdm:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/home/vitaly/bin:/usr/java/jdk1.7.0_17/bin

.bashrcTập tin của tôi là:

# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples

# If not running interactively, don't do anything
case $- in
    *i*) ;;
      *) return;;
esac

# don't put duplicate lines or lines starting with space in the history.
# See bash(1) for more options
HISTCONTROL=ignoreboth

# append to the history file, don't overwrite it
shopt -s histappend

# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
HISTSIZE=1000
HISTFILESIZE=2000

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize

# If set, the pattern "**" used in a pathname expansion context will
# match all files and zero or more directories and subdirectories.
#shopt -s globstar

# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy prompt (non-color, unless we know we "want" color)
case "$TERM" in
    xterm-color) color_prompt=yes;;
esac

# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
#force_color_prompt=yes

if [ -n "$force_color_prompt" ]; then
    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
    # We have color support; assume it's compliant with Ecma-48
    # (ISO/IEC-6429). (Lack of such support is extremely rare, and such
    # a case would tend to support setf rather than setaf.)
    color_prompt=yes
    else
    color_prompt=
    fi
fi

if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi
unset color_prompt force_color_prompt

# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
    ;;
*)
    ;;
esac

# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
    alias ls='ls --color=auto'
    #alias dir='dir --color=auto'
    #alias vdir='vdir --color=auto'

    alias grep='grep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias egrep='egrep --color=auto'
fi

# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

# Add an "alert" alias for long running commands.  Use like so:
#   sleep 10; alert
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi

.profileTập tin của tôi là:

# ~/.profile: executed by the command interpreter for login shells.
# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
# exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package.
#umask 022

# if running bash
if [ -n "$BASH_VERSION" ]; then
    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
    . "$HOME/.bashrc"
    fi
fi

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

Các tập tin /etc/profileở đây: http://paste.ubfox.com/5781361/

Cách giải quyết

Đầu tiên, tôi nghĩ rằng bạn giới thiệu về khi bạn đi trong tty1 - Ctrl+ Alt+ F1.

Bây giờ, tôi nghĩ đang xảy ra những gì bạn nói rất có thể là do bạn có một ký tự lạ như ♦ ( ký tự phù hợp với kim cương hoặc huy hiệu đặc biệt cho người điều hành Askubfox ) trong ~/.bashrchoặc ~/.profiletệp hoặc tệp khác có chứa các lệnh khởi tạo khác nhau.

Như bạn có thể thấy trong hình ảnh tiếp theo, tôi đã chỉnh sửa ~/.bashrctập tin đặt bên trong ký tự ♦ trên một dòng. Kết quả là, khi tôi mở thiết bị đầu cuối, nó gặp vấn đề được mô tả bởi bạn:

Nó cũng xảy ra tương tự khi tôi đi trong tty1 với Ctrl+ Alt+ F1.

File có chứa khởi lệnh khi một vỏ được gọi: /etc/profile, /etc/bashrc, ~/.bash_login, ~/.profile, ~/.bashrc, ~/.bash_aliasesvà có lẽ những người khác. Xem tập tin khởi tạo Shell .

Để nhanh chóng kiểm tra xem một trong những tệp này có lỗi gì đó bên trong bạn có thể sử dụng sourcelệnh. Ví dụ:

source ~/.bashrc

Giải pháp cuối cùng

Sau khi kiểm tra /etc/profiletừ http://paste.ubfox.com/5781361/ , tôi thấy rằng trên dòng 31 có "Ghi đè từ phải sang trái" -‮ ký tự unicode. Chỉ cần mở /etc/profiletệp với sudo -H gedit /etc/profile, đảm bảo xóa ký tự lạ này và vấn đề sẽ biến mất.

Như một trò giải trí, ví dụ như trong HTML, nếu bạn chèn ký tự unicode này bằng mã thập phân ( ‮) trước một dòng, hãy xem điều gì đang xảy ra:

Văn bản này là tiếng Ả Rập-tiếng Anh!

Một giải pháp tổng quát hơn

Chúng tôi sẽ tìm thấy lệnh chính xác gây ra lỗi bằng cách sử dụng " bẫy ".

Đầu tiên, chúng ta phải tạo một tệp script mới trong ~/binthư mục, hãy gọi nó là lib.trap.sh( gedit ~/bin/lib.trap.sh), với phần bên trong:

lib_name='trap'

lib_version=20130620
#changed from lib_version=20121026 found it at /programming//a/13099228/2353900 to work well at initialization of the shell

stderr_log="/dev/shm/stderr.log"

#
# TO BE SOURCED ONLY ONCE:
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

if test "${g_libs[$lib_name]+_}"; then
    return 0
else
    if test ${#g_libs[@]} == 0; then
        declare -A g_libs
    fi
    g_libs[$lib_name]=$lib_version
fi


#
# MAIN CODE:
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

set -o pipefail  # trace ERR through pipes
set -o errtrace  # trace ERR through 'time command' and other functions
set -o nounset   ## set -u : exit the script if you try to use an uninitialised variable
set -o errexit   ## set -e : exit the script if any statement returns a non-true return value

exec 2>"$stderr_log"


###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##
#
# FUNCTION: EXIT_HANDLER
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

function exit_handler ()
{
    local error_code="$?"

    test $error_code == 0 && return;

    #
    # LOCAL VARIABLES:
    # ------------------------------------------------------------------
    #    
    local i=0
    local regex=''
    local mem=''

    local error_file=''
    local error_lineno=''
    local error_message='unknown'

    local lineno=''


    #
    # PRINT THE HEADER:
    # ------------------------------------------------------------------
    #
    # Color the output if it's an interactive terminal
    test -t 1 && tput bold; tput setf 4                                 ## red bold
    echo -e "\n(!) EXIT HANDLER\n"


    #
    # GETTING LAST ERROR OCCURRED:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    #
    # Read last file from the error log
    # ------------------------------------------------------------------
    #
    if test -f "$stderr_log"
        then
            stderr=$( tail -n 1 "$stderr_log" )
            rm "$stderr_log"
    fi

    #
    # Managing the line to extract information:
    # ------------------------------------------------------------------
    #

    if test -n "$stderr"
        then        
            # Exploding stderr on :
            mem="$IFS"
            local shrunk_stderr=$( echo "$stderr" | sed 's/\: /\:/g' )
            IFS=':'
            local stderr_parts=( $shrunk_stderr )
            IFS="$mem"

            # Storing information on the error
            error_file="${stderr_parts[0]}"
            error_lineno="${stderr_parts[1]}"
            error_message=""

            for (( i = 3; i <= ${#stderr_parts[@]}; i++ ))
                do
                    error_message="$error_message "${stderr_parts[$i-1]}": "
            done

            # Removing last ':' (colon character)
            error_message="${error_message%:*}"

            # Trim
            error_message="$( echo "$error_message" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//' )"
    fi

    #
    # GETTING BACKTRACE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    _backtrace=$( backtrace 2 )


    #
    # MANAGING THE OUTPUT:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    local lineno=""
    regex='^([a-z]{1,}) ([0-9]{1,})$'

    if [[ $error_lineno =~ $regex ]]

        # The error line was found on the log
        # (e.g. type 'ff' without quotes wherever)
        # --------------------------------------------------------------
        then
            local row="${BASH_REMATCH[1]}"
            lineno="${BASH_REMATCH[2]}"

            echo -e "FILE:\t\t${error_file}"
            echo -e "${row^^}:\t\t${lineno}\n"

            echo -e "ERROR CODE:\t${error_code}"             
            test -t 1 && tput setf 6                                    ## white yellow
            echo -e "ERROR MESSAGE:\n$error_message"


        else
            regex="^${error_file}\$|^${error_file}\s+|\s+${error_file}\s+|\s+${error_file}\$"
            if [[ "$_backtrace" =~ $regex ]]

                # The file was found on the log but not the error line
                # (could not reproduce this case so far)
                # ------------------------------------------------------
                then
                    echo -e "FILE:\t\t$error_file"
                    echo -e "ROW:\t\tunknown\n"

                    echo -e "ERROR CODE:\t${error_code}"
                    test -t 1 && tput setf 6                            ## white yellow
                    echo -e "ERROR MESSAGE:\n${stderr}"

                # Neither the error line nor the error file was found on the log
                # (e.g. type 'cp ffd fdf' without quotes wherever)
                # ------------------------------------------------------
                else
                    #
                    # The error file is the first on backtrace list:

                    # Exploding backtrace on newlines
                    mem=$IFS
                    IFS='
                    '
                    #
                    # Substring: I keep only the carriage return
                    # (others needed only for tabbing purpose)
                    IFS=${IFS:0:1}
                    local lines=( $_backtrace )

                    IFS=$mem

                    error_file=""

                    if test -n "${lines[1]}"
                        then
                            array=( ${lines[1]} )

                            for (( i=2; i<${#array[@]}; i++ ))
                                do
                                    error_file="$error_file ${array[$i]}"
                            done

                            # Trim
                            error_file="$( echo "$error_file" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//' )"
                    fi

            echo -e "ROW, FILE:\t\t${lines[2]   }\n"

                    echo -e "ERROR CODE:\t${error_code}"
                    test -t 1 && tput setf 6                            ## white yellow
                    if test -n "${stderr}"
                        then
                            echo -e "ERROR MESSAGE:\n${stderr}"
                        else
                            echo -e "ERROR MESSAGE:\n${error_message}"
                    fi
            fi
    fi

    #
    # PRINTING THE BACKTRACE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    test -t 1 && tput setf 7                                            ## white bold
    echo -e "\n$_backtrace\n"

    #
    # EXITING:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    test -t 1 && tput setf 4                                            ## red bold
    echo "Exiting!"

    test -t 1 && tput sgr0 # Reset terminal

    exit "$error_code"
}
trap exit_handler ERR                                                  # ! ! ! TRAP EXIT ! ! !
#trap exit ERR                                                        # ! ! ! TRAP ERR ! ! ! 


###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##
#
# FUNCTION: BACKTRACE
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

function backtrace
{
    local _start_from_=0

    local params=( "$@" )
    if (( "${#params[@]}" >= "1" ))
        then
            _start_from_="$1"
    fi

    local i=0
    local first=false
    while caller $i > /dev/null
    do
        if test -n "$_start_from_" && (( "$i" + 1   >= "$_start_from_" ))
            then
                if test "$first" == false
                    then
                        echo "BACKTRACE IS:"
                        first=true
                fi
                caller $i
        fi
        let "i=i+1"
    done
}

return 0

Bây giờ, điều duy nhất bạn phải làm là đặt dòng tiếp theo vào lúc bắt đầu của tệp /etc/profile( sudo -H gedit /etc/profile):

source '/home/<user_name>/bin/lib.trap.sh'

Thay đổi <user_name>với tên người dùng của bạn. Như thế này, tất cả các tệp có chứa các lệnh khởi tạo khi trình bao được gọi sẽ chuyển qua "bẫy".

/etc/profileVí dụ, để kiểm tra xem có lệnh sai hay không , hãy chạy trong các lệnh tiếp theo của thiết bị đầu cuối:

nguồn bash / etc / profile

Nếu có gì đó không đúng, như trong trường hợp này, kết quả sẽ là:

Vì vậy, bây giờ chúng tôi biết chắc chắn rằng có một vấn đề ( command not found) trong /etc/profiletệp ở dòng 32 (nó không nằm ở dòng 31 như trên vì chúng tôi đã chèn một dòng mới ở đầu tệp).

Rất cám ơn Luca Borrione cho kịch bản của anh ấy từ câu trả lời này đã giúp tôi hoàn thành giải pháp tổng quát này.

Để gỡ lỗi các tập lệnh khởi tạo của bash, hãy chạy như sau (sau khi đã đăng nhập tại bảng điều khiển ảo).

PS4='+ $BASH_SOURCE:$LINENO:' bash -xlic ''

Ở trên chạy bash trong chế độ tương tác ( -i) login ( -l), giống như loginchương trình khi bạn đăng nhập vào bảng điều khiển ảo. -c ''làm cho nó thoát ra ngay lập tức sau khi chạy qua các kịch bản khởi tạo, và -xvà PS4=...làm cho nó ra mỗi lệnh, trước khi nó chạy chúng, cùng với tên file và đường số lệnh đó. Điều đó sẽ giúp xác định dòng nào của tập tin mà lệnh không hợp lệ nằm trong đó.

Mặt khác, ♦ là ký hiệu phông chữ mặc định cho bảng điều khiển ảo sử dụng để in các ký tự mà nó không có ký hiệu cho.

Trong khi tìm kiếm các tệp khởi tạo của bạn, có thể hữu ích để tìm kiếm hệ thập lục phân được sử dụng để xuất ra ♦. Mã hex cho ♦ là 2666, theo ký tự Unicode 'BLACK DIAMOND SUIT' . Lưu ý: Có ít nhất một mã hex khác, 25C6, tạo ra biểu tượng trông giống hoặc tương tự. Xem kết quả tìm kiếm cho "kim cương". Tìm kiếm ký tự Unicode

Có lẽ một cái gì đó giống như \u2666là trong một trong các kịch bản. Từ Hướng dẫn tham khảo Bash cho tiếng vang - "\ uhhhh ký tự Unicode (ISO / IEC 10646) có giá trị là giá trị thập lục phân HHHH (một đến bốn chữ số hex)"

Nó phụ thuộc vào mã hóa ký tự được sử dụng, vì vậy bạn có thể muốn tìm kiếm những cái có khả năng nhất trước tiên. echo $LC_CTYPEsẽ trả về mã hóa ký tự được sử dụng bởi shell của bạn. Xem cách nhận mã hóa ký tự của thiết bị đầu cuối

Viết đường dẫn đầy đủ đến một công cụ đã biết sẽ cho phép bạn chỉnh sửa tệp bashrc của mình, cùng với đường dẫn đầy đủ đến tệp bashrc của bạn.

/bin/nano /home/username/.bashrc

Tìm bất kỳ lạm dụng để PATHbiến của bạn và nhận xét nó ra. Có khả năng khi cố gắng thêm một cái gì đó vào đường dẫn của bạn, nó đã được trích dẫn một lần thay vì trích dẫn kép.

PATH='$PATH:/path/to/new/tool' # very BAD, single quotes won't expand PATH
#    ^                       ^

PATH="$PATH:/path/to/new/tool" # Good! The double quotes allow variable expansion

Sao chép .bashrc của bạn vào một công cụ như https://www.shellcheck.net/ để xem bạn có bất kỳ vấn đề rõ ràng nào khi sử dụng bash không.

Mong rằng sẽ giúp.