Bring out the inner llama of a sentence
Perl, 52 bytes

The solution is provided as function that takes the string as argument and returns a list of positions.


One-based positions, case-sensitive search, without newlines: 52 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/;@+[1..$#+]}


The case-sensitive search returns an empty array in the example of the question, because after matching the first three letters the lowercase letter m is missing in the input text.
Support of newlines: + 1 byte = 53 bytes

sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/s;@+[1..$#+]}


The text can now span several lines.
Case-insensitive search: + 1 byte = 54 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;@+[1..$#+]}


Now the example in the question reports a list of index positions,
they are one-based numbers:

[45 68 77 106 115]

Zero-based positions: + 9 bytes = 63 bytes

 sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;map{$_-1}@+[1..$#+]}


Result for the example in the question:

[44 67 76 105 114]



Ungolfed:

The latter variant includes more or less the other variants.

sub l {
    # pop() gets the last argument 
    pop() =~ /(l).*?(l).*?(a).*?(m).*?(a)/si;
    # the letters inbetween are matched against ".*?",
    # the non-greedy variant of ".*". Thus ".*?"
    # matches only as few as possible characters.
    # The modifier /i controls the case-sensitivity
    # and means ignore case. Without the case matters.
    # Modifier /s treats the string as single line,
    # even if it contains newlines.
    map { $_-1 }   # subtract 1 for zero-based positions
        @+[1..$#+]
    # Array @+ contains the end-positions of the last
    # submatches, and of the whole match in the first position.
    # Therefore the first value is sliced away.
    # @+ is available since Perl 5.6.
}

# test
my @result = l(&lt;&lt;"END_STR");
Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
END_STR
print "[@result]\n";