On Tue, 2011-06-07 at 18:30 +0530, Srikar Dronamraju wrote:

+void uprobe_notify_resume(struct pt_regs *regs)
+{
+       struct vm_area_struct *vma;
+       struct uprobe_task *utask;
+       struct mm_struct *mm;
+       struct uprobe *u = NULL;
+       unsigned long probept;
+
+       utask = current->utask;
+       mm = current->mm;
+       if (!utask || utask->state == UTASK_BP_HIT) {
+               probept = get_uprobe_bkpt_addr(regs);
+               down_read(&mm->mmap_sem);
+               vma = find_vma(mm, probept);
+               if (vma && valid_vma(vma))
+                       u = find_uprobe(vma->vm_file->f_mapping->host,
+                                       probept - vma->vm_start +
+                                       (vma->vm_pgoff << PAGE_SHIFT));
+               up_read(&mm->mmap_sem);
+               if (!u)
+                       goto cleanup_ret;
+               if (!utask) {
+                       utask = add_utask();
+                       if (!utask)
+                               goto cleanup_ret;

So if we fail to allocate task state,..

+               }
+               /* TODO Start queueing signals. */
+               utask->active_uprobe = u;
+               handler_chain(u, regs);
+               utask->state = UTASK_SSTEP;
+               if (!pre_ssout(u, regs, probept))
+                       user_enable_single_step(current);
+               else
+                       goto cleanup_ret;
+       } else if (utask->state == UTASK_SSTEP) {
+               u = utask->active_uprobe;
+               if (sstep_complete(u, regs)) {
+                       put_uprobe(u);
+                       utask->active_uprobe = NULL;
+                       utask->state = UTASK_RUNNING;
+                       user_disable_single_step(current);
+                       xol_free_insn_slot(current);
+
+                       /* TODO Stop queueing signals. */
+               }
+       }
+       return;
+
+cleanup_ret:
+       if (u) {
+               down_read(&mm->mmap_sem);
+               if (!set_orig_insn(current, u, probept, true))

we try to undo the probe? That doesn't make any sense. I thought you
meant to return to userspace, let it re-take the trap and try again
until you do manage to allocate the user resource.

This behaviour makes probes totally unreliable under memory pressure. 

+                       atomic_dec(&mm->uprobes_count);
+               up_read(&mm->mmap_sem);
+               put_uprobe(u);
+       } else {
+       /*TODO Return SIGTRAP signal */
+       }
+       if (utask) {
+               utask->active_uprobe = NULL;
+               utask->state = UTASK_RUNNING;
+       }
+       set_instruction_pointer(regs, probept);
+} 

Also, there's a scary amount of TODO in there...

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>