Cfrgtkky

You can pause execution of a process by sending it a SIGSTOP signal and then later resume it by sending it a SIGCONT.

Assuming your workload is a single process (doesn't fork helpers running in background), you can use something like this:

# start copy in background, store pid

cp src dst &

echo "$!" >/var/run/bigcopy.pid

Then when busy time starts, send it a SIGSTOP:

# pause execution of bigcopy

kill -STOP "$(cat /var/run/bigcopy.pid)"

Later on, when the server is idle again, resume it.

# resume execution of bigcopy

kill -CONT "$(cat /var/run/bigcopy.pid)"

You will need to schedule this for specific times when you want it executed, you can use tools such as cron or systemd timers (or a variety of other similar tools) to get this scheduled. Instead of scheduling based on a time interval, you might choose to monitor the server (perhaps looking at load average, cpu usage or activity from server logs) to make a decision of when to pause/resume the copy.

You also need to manage the PID file (if you use one), make sure your copy is actually still running before pausing it, probably you'll want to clean up by removing the pidfile once the copy is finished, etc.

In other words, you need more around this to make a reliable, but the base idea of using these SIGSTOP and SIGCONT signals to pause/resume execution of a process seems to be what you're looking for.

Instead of suspending the process, you could also give it lower priority:

renice 19 "$pid"

will give it the lowest priority (highest niceness), so that process will yield the CPU to other processes that need it most of the time.

On Linux, the same can be done with I/O with ionice:

ionice -c idle -p "$pid"

Will put the process in the "idle" class, so that it will only get disk time when no other program has asked for disk I/O for a defined grace period.

Use rsync, forget about cp, for this scenario.
there are params to limit bandwith, or can be killed/stoped and started later, in a way it will continue, where it left
google rsync example/s

Yes, you Need to

acquire the process id of the process-to-paus (PS), then do

$> kill -SIGSTOP <pid>

The process will then Show up with Status "T" (PS). To continue do a

$> kill -CONT <pid>

Good Luck!

If you are going to do it by interrupting the running process, I suggest playing with the Screen program. I haven't used Linux in a while, but IIRC just pausing the command and resuming it later leaves you pretty vulnerable, if you accidentally get logged off you won't be able to resume your session.

With screen I believe you can interrupt the session then detach it and log out. Later you can go back in and reattach to that session. You'd have to play with it a bit but it made sessions much more robust.

You can also log out and go home then log in remotely, reattach to the system y you started in the office and resume it for the evening, then pick it up again the next day at work.

If your shell supports it (almost all do), you can press ^Z (Ctrl+Z) to easily send a SIGTSTP signal to the foreground task, then continue it with fg (on foreground) or bg (on background).

If you do this on multiple tasks and want to return to them later, you can use jobs command, then return with fg/bg %#, where # is the number given in brackets on jobs.

Keep in mind that SIGTSTP is a bit different than SIGSTOP (which is used on all other answers), most importantly due to the fact that it can be ignored (but I didn't see a program ignore it other than sl). More details can be found on this answer on StackOverflow.

This can be easily achieved by emitting SIGSTOP signal and SIGCONT to re-initiate the process