Відео

❤ i want to know more about this

thx mate!!!!

Bb

$ Ls -L

It's being done to me,,I know who it is

send me pdf sir

Nice explanation. Truly. This data recovery software is excellent for retrieving lost files. It's easy to use and quickly recovers documents, photos, and other data with just a few clicks.

I can't believe there's a course like this on UA-cam! I've been trying to learn Linux for four years, and this finally seems like the perfect fit for my needs.

All are working properly 100% Thank you so much ❤

very nice sir, abhi jake mera concept clear hua, thank you

Many courses fail to notice that writing at the bottom of the terminal page creates a difficult experience for the viewer needing translation

plzzz Upload This same course in hindi please

Sir, I have just watched a bit of this video. Do you think that after watching the complete video, I will be able to learn the skills of a Linux administrator, and will I be ready for a job as a Linux administrator?

Selam Brother , The DECK STOP would be on a Ship i think ... The DESK is an Table ' so it's DESK TOP ( the top of an table ) u know ; ) hehe * But i know whole india says' DECK Stop ' but its not an Steamdeck hehehe

its not complete dude linux has other package managers! so I dont even know why you write complete! rewrite the subject saying complete debian based linux administration bootcamp!!! This is pretty dumb and leads new guys wrong direction... some newbie will be thinking after this hey i can run linux and then handed an RHEL or worse Arch he will be like WTF lmfao

0:07

Indian speaking english sounds very ridiculous, next time use subtitles, the world will thank you.

super

Hey There, do we have any real life scenarios on loops, conditions, nested loops and conditions? please revert , ready to pay for that also

Thanks a lot

malloc/calloc and free are not system calls. They're libc functions. The actual system call is typically sbrk, which requests the OS to expand (or shrink if the size is negative) the program's memory segment. Every call to sbrk works on the same boundary and thus the memory retrieved is all contiguous. Having a program get a bunch of contiguous memory and then trying to free it back is a headache because of fragmentation. For example, let's say you allocate 4 megabytes and assign it to a pointer called A, and then 2 bytes and assign it to a pointer called B. But now you're done with A and want to free it, but you still need B. How do you do that? The answer is it's impossible. If you were to roll back the 4MB you allocated for A you would end up freeing B in the process, and then you'd have 2 bytes of A unaccounted for. You've just leaked memory, and what's worse is that B is now a dangling pointer, and if you try to use it, that's undefined behavior. allocated: [AAAAAAAABB] after sbrk free: allocated: [AA], freed: [AAAAAABB] ^ leaked ^ invalid This type of memory management works fine in a stack frame, which is where functions get the memory for local variables, since the variables are automatically allocated and freed in bulk. But for dynamic objects where the order and quantity of allocations are unpredictable, you're going to have fragmentation, and therefore need a way to, somehow, keep track of the memory obtained through sbrk so that it can be freed back to the OS at some point. It's also worth pointing out that system calls are slow because they require switching execution to a kernel mode context, and this switch in and out of kernel mode takes time, so spamming sbrk calls is also terrible for performance. This is where malloc/free come in. Malloc will call sbrk only when necessary but otherwise will allocate in bulk and carve out chunks of memory per request. Each call to malloc actually uses a little more than the amount requested, because it inserts its bookkeeping data structures into the memory it's managing. So say you call malloc requesting 6 bytes of memory, it'll look through its bookkeeping structures (which I will call "memory nodes" from now on) to see if it can find a chunk of free memory that's 6 or more bytes in size. If it doesn't find it in any of the pools it's managing, it'll allocate another pool or buffer using sbrk that's, say, 4KiB in size, and then carve the 6 bytes + node from that. If it finds it in the existing memory, it'll insert another node right after the segment of memory it's about to return accounting for the remainder, adjust the size recorded in the original node to 6 bytes, and then mark the chunk as used and return the address to it. If a bookkeeping node is 16 bytes, that means you'll typically see it returning (node + 16). When you free memory back to malloc, it takes that pointer, subtracts or adds a fixed offset to get to the bookkeeping node (node = ptr - 16), marks it as free, and then attempts to combine it with adjacent free nodes. It will then check the whole pool to see if it only has one free node and is the most recent pool to be allocated, and if both of these conditions are true, then it calls sbrk with a negative size to return all the memory at once. As you can see, calling free does not guarantee that the memory is actually freed to the OS. Memory is only freed when there is no fragmentation in a contiguous chunk that malloc is tracking. But malloc's job is to buffer sbrk calls and manage fragmentation. malloc is not a system call. This should also help explain why double freeing is illegal (malloc expects there to be a bookkeeping node near the pointer, and if it got overwritten with garbage, then calling free on that pointer, which will lead free to a node with an unknown size, will wreak havoc), why free can only accept pointers generated by malloc (malloc generates the pointers based on the bookkeeping nodes. Giving it any other pointer than NULL or a malloc'd pointer will result in it treating unknown memory as a bookkeeping node), and why it's a bidea to mix malloc and sbrk calls. If you're going to write your own malloc, for example, then don't use libc malloc. You can't know how malloc manages memory, and if it assumes that all of its memory is contiguous and just appends nodes at the end when it allocs memory, then calling sbrk between malloc calls would break the program, leaking memory at best or causing a crash at worst. A bookkeeping structure might look like this: struct memnode { size_t size; int flags; // USED, ISFIRST, ISLAST, ISSTATIC, etc }; There are two models you can use. The first is to not assume that the bulk pools or buffers obtained from sbrk are contiguous with each other (you can assume the pools are self-contiguous, just not contiguous with other pools), this requires more memory per node to account for the different linked lists it needs to maintain, and is also generally slower, cause, for example, to free memory back, you'd have to go through the "up-list" to get to the last item, check if it's all free, free it, then check the next one down. It can also be faster due to the fact that pools are only ever freed all at once since they are kept separate. The second is to assume that nobody else is calling sbrk and take ownership of it, assuming that all the pools are contiguous. This means that every pool is appended to the end of the list and we can just work backwards from the end to free memory, and the nodes use less memory since they only have to track the size and tags. but the drawback is that there will be more calls to sbrk overall. Conserving memory takes higher priority so generally, you will see implementations of malloc opting for the latter. One further optimization you could do when using the contiguous pools model is to track the size of the entire pool separately, as well as having pointers to the first and last node. You might also opt to allocate a static char array of a certain size like 16384 so that programs that only do small allocations get memory much faster. static size_t pool_total_size; // cumulative size of all dynamic pools static void * first_node; // use void * to avoid pointer arithmetic shenanigans static void * last_node; static char static_pool[16384]; // static pool to avoid having to use sbrk right away static int static_pool_too_full; // set this to 1 the first time the allocator fails to find enough memory in the static pool. Set to 0 when freeing static pool memory

still not getting it

The background sound is very annoying. I stopped watching because of that.

Do we need to define the function pointers inside struct? Is it better just to use the function with the instance without the funciton pointer?

How can I retrieve data from Sq;l and then write it to file without erasing the file content that was already there?

Why can I see anything in the more... fields

3.2k+...This is gonna be a great journey. Thanks

Sorry, to much wrong information in the beginning for me to want waching this for 6 hours. Stuff like BIOS and MBR, both replaced for almost 20 years ago. LILO, LInux LOader, not last in last out. Then showing commands with uppercase letters that should be lowercase.

Sick of bill gates windows Want a new life

guys... 6 hours.. total waste of time.. and painful to hear an Indian accent for 6 hours.. as a Lunix pro.. I advice you to just read online resources and follow along

Bro yappin

Indian Assemble 😎

TL;DR, This is a wrong example of memory leaks. The pointer variable is stored in the stack part of memory, the memory for the variable is automatically "freed" after the function returns. Long explanation: This isn't a memory leak because the pointer variable created has automatic storage duration, meaning the memory for the pointer variable is stored in the stack memory segment not the heap. After the function returns the memory for all automatic storage duration variables (in this case ptr and number) are "automatically freed" (this is however different for static variables, they have static storage duration, they are stored in data segment of the memory and stay there until the program exits if I'm not mistaken). If you use malloc or calloc to assign memory from the heap segment and return **without** using free() then it will cause a memory leak. If you are running linux you can use valgrind to find memory leaks in your program. I don't know if WSL has support for that yet or not.

Are u by any chance indian ?? Dont mind how i came to this

God bless you anywhere you are!!

🥰

Apesar de um pouco complicado para iniciantes, o google drive está instalado corretamente.

And what about when you visite an infected site like pornsites?

Very informative

nice

Whats the roadmap to become system admin(linux) to get job ready

Windows will win

Give me this code, plz

🙏👍

Nice lecture

I have tried both and compare. If you have old machine, LUBUNTU is the better and lighter option.

Thank you ❤

def clear_screen() os.system('cls' if os.name=='nt' else 'clear') I just use this 😂😂😂😂

also me

I would like to create a folder structure in a project folder. so far quite easy following the steps you provided, however the project folder should start with a date and then have Customer and project in the name. A bit like "JJMMDD customername projectname" so how xoulöd I a) get that date string and b) combine varius strings into one folder name ?